/****** Reset the core ******/
void SGB_core::reset()
{
bool can_reset = true;
core_cpu.reset();
core_cpu.controllers.video.reset();
core_cpu.controllers.audio.reset();
core_cpu.controllers.serial_io.reset();
core_mmu.reset();
//Link CPU and MMU
core_cpu.mem = &core_mmu;
//Link LCD and MMU
core_cpu.controllers.video.mem = &core_mmu;
//Link APU and MMU
core_cpu.controllers.audio.mem = &core_mmu;
//Link SIO and MMU
core_cpu.controllers.serial_io.mem = &core_mmu;
//Link MMU and GamePad
core_cpu.mem->g_pad = &core_pad;
//Re-read specified ROM file
if(!core_mmu.read_file(config::rom_file)) { can_reset = false; }
//Re-read BIOS file
if((config::use_bios) && (!read_bios(config::bios_file))) { can_reset = false; }
//Start everything all over again
if(can_reset) { start(); }
else { running = false; }
}
int main(int argc, char **argv)
{
read_bios("bios.rom");
return 0;
}
bool PTnVmon::start (IOService* provider) {
bool result=IOService::start(provider);
int card_number=0;
nvclock.dpy = NULL;
char* key = (char*)IOMalloc(5);
max_card=probe_devices();
if(!max_card){
char buf[80];
printf("Error: %s\n", get_error(buf, 80));
return 0;
}
for (card_number=0; card_number<max_card; card_number++) {
/* set the card object to the requested card */
if(!set_card(card_number)){
char buf[80];
printf("Error: %s\n", get_error(buf, 80));
return 0;
}
nvbios* bios=read_bios("");
nvclock.card[card_number].bios=bios;
/* Check if the card is supported, if not print a message. */
if(nvclock.card[card_number].gpu == UNKNOWN){
printf("It seems your card isn't officialy supported in FakeSMCnVclockPort yet.\n");
printf("Please tell the author the pci_id of the card for further investigation.\n");
printf("Continuing anyway\n");
}
if(nv_card->caps & (GPU_TEMP_MONITORING)){
snprintf(key, 5, KEY_FORMAT_GPU_DIODE_TEMPERATURE, card_number);
tempSensor[card_number]=new TemperatureSensor(key, TYPE_SP78, 2);
if(nv_card->caps & (BOARD_TEMP_MONITORING)) {
snprintf(key, 5, KEY_FORMAT_GPU_BOARD_TEMPERATURE, card_number);
boardSensor[card_number]=new TemperatureSensor(key, TYPE_SP78, 2);
}
}
if(nv_card->caps & (I2C_FANSPEED_MONITORING | GPU_FANSPEED_MONITORING)){
int id=GetNextUnusedKey(KEY_FORMAT_FAN_ID, key);
int ac=GetNextUnusedKey(KEY_FORMAT_FAN_SPEED, key);
if (id!=-1 || ac!=-1) {
int no=id>ac ? id : ac;
char name[6];
snprintf (name, 6, "GPU %d", card_number);
snprintf(key, 5, KEY_FORMAT_FAN_ID, no);
FakeSMCAddKey(key, TYPE_CH8, 4, name);
snprintf(key, 5, KEY_FORMAT_FAN_SPEED, no);
fanSensor[card_number]=new FanSensor(key, TYPE_FPE2, 2);
UpdateFNum();
}
}
snprintf(key, 5, "FGC%d", card_number);
gpuFreqSensor[card_number]=new FrequencySensor(key, "freq", 2);
}
IOFree(key, 5);
return result;
}
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;
}
