bool FakeSMCPlugin::start(IOService *provider) { if (!super::start(provider)) return false; if (!(headingProvider = waitForService(serviceMatching(kFakeSMCService)))) HWSensorsWarningLog("failed to locate FakeSMC service, specific OEM configurations will be unavailable"); if (!(storageProvider = waitForService(serviceMatching(kFakeSMCDeviceService)))) { HWSensorsFatalLog("failed to locate FakeSMCDevice"); return false; } return true; }
void IOPlatformExpert::setCPUInterruptProperties(IOService *service) { IOCPUInterruptController *controller; controller = OSDynamicCast(IOCPUInterruptController, waitForService(serviceMatching("IOCPUInterruptController"))); if (controller) controller->setCPUInterruptProperties(service); }
bool SuperIODevice::start(IOService *provider) { if (!super::start(provider)) return false; // Gigabyte mobos usualy use ITE if (IOService *headingProvider = waitForService(serviceMatching(kFakeSMCService))) { if (OSString *manufacturer = OSDynamicCast(OSString, headingProvider->getProperty(kOEMInfoManufacturer))) { if (manufacturer->isEqualTo("Gigabyte")) { if (!detectITEFamilyChip()) { UInt16 ite_id = id; if (!detectWinbondFamilyChip()) { HWSensorsFatalLog("found unsupported chip! ITE sequence ID=0x%x, Winbond sequence ID=0x%x", ite_id, id); return false; } } } } } // Other vendors usualy use Winbond family chipsets if (model == 0) { if (!detectWinbondFamilyChip()) { UInt16 wnbnd_id = id; if (!detectITEFamilyChip()) { HWSensorsFatalLog("found unsupported chip! ITE sequence ID=0x%x, Winbond sequence ID=0x%x", id, wnbnd_id); return false; } } } HWSensorsInfoLog("found %s %s on port=0x%x address=0x%x", vendor, superio_get_model_name(model), port, address); char string[128]; snprintf(string, sizeof(string), "%s,%s", vendor, superio_get_model_name(model)); setName(string); //setProperty("name", &string, (UInt32)strlen(string) + 1); setProperty(kSuperIOHWMAddress, address, 16); setProperty(kSuperIOControlPort, port, 8); setProperty(kSuperIOModelValue, model, 16); setProperty(kSuperIOModelName, superio_get_model_name(model)); setProperty(kSuperIOVendorName, vendor); setProperty(kSuperIODeviceID, OSData::withBytes(&id, sizeof(id))); registerService(); return true; }
bool FakeSMCPlugin::start(IOService *provider) { if (!super::start(provider)) return false; if (!(fakeSMC = waitForService(serviceMatching(kFakeSMCDeviceService)))) { HWSensorsWarningLog("can't locate FakeSMCDevice"); return false; } return true; }
bool SuperIOMonitor::start(IOService *provider) { DebugLog("starting..."); if (!super::start(provider)) return false; if (!(fakeSMC = waitForService(serviceMatching(kFakeSMCDeviceService)))) { WarningLog("can't locate fake SMC device, kext will not load"); return false; } return true; }
bool FakeSMCPlugin::start(IOService *provider) { DebugLog("Starting..."); if (!super::start(provider)) return false; if (!(fakeSMC = waitForService(serviceMatching(kFakeSMCDeviceService)))) { WarningLog("Can't locate fake SMC device!"); return false; } return true; }
IOReturn IOPlatformExpert::callPlatformFunction(const OSSymbol *functionName, bool waitForFunction, void *param1, void *param2, void *param3, void *param4) { IOService *service, *_resources; if (waitForFunction) { _resources = waitForService(resourceMatching(functionName)); } else { _resources = resources(); } if (_resources == 0) return kIOReturnUnsupported; service = OSDynamicCast(IOService, _resources->getProperty(functionName)); if (service == 0) return kIOReturnUnsupported; return service->callPlatformFunction(functionName, waitForFunction, param1, param2, param3, param4); }
bool X3100monitor::start(IOService * provider) { if (!provider || !super::start(provider)) return false; if (!(fakeSMC = waitForService(serviceMatching(kFakeSMCDeviceService)))) { WarningLog("Can't locate fake SMC device, kext will not load"); return false; } IOMemoryDescriptor * theDescriptor; IOPhysicalAddress bar = (IOPhysicalAddress)((VCard->configRead32(kMCHBAR)) & ~0xf); DebugLog("Fx3100: register space=%08lx\n", (long unsigned int)bar); theDescriptor = IOMemoryDescriptor::withPhysicalAddress (bar, 0x2000, kIODirectionOutIn); // | kIOMapInhibitCache); if(theDescriptor != NULL) { mmio = theDescriptor->map(); if(mmio != NULL) { mmio_base = (volatile UInt8 *)mmio->getVirtualAddress(); #if DEBUG DebugLog(" MCHBAR mapped\n"); for (int i=0; i<0x2f; i +=16) { DebugLog("%04lx: ", (long unsigned int)i+0x1000); for (int j=0; j<16; j += 1) { DebugLog("%02lx ", (long unsigned int)INVID8(i+j+0x1000)); } DebugLog("\n"); } #endif } else { InfoLog(" MCHBAR failed to map\n"); return -1; } } char name[5]; //try to find empty key for (int i = 0; i < 0x10; i++) { snprintf(name, 5, KEY_FORMAT_GPU_DIODE_TEMPERATURE, i); UInt8 length = 0; void * data = 0; IOReturn result = fakeSMC->callPlatformFunction(kFakeSMCGetKeyValue, true, (void *)name, (void *)&length, (void *)&data, 0); if (kIOReturnSuccess == result) { continue; } if (addSensor(name, TYPE_SP78, 2, i)) { numCard = i; break; } } if (kIOReturnSuccess != fakeSMC->callPlatformFunction(kFakeSMCAddKeyHandler, false, (void *)name, (void *)TYPE_SP78, (void *)2, this)) { WarningLog("Can't add key to fake SMC device, kext will not load"); return false; } return true; }
bool ACPIBacklightPanel::start( IOService * provider ) { DbgLog("%s::%s()\n", this->getName(),__FUNCTION__); #if 0 if (!provider) return false; _provider = provider; _provider->retain(); #endif _lock = IORecursiveLockAlloc(); if (!_lock) return false; findDevices(provider); getDeviceControl(); hasSaveMethod = hasSAVEMethod(backLightDevice); min = 0; max = setupIndexedLevels(); if (min == max) { IOLog("ACPIBacklight: setupIndexedLevels failed (min==max)... aborting"); return false; } // add interrupt source for delayed actions... _workSource = IOInterruptEventSource::interruptEventSource(this, OSMemberFunctionCast(IOInterruptEventAction, this, &ACPIBacklightPanel::processWorkQueue)); if (!_workSource) return false; IOWorkLoop* workLoop = getWorkLoop(); if (!workLoop) { _workSource->release(); _workSource = NULL; return false; } workLoop->addEventSource(_workSource); _workPending = 0; // add timer for smooth fade ins if (_extended && !(_options & kDisableSmooth)) { _smoothTimer = IOTimerEventSource::timerEventSource(this, OSMemberFunctionCast(IOTimerEventSource::Action, this, &ACPIBacklightPanel::onSmoothTimer)); if (_smoothTimer) workLoop->addEventSource(_smoothTimer); } _cmdGate = IOCommandGate::commandGate(this); if (_cmdGate) workLoop->addEventSource(_cmdGate); // initialize from properties OSDictionary* dict = getPropertyTable(); setPropertiesGated(dict); // write current values from smoothData for (int i = 0; i < countof(smoothData); i++) { char buf[kSmoothBufSize]; snprintf(buf, sizeof(buf), kSmoothDelta, i); setProperty(buf, smoothData[i].delta, 32); snprintf(buf, sizeof(buf), kSmoothStep, i); setProperty(buf, smoothData[i].step, 32); snprintf(buf, sizeof(buf), kSmoothTimeout, i); setProperty(buf, smoothData[i].timeout, 32); } #ifdef DEBUG setProperty("CycleTest", 1, 32); setProperty("KLVX", 1, 32); #endif // make the service available for clients like 'ioio'... registerService(); // load and set default brightness level UInt32 value = loadFromNVRAM(); DbgLog("%s: loadFromNVRAM returns %d\n", this->getName(), value); // registerService above must be called before we wait for the BacklightHandler if (useBacklightHandler()) { DbgLog("%s: Waiting for BacklightHandler\n", this->getName()); waitForService(serviceMatching("BacklightHandler")); } // after backlight handler is in place, now we can manipulate backlight level UInt32 current = queryACPICurentBrightnessLevel(); setProperty(kRawBrightness, current, 32); #if 0 _provider->setProperty("AppleBacklightAtBoot", current, 32); _provider->setProperty("AppleMaxBrightness", BCLlevels[BCLlevelsCount-1], 32); #endif _committed_value = _value = _from_value = levelForValue(current); DbgLog("%s: current brightness: %d (%d)\n", this->getName(), _from_value, current); if (-1 != value) { _committed_value = value; DbgLog("%s: setting to value from nvram %d\n", this->getName(), value); setBrightnessLevelSmooth(value); } _saved_value = _committed_value; DbgLog("%s: min = %u, max = %u\n", this->getName(), min, max); // announce version extern kmod_info_t kmod_info; IOLog("ACPIBacklight: Version %s starting on OS X Darwin %d.%d.\n", kmod_info.version, version_major, version_minor); // place version/build info in ioreg properties RM,Build and RM,Version char buf[128]; snprintf(buf, sizeof(buf), "%s %s", kmod_info.name, kmod_info.version); setProperty("RM,Version", buf); #ifdef DEBUG setProperty("RM,Build", "Debug-" LOGNAME); #else setProperty("RM,Build", "Release-" LOGNAME); #endif return true; }
bool IOI2CDriveBayGPIO::start(IOService *provider) { IOReturn status; OSData *data; mach_timespec_t timeout; DLOG("IOI2CDriveBayGPIO::start\n"); // Get our "reg" property.. I2C address. if (0 == (data = OSDynamicCast(OSData, provider->getProperty("reg")))) { DLOG("IOI2CDriveBayGPIO::start -- no reg property\n"); return false; } fReg = *((UInt32 *)data->getBytesNoCopy()); // Find the PCA9554M node. It provides our interrupt source... timeout.tv_sec = 30; timeout.tv_nsec = 0; if (0 == (fPCA9554M = waitForService(serviceMatching("IOI2CDriveBayMGPIO"), &timeout))) { DLOG("IOI2CDriveBayGPIO::start -- timeout waiting for IOI2CDriveBayMGPIO\n"); return false; } fConfigReg = 0xFF; // default to all input pins fPolarityReg = 0x00; // no polarity inversion // find out how to program the config register if (data = OSDynamicCast(OSData, provider->getProperty("config-reg"))) fConfigReg = (UInt8)*((UInt32 *)data->getBytesNoCopy()); // find out how to program the polarity register if (data = OSDynamicCast(OSData, provider->getProperty("polarity-reg"))) fPolarityReg = (UInt8)*((UInt32 *)data->getBytesNoCopy()); DLOG("IOI2CDriveBayGPIO(%x)::start fConfigReg = %02x fPolarityReg = %02x\n", (int)fReg, fConfigReg, fPolarityReg); // allocate my lock fClientLock = IOLockAlloc(); // Register with the combined PCA9554M DLOG("IOI2CDriveBayGPIO(%x)::start - register9554MInterruptClient\n", (int)fReg); if (kIOReturnSuccess != (status = fPCA9554M->callPlatformFunction("register9554MInterruptClient", false, (void *)fReg, (void *)&sProcess9554MInterrupt, (void *)this, (void *)true))) { DLOG("IOI2CDriveBayGPIO(%x)::start failed to register (%x)\n", (int)fReg, (int)status); return false; } // Start IOI2C services... if (false == super::start(provider)) { DLOG("IOI2CDriveBayGPIO(%x)::start -- super::start returned error\n", (int)fReg); return false; } super::callPlatformFunction("IOI2CSetDebugFlags", false, (void *)kStateFlags_kprintf, (void *)true, (void *)NULL, (void *)NULL); if (kIOReturnSuccess != readI2C(k9554OutputPort, &fOutputReg, 1)) { DLOG("IOI2CDriveBayGPIO(%x)::start -- super::start returned error\n", (int)fReg); freeI2CResources(); return false; } // start matching on children publishChildren(provider); registerService(); DLOG("IOI2CDriveBayGPIO@%lx::start succeeded\n", getI2CAddress()); return true; }
bool SuperIODevice::start(IOService *provider) { if (!super::start(provider)) return false; /*for (int i = 0; i < 2; i++) { i386_ioport_t port = kSuperIOPorts[i]; winbond_family_enter(port); UInt16 id = superio_listen_port_word(port, kSuperIOChipIDRegister); UInt16 model = 0; UInt8 ldn = 0; const char* vendor = ""; switch (id) { // Fintek case F71858: model = id; ldn = kF71858HardwareMonitorLDN; vendor = "Fintek"; break; case F71862: case F71868A: case F71869: case F71869A: case F71882: case F71889AD: case F71889ED: case F71889F: case F71808E: model = id; ldn = kFintekITEHardwareMonitorLDN; vendor = "Fintek"; break; default: switch (id >> 8) { // Winbond case 0x52: switch (id & 0xff) { case 0x17: case 0x3A: case 0x41: model = W83627HF; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; case 0x82: switch (id & 0xf0) { case 0x80: model = W83627THF; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; case 0x85: switch (id & 0xff) { case 0x41: model = W83687THF; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; case 0x88: switch (id & 0xf0) { case 0x50: case 0x60: model = W83627EHF; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; case 0xA0: switch (id & 0xf0) { case 0x20: model = W83627DHG; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; case 0xA5: switch (id & 0xf0) { case 0x10: model = W83667HG; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; case 0xB0: switch (id & 0xf0) { case 0x70: model = W83627DHGP; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; case 0xB3: switch (id & 0xf0) { case 0x50: model = W83667HGB; ldn = kWinbondHardwareMonitorLDN; vendor = "Winbond"; break; } break; // Nuvoton case 0xB4: switch (id & 0xf0) { case 0x70: model = NCT6771F; ldn = kWinbondHardwareMonitorLDN; vendor = "Nuvoton"; break; } break; case 0xC3: switch (id & 0xf0) { case 0x30: model = NCT6776F; ldn = kWinbondHardwareMonitorLDN; vendor = "Nuvoton"; break; } break; case 0xC5: switch (id & 0xf0) { case 0x60: model = NCT6779D; ldn = kWinbondHardwareMonitorLDN; vendor = "Nuvoton"; break; } break; } break; } UInt16 address = 0; UInt16 verify = 0; if (model != 0 && ldn != 0) { superio_select_logical_device(port, ldn); address = superio_listen_port_word(port, kSuperIOBaseAddressRegister); IOSleep(50); verify = superio_listen_port_word(port, kSuperIOBaseAddressRegister); winbond_family_exit(port); if (address != verify) continue; // some Fintek chips have address register offset 0x05 added already if ((address & 0x07) == 0x05) address &= 0xFFF8; if (address < 0x100 || (address & 0xF007) != 0) continue; } else { winbond_family_exit(port); IOSleep(50); // IT87XX can enter only on port 0x2E if (port == 0x2E) { ite_family_enter(port); id = superio_listen_port_word(port, kSuperIOChipIDRegister); ldn = 0; vendor = ""; switch (id) { case IT8512F: case IT8712F: case IT8716F: case IT8718F: case IT8720F: case IT8721F: case IT8726F: case IT8728F: case IT8752F: case IT8771E: case IT8772E: model = id; ldn = kFintekITEHardwareMonitorLDN; vendor = "ITE"; break; } if (model != 0 && ldn != 0) { superio_select_logical_device(port, ldn); address = superio_listen_port_word(port, kSuperIOBaseAddressRegister); IOSleep(50); verify = superio_listen_port_word(port, kSuperIOBaseAddressRegister); ite_family_exit(port); if (address != verify || address < 0x100 || (address & 0xF007) != 0) continue; } else { ite_family_exit(port); continue; } } }*/ // Gigabyte mobos usualy use ITE if (IOService *headingProvider = waitForService(serviceMatching(kFakeSMCService))) { if (OSString *manufacturer = OSDynamicCast(OSString, headingProvider->getProperty(kOEMInfoManufacturer))) { if (manufacturer->isEqualTo("Gigabyte")) { if (!detectITEFamilyChip()) { UInt16 ite_id = id; if (!detectWinbondFamilyChip()) { HWSensorsFatalLog("found unsupported ship ITE sequence ID=0x%x, Winbond sequence ID=0x%x", ite_id, id); return false; } } } } } // Other vendors usualy use Winbond family chipsets if (model == 0) { if (!detectWinbondFamilyChip()) { UInt16 wnbnd_id = id; if (!detectITEFamilyChip()) { HWSensorsFatalLog("found unsupported ship ITE sequence ID=0x%x, Winbond sequence ID=0x%x", id, wnbnd_id); return false; } } } HWSensorsInfoLog("found %s %s on port=0x%x address=0x%x", vendor, superio_get_model_name(model), port, address); char string[128]; snprintf(string, sizeof(string), "%s,%s", vendor, superio_get_model_name(model)); setName(string); //setProperty("name", &string, (UInt32)strlen(string) + 1); setProperty(kSuperIOHWMAddress, address, 16); setProperty(kSuperIOControlPort, port, 8); setProperty(kSuperIOModelValue, model, 16); setProperty(kSuperIOModelName, superio_get_model_name(model)); setProperty(kSuperIOVendorName, vendor); setProperty(kSuperIODeviceID, OSData::withBytes(&id, sizeof(id))); registerService(); return true; }
/*! * \brief Launcher of Ros node cmd * * \param argc Number of parameters * \param argv The arguments * */ int main(int argc, char *argv[]) { // Initialize ros for this node ros::init(argc, argv, "pikopter_test_takeoff"); // Struct for handling timeout struct timeval tv; // set a timeout tv.tv_sec = 0; tv.tv_usec = 100000; // 100ms ros::NodeHandle nh; ros::Subscriber state_sub = nh.subscribe<mavros_msgs::State> ("mavros/state", 10, state_cb); ros::ServiceClient arming_client = nh.serviceClient<mavros_msgs::CommandBool> ("mavros/cmd/arming"); ros::ServiceClient set_mode_client = nh.serviceClient<mavros_msgs::SetMode> ("mavros/set_mode"); ros::ServiceClient tol_client = nh.serviceClient<mavros_msgs::CommandTOL> ("mavros/cmd/takeoff"); ros::Publisher velocity_pub = nh.advertise<geometry_msgs::TwistStamped>("/mavros/setpoint_velocity/cmd_vel", 100); mavros_msgs::SetMode srvGuided; mavros_msgs::CommandTOL srvTakeOffLand; mavros_msgs::CommandBool srvArmed; geometry_msgs::TwistStamped msgMove; srvGuided.request.custom_mode = "GUIDED"; srvGuided.request.base_mode = 0; srvTakeOffLand.request.altitude = 50; srvArmed.request.value = true; ROS_INFO("Wait for land service"); waitForService("/mavros/cmd/land"); ROS_INFO("Wait for set_mode service"); waitForService("/mavros/set_mode"); ROS_INFO("Wait for set_mode service"); waitForService("/mavros/cmd/arming"); ros::Rate rate(20.0); ros::Time last_request = ros::Time::now(); ros::Time loop_time = ros::Time::now(); bool takeoff = false; bool land = false; /*while(ros::ok()){ if(current_state.mode != "GUIDED" && (ros::Time::now() - last_request > ros::Duration(5.0))){ if( set_mode_client.call(srvGuided) && srvGuided.response.success){ ROS_INFO("Guided mode enabled"); } last_request = ros::Time::now(); } else { if(!current_state.armed && (ros::Time::now() - last_request > ros::Duration(5.0))){ if( arming_client.call(srvArmed) && srvArmed.response.success){ ROS_INFO("Vehicle armed"); } last_request = ros::Time::now(); } } if(ros::Time::now() - last_request > ros::Duration(5.0) && !takeoff){ if(tol_client.call(srvTakeOffLand) && srvTakeOffLand.response.success){ takeoff = true; sleep(10); ROS_INFO("Vehicle has takeoff"); } last_request = ros::Time::now(); } ros::spinOnce(); rate.sleep(); } return 0;*/ sleep(5); // Set mode to GUIDED if(ros::service::call("/mavros/set_mode", srvGuided) && srvGuided.response.success) { ROS_INFO("Mode MAV_MODE_GUIDED activated."); } else { ROS_ERROR("Problem occured on calling set_mode service"); exit(ERROR_ENCOUNTERED); } // Wait a little before arming sleep(1); // Arming motors if(ros::service::call("/mavros/cmd/arming", srvArmed) && srvArmed.response.success) { ROS_INFO("Arming command called."); } else { ROS_ERROR("Problem occured on calling arming command"); exit(ERROR_ENCOUNTERED); } // Wait a little before taking off (need to warn everyone aroun!) sleep(2); // Calling takeoff service if(ros::service::call("/mavros/cmd/takeoff", srvTakeOffLand) && srvTakeOffLand.response.success) { ROS_INFO("Takeoff called"); } else { ROS_ERROR("Problem occured on calling takeoff command"); exit(ERROR_ENCOUNTERED); } sleep(5); msgMove.header.stamp = ros::Time::now(); msgMove.twist.linear.x = -10; velocity_pub.publish(msgMove); ROS_INFO("Linear velocity -> x = %f, y = %f, z = %f", msgMove.twist.linear.x, msgMove.twist.linear.y, msgMove.twist.linear.z); // ROS_INFO("Angular velocity -> x = %f, y = %f, z = %f", msgMove.twist.angular.x, msgMove.twist.angular.y, msgMove.twist.angular.z); // Drone will move during 15 seconds sleep(15); msgMove.header.stamp = ros::Time::now(); msgMove.twist.linear.x = 0; msgMove.twist.angular.z = 0; velocity_pub.publish(msgMove); ROS_INFO("Linear velocity -> x = %f, y = %f, z = %f", msgMove.twist.linear.x, msgMove.twist.linear.y, msgMove.twist.linear.z); ROS_INFO("Angular velocity -> x = %f, y = %f, z = %f", msgMove.twist.angular.x, msgMove.twist.angular.y, msgMove.twist.angular.z); sleep(5); if(ros::service::call("/mavros/cmd/land", srvTakeOffLand)) ROS_INFO("Land called"); else ROS_ERROR("Problem occured on calling land command"); return 0; }
bool MacRISC2CPU::start(IOService *provider) { kern_return_t result; IORegistryEntry *cpusRegEntry, *uniNRegEntry, *mpicRegEntry, *devicetreeRegEntry; OSIterator *cpusIterator; OSData *tmpData; IOService *service; const OSSymbol *interruptControllerName; OSData *interruptData; OSArray *tmpArray; UInt32 maxCPUs, uniNVersion, physCPU; ml_processor_info_t processor_info; #if enableUserClientInterface DFScontMode = 0; fWorkLoop = 0; DFS_Status = false; GPU_Status = kGPUHigh; vStepped = false; #endif // callPlatformFunction symbols mpic_getProvider = OSSymbol::withCString("mpic_getProvider"); mpic_getIPIVector= OSSymbol::withCString("mpic_getIPIVector"); mpic_setCurrentTaskPriority = OSSymbol::withCString("mpic_setCurrentTaskPriority"); mpic_setUpForSleep = OSSymbol::withCString("mpic_setUpForSleep"); mpic_dispatchIPI = OSSymbol::withCString("mpic_dispatchIPI"); keyLargo_restoreRegisterState = OSSymbol::withCString("keyLargo_restoreRegisterState"); keyLargo_syncTimeBase = OSSymbol::withCString("keyLargo_syncTimeBase"); keyLargo_saveRegisterState = OSSymbol::withCString("keyLargo_saveRegisterState"); keyLargo_turnOffIO = OSSymbol::withCString("keyLargo_turnOffIO"); keyLargo_writeRegUInt8 = OSSymbol::withCString("keyLargo_writeRegUInt8"); keyLargo_getHostKeyLargo = OSSymbol::withCString("keyLargo_getHostKeyLargo"); keyLargo_setPowerSupply = OSSymbol::withCString("setPowerSupply"); uniN_setPowerState = OSSymbol::withCString(kUniNSetPowerState); uniN_setAACKDelay = OSSymbol::withCString(kUniNSetAACKDelay); pmu_cpuReset = OSSymbol::withCString("cpuReset"); ati_prepareDMATransaction = OSSymbol::withCString(kIOFBPrepareDMAValueKey); ati_performDMATransaction = OSSymbol::withCString(kIOFBPerformDMAValueKey); macRISC2PE = OSDynamicCast(MacRISC2PE, getPlatform()); if (macRISC2PE == 0) return false; if (!super::start(provider)) return false; // Get the Uni-N Version. uniNRegEntry = fromPath("/uni-n", gIODTPlane); if (uniNRegEntry == 0) return false; tmpData = OSDynamicCast(OSData, uniNRegEntry->getProperty("device-rev")); if (tmpData == 0) return false; uniNVersion = *(long *)tmpData->getBytesNoCopy(); // Find out if this is the boot CPU. bootCPU = false; tmpData = OSDynamicCast(OSData, provider->getProperty("state")); if (tmpData == 0) return false; if (!strcmp((char *)tmpData->getBytesNoCopy(), "running")) bootCPU = true; // Count the CPUs. numCPUs = 0; cpusRegEntry = fromPath("/cpus", gIODTPlane); if (cpusRegEntry == 0) return false; cpusIterator = cpusRegEntry->getChildIterator(gIODTPlane); while (cpusIterator->getNextObject()) numCPUs++; cpusIterator->release(); // [3830950] - The bootCPU driver inits globals for all instances (like gCPUIC) so if we're not the // boot CPU driver we wait here for that driver to finish its initialization if ((numCPUs > 1) && !bootCPU) // Wait for bootCPU driver to say it's up and running (void) waitForService (resourceMatching ("BootCPU")); // Limit the number of CPUs to one if uniNVersion is 1.0.7 or less. if (uniNVersion < kUniNVersion107) numCPUs = 1; // Limit the number of CPUs by the cpu=# boot arg. if (PE_parse_boot_arg("cpus", &maxCPUs)) { if (numCPUs > maxCPUs) numCPUs = maxCPUs; } ignoreSpeedChange = false; doSleep = false; topLevelPCIBridgeCount = 0; // Get the "flush-on-lock" property from the first cpu node. flushOnLock = false; cpusRegEntry = fromPath("/cpus/@0", gIODTPlane); if (cpusRegEntry == 0) return false; if (cpusRegEntry->getProperty("flush-on-lock") != 0) flushOnLock = true; // Set flushOnLock when numCPUs is not one. if (numCPUs != 1) flushOnLock = true; // If system is PowerMac3,5 (TowerG4), then set flushOnLock to disable nap devicetreeRegEntry = fromPath("/", gIODTPlane); tmpData = OSDynamicCast(OSData, devicetreeRegEntry->getProperty("model")); if (tmpData == 0) return false; #if 0 if(!strcmp((char *)tmpData->getBytesNoCopy(), "PowerMac3,5")) flushOnLock = true; #endif // Get the physical CPU number from the "reg" property. tmpData = OSDynamicCast(OSData, provider->getProperty("reg")); if (tmpData == 0) return false; physCPU = *(long *)tmpData->getBytesNoCopy(); setCPUNumber(physCPU); // Get the gpio offset for soft reset from the "soft-reset" property. tmpData = OSDynamicCast(OSData, provider->getProperty("soft-reset")); if (tmpData == 0) { if (physCPU == 0) soft_reset_offset = 0x5B; else soft_reset_offset = 0x5C; } else soft_reset_offset = *(long *)tmpData->getBytesNoCopy(); // Get the gpio offset for timebase enable from the "timebase-enable" property. tmpData = OSDynamicCast(OSData, provider->getProperty("timebase-enable")); if (tmpData == 0) timebase_enable_offset = 0x73; else timebase_enable_offset = *(long *)tmpData->getBytesNoCopy(); // See if reset is needed on wake resetOnWake = (provider->getProperty ("reset-on-wake") != NULL); if (resetOnWake) { vm_address_t reserveMem; reserveMem = (vm_address_t)IOMallocAligned (PAGE_SIZE, PAGE_SIZE); // Get one page (which we keep forever) if (reserveMem) { // map it reserveMemDesc = IOMemoryDescriptor::withAddress (reserveMem, PAGE_SIZE, kIODirectionNone, NULL); if (reserveMemDesc) { // get the physical address reserveMemPhys = reserveMemDesc->getPhysicalAddress(); } } } // On machines with a 'vmin' property in the CPU Node we need to make sure to tell the kernel to // ml_set_processor_voltage on needed processors. needVSetting = (provider->getProperty( "vmin" ) != 0); // While techincally the Apollo7PM machines do need AACK delay, it is already set in the bootROM // since we boot slow. We don't want the machine to switch AACKdelay off when we run DFS high so // setting this to false will take care of the issue. needAACKDelay = false; if (bootCPU) { gCPUIC = new IOCPUInterruptController; if (gCPUIC == 0) return false; if (gCPUIC->initCPUInterruptController(numCPUs) != kIOReturnSuccess) return false; gCPUIC->attach(this); gCPUIC->registerCPUInterruptController(); } // Get the l2cr value from the property list. tmpData = OSDynamicCast(OSData, provider->getProperty("l2cr")); if (tmpData != 0) { l2crValue = *(long *)tmpData->getBytesNoCopy() & 0x7FFFFFFF; } else { l2crValue = mfl2cr() & 0x7FFFFFFF; } // Wait for KeyLargo to show up. keyLargo = waitForService(serviceMatching("KeyLargo")); if (keyLargo == 0) return false; keyLargo->callPlatformFunction (keyLargo_getHostKeyLargo, false, &keyLargo, 0, 0, 0); if (keyLargo == 0) { kprintf ("MacRISC2CPU::start - getHostKeyLargo returned nil\n"); return false; } // Wait for MPIC to show up. mpic = waitForService(serviceMatching("AppleMPICInterruptController")); if (mpic == 0) return false; // Set the Interrupt Properties for this cpu. mpic->callPlatformFunction(mpic_getProvider, false, (void *)&mpicRegEntry, 0, 0, 0); interruptControllerName = IODTInterruptControllerName(mpicRegEntry); mpic->callPlatformFunction(mpic_getIPIVector, false, (void *)&physCPU, (void *)&interruptData, 0, 0); if ((interruptControllerName == 0) || (interruptData == 0)) return false; tmpArray = OSArray::withCapacity(1); tmpArray->setObject(interruptControllerName); cpuNub->setProperty(gIOInterruptControllersKey, tmpArray); tmpArray->release(); tmpArray = OSArray::withCapacity(1); tmpArray->setObject(interruptData); cpuNub->setProperty(gIOInterruptSpecifiersKey, tmpArray); tmpArray->release(); setCPUState(kIOCPUStateUninitalized); // necessary bootCPU initialization is done, so release other CPU drivers to do their thing // other drivers need to be unblocked *before* we call processor_start otherwise we deadlock if (bootCPU) publishResource ("BootCPU", this); if (physCPU < numCPUs) { processor_info.cpu_id = (cpu_id_t)this; processor_info.boot_cpu = bootCPU; processor_info.start_paddr = 0x0100; processor_info.l2cr_value = l2crValue; processor_info.supports_nap = !flushOnLock; processor_info.time_base_enable = OSMemberFunctionCast(time_base_enable_t, this, &MacRISC2CPU::enableCPUTimeBase); // [4091924] // Register this CPU with mach. result = ml_processor_register(&processor_info, &machProcessor, &ipi_handler); if (result == KERN_FAILURE) return false; processor_start(machProcessor); } // Before to go to sleep we wish to disable the napping mode so that the PMU // will not shutdown the system while going to sleep: service = waitForService(serviceMatching("IOPMrootDomain")); pmRootDomain = OSDynamicCast(IOPMrootDomain, service); if (pmRootDomain != 0) { kprintf("Register MacRISC2CPU %ld to acknowledge power changes\n", getCPUNumber()); pmRootDomain->registerInterestedDriver(this); // Join the Power Management Tree to receive setAggressiveness calls. PMinit(); provider->joinPMtree(this); } // Finds PMU and UniN so in quiesce we can put the machine to sleep. // I can not put these calls there because quiesce runs in interrupt // context and waitForService may block. pmu = waitForService(serviceMatching("ApplePMU")); uniN = waitForService(serviceMatching("AppleUniN")); if ((pmu == 0) || (uniN == 0)) return false; if (macRISC2PE->hasPMon) { // Find the platform monitor, if present service = waitForService(resourceMatching("IOPlatformMonitor")); ioPMon = OSDynamicCast (IOPlatformMonitor, service->getProperty("IOPlatformMonitor")); if (!ioPMon) return false; ioPMonDict = OSDictionary::withCapacity(2); if (!ioPMonDict) { ioPMon = NULL; } else { ioPMonDict->setObject (kIOPMonTypeKey, OSSymbol::withCString (kIOPMonTypeCPUCon)); ioPMonDict->setObject (kIOPMonCPUIDKey, OSNumber::withNumber ((long long)getCPUNumber(), 32)); if (messageClient (kIOPMonMessageRegister, ioPMon, (void *)ioPMonDict) != kIOReturnSuccess) { // IOPMon doesn't need to know about us, so don't bother with it IOLog ("MacRISC2CPU::start - failed to register cpu with IOPlatformMonitor\n"); ioPMonDict->release(); ioPMon = NULL; } } } if (macRISC2PE->hasPPlugin) { IOService *ioPPlugin; OSDictionary *ioPPluginDict; // Find the platform plugin, if present service = waitForService(resourceMatching("IOPlatformPlugin")); ioPPlugin = OSDynamicCast (IOService, service->getProperty("IOPlatformPlugin")); if (!ioPPlugin) return false; ioPPluginDict = OSDictionary::withCapacity(2); if (ioPPluginDict) { ioPPluginDict->setObject ("cpu-id", OSNumber::withNumber ((long long)getCPUNumber(), 32)); // Register with the plugin - same API as for platform monitor if (messageClient (kIOPMonMessageRegister, ioPPlugin, (void *)ioPPluginDict) != kIOReturnSuccess) { // ioPPlugin doesn't need to know about us, so don't bother with it IOLog ("MacRISC2CPU::start - failed to register cpu with IOPlatformPlugin\n"); } ioPPluginDict->release(); // Not needed any more } } #if enableUserClientInterface // // UserClient stuff... // fWorkLoop = getWorkLoop(); if(!fWorkLoop) { IOLog("MacRISC2CPU::start ERROR: failed to find a fWorkLoop\n"); } if(!initTimers()) { IOLog("MacRISC2CPU::start ERROR: failed to init the timers\n"); } #endif registerService(); return true; }
bool GeforceSensors::start(IOService * provider) { DebugLog("Starting..."); if (!super::start(provider)) return false; if (!(fakeSMC = waitForService(serviceMatching(kFakeSMCDeviceService)))) { WarningLog("Can't locate fake SMC device, kext will not load"); return false; } struct nouveau_device *device = &card; //Find card number card.card_index = getVacantGPUIndex(); if (card.card_index < 0) { nv_error(device, "failed to obtain vacant GPU index\n"); return false; } // map device memory // device->pcidev = (IOPCIDevice*)provider; if (device->pcidev) { device->pcidev->setMemoryEnable(true); if ((device->mmio = device->pcidev->mapDeviceMemoryWithIndex(0))) { nv_debug(device, "memory mapped successfully\n"); } else { nv_error(device, "failed to map memory\n"); return false; } } else { nv_error(device, "failed to assign PCI device\n"); return false; } // identify chipset if (!nouveau_identify(device)) return false; // shadow and parse bios //try to load bios from registry first from "vbios" property created by Chameleon boolloader if (OSData *vbios = OSDynamicCast(OSData, provider->getProperty("vbios"))) { device->bios.size = vbios->getLength(); device->bios.data = (u8*)IOMalloc(card.bios.size); memcpy(device->bios.data, vbios->getBytesNoCopy(), device->bios.size); } if (!device->bios.data || !device->bios.size || nouveau_bios_score(device, true) < 1) if (!nouveau_bios_shadow(device)) { if (device->bios.data && device->bios.size) { IOFree(card.bios.data, card.bios.size); device->bios.data = NULL; device->bios.size = 0; } nv_error(device, "unable to shadow VBIOS\n"); return false; } nouveau_vbios_init(device); nouveau_bios_parse(device); // initialize funcs and variables if (!nouveau_init(device)) { nv_error(device, "unable to initialize monitoring driver\n"); return false; } nv_info(device, "chipset: %s (NV%02X) bios: %02x.%02x.%02x.%02x\n", device->cname, (unsigned int)device->chipset, device->bios.version.major, device->bios.version.chip, device->bios.version.minor, device->bios.version.micro); if (device->card_type < NV_C0) { // init i2c structures nouveau_i2c_create(device); // setup nouveau i2c sensors nouveau_i2c_probe(device); } // Register sensors char key[5]; if (card.core_temp_get || card.board_temp_get) { nv_debug(device, "registering i2c temperature sensors...\n"); if (card.core_temp_get && card.board_temp_get) { snprintf(key, 5, KEY_FORMAT_GPU_DIODE_TEMPERATURE, card.card_index); this->addSensor(key, TYPE_SP78, 2, 0); snprintf(key, 5, KEY_FORMAT_GPU_HEATSINK_TEMPERATURE, card.card_index); addSensor(key, TYPE_SP78, 2, 0); } else if (card.core_temp_get) { snprintf(key, 5, KEY_FORMAT_GPU_PROXIMITY_TEMPERATURE, card.card_index); addSensor(key, TYPE_SP78, 2, 0); } else if (card.board_temp_get) { snprintf(key, 5, KEY_FORMAT_GPU_PROXIMITY_TEMPERATURE, card.card_index); addSensor(key, TYPE_SP78, 2, 0); } } else if (card.temp_get) { nv_debug(device, "registering temperature sensors...\n"); snprintf(key, 5, KEY_FORMAT_GPU_PROXIMITY_TEMPERATURE, card.card_index); addSensor(key, TYPE_SP78, 2, 0); } if (card.clocks_get) { nv_debug(device, "registering clocks sensors...\n"); if (card.clocks_get(&card, nouveau_clock_core) > 0) { snprintf(key, 5, KEY_FAKESMC_FORMAT_GPU_FREQUENCY, card.card_index); addSensor(key, TYPE_UI32, TYPE_UI32_SIZE, nouveau_clock_core); } if (card.clocks_get(&card, nouveau_clock_shader) > 0) { snprintf(key, 5, KEY_FAKESMC_FORMAT_GPU_SHADER_FREQUENCY, card.card_index); addSensor(key, TYPE_UI32, TYPE_UI32_SIZE, nouveau_clock_shader); } if (card.clocks_get(&card, nouveau_clock_rop) > 0) { snprintf(key, 5, KEY_FAKESMC_FORMAT_GPU_ROP_FREQUENCY, card.card_index); addSensor(key, TYPE_UI32, TYPE_UI32_SIZE, nouveau_clock_rop); } if (card.clocks_get(&card, nouveau_clock_memory) > 0) { snprintf(key, 5, KEY_FAKESMC_FORMAT_GPU_MEMORY_FREQUENCY, card.card_index); addSensor(key, TYPE_UI32, TYPE_UI32_SIZE, nouveau_clock_memory); } } if (card.fan_pwm_get || card.fan_rpm_get) { nv_debug(device, "registering PWM sensors...\n"); if (card.fan_rpm_get && card.fan_rpm_get(device) > 0) { char title[6]; snprintf (title, 6, "GPU %X", card.card_index + 1); UInt8 fanIndex = 0; if (addTachometer( fanIndex)) { if (card.fan_pwm_get && card.fan_pwm_get(device) > 0) { snprintf(key, 5, KEY_FAKESMC_FORMAT_GPUPWM, fanIndex); addSensor(key, TYPE_UI8, TYPE_UI8_SIZE, 0); } } } } if (card.voltage_get && card.voltage.supported) { nv_debug(device, "registering voltage sensors...\n"); snprintf(key, 5, KEY_FORMAT_GPU_VOLTAGE, card.card_index); addSensor(key, TYPE_FP2E, TYPE_FPXX_SIZE, 0); } nv_info(device, "started\n"); return true; }
bool AppleMediaBay::start(IOService *provider) { OSData *compatibleEntry; // If the super class failed there is little point in // going on: if (!super::start(provider)) return false; // Find out the controller for the mediabay: mbControllerType = kMBControllerUndefined; compatibleEntry = OSDynamicCast( OSData, provider->getProperty( "compatible" ) ); if ( compatibleEntry == 0 ) { #ifdef APPLEMB_VERBOSE IOLog("No compatible entry found.\n"); #endif //APPLEMB_VERBOSE return false; } if ( compatibleEntry->isEqualTo( "keylargo-media-bay", sizeof("keylargo-media-bay")-1 ) == true ) { #ifdef APPLEMB_VERBOSE IOLog("Found KeyLargo compatible property.\n"); #endif // APPLEMB_VERBOSE mbControllerType = kMBControllerKeyLargo; myMacIO = waitForService(serviceMatching("KeyLargo")); } if ( compatibleEntry->isEqualTo( "heathrow-media-bay", sizeof("heathrow-media-bay")-1 ) == true ) { #ifdef APPLEMB_VERBOSE IOLog("Found Heathrow compatible property.\n"); #endif // APPLEMB_VERBOSE mbControllerType = kMBControllerHeathrow; // now the parent could be either Hetrow or Gatwick // so jump back looking for my MacIO: myMacIO = OSDynamicCast(AppleMacIO, provider->getProvider()); } if ( compatibleEntry->isEqualTo( "ohare-media-bay", sizeof("ohare-media-bay")-1 ) == true ) { #ifdef APPLEMB_VERBOSE IOLog("Found OHare compatible property.\n"); #endif // APPLEMB_VERBOSE mbControllerType = kMBControllerOHare; myMacIO = waitForService(serviceMatching("OHare")); } if( (configAddrMap = provider->mapDeviceMemoryWithIndex( 0 ))) { configAddr = (volatile UInt32 *) configAddrMap->getVirtualAddress(); #ifdef APPLEMB_VERBOSE IOLog("configAddr = 0x%08lx.\n",(unsigned int)configAddr); #endif // APPLEMB_VERBOSE } else { #ifdef APPLEMB_VERBOSE IOLog("configAddrMap failed.\n"); #endif // APPLEMB_VERBOSE return false; } if (myMacIO == NULL) { #ifdef APPLEMB_VERBOSE IOLog("myMacIO == NULL.\n"); #endif // APPLEMB_VERBOSE return false; } workloop = IOWorkLoop::workLoop(); // make the workloop if(!workloop) { #ifdef APPLEMB_VERBOSE IOLog("Error creating workloop.\n"); #endif // APPLEMB_VERBOSE return false; } intSource = IOInterruptEventSource::interruptEventSource (this, (IOInterruptEventAction) &handleInterrupt, provider); if ((intSource == NULL) || (workloop->addEventSource(intSource) != kIOReturnSuccess)) { #ifdef APPLEMB_VERBOSE IOLog("Problem adding interrupt event source...\n"); #endif // APPLEMB_VERBOSE return false; } else workloop->enableAllInterrupts(); // Creates the command gate for the events that need to be in the queue commandGate = IOCommandGate::commandGate(this, commandGateCaller); // and adds it to the workloop: if ((commandGate == NULL) || (workloop->addEventSource(commandGate) != kIOReturnSuccess)) { #ifdef VERBOSE_LOGS_ON_PMU_INT IOLog("Can not add a new IOCommandGate\n"); #endif // VERBOSE_LOGS_ON_PMU_INT return false; } // by default we start without client: ioClient = NULL; // The symbol to change power to the media bay: powerMediaBay = OSSymbol::withCString("powerMediaBay"); // Remember with wich device we are starting: mbCurrentDevice = readMBID(); // Starts the power managment. NOTE: to assure the correct behavior // of the driver initForPM should be called AFTER mbCurrentDevice is // set to its initial value. if (!initForPM(provider)) { #ifdef APPLEMB_VERBOSE IOLog("Error joining the power managment tree.\n"); #endif // APPLEMB_VERBOSE return false; } // calls registerService so that the ata nubs can find this driver // and register with it: registerService(); return true; }
bool AppleGPIO::start(IOService *provider) { bool doSleepWake; UInt32 i, flags, intCapable; IOPlatformFunction *func; const OSSymbol *functionSymbol = OSSymbol::withCString("InstantiatePlatformFunctions"); IOReturn retval; IOService *parentDev; OSData *data; if (!super::start(provider)) return(false); // set my id data = OSDynamicCast(OSData, provider->getProperty("reg")); if (!data) return(false); fGPIOID = *(UInt32 *)data->getBytesNoCopy(); // find the gpio parent parentDev = OSDynamicCast(IOService, provider->getParentEntry(gIODTPlane)); if (!parentDev) return(false); fParent = OSDynamicCast(IOService, parentDev->getChildEntry(gIOServicePlane)); if (!fParent) return(false); // Create the interrupt register/enable symbols fSymIntRegister = OSSymbol::withCString(kIOPFInterruptRegister); fSymIntUnRegister = OSSymbol::withCString(kIOPFInterruptUnRegister); fSymIntEnable = OSSymbol::withCString(kIOPFInterruptEnable); fSymIntDisable = OSSymbol::withCString(kIOPFInterruptDisable); // Allocate our constant callPlatformFunction symbols so we can be called at interrupt time. fSymGPIOParentWriteGPIO = OSSymbol::withCString(kSymGPIOParentWriteGPIO); fSymGPIOParentReadGPIO = OSSymbol::withCString(kSymGPIOParentReadGPIO); // Scan for platform-do-xxx functions fPlatformFuncArray = NULL; DLOG("AppleGPIO::start(%s@%lx) - calling InstantiatePlatformFunctions\n", provider->getName(), fGPIOID); retval = provider->getPlatform()->callPlatformFunction(functionSymbol, false, (void *)provider, (void *)&fPlatformFuncArray, (void *)0, (void *)0); DLOG("AppleGPIO::start(%s@%lx) - InstantiatePlatformFunctions returned %ld, pfArray %sNULL\n", provider->getName(), fGPIOID, retval, fPlatformFuncArray ? "NOT " : ""); if (retval == kIOReturnSuccess && (fPlatformFuncArray != NULL)) { // Find out if the GPIO parent supports interrupt events if (fParent->callPlatformFunction(kSymGPIOParentIntCapable, false, &intCapable, 0, 0, 0) != kIOReturnSuccess) { intCapable = 0; } DLOG("AppleGPIO::start(%s@%lx) - iterating platformFunc array, count = %ld\n", provider->getName(), fGPIOID, fPlatformFuncArray->getCount()); doSleepWake = false; UInt32 count = fPlatformFuncArray->getCount(); for (i = 0; i < count; i++) { if (func = OSDynamicCast(IOPlatformFunction, fPlatformFuncArray->getObject(i))) { flags = func->getCommandFlags(); DLOG ("AppleGPIO::start(%s@%lx) - functionCheck - got function, flags 0x%lx, pHandle 0x%lx\n", provider->getName(), fGPIOID, flags, func->getCommandPHandle()); // If this function is flagged to be performed at initialization, do it if (flags & kIOPFFlagOnInit) { performFunction(func, (void *)1, (void *)0, (void *)0, (void *)0); } if ((flags & kIOPFFlagOnDemand) || ((flags & kIOPFFlagIntGen) && intCapable)) { // Set the flag to indicate whether any of the platform functions are using // interrupts -- this is used to allocate some locks that are needed for this // functionality if ((flags & kIOPFFlagIntGen) && (fIntGen == false)) { fIntGen = true; // Allocate event-related state variable locks fClientsLock = IOSimpleLockAlloc(); fAmRegisteredLock = IOLockAlloc(); fAmEnabledLock = IOSimpleLockAlloc(); } // This is a bit of overkill. Strictly speaking the lock needs to protect // individual platformFunc array entries so that only one thread is executing // that function at a time. The way we're using it here is only one of *any* // of the platform functions can be executing at a time. if (!fPFLock) fPFLock = IOLockAlloc(); // Use for both On-Demand and IntGen functions // On-Demand and IntGen functions need to have a resource published func->publishPlatformFunction(this); } // If we need to do anything at sleep/wake time, we'll need to set this // flag so we know to register for notifications if (flags & (kIOPFFlagOnSleep | kIOPFFlagOnWake)) doSleepWake = true; } else { // This function won't be used -- generate a warning IOLog("AppleGPIO::start(%s@%lx) - functionCheck - not an IOPlatformFunction object\n", getProvider()->getName(), fGPIOID); } } // Register sleep and wake notifications if (doSleepWake) { mach_timespec_t waitTimeout; waitTimeout.tv_sec = 30; waitTimeout.tv_nsec = 0; pmRootDomain = OSDynamicCast(IOPMrootDomain, waitForService(serviceMatching("IOPMrootDomain"), &waitTimeout)); if (pmRootDomain != 0) { DLOG("AppleGPIO::start to acknowledge power changes\n"); pmRootDomain->registerInterestedDriver(this); } else { IOLog("AppleGPIO failed to register PM interest!"); } } } #ifdef OLD_STYLE_COMPAT /* * Legacy Support * * In the initial implementation, extra strings were published for event registration * and deregistration as well as enable/disable functions. In the IOPlatformFunction * implementation, the client access these functions by calling the platform-xxx function * and passing one of four OSSymbol objects (see fSymIntRegister, fSymIntUnRegister, * fSymIntEnable, fSymIntDisable). For now, we need to continue to support the old * implementation. The following code will generate and publish resources for these * functions. */ if (fIntGen) { const OSSymbol *functionSym, *aKey; char funcNameWithPrefix[160]; const char *funcName; UInt32 count = fPlatformFuncArray->getCount(); for (i = 0; i < count; i++) { // Only publish strings for on-demand and int-gen functions if ((func = OSDynamicCast(IOPlatformFunction, fPlatformFuncArray->getObject(i))) != NULL && (func->getCommandFlags() & (kIOPFFlagOnDemand | kIOPFFlagIntGen)) != NULL) { functionSym = func->getPlatformFunctionName(); if (!functionSym) continue; else funcName = functionSym->getCStringNoCopy() + strlen(kFunctionRequiredPrefix); // register string list strncpy(funcNameWithPrefix, kFunctionRegisterPrefix, strlen (kFunctionRegisterPrefix)+1); strncat(funcNameWithPrefix, funcName, sizeof (funcNameWithPrefix) - strlen (funcNameWithPrefix) - 1); funcNameWithPrefix[sizeof (funcNameWithPrefix) - 1] = '\0'; if ((aKey = OSSymbol::withCString(funcNameWithPrefix)) == 0) continue; ADD_OBJ_TO_SET(aKey, fRegisterStrings); // unregister string list strncpy(funcNameWithPrefix, kFunctionUnregisterPrefix, strlen (kFunctionUnregisterPrefix)+1); strncat(funcNameWithPrefix, funcName, sizeof (funcNameWithPrefix) - strlen (funcNameWithPrefix) - 1); funcNameWithPrefix[sizeof (funcNameWithPrefix) - 1] = '\0'; if ((aKey = OSSymbol::withCString(funcNameWithPrefix)) == 0) continue; ADD_OBJ_TO_SET(aKey, fUnregisterStrings); // register string list strncpy(funcNameWithPrefix, kFunctionEvtEnablePrefix, strlen (kFunctionEvtEnablePrefix)+1); strncat(funcNameWithPrefix, funcName, sizeof (funcNameWithPrefix) - strlen (funcNameWithPrefix) - 1); funcNameWithPrefix[sizeof (funcNameWithPrefix) - 1] = '\0'; if ((aKey = OSSymbol::withCString(funcNameWithPrefix)) == 0) continue; ADD_OBJ_TO_SET(aKey, fEnableStrings); // register string list strncpy(funcNameWithPrefix, kFunctionEvtDisablePrefix, strlen (kFunctionEvtDisablePrefix)+1); strncat(funcNameWithPrefix, funcName, sizeof (funcNameWithPrefix) - strlen (funcNameWithPrefix) - 1); funcNameWithPrefix[sizeof (funcNameWithPrefix) - 1] = '\0'; if ((aKey = OSSymbol::withCString(funcNameWithPrefix)) == 0) continue; ADD_OBJ_TO_SET(aKey, fDisableStrings); } } publishStrings(fRegisterStrings); publishStrings(fUnregisterStrings); publishStrings(fEnableStrings); publishStrings(fDisableStrings); } #endif if (fPlatformFuncArray && fPlatformFuncArray->getCount() > 0) { registerService(); return(true); } else { // No reason for me to be here return(false); } }