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> | |
c85cc817 | 35 | #include "internal.h" |
1da177e4 | 36 | |
04348e69 | 37 | #define ACPI_MAX_TABLES 128 |
1da177e4 | 38 | |
1da177e4 LT |
39 | static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; |
40 | static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; | |
41 | ||
ad71860a | 42 | static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; |
1da177e4 | 43 | |
4e381a4f | 44 | static int acpi_apic_instance __initdata; |
a1fdcc0d | 45 | |
4fc0a7e8 LZ |
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 | ||
a1fdcc0d | 52 | void acpi_table_print_madt_entry(struct acpi_subtable_header *header) |
1da177e4 LT |
53 | { |
54 | if (!header) | |
55 | return; | |
56 | ||
57 | switch (header->type) { | |
58 | ||
5f3b1a8b | 59 | case ACPI_MADT_TYPE_LOCAL_APIC: |
4be44fcd | 60 | { |
5f3b1a8b AS |
61 | struct acpi_madt_local_apic *p = |
62 | (struct acpi_madt_local_apic *)header; | |
07f438df HG |
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"); | |
4be44fcd | 66 | } |
1da177e4 LT |
67 | break; |
68 | ||
7237d3de SS |
69 | case ACPI_MADT_TYPE_LOCAL_X2APIC: |
70 | { | |
71 | struct acpi_madt_local_x2apic *p = | |
72 | (struct acpi_madt_local_x2apic *)header; | |
07f438df HG |
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"); | |
7237d3de SS |
76 | } |
77 | break; | |
78 | ||
5f3b1a8b | 79 | case ACPI_MADT_TYPE_IO_APIC: |
4be44fcd | 80 | { |
5f3b1a8b AS |
81 | struct acpi_madt_io_apic *p = |
82 | (struct acpi_madt_io_apic *)header; | |
07f438df HG |
83 | pr_debug("IOAPIC (id[0x%02x] address[0x%08x] gsi_base[%d])\n", |
84 | p->id, p->address, p->global_irq_base); | |
4be44fcd | 85 | } |
1da177e4 LT |
86 | break; |
87 | ||
5f3b1a8b | 88 | case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: |
4be44fcd | 89 | { |
5f3b1a8b AS |
90 | struct acpi_madt_interrupt_override *p = |
91 | (struct acpi_madt_interrupt_override *)header; | |
730bf5eb HG |
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]); | |
5f3b1a8b AS |
96 | if (p->inti_flags & |
97 | ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)) | |
730bf5eb HG |
98 | pr_info("INT_SRC_OVR unexpected reserved flags: 0x%x\n", |
99 | p->inti_flags & | |
5f3b1a8b | 100 | ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)); |
4be44fcd | 101 | } |
1da177e4 LT |
102 | break; |
103 | ||
5f3b1a8b | 104 | case ACPI_MADT_TYPE_NMI_SOURCE: |
4be44fcd | 105 | { |
5f3b1a8b AS |
106 | struct acpi_madt_nmi_source *p = |
107 | (struct acpi_madt_nmi_source *)header; | |
730bf5eb HG |
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); | |
4be44fcd | 112 | } |
1da177e4 LT |
113 | break; |
114 | ||
5f3b1a8b | 115 | case ACPI_MADT_TYPE_LOCAL_APIC_NMI: |
4be44fcd | 116 | { |
5f3b1a8b AS |
117 | struct acpi_madt_local_apic_nmi *p = |
118 | (struct acpi_madt_local_apic_nmi *)header; | |
730bf5eb HG |
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); | |
7237d3de SS |
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 | ||
730bf5eb HG |
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); | |
4be44fcd | 141 | } |
1da177e4 LT |
142 | break; |
143 | ||
5f3b1a8b | 144 | case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: |
4be44fcd | 145 | { |
5f3b1a8b AS |
146 | struct acpi_madt_local_apic_override *p = |
147 | (struct acpi_madt_local_apic_override *)header; | |
730bf5eb HG |
148 | pr_info("LAPIC_ADDR_OVR (address[%p])\n", |
149 | (void *)(unsigned long)p->address); | |
4be44fcd | 150 | } |
1da177e4 LT |
151 | break; |
152 | ||
5f3b1a8b | 153 | case ACPI_MADT_TYPE_IO_SAPIC: |
4be44fcd | 154 | { |
5f3b1a8b AS |
155 | struct acpi_madt_io_sapic *p = |
156 | (struct acpi_madt_io_sapic *)header; | |
07f438df HG |
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); | |
4be44fcd | 160 | } |
1da177e4 LT |
161 | break; |
162 | ||
5f3b1a8b | 163 | case ACPI_MADT_TYPE_LOCAL_SAPIC: |
4be44fcd | 164 | { |
5f3b1a8b AS |
165 | struct acpi_madt_local_sapic *p = |
166 | (struct acpi_madt_local_sapic *)header; | |
07f438df HG |
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"); | |
4be44fcd | 170 | } |
1da177e4 LT |
171 | break; |
172 | ||
5f3b1a8b | 173 | case ACPI_MADT_TYPE_INTERRUPT_SOURCE: |
4be44fcd | 174 | { |
5f3b1a8b AS |
175 | struct acpi_madt_interrupt_source *p = |
176 | (struct acpi_madt_interrupt_source *)header; | |
730bf5eb HG |
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); | |
4be44fcd | 182 | } |
1da177e4 LT |
183 | break; |
184 | ||
4c1c8d7a HG |
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 | ||
1da177e4 | 207 | default: |
730bf5eb HG |
208 | pr_warn("Found unsupported MADT entry (type = 0x%x)\n", |
209 | header->type); | |
1da177e4 LT |
210 | break; |
211 | } | |
212 | } | |
213 | ||
9b3fedde LA |
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, | |
f08bb472 | 234 | struct acpi_table_header *table_header, |
9b3fedde LA |
235 | struct acpi_subtable_proc *proc, int proc_num, |
236 | unsigned int max_entries) | |
1da177e4 | 237 | { |
5f3b1a8b | 238 | struct acpi_subtable_header *entry; |
6eb87fed | 239 | unsigned long table_end; |
9b3fedde LA |
240 | int count = 0; |
241 | int i; | |
1da177e4 | 242 | |
68ca4069 | 243 | if (acpi_disabled) |
e5b8fc6a LB |
244 | return -ENODEV; |
245 | ||
9b3fedde | 246 | if (!id) |
1da177e4 LT |
247 | return -EINVAL; |
248 | ||
f08bb472 AC |
249 | if (!table_size) |
250 | return -EINVAL; | |
1da177e4 | 251 | |
6eb87fed | 252 | if (!table_header) { |
730bf5eb | 253 | pr_warn("%4.4s not present\n", id); |
1da177e4 LT |
254 | return -ENODEV; |
255 | } | |
256 | ||
6eb87fed | 257 | table_end = (unsigned long)table_header + table_header->length; |
1da177e4 LT |
258 | |
259 | /* Parse all entries looking for a match. */ | |
260 | ||
5f3b1a8b | 261 | entry = (struct acpi_subtable_header *) |
6eb87fed | 262 | ((unsigned long)table_header + table_size); |
1da177e4 | 263 | |
5f3b1a8b | 264 | while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) < |
6eb87fed | 265 | table_end) { |
9b3fedde LA |
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; | |
362414d9 DC |
272 | if (!proc[i].handler || |
273 | proc[i].handler(entry, table_end)) | |
f08bb472 | 274 | return -EINVAL; |
369d913b | 275 | |
9b3fedde LA |
276 | proc->count++; |
277 | break; | |
4ceacd02 | 278 | } |
9b3fedde LA |
279 | if (i != proc_num) |
280 | count++; | |
4ceacd02 | 281 | |
369d913b FY |
282 | /* |
283 | * If entry->length is 0, break from this loop to avoid | |
284 | * infinite loop. | |
285 | */ | |
286 | if (entry->length == 0) { | |
9b3fedde | 287 | pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id); |
f08bb472 | 288 | return -EINVAL; |
369d913b | 289 | } |
1da177e4 | 290 | |
5f3b1a8b | 291 | entry = (struct acpi_subtable_header *) |
4be44fcd | 292 | ((unsigned long)entry + entry->length); |
1da177e4 | 293 | } |
f08bb472 | 294 | |
1da177e4 | 295 | if (max_entries && count > max_entries) { |
730bf5eb | 296 | pr_warn("[%4.4s:0x%02x] ignored %i entries of %i found\n", |
9b3fedde | 297 | id, proc->id, count - max_entries, count); |
1da177e4 LT |
298 | } |
299 | ||
300 | return count; | |
f08bb472 AC |
301 | } |
302 | ||
303 | int __init | |
9b3fedde LA |
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, | |
f08bb472 | 321 | unsigned long table_size, |
9b3fedde | 322 | struct acpi_subtable_proc *proc, int proc_num, |
f08bb472 AC |
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 | ||
9b3fedde | 333 | if (!id) |
f08bb472 AC |
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 | ||
9b3fedde LA |
345 | count = acpi_parse_entries_array(id, table_size, table_header, |
346 | proc, proc_num, max_entries); | |
f08bb472 | 347 | |
369d913b | 348 | early_acpi_os_unmap_memory((char *)table_header, tbl_size); |
f08bb472 | 349 | return count; |
1da177e4 LT |
350 | } |
351 | ||
9b3fedde LA |
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 | ||
1da177e4 | 368 | int __init |
5f3b1a8b | 369 | acpi_table_parse_madt(enum acpi_madt_type id, |
b43e1065 | 370 | acpi_tbl_entry_handler handler, unsigned int max_entries) |
1da177e4 | 371 | { |
6eb87fed | 372 | return acpi_table_parse_entries(ACPI_SIG_MADT, |
4be44fcd LB |
373 | sizeof(struct acpi_table_madt), id, |
374 | handler, max_entries); | |
1da177e4 LT |
375 | } |
376 | ||
7f8f97c3 LB |
377 | /** |
378 | * acpi_table_parse - find table with @id, run @handler on it | |
7f8f97c3 LB |
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, | |
f8a571b2 | 383 | * run @handler on it. |
384 | * | |
385 | * Return 0 if table found, -errno if not. | |
7f8f97c3 | 386 | */ |
b43e1065 | 387 | int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler) |
1da177e4 | 388 | { |
ceb6c468 | 389 | struct acpi_table_header *table = NULL; |
7d97277b | 390 | acpi_size tbl_size; |
a1fdcc0d | 391 | |
68ca4069 | 392 | if (acpi_disabled) |
e5b8fc6a LB |
393 | return -ENODEV; |
394 | ||
de2d1a7e | 395 | if (!id || !handler) |
1da177e4 LT |
396 | return -EINVAL; |
397 | ||
a1fdcc0d | 398 | if (strncmp(id, ACPI_SIG_MADT, 4) == 0) |
7d97277b | 399 | acpi_get_table_with_size(id, acpi_apic_instance, &table, &tbl_size); |
a1fdcc0d | 400 | else |
7d97277b | 401 | acpi_get_table_with_size(id, 0, &table, &tbl_size); |
a1fdcc0d | 402 | |
ceb6c468 AS |
403 | if (table) { |
404 | handler(table); | |
7d97277b | 405 | early_acpi_os_unmap_memory(table, tbl_size); |
ceb6c468 | 406 | return 0; |
7f8f97c3 | 407 | } else |
95df812d | 408 | return -ENODEV; |
1da177e4 LT |
409 | } |
410 | ||
a1fdcc0d LB |
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; | |
7d97277b | 419 | acpi_size tbl_size; |
a1fdcc0d | 420 | |
7d97277b | 421 | acpi_get_table_with_size(ACPI_SIG_MADT, 2, &table, &tbl_size); |
a1fdcc0d | 422 | if (table) { |
730bf5eb HG |
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); | |
7d97277b | 428 | early_acpi_os_unmap_memory(table, tbl_size); |
a1fdcc0d LB |
429 | |
430 | } else | |
431 | acpi_apic_instance = 0; | |
432 | ||
433 | return; | |
434 | } | |
435 | ||
1da177e4 LT |
436 | /* |
437 | * acpi_table_init() | |
438 | * | |
439 | * find RSDP, find and checksum SDT/XSDT. | |
440 | * checksum all tables, print SDT/XSDT | |
5f3b1a8b | 441 | * |
1da177e4 LT |
442 | * result: sdt_entry[] is initialized |
443 | */ | |
444 | ||
4be44fcd | 445 | int __init acpi_table_init(void) |
1da177e4 | 446 | { |
9e3a9d1e LB |
447 | acpi_status status; |
448 | ||
4fc0a7e8 LZ |
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 | ||
9e3a9d1e LB |
457 | status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); |
458 | if (ACPI_FAILURE(status)) | |
95df812d | 459 | return -EINVAL; |
c85cc817 | 460 | acpi_initrd_initialize_tables(); |
9e3a9d1e | 461 | |
a1fdcc0d LB |
462 | check_multiple_madt(); |
463 | return 0; | |
464 | } | |
465 | ||
466 | static int __init acpi_parse_apic_instance(char *str) | |
467 | { | |
f0df2d6b CG |
468 | if (!str) |
469 | return -EINVAL; | |
a1fdcc0d | 470 | |
3d915894 CJ |
471 | if (kstrtoint(str, 0, &acpi_apic_instance)) |
472 | return -EINVAL; | |
a1fdcc0d | 473 | |
730bf5eb | 474 | pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance); |
a1fdcc0d | 475 | |
1da177e4 LT |
476 | return 0; |
477 | } | |
a1fdcc0d LB |
478 | |
479 | early_param("acpi_apic_instance", acpi_parse_apic_instance); | |
4fc0a7e8 LZ |
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); | |
b2ca5dae CIK |
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); |