Chameleon

Chameleon Svn Source Tree

Root/branches/azimutz/CleanCut/i386/libsaio/acpi_patcher.c

1/*
2 * Copyright 2008 mackerintel
3 */
4
5#include "libsaio.h"
6#include "boot.h"
7#include "bootstruct.h"
8#include "acpi.h"
9#include "efi_tables.h"
10#include "fake_efi.h"
11#include "acpi_patcher.h"
12#include "platform.h"
13#include "cpu.h"
14#include "aml_generator.h"
15
16#ifndef DEBUG_ACPI
17#define DEBUG_ACPI 0
18#endif
19
20#if DEBUG_ACPI==2
21#define DBG(x...) {printf(x); sleep(1);}
22#elif DEBUG_ACPI==1
23#define DBG(x...) printf(x)
24#else
25#define DBG(x...)
26#endif
27
28// Slice: New signature compare function
29boolean_t tableSign(char *table, const char *sgn)
30{
31int i;
32for (i=0; i<4; i++) {
33if ((table[i] &~0x20) != (sgn[i] &~0x20)) {
34return false;
35}
36}
37return true;
38}
39
40/* Gets the ACPI 1.0 RSDP address */
41static struct acpi_2_rsdp* getAddressOfAcpiTable()
42{
43 /* TODO: Before searching the BIOS space we are supposed to search the first 1K of the EBDA */
44
45 void *acpi_addr = (void*)ACPI_RANGE_START;
46 for(; acpi_addr <= (void*)ACPI_RANGE_END; acpi_addr += 16)
47 {
48 if(*(uint64_t *)acpi_addr == ACPI_SIGNATURE_UINT64_LE)
49 {
50 uint8_t csum = checksum8(acpi_addr, 20);
51 if(csum == 0)
52 {
53 // Only return the table if it is a true version 1.0 table (Revision 0)
54 if(((struct acpi_2_rsdp*)acpi_addr)->Revision == 0)
55 return acpi_addr;
56 }
57 }
58 }
59 return NULL;
60}
61
62/* Gets the ACPI 2.0 RSDP address */
63static struct acpi_2_rsdp* getAddressOfAcpi20Table()
64{
65 /* TODO: Before searching the BIOS space we are supposed to search the first 1K of the EBDA */
66
67 void *acpi_addr = (void*)ACPI_RANGE_START;
68 for(; acpi_addr <= (void*)ACPI_RANGE_END; acpi_addr += 16)
69 {
70 if(*(uint64_t *)acpi_addr == ACPI_SIGNATURE_UINT64_LE)
71 {
72 uint8_t csum = checksum8(acpi_addr, 20);
73
74 /* Only assume this is a 2.0 or better table if the revision is greater than 0
75 * NOTE: ACPI 3.0 spec only seems to say that 1.0 tables have revision 1
76 * and that the current revision is 2.. I am going to assume that rev > 0 is 2.0.
77 */
78
79 if(csum == 0 && (((struct acpi_2_rsdp*)acpi_addr)->Revision > 0))
80 {
81 uint8_t csum2 = checksum8(acpi_addr, sizeof(struct acpi_2_rsdp));
82 if(csum2 == 0)
83 return acpi_addr;
84 }
85 }
86 }
87 return NULL;
88}
89/** The folowing ACPI Table search algo. should be reused anywhere needed:*/
90int search_and_get_acpi_fd(const char * filename, const char ** outDirspec)
91{
92int fd=0;
93const char * overriden_pathname=NULL;
94static char dirspec[512]="";
95static bool first_time =true;
96int len=0;
97
98/// Take in accound user overriding if it's DSDT only
99if (strstr(filename, "DSDT") &&
100getValueForKey(kDSDT, &overriden_pathname, &len,
101 &bootInfo->bootConfig))
102 {
103sprintf(dirspec, "%s", overriden_pathname);
104fd=open (dirspec,0);
105if (fd>=0) goto success_fd;
106 }
107// Check that dirspec is not already assigned with a path
108if (!first_time && *dirspec)
109{ // it is so start searching this cached patch first
110//extract path
111for (len=strlen(dirspec)-1; len; len--)
112if (dirspec[len]=='/' || len==0)
113{
114dirspec[len]='\0';
115break;
116}
117// now concat with the filename
118strncat(dirspec, "/", sizeof(dirspec));
119strncat(dirspec, filename, sizeof(dirspec));
120// and test to see if we don't have our big boy here:
121fd=open (dirspec,0);
122if (fd>=0)
123{
124// printf("ACPI file search cache hit: file found at %s\n", dirspec);
125goto success_fd;
126}
127}
128// Start searching any potential location for ACPI Table
129// search the Extra folders first
130sprintf(dirspec,"/Extra/%s",filename);
131fd=open (dirspec,0);
132if (fd>=0) goto success_fd;
133
134sprintf(dirspec,"bt(0,0)/Extra/%s",filename);
135fd=open (dirspec,0);
136if (fd>=0) goto success_fd;
137
138sprintf(dirspec, "%s", filename); // search current dir
139fd=open (dirspec,0);
140if (fd>=0) goto success_fd;
141
142sprintf(dirspec, "/%s", filename); // search root
143fd=open (dirspec,0);
144if (fd>=0) goto success_fd;
145
146// NOT FOUND:
147//verbose("ACPI Table not found: %s\n", filename);
148if (outDirspec) *outDirspec = "";
149first_time = false;
150return -1;
151// FOUND
152success_fd:
153first_time = false;
154if (outDirspec) *outDirspec = dirspec;
155return fd;
156}
157
158void *loadACPITable (const char * filename)
159{
160void *tableAddr;
161const char * dirspec=NULL;
162
163int fd = search_and_get_acpi_fd(filename, &dirspec);
164
165if (fd>=0)
166{
167tableAddr=(void*)AllocateKernelMemory(file_size (fd));
168if (tableAddr)
169{
170if (read (fd, tableAddr, file_size (fd))!=file_size (fd))
171{
172printf("Couldn't read table %s\n",dirspec);
173free (tableAddr);
174close (fd);
175return NULL;
176}
177
178DBG("Table %s read and stored at: %x\n", dirspec, tableAddr);
179close (fd);
180return tableAddr;
181}
182close (fd);
183printf("Couldn't allocate memory for table \n", dirspec);
184}
185//printf("Couldn't find table %s\n", filename);
186return NULL;
187}
188
189uint8_tacpi_cpu_count = 0;
190char* acpi_cpu_name[32];
191
192void get_acpi_cpu_names(unsigned char* dsdt, uint32_t length)
193{
194uint32_t i;
195
196for (i=0; i<length-7; i++)
197{
198if (dsdt[i] == 0x5B && dsdt[i+1] == 0x83) // ProcessorOP
199{
200uint32_t offset = i + 3 + (dsdt[i+2] >> 6);
201
202bool add_name = true;
203
204uint8_t j;
205
206for (j=0; j<4; j++)
207{
208char c = dsdt[offset+j];
209
210if (!aml_isvalidchar(c))
211{
212add_name = false;
213verbose("Invalid character found in ProcessorOP 0x%x!\n", c);
214break;
215}
216}
217
218if (add_name)
219{
220acpi_cpu_name[acpi_cpu_count] = malloc(4);
221memcpy(acpi_cpu_name[acpi_cpu_count], dsdt+offset, 4);
222i = offset + 5;
223
224verbose("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]);
225
226if (++acpi_cpu_count == 32) return;
227}
228}
229}
230}
231
232struct acpi_2_ssdt *generate_cst_ssdt(struct acpi_2_fadt* fadt)
233{
234char ssdt_header[] =
235{
2360x53, 0x53, 0x44, 0x54, 0xE7, 0x00, 0x00, 0x00, /* SSDT.... */
2370x01, 0x17, 0x50, 0x6D, 0x52, 0x65, 0x66, 0x41, /* ..PmRefA */
2380x43, 0x70, 0x75, 0x43, 0x73, 0x74, 0x00, 0x00, /* CpuCst.. */
2390x00, 0x10, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* ....INTL */
2400x31, 0x03, 0x10, 0x20 /* 1.._*/
241};
242
243char cstate_resource_template[] =
244{
2450x11, 0x14, 0x0A, 0x11, 0x82, 0x0C, 0x00, 0x7F,
2460x01, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
2470x00, 0x00, 0x00, 0x79, 0x00
248};
249
250if (Platform.CPU.Vendor != 0x756E6547) {
251verbose ("Not an Intel platform: C-States will not be generated !!!\n");
252return NULL;
253}
254
255if (fadt == NULL) {
256verbose ("FACP not exists: C-States will not be generated !!!\n");
257return NULL;
258}
259
260struct acpi_2_dsdt* dsdt = (void*)fadt->DSDT;
261
262if (dsdt == NULL) {
263verbose ("DSDT not found: C-States will not be generated !!!\n");
264return NULL;
265}
266
267if (acpi_cpu_count == 0)
268get_acpi_cpu_names((void*)dsdt, dsdt->Length);
269
270if (acpi_cpu_count > 0)
271{
272bool c2_enabled = fadt->C2_Latency < 100;
273bool c3_enabled = fadt->C3_Latency < 1000;
274bool c4_enabled = false;
275
276getBoolForKey(kEnableC4States, &c4_enabled, &bootInfo->bootConfig);
277
278unsigned char cstates_count = 1 + (c2_enabled ? 1 : 0) + (c3_enabled ? 1 : 0);
279
280struct aml_chunk* root = aml_create_node(NULL);
281aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header
282struct aml_chunk* scop = aml_add_scope(root, "\\_PR_");
283struct aml_chunk* name = aml_add_name(scop, "CST_");
284struct aml_chunk* pack = aml_add_package(name);
285aml_add_byte(pack, cstates_count);
286
287struct aml_chunk* tmpl = aml_add_package(pack);
288cstate_resource_template[11] = 0x00; // C1
289aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));
290aml_add_byte(tmpl, 0x01); // C1
291aml_add_byte(tmpl, 0x01); // Latency
292aml_add_word(tmpl, 0x03e8); // Power
293
294// C2
295if (c2_enabled)
296{
297tmpl = aml_add_package(pack);
298cstate_resource_template[11] = 0x10; // C2
299aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));
300aml_add_byte(tmpl, 0x02); // C2
301aml_add_byte(tmpl, fadt->C2_Latency);
302aml_add_word(tmpl, 0x01f4); // Power
303}
304// C4
305if (c4_enabled)
306{
307tmpl = aml_add_package(pack);
308cstate_resource_template[11] = 0x30; // C4
309aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));
310aml_add_byte(tmpl, 0x04); // C4
311aml_add_word(tmpl, fadt->C3_Latency / 2); // TODO: right latency for C4
312aml_add_byte(tmpl, 0xfa); // Power
313}
314else
315// C3
316if (c3_enabled)
317{
318tmpl = aml_add_package(pack);
319cstate_resource_template[11] = 0x20; // C3
320aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));
321aml_add_byte(tmpl, 0x03); // C3
322aml_add_word(tmpl, fadt->C3_Latency);
323aml_add_word(tmpl, 0x015e); // Power
324}
325
326
327// Aliaces
328int i;
329for (i = 0; i < acpi_cpu_count; i++)
330{
331char name[9];
332sprintf(name, "_PR_%c%c%c%c", acpi_cpu_name[i][0], acpi_cpu_name[i][1], acpi_cpu_name[i][2], acpi_cpu_name[i][3]);
333
334scop = aml_add_scope(root, name);
335aml_add_alias(scop, "CST_", "_CST");
336}
337
338aml_calculate_size(root);
339
340struct acpi_2_ssdt *ssdt = (struct acpi_2_ssdt *)AllocateKernelMemory(root->Size);
341
342aml_write_node(root, (void*)ssdt, 0);
343
344ssdt->Length = root->Size;
345ssdt->Checksum = 0;
346ssdt->Checksum = 256 - checksum8(ssdt, ssdt->Length);
347
348aml_destroy_node(root);
349
350//dumpPhysAddr("C-States SSDT content: ", ssdt, ssdt->Length);
351
352verbose ("SSDT with CPU C-States generated successfully\n");
353
354return ssdt;
355}
356else
357{
358verbose ("ACPI CPUs not found: C-States not generated !!!\n");
359}
360
361return NULL;
362}
363
364struct acpi_2_ssdt *generate_pss_ssdt(struct acpi_2_dsdt* dsdt)
365{
366char ssdt_header[] =
367{
3680x53, 0x53, 0x44, 0x54, 0x7E, 0x00, 0x00, 0x00, /* SSDT.... */
3690x01, 0x6A, 0x50, 0x6D, 0x52, 0x65, 0x66, 0x00, /* ..PmRef. */
3700x43, 0x70, 0x75, 0x50, 0x6D, 0x00, 0x00, 0x00, /* CpuPm... */
3710x00, 0x30, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* .0..INTL */
3720x31, 0x03, 0x10, 0x20,/* 1.._*/
373};
374
375if (Platform.CPU.Vendor != 0x756E6547) {
376verbose ("Not an Intel platform: P-States will not be generated !!!\n");
377return NULL;
378}
379
380if (!(Platform.CPU.Features & CPU_FEATURE_MSR)) {
381verbose ("Unsupported CPU: P-States will not be generated !!!\n");
382return NULL;
383}
384
385if (acpi_cpu_count == 0)
386get_acpi_cpu_names((void*)dsdt, dsdt->Length);
387
388if (acpi_cpu_count > 0)
389{
390
391struct p_state initial, maximum, minimum, p_states[32];
392uint8_t p_states_count = 0;
393
394// Retrieving P-States, ported from code by superhai (c)
395switch (Platform.CPU.Family) {
396case 0x06:
397{
398switch (Platform.CPU.Model)
399{
400case 0x0F: // Intel Core (65nm)
401case 0x17: // Intel Core (45nm)
402case 0x1C: // Intel Atom (45nm)
403{
404bool cpu_dynamic_fsb = false;
405
406if (rdmsr64(MSR_IA32_EXT_CONFIG) & (1 << 27))
407{
408wrmsr64(MSR_IA32_EXT_CONFIG, (rdmsr64(MSR_IA32_EXT_CONFIG) | (1 << 28)));
409delay(1);
410cpu_dynamic_fsb = rdmsr64(MSR_IA32_EXT_CONFIG) & (1 << 28);
411}
412
413bool cpu_noninteger_bus_ratio = (rdmsr64(MSR_IA32_PERF_STATUS) & (1ULL << 46));
414
415initial.Control = rdmsr64(MSR_IA32_PERF_STATUS);
416
417maximum.Control = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 32) & 0x1F3F) | (0x4000 * cpu_noninteger_bus_ratio);
418maximum.CID = ((maximum.FID & 0x1F) << 1) | cpu_noninteger_bus_ratio;
419
420minimum.FID = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 24) & 0x1F) | (0x80 * cpu_dynamic_fsb);
421minimum.VID = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 48) & 0x3F);
422
423if (minimum.FID == 0)
424{
425uint64_t msr;
426uint8_t i;
427// Probe for lowest fid
428for (i = maximum.FID; i >= 0x6; i--)
429{
430msr = rdmsr64(MSR_IA32_PERF_CONTROL);
431wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (i << 8) | minimum.VID);
432intel_waitforsts();
433minimum.FID = (rdmsr64(MSR_IA32_PERF_STATUS) >> 8) & 0x1F;
434delay(1);
435}
436
437msr = rdmsr64(MSR_IA32_PERF_CONTROL);
438wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (maximum.FID << 8) | maximum.VID);
439intel_waitforsts();
440}
441
442if (minimum.VID == maximum.VID)
443{
444uint64_t msr;
445uint8_t i;
446// Probe for lowest vid
447for (i = maximum.VID; i > 0xA; i--)
448{
449msr = rdmsr64(MSR_IA32_PERF_CONTROL);
450wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (minimum.FID << 8) | i);
451intel_waitforsts();
452minimum.VID = rdmsr64(MSR_IA32_PERF_STATUS) & 0x3F;
453delay(1);
454}
455
456msr = rdmsr64(MSR_IA32_PERF_CONTROL);
457wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (maximum.FID << 8) | maximum.VID);
458intel_waitforsts();
459}
460
461minimum.CID = ((minimum.FID & 0x1F) << 1) >> cpu_dynamic_fsb;
462
463// Sanity check
464if (maximum.CID < minimum.CID)
465{
466DBG("Insane FID values!");
467p_states_count = 1;
468}
469else
470{
471// Finalize P-States
472// Find how many P-States machine supports
473p_states_count = maximum.CID - minimum.CID + 1;
474
475if (p_states_count > 32)
476p_states_count = 32;
477
478uint8_t vidstep;
479uint8_t i = 0, u, invalid = 0;
480
481vidstep = ((maximum.VID << 2) - (minimum.VID << 2)) / (p_states_count - 1);
482
483for (u = 0; u < p_states_count; u++)
484{
485i = u - invalid;
486
487p_states[i].CID = maximum.CID - u;
488p_states[i].FID = (p_states[i].CID >> 1);
489
490if (p_states[i].FID < 0x6)
491{
492if (cpu_dynamic_fsb)
493p_states[i].FID = (p_states[i].FID << 1) | 0x80;
494}
495else if (cpu_noninteger_bus_ratio)
496{
497p_states[i].FID = p_states[i].FID | (0x40 * (p_states[i].CID & 0x1));
498}
499
500if (i && p_states[i].FID == p_states[i-1].FID)
501invalid++;
502
503p_states[i].VID = ((maximum.VID << 2) - (vidstep * u)) >> 2;
504
505uint32_t multiplier = p_states[i].FID & 0x1f;// = 0x08
506bool half = p_states[i].FID & 0x40;// = 0x01
507bool dfsb = p_states[i].FID & 0x80;// = 0x00
508uint32_t fsb = Platform.CPU.FSBFrequency / 1000000; // = 400
509uint32_t halffsb = (fsb + 1) >> 1;// = 200
510uint32_t frequency = (multiplier * fsb);// = 3200
511
512p_states[i].Frequency = (frequency + (half * halffsb)) >> dfsb;// = 3200 + 200 = 3400
513}
514
515p_states_count -= invalid;
516}
517} break;
518case 0x1A: // Intel Core i7 LGA1366 (45nm)
519case 0x1E: // Intel Core i5, i7 LGA1156 (45nm)
520case 0x1F:
521case 0x25: // Intel Core i3, i5, i7 LGA1156 (32nm)
522case 0x2C: // Intel Core i7 LGA1366 (32nm) 6 Core
523case 0x2F:
524default:
525verbose ("Unsupported CPU: P-States not generated !!!\n");
526break;
527}
528}
529}
530
531// Generating SSDT
532
533if (p_states_count > 0)
534{
535int i;
536
537struct aml_chunk* root = aml_create_node(NULL);
538aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header
539struct aml_chunk* scop = aml_add_scope(root, "\\_PR_");
540struct aml_chunk* name = aml_add_name(scop, "PSS_");
541struct aml_chunk* pack = aml_add_package(name);
542
543for (i = 0; i < p_states_count; i++)
544{
545struct aml_chunk* pstt = aml_add_package(pack);
546
547aml_add_dword(pstt, p_states[i].Frequency);
548aml_add_dword(pstt, 0x00000000); // Power
549aml_add_dword(pstt, 0x0000000A); // Latency
550aml_add_dword(pstt, 0x0000000A); // Latency
551aml_add_dword(pstt, p_states[i].Control);
552aml_add_dword(pstt, i+1); // Status
553}
554
555// Add aliaces
556for (i = 0; i < acpi_cpu_count; i++)
557{
558char name[9];
559sprintf(name, "_PR_%c%c%c%c", acpi_cpu_name[i][0], acpi_cpu_name[i][1], acpi_cpu_name[i][2], acpi_cpu_name[i][3]);
560
561scop = aml_add_scope(root, name);
562aml_add_alias(scop, "PSS_", "_PSS");
563}
564
565aml_calculate_size(root);
566
567struct acpi_2_ssdt *ssdt = (struct acpi_2_ssdt *)AllocateKernelMemory(root->Size);
568
569aml_write_node(root, (void*)ssdt, 0);
570
571ssdt->Length = root->Size;
572ssdt->Checksum = 0;
573ssdt->Checksum = 256 - checksum8(ssdt, ssdt->Length);
574
575aml_destroy_node(root);
576
577//dumpPhysAddr("P-States SSDT content: ", ssdt, ssdt->Length);
578
579verbose ("SSDT with CPU P-States generated successfully\n");
580
581return ssdt;
582}
583}
584else
585{
586verbose ("ACPI CPUs not found: P-States not generated !!!\n");
587}
588
589return NULL;
590}
591
592struct acpi_2_fadt *patch_fadt(struct acpi_2_fadt *fadt, struct acpi_2_dsdt *new_dsdt)
593{
594extern void setupSystemType();
595
596struct acpi_2_fadt *fadt_mod;
597bool fadt_rev2_needed = false;
598bool fix_restart;
599const char * value;
600
601// Restart Fix
602if (Platform.CPU.Vendor == 0x756E6547) // Intel
603{
604fix_restart = false; //Azi: think this should be false by default; i never needed any.
605// On the other hand, i could use a shutdown fix now and then :)
606getBoolForKey(kRestartFix, &fix_restart, &bootInfo->bootConfig);
607}
608else
609{
610verbose ("Not an Intel platform: Restart Fix not applied !!!\n");
611fix_restart = false;
612}
613
614if (fix_restart) fadt_rev2_needed = true;
615
616// Allocate new fadt table
617if (fadt->Length < 0x84 && fadt_rev2_needed)
618{
619fadt_mod=(struct acpi_2_fadt *)AllocateKernelMemory(0x84);
620memcpy(fadt_mod, fadt, fadt->Length);
621fadt_mod->Length = 0x84;
622fadt_mod->Revision = 0x02; // FADT rev 2 (ACPI 1.0B MS extensions)
623}
624else
625{
626fadt_mod=(struct acpi_2_fadt *)AllocateKernelMemory(fadt->Length);
627memcpy(fadt_mod, fadt, fadt->Length);
628}
629// Determine system type / PM_Model
630if ( (value=getStringForKey(kSystemType, &bootInfo->bootConfig))!=NULL)
631{
632if (Platform.Type > 6)
633{
634if(fadt_mod->PM_Profile<=6)
635Platform.Type = fadt_mod->PM_Profile; // get the fadt if correct
636else
637Platform.Type = 1; // Set a fixed value (Desktop)
638verbose("Error: system-type must be 0..6. Defaulting to %d !\n", Platform.Type);
639}
640else
641Platform.Type = (unsigned char) strtoul(value, NULL, 10);
642}
643// Set PM_Profile from System-type only if user wanted this value to be forced
644if (fadt_mod->PM_Profile != Platform.Type)
645{
646 if (value)
647{ // user has overriden the SystemType so take care of it in FACP
648verbose("FADT: changing PM_Profile from 0x%02x to 0x%02x\n", fadt_mod->PM_Profile, Platform.Type);
649fadt_mod->PM_Profile = Platform.Type;
650 }
651 else
652 { // PM_Profile has a different value and no override has been set, so reflect the user value to ioregs
653Platform.Type = fadt_mod->PM_Profile <= 6 ? fadt_mod->PM_Profile : 1;
654 }
655}
656// We now have to write the systemm-type in ioregs: we cannot do it before in setupDeviceTree()
657// because we need to take care of facp original content, if it is correct.
658setupSystemType();
659
660// Patch FADT to fix restart
661if (fix_restart)
662{
663fadt_mod->Flags|= 0x400;
664fadt_mod->Reset_SpaceID= 0x01; // System I/O
665fadt_mod->Reset_BitWidth= 0x08; // 1 byte
666fadt_mod->Reset_BitOffset= 0x00; // Offset 0
667fadt_mod->Reset_AccessWidth= 0x01; // Byte access
668fadt_mod->Reset_Address= 0x0cf9; // Address of the register
669fadt_mod->Reset_Value= 0x06; // Value to write to reset the system
670verbose("FADT: Restart Fix applied!\n");
671}
672
673// Patch DSDT Address if we have loaded DSDT.aml
674if(new_dsdt)
675{
676DBG("DSDT: Old @%x,%x, ",fadt_mod->DSDT,fadt_mod->X_DSDT);
677
678fadt_mod->DSDT=(uint32_t)new_dsdt;
679if ((uint32_t)(&(fadt_mod->X_DSDT))-(uint32_t)fadt_mod+8<=fadt_mod->Length)
680fadt_mod->X_DSDT=(uint32_t)new_dsdt;
681
682DBG("New @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT);
683
684verbose("FADT: Using custom DSDT!\n");
685}
686
687// Correct the checksum
688fadt_mod->Checksum=0;
689fadt_mod->Checksum=256-checksum8(fadt_mod,fadt_mod->Length);
690
691return fadt_mod;
692}
693
694/* Setup ACPI without replacing DSDT. - not needed atm.
695int setupAcpiNoMod()
696{
697//addConfigurationTable(&gEfiAcpiTableGuid, getAddressOfAcpiTable(), "ACPI");
698//addConfigurationTable(&gEfiAcpi20TableGuid, getAddressOfAcpi20Table(), "ACPI_20");
699// XXX aserebln why uint32 cast if pointer is uint64 ?
700acpi10_p = (uint32_t)getAddressOfAcpiTable();
701acpi20_p = (uint32_t)getAddressOfAcpi20Table();
702addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI");
703if(acpi20_p) addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20");
704return 1;
705}*/
706
707/* Setup ACPI. Replace DSDT if DSDT.aml is found */
708int setupAcpi(void)
709{
710int version;
711void *new_dsdt;
712
713// Load replacement DSDT
714new_dsdt=loadACPITable("DSDT.aml");
715// Mozodojo: going to patch FACP and load SSDT's even if DSDT.aml is not present
716/*if (!new_dsdt)
717 {
718 return setupAcpiNoMod();
719 }*/
720
721// Mozodojo: Load additional SSDTs
722struct acpi_2_ssdt *new_ssdt[32]; // 30 + 2 additional tables for pss & cst
723int ssdt_count=0;
724
725// SSDT Options
726bool drop_ssdt=false, generate_pstates=false, generate_cstates=false;
727
728getBoolForKey(kDropSSDT, &drop_ssdt, &bootInfo->bootConfig);
729getBoolForKey(kGeneratePStates, &generate_pstates, &bootInfo->bootConfig);
730getBoolForKey(kGenerateCStates, &generate_cstates, &bootInfo->bootConfig);
731
732{
733int i;
734
735for (i=0; i<30; i++)
736{
737char filename[512];
738
739sprintf(filename, i>0?"SSDT-%d.aml":"SSDT.aml", i);
740
741if(new_ssdt[ssdt_count] = loadACPITable(filename))
742{
743ssdt_count++;
744}
745else
746{
747break;
748}
749}
750}
751
752// Do the same procedure for both versions of ACPI
753for (version=0; version<2; version++) {
754struct acpi_2_rsdp *rsdp, *rsdp_mod;
755struct acpi_2_rsdt *rsdt, *rsdt_mod;
756int rsdplength;
757
758// Find original rsdp
759rsdp=(struct acpi_2_rsdp *)(version?getAddressOfAcpi20Table():getAddressOfAcpiTable());
760if (!rsdp)
761{
762DBG("No ACPI version %d found. Ignoring\n", version+1);
763if (version)
764addConfigurationTable(&gEfiAcpi20TableGuid, NULL, "ACPI_20");
765else
766addConfigurationTable(&gEfiAcpiTableGuid, NULL, "ACPI");
767continue;
768}
769rsdplength=version?rsdp->Length:20;
770
771DBG("RSDP version %d found @%x. Length=%d\n",version+1,rsdp,rsdplength);
772
773/* FIXME: no check that memory allocation succeeded
774 * Copy and patch RSDP,RSDT, XSDT and FADT
775 * For more info see ACPI Specification pages 110 and following
776 */
777
778rsdp_mod=(struct acpi_2_rsdp *) AllocateKernelMemory(rsdplength);
779memcpy(rsdp_mod, rsdp, rsdplength);
780rsdt=(struct acpi_2_rsdt *)(rsdp->RsdtAddress);
781
782DBG("RSDT @%x, Length %d\n",rsdt, rsdt->Length);
783
784if (rsdt && (uint32_t)rsdt !=0xffffffff && rsdt->Length<0x10000)
785{
786uint32_t *rsdt_entries;
787int rsdt_entries_num;
788int dropoffset=0, i;
789
790// mozo: using malloc cos I didn't found how to free already allocated kernel memory
791rsdt_mod=(struct acpi_2_rsdt *)malloc(rsdt->Length);
792memcpy (rsdt_mod, rsdt, rsdt->Length);
793rsdp_mod->RsdtAddress=(uint32_t)rsdt_mod;
794rsdt_entries_num=(rsdt_mod->Length-sizeof(struct acpi_2_rsdt))/4;
795rsdt_entries=(uint32_t *)(rsdt_mod+1);
796for (i=0;i<rsdt_entries_num;i++)
797{
798char *table=(char *)(rsdt_entries[i]);
799if (!table)
800continue;
801
802DBG("TABLE %c%c%c%c,",table[0],table[1],table[2],table[3]);
803
804rsdt_entries[i-dropoffset]=rsdt_entries[i];
805
806if (drop_ssdt && tableSign(table, "SSDT"))
807{
808dropoffset++;
809continue;
810}
811if (tableSign(table, "DSDT"))
812{
813DBG("DSDT found\n");
814
815if(new_dsdt)
816rsdt_entries[i-dropoffset]=(uint32_t)new_dsdt;
817
818continue;
819}
820if (tableSign(table, "FACP"))
821{
822struct acpi_2_fadt *fadt, *fadt_mod;
823fadt=(struct acpi_2_fadt *)rsdt_entries[i];
824
825DBG("FADT found @%x, Length %d\n",fadt, fadt->Length);
826
827if (!fadt || (uint32_t)fadt == 0xffffffff || fadt->Length>0x10000)
828{
829printf("FADT incorrect. Not modified\n");
830continue;
831}
832
833fadt_mod = patch_fadt(fadt, new_dsdt);
834rsdt_entries[i-dropoffset]=(uint32_t)fadt_mod;
835
836// Generate _CST SSDT
837if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))
838{
839generate_cstates = false; // Generate SSDT only once!
840ssdt_count++;
841}
842
843// Generating _PSS SSDT
844if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))
845{
846generate_pstates = false; // Generate SSDT only once!
847ssdt_count++;
848}
849
850continue;
851}
852}
853DBG("\n");
854
855// Allocate rsdt in Kernel memory area
856rsdt_mod->Length += 4*ssdt_count - 4*dropoffset;
857struct acpi_2_rsdt *rsdt_copy = (struct acpi_2_rsdt *)AllocateKernelMemory(rsdt_mod->Length);
858memcpy (rsdt_copy, rsdt_mod, rsdt_mod->Length);
859free(rsdt_mod); rsdt_mod = rsdt_copy;
860rsdp_mod->RsdtAddress=(uint32_t)rsdt_mod;
861rsdt_entries_num=(rsdt_mod->Length-sizeof(struct acpi_2_rsdt))/4;
862rsdt_entries=(uint32_t *)(rsdt_mod+1);
863
864// Mozodojo: Insert additional SSDTs into RSDT
865if(ssdt_count>0)
866{
867int j;
868
869for (j=0; j<ssdt_count; j++)
870rsdt_entries[i-dropoffset+j]=(uint32_t)new_ssdt[j];
871
872verbose("RSDT: Added %d SSDT table(s)\n", ssdt_count);
873}
874
875// Correct the checksum of RSDT
876DBG("RSDT: Original checksum %d, ", rsdt_mod->Checksum);
877
878rsdt_mod->Checksum=0;
879rsdt_mod->Checksum=256-checksum8(rsdt_mod,rsdt_mod->Length);
880
881DBG("New checksum %d at %x\n", rsdt_mod->Checksum,rsdt_mod);
882}
883else
884{
885rsdp_mod->RsdtAddress=0;
886printf("RSDT not found or RSDT incorrect\n");
887}
888
889if (version)
890{
891struct acpi_2_xsdt *xsdt, *xsdt_mod;
892
893// FIXME: handle 64-bit address correctly
894
895xsdt=(struct acpi_2_xsdt*) ((uint32_t)rsdp->XsdtAddress);
896DBG("XSDT @%x;%x, Length=%d\n", (uint32_t)(rsdp->XsdtAddress>>32),(uint32_t)rsdp->XsdtAddress,
897xsdt->Length);
898if (xsdt && (uint64_t)rsdp->XsdtAddress<0xffffffff && xsdt->Length<0x10000)
899{
900uint64_t *xsdt_entries;
901int xsdt_entries_num, i;
902int dropoffset=0;
903
904// mozo: using malloc cos I didn't found how to free already allocated kernel memory
905xsdt_mod=(struct acpi_2_xsdt*)malloc(xsdt->Length);
906memcpy(xsdt_mod, xsdt, xsdt->Length);
907rsdp_mod->XsdtAddress=(uint32_t)xsdt_mod;
908xsdt_entries_num=(xsdt_mod->Length-sizeof(struct acpi_2_xsdt))/8;
909xsdt_entries=(uint64_t *)(xsdt_mod+1);
910for (i=0;i<xsdt_entries_num;i++)
911{
912char *table=(char *)((uint32_t)(xsdt_entries[i]));
913if (!table)
914continue;
915
916xsdt_entries[i-dropoffset]=xsdt_entries[i];
917
918if (drop_ssdt && tableSign(table, "SSDT"))
919{
920dropoffset++;
921continue;
922}
923if (tableSign(table, "DSDT"))
924{
925DBG("DSDT found\n");
926
927if (new_dsdt)
928xsdt_entries[i-dropoffset]=(uint32_t)new_dsdt;
929
930DBG("TABLE %c%c%c%c@%x,",table[0],table[1],table[2],table[3],xsdt_entries[i]);
931
932continue;
933}
934if (tableSign(table, "FACP"))
935{
936struct acpi_2_fadt *fadt, *fadt_mod;
937fadt=(struct acpi_2_fadt *)(uint32_t)xsdt_entries[i];
938
939DBG("FADT found @%x,%x, Length %d\n",(uint32_t)(xsdt_entries[i]>>32),fadt,
940fadt->Length);
941
942if (!fadt || (uint64_t)xsdt_entries[i] >= 0xffffffff || fadt->Length>0x10000)
943{
944verbose("FADT incorrect or after 4GB. Dropping XSDT\n");
945goto drop_xsdt;
946}
947
948fadt_mod = patch_fadt(fadt, new_dsdt);
949xsdt_entries[i-dropoffset]=(uint32_t)fadt_mod;
950
951DBG("TABLE %c%c%c%c@%x,",table[0],table[1],table[2],table[3],xsdt_entries[i]);
952
953// Generate _CST SSDT
954if (generate_cstates && (new_ssdt[ssdt_count] = generate_cst_ssdt(fadt_mod)))
955{
956generate_cstates = false; // Generate SSDT only once!
957ssdt_count++;
958}
959
960// Generating _PSS SSDT
961if (generate_pstates && (new_ssdt[ssdt_count] = generate_pss_ssdt((void*)fadt_mod->DSDT)))
962{
963generate_pstates = false; // Generate SSDT only once!
964ssdt_count++;
965}
966
967continue;
968}
969
970DBG("TABLE %c%c%c%c@%x,",table[0],table[1],table[2],table[3],xsdt_entries[i]);
971
972}
973
974// Allocate xsdt in Kernel memory area
975xsdt_mod->Length += 8*ssdt_count - 8*dropoffset;
976struct acpi_2_xsdt *xsdt_copy = (struct acpi_2_xsdt *)AllocateKernelMemory(xsdt_mod->Length);
977memcpy(xsdt_copy, xsdt_mod, xsdt_mod->Length);
978free(xsdt_mod); xsdt_mod = xsdt_copy;
979rsdp_mod->XsdtAddress=(uint32_t)xsdt_mod;
980xsdt_entries_num=(xsdt_mod->Length-sizeof(struct acpi_2_xsdt))/8;
981xsdt_entries=(uint64_t *)(xsdt_mod+1);
982
983// Mozodojo: Insert additional SSDTs into XSDT
984if(ssdt_count>0)
985{
986int j;
987
988for (j=0; j<ssdt_count; j++)
989xsdt_entries[i-dropoffset+j]=(uint32_t)new_ssdt[j];
990
991verbose("Added %d SSDT table(s) into XSDT\n", ssdt_count);
992}
993
994// Correct the checksum of XSDT
995xsdt_mod->Checksum=0;
996xsdt_mod->Checksum=256-checksum8(xsdt_mod,xsdt_mod->Length);
997}
998else
999{
1000drop_xsdt:
1001
1002DBG("About to drop XSDT\n");
1003
1004/*FIXME: Now we just hope that if MacOS doesn't find XSDT it reverts to RSDT.
1005 * A Better strategy would be to generate
1006 */
1007
1008rsdp_mod->XsdtAddress=0xffffffffffffffffLL;
1009verbose("XSDT not found or XSDT incorrect\n");
1010}
1011}
1012
1013// Correct the checksum of RSDP
1014
1015DBG("RSDP: Original checksum %d, ", rsdp_mod->Checksum);
1016
1017rsdp_mod->Checksum=0;
1018rsdp_mod->Checksum=256-checksum8(rsdp_mod,20);
1019
1020DBG("New checksum %d\n", rsdp_mod->Checksum);
1021
1022if (version)
1023{
1024DBG("RSDP: Original extended checksum %d", rsdp_mod->ExtendedChecksum);
1025
1026rsdp_mod->ExtendedChecksum=0;
1027rsdp_mod->ExtendedChecksum=256-checksum8(rsdp_mod,rsdp_mod->Length);
1028
1029DBG("New extended checksum %d\n", rsdp_mod->ExtendedChecksum);
1030
1031}
1032
1033//verbose("Patched ACPI version %d DSDT\n", version+1);
1034if (version)
1035{
1036/* XXX aserebln why uint32 cast if pointer is uint64 ? */
1037acpi20_p = (uint32_t)rsdp_mod;
1038addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20");
1039}
1040else
1041{
1042/* XXX aserebln why uint32 cast if pointer is uint64 ? */
1043acpi10_p = (uint32_t)rsdp_mod;
1044addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI");
1045}
1046}
1047#if DEBUG_ACPI
1048printf("Press a key to continue... (DEBUG_ACPI)\n");
1049getc();
1050#endif
1051return 1;
1052}
1053

Archive Download this file

Revision: 321