Subclassing Logical Unit Drivers

OSBundleRequired        String  Local-Root

#ifndef _MyLogicalUnitDriver_H_

#define _MyLogicalUnitDriver_H_

// Because the sample driver is a subclass of the Apple-provided

// peripheral device type 05 driver, it must include that driver's

// header file.

#include <IOKit/scsi-commands/IOSCSIPeripheralDeviceType05.h>

// Here, the sample driver declares its inheritance and the method

// it overrides.

class com_MySoftwareCompany_driver_MyLogicalUnitDriver : public

        IOSCSIPeripheralDeviceType05

{

    OSDeclareDefaultStructors (

                com_MySoftwareCompany_driver_MyLogicalUnitDriver )

protected:

    virtual IOReturn GetConfiguration ( void );

};

#endif /* _MyLogicalUnitDriver_H_ */

// Include the header file you created

#include "MyLogicalUnitDriver.h"

// This definition allows you to use the more convenient "super" in

// place of "IOSCSIPeripheralDeviceType05", where appropriate.

#define super IOSCSIPeripheralDeviceType05

// This macro must appear before you define any of your class's methods.

// Note that you must use the literal name of the superclass here, not

// "super" as defined above.

OSDefineMetaClassAndStructors (

        com_MySoftwareCompany_driver_MyLogicalUnitDriver,

        IOSCSIPeripheralDeviceType05 );

// Define the method to override.

IOReturn

com_MySoftwareCompany_driver_MyLogicalUnitDriver::GetConfiguration ( void )

{

    IOLog( "MyLogicalUnitDriver overriding GetConfiguration\n" );

// You can add code that accesses your device here.

// Call super's GetConfiguration method before returning.

    return super::GetConfiguration();

}

tail -f /var/log/system.log

#ifndef _SampleINQUIRYDriver_H_

#define _SampleINQUIRYDriver_H_

#include <IOKit/scsi/IOSCSIPeripheralDeviceType00.h>

class com_MySoftwareCompany_driver_SampleINQUIRYDriver : public IOSCSIPeripheralDeviceType00

{

    OSDeclareDefaultStructors ( com_MySoftwareCompany_driver_SampleINQUIRYDriver )

protected:

    bool    InitializeDeviceSupport ( void );

    void    SendBuiltInINQUIRY ( void );

    void    SendCreatedINQUIRY ( void );

    bool    BuildINQUIRY ( SCSITaskIdentifier    request,

                           IOBufferMemoryDescriptor *    buffer,

                           SCSICmdField1Bit      CMDDT,

                           SCSICmdField1Bit      EVPD,

                           SCSICmdField1Byte     PAGE_OR_OPERATION_CODE,

                           SCSICmdField1Byte     ALLOCATION_LENGTH,

                           SCSICmdField1Byte     CONTROL );

};

#endif /* _SampleINQUIRYDriver_H_ */

#include <IOKit/IOBufferMemoryDescriptor.h>

#include <IOKit/scsi/SCSICmds_INQUIRY_Definitions.h>

#include <IOKit/scsi/SCSICommandOperationCodes.h>

#include <IOKit/scsi/SCSITask.h>

#include "SampleINQUIRYDriver.h"

#define super IOSCSIPeripheralDeviceType00

OSDefineMetaClassAndStructors ( com_MySoftwareCompany_driver_SampleINQUIRYDriver, IOSCSIPeripheralDeviceType00 );

bool

com_MySoftwareCompany_driver_SampleINQUIRYDriver::InitializeDeviceSupport ( void )

{

    bool    result = false;

    result = super::InitializeDeviceSupport ( );

    if ( result == true ) {

        SendBuiltInINQUIRY ( );

        SendCreatedINQUIRY ( );

    }

    return result;

}

void

com_MySoftwareCompany_driver_SampleINQUIRYDriver::SendBuiltInINQUIRY ( void )

