diff options
Diffstat (limited to 'drivers/acpi/tables.c')
-rw-r--r-- | drivers/acpi/tables.c | 396 |
1 files changed, 16 insertions, 380 deletions
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c index 5bb143151169..962ff29fbf07 100644 --- a/drivers/acpi/tables.c +++ b/drivers/acpi/tables.c | |||
@@ -38,71 +38,11 @@ | |||
38 | 38 | ||
39 | #define ACPI_MAX_TABLES 128 | 39 | #define ACPI_MAX_TABLES 128 |
40 | 40 | ||
41 | static char *acpi_table_signatures[ACPI_TABLE_COUNT] = { | ||
42 | [ACPI_TABLE_UNKNOWN] = "????", | ||
43 | [ACPI_APIC] = "APIC", | ||
44 | [ACPI_BOOT] = "BOOT", | ||
45 | [ACPI_DBGP] = "DBGP", | ||
46 | [ACPI_DSDT] = "DSDT", | ||
47 | [ACPI_ECDT] = "ECDT", | ||
48 | [ACPI_ETDT] = "ETDT", | ||
49 | [ACPI_FADT] = "FACP", | ||
50 | [ACPI_FACS] = "FACS", | ||
51 | [ACPI_OEMX] = "OEM", | ||
52 | [ACPI_PSDT] = "PSDT", | ||
53 | [ACPI_SBST] = "SBST", | ||
54 | [ACPI_SLIT] = "SLIT", | ||
55 | [ACPI_SPCR] = "SPCR", | ||
56 | [ACPI_SRAT] = "SRAT", | ||
57 | [ACPI_SSDT] = "SSDT", | ||
58 | [ACPI_SPMI] = "SPMI", | ||
59 | [ACPI_HPET] = "HPET", | ||
60 | [ACPI_MCFG] = "MCFG", | ||
61 | }; | ||
62 | |||
63 | static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; | 41 | static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; |
64 | static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; | 42 | static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; |
65 | 43 | ||
66 | /* System Description Table (RSDT/XSDT) */ | ||
67 | struct acpi_table_sdt { | ||
68 | unsigned long pa; | ||
69 | enum acpi_table_id id; | ||
70 | unsigned long size; | ||
71 | } __attribute__ ((packed)); | ||
72 | |||
73 | static unsigned long sdt_pa; /* Physical Address */ | ||
74 | static unsigned long sdt_count; /* Table count */ | ||
75 | |||
76 | static struct acpi_table_sdt sdt_entry[ACPI_MAX_TABLES] __initdata; | ||
77 | static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; | 44 | static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; |
78 | 45 | ||
79 | void acpi_table_print(struct acpi_table_header *header, unsigned long phys_addr) | ||
80 | { | ||
81 | char *name = NULL; | ||
82 | |||
83 | if (!header) | ||
84 | return; | ||
85 | |||
86 | /* Some table signatures aren't good table names */ | ||
87 | |||
88 | if (!strncmp((char *)&header->signature, | ||
89 | acpi_table_signatures[ACPI_APIC], | ||
90 | sizeof(header->signature))) { | ||
91 | name = "MADT"; | ||
92 | } else if (!strncmp((char *)&header->signature, | ||
93 | acpi_table_signatures[ACPI_FADT], | ||
94 | sizeof(header->signature))) { | ||
95 | name = "FADT"; | ||
96 | } else | ||
97 | name = header->signature; | ||
98 | |||
99 | printk(KERN_DEBUG PREFIX | ||
100 | "%.4s (v%3.3d %6.6s %8.8s 0x%08x %.4s 0x%08x) @ 0x%p\n", name, | ||
101 | header->revision, header->oem_id, header->oem_table_id, | ||
102 | header->oem_revision, header->asl_compiler_id, | ||
103 | header->asl_compiler_revision, (void *)phys_addr); | ||
104 | } | ||
105 | |||
106 | void acpi_table_print_madt_entry(acpi_table_entry_header * header) | 46 | void acpi_table_print_madt_entry(acpi_table_entry_header * header) |
107 | { | 47 | { |
108 | if (!header) | 48 | if (!header) |
@@ -226,123 +166,32 @@ void acpi_table_print_madt_entry(acpi_table_entry_header * header) | |||
226 | } | 166 | } |
227 | } | 167 | } |
228 | 168 | ||
229 | static int | ||
230 | acpi_table_compute_checksum(void *table_pointer, unsigned long length) | ||
231 | { | ||
232 | u8 *p = table_pointer; | ||
233 | unsigned long remains = length; | ||
234 | unsigned long sum = 0; | ||
235 | |||
236 | if (!p || !length) | ||
237 | return -EINVAL; | ||
238 | |||
239 | while (remains--) | ||
240 | sum += *p++; | ||
241 | |||
242 | return (sum & 0xFF); | ||
243 | } | ||
244 | |||
245 | /* | ||
246 | * acpi_get_table_header_early() | ||
247 | * for acpi_blacklisted(), acpi_table_get_sdt() | ||
248 | */ | ||
249 | int __init | ||
250 | acpi_get_table_header_early(enum acpi_table_id id, | ||
251 | struct acpi_table_header **header) | ||
252 | { | ||
253 | unsigned int i; | ||
254 | enum acpi_table_id temp_id; | ||
255 | |||
256 | /* DSDT is different from the rest */ | ||
257 | if (id == ACPI_DSDT) | ||
258 | temp_id = ACPI_FADT; | ||
259 | else | ||
260 | temp_id = id; | ||
261 | |||
262 | /* Locate the table. */ | ||
263 | |||
264 | for (i = 0; i < sdt_count; i++) { | ||
265 | if (sdt_entry[i].id != temp_id) | ||
266 | continue; | ||
267 | *header = (void *) | ||
268 | __acpi_map_table(sdt_entry[i].pa, sdt_entry[i].size); | ||
269 | if (!*header) { | ||
270 | printk(KERN_WARNING PREFIX "Unable to map %s\n", | ||
271 | acpi_table_signatures[temp_id]); | ||
272 | return -ENODEV; | ||
273 | } | ||
274 | break; | ||
275 | } | ||
276 | |||
277 | if (!*header) { | ||
278 | printk(KERN_WARNING PREFIX "%s not present\n", | ||
279 | acpi_table_signatures[id]); | ||
280 | return -ENODEV; | ||
281 | } | ||
282 | |||
283 | /* Map the DSDT header via the pointer in the FADT */ | ||
284 | if (id == ACPI_DSDT) { | ||
285 | struct fadt_descriptor *fadt = | ||
286 | (struct fadt_descriptor *)*header; | ||
287 | |||
288 | if (fadt->header.revision == 3 && fadt->Xdsdt) { | ||
289 | *header = (void *)__acpi_map_table(fadt->Xdsdt, | ||
290 | sizeof(struct | ||
291 | acpi_table_header)); | ||
292 | } else if (fadt->dsdt) { | ||
293 | *header = (void *)__acpi_map_table(fadt->dsdt, | ||
294 | sizeof(struct | ||
295 | acpi_table_header)); | ||
296 | } else | ||
297 | *header = NULL; | ||
298 | |||
299 | if (!*header) { | ||
300 | printk(KERN_WARNING PREFIX "Unable to map DSDT\n"); | ||
301 | return -ENODEV; | ||
302 | } | ||
303 | } | ||
304 | |||
305 | return 0; | ||
306 | } | ||
307 | 169 | ||
308 | int __init | 170 | int __init |
309 | acpi_table_parse_madt_family(enum acpi_table_id id, | 171 | acpi_table_parse_madt_family(char *id, |
310 | unsigned long madt_size, | 172 | unsigned long madt_size, |
311 | int entry_id, | 173 | int entry_id, |
312 | acpi_madt_entry_handler handler, | 174 | acpi_madt_entry_handler handler, |
313 | unsigned int max_entries) | 175 | unsigned int max_entries) |
314 | { | 176 | { |
315 | void *madt = NULL; | 177 | struct acpi_table_header *madt = NULL; |
316 | acpi_table_entry_header *entry; | 178 | acpi_table_entry_header *entry; |
317 | unsigned int count = 0; | 179 | unsigned int count = 0; |
318 | unsigned long madt_end; | 180 | unsigned long madt_end; |
319 | unsigned int i; | ||
320 | 181 | ||
321 | if (!handler) | 182 | if (!handler) |
322 | return -EINVAL; | 183 | return -EINVAL; |
323 | 184 | ||
324 | /* Locate the MADT (if exists). There should only be one. */ | 185 | /* Locate the MADT (if exists). There should only be one. */ |
325 | 186 | ||
326 | for (i = 0; i < sdt_count; i++) { | 187 | acpi_get_table(id, 0, &madt); |
327 | if (sdt_entry[i].id != id) | ||
328 | continue; | ||
329 | madt = (void *) | ||
330 | __acpi_map_table(sdt_entry[i].pa, sdt_entry[i].size); | ||
331 | if (!madt) { | ||
332 | printk(KERN_WARNING PREFIX "Unable to map %s\n", | ||
333 | acpi_table_signatures[id]); | ||
334 | return -ENODEV; | ||
335 | } | ||
336 | break; | ||
337 | } | ||
338 | 188 | ||
339 | if (!madt) { | 189 | if (!madt) { |
340 | printk(KERN_WARNING PREFIX "%s not present\n", | 190 | printk(KERN_WARNING PREFIX "%4.4s not present\n", id); |
341 | acpi_table_signatures[id]); | ||
342 | return -ENODEV; | 191 | return -ENODEV; |
343 | } | 192 | } |
344 | 193 | ||
345 | madt_end = (unsigned long)madt + sdt_entry[i].size; | 194 | madt_end = (unsigned long)madt + madt->length; |
346 | 195 | ||
347 | /* Parse all entries looking for a match. */ | 196 | /* Parse all entries looking for a match. */ |
348 | 197 | ||
@@ -360,9 +209,8 @@ acpi_table_parse_madt_family(enum acpi_table_id id, | |||
360 | ((unsigned long)entry + entry->length); | 209 | ((unsigned long)entry + entry->length); |
361 | } | 210 | } |
362 | if (max_entries && count > max_entries) { | 211 | if (max_entries && count > max_entries) { |
363 | printk(KERN_WARNING PREFIX "[%s:0x%02x] ignored %i entries of " | 212 | printk(KERN_WARNING PREFIX "[%4.4s:0x%02x] ignored %i entries of " |
364 | "%i found\n", acpi_table_signatures[id], entry_id, | 213 | "%i found\n", id, entry_id, count - max_entries, count); |
365 | count - max_entries, count); | ||
366 | } | 214 | } |
367 | 215 | ||
368 | return count; | 216 | return count; |
@@ -372,195 +220,24 @@ int __init | |||
372 | acpi_table_parse_madt(enum acpi_madt_entry_id id, | 220 | acpi_table_parse_madt(enum acpi_madt_entry_id id, |
373 | acpi_madt_entry_handler handler, unsigned int max_entries) | 221 | acpi_madt_entry_handler handler, unsigned int max_entries) |
374 | { | 222 | { |
375 | return acpi_table_parse_madt_family(ACPI_APIC, | 223 | return acpi_table_parse_madt_family("APIC", |
376 | sizeof(struct acpi_table_madt), id, | 224 | sizeof(struct acpi_table_madt), id, |
377 | handler, max_entries); | 225 | handler, max_entries); |
378 | } | 226 | } |
379 | 227 | ||
380 | int __init acpi_table_parse(enum acpi_table_id id, acpi_table_handler handler) | 228 | int __init acpi_table_parse(char *id, acpi_table_handler handler) |
381 | { | 229 | { |
382 | int count = 0; | 230 | struct acpi_table_header *table = NULL; |
383 | unsigned int i = 0; | ||
384 | 231 | ||
385 | if (!handler) | 232 | if (!handler) |
386 | return -EINVAL; | 233 | return -EINVAL; |
387 | 234 | ||
388 | for (i = 0; i < sdt_count; i++) { | 235 | acpi_get_table(id, 0, &table); |
389 | if (sdt_entry[i].id != id) | 236 | if (table) { |
390 | continue; | 237 | handler(table); |
391 | count++; | 238 | return 1; |
392 | if (count == 1) | 239 | } else |
393 | handler(sdt_entry[i].pa, sdt_entry[i].size); | 240 | return 0; |
394 | |||
395 | else | ||
396 | printk(KERN_WARNING PREFIX | ||
397 | "%d duplicate %s table ignored.\n", count, | ||
398 | acpi_table_signatures[id]); | ||
399 | } | ||
400 | |||
401 | return count; | ||
402 | } | ||
403 | |||
404 | static int __init acpi_table_get_sdt(struct acpi_table_rsdp *rsdp) | ||
405 | { | ||
406 | struct acpi_table_header *header = NULL; | ||
407 | unsigned int i, id = 0; | ||
408 | |||
409 | if (!rsdp) | ||
410 | return -EINVAL; | ||
411 | |||
412 | /* First check XSDT (but only on ACPI 2.0-compatible systems) */ | ||
413 | |||
414 | if ((rsdp->revision >= 2) && rsdp->xsdt_physical_address) { | ||
415 | |||
416 | struct acpi_table_xsdt *mapped_xsdt = NULL; | ||
417 | |||
418 | sdt_pa = rsdp->xsdt_physical_address; | ||
419 | |||
420 | /* map in just the header */ | ||
421 | header = (struct acpi_table_header *) | ||
422 | __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header)); | ||
423 | |||
424 | if (!header) { | ||
425 | printk(KERN_WARNING PREFIX | ||
426 | "Unable to map XSDT header\n"); | ||
427 | return -ENODEV; | ||
428 | } | ||
429 | |||
430 | /* remap in the entire table before processing */ | ||
431 | mapped_xsdt = (struct acpi_table_xsdt *) | ||
432 | __acpi_map_table(sdt_pa, header->length); | ||
433 | if (!mapped_xsdt) { | ||
434 | printk(KERN_WARNING PREFIX "Unable to map XSDT\n"); | ||
435 | return -ENODEV; | ||
436 | } | ||
437 | header = &mapped_xsdt->header; | ||
438 | |||
439 | if (strncmp(header->signature, "XSDT", 4)) { | ||
440 | printk(KERN_WARNING PREFIX | ||
441 | "XSDT signature incorrect\n"); | ||
442 | return -ENODEV; | ||
443 | } | ||
444 | |||
445 | if (acpi_table_compute_checksum(header, header->length)) { | ||
446 | printk(KERN_WARNING PREFIX "Invalid XSDT checksum\n"); | ||
447 | return -ENODEV; | ||
448 | } | ||
449 | |||
450 | sdt_count = | ||
451 | (header->length - sizeof(struct acpi_table_header)) >> 3; | ||
452 | if (sdt_count > ACPI_MAX_TABLES) { | ||
453 | printk(KERN_WARNING PREFIX | ||
454 | "Truncated %lu XSDT entries\n", | ||
455 | (sdt_count - ACPI_MAX_TABLES)); | ||
456 | sdt_count = ACPI_MAX_TABLES; | ||
457 | } | ||
458 | |||
459 | for (i = 0; i < sdt_count; i++) | ||
460 | sdt_entry[i].pa = (unsigned long)mapped_xsdt->table_offset_entry[i]; | ||
461 | } | ||
462 | |||
463 | /* Then check RSDT */ | ||
464 | |||
465 | else if (rsdp->rsdt_physical_address) { | ||
466 | |||
467 | struct acpi_table_rsdt *mapped_rsdt = NULL; | ||
468 | |||
469 | sdt_pa = rsdp->rsdt_physical_address; | ||
470 | |||
471 | /* map in just the header */ | ||
472 | header = (struct acpi_table_header *) | ||
473 | __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header)); | ||
474 | if (!header) { | ||
475 | printk(KERN_WARNING PREFIX | ||
476 | "Unable to map RSDT header\n"); | ||
477 | return -ENODEV; | ||
478 | } | ||
479 | |||
480 | /* remap in the entire table before processing */ | ||
481 | mapped_rsdt = (struct acpi_table_rsdt *) | ||
482 | __acpi_map_table(sdt_pa, header->length); | ||
483 | if (!mapped_rsdt) { | ||
484 | printk(KERN_WARNING PREFIX "Unable to map RSDT\n"); | ||
485 | return -ENODEV; | ||
486 | } | ||
487 | header = &mapped_rsdt->header; | ||
488 | |||
489 | if (strncmp(header->signature, "RSDT", 4)) { | ||
490 | printk(KERN_WARNING PREFIX | ||
491 | "RSDT signature incorrect\n"); | ||
492 | return -ENODEV; | ||
493 | } | ||
494 | |||
495 | if (acpi_table_compute_checksum(header, header->length)) { | ||
496 | printk(KERN_WARNING PREFIX "Invalid RSDT checksum\n"); | ||
497 | return -ENODEV; | ||
498 | } | ||
499 | |||
500 | sdt_count = | ||
501 | (header->length - sizeof(struct acpi_table_header)) >> 2; | ||
502 | if (sdt_count > ACPI_MAX_TABLES) { | ||
503 | printk(KERN_WARNING PREFIX | ||
504 | "Truncated %lu RSDT entries\n", | ||
505 | (sdt_count - ACPI_MAX_TABLES)); | ||
506 | sdt_count = ACPI_MAX_TABLES; | ||
507 | } | ||
508 | |||
509 | for (i = 0; i < sdt_count; i++) | ||
510 | sdt_entry[i].pa = (unsigned long)mapped_rsdt->table_offset_entry[i]; | ||
511 | } | ||
512 | |||
513 | else { | ||
514 | printk(KERN_WARNING PREFIX | ||
515 | "No System Description Table (RSDT/XSDT) specified in RSDP\n"); | ||
516 | return -ENODEV; | ||
517 | } | ||
518 | |||
519 | acpi_table_print(header, sdt_pa); | ||
520 | |||
521 | for (i = 0; i < sdt_count; i++) { | ||
522 | |||
523 | /* map in just the header */ | ||
524 | header = (struct acpi_table_header *) | ||
525 | __acpi_map_table(sdt_entry[i].pa, | ||
526 | sizeof(struct acpi_table_header)); | ||
527 | if (!header) | ||
528 | continue; | ||
529 | |||
530 | /* remap in the entire table before processing */ | ||
531 | header = (struct acpi_table_header *) | ||
532 | __acpi_map_table(sdt_entry[i].pa, header->length); | ||
533 | if (!header) | ||
534 | continue; | ||
535 | |||
536 | acpi_table_print(header, sdt_entry[i].pa); | ||
537 | |||
538 | if (acpi_table_compute_checksum(header, header->length)) { | ||
539 | printk(KERN_WARNING " >>> ERROR: Invalid checksum\n"); | ||
540 | continue; | ||
541 | } | ||
542 | |||
543 | sdt_entry[i].size = header->length; | ||
544 | |||
545 | for (id = 0; id < ACPI_TABLE_COUNT; id++) { | ||
546 | if (!strncmp((char *)&header->signature, | ||
547 | acpi_table_signatures[id], | ||
548 | sizeof(header->signature))) { | ||
549 | sdt_entry[i].id = id; | ||
550 | } | ||
551 | } | ||
552 | } | ||
553 | |||
554 | /* | ||
555 | * The DSDT is *not* in the RSDT (why not? no idea.) but we want | ||
556 | * to print its info, because this is what people usually blacklist | ||
557 | * against. Unfortunately, we don't know the phys_addr, so just | ||
558 | * print 0. Maybe no one will notice. | ||
559 | */ | ||
560 | if (!acpi_get_table_header_early(ACPI_DSDT, &header)) | ||
561 | acpi_table_print(header, 0); | ||
562 | |||
563 | return 0; | ||
564 | } | 241 | } |
565 | 242 | ||
566 | /* | 243 | /* |
@@ -574,47 +251,6 @@ static int __init acpi_table_get_sdt(struct acpi_table_rsdp *rsdp) | |||
574 | 251 | ||
575 | int __init acpi_table_init(void) | 252 | int __init acpi_table_init(void) |
576 | { | 253 | { |
577 | struct acpi_table_rsdp *rsdp = NULL; | ||
578 | unsigned long rsdp_phys = 0; | ||
579 | int result = 0; | ||
580 | |||
581 | /* Locate and map the Root System Description Table (RSDP) */ | ||
582 | |||
583 | rsdp_phys = acpi_find_rsdp(); | ||
584 | if (!rsdp_phys) { | ||
585 | printk(KERN_ERR PREFIX "Unable to locate RSDP\n"); | ||
586 | return -ENODEV; | ||
587 | } | ||
588 | |||
589 | rsdp = (struct acpi_table_rsdp *)__acpi_map_table(rsdp_phys, | ||
590 | sizeof(struct acpi_table_rsdp)); | ||
591 | if (!rsdp) { | ||
592 | printk(KERN_WARNING PREFIX "Unable to map RSDP\n"); | ||
593 | return -ENODEV; | ||
594 | } | ||
595 | |||
596 | printk(KERN_DEBUG PREFIX | ||
597 | "RSDP (v%3.3d %6.6s ) @ 0x%p\n", | ||
598 | rsdp->revision, rsdp->oem_id, (void *)rsdp_phys); | ||
599 | |||
600 | if (rsdp->revision < 2) | ||
601 | result = | ||
602 | acpi_table_compute_checksum(rsdp, ACPI_RSDP_REV0_SIZE); | ||
603 | else | ||
604 | result = | ||
605 | acpi_table_compute_checksum(rsdp, rsdp->length); | ||
606 | |||
607 | if (result) { | ||
608 | printk(KERN_WARNING " >>> ERROR: Invalid checksum\n"); | ||
609 | return -ENODEV; | ||
610 | } | ||
611 | |||
612 | /* Locate and map the System Description table (RSDT/XSDT) */ | ||
613 | |||
614 | if (acpi_table_get_sdt(rsdp)) | ||
615 | return -ENODEV; | ||
616 | |||
617 | acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); | 254 | acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); |
618 | |||
619 | return 0; | 255 | return 0; |
620 | } | 256 | } |