IOUSBControllerV3.cpp [plain text]
#include <libkern/OSDebug.h>
#include <IOKit/pwr_mgt/RootDomain.h>
#include <IOKit/IOHibernatePrivate.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/usb/IOUSBControllerV3.h>
#include <IOKit/usb/IOUSBRootHubDevice.h>
#include <IOKit/usb/IOUSBHubPolicyMaker.h>
#include <IOKit/usb/IOUSBLog.h>
#include "USBTracepoints.h"
uint32_t * IOUSBControllerV3::_gHibernateState;
#define super IOUSBControllerV2
#define _controllerCanSleep _expansionData->_controllerCanSleep
#define _rootHubPollingRate32 _v3ExpansionData->_rootHubPollingRate32
#define _rootHubTransactionWasAborted _v3ExpansionData->_rootHubTransactionWasAborted
#ifndef CONTROLLERV3_USE_KPRINTF
#define CONTROLLERV3_USE_KPRINTF 0
#endif
#if CONTROLLERV3_USE_KPRINTF
#undef USBLog
#undef USBError
void kprintf(const char *format, ...)
__attribute__((format(printf, 1, 2)));
#define USBLog( LEVEL, FORMAT, ARGS... ) if ((LEVEL) <= CONTROLLERV3_USE_KPRINTF) { kprintf( FORMAT "\n", ## ARGS ) ; }
#define USBError( LEVEL, FORMAT, ARGS... ) { kprintf( FORMAT "\n", ## ARGS ) ; }
#endif
OSDefineMetaClass( IOUSBControllerV3, IOUSBControllerV2 )
OSDefineAbstractStructors(IOUSBControllerV3, IOUSBControllerV2)
#pragma mark ееее IOKit methods ееее
bool
IOUSBControllerV3::init(OSDictionary * propTable)
{
if (!super::init(propTable)) return false;
if (!_v3ExpansionData)
{
_v3ExpansionData = (V3ExpansionData *)IOMalloc(sizeof(V3ExpansionData));
if (!_v3ExpansionData)
return false;
bzero(_v3ExpansionData, sizeof(V3ExpansionData));
}
_powerStateChangingTo = kUSBPowerStateStable;
return true;
}
bool
IOUSBControllerV3::start( IOService * provider )
{
IOReturn err;
_device = OSDynamicCast(IOPCIDevice, provider);
if (_device == NULL)
{
return false;
}
if (_controllerSpeed == kUSBDeviceSpeedFull)
{
err = CheckForEHCIController(provider);
if (err)
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::start - CheckForEHCIController returned (%p)", getName(), this, (void*)err);
USBTrace( kUSBTController, kTPControllerV3Start, (uintptr_t)this, err, 0, 1 );
return false;
}
}
if ( !super::start(provider))
{
if (_ehciController)
{
_ehciController->release();
_ehciController = NULL;
}
return false;
}
if (_expansionData && _watchdogUSBTimer && _watchdogTimerActive)
{
_watchdogUSBTimer->cancelTimeout(); _watchdogTimerActive = false;
}
_rootHubTimer = IOTimerEventSource::timerEventSource(this, (IOTimerEventSource::Action) RootHubTimerFired);
if ( _rootHubTimer == NULL )
{
USBLog(1, "IOUSBControllerV3[%p]::UIMInitialize - couldn't allocate timer event source", this);
USBTrace( kUSBTController, kTPControllerV3Start, (uintptr_t)this, kIOReturnNoMemory, 0, 2 );
return kIOReturnNoMemory;
}
if ( _workLoop->addEventSource( _rootHubTimer ) != kIOReturnSuccess )
{
USBLog(1, "IOUSBControllerV3[%p]::UIMInitialize - couldn't add timer event source", this);
USBTrace( kUSBTController, kTPControllerV3Start, (uintptr_t)this, kIOReturnError, 0, 3 );
return kIOReturnError;
}
err = InitForPM();
if (err)
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::start - InitForPM returned (%p)", getName(), this, (void*)err);
USBTrace( kUSBTController, kTPControllerV3Start, (uintptr_t)this, err, 0, 4 );
return false;
}
return true;
}
void
IOUSBControllerV3::stop( IOService * provider )
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::stop isInactive = %d", getName(), this, isInactive());
if (_ehciController)
{
_ehciController->release();
_ehciController = NULL;
}
if (_rootHubTimer)
{
_rootHubTimer->cancelTimeout();
if ( _workLoop )
_workLoop->removeEventSource(_rootHubTimer);
_rootHubTimer->release();
_rootHubTimer = NULL;
}
super::stop(provider);
}
unsigned long
IOUSBControllerV3::maxCapabilityForDomainState ( IOPMPowerFlags domainState )
{
unsigned long ret = super::maxCapabilityForDomainState(domainState);
IOPMPowerFlags domainStateForDoze = kIOPMDoze | (_myPowerStates[kUSBPowerStateOn].inputPowerRequirement & kIOPMClockNormal);
if ( (_myPowerState == kUSBPowerStateSleep) && _gHibernateState && (*_gHibernateState == kIOHibernateStateWakingFromHibernate) && !_wakingFromHibernation)
{
UInt16 configCommand = _device->configRead16(kIOPCIConfigCommand);
USBLog(5, "IOUSBControllerV3(%s)[%p]::maxCapabilityForDomainState - waking from hibernation - setting flag - kIOPCIConfigCommand(%p)", getName(), this, (void*)configCommand);
_device->configWrite16(kIOPCIConfigCommand, configCommand | kIOPCICommandMemorySpace);
USBLog(5, "IOUSBControllerV3(%s)[%p]::maxCapabilityForDomainState - new kIOPCIConfigCommand(%p)", getName(), this, (void*)_device->configRead16(kIOPCIConfigCommand));
ResetControllerState();
EnableAllEndpoints(true);
_wakingFromHibernation = true;
ret = kUSBPowerStateOff;
}
else if (_restarting)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::maxCapabilityForDomainState - restarting", getName(), this);
ret = kUSBPowerStateRestart;
}
else if (_poweringDown)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::maxCapabilityForDomainState - powering off", getName(), this);
ret = kUSBPowerStateOff;
}
else if (domainState == domainStateForDoze)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::maxCapabilityForDomainState - going into the PCI Doze state - we can support full ON..", getName(), this);
ret = kUSBPowerStateOn;
}
USBLog(5, "IOUSBControllerV3(%s)[%p]::maxCapabilityForDomainState - domainState[%p], returning[%p]", getName(), this, (void*)domainState, (void*)ret);
return ret;
}
unsigned long
IOUSBControllerV3::initialPowerStateForDomainState ( IOPMPowerFlags domainState )
{
unsigned long ret = super::initialPowerStateForDomainState(domainState);
USBLog(5, "IOUSBControllerV3(%s)[%p]::initialPowerStateForDomainState - domainState[%p], returning[%p]", getName(), this, (void*)domainState, (void*)ret);
return ret;
}
IOReturn
IOUSBControllerV3::powerStateWillChangeTo ( IOPMPowerFlags capabilities, unsigned long stateNumber, IOService* whatDevice)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::powerStateWillChangeTo - capabilities(%p) - stateNumber (%d) - whatDevice(%p): currrent _myPowerState(%d)", getName(), this, (void*)capabilities, (int)stateNumber, whatDevice, (int)_myPowerState);
_powerStateChangingTo = stateNumber;
return super::powerStateWillChangeTo(capabilities, stateNumber, whatDevice);
}
IOReturn
IOUSBControllerV3::setPowerState( unsigned long powerStateOrdinal, IOService* whatDevice )
{
USBTrace_Start( kUSBTController, kTPControllersetPowerState, (uintptr_t)this, (int)powerStateOrdinal, (uintptr_t)whatDevice, (int)_myPowerState );
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - powerStateOrdinal(%d) - whatDevice(%p) current state(%d)", getName(), this, (int)powerStateOrdinal, whatDevice, (int)_myPowerState);
if ( whatDevice != this )
{
USBLog(1,"IOUSBControllerV3(%s)[%p]::setPowerState - whatDevice != this", getName(), this);
USBTrace( kUSBTController, kTPControllersetPowerState, (uintptr_t)this, 0, 0, 1 );
return kIOPMAckImplied;
}
if ( isInactive() )
{
USBLog(1,"IOUSBControllerV3(%s)[%p]::setPowerState - isInactive - no op", getName(), this);
USBTrace( kUSBTController, kTPControllersetPowerState, (uintptr_t)this, 0, 0, 2 );
return kIOPMAckImplied;
}
if (powerStateOrdinal > kUSBPowerStateOn)
{
USBLog(1,"IOUSBControllerV3(%s)[%p]::setPowerState - bad ordinal(%d)", getName(), this, (int)powerStateOrdinal);
USBTrace( kUSBTController, kTPControllersetPowerState, (uintptr_t)this, 0, 0, 3 );
return kIOPMNoSuchState;
}
if (_myPowerState == powerStateOrdinal)
{
USBLog(5,"IOUSBControllerV3(%s)[%p]::setPowerState - already in correct power state (%d) - no op", getName(), this, (int)_myPowerState);
return kIOPMAckImplied;
}
if ((_myPowerState < kUSBPowerStateLowPower) && (powerStateOrdinal >= kUSBPowerStateLowPower))
{
EnableBusMastering(true);
}
else if ((_myPowerState > kUSBPowerStateSleep) && (powerStateOrdinal <= kUSBPowerStateSleep))
{
if (_expansionData && _watchdogUSBTimer && _watchdogTimerActive)
{
_watchdogUSBTimer->cancelTimeout(); _watchdogTimerActive = false;
}
}
if (_ehciController)
{
if (_wakingFromHibernation)
{
while (_ehciController->_myPowerState <= kUSBPowerStateSleep)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - _wakingFromHibernation - waiting for EHCI controller (%p) to get higher than SLEEP before I proceed - current state (%d)", getName(), this, _ehciController, (int)_myPowerState);
IOSleep(10);
}
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - done waiting for EHCI controller - current state (%d)", getName(), this, (int)_myPowerState);
}
else
{
if ((_myPowerState < kUSBPowerStateLowPower) && (powerStateOrdinal >= kUSBPowerStateLowPower))
{
while (_ehciController->_myPowerState < kUSBPowerStateLowPower)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - waiting for EHCI controller (%p) to power up before I proceed - current state (%d)", getName(), this, _ehciController, (int)_myPowerState);
IOSleep(10);
}
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - done waiting for EHCI controller - current state (%d)", getName(), this, (int)_myPowerState);
}
if ((_myPowerState > kUSBPowerStateRestart) && (powerStateOrdinal <= kUSBPowerStateRestart))
{
while (_ehciController->_myPowerState > kUSBPowerStateRestart)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - waiting for EHCI controller (%p) to power down before I proceed - current state (%d)", getName(), this, _ehciController, (int)_myPowerState);
IOSleep(10);
}
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - done waiting for EHCI controller - current state (%d)", getName(), this, (int)_myPowerState);
}
}
}
HandlePowerChange(powerStateOrdinal);
USBLog(5, "IOUSBControllerV3(%s)[%p]::setPowerState - returning kIOPMAckImplied", getName(), this);
USBTrace_End( kUSBTController, kTPControllersetPowerState, (uintptr_t)this, _myPowerState, 0, 0);
return kIOPMAckImplied;
}
IOReturn
IOUSBControllerV3::powerStateDidChangeTo ( IOPMPowerFlags capabilities, unsigned long stateNumber, IOService* whatDevice)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::powerStateDidChangeTo - capabilities(%p) - stateNumber (%d) - whatDevice(%p): current state(%d)", getName(), this, (void*)capabilities, (int)stateNumber, whatDevice, (int)_myPowerState);
return super::powerStateDidChangeTo(capabilities, stateNumber, whatDevice);
}
void
IOUSBControllerV3::powerChangeDone ( unsigned long fromState)
{
USBLog((fromState == _myPowerState) ? 7 : 5, "IOUSBControllerV3(%s)[%p]::powerChangeDone - fromState (%d) current state (%d) _wakingFromHibernation(%s) _needToAckPowerDown(%s)", getName(), this, (int)fromState, (int)_myPowerState, _wakingFromHibernation ? "true" : "false", _needToAckPowerDown ? "true" : "false");
_powerStateChangingTo = kUSBPowerStateStable;
if (_wakingFromHibernation)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::powerChangeDone - OFF while _wakingFromHibernation - turning ON", getName(), this);
_wakingFromHibernation = false;
_poweringDown = false;
_restarting = false;
changePowerStateToPriv(kUSBPowerStateOn); EnsureUsability(); changePowerStateToPriv(kUSBPowerStateLowPower); }
else if (_needToAckPowerDown)
{
if (_myPowerState == kUSBPowerStateRestart)
{
_needToAckPowerDown = false;
USBLog(5, "IOUSBControllerV3(%s)[%p]::powerChangeDone - acknowledging systemWillShutdown(kIOMessageSystemWillRestart)", getName(), this);
IOService::systemWillShutdown(kIOMessageSystemWillRestart);
}
else if (_myPowerState == kUSBPowerStateOff)
{
_needToAckPowerDown = false;
USBLog(5, "IOUSBControllerV3(%s)[%p]::powerChangeDone - acknowledging systemWillShutdown(kIOMessageSystemWillPowerOff)", getName(), this);
IOService::systemWillShutdown(kIOMessageSystemWillPowerOff);
}
else
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::powerChangeDone - NOT acknowledging systemWillShutdown yet", getName(), this);
}
}
super::powerChangeDone(fromState);
}
void
IOUSBControllerV3::systemWillShutdown( IOOptionBits specifier )
{
bool ackNow = true;
USBLog(5, "IOUSBControllerV3(%s)[%p]::systemWillShutdown - specifier(%p)", getName(), this, (void*)specifier);
switch (specifier)
{
case kIOMessageSystemWillRestart:
ackNow = false;
_needToAckPowerDown = true;
_restarting = true;
USBLog(5, "IOUSBControllerV3(%s)[%p]::systemWillShutdown - changing power state to restart", getName(), this);
changePowerStateToPriv(kUSBPowerStateRestart);
powerOverrideOnPriv();
break;
case kIOMessageSystemWillPowerOff:
ackNow = false;
_needToAckPowerDown = true;
_poweringDown = true;
USBLog(5, "IOUSBControllerV3(%s)[%p]::systemWillShutdown - changing power state to off", getName(), this);
changePowerStateToPriv(kUSBPowerStateOff);
powerOverrideOnPriv();
break;
default:
break;
}
if (ackNow)
{
USBLog(5, "AppleUSBUHCI[%p]::systemWillShutdown - acknowledging", this);
IOService::systemWillShutdown(specifier);
}
}
void
IOUSBControllerV3::free()
{
if (_v3ExpansionData)
{
IOFree(_v3ExpansionData, sizeof(ExpansionData));
_v3ExpansionData = NULL;
}
super::free();
}
#pragma mark ееее class methods ееее
IOReturn
IOUSBControllerV3::CheckForEHCIController(IOService *provider)
{
OSIterator *siblings = NULL;
OSIterator *ehciList = NULL;
mach_timespec_t t;
IOService *service;
IORegistryEntry *entry;
bool ehciPresent = false;
int myDeviceNum = 0;
int ehciDeviceNum = 0;
IOUSBControllerV3 * testEHCI;
int checkListCount = 0;
USBLog(6, "+%s[%p]::CheckForEHCIController", getName(), this);
if ( _device )
{
myDeviceNum = _device->getDeviceNumber();
}
if (provider)
{
siblings = provider->getParentEntry(gIOServicePlane)->getChildIterator(gIOServicePlane);
}
else
{
USBLog(2, "%s[%p]::CheckForEHCIController - NULL provider", getName(), this);
}
if ( siblings )
{
while( (entry = OSDynamicCast(IORegistryEntry, siblings->getNextObject())))
{
UInt32 classCode;
OSData *obj = OSDynamicCast(OSData, entry->getProperty("class-code"));
if (obj)
{
classCode = *(UInt32 *)obj->getBytesNoCopy();
if (classCode == 0x0c0320)
{
ehciPresent = true;
break;
}
}
}
siblings->release();
}
else
{
USBLog(2, "%s[%p]::CheckForEHCIController - NULL siblings", getName(), this);
}
if (ehciPresent)
{
t.tv_sec = 5;
t.tv_nsec = 0;
USBLog(7, "%s[%p]::CheckForEHCIController calling waitForService for AppleUSBEHCI", getName(), this);
service = waitForService( serviceMatching("AppleUSBEHCI"), &t );
testEHCI = (IOUSBControllerV3*)service;
while (testEHCI)
{
IOPCIDevice * testPCI = (IOPCIDevice*)testEHCI->getParentEntry(gIOServicePlane);
ehciDeviceNum = testPCI->getDeviceNumber();
if (myDeviceNum == ehciDeviceNum)
{
USBLog(5, "%s[%p]::CheckForEHCIController - ehciDeviceNum and myDeviceNum match (%d)", getName(), this, myDeviceNum);
_ehciController = testEHCI;
_ehciController->retain();
USBLog(7, "%s[%p]::CheckForEHCIController got EHCI service %p", getName(), this, service);
setProperty("Companion", "yes");
break;
}
else
{
USBLog(5, "%s[%p]::CheckForEHCIController - ehciDeviceNum(%d) and myDeviceNum(%d) do NOT match", getName(), this, ehciDeviceNum, myDeviceNum);
if (ehciList)
{
testEHCI = (IOUSBControllerV3*)(ehciList->getNextObject());
if (testEHCI)
{
USBLog(3, "%s[%p]::CheckForEHCIController - found AppleUSBEHCI after %d ms", getName(), this, checkListCount * 10);
}
}
else
{
testEHCI = NULL;
}
if (!testEHCI && (checkListCount++ < 500))
{
if (ehciList)
ehciList->release();
IOSleep(10);
USBLog(5, "%s[%p]::CheckForEHCIController - getting an AppleUSBEHCI list", getName(), this);
ehciList = getMatchingServices(serviceMatching("AppleUSBEHCI"));
if (ehciList)
{
testEHCI = (IOUSBControllerV3*)(ehciList->getNextObject());
if (testEHCI)
{
USBLog(5, "%s[%p]::CheckForEHCIController - got AppleUSBEHCI[%p] from the list", getName(), this, testEHCI);
}
}
}
}
}
}
if ( !ehciPresent || checkListCount == 500 )
{
USBError(1, "We could not find a corresponding USB EHCI controller for our OHCI controller at PCI device number%d", myDeviceNum);
}
if (ehciList)
ehciList->release();
USBLog(6, "-%s[%p]::CheckForEHCIController", getName(), this);
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::AllocatePowerStateArray(void)
{
unsigned long i;
_numPowerStates = kUSBNumberBusPowerStates;
_myPowerStates = (IOPMPowerState*)IOMalloc(kUSBNumberBusPowerStates * sizeof(IOPMPowerState));
if (!_myPowerStates)
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::AllocatePowerStateArray - no memory", getName(), this);
USBTrace( kUSBTController, kTPAllocatePowerStateArray, (uintptr_t)this, kIOReturnNoMemory, 0, 0 );
return kIOReturnNoMemory;
}
bzero(_myPowerStates, kUSBNumberBusPowerStates * sizeof(IOPMPowerState));
for (i=0; i < _numPowerStates; i++)
{
_myPowerStates[i].version = kIOPMPowerStateVersion1;
}
_myPowerStates[kUSBPowerStateRestart].capabilityFlags = kIOPMRestartCapability;
_myPowerStates[kUSBPowerStateRestart].outputPowerCharacter = kIOPMRestart;
_myPowerStates[kUSBPowerStateSleep].capabilityFlags = kIOPMSleepCapability;
_myPowerStates[kUSBPowerStateSleep].outputPowerCharacter = kIOPMSleep;
_myPowerStates[kUSBPowerStateSleep].inputPowerRequirement = _controllerCanSleep ? 0 : kIOPMSleep;
_myPowerStates[kUSBPowerStateLowPower].capabilityFlags = kIOPMLowPower;
_myPowerStates[kUSBPowerStateLowPower].outputPowerCharacter = kIOPMLowPower;
_myPowerStates[kUSBPowerStateLowPower].inputPowerRequirement = IOPMPowerOn;
_myPowerStates[kUSBPowerStateOn].capabilityFlags = IOPMDeviceUsable;
_myPowerStates[kUSBPowerStateOn].outputPowerCharacter = IOPMPowerOn;
_myPowerStates[kUSBPowerStateOn].inputPowerRequirement = IOPMPowerOn;
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::InitForPM(void)
{
IOReturn err;
err = AllocatePowerStateArray();
if (err)
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::InitForPM - AllocatePowerStateArray returned (%p)", getName(), this, (void*)err);
USBTrace( kUSBTController, kTPInitForPM, (uintptr_t)this, err, 0, 0 );
return kIOReturnNoMemory;
}
makeUsable();
USBLog(3, "IOUSBControllerV3(%s)[%p]::InitForPM - calling registerPowerDriver", getName(), this);
registerPowerDriver(this, _myPowerStates, _numPowerStates);
changePowerStateTo(kUSBPowerStateLowPower);
changePowerStateToPriv(kUSBPowerStateLowPower);
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::CheckPowerModeBeforeGatedCall(char *fromStr)
{
#pragma unused (fromStr)
IOReturn kr = kIOReturnSuccess;
SInt32 retries = 100;
if (!_workLoop) return kIOReturnNotPermitted;
if (_myPowerState != kUSBPowerStateOn)
{
if ((_powerStateChangingTo != kUSBPowerStateStable) && (_powerStateChangingTo != kUSBPowerStateOn))
{
USBLog(2, "IOUSBControllerV3(%s)[%p]::CheckPowerModeBeforeGatedCall from (%s) - we are already in the process of changing state to (%d) - returning kIOReturnNotResponding", getName(), this, fromStr, (int)_powerStateChangingTo);
kr = kIOReturnNotResponding;
}
else if (_workLoop->onThread())
{
if (!_controllerAvailable)
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::CheckPowerModeBeforeGatedCall - call (%s) - onThread is true while !_controllerAvailable", getName(), this, fromStr);
kr = kIOReturnNotReady;
USBTrace( kUSBTController, kTPControllerCheckPowerModeBeforeGatedCall, (uintptr_t)this, (int)_myPowerState, kr, 1 );
}
}
else
{
while ( (_myPowerState != kUSBPowerStateOn) and (retries-- > 0) )
{
#if 0
char* bt[8];
OSBacktrace((void**)bt, 8);
USBLog(4, "IOUSBControllerV3(%s)[%p]::CheckPowerModeBeforeGatedCall - call (%s) while _myPowerState(%d) _controllerAvailable(%s) _powerStateChangingTo(%d) - sleeping thread, bt:[%p][%p][%p][%p][%p][%p][%p]", getName(), this, fromStr, (int)_myPowerState, _controllerAvailable ? "true" : "false", (int)_powerStateChangingTo, bt[1], bt[2], bt[3], bt[4], bt[5], bt[6], bt[7]);
#endif
IOSleep(10);
}
}
if ( retries < 1 )
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::CheckPowerModeBeforeGatedCall - call (%s) while _myPowerState(%d) _controllerAvailable (%s) - we could not wake up the controller, returning kIOReturnNotResponding", getName(), this, fromStr, (int)_myPowerState, _controllerAvailable ? "true" : "false");
kr = kIOReturnNotResponding;
USBTrace( kUSBTController, kTPControllerCheckPowerModeBeforeGatedCall, (uintptr_t)this, (int)_myPowerState, kr, 2 );
}
}
return kr;
}
IOReturn
IOUSBControllerV3::DoEnableAddressEndpoints(OSObject *owner, void *arg0, void *arg1, void *arg2, void *arg3 )
{
#pragma unused (arg2, arg3)
IOUSBControllerV3 *me = (IOUSBControllerV3 *)owner;
return me->UIMEnableAddressEndpoints((USBDeviceAddress)(uintptr_t)arg0, (bool)(uintptr_t) arg1);
}
IOReturn
IOUSBControllerV3::EnableAddressEndpoints(USBDeviceAddress address, bool enable)
{
IOCommandGate * commandGate = GetCommandGate();
return commandGate->runAction(DoEnableAddressEndpoints, (void*)(uintptr_t)address, (void*)enable);
}
IOReturn
IOUSBControllerV3::DoEnableAllEndpoints(OSObject *owner, void *arg0, void *arg1, void *arg2, void *arg3 )
{
#pragma unused (arg1, arg2, arg3)
IOUSBControllerV3 *me = (IOUSBControllerV3 *)owner;
return me->UIMEnableAllEndpoints((bool)(uintptr_t)arg0);
}
IOReturn
IOUSBControllerV3::EnableAllEndpoints(bool enable)
{
IOCommandGate * commandGate = GetCommandGate();
return commandGate->runAction(DoEnableAllEndpoints, (void*)enable);
}
void
IOUSBControllerV3::ControllerOff(void)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerOff - calling ResetControllerState", getName(), this);
ResetControllerState();
if (_expansionData && _watchdogUSBTimer && _watchdogTimerActive)
{
_watchdogUSBTimer->cancelTimeout(); _watchdogTimerActive = false;
}
}
void
IOUSBControllerV3::ControllerRestart(void)
{
ControllerOff();
}
void
IOUSBControllerV3::ControllerSleep(void)
{
if ( !_gHibernateState )
{
OSData * data = OSDynamicCast(OSData, (IOService::getPMRootDomain())->getProperty(kIOHibernateStateKey));
if (data)
{
_gHibernateState = (uint32_t *) data->getBytesNoCopy();
}
}
if (_myPowerState == kUSBPowerStateLowPower)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerSleep - dozing now - need to wake controller from doze first", getName(), this);
WakeControllerFromDoze();
}
EnableInterruptsFromController(false);
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerSleep - calling SaveControllerStateForSleep", getName(), this);
SaveControllerStateForSleep();
}
void
IOUSBControllerV3::ControllerDoze(void)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerDoze", getName(), this);
switch(_myPowerState)
{
case kUSBPowerStateOff:
case kUSBPowerStateRestart:
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerDoze - OFF now - need to restart before dozing", getName(), this);
RestartControllerFromReset();
break;
case kUSBPowerStateSleep:
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerDoze - sleeping now - need to wake from sleep before dozing", getName(), this);
RestoreControllerStateFromSleep();
break;
}
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerDoze - calling DozeController", getName(), this);
DozeController();
}
void
IOUSBControllerV3::ControllerOn(void)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::ControllerOn - current state (%d) _ehciController(%p)", getName(), this, (int)_myPowerState, _ehciController);
switch(_myPowerState)
{
case kUSBPowerStateOff:
case kUSBPowerStateRestart:
RestartControllerFromReset();
break;
case kUSBPowerStateSleep:
RestoreControllerStateFromSleep();
break;
case kUSBPowerStateLowPower:
WakeControllerFromDoze();
break;
}
}
bool
IOUSBControllerV3::IsControllerAvailable(void)
{
return _controllerAvailable;
}
IOReturn
IOUSBControllerV3::GatedPowerChange(OSObject *owner, void *arg0, void *arg1, void *arg2, void *arg3 )
{
#pragma unused (arg1, arg2, arg3)
IOUSBControllerV3 *me = (IOUSBControllerV3 *)owner;
unsigned long powerStateOrdinal = (unsigned long)arg0;
unsigned long oldState = me->_myPowerState;
switch (powerStateOrdinal)
{
case kUSBPowerStateOff:
me->ControllerOff();
break;
case kUSBPowerStateRestart:
me->ControllerRestart();
break;
case kUSBPowerStateSleep:
me->ControllerSleep();
break;
case kUSBPowerStateLowPower:
me->ControllerDoze();
break;
case kUSBPowerStateOn:
me->ControllerOn();
break;
}
me->_myPowerState = powerStateOrdinal;
if (powerStateOrdinal < kUSBPowerStateLowPower)
{
me->_controllerAvailable = false; me->RootHubStopTimer();
me->EnableBusMastering(false); }
else
{
me->_controllerAvailable = true;
if (oldState < kUSBPowerStateLowPower)
{
me->EnableInterruptsFromController(true);
if (me->_rootHubPollingRate32) me->RootHubStartTimer32(me->_rootHubPollingRate32); }
if ( me->_rootHubDevice == NULL )
{
IOReturn err;
USBLog(5, "IOUSBControllerV3(%s)[%p]::powerStateDidChangeTo - calling CreateRootHubDevice", me->getName(), me);
err = me->CreateRootHubDevice( me->_device, &(me->_rootHubDevice) );
USBLog(5,"IOUSBControllerV3(%s)[%p]::powerStateDidChangeTo - done with CreateRootHubDevice - return (%p)", me->getName(), me, (void*)err);
if ( err != kIOReturnSuccess )
{
USBLog(1,"AppleUSBEHCI[%p]::powerStateDidChangeTo - Could not create root hub device upon wakeup (%x)!", me, err);
USBTrace( kUSBTController, kTPControllerGatedPowerChange, (uintptr_t)me, err, 0, 0 );
}
else
{
me->_rootHubDevice->registerService(kIOServiceRequired | kIOServiceSynchronous);
}
}
if (me->_expansionData && me->_watchdogUSBTimer && !me->_watchdogTimerActive)
{
me->_watchdogTimerActive = true;
me->_watchdogUSBTimer->setTimeoutMS(kUSBWatchdogTimeoutMS);
}
}
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::HandlePowerChange(unsigned long powerStateOrdinal)
{
IOCommandGate * commandGate = GetCommandGate();
USBLog(5, "IOUSBControllerV3(%s)[%p]::HandlePowerChange - sending the state change request (%d) through the gate - configCommand(%p)", getName(), this, (int)powerStateOrdinal, (void*)_device->configRead16(kIOPCIConfigCommand));
return commandGate->runAction(GatedPowerChange, (void*)powerStateOrdinal);
}
IOReturn
IOUSBControllerV3::EnableBusMastering(bool enable)
{
UInt16 config = _device->configRead16(kIOPCIConfigCommand);
if (enable)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::EnableBusMastering(true) - currently (%p) - enabling", getName(), this, (void*)config);
config |= kIOPCICommandBusMaster;
}
else
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::EnableBusMastering(false) - currently (%p) - disabling", getName(), this, (void*)config);
config &= ~kIOPCICommandBusMaster;
}
_device->configWrite16(kIOPCIConfigCommand, config);
USBLog(5, "IOUSBControllerV3(%s)[%p]::EnableBusMastering - new value[%p]", getName(), this, (void*)_device->configRead16(kIOPCIConfigCommand));
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::EnsureUsability(void)
{
if (_rootHubDevice && _rootHubDevice->GetPolicyMaker())
{
USBLog(7, "IOUSBControllerV3(%s)[%p]::EnsureUsability - passing on to root hub policy maker[%p]", getName(), this, _rootHubDevice->GetPolicyMaker());
_rootHubDevice->GetPolicyMaker()->EnsureUsability();
}
return kIOReturnSuccess;
}
void
IOUSBControllerV3::RootHubTimerFired(OSObject *owner, IOTimerEventSource *sender)
{
#pragma unused (sender)
IOUSBControllerV3 *me;
IOReturn ret;
me = OSDynamicCast(IOUSBControllerV3, owner);
if (!me || me->isInactive() || !me->_controllerAvailable)
return;
if (me->_rootHubDevice && me->_rootHubDevice->GetPolicyMaker())
{
USBLog(7, "IOUSBControllerV3(%s)[%p]::RootHubTimerFired - PolicyMaker[%p] powerState[%d] _powerStateChangingTo[%d]", me->getName(), me, me->_rootHubDevice->GetPolicyMaker(), (int)me->_rootHubDevice->GetPolicyMaker()->getPowerState(),(int)me->_powerStateChangingTo);
if ((me->_powerStateChangingTo == kUSBPowerStateSleep) and (me->_rootHubDevice->GetPolicyMaker()->getPowerState() == kIOUSBHubPowerStateSleep))
{
USBLog(2, "IOUSBControllerV3(%s)[%p]::RootHubTimerFired - abandoning ship because I am going to sleep and my root hub is already asleep", me->getName(), me);
return;
}
}
else
{
USBLog(7, "IOUSBControllerV3(%s)[%p]::RootHubTimerFired", me->getName(), me);
}
USBTrace( kUSBTController, kTPControllerRootHubTimer, (uintptr_t)me, (uintptr_t)me->_rootHubDevice->GetPolicyMaker(), (uintptr_t)me->_rootHubDevice->GetPolicyMaker()->getPowerState(), 4 );
ret = me->CheckForRootHubChanges();
if (me->_rootHubPollingRate32 && !me->isInactive() && me->_controllerAvailable)
me->_rootHubTimer->setTimeoutMS(me->_rootHubPollingRate32);
}
IOReturn
IOUSBControllerV3::CheckForRootHubChanges(void)
{
IOUSBRootHubInterruptTransaction xaction;
UInt8 bBitmap;
UInt16 wBitmap;
UInt8 bytesToMove;
UInt8* pBytes;
int i;
UIMRootHubStatusChange();
if (_rootHubStatusChangedBitmap)
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::CheckForRootHubChanges - got _rootHubStatusChangedBitmap(%p)", getName(), this, (void*)_rootHubStatusChangedBitmap);
if (_rootHubDevice && _rootHubDevice->GetPolicyMaker())
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::CheckForRootHubChanges - making sure root hub driver AppleUSBHub[%p] is usable", getName(), this, _rootHubDevice->GetPolicyMaker());
_rootHubDevice->GetPolicyMaker()->EnsureUsability(); }
else
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::CheckForRootHubChanges - _rootHubStatusChangedBitmap(%p) with no _rootHubDevice or policy maker!!", getName(), this, (void*)_rootHubStatusChangedBitmap);
USBTrace( kUSBTController, kTPControllerCheckForRootHubChanges, (uintptr_t)this, _rootHubStatusChangedBitmap, 0, 0);
}
if (_outstandingRHTrans[0].completion.action)
{
xaction = _outstandingRHTrans[0];
for (i = 0; i < (kIOUSBMaxRootHubTransactions-1); i++)
{
_outstandingRHTrans[i] = _outstandingRHTrans[i+1];
}
_outstandingRHTrans[kIOUSBMaxRootHubTransactions-1].completion.action = NULL;
if (_rootHubNumPorts < 8)
{
bytesToMove = 1;
bBitmap = (UInt8)_rootHubStatusChangedBitmap;
pBytes = &bBitmap;
}
else
{
bytesToMove = 2;
wBitmap = HostToUSBWord(_rootHubStatusChangedBitmap);
pBytes = (UInt8*)&wBitmap;
}
USBTrace( kUSBTController, kTPControllerRootHubTimer, (uintptr_t)this, 0, 0, 5 );
USBLog(6, "IOUSBControllerV3(%s)[%p]::CheckForRootHubChanges - stopping timer and calling complete", getName(), this);
RootHubStopTimer();
_rootHubTransactionWasAborted = false;
xaction.buf->writeBytes(0, pBytes, bytesToMove);
Complete(xaction.completion, kIOReturnSuccess, xaction.bufLen - bytesToMove);
}
else
{
USBLog(5, "IOUSBControllerV3(%s)[%p]::CheckForRootHubChanges - no one is listening - i will try again later", getName(), this);
}
}
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::RootHubQueueInterruptRead(IOMemoryDescriptor *buf, UInt32 bufLen, IOUSBCompletion completion)
{
int i;
USBTrace_Start( kUSBTController, kTPControllerRootHubQueueInterruptRead, (uintptr_t)this, (uintptr_t)buf, bufLen, 0);
USBLog(6, "IOUSBControllerV3(%s)[%p]::RootHubQueueInterruptRead, starting timer", getName(), this);
RootHubStartTimer32(kUSBRootHubPollingRate);
for (i = 0; i < kIOUSBMaxRootHubTransactions; i++)
{
if (_outstandingRHTrans[i].completion.action == NULL)
{
_outstandingRHTrans[i].buf = buf;
_outstandingRHTrans[i].bufLen = bufLen;
_outstandingRHTrans[i].completion = completion;
if (i != 0)
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::RootHubQueueInterruptRead - this is index(%d) - UNEXPECTED?", getName(), this, (int)i);
USBTrace( kUSBTController, kTPControllerRootHubQueueInterruptRead, (uintptr_t)this, i, 0, 0 );
break;
}
if ( _rootHubTransactionWasAborted )
{
USBLog(6, "IOUSBControllerV3(%s)[%p]::RootHubQueueInterruptRead _rootHubTransactionWasAborted was true, calling CheckForRootHubChanges()", getName(), this);
CheckForRootHubChanges();
}
return kIOReturnSuccess;
}
else
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::RootHubQueueInterruptRead we already had a completion.action for trans: %d, returning an error", getName(), this, i);
break;
}
}
USBTrace_End( kUSBTController, kTPControllerRootHubQueueInterruptRead, (uintptr_t)this, kIOReturnInternalError, bufLen, 0);
return kIOReturnNotPermitted;
}
IOReturn
IOUSBControllerV3::RootHubAbortInterruptRead()
{
int i;
IOUSBRootHubInterruptTransaction xaction;
USBTrace( kUSBTController, kTPControllerRootHubTimer, (uintptr_t)this, 0, 0, 3 );
USBLog(6, "IOUSBControllerV3(%s)[%p]::RootHubAbortInterruptRead, stopping timer", getName(), this);
RootHubStopTimer();
xaction = _outstandingRHTrans[0];
if (xaction.completion.action)
{
for (i = 0; i < (kIOUSBMaxRootHubTransactions-1); i++)
{
_outstandingRHTrans[i] = _outstandingRHTrans[i+1];
}
_outstandingRHTrans[kIOUSBMaxRootHubTransactions-1].completion.action = NULL;
Complete(xaction.completion, kIOReturnAborted, xaction.bufLen);
_rootHubTransactionWasAborted = true;
}
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::RootHubStartTimer(UInt8 pollingRate)
{
#pragma unused (pollingRate)
USBLog(1,"IOUSBControllerV3(%s)[[%p]::RootHubStartTimer Obsolete method called", getName(), this);
return kIOReturnUnsupported;
}
IOReturn
IOUSBControllerV3::RootHubStartTimer32(uint32_t pollingRate)
{
USBTrace( kUSBTController, kTPControllerRootHubTimer, (uintptr_t)this, pollingRate, 0, 1 );
if (pollingRate == 0)
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::RootHubStartTimer32 - invalid polling rate (%d)", getName(), this, pollingRate);
USBTrace( kUSBTController, kTPControllerRootHubTimer, (uintptr_t)this, pollingRate, kIOReturnBadArgument, 6 );
return kIOReturnBadArgument;
}
_rootHubPollingRate32 = pollingRate;
if (_rootHubTimer)
{
USBLog(6, "IOUSBControllerV3(%s)[%p]::RootHubStartTimer32", getName(), this);
_rootHubTimer->setTimeoutMS(_rootHubPollingRate32);
}
else
{
USBLog(1, "IOUSBControllerV3(%s)[%p]::RootHubStartTimer32 - NO TIMER!!", getName(), this);
USBTrace( kUSBTController, kTPControllerRootHubTimer, (uintptr_t)this, 0, kIOReturnSuccess, 7 );
}
return kIOReturnSuccess;
}
IOReturn
IOUSBControllerV3::RootHubStopTimer(void)
{
USBTrace( kUSBTController, kTPControllerRootHubTimer, (uintptr_t)this, 0, 0, 2 );
USBLog(6, "IOUSBControllerV3(%s)[%p]::RootHubStopTimer", getName(), this);
if (_rootHubTimer)
{
_rootHubTimer->cancelTimeout();
}
return kIOReturnSuccess;
}
UInt32
IOUSBControllerV3::AllocateExtraRootHubPortPower(UInt32 extraPowerRequested)
{
#pragma unused (extraPowerRequested)
USBLog(2, "IOUSBControllerV3(%s)[%p]::AllocateExtraRootHubPortPower - not available on this controller", getName(), this);
return 0;
}
void
IOUSBControllerV3::ReturnExtraRootHubPortPower(UInt32 extraPowerReturned)
{
#pragma unused (extraPowerReturned)
USBLog(2, "IOUSBControllerV3(%s)[%p]::ReturnExtraRootHubPortPower - not available on this controller", getName(), this);
return;
}
#pragma mark еееее IOUSBController methods еееее
IOReturn
IOUSBControllerV3::AcquireDeviceZero( void )
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall( (char *) "AcquireDeviceZero");
if ( kr != kIOReturnSuccess )
{
USBError(1, "IOUSBControllerV3(%s)[%p]::AcquireDeviceZero - CheckPowerModeBeforeGatedCall returned 0x%x", getName(), this, kr);
return kr;
}
return IOUSBController::AcquireDeviceZero();
}
void
IOUSBControllerV3::ReleaseDeviceZero( void )
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "ReleaseDeviceZero");
if ( kr != kIOReturnSuccess )
return;
return IOUSBController::ReleaseDeviceZero();
}
IOReturn
IOUSBControllerV3::DeviceRequest(IOUSBDevRequest *request, IOUSBCompletion *completion, USBDeviceAddress address, UInt8 epNum, UInt32 noDataTimeout, UInt32 completionTimeout)
{
IOReturn kr;
if ((_powerStateChangingTo == kUSBPowerStateStable) || (_powerStateChangingTo > kUSBPowerStateSleep))
{
USBLog(7, "IOUSBControllerV3(%s)[%p]::DeviceRequest - current state (%d) _powerStateChangingTo(%d) - calling changePowerStateTo(4)", getName(), this, (int)_myPowerState, (int)_powerStateChangingTo);
changePowerStateTo(kUSBPowerStateOn);
}
kr = CheckPowerModeBeforeGatedCall((char *) "DeviceRequest");
if ( kr != kIOReturnSuccess )
return kr;
kr = IOUSBController::DeviceRequest(request, completion, address, epNum, noDataTimeout, completionTimeout);
if ((_powerStateChangingTo == kUSBPowerStateStable) || (_powerStateChangingTo > kUSBPowerStateSleep))
{
USBLog(7, "IOUSBControllerV3(%s)[%p]::DeviceRequest done - current state (%d) - calling changePowerStateTo(3)", getName(), this, (int)_myPowerState);
changePowerStateTo(kUSBPowerStateLowPower);
}
return kr;
}
IOReturn
IOUSBControllerV3::DeviceRequest(IOUSBDevRequestDesc *request, IOUSBCompletion *completion, USBDeviceAddress address, UInt8 epNum, UInt32 noDataTimeout, UInt32 completionTimeout)
{
IOReturn kr;
USBLog(7, "IOUSBControllerV3(%s)[%p]::DeviceRequest - current state (%d) _powerStateChangingTo(%d) - calling changePowerStateTo(4)", getName(), this, (int)_myPowerState, (int)_powerStateChangingTo);
changePowerStateTo(kUSBPowerStateOn);
kr = CheckPowerModeBeforeGatedCall((char *) "DeviceRequest");
if ( kr != kIOReturnSuccess )
return kr;
kr = IOUSBController::DeviceRequest(request, completion, address, epNum, noDataTimeout, completionTimeout);
USBLog(7, "IOUSBControllerV3(%s)[%p]::DeviceRequest done - current state (%d) - calling changePowerStateTo(3)", getName(), this, (int)_myPowerState);
changePowerStateTo(kUSBPowerStateLowPower);
return kr;
}
IOReturn
IOUSBControllerV3::ClosePipe(USBDeviceAddress address, Endpoint *endpoint)
{
IOReturn kr;
if (!(_controllerAvailable || _wakingFromHibernation || _restarting || _poweringDown))
{
kr = CheckPowerModeBeforeGatedCall((char *) "ClosePipe");
if ( kr != kIOReturnSuccess )
return kr;
}
return IOUSBController::ClosePipe(address, endpoint);
}
IOReturn
IOUSBControllerV3::AbortPipe(USBDeviceAddress address, Endpoint *endpoint)
{
IOReturn kr;
if (!(_controllerAvailable || _wakingFromHibernation || _restarting || _poweringDown))
{
kr = CheckPowerModeBeforeGatedCall((char *) "AbortPipe");
if ( kr != kIOReturnSuccess )
return kr;
}
return IOUSBController::AbortPipe(address, endpoint);
}
IOReturn
IOUSBControllerV3::ResetPipe(USBDeviceAddress address, Endpoint *endpoint)
{
IOReturn kr;
if (!(_controllerAvailable || _wakingFromHibernation || _restarting || _poweringDown))
{
kr = CheckPowerModeBeforeGatedCall((char *) "ResetPipe");
if ( kr != kIOReturnSuccess )
return kr;
}
return IOUSBController::ResetPipe(address, endpoint);
}
IOReturn
IOUSBControllerV3::ClearPipeStall(USBDeviceAddress address, Endpoint *endpoint)
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "ClearPipeStall");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBController::ClearPipeStall(address, endpoint);
}
IOReturn
IOUSBControllerV3::Read(IOMemoryDescriptor *buffer, USBDeviceAddress address, Endpoint *endpoint, IOUSBCompletion *completion, UInt32 noDataTimeout, UInt32 completionTimeout, IOByteCount reqCount)
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "Read");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBController::Read(buffer, address, endpoint, completion, noDataTimeout, completionTimeout, reqCount);
}
IOReturn
IOUSBControllerV3::Write(IOMemoryDescriptor *buffer, USBDeviceAddress address, Endpoint *endpoint, IOUSBCompletion *completion, UInt32 noDataTimeout, UInt32 completionTimeout, IOByteCount reqCount)
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "Write");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBController::Write(buffer, address, endpoint, completion, noDataTimeout, completionTimeout, reqCount);
}
IOReturn
IOUSBControllerV3::IsocIO(IOMemoryDescriptor *buffer, UInt64 frameStart, UInt32 numFrames, IOUSBIsocFrame *frameList, USBDeviceAddress address, Endpoint *endpoint, IOUSBIsocCompletion *completion )
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "IsocIO");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBController::IsocIO(buffer, frameStart, numFrames, frameList, address, endpoint, completion);
}
IOReturn
IOUSBControllerV3::IsocIO(IOMemoryDescriptor *buffer, UInt64 frameStart, UInt32 numFrames, IOUSBLowLatencyIsocFrame *frameList, USBDeviceAddress address, Endpoint *endpoint, IOUSBLowLatencyIsocCompletion *completion, UInt32 updateFrequency )
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "IsocIO");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBController::IsocIO(buffer, frameStart, numFrames, frameList, address, endpoint, completion, updateFrequency);
}
#pragma mark еееее IOUSBControllerV2 methods еееее
IOReturn
IOUSBControllerV3::OpenPipe(USBDeviceAddress address, UInt8 speed, Endpoint *endpoint)
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "OpenPipe");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBControllerV2::OpenPipe(address, speed, endpoint);
}
IOReturn
IOUSBControllerV3::AddHSHub(USBDeviceAddress highSpeedHub, UInt32 flags)
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "AddHSHub");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBControllerV2::AddHSHub(highSpeedHub, flags);
}
IOReturn
IOUSBControllerV3::RemoveHSHub(USBDeviceAddress highSpeedHub)
{
IOReturn kr;
if (!(_controllerAvailable || _wakingFromHibernation || _restarting || _poweringDown))
{
kr = CheckPowerModeBeforeGatedCall((char *) "RemoveHSHub");
if ( kr != kIOReturnSuccess )
return kr;
}
return IOUSBControllerV2::RemoveHSHub(highSpeedHub);
}
IOReturn
IOUSBControllerV3::SetTestMode(UInt32 mode, UInt32 port)
{
IOReturn kr;
changePowerStateTo(kUSBPowerStateOn); kr = CheckPowerModeBeforeGatedCall((char *) "SetTestMode");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBControllerV2::SetTestMode(mode, port);
}
IOReturn
IOUSBControllerV3::ReadV2(IOMemoryDescriptor *buffer, USBDeviceAddress address, Endpoint *endpoint, IOUSBCompletionWithTimeStamp *completion, UInt32 noDataTimeout, UInt32 completionTimeout, IOByteCount reqCount)
{
IOReturn kr;
kr = CheckPowerModeBeforeGatedCall((char *) "ReadV2");
if ( kr != kIOReturnSuccess )
return kr;
return IOUSBControllerV2::ReadV2(buffer, address, endpoint, completion, noDataTimeout, completionTimeout, reqCount);
}
OSMetaClassDefineReservedUsed(IOUSBControllerV3, 0);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 1);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 2);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 3);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 4);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 5);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 6);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 7);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 8);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 9);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 10);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 11);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 12);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 13);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 14);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 15);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 16);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 17);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 18);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 19);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 20);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 21);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 22);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 23);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 24);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 25);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 26);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 27);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 28);
OSMetaClassDefineReservedUnused(IOUSBControllerV3, 29);