drivers/acpi/tables.c

   1 /*
   2  *  acpi_tables.c - ACPI Boot-Time Table Parsing
   3  *
   4  *  Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   5  *
   6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23  *
  24  */
  25
  26 #include <linux/config.h>
  27 #include <linux/init.h>
  28 #include <linux/kernel.h>
  29 #include <linux/sched.h>
  30 #include <linux/smp.h>
  31 #include <linux/string.h>
  32 #include <linux/types.h>
  33 #include <linux/irq.h>
  34 #include <linux/errno.h>
  35 #include <linux/acpi.h>
  36 #include <linux/bootmem.h>
  37
  38 #define PREFIX                  "ACPI: "
  39
  40 #define ACPI_MAX_TABLES         256
  41
  42 static char *acpi_table_signatures[ACPI_TABLE_COUNT] = {
  43         [ACPI_TABLE_UNKNOWN]    = "????",
  44         [ACPI_APIC]             = "APIC",
  45         [ACPI_BOOT]             = "BOOT",
  46         [ACPI_DBGP]             = "DBGP",
  47         [ACPI_DSDT]             = "DSDT",
  48         [ACPI_ECDT]             = "ECDT",
  49         [ACPI_ETDT]             = "ETDT",
  50         [ACPI_FADT]             = "FACP",
  51         [ACPI_FACS]             = "FACS",
  52         [ACPI_OEMX]             = "OEM",
  53         [ACPI_PSDT]             = "PSDT",
  54         [ACPI_SBST]             = "SBST",
  55         [ACPI_SLIT]             = "SLIT",
  56         [ACPI_SPCR]             = "SPCR",
  57         [ACPI_SRAT]             = "SRAT",
  58         [ACPI_SSDT]             = "SSDT",
  59         [ACPI_SPMI]             = "SPMI",
  60         [ACPI_HPET]             = "HPET",
  61         [ACPI_MCFG]             = "MCFG",
  62 };
  63
  64 static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" };
  65 static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" };
  66
  67 /* System Description Table (RSDT/XSDT) */
  68 struct acpi_table_sdt {
  69         unsigned long           pa;
  70         enum acpi_table_id      id;
  71         unsigned long           size;
  72 } __attribute__ ((packed));
  73
  74 static unsigned long            sdt_pa;         /* Physical Address */
  75 static unsigned long            sdt_count;      /* Table count */
  76
  77 static struct acpi_table_sdt    sdt_entry[ACPI_MAX_TABLES];
  78
  79 void
  80 acpi_table_print (
  81         struct acpi_table_header *header,
  82         unsigned long           phys_addr)
  83 {
  84         char                    *name = NULL;
  85
  86         if (!header)
  87                 return;
  88
  89         /* Some table signatures aren't good table names */
  90
  91         if (!strncmp((char *) &header->signature,
  92                 acpi_table_signatures[ACPI_APIC],
  93                 sizeof(header->signature))) {
  94                 name = "MADT";
  95         }
  96         else if (!strncmp((char *) &header->signature,
  97                 acpi_table_signatures[ACPI_FADT],
  98                 sizeof(header->signature))) {
  99                 name = "FADT";
 100         }
 101         else
 102                 name = header->signature;
 103
 104         printk(KERN_INFO PREFIX "%.4s (v%3.3d %6.6s %8.8s 0x%08x %.4s 0x%08x) @ 0x%p\n",
 105                 name, header->revision, header->oem_id,
 106                 header->oem_table_id, header->oem_revision,
 107                 header->asl_compiler_id, header->asl_compiler_revision,
 108                 (void *) phys_addr);
 109 }
 110
 111
 112 void
 113 acpi_table_print_madt_entry (
 114         acpi_table_entry_header *header)
 115 {
 116         if (!header)
 117                 return;
 118
 119         switch (header->type) {
 120
 121         case ACPI_MADT_LAPIC:
 122         {
 123                 struct acpi_table_lapic *p =
 124                         (struct acpi_table_lapic*) header;
 125                 printk(KERN_INFO PREFIX "LAPIC (acpi_id[0x%02x] lapic_id[0x%02x] %s)\n",
 126                         p->acpi_id, p->id, p->flags.enabled?"enabled":"disabled");
 127         }
 128                 break;
 129
 130         case ACPI_MADT_IOAPIC:
 131         {
 132                 struct acpi_table_ioapic *p =
 133                         (struct acpi_table_ioapic*) header;
 134                 printk(KERN_INFO PREFIX "IOAPIC (id[0x%02x] address[0x%08x] global_irq_base[0x%x])\n",
 135                         p->id, p->address, p->global_irq_base);
 136         }
 137                 break;
 138
 139         case ACPI_MADT_INT_SRC_OVR:
 140         {
 141                 struct acpi_table_int_src_ovr *p =
 142                         (struct acpi_table_int_src_ovr*) header;
 143                 printk(KERN_INFO PREFIX "INT_SRC_OVR (bus %d bus_irq %d global_irq %d %s %s)\n",
 144                         p->bus, p->bus_irq, p->global_irq,
 145                         mps_inti_flags_polarity[p->flags.polarity],
 146                         mps_inti_flags_trigger[p->flags.trigger]);
 147                 if(p->flags.reserved)
 148                         printk(KERN_INFO PREFIX "INT_SRC_OVR unexpected reserved flags: 0x%x\n",
 149                                 p->flags.reserved);
 150
 151         }
 152                 break;
 153
 154         case ACPI_MADT_NMI_SRC:
 155         {
 156                 struct acpi_table_nmi_src *p =
 157                         (struct acpi_table_nmi_src*) header;
 158                 printk(KERN_INFO PREFIX "NMI_SRC (%s %s global_irq %d)\n",
 159                         mps_inti_flags_polarity[p->flags.polarity],
 160                         mps_inti_flags_trigger[p->flags.trigger], p->global_irq);
 161         }
 162                 break;
 163
 164         case ACPI_MADT_LAPIC_NMI:
 165         {
 166                 struct acpi_table_lapic_nmi *p =
 167                         (struct acpi_table_lapic_nmi*) header;
 168                 printk(KERN_INFO PREFIX "LAPIC_NMI (acpi_id[0x%02x] %s %s lint[0x%x])\n",
 169                         p->acpi_id,
 170                         mps_inti_flags_polarity[p->flags.polarity],
 171                         mps_inti_flags_trigger[p->flags.trigger], p->lint);
 172         }
 173                 break;
 174
 175         case ACPI_MADT_LAPIC_ADDR_OVR:
 176         {
 177                 struct acpi_table_lapic_addr_ovr *p =
 178                         (struct acpi_table_lapic_addr_ovr*) header;
 179                 printk(KERN_INFO PREFIX "LAPIC_ADDR_OVR (address[%p])\n",
 180                         (void *) (unsigned long) p->address);
 181         }
 182                 break;
 183
 184         case ACPI_MADT_IOSAPIC:
 185         {
 186                 struct acpi_table_iosapic *p =
 187                         (struct acpi_table_iosapic*) header;
 188                 printk(KERN_INFO PREFIX "IOSAPIC (id[0x%x] global_irq_base[0x%x] address[%p])\n",
 189                         p->id, p->global_irq_base, (void *) (unsigned long) p->address);
 190         }
 191                 break;
 192
 193         case ACPI_MADT_LSAPIC:
 194         {
 195                 struct acpi_table_lsapic *p =
 196                         (struct acpi_table_lsapic*) header;
 197                 printk(KERN_INFO PREFIX "LSAPIC (acpi_id[0x%02x] lsapic_id[0x%02x] lsapic_eid[0x%02x] %s)\n",
 198                         p->acpi_id, p->id, p->eid, p->flags.enabled?"enabled":"disabled");
 199         }
 200                 break;
 201
 202         case ACPI_MADT_PLAT_INT_SRC:
 203         {
 204                 struct acpi_table_plat_int_src *p =
 205                         (struct acpi_table_plat_int_src*) header;
 206                 printk(KERN_INFO PREFIX "PLAT_INT_SRC (%s %s type[0x%x] id[0x%04x] eid[0x%x] iosapic_vector[0x%x] global_irq[0x%x]\n",
 207                         mps_inti_flags_polarity[p->flags.polarity],
 208                         mps_inti_flags_trigger[p->flags.trigger],
 209                         p->type, p->id, p->eid, p->iosapic_vector, p->global_irq);
 210         }
 211                 break;
 212
 213         default:
 214                 printk(KERN_WARNING PREFIX "Found unsupported MADT entry (type = 0x%x)\n",
 215                         header->type);
 216                 break;
 217         }
 218 }
 219
 220
 221 static int
 222 acpi_table_compute_checksum (
 223         void                    *table_pointer,
 224         unsigned long           length)
 225 {
 226         u8                      *p = (u8 *) table_pointer;
 227         unsigned long           remains = length;
 228         unsigned long           sum = 0;
 229
 230         if (!p || !length)
 231                 return -EINVAL;
 232
 233         while (remains--)
 234                 sum += *p++;
 235
 236         return (sum & 0xFF);
 237 }
 238
 239 /*
 240  * acpi_get_table_header_early()
 241  * for acpi_blacklisted(), acpi_table_get_sdt()
 242  */
 243 int __init
 244 acpi_get_table_header_early (
 245         enum acpi_table_id      id,
 246         struct acpi_table_header **header)
 247 {
 248         unsigned int i;
 249         enum acpi_table_id temp_id;
 250
 251         /* DSDT is different from the rest */
 252         if (id == ACPI_DSDT)
 253                 temp_id = ACPI_FADT;
 254         else
 255                 temp_id = id;
 256
 257         /* Locate the table. */
 258
 259         for (i = 0; i < sdt_count; i++) {
 260                 if (sdt_entry[i].id != temp_id)
 261                         continue;
 262                 *header = (void *)
 263                         __acpi_map_table(sdt_entry[i].pa, sdt_entry[i].size);
 264                 if (!*header) {
 265                         printk(KERN_WARNING PREFIX "Unable to map %s\n",
 266                                acpi_table_signatures[temp_id]);
 267                         return -ENODEV;
 268                 }
 269                 break;
 270         }
 271
 272         if (!*header) {
 273                 printk(KERN_WARNING PREFIX "%s not present\n",
 274                        acpi_table_signatures[id]);
 275                 return -ENODEV;
 276         }
 277
 278         /* Map the DSDT header via the pointer in the FADT */
 279         if (id == ACPI_DSDT) {
 280                 struct fadt_descriptor_rev2 *fadt = (struct fadt_descriptor_rev2 *) *header;
 281
 282                 if (fadt->revision == 3 && fadt->Xdsdt) {
 283                         *header = (void *) __acpi_map_table(fadt->Xdsdt,
 284                                         sizeof(struct acpi_table_header));
 285                 } else if (fadt->V1_dsdt) {
 286                         *header = (void *) __acpi_map_table(fadt->V1_dsdt,
 287                                         sizeof(struct acpi_table_header));
 288                 } else
 289                         *header = 0;
 290
 291                 if (!*header) {
 292                         printk(KERN_WARNING PREFIX "Unable to map DSDT\n");
 293                         return -ENODEV;
 294                 }
 295         }
 296
 297         return 0;
 298 }
 299
 300
 301 int __init
 302 acpi_table_parse_madt_family (
 303         enum acpi_table_id      id,
 304         unsigned long           madt_size,
 305         int                     entry_id,
 306         acpi_madt_entry_handler handler,
 307         unsigned int            max_entries)
 308 {
 309         void                    *madt = NULL;
 310         acpi_table_entry_header *entry;
 311         unsigned int            count = 0;
 312         unsigned long           madt_end;
 313         unsigned int            i;
 314
 315         if (!handler)
 316                 return -EINVAL;
 317
 318         /* Locate the MADT (if exists). There should only be one. */
 319
 320         for (i = 0; i < sdt_count; i++) {
 321                 if (sdt_entry[i].id != id)
 322                         continue;
 323                 madt = (void *)
 324                         __acpi_map_table(sdt_entry[i].pa, sdt_entry[i].size);
 325                 if (!madt) {
 326                         printk(KERN_WARNING PREFIX "Unable to map %s\n",
 327                                acpi_table_signatures[id]);
 328                         return -ENODEV;
 329                 }
 330                 break;
 331         }
 332
 333         if (!madt) {
 334                 printk(KERN_WARNING PREFIX "%s not present\n",
 335                        acpi_table_signatures[id]);
 336                 return -ENODEV;
 337         }
 338
 339         madt_end = (unsigned long) madt + sdt_entry[i].size;
 340
 341         /* Parse all entries looking for a match. */
 342
 343         entry = (acpi_table_entry_header *)
 344                 ((unsigned long) madt + madt_size);
 345
 346         while (((unsigned long) entry) < madt_end) {
 347                 if (entry->type == entry_id &&
 348                     (!max_entries || count++ < max_entries))
 349                         handler(entry);
 350
 351                 entry = (acpi_table_entry_header *)
 352                         ((unsigned long) entry + entry->length);
 353         }
 354         if (max_entries && count > max_entries) {
 355                 printk(KERN_WARNING PREFIX "[%s:0x%02x] ignored %i entries of "
 356                        "%i found\n", acpi_table_signatures[id], entry_id,
 357                        count - max_entries, count);
 358         }
 359
 360         return count;
 361 }
 362
 363
 364 int __init
 365 acpi_table_parse_madt (
 366         enum acpi_madt_entry_id id,
 367         acpi_madt_entry_handler handler,
 368         unsigned int max_entries)
 369 {
 370         return acpi_table_parse_madt_family(ACPI_APIC, sizeof(struct acpi_table_madt),
 371                                             id, handler, max_entries);
 372 }
 373
 374
 375 int __init
 376 acpi_table_parse (
 377         enum acpi_table_id      id,
 378         acpi_table_handler      handler)
 379 {
 380         int                     count = 0;
 381         unsigned int            i = 0;
 382
 383         if (!handler)
 384                 return -EINVAL;
 385
 386         for (i = 0; i < sdt_count; i++) {
 387                 if (sdt_entry[i].id != id)
 388                         continue;
 389                 count++;
 390                 if (count == 1)
 391                         handler(sdt_entry[i].pa, sdt_entry[i].size);
 392
 393                 else
 394                         printk(KERN_WARNING PREFIX "%d duplicate %s table ignored.\n",
 395                                 count, acpi_table_signatures[id]);
 396         }
 397
 398         return count;
 399 }
 400
 401
 402 static int __init
 403 acpi_table_get_sdt (
 404         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) &&
 415                 (((struct acpi20_table_rsdp*)rsdp)->xsdt_address)) {
 416
 417                 struct acpi_table_xsdt  *mapped_xsdt = NULL;
 418
 419                 sdt_pa = ((struct acpi20_table_rsdp*)rsdp)->xsdt_address;
 420
 421                 /* map in just the header */
 422                 header = (struct acpi_table_header *)
 423                         __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header));
 424
 425                 if (!header) {
 426                         printk(KERN_WARNING PREFIX "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 "XSDT signature incorrect\n");
 441                         return -ENODEV;
 442                 }
 443
 444                 if (acpi_table_compute_checksum(header, header->length)) {
 445                         printk(KERN_WARNING PREFIX "Invalid XSDT checksum\n");
 446                         return -ENODEV;
 447                 }
 448
 449                 sdt_count = (header->length - sizeof(struct acpi_table_header)) >> 3;
 450                 if (sdt_count > ACPI_MAX_TABLES) {
 451                         printk(KERN_WARNING PREFIX "Truncated %lu XSDT entries\n",
 452                                 (sdt_count - ACPI_MAX_TABLES));
 453                         sdt_count = ACPI_MAX_TABLES;
 454                 }
 455
 456                 for (i = 0; i < sdt_count; i++)
 457                         sdt_entry[i].pa = (unsigned long) mapped_xsdt->entry[i];
 458         }
 459
 460         /* Then check RSDT */
 461
 462         else if (rsdp->rsdt_address) {
 463
 464                 struct acpi_table_rsdt  *mapped_rsdt = NULL;
 465
 466                 sdt_pa = rsdp->rsdt_address;
 467
 468                 /* map in just the header */
 469                 header = (struct acpi_table_header *)
 470                         __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header));
 471                 if (!header) {
 472                         printk(KERN_WARNING PREFIX "Unable to map RSDT header\n");
 473                         return -ENODEV;
 474                 }
 475
 476                 /* remap in the entire table before processing */
 477                 mapped_rsdt = (struct acpi_table_rsdt *)
 478                         __acpi_map_table(sdt_pa, header->length);
 479                 if (!mapped_rsdt) {
 480                         printk(KERN_WARNING PREFIX "Unable to map RSDT\n");
 481                         return -ENODEV;
 482                 }
 483                 header = &mapped_rsdt->header;
 484
 485                 if (strncmp(header->signature, "RSDT", 4)) {
 486                         printk(KERN_WARNING PREFIX "RSDT signature incorrect\n");
 487                         return -ENODEV;
 488                 }
 489
 490                 if (acpi_table_compute_checksum(header, header->length)) {
 491                         printk(KERN_WARNING PREFIX "Invalid RSDT checksum\n");
 492                         return -ENODEV;
 493                 }
 494
 495                 sdt_count = (header->length - sizeof(struct acpi_table_header)) >> 2;
 496                 if (sdt_count > ACPI_MAX_TABLES) {
 497                         printk(KERN_WARNING PREFIX "Truncated %lu RSDT entries\n",
 498                                 (sdt_count - ACPI_MAX_TABLES));
 499                         sdt_count = ACPI_MAX_TABLES;
 500                 }
 501
 502                 for (i = 0; i < sdt_count; i++)
 503                         sdt_entry[i].pa = (unsigned long) mapped_rsdt->entry[i];
 504         }
 505
 506         else {
 507                 printk(KERN_WARNING PREFIX "No System Description Table (RSDT/XSDT) specified in RSDP\n");
 508                 return -ENODEV;
 509         }
 510
 511         acpi_table_print(header, sdt_pa);
 512
 513         for (i = 0; i < sdt_count; i++) {
 514
 515                 /* map in just the header */
 516                 header = (struct acpi_table_header *)
 517                         __acpi_map_table(sdt_entry[i].pa,
 518                                 sizeof(struct acpi_table_header));
 519                 if (!header)
 520                         continue;
 521
 522                 /* remap in the entire table before processing */
 523                 header = (struct acpi_table_header *)
 524                         __acpi_map_table(sdt_entry[i].pa,
 525                                 header->length);
 526                 if (!header)
 527                         continue;
 528
 529                 acpi_table_print(header, sdt_entry[i].pa);
 530
 531                 if (acpi_table_compute_checksum(header, header->length)) {
 532                         printk(KERN_WARNING "  >>> ERROR: Invalid checksum\n");
 533                         continue;
 534                 }
 535
 536                 sdt_entry[i].size = header->length;
 537
 538                 for (id = 0; id < ACPI_TABLE_COUNT; id++) {
 539                         if (!strncmp((char *) &header->signature,
 540                                 acpi_table_signatures[id],
 541                                 sizeof(header->signature))) {
 542                                 sdt_entry[i].id = id;
 543                         }
 544                 }
 545         }
 546
 547         /*
 548          * The DSDT is *not* in the RSDT (why not? no idea.) but we want
 549          * to print its info, because this is what people usually blacklist
 550          * against. Unfortunately, we don't know the phys_addr, so just
 551          * print 0. Maybe no one will notice.
 552          */
 553         if(!acpi_get_table_header_early(ACPI_DSDT, &header))
 554                 acpi_table_print(header, 0);
 555
 556         return 0;
 557 }
 558
 559 /*
 560  * acpi_table_init()
 561  *
 562  * find RSDP, find and checksum SDT/XSDT.
 563  * checksum all tables, print SDT/XSDT
 564  *
 565  * result: sdt_entry[] is initialized
 566  */
 567
 568 int __init
 569 acpi_table_init (void)
 570 {
 571         struct acpi_table_rsdp  *rsdp = NULL;
 572         unsigned long           rsdp_phys = 0;
 573         int                     result = 0;
 574
 575         /* Locate and map the Root System Description Table (RSDP) */
 576
 577         rsdp_phys = acpi_find_rsdp();
 578         if (!rsdp_phys) {
 579                 printk(KERN_ERR PREFIX "Unable to locate RSDP\n");
 580                 return -ENODEV;
 581         }
 582
 583         rsdp = (struct acpi_table_rsdp *) __va(rsdp_phys);
 584         if (!rsdp) {
 585                 printk(KERN_WARNING PREFIX "Unable to map RSDP\n");
 586                 return -ENODEV;
 587         }
 588
 589         printk(KERN_INFO PREFIX "RSDP (v%3.3d %6.6s                                    ) @ 0x%p\n",
 590                 rsdp->revision, rsdp->oem_id, (void *) rsdp_phys);
 591
 592         if (rsdp->revision < 2)
 593                 result = acpi_table_compute_checksum(rsdp, sizeof(struct acpi_table_rsdp));
 594         else
 595                 result = acpi_table_compute_checksum(rsdp, ((struct acpi20_table_rsdp *)rsdp)->length);
 596
 597         if (result) {
 598                 printk(KERN_WARNING "  >>> ERROR: Invalid checksum\n");
 599                 return -ENODEV;
 600         }
 601
 602         /* Locate and map the System Description table (RSDT/XSDT) */
 603
 604         if (acpi_table_get_sdt(rsdp))
 605                 return -ENODEV;
 606
 607         return 0;
 608 }