Chameleon

Chameleon Svn Source Tree

Root/trunk/i386/libsaio/acpi_patcher.c

1/*␊
2 * Copyright 2008 mackerintel␊
3 * 2010 mojodojo, 2012 slice␊
4 */␊
5␊
6#include "libsaio.h"␊
7#include "boot.h"␊
8#include "bootstruct.h"␊
9#include "acpi.h"␊
10#include "efi_tables.h"␊
11#include "fake_efi.h"␊
12#include "acpi_patcher.h"␊
13#include "platform.h"␊
14#include "cpu.h"␊
15#include "aml_generator.h"␊
16#include "state_generator.h"␊
17␊
18#ifndef DEBUG_ACPI␊
19␉#define DEBUG_ACPI 0␊
20#endif␊
21␊
22#if DEBUG_ACPI==2␊
23␉#define DBG(x...) {printf(x); sleep(1);}␊
24#elif DEBUG_ACPI==1␊
25␉#define DBG(x...) printf(x)␊
26#else␊
27␉#define DBG(x...) msglog(x)␊
28#endif␊
29␊
30// Slice: New signature compare function␊
31boolean_t tableSign(char *table, const char *sgn)␊
32{␊
33␉int i;␊
34␉for (i = 0; i < 4; i++)␊
35␉{␊
36␉␉if ((table[i] & ~0x20) != (sgn[i] & ~0x20))␊
37␉␉{␊
38␉␉␉return false;␊
39␉␉}␊
40␉}␊
41␉return true;␊
42}␊
43␊
44/* Gets the ACPI 1.0 RSDP address */␊
45static struct acpi_2_rsdp *getAddressOfAcpiTable()␊
46{␊
47␉/* TODO: Before searching the BIOS space we are supposed to search the first 1K of the EBDA */␊
48␊
49␉void *acpi_addr = (void*)ACPI_RANGE_START;␊
50␊
51␉for(; acpi_addr <= (void*)ACPI_RANGE_END; acpi_addr += 16)␊
52␉{␊
53␉␉if(*(uint64_t *)acpi_addr == ACPI_SIGNATURE_UINT64_LE)␊
54␉␉{␊
55␉␉␉uint8_t csum = checksum8(acpi_addr, 20);␊
56␉␉␉if (csum == 0)␊
57␉␉␉{␊
58␉␉␉// Only return the table if it is a true version 1.0 table (Revision 0)␊
59␉␉␉␉if(((struct acpi_2_rsdp*)acpi_addr)->Revision == 0)␊
60␉␉␉␉return acpi_addr;␊
61␉␉␉}␊
62␉␉}␊
63␉}␊
64␉return NULL;␊
65}␊
66␊
67/* Gets the ACPI 2.0 RSDP address */␊
68static struct acpi_2_rsdp *getAddressOfAcpi20Table()␊
69{␊
70␉/* TODO: Before searching the BIOS space we are supposed to search the first 1K of the EBDA */␊
71␊
72␉void *acpi_addr = (void *)ACPI_RANGE_START;␊
73␊
74␉for(; acpi_addr <= (void *)ACPI_RANGE_END; acpi_addr += 16)␊
75␉{␊
76␉␉if(*(uint64_t *)acpi_addr == ACPI_SIGNATURE_UINT64_LE)␊
77␉␉{␊
78␉␉␉uint8_t csum = checksum8(acpi_addr, 20);␊
79␊
80␉␉␉/* Only assume this is a 2.0 or better table if the revision is greater than 0␊
81␉␉␉ * NOTE: ACPI 3.0 spec only seems to say that 1.0 tables have revision 1␊
82␉␉␉ * and that the current revision is 2.. I am going to assume that rev > 0 is 2.0.␊
83␉␉␉ */␊
84␊
85␉␉␉if(csum == 0 && (((struct acpi_2_rsdp*)acpi_addr)->Revision > 0))␊
86␉␉␉{␊
87␉␉␉␉uint8_t csum2 = checksum8(acpi_addr, sizeof(struct acpi_2_rsdp));␊
88␉␉␉␉if(csum2 == 0)␊
89␉␉␉␉{␊
90␉␉␉␉␉return acpi_addr;␊
91␉␉␉␉}␊
92␉␉␉}␊
93␉␉}␊
94␉}␊
95␉return NULL;␊
96}␊
97␊
98/* The folowing ACPI Table search algo. should be reused anywhere needed:*/␊
99/* WARNING: outDirspec string will be overwritten by subsequent calls! */␊
100int search_and_get_acpi_fd(const char *filename, const char **outDirspec)␊
101{␊
102␉int fd = 0;␊
103␉static char dirSpec[512];␊
104␊
105␉// Try finding 'filename' in the usual places␊
106␉// Start searching any potential location for ACPI Table␊
107␉strncpy(dirSpec, filename, sizeof(dirSpec) );␊
108␉fd = open(dirSpec, 0);␊
109␉if (fd < 0)␊
110␉{␊
111␉␉snprintf(dirSpec, sizeof(dirSpec), "/Extra/%s", filename); ␊
112␉␉fd = open(dirSpec, 0);␊
113␉␉if (fd < 0)␊
114␉␉{␊
115␉␉␉snprintf(dirSpec, sizeof(dirSpec), "bt(0,0)/Extra/%s", filename);␊
116␉␉␉fd = open(dirSpec, 0);␊
117␉␉␉if (fd < 0)␊
118␉␉␉{␊
119␉␉␉␉// NOT FOUND:␊
120␉␉␉␉DBG("\tACPI Table not found: %s\n", filename);␊
121␉␉␉␉*dirSpec = '\0';␊
122␉␉␉}␊
123␉␉}␊
124␉}␊
125␊
126␉if (outDirspec) *outDirspec = dirSpec; ␊
127␉return fd;␊
128}␊
129␊
130void *loadACPITable (const char *filename)␊
131{␊
132␉const char *dirspec = NULL;␊
133␊
134␉int fd = search_and_get_acpi_fd(filename, &dirspec);␊
135␊
136␉if (fd >= 0)␊
137␉{␊
138␉␉void *tableAddr = (void *)AllocateKernelMemory(file_size(fd));␊
139␉␉if (tableAddr)␊
140␉␉{␊
141␉␉␉if (read(fd, tableAddr, file_size(fd)) != file_size(fd))␊
142␉␉␉{␊
143␉␉␉␉DBG("\tCouldn't read table %s\n", dirspec);␊
144␉␉␉␉free(tableAddr);␊
145␉␉␉␉close(fd);␊
146␉␉␉␉return NULL;␊
147␉␉␉}␊
148␊
149␉␉␉DBG("\tTable %s read and stored at: %x\n", dirspec, tableAddr);␊
150␉␉␉close(fd);␊
151␉␉␉return tableAddr;␊
152␉␉}␊
153␉␉close(fd);␊
154␉␉DBG("\tCouldn't allocate memory for table: %s.\n", dirspec);␊
155␉}␊
156␉//printf("Couldn't find table %s\n", filename);␊
157␉return NULL;␊
158}␊
159␊
160struct acpi_2_fadt *patch_fadt(struct acpi_2_fadt *fadt, struct acpi_2_dsdt *new_dsdt)␊
161{␊
162␉extern void setupSystemType();␊
163␊
164␉struct acpi_2_fadt *fadt_mod = NULL;␊
165␉bool fadt_rev2_needed = false;␊
166␉bool fix_restart;␊
167␉bool fix_restart_ps2;␊
168␉const char * value;␊
169␊
170␉// Restart Fix␊
171␉if (Platform.CPU.Vendor == 0x756E6547)␊
172␉{␉/* Intel */␊
173␉␉fix_restart = true;␊
174␉␉fix_restart_ps2 = false;␊
175␉␉if ( getBoolForKey(kPS2RestartFix, &fix_restart_ps2, &bootInfo->chameleonConfig) && fix_restart_ps2)␊
176␉␉{␊
177␉␉␉fix_restart = true;␊
178␉␉}␊
179␉␉else␊
180␉␉{␊
181␉␉␉getBoolForKey(kRestartFix, &fix_restart, &bootInfo->chameleonConfig);␊
182␉␉}␊
183␉}␊
184␉else␊
185␉{␊
186␉␉DBG("\tNot an Intel platform, FACP Restart Fix will not be applied!\n");␊
187␉␉fix_restart = false;␊
188␉}␊
189␊
190␉if (fix_restart)␊
191␉{␊
192␉␉fadt_rev2_needed = true;␊
193␉}␊
194␊
195␉// Allocate new fadt table␊
196␉if ((fadt->Length < 0x84) && fadt_rev2_needed)␊
197␉{␊
198␉␉fadt_mod = (struct acpi_2_fadt *)AllocateKernelMemory(0x84);␊
199␉␉memcpy(fadt_mod, fadt, fadt->Length);␊
200␉␉fadt_mod->Length = 0x84;␊
201␉␉fadt_mod->Revision = 0x02; // FACP rev 2 (ACPI 1.0B MS extensions)␊
202␉}␊
203␉else␊
204␉{␊
205␉␉fadt_mod = (struct acpi_2_fadt *)AllocateKernelMemory(fadt->Length);␊
206␉␉memcpy(fadt_mod, fadt, fadt->Length);␊
207␉}␊
208␉// Determine system type / PM_Model␊
209␉if ( (value=getStringForKey(kSystemType, &bootInfo->chameleonConfig))!=NULL)␊
210␉{␊
211␉␉if (Platform.Type > 6)␊
212␉␉{␊
213␉␉␉if(fadt_mod->PM_Profile<=6)␊
214␉␉␉{␊
215␉␉␉␉Platform.Type = fadt_mod->PM_Profile; // get the fadt if correct␊
216␉␉␉}␊
217␉␉␉else␊
218␉␉␉{␊
219␉␉␉␉Platform.Type = 1;␉␉/* Set a fixed value (Desktop) */␊
220␉␉␉}␊
221␉␉␉DBG("\tError: system-type must be 0..6. Defaulting to %d !\n", Platform.Type);␊
222␉␉}␊
223␉␉else␊
224␉␉{␊
225␉␉␉Platform.Type = (unsigned char) strtoul(value, NULL, 10);␊
226␉␉}␊
227␉}␊
228␉// Set PM_Profile from System-type if only user wanted this value to be forced␊
229␉if (fadt_mod->PM_Profile != Platform.Type)␊
230␉{␊
231␉␉if (value)␊
232␉␉{␊
233␉␉␉// user has overriden the SystemType so take care of it in FACP␊
234␉␉␉DBG("\tFADT: changing PM_Profile from 0x%02x to 0x%02x\n", fadt_mod->PM_Profile, Platform.Type);␊
235␉␉␉fadt_mod->PM_Profile = Platform.Type;␊
236␉␉}␊
237␉␉else␊
238␉␉{␊
239␉␉␉// PM_Profile has a different value and no override has been set, so reflect the user value to ioregs␊
240␉␉␉Platform.Type = fadt_mod->PM_Profile <= 6 ? fadt_mod->PM_Profile : 1;␊
241␉␉}␊
242␉}␊
243␉// We now have to write the systemm-type in ioregs: we cannot do it before in setupDeviceTree()␊
244␉// because we need to take care of FACP original content, if it is correct.␊
245␉setupSystemType();␊
246␊
247␉// Patch FACP to fix restart␊
248␉if (fix_restart)␊
249␉{␊
250␉␉if (fix_restart_ps2)␊
251␉␉{␊
252␉␉␉fadt_mod->Flags|= 0x400;␊
253␉␉␉fadt_mod->Reset_SpaceID␉␉= 0x01; // System I/O␊
254␉␉␉fadt_mod->Reset_BitWidth␉= 0x08; // 1 byte␊
255␉␉␉fadt_mod->Reset_BitOffset␉= 0x00; // Offset 0␊
256␉␉␉fadt_mod->Reset_AccessWidth␉= 0x01; // Byte access␊
257␉␉␉fadt_mod->Reset_Address␉␉= 0x64; // Address of the register␊
258␉␉␉fadt_mod->Reset_Value␉␉= 0xfe; // Value to write to reset the system␊
259␉␉␉DBG("\tFACP PS2 Restart Fix applied!\n");␊
260␉␉}␊
261␉␉else␊
262␉␉{␊
263␉␉␉fadt_mod->Flags|= 0x400;␊
264␉␉␉fadt_mod->Reset_SpaceID␉␉= 0x01; // System I/O␊
265␉␉␉fadt_mod->Reset_BitWidth␉= 0x08; // 1 byte␊
266␉␉␉fadt_mod->Reset_BitOffset␉= 0x00; // Offset 0␊
267␉␉␉fadt_mod->Reset_AccessWidth␉= 0x01; // Byte access␊
268␉␉␉fadt_mod->Reset_Address␉␉= 0x0cf9; // Address of the register␊
269␉␉␉fadt_mod->Reset_Value␉␉= 0x06; // Value to write to reset the system␊
270␉␉␉DBG("\tFACP Restart Fix applied!\n");␊
271␉␉}␊
272␊
273␉}␊
274␊
275␉// Bungo: Save Hardware Signature (machine-signature)␊
276␉if ((fadt_mod->FACS > 0) && (fadt_mod->FACS < 0xFFFFFFFF) && (((struct acpi_2_facs *)fadt_mod->FACS)->Length >= 64))␊
277␉{␊
278␉␉Platform.HWSignature = ((struct acpi_2_facs *)fadt_mod->FACS)->HWSignature;␊
279␉␉DBG("\tHardware Signature=0x%08X: using.\n", Platform.HWSignature);␊
280␉}␊
281␉else␊
282␉{␊
283␉␉Platform.HWSignature = 0;␊
284␉␉DBG("\tFixing Hardware Signature=0x%08X.\n", Platform.HWSignature);␊
285␉}␊
286␊
287␉// Patch DSDT address if we have loaded DSDT.aml␊
288␉if (new_dsdt)␊
289␉{␊
290␉␉DBG("\tDSDT: Old @%x,%x, ",fadt_mod->DSDT,fadt_mod->X_DSDT);␊
291␊
292␉␉fadt_mod->DSDT = (uint32_t)new_dsdt;␊
293␉␉if ((uint32_t)(&(fadt_mod->X_DSDT)) - (uint32_t)fadt_mod + 8<=fadt_mod->Length)␊
294␉␉{␊
295␉␉␉fadt_mod->X_DSDT = (uint32_t)new_dsdt;␊
296␉␉}␊
297␊
298␉␉DBG("\tNew @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT);␊
299␊
300␉␉DBG("\tFADT: Using custom DSDT!\n");␊
301␉}␊
302␊
303␉// Correct the checksum␊
304␉fadt_mod->Checksum=0;␊
305␉fadt_mod->Checksum=256-checksum8(fadt_mod,fadt_mod->Length);␊
306␊
307␉return fadt_mod;␊
308}␊
309␊
310/* Setup ACPI without replacing DSDT. */␊
311int setupAcpiNoMod()␊
312{␊
313//␉addConfigurationTable(&gEfiAcpiTableGuid, getAddressOfAcpiTable(), "ACPI");␊
314//␉addConfigurationTable(&gEfiAcpi20TableGuid, getAddressOfAcpi20Table(), "ACPI_20");␊
315␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
316␉acpi10_p = (uint64_t)(uint32_t)getAddressOfAcpiTable();␊
317␉acpi20_p = (uint64_t)(uint32_t)getAddressOfAcpi20Table();␊
318␉addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI");␊
319␉if(acpi20_p)␊
320␉{␊
321␉␉addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20");␊
322␉}␊
323␉else␊
324␉{␊
325␉␉DBG("\tNo ACPI 2.\n");␊
326␉}␊
327␉return 1;␊
328}␊
329␊
330/* Setup ACPI. Replace DSDT if DSDT.aml is found */␊
331int setupAcpi(void)␊
332{␊
333␉verbose("[ ACPI PATCHER ]\n");␊
334␉int version;␊
335␉void *new_dsdt = NULL;␊
336␊
337␊
338␉const char *filename;␊
339␉char dirSpec[128];␊
340␉int len = 0;␊
341␊
342␉// always reset cpu count to 0 when injecting new acpi␊
343␉acpi_cpu_count = 0;␊
344␊
345␉/* Try using the file specified with the DSDT option */␊
346␉if (getValueForKey(kDSDT, &filename, &len, &bootInfo->chameleonConfig))␊
347␉{␊
348␉␉strncpy(dirSpec, filename, sizeof(dirSpec) );␊
349␉}␊
350␉else␊
351␉{␊
352␉␉strcpy(dirSpec, "DSDT.aml");␊
353␉␉//verbose("dirSpec, DSDT.aml");␊
354␉}␊
355␊
356␉// Load replacement DSDT␊
357␉new_dsdt = loadACPITable(dirSpec);␊
358␊
359␉// Mozodojo: going to patch FACP and load SSDT's even if DSDT.aml is not present␊
360␉/*if (!new_dsdt)␊
361␉ {␊
362␉ return setupAcpiNoMod();␊
363␉ }*/␊
364␊
365␉// Mozodojo: Load additional SSDTs␊
366␉struct acpi_2_ssdt *new_ssdt[32]; // 30 + 2 additional tables for pss & cst␊
367␉int ssdt_count=0;␊
368␊
369␉// SSDT Options␊
370␉bool drop_ssdt = false, generate_pstates = false, generate_cstates = false;␊
371␊
372␉getBoolForKey(kDropSSDT, &drop_ssdt, &bootInfo->chameleonConfig);␊
373␉getBoolForKey(kGeneratePStates, &generate_pstates, &bootInfo->chameleonConfig);␊
374␉getBoolForKey(kGenerateCStates, &generate_cstates, &bootInfo->chameleonConfig);␊
375␉//getBoolForKey(kGenerateTStates, &generate_tstates, &bootInfo->chameleonConfig);␊
376␊
377␉DBG("\tGenerating P-States config: %s\n", generate_pstates ? "Yes" : "No");␊
378␉DBG("\tGenerating C-States config: %s\n", generate_cstates ? "Yes" : "No");␊
379␉//DBG("Generating T-States config: %s\n", generate_tstates ? "Yes" : "No");␊
380␊
381␉{␊
382␉␉int i;␊
383␊
384␉␉for (i = 0; i < 30; i++)␊
385␉␉{␊
386␉␉␉char filename[512];␊
387␊
388␉␉␉if (i > 0)␊
389␉␉␉{␊
390␉␉␉␉sprintf(filename, "SSDT-%d.aml", i);␊
391␉␉␉}␊
392␉␉␉else␊
393␉␉␉{␊
394␉␉␉␉strcpy(filename, "SSDT.aml");␊
395␉␉␉}␊
396␊
397␉␉␉if ( (new_ssdt[ssdt_count] = loadACPITable(filename)) )␊
398␉␉␉{␊
399␉␉␉␉ssdt_count++;␊
400␉␉␉}␊
401␉␉␉else␊
402␉␉␉{␊
403␉␉␉␉break;␊
404␉␉␉}␊
405␉␉}␊
406␉}␊
407␊
408␉// Do the same procedure for both versions of ACPI␊
409␉for (version = 0; version < 2; version++)␊
410␉{␊
411␉␉struct acpi_2_rsdp *rsdp, *rsdp_mod;␊
412␉␉struct acpi_2_rsdt *rsdt, *rsdt_mod;␊
413␉␉int rsdplength;␊
414␊
415␉␉// Find original rsdp␊
416␉␉rsdp = (struct acpi_2_rsdp *)(version ? getAddressOfAcpi20Table() : getAddressOfAcpiTable());␊
417␉␉if (!rsdp)␊
418␉␉{␊
419␉␉␉DBG("\tNo ACPI version %d found. Ignoring\n", version+1);␊
420␉␉␉if (version)␊
421␉␉␉{␊
422␉␉␉␉addConfigurationTable(&gEfiAcpi20TableGuid, NULL, "ACPI_20");␊
423␉␉␉}␊
424␉␉␉else␊
425␉␉␉{␊
426␉␉␉␉addConfigurationTable(&gEfiAcpiTableGuid, NULL, "ACPI");␊
427␉␉␉}␊
428␉␉␉continue;␊
429␉␉}␊
430␉␉rsdplength = version ? rsdp->Length : 20;␊
431␊
432␉␉DBG("\tRSDP version %d found @%x. Length=%d\n",version+1,rsdp,rsdplength);␊
433␊
434␉␉/* FIXME: no check that memory allocation succeeded ␊
435␉␉ * Copy and patch RSDP,RSDT, XSDT and FADT␊
436␉␉ * For more info see ACPI Specification pages 110 and following␊
437␉␉ */␊
438␊
439␉␉rsdp_mod = (struct acpi_2_rsdp *) AllocateKernelMemory(rsdplength);␊
440␉␉memcpy(rsdp_mod, rsdp, rsdplength);␊
441␊
442␉␉rsdt = (struct acpi_2_rsdt *)rsdp->RsdtAddress;␊
443␊
444␉␉DBG("\tRSDT @%x, Length %d\n",rsdt, rsdt ? rsdt->Length : 0);␊
445␊
446␉␉if (rsdt && (uint32_t)rsdt !=0xffffffff && rsdt->Length < 0x10000)␊
447␉␉{␊
448␉␉␉uint32_t *rsdt_entries;␊
449␉␉␉int rsdt_entries_num;␊
450␉␉␉int dropoffset = 0, i;␊
451␊
452␉␉␉// mozo: using malloc cos I didn't found how to free already allocated kernel memory␊
453␉␉␉rsdt_mod = (struct acpi_2_rsdt *)malloc(rsdt->Length);␊
454␉␉␉memcpy(rsdt_mod, rsdt, rsdt->Length);␊
455␉␉␉rsdp_mod->RsdtAddress = (uint32_t)rsdt_mod;␊
456␉␉␉rsdt_entries_num = (rsdt_mod->Length - sizeof(struct acpi_2_rsdt)) / 4;␊
457␉␉␉rsdt_entries = (uint32_t *)(rsdt_mod + 1);␊
458␉␉␉for (i = 0; i < rsdt_entries_num; i++)␊
459␉␉␉{␊
460␉␉␉␉char *table=(char *)(rsdt_entries[i]);␊
461␉␉␉␉if (!table)␊
462␉␉␉␉{␊
463␉␉␉␉␉continue;␊
464␉␉␉␉}␊
465␊
466␉␉␉␉DBG("\tTABLE %c%c%c%c,",table[0],table[1],table[2],table[3]);␊
467␊
468␉␉␉␉rsdt_entries[i-dropoffset]=rsdt_entries[i];␊
469␊
470␉␉␉␉// Dropping DMAR (DMA Remapping table) table can fix stuck on "waitForSystemMapper" or "PCI configuration begin" if nothing wokrks except rolling old AppleACPIplatform.kext back. Needs testing with current OEM AppleACPIplatform.kext not with old rolled back one␊
471␉␉␉␉if (tableSign(table, "DMAR"))␊
472␉␉␉␉{␊
473␉␉␉␉␉DBG("\tOEM DMAR table was dropped\n");␊
474␉␉␉␉␉dropoffset++;␊
475␉␉␉␉␉continue;␊
476␉␉␉␉}␊
477␊
478␉␉␉␉if (drop_ssdt && tableSign(table, "SSDT"))␊
479␉␉␉␉{␊
480␉␉␉␉␉DBG("\tOEM SSDT tables was dropped\n");␊
481␉␉␉␉␉dropoffset++;␊
482␉␉␉␉␉continue;␊
483␉␉␉␉}␊
484␊
485␉␉␉␉if (tableSign(table, "DSDT"))␊
486␉␉␉␉{␊
487␉␉␉␉␉DBG("\tDSDT found\n");␊
488␉␉␉␉␉DBG("\tCustom DSDT table was found\n");␊
489␉␉␉␉␉if(new_dsdt)␊
490␉␉␉␉␉{␊
491␉␉␉␉␉␉rsdt_entries[i-dropoffset] = (uint32_t)new_dsdt;␊
492␉␉␉␉␉}␊
493␊
494␉␉␉␉␉continue;␊
495␉␉␉␉}␊
496␊
497␉␉␉␉if (tableSign(table, "FACP"))␊
498␉␉␉␉{␊
499␉␉␉␉␉struct acpi_2_fadt *fadt, *fadt_mod;␊
500␉␉␉␉␉fadt=(struct acpi_2_fadt *)rsdt_entries[i];␊
501␊
502␉␉␉␉␉DBG("\tFADT found @%x, Length %d\n",fadt, fadt->Length);␊
503␊
504␉␉␉␉␉if (!fadt || (uint32_t)fadt == 0xffffffff || fadt->Length>0x10000)␊
505␉␉␉␉␉{␊
506␉␉␉␉␉␉DBG("\tFADT incorrect. Not modified\n");␊
507␉␉␉␉␉␉continue;␊
508␉␉␉␉␉}␊
509␉␉␉␉␉␊
510␉␉␉␉␉fadt_mod = patch_fadt(fadt, new_dsdt);␊
511␉␉␉␉␉rsdt_entries[i-dropoffset] = (uint32_t)fadt_mod;␊
512␉␉␉␉␉␊
513␉␉␉␉␉// Generate _CST SSDT␊
514␉␉␉␉␉if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))␊
515␉␉␉␉␉{␊
516␉␉␉␉␉␉DBG("\tC-States generated.\n");␊
517␉␉␉␉␉␉generate_cstates = false; // Generate SSDT only once!␊
518␉␉␉␉␉␉ssdt_count++;␊
519␉␉␉␉␉}␊
520␊
521␉␉␉␉␉// Generating _PSS SSDT␊
522␉␉␉␉␉if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))␊
523␉␉␉␉␉{␊
524␉␉␉␉␉␉DBG("\tP-States generated.\n");␊
525␉␉␉␉␉␉generate_pstates = false; // Generate SSDT only once!␊
526␉␉␉␉␉␉ssdt_count++;␊
527␉␉␉␉␉}␊
528␉␉␉␉␉continue;␊
529␉␉␉␉}␊
530␉␉␉}␊
531␉␉␉DBG("\n");␊
532␊
533␉␉␉// Allocate rsdt in Kernel memory area␊
534␉␉␉rsdt_mod->Length += 4*ssdt_count - 4*dropoffset;␊
535␉␉␉struct acpi_2_rsdt *rsdt_copy = (struct acpi_2_rsdt *)AllocateKernelMemory(rsdt_mod->Length);␊
536␉␉␉memcpy(rsdt_copy, rsdt_mod, rsdt_mod->Length);␊
537␉␉␉free(rsdt_mod);␊
538␉␉␉rsdt_mod = rsdt_copy;␊
539␉␉␉rsdp_mod->RsdtAddress = (uint32_t)rsdt_mod;␊
540␉␉␉rsdt_entries_num = (rsdt_mod->Length-sizeof(struct acpi_2_rsdt)) / 4;␊
541␉␉␉rsdt_entries = (uint32_t *)(rsdt_mod + 1);␊
542␊
543␉␉␉// Mozodojo: Insert additional SSDTs into RSDT␊
544␉␉␉if(ssdt_count > 0)␊
545␉␉␉{␊
546␉␉␉␉int j;␊
547␊
548␉␉␉␉for (j=0; j<ssdt_count; j++)␊
549␉␉␉␉{␊
550␉␉␉␉␉rsdt_entries[i-dropoffset+j] = (uint32_t)new_ssdt[j];␊
551␉␉␉␉}␊
552␊
553␉␉␉␉DBG("\tRSDT: Added %d SSDT table(s)\n", ssdt_count);␊
554␊
555␉␉␉}␊
556␊
557␉␉␉// Correct the checksum of RSDT␊
558␉␉␉DBG("\tRSDT: Original checksum %d, ", rsdt_mod->Checksum);␊
559␊
560␉␉␉rsdt_mod->Checksum=0;␊
561␉␉␉rsdt_mod->Checksum=256-checksum8(rsdt_mod,rsdt_mod->Length);␊
562␊
563␉␉␉DBG("\tNew checksum %d at %x\n", rsdt_mod->Checksum,rsdt_mod);␊
564␉␉}␊
565␉␉else␊
566␉␉{␊
567␉␉␉rsdp_mod->RsdtAddress=0;␊
568␉␉␉DBG("\tRSDT not found or RSDT incorrect\n");␊
569␉␉}␊
570␉␉DBG("\n");␊
571␊
572␉␉if (version)␊
573␉␉{␊
574␉␉␉struct acpi_2_xsdt *xsdt, *xsdt_mod;␊
575␊
576␉␉␉// FIXME: handle 64-bit address correctly␊
577␊
578␉␉␉xsdt=(struct acpi_2_xsdt*) ((uint32_t)rsdp->XsdtAddress);␊
579␉␉␉DBG("\tXSDT @%x;%x, Length=%d\n", (uint32_t)(rsdp->XsdtAddress>>32),(uint32_t)rsdp->XsdtAddress, xsdt->Length);␊
580␊
581␉␉␉if (xsdt && (uint64_t)rsdp->XsdtAddress<0xffffffff && xsdt->Length<0x10000)␊
582␉␉␉{␊
583␉␉␉␉uint64_t *xsdt_entries;␊
584␉␉␉␉int xsdt_entries_num, i;␊
585␉␉␉␉int dropoffset = 0;␊
586␊
587␉␉␉␉// mozo: using malloc cos I didn't found how to free already allocated kernel memory␊
588␉␉␉␉xsdt_mod = (struct acpi_2_xsdt *)malloc(xsdt->Length);␊
589␉␉␉␉memcpy(xsdt_mod, xsdt, xsdt->Length);␊
590␊
591␉␉␉␉rsdp_mod->XsdtAddress = (uint32_t)xsdt_mod;␊
592␉␉␉␉xsdt_entries_num = (xsdt_mod->Length - sizeof(struct acpi_2_xsdt)) / 8;␊
593␉␉␉␉xsdt_entries = (uint64_t *)(xsdt_mod + 1);␊
594␉␉␉␉for (i = 0;i < xsdt_entries_num; i++)␊
595␉␉␉␉{␊
596␉␉␉␉␉char *table = (char *)((uint32_t)(xsdt_entries[i]));␊
597␉␉␉␉␉if (!table)␊
598␉␉␉␉␉{␊
599␉␉␉␉␉␉continue;␊
600␉␉␉␉␉}␊
601␉␉␉␉␉xsdt_entries[i - dropoffset] = xsdt_entries[i];␊
602␊
603␉␉␉␉␉// Dropping DMAR (DMA Remapping table) table can fix stuck on "waitForSystemMapper" or "PCI configuration begin" if nothing wokrks except rolling old AppleACPIplatform.kext back. Needs testing with current OEM AppleACPIplatform.kext not with old rolled back one␊
604␉␉␉␉␉if (tableSign(table, "DMAR"))␊
605␉␉␉␉␉{␊
606␉␉␉␉␉␉DBG("\tOEM DMAR table was dropped\n");␊
607␉␉␉␉␉␉dropoffset++;␊
608␉␉␉␉␉␉continue;␊
609␉␉␉␉␉}␊
610␊
611␉␉␉␉␉if (drop_ssdt && tableSign(table, "SSDT"))␊
612␉␉␉␉␉{␊
613␉␉␉␉␉␉DBG("\tOEM SSDT tables was dropped\n");␊
614␉␉␉␉␉␉dropoffset++;␊
615␉␉␉␉␉␉continue;␊
616␉␉␉␉␉}␊
617␉␉␉␉␉if (tableSign(table, "DSDT"))␊
618␉␉␉␉␉{␊
619␉␉␉␉␉␉DBG("\tDSDT found\n");␊
620␊
621␉␉␉␉␉␉if (new_dsdt)␊
622␉␉␉␉␉␉{␊
623␉␉␉␉␉␉␉xsdt_entries[i-dropoffset] = (uint32_t)new_dsdt;␊
624␉␉␉␉␉␉␉DBG("\tcustom table added.\n");␊
625␉␉␉␉␉␉}␊
626␊
627␉␉␉␉␉␉DBG("\tTABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
628␊
629␉␉␉␉␉␉continue;␊
630␉␉␉␉␉}␊
631␉␉␉␉␉if (tableSign(table, "FACP"))␊
632␉␉␉␉␉{␊
633␉␉␉␉␉␉struct acpi_2_fadt *fadt, *fadt_mod;␊
634␉␉␉␉␉␉fadt=(struct acpi_2_fadt *)(uint32_t)xsdt_entries[i];␊
635␊
636␉␉␉␉␉␉DBG("\tFADT found @%x%x, Length %d\n",(uint32_t)(xsdt_entries[i]>>32),fadt, ␊
637␉␉␉␉␉␉␉fadt->Length);␊
638␊
639␉␉␉␉␉␉if (!fadt || (uint64_t)xsdt_entries[i] >= 0xffffffff || fadt->Length>0x10000)␊
640␉␉␉␉␉␉{␊
641␉␉␉␉␉␉␉DBG("\tFADT incorrect or after 4GB. Dropping XSDT\n");␊
642␉␉␉␉␉␉␉goto drop_xsdt;␊
643␉␉␉␉␉␉}␊
644␊
645␉␉␉␉␉␉fadt_mod = patch_fadt(fadt, new_dsdt);␊
646␉␉␉␉␉␉xsdt_entries[i - dropoffset] = (uint32_t)fadt_mod;␊
647␊
648␉␉␉␉␉␉// DBG("\tTABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
649␊
650␉␉␉␉␉␉// Generate _CST SSDT␊
651␉␉␉␉␉␉if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))␊
652␉␉␉␉␉␉{␊
653␉␉␉␉␉␉␉DBG("\tC-States generated.\n");␊
654␉␉␉␉␉␉␉generate_cstates = false; // Generate SSDT only once!␊
655␉␉␉␉␉␉␉ssdt_count++;␊
656␉␉␉␉␉␉}␊
657␊
658␉␉␉␉␉␉// Generating _PSS SSDT␊
659␉␉␉␉␉␉if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))␊
660␉␉␉␉␉␉{␊
661␉␉␉␉␉␉␉DBG("\tP-States generated.\n");␊
662␉␉␉␉␉␉␉generate_pstates = false; // Generate SSDT only once!␊
663␉␉␉␉␉␉␉ssdt_count++;␊
664␉␉␉␉␉␉}␊
665␊
666␉␉␉␉␉␉// Generating _TSS SSDT␊
667␉␉␉␉␉␉/*if (generate_tstates && (new_ssdt[ssdt_count] = generate_tss_ssdt((void*)fadt_mod->DSDT)))␊
668␉␉␉␉␉␉{␊
669␉␉␉␉␉␉␉generate_tstates = false; // Generate SSDT only once!␊
670␉␉␉␉␉␉␉ssdt_count++;␊
671␉␉␉␉␉␉}*/␊
672␉␉␉␉␉␉continue;␊
673␉␉␉␉␉}␊
674␉␉␉␉␉DBG("\tcopied (OEM)\n");␊
675␉␉␉␉␉// DBG("\tTABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
676␉␉␉␉}␊
677␊
678␉␉␉␉// Allocate xsdt in Kernel memory area␊
679␉␉␉␉xsdt_mod->Length += 8*ssdt_count - 8*dropoffset;␊
680␉␉␉␉struct acpi_2_xsdt *xsdt_copy = (struct acpi_2_xsdt *)AllocateKernelMemory(xsdt_mod->Length);␊
681␉␉␉␉memcpy(xsdt_copy, xsdt_mod, xsdt_mod->Length);␊
682␉␉␉␉free(xsdt_mod);␊
683␉␉␉␉xsdt_mod = xsdt_copy;␊
684␉␉␉␉rsdp_mod->XsdtAddress = (uint32_t)xsdt_mod;␊
685␉␉␉␉xsdt_entries_num = (xsdt_mod->Length - sizeof(struct acpi_2_xsdt)) / 8;␊
686␉␉␉␉xsdt_entries = (uint64_t *)(xsdt_mod + 1);␊
687␊
688␉␉␉␉// Mozodojo: Insert additional SSDTs into XSDT␊
689␉␉␉␉if(ssdt_count > 0)␊
690␉␉␉␉{␊
691␉␉␉␉␉int j;␊
692␊
693␉␉␉␉␉for (j=0; j<ssdt_count; j++)␊
694␉␉␉␉␉{␊
695␉␉␉␉␉␉xsdt_entries[i - dropoffset + j] = (uint32_t)new_ssdt[j];␊
696␉␉␉␉␉}␊
697␊
698␉␉␉␉␉verbose("\tAdded %d SSDT table(s) into XSDT\n", ssdt_count);␊
699␊
700␉␉␉␉}␊
701␊
702␉␉␉␉// Correct the checksum of XSDT␊
703␉␉␉␉xsdt_mod->Checksum=0;␊
704␉␉␉␉xsdt_mod->Checksum=256-checksum8(xsdt_mod,xsdt_mod->Length);␊
705␉␉␉}␊
706␉␉␉else␊
707␉␉␉{␊
708␉␉␉drop_xsdt:␊
709␊
710␉␉␉␉DBG("\tAbout to drop XSDT\n");␊
711␊
712␉␉␉␉/*FIXME: Now we just hope that if MacOS doesn't find XSDT it reverts to RSDT. ␊
713␉␉␉␉ * A Better strategy would be to generate␊
714␉␉␉␉ */␊
715␊
716␉␉␉␉rsdp_mod->XsdtAddress=0xffffffffffffffffLL;␊
717␉␉␉␉verbose("\tXSDT not found or XSDT incorrect\n");␊
718␉␉␉}␊
719␉␉}␊
720␉␉DBG("\n");␊
721␊
722␉␉// Correct the checksum of RSDP␊
723␊
724␉␉DBG("\tRSDP: Original checksum %d, ", rsdp_mod->Checksum);␊
725␊
726␉␉rsdp_mod->Checksum=0;␊
727␉␉rsdp_mod->Checksum=256-checksum8(rsdp_mod,20);␊
728␊
729␉␉DBG("\tNew checksum %d\n", rsdp_mod->Checksum);␊
730␊
731␉␉if (version)␊
732␉␉{␊
733␉␉␉DBG("\tRSDP: Original extended checksum %d, ", rsdp_mod->ExtendedChecksum);␊
734␊
735␉␉␉rsdp_mod->ExtendedChecksum=0;␊
736␉␉␉rsdp_mod->ExtendedChecksum=256-checksum8(rsdp_mod,rsdp_mod->Length);␊
737␊
738␉␉␉DBG("\tNew extended checksum %d\n", rsdp_mod->ExtendedChecksum);␊
739␊
740␉␉}␊
741␊
742␉␉if (version)␊
743␉␉{␊
744␉␉␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
745␉␉␉acpi20_p = (uint64_t)(uint32_t)rsdp_mod;␊
746␉␉␉addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20");␊
747␉␉}␊
748␉␉else␊
749␉␉{␊
750␉␉␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
751␉␉␉acpi10_p = (uint64_t)(uint32_t)rsdp_mod;␊
752␉␉␉addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI");␊
753␉␉}␊
754␉␉DBG("\tACPI version %d patching finished\n\n", version + 1);␊
755␉}␊
756#if DEBUG_ACPI␊
757␉printf("Press a key to continue... (DEBUG_ACPI)\n");␊
758␉getchar();␊
759#endif␊
760␉return 1;␊
761}␊
762

Archive Download this file

Revision: 2847