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