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

Archive Download this file

Revision: 2639