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