MMCDeviceUserClientClass.cpp [plain text]
#include <CoreFoundation/CFMachPort.h>
#include <CoreFoundation/CFNumber.h>
#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/scsi-commands/SCSICmds_INQUIRY_Definitions.h>
#include "MMCDeviceUserClientClass.h"
#include "SCSITaskDeviceClass.h"
#include <string.h>
__BEGIN_DECLS
#include <mach/mach_interface.h>
#include <IOKit/iokitmig.h>
__END_DECLS
#define MMC_DEVICE_CLASS_DEBUGGING_LEVEL 0
#if ( MMC_DEVICE_CLASS_DEBUGGING_LEVEL > 0 )
#define PRINT(x) printf x
#else
#define PRINT(x)
#endif
IOCFPlugInInterface
MMCDeviceUserClientClass::sIOCFPlugInInterface =
{
0,
&MMCDeviceUserClientClass::staticQueryInterface,
&MMCDeviceUserClientClass::staticAddRef,
&MMCDeviceUserClientClass::staticRelease,
1, 0, &MMCDeviceUserClientClass::staticProbe,
&MMCDeviceUserClientClass::staticStart,
&MMCDeviceUserClientClass::staticStop
};
MMCDeviceInterface
MMCDeviceUserClientClass::sMMCDeviceInterface =
{
0,
&MMCDeviceUserClientClass::staticQueryInterface,
&MMCDeviceUserClientClass::staticAddRef,
&MMCDeviceUserClientClass::staticRelease,
1, 0, &MMCDeviceUserClientClass::staticInquiry,
&MMCDeviceUserClientClass::staticTestUnitReady,
&MMCDeviceUserClientClass::staticGetPerformance,
&MMCDeviceUserClientClass::staticGetConfiguration,
&MMCDeviceUserClientClass::staticModeSense10,
&MMCDeviceUserClientClass::staticSetWriteParametersModePage,
&MMCDeviceUserClientClass::staticGetTrayState,
&MMCDeviceUserClientClass::staticSetTrayState,
&MMCDeviceUserClientClass::staticReadTableOfContents,
&MMCDeviceUserClientClass::staticReadDiscInformation,
&MMCDeviceUserClientClass::staticReadTrackInformation,
&MMCDeviceUserClientClass::staticReadDVDStructure,
&MMCDeviceUserClientClass::staticGetSCSITaskDeviceInterface
};
#pragma mark Public Methods
IOCFPlugInInterface **
MMCDeviceUserClientClass::alloc ( void )
{
MMCDeviceUserClientClass * userClient;
IOCFPlugInInterface ** interface = NULL;
PRINT ( ( "MMCDeviceUserClientClass::alloc called\n" ) );
userClient = new MMCDeviceUserClientClass;
if ( userClient != NULL )
{
userClient->AddRef ( );
interface = ( IOCFPlugInInterface ** ) &userClient->fMMCDeviceInterfaceMap.pseudoVTable;
}
else
{
PRINT ( ( "userClient is null\n" ) );
}
PRINT ( ( "returning interface\n" ) );
return interface;
}
#pragma mark -
#pragma mark Protected Methods
MMCDeviceUserClientClass::MMCDeviceUserClientClass ( void )
{
PRINT ( ( "MMCDeviceUserClientClass constructor called\n" ) );
fRefCount = 0;
fConnection = MACH_PORT_NULL;
fService = MACH_PORT_NULL;
fIOCFPlugInInterface.pseudoVTable = ( IUnknownVTbl * ) &sIOCFPlugInInterface;
fIOCFPlugInInterface.obj = this;
fMMCDeviceInterfaceMap.pseudoVTable = ( IUnknownVTbl * ) &sMMCDeviceInterface;
fMMCDeviceInterfaceMap.obj = this;
fFactoryId = kIOSCSITaskLibFactoryID;
CFRetain ( fFactoryId );
CFPlugInAddInstanceForFactory ( fFactoryId );
}
MMCDeviceUserClientClass::~MMCDeviceUserClientClass ( void )
{
kern_return_t err = 0;
PRINT ( ( "MMCDeviceUserClientClass destructor called\n" ) );
if ( fConnection != MACH_PORT_NULL )
{
err = IOServiceClose ( fConnection );
fConnection = MACH_PORT_NULL;
PRINT ( ( "MMCDeviceUserClientClass : IOServiceClose returned err = 0x%08x\n", err ) );
}
PRINT ( ( "MMCDeviceUserClientClass : calling CFPlugInRemoveInstanceForFactory\n" ) );
CFPlugInRemoveInstanceForFactory ( fFactoryId );
PRINT ( ( "MMCDeviceUserClientClass : CFPlugInRemoveInstanceForFactory called\n" ) );
CFRelease ( fFactoryId );
PRINT ( ( "MMCDeviceUserClientClass : CFRelease called\n" ) );
}
HRESULT
MMCDeviceUserClientClass::staticQueryInterface ( void * self, REFIID iid, void ** ppv )
{
return getThis ( self )->QueryInterface ( iid, ppv );
}
HRESULT
MMCDeviceUserClientClass::QueryInterface ( REFIID iid, void ** ppv )
{
CFUUIDRef uuid = CFUUIDCreateFromUUIDBytes ( NULL, iid );
HRESULT result = S_OK;
PRINT ( ( "MMCDeviceUserClientClass QueryInterface called\n" ) );
if ( CFEqual ( uuid, IUnknownUUID ) || CFEqual ( uuid, kIOCFPlugInInterfaceID ) )
{
PRINT ( ( "UUID recognized, unknownUUID or IOCFPlugin UUID\n" ) );
*ppv = &fIOCFPlugInInterface;
AddRef ( );
}
else if ( CFEqual ( uuid, kIOMMCDeviceInterfaceID ) )
{
PRINT ( ( "MMC UUID recognized\n" ) );
*ppv = &fMMCDeviceInterfaceMap;
AddRef ( );
}
else
{
PRINT ( ( "UUID unrecognized\n" ) );
*ppv = 0;
}
if ( !*ppv )
result = E_NOINTERFACE;
CFRelease ( uuid );
return result;
}
UInt32
MMCDeviceUserClientClass::staticAddRef ( void * self )
{
return getThis ( self )->AddRef ( );
}
UInt32
MMCDeviceUserClientClass::AddRef ( void )
{
PRINT ( ( "MMCDeviceUserClientClass AddRef called\n" ) );
fRefCount += 1;
PRINT ( ( "fRefCount = %ld\n", fRefCount ) );
return fRefCount;
}
UInt32
MMCDeviceUserClientClass::staticRelease ( void * self )
{
return getThis ( self )->Release ( );
}
UInt32
MMCDeviceUserClientClass::Release ( void )
{
UInt32 retVal = fRefCount;
PRINT ( ( "MMCDeviceUserClientClass Release called\n" ) );
if ( 1 == fRefCount-- )
{
delete this;
}
else if ( fRefCount < 0 )
{
fRefCount = 0;
}
PRINT ( ( "fRefCount = %ld\n", fRefCount ) );
return retVal;
}
IOReturn
MMCDeviceUserClientClass::staticProbe ( void * self, CFDictionaryRef propertyTable,
io_service_t service, SInt32 * order )
{
return getThis ( self )->Probe ( propertyTable, service, order );
}
IOReturn
MMCDeviceUserClientClass::Probe ( CFDictionaryRef propertyTable,
io_service_t inService,
SInt32 * order )
{
CFMutableDictionaryRef dict;
kern_return_t kernErr;
PRINT ( ( "MMCDeviceUserClientClass::Probe called\n" ) );
if ( inService == NULL )
return kIOReturnBadArgument;
kernErr = IORegistryEntryCreateCFProperties ( inService, &dict, NULL, 0 );
if ( kernErr != KERN_SUCCESS )
{
return kIOReturnBadArgument;
}
if ( CFDictionaryContainsKey ( dict, CFSTR ( kIOPropertySCSITaskUserClientInstanceGUID ) ) )
{
if ( !IOObjectConformsTo ( inService, "IOCompactDiscServices" ) &&
!IOObjectConformsTo ( inService, "IODVDServices" ) )
{
PRINT ( ( "MMCDeviceUserClientClass::Probe not our service type\n" ) );
return kIOReturnBadArgument;
}
}
else
{
return kIOReturnBadArgument;
}
return kIOReturnSuccess;
}
IOReturn
MMCDeviceUserClientClass::staticStart ( void * self,
CFDictionaryRef propertyTable,
io_service_t service )
{
return getThis ( self )->Start ( propertyTable, service );
}
IOReturn
MMCDeviceUserClientClass::Start ( CFDictionaryRef propertyTable, io_service_t service )
{
IOReturn status = kIOReturnSuccess;
PRINT ( ( "MMCDeviceUserClientClass : start\n" ) );
fService = service;
status = IOServiceOpen ( fService, mach_task_self ( ),
kSCSITaskLibConnection, &fConnection );
if ( !fConnection )
status = kIOReturnNoDevice;
PRINT ( ( "MMCDeviceUserClientClass : IOServiceOpen status = 0x%08lx, connection = %d\n",
( UInt32 ) status, fConnection ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticStop ( void * self )
{
return getThis ( self )->Stop ( );
}
IOReturn
MMCDeviceUserClientClass::Stop ( void )
{
IOReturn status = kIOReturnSuccess;
PRINT ( ( "MMCDeviceUserClientClass : stop\n" ) );
if ( fConnection )
{
PRINT ( ( "MMCDeviceUserClientClass : IOServiceClose connection = %d\n", fConnection ) );
status = IOServiceClose ( fConnection );
fConnection = MACH_PORT_NULL;
PRINT ( ( "IOServiceClose status = 0x%08x\n", status ) );
}
return kIOReturnSuccess;
}
IOReturn
MMCDeviceUserClientClass::staticInquiry ( void * self,
SCSICmd_INQUIRY_StandardData * inquiryBuffer,
UInt32 inqBufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->Inquiry ( inquiryBuffer, inqBufferSize, outTaskStatus, senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::Inquiry ( SCSICmd_INQUIRY_StandardData * inquiryBuffer,
UInt32 inqBufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status;
UInt32 params[3];
UInt32 outParams[1];
mach_msg_type_number_t len = 1;
params[0] = ( UInt32 ) inqBufferSize;
params[1] = ( UInt32 ) inquiryBuffer;
params[2] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceInquiry,
( int * ) params, 3,
( int * ) outParams, &len );
PRINT ( ( "MMCDeviceUserClientClass : Inquiry status = 0x%08x\n", status ) );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
return status;
}
IOReturn
MMCDeviceUserClientClass::staticTestUnitReady ( void * self,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->TestUnitReady ( outTaskStatus, senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::TestUnitReady ( SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status;
UInt32 params[1];
UInt32 outParams[1];
mach_msg_type_number_t len = 1;
params[0] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceTestUnitReady,
( int * ) params, 1,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : TestUnitReady taskStatus = %d\n", *outTaskStatus ) );
if ( *outTaskStatus == kSCSITaskStatus_CHECK_CONDITION )
{
PRINT ( ( "SENSE_KEY_CODE: 0x%08x, ASC: 0x%08x, ASCQ: 0x%08x\n",
senseDataBuffer->SENSE_KEY & kSENSE_KEY_Mask,
senseDataBuffer->ADDITIONAL_SENSE_CODE,
senseDataBuffer->ADDITIONAL_SENSE_CODE_QUALIFIER ) );
}
return status;
}
IOReturn
MMCDeviceUserClientClass::staticGetPerformance ( void * self, UInt8 TOLERANCE, UInt8 WRITE, UInt8 EXCEPT,
UInt32 STARTING_LBA, UInt16 MAXIMUM_NUMBER_OF_DESCRIPTORS,
void * buffer, UInt16 bufferSize, SCSITaskStatus * taskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->GetPerformance ( TOLERANCE, WRITE, EXCEPT, STARTING_LBA, MAXIMUM_NUMBER_OF_DESCRIPTORS,
buffer, bufferSize, taskStatus, senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::GetPerformance ( UInt8 TOLERANCE, UInt8 WRITE, UInt8 EXCEPT, UInt32 STARTING_LBA,
UInt16 MAXIMUM_NUMBER_OF_DESCRIPTORS, void * buffer, UInt16 bufferSize,
SCSITaskStatus * outTaskStatus, SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status;
mach_msg_type_number_t len = 1;
UInt32 params[5];
UInt32 outParams[1];
params[0] = ( UInt32 ) ( ( TOLERANCE << 16 ) | ( WRITE << 8 ) | EXCEPT );
params[1] = ( UInt32 ) ( STARTING_LBA );
params[2] = ( UInt32 ) ( ( MAXIMUM_NUMBER_OF_DESCRIPTORS << 16 ) | bufferSize );
params[3] = ( UInt32 ) buffer;
params[4] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceGetConfiguration,
( int * ) params, 5,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : GetConfiguration status = %d\n", status ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticGetConfiguration ( void * self, UInt8 RT, UInt16 STARTING_FEATURE_NUMBER,
void * buffer, UInt16 bufferSize, SCSITaskStatus * taskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->GetConfiguration ( RT, STARTING_FEATURE_NUMBER, buffer, bufferSize,
taskStatus, senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::GetConfiguration ( UInt8 RT, UInt16 STARTING_FEATURE_NUMBER,
void * buffer, UInt16 bufferSize, SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status;
mach_msg_type_number_t len = 1;
UInt32 params[5];
UInt32 outParams[1];
if ( RT > 0x02 )
return kIOReturnBadArgument;
params[0] = ( UInt32 ) ( RT );
params[1] = ( UInt32 ) ( STARTING_FEATURE_NUMBER );
params[2] = ( UInt32 ) buffer;
params[3] = ( UInt32 ) bufferSize;
params[4] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceGetConfiguration,
( int * ) params, 5,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : GetConfiguration status = %d\n", status ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticModeSense10 ( void * self, UInt8 LLBAA, UInt8 DBD, UInt8 PC,
UInt8 PAGE_CODE, void * buffer, UInt16 bufferSize,
SCSITaskStatus * outTaskStatus, SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->ModeSense10 ( LLBAA, DBD, PC, PAGE_CODE, buffer,
bufferSize, outTaskStatus, senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::ModeSense10 ( UInt8 LLBAA, UInt8 DBD, UInt8 PC, UInt8 PAGE_CODE,
void * buffer, UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status;
mach_msg_type_number_t len = 1;
UInt32 params[5];
UInt32 outParams[1];
params[0] = ( UInt32 ) ( ( DBD & 0x01 << 2 ) | ( LLBAA & 0x01 << 3 ) );
params[1] = ( UInt32 ) ( ( PC & 0x04 << 5 ) | ( PAGE_CODE & 0x3F ) );
params[2] = ( UInt32 ) buffer;
params[3] = ( UInt32 ) bufferSize;
params[4] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceModeSense10,
( int * ) params, 5,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : ModeSense10 status = %d\n", status ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticSetWriteParametersModePage ( void * self, void * buffer, UInt8 bufferSize,
SCSITaskStatus * taskStatus, SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->SetWriteParametersModePage ( buffer, bufferSize, taskStatus, senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::SetWriteParametersModePage ( void * buffer, UInt8 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status;
mach_msg_type_number_t len = 1;
UInt32 params[3];
UInt32 outParams[1];
if ( ( ( ( UInt8 * ) buffer )[8] & 0x3F ) != 0x05 )
return kIOReturnBadArgument;
params[0] = ( UInt32 ) buffer;
params[1] = bufferSize;
params[2] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceSetWriteParametersModePage,
( int * ) params, 3,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : SetWriteParametersModePage status = %d\n", status ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticGetTrayState ( void * self, UInt8 * trayState )
{
return getThis ( self )->GetTrayState ( trayState );
}
IOReturn
MMCDeviceUserClientClass::GetTrayState ( UInt8 * trayState )
{
IOReturn status;
UInt32 outParams[1];
mach_msg_type_number_t len = 1;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceGetTrayState,
NULL, 0,
( int * ) outParams, &len );
*trayState = ( UInt8 )( ( outParams[0] != 0 ) ? kMMCDeviceTrayOpen : kMMCDeviceTrayClosed );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticSetTrayState ( void * self, UInt8 trayState )
{
return getThis ( self )->SetTrayState ( trayState );
}
IOReturn
MMCDeviceUserClientClass::SetTrayState ( UInt8 trayState )
{
IOReturn status;
UInt32 params[1];
mach_msg_type_number_t len = 0;
if ( ( trayState != kMMCDeviceTrayOpen ) &&
( trayState != kMMCDeviceTrayClosed ) )
return kIOReturnBadArgument;
params[0] = trayState;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceSetTrayState,
( int * ) params, 1,
NULL, &len );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticReadTableOfContents ( void * self, UInt8 MSF,
UInt8 format, UInt8 trackSessionNumber,
void * buffer, UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->ReadTableOfContents ( MSF, format, trackSessionNumber,
buffer, bufferSize, outTaskStatus,
senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::ReadTableOfContents ( UInt8 MSF,
UInt8 format,
UInt8 trackSessionNumber,
void * buffer,
UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status = kIOReturnSuccess;
mach_msg_type_number_t len = 1;
UInt32 params[5];
UInt32 outParams[1];
params[0] = ( UInt32 ) ( ( MSF << 8 ) | format );
params[1] = ( UInt32 ) trackSessionNumber;
params[2] = ( UInt32 ) buffer;
params[3] = ( UInt32 ) bufferSize;
params[4] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceReadTableOfContents,
( int * ) params, 5,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : ReadTableOfContents status = 0x%08x\n", status ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticReadDiscInformation ( void * self,
void * buffer,
UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->ReadDiscInformation ( buffer, bufferSize, outTaskStatus, senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::ReadDiscInformation ( void * buffer, UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status = kIOReturnSuccess;
mach_msg_type_number_t len = 1;
UInt32 params[3];
UInt32 outParams[1];
params[0] = ( UInt32 ) buffer;
params[1] = ( UInt32 ) bufferSize;
params[2] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceReadDiscInformation,
( int * ) params, 3,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : ReadDiscInformation status = 0x%08x\n", status ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticReadTrackInformation ( void * self,
UInt8 addressNumberType,
UInt32 lbaTrackSessionNumber,
void * buffer,
UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->ReadTrackInformation ( addressNumberType,
lbaTrackSessionNumber,
buffer,
bufferSize,
outTaskStatus,
senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::ReadTrackInformation ( UInt8 addressNumberType,
UInt32 lbaTrackSessionNumber,
void * buffer,
UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status = kIOReturnSuccess;
mach_msg_type_number_t len = 1;
UInt32 params[5];
UInt32 outParams[1];
params[0] = ( UInt32 ) addressNumberType;
params[1] = ( UInt32 ) lbaTrackSessionNumber;
params[2] = ( UInt32 ) buffer;
params[3] = ( UInt32 ) bufferSize;
params[4] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceReadTrackInformation,
( int * ) params, 5,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : ReadTrackInformation status = 0x%08x\n", status ) );
return status;
}
IOReturn
MMCDeviceUserClientClass::staticReadDVDStructure ( void * self,
UInt32 logicalBlockAddress,
UInt8 layerNumber,
UInt8 format,
void * buffer,
UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
return getThis ( self )->ReadDVDStructure ( logicalBlockAddress,
layerNumber,
format,
buffer,
bufferSize,
outTaskStatus,
senseDataBuffer );
}
IOReturn
MMCDeviceUserClientClass::ReadDVDStructure ( UInt32 logicalBlockAddress,
UInt8 layerNumber,
UInt8 format,
void * buffer,
UInt16 bufferSize,
SCSITaskStatus * outTaskStatus,
SCSI_Sense_Data * senseDataBuffer )
{
IOReturn status = kIOReturnSuccess;
mach_msg_type_number_t len = 1;
UInt32 params[5];
UInt32 outParams[1];
params[0] = ( UInt32 ) logicalBlockAddress;
params[1] = ( UInt32 ) ( layerNumber << 8 ) | format;
params[2] = ( UInt32 ) buffer;
params[3] = ( UInt32 ) bufferSize;
params[4] = ( UInt32 ) senseDataBuffer;
status = io_connect_method_scalarI_scalarO ( fConnection,
kMMCDeviceReadDVDStructure,
( int * ) params, 5,
( int * ) outParams, &len );
*outTaskStatus = ( SCSITaskStatus ) outParams[0];
PRINT ( ( "MMCDeviceUserClientClass : ReadDVDStructure status = 0x%08x\n", status ) );
return status;
}
SCSITaskDeviceInterface **
MMCDeviceUserClientClass::staticGetSCSITaskDeviceInterface ( void * self )
{
return getThis ( self )->GetSCSITaskDeviceInterface ( );
}
SCSITaskDeviceInterface **
MMCDeviceUserClientClass::GetSCSITaskDeviceInterface ( void )
{
return ( SCSITaskDeviceInterface ** ) SCSITaskDeviceClass::alloc ( fService, fConnection );
}