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

Archive Download this file

Revision: 2538