/* * Copyright (c) 2011-2012 Frank Peng. All rights reserved. * */ //totally rebuilt by Slice, 2012-2013 // NForce additions by Oscar09, 2013 #include "Platform.h" #include "FixBiosDsdt.h" #include "StateGenerator.h" #include "AcpiPatcher.h" #include "cpu.h" #include "../include/Pci.h" #include "../include/Devices.h" extern "C" { #include } #ifdef DBG #undef DBG #endif #ifndef DEBUG_FIX #ifndef DEBUG_ALL #define DEBUG_FIX 0 #else #define DEBUG_FIX DEBUG_ALL #endif #endif #if DEBUG_FIX==0 #define DBG(...) #else #define DBG(...) DebugLog(DEBUG_FIX, __VA_ARGS__) #endif OPER_REGION *gRegions = NULL; CHAR8* device_name[12]; // 0=>Display 1=>network 2=>firewire 3=>LPCB 4=>HDAAudio 5=>RTC 6=>TMR 7=>SBUS 8=>PIC 9=>Airport 10=>XHCI 11=>HDMI CHAR8* UsbName[10]; BOOLEAN HDAFIX = TRUE; BOOLEAN GFXHDAFIX = TRUE; BOOLEAN DisplayName1; BOOLEAN DisplayName2; BOOLEAN NetworkName; BOOLEAN ArptName; BOOLEAN XhciName; BOOLEAN ArptBCM; BOOLEAN ArptAtheros; BOOLEAN LPCBFIX; BOOLEAN IDEFIX; BOOLEAN SATAFIX; BOOLEAN ASUSFIX; BOOLEAN USBIntel; BOOLEAN USBNForce; BOOLEAN USBIDFIX = TRUE; //BOOLEAN Display1PCIE; //BOOLEAN Display2PCIE; BOOLEAN FirewireName; // for read computer data UINT32 DisplayADR1[4]; UINT32 DisplayADR2[4]; UINT32 NetworkADR1[4]; UINT32 NetworkADR2[4]; CONST CHAR8* Netmodel[4]; CONST CHAR8* NetName[4] = { "ETH0", "ETH1", "ETH2", "ETH3" }; UINT32 net_count = 0; UINT32 ArptADR1; UINT32 ArptADR2; UINT32 FirewireADR1; UINT32 FirewireADR2; UINT32 SBUSADR1; UINT32 SBUSADR2; UINT32 IMEIADR1; UINT32 IMEIADR2; UINT32 IDEADR1; UINT32 IDEADR2; UINT32 SATAADR1; UINT32 SATAADR2; UINT32 SATAAHCIADR1; UINT32 SATAAHCIADR2; UINT32 IDEVENDOR; UINT32 SATAVENDOR; UINT32 SATAAHCIVENDOR; UINT32 DisplayVendor[4]; UINT16 DisplayID[4]; UINT32 DisplaySubID[4]; UINT16 ArptDID; //UINT32 PWRBADR; UINT32 HDAADR1; UINT32 HDMIADR1; UINT32 HDMIADR2; UINT32 USBADR[12]; UINT32 USBADR2[12]; UINT32 USBADR3[12]; /*<-NFORCE_USB*/ UINT32 USBID[12]; UINT32 USB20[12]; UINT32 USB30[12]; UINT32 USB40[12]; /*<-NFORCE_USB*/ UINT32 HDAcodecId=0; UINT32 HDAlayoutId=0; UINT32 GfxcodecId[2] = {0, 1}; UINT32 GfxlayoutId[2] = {1, 12}; pci_dt_t Displaydevice[2]; UINTN usb; struct lpc_device_t { UINT32 id; }; //static UINT8 dataBuiltin[] = {0x00}; //static UINT8 dataBuiltin1[] = {0x01}; static struct lpc_device_t lpc_chipset[] = { {0x00000000}, // {0x80862811}, {0x80862815}, {0x808627b9}, {0x808627bd}, {0x80862670}, {0x80868119}, {0x80862916}, {0x80863a18}, {0x80863b00}, {0x80863b01}, {0x80863b02}, {0x80863b09}, {0x10de0aac}, {0x10de0aae}, {0x10de0aaf}, {0x10de0d80}, {0x10de0d81}, {0x10de0d82}, {0x10de0d83}, //SB {0x80861c42}, {0x80861c44}, {0x80861c4e}, {0x80861c4c}, {0x80861c50}, {0x80861c4a}, {0x80861c46}, {0x80861c5c}, {0x80861c52}, {0x80861c54}, {0x80861c56}, {0x80861c43}, {0x80861c4f}, {0x80861c47}, {0x80861c4b}, {0x80861c49}, {0x80861c41}, {0x80861c4d}, }; struct net_chipsets_t { UINT32 id; CONST CHAR8 *name; }; static struct net_chipsets_t NetChipsets[] = { { 0x00000000, "Unknown" }, // 8169 { 0x10EC8169, "Realtek 8169/8110 Gigabit Ethernet" }, { 0x10EC8168, "Realtek 8168/8101E Gigabit Ethernet" }, { 0x10EC8167, "Realtek 8169/8110 Gigabit Ethernet" }, { 0x10EC8136, "Realtek 8168/8101E Gigabit Ethernet" }, // 8139 { 0x10EC8139, "Realtek RTL8139/810x Family Fast Ethernet" }, { 0x11861300, "Realtek RTL8139/810x Family Fast Ethernet" }, { 0x11131211, "Realtek RTL8139/810x Family Fast Ethernet" }, // Broadcom 57XX { 0x14e41600, "Broadcom 5751 Ethernet" }, { 0x14e41659, "Broadcom 57XX Ethernet" }, { 0x14e4165A, "BCM5722 NetXtreme Server Gigabit Ethernet" }, { 0x14e4166A, "Broadcom 57XX Ethernet" }, { 0x14e41672, "BCM5754M NetXtreme Gigabit Ethernet" }, { 0x14e41673, "BCM5755M NetXtreme Gigabit Ethernet" }, { 0x14e4167A, "BCM5754 NetXtreme Gigabit Ethernet" }, { 0x14e4167B, "BCM5755 NetXtreme Gigabit Ethernet" }, { 0x14e41684, "Broadcom 57XX Ethernet" }, { 0x14e41691, "BCM57788 NetLink (TM) Gigabit Ethernet" }, { 0x14e41693, "BCM5787M NetLink (TM) Gigabit Ethernet" }, { 0x14e4169B, "BCM5787 NetLink (TM) Gigabit Ethernet" }, { 0x14e416B4, "Broadcom 57XX Ethernet" }, { 0x14e416B5, "BCM57785 Gigabit Ethernet PCIe" }, { 0x14e41712, "BCM5906 NetLink (TM) Fast Ethernet" }, { 0x14e41713, "BCM5906M NetLink (TM) Fast Ethernet" }, // Intel 8255x Ethernet { 0x80861051, "Intel 8255x Ethernet" }, { 0x80861050, "Intel 8255x Ethernet" }, { 0x80861029, "Intel 8255x Ethernet" }, { 0x80861030, "Intel 8255x Ethernet" }, { 0x80861209, "Intel 8255x Ethernet" }, { 0x80861227, "Intel 8255x Ethernet" }, { 0x80861228, "Intel 8255x Ethernet" }, { 0x80861229, "Intel 8255x Ethernet" }, { 0x80861503, "Intel 82579V Gigabit Network Controller" }, { 0x80862449, "Intel 8255x Ethernet" }, { 0x80862459, "Intel 8255x Ethernet" }, { 0x8086245D, "Intel 8255x Ethernet" }, { 0x80861091, "Intel 8255x Ethernet" }, { 0x80861060, "Intel 8255x Ethernet" }, // Atheros AR8151 Ethernet { 0x19691083, "Qualcomm Atheros AR8151 v2.0 Gigabit Ethernet" }, }; struct ide_chipsets_t { UINT32 id; }; static struct ide_chipsets_t ide_chipset[] = { // IDE {0x00000000}, // {0x8086269e}, {0x808627df}, {0x80862850}, //SATA {0x80862680}, {0x808627c0}, {0x808627c4}, {0x80862828}, }; //2820? 2825? /* struct ahci_chipsets_t { UINT32 id; }; static struct ahci_chipsets_t ahci_chipset[] = { // SATA AHCI {0x00000000}, // {0x80863a22}, {0x80862681}, {0x80862682}, {0x808627c5}, {0x80862825}, {0x80862829}, {0x80863b29}, {0x80863b22}, {0x80863b2f}, {0x80861c02}, {0x80861c03}, {0x10de0ab9}, {0x10de0b88}, }; */ UINT8 dtgp[] = // Method (DTGP, 5, NotSerialized) ...... { 0x14, 0x3F, 0x44, 0x54, 0x47, 0x50, 0x05, 0xA0, 0x30, 0x93, 0x68, 0x11, 0x13, 0x0A, 0x10, 0xC6, 0xB7, 0xB5, 0xA0, 0x18, 0x13, 0x1C, 0x44, 0xB0, 0xC9, 0xFE, 0x69, 0x5E, 0xAF, 0x94, 0x9B, 0xA0, 0x18, 0x93, 0x69, 0x01, 0xA0, 0x0C, 0x93, 0x6A, 0x00, 0x70, 0x11, 0x03, 0x01, 0x03, 0x6C, 0xA4, 0x01, 0xA0, 0x06, 0x93, 0x6A, 0x01, 0xA4, 0x01, 0x70, 0x11, 0x03, 0x01, 0x00, 0x6C, 0xA4, 0x00 }; UINT8 sbus1[] = { // Device (SBUS) _ADR,1F0003 size=E9+2=EB 0x5B, 0x82, 0x49, 0x0E, 0x53, 0x42, 0x55, 0x53, // 00000080 "[.I.SBUS" 0x08, 0x5F, 0x41, 0x44, 0x52, 0x0C, // 00000088 "._ADR." 0x03, 0x00, 0x1F, 0x00, 0x5B, 0x82, 0x4B, 0x05, // 00000090 "....[.K." 0x42, 0x55, 0x53, 0x30, 0x08, 0x5F, 0x43, 0x49, // 00000098 "BUS0._CI" 0x44, 0x0D, 0x73, 0x6D, 0x62, 0x75, 0x73, 0x00, // 000000A0 "D.smbus." 0x08, 0x5F, 0x41, 0x44, 0x52, 0x00, 0x5B, 0x82, // 000000A8 "._ADR.[." 0x41, 0x04, 0x44, 0x56, 0x4C, 0x30, 0x08, 0x5F, // 000000B0 "A.DVL0._" 0x41, 0x44, 0x52, 0x0A, 0x57, 0x08, 0x5F, 0x43, // 000000B8 "ADR.W._C" 0x49, 0x44, 0x0D, 0x64, 0x69, 0x61, 0x67, 0x73, // 000000C0 "ID.diags" 0x76, 0x61, 0x75, 0x6C, 0x74, 0x00, 0x14, 0x22, // 000000C8 "vault.."" 0x5F, 0x44, 0x53, 0x4D, 0x04, 0x70, 0x12, 0x0D, // 000000D0 "_DSM.p.." 0x02, 0x0D, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, // 000000D8 "..addres" 0x73, 0x00, 0x0A, 0x57, 0x60, 0x44, 0x54, 0x47, // 000000E0 "s..W`DTG" 0x50, 0x68, 0x69, 0x6A, 0x6B, 0x71, 0x60, 0xA4, // 000000E8 "Phijkq`." 0x60, 0x14, 0x4B, 0x07, 0x5F, 0x44, 0x53, 0x4D, // 000000F0 "`.K._DSM" 0x04, 0x70, 0x12, 0x45, 0x06, 0x08, 0x0D, 0x62, // 000000F8 ".p.E...b" 0x75, 0x69, 0x6C, 0x74, 0x2D, 0x69, 0x6E, 0x00, // 00000100 "uilt-in." 0x11, 0x03, 0x01, 0x01, 0x0D, 0x64, 0x65, 0x76, // 00000108 ".....dev" 0x69, 0x63, 0x65, 0x2D, 0x69, 0x64, 0x00, 0x11, // 00000110 "ice-id.." 0x07, 0x0A, 0x04, 0x30, 0x3A, 0x00, 0x00, 0x0D, // 00000118 "...0:..." 0x6D, 0x6F, 0x64, 0x65, 0x6C, 0x00, 0x11, 0x1E, // 00000120 "model..." 0x0A, 0x1B, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x20, // 00000128 "..Intel " 0x38, 0x32, 0x38, 0x30, 0x31, 0x4A, 0x49, 0x20, // 00000130 "82801JI " 0x49, 0x43, 0x48, 0x31, 0x30, 0x20, 0x46, 0x61, // 00000138 "ICH10 Fa" 0x6D, 0x69, 0x6C, 0x79, 0x00, 0x0D, 0x6E, 0x61, // 00000140 "mily..na" 0x6D, 0x65, 0x00, 0x11, 0x14, 0x0A, 0x11, 0x53, // 00000148 "me.....S" 0x4D, 0x42, 0x75, 0x73, 0x20, 0x63, 0x6F, 0x6E, // 00000150 "MBus con" 0x74, 0x72, 0x6F, 0x6C, 0x6C, 0x65, 0x72, 0x00, // 00000158 "troller." 0x60, 0x44, 0x54, 0x47, 0x50, 0x68, 0x69, 0x6A, // 00000160 "`DTGPhij" 0x6B, 0x71, 0x60, 0xA4, 0x60 }; UINT8 bus0[] = { //size=5B+2=5D 0x5B, 0x82, 0x4B, 0x05, 0x42, 0x55, 0x53, 0x30, 0x08, 0x5F, 0x43, 0x49, 0x44, 0x0D, 0x73, 0x6D, 0x62, 0x75, 0x73, 0x00, 0x08, 0x5F, 0x41, 0x44, 0x52, 0x00, 0x5B, 0x82, 0x41, 0x04, 0x44, 0x56, 0x4C, 0x30, 0x08, 0x5F, 0x41, 0x44, 0x52, 0x0A, 0x57, 0x08, 0x5F, 0x43, 0x49, 0x44, 0x0D, 0x64, 0x69, 0x61, 0x67, 0x73, 0x76, 0x61, 0x75, 0x6C, 0x74, 0x00, 0x14, 0x22, 0x5F, 0x44, 0x53, 0x4D, 0x04, 0x70, 0x12, 0x0D, 0x02, 0x0D, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x00, 0x0A, 0x57, 0x60, 0x44, 0x54, 0x47, 0x50, 0x68, 0x69, 0x6A, 0x6B, 0x71, 0x60, 0xA4, 0x60 }; UINT8 patafix[] = { /* OperationRegion (IDET, PCI_Config, 0x40, 0x04) Field (IDET, WordAcc, NoLock, Preserve) { M1, 8, M2, 8, M3, 8, M4, 8 } Method (_INI, 0, NotSerialized) { Store (0x07, M1) Store (0xE3, M2) Store (Zero, M3) Store (0xC0, M4) Return (Zero) } */ 0x5B, 0x80, 0x49, 0x44, 0x45, 0x54, 0x02, 0x0A, 0x40, //000001C0 ".IDET..@" 0x0A, 0x04, 0x5B, 0x81, 0x1A, 0x49, 0x44, 0x45, //000001C8 "..[..IDE" 0x54, 0x02, 0x4D, 0x31, 0x5F, 0x5F, 0x08, 0x4D, //000001D0 "T.M1__.M" 0x32, 0x5F, 0x5F, 0x08, 0x4D, 0x33, 0x5F, 0x5F, //000001D8 "2__.M3__" 0x08, 0x4D, 0x34, 0x5F, 0x5F, 0x08, 0x14, 0x23, //000001E0 ".M4__..#" 0x5F, 0x49, 0x4E, 0x49, 0x00, 0x70, 0x0A, 0x07, //000001E8 "_INI.p.." 0x4D, 0x31, 0x5F, 0x5F, 0x70, 0x0A, 0xE3, 0x4D, //000001F0 "M1__p..M" 0x32, 0x5F, 0x5F, 0x70, 0x00, 0x4D, 0x33, 0x5F, //000001F8 "2__p.M3_" 0x5F, 0x70, 0x0A, 0xC0, 0x4D, 0x34, 0x5F, 0x5F, //00000200 "_p..M4__" 0xA4, 0x00 //00000208 ".." }; UINT8 hpet0[] = { 0x5B, 0x82, 0x3A, 0x48, 0x50, 0x45, 0x54, // Device (HPET) 0x08, 0x5F, 0x48, 0x49, 0x44, 0x0C, 0x41, 0xD0, 0x01, 0x03, // Name (_HID, EisaId ("PNP0103")) 0x08, 0x5F, 0x43, 0x49, 0x44, 0x0C, 0x41, 0xD0, 0x0C, 0x01, // Name (_CID, EisaId ("PNP0C01")) 0x08, 0x5F, 0x53, 0x54, 0x41, 0x0A, 0x0F, // Name (_STA, 0x0F) 0x08, 0x5F, 0x43, 0x52, 0x53, 0x11, 0x14, 0x0A, 0x11, // Name (_CRS, ResourceTemplate () 0x22, 0x01, 0x09, 0x86, 0x09, 0x00, 0x01, // IRQNoFlags () {0,8,11} 0x00, 0x00, 0xD0, 0xFE, 0x00, 0x04, 0x00, 0x00, // Memory32Fixed (ReadWrite, 0x79, 0x00 // 0xFED00000, 0x00000400 ) /* 0x5B, 0x82, 0x47, 0x04, 0x48, 0x50, 0x45, 0x54, //Device (HPET) 0x08, 0x5F, 0x48, 0x49, 0x44, 0x0C, 0x41, 0xD0, 0x01, 0x03, //Name (_HID, EisaId ("PNP0103")) 0x08, 0x5F, 0x43, 0x49, 0x44, 0x0C, 0x41, 0xD0, 0x0C, 0x01, //Name (_CID, EisaId ("PNP0C01")) 0x08, 0x41, 0x54, 0x54, 0x30, 0x11, 0x14, 0x0A, 0x11, //Name (ATT0, ResourceTemplate () 0x86, 0x09, 0x00, 0x01, // Memory32Fixed (ReadWrite, 0x00, 0x00, 0xD0, 0xFE, 0x00, 0x04, 0x00, 0x00, // 0xFED00000, 0x00000400, ) 0x22, 0x01, 0x09, 0x79, 0x00, // IRQNoFlags () {0,8,11} // 0x14, 0x09, 0x5F, 0x53, 0x54, 0x41, 0x00, //Method (_STA, 0, NotSerialized) // 0xA4, 0x0A, 0x0F, // Return (0x0F) 0x08, 0x5F, 0x53, 0x54, 0x41, 0x0A, 0x0F, // Name (_STA, 0x0F) 0x14, 0x0B, 0x5F, 0x43, 0x52, 0x53, 0x00, //Method (_CRS, 0, NotSerialized) 0xA4, 0x41, 0x54, 0x54, 0x30 // Return (ATT0) */ }; /* UINT8 hpet1[] = // Name (_CID, EisaId ("PNP0C01")) { 0x08, 0x5F, 0x43, 0x49, 0x44, 0x0C, 0x41, 0xD0, 0x0C, 0x01 }; */ const UINT8 wakret[] = { 0xA4, 0x12, 0x04, 0x02, 0x00, 0x00 }; //const UINT8 wakslp1[] = { 0x5B, 0x80, 0x50, 0x4D, 0x33, 0x30, 0x01 }; //const UINT8 wakslp2[] = { 0x0A, 0x08, 0x5B, 0x81, 0x0D, 0x50, 0x4D, 0x33, 0x30, 0x01, // 0x00, 0x04, 0x53, 0x4C, 0x4D, 0x45, 0x01, 0x70, 0x00, 0x53, 0x4C, 0x4D, 0x45 }; const UINT8 waksecur[] = {0xA0, 0x0D, 0x91, 0x95, 0x68, 0x01, 0x94, 0x68, 0x0A, 0x05, 0x70, 0x0A, 0x03, 0x68}; //const UINT8 pwrb[] = { //? \_SB_PWRB, 0x02 // 0x86, 0x5C, 0x2E, 0x5F, 0x53, 0x42, 0x5F, 0x50, 0x57, 0x52, 0x42, 0x0A, 0x02 //}; const UINT8 acpi3[] = { //Name(_HID, "ACPI003") 0x08, 0x5F, 0x48, 0x49, 0x44, 0x0D, 0x41, 0x43, 0x50, 0x49, 0x30, 0x30, 0x30, 0x33, 0x00 }; //Name (_PRW, Package (0x02){0x1C, 0x03} const UINT8 prw1c[] = { 0x08, 0x5F, 0x50, 0x52, 0x57, 0x12, 0x06, 0x02, 0x0A, 0x1C, 0x0A, 0x03 }; const UINT8 dtgp_1[] = { // DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0)) // Return (Local0) 0x44, 0x54, 0x47, 0x50, 0x68, 0x69, 0x6A, 0x6B, 0x71, 0x60, 0xA4, 0x60 }; //const UINT8 pwrbcid[] = { // 0x08, 0x5F, 0x43, 0x49, 0x44, 0x0C, 0x41, 0xD0, 0x0C, 0x0E, 0x14, // 0x0E, 0x5F, 0x50, 0x52, 0x57, 0x00, 0xA4, 0x12, 0x06, 0x02, 0x0A, // 0x0B, 0x0A, 0x04 //}; //const UINT8 pwrbprw[] = { // 0x14, 0x0E, 0x5F, 0x50, 0x52, 0x57, 0x00, 0xA4, 0x12, 0x06, 0x02, // 0x0A, 0x0B, 0x0A, 0x04 //}; const UINT8 shutdown0[] = { 0xA0, 0x05, 0x93, 0x68, 0x0A, 0x05, 0xA1, 0x01 }; const UINT8 shutdown1[] = { 0xA0, 0x0F, 0x91, 0x91, 0x93, 0x68, 0x0A, 0x03, 0x93, 0x68, 0x0A, 0x04, 0x93, 0x68, 0x0A, 0x05, 0xA1, 0x01 }; const UINT8 pnlf[] = { 0x5B, 0x82, 0x2D, 0x50, 0x4E, 0x4C, 0x46, //Device (PNLF) 0x08, 0x5F, 0x48, 0x49, 0x44, 0x0C, 0x06, 0x10, 0x00, 0x02, // Name (_HID, EisaId ("APP0002")) 0x08, 0x5F, 0x43, 0x49, 0x44, // Name (_CID, 0x0D, 0x62, 0x61, 0x63, 0x6B, 0x6C, 0x69, 0x67, 0x68, 0x74, 0x00, // "backlight") 0x08, 0x5F, 0x55, 0x49, 0x44, 0x0A, 0x0A, // Name (_UID, 0x0A) 0x08, 0x5F, 0x53, 0x54, 0x41, 0x0A, 0x0B // Name (_STA, 0x0B) }; ////Scope (_SB.PCI0.LPCB) //const UINT8 pnlfLPC[] = { // 0x10, 0x3e, 0x2f, 0x03, 0x5f, 0x53, 0x42, 0x5f, 0x50, 0x43, 0x49, 0x30, 0x4c, 0x50, 0x43, 0x42, // 0x5b, 0x82, 0x2d, 0x50, 0x4e, 0x4c, 0x46, 0x08, 0x5f, 0x48, 0x49, // 0x44, 0x0c, 0x06, 0x10, 0x00, 0x02, 0x08, 0x5f, 0x43, 0x49, 0x44, 0x0d, // 0x62, 0x61, 0x63, 0x6b, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x00, 0x08, 0x5f, // 0x55, 0x49, 0x44, 0x0a, 0x0a, 0x08, 0x5f, 0x53, 0x54, 0x41, 0x0a, 0x0b //}; const UINT8 app2[] = { //Name (_HID, EisaId("APP0002")) 0x08, 0x5F, 0x48, 0x49, 0x44, 0x0C, 0x06, 0x10, 0x00, 0x02 }; UINT8 darwin[] = //it is not const { //addresses shifted by 0x24 0x08, 0x56, 0x45, 0x52, // 00000020 " .. .VER" 0x30, 0x0D, 0x43, 0x6C, 0x6F, 0x76, 0x65, 0x72, // 00000028 "0.Clover" 0x20, 0x61, 0x75, 0x74, 0x6F, 0x70, 0x61, 0x74, // 00000030 " autopat" 0x63, 0x68, 0x65, 0x64, 0x00, 0x08, 0x57, 0x58, // 00000038 "ched..WX" 0x50, 0x31, 0x0D, 0x57, 0x69, 0x6E, 0x64, 0x6F, // 00000040 "P1.Windo" 0x77, 0x73, 0x20, 0x32, 0x30, 0x30, 0x31, 0x00, // 00000048 "ws 2001." 0x14, 0x12, 0x47, 0x45, 0x54, 0x39, 0x02, 0x8C, // 00000050 "..GET9.." 0x68, 0x69, 0x54, 0x43, 0x48, 0x39, 0xA4, 0x54, // 00000058 "hiTCH9.T" 0x43, 0x48, 0x39, 0x14, 0x40, 0x05, 0x53, 0x54, // 00000060 "CH9.@.ST" 0x52, 0x39, 0x02, 0x08, 0x53, 0x54, 0x52, 0x38, // 00000068 "R9..STR8" 0x11, 0x03, 0x0A, 0x50, 0x08, 0x53, 0x54, 0x52, // 00000070 "...P.STR" 0x39, 0x11, 0x03, 0x0A, 0x50, 0x70, 0x68, 0x53, // 00000078 "9...PphS" 0x54, 0x52, 0x38, 0x70, 0x69, 0x53, 0x54, 0x52, // 00000080 "TR8piSTR" 0x39, 0x70, 0x00, 0x60, 0x70, 0x01, 0x61, 0xA2, // 00000088 "9p.`p.a." 0x22, 0x61, 0x70, 0x47, 0x45, 0x54, 0x39, 0x53, // 00000090 ""apGET9S" 0x54, 0x52, 0x38, 0x60, 0x61, 0x70, 0x47, 0x45, // 00000098 "TR8`apGE" 0x54, 0x39, 0x53, 0x54, 0x52, 0x39, 0x60, 0x62, // 000000A0 "T9STR9`b" 0xA0, 0x07, 0x92, 0x93, 0x61, 0x62, 0xA4, 0x00, // 000000A8 "....ab.." 0x75, 0x60, 0xA4, 0x01, 0x14, 0x15, 0x4F, 0x4F, // 000000B0 "u`....OO" 0x53, 0x49, 0x01, 0xA0, 0x0C, 0x53, 0x54, 0x52, // 000000B8 "SI...STR" 0x39, 0x57, 0x58, 0x50, 0x31, 0x68, 0xA4, 0x01, // 000000C0 "9WXP1h.." 0xA4, 0x00 // 000000C8 ".." }; BOOLEAN CmpNum(UINT8 *dsdt, INT32 i, BOOLEAN Sure) { return ((Sure && ((dsdt[i-1] == 0x0A) || (dsdt[i-2] == 0x0B) || (dsdt[i-4] == 0x0C))) || (!Sure && (((dsdt[i-1] >= 0x0A) && (dsdt[i-1] <= 0x0C)) || ((dsdt[i-2] == 0x0B) || (dsdt[i-2] == 0x0C)) || (dsdt[i-4] == 0x0C)))); } // for HDA from device_inject.c and mark device_inject function //extern UINT32 HDA_IC_sendVerb(EFI_PCI_IO_PROTOCOL *PciIo, UINT32 codecAdr, UINT32 nodeId, UINT32 verb); BOOLEAN get_lpc_model(UINT32 id) { UINTN i; for (i=1; i< (sizeof(lpc_chipset) / sizeof(lpc_chipset[0])); i++) { if (lpc_chipset[i].id == id) { return FALSE; } } return TRUE; } BOOLEAN get_ide_model(UINT32 id) { UINTN i; for (i=1; i< (sizeof(ide_chipset) / sizeof(ide_chipset[0])); i++) { if (ide_chipset[i].id == id) { return FALSE; } } return TRUE; } /* BOOLEAN get_ahci_model(UINT32 id) { UINTN i; for (i=1; i< (sizeof(ahci_chipset) / sizeof(ahci_chipset[0])); i++) { if (ahci_chipset[i].id == id) { return FALSE; } } return TRUE; } */ CONST CHAR8* get_net_model(UINT32 id) { UINTN i; for (i=1; i< (sizeof(NetChipsets) / sizeof(NetChipsets[0])); i++) { if (NetChipsets[i].id == id) { return NetChipsets[i].name; } } return NetChipsets[0].name; } VOID GetPciADR(IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, OUT UINT32 *Addr1, OUT UINT32 *Addr2, OUT UINT32 *Addr3) { PCI_DEVICE_PATH *PciNode; UINTN PciNodeCount; EFI_DEVICE_PATH_PROTOCOL *TmpDevicePath = DuplicateDevicePath(DevicePath); // default to 0 if (Addr1 != NULL) *Addr1 = 0; if (Addr2 != NULL) *Addr2 = 0xFFFE; //some code we will consider as "non-exists" b/c 0 is meaningful value // as well as 0xFFFF if (Addr3 != NULL) *Addr3 = 0xFFFE; if (!TmpDevicePath) { return; } // sanity check - expecting ACPI path for PciRoot if (TmpDevicePath->Type != ACPI_DEVICE_PATH && TmpDevicePath->SubType != ACPI_DP) { FreePool(TmpDevicePath); return; } PciNodeCount = 0; while (TmpDevicePath && !IsDevicePathEndType(TmpDevicePath)) { if (TmpDevicePath->Type == HARDWARE_DEVICE_PATH && TmpDevicePath->SubType == HW_PCI_DP) { PciNodeCount++; PciNode = (PCI_DEVICE_PATH *)TmpDevicePath; if (PciNodeCount == 1 && Addr1 != NULL) { *Addr1 = (PciNode->Device << 16) | PciNode->Function; } else if (PciNodeCount == 2 && Addr2 != NULL) { *Addr2 = (PciNode->Device << 16) | PciNode->Function; } else if (PciNodeCount == 3 && Addr3 != NULL) { *Addr3 = (PciNode->Device << 16) | PciNode->Function; } else { break; } } TmpDevicePath = NextDevicePathNode(TmpDevicePath); } return; } /* Discussion Native USB mean for those chipsets IOUSBFamily set some "errata" for example native 0x1cXX has no such errata */ BOOLEAN NativeUSB(UINT16 DID) { UINT16 d = DID & 0xFF00; return ((d == 0x2600) || (d == 0x2700) || (d == 0x2800) || (d == 0x3a00) || (d == /*NFORCE_USB->*/0x0a00)); } VOID CheckHardware() { EFI_STATUS Status; EFI_HANDLE *HandleBuffer = NULL; EFI_HANDLE Handle; EFI_PCI_IO_PROTOCOL *PciIo; PCI_TYPE00 Pci; UINTN HandleCount = 0; UINTN HandleIndex; UINTN Segment; UINTN Bus; UINTN Device; UINTN Function; UINTN display=0; // pci_dt_t PCIdevice; EFI_DEVICE_PATH_PROTOCOL *DevicePath = NULL; usb=0; // Scan PCI handles Status = gBS->LocateHandleBuffer ( ByProtocol, &gEfiPciIoProtocolGuid, NULL, &HandleCount, &HandleBuffer ); if (!EFI_ERROR(Status)) { // DBG("PciIo handles count=%d\n", HandleCount); for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) { Handle = HandleBuffer[HandleIndex]; Status = gBS->HandleProtocol ( Handle, &gEfiPciIoProtocolGuid, (VOID **)&PciIo ); if (!EFI_ERROR(Status)) { UINT32 deviceid; /* Read PCI BUS */ PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function); Status = PciIo->Pci.Read ( PciIo, EfiPciIoWidthUint32, 0, sizeof (Pci) / sizeof (UINT32), &Pci ); deviceid = Pci.Hdr.DeviceId | (Pci.Hdr.VendorId << 16); // add for auto patch dsdt get DSDT Device _ADR // PCIdevice.DeviceHandle = Handle; DevicePath = DevicePathFromHandle (Handle); if (DevicePath) { // DBG("Device patch = %ls \n", DevicePathToStr(DevicePath)); //Display ADR if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_DISPLAY) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_DISPLAY_VGA)) { #if DEBUG_FIX UINT32 dadr1, dadr2; #endif // PCI_IO_DEVICE *PciIoDevice; GetPciADR(DevicePath, &DisplayADR1[display], &DisplayADR2[display], NULL); DBG("VideoCard devID=0x%X\n", ((Pci.Hdr.DeviceId << 16) | Pci.Hdr.VendorId)); #if DEBUG_FIX dadr1 = DisplayADR1[display]; dadr2 = DisplayADR2[display]; DBG("DisplayADR1[%llu] = 0x%X, DisplayADR2[%llu] = 0x%X\n", display, dadr1, display, dadr2); #endif // dadr2 = dadr1; //to avoid warning "unused variable" :( DisplayVendor[display] = Pci.Hdr.VendorId; DisplayID[display] = Pci.Hdr.DeviceId; DisplaySubID[display] = (Pci.Device.SubsystemID << 16) | (Pci.Device.SubsystemVendorID << 0); // for get display data Displaydevice[display].DeviceHandle = HandleBuffer[HandleIndex]; Displaydevice[display].dev.addr = (UINT32)PCIADDR(Bus, Device, Function); Displaydevice[display].vendor_id = Pci.Hdr.VendorId; Displaydevice[display].device_id = Pci.Hdr.DeviceId; Displaydevice[display].revision = Pci.Hdr.RevisionID; Displaydevice[display].subclass = Pci.Hdr.ClassCode[0]; Displaydevice[display].class_id = *((UINT16*)(Pci.Hdr.ClassCode+1)); Displaydevice[display].subsys_id.subsys.vendor_id = Pci.Device.SubsystemVendorID; Displaydevice[display].subsys_id.subsys.device_id = Pci.Device.SubsystemID; // // Detect if PCI Express Device // // // Go through the Capability list //unused /* PciIoDevice = PCI_IO_DEVICE_FROM_PCI_IO_THIS (PciIo); if (PciIoDevice->IsPciExp) { if (display==0) Display1PCIE = TRUE; else Display2PCIE = TRUE; } DBG("Display %d is %sPCIE\n", display, (PciIoDevice->IsPciExp) ? "" :" not"); */ display++; } //Network ADR if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_NETWORK) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_NETWORK_ETHERNET)) { GetPciADR(DevicePath, &NetworkADR1[net_count], &NetworkADR2[net_count], NULL); // DBG("NetworkADR1 = 0x%X, NetworkADR2 = 0x%X\n", NetworkADR1, NetworkADR2); // Netmodel = get_net_model(deviceid); Netmodel[net_count] = get_net_model(deviceid); net_count++; } //Network WiFi ADR if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_NETWORK) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_NETWORK_OTHER)) { GetPciADR(DevicePath, &ArptADR1, &ArptADR2, NULL); // DBG("ArptADR1 = 0x%X, ArptADR2 = 0x%X\n", ArptADR1, ArptADR2); // Netmodel = get_arpt_model(deviceid); ArptBCM = (Pci.Hdr.VendorId == 0x14e4); if (ArptBCM) { DBG("Found Airport BCM at 0x%X, 0x%X\n", ArptADR1, ArptADR2); } ArptAtheros = (Pci.Hdr.VendorId == 0x168c); ArptDID = Pci.Hdr.DeviceId; if (ArptAtheros) { DBG("Found Airport Atheros at 0x%X, 0x%X, DeviceID=0x%04hX\n", ArptADR1, ArptADR2, ArptDID); } } //Firewire ADR if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_SERIAL) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_SERIAL_FIREWIRE)) { GetPciADR(DevicePath, &FirewireADR1, &FirewireADR2, NULL); // DBG("FirewireADR1 = 0x%X, FirewireADR2 = 0x%X\n", FirewireADR1, FirewireADR2); } //SBUS ADR if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_SERIAL) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_SERIAL_SMB)) { GetPciADR(DevicePath, &SBUSADR1, &SBUSADR2, NULL); // DBG("SBUSADR1 = 0x%X, SBUSADR2 = 0x%X\n", SBUSADR1, SBUSADR2); } //IMEI ADR if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_SCC) && (Pci.Hdr.ClassCode[1] == PCI_SUBCLASS_SCC_OTHER)) { GetPciADR(DevicePath, &IMEIADR1, &IMEIADR2, NULL); } //USB if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_SERIAL) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_SERIAL_USB) && (Pci.Hdr.ClassCode[0] != 0xFE)) { UINT16 DID = Pci.Hdr.DeviceId; USBIntel = (Pci.Hdr.VendorId == 0x8086); USBNForce = (Pci.Hdr.VendorId == 0x10de); GetPciADR(DevicePath, &USBADR[usb], &USBADR2[usb], &USBADR3[usb]); DBG("USBADR[%llu] = 0x%X and PCIe = 0x%X\n", usb, USBADR[usb], USBADR2[usb]); if (USBIDFIX) { if (USBADR[usb] == 0x001D0000 && !NativeUSB(DID)) DID = 0x3a34; if (USBADR[usb] == 0x001D0001 && !NativeUSB(DID)) DID = 0x3a35; if (USBADR[usb] == 0x001D0002 && !NativeUSB(DID)) DID = 0x3a36; if (USBADR[usb] == 0x001D0003 && !NativeUSB(DID)) DID = 0x3a37; if (USBADR[usb] == 0x001A0000 && !NativeUSB(DID)) DID = 0x3a37; if (USBADR[usb] == 0x001A0001 && !NativeUSB(DID)) DID = 0x3a38; if (USBADR[usb] == 0x001A0002 && !NativeUSB(DID)) DID = 0x3a39; if (USBADR[usb] == 0x001D0007 && !NativeUSB(DID)) DID = 0x3a3a; if (USBADR[usb] == 0x001A0007 && !NativeUSB(DID)) DID = 0x3a3c; //NFORCE_USB_START if (USBADR3[usb] == 0x00040000 && !NativeUSB(DID)) DID = 0x0aa5; if (USBADR3[usb] == 0x00040001 && !NativeUSB(DID)) DID = 0x0aa6; if (USBADR3[usb] == 0x00060000 && !NativeUSB(DID)) DID = 0x0aa7; if (USBADR3[usb] == 0x00060001 && !NativeUSB(DID)) DID = 0x0aa9; //NFORCE_USB_END } USBID[usb] = DID; USB20[usb] = (Pci.Hdr.ClassCode[0] == 0x20)?1:0; USB30[usb] = (Pci.Hdr.ClassCode[0] == 0x30)?1:0; USB40[usb] = ((Pci.Hdr.ClassCode[0] == 0x20) && USBNForce)?1:0; usb++; } // HDA and HDMI Audio if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_MEDIA) && ((Pci.Hdr.ClassCode[1] == PCI_CLASS_MEDIA_HDA) || (Pci.Hdr.ClassCode[1] == PCI_CLASS_MEDIA_AUDIO))) { UINT32 codecId = 0, layoutId = 0; if (!IsHDMIAudio(Handle)) { // if ((Pci.Hdr.VendorId == 0x8086) && // ((Pci.Hdr.DeviceId & 0xFF00) != 0x0C00)) { //0x0C0C is HDMI sound GetPciADR(DevicePath, &HDAADR1, NULL, NULL); if (gSettings.HDALayoutId > 0) { // layoutId is specified - use it layoutId = (UINT32)gSettings.HDALayoutId; DBG("Audio HDA (addr:0x%X) setting specified layout-id=%d (0x%X)\n", HDAADR1, layoutId, layoutId); } HDAFIX = TRUE; HDAcodecId = codecId; HDAlayoutId = layoutId; } else { //HDMI GetPciADR(DevicePath, &HDMIADR1, &HDMIADR2, NULL); GFXHDAFIX = TRUE; } } // LPC if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_BRIDGE) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_BRIDGE_ISA)) { LPCBFIX = get_lpc_model(deviceid); } // IDE device if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_MASS_STORAGE) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_MASS_STORAGE_IDE)) { GetPciADR(DevicePath, &IDEADR1, &IDEADR2, NULL); // DBG("IDEADR1 = 0x%X, IDEADR2 = 0x%X\n", IDEADR1, IDEADR2); IDEFIX = get_ide_model(deviceid); IDEVENDOR = Pci.Hdr.VendorId; } // SATA if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_MASS_STORAGE) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_MASS_STORAGE_SATADPA) && (Pci.Hdr.ClassCode[0] == 0x00)) { GetPciADR(DevicePath, &SATAADR1, &SATAADR2, NULL); // DBG("SATAADR1 = 0x%X, SATAADR2 = 0x%X\n", SATAADR1, SATAADR2); SATAFIX = get_ide_model(deviceid); SATAVENDOR = Pci.Hdr.VendorId; } // SATA AHCI if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_MASS_STORAGE) && (Pci.Hdr.ClassCode[1] == PCI_CLASS_MASS_STORAGE_SATADPA) && (Pci.Hdr.ClassCode[0] == 0x01)) { GetPciADR(DevicePath, &SATAAHCIADR1, &SATAAHCIADR2, NULL); // DBG("SATAAHCIADR1 = 0x%X, SATAAHCIADR2 = 0x%X\n", SATAAHCIADR1, SATAAHCIADR2); // AHCIFIX = get_ahci_model(deviceid); SATAAHCIVENDOR = Pci.Hdr.VendorId; } } // detected finish } } } } UINT8 slash[] = {0x5c, 0}; VOID InsertScore(UINT8* dsdt, UINT32 off2, INTN root) { UINT8 NumNames = 0; UINT32 ind = 0, i; CHAR8 buf[31]; if (dsdt[off2 + root] == 0x2E) { NumNames = 2; off2 += (UINT32)(root + 1); } else if (dsdt[off2 + root] == 0x2F) { NumNames = dsdt[off2 + root + 1]; off2 += (UINT32)(root + 2); } else if (dsdt[off2 + root] != 0x00) { NumNames = 1; off2 += (UINT32)root; } if (NumNames > 4) { DBG(" strange NumNames=%d\n", NumNames); NumNames = 1; } NumNames *= 4; CopyMem(buf + ind, dsdt + off2, NumNames); ind += NumNames; // apianti - This generates a memcpy call /* for (i = 0; i < NumNames; i++) { buf[ind++] = dsdt[off2 + i]; } */ i = 0; while (i < 127) { buf[ind++] = acpi_cpu_score[i]; if (acpi_cpu_score[i] == 0) { break; } i++; } CopyMem(acpi_cpu_score, buf, ind); acpi_cpu_score[ind] = 0; } VOID findCPU(UINT8* dsdt, UINT32 length) { UINT32 i, k, size; UINT32 SBSIZE = 0, SBADR = 0; BOOLEAN SBFound = FALSE; UINT32 off2, j1; if (acpi_cpu_score) { FreePool(acpi_cpu_score); } acpi_cpu_score = (__typeof__(acpi_cpu_score))AllocateZeroPool(128); acpi_cpu_count = 0; // 5B 83 41 0C 5C 2E 5F 50 52 5F 43 50 55 30 01 10 // 10 00 00 06 //one another kind /* 5B 82 4D 95 53 43 4B 30 08 5F 48 49 44 0D 41 43 50 49 30 30 30 34 00 08 5F 55 49 44 0D 43 50 55 53 43 4B 30 00 08 53 43 4B 4E 00 08 4C 53 54 41 0A FF 14 28 5F 53 54 41 00 70 0D 43 50 55 53 43 4B 30 00 43 55 55 30 70 50 53 54 41 00 60 7B 60 0A 03 61 70 61 4C 53 54 41 A4 60 5B 83 4A 04 43 30 30 30 00 10 04 00 00 06 08 5F 48 49 44 0D 41 43 50 49 30 30 30 37 00 08 5F 55 49 44 0D 50 43 49 30 2D 43 50 30 30 30 00 08 5F 50 58 4D 00 // Device (SCK0) { Name (_HID, "ACPI0004") // _HID: Hardware ID Name (_UID, "CPUSCK0") // _UID: Unique ID Name (SCKN, Zero) Name (LSTA, 0xFF) Method (_STA, 0, NotSerialized) // _STA: Status { Store ("CPUSCK0", CUU0) Store (PSTA (Zero), Local0) And (Local0, 0x03, Local1) Store (Local1, LSTA) Return (Local0) } Processor (C000, 0x00, 0x00000410, 0x06) { Name (_HID, "ACPI0007") // _HID: Hardware ID Name (_UID, "PCI0-CP000") // _UID: Unique ID Name (_PXM, Zero) // _PXM: Device Proximity */ for (i = 0; i < length - 20; i++) { if (dsdt[i] == 0x5B && dsdt[i + 1] == 0x83) { // ProcessorOP UINT32 j; UINT32 offset = i + 3 + (dsdt[i + 2] >> 6); // name BOOLEAN add_name = TRUE; if (acpi_cpu_count == 0) { //only first time in the cycle CHAR8 c1 = dsdt[offset + 1]; // I want to determine a scope of PR //1. if name begin with \\ this is with score //2. else find outer device or scope until \\ is found //3. add new name everytime is found // DBG("first CPU found at %X offset %X\n", i, offset); if (dsdt[offset] == '\\') { // "\_PR.CPU0" j = 1; if (c1 == 0x2E) { j = 2; } else if (c1 == 0x2F) { c1 = dsdt[offset + 2]; j = 2 + (c1 - 2) * 4; } CopyMem(acpi_cpu_score, dsdt + offset + j, 4); // DBG("slash found\n"); } else { //-------- j = i - 1; //usually adr = &5B - 1 = sizefield - 3 while (j > 0x24) { //find devices that previous to adr //check device k = j + 2; if ((dsdt[j] == 0x5B) && (dsdt[j + 1] == 0x82) && !CmpNum(dsdt, j, TRUE)) { //device candidate // DBG("device candidate at %X\n", j); size = get_size(dsdt, k); if (size) { if (k + size > i + 3) { //Yes - it is outer off2 = j + 3 + (dsdt[j + 2] >> 6); if (dsdt[off2] == '\\') { // "\_SB.SCL0" InsertScore(dsdt, off2, 1); // DBG("acpi_cpu_score calculated as %s\n", acpi_cpu_score); break; } else { InsertScore(dsdt, off2, 0); // DBG("device inserted in acpi_cpu_score %s\n", acpi_cpu_score); } } //else not an outer device } //else wrong size field - not a device } //else not a device // check scope // a problem 45 43 4F 4E 08 10 84 10 05 5F 53 42 5F SBSIZE = 0; if ((dsdt[j] == '_' && dsdt[j + 1] == 'S' && dsdt[j + 2] == 'B' && dsdt[j + 3] == '_') || (dsdt[j] == '_' && dsdt[j + 1] == 'P' && dsdt[j + 2] == 'R' && dsdt[j + 3] == '_')) { // DBG("score candidate at %X\n", j); for (j1=0; j1 < 10; j1++) { if (dsdt[j - j1] != 0x10) { continue; } if (!CmpNum(dsdt, j - j1, TRUE)) { SBADR = j - j1 + 1; SBSIZE = get_size(dsdt, SBADR); // DBG("found Scope(\\_SB) address = 0x%08X size = 0x%08X\n", SBADR, SBSIZE); if ((SBSIZE != 0) && (SBSIZE < length)) { //if zero or too large then search more //if found k = SBADR - 6; if ((SBADR + SBSIZE) > i + 4) { //Yes - it is outer SBFound = TRUE; break; //SB found } //else not an outer scope } } } } //else not a scope if (SBFound) { InsertScore(dsdt, j, 0); // DBG("score inserted in acpi_cpu_score %s\n", acpi_cpu_score); break; } j = k - 3; //if found then search again from found } //while j //-------- } } for (j = 0; j < 4; j++) { CHAR8 c = dsdt[offset + j]; CHAR8 c1 = dsdt[offset + j + 1]; if(c == '\\') { offset += 5; if (c1 == 0x2E) { offset++; } else if (c1 == 0x2F) { c1 = dsdt[offset + j + 2]; offset += 2 + (c1 - 2) * 4; } c = dsdt[offset + j]; } if (!(IS_UPPER(c) || IS_DIGIT(c) || c == '_')) { add_name = FALSE; DBG("Invalid character found in ProcessorOP 0x%hhX!\n", c); break; } } if (add_name) { acpi_cpu_name[acpi_cpu_count] = (__typeof_am__(acpi_cpu_name[acpi_cpu_count]))AllocateZeroPool(5); CopyMem(acpi_cpu_name[acpi_cpu_count], dsdt+offset, 4); acpi_cpu_processor_id[acpi_cpu_count] = dsdt[offset + 4]; i = offset + 5; //if (acpi_cpu_count == 0) // acpi_cpu_p_blk = dsdt[i] | (dsdt[i+1] << 8); if (acpi_cpu_count == 0) { DBG("Found ACPI CPU: %s ", acpi_cpu_name[acpi_cpu_count]); } else { DBG("| %s ", acpi_cpu_name[acpi_cpu_count]); } if (++acpi_cpu_count == acpi_cpu_max) break; } } } DBG(", within the score: %s\n", acpi_cpu_score); if (!acpi_cpu_count) { for (i=0; i < acpi_cpu_max; i++) { acpi_cpu_name[i] = (__typeof_am__(acpi_cpu_name[i]))AllocateZeroPool(5); snprintf(acpi_cpu_name[i], 5, "CPU%X", i); acpi_cpu_processor_id[i] = (UINT8)(i & 0x7F); } } return; } // start => move data start address // offset => data move how many byte // len => initial length of the buffer // return final length of the buffer // we suppose that buffer allocation is more then len+offset UINT32 move_data(UINT32 start, UINT8* buffer, UINT32 len, INT32 offset) { UINT32 i; if (offset<0) { for (i=start; i0 && len >=1) { // data move to back for (i=len-1; i>=start; i--) { buffer[i+offset] = buffer[i]; } } return len + offset; } UINT32 get_size(UINT8* Buffer, UINT32 adr) { UINT32 temp; temp = Buffer[adr] & 0xF0; //keep bits 0x30 to check if this is valid size field if(temp <= 0x30) { // 0 temp = Buffer[adr]; } else if(temp == 0x40) { // 4 temp = (Buffer[adr] - 0x40) << 0| Buffer[adr+1] << 4; } else if(temp == 0x80) { // 8 temp = (Buffer[adr] - 0x80) << 0| Buffer[adr+1] << 4| Buffer[adr+2] << 12; } else if(temp == 0xC0) { // C temp = (Buffer[adr] - 0xC0) << 0| Buffer[adr+1] << 4| Buffer[adr+2] << 12| Buffer[adr+3] << 20; } else { // DBG("wrong pointer to size field at %X\n", adr); return 0; } return temp; } //return 1 if new size is two bytes else 0 UINT32 write_offset(UINT32 adr, UINT8* buffer, UINT32 len, INT32 offset) { UINT32 i, shift = 0; UINT32 size = offset + 1; if (size >= 0x3F) { for (i=len; i>adr; i--) { buffer[i+1] = buffer[i]; } shift = 1; size += 1; } aml_write_size(size, (CHAR8 *)buffer, adr); return shift; } /* adr - a place to write new size. Size of some object. buffer - the binary aml codes array len - its length sizeoffset - how much the object increased in size return address shift from original +/- n from outers When we increase the object size there is a chance that new size field +1 so out devices should also be corrected +1 and this may lead to new shift */ //Slice - I excluded check (oldsize <= 0x0fffff && size > 0x0fffff) //because I think size of DSDT will never be 1Mb INT32 write_size(UINT32 adr, UINT8* buffer, UINT32 len, INT32 sizeoffset) { UINT32 size, oldsize; INT32 offset = 0; oldsize = get_size(buffer, adr); if (!oldsize) { return 0; //wrong address, will not write here } size = oldsize + sizeoffset; // data move to back if (oldsize <= 0x3f && size > 0x0fff) { offset = 2; } else if ((oldsize <= 0x3f && size > 0x3f) || (oldsize<=0x0fff && size > 0x0fff)) { offset = 1; } // data move to front else if ((size <= 0x3f && oldsize > 0x3f) || (size<=0x0fff && oldsize > 0x0fff)) { offset = -1; } else if (oldsize > 0x0fff && size <= 0x3f) { offset = -2; } len = move_data(adr, buffer, len, offset); size += offset; aml_write_size(size, (CHAR8 *)buffer, adr); //reuse existing codes return offset; } INT32 FindName(UINT8 *dsdt, INT32 len, CONST CHAR8* name) { INT32 i; for (i = 0; len >= 5 && i < len-5; i++) { if ((dsdt[i] == 0x08) && (dsdt[i+1] == name[0]) && (dsdt[i+2] == name[1]) && (dsdt[i+3] == name[2]) && (dsdt[i+4] == name[3])) { return i+1; } } return 0; } BOOLEAN GetName(UINT8 *dsdt, INT32 adr, OUT CHAR8* name, OUT INTN *shift) { INT32 i; INT32 j = (dsdt[adr] == 0x5C)?1:0; //now we accept \NAME if (!name) { return FALSE; } for (i = adr + j; i < adr + j + 4; i++) { if ((dsdt[i] < 0x2F) || ((dsdt[i] > 0x39) && (dsdt[i] < 0x41)) || ((dsdt[i] > 0x5A) && (dsdt[i] != 0x5F))) { return FALSE; } name[i - adr - j] = dsdt[i]; } name[4] = 0; if (shift) { *shift = j; } return TRUE; } // if (CmpAdr(dsdt, j, NetworkADR1)) // Name (_ADR, 0x90000) template BOOLEAN CmpAdr (const T& dsdt, UINT32 j, UINT32 PciAdr) { // Name (_ADR, 0x001f0001) return (BOOLEAN) ((dsdt[j + 4] == 0x08) && (dsdt[j + 5] == 0x5F) && (dsdt[j + 6] == 0x41) && (dsdt[j + 7] == 0x44) && (dsdt[j + 8] == 0x52) && (//-------------------- ((dsdt[j + 9] == 0x0C) && (dsdt[j + 10] == ((PciAdr & 0x000000ff) >> 0)) && (dsdt[j + 11] == ((PciAdr & 0x0000ff00) >> 8)) && (dsdt[j + 12] == ((PciAdr & 0x00ff0000) >> 16)) && (dsdt[j + 13] == ((PciAdr & 0xff000000) >> 24)) ) || //-------------------- ((dsdt[j + 9] == 0x0B) && (dsdt[j + 10] == ((PciAdr & 0x000000ff) >> 0)) && (dsdt[j + 11] == ((PciAdr & 0x0000ff00) >> 8)) && (PciAdr < 0x10000) ) || //----------------------- ((dsdt[j + 9] == 0x0A) && (dsdt[j + 10] == (PciAdr & 0x000000ff)) && (PciAdr < 0x100) ) || //----------------- ((dsdt[j + 9] == 0x00) && (PciAdr == 0)) || //------------------ ((dsdt[j + 9] == 0x01) && (PciAdr == 1)) ) ); } BOOLEAN CmpPNP (UINT8 *dsdt, UINT32 j, UINT16 PNP) { // Name (_HID, EisaId ("PNP0C0F")) for PNP=0x0C0F BigEndian if (PNP == 0) { return (BOOLEAN) ((dsdt[j + 0] == 0x08) && (dsdt[j + 1] == 0x5F) && (dsdt[j + 2] == 0x48) && (dsdt[j + 3] == 0x49) && (dsdt[j + 4] == 0x44) && (dsdt[j + 5] == 0x0B) && (dsdt[j + 6] == 0x41) && (dsdt[j + 7] == 0xD0)); } return (BOOLEAN) ((dsdt[j + 0] == 0x08) && (dsdt[j + 1] == 0x5F) && (dsdt[j + 2] == 0x48) && (dsdt[j + 3] == 0x49) && (dsdt[j + 4] == 0x44) && (dsdt[j + 5] == 0x0C) && (dsdt[j + 6] == 0x41) && (dsdt[j + 7] == 0xD0) && (dsdt[j + 8] == ((PNP & 0xff00) >> 8)) && (dsdt[j + 9] == ((PNP & 0x00ff) >> 0))); } template INT32 CmpDev(UINT8 *dsdt, UINT32 i, const T& Name) { if ((dsdt[i+0] == Name[0]) && (dsdt[i+1] == Name[1]) && (dsdt[i+2] == Name[2]) && (dsdt[i+3] == Name[3]) && (((dsdt[i-2] == 0x82) && (dsdt[i-3] == 0x5B) && (dsdt[i-1] < 0x40)) || ((dsdt[i-3] == 0x82) && (dsdt[i-4] == 0x5B) && ((dsdt[i-2] & 0xF0) == 0x40)) || ((dsdt[i-4] == 0x82) && (dsdt[i-5] == 0x5B) && ((dsdt[i-3] & 0xF0) == 0x80))) ) { if (dsdt[i-5] == 0x5B) { return i - 3; } else if (dsdt[i-4] == 0x5B){ return i - 2; } else { return i - 1; } } return 0; } //the procedure can find BIN array UNSIGNED CHAR8 sizeof N inside part of large array "dsdt" size of len // return position or -1 if not found INT32 FindBin (UINT8 *dsdt, UINT32 len, const UINT8* bin, UINT32 N) { UINT32 i, j; BOOLEAN eq; for (i=0; len >= N && i < len - N; i++) { eq = TRUE; for (j=0; j= 7 && i < len - 7; i++) { if (((dsdt[i] == 0x14) || (dsdt[i+1] == 0x14) || (i>0 && dsdt[i-1] == 0x14)) && (dsdt[i+3] == Name[0]) && (dsdt[i+4] == Name[1]) && (dsdt[i+5] == Name[2]) && (dsdt[i+6] == Name[3]) ){ if (i>0 && dsdt[i-1] == 0x14) return i; return (dsdt[i+1] == 0x14)?(i+2):(i+1); //pointer to size field } } return 0; } //this procedure corrects size of outer method. Embedded methods is not proposed // adr - a place of changes // shift - a size of changes UINT32 CorrectOuterMethod (UINT8 *dsdt, UINT32 len, UINT32 adr, INT32 shift) { INT32 i, k; UINT32 size = 0; INT32 offset = 0; // INTN NameShift; CHAR8 Name[5]; if (shift == 0) { return len; } i = adr; //usually adr = @5B - 1 = sizefield - 3 while (i-- > 0x20) { //find method that previous to adr k = i + 1; if ((dsdt[i] == 0x14) && !CmpNum(dsdt, i, FALSE)) { //method candidate size = get_size(dsdt, k); if (!size) { continue; } if (((size <= 0x3F) && !GetName(dsdt, k+1, &Name[0], NULL)) || ((size > 0x3F) && (size <= 0xFFF) && !GetName(dsdt, k+2, &Name[0], NULL)) || ((size > 0xFFF) && !GetName(dsdt, k+3, &Name[0], NULL))) { DBG("method found, size=0x%X but name is not\n", size); continue; } if ((k+size) > adr+4) { //Yes - it is outer DBG("found outer method %s begin=%X end=%X\n", Name, k, k+size); offset = write_size(k, dsdt, len, shift); //size corrected to sizeoffset at address j // shift += offset; len += offset; } //else not an outer method break; } } return len; } //return final length of dsdt UINT32 CorrectOuters (UINT8 *dsdt, UINT32 len, UINT32 adr, INT32 shift) { INT32 i, k; INT32 j; INT32 size = 0; INT32 offset = 0; // UINT32 SBSIZE = 0, SBADR = 0; BOOLEAN SBFound = FALSE; if (shift == 0) { return len; } i = adr; //usually adr = @5B - 1 = sizefield - 3 while (i > 0x20) { //find devices that previous to adr //check device k = 0; if ((dsdt[i] == 0x5B) && (dsdt[i+1] == 0x82) && !CmpNum(dsdt, i, TRUE)) { //device candidate k = i + 2; } else if ((dsdt[i] == 0x10) && //looks like Scope (dsdt[i-1] != 0x14) && //this is Method() (dsdt[i-1] != 0xA0) && //this is If() (dsdt[i-1] != 0xA1) && //this is Else() (dsdt[i-1] != 0xA2) && //this is While() !CmpNum(dsdt, i, TRUE)) { //device scope like Scope (_PCI) //additional check for Field // a problem with fields 52 4D 53 33 10 41 4D 45 4D // 1. Search outer filed // 2. check the size of the field // 3. compare if we are in the filed j = i - 1; SBFound = TRUE; while (j > 0x20) { if (((dsdt[j - 1] == 0x5B) && (dsdt[j] == 0x81)) || ((dsdt[j - 1] == 0x5B) && (dsdt[j] == 0x82)) || ((dsdt[j - 1] == 0x5B) && (dsdt[j] == 0x86))) { //we found a Field() or IndexField before the 0x10 will check what is it size = (INT32)get_size(dsdt, j + 1); // if it is not a size then size = 0 if (j + size >= i) { // it is inside a Field, skip it SBFound = FALSE; } break; // other field so we stop search } j--; } if (SBFound) { k = i + 1; } } if ( k != 0) { size = (INT32)get_size(dsdt, k); if (size) { if ((k + size) > (INT32)adr+4) { //Yes - it is outer // DBG("found outer device begin=%X end=%X\n", k, k+size); offset = write_size(k, dsdt, len, shift); //size corrected to sizeoffset at address j shift += offset; len += offset; } //else not an outer device } //else wrong size field - not a device } //else not a device // check scope _SB_ // a problem 45 43 4F 4E 08 10 84 10 05 5F 53 42 5F /* SBSIZE = 0; if (dsdt[i] == '_' && dsdt[i+1] == 'S' && dsdt[i+2] == 'B' && dsdt[i+3] == '_') { for (j=0; j<10; j++) { if (dsdt[i-j] != 0x10) { continue; } if (!CmpNum(dsdt, i-j, TRUE)) { SBADR = i-j+1; SBSIZE = get_size(dsdt, SBADR); // DBG("found Scope(\\_SB) address = 0x%08X size = 0x%08X\n", SBADR, SBSIZE); if ((SBSIZE != 0) && (SBSIZE < len)) { //if zero or too large then search more //if found k = SBADR - 6; if ((SBADR + SBSIZE) > adr+4) { //Yes - it is outer // DBG("found outer scope begin=%X end=%X\n", SBADR, SBADR+SBSIZE); offset = write_size(SBADR, dsdt, len, shift); shift += offset; len += offset; SBFound = TRUE; break; //SB found } //else not an outer scope } } } } //else not a scope if (SBFound) { break; } */ if (k == 0) { i--; } else { i = k - 3; //if found then search again from found } } return len; } //ReplaceName(dsdt, len, "AZAL", "HDEF"); INTN ReplaceName(UINT8 *dsdt, UINT32 len, CONST CHAR8 *OldName, CONST CHAR8 *NewName) { UINTN i; INTN j = 0; for (i = 0; len >= 4 && i < len - 4; i++) { if ((dsdt[i+0] == NewName[0]) && (dsdt[i+1] == NewName[1]) && (dsdt[i+2] == NewName[2]) && (dsdt[i+3] == NewName[3])) { if (OldName) { MsgLog("NewName %s already present, renaming impossible\n", NewName); } else { DBG("name %s present at %llX\n", NewName, i); } return -1; } } if (!OldName) { return 0; } for (i = 0; len >= 4 && i < len - 4; i++) { if ((dsdt[i+0] == OldName[0]) && (dsdt[i+1] == OldName[1]) && (dsdt[i+2] == OldName[2]) && (dsdt[i+3] == OldName[3])) { MsgLog("Name %s present at 0x%llX, renaming to %s\n", OldName, i, NewName); dsdt[i+0] = NewName[0]; dsdt[i+1] = NewName[1]; dsdt[i+2] = NewName[2]; dsdt[i+3] = NewName[3]; j++; } } return j; //number of replacement } //the procedure search nearest "Device" code before given address //should restrict the search by 6 bytes... OK, 10, .. until dsdt begin //hmmm? will check device name UINT32 devFind(UINT8 *dsdt, UINT32 address) { UINT32 k = address; INT32 size = 0; while (k > 30) { k--; if (dsdt[k] == 0x82 && dsdt[k-1] == 0x5B) { size = get_size(dsdt, k+1); if (!size) { continue; } if ((k + size + 1) > address) { return (k+1); //pointer to size } //else continue } } MsgLog("Device definition before adr=%X not found\n", address); return 0; //impossible value for fool proof } BOOLEAN CustProperties(AML_CHUNK* pack, UINT32 Dev) { UINTN i; BOOLEAN Injected = FALSE; if (gSettings.NrAddProperties == 0xFFFE) { return FALSE; // not do this for Arbitrary properties? } for (i = 0; i < gSettings.NrAddProperties; i++) { if (gSettings.AddProperties[i].Device != Dev) { continue; } Injected = TRUE; if (!gSettings.AddProperties[i].MenuItem.BValue) { //DBG(" disabled property Key: %s, len: %d\n", gSettings.AddProperties[i].Key, gSettings.AddProperties[i].ValueLen); } else { aml_add_string(pack, gSettings.AddProperties[i].Key); aml_add_byte_buffer(pack, gSettings.AddProperties[i].Value, (UINT32)gSettings.AddProperties[i].ValueLen); //DBG(" added property Key: %s, len: %d\n", gSettings.AddProperties[i].Key, gSettings.AddProperties[i].ValueLen); } } return Injected; } //len = DeleteDevice("AZAL", dsdt, len); UINT32 DeleteDevice(const XString8& Name, UINT8 *dsdt, UINT32 len) { UINT32 i, j; INT32 size = 0, sizeoffset; MsgLog(" deleting device %s\n", Name.c_str()); for (i=20; i 0) { // find PCIRootUID for (j=PCIADR; j= 0){ DBG("_prw is present\n"); return len; } j = adr + size; sizeoffset = sizeof(prw1c); len = move_data(j, dsdt, len, sizeoffset); CopyMem(dsdt + j, prw1c, sizeoffset); shift = write_size(adr, dsdt, len, sizeoffset); sizeoffset += shift; len += shift; len = CorrectOuters(dsdt, len, adr - 3, sizeoffset); return len; } UINT32 FixAny (UINT8* dsdt, UINT32 len, const UINT8* ToFind, UINT32 LenTF, const UINT8* ToReplace, UINT32 LenTR) { INT32 sizeoffset, adr; UINT32 i; BOOLEAN found = FALSE; if (!ToFind || !LenTF || !LenTR) { DBG(" invalid patches!\n"); return len; } MsgLog(" pattern %02hhX%02hhX%02hhX%02hhX,", ToFind[0], ToFind[1], ToFind[2], ToFind[3]); if ((LenTF + sizeof(EFI_ACPI_DESCRIPTION_HEADER)) > len) { MsgLog(" the patch is too large!\n"); return len; } sizeoffset = LenTR - LenTF; for (i = 20; i < len; ) { adr = FindBin(dsdt + i, len - i, ToFind, LenTF); if (adr < 0) { if (found) { MsgLog(" ]\n"); } else { MsgLog(" bin not found / already patched!\n"); } return len; } if (!found) { MsgLog(" patched at: ["); MsgLog(" (%X)", adr); //print once because whole duration is 26 seconds!!! } // MsgLog(" (%X)", adr); found = TRUE; len = move_data(adr + i, dsdt, len, sizeoffset); if ((LenTR > 0) && (ToReplace != NULL)) { CopyMem(dsdt + adr + i, ToReplace, LenTR); } len = CorrectOuterMethod(dsdt, len, adr + i - 2, sizeoffset); len = CorrectOuters(dsdt, len, adr + i - 3, sizeoffset); i += adr + LenTR; } MsgLog(" ]\n"); //should not be here return len; } //new method. by goodwin_c UINT32 FixRenameByBridge2 (UINT8* dsdt, UINT32 len, CHAR8* TgtBrgName, const UINT8* ToFind, UINT32 LenTF, const UINT8* ToReplace, UINT32 LenTR) { INT32 adr; BOOLEAN found = FALSE; UINT32 i, k; UINT32 BrdADR = 0, BridgeSize; if (!ToFind || !LenTF || !LenTR) { DBG(" invalid patches!\n"); return len; } if (LenTF != LenTR) { DBG(" find/replace different size!\n"); return len; } DBG(" pattern %02hhX%02hhX%02hhX%02hhX,", ToFind[0], ToFind[1], ToFind[2], ToFind[3]); if ((LenTF + sizeof(EFI_ACPI_DESCRIPTION_HEADER)) > len) { DBG(" the patch is too large!\n"); return len; } DBG("Start ByBridge Rename Fix\n"); for (i=0x20; len >= 10 && i < len - 10; i++) { if (CmpDev(dsdt, i, (UINT8*)TgtBrgName)) { BrdADR = devFind(dsdt, i); if (!BrdADR) { continue; } BridgeSize = get_size(dsdt, BrdADR); if(!BridgeSize) continue; if(BridgeSize <= LenTF) continue; k = 0; found = FALSE; while (k <= 100) { adr = FindBin(dsdt + BrdADR, BridgeSize, ToFind, LenTF); if (adr < 0) { if (found) { DBG(" ]\n"); } else { DBG(" bin not found / already patched!\n"); } return len; } if (!found) { DBG(" patched at: ["); } DBG(" (%X)", adr); found = TRUE; if ((LenTR > 0) && (ToReplace != NULL)) { CopyMem(dsdt + BrdADR + adr, ToReplace, LenTR); } k++; } } } DBG(" ]\n"); return len; } UINT32 FIXDarwin (UINT8* dsdt, UINT32 len) { CONST UINT32 adr = 0x24; DBG("Start Darwin Fix\n"); ReplaceName(dsdt, len, "_OSI", "OOSI"); if (gSettings.FixDsdt & FIX_DARWIN) { darwin[42] = '9'; //windows 2009 } len = move_data(adr, dsdt, len, sizeof(darwin)); CopyMem(dsdt+adr, darwin, sizeof(darwin)); return len; } VOID FixS3D (UINT8* dsdt, UINT32 len) { UINT32 i; DBG("Start _S3D Fix\n"); for (i=20; len >= 5 && i < len - 5; i++) { if ((dsdt[i + 0] == 0x08) && (dsdt[i + 1] == '_') && (dsdt[i + 2] == 'S') && (dsdt[i + 3] == '3') && (dsdt[i + 4] == 'D') && (dsdt[i + 5] == 0x0A) && (dsdt[i + 6] == 0x02)) { dsdt[i + 6] = 3; } } } UINT32 AddPNLF (UINT8 *dsdt, UINT32 len) { #if AUTO_PNLF EFI_STATUS Status; EFI_HANDLE *HandleBuffer = NULL; EFI_HANDLE Handle; EFI_PCI_IO_PROTOCOL *PciIo; PCI_TYPE00 Pci; UINTN HandleCount = 0; UINTN HandleIndex; UINTN Segment; UINTN Bus; UINTN Device; UINTN Function; #endif UINT32 i; //, j, size; UINT32 adr = 0; DBG("Start PNLF Fix\n"); if (FindBin(dsdt, len, app2, 10) >= 0) { return len; //the device already exists } //search PWRB PNP0C0C for (i=0x20; len >= 6 && i < len - 6; i++) { if (CmpPNP(dsdt, i, 0x0C0C)) { DBG("found PWRB at %X\n", i); adr = devFind(dsdt, i); break; } } if (!adr) { //search battery DBG("not found PWRB, look BAT0\n"); for (i=0x20; len >= 6 && i < len - 6; i++) { if (CmpPNP(dsdt, i, 0x0C0A)) { adr = devFind(dsdt, i); DBG("found BAT0 at %X\n", i); break; } } } if (!adr) { return len; } //Slice - add custom UID if (gSettings.PNLF_UID != 0xFF) { ((CHAR8*)pnlf)[39] = gSettings.PNLF_UID; } // _UID reworked by Sherlocks. 2018.10.08 //Slice - it can't depends on video DeviceID. It is hardware ID of LCD screen. #if AUTO_PNLF Status = gBS->LocateHandleBuffer ( ByProtocol, &gEfiPciIoProtocolGuid, NULL, &HandleCount, &HandleBuffer ); if (!EFI_ERROR(Status)) { for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) { Handle = HandleBuffer[HandleIndex]; Status = gBS->HandleProtocol ( Handle, &gEfiPciIoProtocolGuid, (VOID **)&PciIo ); if (!EFI_ERROR(Status)) { PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function); Status = PciIo->Pci.Read ( PciIo, EfiPciIoWidthUint32, 0, sizeof (Pci) / sizeof (UINT32), &Pci ); } if ((Pci.Hdr.ClassCode[2] == PCI_CLASS_DISPLAY) && ((Pci.Hdr.ClassCode[1] == PCI_CLASS_DISPLAY_VGA) || (Pci.Hdr.ClassCode[1] == PCI_CLASS_DISPLAY_OTHER))) { switch (Pci.Hdr.VendorId) { case 0x8086: // followed standard _UID of AppleBacklight // it works for both default and AppleBacklightInjector switch (Pci.Hdr.DeviceId) { case 0x2772: // "Intel GMA 950" case 0x2776: // "Intel GMA 950" case 0x27A2: // "Intel GMA 950" case 0x27A6: // "Intel GMA 950" case 0x27AE: // "Intel GMA 950" case 0xA001: // "Intel GMA 3150" case 0xA002: // "Intel GMA 3150" case 0xA011: // "Intel GMA 3150" case 0xA012: // "Intel GMA 3150" case 0x2A02: // "Intel GMA X3100" case 0x2A03: // "Intel GMA X3100" case 0x2A12: // "Intel GMA X3100" case 0x2A13: // "Intel GMA X3100" case 0x0042: // "Intel HD Graphics" case 0x0046: // "Intel HD Graphics" // _UID: 10 break; case 0x0102: // "Intel HD Graphics 2000" case 0x0106: // "Intel HD Graphics 2000" case 0x010A: // "Intel HD Graphics P3000" case 0x0112: // "Intel HD Graphics 3000" case 0x0116: // "Intel HD Graphics 3000" case 0x0122: // "Intel HD Graphics 3000" case 0x0126: // "Intel HD Graphics 3000" case 0x0152: // "Intel HD Graphics 2500" case 0x0156: // "Intel HD Graphics 2500" case 0x015A: // "Intel HD Graphics 2500" case 0x0162: // "Intel HD Graphics 4000" case 0x0166: // "Intel HD Graphics 4000" case 0x016A: // "Intel HD Graphics P4000" ((CHAR8*)pnlf)[39] = 0x0E; // _UID: 14 break; case 0x0412: // "Intel HD Graphics 4600" case 0x0416: // "Intel HD Graphics 4600" case 0x041A: // "Intel HD Graphics P4600" case 0x041E: // "Intel HD Graphics 4400" case 0x0422: // "Intel HD Graphics 5000" case 0x0426: // "Intel HD Graphics 5000" case 0x042A: // "Intel HD Graphics 5000" case 0x0A06: // "Intel HD Graphics" case 0x0A16: // "Intel HD Graphics 4400" case 0x0A1E: // "Intel HD Graphics 4200" case 0x0A22: // "Intel Iris Graphics 5100" case 0x0A26: // "Intel HD Graphics 5000" case 0x0A2A: // "Intel Iris Graphics 5100" case 0x0A2B: // "Intel Iris Graphics 5100" case 0x0A2E: // "Intel Iris Graphics 5100" case 0x0D12: // "Intel HD Graphics 4600" case 0x0D16: // "Intel HD Graphics 4600" case 0x0D22: // "Intel Iris Pro Graphics 5200" case 0x0D26: // "Intel Iris Pro Graphics 5200" case 0x0D2A: // "Intel Iris Pro Graphics 5200" case 0x0D2B: // "Intel Iris Pro Graphics 5200" case 0x0D2E: // "Intel Iris Pro Graphics 5200" case 0x1612: // "Intel HD Graphics 5600" case 0x1616: // "Intel HD Graphics 5500" case 0x161E: // "Intel HD Graphics 5300" case 0x1626: // "Intel HD Graphics 6000" case 0x162B: // "Intel Iris Graphics 6100" case 0x162D: // "Intel Iris Pro Graphics P6300" case 0x1622: // "Intel Iris Pro Graphics 6200" case 0x162A: // "Intel Iris Pro Graphics P6300" ((CHAR8*)pnlf)[39] = 0x0F; // _UID: 15 break; default: ((CHAR8*)pnlf)[39] = 0x10; // _UID: 16 break; } break; default: // ATI/NVIDIA // _UID: 10 break; } } } } #endif i = adr - 2; len = move_data(i, dsdt, len, sizeof(pnlf)); CopyMem(dsdt+i, pnlf, sizeof(pnlf)); len = CorrectOuters(dsdt, len, adr-3, sizeof(pnlf)); return len; } UINT32 FixRTC (UINT8 *dsdt, UINT32 len) { UINT32 i, j, k, l; UINT32 IOADR = 0; UINT32 RESADR = 0; UINT32 adr = 0; UINT32 rtcsize = 0; INT32 shift, sizeoffset = 0; DBG("Start RTC Fix\n"); for (j=20; j> find this if (dsdt[i] == 0x70 && dsdt[i+1] == 0x00 && dsdt[i+2] == 0x70 && dsdt[i+3] == 0x00) { if (dsdt[i+5] == 0x08 && gSettings.Rtc8Allowed) { MsgLog("CMOS reset not will be, patch length is not needed\n"); } else { // First Fix RTC CMOS Reset Problem if (dsdt[i+4] != 0x00 || dsdt[i+5] != 0x02) { //dsdt[j+4] => Alignment dsdt[j+5] => Length dsdt[i+4] = 0x00; //Alignment dsdt[i+5] = 0x02; //Length MsgLog("found RTC Length not match, Maybe will cause CMOS reset, will patch it.\n"); } } for (l = adr + 4; l < i; l++) { if (dsdt[l] == 0x11 && dsdt[l+2] == 0x0A) { RESADR = l + 1; //Format 11, size, 0A, size-3,... 79, 00 IOADR = l + 3; //IO (Decode16 ==> 47, 01 } } break; } if ((dsdt[i+1] == 0x5B) && (dsdt[i+2] == 0x82)) { break; //end of RTC device and begin of new Device() } } for (l = adr + 4; l < adr + rtcsize; l++) { if ((dsdt[l] == 0x22) && (l>IOADR) && (l 0 Fix Device RTC size if (sizeoffset != 0) { // RTC size shift = write_size(adr, dsdt, len, sizeoffset); sizeoffset += shift; //sizeoffset changed len += shift; DBG("new size written to %X shift=%X len=%X\n", adr, shift, len); len = CorrectOuters(dsdt, len, adr-3, sizeoffset); DBG("len after correct outers %X\n", len); sizeoffset = 0; } // sizeoffset if } // l loop return len; } UINT32 FixTMR (UINT8 *dsdt, UINT32 len) { UINT32 i, j, k; UINT32 IOADR = 0; UINT32 RESADR = 0; UINT32 adr = 0; UINT32 TMRADR, tmrsize = 0; INT32 offset = 0, sizeoffset = 0; DBG("Start TMR Fix\n"); for (j=20; j 47, 01 j = get_size(dsdt, IOADR); } if (dsdt[i] == 0x22) { // Had IRQNoFlag for (k=i; k 0 Fix Device TMR size if (sizeoffset != 0) { // TMR size offset = write_size(adr, dsdt, len, sizeoffset); sizeoffset += offset; len += offset; len = CorrectOuters(dsdt, len, adr-3, sizeoffset); sizeoffset = 0; } // offset if if ((dsdt[i+1] == 0x5B) && (dsdt[i+2] == 0x82)) { break; //end of TMR device and begin of new Device() } } // i loop return len; } UINT32 FixPIC (UINT8 *dsdt, UINT32 len) { UINT32 i, j, k; UINT32 IOADR = 0; UINT32 RESADR = 0; UINT32 adr = 0; INT32 offset = 0, sizeoffset = 0; UINT32 PICADR, picsize = 0; DBG("Start PIC Fix\n"); for (j=20; j 47, 01 continue; } else { // or 11 41 09 0A 8D 47 01 20 00 -> size=0x91 size-4=0x89 if ((dsdt[i] == 0x11) && (dsdt[i+3] == 0x0A) && ((dsdt[i+1] & 0xF0) == 0x40)) { RESADR = i+1; //Format 11, size1, size2, 0A, size-4,... 79, 00 IOADR = i+4; //IO (Decode16 ==> 47, 01 DBG("found CRS at %X size %hhX\n", RESADR, dsdt[IOADR]); continue; } } if (dsdt[i] == 0x22) { // Had IRQNoFlag for (k = i; k < RESADR + dsdt[IOADR] + 4; k++) { if ((dsdt[k] == 0x79) || ((dsdt[k] == 0x47) && (dsdt[k+1] == 0x01)) || ((dsdt[k] == 0x86) && (dsdt[k+1] == 0x09))) { sizeoffset = i - k; MsgLog("found PIC had IRQNoFlag will move %d bytes\n", sizeoffset); // First move offset byte remove IRQNoFlag len = move_data(i, dsdt, len, sizeoffset); // Fix IO (Decode16, size and _CRS size // dsdt[RESADR] += (UINT8)sizeoffset; dsdt[IOADR] += (UINT8)sizeoffset; offset = write_size(RESADR, dsdt, len, sizeoffset); sizeoffset += offset; len += offset; break; } } } // if offset > 0 Fix Device PIC size if (sizeoffset != 0 ) { offset = write_size(adr, dsdt, len, sizeoffset); sizeoffset += offset; DBG("Fix Device PIC size %d\n", sizeoffset); len += offset; len = CorrectOuters(dsdt, len, adr-3, sizeoffset); sizeoffset = 0; } // sizeoffset if if ((dsdt[i+1] == 0x5B) && (dsdt[i+2] == 0x82)) { break; //end of PIC device and begin of new Device() } } // i loop return len; } UINT32 FixHPET (UINT8* dsdt, UINT32 len) { UINT32 i, j; UINT32 adr = 0; UINT32 hpetsize = 0; INT32 sizeoffset = sizeof(hpet0); INT32 shift = 0; UINT32 LPCBADR = 0, LPCBSIZE = 0; MsgLog("Start HPET Fix\n"); //have to find LPC for (j=0x20; len >= 10 && j < len - 10; j++) { if (CmpAdr(dsdt, j, 0x001F0000)) { LPCBADR = devFind(dsdt, j); if (!LPCBADR) { continue; } LPCBSIZE = get_size(dsdt, LPCBADR); } // End LPCB find } if (!LPCBSIZE) { MsgLog("No LPCB device! Patch HPET will not be applied\n"); return len; } for (j=20; j= 10 && j < len - 10; j++) { if (CmpAdr(dsdt, j, 0x001F0000)) { LPCBADR = devFind(dsdt, j); if (!LPCBADR) { continue; } LPCBSIZE = get_size(dsdt, LPCBADR); device_name[3] = (__typeof_am__(device_name[3]))AllocateZeroPool(5); CopyMem(device_name[3], dsdt + j, 4); MsgLog("found LPCB device NAME(_ADR,0x001F0000) at %X And Name is %s\n", j, device_name[3]); if (LPCBSIZE) break; } // End LPCB find } if (!LPCBSIZE) return len; LPCBADR1 = LPCBADR + LPCBSIZE; ReplaceName(dsdt, len, device_name[3], "LPCB"); if (LPCBADR) { // bridge or device i = LPCBADR; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); if(!Size) { return len; } sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); //to correct outers we have to calculate offset len = CorrectOuters(dsdt, len, k - 2, sizeoffset); MsgLog("_DSM in LPC already exists, dropped\n"); } } root = aml_create_node(NULL); // add Method(_DSM,4,NotSerialized) for LPC met = aml_add_method(root, "_DSM", 4); met = aml_add_store(met); pack = aml_add_package(met); aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, dataLPC, 4); snprintf(NameCard, sizeof(NameCard), "pci8086,3a18"); aml_add_string(pack, "name"); aml_add_string_buffer(pack, &NameCard[0]); aml_add_string(pack, "compatible"); aml_add_string_buffer(pack, &NameCard[0]); CustProperties(pack, DEV_LPC); aml_add_local0(met); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); lpcb = (__typeof__(lpcb))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, lpcb, 0); aml_destroy_node(root); // add LPCB code len = move_data(LPCBADR1, dsdt, len, sizeoffset); CopyMem(dsdt + LPCBADR1, lpcb, sizeoffset); shift = write_size(LPCBADR, dsdt, len, sizeoffset); sizeoffset += shift; len += shift; len = CorrectOuters(dsdt, len, LPCBADR-3, sizeoffset); FreePool(lpcb); return len; } //CONST UINT8 Yes[] = {0x01,0x00,0x00,0x00}; UINT8 data2[] = {0xe0,0x00,0x56,0x28}; UINT8 VenATI[] = {0x02, 0x10}; UINT32 FIXDisplay (UINT8 *dsdt, UINT32 len, INT32 VCard) { UINT32 i = 0, j, k; INT32 sizeoffset = 0; UINT32 PCIADR = 0, PCISIZE = 0, Size; CHAR8 *display; UINT32 devadr=0, devsize=0, devadr1=0, devsize1=0; BOOLEAN DISPLAYFIX = FALSE; BOOLEAN NonUsable = FALSE; BOOLEAN DsmFound = FALSE; BOOLEAN NeedHDMI = !!(gSettings.FixDsdt & FIX_HDMI); AML_CHUNK *root = NULL; AML_CHUNK *gfx0, *peg0; AML_CHUNK *met, *met2; AML_CHUNK *pack; UINT32 FakeID = 0; UINT32 FakeVen = 0; DisplayName1 = FALSE; if (!DisplayADR1[VCard]) return len; PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) return len; //what is the bad DSDT ?! MsgLog("Start Display%d Fix\n", VCard); root = aml_create_node(NULL); //search DisplayADR1[0] for (j=0x20; len >= 10 && j < len - 10; j++) { if (CmpAdr(dsdt, j, DisplayADR1[VCard])) { //for example 0x00020000=2,0 devadr = devFind(dsdt, j); //PEG0@2,0 if (!devadr) { continue; } devsize = get_size(dsdt, devadr); //sizeof PEG0 0x35 if (devsize) { DisplayName1 = TRUE; break; } } // End Display1 } //what if PEG0 is not found? if (devadr) { for (j=devadr; j 0x3F) aml_add_dword(gfx0, DisplayADR2[VCard]); else aml_add_byte(gfx0, (UINT8)DisplayADR2[VCard]); } else { gfx0 = peg0; } if ( DsmFound || ( !NeedHDMI && ( ((DisplayVendor[VCard] == 0x8086) && (gSettings.InjectIntel || !gSettings.FakeIntel)) || ((DisplayVendor[VCard] == 0x10DE) && (gSettings.InjectNVidia || !gSettings.FakeNVidia)) || ((DisplayVendor[VCard] == 0x1002) && (gSettings.InjectATI || !gSettings.FakeATI)) ) ) ) { MsgLog("Skipping Method(_DSM) for %04X card\n", DisplayVendor[VCard]); goto Skip_DSM; } MsgLog("Creating Method(_DSM) for %04X card\n", DisplayVendor[VCard]); met = aml_add_method(gfx0, "_DSM", 4); met2 = aml_add_store(met); pack = aml_add_package(met2); if (NeedHDMI) { aml_add_string(pack, "hda-gfx"); aml_add_string_buffer(pack, (gSettings.UseIntelHDMI && DisplayVendor[VCard] != 0x8086) ? "onboard-2" : "onboard-1"); } switch (DisplayVendor[VCard]) { case 0x8086: if (gSettings.FakeIntel) { FakeID = gSettings.FakeIntel >> 16; aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeID, 4); FakeVen = gSettings.FakeIntel & 0xFFFF; aml_add_string(pack, "vendor-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeVen, 4); } break; case 0x10DE: if (gSettings.FakeNVidia) { FakeID = gSettings.FakeNVidia >> 16; aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeID, 4); FakeVen = gSettings.FakeNVidia & 0xFFFF; aml_add_string(pack, "vendor-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeVen, 4); } break; case 0x1002: if (gSettings.FakeATI) { FakeID = gSettings.FakeATI >> 16; aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeID, 4); aml_add_string(pack, "ATY,DeviceID"); aml_add_byte_buffer(pack, (UINT8*)&FakeID, 2); FakeVen = gSettings.FakeATI & 0xFFFF; aml_add_string(pack, "vendor-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeVen, 4); aml_add_string(pack, "ATY,VendorID"); aml_add_byte_buffer(pack, (UINT8*)&FakeVen, 2); }/* else { aml_add_string(pack, "ATY,VendorID"); aml_add_byte_buffer(pack, VenATI, 2); }*/ break; } aml_add_local0(met); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); Skip_DSM: //add _sun /* switch (DisplayVendor[VCard]) { case 0x10DE: case 0x1002: Size = get_size(dsdt, i); j = (DisplayVendor[VCard] == 0x1002) ? 0 : 1; k = FindMethod(dsdt + i, Size, "_SUN"); if (k == 0) { k = FindName(dsdt + i, Size, "_SUN"); if (k == 0) { aml_add_name(gfx0, "_SUN"); aml_add_dword(gfx0, SlotDevices[j].SlotID); } else { //we have name sun, set the number if (dsdt[k + 4] == 0x0A) { dsdt[k + 5] = SlotDevices[j].SlotID; } } } else { MsgLog("Warning: Method(_SUN) found for %04X card\n", DisplayVendor[VCard]); } break; } */ if (!NonUsable) { //now insert video DBG("now inserting Video device\n"); aml_calculate_size(root); display = (__typeof__(display))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, display, 0); aml_destroy_node(root); if (DisplayName1) { //bridge is present // move data to back for add Display DBG("... into existing bridge\n"); if (!DISPLAYFIX || (DisplayADR2[VCard] == 0xFFFE)) { //subdevice absent devsize = get_size(dsdt, devadr); if (!devsize) { DBG("BUG! Address of existing PEG0 is lost %X\n", devadr); FreePool(display); return len; } i = devadr + devsize; len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt+i, display, sizeoffset); j = write_size(devadr, dsdt, len, sizeoffset); //correct bridge size sizeoffset += j; len += j; len = CorrectOuters(dsdt, len, devadr-3, sizeoffset); } else { devsize1 = get_size(dsdt, devadr1); if (!devsize1) { FreePool(display); return len; } i = devadr1 + devsize1; len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt+i, display, sizeoffset); j = write_size(devadr1, dsdt, len, sizeoffset); sizeoffset += j; len += j; len = CorrectOuters(dsdt, len, devadr1-3, sizeoffset); } } else { //insert PEG0 into PCI0 at the end //PCI corrected so search again DBG("... into created bridge\n"); PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) return len; //what is the bad DSDT ?! i = PCIADR + PCISIZE; // devadr = i + 2; //skip 5B 82 len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt + i, display, sizeoffset); // Fix PCI0 size k = write_size(PCIADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; // devadr += k; k = CorrectOuters(dsdt, len, PCIADR-3, sizeoffset); // devadr += k - len; len = k; } FreePool(display); } return len; } UINT32 AddHDMI (UINT8 *dsdt, UINT32 len) { UINT32 i, j, k; INT32 sizeoffset = 0; UINT32 PCIADR = 0, PCISIZE = 0, Size; CHAR8 *hdmi = NULL; UINT32 devadr=0, BridgeSize=0, devadr1=0; //, devsize1=0; BOOLEAN BridgeFound = FALSE; BOOLEAN HdauFound = FALSE; AML_CHUNK* brd = NULL; AML_CHUNK *root = NULL; AML_CHUNK *met, *met2; AML_CHUNK *pack; if (!HDMIADR1) return len; PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) return len; //what is the bad DSDT ?! DBG("Start HDMI Fix\n"); // Device Address for (i=0x20; len >= 10 && i < len - 10; i++) { if (CmpAdr(dsdt, i, HDMIADR1)) { devadr = devFind(dsdt, i); if (!devadr) { continue; } BridgeSize = get_size(dsdt, devadr); if (!BridgeSize) { continue; } BridgeFound = TRUE; if (HDMIADR2 != 0xFFFE){ for (k = devadr + 9; k < devadr + BridgeSize; k++) { if (CmpAdr(dsdt, k, HDMIADR2)) { devadr1 = devFind(dsdt, k); if (!devadr1) { continue; } device_name[11] = (__typeof_am__(device_name[11]))AllocateZeroPool(5); CopyMem(device_name[11], dsdt+k, 4); DBG("found HDMI device [0x%08X:%X] at %X and Name is %s\n", HDMIADR1, HDMIADR2, devadr1, device_name[11]); ReplaceName(dsdt + devadr, BridgeSize, device_name[11], "HDAU"); HdauFound = TRUE; break; } } if (!HdauFound) { DBG("have no HDMI device while HDMIADR2=%X\n", HDMIADR2); devadr1 = devadr; } } else { devadr1 = devadr; } break; } // End if devadr1 find } if (BridgeFound) { // bridge or device if (HdauFound) { i = devadr1; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in HDAU already exists, dropped\n"); } } root = aml_create_node(NULL); //what to do if no HDMI bridge? } else { brd = aml_create_node(NULL); root = aml_add_device(brd, "HDM0"); aml_add_name(root, "_ADR"); aml_add_dword(root, HDMIADR1); DBG("Created bridge device with ADR=0x%X\n", HDMIADR1); } DBG("HDMIADR1=%X HDMIADR2=%X\n", HDMIADR1, HDMIADR2); if (!HdauFound && (HDMIADR2 != 0xFFFE)) //there is no HDMI device at dsdt, creating new one { AML_CHUNK* dev = aml_add_device(root, "HDAU"); aml_add_name(dev, "_ADR"); if (HDMIADR2) { if (HDMIADR2 > 0x3F) aml_add_dword(dev, HDMIADR2); else aml_add_byte(dev, (UINT8)HDMIADR2); } else { aml_add_byte(dev, 0x01); } met = aml_add_method(dev, "_DSM", 4); } else { //HDAU device already present met = aml_add_method(root, "_DSM", 4); } met2 = aml_add_store(met); pack = aml_add_package(met2); if (!gSettings.NoDefaultProperties) { aml_add_string(pack, "hda-gfx"); if (gSettings.UseIntelHDMI) { aml_add_string_buffer(pack, "onboard-2"); } else { aml_add_string_buffer(pack, "onboard-1"); } } /* if (!CustProperties(pack, DEV_HDMI)) { DBG(" with default properties\n"); aml_add_string(pack, "layout-id"); aml_add_byte_buffer(pack, (CHAR8*)&GfxlayoutId[0], 4); aml_add_string(pack, "PinConfigurations"); aml_add_byte_buffer(pack, data2, sizeof(data2)); } */ aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); hdmi = (__typeof__(hdmi))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, hdmi, 0); aml_destroy_node(root); //insert HDAU if (BridgeFound) { // bridge or lan k = devadr1; } else { //this is impossible k = PCIADR; } Size = get_size(dsdt, k); if (Size > 0) { i = k + Size; len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt + i, hdmi, sizeoffset); j = write_size(k, dsdt, len, sizeoffset); sizeoffset += j; len += j; len = CorrectOuters(dsdt, len, k-3, sizeoffset); } if (hdmi) { FreePool(hdmi); } return len; } //Network ------------------------------------------------------------- UINT32 FIXNetwork (UINT8 *dsdt, UINT32 len, UINT32 card) { UINT32 i, k; UINT32 NetworkADR = 0, BridgeSize, Size, BrdADR = 0; UINT32 PCIADR, PCISIZE = 0; INT32 sizeoffset; AML_CHUNK *met, *met2; AML_CHUNK *brd; AML_CHUNK *root; AML_CHUNK *pack; AML_CHUNK *dev; CHAR8 *network; UINT32 FakeID = 0; UINT32 FakeVen = 0; CHAR8 NameCard[32]; if (!NetworkADR1[card]) return len; DBG("Start NetWork %d Fix\n", card); if (gSettings.FakeLAN) { FakeID = gSettings.FakeLAN >> 16; FakeVen = gSettings.FakeLAN & 0xFFFF; snprintf(NameCard, 32, "pci%x,%x", FakeVen, FakeID); Netmodel[card] = get_net_model((FakeVen << 16) + FakeID); } PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) return len; //what is the bad DSDT ?! NetworkName = FALSE; // Network Address for (i = 0x24; len >=10 && i < len - 10; i++) { if (CmpAdr(dsdt, i, NetworkADR1[card])) { //0x001C0004 BrdADR = devFind(dsdt, i); if (!BrdADR) { continue; } BridgeSize = get_size(dsdt, BrdADR); if (!BridgeSize) { continue; } if (NetworkADR2[card] != 0xFFFE){ //0 for (k = BrdADR + 9; k < BrdADR + BridgeSize; k++) { if (CmpAdr(dsdt, k, NetworkADR2[card])) { NetworkADR = devFind(dsdt, k); if (!NetworkADR) { continue; } device_name[1] = (__typeof_am__(device_name[1]))AllocateZeroPool(5); CopyMem(device_name[1], dsdt+k, 4); DBG("found NetWork device [0x%08X:%X] at %X and Name is %s\n", NetworkADR1[card], NetworkADR2[card], NetworkADR, device_name[1]); //renaming disabled until better way will found // ReplaceName(dsdt + BrdADR, BridgeSize, device_name[1], "GIGE"); NetworkName = TRUE; break; } } if (!NetworkName) { DBG("have no Network device while NetworkADR2=%X\n", NetworkADR2[card]); //in this case NetworkADR point to bridge NetworkADR = BrdADR; } } else { NetworkADR = BrdADR; } break; } // End if NetworkADR find } if (BrdADR) { // bridge or device i = NetworkADR; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in LAN already exists, dropped\n"); } root = aml_create_node(NULL); } else { //what to do if no LAN bridge? i = PCIADR; brd = aml_create_node(NULL); root = aml_add_device(brd, "LAN0"); aml_add_name(root, "_ADR"); aml_add_dword(root, NetworkADR1[card]); DBG("Created bridge device with ADR=0x%X\n", NetworkADR1[card]); } DBG("NetworkADR1=%X NetworkADR2=%X\n", NetworkADR1[card], NetworkADR2[card]); dev = root; if (!NetworkName && (NetworkADR2[card] != 0xFFFE)) //there is no network device at dsdt, creating new one { dev = aml_add_device(root, NetName[card]); aml_add_name(dev, "_ADR"); if (NetworkADR2[card]) { if (NetworkADR2[card] > 0x3F) aml_add_dword(dev, NetworkADR2[card]); else aml_add_byte(dev, (UINT8)NetworkADR2[card]); } else { aml_add_byte(dev, 0x00); } } Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_SUN"); if (k == 0) { k = FindName(dsdt + i, Size, "_SUN"); if (k == 0) { aml_add_name(dev, "_SUN"); aml_add_dword(dev, SlotDevices[5].SlotID); } else { //we have name sun, set the number if (dsdt[k + 4] == 0x0A) { dsdt[k + 5] = SlotDevices[5].SlotID; } } } // add Method(_DSM,4,NotSerialized) for network if (gSettings.FakeLAN || !gSettings.NoDefaultProperties) { met = aml_add_method(dev, "_DSM", 4); met2 = aml_add_store(met); pack = aml_add_package(met2); aml_add_string(pack, "built-in"); aml_add_byte_buffer(pack, dataBuiltin, sizeof(dataBuiltin)); aml_add_string(pack, "model"); aml_add_string_buffer(pack, Netmodel[card]); // aml_add_string(pack, "device_type"); // aml_add_string_buffer(pack, "Ethernet"); if (gSettings.FakeLAN) { // aml_add_string(pack, "model"); // aml_add_string_buffer(pack, "Apple LAN card"); aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (UINT8 *)&FakeID, 4); aml_add_string(pack, "vendor-id"); aml_add_byte_buffer(pack, (UINT8 *)&FakeVen, 4); aml_add_string(pack, "name"); aml_add_string_buffer(pack, &NameCard[0]); aml_add_string(pack, "compatible"); aml_add_string_buffer(pack, &NameCard[0]); } // Could we just comment this part? (Until remember what was the purposes?) /* if (!CustProperties(pack, DEV_LAN) && !gSettings.FakeLAN && !gSettings.NoDefaultProperties) { aml_add_string(pack, "empty"); aml_add_byte(pack, 0); } */ aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); } // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); network = (__typeof__(network))AllocateZeroPool(root->Size); if (!network) { return len; } sizeoffset = root->Size; DBG("network DSM created, size=%X\n", sizeoffset); aml_write_node(root, network, 0); aml_destroy_node(root); if (NetworkADR) { // bridge or lan i = NetworkADR; } else { //this is impossible i = PCIADR; } Size = get_size(dsdt, i); // move data to back for add patch k = i + Size; len = move_data(k, dsdt, len, sizeoffset); CopyMem(dsdt+k, network, sizeoffset); // Fix Device network size k = write_size(i, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, i-3, sizeoffset); FreePool(network); return len; } //Airport-------------------------------------------------- //CHAR8 dataBCM[] = {0x12, 0x43, 0x00, 0x00}; //CHAR8 data1ATH[] = {0x2a, 0x00, 0x00, 0x00}; //CHAR8 data2ATH[] = {0x8F, 0x00, 0x00, 0x00}; //CHAR8 data3ATH[] = {0x6B, 0x10, 0x00, 0x00}; UINT32 FIXAirport (UINT8 *dsdt, UINT32 len) { UINT32 i, k; UINT32 ArptADR = 0, BridgeSize, Size, BrdADR = 0; UINT32 PCIADR, PCISIZE = 0; INT32 sizeoffset; AML_CHUNK *met, *met2; AML_CHUNK* brd; AML_CHUNK* root; AML_CHUNK* pack; AML_CHUNK* dev; CHAR8 *network; UINT32 FakeID = 0; UINT32 FakeVen = 0; CHAR8 NameCard[32]; if (!ArptADR1) return len; // no device - no patch if (gSettings.FakeWIFI) { FakeID = gSettings.FakeWIFI >> 16; FakeVen = gSettings.FakeWIFI & 0xFFFF; snprintf(NameCard, 32, "pci%x,%x", FakeVen, FakeID); } PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) return len; //what is the bad DSDT ?! DBG("Start Airport Fix\n"); ArptName = FALSE; for (i=0x20; len >= 10 && i < len - 10; i++) { // AirPort Address if ( CmpAdr(dsdt, i, ArptADR1) || CmpDev(dsdt, i, gSettings.AirportBridgeDeviceName) ) { BrdADR = devFind(dsdt, i); if (!BrdADR) { continue; } BridgeSize = get_size(dsdt, BrdADR); if(!BridgeSize) continue; if (ArptADR2 != 0xFFFE){ for (k = BrdADR + 9; k < BrdADR + BridgeSize; k++) { if (CmpAdr(dsdt, k, ArptADR2)) { ArptADR = devFind(dsdt, k); if (!ArptADR) { continue; } device_name[9] = (__typeof_am__(device_name[9]))AllocateZeroPool(5); CopyMem(device_name[9], dsdt+k, 4); DBG("found Airport device [%08X:%X] at %X And Name is %s\n", ArptADR1, ArptADR2, ArptADR, device_name[9]); // ReplaceName(dsdt + BrdADR, BridgeSize, device_name[9], "ARPT"); //sometimes dangeous ArptName = TRUE; break; } } } break; } // End ArptADR2 } if (!ArptName) { ArptADR = BrdADR; } if (BrdADR) { // bridge or device i = ArptADR; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in ARPT already exists, dropped\n"); } root = aml_create_node(NULL); } //what to do if no Arpt bridge? else { brd = aml_create_node(NULL); root = aml_add_device(brd, "ARP0"); aml_add_name(root, "_ADR"); aml_add_dword(root, ArptADR1); DBG("Created bridge device with ADR=0x%X\n", ArptADR1); } dev = root; if (!ArptName && (ArptADR2 != 0xFFFE)) {//there is no Airport device at dsdt, creating new one dev = aml_add_device(root, "ARPT"); aml_add_name(dev, "_ADR"); if (ArptADR2) { if (ArptADR2> 0x3F) aml_add_dword(dev, ArptADR2); else aml_add_byte(dev, (UINT8)ArptADR2); } else { aml_add_byte(dev, 0x00); } } Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_SUN"); if (k == 0) { k = FindName(dsdt + i, Size, "_SUN"); if (k == 0) { aml_add_name(dev, "_SUN"); aml_add_dword(dev, SlotDevices[6].SlotID); } else { //we have name sun, set the number if (dsdt[k + 4] == 0x0A) { dsdt[k + 5] = SlotDevices[6].SlotID; } } } else { DBG("Warning: Method(_SUN) found for airport\n"); } // add Method(_DSM,4,NotSerialized) for network if (gSettings.FakeWIFI || !gSettings.NoDefaultProperties) { met = aml_add_method(dev, "_DSM", 4); met2 = aml_add_store(met); pack = aml_add_package(met2); if (!gSettings.NoDefaultProperties) { aml_add_string(pack, "built-in"); aml_add_byte_buffer(pack, dataBuiltin, sizeof(dataBuiltin)); aml_add_string(pack, "model"); aml_add_string_buffer(pack, "Apple WiFi card"); aml_add_string(pack, "device_type"); aml_add_string_buffer(pack, "AirPort"); // aml_add_string(pack, "AAPL,slot-name"); // aml_add_string_buffer(pack, "AirPort"); } if (gSettings.FakeWIFI) { //aml_add_string(pack, "device-id"); //aml_add_byte_buffer(pack, (CHAR8 *)&FakeID, 4); //aml_add_string(pack, "vendor-id"); //aml_add_byte_buffer(pack, (CHAR8 *)&FakeVen, 4); aml_add_string(pack, "name"); aml_add_string_buffer(pack, (CHAR8 *)&NameCard[0]); aml_add_string(pack, "compatible"); aml_add_string_buffer(pack, (CHAR8 *)&NameCard[0]); } if (!CustProperties(pack, DEV_WIFI) && !gSettings.NoDefaultProperties && !gSettings.FakeWIFI) { aml_add_string(pack, "empty"); aml_add_byte(pack, 0); } aml_add_local0(met); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); } // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); network = (__typeof__(network))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, network, 0); aml_destroy_node(root); DBG("AirportADR=%X add patch size=%X\n", ArptADR, sizeoffset); if (ArptADR) { // bridge or WiFi i = ArptADR; } else { //this is impossible i = PCIADR; } Size = get_size(dsdt, i); DBG("adr %X size of arpt=%X\n", i, Size); // move data to back for add patch k = i + Size; len = move_data(k, dsdt, len, sizeoffset); CopyMem(dsdt+k, network, sizeoffset); // Fix Device size k = write_size(i, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, i-3, sizeoffset); FreePool(network); return len; } UINT32 FIXSBUS (UINT8 *dsdt, UINT32 len) { UINT32 i, k; UINT32 SBUSADR=0, Size=0; UINT32 PCIADR, PCISIZE = 0; INT32 sizeoffset; PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) { // DBG("wrong PCI0 address, patch SBUS will not be applied\n"); return len; } DBG("Start SBUS Fix PCI=%X len=%X\n", PCIADR, len); // Find Device SBUS if (SBUSADR1) { for (i=0x20; len >= 10 && i < len - 10; i++) { if (CmpAdr(dsdt, i, SBUSADR1)) { SBUSADR = devFind(dsdt, i); if (SBUSADR) { DBG("device (SBUS) found at %X\n", SBUSADR); break; } } // end SBUS } } if (SBUSADR) { // bridge or device i = SBUSADR; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in SBUS already exists, dropped\n"); } Size = get_size(dsdt, SBUSADR); if (ReplaceName(dsdt + SBUSADR, Size, NULL, "BUS0") < 0) { DBG("BUS0 already exists, patch SBUS will not be applied\n"); return len; } } if (SBUSADR) sizeoffset = sizeof(bus0); else sizeoffset = sizeof(sbus1); // DBG("SBUS address %X code size = 0x%08X\n", SBUSADR, sizeoffset); if (SBUSADR) { // move data to back for add sbus Size = get_size(dsdt, SBUSADR); i = SBUSADR + Size; len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt+i, bus0, sizeoffset); // Fix Device sbus size k = write_size(SBUSADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, SBUSADR-3, sizeoffset); // SBUSADR = adr1; DBG("SBUS code size fix = 0x%08X\n", sizeoffset); } else { PCISIZE = get_size(dsdt, PCIADR); i = PCIADR + PCISIZE; DBG("SBUS absent, adding to the end of PCI0 at %X\n", i); len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt+i, sbus1, sizeoffset); // Fix PCIX size k = write_size(PCIADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, PCIADR-3, sizeoffset); } return len; } //CHAR8 dataMCHC[] = {0x44,0x00,0x00,0x00}; UINT32 AddMCHC (UINT8 *dsdt, UINT32 len) { UINT32 i, k = 0; UINT32 PCIADR, PCISIZE = 0; //, Size; INT32 sizeoffset; AML_CHUNK *root; AML_CHUNK *device; // AML_CHUNK *met, *met2; // AML_CHUNK *pack; CHAR8 *mchc; PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) { // DBG("wrong PCI0 address, patch MCHC will not be applied\n"); return len; } //Find Device MCHC by name for (i=0x20; len >= 10 && i < len - 10; i++) { k = CmpDev(dsdt, i, (UINT8*)"MCHC"); if (k != 0) { DBG("device name (MCHC) found at %X, don't add!\n", k); // break; return len; } } DBG("Start Add MCHC\n"); root = aml_create_node(NULL); //Slice - now I don\t want to add _DSM to MCHC //as far as I understand it works only for native ID, not FakeID. /* if (!k) { //device not found device = aml_add_device(root, "MCHC"); aml_add_name(device, "_ADR"); aml_add_byte(device, 0x00); met = aml_add_method(device, "_DSM", 4); } else { //if device present then check _DSM Size = get_size(dsdt, k); i = FindMethod(dsdt + k, Size, "_DSM"); if (i != 0) { DBG("found MCHC with DSM, patch is not needed\n"); return len; } met = aml_add_method(root, "_DSM", 4); } */ device = aml_add_device(root, "MCHC"); aml_add_name(device, "_ADR"); aml_add_byte(device, 0x00); // add Method(_DSM,4,NotSerialized) for MCHC /* met2 = aml_add_store(met); pack = aml_add_package(met2); aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, dataMCHC, sizeof(dataMCHC)); aml_add_string(pack, "name"); aml_add_string(pack, "pci8086,44"); aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) */ aml_calculate_size(root); mchc = (__typeof__(mchc))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, mchc, 0); aml_destroy_node(root); // always add on PCIX back PCISIZE = get_size(dsdt, PCIADR); len = move_data(PCIADR + PCISIZE, dsdt, len, sizeoffset); CopyMem(dsdt + PCIADR + PCISIZE, mchc, sizeoffset); // Fix PCIX size k = write_size(PCIADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, PCIADR-3, sizeoffset); FreePool(mchc); return len; } UINT32 AddIMEI (UINT8 *dsdt, UINT32 len) { UINT32 i, k = 0; UINT32 PCIADR, PCISIZE = 0; INT32 sizeoffset; AML_CHUNK *root; AML_CHUNK *device; AML_CHUNK *met, *met2; AML_CHUNK *pack; CHAR8 *imei; UINT32 FakeID; UINT32 FakeVen; if (gSettings.FakeIMEI) { FakeID = gSettings.FakeIMEI >> 16; FakeVen = gSettings.FakeIMEI & 0xFFFF; } PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) { // DBG("wrong PCI0 address, patch IMEI will not be applied\n"); return len; } // Find Device IMEI if (IMEIADR1) { for (i=0x20; len >= 10 && i < len - 10; i++) { if (CmpAdr(dsdt, i, IMEIADR1)) { k = devFind(dsdt, i); if (k) { MsgLog("device (IMEI) found at %X, don't add!\n", k); // break; return len; } } } } //Find Device IMEI by name for (i=0x20; len >= 10 && i < len - 10; i++) { k = CmpDev(dsdt, i, (UINT8*)"IMEI"); if (k != 0) { MsgLog("device name (IMEI) found at %X, don't add!\n", k); return len; } } MsgLog("Start Add IMEI\n"); root = aml_create_node(NULL); device = aml_add_device(root, "IMEI"); aml_add_name(device, "_ADR"); aml_add_dword(device, IMEIADR1); // add Method(_DSM,4,NotSerialized) if (gSettings.FakeIMEI) { met = aml_add_method(device, "_DSM", 4); met2 = aml_add_store(met); pack = aml_add_package(met2); aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeID, 4); aml_add_string(pack, "vendor-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeVen, 4); aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) } aml_calculate_size(root); imei = (__typeof__(imei))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, imei, 0); aml_destroy_node(root); // always add on PCIX back len = move_data(PCIADR+PCISIZE, dsdt, len, sizeoffset); CopyMem(dsdt+PCIADR+PCISIZE, imei, sizeoffset); // Fix PCIX size k = write_size(PCIADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, PCIADR-3, sizeoffset); FreePool(imei); return len; } UINT8 dataFW[] = {0x00,0x00,0x00,0x00}; UINT32 FIXFirewire (UINT8 *dsdt, UINT32 len) { UINT32 i, k; UINT32 FirewireADR = 0, BrdADR = 0, BridgeSize, Size; INT32 sizeoffset; UINT32 PCIADR, PCISIZE = 0; AML_CHUNK *met; AML_CHUNK *root; AML_CHUNK *stro; AML_CHUNK *pack; CHAR8 *firewire; AML_CHUNK* device; PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) { DBG("wrong PCI0 address, patch FRWR will not be applied\n"); return len; } // Firewire Address for (i = 0x20; len >=10 && i < len - 10; i++) { if (FirewireADR1 != 0x00000000 && CmpAdr(dsdt, i, FirewireADR1)) { BrdADR = devFind(dsdt, i); if (!BrdADR) { continue; } BridgeSize = get_size(dsdt, BrdADR); if (FirewireADR2 != 0xFFFE ){ for (k = BrdADR + 9; k < BrdADR + BridgeSize; k++) { if (CmpAdr(dsdt, k, FirewireADR2)) { FirewireADR = devFind(dsdt, k); if (!FirewireADR) { continue; } device_name[2] = (__typeof_am__(device_name[2]))AllocateZeroPool(5); CopyMem(device_name[2], dsdt+k, 4); DBG("found Firewire device NAME(_ADR,0x%08X) at %X And Name is %s\n", FirewireADR2, k, device_name[2]); ReplaceName(dsdt + BrdADR, BridgeSize, device_name[2], "FRWR"); FirewireName = TRUE; break; } } } break; } // End Firewire } if (!BrdADR) { DBG("Bridge for FRWR is not found\n"); return len; } //safe for twice fix: if _DSM already present then cancel fix if (FirewireADR) { // bridge or device i = FirewireADR; } else { i = BrdADR; } Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in FRWR already exists, dropped\n"); } root = aml_create_node(NULL); device = root; DBG("Start Firewire Fix\n"); if (!FirewireName) { device = aml_add_device(root, "FRWR"); aml_add_name(device, "_ADR"); if (FirewireADR2) { if (FirewireADR2 <= 0x3F) { aml_add_byte(device, (UINT8)FirewireADR2); } else { aml_add_dword(device, FirewireADR2); } } else aml_add_byte(device, 0); aml_add_name(device, "_GPE"); aml_add_byte(device, 0x1A); } met = aml_add_method(device, "_DSM", 4); Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_SUN"); if (k == 0) { k = FindName(dsdt + i, Size, "_SUN"); if (k == 0) { aml_add_name(device, "_SUN"); aml_add_dword(device, SlotDevices[12].SlotID); } else { //we have name sun, set the number if (dsdt[k + 4] == 0x0A) { dsdt[k + 5] = SlotDevices[12].SlotID; } } } else { DBG("Warning: Method(_SUN) found for firewire\n"); } stro = aml_add_store(met); pack = aml_add_package(stro); if (!CustProperties(pack, DEV_FIREWIRE)) { aml_add_string(pack, "fwhub"); aml_add_byte_buffer(pack, dataFW, sizeof(dataFW)); } aml_add_local0(stro); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); firewire = (__typeof__(firewire))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, firewire, 0); aml_destroy_node(root); // move data to back for add patch Size = get_size(dsdt, i); if (!Size) { FreePool(firewire); return len; } k = i + Size; len = move_data(k, dsdt, len, sizeoffset); CopyMem(dsdt + k, firewire, sizeoffset); // Fix Device size k = write_size(i, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, i-3, sizeoffset); FreePool(firewire); return len; } UINT32 AddHDEF (UINT8 *dsdt, UINT32 len, const XString8& OSVersion) { UINT32 i, k; UINT32 PCIADR, PCISIZE = 0; INT32 sizeoffset; UINT32 HDAADR = 0, Size; AML_CHUNK* root; // AML_CHUNK* met, *met2; AML_CHUNK* device; // AML_CHUNK* pack; CHAR8 *hdef; PCIADR = GetPciDevice(dsdt, len); if (PCIADR) { PCISIZE = get_size(dsdt, PCIADR); } if (!PCISIZE) return len; //what is the bad DSDT ?! DBG("Start HDA Fix\n"); // len = DeleteDevice("AZAL", dsdt, len); // HDA Address for (i=0x20; len >= 10 && i < len - 10; i++) { if (HDAADR1 != 0x00000000 && HDAFIX && CmpAdr(dsdt, i, HDAADR1)) { HDAADR = devFind(dsdt, i); if (!HDAADR) { continue; } // BridgeSize = get_size(dsdt, HDAADR); device_name[4] = (__typeof_am__(device_name[4]))AllocateZeroPool(5); CopyMem(device_name[4], dsdt+i, 4); DBG("found HDA device NAME(_ADR,0x%08X) And Name is %s\n", HDAADR1, device_name[4]); ReplaceName(dsdt, len, device_name[4], "HDEF"); HDAFIX = FALSE; break; } // End HDA } if (HDAADR) { // bridge or device i = HDAADR; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in HDA already exists, dropped\n"); } } root = aml_create_node(NULL); if (HDAFIX) { MsgLog("Start Add Device HDEF\n"); device = aml_add_device(root, "HDEF"); aml_add_name(device, "_ADR"); aml_add_dword(device, HDAADR1); // add Method(_DSM,4,NotSerialized) /* met = aml_add_method(device, "_DSM", 4); } else { met = aml_add_method(root, "_DSM", 4); } met2 = aml_add_store(met); pack = aml_add_package(met2); if (gSettings.UseIntelHDMI) { aml_add_string(pack, "hda-gfx"); aml_add_string_buffer(pack, "onboard-1"); } if (!CustProperties(pack, DEV_HDA)) { if ((OSVersion != NULL && AsciiOSVersionToUint64(OSVersion) < AsciiOSVersionToUint64("10.8")) || (gSettings.HDALayoutId > 0)) { aml_add_string(pack, "layout-id"); aml_add_byte_buffer(pack, (CHAR8*)&HDAlayoutId, 4); } aml_add_string(pack, "MaximumBootBeepVolume"); aml_add_byte_buffer(pack, (CHAR8*)&dataBuiltin1[0], 1); if (gSettings.AFGLowPowerState) { aml_add_string(pack, "AFGLowPowerState"); aml_add_byte_buffer(pack, Yes, 4); } aml_add_string(pack, "PinConfigurations"); aml_add_byte_buffer(pack, 0, 0);//data, sizeof(data)); } aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) */ } aml_calculate_size(root); hdef = (__typeof__(hdef))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, hdef, 0); aml_destroy_node(root); if (!HDAFIX) { // bridge or device i = HDAADR; } else { i = PCIADR; } Size = get_size(dsdt, i); // move data to back for add patch k = i + Size; len = move_data(k, dsdt, len, sizeoffset); CopyMem(dsdt + k, hdef, sizeoffset); // Fix Device size k = write_size(i, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, i-3, sizeoffset); FreePool(hdef); return len; } UINT32 FIXUSB (UINT8 *dsdt, UINT32 len) { UINT32 i, j, k; UINT32 Size, size1, size2, size3; //, size4; UINT32 adr=0, adr1=0; INT32 sizeoffset; AML_CHUNK* root; AML_CHUNK* root1; AML_CHUNK* met; AML_CHUNK* pack; AML_CHUNK *met1, *met2; AML_CHUNK* pack1; CHAR8 *USBDATA1; CHAR8 *USBDATA2; CHAR8 *USBDATA3; // CHAR8 *USBDATA4; DBG("Start USB Fix\n"); //DBG("len = 0x%08X\n", len); root = aml_create_node(NULL); root1 = aml_create_node(NULL); // add Method(_DSM,4,NotSerialized) for USB met = aml_add_method(root, "_DSM", 4); met2 = aml_add_store(met); pack = aml_add_package(met2); if (!CustProperties(pack, DEV_USB)) { aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (/* CONST*/ UINT8*)&USBID[0], 4); aml_add_string(pack, "built-in"); aml_add_byte_buffer(pack, dataBuiltin, sizeof(dataBuiltin)); aml_add_string(pack, "device_type"); if (USBIntel) { aml_add_string_buffer(pack, "UHCI"); } else if (USBNForce) { aml_add_string_buffer(pack, "OHCI"); } if (gSettings.InjectClockID) { aml_add_string(pack, "AAPL,clock-id"); aml_add_byte_buffer(pack, dataBuiltin, 1); } } aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); USBDATA1 = (__typeof__(USBDATA1))AllocateZeroPool(root->Size); size1 = root->Size; // DBG("USB1 code size = 0x%08X\n", size1); aml_write_node(root, USBDATA1, 0); aml_destroy_node(root); // add Method(_DSM,4,NotSerialized) for USB2 met1 = aml_add_method(root1, "_DSM", 4); met2 = aml_add_store(met1); pack1 = aml_add_package(met2); if (!CustProperties(pack, DEV_USB)) { aml_add_string(pack1, "device-id"); aml_add_byte_buffer(pack1, (/* CONST*/ UINT8*)&USBID[0], 4); aml_add_string(pack1, "built-in"); aml_add_byte_buffer(pack1, dataBuiltin, sizeof(dataBuiltin)); aml_add_string(pack1, "device_type"); aml_add_string_buffer(pack1, "EHCI"); if (gSettings.InjectClockID) { aml_add_string(pack1, "AAPL,clock-id"); aml_add_byte_buffer(pack1, dataBuiltin, sizeof(dataBuiltin)); } if (USBIntel) { aml_add_string(pack1, "AAPL,current-available"); if (gSettings.HighCurrent) { aml_add_word(pack1, 0x0834); } else { aml_add_word(pack1, 0x05DC); } aml_add_string(pack1, "AAPL,current-extra"); if (gSettings.HighCurrent) { aml_add_word(pack1, 0x0C80); } else { aml_add_word(pack1, 0x03E8); } aml_add_string(pack1, "AAPL,current-in-sleep"); aml_add_word(pack1, 0x0BB8); // aml_add_string(pack1, "AAPL,device-internal"); // aml_add_byte(pack1, 0x02); } else if (USBNForce) { aml_add_string(pack1, "AAPL,current-available"); aml_add_word(pack1, 0x04B0); aml_add_string(pack1, "AAPL,current-extra"); aml_add_word(pack1, 0x02BC); aml_add_string(pack1, "AAPL,current-in-sleep"); aml_add_word(pack1, 0x03E8); } } //new systems has new strings /* Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method { Store (Package (0x08) { "kUSBSleepPowerSupply", 0x13EC, "kUSBSleepPortCurrentLimit", 0x0834, "kUSBWakePowerSupply", 0x13EC, "kUSBWakePortCurrentLimit", 0x0834 }, Local0) DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0)) Return (Local0) } */ aml_add_byte_buffer(pack1, dataBuiltin, sizeof(dataBuiltin)); aml_add_local0(met2); aml_add_buffer(met1, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root1); USBDATA2 = (__typeof__(USBDATA2))AllocateZeroPool(root1->Size); size2 = root1->Size; // DBG("USB2 code size = 0x%08X\n", size2); aml_write_node(root1, USBDATA2, 0); aml_destroy_node(root1); //NFORCE_USB_START -- already done Intel or NForce same USBDATA2 /* aml_calculate_size(root1); USBDATA4 = (__typeof__(USBDATA4))AllocateZeroPool(root1->Size); size4 = root1->Size; DBG("USB OHCI code size = 0x%08X\n", size4); aml_write_node(root1, USBDATA4, 0); aml_destroy_node(root1); */ //NFORCE_USB_END // add Method(_DSM,4,NotSerialized) for USB3 root1 = aml_create_node(NULL); met1 = aml_add_method(root1, "_DSM", 4); met2 = aml_add_store(met1); pack1 = aml_add_package(met2); if (!CustProperties(pack, DEV_USB)) { aml_add_string(pack1, "device-id"); aml_add_byte_buffer(pack1, (/* CONST*/ UINT8*)&USBID[0], 4); aml_add_string(pack1, "built-in"); aml_add_byte_buffer(pack1, dataBuiltin, sizeof(dataBuiltin)); aml_add_string(pack1, "device_type"); aml_add_string_buffer(pack1, "XHCI"); if (gSettings.InjectClockID) { aml_add_string(pack1, "AAPL,clock-id"); aml_add_byte_buffer(pack1, dataBuiltin, sizeof(dataBuiltin)); } aml_add_string(pack1, "AAPL,current-available"); aml_add_word(pack1, 0x0834); aml_add_string(pack1, "AAPL,current-extra"); aml_add_word(pack1, 0x0A8C); aml_add_string(pack1, "AAPL,current-in-sleep"); aml_add_word(pack1, 0x0A8C); aml_add_string(pack1, "AAPL,max-port-current-in-sleep"); aml_add_word(pack1, 0x0834); aml_add_string(pack1, "AAPL,device-internal"); aml_add_byte(pack1, 0x00); } aml_add_byte_buffer(pack1, dataBuiltin, sizeof(dataBuiltin)); aml_add_local0(met2); aml_add_buffer(met1, dtgp_1, sizeof(dtgp_1)); // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root1); USBDATA3 = (__typeof__(USBDATA3))AllocateZeroPool(root1->Size); size3 = root1->Size; // DBG("USB3 code size = 0x%08X\n", size3); aml_write_node(root1, USBDATA3, 0); aml_destroy_node(root1); if (usb > 0) { for (i = 0; i < usb; i++) { INT32 XhciCount = 1; INT32 EhciCount = 0; // find USB adr for (j = 0x20; len >= 4 && j < len - 4; j++) { if (CmpAdr(dsdt, j, USBADR[i])) { //j+4 -> _ADR XhciName = FALSE; UsbName[i] = (__typeof_am__(UsbName[i]))AllocateZeroPool(5); // DBG("found USB at 0x%X\n", j); adr1 = devFind(dsdt, j + 2); if (!adr1) { continue; } Size = get_size(dsdt, adr1); //bridgesize DBG("USB bridge[%X] at %X, size = %X\n", USBADR[i], adr1, Size); if (USBADR2[i] != 0xFFFE ){ for (k = adr1 + 9; k < adr1 + Size; k++) { if (CmpAdr(dsdt, k, USBADR2[i])) { adr = devFind(dsdt, k); if (!adr) { continue; } device_name[10] = (__typeof_am__(device_name[10]))AllocateZeroPool(5); CopyMem(device_name[10], dsdt+k, 4); DBG("found USB device [%08X:%X] at %X and Name was %s ->", USBADR[i], USBADR2[i], k, device_name[10]); if (USB30[i]) { if (gSettings.NameXH00) { snprintf(UsbName[i], 5, "XH%02x", XhciCount++); } else { snprintf(UsbName[i], 5, "XHC%01x", XhciCount++); } } else if (USB20[i]) { if (gSettings.NameEH00) { snprintf(UsbName[i], 5, "EH%02x", EhciCount++); } else { snprintf(UsbName[i], 5, "EHC%01x", EhciCount++); } } else { snprintf(UsbName[i], 5, "USB%d", i); // %01d is strictly the same as %d } DBG(" %s\n", UsbName[i]); ReplaceName(dsdt + adr1, Size, device_name[10], UsbName[i]); XhciName = TRUE; break; } } } if (!XhciName) { adr = adr1; } Size = get_size(dsdt, adr); k = FindMethod(dsdt + adr, Size, "_DSM"); if (k != 0) { k += adr; //here we want to check who is the master of the _DSM adr1 = devFind(dsdt, k); if (adr1 == adr) { Size = get_size(dsdt, k); if (!Size) { continue; } sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in USB already exists, dropped by 0x%X\n", sizeoffset); } else { DBG(" found slave _DSM, skip\n"); continue; } } //UINT32 k = (adr > 0x3F)?1:0; /* 14 45 06 5F 44 53 4D 04 70 12 4F 04 08 0D 64 65 76 69 63 65 2D 69 64 00 11 07 0A 04 31 1E 00 00 0D 62 75 69 6C 74 2D 69 6E 00 11 04 0A 01 00 0D 64 65 76 69 63 65 5F 74 79 70 65 00 11 08 0A 04 55 48 43 49 00 0D 41 41 50 4C 2C 63 6C 6F 63 6B 2D 69 64 00 11 04 0A 01 00 60 44 54 47 50 68 69 6A 6B 71 60 A4 60 */ if (USB30[i]) { if ((USBDATA3[25] == 0x0A) && (USBDATA3[26] == 0x04)) { k = 27; } else if ((USBDATA3[26] == 0x0A) && (USBDATA3[27] == 0x04)) { k = 28; } else { continue; } if (gSettings.FakeXHCI) { USBID[i] = gSettings.FakeXHCI >> 16; } CopyMem(USBDATA3+k, (VOID*)&USBID[i], 4); sizeoffset = size3; } else if (USB20[i]) { if ((USBDATA2[25] == 0x0A) && (USBDATA2[26] == 0x04)) { k = 27; } else if ((USBDATA2[26] == 0x0A) && (USBDATA2[27] == 0x04)) { k = 28; } else { continue; } CopyMem(USBDATA2+k, (VOID*)&USBID[i], 4); sizeoffset = size2; } else { if ((USBDATA1[25] == 0x0A) && (USBDATA1[26] == 0x04)) { k = 27; } else if ((USBDATA1[26] == 0x0A) && (USBDATA1[27] == 0x04)) { k = 28; } else { continue; } CopyMem(USBDATA1+k, (VOID*)&USBID[i], 4); sizeoffset = size1; } len = move_data(adr + Size, dsdt, len, sizeoffset); if (USB30[i]) { CopyMem(dsdt + adr + Size, USBDATA3, sizeoffset); } else if (USB20[i]) { CopyMem(dsdt + adr + Size, USBDATA2, sizeoffset); } else { CopyMem(dsdt + adr + Size, USBDATA1, sizeoffset); } // Fix Device USB size k = write_size(adr, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, adr-3, sizeoffset); break; } //NFORCE_USB_START else if (CmpAdr(dsdt, j, USBADR3[i])) { UsbName[i] = (__typeof_am__(UsbName[i]))AllocateZeroPool(5); CopyMem(UsbName[i], dsdt+j, 4); adr1 = devFind(dsdt, j); if (!adr1) { continue; } adr = get_size(dsdt, adr1); //UINT32 k = (adr > 0x3F)?1:0; /* 14 45 06 5F 44 53 4D 04 70 12 4F 04 08 0D 64 65 76 69 63 65 2D 69 64 00 11 07 0A 04 31 1E 00 00 0D 62 75 69 6C 74 2D 69 6E 00 11 04 0A 01 00 0D 64 65 76 69 63 65 5F 74 79 70 65 00 11 08 0A 04 55 48 43 49 00 0D 41 41 50 4C 2C 63 6C 6F 63 6B 2D 69 64 00 11 04 0A 01 00 60 44 54 47 50 68 69 6A 6B 71 60 A4 60 */ if (USB40[i]) { if ((USBDATA2[25] == 0x0A) && (USBDATA2[26] == 0x04)) { k = 27; } else if ((USBDATA2[26] == 0x0A) && (USBDATA2[27] == 0x04)) { k = 28; } else { continue; } CopyMem(USBDATA2+k, (VOID*)&USBID[i], 4); sizeoffset = size2; } else { if ((USBDATA1[25] == 0x0A) && (USBDATA1[26] == 0x04)) { k = 27; } else if ((USBDATA1[26] == 0x0A) && (USBDATA1[27] == 0x04)) { k = 28; } else { continue; } CopyMem(USBDATA1+k, (VOID*)&USBID[i], 4); sizeoffset = size1; } len = move_data(adr1+adr, dsdt, len, sizeoffset); if (USB40[i]) { CopyMem(dsdt+adr1+adr, USBDATA2, sizeoffset); } else { CopyMem(dsdt+adr1+adr, USBDATA1, sizeoffset); } // Fix Device USB size k = write_size(adr1, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, adr1-3, sizeoffset); break; } //NFORCE_USB_END } } } FreePool(USBDATA1); FreePool(USBDATA2); FreePool(USBDATA3); // FreePool(USBDATA4); return len; } UINT8 DevIDE[] = {0x9E,0x26,0x00,0x00}; UINT8 VenIDE[] = {0x86,0x80,0x00,0x00}; UINT32 FIXIDE (UINT8 *dsdt, UINT32 len) { UINT32 i, k; UINT32 j; UINT32 IDEADR = 0, BridgeSize = 0, Size; INT32 sizeoffset; AML_CHUNK *root; AML_CHUNK *device; CHAR8 *ide; BOOLEAN PATAFIX=TRUE; AML_CHUNK *met, *met2; AML_CHUNK *pack; AML_CHUNK *device1; AML_CHUNK *device2; if (!IDEADR1) return len; for (i=0x20; len >= 10 && i < len - 10; i++) { if (CmpAdr(dsdt, i, IDEADR1)) { DBG("Found IDEADR1=%X at %X\n", IDEADR1, i); IDEADR = devFind(dsdt, i); if (!IDEADR) { continue; } BridgeSize = get_size(dsdt, IDEADR); if (BridgeSize) break; } // End IDE } if (!BridgeSize) return len; DBG("Start IDE Fix\n"); // find Name(_ADR, Zero) if yes, don't need to inject PATA name for (j=IDEADR+9; jSize); sizeoffset = root->Size; aml_write_node(root, ide, 0); aml_destroy_node(root); // move data to back for add DSM j = IDEADR + BridgeSize; len = move_data(j, dsdt, len, sizeoffset); CopyMem(dsdt+j, ide, sizeoffset); // Fix Device ide size k = write_size(IDEADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, IDEADR-3, sizeoffset); //add patafix sizeoffset = sizeof(patafix); // DBG("add patafix size=%X\n", sizeoffset); i = get_size(dsdt, IDEADR); j = IDEADR + i; len = move_data(j, dsdt, len, sizeoffset); CopyMem(dsdt+j, patafix, sizeoffset); k = write_size(IDEADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, IDEADR-3, sizeoffset); FreePool(ide); return len; } //CHAR8 DevSATA[] = {0x81, 0x26, 0x00, 0x00}; UINT32 FIXSATAAHCI (UINT8 *dsdt, UINT32 len) { UINT32 i, k; UINT32 SATAAHCIADR = 0, BridgeSize = 0, Size; INT32 sizeoffset; AML_CHUNK* root; AML_CHUNK* met, *met2; AML_CHUNK* pack; CHAR8 *sata; UINT32 FakeID; UINT32 FakeVen; if (gSettings.FakeSATA) { FakeID = gSettings.FakeSATA >> 16; FakeVen = gSettings.FakeSATA & 0xFFFF; } if (!SATAAHCIADR1) return len; for (i=0x20; len >= 10 && i < len - 10; i++) { if (CmpAdr(dsdt, i, SATAAHCIADR1)) { // DBG("Found SATAAHCIADR1=%X at %X\n", SATAAHCIADR1, i); SATAAHCIADR = devFind(dsdt, i); if (!SATAAHCIADR) { continue; } BridgeSize = get_size(dsdt, SATAAHCIADR); if (BridgeSize) break; } } if (!BridgeSize) return len; if (SATAAHCIADR) { // bridge or device i = SATAAHCIADR; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in SATA already exists, dropped\n"); } } DBG("Start SATA AHCI Fix\n"); root = aml_create_node(NULL); // add Method(_DSM,4,NotSerialized) if (gSettings.FakeSATA || !gSettings.NoDefaultProperties) { met = aml_add_method(root, "_DSM", 4); met2 = aml_add_store(met); pack = aml_add_package(met2); if (gSettings.FakeSATA) { aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeID, 4); aml_add_string(pack, "vendor-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeVen, 4); } if (!CustProperties(pack, DEV_SATA) && !gSettings.NoDefaultProperties && !gSettings.FakeSATA) { aml_add_string(pack, "empty"); aml_add_byte(pack, 0); } aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); } // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); sata = (__typeof__(sata))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, sata, 0); aml_destroy_node(root); // move data to back for add DSM BridgeSize = get_size(dsdt, SATAAHCIADR); i = SATAAHCIADR + BridgeSize; len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt + i, sata, sizeoffset); // Fix Device SATA size k = write_size(SATAAHCIADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, SATAAHCIADR-3, sizeoffset); FreePool(sata); return len; } //CHAR8 DevSATA0[] = {0x80, 0x26, 0x00, 0x00}; UINT32 FIXSATA (UINT8 *dsdt, UINT32 len) { UINT32 i, k; UINT32 SATAADR = 0, BridgeSize = 0, Size; INT32 sizeoffset; AML_CHUNK* root; AML_CHUNK* met, *met2; AML_CHUNK* pack; CHAR8 *sata; UINT32 FakeID; UINT32 FakeVen; if (gSettings.FakeSATA) { FakeID = gSettings.FakeSATA >> 16; FakeVen = gSettings.FakeSATA & 0xFFFF; } if (!SATAADR1) return len; for (i=0x20; len >= 10 && i < len - 10; i++) { if (CmpAdr(dsdt, i, SATAADR1)) { // DBG("Found SATAAHCIADR1=%X at %X\n", SATAAHCIADR1, j); SATAADR = devFind(dsdt, i); if (!SATAADR) { continue; } BridgeSize = get_size(dsdt, SATAADR); if (BridgeSize) break; } // End IDE } if (!BridgeSize) return len; if (SATAADR) { // bridge or device i = SATAADR; Size = get_size(dsdt, i); k = FindMethod(dsdt + i, Size, "_DSM"); if (k != 0) { k += i; Size = get_size(dsdt, k); sizeoffset = - 1 - Size; len = move_data(k - 1, dsdt, len, sizeoffset); len = CorrectOuters(dsdt, len, k - 2, sizeoffset); DBG("_DSM in SATA already exists, dropped\n"); } } DBG("Start SATA Fix\n"); root = aml_create_node(NULL); // add Method(_DSM,4,NotSerialized) if (gSettings.FakeSATA || !gSettings.NoDefaultProperties) { met = aml_add_method(root, "_DSM", 4); met2 = aml_add_store(met); pack = aml_add_package(met2); if (gSettings.FakeSATA) { aml_add_string(pack, "device-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeID, 4); aml_add_string(pack, "vendor-id"); aml_add_byte_buffer(pack, (UINT8*)&FakeVen, 4); } if (!CustProperties(pack, DEV_SATA) && !gSettings.NoDefaultProperties && !gSettings.FakeSATA) { aml_add_string(pack, "empty"); aml_add_byte(pack, 0); } aml_add_local0(met2); aml_add_buffer(met, dtgp_1, sizeof(dtgp_1)); } // finish Method(_DSM,4,NotSerialized) aml_calculate_size(root); sata = (__typeof__(sata))AllocateZeroPool(root->Size); sizeoffset = root->Size; aml_write_node(root, sata, 0); aml_destroy_node(root); // move data to back for add DSM BridgeSize = get_size(dsdt, SATAADR); i = SATAADR + BridgeSize; len = move_data(i, dsdt, len, sizeoffset); CopyMem(dsdt + i, sata, sizeoffset); // Fix Device SATA size k = write_size(SATAADR, dsdt, len, sizeoffset); sizeoffset += k; len += k; len = CorrectOuters(dsdt, len, SATAADR-3, sizeoffset); FreePool(sata); return len; } /* UINT32 FIXCPU1 (UINT8 *dsdt, UINT32 len) { UINT32 i, j; UINT32 count=0; UINT32 pradr=0; UINT32 prsize=0, size=0; UINT32 prsize1=0; INT32 offset, sizeoffset; DBG("Start CPUS=1 Fix\n"); DBG("len = 0x%08X\n", len); // find _PR_ and get PR size for (i=0x20; i 0x3F there should be had P_states code so don't fix if (prsize > 0x3F) return len; DBG("_PR_ adr = 0x%08X size = 0x%08X\n", pradr, prsize); break; } } break; } } sizeoffset = 9; // find alias for (i=pradr; i> 6); if (dsdt[offset] == '\\') offset = i + 8 + (dsdt[i+7] >> 6); if (dsdt[i+2+size] != 0x06 && dsdt[offset] != 'C' && dsdt[offset+1] != 'P' && dsdt[offset+2] != 'U') { DBG("Found alias CPU.\n"); len = move_data(i+2+size, dsdt, len, sizeoffset); dsdt[i+2+size] = 0x06; dsdt[i+3+size] = dsdt[i+2]; dsdt[i+4+size] = dsdt[i+3]; dsdt[i+5+size] = dsdt[i+4]; dsdt[i+6+size] = dsdt[i+5]; dsdt[i+7+size] = 'C'; dsdt[i+8+size] = 'P'; dsdt[i+9+size] = 'U'; dsdt[i+10+size] = dsdt[i+5]; j = write_size(pradr, dsdt, len, sizeoffset); sizeoffset += j; len += j; count++; continue; } } } DBG("return len=%X\n", len); return len; } */ UINT32 FIXWAK (UINT8 *dsdt, UINT32 len, EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE* fadt) { UINT32 i, j, k; UINT32 wakadr=0; UINT32 waksize=0; UINT32 sizeoffset = 0, sizeoffset2 = 0; // UINT16 PM30 = 0x430; //default BOOLEAN ReturnFound = FALSE; DBG("Start _WAK Return Fix\n"); for (i = 0x24; len >= 5 && i < len - 5; i++) { if(dsdt[i] == '_' && dsdt[i+1] == 'W' && dsdt[i+2] == 'A' && dsdt[i+3] == 'K') { for (j=0; j<10; j++) { if(dsdt[i-j] == 0x14) { //Method _WAK found wakadr = i-j+1; waksize = get_size(dsdt, wakadr); if (!waksize) { continue; } //DBG( "_WAK adr = 0x%08X, size = 0x%08X\n", wakadr, waksize); for (k=0; kPm1aEvtBlk + 0x30; sizeoffset = sizeof(wakslp1) + 3 + sizeof(wakslp2); len = move_data(i + 5, dsdt, len, sizeoffset); CopyMem(dsdt + i + 5, wakslp1, sizeof(wakslp1)); k = i + 5 + sizeof(wakslp1); dsdt[k++] = 0x0B; dsdt[k++] = PM30 & 0xFF; dsdt[k++] = PM30 >> 8; CopyMem(dsdt + k, wakslp2, sizeof(wakslp2)); k = write_size(wakadr, dsdt, len, sizeoffset); sizeoffset += k; len += k; } */ sizeoffset = sizeof(waksecur); len = move_data(i + 5, dsdt, len, sizeoffset); CopyMem(dsdt + i + 5, waksecur, sizeof(waksecur)); k = write_size(wakadr, dsdt, len, sizeoffset); sizeoffset += k; len += k; if (!ReturnFound) { DBG( "_WAK Method need return data, will patch it.\n"); waksize = get_size(dsdt, wakadr); if (!waksize) { continue; } sizeoffset2 = sizeof(wakret); len = move_data(wakadr + waksize, dsdt, len, sizeoffset2); CopyMem(dsdt + wakadr + waksize, wakret, sizeoffset2); k = write_size(wakadr, dsdt, len, sizeoffset2); sizeoffset += k + sizeoffset2; len += k; } len = CorrectOuters(dsdt, len, wakadr-2, sizeoffset); break; } } break; } } DBG("return len=%X\n", len); return len; } #if 0 UINT32 FIXGPE (UINT8 *dsdt, UINT32 len) { UINT32 i, j, k, l, m, n; UINT32 gpeadr=0; // UINT32 gpesize=0; UINT32 pwrbadr=0; UINT32 pwrbsize=0; UINT32 usbcount=0; UINT32 PWRBADR = 0; // UINT32 adr=0; INT32 offset=0; INT32 sizeoffset; // BOOLEAN pwrbfix = FALSE; // BOOLEAN usbpwrb = FALSE; // BOOLEAN foundpwrb = FALSE; sizeoffset = sizeof(pwrb); if (!PWRBADR) { return len; } DBG("Start _GPE device remove error Fix\n"); //DBG("len = 0x%08X\n", len); for (i=0; i body 53 4D 49 5F 0A 8A 68 */ // sizeoffset = sizeof(shutdown); // == 18 size = get_size(dsdt, adr); adr1 = adr; for (j=0; j<20; j++) { if ((dsdt[adr+j] == 'T') && (dsdt[adr+j+1] == 'S')) { adr1 = adr+j+3; //address of body break; } } adr2 = adr1 + sizeoffset - 1; //jump adr len = move_data(adr1, dsdt, len, sizeoffset); //new len CopyMem(dsdt+adr1, shutdown, sizeoffset); //insert shutdown i = adr + size - adr1; //body size shift = write_offset(adr2, dsdt, len, i); //may return 0 or 1 len += shift; sizeoffset += shift; shift = write_size(adr, dsdt, len, sizeoffset); // sizeoffset += shift; len += shift; return len; } #if 0 //Slice - this procedure was not corrected and mostly wrong UINT32 FIXOTHER (UINT8 *dsdt, UINT32 len) { UINT32 i, j, k, m, offset, l; UINT32 size; // Fix USB _PRW value for 0x0X, 0x04 ==> 0x0X, 0x01 for(j=0; j= 15 && i < len - 15; i++) { if ((dsdt[i] == 0x5B) && (dsdt[i+1] == 0x80) && GetName(dsdt, (INT32)(i+2), &Name[0], &shift)) { //this is region. Compare to bios tables p = gRegions; while (p) { if (AsciiStrStr(p->Name, Name)) { UINT32 oldAddress = 0; //apply patch if (dsdt[i+7+shift] == 0x0C) { CopyMem(&oldAddress, &dsdt[i+8+shift], 4); CopyMem(&dsdt[i+8+shift], &p->Address, 4); } else if (dsdt[i+7+shift] == 0x0B) { CopyMem(&oldAddress, &dsdt[i+8+shift], 2); CopyMem(&dsdt[i+8+shift], &p->Address, 2); } else { //propose this is indirect name if (GetName(dsdt, (INT32)(i+7+shift), &NameAdr[0], NULL)) { j = FindName(dsdt, len, &NameAdr[0]); if (j > 0) { MsgLog(" indirect name=%s\n", NameAdr); if (dsdt[j+4] == 0x0C) { CopyMem(&oldAddress, &dsdt[j+5], 4); CopyMem(&dsdt[j+5], &p->Address, 4); // Corrected = TRUE; } else if (dsdt[j+4] == 0x0B) { CopyMem(&oldAddress, &dsdt[j+5], 2); CopyMem(&dsdt[j+5], &p->Address, 2); } else { MsgLog("... value not defined\n"); } } } } if (oldAddress != p->Address) { MsgLog("OperationRegion (%s...) corrected from 0x%X to addr=0x%X\n", Name, oldAddress, p->Address); } break; } p = p->next; } } } } VOID GetBiosRegions(UINT8 *buffer) { EFI_ACPI_DESCRIPTION_HEADER *TableHeader; // UINT8 *buffer = NULL; UINT32 bufferLen = 0; UINTN i, j; INTN shift, shift2; CHAR8 Name[8]; CHAR8 NameAdr[8]; if (!buffer) { return; } // gRegions = NULL; // buffer = (UINT8*)(UINTN)fadt->Dsdt; TableHeader = (EFI_ACPI_DESCRIPTION_HEADER*)buffer; bufferLen = TableHeader->Length; for (i=0x24; bufferLen >= 15 && i < bufferLen - 15; i++) { if ((buffer[i] == 0x5B) && (buffer[i+1] == 0x80) && GetName(buffer, (INT32)(i+2), &Name[0], &shift)) { if (buffer[i+6+shift] == 0) { //this is SystemMemory region. Write to bios regions tables OPER_REGION tmp; tmp.Address = 0; CopyMem(&tmp.Name[0], &buffer[i+2+shift], 4); tmp.Name[4] = 0; if (buffer[i+7+shift] == 0x0C) { CopyMem(&tmp.Address, &buffer[i+8+shift], 4); } else if (buffer[i+7+shift] == 0x0B) { CopyMem(&tmp.Address, &buffer[i+8+shift], 2); } else if (GetName(buffer, (INT32)(i+7+shift), &NameAdr[0], &shift2)) { j = FindName(buffer, bufferLen, &NameAdr[0]); if (j > 0) { if (buffer[j+4] == 0x0C) { CopyMem(&tmp.Address, &buffer[j+5], 4); } else if (buffer[j+4] == 0x0B) { CopyMem(&tmp.Address, &buffer[j+5], 2); } } } if (tmp.Address) { OPER_REGION *newRegion = (__typeof__(newRegion))AllocateZeroPool(sizeof(OPER_REGION)); MsgLog("Found OperationRegion(%s, SystemMemory, %X, ...)\n", tmp.Name, tmp.Address); *newRegion = tmp; newRegion->next = gRegions; gRegions = newRegion; } else { // ignore OperationRegion where the address cannot be determined //DBG("Unable to determine address for OperationRegion(%s, SystemMemory, ...) skipping\n", tmp.Name); } } } } } // RehabMan: Fix Mutex with non-zero SyncLevel (change to zero) // For example: Mutex(ECMX, 3) -> Mutex(ECMX, 0) // representation example: // Mutex(M2, 1) -> 5B 01 4D 32 5F 5F 01 // Although Mutex with non-zero SyncLevel is perfectly legal macOS/OS X doesn't like // One of the common fixes for ACPI battery status on laptops #define IsNameChar(ch) (((ch)>='A' && (ch)<='Z') || ((ch)>='0' && (ch)<='9') || (ch)=='_') VOID FixMutex(UINT8 *dsdt, UINT32 len) { UINT8* p = dsdt + sizeof(EFI_ACPI_DESCRIPTION_HEADER); UINT8* end = dsdt + len - 7; // pattern is 7-bytes MsgLog("Start Mutex Fix\n"); for (; p <= end; p++) { if (p[0] == 0x5b && p[1] == 0x01 && IsNameChar(p[2]) && IsNameChar(p[3]) && IsNameChar(p[4]) && IsNameChar(p[5])) { if (p[6] != 0) { MsgLog("Fixing Mutex(%c%c%c%c, %d)\n", p[2], p[3], p[4], p[5], p[6]); } p[6] = 0; } } } /* _SB.PCI0.RP02.PSXS We have to take into account fields like Scope(\_SB) { Device (PCI0) { Device(RP02) { Device(PSXS) <- to patch { Method(_ON) { } Method(_OFF) { } } PSXS._ON() <- to patch } Scope(RP02) { PSXS._OFF() <- to patch } Device(RP03) { Device(PSXS) <- to not patch { } PSXS._ON() <- to not patch } */ BOOLEAN isACPI_Char(CHAR8 C) { return (((C >= 'A') && (C <= 'Z')) || ((C >= '0') && (C <= '9')) || (C == '_')); } BOOLEAN CmpFullName(UINT8* Table, UINTN Len, ACPI_NAME_LIST *Bridge) { // "RP02" NameLen=4 // "_SB_PCI0RP02" NameLen=12 UINTN NameLen = 0; INTN i = 0; CHAR8 *Name; while ((NameLen < Len) && isACPI_Char((CHAR8)Table[NameLen])) NameLen++; NameLen &= ~3; if (NameLen < 4) { return FALSE; } Name = (__typeof__(Name))AllocateCopyPool(NameLen + 1, Table); Name[NameLen] = '\0'; i = NameLen - 4; while (Bridge && (i >= 0)) { if (AsciiStrStr(Name + i, Bridge->Name) == NULL) { //compare Bridge->Name with RP02, Next->Name with PCI0 then _SB_ FreePool(Name); return FALSE; } i -= 4; Bridge = Bridge->Next; } FreePool(Name); return TRUE; } VOID RenameDevices(UINT8* table) { ACPI_NAME_LIST *List; ACPI_NAME_LIST *Bridge; CHAR8 *Replace; CHAR8 *Find; INTN i; INTN k=0; // Cland complain about possible use uninitialised. Not true, but I don't like warnings. UINTN index; INTN size; UINTN len = ((EFI_ACPI_DESCRIPTION_HEADER*)table)->Length; INTN adr, shift, Num = 0; BOOLEAN found; for (index = 0; index < gSettings.DeviceRenameCount; index++) { List = gSettings.DeviceRename[index].Next; Replace = gSettings.DeviceRename[index].Name; Find = List->Name; Bridge = List->Next; MsgLog("Name: %s, Bridge: %s, Replace: %s\n", Find, Bridge->Name, Replace); adr = 0; do { shift = FindBin(table + adr, (UINT32)(len - adr), (const UINT8*)Find, 4); //next occurence if (shift < 0) { break; //not found } adr += shift; // DBG("found Name @ 0x%X\n", adr); if (!Bridge || (FindBin(table + adr - 4, 5, (const UINT8*)(Bridge->Name), 4) == 0)) { // long name like "RP02.PXSX" CopyMem(table + adr, Replace, 4); adr += 5; //at least, it is impossible to see PXSXPXSX // DBG("replaced\n"); Num++; continue; } //find outer device or scope i = adr; while ((i > 0) && isACPI_Char(table[i])) i--; //skip attached name i -= 6; //skip size and device field // DBG("search for bridge since %d\n", adr); while (i > 0x20) { //find devices that previous to adr found = FALSE; //check device if ((table[i] == 0x5B) && (table[i + 1] == 0x82) && !CmpNum(table, (INT32)i, TRUE)) { //device candidate k = i + 2; found = TRUE; } //check scope if ((table[i] == 0x10) && !CmpNum(table, (INT32)i, TRUE)) { k = i + 1; found = TRUE; } if (found) { // i points to Device or Scope size = get_size(table, (UINT32)(UINTN)k); //k points to size // DBG("found bridge candidate 0x%X size %d\n", table[i], size); if (size) { if ((k + size) > (adr + 4)) { //Yes - it is outer // DBG("found Bridge device begin=%X end=%X\n", k, k+size); if (table[k] < 0x40) { k += 1; } else if ((table[k] & 0x40) != 0) { k += 2; } else if ((table[k] & 0x80) != 0) { k += 3; } //now k points to the outer name if (CmpFullName(table + k, len - k, Bridge)) { CopyMem(table + adr, Replace, 4); adr += 5; DBG("found Bridge device begin=%llX end=%llX\n", k, k+size); // DBG(" name copied\n"); Num++; break; //cancel search outer bridge, we found it. } } //else not an outer device } //else wrong size field - not a device } //else not a device or scope i--; } //while find outer bridge adr += 5; } while (1); //next occurence } //DeviceRenameCount MsgLog(" %lld replacements\n", Num); } VOID FixBiosDsdt(UINT8* temp, EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE* fadt, const XString8& OSVersion) { UINT32 DsdtLen; UINTN i; if (!temp) { return; } //Reenter requires ZERO values HDAFIX = TRUE; GFXHDAFIX = TRUE; USBIDFIX = TRUE; DsdtLen = ((EFI_ACPI_DESCRIPTION_HEADER*)temp)->Length; if ((DsdtLen < 20) || (DsdtLen > 1000000)) { //fool proof (some ASUS dsdt > 300kb?). Up to 1Mb MsgLog("DSDT length out of range\n"); return; } // DBG("========= Auto patch DSDT Starting ========\n"); DbgHeader("FixBiosDsdt"); // First check hardware address: GetPciADR(DevicePath, &NetworkADR1, &NetworkADR2); CheckHardware(); //arbitrary fixes if (gSettings.PatchDsdtNum > 0) { MsgLog("Patching DSDT:\n"); for (i = 0; i < gSettings.PatchDsdtNum; i++) { if (!gSettings.PatchDsdtFind[i] || !gSettings.LenToFind[i]) { continue; } MsgLog(" - [%s]:", gSettings.PatchDsdtLabel[i]); //yyyy if (gSettings.PatchDsdtMenuItem[i].BValue) { if (!gSettings.PatchDsdtTgt[i]) { DsdtLen = FixAny(temp, DsdtLen, (const UINT8*)gSettings.PatchDsdtFind[i], gSettings.LenToFind[i], (const UINT8*)gSettings.PatchDsdtReplace[i], gSettings.LenToReplace[i]); }else{ // DBG("Patching: renaming in bridge\n"); DsdtLen = FixRenameByBridge2(temp, DsdtLen, gSettings.PatchDsdtTgt[i], (const UINT8*)gSettings.PatchDsdtFind[i], gSettings.LenToFind[i], (const UINT8*)gSettings.PatchDsdtReplace[i], gSettings.LenToReplace[i]); } } else { MsgLog(" disabled\n"); } } } //renaming Devices RenameDevices(temp); // find ACPI CPU name and hardware address findCPU(temp, DsdtLen); // add Method (DTGP, 5, NotSerialized) if ((gSettings.FixDsdt & FIX_DTGP)) { if (!FindMethod(temp, DsdtLen, "DTGP")) { CopyMem((CHAR8 *)temp+DsdtLen, dtgp, sizeof(dtgp)); DsdtLen += sizeof(dtgp); ((EFI_ACPI_DESCRIPTION_HEADER*)temp)->Length = DsdtLen; } } // gSettings.PCIRootUID = 0; findPciRoot(temp, DsdtLen); // Fix RTC if ((gSettings.FixDsdt & FIX_RTC)) { // DBG("patch RTC in DSDT \n"); DsdtLen = FixRTC(temp, DsdtLen); } // Fix TMR if ((gSettings.FixDsdt & FIX_TMR)) { // DBG("patch TMR in DSDT \n"); DsdtLen = FixTMR(temp, DsdtLen); } // Fix PIC or IPIC if ((gSettings.FixDsdt & FIX_IPIC) != 0) { // DBG("patch IPIC in DSDT \n"); DsdtLen = FixPIC(temp, DsdtLen); } // Fix HPET if ((gSettings.FixDsdt & FIX_HPET) != 0) { // DBG("patch HPET in DSDT \n"); DsdtLen = FixHPET(temp, DsdtLen); } // Fix LPC if don't had HPET don't need to inject LPC?? if (LPCBFIX && (gCPUStructure.Family == 0x06) && (gSettings.FixDsdt & FIX_LPC)) { // DBG("patch LPC in DSDT \n"); DsdtLen = FIXLPCB(temp, DsdtLen); } // Fix Display if ((gSettings.FixDsdt & FIX_DISPLAY) || (gSettings.FixDsdt & FIX_INTELGFX)) { INT32 j; for (j=0; j<4; ++j) { if (DisplayADR1[j]) { if (((DisplayVendor[j] != 0x8086) && (gSettings.FixDsdt & FIX_DISPLAY)) || ((DisplayVendor[j] == 0x8086) && (gSettings.FixDsdt & FIX_INTELGFX))) { DsdtLen = FIXDisplay(temp, DsdtLen, j); MsgLog("patch Display #%d of Vendor=0x%4X\n", j, DisplayVendor[j]); } } } } // Fix Network if ((gSettings.FixDsdt & FIX_LAN)) { // DBG("patch LAN in DSDT \n"); UINT32 j; for (j = 0; j <= net_count; ++j) { if (NetworkADR1[j]) { MsgLog("patch LAN0 in DSDT \n"); DsdtLen = FIXNetwork(temp, DsdtLen, j); } } } // Fix Airport if (ArptADR1 && (gSettings.FixDsdt & FIX_WIFI)) { // DBG("patch Airport in DSDT \n"); DsdtLen = FIXAirport(temp, DsdtLen); } // Fix SBUS if (SBUSADR1 && (gSettings.FixDsdt & FIX_SBUS)) { // DBG("patch SBUS in DSDT \n"); DsdtLen = FIXSBUS(temp, DsdtLen); } // Fix IDE inject if (IDEFIX && (IDEVENDOR == 0x8086 || IDEVENDOR == 0x11ab) && (gSettings.FixDsdt & FIX_IDE)) { // DBG("patch IDE in DSDT \n"); DsdtLen = FIXIDE(temp, DsdtLen); } // Fix SATA AHCI orange icon if (SATAAHCIADR1 && (SATAAHCIVENDOR == 0x8086) && (gSettings.FixDsdt & FIX_SATA)) { DBG("patch AHCI in DSDT \n"); DsdtLen = FIXSATAAHCI(temp, DsdtLen); } // Fix SATA inject if (SATAFIX && (SATAVENDOR == 0x8086) && (gSettings.FixDsdt & FIX_SATA)) { DBG("patch SATA in DSDT \n"); DsdtLen = FIXSATA(temp, DsdtLen); } // Fix Firewire if (FirewireADR1 && (gSettings.FixDsdt & FIX_FIREWIRE)) { DBG("patch FRWR in DSDT \n"); DsdtLen = FIXFirewire(temp, DsdtLen); } // HDA HDEF if (HDAFIX && (gSettings.FixDsdt & FIX_HDA)) { DBG("patch HDEF in DSDT \n"); DsdtLen = AddHDEF(temp, DsdtLen, OSVersion); } //Always add MCHC for PM if ((gCPUStructure.Family == 0x06) && (gSettings.FixDsdt & FIX_MCHC)) { // DBG("patch MCHC in DSDT \n"); DsdtLen = AddMCHC(temp, DsdtLen); } //add IMEI if ((gSettings.FixDsdt & FIX_IMEI)) { DsdtLen = AddIMEI(temp, DsdtLen); } //Add HDMI device if ((gSettings.FixDsdt & FIX_HDMI)) { DsdtLen = AddHDMI(temp, DsdtLen); } // Always Fix USB if ((gSettings.FixDsdt & FIX_USB)) { DsdtLen = FIXUSB(temp, DsdtLen); } if ((gSettings.FixDsdt & FIX_WAK)){ // Always Fix _WAK Return value DsdtLen = FIXWAK(temp, DsdtLen, fadt); } // DBG("patch warnings \n"); // Always Fix alias cpu FIX cpus=1 // DsdtLen = FIXCPU1(temp, DsdtLen); // DsdtLen = FIXPWRB(temp, DsdtLen); // USB Device remove error Fix // DsdtLen = FIXGPE(temp, DsdtLen); if ((gSettings.FixDsdt & FIX_UNUSED)) { //I want these fixes even if no Display fix. We have GraphicsInjector DsdtLen = DeleteDevice("CRT_"_XS8, temp, DsdtLen); DsdtLen = DeleteDevice("DVI_"_XS8, temp, DsdtLen); //good company DsdtLen = DeleteDevice("SPKR"_XS8, temp, DsdtLen); DsdtLen = DeleteDevice("ECP_"_XS8, temp, DsdtLen); DsdtLen = DeleteDevice("LPT_"_XS8, temp, DsdtLen); DsdtLen = DeleteDevice("FDC0"_XS8, temp, DsdtLen); DsdtLen = DeleteDevice("ECP1"_XS8, temp, DsdtLen); DsdtLen = DeleteDevice("LPT1"_XS8, temp, DsdtLen); } if ((gSettings.FixDsdt & FIX_ACST)) { ReplaceName(temp, DsdtLen, "ACST", "OCST"); ReplaceName(temp, DsdtLen, "ACSS", "OCSS"); ReplaceName(temp, DsdtLen, "APSS", "OPSS"); ReplaceName(temp, DsdtLen, "APSN", "OPSN"); ReplaceName(temp, DsdtLen, "APLF", "OPLF"); } if ((gSettings.FixDsdt & FIX_PNLF)) { DsdtLen = AddPNLF(temp, DsdtLen); } if ((gSettings.FixDsdt & FIX_S3D)) { FixS3D(temp, DsdtLen); } //Fix OperationRegions if ((gSettings.FixDsdt & FIX_REGIONS)) { FixRegions(temp, DsdtLen); } //RehabMan: Fix Mutex objects if ((gSettings.FixDsdt & FIX_MUTEX)) { FixMutex(temp, DsdtLen); } // pwrb add _CID sleep button fix if ((gSettings.FixDsdt & FIX_ADP1)) { DsdtLen = FixADP1(temp, DsdtLen); } // other compiler warning fix _T_X, MUTE .... USB _PRW value form 0x04 => 0x01 // DsdtLen = FIXOTHER(temp, DsdtLen); if ((gSettings.FixDsdt & FIX_WARNING) || (gSettings.FixDsdt & FIX_DARWIN)) { if (!FindMethod(temp, DsdtLen, "GET9") && !FindMethod(temp, DsdtLen, "STR9") && !FindMethod(temp, DsdtLen, "OOSI")) { DsdtLen = FIXDarwin(temp, DsdtLen); } } // Fix SHUTDOWN For ASUS if ((gSettings.FixDsdt & FIX_SHUTDOWN)) { DsdtLen = FIXSHUTDOWN_ASUS(temp, DsdtLen); //safe to do twice } // Finish DSDT patch and resize DSDT Length /* temp[4] = (DsdtLen & 0x000000FF); temp[5] = (UINT8)((DsdtLen & 0x0000FF00) >> 8); temp[6] = (UINT8)((DsdtLen & 0x00FF0000) >> 16); temp[7] = (UINT8)((DsdtLen & 0xFF000000) >> 24); CopyMem((UINT8*)((EFI_ACPI_DESCRIPTION_HEADER*)temp)->OemId, (UINT8*)BiosVendor, 6); ((EFI_ACPI_DESCRIPTION_HEADER*)temp)->Checksum = 0; ((EFI_ACPI_DESCRIPTION_HEADER*)temp)->Checksum = (UINT8)(256-Checksum8(temp, DsdtLen)); */ EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)temp; Table->Length = DsdtLen; FixChecksum(Table); //DBG("========= Auto patch DSDT Finished ========\n"); //PauseForKey(L"waiting for key press...\n"); }