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

Archive Download this file

Revision: HEAD