Chameleon

Chameleon Svn Source Tree

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

Archive Download this file

Revision: 243