bool X3100monitor::start(IOService * provider) { if (!super::start(provider)) return false; //Find card number SInt8 cardIndex = getVacantGPUIndex(); if (cardIndex < 0) { HWSensorsWarningLog("failed to obtain vacant GPU index"); return false; } char key[5]; snprintf(key, 5, KEY_FORMAT_GPU_PROXIMITY_TEMPERATURE, cardIndex); if (!addSensor(key, TYPE_SP78, 2, kFakeSMCTemperatureSensor, 0)) { HWSensorsWarningLog("failed to register temperature sensor"); return false; } 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 SuperIOMonitor::addVoltageSensors(OSDictionary *configuration) { HWSensorsDebugLog("adding voltage sensors..."); for (int i = 0; i < voltageSensorsLimit(); i++) { char key[5]; OSString* name; float reference = 0.0f; float gain = 0.0f; float offset = 0.0f; snprintf(key, 5, "VIN%X", i); if (process_sensor_entry(configuration->getObject(key), &name, &reference, &gain, &offset)) { if (name->isEqualTo("CPU")) { if (!addSensor(KEY_CPU_VOLTAGE, TYPE_FP2E, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add CPU voltage sensor"); } else if (name->isEqualTo("Memory")) { if (!addSensor(KEY_MEMORY_VOLTAGE, TYPE_FP2E, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add Memory voltage sensor"); } else if (name->isEqualTo("Main 12V")) { if (!addSensor(KEY_MAIN_12V_VOLTAGE, TYPE_FP4C, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add Main 12V voltage sensor"); } else if (name->isEqualTo("PCIe 12V")) { if (!addSensor(KEY_PCIE_12V_VOLTAGE, TYPE_FP4C, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add PCIe 12V voltage sensor"); } else if (name->isEqualTo("Main 5V")) { if (!addSensor(KEY_MAIN_5V_VOLTAGE, TYPE_FP4C, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add Main 5V voltage sensor"); } else if (name->isEqualTo("Standby 5V")) { if (!addSensor(KEY_STANDBY_5V_VOLTAGE, TYPE_FP4C, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add Standby 5V voltage sensor"); } else if (name->isEqualTo("Main 3V")) { if (!addSensor(KEY_MAIN_3V3_VOLTAGE, TYPE_FP2E, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add Main 3V voltage sensor"); } else if (name->isEqualTo("Auxiliary 3V")) { if (!addSensor(KEY_AUXILIARY_3V3V_VOLTAGE, TYPE_FP2E, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add Auxiliary 3V voltage sensor"); } else if (name->isEqualTo("Power/Battery")) { if (!addSensor(KEY_POWERBATTERY_VOLTAGE, TYPE_FP2E, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add Power/Battery voltage sensor"); } else if (name->isEqualTo("GPU")) { SInt8 index = getVacantGPUIndex(); if (index > -1) { snprintf(key, 5, KEY_FORMAT_GPU_VOLTAGE, index); if (!addSensor(key, TYPE_FP2E, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add GPU voltage sensor"); } else HWSensorsWarningLog("failed to obtain vacant GPU index"); } for (int j = 0; j <= 0xf; j++) { char caption[32]; snprintf(caption, 15, "Power Supply %X", j); if (name->isEqualTo(caption)) { snprintf(key, 5, KEY_FORMAT_POWERSUPPLY_VOLTAGE, j); if (!addSensor(key, TYPE_FP4C, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add PWR%X voltage sensor", j); } else { snprintf(caption, 17, "CPU VRM Supply %X", j); if (name->isEqualTo(caption)) { snprintf(key, 5, KEY_FORMAT_CPU_VRMSUPPLY_VOLTAGE, j); if (!addSensor(key, TYPE_FP4C, TYPE_FPXX_SIZE, kSuperIOVoltageSensor, i, reference, gain, offset)) HWSensorsWarningLog("can't add VRM%X voltage sensor", j); } } } } } return true; }
bool NVClockX::start(IOService * provider) { HWSensorsDebugLog("Starting..."); if (!super::start(provider)) return false; if ((videoCard = (IOPCIDevice*)provider)) { if (videoCard->setMemoryEnable(true)) { if ((nvio = videoCard->mapDeviceMemoryWithIndex(0))) { IOVirtualAddress addr = nvio->getVirtualAddress(); if (OSData * data = OSDynamicCast(OSData, videoCard->getProperty("device-id"))) { nvclock.card[nvclock.num_cards].device_id=*(UInt32*)data->getBytesNoCopy(); nvclock.card[nvclock.num_cards].arch = get_gpu_arch(nvclock.card[nvclock.num_cards].device_id); nvclock.card[nvclock.num_cards].number = nvclock.num_cards; nvclock.card[nvclock.num_cards].card_name = (char*)get_card_name(nvclock.card[nvclock.num_cards].device_id, &nvclock.card[nvclock.num_cards].gpu); nvclock.card[nvclock.num_cards].state = 0; //nvclock.card[nvclock.num_cards].reg_address = addr; //map_mem_card(&nvclock.card[nvclock.num_cards], addr); // Map the registers of the nVidia chip // normally pmc is till 0x2000 but extended it for nv40 nvclock.card[nvclock.num_cards].PEXTDEV = (volatile unsigned int*)(addr + 0x101000); nvclock.card[nvclock.num_cards].PFB = (volatile unsigned int*)(addr + 0x100000); nvclock.card[nvclock.num_cards].PMC = (volatile unsigned int*)(addr + 0x000000); nvclock.card[nvclock.num_cards].PCIO = (volatile unsigned char*)(addr + 0x601000); nvclock.card[nvclock.num_cards].PDISPLAY= (volatile unsigned int*)(addr + NV_PDISPLAY_OFFSET); nvclock.card[nvclock.num_cards].PRAMDAC = (volatile unsigned int*)(addr + 0x680000); nvclock.card[nvclock.num_cards].PRAMIN = (volatile unsigned int*)(addr + NV_PRAMIN_OFFSET); nvclock.card[nvclock.num_cards].PROM = (volatile unsigned char*)(addr + 0x300000); // On Geforce 8xxx cards it appears that the pci config header has been moved if(nvclock.card[nvclock.num_cards].arch & NV5X) nvclock.card[nvclock.num_cards].PBUS = (volatile unsigned int*)(addr + 0x88000); else nvclock.card[nvclock.num_cards].PBUS = nvclock.card[nvclock.num_cards].PMC + 0x1800/4; nvclock.card[nvclock.num_cards].mem_mapped = 1; HWSensorsInfoLog("%s device-id=0x%x arch=0x%x", nvclock.card[nvclock.num_cards].card_name, nvclock.card[nvclock.num_cards].device_id, nvclock.card[nvclock.num_cards].arch); nvclock.num_cards++; } else HWSensorsWarningLog("device-id property not found"); } else { HWSensorsWarningLog("failed to map device's memory"); return false; } } }else { HWSensorsWarningLog("failed to assign PCI device"); return false; } char key[7]; nvclock.dpy = NULL; for (int index = 0; index < nvclock.num_cards; index++) { /* set the card object to the requested card */ if (!set_card(index)){ char buffer[256]; HWSensorsWarningLog("%s", get_error(buffer, 256)); return false; } OSData *bios = OSDynamicCast(OSData, videoCard->getProperty("vbios")); nvclock.card[index].bios = read_bios(bios ? bios->getBytesNoCopy() : NULL); /* Check if the card is supported, if not print a message. */ if(nvclock.card[index].gpu == UNKNOWN){ HWSensorsWarningLog("it seems your card isn't officialy supported yet"); HWSensorsWarningLog("please tell the author the pci_id of the card for further investigation"); HWSensorsWarningLog("continuing anyway"); } SInt8 cardIndex = getVacantGPUIndex(); if (cardIndex < 0) { HWSensorsWarningLog("failed to obtain vacant GPU index"); return false; } if(nv_card->caps & (GPU_TEMP_MONITORING)) { HWSensorsInfoLog("registering temperature sensors"); if(nv_card->caps & BOARD_TEMP_MONITORING) { snprintf(key, 5, KEY_FORMAT_GPU_DIODE_TEMPERATURE, cardIndex); addSensor(key, TYPE_SP78, 2, kNVCLockDiodeTemperatureSensor, index); snprintf(key, 5, KEY_FORMAT_GPU_HEATSINK_TEMPERATURE, cardIndex); addSensor(key, TYPE_SP78, 2, kNVCLockBoardTemperatureSensor, index); } else { snprintf(key, 5, KEY_FORMAT_GPU_PROXIMITY_TEMPERATURE, cardIndex); addSensor(key, TYPE_SP78, 2, kNVCLockBoardTemperatureSensor, index); } } if (nv_card->caps & I2C_FANSPEED_MONITORING || nv_card->caps & GPU_FANSPEED_MONITORING){ HWSensorsInfoLog("registering tachometer sensors"); char title[6]; snprintf (title, 6, "GPU %X", cardIndex); addTachometer(index, title); } HWSensorsInfoLog("registering frequency sensors"); snprintf(key, 5, KEY_FAKESMC_FORMAT_GPU_FREQUENCY, index); addSensor(key, TYPE_UI32, TYPE_UI32_SIZE, kNVCLockCoreFrequencySensor, index); snprintf(key, 5, KEY_FAKESMC_FORMAT_GPU_MEMORY_FREQUENCY, index); addSensor(key, TYPE_UI32, TYPE_UI32_SIZE, kNVCLockMemoryFrequencySensor, index); snprintf(key, 5, KEY_FAKESMC_FORMAT_GPU_SHADER_FREQUENCY, index); addSensor(key, TYPE_UI32, TYPE_UI32_SIZE, kNVCLockMemoryFrequencySensor, index); /*OSNumber* fanKey = OSDynamicCast(OSNumber, getProperty("FanSpeedPercentage")); if((fanKey!=NULL)&(nv_card->set_fanspeed!=NULL)) { HWSensorsInfoLog("Changing fan speed to %d", fanKey->unsigned8BitValue()); nv_card->set_fanspeed(fanKey->unsigned8BitValue()); } OSNumber* speedKey=OSDynamicCast(OSNumber, getProperty("GPUSpeed")); if ((speedKey!=NULL)&(nv_card->caps&GPU_OVERCLOCKING)) { HWSensorsInfoLog("Default speed %d", (UInt16)nv_card->get_gpu_speed()); //HWSensorsInfoLog("%d", speedKey->unsigned16BitValue()); nv_card->set_gpu_speed(speedKey->unsigned16BitValue()); HWSensorsInfoLog("Overclocked to %d", (UInt16)nv_card->get_gpu_speed()); }*/ } registerService(); return true; }