IOATAStandardCommand.cpp [plain text]
#include <IOKit/IOSyncer.h>
#include <IOKit/ata/IOATAStandardInterface.h>
#include <libkern/OSAtomic.h>
#undef super
#define super IOATACommand
OSDefineMetaClassAndStructors( IOATAStandardCommand, IOATACommand )
OSDefineMetaClassAndAbstractStructors( IOATACommand, IOCDBCommand )
IOATADevice *IOATAStandardCommand::getDevice(IOATADevice *)
{
return (IOATADevice *)device;
}
IOATAStandardDevice *IOATAStandardCommand::getDevice(IOATAStandardDevice *)
{
return device;
}
void *IOATAStandardCommand::getClientData()
{
return clientData;
}
void *IOATAStandardCommand::getCommandData()
{
return commandPrivateData;
}
UInt32 IOATAStandardCommand::getCmdType()
{
return cmdType;
}
IOATAStandardCommand *IOATAStandardCommand::getOriginalCmd()
{
return origCommand;
}
UInt32 IOATAStandardCommand::getSequenceNumber()
{
return sequenceNumber;
}
ATAUnit IOATAStandardCommand::getUnit()
{
return device->unit;
}
void IOATAStandardCommand::setTaskfile( ATATaskfile *srcTaskfile )
{
taskfile = *srcTaskfile;
}
void IOATAStandardCommand::getTaskfile( ATATaskfile *dstTaskfile )
{
*dstTaskfile = taskfile;
}
UInt32 IOATAStandardCommand::getFlags()
{
return taskfile.flags;
}
ATAProtocol IOATAStandardCommand::getProtocol()
{
return taskfile.protocol;
}
UInt32 IOATAStandardCommand::getResultMask()
{
return taskfile.resultmask;
}
void IOATAStandardCommand::setTimeout( UInt32 timeoutMS )
{
timeout = timeoutMS;
}
UInt32 IOATAStandardCommand::getTimeout()
{
return timeout;
}
void IOATAStandardCommand::setResults( ATAResults *srcResults )
{
results = *srcResults;
if ( getCmdType() == kATACommandExecute )
{
if ( results.bytesTransferred < xferCount )
{
if ( results.returnCode == kIOReturnSuccess )
{
results.returnCode = kIOReturnUnderrun;
}
}
}
}
IOReturn IOATAStandardCommand::getResults( ATAResults *dstResults )
{
if ( dstResults != 0 )
{
*dstResults = results;
}
return results.returnCode;
}
void IOATAStandardCommand::setQueueInfo( UInt32 forQueueType, UInt32 forQueuePosition )
{
queueType = forQueueType;
queuePosition = forQueuePosition;
}
void IOATAStandardCommand::getQueueInfo( UInt32 *forQueueType, UInt32 *forQueuePosition = 0 )
{
if ( forQueueType != 0 ) *forQueueType = queueType;
if ( forQueuePosition != 0 ) *forQueuePosition = queuePosition;
}
void IOATAStandardCommand::setPointers( IOMemoryDescriptor *clientDesc, UInt32 transferCount, bool isWrite, bool isSense = false )
{
if ( isSense == false )
{
xferDesc = clientDesc;
xferCount = transferCount;
xferDirection = isWrite;
}
else
{
senseData = clientDesc;
senseLength = transferCount;
}
}
void IOATAStandardCommand::getPointers( IOMemoryDescriptor **clientDesc, UInt32 *transferCount, bool *isWrite, bool isSense = false )
{
if ( clientDesc != NULL )
{
*clientDesc = (isSense == false) ? xferDesc : senseData;
}
if ( transferCount != NULL )
{
*transferCount = (isSense == false) ? xferCount : senseLength;
}
if ( isWrite != NULL )
{
*isWrite = (isSense == false) ? xferDirection : false;
}
}
void IOATAStandardCommand::setCDB( ATACDBInfo *clientATACmd )
{
ataCmd = *clientATACmd;
}
void IOATAStandardCommand::getCDB( ATACDBInfo *clientATACmd )
{
*clientATACmd = ataCmd;
}
void IOATAStandardCommand::setCallback( void *clientTarget, CallbackFn clientATADoneFn, void *clientRefcon )
{
completionInfo.async.target = clientTarget;
completionInfo.async.callback = clientATADoneFn;
completionInfo.async.refcon = clientRefcon;
}
bool IOATAStandardCommand::execute( UInt32 *cmdSequenceNumber )
{
bool isSync;
do
{
sequenceNumber = OSIncrementAtomic( (SInt32 *)&controller->sequenceNumber );
}
while ( sequenceNumber == 0 );
if ( cmdSequenceNumber != 0 )
{
*cmdSequenceNumber = sequenceNumber;
}
list = (queue_head_t *)device->deviceGate;
isSync = (completionInfo.async.callback == 0);
if ( isSync )
{
completionInfo.sync.lock = IOSyncer::create();
}
device->submitCommand( kATACommandExecute, this );
if ( isSync )
{
completionInfo.sync.lock->wait();
}
return true;
}
void IOATAStandardCommand::abort( UInt32 sequenceNumber )
{
device->submitCommand( kATACommandAbort, this, sequenceNumber );
}
void IOATAStandardCommand::complete()
{
if ( device )
{
device->completeCommand( this );
}
else
{
controller->completeCommand( this );
}
}
void IOATAStandardCommand::getCDB( CDBInfo *cdbInfo )
{
ATACDBInfo ataCDBInfo;
bzero( cdbInfo, sizeof(CDBInfo) );
getCDB( &ataCDBInfo );
cdbInfo->cdb = ataCDBInfo.cdb;
cdbInfo->cdbLength = ataCDBInfo.cdbLength;
}
void IOATAStandardCommand::setCDB( CDBInfo *cdbInfo )
{
IOATAStandardDevice *ataDevice;
ATATimingProtocol ataTimingProtocol;
ATACDBInfo ataCDBInfo;
ATATaskfile ataTaskfile;
ataDevice = getDevice(kIOATAStandardDevice);
if ( ataDevice->getDeviceType() != kATADeviceATAPI )
{
return;
}
bzero( &ataTaskfile, sizeof(ataTaskfile) );
ataDevice->getTimingSelected( &ataTimingProtocol );
ataTaskfile.regmask = ATARegtoMask(kATARegATAPIDeviceSelect)
| ATARegtoMask(kATARegATAPICommand)
| ATARegtoMask(kATARegATAPIByteCountLow)
| ATARegtoMask(kATARegATAPIByteCountHigh)
| ATARegtoMask(kATARegATAPIFeatures);
ataTaskfile.ataRegs[kATARegATAPICommand] = kATACommandATAPIPacket;
ataTaskfile.ataRegs[kATARegATAPIDeviceSelect] = kATAModeLBA | (getUnit() << 4);
if ( ataTimingProtocol & ~kATATimingPIO )
{
ataTaskfile.protocol = kATAProtocolATAPIDMA;
ataTaskfile.ataRegs[kATARegATAPIFeatures] = 0x01;
}
else
{
ataTaskfile.protocol = kATAProtocolATAPIPIO;
ataTaskfile.ataRegs[kATARegATAPIByteCountLow] = 0xfe;
ataTaskfile.ataRegs[kATARegATAPIByteCountHigh] = 0xff;
}
setTaskfile( &ataTaskfile );
bzero( &ataCDBInfo, sizeof(ATACDBInfo) );
ataCDBInfo.cdbLength = cdbInfo->cdbLength;
ataCDBInfo.cdb = cdbInfo->cdb;
setCDB( &ataCDBInfo );
setQueueInfo();
}
IOReturn IOATAStandardCommand::getResults( CDBResults *cdbResults )
{
ATAResults ataResults;
IOReturn rc;
rc = getResults( &ataResults );
if ( cdbResults != 0 )
{
bzero( cdbResults, sizeof(CDBResults) );
cdbResults->returnCode = ataResults.returnCode;
cdbResults->bytesTransferred = ataResults.bytesTransferred;
cdbResults->requestSenseDone = ataResults.returnCode;
cdbResults->requestSenseLength = ataResults.requestSenseLength;
}
return rc;
}
IOCDBDevice *IOATAStandardCommand::getDevice( IOCDBDevice * )
{
return (IOCDBDevice *)device;
}