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 \n", dirspec);␊
155␉} ␊
156␉//printf("Couldn't find table %s\n", filename);␊
157␉return NULL;␊
158}␊
159␊
160uint8_t acpi_cpu_count␉= 0;␊
161uint32_t acpi_cpu_p_blk␉= 0;␊
162char *acpi_cpu_name[32];␊
163␊
164void get_acpi_cpu_names(unsigned char *dsdt, uint32_t length)␊
165{␊
166␉uint32_t i;␊
167␊
168␉DBG("ACPIpatcher: start finding cpu names. Length %d\n", length);␊
169␊
170␉for (i=0; i<length-7; i++)␊
171␉{␊
172␉␉if (dsdt[i] == 0x5B && dsdt[i+1] == 0x83) // ProcessorOP␊
173␉␉{␊
174␉␉␉DBG("ACPIpatcher: DSDT[%X%X]\n", dsdt[i], dsdt[i+1]);␊
175␊
176␉␉␉uint32_t offset = i + 3 + (dsdt[i+2] >> 6);␊
177␊
178␉␉␉bool add_name = true;␊
179␊
180␉␉␉uint8_t j;␊
181␊
182␉␉␉for (j=0; j<4; j++)␊
183␉␉␉{␊
184␉␉␉␉char c = dsdt[offset+j];␊
185␊
186␉␉␉␉if (!aml_isvalidchar(c))␊
187␉␉␉␉{␊
188␉␉␉␉␉add_name = false;␊
189␉␉␉␉␉DBG("ACPIpatcher: invalid character found in ProcessorOP '0x%X'!\n", c);␊
190␉␉␉␉␉break;␊
191␉␉␉␉}␊
192␉␉␉}␊
193␊
194␉␉␉if (add_name)␊
195␉␉␉{␊
196␉␉␉␉acpi_cpu_name[acpi_cpu_count] = malloc(4);␊
197␉␉␉␉memcpy(acpi_cpu_name[acpi_cpu_count], dsdt+offset, 4);␊
198␉␉␉␉i = offset + 5;␊
199␊
200␉␉␉␉if (acpi_cpu_count == 0)␊
201␉␉␉␉{␊
202␉␉␉␉␉acpi_cpu_p_blk = dsdt[i] | (dsdt[i+1] << 8);␊
203␉␉␉␉}␊
204␊
205␉␉␉␉DBG("ACPIpatcher: found ACPI CPU [%c%c%c%c]\n", acpi_cpu_name[acpi_cpu_count][0], acpi_cpu_name[acpi_cpu_count][1], acpi_cpu_name[acpi_cpu_count][2], acpi_cpu_name[acpi_cpu_count][3]);␊
206␊
207␉␉␉␉if (++acpi_cpu_count == 32)␊
208␉␉␉␉{␊
209␉␉␉␉␉return;␊
210␉␉␉␉}␊
211␉␉␉}␊
212␉␉}␊
213␉}␊
214␊
215␉DBG("ACPIpatcher: finished finding cpu names. Found: %d.\n", acpi_cpu_count);␊
216}␊
217␊
218struct acpi_2_fadt *patch_fadt(struct acpi_2_fadt *fadt, struct acpi_2_dsdt *new_dsdt)␊
219{␊
220␉extern void setupSystemType();␊
221␊
222␉struct acpi_2_fadt *fadt_mod = NULL;␊
223␉bool fadt_rev2_needed = false;␊
224␉bool fix_restart;␊
225␉bool fix_restart_ps2;␊
226␉const char * value;␊
227␊
228␉// Restart Fix␊
229␉if (Platform.CPU.Vendor == 0x756E6547)␊
230␉{␉/* Intel */␊
231␉␉fix_restart = true;␊
232␉␉fix_restart_ps2 = false;␊
233␉␉if ( getBoolForKey(kPS2RestartFix, &fix_restart_ps2, &bootInfo->chameleonConfig) && fix_restart_ps2)␊
234␉␉{␊
235␉␉␉fix_restart = true;␊
236␉␉}␊
237␉␉else␊
238␉␉{␊
239␉␉␉getBoolForKey(kRestartFix, &fix_restart, &bootInfo->chameleonConfig);␊
240␉␉}␊
241␉}␊
242␉else␊
243␉{␊
244␉␉DBG("Not an Intel platform: Restart Fix not applied !!!\n");␊
245␉␉fix_restart = false;␊
246␉}␊
247␊
248␉if (fix_restart)␊
249␉{␊
250␉␉fadt_rev2_needed = true;␊
251␉}␊
252␊
253␉// Allocate new fadt table␊
254␉if (fadt->Length < 0x84 && fadt_rev2_needed)␊
255␉{␊
256␉␉fadt_mod = (struct acpi_2_fadt *)AllocateKernelMemory(0x84);␊
257␉␉memcpy(fadt_mod, fadt, fadt->Length);␊
258␉␉fadt_mod->Length = 0x84;␊
259␉␉fadt_mod->Revision = 0x02; // FADT rev 2 (ACPI 1.0B MS extensions)␊
260␉}␊
261␉else␊
262␉{␊
263␉␉fadt_mod = (struct acpi_2_fadt *)AllocateKernelMemory(fadt->Length);␊
264␉␉memcpy(fadt_mod, fadt, fadt->Length);␊
265␉}␊
266␉// Determine system type / PM_Model␊
267␉if ( (value=getStringForKey(kSystemType, &bootInfo->chameleonConfig))!=NULL)␊
268␉{␊
269␉␉if (Platform.Type > 6)␊
270␉␉{␊
271␉␉␉if(fadt_mod->PM_Profile<=6)␊
272␉␉␉{␊
273␉␉␉␉Platform.Type = fadt_mod->PM_Profile; // get the fadt if correct␊
274␉␉␉}␊
275␉␉␉else␊
276␉␉␉{␊
277␉␉␉␉Platform.Type = 1;␉␉/* Set a fixed value (Desktop) */␊
278␉␉␉}␊
279␉␉␉DBG("Error: system-type must be 0..6. Defaulting to %d !\n", Platform.Type);␊
280␉␉}␊
281␉␉else␊
282␉␉{␊
283␉␉␉Platform.Type = (unsigned char) strtoul(value, NULL, 10);␊
284␉␉}␊
285␉}␊
286␉// Set PM_Profile from System-type if only user wanted this value to be forced␊
287␉if (fadt_mod->PM_Profile != Platform.Type)␊
288␉{␊
289␉␉if (value)␊
290␉␉{␊
291␉␉␉// user has overriden the SystemType so take care of it in FACP␊
292␉␉␉DBG("FADT: changing PM_Profile from 0x%02x to 0x%02x\n", fadt_mod->PM_Profile, Platform.Type);␊
293␉␉␉fadt_mod->PM_Profile = Platform.Type;␊
294␉␉}␊
295␉␉else␊
296␉␉{␊
297␉␉␉// PM_Profile has a different value and no override has been set, so reflect the user value to ioregs␊
298␉␉␉Platform.Type = fadt_mod->PM_Profile <= 6 ? fadt_mod->PM_Profile : 1;␊
299␉␉}␊
300␉}␊
301␉// We now have to write the systemm-type in ioregs: we cannot do it before in setupDeviceTree()␊
302␉// because we need to take care of FACP original content, if it is correct.␊
303␉setupSystemType();␊
304␊
305␉// Patch FADT to fix restart␊
306␉if (fix_restart)␊
307␉{␊
308␉␉if (fix_restart_ps2)␊
309␉␉{␊
310␉␉␉fadt_mod->Flags|= 0x400;␊
311␉␉␉fadt_mod->Reset_SpaceID␉␉= 0x01; // System I/O␊
312␉␉␉fadt_mod->Reset_BitWidth␉= 0x08; // 1 byte␊
313␉␉␉fadt_mod->Reset_BitOffset␉= 0x00; // Offset 0␊
314␉␉␉fadt_mod->Reset_AccessWidth␉= 0x01; // Byte access␊
315␉␉␉fadt_mod->Reset_Address␉␉= 0x64; // Address of the register␊
316␉␉␉fadt_mod->Reset_Value␉␉= 0xfe; // Value to write to reset the system␊
317␉␉␉DBG("FADT: PS2 Restart Fix applied!\n");␊
318␉␉}␊
319␉␉else␊
320␉␉{␊
321␉␉␉fadt_mod->Flags|= 0x400;␊
322␉␉␉fadt_mod->Reset_SpaceID␉␉= 0x01; // System I/O␊
323␉␉␉fadt_mod->Reset_BitWidth␉= 0x08; // 1 byte␊
324␉␉␉fadt_mod->Reset_BitOffset␉= 0x00; // Offset 0␊
325␉␉␉fadt_mod->Reset_AccessWidth␉= 0x01; // Byte access␊
326␉␉␉fadt_mod->Reset_Address␉␉= 0x0cf9; // Address of the register␊
327␉␉␉fadt_mod->Reset_Value␉␉= 0x06; // Value to write to reset the system␊
328␉␉␉DBG("FADT: ACPI Restart Fix applied!\n");␊
329␉␉}␊
330␊
331␉}␊
332␊
333␉// Patch DSDT Address if we have loaded DSDT.aml␊
334␉if(new_dsdt)␊
335␉{␊
336␉␉DBG("DSDT: Old @%x,%x, ",fadt_mod->DSDT,fadt_mod->X_DSDT);␊
337␊
338␉␉fadt_mod->DSDT=(uint32_t)new_dsdt;␊
339␉␉if ((uint32_t)(&(fadt_mod->X_DSDT))-(uint32_t)fadt_mod+8<=fadt_mod->Length)␊
340␉␉{␊
341␉␉␉fadt_mod->X_DSDT=(uint32_t)new_dsdt;␊
342␉␉}␊
343␊
344␉␉DBG("New @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT);␊
345␊
346␉␉DBG("FADT: Using custom DSDT!\n");␊
347␉}␊
348␊
349␉// Correct the checksum␊
350␉fadt_mod->Checksum=0;␊
351␉fadt_mod->Checksum=256-checksum8(fadt_mod,fadt_mod->Length);␊
352␊
353␉return fadt_mod;␊
354}␊
355␊
356/* Setup ACPI without replacing DSDT. */␊
357int setupAcpiNoMod()␊
358{␊
359//␉addConfigurationTable(&gEfiAcpiTableGuid, getAddressOfAcpiTable(), "ACPI");␊
360//␉addConfigurationTable(&gEfiAcpi20TableGuid, getAddressOfAcpi20Table(), "ACPI_20");␊
361␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
362␉acpi10_p = (uint64_t)(uint32_t)getAddressOfAcpiTable();␊
363␉acpi20_p = (uint64_t)(uint32_t)getAddressOfAcpi20Table();␊
364␉addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI");␊
365␉if(acpi20_p)␊
366␉{␊
367␉␉addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20");␊
368␉}␊
369␉else␊
370␉{␊
371␉␉DBG("No ACPI 2.\n");␊
372␉}␊
373␉return 1;␊
374}␊
375␊
376/* Setup ACPI. Replace DSDT if DSDT.aml is found */␊
377int setupAcpi(void)␊
378{␊
379␉int version;␊
380␉void *new_dsdt = NULL;␊
381␊
382␊
383␉const char *filename;␊
384␉char dirSpec[128];␊
385␉int len = 0;␊
386␊
387␉// always reset cpu count to 0 when injecting new acpi␊
388␉acpi_cpu_count = 0;␊
389␊
390␉/* Try using the file specified with the DSDT option */␊
391␉if (getValueForKey(kDSDT, &filename, &len, &bootInfo->chameleonConfig))␊
392␉{␊
393␉␉strncpy(dirSpec, filename, sizeof(dirSpec) );␊
394␉}␊
395␉else␊
396␉{␊
397␉␉strcpy(dirSpec, "DSDT.aml");␊
398␉␉//verbose("dirSpec, DSDT.aml");␊
399␉}␊
400␊
401␉// Load replacement DSDT␊
402␉new_dsdt = loadACPITable(dirSpec);␊
403␊
404␉// Mozodojo: going to patch FACP and load SSDT's even if DSDT.aml is not present␊
405␉/*if (!new_dsdt)␊
406␉ {␊
407␉ return setupAcpiNoMod();␊
408␉ }*/␊
409␊
410␉// Mozodojo: Load additional SSDTs␊
411␉struct acpi_2_ssdt *new_ssdt[32]; // 30 + 2 additional tables for pss & cst␊
412␉int ssdt_count=0;␊
413␊
414␉// SSDT Options␊
415␉bool drop_ssdt = false, generate_pstates = false, generate_cstates = false;␊
416␊
417␉getBoolForKey(kDropSSDT, &drop_ssdt, &bootInfo->chameleonConfig);␊
418␉getBoolForKey(kGeneratePStates, &generate_pstates, &bootInfo->chameleonConfig);␊
419␉getBoolForKey(kGenerateCStates, &generate_cstates, &bootInfo->chameleonConfig);␊
420␊
421␉DBG("Generating P-States config: %s\n", generate_pstates ? "YES" : "NO");␊
422␉DBG("Generating C-States config: %s\n", generate_cstates ? "YES" : "NO");␊
423␊
424␉{␊
425␉␉int i;␊
426␊
427␉␉for (i = 0; i < 30; i++)␊
428␉␉{␊
429␉␉␉char filename[512];␊
430␊
431␉␉␉if (i > 0)␊
432␉␉␉{␊
433␉␉␉␉sprintf(filename, "SSDT-%d.aml", i);␊
434␉␉␉}␊
435␉␉␉else␊
436␉␉␉{␊
437␉␉␉␉strcpy(filename, "SSDT.aml");␊
438␉␉␉}␊
439␊
440␉␉␉if ( (new_ssdt[ssdt_count] = loadACPITable(filename)) )␊
441␉␉␉{␊
442␉␉␉␉ssdt_count++;␊
443␉␉␉}␊
444␉␉␉else␊
445␉␉␉{␊
446␉␉␉␉break;␊
447␉␉␉}␊
448␉␉}␊
449␉}␊
450␊
451␉// Do the same procedure for both versions of ACPI␊
452␉for (version = 0; version < 2; version++)␊
453␉{␊
454␉␉struct acpi_2_rsdp *rsdp, *rsdp_mod;␊
455␉␉struct acpi_2_rsdt *rsdt, *rsdt_mod;␊
456␉␉int rsdplength;␊
457␊
458␉␉// Find original rsdp␊
459␉␉rsdp = (struct acpi_2_rsdp *)(version ? getAddressOfAcpi20Table() : getAddressOfAcpiTable());␊
460␉␉if (!rsdp)␊
461␉␉{␊
462␉␉␉DBG("No ACPI version %d found. Ignoring\n", version+1);␊
463␉␉␉if (version)␊
464␉␉␉{␊
465␉␉␉␉addConfigurationTable(&gEfiAcpi20TableGuid, NULL, "ACPI_20");␊
466␉␉␉}␊
467␉␉␉else␊
468␉␉␉{␊
469␉␉␉␉addConfigurationTable(&gEfiAcpiTableGuid, NULL, "ACPI");␊
470␉␉␉}␊
471␉␉␉continue;␊
472␉␉}␊
473␉␉rsdplength = version ? rsdp->Length : 20;␊
474␊
475␉␉DBG("RSDP version %d found @%x. Length=%d\n",version+1,rsdp,rsdplength);␊
476␊
477␉␉/* FIXME: no check that memory allocation succeeded ␊
478␉␉ * Copy and patch RSDP,RSDT, XSDT and FADT␊
479␉␉ * For more info see ACPI Specification pages 110 and following␊
480␉␉ */␊
481␊
482␉␉rsdp_mod = (struct acpi_2_rsdp *) AllocateKernelMemory(rsdplength);␊
483␉␉memcpy(rsdp_mod, rsdp, rsdplength);␊
484␊
485␉␉rsdt = (struct acpi_2_rsdt *)rsdp->RsdtAddress;␊
486␊
487␉␉DBG("RSDT @%x, Length %d\n",rsdt, rsdt ? rsdt->Length : 0);␊
488␊
489␉␉if (rsdt && (uint32_t)rsdt !=0xffffffff && rsdt->Length < 0x10000)␊
490␉␉{␊
491␉␉␉uint32_t *rsdt_entries;␊
492␉␉␉int rsdt_entries_num;␊
493␉␉␉int dropoffset=0, i;␊
494␊
495␉␉␉// mozo: using malloc cos I didn't found how to free already allocated kernel memory␊
496␉␉␉rsdt_mod = (struct acpi_2_rsdt *)malloc(rsdt->Length);␊
497␉␉␉memcpy(rsdt_mod, rsdt, rsdt->Length);␊
498␉␉␉rsdp_mod->RsdtAddress = (uint32_t)rsdt_mod;␊
499␉␉␉rsdt_entries_num = (rsdt_mod->Length - sizeof(struct acpi_2_rsdt)) / 4;␊
500␉␉␉rsdt_entries = (uint32_t *)(rsdt_mod + 1);␊
501␉␉␉for (i = 0;i < rsdt_entries_num;i++)␊
502␉␉␉{␊
503␉␉␉␉char *table=(char *)(rsdt_entries[i]);␊
504␉␉␉␉if (!table)␊
505␉␉␉␉{␊
506␉␉␉␉␉continue;␊
507␉␉␉␉}␊
508␊
509␉␉␉␉DBG("TABLE %c%c%c%c,",table[0],table[1],table[2],table[3]);␊
510␊
511␉␉␉␉rsdt_entries[i-dropoffset]=rsdt_entries[i];␊
512␊
513␉␉␉␉if (drop_ssdt && tableSign(table, "SSDT"))␊
514␉␉␉␉{␊
515␉␉␉␉␉DBG("OEM SSDT tables was dropped\n");␊
516␉␉␉␉␉dropoffset++;␊
517␉␉␉␉␉continue;␊
518␉␉␉␉}␊
519␊
520␉␉␉␉if (tableSign(table, "DSDT"))␊
521␉␉␉␉{␊
522␉␉␉␉␉DBG("DSDT found\n");␊
523␉␉␉␉␉DBG("Custom DSDT table was found\n");␊
524␉␉␉␉␉if(new_dsdt)␊
525␉␉␉␉␉{␊
526␉␉␉␉␉␉rsdt_entries[i-dropoffset]=(uint32_t)new_dsdt;␊
527␉␉␉␉␉}␊
528␊
529␉␉␉␉␉continue;␊
530␉␉␉␉}␊
531␊
532␉␉␉␉if (tableSign(table, "FACP"))␊
533␉␉␉␉{␊
534␉␉␉␉␉struct acpi_2_fadt *fadt, *fadt_mod;␊
535␉␉␉␉␉fadt=(struct acpi_2_fadt *)rsdt_entries[i];␊
536␊
537␉␉␉␉␉DBG("FADT found @%x, Length %d\n",fadt, fadt->Length);␊
538␊
539␉␉␉␉␉if (!fadt || (uint32_t)fadt == 0xffffffff || fadt->Length>0x10000)␊
540␉␉␉␉␉{␊
541␉␉␉␉␉␉DBG("FADT incorrect. Not modified\n");␊
542␉␉␉␉␉␉continue;␊
543␉␉␉␉␉}␊
544␉␉␉␉␉␊
545␉␉␉␉␉fadt_mod = patch_fadt(fadt, new_dsdt);␊
546␉␉␉␉␉rsdt_entries[i-dropoffset] = (uint32_t)fadt_mod;␊
547␉␉␉␉␉␊
548␉␉␉␉␉// Generate _CST SSDT␊
549␉␉␉␉␉if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))␊
550␉␉␉␉␉{␊
551␉␉␉␉␉␉DBG("C-States generated\n");␊
552␉␉␉␉␉␉generate_cstates = false; // Generate SSDT only once!␊
553␉␉␉␉␉␉ssdt_count++;␊
554␉␉␉␉␉}␊
555␊
556␉␉␉␉␉// Generating _PSS SSDT␊
557␉␉␉␉␉if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))␊
558␉␉␉␉␉{␊
559␉␉␉␉␉␉DBG("P-States generated\n");␊
560␉␉␉␉␉␉generate_pstates = false; // Generate SSDT only once!␊
561␉␉␉␉␉␉ssdt_count++;␊
562␉␉␉␉␉}␊
563␉␉␉␉␉continue;␊
564␉␉␉␉}␊
565␉␉␉}␊
566␉␉␉DBG("\n");␊
567␊
568␉␉␉// Allocate rsdt in Kernel memory area␊
569␉␉␉rsdt_mod->Length += 4*ssdt_count - 4*dropoffset;␊
570␉␉␉struct acpi_2_rsdt *rsdt_copy = (struct acpi_2_rsdt *)AllocateKernelMemory(rsdt_mod->Length);␊
571␉␉␉memcpy(rsdt_copy, rsdt_mod, rsdt_mod->Length);␊
572␉␉␉free(rsdt_mod);␊
573␉␉␉rsdt_mod = rsdt_copy;␊
574␉␉␉rsdp_mod->RsdtAddress = (uint32_t)rsdt_mod;␊
575␉␉␉rsdt_entries_num = (rsdt_mod->Length-sizeof(struct acpi_2_rsdt)) / 4;␊
576␉␉␉rsdt_entries = (uint32_t *)(rsdt_mod + 1);␊
577␊
578␉␉␉// Mozodojo: Insert additional SSDTs into RSDT␊
579␉␉␉if(ssdt_count > 0)␊
580␉␉␉{␊
581␉␉␉␉int j;␊
582␊
583␉␉␉␉for (j=0; j<ssdt_count; j++)␊
584␉␉␉␉{␊
585␉␉␉␉␉rsdt_entries[i-dropoffset+j]=(uint32_t)new_ssdt[j];␊
586␉␉␉␉}␊
587␊
588␉␉␉␉DBG("RSDT: Added %d SSDT table(s)\n", ssdt_count);␊
589␊
590␉␉␉}␊
591␊
592␉␉␉// Correct the checksum of RSDT␊
593␉␉␉DBG("RSDT: Original checksum %d, ", rsdt_mod->Checksum);␊
594␊
595␉␉␉rsdt_mod->Checksum=0;␊
596␉␉␉rsdt_mod->Checksum=256-checksum8(rsdt_mod,rsdt_mod->Length);␊
597␊
598␉␉␉DBG("New checksum %d at %x\n", rsdt_mod->Checksum,rsdt_mod);␊
599␉␉}␊
600␉␉else␊
601␉␉{␊
602␉␉␉rsdp_mod->RsdtAddress=0;␊
603␉␉␉DBG("RSDT not found or RSDT incorrect\n");␊
604␉␉}␊
605␉␉DBG("\n");␊
606␊
607␉␉if (version)␊
608␉␉{␊
609␉␉␉struct acpi_2_xsdt *xsdt, *xsdt_mod;␊
610␊
611␉␉␉// FIXME: handle 64-bit address correctly␊
612␊
613␉␉␉xsdt=(struct acpi_2_xsdt*) ((uint32_t)rsdp->XsdtAddress);␊
614␉␉␉DBG("XSDT @%x;%x, Length=%d\n", (uint32_t)(rsdp->XsdtAddress>>32),(uint32_t)rsdp->XsdtAddress, xsdt->Length);␊
615␊
616␉␉␉if (xsdt && (uint64_t)rsdp->XsdtAddress<0xffffffff && xsdt->Length<0x10000)␊
617␉␉␉{␊
618␉␉␉␉uint64_t *xsdt_entries;␊
619␉␉␉␉int xsdt_entries_num, i;␊
620␉␉␉␉int dropoffset=0;␊
621␊
622␉␉␉␉// mozo: using malloc cos I didn't found how to free already allocated kernel memory␊
623␉␉␉␉xsdt_mod=(struct acpi_2_xsdt*)malloc(xsdt->Length);␊
624␉␉␉␉memcpy(xsdt_mod, xsdt, xsdt->Length);␊
625␊
626␉␉␉␉rsdp_mod->XsdtAddress = (uint32_t)xsdt_mod;␊
627␉␉␉␉xsdt_entries_num = (xsdt_mod->Length - sizeof(struct acpi_2_xsdt)) / 8;␊
628␉␉␉␉xsdt_entries = (uint64_t *)(xsdt_mod + 1);␊
629␉␉␉␉for (i = 0;i < xsdt_entries_num;i++)␊
630␉␉␉␉{␊
631␉␉␉␉␉char *table = (char *)((uint32_t)(xsdt_entries[i]));␊
632␉␉␉␉␉if (!table)␊
633␉␉␉␉␉{␊
634␉␉␉␉␉␉continue;␊
635␉␉␉␉␉}␊
636␉␉␉␉␉xsdt_entries[i - dropoffset] = xsdt_entries[i];␊
637␊
638␉␉␉␉␉if (drop_ssdt && tableSign(table, "SSDT"))␊
639␉␉␉␉␉{␊
640␉␉␉␉␉␉DBG("OEM SSDT tables was dropped\n");␊
641␉␉␉␉␉␉dropoffset++;␊
642␉␉␉␉␉␉continue;␊
643␉␉␉␉␉}␊
644␉␉␉␉␉if (tableSign(table, "DSDT"))␊
645␉␉␉␉␉{␊
646␉␉␉␉␉␉DBG("DSDT found\n");␊
647␊
648␉␉␉␉␉␉if (new_dsdt)␊
649␉␉␉␉␉␉{␊
650␉␉␉␉␉␉␉xsdt_entries[i-dropoffset] = (uint32_t)new_dsdt;␊
651␉␉␉␉␉␉␉DBG("custom table added\n");␊
652␉␉␉␉␉␉}␊
653␊
654␉␉␉␉␉␉DBG("TABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
655␊
656␉␉␉␉␉␉continue;␊
657␉␉␉␉␉}␊
658␉␉␉␉␉if (tableSign(table, "FACP"))␊
659␉␉␉␉␉{␊
660␉␉␉␉␉␉struct acpi_2_fadt *fadt, *fadt_mod;␊
661␉␉␉␉␉␉fadt=(struct acpi_2_fadt *)(uint32_t)xsdt_entries[i];␊
662␊
663␉␉␉␉␉␉DBG("FADT found @%x%x, Length %d\n",(uint32_t)(xsdt_entries[i]>>32),fadt, ␊
664␉␉␉␉␉␉␉fadt->Length);␊
665␊
666␉␉␉␉␉␉if (!fadt || (uint64_t)xsdt_entries[i] >= 0xffffffff || fadt->Length>0x10000)␊
667␉␉␉␉␉␉{␊
668␉␉␉␉␉␉␉DBG("FADT incorrect or after 4GB. Dropping XSDT\n");␊
669␉␉␉␉␉␉␉goto drop_xsdt;␊
670␉␉␉␉␉␉}␊
671␊
672␉␉␉␉␉␉fadt_mod = patch_fadt(fadt, new_dsdt);␊
673␉␉␉␉␉␉xsdt_entries[i-dropoffset]=(uint32_t)fadt_mod;␊
674␊
675␉␉␉␉␉␉// DBG("TABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
676␊
677␉␉␉␉␉␉// Generate _CST SSDT␊
678␉␉␉␉␉␉if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))␊
679␉␉␉␉␉␉{␊
680␉␉␉␉␉␉␉DBG("C-States generated\n");␊
681␉␉␉␉␉␉␉generate_cstates = false; // Generate SSDT only once!␊
682␉␉␉␉␉␉␉ssdt_count++;␊
683␉␉␉␉␉␉}␊
684␊
685␉␉␉␉␉␉// Generating _PSS SSDT␊
686␉␉␉␉␉␉if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))␊
687␉␉␉␉␉␉{␊
688␉␉␉␉␉␉␉DBG("P-States generated\n");␊
689␉␉␉␉␉␉␉generate_pstates = false; // Generate SSDT only once!␊
690␉␉␉␉␉␉␉ssdt_count++;␊
691␉␉␉␉␉␉}␊
692␊
693␉␉␉␉␉␉continue;␊
694␉␉␉␉␉}␊
695␉␉␉␉␉DBG("copied (OEM)\n");␊
696␉␉␉␉␉// DBG("TABLE %c%c%c%c@%x \n", table[0],table[1],table[2],table[3],xsdt_entries[i]);␊
697␉␉␉␉}␊
698␊
699␉␉␉␉// Allocate xsdt in Kernel memory area␊
700␉␉␉␉xsdt_mod->Length += 8*ssdt_count - 8*dropoffset;␊
701␉␉␉␉struct acpi_2_xsdt *xsdt_copy = (struct acpi_2_xsdt *)AllocateKernelMemory(xsdt_mod->Length);␊
702␉␉␉␉memcpy(xsdt_copy, xsdt_mod, xsdt_mod->Length);␊
703␉␉␉␉free(xsdt_mod);␊
704␉␉␉␉xsdt_mod = xsdt_copy;␊
705␉␉␉␉rsdp_mod->XsdtAddress = (uint32_t)xsdt_mod;␊
706␉␉␉␉xsdt_entries_num = (xsdt_mod->Length - sizeof(struct acpi_2_xsdt)) / 8;␊
707␉␉␉␉xsdt_entries = (uint64_t *)(xsdt_mod + 1);␊
708␊
709␉␉␉␉// Mozodojo: Insert additional SSDTs into XSDT␊
710␉␉␉␉if(ssdt_count > 0)␊
711␉␉␉␉{␊
712␉␉␉␉␉int j;␊
713␊
714␉␉␉␉␉for (j=0; j<ssdt_count; j++)␊
715␉␉␉␉␉{␊
716␉␉␉␉␉␉xsdt_entries[i-dropoffset+j]=(uint32_t)new_ssdt[j];␊
717␉␉␉␉␉}␊
718␊
719␉␉␉␉␉verbose("Added %d SSDT table(s) into XSDT\n", ssdt_count);␊
720␊
721␉␉␉␉}␊
722␊
723␉␉␉␉// Correct the checksum of XSDT␊
724␉␉␉␉xsdt_mod->Checksum=0;␊
725␉␉␉␉xsdt_mod->Checksum=256-checksum8(xsdt_mod,xsdt_mod->Length);␊
726␉␉␉}␊
727␉␉␉else␊
728␉␉␉{␊
729␉␉␉drop_xsdt:␊
730␊
731␉␉␉␉DBG("About to drop XSDT\n");␊
732␊
733␉␉␉␉/*FIXME: Now we just hope that if MacOS doesn't find XSDT it reverts to RSDT. ␊
734␉␉␉␉ * A Better strategy would be to generate␊
735␉␉␉␉ */␊
736␊
737␉␉␉␉rsdp_mod->XsdtAddress=0xffffffffffffffffLL;␊
738␉␉␉␉verbose("XSDT not found or XSDT incorrect\n");␊
739␉␉␉}␊
740␉␉}␊
741␉␉DBG("\n");␊
742␊
743␉␉// Correct the checksum of RSDP␊
744␊
745␉␉DBG("RSDP: Original checksum %d, ", rsdp_mod->Checksum);␊
746␊
747␉␉rsdp_mod->Checksum=0;␊
748␉␉rsdp_mod->Checksum=256-checksum8(rsdp_mod,20);␊
749␊
750␉␉DBG("New checksum %d\n", rsdp_mod->Checksum);␊
751␊
752␉␉if (version)␊
753␉␉{␊
754␉␉␉DBG("RSDP: Original extended checksum %d, ", rsdp_mod->ExtendedChecksum);␊
755␊
756␉␉␉rsdp_mod->ExtendedChecksum=0;␊
757␉␉␉rsdp_mod->ExtendedChecksum=256-checksum8(rsdp_mod,rsdp_mod->Length);␊
758␊
759␉␉␉DBG("New extended checksum %d\n", rsdp_mod->ExtendedChecksum);␊
760␊
761␉␉}␊
762␊
763␉␉if (version)␊
764␉␉{␊
765␉␉␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
766␉␉␉acpi20_p = (uint64_t)(uint32_t)rsdp_mod;␊
767␉␉␉addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20");␊
768␉␉}␊
769␉␉else␊
770␉␉{␊
771␉␉␉/* XXX aserebln why uint32 cast if pointer is uint64 ? */␊
772␉␉␉acpi10_p = (uint64_t)(uint32_t)rsdp_mod;␊
773␉␉␉addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI");␊
774␉␉}␊
775␉␉DBG("ACPI version %d patching finished\n\n", version+1);␊
776␉}␊
777#if DEBUG_ACPI␊
778␉printf("Press a key to continue... (DEBUG_ACPI)\n");␊
779␉getchar();␊
780#endif␊
781␉return 1;␊
782}␊
783

Archive Download this file

Revision: 2633