{

    // The Service Response represents the execution status of a service request.

    SCSIServiceResponse                serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;

    IOBufferMemoryDescriptor *         buffer  = NULL;

    SCSITaskIdentifier                 request = NULL;

    UInt8 *                            ptr     = NULL;

    // Get a new IOBufferMemoryDescriptor object with a buffer large enough

    // to hold the SCSICmd_INQUIRY_StandardData structure (defined

    // in SCSICmds_INQUIRY_Definitions.h).

    buffer = IOBufferMemoryDescriptor::withCapacity ( sizeof ( SCSICmd_INQUIRY_StandardData ), kIODirectionIn, false );

    require ( ( buffer != NULL ), ErrorExit );

    // Get the address of the beginning of the buffer and zero-fill the buffer.

    ptr = ( UInt8 * ) buffer->getBytesNoCopy ( );

    bzero ( ptr, buffer->getLength ( ) );

    // Create a new SCSITask object; if unsuccessful, release

    request = GetSCSITask ( );

    require ( ( request != NULL ), ReleaseBuffer );

    // Prepare the buffer for an I/O transaction. This call must be

    // balanced by a call to the complete method (shown just before

    // ReleaseTask).

    require ( ( buffer->prepare ( ) == kIOReturnSuccess ), ReleaseTask );

    // Use the INQUIRY method to assemble the command. Then use the

    // SendCommand method to synchronously issue the request.

    if ( INQUIRY (  request,

                    buffer,

                    0,

                    0,

                    0x00,

                    buffer->getLength ( ),

                    0 ) == true )

    {

        serviceResponse = SendCommand ( request, kTenSecondTimeoutInMS );

    }

    // Check the SendCommand method's return value and the status of the SCSITask object.

    if ( ( serviceResponse == kSCSIServiceResponse_TASK_COMPLETE ) &&

           GetTaskStatus ( request ) == kSCSITaskStatus_GOOD )

    {

        IOLog ( "INQUIRY succeeded\n" );

    }

    else

    {

        IOLog ( "INQUIRY failed\n" );

    }

    // Complete the processing of this buffer after the I/O transaction

    // (this call balances the earlier call to prepare).

    buffer->complete ( );

// Clean up before exiting.

ReleaseTask:

    require_quiet ( ( request != NULL ), ReleaseBuffer );

    ReleaseSCSITask ( request );

    request = NULL;

ReleaseBuffer:

    require_quiet ( ( buffer != NULL ), ErrorExit );

    buffer->release ( );

    buffer = NULL;

ErrorExit:

    return;

}

void

com_MySoftwareCompany_driver_SampleINQUIRYDriver::SendCreatedINQUIRY ( void )

{

    SCSIServiceResponse                serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;

    IOBufferMemoryDescriptor *        buffer            = NULL;

    SCSITaskIdentifier                request            = NULL;

    UInt8 *                            ptr                = NULL;

    // Get a new IOBufferMemoryDescriptor object with a buffer large enough

    // to hold the SCSICmd_INQUIRY_StandardData structure (defined in

    // SCSICmds_INQUIRY_Definitions.h).

    buffer = IOBufferMemoryDescriptor::withCapacity ( sizeof ( SCSICmd_INQUIRY_StandardData ), kIODirectionIn, false );

    // Return immediately if the buffer wasn't created.

    require ( ( buffer != NULL ), ErrorExit );

    // Get the address of the beginning of the buffer and zero-fill the buffer.

    ptr = ( UInt8 * ) buffer->getBytesNoCopy ( );

    bzero ( ptr, buffer->getLength ( ) );

    // Create a new SCSITask object; if unsuccessful, release the buffer and return.

    request = GetSCSITask ( );

    require ( ( request != NULL ), ReleaseBuffer );

    // Prepare the buffer for an I/O transaction. This call must be

    // balanced by a call to the complete method (shown just before

    // ReleaseTask).

    require ( ( buffer->prepare ( ) == kIOReturnSuccess ), ReleaseTask );

    // The BuildINQUIRY function shows how you can design and use a

    // command-building function to create a custom command to send

    // to your device. Although the BuildINQUIRY function builds a standard INQUIRY

    // command from the passed-in values, you do not create a custom function to

    // build a standard command in a real driver. Instead, you use the SCSI

    // Architecture Model family's built-in command-building functions. The

    // BuildINQUIRY function uses INQUIRY as an example merely because

    // it is a well-understood command.

    if ( BuildINQUIRY ( request,

                        buffer,

                        0x00, // CMDDT (Command support data)

                        0x00, // EVPD  (Vital product data)

                        0x00, // PAGE_OR_OPERATION_CODE

                        buffer->getLength ( ), // ALLOCATION_LENGTH

                        0x00 )  // CONTROL

                == true)

    {

        serviceResponse = SendCommand ( request, kTenSecondTimeoutInMS );

    }

    if ( ( serviceResponse == kSCSIServiceResponse_TASK_COMPLETE ) &&

           GetTaskStatus ( request ) == kSCSITaskStatus_GOOD )

    {

        IOLog ( "Vendor-created INQUIRY command succeeded\n" );

    }

    else

    {

        IOLog ( "Vendor-created INQUIRY command failed\n" );

    }

    buffer->complete ( );

ReleaseTask:

    require_quiet ( ( request != NULL ), ReleaseBuffer );

    ReleaseSCSITask ( request );

    request = NULL;

ReleaseBuffer:

    require_quiet ( ( buffer != NULL ), ErrorExit );

    buffer->release ( );

    buffer = NULL;

ErrorExit:

    return;

}

