IOReturn SPFramebuffer::enableController() {
IOLog("SPFramebuffer::enableController()\n");
// configure power management
powerState = kUBWakeState;
IOPMPowerState powerStates [] = {
{kIOPMPowerStateVersion1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // kUBSleepState
{kIOPMPowerStateVersion1, 0, 0, IOPMPowerOn, 0, 0, 0, 0, 0, 0, 0, 0}, // kUBDozeState
{kIOPMPowerStateVersion1, IOPMDeviceUsable, IOPMPowerOn, IOPMPowerOn, 0, 0, 0, 0, 0, 0, 0, 0} // kUBWakeState
};
registerPowerDriver(this, powerStates, 3);
temporaryPowerClampOn();
changePowerStateTo(kUBWakeState);
getProvider()->setProperty(kIOPMIsPowerManagedKey, true);
// configure framebuffer
IOReturn ret;
if ((ret = calculateFramebufferSize(currentMode, &maximumSize))) return ret;
IOLog("%s: attempting to allocate %d bytes\n", getMetaClass()->getClassName(), maximumSize);
buffer = IOBufferMemoryDescriptor::withCapacity(maximumSize, kIODirectionInOut);
if (!buffer) {
IOLog("%s: error allocating memory: %d bytes\n", getMetaClass()->getClassName(), maximumSize);
return KERN_FAILURE;
}
return kIOReturnSuccess;
}
/*!
@method enableController
@abstract Perform first time setup of the framebuffer.
@discussion IOFramebuffer subclasses should perform their
initialization of the hardware here. The
IOService start() method is not called at a
time appropriate for this initialization.
@param <#name#> <#description#>
@result <#description#>
*/
IOReturn
com_doequalsglory_driver_IOProxyFramebuffer::enableController(void) {
#if defined(DEBUG_CALLS)
IOLog(kDebugStr "enableController()\n");
#endif
// set up initial display mode. should setDisplayMode do the
// framebuffer memory allocation? I think so
IODisplayModeID initialDisplayMode;
IOIndex initialDepth;
getStartupDisplayMode(&initialDisplayMode, &initialDepth);
setDisplayMode(initialDisplayMode, initialDepth);
// set up power management
fPowerState = kDFBWakeState;
IOPMPowerState powerStates [] = {
{kIOPMPowerStateVersion1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // kDFBSleepState
{kIOPMPowerStateVersion1, 0, 0, IOPMPowerOn, 0, 0, 0, 0, 0, 0, 0, 0 }, // kDFBDozeState
{kIOPMPowerStateVersion1, IOPMDeviceUsable, IOPMPowerOn, IOPMPowerOn, 0, 0, 0, 0, 0, 0, 0, 0 } // kDFBWakeState
};
registerPowerDriver(this, powerStates, 3);
temporaryPowerClampOn();
changePowerStateTo(kDFBDozeState);
getProvider()->setProperty(kIOPMIsPowerManagedKey, true);
// we only allocate memory at enableController time instead of at
// setDisplayMode, so make sure we have enough to handle whatever sized
// display modes we might want to switch to
fBuffer = IOBufferMemoryDescriptor::withCapacity(getApertureSize(kLargestDisplayMode, kDepth32Bit), kIODirectionInOut);
return kIOReturnSuccess;
}
bool info_ennowelbers_proxyframebuffer_driver::start(IOService *provider)
{
bool res=super::start(provider);
if(res)
{
//in order to get a framebuffer up and working, we need to correctly configure powermanagement.
//we're setting up three power states: off, on and usable.
PMinit();
getProvider()->joinPMtree(this);
static IOPMPowerState myPowerStates[3];
myPowerStates[0].version=1;
myPowerStates[0].capabilityFlags=0;
myPowerStates[0].outputPowerCharacter=0;
myPowerStates[0].inputPowerRequirement=0;
myPowerStates[1].version=1;
myPowerStates[1].capabilityFlags=0;
myPowerStates[1].outputPowerCharacter=0;
myPowerStates[1].inputPowerRequirement=IOPMPowerOn;
myPowerStates[2].version=1;
myPowerStates[2].capabilityFlags=IOPMDeviceUsable;
myPowerStates[2].outputPowerCharacter=IOPMPowerOn;
myPowerStates[2].inputPowerRequirement=IOPMPowerOn;
registerPowerDriver(this, myPowerStates, 3);
//and we're switching to power state USABLE
changePowerStateTo(2);
//you need to to this AFTER setting power configuration.
//at least that's what i recall
registerService();
IOLog("EWProxyFrameBuffer: start with maximum resolution %dx%d\n",getMaxWidth(),getMaxHeight());
if(shouldInitFB())
{
IOLog("EWProxyFrameBuffer: Initializing Framebuffer. Unload from this point is impossible.\n");
initFB();
}
else
{
IOLog("EWProxyFrameBuffer: Framebuffer initialization deactivated.\n");
}
//StartFramebuffer(640, 480);
}
//IOLog("Starting\n");
return res;
}
void
IOI2CDevice::freeI2CResources(void)
{
if (fStateFlags & kStateFlags_TEARDOWN)
return;
fStateFlags |= kStateFlags_TEARDOWN;
DLOG("+IOI2CDevice@%lx::freeI2CResources %x\n",fI2CAddress, fStateFlags);
#ifdef kUSE_IOLOCK
if(fClientLock)
#else
if(fClientSem)
#endif
I2CLOCK;
fDeviceOffline = TRUE;
#ifdef kUSE_IOLOCK
if(fClientLock)
#else
if(fClientSem)
#endif
I2CUNLOCK;
DLOG("+IOI2CDevice@%lx::freeI2CResources\n",fI2CAddress);
if (fStateFlags & kStateFlags_PMInit) // Don't rely on initialized flag to identify if PMinit was called.
{
DLOGPWR("+IOI2CDevice@%lx::freeI2CResources requesting power OFF\n",fI2CAddress);
changePowerStateTo(kIOI2CPowerState_OFF);
AbsoluteTime deadline, currentTime;
clock_interval_to_deadline(20, kSecondScale, &deadline);
while (fCurrentPowerState != kIOI2CPowerState_OFF)
{
IOSleep(10);
clock_get_uptime(¤tTime);
if ( CMP_ABSOLUTETIME(¤tTime, &deadline) > 0 )
{
ERRLOG("IOI2CDevice@%lx::freeI2CResources timed out waiting to power off\n", fI2CAddress);
break;
}
}
DLOGPWR("+IOI2CDevice@%lx::freeI2CResources calling PMStop\n",fI2CAddress);
if (fStateFlags & kStateFlags_PMInit)
{
fStateFlags &= ~kStateFlags_PMInit;
PMstop();
}
}
DLOG("IOI2CDevice@%lx::freeI2CResources 1\n",fI2CAddress);
if (fPowerStateThreadCall)
{
thread_call_cancel(fPowerStateThreadCall);
thread_call_free(fPowerStateThreadCall);
fPowerStateThreadCall = 0;
}
if (fProvider)
fProvider->callPlatformFunction("IOI2CPowerStateInterest", FALSE, (void *)this, (void *)false, 0, 0);
DLOG("IOI2CDevice@%lx::freeI2CResources 2\n",fI2CAddress);
if (symLockI2CBus) { symLockI2CBus->release(); symLockI2CBus = 0; }
if (symUnlockI2CBus) { symUnlockI2CBus->release(); symUnlockI2CBus = 0; }
if (symWriteI2CBus) { symWriteI2CBus->release(); symWriteI2CBus = 0; }
if (symReadI2CBus) { symReadI2CBus->release(); symReadI2CBus = 0; }
DLOG("IOI2CDevice@%lx::freeI2CResources 3\n",fI2CAddress);
#ifdef kUSE_IOLOCK
if (fClientLock) { IOLockFree(fClientLock); fClientLock = 0; }
#else
if (fClientSem) { semaphore_destroy(current_task(), fClientSem); fClientSem = 0; }
#endif
DLOG("IOI2CDevice@%lx::freeI2CResources 4\n",fI2CAddress);
if (reserved)
{
if (symClientRead) { symClientRead->release(); symClientRead = 0; }
if (symClientWrite) { symClientWrite->release(); symClientWrite = 0; }
if (symPowerInterest) { symPowerInterest->release(); symPowerInterest = 0; }
}
DLOG("-IOI2CDevice@%lx::freeI2CResources\n",fI2CAddress);
}
