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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 19 * 20 */ 21 22 /* Uncomment next line to get verbose printout */ 23 /* #define DEBUG */ 24 #define pr_fmt(fmt) "ACPI: " fmt 25 26 #include <linux/init.h> 27 #include <linux/kernel.h> 28 #include <linux/smp.h> 29 #include <linux/string.h> 30 #include <linux/types.h> 31 #include <linux/irq.h> 32 #include <linux/errno.h> 33 #include <linux/acpi.h> 34 #include <linux/bootmem.h> 35 #include "internal.h" 36 37 #define ACPI_MAX_TABLES 128 38 39 static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; 40 static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; 41 42 static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; 43 44 static int acpi_apic_instance __initdata; 45 46 /* 47 * Disable table checksum verification for the early stage due to the size 48 * limitation of the current x86 early mapping implementation. 49 */ 50 static bool acpi_verify_table_checksum __initdata = false; 51 52 void acpi_table_print_madt_entry(struct acpi_subtable_header *header) 53 { 54 if (!header) 55 return; 56 57 switch (header->type) { 58 59 case ACPI_MADT_TYPE_LOCAL_APIC: 60 { 61 struct acpi_madt_local_apic *p = 62 (struct acpi_madt_local_apic *)header; 63 pr_debug("LAPIC (acpi_id[0x%02x] lapic_id[0x%02x] %s)\n", 64 p->processor_id, p->id, 65 (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 66 } 67 break; 68 69 case ACPI_MADT_TYPE_LOCAL_X2APIC: 70 { 71 struct acpi_madt_local_x2apic *p = 72 (struct acpi_madt_local_x2apic *)header; 73 pr_debug("X2APIC (apic_id[0x%02x] uid[0x%02x] %s)\n", 74 p->local_apic_id, p->uid, 75 (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 76 } 77 break; 78 79 case ACPI_MADT_TYPE_IO_APIC: 80 { 81 struct acpi_madt_io_apic *p = 82 (struct acpi_madt_io_apic *)header; 83 pr_debug("IOAPIC (id[0x%02x] address[0x%08x] gsi_base[%d])\n", 84 p->id, p->address, p->global_irq_base); 85 } 86 break; 87 88 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 89 { 90 struct acpi_madt_interrupt_override *p = 91 (struct acpi_madt_interrupt_override *)header; 92 pr_info("INT_SRC_OVR (bus %d bus_irq %d global_irq %d %s %s)\n", 93 p->bus, p->source_irq, p->global_irq, 94 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], 95 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2]); 96 if (p->inti_flags & 97 ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)) 98 pr_info("INT_SRC_OVR unexpected reserved flags: 0x%x\n", 99 p->inti_flags & 100 ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)); 101 } 102 break; 103 104 case ACPI_MADT_TYPE_NMI_SOURCE: 105 { 106 struct acpi_madt_nmi_source *p = 107 (struct acpi_madt_nmi_source *)header; 108 pr_info("NMI_SRC (%s %s global_irq %d)\n", 109 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], 110 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], 111 p->global_irq); 112 } 113 break; 114 115 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 116 { 117 struct acpi_madt_local_apic_nmi *p = 118 (struct acpi_madt_local_apic_nmi *)header; 119 pr_info("LAPIC_NMI (acpi_id[0x%02x] %s %s lint[0x%x])\n", 120 p->processor_id, 121 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK ], 122 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], 123 p->lint); 124 } 125 break; 126 127 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 128 { 129 u16 polarity, trigger; 130 struct acpi_madt_local_x2apic_nmi *p = 131 (struct acpi_madt_local_x2apic_nmi *)header; 132 133 polarity = p->inti_flags & ACPI_MADT_POLARITY_MASK; 134 trigger = (p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2; 135 136 pr_info("X2APIC_NMI (uid[0x%02x] %s %s lint[0x%x])\n", 137 p->uid, 138 mps_inti_flags_polarity[polarity], 139 mps_inti_flags_trigger[trigger], 140 p->lint); 141 } 142 break; 143 144 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 145 { 146 struct acpi_madt_local_apic_override *p = 147 (struct acpi_madt_local_apic_override *)header; 148 pr_info("LAPIC_ADDR_OVR (address[%p])\n", 149 (void *)(unsigned long)p->address); 150 } 151 break; 152 153 case ACPI_MADT_TYPE_IO_SAPIC: 154 { 155 struct acpi_madt_io_sapic *p = 156 (struct acpi_madt_io_sapic *)header; 157 pr_debug("IOSAPIC (id[0x%x] address[%p] gsi_base[%d])\n", 158 p->id, (void *)(unsigned long)p->address, 159 p->global_irq_base); 160 } 161 break; 162 163 case ACPI_MADT_TYPE_LOCAL_SAPIC: 164 { 165 struct acpi_madt_local_sapic *p = 166 (struct acpi_madt_local_sapic *)header; 167 pr_debug("LSAPIC (acpi_id[0x%02x] lsapic_id[0x%02x] lsapic_eid[0x%02x] %s)\n", 168 p->processor_id, p->id, p->eid, 169 (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 170 } 171 break; 172 173 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 174 { 175 struct acpi_madt_interrupt_source *p = 176 (struct acpi_madt_interrupt_source *)header; 177 pr_info("PLAT_INT_SRC (%s %s type[0x%x] id[0x%04x] eid[0x%x] iosapic_vector[0x%x] global_irq[0x%x]\n", 178 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], 179 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], 180 p->type, p->id, p->eid, p->io_sapic_vector, 181 p->global_irq); 182 } 183 break; 184 185 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 186 { 187 struct acpi_madt_generic_interrupt *p = 188 (struct acpi_madt_generic_interrupt *)header; 189 pr_debug("GICC (acpi_id[0x%04x] address[%llx] MPIDR[0x%llx] %s)\n", 190 p->uid, p->base_address, 191 p->arm_mpidr, 192 (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 193 194 } 195 break; 196 197 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 198 { 199 struct acpi_madt_generic_distributor *p = 200 (struct acpi_madt_generic_distributor *)header; 201 pr_debug("GIC Distributor (gic_id[0x%04x] address[%llx] gsi_base[%d])\n", 202 p->gic_id, p->base_address, 203 p->global_irq_base); 204 } 205 break; 206 207 default: 208 pr_warn("Found unsupported MADT entry (type = 0x%x)\n", 209 header->type); 210 break; 211 } 212 } 213 214 /** 215 * acpi_parse_entries_array - for each proc_num find a suitable subtable 216 * 217 * @id: table id (for debugging purposes) 218 * @table_size: single entry size 219 * @table_header: where does the table start? 220 * @proc: array of acpi_subtable_proc struct containing entry id 221 * and associated handler with it 222 * @proc_num: how big proc is? 223 * @max_entries: how many entries can we process? 224 * 225 * For each proc_num find a subtable with proc->id and run proc->handler 226 * on it. Assumption is that there's only single handler for particular 227 * entry id. 228 * 229 * On success returns sum of all matching entries for all proc handlers. 230 * Otherwise, -ENODEV or -EINVAL is returned. 231 */ 232 static int __init 233 acpi_parse_entries_array(char *id, unsigned long table_size, 234 struct acpi_table_header *table_header, 235 struct acpi_subtable_proc *proc, int proc_num, 236 unsigned int max_entries) 237 { 238 struct acpi_subtable_header *entry; 239 unsigned long table_end; 240 int count = 0; 241 int i; 242 243 if (acpi_disabled) 244 return -ENODEV; 245 246 if (!id) 247 return -EINVAL; 248 249 if (!table_size) 250 return -EINVAL; 251 252 if (!table_header) { 253 pr_warn("%4.4s not present\n", id); 254 return -ENODEV; 255 } 256 257 table_end = (unsigned long)table_header + table_header->length; 258 259 /* Parse all entries looking for a match. */ 260 261 entry = (struct acpi_subtable_header *) 262 ((unsigned long)table_header + table_size); 263 264 while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) < 265 table_end) { 266 if (max_entries && count >= max_entries) 267 break; 268 269 for (i = 0; i < proc_num; i++) { 270 if (entry->type != proc[i].id) 271 continue; 272 if (!proc[i].handler || 273 proc[i].handler(entry, table_end)) 274 return -EINVAL; 275 276 proc->count++; 277 break; 278 } 279 if (i != proc_num) 280 count++; 281 282 /* 283 * If entry->length is 0, break from this loop to avoid 284 * infinite loop. 285 */ 286 if (entry->length == 0) { 287 pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id); 288 return -EINVAL; 289 } 290 291 entry = (struct acpi_subtable_header *) 292 ((unsigned long)entry + entry->length); 293 } 294 295 if (max_entries && count > max_entries) { 296 pr_warn("[%4.4s:0x%02x] ignored %i entries of %i found\n", 297 id, proc->id, count - max_entries, count); 298 } 299 300 return count; 301 } 302 303 int __init 304 acpi_parse_entries(char *id, 305 unsigned long table_size, 306 acpi_tbl_entry_handler handler, 307 struct acpi_table_header *table_header, 308 int entry_id, unsigned int max_entries) 309 { 310 struct acpi_subtable_proc proc = { 311 .id = entry_id, 312 .handler = handler, 313 }; 314 315 return acpi_parse_entries_array(id, table_size, table_header, 316 &proc, 1, max_entries); 317 } 318 319 int __init 320 acpi_table_parse_entries_array(char *id, 321 unsigned long table_size, 322 struct acpi_subtable_proc *proc, int proc_num, 323 unsigned int max_entries) 324 { 325 struct acpi_table_header *table_header = NULL; 326 acpi_size tbl_size; 327 int count; 328 u32 instance = 0; 329 330 if (acpi_disabled) 331 return -ENODEV; 332 333 if (!id) 334 return -EINVAL; 335 336 if (!strncmp(id, ACPI_SIG_MADT, 4)) 337 instance = acpi_apic_instance; 338 339 acpi_get_table_with_size(id, instance, &table_header, &tbl_size); 340 if (!table_header) { 341 pr_warn("%4.4s not present\n", id); 342 return -ENODEV; 343 } 344 345 count = acpi_parse_entries_array(id, table_size, table_header, 346 proc, proc_num, max_entries); 347 348 early_acpi_os_unmap_memory((char *)table_header, tbl_size); 349 return count; 350 } 351 352 int __init 353 acpi_table_parse_entries(char *id, 354 unsigned long table_size, 355 int entry_id, 356 acpi_tbl_entry_handler handler, 357 unsigned int max_entries) 358 { 359 struct acpi_subtable_proc proc = { 360 .id = entry_id, 361 .handler = handler, 362 }; 363 364 return acpi_table_parse_entries_array(id, table_size, &proc, 1, 365 max_entries); 366 } 367 368 int __init 369 acpi_table_parse_madt(enum acpi_madt_type id, 370 acpi_tbl_entry_handler handler, unsigned int max_entries) 371 { 372 return acpi_table_parse_entries(ACPI_SIG_MADT, 373 sizeof(struct acpi_table_madt), id, 374 handler, max_entries); 375 } 376 377 /** 378 * acpi_table_parse - find table with @id, run @handler on it 379 * @id: table id to find 380 * @handler: handler to run 381 * 382 * Scan the ACPI System Descriptor Table (STD) for a table matching @id, 383 * run @handler on it. 384 * 385 * Return 0 if table found, -errno if not. 386 */ 387 int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler) 388 { 389 struct acpi_table_header *table = NULL; 390 acpi_size tbl_size; 391 392 if (acpi_disabled) 393 return -ENODEV; 394 395 if (!id || !handler) 396 return -EINVAL; 397 398 if (strncmp(id, ACPI_SIG_MADT, 4) == 0) 399 acpi_get_table_with_size(id, acpi_apic_instance, &table, &tbl_size); 400 else 401 acpi_get_table_with_size(id, 0, &table, &tbl_size); 402 403 if (table) { 404 handler(table); 405 early_acpi_os_unmap_memory(table, tbl_size); 406 return 0; 407 } else 408 return -ENODEV; 409 } 410 411 /* 412 * The BIOS is supposed to supply a single APIC/MADT, 413 * but some report two. Provide a knob to use either. 414 * (don't you wish instance 0 and 1 were not the same?) 415 */ 416 static void __init check_multiple_madt(void) 417 { 418 struct acpi_table_header *table = NULL; 419 acpi_size tbl_size; 420 421 acpi_get_table_with_size(ACPI_SIG_MADT, 2, &table, &tbl_size); 422 if (table) { 423 pr_warn("BIOS bug: multiple APIC/MADT found, using %d\n", 424 acpi_apic_instance); 425 pr_warn("If \"acpi_apic_instance=%d\" works better, " 426 "notify linux-acpi@vger.kernel.org\n", 427 acpi_apic_instance ? 0 : 2); 428 early_acpi_os_unmap_memory(table, tbl_size); 429 430 } else 431 acpi_apic_instance = 0; 432 433 return; 434 } 435 436 /* 437 * acpi_table_init() 438 * 439 * find RSDP, find and checksum SDT/XSDT. 440 * checksum all tables, print SDT/XSDT 441 * 442 * result: sdt_entry[] is initialized 443 */ 444 445 int __init acpi_table_init(void) 446 { 447 acpi_status status; 448 449 if (acpi_verify_table_checksum) { 450 pr_info("Early table checksum verification enabled\n"); 451 acpi_gbl_verify_table_checksum = TRUE; 452 } else { 453 pr_info("Early table checksum verification disabled\n"); 454 acpi_gbl_verify_table_checksum = FALSE; 455 } 456 457 status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); 458 if (ACPI_FAILURE(status)) 459 return -EINVAL; 460 acpi_initrd_initialize_tables(); 461 462 check_multiple_madt(); 463 return 0; 464 } 465 466 static int __init acpi_parse_apic_instance(char *str) 467 { 468 if (!str) 469 return -EINVAL; 470 471 if (kstrtoint(str, 0, &acpi_apic_instance)) 472 return -EINVAL; 473 474 pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance); 475 476 return 0; 477 } 478 479 early_param("acpi_apic_instance", acpi_parse_apic_instance); 480 481 static int __init acpi_force_table_verification_setup(char *s) 482 { 483 acpi_verify_table_checksum = true; 484 485 return 0; 486 } 487 488 early_param("acpi_force_table_verification", acpi_force_table_verification_setup); 489 490 static int __init acpi_force_32bit_fadt_addr(char *s) 491 { 492 pr_info("Forcing 32 Bit FADT addresses\n"); 493 acpi_gbl_use32_bit_fadt_addresses = TRUE; 494 495 return 0; 496 } 497 498 early_param("acpi_force_32bit_fadt_addr", acpi_force_32bit_fadt_addr); 499