bool

com_MySoftwareCompany_driver_SampleINQUIRYDriver::BuildINQUIRY (

                                            SCSITaskIdentifier    request,

                                            IOBufferMemoryDescriptor *    dataBuffer,

                                            SCSICmdField1Bit     CMDDT,

                                            SCSICmdField1Bit     EVPD,

                                            SCSICmdField1Byte     PAGE_OR_OPERATION_CODE,

                                            SCSICmdField1Byte     ALLOCATION_LENGTH,

                                            SCSICmdField1Byte     CONTROL )

{

    bool result = false;

    // Validate the parameters here.

    require ( ( request != NULL ), ErrorExit );

    require ( ResetForNewTask ( request ), ErrorExit );

    // The helper functions ensure that the parameters fit within the

    // CDB fields and that the buffer passed in is large enough for

    // the transfer length.

    require ( IsParameterValid ( CMDDT, kSCSICmdFieldMask1Bit ), ErrorExit );

    require ( IsParameterValid ( EVPD, kSCSICmdFieldMask1Bit ), ErrorExit );

    require ( IsParameterValid ( PAGE_OR_OPERATION_CODE, kSCSICmdFieldMask1Byte ), ErrorExit );

    require ( IsParameterValid ( ALLOCATION_LENGTH, kSCSICmdFieldMask1Byte ), ErrorExit );

    require ( IsParameterValid ( CONTROL, kSCSICmdFieldMask1Byte ), ErrorExit );

    require ( IsMemoryDescriptorValid ( dataBuffer, ALLOCATION_LENGTH ), ErrorExit );

    // Check the validity of the PAGE_OR_OPERATION_CODE parameter, when using both the CMDDT and EVPD parameters.

    if ( PAGE_OR_OPERATION_CODE != 0 )

    {

        if ( ( ( CMDDT == 1 ) && ( EVPD == 1 ) ) || ( ( CMDDT == 0 ) && ( EVPD == 0 ) ) )

        {

            goto ErrorExit;

        }

    }

    // This is a 6-byte command: fill out the CDB appropriately

    SetCommandDescriptorBlock ( request,

                                kSCSICmd_INQUIRY,

                                ( CMDDT << 1 ) | EVPD,

                                PAGE_OR_OPERATION_CODE,

                                0x00,

                                ALLOCATION_LENGTH,

                                CONTROL );

    SetDataTransferDirection ( request, kSCSIDataTransfer_FromTargetToInitiator );

    SetTimeoutDuration ( request, 0 );

    SetDataBuffer ( request, dataBuffer );

    SetRequestedDataTransferCount ( request, ALLOCATION_LENGTH );

    result = true;

ErrorExit:

    return result;

}