1
0
Fork 0
mirror of https://gitlab.com/sortix/sortix.git synced 2023-02-13 20:55:38 -05:00
sortix--sortix/kernel/ata.cpp
2014-03-01 14:37:39 +01:00

484 lines
13 KiB
C++

/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012, 2013.
This file is part of Sortix.
Sortix is free software: you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
Sortix is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
details.
You should have received a copy of the GNU General Public License along with
Sortix. If not, see <http://www.gnu.org/licenses/>.
ata.cpp
Allowes access to block devices over ATA PIO.
*******************************************************************************/
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <sortix/stat.h>
#include <sortix/kernel/cpu.h>
#include <sortix/kernel/descriptor.h>
#include <sortix/kernel/inode.h>
#include <sortix/kernel/interlock.h>
#include <sortix/kernel/ioctx.h>
#include <sortix/kernel/kernel.h>
#include <sortix/kernel/kthread.h>
#include <sortix/kernel/refcount.h>
#include "ata.h"
// TODO: Use the PCI to detect ATA devices instead of relying on them being on
// standard locations.
namespace Sortix {
const uint16_t PRIMARY_BUS_OFFSET = 0x1F0;
const uint16_t SECONDARY_BUS_OFFSET = 0x170;
const uint16_t DATA = 0x0;
const uint16_t FEATURE = 0x1;
const uint16_t ERROR = 0x1;
const uint16_t SECTOR_COUNT = 0x2;
const uint16_t LBA_LOW = 0x3;
const uint16_t LBA_MID = 0x4;
const uint16_t LBA_HIGH = 0x5;
const uint16_t DRIVE_SELECT = 0x6;
const uint16_t COMMAND = 0x7;
const uint16_t STATUS = 0x7;
const uint8_t CMD_READ = 0x20;
const uint8_t CMD_READ_EXT = 0x24;
const uint8_t CMD_WRITE = 0x30;
const uint8_t CMD_WRITE_EXT = 0x34;
const uint8_t CMD_FLUSH_CACHE = 0xE7;
const uint8_t CMD_IDENTIFY = 0xEC;
const uint8_t STATUS_ERROR = (1<<0);
const uint8_t STATUS_DATAREADY = (1<<3);
const uint8_t STATUS_DRIVEFAULT = (1<<5);
const uint8_t STATUS_BUSY = (1<<7);
const uint8_t CTL_NO_INTERRUPT = (1<<1);
const uint8_t CTL_RESET = (1<<2);
namespace ATA {
class ATANode : public AbstractInode
{
public:
ATANode(ATADrive* drive, uid_t owner, gid_t group, mode_t mode, dev_t dev,
ino_t ino);
virtual ~ATANode();
virtual int sync(ioctx_t* ctx);
virtual int truncate(ioctx_t* ctx, off_t length);
virtual off_t lseek(ioctx_t* ctx, off_t offset, int whence);
virtual ssize_t pread(ioctx_t* ctx, uint8_t* buf, size_t count,
off_t off);
virtual ssize_t pwrite(ioctx_t* ctx, const uint8_t* buf, size_t count,
off_t off);
private:
kthread_mutex_t filelock;
ATADrive* drive;
};
ATANode::ATANode(ATADrive* drive, uid_t owner, gid_t group, mode_t mode,
dev_t dev, ino_t /*ino*/)
{
inode_type = INODE_TYPE_FILE;
filelock = KTHREAD_MUTEX_INITIALIZER;
this->dev = dev;
this->ino = (ino_t) this;
this->stat_uid = owner;
this->stat_gid = group;
this->type = S_IFBLK;
this->stat_size = (off_t) drive->GetSize();
this->stat_mode = (mode & S_SETABLE) | this->type;
this->stat_blksize = (blksize_t) drive->GetSectorSize();
this->stat_blocks = (blkcnt_t) drive->GetNumSectors();
this->drive = drive;
}
ATANode::~ATANode()
{
delete drive;
}
int ATANode::sync(ioctx_t* /*ctx*/)
{
// TODO: Actually sync the device here!
return 0;
}
int ATANode::truncate(ioctx_t* /*ctx*/, off_t length)
{
ScopedLock lock(&filelock);
if ( length == drive->GetSize() ) { return 0; }
errno = EPERM;
return -1;
}
off_t ATANode::lseek(ioctx_t* /*ctx*/, off_t offset, int whence)
{
ScopedLock lock(&filelock);
if ( whence == SEEK_SET )
return offset;
if ( whence == SEEK_END )
return (off_t) drive->GetSize() + offset;
errno = EINVAL;
return -1;
}
ssize_t ATANode::pread(ioctx_t* /*ctx*/, uint8_t* buf, size_t count, off_t off)
{
// TODO: SECURITY: Use ioctx copy functions to copy or we have a serious
// security hole if invoked from user-space!
size_t numbytes = drive->Read(off, buf, count);
if ( numbytes < count )
return -1;
return (ssize_t) numbytes;
}
ssize_t ATANode::pwrite(ioctx_t* /*ctx*/, const uint8_t* buf, size_t count,
off_t off)
{
// TODO: SECURITY: Use ioctx copy functions to copy or we have a serious
// security hole if invoked from user-space!
size_t numbytes = drive->Write(off, buf, count);
if ( numbytes < count )
return -1;
return (ssize_t) numbytes;
}
void DetectDrive(const char* devpath, Ref<Descriptor> slashdev, unsigned busid,
ATABus* bus, unsigned driveid)
{
unsigned ataid = busid*2 + driveid;
ATADrive* drive = bus->Instatiate(driveid);
if ( !drive )
return;
Ref<ATANode> node(new ATANode(drive, 0, 0, 0660, slashdev->dev, 0));
if ( !node )
Panic("Unable to allocate memory for ATA drive inode.");
const size_t NAMELEN = 64;
char name[NAMELEN];
snprintf(name, NAMELEN, "ata%u", ataid);
ioctx_t ctx; SetupKernelIOCtx(&ctx);
if ( LinkInodeInDir(&ctx, slashdev, name, node) != 0 )
PanicF("Unable to link %s/%s to ATA driver inode.", devpath, name);
}
void DetectBus(const char* devpath, Ref<Descriptor> slashdev, unsigned busid,
uint16_t ioport, uint16_t altio)
{
ATABus* bus = ATA::CreateBus(ioport, altio);
if ( !bus )
return;
DetectDrive(devpath, slashdev, busid, bus, 0);
DetectDrive(devpath, slashdev, busid, bus, 1);
}
void Init(const char* devpath, Ref<Descriptor> slashdev)
{
DetectBus(devpath, slashdev, 0, 0x1F0, 0x3F6);
DetectBus(devpath, slashdev, 1, 0x170, 0x366);
}
ATABus* CreateBus(uint16_t portoffset, uint16_t altport)
{
unsigned status = CPU::InPortB(portoffset + STATUS);
// Detect if there is no such bus.
if ( status == 0xFF )
{
errno = ENODEV;
return NULL;
}
return new ATABus(portoffset, altport);
}
} // namespace ATA
void Wait400NSecs(uint16_t iobase)
{
// Now wait 400 ns for the drive to be ready.
for ( unsigned i = 0; i < 4; i++ ) { CPU::InPortB(iobase + STATUS); }
}
ATABus::ATABus(uint16_t portoffset, uint16_t altport)
{
this->iobase = portoffset;
this->altport = altport;
this->curdriveid = 0;
}
ATABus::~ATABus()
{
}
ATADrive* ATABus::Instatiate(unsigned driveid)
{
if ( 1 < driveid )
return errno = EINVAL, (ATADrive*) NULL;
curdriveid = 0;
uint8_t drivemagic = 0xA0 | (driveid << 4);
CPU::OutPortB(iobase + DRIVE_SELECT, drivemagic);
CPU::OutPortB(iobase + SECTOR_COUNT, 0);
CPU::OutPortB(iobase + LBA_LOW, 0);
CPU::OutPortB(iobase + LBA_MID, 0);
CPU::OutPortB(iobase + LBA_HIGH, 0);
CPU::OutPortB(iobase + COMMAND, CMD_IDENTIFY);
uint8_t status;
while ( true )
{
status = CPU::InPortB(iobase + STATUS);
if ( !status || status == 0xFF )
return errno = ENODEV, (ATADrive*) NULL;
if ( !(status & STATUS_BUSY) )
break;
}
// Check for ATAPI device not following spec.
if ( CPU::InPortB(iobase + LBA_MID) || CPU::InPortB(iobase + LBA_MID) )
return errno = ENODEV, (ATADrive*) NULL;
while ( !(status & STATUS_DATAREADY) && !(status & STATUS_ERROR) )
status = CPU::InPortB(iobase + STATUS);
if ( status & STATUS_ERROR )
{
unsigned mid = CPU::InPortB(iobase + LBA_MID);
unsigned high = CPU::InPortB(iobase + LBA_HIGH);
if ( mid == 0x14 && high == 0xEB )
{
//Log::PrintF("Found ATAPI device instead of ATA\n");
}
else if ( mid == 0x3C && high == 0xC3 )
{
//Log::PrintF("Found SATA device instead of ATA\n");
}
else if ( mid || high )
{
//Log::PrintF("Found unknown device instead of ATA\n");
}
else
{
//Log::PrintF("Error status during identify\n");
}
return errno = EIO, (ATADrive*) NULL;
}
ATADrive* drive = new ATADrive(this, driveid, iobase, altport);
return drive;
}
bool ATABus::SelectDrive(unsigned driveid)
{
if ( driveid == curdriveid ) { return true; }
if ( 1 < driveid ) { errno = EINVAL; return false; }
uint8_t drivemagic = 0xA0 | (driveid << 4);
CPU::OutPortB(iobase + DRIVE_SELECT, drivemagic);
Wait400NSecs(iobase);
return true;
}
const size_t META_LBA28 = 60;
const size_t META_FLAGS = 83;
const size_t META_LBA48 = 100;
const uint16_t FLAG_LBA48 = (1<<10);
ATADrive::ATADrive(ATABus* bus, unsigned driveid, uint16_t portoffset, uint16_t altport)
{
this->atalock = KTHREAD_MUTEX_INITIALIZER;
this->bus = bus;
this->driveid = driveid;
this->iobase = portoffset;
this->altport = altport;
for ( size_t i = 0; i < 256; i++ )
{
meta[i] = CPU::InPortW(iobase + DATA);
}
lba48 = meta[META_FLAGS] & FLAG_LBA48;
numsectors = 0;
if ( lba48 )
{
numsectors = (uint64_t) meta[META_LBA48 + 0] << 0
| (uint64_t) meta[META_LBA48 + 1] << 8
| (uint64_t) meta[META_LBA48 + 2] << 16
| (uint64_t) meta[META_LBA48 + 3] << 24
| (uint64_t) meta[META_LBA48 + 4] << 32
| (uint64_t) meta[META_LBA48 + 5] << 40
| (uint64_t) meta[META_LBA48 + 6] << 48
| (uint64_t) meta[META_LBA48 + 7] << 56;
}
else
{
numsectors = meta[META_LBA28 + 0] << 0
| meta[META_LBA28 + 1] << 8
| meta[META_LBA28 + 2] << 16
| meta[META_LBA28 + 3] << 24;
}
sectorsize = 512; // TODO: Detect this!
Initialize();
}
ATADrive::~ATADrive()
{
}
off_t ATADrive::GetSectorSize()
{
return sectorsize;
}
off_t ATADrive::GetNumSectors()
{
return numsectors;
}
bool ATADrive::PrepareIO(bool write, off_t sector)
{
if ( numsectors <= sector ) { errno = EINVAL; return false; }
if ( write && !ENABLE_DISKWRITE )
{
errno = EPERM;
return false;
}
bus->SelectDrive(driveid);
uint8_t mode = (lba48) ? 0x40 : 0xE0;
mode |= driveid << 4;
mode |= (lba48) ? 0 : (sector >> 24) & 0x0F;
CPU::OutPortB(iobase + DRIVE_SELECT, mode);
uint16_t sectorcount = 1;
uint8_t sectorcountlow = sectorcount & 0xFF;
uint8_t sectorcounthigh = (sectorcount >> 8) & 0xFF;
if ( lba48 )
{
CPU::OutPortB(iobase + SECTOR_COUNT, sectorcounthigh);
CPU::OutPortB(iobase + LBA_LOW, (sector >> 24) & 0xFF);
CPU::OutPortB(iobase + LBA_MID, (sector >> 32) & 0xFF);
CPU::OutPortB(iobase + LBA_HIGH, (sector >> 40) & 0xFF);
}
CPU::OutPortB(iobase + SECTOR_COUNT, sectorcountlow);
CPU::OutPortB(iobase + LBA_LOW, sector & 0xFF);
CPU::OutPortB(iobase + LBA_MID, (sector >> 8) & 0xFF);
CPU::OutPortB(iobase + LBA_HIGH, (sector >> 16) & 0xFF);
uint8_t command = (write) ? CMD_WRITE : CMD_READ;
if ( lba48 ) { command = (write) ? CMD_WRITE_EXT : CMD_READ_EXT; }
CPU::OutPortB(iobase + COMMAND, command);
while ( true )
{
uint8_t status = CPU::InPortB(iobase + STATUS);
if ( status & STATUS_BUSY ) { continue; }
if ( status & STATUS_DATAREADY ) { break; }
if ( status & STATUS_ERROR ) { errno = EIO; return false; }
if ( status & STATUS_DRIVEFAULT ) { errno = EIO; return false; }
}
return true;
}
bool ATADrive::ReadSector(off_t sector, uint8_t* dest)
{
ScopedLock lock(&atalock);
if ( !PrepareIO(false, sector) ) { return false; }
uint16_t* destword = (uint16_t*) dest;
for ( size_t i = 0; i < sectorsize/2; i++ )
{
destword[i] = CPU::InPortW(iobase + DATA);
}
Wait400NSecs(iobase);
CPU::InPortB(iobase + STATUS);
return true;
}
bool ATADrive::WriteSector(off_t sector, const uint8_t* src)
{
ScopedLock lock(&atalock);
if ( !PrepareIO(true, sector) ) { return false; }
const uint16_t* srcword = (const uint16_t*) src;
for ( size_t i = 0; i < sectorsize/2; i++ )
{
CPU::OutPortW(iobase + DATA, srcword[i]);
}
Wait400NSecs(iobase);
CPU::OutPortB(iobase + COMMAND, CMD_FLUSH_CACHE);
while ( true )
{
uint8_t status = CPU::InPortB(iobase + STATUS);
if ( status & STATUS_ERROR ) { errno = EIO; return false; }
if ( status & STATUS_DRIVEFAULT ) { errno = EIO; return false; }
if ( !(status & STATUS_BUSY) ) { break; }
}
return true;
}
size_t ATADrive::Read(off_t byteoffset, uint8_t* dest, size_t numbytes)
{
size_t sofar = 0;
size_t leadingbytes = byteoffset % sectorsize;
if ( leadingbytes || numbytes < sectorsize )
{
size_t wanted = sectorsize - leadingbytes;
if ( numbytes < wanted ) { wanted = numbytes; }
uint8_t temp[512 /*sectorsize*/];
if ( !ReadSector(byteoffset/sectorsize, temp) ) { return sofar; }
memcpy(dest + sofar, temp + leadingbytes, wanted);
sofar += wanted;
numbytes -= wanted;
byteoffset += wanted;
}
while ( sectorsize <= numbytes )
{
if ( !ReadSector(byteoffset/sectorsize, dest + sofar) ) { return sofar; }
sofar += sectorsize;
numbytes -= sectorsize;
byteoffset += sectorsize;
}
if ( numbytes ) { return sofar + Read(byteoffset, dest + sofar, numbytes); }
return sofar;
}
size_t ATADrive::Write(off_t byteoffset, const uint8_t* src, size_t numbytes)
{
size_t sofar = 0;
size_t leadingbytes = byteoffset % sectorsize;
if ( leadingbytes || numbytes < sectorsize )
{
size_t wanted = sectorsize - leadingbytes;
if ( numbytes < wanted ) { wanted = numbytes; }
uint8_t temp[512 /*sectorsize*/];
if ( !ReadSector(byteoffset/sectorsize, temp) ) { return sofar; }
memcpy(temp + leadingbytes, src + sofar, wanted);
if ( !WriteSector(byteoffset/sectorsize, temp) ) { return sofar; }
sofar += wanted;
numbytes -= wanted;
byteoffset += wanted;
}
while ( sectorsize <= numbytes )
{
if ( !WriteSector(byteoffset/sectorsize, src + sofar) ) { return sofar; }
sofar += sectorsize;
numbytes -= sectorsize;
byteoffset += sectorsize;
}
if ( numbytes ) { return sofar + Write(byteoffset, src + sofar, numbytes); }
return sofar;
}
void ATADrive::Initialize()
{
bus->SelectDrive(driveid);
CPU::OutPortB(iobase + COMMAND, CTL_NO_INTERRUPT);
}
} // namespace Sortix