]>
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 | * | |
1da177e4 LT |
18 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
19 | * | |
20 | */ | |
21 | ||
07f438df HG |
22 | /* Uncomment next line to get verbose printout */ |
23 | /* #define DEBUG */ | |
730bf5eb HG |
24 | #define pr_fmt(fmt) "ACPI: " fmt |
25 | ||
1da177e4 LT |
26 | #include <linux/init.h> |
27 | #include <linux/kernel.h> | |
1da177e4 LT |
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> | |
5ae74f2c LZ |
35 | #include <linux/earlycpio.h> |
36 | #include <linux/memblock.h> | |
da3d3f98 | 37 | #include <linux/initrd.h> |
84b06ca3 | 38 | #include <linux/acpi.h> |
c85cc817 | 39 | #include "internal.h" |
1da177e4 | 40 | |
74216699 RW |
41 | #ifdef CONFIG_ACPI_CUSTOM_DSDT |
42 | #include CONFIG_ACPI_CUSTOM_DSDT_FILE | |
43 | #endif | |
44 | ||
04348e69 | 45 | #define ACPI_MAX_TABLES 128 |
1da177e4 | 46 | |
1da177e4 LT |
47 | static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; |
48 | static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; | |
49 | ||
ad71860a | 50 | static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; |
1da177e4 | 51 | |
4e381a4f | 52 | static int acpi_apic_instance __initdata; |
a1fdcc0d | 53 | |
4fc0a7e8 LZ |
54 | /* |
55 | * Disable table checksum verification for the early stage due to the size | |
56 | * limitation of the current x86 early mapping implementation. | |
57 | */ | |
58 | static bool acpi_verify_table_checksum __initdata = false; | |
59 | ||
a1fdcc0d | 60 | void acpi_table_print_madt_entry(struct acpi_subtable_header *header) |
1da177e4 LT |
61 | { |
62 | if (!header) | |
63 | return; | |
64 | ||
65 | switch (header->type) { | |
66 | ||
5f3b1a8b | 67 | case ACPI_MADT_TYPE_LOCAL_APIC: |
4be44fcd | 68 | { |
5f3b1a8b AS |
69 | struct acpi_madt_local_apic *p = |
70 | (struct acpi_madt_local_apic *)header; | |
07f438df HG |
71 | pr_debug("LAPIC (acpi_id[0x%02x] lapic_id[0x%02x] %s)\n", |
72 | p->processor_id, p->id, | |
73 | (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); | |
4be44fcd | 74 | } |
1da177e4 LT |
75 | break; |
76 | ||
7237d3de SS |
77 | case ACPI_MADT_TYPE_LOCAL_X2APIC: |
78 | { | |
79 | struct acpi_madt_local_x2apic *p = | |
80 | (struct acpi_madt_local_x2apic *)header; | |
07f438df HG |
81 | pr_debug("X2APIC (apic_id[0x%02x] uid[0x%02x] %s)\n", |
82 | p->local_apic_id, p->uid, | |
83 | (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); | |
7237d3de SS |
84 | } |
85 | break; | |
86 | ||
5f3b1a8b | 87 | case ACPI_MADT_TYPE_IO_APIC: |
4be44fcd | 88 | { |
5f3b1a8b AS |
89 | struct acpi_madt_io_apic *p = |
90 | (struct acpi_madt_io_apic *)header; | |
07f438df HG |
91 | pr_debug("IOAPIC (id[0x%02x] address[0x%08x] gsi_base[%d])\n", |
92 | p->id, p->address, p->global_irq_base); | |
4be44fcd | 93 | } |
1da177e4 LT |
94 | break; |
95 | ||
5f3b1a8b | 96 | case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: |
4be44fcd | 97 | { |
5f3b1a8b AS |
98 | struct acpi_madt_interrupt_override *p = |
99 | (struct acpi_madt_interrupt_override *)header; | |
730bf5eb HG |
100 | pr_info("INT_SRC_OVR (bus %d bus_irq %d global_irq %d %s %s)\n", |
101 | p->bus, p->source_irq, p->global_irq, | |
102 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], | |
103 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2]); | |
5f3b1a8b AS |
104 | if (p->inti_flags & |
105 | ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)) | |
730bf5eb HG |
106 | pr_info("INT_SRC_OVR unexpected reserved flags: 0x%x\n", |
107 | p->inti_flags & | |
5f3b1a8b | 108 | ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)); |
4be44fcd | 109 | } |
1da177e4 LT |
110 | break; |
111 | ||
5f3b1a8b | 112 | case ACPI_MADT_TYPE_NMI_SOURCE: |
4be44fcd | 113 | { |
5f3b1a8b AS |
114 | struct acpi_madt_nmi_source *p = |
115 | (struct acpi_madt_nmi_source *)header; | |
730bf5eb HG |
116 | pr_info("NMI_SRC (%s %s global_irq %d)\n", |
117 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], | |
118 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], | |
119 | p->global_irq); | |
4be44fcd | 120 | } |
1da177e4 LT |
121 | break; |
122 | ||
5f3b1a8b | 123 | case ACPI_MADT_TYPE_LOCAL_APIC_NMI: |
4be44fcd | 124 | { |
5f3b1a8b AS |
125 | struct acpi_madt_local_apic_nmi *p = |
126 | (struct acpi_madt_local_apic_nmi *)header; | |
730bf5eb HG |
127 | pr_info("LAPIC_NMI (acpi_id[0x%02x] %s %s lint[0x%x])\n", |
128 | p->processor_id, | |
129 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK ], | |
130 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], | |
131 | p->lint); | |
7237d3de SS |
132 | } |
133 | break; | |
134 | ||
135 | case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: | |
136 | { | |
137 | u16 polarity, trigger; | |
138 | struct acpi_madt_local_x2apic_nmi *p = | |
139 | (struct acpi_madt_local_x2apic_nmi *)header; | |
140 | ||
141 | polarity = p->inti_flags & ACPI_MADT_POLARITY_MASK; | |
142 | trigger = (p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2; | |
143 | ||
730bf5eb HG |
144 | pr_info("X2APIC_NMI (uid[0x%02x] %s %s lint[0x%x])\n", |
145 | p->uid, | |
146 | mps_inti_flags_polarity[polarity], | |
147 | mps_inti_flags_trigger[trigger], | |
148 | p->lint); | |
4be44fcd | 149 | } |
1da177e4 LT |
150 | break; |
151 | ||
5f3b1a8b | 152 | case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: |
4be44fcd | 153 | { |
5f3b1a8b AS |
154 | struct acpi_madt_local_apic_override *p = |
155 | (struct acpi_madt_local_apic_override *)header; | |
730bf5eb HG |
156 | pr_info("LAPIC_ADDR_OVR (address[%p])\n", |
157 | (void *)(unsigned long)p->address); | |
4be44fcd | 158 | } |
1da177e4 LT |
159 | break; |
160 | ||
5f3b1a8b | 161 | case ACPI_MADT_TYPE_IO_SAPIC: |
4be44fcd | 162 | { |
5f3b1a8b AS |
163 | struct acpi_madt_io_sapic *p = |
164 | (struct acpi_madt_io_sapic *)header; | |
07f438df HG |
165 | pr_debug("IOSAPIC (id[0x%x] address[%p] gsi_base[%d])\n", |
166 | p->id, (void *)(unsigned long)p->address, | |
167 | p->global_irq_base); | |
4be44fcd | 168 | } |
1da177e4 LT |
169 | break; |
170 | ||
5f3b1a8b | 171 | case ACPI_MADT_TYPE_LOCAL_SAPIC: |
4be44fcd | 172 | { |
5f3b1a8b AS |
173 | struct acpi_madt_local_sapic *p = |
174 | (struct acpi_madt_local_sapic *)header; | |
07f438df HG |
175 | pr_debug("LSAPIC (acpi_id[0x%02x] lsapic_id[0x%02x] lsapic_eid[0x%02x] %s)\n", |
176 | p->processor_id, p->id, p->eid, | |
177 | (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); | |
4be44fcd | 178 | } |
1da177e4 LT |
179 | break; |
180 | ||
5f3b1a8b | 181 | case ACPI_MADT_TYPE_INTERRUPT_SOURCE: |
4be44fcd | 182 | { |
5f3b1a8b AS |
183 | struct acpi_madt_interrupt_source *p = |
184 | (struct acpi_madt_interrupt_source *)header; | |
730bf5eb HG |
185 | 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", |
186 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], | |
187 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], | |
188 | p->type, p->id, p->eid, p->io_sapic_vector, | |
189 | p->global_irq); | |
4be44fcd | 190 | } |
1da177e4 LT |
191 | break; |
192 | ||
4c1c8d7a HG |
193 | case ACPI_MADT_TYPE_GENERIC_INTERRUPT: |
194 | { | |
195 | struct acpi_madt_generic_interrupt *p = | |
196 | (struct acpi_madt_generic_interrupt *)header; | |
197 | pr_debug("GICC (acpi_id[0x%04x] address[%llx] MPIDR[0x%llx] %s)\n", | |
198 | p->uid, p->base_address, | |
199 | p->arm_mpidr, | |
200 | (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); | |
201 | ||
202 | } | |
203 | break; | |
204 | ||
205 | case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: | |
206 | { | |
207 | struct acpi_madt_generic_distributor *p = | |
208 | (struct acpi_madt_generic_distributor *)header; | |
209 | pr_debug("GIC Distributor (gic_id[0x%04x] address[%llx] gsi_base[%d])\n", | |
210 | p->gic_id, p->base_address, | |
211 | p->global_irq_base); | |
212 | } | |
213 | break; | |
214 | ||
1da177e4 | 215 | default: |
730bf5eb HG |
216 | pr_warn("Found unsupported MADT entry (type = 0x%x)\n", |
217 | header->type); | |
1da177e4 LT |
218 | break; |
219 | } | |
220 | } | |
221 | ||
9b3fedde LA |
222 | /** |
223 | * acpi_parse_entries_array - for each proc_num find a suitable subtable | |
224 | * | |
225 | * @id: table id (for debugging purposes) | |
226 | * @table_size: single entry size | |
227 | * @table_header: where does the table start? | |
228 | * @proc: array of acpi_subtable_proc struct containing entry id | |
229 | * and associated handler with it | |
230 | * @proc_num: how big proc is? | |
231 | * @max_entries: how many entries can we process? | |
232 | * | |
233 | * For each proc_num find a subtable with proc->id and run proc->handler | |
234 | * on it. Assumption is that there's only single handler for particular | |
235 | * entry id. | |
236 | * | |
237 | * On success returns sum of all matching entries for all proc handlers. | |
238 | * Otherwise, -ENODEV or -EINVAL is returned. | |
239 | */ | |
240 | static int __init | |
241 | acpi_parse_entries_array(char *id, unsigned long table_size, | |
f08bb472 | 242 | struct acpi_table_header *table_header, |
9b3fedde LA |
243 | struct acpi_subtable_proc *proc, int proc_num, |
244 | unsigned int max_entries) | |
1da177e4 | 245 | { |
5f3b1a8b | 246 | struct acpi_subtable_header *entry; |
6eb87fed | 247 | unsigned long table_end; |
9b3fedde LA |
248 | int count = 0; |
249 | int i; | |
1da177e4 | 250 | |
68ca4069 | 251 | if (acpi_disabled) |
e5b8fc6a LB |
252 | return -ENODEV; |
253 | ||
9b3fedde | 254 | if (!id) |
1da177e4 LT |
255 | return -EINVAL; |
256 | ||
f08bb472 AC |
257 | if (!table_size) |
258 | return -EINVAL; | |
1da177e4 | 259 | |
6eb87fed | 260 | if (!table_header) { |
730bf5eb | 261 | pr_warn("%4.4s not present\n", id); |
1da177e4 LT |
262 | return -ENODEV; |
263 | } | |
264 | ||
6eb87fed | 265 | table_end = (unsigned long)table_header + table_header->length; |
1da177e4 LT |
266 | |
267 | /* Parse all entries looking for a match. */ | |
268 | ||
5f3b1a8b | 269 | entry = (struct acpi_subtable_header *) |
6eb87fed | 270 | ((unsigned long)table_header + table_size); |
1da177e4 | 271 | |
5f3b1a8b | 272 | while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) < |
6eb87fed | 273 | table_end) { |
9b3fedde LA |
274 | if (max_entries && count >= max_entries) |
275 | break; | |
276 | ||
277 | for (i = 0; i < proc_num; i++) { | |
278 | if (entry->type != proc[i].id) | |
279 | continue; | |
362414d9 DC |
280 | if (!proc[i].handler || |
281 | proc[i].handler(entry, table_end)) | |
f08bb472 | 282 | return -EINVAL; |
369d913b | 283 | |
9b3fedde LA |
284 | proc->count++; |
285 | break; | |
4ceacd02 | 286 | } |
9b3fedde LA |
287 | if (i != proc_num) |
288 | count++; | |
4ceacd02 | 289 | |
369d913b FY |
290 | /* |
291 | * If entry->length is 0, break from this loop to avoid | |
292 | * infinite loop. | |
293 | */ | |
294 | if (entry->length == 0) { | |
9b3fedde | 295 | pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id); |
f08bb472 | 296 | return -EINVAL; |
369d913b | 297 | } |
1da177e4 | 298 | |
5f3b1a8b | 299 | entry = (struct acpi_subtable_header *) |
4be44fcd | 300 | ((unsigned long)entry + entry->length); |
1da177e4 | 301 | } |
f08bb472 | 302 | |
1da177e4 | 303 | if (max_entries && count > max_entries) { |
730bf5eb | 304 | pr_warn("[%4.4s:0x%02x] ignored %i entries of %i found\n", |
9b3fedde | 305 | id, proc->id, count - max_entries, count); |
1da177e4 LT |
306 | } |
307 | ||
308 | return count; | |
f08bb472 AC |
309 | } |
310 | ||
311 | int __init | |
9b3fedde LA |
312 | acpi_parse_entries(char *id, |
313 | unsigned long table_size, | |
314 | acpi_tbl_entry_handler handler, | |
315 | struct acpi_table_header *table_header, | |
316 | int entry_id, unsigned int max_entries) | |
317 | { | |
318 | struct acpi_subtable_proc proc = { | |
319 | .id = entry_id, | |
320 | .handler = handler, | |
321 | }; | |
322 | ||
323 | return acpi_parse_entries_array(id, table_size, table_header, | |
324 | &proc, 1, max_entries); | |
325 | } | |
326 | ||
327 | int __init | |
328 | acpi_table_parse_entries_array(char *id, | |
f08bb472 | 329 | unsigned long table_size, |
9b3fedde | 330 | struct acpi_subtable_proc *proc, int proc_num, |
f08bb472 AC |
331 | unsigned int max_entries) |
332 | { | |
333 | struct acpi_table_header *table_header = NULL; | |
334 | acpi_size tbl_size; | |
335 | int count; | |
336 | u32 instance = 0; | |
337 | ||
338 | if (acpi_disabled) | |
339 | return -ENODEV; | |
340 | ||
9b3fedde | 341 | if (!id) |
f08bb472 AC |
342 | return -EINVAL; |
343 | ||
344 | if (!strncmp(id, ACPI_SIG_MADT, 4)) | |
345 | instance = acpi_apic_instance; | |
346 | ||
347 | acpi_get_table_with_size(id, instance, &table_header, &tbl_size); | |
348 | if (!table_header) { | |
349 | pr_warn("%4.4s not present\n", id); | |
350 | return -ENODEV; | |
351 | } | |
352 | ||
9b3fedde LA |
353 | count = acpi_parse_entries_array(id, table_size, table_header, |
354 | proc, proc_num, max_entries); | |
f08bb472 | 355 | |
369d913b | 356 | early_acpi_os_unmap_memory((char *)table_header, tbl_size); |
f08bb472 | 357 | return count; |
1da177e4 LT |
358 | } |
359 | ||
9b3fedde LA |
360 | int __init |
361 | acpi_table_parse_entries(char *id, | |
362 | unsigned long table_size, | |
363 | int entry_id, | |
364 | acpi_tbl_entry_handler handler, | |
365 | unsigned int max_entries) | |
366 | { | |
367 | struct acpi_subtable_proc proc = { | |
368 | .id = entry_id, | |
369 | .handler = handler, | |
370 | }; | |
371 | ||
372 | return acpi_table_parse_entries_array(id, table_size, &proc, 1, | |
373 | max_entries); | |
374 | } | |
375 | ||
1da177e4 | 376 | int __init |
5f3b1a8b | 377 | acpi_table_parse_madt(enum acpi_madt_type id, |
b43e1065 | 378 | acpi_tbl_entry_handler handler, unsigned int max_entries) |
1da177e4 | 379 | { |
6eb87fed | 380 | return acpi_table_parse_entries(ACPI_SIG_MADT, |
4be44fcd LB |
381 | sizeof(struct acpi_table_madt), id, |
382 | handler, max_entries); | |
1da177e4 LT |
383 | } |
384 | ||
7f8f97c3 LB |
385 | /** |
386 | * acpi_table_parse - find table with @id, run @handler on it | |
7f8f97c3 LB |
387 | * @id: table id to find |
388 | * @handler: handler to run | |
389 | * | |
390 | * Scan the ACPI System Descriptor Table (STD) for a table matching @id, | |
f8a571b2 | 391 | * run @handler on it. |
392 | * | |
393 | * Return 0 if table found, -errno if not. | |
7f8f97c3 | 394 | */ |
b43e1065 | 395 | int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler) |
1da177e4 | 396 | { |
ceb6c468 | 397 | struct acpi_table_header *table = NULL; |
7d97277b | 398 | acpi_size tbl_size; |
a1fdcc0d | 399 | |
68ca4069 | 400 | if (acpi_disabled) |
e5b8fc6a LB |
401 | return -ENODEV; |
402 | ||
de2d1a7e | 403 | if (!id || !handler) |
1da177e4 LT |
404 | return -EINVAL; |
405 | ||
a1fdcc0d | 406 | if (strncmp(id, ACPI_SIG_MADT, 4) == 0) |
7d97277b | 407 | acpi_get_table_with_size(id, acpi_apic_instance, &table, &tbl_size); |
a1fdcc0d | 408 | else |
7d97277b | 409 | acpi_get_table_with_size(id, 0, &table, &tbl_size); |
a1fdcc0d | 410 | |
ceb6c468 AS |
411 | if (table) { |
412 | handler(table); | |
7d97277b | 413 | early_acpi_os_unmap_memory(table, tbl_size); |
ceb6c468 | 414 | return 0; |
7f8f97c3 | 415 | } else |
95df812d | 416 | return -ENODEV; |
1da177e4 LT |
417 | } |
418 | ||
a1fdcc0d LB |
419 | /* |
420 | * The BIOS is supposed to supply a single APIC/MADT, | |
421 | * but some report two. Provide a knob to use either. | |
422 | * (don't you wish instance 0 and 1 were not the same?) | |
423 | */ | |
424 | static void __init check_multiple_madt(void) | |
425 | { | |
426 | struct acpi_table_header *table = NULL; | |
7d97277b | 427 | acpi_size tbl_size; |
a1fdcc0d | 428 | |
7d97277b | 429 | acpi_get_table_with_size(ACPI_SIG_MADT, 2, &table, &tbl_size); |
a1fdcc0d | 430 | if (table) { |
730bf5eb HG |
431 | pr_warn("BIOS bug: multiple APIC/MADT found, using %d\n", |
432 | acpi_apic_instance); | |
433 | pr_warn("If \"acpi_apic_instance=%d\" works better, " | |
434 | "notify linux-acpi@vger.kernel.org\n", | |
435 | acpi_apic_instance ? 0 : 2); | |
7d97277b | 436 | early_acpi_os_unmap_memory(table, tbl_size); |
a1fdcc0d LB |
437 | |
438 | } else | |
439 | acpi_apic_instance = 0; | |
440 | ||
441 | return; | |
442 | } | |
443 | ||
5ae74f2c LZ |
444 | static void acpi_table_taint(struct acpi_table_header *table) |
445 | { | |
446 | pr_warn("Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n", | |
447 | table->signature, table->oem_table_id); | |
448 | add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE); | |
449 | } | |
450 | ||
5d881327 | 451 | #ifdef CONFIG_ACPI_TABLE_UPGRADE |
5ae74f2c LZ |
452 | static u64 acpi_tables_addr; |
453 | static int all_tables_size; | |
454 | ||
455 | /* Copied from acpica/tbutils.c:acpi_tb_checksum() */ | |
456 | static u8 __init acpi_table_checksum(u8 *buffer, u32 length) | |
457 | { | |
458 | u8 sum = 0; | |
459 | u8 *end = buffer + length; | |
460 | ||
461 | while (buffer < end) | |
462 | sum = (u8) (sum + *(buffer++)); | |
463 | return sum; | |
464 | } | |
465 | ||
466 | /* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */ | |
467 | static const char * const table_sigs[] = { | |
468 | ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ, | |
469 | ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT, | |
470 | ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF, | |
471 | ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET, | |
472 | ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI, | |
473 | ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA, | |
474 | ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT, | |
475 | ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT, | |
476 | ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL }; | |
477 | ||
478 | #define ACPI_HEADER_SIZE sizeof(struct acpi_table_header) | |
479 | ||
5d881327 LZ |
480 | #define NR_ACPI_INITRD_TABLES 64 |
481 | static struct cpio_data __initdata acpi_initrd_files[NR_ACPI_INITRD_TABLES]; | |
482 | static DECLARE_BITMAP(acpi_initrd_installed, NR_ACPI_INITRD_TABLES); | |
5ae74f2c LZ |
483 | |
484 | #define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT) | |
485 | ||
da3d3f98 | 486 | void __init acpi_table_upgrade(void) |
5ae74f2c | 487 | { |
da3d3f98 AM |
488 | void *data = (void *)initrd_start; |
489 | size_t size = initrd_end - initrd_start; | |
5ae74f2c LZ |
490 | int sig, no, table_nr = 0, total_offset = 0; |
491 | long offset = 0; | |
492 | struct acpi_table_header *table; | |
493 | char cpio_path[32] = "kernel/firmware/acpi/"; | |
494 | struct cpio_data file; | |
495 | ||
496 | if (data == NULL || size == 0) | |
497 | return; | |
498 | ||
5d881327 | 499 | for (no = 0; no < NR_ACPI_INITRD_TABLES; no++) { |
5ae74f2c LZ |
500 | file = find_cpio_data(cpio_path, data, size, &offset); |
501 | if (!file.data) | |
502 | break; | |
503 | ||
504 | data += offset; | |
505 | size -= offset; | |
506 | ||
507 | if (file.size < sizeof(struct acpi_table_header)) { | |
508 | pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n", | |
509 | cpio_path, file.name); | |
510 | continue; | |
511 | } | |
512 | ||
513 | table = file.data; | |
514 | ||
515 | for (sig = 0; table_sigs[sig]; sig++) | |
516 | if (!memcmp(table->signature, table_sigs[sig], 4)) | |
517 | break; | |
518 | ||
519 | if (!table_sigs[sig]) { | |
520 | pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n", | |
521 | cpio_path, file.name); | |
522 | continue; | |
523 | } | |
524 | if (file.size != table->length) { | |
525 | pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n", | |
526 | cpio_path, file.name); | |
527 | continue; | |
528 | } | |
529 | if (acpi_table_checksum(file.data, table->length)) { | |
530 | pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n", | |
531 | cpio_path, file.name); | |
532 | continue; | |
533 | } | |
534 | ||
535 | pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n", | |
536 | table->signature, cpio_path, file.name, table->length); | |
537 | ||
538 | all_tables_size += table->length; | |
539 | acpi_initrd_files[table_nr].data = file.data; | |
540 | acpi_initrd_files[table_nr].size = file.size; | |
541 | table_nr++; | |
542 | } | |
543 | if (table_nr == 0) | |
544 | return; | |
545 | ||
546 | acpi_tables_addr = | |
84b06ca3 | 547 | memblock_find_in_range(0, ACPI_TABLE_UPGRADE_MAX_PHYS, |
5ae74f2c LZ |
548 | all_tables_size, PAGE_SIZE); |
549 | if (!acpi_tables_addr) { | |
550 | WARN_ON(1); | |
551 | return; | |
552 | } | |
553 | /* | |
554 | * Only calling e820_add_reserve does not work and the | |
555 | * tables are invalid (memory got used) later. | |
556 | * memblock_reserve works as expected and the tables won't get modified. | |
557 | * But it's not enough on X86 because ioremap will | |
558 | * complain later (used by acpi_os_map_memory) that the pages | |
559 | * that should get mapped are not marked "reserved". | |
560 | * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area) | |
561 | * works fine. | |
562 | */ | |
563 | memblock_reserve(acpi_tables_addr, all_tables_size); | |
564 | arch_reserve_mem_area(acpi_tables_addr, all_tables_size); | |
565 | ||
566 | /* | |
567 | * early_ioremap only can remap 256k one time. If we map all | |
568 | * tables one time, we will hit the limit. Need to map chunks | |
569 | * one by one during copying the same as that in relocate_initrd(). | |
570 | */ | |
571 | for (no = 0; no < table_nr; no++) { | |
572 | unsigned char *src_p = acpi_initrd_files[no].data; | |
573 | phys_addr_t size = acpi_initrd_files[no].size; | |
574 | phys_addr_t dest_addr = acpi_tables_addr + total_offset; | |
575 | phys_addr_t slop, clen; | |
576 | char *dest_p; | |
577 | ||
578 | total_offset += size; | |
579 | ||
580 | while (size) { | |
581 | slop = dest_addr & ~PAGE_MASK; | |
582 | clen = size; | |
583 | if (clen > MAP_CHUNK_SIZE - slop) | |
584 | clen = MAP_CHUNK_SIZE - slop; | |
ce0c1fcc AM |
585 | dest_p = early_memremap(dest_addr & PAGE_MASK, |
586 | clen + slop); | |
5ae74f2c | 587 | memcpy(dest_p + slop, src_p, clen); |
ce0c1fcc | 588 | early_memunmap(dest_p, clen + slop); |
5ae74f2c LZ |
589 | src_p += clen; |
590 | dest_addr += clen; | |
591 | size -= clen; | |
592 | } | |
593 | } | |
594 | } | |
595 | ||
596 | static acpi_status | |
597 | acpi_table_initrd_override(struct acpi_table_header *existing_table, | |
598 | acpi_physical_address *address, u32 *length) | |
599 | { | |
600 | int table_offset = 0; | |
601 | int table_index = 0; | |
602 | struct acpi_table_header *table; | |
603 | u32 table_length; | |
604 | ||
605 | *length = 0; | |
606 | *address = 0; | |
607 | if (!acpi_tables_addr) | |
608 | return AE_OK; | |
609 | ||
610 | while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { | |
611 | table = acpi_os_map_memory(acpi_tables_addr + table_offset, | |
612 | ACPI_HEADER_SIZE); | |
613 | if (table_offset + table->length > all_tables_size) { | |
614 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); | |
615 | WARN_ON(1); | |
616 | return AE_OK; | |
617 | } | |
618 | ||
619 | table_length = table->length; | |
620 | ||
621 | /* Only override tables matched */ | |
5d881327 LZ |
622 | if (memcmp(existing_table->signature, table->signature, 4) || |
623 | memcmp(table->oem_id, existing_table->oem_id, | |
624 | ACPI_OEM_ID_SIZE) || | |
5ae74f2c LZ |
625 | memcmp(table->oem_table_id, existing_table->oem_table_id, |
626 | ACPI_OEM_TABLE_ID_SIZE)) { | |
627 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); | |
628 | goto next_table; | |
629 | } | |
5d881327 LZ |
630 | /* |
631 | * Mark the table to avoid being used in | |
632 | * acpi_table_initrd_scan() and check the revision. | |
633 | */ | |
634 | if (test_and_set_bit(table_index, acpi_initrd_installed) || | |
635 | existing_table->oem_revision >= table->oem_revision) { | |
636 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); | |
637 | goto next_table; | |
638 | } | |
5ae74f2c LZ |
639 | |
640 | *length = table_length; | |
641 | *address = acpi_tables_addr + table_offset; | |
5d881327 LZ |
642 | pr_info("Table Upgrade: override [%4.4s-%6.6s-%8.8s]\n", |
643 | table->signature, table->oem_id, | |
644 | table->oem_table_id); | |
5ae74f2c | 645 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); |
5ae74f2c LZ |
646 | break; |
647 | ||
648 | next_table: | |
649 | table_offset += table_length; | |
650 | table_index++; | |
651 | } | |
652 | return AE_OK; | |
653 | } | |
654 | ||
655 | static void __init acpi_table_initrd_scan(void) | |
656 | { | |
657 | int table_offset = 0; | |
658 | int table_index = 0; | |
659 | u32 table_length; | |
660 | struct acpi_table_header *table; | |
661 | ||
662 | if (!acpi_tables_addr) | |
663 | return; | |
664 | ||
665 | while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { | |
666 | table = acpi_os_map_memory(acpi_tables_addr + table_offset, | |
667 | ACPI_HEADER_SIZE); | |
668 | if (table_offset + table->length > all_tables_size) { | |
669 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); | |
670 | WARN_ON(1); | |
671 | return; | |
672 | } | |
673 | ||
674 | table_length = table->length; | |
675 | ||
676 | /* Skip RSDT/XSDT which should only be used for override */ | |
5d881327 | 677 | if (ACPI_COMPARE_NAME(table->signature, ACPI_SIG_RSDT) || |
5ae74f2c LZ |
678 | ACPI_COMPARE_NAME(table->signature, ACPI_SIG_XSDT)) { |
679 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); | |
680 | goto next_table; | |
681 | } | |
5d881327 LZ |
682 | /* |
683 | * Mark the table to avoid being used in | |
684 | * acpi_table_initrd_override(). Though this is not possible | |
685 | * because override is disabled in acpi_install_table(). | |
686 | */ | |
687 | if (test_and_set_bit(table_index, acpi_initrd_installed)) { | |
688 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); | |
689 | goto next_table; | |
690 | } | |
5ae74f2c | 691 | |
5d881327 LZ |
692 | pr_info("Table Upgrade: install [%4.4s-%6.6s-%8.8s]\n", |
693 | table->signature, table->oem_id, | |
694 | table->oem_table_id); | |
5ae74f2c LZ |
695 | acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); |
696 | acpi_install_table(acpi_tables_addr + table_offset, TRUE); | |
5ae74f2c LZ |
697 | next_table: |
698 | table_offset += table_length; | |
699 | table_index++; | |
700 | } | |
701 | } | |
702 | #else | |
5ae74f2c LZ |
703 | static acpi_status |
704 | acpi_table_initrd_override(struct acpi_table_header *existing_table, | |
705 | acpi_physical_address *address, | |
706 | u32 *table_length) | |
707 | { | |
708 | *table_length = 0; | |
709 | *address = 0; | |
710 | return AE_OK; | |
711 | } | |
712 | ||
713 | static void __init acpi_table_initrd_scan(void) | |
714 | { | |
715 | } | |
5d881327 | 716 | #endif /* CONFIG_ACPI_TABLE_UPGRADE */ |
5ae74f2c LZ |
717 | |
718 | acpi_status | |
719 | acpi_os_physical_table_override(struct acpi_table_header *existing_table, | |
720 | acpi_physical_address *address, | |
721 | u32 *table_length) | |
722 | { | |
723 | return acpi_table_initrd_override(existing_table, address, | |
724 | table_length); | |
725 | } | |
726 | ||
727 | acpi_status | |
728 | acpi_os_table_override(struct acpi_table_header *existing_table, | |
729 | struct acpi_table_header **new_table) | |
730 | { | |
731 | if (!existing_table || !new_table) | |
732 | return AE_BAD_PARAMETER; | |
733 | ||
734 | *new_table = NULL; | |
735 | ||
736 | #ifdef CONFIG_ACPI_CUSTOM_DSDT | |
737 | if (strncmp(existing_table->signature, "DSDT", 4) == 0) | |
738 | *new_table = (struct acpi_table_header *)AmlCode; | |
739 | #endif | |
740 | if (*new_table != NULL) | |
741 | acpi_table_taint(existing_table); | |
742 | return AE_OK; | |
743 | } | |
744 | ||
1da177e4 LT |
745 | /* |
746 | * acpi_table_init() | |
747 | * | |
748 | * find RSDP, find and checksum SDT/XSDT. | |
749 | * checksum all tables, print SDT/XSDT | |
5f3b1a8b | 750 | * |
1da177e4 LT |
751 | * result: sdt_entry[] is initialized |
752 | */ | |
753 | ||
4be44fcd | 754 | int __init acpi_table_init(void) |
1da177e4 | 755 | { |
9e3a9d1e LB |
756 | acpi_status status; |
757 | ||
4fc0a7e8 LZ |
758 | if (acpi_verify_table_checksum) { |
759 | pr_info("Early table checksum verification enabled\n"); | |
760 | acpi_gbl_verify_table_checksum = TRUE; | |
761 | } else { | |
762 | pr_info("Early table checksum verification disabled\n"); | |
763 | acpi_gbl_verify_table_checksum = FALSE; | |
764 | } | |
765 | ||
9e3a9d1e LB |
766 | status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); |
767 | if (ACPI_FAILURE(status)) | |
95df812d | 768 | return -EINVAL; |
5ae74f2c | 769 | acpi_table_initrd_scan(); |
9e3a9d1e | 770 | |
a1fdcc0d LB |
771 | check_multiple_madt(); |
772 | return 0; | |
773 | } | |
774 | ||
775 | static int __init acpi_parse_apic_instance(char *str) | |
776 | { | |
f0df2d6b CG |
777 | if (!str) |
778 | return -EINVAL; | |
a1fdcc0d | 779 | |
3d915894 CJ |
780 | if (kstrtoint(str, 0, &acpi_apic_instance)) |
781 | return -EINVAL; | |
a1fdcc0d | 782 | |
730bf5eb | 783 | pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance); |
a1fdcc0d | 784 | |
1da177e4 LT |
785 | return 0; |
786 | } | |
a1fdcc0d LB |
787 | |
788 | early_param("acpi_apic_instance", acpi_parse_apic_instance); | |
4fc0a7e8 LZ |
789 | |
790 | static int __init acpi_force_table_verification_setup(char *s) | |
791 | { | |
792 | acpi_verify_table_checksum = true; | |
793 | ||
794 | return 0; | |
795 | } | |
796 | ||
797 | early_param("acpi_force_table_verification", acpi_force_table_verification_setup); | |
b2ca5dae CIK |
798 | |
799 | static int __init acpi_force_32bit_fadt_addr(char *s) | |
800 | { | |
801 | pr_info("Forcing 32 Bit FADT addresses\n"); | |
802 | acpi_gbl_use32_bit_fadt_addresses = TRUE; | |
803 | ||
804 | return 0; | |
805 | } | |
806 | ||
807 | early_param("acpi_force_32bit_fadt_addr", acpi_force_32bit_fadt_addr); |