#include "SCSITaskIUnknown.h"
#include "SCSITaskClass.h"
#include "SCSITaskDeviceClass.h"
#include "MMCDeviceUserClientClass.h"
#ifdef __cplusplus
extern "C" {
#endif
#include <mach/mach_interface.h>
#include <IOKit/iokitmig.h>
#ifdef __cplusplus
}
#endif
#define DEBUG 0
#define DEBUG_ASSERT_COMPONENT_NAME_STRING "SCSITaskClass"
#if DEBUG
#define PRINT(x) printf x
#else
#define PRINT(x)
#endif
#define kSCSITaskNULLReference ( UInt32 ) -1
#include "IOSCSIArchitectureModelFamilyDebugging.h"
SCSITaskInterface
SCSITaskClass::sSCSITaskInterface =
{
0,
&SCSITaskClass::sQueryInterface,
&SCSITaskClass::sAddRef,
&SCSITaskClass::sRelease,
1, 0, &SCSITaskClass::sIsTaskActive,
&SCSITaskClass::sSetTaskAttribute,
&SCSITaskClass::sGetTaskAttribute,
&SCSITaskClass::sSetCommandDescriptorBlock,
&SCSITaskClass::sGetCommandDescriptorBlockSize,
&SCSITaskClass::sGetCommandDescriptorBlock,
&SCSITaskClass::sSetScatterGatherEntries,
&SCSITaskClass::sSetTimeoutDuration,
&SCSITaskClass::sGetTimeoutDuration,
&SCSITaskClass::sSetTaskCompletionCallback,
&SCSITaskClass::sExecuteTaskAsync,
&SCSITaskClass::sExecuteTaskSync,
&SCSITaskClass::sAbortTask,
&SCSITaskClass::sGetServiceResponse,
&SCSITaskClass::sGetTaskState,
&SCSITaskClass::sGetTaskStatus,
&SCSITaskClass::sGetRealizedDataTransferCount,
&SCSITaskClass::sGetAutoSenseData,
&SCSITaskClass::sSetSenseDataBuffer
};
#if 0
#pragma mark -
#pragma mark Public Methods
#pragma mark -
#endif
SCSITaskInterface **
SCSITaskClass::alloc ( SCSITaskDeviceClass * scsiTaskDevice,
io_connect_t connection,
mach_port_t asyncPort )
{
IOReturn status = kIOReturnSuccess;
SCSITaskClass * task = NULL;
SCSITaskInterface ** interface = NULL;
PRINT ( ( "SCSITaskClass::alloc called\n" ) );
task = new SCSITaskClass ( );
require_nonzero ( task, Error_Exit );
status = task->Init ( scsiTaskDevice, connection, asyncPort );
require_success_action ( status, Error_Exit, delete task );
interface = ( SCSITaskInterface ** ) &task->fInterfaceMap.pseudoVTable;
Error_Exit:
return interface;
}
void
SCSITaskClass::sSetConnectionAndPort ( const void * task, void * context )
{
SCSITaskClass * myTask;
MyConnectionAndPortContext * myContext;
myTask = getThis ( ( void * ) task );
myContext = ( MyConnectionAndPortContext * ) context;
PRINT ( ( "sSetConnectionAndPort called, task = %p, context = %p\n", myTask, myContext ) );
( void ) myTask->SetConnectionAndPort ( myContext->connection, myContext->asyncPort );
}
void
SCSITaskClass::sAbortAndReleaseTasks ( const void * value, void * context )
{
SCSITaskClass * task = NULL;
require_nonzero ( value, Error_Exit );
task = getThis ( ( void * ) value );
PRINT ( ( "SCSITaskClass::sAbortAndReleaseTasks\n" ) );
require_nonzero ( task, Error_Exit );
nrequire ( task->IsTaskActive ( ), Error_Exit );
( void ) task->AbortTask ( );
Error_Exit:
return;
}
IOReturn
SCSITaskClass::SetConnectionAndPort ( io_connect_t connection,
mach_port_t asyncPort )
{
IOReturn status = kIOReturnSuccess;
io_async_ref_t asyncRef = { 0 };
io_scalar_inband_t params = { 0 };
mach_msg_type_number_t size = 0;
PRINT ( ( "SCSITaskClass::SetConnectionAndPort called\n" ) );
check ( connection != 0 );
fConnection = connection;
require_action_quiet ( asyncPort != MACH_PORT_NULL,
Error_Exit,
fAsyncPort = MACH_PORT_NULL );
asyncRef[0] = 0;
params[0] = ( UInt32 ) fTaskArguments.taskReference;
params[1] = ( UInt32 ) ( IOAsyncCallback ) &SCSITaskClass::sTaskCompletion;
params[2] = ( UInt32 ) this;
status = io_async_method_scalarI_scalarO ( fConnection,
asyncPort,
asyncRef,
1,
kSCSITaskUserClientSetAsyncCallback,
params,
3,
NULL,
&size );
PRINT ( ( "SetAsyncCallback : status = 0x%08x\n", status ) );
require_success ( status, Error_Exit );
fAsyncPort = asyncPort;
Error_Exit:
return status;
}
IOReturn
SCSITaskClass::Init ( SCSITaskDeviceClass * scsiTaskDevice,
io_connect_t connection,
mach_port_t asyncPort )
{
IOReturn status = kIOReturnSuccess;
PRINT ( ( "SCSITaskClass::Init called\n" ) );
require_nonzero_action ( scsiTaskDevice, Error_Exit, status = kIOReturnBadArgument );
require_nonzero_action ( connection, Error_Exit, status = kIOReturnBadArgument );
fSCSITaskDevice = scsiTaskDevice;
status = IOConnectMethodScalarIScalarO ( connection,
kSCSITaskUserClientCreateTask,
0,
1,
&fTaskArguments.taskReference );
require_success ( status, Error_Exit );
PRINT ( ( "fTaskArguments.taskReference = %ld\n", fTaskArguments.taskReference ) );
status = SetConnectionAndPort ( connection, asyncPort );
require_success ( status, Error_Exit );
status = SetSenseDataBuffer ( &fSenseData, sizeof ( fSenseData ) );
require_success ( status, Error_Exit );
PRINT ( ( "SetBuffers succeeded\n" ) );
PRINT ( ( "SCSITaskClass : fConnection %d, fAsyncPort %d, fSCSITaskDevice = %p\n",
fConnection, fAsyncPort, fSCSITaskDevice ) );
Error_Exit:
PRINT ( ( "SCSITaskClass : status = 0x%08x\n", status ) );
return status;
}
#if 0
#pragma mark -
#pragma mark Protected Methods
#pragma mark -
#endif
SCSITaskClass::SCSITaskClass ( void ) :
SCSITaskIUnknown ( &sSCSITaskInterface )
{
fConnection = 0;
fTaskState = kSCSITaskState_NEW_TASK;
PRINT ( ( "SCSITaskClass constructor called\n" ) );
memset ( &fTaskArguments, 0, sizeof ( fTaskArguments ) );
memset ( &fTaskResults, 0, sizeof ( fTaskResults ) );
fCallbackFunction = NULL;
fCallbackRefCon = NULL;
fAsyncPort = NULL;
fExternalSenseData = NULL;
fTaskArguments.taskReference = kSCSITaskNULLReference;
}
SCSITaskClass::~SCSITaskClass ( void )
{
IOReturn status = kIOReturnSuccess;
PRINT ( ( "SCSITaskClass destructor called\n" ) );
if ( fSCSITaskDevice != NULL )
{
PRINT ( ( "Removing task from set\n" ) );
fSCSITaskDevice->RemoveTaskFromTaskSet (
( SCSITaskInterface ** ) &fInterfaceMap.pseudoVTable );
}
if ( fTaskArguments.taskReference != kSCSITaskNULLReference )
{
PRINT ( ( "Releasing task\n" ) );
status = IOConnectMethodScalarIScalarO ( fConnection,
kSCSITaskUserClientReleaseTask,
1,
0,
fTaskArguments.taskReference );
PRINT ( ( "SCSITaskClass : release task status = 0x%08x\n", status ) );
}
}
HRESULT
SCSITaskClass::QueryInterface ( REFIID iid, void ** ppv )
{
CFUUIDRef uuid = CFUUIDCreateFromUUIDBytes ( NULL, iid );
HRESULT result = S_OK;
PRINT ( ( "SCSITaskClass::QueryInterface\n" ) );
if ( CFEqual ( uuid, IUnknownUUID ) || CFEqual ( uuid, kIOSCSITaskInterfaceID ) )
{
*ppv = &fInterfaceMap;
AddRef ( );
}
else
{
*ppv = 0;
result = E_NOINTERFACE;
}
CFRelease ( uuid );
return result;
}
Boolean
SCSITaskClass::IsTaskActive ( void )
{
Boolean isActive;
isActive = ( ( fTaskState != kSCSITaskState_NEW_TASK ) &&
( fTaskState != kSCSITaskState_ENDED ) ) ? true : false;
PRINT ( ( "SCSITaskClass : IsTaskActive isActive = %d\n", isActive ) );
return isActive;
}
void
SCSITaskClass::SetTaskAttribute ( SCSITaskAttribute inAttributeValue )
{
PRINT ( ( "SCSITaskClass : SetTaskAttribute\n" ) );
PRINT ( ( "taskAttribute = %d\n", inAttributeValue ) );
fTaskArguments.taskAttribute = inAttributeValue;
}
SCSITaskAttribute
SCSITaskClass::GetTaskAttribute ( void )
{
PRINT ( ( "SCSITaskClass : GetTaskAttribute\n" ) );
PRINT ( ( "taskAttribute = %d\n", fTaskArguments.taskAttribute ) );
return fTaskArguments.taskAttribute;
}
IOReturn
SCSITaskClass::SetCommandDescriptorBlock ( UInt8 * inCDB, UInt8 inSize )
{
IOReturn status = kIOReturnBadArgument;
PRINT ( ( "SCSITaskClass : SetCommandDescriptorBlock\n" ) );
require_nonzero ( inCDB, Error_Exit );
switch ( inSize )
{
case kSCSICDBSize_6Byte:
case kSCSICDBSize_10Byte:
case kSCSICDBSize_12Byte:
case kSCSICDBSize_16Byte:
break;
default:
goto Error_Exit;
break;
}
memset ( fTaskArguments.cdbData, 0, sizeof ( SCSICommandDescriptorBlock ) );
memcpy ( fTaskArguments.cdbData, inCDB, inSize );
fTaskArguments.cdbSize = inSize;
status = kIOReturnSuccess;
Error_Exit:
return status;
}
UInt8
SCSITaskClass::GetCommandDescriptorBlockSize ( void )
{
check ( fTaskArguments.cdbSize != 0 );
return fTaskArguments.cdbSize;
}
void
SCSITaskClass::GetCommandDescriptorBlock ( UInt8 * outCDB )
{
check ( outCDB != NULL );
memcpy ( outCDB, fTaskArguments.cdbData, fTaskArguments.cdbSize );
}
IOReturn
SCSITaskClass::SetScatterGatherEntries ( IOVirtualRange * inScatterGatherList,
UInt8 inScatterGatherEntries,
UInt64 transferCount,
UInt8 transferDirection )
{
IOReturn status = kIOReturnSuccess;
PRINT ( ( "SCSITaskClass : SetScatterGatherEntries\n" ) );
check ( inScatterGatherList != NULL );
fSGList = inScatterGatherList;
fTaskArguments.scatterGatherEntries = inScatterGatherEntries;
fTaskArguments.requestedTransferCount = transferCount;
fTaskArguments.transferDirection = transferDirection;
return status;
}
void
SCSITaskClass::SetTimeoutDuration ( UInt32 timeoutDurationMS )
{
PRINT ( ( "SCSITaskClass : SetTimeoutDuration\n" ) );
PRINT ( ( "duration = %ldms\n", timeoutDurationMS ) );
fTaskArguments.timeoutDuration = timeoutDurationMS;
}
UInt32
SCSITaskClass::GetTimeoutDuration ( void )
{
PRINT ( ( "SCSITaskClass : GetTimeoutDuration\n" ) );
return fTaskArguments.timeoutDuration;
}
void
SCSITaskClass::SetTaskCompletionCallback ( SCSITaskCallbackFunction callback,
void * refCon )
{
PRINT ( ( "SCSITaskClass : SetTaskCompletionCallback\n" ) );
fCallbackFunction = callback;
fCallbackRefCon = refCon;
}
IOReturn
SCSITaskClass::ExecuteTaskAsync ( void )
{
IOReturn status = kIOReturnNotPermitted;
PRINT ( ( "SCSITaskClass : ExecuteTaskAsync\n" ) );
require ( fAsyncPort != MACH_PORT_NULL, Error_Exit );
require_nonzero ( fCallbackFunction, Error_Exit );
fTaskArguments.isSync = false;
status = ExecuteTask ( );
Error_Exit:
PRINT ( ( "SCSITaskClass : ExecuteTaskAsync status = 0x%08x\n", status ) );
return status;
}
IOReturn
SCSITaskClass::ExecuteTaskSync ( SCSI_Sense_Data * senseDataBuffer,
SCSITaskStatus * taskStatus,
UInt64 * realizedTransferCount )
{
IOReturn status = kIOReturnSuccess;
PRINT ( ( "SCSITaskClass : ExecuteTaskSync\n" ) );
fTaskArguments.isSync = true;
status = ExecuteTask ( );
fTaskState = kSCSITaskState_ENDED;
PRINT ( ( "SCSITaskClass : ExecuteTaskSync status = 0x%08x\n", status ) );
if ( taskStatus != NULL )
{
*taskStatus = fTaskResults.taskStatus;
}
if ( realizedTransferCount != NULL )
{
*realizedTransferCount = fTaskResults.realizedTransferCount;
}
if ( senseDataBuffer != NULL )
{
if ( ( fTaskResults.serviceResponse == kSCSIServiceResponse_TASK_COMPLETE ) &&
( fTaskResults.taskStatus == kSCSITaskStatus_CHECK_CONDITION ) )
{
if ( fExternalSenseData == NULL )
{
memcpy ( senseDataBuffer, &fSenseData, sizeof ( SCSI_Sense_Data ) );
PRINT ( ( "SENSE_KEY_CODE: 0x%02x, ASC: 0x%02x, ASCQ: 0x%02x\n",
senseDataBuffer->SENSE_KEY & kSENSE_KEY_Mask,
senseDataBuffer->ADDITIONAL_SENSE_CODE,
senseDataBuffer->ADDITIONAL_SENSE_CODE_QUALIFIER ) );
}
}
}
return status;
}
IOReturn
SCSITaskClass::AbortTask ( void )
{
IOReturn status = kIOReturnSuccess;
PRINT ( ( "SCSITaskClass : AbortTask\n" ) );
status = IOConnectMethodScalarIScalarO ( fConnection,
kSCSITaskUserClientAbortTask,
1,
0,
fTaskArguments.taskReference );
PRINT ( ( "SCSITaskClass : AbortTask status = 0x%08x\n", status ) );
return status;
}
SCSITaskState
SCSITaskClass::GetTaskState ( void )
{
PRINT ( ( "SCSITaskClass : GetTaskState taskState = %d\n", fTaskState ) );
return fTaskState;
}
SCSITaskStatus
SCSITaskClass::GetTaskStatus ( void )
{
PRINT ( ( "SCSITaskClass : GetTaskStatus taskStatus = %d\n", fTaskResults.taskStatus ) );
return fTaskResults.taskStatus;
}
UInt64
SCSITaskClass::GetRealizedDataTransferCount ( void )
{
PRINT ( ( "SCSITaskClass : GetRealizedDataTransferCount\n" ) );
PRINT ( ( "0x%lx 0x%lx\n", fTaskResults.realizedTransferCount >> 32,
fTaskResults.realizedTransferCount & 0xFFFFFFFF ) );
return fTaskResults.realizedTransferCount;
}
SCSIServiceResponse
SCSITaskClass::GetServiceResponse ( void )
{
PRINT ( ( "SCSITaskClass : GetServiceResponse\n" ) );
PRINT ( ( "serviceResponse = %d\n", fTaskResults.serviceResponse ) );
return fTaskResults.serviceResponse;
}
IOReturn
SCSITaskClass::GetAutoSenseData ( SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status = kIOReturnNotPermitted;
require_nonzero ( senseDataBuffer, ErrorExit );
if ( ( fTaskResults.serviceResponse == kSCSIServiceResponse_TASK_COMPLETE ) &&
( fTaskResults.taskStatus == kSCSITaskStatus_CHECK_CONDITION ) )
{
if ( fExternalSenseData == NULL )
{
memcpy ( senseDataBuffer, &fSenseData, sizeof ( SCSI_Sense_Data ) );
status = kIOReturnSuccess;
}
PRINT ( ( "SENSE_KEY_CODE: 0x%02x, ASC: 0x%02x, ASCQ: 0x%02x\n",
senseDataBuffer->SENSE_KEY & kSENSE_KEY_Mask,
senseDataBuffer->ADDITIONAL_SENSE_CODE,
senseDataBuffer->ADDITIONAL_SENSE_CODE_QUALIFIER ) );
}
ErrorExit:
return status;
}
void
SCSITaskClass::TaskCompletion ( IOReturn result, void ** args, int numArgs )
{
PRINT ( ( "SCSITaskClass : TaskCompletion, numArgs = %d\n", numArgs ) );
PRINT ( ( "SCSITaskClass : TaskCompletion, result = %d\n", result ) );
fTaskState = kSCSITaskState_ENDED;
if ( fCallbackFunction != NULL )
( fCallbackFunction )( fTaskResults.serviceResponse,
fTaskResults.taskStatus,
fTaskResults.realizedTransferCount,
fCallbackRefCon );
}
IOReturn
SCSITaskClass::ExecuteTask ( void )
{
IOReturn status = kIOReturnSuccess;
UInt32 size = 0;
UInt8 commandData[4096] = { 0 };
SCSITaskData * args;
PRINT ( ( "SCSITaskClass::ExecuteTask\n" ) );
fTaskResults.realizedTransferCount = 0;
fTaskState = kSCSITaskState_ENABLED;
args = ( SCSITaskData * ) commandData;
*args = fTaskArguments;
PRINT ( ( "Copying SG entries\n" ) );
memcpy ( &args->scatterGatherList[0], fSGList, fTaskArguments.scatterGatherEntries * sizeof ( IOVirtualRange ) );
PRINT ( ( "Determining size\n" ) );
PRINT ( ( "Struct size = %ld\n", sizeof ( SCSITaskData ) ) );
size = ( ( char * ) &args->scatterGatherList[fTaskArguments.scatterGatherEntries] ) - ( char * ) commandData;
PRINT ( ( "size = %ld\n", size ) );
status = IOConnectMethodScalarIStructureI ( fConnection,
kSCSITaskUserClientExecuteTask,
0,
size,
commandData );
PRINT ( ( "ExecuteTask status = 0x%08x\n", status ) );
return status;
}
IOReturn
SCSITaskClass::SetSenseDataBuffer ( void * buffer, UInt8 bufferSize )
{
IOReturn status = kIOReturnBadArgument;
UInt8 size = 0;
PRINT ( ( "SCSITaskClass::SetSenseDataBuffer\n" ) );
require_nonzero ( bufferSize, ErrorExit );
if ( buffer == NULL )
{
PRINT ( ( "buffer == NULL\n" ) );
buffer = ( void * ) &fSenseData;
size = sizeof ( fSenseData );
bufferSize = ( bufferSize < size ) ? bufferSize : size;
}
if ( buffer != &fSenseData )
{
fExternalSenseData = ( SCSI_Sense_Data * ) buffer;
}
else
{
fExternalSenseData = NULL;
}
PRINT ( ( "taskReference = %ld\n", fTaskArguments.taskReference ) );
PRINT ( ( "fTaskResultsBuffer = %x\n", &fTaskResults ) );
PRINT ( ( "senseDataBuffer = %x\n", buffer ) );
PRINT ( ( "senseDataBufferSize = %ld\n", bufferSize ) );
status = IOConnectMethodScalarIScalarO ( fConnection,
kSCSITaskUserClientSetBuffers,
4,
0,
fTaskArguments.taskReference,
&fTaskResults,
buffer,
bufferSize );
PRINT ( ( "SetBuffers returned status = 0x%08x\n", status ) );
ErrorExit:
return status;
}
#if 0
#pragma mark -
#pragma mark Static C->C++ Glue Functions
#pragma mark -
#endif
Boolean
SCSITaskClass::sIsTaskActive ( void * task )
{
check ( task != NULL );
return getThis ( task )->IsTaskActive ( );
}
IOReturn
SCSITaskClass::sSetTaskAttribute (
void * task,
SCSITaskAttribute inAttributeValue )
{
check ( task != NULL );
getThis ( task )->SetTaskAttribute ( inAttributeValue );
return kIOReturnSuccess;
}
IOReturn
SCSITaskClass::sGetTaskAttribute (
void * task,
SCSITaskAttribute * outTaskAttributeValue )
{
check ( task != NULL );
*outTaskAttributeValue = getThis ( task )->GetTaskAttribute ( );
return kIOReturnSuccess;
}
IOReturn
SCSITaskClass::sSetCommandDescriptorBlock ( void * task,
UInt8 * inCDB,
UInt8 inSize )
{
check ( task != NULL );
return getThis ( task )->SetCommandDescriptorBlock ( inCDB, inSize );
}
UInt8
SCSITaskClass::sGetCommandDescriptorBlockSize ( void * task )
{
check ( task != NULL );
return getThis ( task )->GetCommandDescriptorBlockSize ( );
}
IOReturn
SCSITaskClass::sGetCommandDescriptorBlock ( void * task, UInt8 * outCDB )
{
check ( task != NULL );
getThis ( task )->GetCommandDescriptorBlock ( outCDB );
return kIOReturnSuccess;
}
IOReturn
SCSITaskClass::sSetScatterGatherEntries (
void * task,
IOVirtualRange * inScatterGatherList,
UInt8 inScatterGatherEntries,
UInt64 transferCount,
UInt8 transferDirection )
{
check ( task != NULL );
return getThis ( task )->SetScatterGatherEntries (
inScatterGatherList,
inScatterGatherEntries,
transferCount,
transferDirection );
}
IOReturn
SCSITaskClass::sSetTimeoutDuration ( void * task, UInt32 timeoutDurationMS )
{
check ( task != NULL );
getThis ( task )->SetTimeoutDuration ( timeoutDurationMS );
return kIOReturnSuccess;
}
UInt32
SCSITaskClass::sGetTimeoutDuration ( void * task )
{
check ( task != NULL );
return getThis ( task )->GetTimeoutDuration ( );
}
IOReturn
SCSITaskClass::sSetTaskCompletionCallback (
void * task,
SCSITaskCallbackFunction callback,
void * refCon )
{
check ( task != NULL );
getThis ( task )->SetTaskCompletionCallback ( callback, refCon );
return kIOReturnSuccess;
}
IOReturn
SCSITaskClass::sExecuteTaskAsync ( void * task )
{
check ( task != NULL );
return getThis ( task )->ExecuteTaskAsync ( );
}
IOReturn
SCSITaskClass::sExecuteTaskSync (
void * task,
SCSI_Sense_Data * senseDataBuffer,
SCSITaskStatus * taskStatus,
UInt64 * realizedTransferCount )
{
check ( task != NULL );
return getThis ( task )->ExecuteTaskSync ( senseDataBuffer,
taskStatus,
realizedTransferCount );
}
IOReturn
SCSITaskClass::sAbortTask ( void * task )
{
check ( task != NULL );
return getThis ( task )->AbortTask ( );
}
IOReturn
SCSITaskClass::sGetTaskState ( void * task, SCSITaskState * outTaskState )
{
check ( task != NULL );
*outTaskState = getThis ( task )->GetTaskState ( );
return kIOReturnSuccess;
}
IOReturn
SCSITaskClass::sGetTaskStatus ( void * task, SCSITaskStatus * outTaskStatus )
{
check ( task != NULL );
*outTaskStatus = getThis ( task )->GetTaskStatus ( );
return kIOReturnSuccess;
}
UInt64
SCSITaskClass::sGetRealizedDataTransferCount ( void * task )
{
check ( task != NULL );
return getThis ( task )->GetRealizedDataTransferCount ( );
}
IOReturn
SCSITaskClass::sGetServiceResponse (
void * task,
SCSIServiceResponse * serviceResponse )
{
check ( task != NULL );
*serviceResponse = getThis ( task )->GetServiceResponse ( );
return kIOReturnSuccess;
}
IOReturn
SCSITaskClass::sGetAutoSenseData (
void * task,
SCSI_Sense_Data * senseDataBuffer )
{
check ( task != NULL );
return getThis ( task )->GetAutoSenseData ( senseDataBuffer );
}
void
SCSITaskClass::sTaskCompletion ( void * refcon,
IOReturn result,
void ** args,
int numArgs )
{
PRINT ( ( "SCSITaskClass : sTaskCompletion, numArgs = %d\n", numArgs ) );
check ( refcon != NULL );
( ( SCSITaskClass * ) refcon )->TaskCompletion ( result, args, numArgs );
}
IOReturn
SCSITaskClass::sSetSenseDataBuffer ( void * task,
SCSI_Sense_Data * buffer,
UInt8 bufferSize )
{
check ( task != NULL );
return getThis ( task )->SetSenseDataBuffer ( ( void * ) buffer, bufferSize );
}