Chameleon

Chameleon Svn Source Tree

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

Archive Download this file

Revision: 2679