void IOPMPagingPlexus::processChildren ( void ) { OSIterator * childIterator; IOPowerConnection * nextChildNub; IORegistryEntry * nextChild; IOService * child; unsigned int i; childIterator = getChildIterator(gIOPowerPlane); if ( childIterator ) { while ( (nextChild = (IORegistryEntry *)(childIterator->getNextObject())) ) { if ( (nextChildNub = OSDynamicCast(IOPowerConnection,nextChild)) ) { child = (IOService *)nextChild->getChildEntry(gIOPowerPlane); if ( child->pm_vars->theControllingDriver ) { for ( i = 1; i < child->pm_vars->theNumberOfPowerStates; i++ ) { child->pm_vars->thePowerStates[i].inputPowerRequirement |= IOPMPagingAvailable; } } if ( child->pm_vars->myCurrentState ) { nextChildNub->setDesiredDomainState(kIOPlexusPowerStateCount-1); } } } childIterator->release(); } }
bool net_lundman_zfs_zvol::start (IOService *provider) { bool res = super::start(provider); IOLog("ZFS: Loading module ... \n"); /* * Initialize /dev/zfs, this calls spa_init->dmu_init->arc_init-> etc */ zfs_ioctl_osx_init(); ///sysctl_register_oid(&sysctl__debug_maczfs); //sysctl_register_oid(&sysctl__debug_maczfs_stalk); zfs_vfsops_init(); /* * When is the best time to start the system_taskq? It is strictly * speaking not used by SPL, but by ZFS. ZFS should really start it? */ system_taskq_init(); /* * hostid is left as 0 on OSX, and left to be set if developers wish to * use it. If it is 0, we will hash the hardware.uuid into a 32 bit * value and set the hostid. */ if (!zone_get_hostid(NULL)) { uint32_t myhostid = 0; IORegistryEntry *ioregroot = IORegistryEntry::getRegistryRoot(); if(ioregroot) { //IOLog("ioregroot is '%s'\n", ioregroot->getName(gIOServicePlane)); IORegistryEntry *macmodel = ioregroot->getChildEntry(gIOServicePlane); if(macmodel) { //IOLog("macmodel is '%s'\n", macmodel->getName(gIOServicePlane)); OSObject *ioplatformuuidobj; //ioplatformuuidobj = ioregroot->getProperty("IOPlatformUUID", gIOServicePlane, kIORegistryIterateRecursively); ioplatformuuidobj = macmodel->getProperty(kIOPlatformUUIDKey); if(ioplatformuuidobj) { OSString *ioplatformuuidstr = OSDynamicCast(OSString, ioplatformuuidobj); //IOLog("IOPlatformUUID is '%s'\n", ioplatformuuidstr->getCStringNoCopy()); myhostid = fnv_32a_str(ioplatformuuidstr->getCStringNoCopy(), FNV1_32A_INIT); sysctlbyname("kern.hostid", NULL, NULL, &myhostid, sizeof(myhostid)); printf("ZFS: hostid set to %08x from UUID '%s'\n", myhostid, ioplatformuuidstr->getCStringNoCopy()); } } } } return res; }
void IOPMPagingPlexus::processSiblings ( IOService * aNode ) { OSIterator * parentIterator; IORegistryEntry * nextNub; IORegistryEntry * nextParent; OSIterator * siblingIterator; IORegistryEntry * nextSibling; parentIterator = aNode->getParentIterator(gIOPowerPlane); // iterate parents of this node if ( parentIterator ) { while ( true ) { if ( ! (nextNub = (IORegistryEntry *)(parentIterator->getNextObject())) ) { parentIterator->release(); break; } if ( OSDynamicCast(IOPowerConnection,nextNub) ) { nextParent = nextNub->getParentEntry(gIOPowerPlane); if ( nextParent == getPMRootDomain() ) { continue; // plexus already has root's children } if ( nextParent == this ) { parentIterator->release(); removePowerChild((IOPowerConnection *)nextNub); break; } siblingIterator = nextParent->getChildIterator(gIOPowerPlane); // iterate children of this parent if ( siblingIterator ) { while ( (nextSibling = (IORegistryEntry *)(siblingIterator->getNextObject())) ) { if ( OSDynamicCast(IOPowerConnection,nextSibling) ) { nextSibling = nextSibling->getChildEntry(gIOPowerPlane); if ( nextSibling != aNode ) { // non-ancestor of driver gets addPowerChild((IOService *)nextSibling); // plexus as parent } } } siblingIterator->release(); } processSiblings((IOService *)nextParent); // do the same thing to this parent } } } }
bool createPStateTable(PState* pS, unsigned int* numStates) { checkForPenryn(); // early on, so we can display proper mV values /* If the PState table was specified manually, we dont do the rest. Otherwise autodetect */ if (NumberOfPStates != 0) { dbg("PState table was already created. No autodetection will be performed\n"); return true; } /* Find CPUs in the IODeviceTree plane */ IORegistryEntry* ioreg = IORegistryEntry::fromPath("/cpus", IORegistryEntry::getPlane("IODeviceTree")); if (ioreg == 0) { warn("Holy moly we cannot find your CPU!\n"); return false; } /* Get the first CPU - we assume all CPUs share the same P-State */ IOACPIPlatformDevice* cpu = (IOACPIPlatformDevice*) ioreg->getChildEntry(IORegistryEntry::getPlane("IODeviceTree")); if (cpu == 0) { warn("Um you don't seem to have a CPU o.O\n"); ioreg = 0; return false; } dbg("Using data from %s\n", cpu->getName()); /* Now try to find the performance state table */ OSObject* PSS; cpu->evaluateObject("_PSS", &PSS); if(PSS == 0 ) { warn("Auto-creating a PState table.\n"); int maxFID = MHz_to_FID(getCurrentFrequency()); int maxVID = mV_to_VID(getCurrentVoltage()); int minVID = mV_to_VID(800); // For now we'll use hardcoded minvolt, later use table int minFID = 6; // No LFM right now NumberOfPStates = 1 + ((maxFID - minFID) / 2); for (int i = 1; i < NumberOfPStates; i++) { PStates[i].Frequency = minFID + (2*(NumberOfPStates - i - 1)); PStates[i].AcpiFreq = FID_to_MHz(PStates[i].Frequency); PStates[i].OriginalVoltage = maxVID - (i*((maxVID - minVID) / NumberOfPStates)) ; PStates[i].Voltage = PStates[i].OriginalVoltage; PStates[i].Latency = 110; PStates[i].TimesChosen = 0; } PStates[0].Frequency = maxFID; PStates[0].AcpiFreq = FID_to_MHz(maxFID); PStates[0].OriginalVoltage = maxVID; PStates[0].Voltage = PStates[0].OriginalVoltage; PStates[0].Latency = 110; PStates[0].TimesChosen = 0; MaxLatency = PStates[0].Latency; info("Using %d PStates (auto-created, may not be optimal).\n", NumberOfPStates); ioreg = 0; cpu = 0; return true; } OSArray* PSSArray = (OSArray*) PSS; NumberOfPStates = PSSArray->getCount(); info("Found %d P-States\n", NumberOfPStates); OSArray* onestate; uint16_t ctl, acpifreq; uint32_t power, latency; int i = 0, c = 0; while (c < PSSArray->getCount()) { onestate = ( OSArray* )(PSSArray->getObject(c)); ctl = ((OSNumber*) onestate->getObject(4))->unsigned32BitValue(); acpifreq = ((OSNumber*) onestate->getObject(0))->unsigned32BitValue(); power = ((OSNumber*) onestate->getObject(1))->unsigned32BitValue(); latency = ((OSNumber*) onestate->getObject(2))->unsigned32BitValue(); c++; info("clt: 0x%x , vid: %d , fid: %d \n", ctl , VID(ctl), FID(ctl) ); if (acpifreq - (10 * (acpifreq / 10)) == 1) { // most likely spurious, so skip it warn("** Spurious P-State %d: %d MHz at %d mV, consuming %d W, latency %d usec\n", i, acpifreq, VID_to_mV(ctl), power / 1000, latency); NumberOfPStates--; continue; } if (acpifreq < 1000 && !Below1Ghz) { warn("%d MHz disabled because your processor or kernel doesn't support it.\n",acpifreq); NumberOfPStates--; continue; } PStates[i].AcpiFreq = acpifreq; // cosmetic only PStates[i].Frequency = FID(ctl); PStates[i].OriginalVoltage = VID(ctl); PStates[i].Voltage = PStates[i].OriginalVoltage *50 / 100; // initially same PStates[i].Latency = latency; PStates[i].TimesChosen = 0; if (latency > MaxLatency) MaxLatency = latency; info("Auto: P-State %d: %d MHz at %d mV VID: %d, consuming %d W, latency %d usec\n", i, PStates[i].AcpiFreq, VID_to_mV(PStates[i].Voltage),PStates[i].Voltage, power / 1000, latency); i++; } info("Using %d PStates.\n", NumberOfPStates); ioreg = 0; cpu = 0; PSS = 0; onestate = 0; return true; }