aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi/tables.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/acpi/tables.c')
-rw-r--r--drivers/acpi/tables.c396
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
41static 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
63static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; 41static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" };
64static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; 42static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" };
65 43
66/* System Description Table (RSDT/XSDT) */
67struct acpi_table_sdt {
68 unsigned long pa;
69 enum acpi_table_id id;
70 unsigned long size;
71} __attribute__ ((packed));
72
73static unsigned long sdt_pa; /* Physical Address */
74static unsigned long sdt_count; /* Table count */
75
76static struct acpi_table_sdt sdt_entry[ACPI_MAX_TABLES] __initdata;
77static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; 44static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata;
78 45
79void 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
106void acpi_table_print_madt_entry(acpi_table_entry_header * header) 46void 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
229static int
230acpi_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 */
249int __init
250acpi_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
308int __init 170int __init
309acpi_table_parse_madt_family(enum acpi_table_id id, 171acpi_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
372acpi_table_parse_madt(enum acpi_madt_entry_id id, 220acpi_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
380int __init acpi_table_parse(enum acpi_table_id id, acpi_table_handler handler) 228int __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
404static 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
575int __init acpi_table_init(void) 252int __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}
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-24 12:26:47 -0400