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("ACPI 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("Couldn't read table %s\n", dirspec);␊
144␉␉␉␉free(tableAddr);␊
145␉␉␉␉close(fd);␊
146␉␉␉␉return NULL;␊
147␉␉␉}␊
148␊
149␉␉␉DBG("Table %s read and stored at: %x\n", dirspec, tableAddr);␊
150␉␉␉close(fd);␊
151␉␉␉return tableAddr;␊
152␉␉}␊
153␉␉close(fd);␊
154␉␉DBG("Couldn'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("Error: 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("FADT: 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("DSDT: 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("New @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT);␊
299␊
300␉␉DBG("FADT: 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("No ACPI 2.\n");␊
326␉}␊
327␉return 1;␊
328}␊
329␊
330/* Setup ACPI. Replace DSDT if DSDT.aml is found */␊
331int setupAcpi(void)␊
332{␊
333␉int version;␊
334␉void *new_dsdt = NULL;␊
335␊
336␊
337␉const char *filename;␊
338␉char dirSpec[128];␊
339␉int len = 0;␊
340␊
341␉// always reset cpu count to 0 when injecting new acpi␊
342␉acpi_cpu_count = 0;␊
343␊
344␉/* Try using the file specified with the DSDT option */␊
345␉if (getValueForKey(kDSDT, &filename, &len, &bootInfo->chameleonConfig))␊
346␉{␊
347␉␉strncpy(dirSpec, filename, sizeof(dirSpec) );␊
348␉}␊
349␉else␊
350␉{␊
351␉␉strcpy(dirSpec, "DSDT.aml");␊
352␉␉//verbose("dirSpec, DSDT.aml");␊
353␉}␊
354␊
355␉// Load replacement DSDT␊
356␉new_dsdt = loadACPITable(dirSpec);␊
357␊
358␉// Mozodojo: going to patch FACP and load SSDT's even if DSDT.aml is not present␊
359␉/*if (!new_dsdt)␊
360␉ {␊
361␉ return setupAcpiNoMod();␊
362␉ }*/␊
363␊
364␉// Mozodojo: Load additional SSDTs␊
365␉struct acpi_2_ssdt *new_ssdt[32]; // 30 + 2 additional tables for pss & cst␊
366␉int ssdt_count=0;␊
367␊
368␉// SSDT Options␊
369␉bool drop_ssdt = false, generate_pstates = false, generate_cstates = false;␊
370␊
371␉getBoolForKey(kDropSSDT, &drop_ssdt, &bootInfo->chameleonConfig);␊
372␉getBoolForKey(kGeneratePStates, &generate_pstates, &bootInfo->chameleonConfig);␊
373␉getBoolForKey(kGenerateCStates, &generate_cstates, &bootInfo->chameleonConfig);␊
374␊
375␉DBG("Generating P-States config: %s\n", generate_pstates ? "YES" : "NO");␊
376␉DBG("Generating C-States config: %s\n", generate_cstates ? "YES" : "NO");␊
377␊
378␉{␊
379␉␉int i;␊
380␊
381␉␉for (i = 0; i < 30; i++)␊
382␉␉{␊
383␉␉␉char filename[512];␊
384␊
385␉␉␉if (i > 0)␊
386␉␉␉{␊
387␉␉␉␉sprintf(filename, "SSDT-%d.aml", i);␊
388␉␉␉}␊
389␉␉␉else␊
390␉␉␉{␊
391␉␉␉␉strcpy(filename, "SSDT.aml");␊
392␉␉␉}␊
393␊
394␉␉␉if ( (new_ssdt[ssdt_count] = loadACPITable(filename)) )␊
395␉␉␉{␊
396␉␉␉␉ssdt_count++;␊
397␉␉␉}␊
398␉␉␉else␊
399␉␉␉{␊
400␉␉␉␉break;␊
401␉␉␉}␊
402␉␉}␊
403␉}␊
404␊
405␉// Do the same procedure for both versions of ACPI␊
406␉for (version = 0; version < 2; version++)␊
407␉{␊
408␉␉struct acpi_2_rsdp *rsdp, *rsdp_mod;␊
409␉␉struct acpi_2_rsdt *rsdt, *rsdt_mod;␊
410␉␉int rsdplength;␊
411␊
412␉␉// Find original rsdp␊
413␉␉rsdp = (struct acpi_2_rsdp *)(version ? getAddressOfAcpi20Table() : getAddressOfAcpiTable());␊
414␉␉if (!rsdp)␊
415␉␉{␊
416␉␉␉DBG("No ACPI version %d found. Ignoring\n", version+1);␊
417␉␉␉if (version)␊
418␉␉␉{␊
419␉␉␉␉addConfigurationTable(&gEfiAcpi20TableGuid, NULL, "ACPI_20");␊
420␉␉␉}␊
421␉␉␉else␊
422␉␉␉{␊
423␉␉␉␉addConfigurationTable(&gEfiAcpiTableGuid, NULL, "ACPI");␊
424␉␉␉}␊
425␉␉␉continue;␊
426␉␉}␊
427␉␉rsdplength = version ? rsdp->Length : 20;␊
428␊
429␉␉DBG("RSDP version %d found @%x. Length=%d\n",version+1,rsdp,rsdplength);␊
430␊
431␉␉/* FIXME: no check that memory allocation succeeded ␊
432␉␉ * Copy and patch RSDP,RSDT, XSDT and FADT␊
433␉␉ * For more info see ACPI Specification pages 110 and following␊
434␉␉ */␊
435␊
436␉␉rsdp_mod = (struct acpi_2_rsdp *) AllocateKernelMemory(rsdplength);␊
437␉␉memcpy(rsdp_mod, rsdp, rsdplength);␊
438␊
439␉␉rsdt = (struct acpi_2_rsdt *)rsdp->RsdtAddress;␊
440␊
441␉␉DBG("RSDT @%x, Length %d\n",rsdt, rsdt ? rsdt->Length : 0);␊
442␊
443␉␉if (rsdt && (uint32_t)rsdt !=0xffffffff && rsdt->Length < 0x10000)␊
444␉␉{␊
445␉␉␉uint32_t *rsdt_entries;␊
446␉␉␉int rsdt_entries_num;␊
447␉␉␉int dropoffset = 0, i;␊
448␊
449␉␉␉// mozo: using malloc cos I didn't found how to free already allocated kernel memory␊
450␉␉␉rsdt_mod = (struct acpi_2_rsdt *)malloc(rsdt->Length);␊
451␉␉␉memcpy(rsdt_mod, rsdt, rsdt->Length);␊
452␉␉␉rsdp_mod->RsdtAddress = (uint32_t)rsdt_mod;␊
453␉␉␉rsdt_entries_num = (rsdt_mod->Length - sizeof(struct acpi_2_rsdt)) / 4;␊
454␉␉␉rsdt_entries = (uint32_t *)(rsdt_mod + 1);␊
455␉␉␉for (i = 0; i < rsdt_entries_num; i++)␊
456␉␉␉{␊
457␉␉␉␉char *table=(char *)(rsdt_entries[i]);␊
458␉␉␉␉if (!table)␊
459␉␉␉␉{␊
460␉␉␉␉␉continue;␊
461␉␉␉␉}␊
462␊
463␉␉␉␉DBG("TABLE %c%c%c%c,",table[0],table[1],table[2],table[3]);␊
464␊
465␉␉␉␉rsdt_entries[i-dropoffset]=rsdt_entries[i];␊
466␊
467␉␉␉␉if (drop_ssdt && tableSign(table, "SSDT"))␊
468␉␉␉␉{␊
469␉␉␉␉␉DBG("OEM SSDT tables was dropped\n");␊
470␉␉␉␉␉dropoffset++;␊
471␉␉␉␉␉continue;␊
472␉␉␉␉}␊
473␊
474␉␉␉␉if (tableSign(table, "DSDT"))␊
475␉␉␉␉{␊
476␉␉␉␉␉DBG("DSDT found\n");␊
477␉␉␉␉␉DBG("Custom DSDT table was found\n");␊
478␉␉␉␉␉if(new_dsdt)␊
479␉␉␉␉␉{␊
480␉␉␉␉␉␉rsdt_entries[i-dropoffset] = (uint32_t)new_dsdt;␊
481␉␉␉␉␉}␊
482␊
483␉␉␉␉␉continue;␊
484␉␉␉␉}␊
485␊
486␉␉␉␉if (tableSign(table, "FACP"))␊
487␉␉␉␉{␊
488␉␉␉␉␉struct acpi_2_fadt *fadt, *fadt_mod;␊
489␉␉␉␉␉fadt=(struct acpi_2_fadt *)rsdt_entries[i];␊
490␊
491␉␉␉␉␉DBG("FADT found @%x, Length %d\n",fadt, fadt->Length);␊
492␊
493␉␉␉␉␉if (!fadt || (uint32_t)fadt == 0xffffffff || fadt->Length>0x10000)␊
494␉␉␉␉␉{␊
495␉␉␉␉␉␉DBG("FADT incorrect. Not modified\n");␊
496␉␉␉␉␉␉continue;␊
497␉␉␉␉␉}␊
498␉␉␉␉␉␊
499␉␉␉␉␉fadt_mod = patch_fadt(fadt, new_dsdt);␊
500␉␉␉␉␉rsdt_entries[i-dropoffset] = (uint32_t)fadt_mod;␊
501␉␉␉␉␉␊
502␉␉␉␉␉// Generate _CST SSDT␊
503␉␉␉␉␉if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))␊
504␉␉␉␉␉{␊
505␉␉␉␉␉␉DBG("\tC-States generated.\n");␊
506␉␉␉␉␉␉generate_cstates = false; // Generate SSDT only once!␊
507␉␉␉␉␉␉ssdt_count++;␊
508␉␉␉␉␉}␊
509␊
510␉␉␉␉␉// Generating _PSS SSDT␊
511␉␉␉␉␉if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))␊
512␉␉␉␉␉{␊
513␉␉␉␉␉␉DBG("\tP-States generated.\n");␊
514␉␉␉␉␉␉generate_pstates = false; // Generate SSDT only once!␊
515␉␉␉␉␉␉ssdt_count++;␊
516␉␉␉␉␉}␊
517␉␉␉␉␉continue;␊
518␉␉␉␉}␊
519␉␉␉}␊
520␉␉␉DBG("\n");␊
521␊
522␉␉␉// Allocate rsdt in Kernel memory area␊
523␉␉␉rsdt_mod->Length += 4*ssdt_count - 4*dropoffset;␊
524␉␉␉struct acpi_2_rsdt *rsdt_copy = (struct acpi_2_rsdt *)AllocateKernelMemory(rsdt_mod->Length);␊
525␉␉␉memcpy(rsdt_copy, rsdt_mod, rsdt_mod->Length);␊
526␉␉␉free(rsdt_mod);␊
527␉␉␉rsdt_mod = rsdt_copy;␊
528␉␉␉rsdp_mod->RsdtAddress = (uint32_t)rsdt_mod;␊
529␉␉␉rsdt_entries_num = (rsdt_mod->Length-sizeof(struct acpi_2_rsdt)) / 4;␊
530␉␉␉rsdt_entries = (uint32_t *)(rsdt_mod + 1);␊
531␊
532␉␉␉// Mozodojo: Insert additional SSDTs into RSDT␊
533␉␉␉if(ssdt_count > 0)␊
534␉␉␉{␊
535␉␉␉␉int j;␊
536␊
537␉␉␉␉for (j=0; j<ssdt_count; j++)␊
538␉␉␉␉{␊
539␉␉␉␉␉rsdt_entries[i-dropoffset+j] = (uint32_t)new_ssdt[j];␊
540␉␉␉␉}␊
541␊
542␉␉␉␉DBG("RSDT: Added %d SSDT table(s)\n", ssdt_count);␊
543␊
544␉␉␉}␊
545␊
546␉␉␉// Correct the checksum of RSDT␊
547␉␉␉DBG("RSDT: Original checksum %d, ", rsdt_mod->Checksum);␊
548␊
549␉␉␉rsdt_mod->Checksum=0;␊
550␉␉␉rsdt_mod->Checksum=256-checksum8(rsdt_mod,rsdt_mod->Length);␊
551␊
552␉␉␉DBG("New checksum %d at %x\n", rsdt_mod->Checksum,rsdt_mod);␊
553␉␉}␊
554␉␉else␊
555␉␉{␊
556␉␉␉rsdp_mod->RsdtAddress=0;␊
557␉␉␉DBG("RSDT not found or RSDT incorrect\n");␊
558␉␉}␊
559␉␉DBG("\n");␊
560␊
561␉␉if (version)␊
562␉␉{␊
563␉␉␉struct acpi_2_xsdt *xsdt, *xsdt_mod;␊
564␊
565␉␉␉// FIXME: handle 64-bit address correctly␊
566␊
567␉␉␉xsdt=(struct acpi_2_xsdt*) ((uint32_t)rsdp->XsdtAddress);␊
568␉␉␉DBG("XSDT @%x;%x, Length=%d\n", (uint32_t)(rsdp->XsdtAddress>>32),(uint32_t)rsdp->XsdtAddress, xsdt->Length);␊
569␊
570␉␉␉if (xsdt && (uint64_t)rsdp->XsdtAddress<0xffffffff && xsdt->Length<0x10000)␊
571␉␉␉{␊
572␉␉␉␉uint64_t *xsdt_entries;␊
573␉␉␉␉int xsdt_entries_num, i;␊
574␉␉␉␉int dropoffset = 0;␊
575␊
576␉␉␉␉// mozo: using malloc cos I didn't found how to free already allocated kernel memory␊
577␉␉␉␉xsdt_mod = (struct acpi_2_xsdt *)malloc(xsdt->Length);␊
578␉␉␉␉memcpy(xsdt_mod, xsdt, xsdt->Length);␊
579␊
580␉␉␉␉rsdp_mod->XsdtAddress = (uint32_t)xsdt_mod;␊
581␉␉␉␉xsdt_entries_num = (xsdt_mod->Length - sizeof(struct acpi_2_xsdt)) / 8;␊
582␉␉␉␉xsdt_entries = (uint64_t *)(xsdt_mod + 1);␊
583␉␉␉␉for (i = 0;i < xsdt_entries_num; i++)␊
584␉␉␉␉{␊
585␉␉␉␉␉char *table = (char *)((uint32_t)(xsdt_entries[i]));␊
586␉␉␉␉␉if (!table)␊
587␉␉␉␉␉{␊
588␉␉␉␉␉␉continue;␊
589␉␉␉␉␉}␊
590␉␉␉␉␉xsdt_entries[i - dropoffset] = xsdt_entries[i];␊
591␊
592␉␉␉␉␉if (drop_ssdt && tableSign(table, "SSDT"))␊
593␉␉␉␉␉{␊
594␉␉␉␉␉␉DBG("OEM SSDT tables was dropped\n");␊
595␉␉␉␉␉␉dropoffset++;␊
596␉␉␉␉␉␉continue;␊
597␉␉␉␉␉}␊
598␉␉␉␉␉if (tableSign(table, "DSDT"))␊
599␉␉␉␉␉{␊
600␉␉␉␉␉␉DBG("DSDT found\n");␊
601␊
602␉␉␉␉␉␉if (new_dsdt)␊
603␉␉␉␉␉␉{␊
604␉␉␉␉␉␉␉xsdt_entries[i-dropoffset] = (uint32_t)new_dsdt;␊
605␉␉␉␉␉␉␉DBG("custom table added.\n");␊
606␉␉␉␉␉␉}␊
607␊
608␉␉␉␉␉␉DBG("TABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
609␊
610␉␉␉␉␉␉continue;␊
611␉␉␉␉␉}␊
612␉␉␉␉␉if (tableSign(table, "FACP"))␊
613␉␉␉␉␉{␊
614␉␉␉␉␉␉struct acpi_2_fadt *fadt, *fadt_mod;␊
615␉␉␉␉␉␉fadt=(struct acpi_2_fadt *)(uint32_t)xsdt_entries[i];␊
616␊
617␉␉␉␉␉␉DBG("FADT found @%x%x, Length %d\n",(uint32_t)(xsdt_entries[i]>>32),fadt, ␊
618␉␉␉␉␉␉␉fadt->Length);␊
619␊
620␉␉␉␉␉␉if (!fadt || (uint64_t)xsdt_entries[i] >= 0xffffffff || fadt->Length>0x10000)␊
621␉␉␉␉␉␉{␊
622␉␉␉␉␉␉␉DBG("FADT incorrect or after 4GB. Dropping XSDT\n");␊
623␉␉␉␉␉␉␉goto drop_xsdt;␊
624␉␉␉␉␉␉}␊
625␊
626␉␉␉␉␉␉fadt_mod = patch_fadt(fadt, new_dsdt);␊
627␉␉␉␉␉␉xsdt_entries[i - dropoffset] = (uint32_t)fadt_mod;␊
628␊
629␉␉␉␉␉␉// DBG("TABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
630␊
631␉␉␉␉␉␉// Generate _CST SSDT␊
632␉␉␉␉␉␉if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))␊
633␉␉␉␉␉␉{␊
634␉␉␉␉␉␉␉DBG("\tC-States generated.\n");␊
635␉␉␉␉␉␉␉generate_cstates = false; // Generate SSDT only once!␊
636␉␉␉␉␉␉␉ssdt_count++;␊
637␉␉␉␉␉␉}␊
638␊
639␉␉␉␉␉␉// Generating _PSS SSDT␊
640␉␉␉␉␉␉if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))␊
641␉␉␉␉␉␉{␊
642␉␉␉␉␉␉␉DBG("\tP-States generated.\n");␊
643␉␉␉␉␉␉␉generate_pstates = false; // Generate SSDT only once!␊
644␉␉␉␉␉␉␉ssdt_count++;␊
645␉␉␉␉␉␉}␊
646␊
647␉␉␉␉␉␉continue;␊
648␉␉␉␉␉}␊
649␉␉␉␉␉DBG("copied (OEM)\n");␊
650␉␉␉␉␉// DBG("TABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
651␉␉␉␉}␊
652␊
653␉␉␉␉// Allocate xsdt in Kernel memory area␊
654␉␉␉␉xsdt_mod->Length += 8*ssdt_count - 8*dropoffset;␊
655␉␉␉␉struct acpi_2_xsdt *xsdt_copy = (struct acpi_2_xsdt *)AllocateKernelMemory(xsdt_mod->Length);␊
656␉␉␉␉memcpy(xsdt_copy, xsdt_mod, xsdt_mod->Length);␊
657␉␉␉␉free(xsdt_mod);␊
658␉␉␉␉xsdt_mod = xsdt_copy;␊
659␉␉␉␉rsdp_mod->XsdtAddress = (uint32_t)xsdt_mod;␊
660␉␉␉␉xsdt_entries_num = (xsdt_mod->Length - sizeof(struct acpi_2_xsdt)) / 8;␊
661␉␉␉␉xsdt_entries = (uint64_t *)(xsdt_mod + 1);␊
662␊
663␉␉␉␉// Mozodojo: Insert additional SSDTs into XSDT␊
664␉␉␉␉if(ssdt_count > 0)␊
665␉␉␉␉{␊
666␉␉␉␉␉int j;␊
667␊
668␉␉␉␉␉for (j=0; j<ssdt_count; j++)␊
669␉␉␉␉␉{␊
670␉␉␉␉␉␉xsdt_entries[i - dropoffset + j] = (uint32_t)new_ssdt[j];␊
671␉␉␉␉␉}␊
672␊
673␉␉␉␉␉verbose("Added %d SSDT table(s) into XSDT\n", ssdt_count);␊
674␊
675␉␉␉␉}␊
676␊
677␉␉␉␉// Correct the checksum of XSDT␊
678␉␉␉␉xsdt_mod->Checksum=0;␊
679␉␉␉␉xsdt_mod->Checksum=256-checksum8(xsdt_mod,xsdt_mod->Length);␊
680␉␉␉}␊
681␉␉␉else␊
682␉␉␉{␊
683␉␉␉drop_xsdt:␊
684␊
685␉␉␉␉DBG("About to drop XSDT\n");␊
686␊
687␉␉␉␉/*FIXME: Now we just hope that if MacOS doesn't find XSDT it reverts to RSDT. ␊
688␉␉␉␉ * A Better strategy would be to generate␊
689␉␉␉␉ */␊
690␊
691␉␉␉␉rsdp_mod->XsdtAddress=0xffffffffffffffffLL;␊
692␉␉␉␉verbose("XSDT not found or XSDT incorrect\n");␊
693␉␉␉}␊
694␉␉}␊
695␉␉DBG("\n");␊
696␊
697␉␉// Correct the checksum of RSDP␊
698␊
699␉␉DBG("RSDP: Original checksum %d, ", rsdp_mod->Checksum);␊
700␊
701␉␉rsdp_mod->Checksum=0;␊
702␉␉rsdp_mod->Checksum=256-checksum8(rsdp_mod,20);␊
703␊
704␉␉DBG("New checksum %d\n", rsdp_mod->Checksum);␊
705␊
706␉␉if (version)␊
707␉␉{␊
708␉␉␉DBG("RSDP: Original extended checksum %d, ", rsdp_mod->ExtendedChecksum);␊
709␊
710␉␉␉rsdp_mod->ExtendedChecksum=0;␊
711␉␉␉rsdp_mod->ExtendedChecksum=256-checksum8(rsdp_mod,rsdp_mod->Length);␊
712␊
713␉␉␉DBG("New extended checksum %d\n", rsdp_mod->ExtendedChecksum);␊
714␊
715␉␉}␊
716␊
717␉␉if (version)␊
718␉␉{␊
719␉␉␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
720␉␉␉acpi20_p = (uint64_t)(uint32_t)rsdp_mod;␊
721␉␉␉addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20");␊
722␉␉}␊
723␉␉else␊
724␉␉{␊
725␉␉␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
726␉␉␉acpi10_p = (uint64_t)(uint32_t)rsdp_mod;␊
727␉␉␉addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI");␊
728␉␉}␊
729␉␉DBG("ACPI version %d patching finished\n\n", version + 1);␊
730␉}␊
731#if DEBUG_ACPI␊
732␉printf("Press a key to continue... (DEBUG_ACPI)\n");␊
733␉getchar();␊
734#endif␊
735␉return 1;␊
736}␊
737

Archive Download this file

Revision: 2683