AppleUSBEHCI_PwrMgmt.cpp [plain text]
#include <libkern/OSByteOrder.h>
#include <IOKit/IOLib.h>
#include <IOKit/IOService.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/platform/ApplePlatformExpert.h>
#include <IOKit/pwr_mgt/RootDomain.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOHibernatePrivate.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/usb/IOUSBRootHubDevice.h>
#include <IOKit/usb/IOUSBLog.h>
#include <IOKit/acpi/IOACPIPlatformDevice.h>
#include <libkern/libkern.h>
#ifndef kACPIDevicePathKey
#define kACPIDevicePathKey "acpi-path"
#endif
#include "AppleUSBEHCI.h"
enum {
kGossamerTypeGossamer = 1,
kGossamerTypeSilk,
kGossamerTypeWallstreet,
kGossamerTypeiMac,
kGossamerTypeYosemite,
kGossamerType101
};
#if EHCI_USE_KPRINTF
#define EHCIPWRMGMT_USE_KPRINTF EHCI_USE_KPRINTF
#else
#define EHCIPWRMGMT_USE_KPRINTF 0
#endif
#if EHCIPWRMGMT_USE_KPRINTF
#undef USBLog
#undef USBError
void kprintf(const char *format, ...)
__attribute__((format(printf, 1, 2)));
#define USBLog( LEVEL, FORMAT, ARGS... ) if ((LEVEL) <= EHCIPWRMGMT_USE_KPRINTF) { kprintf( FORMAT "\n", ## ARGS ) ; }
#define USBError( LEVEL, FORMAT, ARGS... ) { kprintf( FORMAT "\n", ## ARGS ) ; }
#endif
#define super IOUSBControllerV3
extern UInt32 getPortSCForWriting(EHCIRegistersPtr _pEHCIRegisters, short port);
#define _controllerCanSleep _expansionData->_controllerCanSleep
void
AppleUSBEHCI::CheckSleepCapability(void)
{
USBLog(2, "AppleUSBEHCI[%p]::CheckSleepCapability - assuming that I can sleep", this);
_controllerCanSleep = true;
_onCardBus = (0 != _device->metaCast("IOCardBusDevice"));
if ( !_device->getProperty("AAPL,clock-id") && !((getPlatform()->getChipSetType() == kChipSetTypeGossamer) && getPlatform()->getMachineType() == kGossamerTypeYosemite) )
{
bool hasSupport = false;
if (_errataBits & kErrataICH6PowerSequencing)
hasSupport = _device->hasPCIPowerManagement(kPCIPMCPMESupportFromD3Cold);
else
hasSupport = _device->hasPCIPowerManagement();
if (hasSupport)
{
if (_errataBits & kErrataICH6PowerSequencing)
hasSupport = (_device->enablePCIPowerManagement(kPCIPMCPMESupportFromD3Cold) == kIOReturnSuccess);
else
hasSupport = (_device->enablePCIPowerManagement() == kIOReturnSuccess);
}
if (hasSupport)
{
_hasPCIPwrMgmt = true;
setProperty("Card Type","Built-in");
}
else
{
USBLog(2, "AppleUSBEHCI[%p]::CheckSleepCapability EHCI controller will be unloaded across sleep",this);
_controllerCanSleep = false;
setProperty("Card Type","PCI");
}
}
else
{
setProperty("Card Type","Built-in");
}
if ( _onCardBus )
{
setProperty("Card Type","CardBus");
USBLog(1, "AppleUSBEHCI[%p]::CheckSleepCapability - i CANNOT sleep(CardBus)", this);
_controllerCanSleep = false;
}
_ExpressCardPort = ExpressCardPort(_device);
_badExpressCardAttached = false;
}
void
AppleUSBEHCI::ResumeUSBBus()
{
UInt8 numPorts;
int i;
bool enabledports = false;
if (USBToHostLong(_pEHCIRegisters->ConfigFlag) != kEHCIPortRoutingBit)
{
USBLog(5, "AppleUSBEHCI[%p]::ResumeUSBBus - restoring ConfigFlag[from 0x%x]", this, (unsigned int) USBToHostLong(_pEHCIRegisters->ConfigFlag));
_pEHCIRegisters->ConfigFlag = HostToUSBLong(kEHCIPortRoutingBit);
IOSync();
if (_errataBits & kErrataNECIncompleteWrite)
{
UInt32 newValue = 0, count = 0;
newValue = USBToHostLong(_pEHCIRegisters->ConfigFlag);
while ((count++ < 10) && (newValue != kEHCIPortRoutingBit))
{
USBError(1, "EHCI driver: ResumeUSBBus - ConfigFlag bit not sticking. Retrying.");
_pEHCIRegisters->ConfigFlag = HostToUSBLong(kEHCIPortRoutingBit);
IOSync();
newValue = USBToHostLong(_pEHCIRegisters->ConfigFlag);
}
}
}
_pEHCIRegisters->PeriodicListBase = _physPeriodicListBase;
IOSync();
if (_savedAsyncListAddr && (_pEHCIRegisters->AsyncListAddr != _savedAsyncListAddr))
{
USBLog(4, "AppleUSBEHCI[%p]::ResumeUSBBus - restoring AsyncListAddr[from 0x%x to 0x%x]", this, (unsigned int)USBToHostLong(_pEHCIRegisters->AsyncListAddr), (unsigned int)USBToHostLong(_savedAsyncListAddr));
_pEHCIRegisters->AsyncListAddr = _savedAsyncListAddr;
IOSync();
}
if (_is64bit)
_pEHCIRegisters->CTRLDSSegment = 0;
if (USBToHostLong(_savedUSBCMD) & kEHCICMDRunStop)
{
_pEHCIRegisters->USBCMD |= HostToUSBLong(kEHCICMDRunStop);
IOSync();
for (i=0; (i< 100) && (USBToHostLong(_pEHCIRegisters->USBSTS) & kEHCIHCHaltedBit); i++)
IODelay(100);
if (i>1)
{
USBError(1, "AppleUSBEHCI[%p]::ResumeUSBBus - controller took (%d) turns to get going", this, i);
}
}
numPorts = USBToHostLong(_pEHCICapRegisters->HCSParams) & kEHCINumPortsMask;
USBLog(7, "AppleUSBEHCI[%p]::ResumeUSBBus - resuming %d ports", this, numPorts);
for (i=0; i < numPorts; i++)
{
UInt32 portStat;
portStat = getPortSCForWriting(_pEHCIRegisters, i+1);
if (portStat & kEHCIPortSC_Owner)
{
USBLog(4, "AppleUSBEHCI[%p]::ResumeUSBBus - port %d owned by OHCI", this, i+1);
}
else if (portStat & kEHCIPortSC_Enabled)
{
if (_badExpressCardAttached && ((int)_ExpressCardPort == (i+1)))
{
portStat |= (kEHCIPortSC_WKCNNT_E|kEHCIPortSC_WKDSCNNT_E);
_pEHCIRegisters->PortSC[i] = USBToHostLong(portStat);
IOSync();
}
enabledports = true;
}
else
{
USBLog(7, "AppleUSBEHCI[%p]::ResumeUSBBus - port %d not enabled", this, i);
}
}
if (_savedUSBCMD)
{
USBLog(5, "AppleUSBEHCI[%p]::ResumeUSBBus - USBCMD is <%p> will be <%p>", this, (void*)_pEHCIRegisters->USBCMD, (void*)_savedUSBCMD);
_pEHCIRegisters->USBCMD = _savedUSBCMD;
}
}
void
AppleUSBEHCI::SuspendUSBBus()
{
UInt8 numPorts;
int i;
UInt32 usbcmd, usbsts;
_savedSuspendedPortBitmap = 0;
_savedUSBCMD = _pEHCIRegisters->USBCMD;
USBLog(7, "AppleUSBEHCI[%p]::SuspendUSBBus - got _savedUSBCMD <%p>", this, (void*)_savedUSBCMD);
usbcmd = USBToHostLong(_savedUSBCMD);
if (usbcmd & kEHCICMDAsyncEnable)
{
for (i=0; (i < 100) && !(USBToHostLong(_pEHCIRegisters->USBSTS) & kEHCISTSAsyncScheduleStatus); i++)
IODelay(100);
if (i)
{
USBError(1, "AppleUSBEHCI[%p]::SuspendUSBBus - Async Schedule should have been on but was off for %d loops", this, i);
}
usbcmd &= ~kEHCICMDAsyncEnable;
}
if (usbcmd & kEHCICMDPeriodicEnable)
{
for (i=0; (i < 100) && !(USBToHostLong(_pEHCIRegisters->USBSTS) & kEHCISTSPeriodicScheduleStatus); i++)
IODelay(100);
if (i)
{
USBError(1, "AppleUSBEHCI[%p]::SuspendUSBBus - Periodic Schedule should have been on but was off for %d loops", this, i);
}
usbcmd &= ~kEHCICMDPeriodicEnable;
}
_pEHCIRegisters->USBCMD = HostToUSBLong(usbcmd); IOSync();
for (i=0; (i < 100) && (USBToHostLong(_pEHCIRegisters->USBSTS) & kEHCISTSAsyncScheduleStatus); i++)
IODelay(1000);
if (i > 2)
{
USBError(1, "AppleUSBEHCI[%p]::SuspendUSBBus - Async Schedule took %d loops to turn off", this, i);
}
for (i=0; (i < 1000) && (USBToHostLong(_pEHCIRegisters->USBSTS) & kEHCISTSPeriodicScheduleStatus); i++)
IODelay(1000);
if (i > 2)
{
USBError(1, "AppleUSBEHCI[%p]::SuspendUSBBus - Periodic Schedule took %d loops to turn off CMD(%p) STS(%p)", this, i, (void*)USBToHostLong(_pEHCIRegisters->USBCMD), (void*)USBToHostLong(_pEHCIRegisters->USBSTS));
}
_savedAsyncListAddr = _pEHCIRegisters->AsyncListAddr;
GetNumberOfPorts( &numPorts );
USBLog(numPorts ? 4 : 1, "AppleUSBEHCI[%p]::SuspendUSBBus - suspending %d ports", this, numPorts);
for (i=0; i < numPorts; i++)
{
UInt32 portStat;
portStat = getPortSCForWriting(_pEHCIRegisters, i+1);
if (portStat & kEHCIPortSC_Owner)
{
USBLog(4, "AppleUSBEHCI[%p]::SuspendUSBBus - port %d owned by OHCI", this, i+1);
}
else if (portStat & kEHCIPortSC_Enabled)
{
if (_badExpressCardAttached && ((int)_ExpressCardPort == (i+1)))
{
portStat &= ~(kEHCIPortSC_WKCNNT_E|kEHCIPortSC_WKDSCNNT_E);
_pEHCIRegisters->PortSC[i] = USBToHostLong(portStat);
IOSync();
}
if (portStat & kEHCIPortSC_Suspend)
{
_savedSuspendedPortBitmap |= (1<<i);
USBLog(4, "AppleUSBEHCI[%p]::SuspendUSBBus - port %d was already suspended (as it should have been)", this, i+1);
}
else
{
USBError(1, "AppleUSBEHCI[%p]::SuspendUSBBus - port %d was NOT already suspended (as it should have been) PROBLEMS AHEAD", this, i+1);
}
}
else
{
USBLog(4, "AppleUSBEHCI[%p]::SuspendUSBBus - port %d not enabled", this, i+1);
}
}
usbcmd &= ~kEHCICMDRunStop;
_pEHCIRegisters->USBCMD = HostToUSBLong(usbcmd);
IOSync();
_myBusState = kUSBBusStateReset;
USBLog(5, "AppleUSBEHCI[%p]::SuspendUSBBus - ports suspended, HC stop set, waiting for halted - USBCMD(%p) USBSTS(%p)", this, (void*)USBToHostLong(_pEHCIRegisters->USBCMD), (void*)USBToHostLong(_pEHCIRegisters->USBSTS));
i=0;
do
{
if ((++i % 10000) == 0)
{
USBLog(1, "AppleUSBEHCI[%p]::SuspendUSBBus - HC not halting! USBCMD(%p) USBSTS(%p) i(%d)", this, (void*)USBToHostLong(_pEHCIRegisters->USBCMD), (void*)USBToHostLong(_pEHCIRegisters->USBSTS), (int)i);
}
usbsts = USBToHostLong(_pEHCIRegisters->USBSTS);
} while (!(usbsts & kEHCIHCHaltedBit));
USBLog(5, "AppleUSBEHCI[%p]::SuspendUSBBus - HC halted", this);
}
void
AppleUSBEHCI::StopUSBBus()
{
UInt32 usbcmd;
usbcmd = USBToHostLong(_pEHCIRegisters->USBCMD);
usbcmd &= ~kEHCICMDRunStop;
_pEHCIRegisters->USBCMD = HostToUSBLong(usbcmd);
_myBusState = kUSBBusStateReset;
USBLog(5, "AppleUSBEHCI[%p]::StopUSBBus - HC halted", this);
}
void
AppleUSBEHCI::RestartUSBBus()
{
UInt32 usbcmd, usbsts;
do
{
usbsts = USBToHostLong(_pEHCIRegisters->USBSTS);
} while (!(usbsts & kEHCIHCHaltedBit));
usbcmd = USBToHostLong(_pEHCIRegisters->USBCMD);
usbcmd |= kEHCICMDRunStop;
_pEHCIRegisters->USBCMD = HostToUSBLong(usbcmd);
_myBusState = kUSBBusStateRunning;
USBLog(5, "AppleUSBEHCI[%p]::RestartUSBBus - HC restarted", this);
}
static IOACPIPlatformDevice * CopyACPIDevice( IORegistryEntry * device )
{
IOACPIPlatformDevice * acpiDevice = 0;
OSString * acpiPath;
if (device)
{
acpiPath = (OSString *) device->copyProperty(kACPIDevicePathKey);
if (acpiPath && !OSDynamicCast(OSString, acpiPath))
{
acpiPath->release();
acpiPath = 0;
}
if (acpiPath)
{
IORegistryEntry * entry;
entry = IORegistryEntry::fromPath(acpiPath->getCStringNoCopy());
acpiPath->release();
if (entry && entry->metaCast("IOACPIPlatformDevice"))
acpiDevice = (IOACPIPlatformDevice *) entry;
else if (entry)
entry->release();
}
}
return (acpiDevice);
}
static bool HasExpressCardUSB( IORegistryEntry * acpiDevice, UInt32 * portnum )
{
const IORegistryPlane * acpiPlane;
bool match = false;
IORegistryIterator * iter;
IORegistryEntry * entry;
do {
acpiPlane = acpiDevice->getPlane( "IOACPIPlane" );
if (!acpiPlane)
break;
iter = IORegistryIterator::iterateOver(
acpiDevice,
acpiPlane,
kIORegistryIterateRecursively);
if (iter)
{
while (!match && (entry = iter->getNextObject()))
{
if ((entry->getChildEntry(acpiPlane) == 0) &&
entry->metaCast("IOACPIPlatformDevice"))
{
IOACPIPlatformDevice * port;
port = (IOACPIPlatformDevice *) entry;
if (port->validateObject( "_EJD" ) == kIOReturnSuccess)
{
if (portnum)
*portnum = strtoul(port->getLocation(), NULL, 10);
match = true;
}
}
}
iter->release();
}
}
while (false);
return match;
}
UInt32
AppleUSBEHCI::ExpressCardPort( IOService * provider )
{
IOACPIPlatformDevice * acpiDevice;
UInt32 portNum = 0;
bool isPCIeUSB;
acpiDevice = CopyACPIDevice( provider );
if (acpiDevice)
{
isPCIeUSB = HasExpressCardUSB( acpiDevice, &portNum );
acpiDevice->release();
}
return(portNum);
}
IOReturn
AppleUSBEHCI::powerStateDidChangeTo ( IOPMPowerFlags capabilities, unsigned long stateNumber, IOService* whatDevice)
{
USBLog(5, "AppleUSBEHCI[%p]::powerStateDidChangeTo - stateNumber(%d)", this, (int)stateNumber);
if ((_myPowerState == kUSBPowerStateSleep) && (stateNumber == kUSBPowerStateLowPower))
{
_savedUSBIntr = _savedUSBIntr | HostToUSBLong(kEHCIPortChangeIntBit);
USBLog(5, "AppleUSBEHCI[%p]::powerStateDidChangeTo - added port change bit to _savedUSBIntr - now (%p)", this, (void*)_savedUSBIntr);
}
return super::powerStateDidChangeTo(capabilities, stateNumber, whatDevice);
}
IOReturn
AppleUSBEHCI::SaveControllerStateForSleep(void)
{
showRegisters(7, "+SaveControllerStateForSleep");
USBLog(5, "AppleUSBEHCI[%p]::SaveControllerStateForSleep - suspending the bus", this);
if (_myBusState < kUSBBusStateRunning)
{
USBLog(5, "AppleUSBEHCI[%p]::SaveControllerStateForSleep - _myBusState < kUSBBusStateRunning - restarting USB before suspending", this);
RestartUSBBus();
}
USBLog(7, "AppleUSBEHCI[%p]::SaveControllerStateForSleep - about to suspend bus - showing queue", this);
printAsyncQueue(7, "SaveControllerStateForSleep");
SuspendUSBBus();
USBLog(7, "AppleUSBEHCI[%p]::SaveControllerStateForSleep The bus is now suspended - showing queue", this);
printAsyncQueue(7, "SaveControllerStateForSleep");
_myBusState = kUSBBusStateSuspended;
showRegisters(7, "-SaveControllerStateForSleep");
return kIOReturnSuccess;
}
IOReturn
AppleUSBEHCI::RestoreControllerStateFromSleep(void)
{
USBLog(5, "AppleUSBEHCI[%p]::RestoreControllerStateFromSleep - setPowerState powering on USB", this);
showRegisters(7, "+RestoreControllerStateFromSleep");
if (USBToHostLong(_pEHCIRegisters->USBSTS) & kEHCIPortChangeIntBit)
{
UInt32 port, numPorts;
IOLog("\nUSB caused wake event (EHCI)\n");
kprintf("\nUSB caused wake event (EHCI)\n");
}
USBLog(7, "AppleUSBEHCI[%p]::RestoreControllerStateFromSleep - about to resume bus - showing queue", this);
printAsyncQueue(7, "RestoreControllerStateFromSleep");
ResumeUSBBus();
USBLog(7, "AppleUSBEHCI[%p]::RestoreControllerStateFromSleep - bus has been resumed - showing queue", this);
printAsyncQueue(7, "RestoreControllerStateFromSleep");
_myBusState = kUSBBusStateRunning;
showRegisters(7, "-RestoreControllerStateFromSleep");
return kIOReturnSuccess;
}
IOReturn
AppleUSBEHCI::ResetControllerState(void)
{
int i;
USBLog(5, "AppleUSBEHCI[%p]::ResetControllerState - powering down USB - _pEHCIRegisters(%p) _pEHCICapRegisters(%p) PCIConfigCommand(%p)", this, _pEHCIRegisters, _pEHCICapRegisters, (void*)_device->configRead16(kIOPCIConfigCommand));
showRegisters(2, "+ResetControllerState");
_pEHCIRegisters->USBCMD = 0; IOSync();
_myBusState = kUSBBusStateReset;
for (i=0; (i < 100) && !(USBToHostLong(_pEHCIRegisters->USBSTS) & kEHCIHCHaltedBit); i++)
IOSleep(1);
if (i >= 100)
{
USBError(1, "AppleUSBEHCI[%p]::ResetControllerState - could not get chip to halt within 100 ms", this);
return kIOReturnInternalError;
}
if (_pEHCIRegisters->AsyncListAddr)
{
_savedAsyncListAddr = _pEHCIRegisters->AsyncListAddr;
USBLog(5, "AppleUSBEHCI[%p]::ResetControllerState - got _savedAsyncListAddr(%p)", this, (void*)_savedAsyncListAddr);
}
_pEHCIRegisters->PeriodicListBase = 0; _pEHCIRegisters->AsyncListAddr = 0; IOSync();
showRegisters(2, "-ResetControllerState");
return kIOReturnSuccess;
}
IOReturn
AppleUSBEHCI::RestartControllerFromReset(void)
{
int i;
UInt32 USBCmd;
USBLog(5, "AppleUSBEHCI[%p]::RestartControllerFromReset - restarting USB _uimInitialized(%s) _savedAsyncListAddr(%p)", this, _uimInitialized ? "yes" : "no", (void*)_savedAsyncListAddr);
_pEHCIRegisters->USBCMD = HostToUSBLong(kEHCICMDHCReset);
IOSync();
for ( i = 0; (i < 100) && (USBToHostLong(_pEHCIRegisters->USBCMD) & kEHCICMDHCReset); i++ )
IOSleep(1);
if ( i >= 100 )
{
USBError(1, "AppleUSBEHCI[%p]::RestartControllerFromReset - could not get chip to come out of reset within 100 ms", this);
return kIOReturnInternalError;
}
_pEHCIRegisters->PeriodicListBase = _physPeriodicListBase;
IOSync();
if (_pEHCIRegisters->AsyncListAddr != _savedAsyncListAddr)
{
USBLog(5, "AppleUSBEHCI[%p]::RestartControllerFromReset - restoring AsyncListAddr[from 0x%lx to 0x%lx]", this, _pEHCIRegisters->AsyncListAddr, _savedAsyncListAddr);
_pEHCIRegisters->AsyncListAddr = _savedAsyncListAddr;
IOSync();
}
USBCmd = USBToHostLong(_pEHCIRegisters->USBCMD);
_frameListSize = (USBCmd & kEHCICMDFrameListSizeMask) >> kEHCICMDFrameListSizeOffset;
if (_frameListSize)
{
USBError(1, "AppleUSBEHCI[%p]::RestartControllerFromReset - bad _frameListSize", this);
return kIOReturnInternalError;
}
_frameListSize = 1024;
USBCmd |= kEHCICMDRunStop;
_myBusState = kUSBBusStateRunning;
USBCmd &= ~kEHCICMDIntThresholdMask;
USBCmd |= 1 << kEHCICMDIntThresholdOffset; _pEHCIRegisters->USBCMD = HostToUSBLong(USBCmd);
_pEHCIRegisters->ConfigFlag = HostToUSBLong(kEHCIPortRoutingBit); IOSync();
if (_errataBits & kErrataNECIncompleteWrite)
{
UInt32 newValue = 0, count = 0;
newValue = USBToHostLong(_pEHCIRegisters->ConfigFlag);
while ((count++ < 10) && (newValue != kEHCIPortRoutingBit))
{
USBError(1, "EHCI driver: RestartControllerFromReset - ConfigFlag bit not sticking. Retrying.");
_pEHCIRegisters->ConfigFlag = HostToUSBLong(kEHCIPortRoutingBit);
IOSync();
newValue = USBToHostLong(_pEHCIRegisters->ConfigFlag);
}
}
_savedUSBIntr = HostToUSBLong(kEHCICompleteIntBit | kEHCIErrorIntBit | kEHCIHostErrorIntBit | kEHCIFrListRolloverIntBit | kEHCIPortChangeIntBit);
_isochBandwidthAvail = 5 *1024;
_outSlot = kEHCIPeriodicListEntries+1;
_frameNumber = 0;
return kIOReturnSuccess;
}
IOReturn
AppleUSBEHCI::DozeController(void)
{
DisableAsyncSchedule(true);
DisablePeriodicSchedule(true);
StopUSBBus();
if (_myPowerState == kUSBPowerStateOn)
{
_pEHCIRegisters->USBIntr = _pEHCIRegisters->USBIntr | HostToUSBLong(kEHCIPortChangeIntBit);
IOSync();
}
return kIOReturnSuccess;
}
IOReturn
AppleUSBEHCI::WakeControllerFromDoze(void)
{
RestartUSBBus();
return kIOReturnSuccess;
}
IOReturn
AppleUSBEHCI::EnableInterruptsFromController(bool enable)
{
if (enable)
{
USBLog(5, "AppleUSBEHCI[%p]::EnableInterruptsFromController - enabling interrupts, USBIntr(%p) _savedUSBIntr(%p)", this, (void*)_pEHCIRegisters->USBIntr, (void*)HostToUSBLong(_savedUSBIntr));
_pEHCIRegisters->USBIntr = _savedUSBIntr;
IOSync();
_savedUSBIntr = 0;
}
else
{
_savedUSBIntr = _pEHCIRegisters->USBIntr; _pEHCIRegisters->USBIntr = HostToUSBLong(kEHCIFrListRolloverIntBit); IOSync();
USBLog(5, "AppleUSBEHCI[%p]::EnableInterruptsFromController - interrupts disabled, _savedUSBIntr(%p)", this, (void*)_savedUSBIntr);
}
return kIOReturnSuccess;
}
void
AppleUSBEHCI::powerChangeDone ( unsigned long fromState)
{
unsigned long newState = getPowerState();
USBLog((fromState == newState) ? 7 : 4, "AppleUSBEHCI[%p]::powerChangeDone from state (%d) to state (%d) _controllerAvailable(%s)", this, (int)fromState, (int)newState, _controllerAvailable ? "true" : "false");
if (_wakingFromHibernation)
{
USBLog(2, "AppleUSBEHCI[%p]::powerChangeDone - _wakingFromHibernation - _savedAsyncListAddr(%p) AsyncListAddr(%p)", this, (void*)USBToHostLong(_savedAsyncListAddr), (void*)_pEHCIRegisters->AsyncListAddr);
_savedAsyncListAddr = _pEHCIRegisters->AsyncListAddr;
}
if (_controllerAvailable)
showRegisters(7, "powerChangeDone");
super::powerChangeDone(fromState);
}