IOSCSIParallelInterfaceController.cpp [plain text]
#include "IOSCSIParallelInterfaceController.h"
#include "IOSCSIParallelInterfaceDevice.h"
#include "SCSIParallelTask.h"
#include "SCSIParallelTimer.h"
#include <libkern/OSAtomic.h>
#include <libkern/c++/OSData.h>
#include <libkern/c++/OSDictionary.h>
#include <libkern/c++/OSNumber.h>
#include <libkern/c++/OSString.h>
#include <IOKit/IOLib.h>
#include <IOKit/IOService.h>
#include <IOKit/IOKitKeys.h>
#include <IOKit/IOCommandPool.h>
#include <IOKit/storage/IOStorageProtocolCharacteristics.h>
#include <IOKit/storage/IOStorageDeviceCharacteristics.h>
#define DEBUG 0
#define DEBUG_ASSERT_COMPONENT_NAME_STRING "SPI Controller"
#if DEBUG
#define SCSI_PARALLEL_INTERFACE_CONTROLLER_DEBUGGING_LEVEL 0
#endif
#include "IOSCSIParallelFamilyDebugging.h"
#if ( SCSI_PARALLEL_INTERFACE_CONTROLLER_DEBUGGING_LEVEL >= 1 )
#define PANIC_NOW(x) IOPanic x
#else
#define PANIC_NOW(x)
#endif
#if ( SCSI_PARALLEL_INTERFACE_CONTROLLER_DEBUGGING_LEVEL >= 2 )
#define ERROR_LOG(x) kprintf x
#else
#define ERROR_LOG(x)
#endif
#if ( SCSI_PARALLEL_INTERFACE_CONTROLLER_DEBUGGING_LEVEL >= 3 )
#define STATUS_LOG(x) kprintf x
#else
#define STATUS_LOG(x)
#endif
#define super IOService
OSDefineMetaClass ( IOSCSIParallelInterfaceController, IOService );
OSDefineAbstractStructors ( IOSCSIParallelInterfaceController, IOService );
#define kIOPropertySCSIInitiatorManagesTargets "Manages Targets"
#define kIOPropertyControllerCharacteristicsKey "Controller Characteristics"
#define kIOPropertyDeviceTreeEntryKey "IODeviceTreeEntry"
enum
{
kWorldWideNameDataSize = 8,
kAddressIdentifierDataSize = 3,
kALPADataSize = 1
};
SInt32 IOSCSIParallelInterfaceController::fSCSIParallelDomainCount = 0;
static IOSCSIParallelInterfaceDevice *
GetDevice ( SCSIParallelTaskIdentifier parallelTask );
#if 0
#pragma mark -
#pragma mark IOKit Member Routines
#pragma mark -
#endif
bool
IOSCSIParallelInterfaceController::handleOpen ( IOService * client,
IOOptionBits options,
void * arg )
{
bool result = false;
STATUS_LOG ( ( "+IOSCSIParallelInterfaceController::handleOpen\n" ) );
result = fClients->setObject( client );
STATUS_LOG ( ( "-IOSCSIParallelInterfaceController::handleOpen\n" ) );
return result;
}
void
IOSCSIParallelInterfaceController::handleClose (
IOService * client,
IOOptionBits options )
{
STATUS_LOG ( ( "IOSCSIParallelInterfaceController::handleClose\n" ) );
fClients->removeObject ( client );
}
bool
IOSCSIParallelInterfaceController::handleIsOpen ( const IOService * client ) const
{
bool result = false;
STATUS_LOG ( ( "+IOSCSIParallelInterfaceController::handleIsOpen\n" ) );
if ( client != NULL )
{
result = fClients->containsObject ( client );
}
else
{
result = ( fClients->getCount ( ) > 0 ) ? true : false;
}
STATUS_LOG ( ( "-IOSCSIParallelInterfaceController::handleIsOpen\n" ) );
return result;
}
bool
IOSCSIParallelInterfaceController::start ( IOService * provider )
{
OSDictionary * dict = NULL;
OSDictionary * copyDict = NULL;
OSNumber * number = NULL;
bool result = false;
STATUS_LOG ( ( "IOSCSIParallelInterfaceController start.\n" ) );
fSCSIDomainIdentifier = OSIncrementAtomic ( &fSCSIParallelDomainCount );
result = super::start ( provider );
require ( result, PROVIDER_START_FAILURE );
require_nonzero ( provider, PROVIDER_START_FAILURE );
result = provider->open ( this );
require ( result, PROVIDER_START_FAILURE );
fProvider = provider;
fWorkLoop = NULL;
fTimerEvent = NULL;
fDispatchEvent = NULL;
fControllerGate = NULL;
fHBAHasBeenInitialized = false;
fHBACanAcceptClientRequests = false;
fClients = OSSet::withCapacity ( 1 );
fDeviceLock = IOSimpleLockAlloc ( );
require_nonzero ( fDeviceLock, DEVICE_LOCK_ALLOC_FAILURE );
result = CreateWorkLoop ( provider );
require ( result, WORKLOOP_CREATE_FAILURE );
dict = OSDictionary::withCapacity ( 1 );
require_nonzero ( dict, CONTROLLER_DICT_FAILURE );
setProperty ( kIOPropertyControllerCharacteristicsKey, dict );
dict->release ( );
dict = NULL;
copyDict = OSDynamicCast ( OSDictionary, copyProperty ( kIOPropertyProtocolCharacteristicsKey ) );
if ( copyDict == NULL )
{
dict = OSDictionary::withCapacity ( 3 );
}
else
{
dict = ( OSDictionary * ) copyDict->copyCollection ( );
copyDict->release ( );
}
if ( dict != NULL )
{
OSString * string = NULL;
OSNumber * number = NULL;
string = OSDynamicCast ( OSString, getProperty ( kIOPropertyPhysicalInterconnectTypeKey ) );
if ( string == NULL )
{
string = OSString::withCString ( kIOPropertyPhysicalInterconnectTypeSCSIParallel );
if ( string != NULL )
{
dict->setObject ( kIOPropertyPhysicalInterconnectTypeKey, string );
string->release ( );
string = NULL;
}
}
else
{
dict->setObject ( kIOPropertyPhysicalInterconnectTypeKey, string );
}
string = OSDynamicCast ( OSString, getProperty ( kIOPropertyPhysicalInterconnectLocationKey ) );
if ( string == NULL )
{
string = OSString::withCString ( kIOPropertyInternalExternalKey );
if ( string != NULL )
{
dict->setObject ( kIOPropertyPhysicalInterconnectLocationKey, string );
string->release ( );
string = NULL;
}
}
else
{
dict->setObject ( kIOPropertyPhysicalInterconnectLocationKey, string );
}
number = OSNumber::withNumber ( fSCSIDomainIdentifier, 32 );
if ( number != NULL )
{
dict->setObject ( kIOPropertySCSIDomainIdentifierKey, number );
number->release ( );
number = NULL;
}
number = OSDynamicCast ( OSNumber, getProperty ( kIOPropertyReadTimeOutDurationKey ) );
if ( number != NULL )
{
dict->setObject ( kIOPropertyReadTimeOutDurationKey, number );
}
number = OSDynamicCast ( OSNumber, getProperty ( kIOPropertyWriteTimeOutDurationKey ) );
if ( number != NULL )
{
dict->setObject ( kIOPropertyWriteTimeOutDurationKey, number );
}
setProperty ( kIOPropertyProtocolCharacteristicsKey, dict );
dict->release ( );
}
result = InitializeController ( );
require ( result, INIT_CONTROLLER_FAILURE );
fInitiatorIdentifier = ReportInitiatorIdentifier ( );
number = OSNumber::withNumber ( fInitiatorIdentifier, 64 );
if ( number != NULL )
{
setProperty ( kIOPropertySCSIInitiatorIdentifierKey, number );
number->release ( );
number = NULL;
}
fHighestSupportedDeviceID = ReportHighestSupportedDeviceID ( );
InitializeDeviceList ( );
fSupportedTaskCount = ReportMaximumTaskCount ( );
result = AllocateSCSIParallelTasks ( );
require ( result, TASK_ALLOCATE_FAILURE );
fHBAHasBeenInitialized = true;
result = StartController ( );
require ( result, START_CONTROLLER_FAILURE );
fHBACanAcceptClientRequests = true;
fWorkLoop->enableAllInterrupts ( );
result = DoesHBAPerformDeviceManagement ( );
setProperty ( kIOPropertySCSIInitiatorManagesTargets, result );
if ( result == false )
{
for ( UInt32 index = 0; index <= fHighestSupportedDeviceID; index++ )
{
CreateTargetForID ( index );
}
}
registerService ( );
result = true;
return result;
START_CONTROLLER_FAILURE:
DeallocateSCSIParallelTasks ( );
TASK_ALLOCATE_FAILURE:
fHBAHasBeenInitialized = false;
TerminateController ( );
INIT_CONTROLLER_FAILURE:
CONTROLLER_DICT_FAILURE:
ReleaseWorkLoop ( );
WORKLOOP_CREATE_FAILURE:
IOSimpleLockFree ( fDeviceLock );
fDeviceLock = NULL;
DEVICE_LOCK_ALLOC_FAILURE:
super::stop ( provider );
PROVIDER_START_FAILURE:
return false;
}
void
IOSCSIParallelInterfaceController::stop ( IOService * provider )
{
fHBACanAcceptClientRequests = false;
StopController ( );
fDispatchEvent->disable ( );
fHBAHasBeenInitialized = false;
TerminateController ( );
DeallocateSCSIParallelTasks ( );
ReleaseWorkLoop ( );
if ( fDeviceLock != NULL )
{
IOSimpleLockFree ( fDeviceLock );
fDeviceLock = NULL;
}
super::stop ( provider );
}
IOWorkLoop *
IOSCSIParallelInterfaceController::getWorkLoop ( void ) const
{
return GetWorkLoop ( );
}
IOService *
IOSCSIParallelInterfaceController::GetProvider ( void )
{
return fProvider;
}
SInt32
IOSCSIParallelInterfaceController::GetSCSIDomainIdentifier ( void )
{
return fSCSIDomainIdentifier;
}
#if 0
#pragma mark -
#pragma mark Property Management
#pragma mark -
#endif
bool
IOSCSIParallelInterfaceController::SetHBAProperty (
const char * key,
OSObject * value )
{
bool result = false;
OSDictionary * hbaDict = NULL;
OSDictionary * copyDict = NULL;
require_nonzero ( key, ErrorExit );
require_nonzero ( value, ErrorExit );
copyDict = OSDynamicCast ( OSDictionary, copyProperty ( kIOPropertyControllerCharacteristicsKey ) );
require_nonzero ( copyDict, ErrorExit );
hbaDict = ( OSDictionary * ) copyDict->copyCollection ( );
copyDict->release ( );
require_nonzero ( hbaDict, ErrorExit );
if ( strcmp ( key, kIOPropertyVendorNameKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyProductNameKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyProductRevisionLevelKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyPortDescriptionKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyPortSpeedKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertySCSIParallelSignalingTypeKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyFibreChannelCableDescriptionKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyFibreChannelPortWorldWideNameKey ) == 0 )
{
OSData * data = OSDynamicCast ( OSData, value );
require_nonzero ( data, ErrorExit );
require ( ( data->getLength ( ) == kWorldWideNameDataSize ), ErrorExit );
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyFibreChannelNodeWorldWideNameKey ) == 0 )
{
OSData * data = OSDynamicCast ( OSData, value );
require_nonzero ( data, ErrorExit );
require ( ( data->getLength ( ) == kWorldWideNameDataSize ), ErrorExit );
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyFibreChannelAddressIdentifierKey ) == 0 )
{
OSData * data = OSDynamicCast ( OSData, value );
require_nonzero ( data, ErrorExit );
require ( ( data->getLength ( ) == kAddressIdentifierDataSize ), ErrorExit );
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyFibreChannelALPAKey ) == 0 )
{
OSData * data = OSDynamicCast ( OSData, value );
require_nonzero ( data, ErrorExit );
require ( ( data->getLength ( ) == kALPADataSize ), ErrorExit );
result = hbaDict->setObject ( key, value );
}
else if ( strcmp ( key, kIOPropertyPortTopologyKey ) == 0 )
{
result = hbaDict->setObject ( key, value );
}
else
{
ERROR_LOG ( ( "SetHBAProperty: Unrecognized property key = %s", key ) );
}
setProperty ( kIOPropertyControllerCharacteristicsKey, hbaDict );
hbaDict->release ( );
hbaDict = NULL;
ErrorExit:
return result;
}
void
IOSCSIParallelInterfaceController::RemoveHBAProperty ( const char * key )
{
OSDictionary * hbaDict = NULL;
OSDictionary * copyDict = NULL;
require_nonzero ( key, ErrorExit );
copyDict = OSDynamicCast ( OSDictionary, copyProperty ( kIOPropertyControllerCharacteristicsKey ) );
require_nonzero ( copyDict, ErrorExit );
hbaDict = ( OSDictionary * ) copyDict->copyCollection ( );
copyDict->release ( );
require_nonzero ( hbaDict, ErrorExit );
if ( hbaDict->getObject ( key ) != NULL )
{
hbaDict->removeObject ( key );
}
setProperty ( kIOPropertyControllerCharacteristicsKey, hbaDict );
hbaDict->release ( );
hbaDict = NULL;
ErrorExit:
return;
}
#if 0
#pragma mark -
#pragma mark WorkLoop Management
#pragma mark -
#endif
IOWorkLoop *
IOSCSIParallelInterfaceController::GetWorkLoop ( void ) const
{
return fWorkLoop;
}
IOCommandGate *
IOSCSIParallelInterfaceController::GetCommandGate ( void )
{
return fControllerGate;
}
bool
IOSCSIParallelInterfaceController::CreateWorkLoop ( IOService * provider )
{
bool result = false;
IOReturn status = kIOReturnSuccess;
if ( fWorkLoop == NULL )
{
fWorkLoop = IOWorkLoop::workLoop ( );
require_nonzero ( fWorkLoop, CREATE_WORKLOOP_FAILURE );
}
fTimerEvent = SCSIParallelTimer::CreateTimerEventSource ( this,
( IOTimerEventSource::Action ) &IOSCSIParallelInterfaceController::TimeoutOccurred );
require_nonzero ( fTimerEvent, TIMER_CREATION_FAILURE );
status = fWorkLoop->addEventSource ( fTimerEvent );
require_success ( status, ADD_TES_FAILURE );
fDispatchEvent = IOFilterInterruptEventSource::filterInterruptEventSource (
this,
&IOSCSIParallelInterfaceController::ServiceInterrupt,
&IOSCSIParallelInterfaceController::FilterInterrupt,
provider,
0 );
require_nonzero ( fDispatchEvent, CREATE_ISR_EVENT_FAILURE );
status = fWorkLoop->addEventSource ( fDispatchEvent );
require_success ( status, ADD_ISR_EVENT_FAILURE );
fControllerGate = IOCommandGate::commandGate ( this, NULL );
require_nonzero ( fControllerGate, ALLOCATE_COMMAND_GATE_FAILURE );
status = fWorkLoop->addEventSource ( fControllerGate );
require_success ( status, ADD_GATE_EVENT_FAILURE );
result = true;
return result;
ADD_GATE_EVENT_FAILURE:
require_nonzero_quiet ( fControllerGate, ALLOCATE_COMMAND_GATE_FAILURE );
fControllerGate->release ( );
fControllerGate = NULL;
ALLOCATE_COMMAND_GATE_FAILURE:
fWorkLoop->removeEventSource ( fDispatchEvent );
ADD_ISR_EVENT_FAILURE:
require_nonzero_quiet ( fDispatchEvent, CREATE_ISR_EVENT_FAILURE );
fDispatchEvent->release ( );
fDispatchEvent = NULL;
CREATE_ISR_EVENT_FAILURE:
fWorkLoop->removeEventSource ( fTimerEvent );
ADD_TES_FAILURE:
require_nonzero_quiet ( fTimerEvent, TIMER_CREATION_FAILURE );
fTimerEvent->release ( );
fTimerEvent = NULL;
TIMER_CREATION_FAILURE:
require_nonzero_quiet ( fWorkLoop, CREATE_WORKLOOP_FAILURE );
fWorkLoop->release ( );
fWorkLoop = NULL;
CREATE_WORKLOOP_FAILURE:
return result;
}
void
IOSCSIParallelInterfaceController::ReleaseWorkLoop ( void )
{
if ( fControllerGate != NULL )
{
fWorkLoop->removeEventSource ( fControllerGate );
fControllerGate->release ( );
fControllerGate = NULL;
}
if ( fTimerEvent != NULL )
{
fTimerEvent->release ( );
fTimerEvent = NULL;
}
if ( fDispatchEvent != NULL )
{
fWorkLoop->removeEventSource ( fDispatchEvent );
fDispatchEvent->release ( );
fDispatchEvent = NULL;
}
if ( fWorkLoop != NULL )
{
fWorkLoop->release ( );
fWorkLoop = NULL;
}
}
#if 0
#pragma mark -
#pragma mark SCSI Parallel Task Management
#pragma mark -
#endif
SCSIParallelTaskIdentifier
IOSCSIParallelInterfaceController::GetSCSIParallelTask ( bool blockForCommand )
{
SCSIParallelTask * parallelTask = NULL;
parallelTask = ( SCSIParallelTask * ) fParallelTaskPool->getCommand ( blockForCommand );
if ( parallelTask != NULL )
{
parallelTask->ResetForNewTask ( );
}
return ( SCSIParallelTaskIdentifier ) parallelTask;
}
void
IOSCSIParallelInterfaceController::FreeSCSIParallelTask (
SCSIParallelTaskIdentifier returnTask )
{
fParallelTaskPool->returnCommand ( ( IOCommand * ) returnTask );
}
bool
IOSCSIParallelInterfaceController::AllocateSCSIParallelTasks ( void )
{
bool result = false;
SCSIParallelTask * parallelTask = NULL;
UInt32 taskSize = 0;
UInt64 mask = 0;
OSNumber * value = NULL;
OSDictionary * constraints = NULL;
taskSize = ReportHBASpecificTaskDataSize ( );
constraints = OSDictionary::withCapacity ( 7 );
require_nonzero ( constraints, ERROR_EXIT );
ReportHBAConstraints ( constraints );
value = OSDynamicCast ( OSNumber, constraints->getObject ( kIOMaximumSegmentCountReadKey ) );
if ( value != NULL )
{
setProperty ( kIOMaximumSegmentCountReadKey, value );
}
value = OSDynamicCast ( OSNumber, constraints->getObject ( kIOMaximumSegmentCountWriteKey ) );
if ( value != NULL )
{
setProperty ( kIOMaximumSegmentCountWriteKey, value );
}
value = OSDynamicCast ( OSNumber, constraints->getObject ( kIOMaximumSegmentByteCountReadKey ) );
if ( value != NULL )
{
setProperty ( kIOMaximumSegmentByteCountReadKey, value );
}
value = OSDynamicCast ( OSNumber, constraints->getObject ( kIOMaximumSegmentByteCountWriteKey ) );
if ( value != NULL )
{
setProperty ( kIOMaximumSegmentByteCountWriteKey, value );
}
value = OSDynamicCast ( OSNumber, constraints->getObject ( kIOMinimumSegmentAlignmentByteCountKey ) );
if ( value != NULL )
{
setProperty ( kIOMinimumSegmentAlignmentByteCountKey, value );
}
value = OSDynamicCast ( OSNumber, constraints->getObject ( kIOMaximumSegmentAddressableBitCountKey ) );
if ( value != NULL )
{
setProperty ( kIOMaximumSegmentAddressableBitCountKey, value );
}
value = OSDynamicCast ( OSNumber, constraints->getObject ( kIOMinimumHBADataAlignmentMaskKey ) );
mask = value->unsigned64BitValue ( );
constraints->release ( );
constraints = NULL;
fParallelTaskPool = IOCommandPool::withWorkLoop ( fWorkLoop );
require_nonzero ( fParallelTaskPool, POOL_CREATION_FAILURE );
parallelTask = SCSIParallelTask::Create ( taskSize, mask );
require_nonzero ( parallelTask, TASK_CREATION_FAILURE );
result = InitializeDMASpecification ( parallelTask );
require ( result, TASK_INIT_FAILURE );
fParallelTaskPool->returnCommand ( parallelTask );
for ( UInt32 index = 1; index < fSupportedTaskCount; index++ )
{
parallelTask = SCSIParallelTask::Create ( taskSize, mask );
if ( parallelTask != NULL )
{
result = InitializeDMASpecification ( parallelTask );
if ( result == false )
{
parallelTask->release ( );
break;
}
fParallelTaskPool->returnCommand ( parallelTask );
}
}
result = true;
return result;
TASK_INIT_FAILURE:
require_nonzero ( parallelTask, TASK_CREATION_FAILURE );
parallelTask->release ( );
parallelTask = NULL;
TASK_CREATION_FAILURE:
require_nonzero ( fParallelTaskPool, POOL_CREATION_FAILURE );
fParallelTaskPool->release ( );
fParallelTaskPool = NULL;
POOL_CREATION_FAILURE:
ERROR_EXIT:
return result;
}
void
IOSCSIParallelInterfaceController::DeallocateSCSIParallelTasks ( void )
{
SCSIParallelTask * parallelTask = NULL;
require_nonzero ( fParallelTaskPool, Exit );
parallelTask = ( SCSIParallelTask * ) fParallelTaskPool->getCommand ( false );
while ( parallelTask != NULL )
{
parallelTask->release ( );
parallelTask = ( SCSIParallelTask * ) fParallelTaskPool->getCommand ( false );
}
fParallelTaskPool->release ( );
fParallelTaskPool = NULL;
Exit:
return;
}
#if 0
#pragma mark -
#pragma mark SCSI Parallel Task Execution
#pragma mark -
#endif
SCSIServiceResponse
IOSCSIParallelInterfaceController::ExecuteParallelTask (
SCSIParallelTaskIdentifier parallelRequest )
{
SCSIServiceResponse serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;
if ( fHBACanAcceptClientRequests == false )
{
}
serviceResponse = ProcessParallelTask ( parallelRequest );
return serviceResponse;
}
void
IOSCSIParallelInterfaceController::CompleteParallelTask (
SCSIParallelTaskIdentifier parallelRequest,
SCSITaskStatus completionStatus,
SCSIServiceResponse serviceResponse )
{
IOSCSIParallelInterfaceDevice * target = NULL;
STATUS_LOG ( ( "+IOSCSIParallelInterfaceController::CompleteParallelTask\n" ) );
( ( SCSIParallelTimer * ) fTimerEvent )->RemoveTask ( parallelRequest );
target = GetDevice ( parallelRequest );
require_nonzero ( target, Exit );
target->CompleteSCSITask ( parallelRequest,
serviceResponse,
completionStatus );
Exit:
STATUS_LOG ( ( "-IOSCSIParallelInterfaceController::CompleteParallelTask\n" ) );
return;
}
SCSIParallelTaskIdentifier
IOSCSIParallelInterfaceController::FindTaskForAddress (
SCSIDeviceIdentifier theT,
SCSILogicalUnitNumber theL,
SCSITaggedTaskIdentifier theQ )
{
SCSIParallelTaskIdentifier task = NULL;
IOSCSIParallelInterfaceDevice * target = NULL;
target = GetTargetForID ( theT );
require_nonzero ( target, Exit );
task = target->FindTaskForAddress ( theL, theQ );
Exit:
return task;
}
SCSIParallelTaskIdentifier
IOSCSIParallelInterfaceController::FindTaskForControllerIdentifier (
SCSIDeviceIdentifier theTarget,
UInt64 theIdentifier )
{
SCSIParallelTaskIdentifier task = NULL;
IOSCSIParallelInterfaceDevice * target = NULL;
target = GetTargetForID ( theTarget );
require_nonzero ( target, Exit );
task = target->FindTaskForControllerIdentifier ( theIdentifier );
Exit:
return task;
}
void
IOSCSIParallelInterfaceController::CompleteAbortTask (
SCSITargetIdentifier theT,
SCSILogicalUnitNumber theL,
SCSITaggedTaskIdentifier theQ,
SCSIServiceResponse serviceResponse )
{
}
void
IOSCSIParallelInterfaceController::CompleteAbortTaskSet (
SCSITargetIdentifier theT,
SCSILogicalUnitNumber theL,
SCSIServiceResponse serviceResponse )
{
}
void
IOSCSIParallelInterfaceController::CompleteClearACA (
SCSITargetIdentifier theT,
SCSILogicalUnitNumber theL,
SCSIServiceResponse serviceResponse )
{
}
void
IOSCSIParallelInterfaceController::CompleteClearTaskSet (
SCSITargetIdentifier theT,
SCSILogicalUnitNumber theL,
SCSIServiceResponse serviceResponse )
{
}
void
IOSCSIParallelInterfaceController::CompleteLogicalUnitReset (
SCSITargetIdentifier theT,
SCSILogicalUnitNumber theL,
SCSIServiceResponse serviceResponse )
{
}
void
IOSCSIParallelInterfaceController::CompleteTargetReset (
SCSITargetIdentifier theT,
SCSIServiceResponse serviceResponse )
{
}
void
IOSCSIParallelInterfaceController::ServiceInterrupt (
OSObject * theObject,
IOInterruptEventSource * theSource,
int count )
{
( ( IOSCSIParallelInterfaceController * ) theObject )->HandleInterruptRequest ( );
}
bool
IOSCSIParallelInterfaceController::FilterInterrupt (
OSObject * theObject,
IOFilterInterruptEventSource * theSource )
{
return ( ( IOSCSIParallelInterfaceController * ) theObject )->FilterInterruptRequest ( );
}
bool
IOSCSIParallelInterfaceController::FilterInterruptRequest ( void )
{
return true;
}
void
IOSCSIParallelInterfaceController::EnableInterrupt ( void )
{
fDispatchEvent->enable ( );
}
void
IOSCSIParallelInterfaceController::DisableInterrupt ( void )
{
fDispatchEvent->disable ( );
}
void
IOSCSIParallelInterfaceController::SignalInterrupt ( void )
{
( ( IOFilterInterruptEventSource * ) fDispatchEvent )->signalInterrupt ( );
}
#if 0
#pragma mark -
#pragma mark Timeout Management
#pragma mark -
#endif
void
IOSCSIParallelInterfaceController::SetTimeoutForTask (
SCSIParallelTaskIdentifier parallelTask,
UInt32 timeoutOverride )
{
( ( SCSIParallelTimer * ) fTimerEvent )->SetTimeout ( parallelTask,
timeoutOverride );
}
void
IOSCSIParallelInterfaceController::TimeoutOccurred (
OSObject * theObject,
IOTimerEventSource * theSender )
{
SCSIParallelTimer * timer = NULL;
SCSIParallelTaskIdentifier expiredTask = NULL;
timer = OSDynamicCast ( SCSIParallelTimer, theSender );
if ( timer != NULL )
{
timer->BeginTimeoutContext ( );
expiredTask = timer->GetExpiredTask ( );
while ( expiredTask != NULL )
{
( ( IOSCSIParallelInterfaceController * ) theObject )->HandleTimeout ( expiredTask );
expiredTask = timer->GetExpiredTask ( );
}
timer->EndTimeoutContext ( );
timer->Rearm ( );
}
}
void
IOSCSIParallelInterfaceController::HandleTimeout (
SCSIParallelTaskIdentifier parallelRequest )
{
check ( parallelRequest != NULL );
CompleteParallelTask ( parallelRequest,
kSCSITaskStatus_TaskTimeoutOccurred,
kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE );
}
#if 0
#pragma mark -
#pragma mark SCSI Parallel Device Management
#pragma mark -
#endif
bool
IOSCSIParallelInterfaceController::CreateTargetForID (
SCSITargetIdentifier targetID )
{
OSDictionary * dict = NULL;
bool result = false;
dict = OSDictionary::withCapacity ( 0 );
require_nonzero ( dict, DICT_CREATION_FAILED );
result = CreateTargetForID ( targetID, dict );
DICT_CREATION_FAILED:
return result;
}
bool
IOSCSIParallelInterfaceController::CreateTargetForID (
SCSITargetIdentifier targetID,
OSDictionary * properties )
{
IOSCSIParallelInterfaceDevice * newDevice = NULL;
IORegistryEntry * entry = NULL;
bool result = false;
require ( ( targetID != fInitiatorIdentifier ), INVALID_PARAMETER_EXIT );
require ( ( GetTargetForID ( targetID ) == NULL ), INVALID_PARAMETER_EXIT );
entry = OSDynamicCast ( IORegistryEntry, properties->getObject ( kIOPropertyDeviceTreeEntryKey ) );
newDevice = IOSCSIParallelInterfaceDevice::CreateTarget (
targetID,
ReportHBASpecificDeviceDataSize ( ),
entry );
require_nonzero ( newDevice, DEVICE_CREATION_FAILED_EXIT );
AddDeviceToTargetList ( newDevice );
result = newDevice->attach ( this );
require ( result, ATTACH_FAILED_EXIT );
result = newDevice->SetInitialTargetProperties ( properties );
require ( result, START_FAILED_EXIT );
result = newDevice->start ( this );
require ( result, START_FAILED_EXIT );
newDevice->release ( );
result = true;
return result;
START_FAILED_EXIT:
newDevice->detach ( this );
ATTACH_FAILED_EXIT:
RemoveDeviceFromTargetList ( newDevice );
newDevice->DestroyTarget ( );
DEVICE_CREATION_FAILED_EXIT:
INVALID_PARAMETER_EXIT:
return result;
}
void
IOSCSIParallelInterfaceController::DestroyTargetForID (
SCSITargetIdentifier targetID )
{
IOSCSIParallelInterfaceDevice * victimDevice = NULL;
victimDevice = GetTargetForID ( targetID );
if ( victimDevice == NULL )
{
return;
}
RemoveDeviceFromTargetList ( victimDevice );
victimDevice->DestroyTarget ( );
victimDevice->terminate ( );
}
bool
IOSCSIParallelInterfaceController::SetTargetProperty (
SCSIDeviceIdentifier targetID,
const char * key,
OSObject * value )
{
bool result = false;
IOSCSIParallelInterfaceDevice * device = NULL;
device = GetTargetForID ( targetID );
require_nonzero ( device, ErrorExit );
result = device->SetTargetProperty ( key, value );
ErrorExit:
return result;
}
void
IOSCSIParallelInterfaceController::RemoveTargetProperty (
SCSIDeviceIdentifier targetID,
const char * key )
{
IOSCSIParallelInterfaceDevice * device = NULL;
device = GetTargetForID ( targetID );
require_nonzero ( device, ErrorExit );
device->RemoveTargetProperty ( key );
ErrorExit:
return;
}
#if 0
#pragma mark -
#pragma mark Device List Management
#pragma mark -
#endif
void
IOSCSIParallelInterfaceController::InitializeDeviceList ( void )
{
for ( UInt32 i = 0; i < kSCSIParallelDeviceListArrayCount; i++ )
{
fParallelDeviceList[i] = NULL;
}
}
IOSCSIParallelInterfaceDevice *
IOSCSIParallelInterfaceController::GetTargetForID ( SCSITargetIdentifier targetID )
{
IOSCSIParallelInterfaceDevice * device = NULL;
IOInterruptState lockState = 0;
UInt8 indexID = 0;
require ( ( targetID >= 0 ), INVALID_PARAMETER_FAILURE );
require ( ( targetID <= fHighestSupportedDeviceID ), INVALID_PARAMETER_FAILURE );
require ( ( targetID != fInitiatorIdentifier ), INVALID_PARAMETER_FAILURE );
lockState = IOSimpleLockLockDisableInterrupt ( fDeviceLock );
indexID = targetID & kSCSIParallelDeviceListIndexMask;
device = fParallelDeviceList[indexID];
while ( device != NULL )
{
if ( device->GetTargetIdentifier ( ) == targetID )
{
break;
}
device = device->GetNextDeviceInList ( );
}
IOSimpleLockUnlockEnableInterrupt ( fDeviceLock, lockState );
INVALID_PARAMETER_FAILURE:
return device;
}
void
IOSCSIParallelInterfaceController::AddDeviceToTargetList (
IOSCSIParallelInterfaceDevice * newDevice )
{
UInt8 indexID = 0;
IOInterruptState lockState = 0;
STATUS_LOG ( ( "+IOSCSIParallelInterfaceController::AddDeviceToTargetList\n" ) );
lockState = IOSimpleLockLockDisableInterrupt ( fDeviceLock );
indexID = newDevice->GetTargetIdentifier ( ) & kSCSIParallelDeviceListIndexMask;
if ( fParallelDeviceList[indexID] == NULL )
{
fParallelDeviceList[indexID] = newDevice;
newDevice->SetNextDeviceInList ( NULL );
newDevice->SetPreviousDeviceInList ( NULL );
}
else
{
IOSCSIParallelInterfaceDevice * currentDevice;
currentDevice = fParallelDeviceList[indexID];
while ( currentDevice->GetNextDeviceInList ( ) != NULL )
{
currentDevice = currentDevice->GetNextDeviceInList ( );
}
currentDevice->SetNextDeviceInList ( newDevice );
newDevice->SetNextDeviceInList ( NULL );
newDevice->SetPreviousDeviceInList ( currentDevice );
}
IOSimpleLockUnlockEnableInterrupt ( fDeviceLock, lockState );
STATUS_LOG ( ( "-IOSCSIParallelInterfaceController::AddDeviceToTargetList\n" ) );
}
void
IOSCSIParallelInterfaceController::RemoveDeviceFromTargetList (
IOSCSIParallelInterfaceDevice * victimDevice )
{
IOSCSIParallelInterfaceDevice * nextDevice = NULL;
IOSCSIParallelInterfaceDevice * prevDevice = NULL;
IOInterruptState lockState = 0;
lockState = IOSimpleLockLockDisableInterrupt ( fDeviceLock );
nextDevice = victimDevice->GetNextDeviceInList ( );
prevDevice = victimDevice->GetPreviousDeviceInList ( );
if ( prevDevice != NULL )
{
prevDevice->SetNextDeviceInList ( nextDevice );
}
else
{
UInt8 indexID = 0;
indexID = victimDevice->GetTargetIdentifier ( ) & kSCSIParallelDeviceListIndexMask;
fParallelDeviceList[indexID] = nextDevice;
}
if ( nextDevice != NULL )
{
nextDevice->SetPreviousDeviceInList ( prevDevice );
}
victimDevice->SetNextDeviceInList ( NULL );
victimDevice->SetPreviousDeviceInList ( NULL );
IOSimpleLockUnlockEnableInterrupt ( fDeviceLock, lockState );
}
#if 0
#pragma mark -
#pragma mark Controller Child Class
#pragma mark -
#endif
bool
IOSCSIParallelInterfaceController::DoesHBAPerformAutoSense ( void )
{
return false;
}
void
IOSCSIParallelInterfaceController::ReportHBAConstraints (
OSDictionary * constraints )
{
UInt64 value = 0;
OSNumber * number = NULL;
value = 0x00000000FFFFFFF0ULL;
number = OSNumber::withNumber ( value, 64 );
if ( number != NULL )
{
constraints->setObject ( kIOMinimumHBADataAlignmentMaskKey, number );
number->release ( );
}
value = 32;
number = OSNumber::withNumber ( value, 64 );
if ( number != NULL )
{
constraints->setObject ( kIOMaximumSegmentAddressableBitCountKey, number );
number->release ( );
}
value = 4;
number = OSNumber::withNumber ( value, 64 );
if ( number != NULL )
{
constraints->setObject ( kIOMinimumSegmentAlignmentByteCountKey, number );
number->release ( );
}
}
bool
IOSCSIParallelInterfaceController::InitializeDMASpecification (
IODMACommand * command )
{
bool result = false;
result = command->initWithSpecification (
kIODMACommandOutputHost32,
32, 4096, IODMACommand::kMapped,
1048576, 4 );
return result;
}
void
IOSCSIParallelInterfaceController::SuspendServices ( void )
{
fHBACanAcceptClientRequests = false;
}
void
IOSCSIParallelInterfaceController::ResumeServices ( void )
{
fHBACanAcceptClientRequests = true;
}
void
IOSCSIParallelInterfaceController::NotifyClientsOfBusReset ( void )
{
messageClients ( kSCSIControllerNotificationBusReset );
}
void
IOSCSIParallelInterfaceController::NotifyClientsOfPortStatusChange (
SCSIPortStatus newStatus )
{
OSDictionary * hbaDict = NULL;
OSDictionary * copyDict = NULL;
OSString * string = NULL;
char * linkStatus = NULL;
copyDict = OSDynamicCast ( OSDictionary, copyProperty ( kIOPropertyControllerCharacteristicsKey ) );
require_nonzero ( copyDict, ErrorExit );
hbaDict = ( OSDictionary * ) copyDict->copyCollection ( );
copyDict->release ( );
require_nonzero ( hbaDict, ErrorExit );
switch ( newStatus )
{
case kSCSIPort_StatusOnline:
linkStatus = kIOPropertyPortStatusLinkEstablishedKey;
break;
case kSCSIPort_StatusOffline:
linkStatus = kIOPropertyPortStatusNoLinkEstablishedKey;
break;
case kSCSIPort_StatusFailure:
linkStatus = kIOPropertyPortStatusLinkFailedKey;
break;
default:
break;
}
string = OSString::withCString ( linkStatus );
if ( string != NULL )
{
hbaDict->setObject ( kIOPropertyPortStatusKey, string );
string->release ( );
string = NULL;
}
setProperty ( kIOPropertyControllerCharacteristicsKey, hbaDict );
hbaDict->release ( );
hbaDict = NULL;
ErrorExit:
messageClients ( kSCSIPort_NotificationStatusChange, ( void * ) newStatus );
}
#if 0
#pragma mark -
#pragma mark SCSI Parallel Task Object Accessors
#pragma mark -
#endif
SCSITaskIdentifier
IOSCSIParallelInterfaceController::GetSCSITaskIdentifier (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return NULL;
}
return tempTask->GetSCSITaskIdentifier ( );
}
SCSITargetIdentifier
IOSCSIParallelInterfaceController::GetTargetIdentifier (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return NULL;
}
return tempTask->GetTargetIdentifier ( );
}
static IOSCSIParallelInterfaceDevice *
GetDevice ( SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return NULL;
}
return tempTask->GetDevice ( );
}
SCSILogicalUnitNumber
IOSCSIParallelInterfaceController::GetLogicalUnitNumber (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetLogicalUnitNumber ( );
}
SCSITaggedTaskIdentifier
IOSCSIParallelInterfaceController::GetTaggedTaskIdentifier (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return kSCSIUntaggedTaskIdentifier;
}
return tempTask->GetTaggedTaskIdentifier ( );
}
SCSITaskAttribute
IOSCSIParallelInterfaceController::GetTaskAttribute (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return kSCSITask_SIMPLE;
}
return tempTask->GetTaskAttribute ( );
}
UInt8
IOSCSIParallelInterfaceController::GetCommandDescriptorBlockSize (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetCommandDescriptorBlockSize ( );
}
bool
IOSCSIParallelInterfaceController::GetCommandDescriptorBlock (
SCSIParallelTaskIdentifier parallelTask,
SCSICommandDescriptorBlock * cdbData )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return false;
}
return tempTask->GetCommandDescriptorBlock ( cdbData );
}
UInt8
IOSCSIParallelInterfaceController::GetDataTransferDirection (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return kSCSIDataTransfer_NoDataTransfer;
}
return tempTask->GetDataTransferDirection ( );
}
UInt64
IOSCSIParallelInterfaceController::GetRequestedDataTransferCount (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetRequestedDataTransferCount ( );
}
UInt64
IOSCSIParallelInterfaceController::GetRealizedDataTransferCount (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetRealizedDataTransferCount ( );
}
bool
IOSCSIParallelInterfaceController::SetRealizedDataTransferCount (
SCSIParallelTaskIdentifier parallelTask,
UInt64 realizedTransferCountInBytes )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return false;
}
return tempTask->SetRealizedDataTransferCount ( realizedTransferCountInBytes );
}
void
IOSCSIParallelInterfaceController::IncrementRealizedDataTransferCount (
SCSIParallelTaskIdentifier parallelTask,
UInt64 realizedTransferCountInBytes )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return;
}
return tempTask->IncrementRealizedDataTransferCount ( realizedTransferCountInBytes );
}
IOMemoryDescriptor *
IOSCSIParallelInterfaceController::GetDataBuffer (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return NULL;
}
return tempTask->GetDataBuffer ( );
}
UInt64
IOSCSIParallelInterfaceController::GetDataBufferOffset (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetDataBufferOffset ( );
}
IODMACommand *
IOSCSIParallelInterfaceController::GetDMACommand (
SCSIParallelTaskIdentifier parallelTask )
{
return ( IODMACommand * ) parallelTask;
}
UInt32
IOSCSIParallelInterfaceController::GetTimeoutDuration (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetTimeoutDuration ( );
}
bool
IOSCSIParallelInterfaceController::SetAutoSenseData (
SCSIParallelTaskIdentifier parallelTask,
SCSI_Sense_Data * newSenseData,
UInt8 senseDataSize )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return false;
}
return tempTask->SetAutoSenseData ( newSenseData, senseDataSize );
}
bool
IOSCSIParallelInterfaceController::GetAutoSenseData (
SCSIParallelTaskIdentifier parallelTask,
SCSI_Sense_Data * receivingBuffer,
UInt8 senseDataSize )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return false;
}
return tempTask->GetAutoSenseData ( receivingBuffer, senseDataSize );
}
UInt8
IOSCSIParallelInterfaceController::GetAutoSenseDataSize (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetAutoSenseDataSize ( );
}
SCSIParallelFeatureRequest
IOSCSIParallelInterfaceController::GetSCSIParallelFeatureNegotiation (
SCSIParallelTaskIdentifier parallelTask,
SCSIParallelFeature requestedFeature )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return kSCSIParallelFeature_NoNegotiation;
}
return tempTask->GetSCSIParallelFeatureNegotiation ( requestedFeature );
}
UInt64
IOSCSIParallelInterfaceController::GetSCSIParallelFeatureNegotiationCount (
SCSIParallelTaskIdentifier parallelTask)
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetSCSIParallelFeatureNegotiationCount ( );
}
void
IOSCSIParallelInterfaceController::SetSCSIParallelFeatureNegotiationResult (
SCSIParallelTaskIdentifier parallelTask,
SCSIParallelFeature requestedFeature,
SCSIParallelFeatureResult newResult )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return;
}
return tempTask->SetSCSIParallelFeatureNegotiationResult ( requestedFeature, newResult );
}
SCSIParallelFeatureResult
IOSCSIParallelInterfaceController::GetSCSIParallelFeatureNegotiationResult (
SCSIParallelTaskIdentifier parallelTask,
SCSIParallelFeature requestedFeature )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return kSCSIParallelFeature_NegotitiationUnchanged;
}
return tempTask->GetSCSIParallelFeatureNegotiationResult ( requestedFeature );
}
UInt64
IOSCSIParallelInterfaceController::GetSCSIParallelFeatureNegotiationResultCount (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetSCSIParallelFeatureNegotiationResultCount ( );
}
void
IOSCSIParallelInterfaceController::SetControllerTaskIdentifier (
SCSIParallelTaskIdentifier parallelTask,
UInt64 newIdentifier )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return;
}
return tempTask->SetControllerTaskIdentifier ( newIdentifier );
}
UInt64
IOSCSIParallelInterfaceController::GetControllerTaskIdentifier (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetControllerTaskIdentifier ( );
}
UInt32
IOSCSIParallelInterfaceController::GetHBADataSize (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return 0;
}
return tempTask->GetHBADataSize ( );
}
void *
IOSCSIParallelInterfaceController::GetHBADataPointer (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return NULL;
}
return tempTask->GetHBADataPointer ( );
}
IOMemoryDescriptor *
IOSCSIParallelInterfaceController::GetHBADataDescriptor (
SCSIParallelTaskIdentifier parallelTask )
{
SCSIParallelTask * tempTask = ( SCSIParallelTask * ) parallelTask;
if ( tempTask == NULL )
{
return NULL;
}
return tempTask->GetHBADataDescriptor ( );
}
#if 0
#pragma mark -
#pragma mark SCSI Parallel Device Object Accessors
#pragma mark -
#endif
UInt32
IOSCSIParallelInterfaceController::GetHBATargetDataSize (
SCSITargetIdentifier targetID )
{
IOSCSIParallelInterfaceDevice * targetDevice;
targetDevice = GetTargetForID ( targetID );
if ( targetDevice == NULL )
{
return 0;
}
return targetDevice->GetHBADataSize ( );
}
void *
IOSCSIParallelInterfaceController::GetHBATargetDataPointer (
SCSITargetIdentifier targetID )
{
IOSCSIParallelInterfaceDevice * targetDevice;
targetDevice = GetTargetForID ( targetID );
if ( targetDevice == NULL )
{
return NULL;
}
return targetDevice->GetHBADataPointer ( );
}
#if 0
#pragma mark -
#pragma mark VTable Padding
#pragma mark -
#endif
OSMetaClassDefineReservedUsed ( IOSCSIParallelInterfaceController, 1 ); OSMetaClassDefineReservedUsed ( IOSCSIParallelInterfaceController, 2 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 3 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 4 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 5 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 6 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 7 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 8 );
OSMetaClassDefineReservedUsed ( IOSCSIParallelInterfaceController, 9 ); OSMetaClassDefineReservedUsed ( IOSCSIParallelInterfaceController, 10 ); OSMetaClassDefineReservedUsed ( IOSCSIParallelInterfaceController, 11 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 12 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 13 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 14 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 15 );
OSMetaClassDefineReservedUnused ( IOSCSIParallelInterfaceController, 16 );