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_DEBUG 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] gsi_base[%d])\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] address[%p] gsi_base[%d])\n",
 189                         p->id, (void *) (unsigned long) p->address, p->global_irq_base);
 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 = NULL;
 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) + sizeof(acpi_table_entry_header) < madt_end) {
 347                 if (entry->type == entry_id &&
 348                     (!max_entries || count++ < max_entries))
 349                         if (handler(entry, madt_end))
 350                                 return -EINVAL;
 351
 352                 entry = (acpi_table_entry_header *)
 353                         ((unsigned long) entry + entry->length);
 354         }
 355         if (max_entries && count > max_entries) {
 356                 printk(KERN_WARNING PREFIX "[%s:0x%02x] ignored %i entries of "
 357                        "%i found\n", acpi_table_signatures[id], entry_id,
 358                        count - max_entries, count);
 359         }
 360
 361         return count;
 362 }
 363
 364
 365 int __init
 366 acpi_table_parse_madt (
 367         enum acpi_madt_entry_id id,
 368         acpi_madt_entry_handler handler,
 369         unsigned int max_entries)
 370 {
 371         return acpi_table_parse_madt_family(ACPI_APIC, sizeof(struct acpi_table_madt),
 372                                             id, handler, max_entries);
 373 }
 374
 375
 376 int __init
 377 acpi_table_parse (
 378         enum acpi_table_id      id,
 379         acpi_table_handler      handler)
 380 {
 381         int                     count = 0;
 382         unsigned int            i = 0;
 383
 384         if (!handler)
 385                 return -EINVAL;
 386
 387         for (i = 0; i < sdt_count; i++) {
 388                 if (sdt_entry[i].id != id)
 389                         continue;
 390                 count++;
 391                 if (count == 1)
 392                         handler(sdt_entry[i].pa, sdt_entry[i].size);
 393
 394                 else
 395                         printk(KERN_WARNING PREFIX "%d duplicate %s table ignored.\n",
 396                                 count, acpi_table_signatures[id]);
 397         }
 398
 399         return count;
 400 }
 401
 402
 403 static int __init
 404 acpi_table_get_sdt (
 405         struct acpi_table_rsdp  *rsdp)
 406 {
 407         struct acpi_table_header *header = NULL;
 408         unsigned int            i, id = 0;
 409
 410         if (!rsdp)
 411                 return -EINVAL;
 412
 413         /* First check XSDT (but only on ACPI 2.0-compatible systems) */
 414
 415         if ((rsdp->revision >= 2) &&
 416                 (((struct acpi20_table_rsdp*)rsdp)->xsdt_address)) {
 417
 418                 struct acpi_table_xsdt  *mapped_xsdt = NULL;
 419
 420                 sdt_pa = ((struct acpi20_table_rsdp*)rsdp)->xsdt_address;
 421
 422                 /* map in just the header */
 423                 header = (struct acpi_table_header *)
 424                         __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header));
 425
 426                 if (!header) {
 427                         printk(KERN_WARNING PREFIX "Unable to map XSDT header\n");
 428                         return -ENODEV;
 429                 }
 430
 431                 /* remap in the entire table before processing */
 432                 mapped_xsdt = (struct acpi_table_xsdt *)
 433                         __acpi_map_table(sdt_pa, header->length);
 434                 if (!mapped_xsdt) {
 435                         printk(KERN_WARNING PREFIX "Unable to map XSDT\n");
 436                         return -ENODEV;
 437                 }
 438                 header = &mapped_xsdt->header;
 439
 440                 if (strncmp(header->signature, "XSDT", 4)) {
 441                         printk(KERN_WARNING PREFIX "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 = (header->length - sizeof(struct acpi_table_header)) >> 3;
 451                 if (sdt_count > ACPI_MAX_TABLES) {
 452                         printk(KERN_WARNING PREFIX "Truncated %lu XSDT entries\n",
 453                                 (sdt_count - ACPI_MAX_TABLES));
 454                         sdt_count = ACPI_MAX_TABLES;
 455                 }
 456
 457                 for (i = 0; i < sdt_count; i++)
 458                         sdt_entry[i].pa = (unsigned long) mapped_xsdt->entry[i];
 459         }
 460
 461         /* Then check RSDT */
 462
 463         else if (rsdp->rsdt_address) {
 464
 465                 struct acpi_table_rsdt  *mapped_rsdt = NULL;
 466
 467                 sdt_pa = rsdp->rsdt_address;
 468
 469                 /* map in just the header */
 470                 header = (struct acpi_table_header *)
 471                         __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header));
 472                 if (!header) {
 473                         printk(KERN_WARNING PREFIX "Unable to map RSDT header\n");
 474                         return -ENODEV;
 475                 }
 476
 477                 /* remap in the entire table before processing */
 478                 mapped_rsdt = (struct acpi_table_rsdt *)
 479                         __acpi_map_table(sdt_pa, header->length);
 480                 if (!mapped_rsdt) {
 481                         printk(KERN_WARNING PREFIX "Unable to map RSDT\n");
 482                         return -ENODEV;
 483                 }
 484                 header = &mapped_rsdt->header;
 485
 486                 if (strncmp(header->signature, "RSDT", 4)) {
 487                         printk(KERN_WARNING PREFIX "RSDT signature incorrect\n");
 488                         return -ENODEV;
 489                 }
 490
 491                 if (acpi_table_compute_checksum(header, header->length)) {
 492                         printk(KERN_WARNING PREFIX "Invalid RSDT checksum\n");
 493                         return -ENODEV;
 494                 }
 495
 496                 sdt_count = (header->length - sizeof(struct acpi_table_header)) >> 2;
 497                 if (sdt_count > ACPI_MAX_TABLES) {
 498                         printk(KERN_WARNING PREFIX "Truncated %lu RSDT entries\n",
 499                                 (sdt_count - ACPI_MAX_TABLES));
 500                         sdt_count = ACPI_MAX_TABLES;
 501                 }
 502
 503                 for (i = 0; i < sdt_count; i++)
 504                         sdt_entry[i].pa = (unsigned long) mapped_rsdt->entry[i];
 505         }
 506
 507         else {
 508                 printk(KERN_WARNING PREFIX "No System Description Table (RSDT/XSDT) specified in RSDP\n");
 509                 return -ENODEV;
 510         }
 511
 512         acpi_table_print(header, sdt_pa);
 513
 514         for (i = 0; i < sdt_count; i++) {
 515
 516                 /* map in just the header */
 517                 header = (struct acpi_table_header *)
 518                         __acpi_map_table(sdt_entry[i].pa,
 519                                 sizeof(struct acpi_table_header));
 520                 if (!header)
 521                         continue;
 522
 523                 /* remap in the entire table before processing */
 524                 header = (struct acpi_table_header *)
 525                         __acpi_map_table(sdt_entry[i].pa,
 526                                 header->length);
 527                 if (!header)
 528                         continue;
 529
 530                 acpi_table_print(header, sdt_entry[i].pa);
 531
 532                 if (acpi_table_compute_checksum(header, header->length)) {
 533                         printk(KERN_WARNING "  >>> ERROR: Invalid checksum\n");
 534                         continue;
 535                 }
 536
 537                 sdt_entry[i].size = header->length;
 538
 539                 for (id = 0; id < ACPI_TABLE_COUNT; id++) {
 540                         if (!strncmp((char *) &header->signature,
 541                                 acpi_table_signatures[id],
 542                                 sizeof(header->signature))) {
 543                                 sdt_entry[i].id = id;
 544                         }
 545                 }
 546         }
 547
 548         /*
 549          * The DSDT is *not* in the RSDT (why not? no idea.) but we want
 550          * to print its info, because this is what people usually blacklist
 551          * against. Unfortunately, we don't know the phys_addr, so just
 552          * print 0. Maybe no one will notice.
 553          */
 554         if(!acpi_get_table_header_early(ACPI_DSDT, &header))
 555                 acpi_table_print(header, 0);
 556
 557         return 0;
 558 }
 559
 560 /*
 561  * acpi_table_init()
 562  *
 563  * find RSDP, find and checksum SDT/XSDT.
 564  * checksum all tables, print SDT/XSDT
 565  *
 566  * result: sdt_entry[] is initialized
 567  */
 568
 569 int __init
 570 acpi_table_init (void)
 571 {
 572         struct acpi_table_rsdp  *rsdp = NULL;
 573         unsigned long           rsdp_phys = 0;
 574         int                     result = 0;
 575
 576         /* Locate and map the Root System Description Table (RSDP) */
 577
 578         rsdp_phys = acpi_find_rsdp();
 579         if (!rsdp_phys) {
 580                 printk(KERN_ERR PREFIX "Unable to locate RSDP\n");
 581                 return -ENODEV;
 582         }
 583
 584         rsdp = (struct acpi_table_rsdp *) __va(rsdp_phys);
 585         if (!rsdp) {
 586                 printk(KERN_WARNING PREFIX "Unable to map RSDP\n");
 587                 return -ENODEV;
 588         }
 589
 590         printk(KERN_DEBUG PREFIX "RSDP (v%3.3d %6.6s                                ) @ 0x%p\n",
 591                 rsdp->revision, rsdp->oem_id, (void *) rsdp_phys);
 592
 593         if (rsdp->revision < 2)
 594                 result = acpi_table_compute_checksum(rsdp, sizeof(struct acpi_table_rsdp));
 595         else
 596                 result = acpi_table_compute_checksum(rsdp, ((struct acpi20_table_rsdp *)rsdp)->length);
 597
 598         if (result) {
 599                 printk(KERN_WARNING "  >>> ERROR: Invalid checksum\n");
 600                 return -ENODEV;
 601         }
 602
 603         /* Locate and map the System Description table (RSDT/XSDT) */
 604
 605         if (acpi_table_get_sdt(rsdp))
 606                 return -ENODEV;
 607
 608         return 0;
 609 }