blob: 4dfbf491b6e370c5cc2ca2b8337e76b8b40603eb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19 *
20 */
21
Hanjun Guo07f438d2015-03-24 14:02:34 +000022/* Uncomment next line to get verbose printout */
23/* #define DEBUG */
Hanjun Guo730bf5e2014-02-20 15:45:33 +080024#define pr_fmt(fmt) "ACPI: " fmt
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/init.h>
27#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#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>
Lv Zheng5ae74f2c2016-04-11 10:13:18 +080035#include <linux/earlycpio.h>
36#include <linux/memblock.h>
Aleksey Makarovda3d3f92016-06-20 13:56:10 +030037#include <linux/initrd.h>
Aleksey Makarov84b06ca2016-06-20 13:56:11 +030038#include <linux/acpi.h>
Lv Zhengc85cc812016-03-02 14:16:25 +080039#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Rafael J. Wysocki74216692016-05-06 01:27:09 +020041#ifdef CONFIG_ACPI_CUSTOM_DSDT
42#include CONFIG_ACPI_CUSTOM_DSDT_FILE
43#endif
44
Len Brown04348e62005-12-30 02:44:59 -050045#define ACPI_MAX_TABLES 128
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" };
48static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" };
49
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +030050static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Len Brown4e381a42007-03-30 14:16:10 -040052static int acpi_apic_instance __initdata;
Len Browna1fdcc02007-03-11 03:26:14 -040053
Lv Zheng4fc0a7e2014-05-31 08:15:02 +080054/*
55 * Disable table checksum verification for the early stage due to the size
56 * limitation of the current x86 early mapping implementation.
57 */
58static bool acpi_verify_table_checksum __initdata = false;
59
Len Browna1fdcc02007-03-11 03:26:14 -040060void acpi_table_print_madt_entry(struct acpi_subtable_header *header)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{
62 if (!header)
63 return;
64
65 switch (header->type) {
66
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +030067 case ACPI_MADT_TYPE_LOCAL_APIC:
Len Brown4be44fc2005-08-05 00:44:28 -040068 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +030069 struct acpi_madt_local_apic *p =
70 (struct acpi_madt_local_apic *)header;
Hanjun Guo07f438d2015-03-24 14:02:34 +000071 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");
Len Brown4be44fc2005-08-05 00:44:28 -040074 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 break;
76
Suresh Siddha7237d3d2009-03-30 13:55:30 -080077 case ACPI_MADT_TYPE_LOCAL_X2APIC:
78 {
79 struct acpi_madt_local_x2apic *p =
80 (struct acpi_madt_local_x2apic *)header;
Hanjun Guo07f438d2015-03-24 14:02:34 +000081 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");
Suresh Siddha7237d3d2009-03-30 13:55:30 -080084 }
85 break;
86
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +030087 case ACPI_MADT_TYPE_IO_APIC:
Len Brown4be44fc2005-08-05 00:44:28 -040088 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +030089 struct acpi_madt_io_apic *p =
90 (struct acpi_madt_io_apic *)header;
Hanjun Guo07f438d2015-03-24 14:02:34 +000091 pr_debug("IOAPIC (id[0x%02x] address[0x%08x] gsi_base[%d])\n",
92 p->id, p->address, p->global_irq_base);
Len Brown4be44fc2005-08-05 00:44:28 -040093 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 break;
95
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +030096 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
Len Brown4be44fc2005-08-05 00:44:28 -040097 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +030098 struct acpi_madt_interrupt_override *p =
99 (struct acpi_madt_interrupt_override *)header;
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800100 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]);
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300104 if (p->inti_flags &
105 ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK))
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800106 pr_info("INT_SRC_OVR unexpected reserved flags: 0x%x\n",
107 p->inti_flags &
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300108 ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK));
Len Brown4be44fc2005-08-05 00:44:28 -0400109 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 break;
111
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300112 case ACPI_MADT_TYPE_NMI_SOURCE:
Len Brown4be44fc2005-08-05 00:44:28 -0400113 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300114 struct acpi_madt_nmi_source *p =
115 (struct acpi_madt_nmi_source *)header;
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800116 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);
Len Brown4be44fc2005-08-05 00:44:28 -0400120 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 break;
122
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300123 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
Len Brown4be44fc2005-08-05 00:44:28 -0400124 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300125 struct acpi_madt_local_apic_nmi *p =
126 (struct acpi_madt_local_apic_nmi *)header;
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800127 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);
Len Brown4be44fc2005-08-05 00:44:28 -0400132 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 break;
134
Suresh Siddha7237d3d2009-03-30 13:55:30 -0800135 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
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800144 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);
Suresh Siddha7237d3d2009-03-30 13:55:30 -0800149 }
150 break;
151
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300152 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
Len Brown4be44fc2005-08-05 00:44:28 -0400153 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300154 struct acpi_madt_local_apic_override *p =
155 (struct acpi_madt_local_apic_override *)header;
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800156 pr_info("LAPIC_ADDR_OVR (address[%p])\n",
157 (void *)(unsigned long)p->address);
Len Brown4be44fc2005-08-05 00:44:28 -0400158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 break;
160
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300161 case ACPI_MADT_TYPE_IO_SAPIC:
Len Brown4be44fc2005-08-05 00:44:28 -0400162 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300163 struct acpi_madt_io_sapic *p =
164 (struct acpi_madt_io_sapic *)header;
Hanjun Guo07f438d2015-03-24 14:02:34 +0000165 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);
Len Brown4be44fc2005-08-05 00:44:28 -0400168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 break;
170
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300171 case ACPI_MADT_TYPE_LOCAL_SAPIC:
Len Brown4be44fc2005-08-05 00:44:28 -0400172 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300173 struct acpi_madt_local_sapic *p =
174 (struct acpi_madt_local_sapic *)header;
Hanjun Guo07f438d2015-03-24 14:02:34 +0000175 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");
Len Brown4be44fc2005-08-05 00:44:28 -0400178 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 break;
180
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300181 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
Len Brown4be44fc2005-08-05 00:44:28 -0400182 {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300183 struct acpi_madt_interrupt_source *p =
184 (struct acpi_madt_interrupt_source *)header;
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800185 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);
Len Brown4be44fc2005-08-05 00:44:28 -0400190 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 break;
192
Hanjun Guo4c1c8d72015-03-24 14:02:44 +0000193 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 default:
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800216 pr_warn("Found unsupported MADT entry (type = 0x%x)\n",
217 header->type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 break;
219 }
220}
221
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200222/**
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 */
240static int __init
241acpi_parse_entries_array(char *id, unsigned long table_size,
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800242 struct acpi_table_header *table_header,
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200243 struct acpi_subtable_proc *proc, int proc_num,
244 unsigned int max_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245{
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300246 struct acpi_subtable_header *entry;
Len Brown6eb87fe2007-02-10 22:17:07 -0500247 unsigned long table_end;
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200248 int count = 0;
Al Stone8726d4f2016-08-19 18:48:12 -0600249 int errs = 0;
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200250 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Len Brown68ca4062010-02-19 00:09:22 -0500252 if (acpi_disabled)
Len Browne5b8fc62009-07-07 23:22:58 -0400253 return -ENODEV;
254
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200255 if (!id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 return -EINVAL;
257
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800258 if (!table_size)
259 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Len Brown6eb87fe2007-02-10 22:17:07 -0500261 if (!table_header) {
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800262 pr_warn("%4.4s not present\n", id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return -ENODEV;
264 }
265
Len Brown6eb87fe2007-02-10 22:17:07 -0500266 table_end = (unsigned long)table_header + table_header->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 /* Parse all entries looking for a match. */
269
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300270 entry = (struct acpi_subtable_header *)
Len Brown6eb87fe2007-02-10 22:17:07 -0500271 ((unsigned long)table_header + table_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300273 while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) <
Len Brown6eb87fe2007-02-10 22:17:07 -0500274 table_end) {
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200275 if (max_entries && count >= max_entries)
276 break;
277
278 for (i = 0; i < proc_num; i++) {
279 if (entry->type != proc[i].id)
280 continue;
Dan Carpenter362414d2015-09-22 15:29:25 +0300281 if (!proc[i].handler ||
Al Stone8726d4f2016-08-19 18:48:12 -0600282 (!errs && proc[i].handler(entry, table_end))) {
283 errs++;
284 continue;
285 }
Fenghua Yu369d9132012-09-25 11:11:43 -0700286
Al Stonefa162a02016-08-19 18:48:11 -0600287 proc[i].count++;
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200288 break;
Tomasz Nowicki4ceacd02014-11-26 22:01:14 +0800289 }
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200290 if (i != proc_num)
291 count++;
Tomasz Nowicki4ceacd02014-11-26 22:01:14 +0800292
Fenghua Yu369d9132012-09-25 11:11:43 -0700293 /*
294 * If entry->length is 0, break from this loop to avoid
295 * infinite loop.
296 */
297 if (entry->length == 0) {
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200298 pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id);
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800299 return -EINVAL;
Fenghua Yu369d9132012-09-25 11:11:43 -0700300 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300302 entry = (struct acpi_subtable_header *)
Len Brown4be44fc2005-08-05 00:44:28 -0400303 ((unsigned long)entry + entry->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 }
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 if (max_entries && count > max_entries) {
Al Stone99b0efd2016-08-19 18:48:13 -0600307 pr_warn("[%4.4s:0x%02x] found the maximum %i entries\n",
308 id, proc->id, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 }
310
Al Stone8726d4f2016-08-19 18:48:12 -0600311 return errs ? -EINVAL : count;
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800312}
313
314int __init
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200315acpi_parse_entries(char *id,
316 unsigned long table_size,
317 acpi_tbl_entry_handler handler,
318 struct acpi_table_header *table_header,
319 int entry_id, unsigned int max_entries)
320{
321 struct acpi_subtable_proc proc = {
322 .id = entry_id,
323 .handler = handler,
324 };
325
326 return acpi_parse_entries_array(id, table_size, table_header,
327 &proc, 1, max_entries);
328}
329
330int __init
331acpi_table_parse_entries_array(char *id,
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800332 unsigned long table_size,
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200333 struct acpi_subtable_proc *proc, int proc_num,
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800334 unsigned int max_entries)
335{
336 struct acpi_table_header *table_header = NULL;
337 acpi_size tbl_size;
338 int count;
339 u32 instance = 0;
340
341 if (acpi_disabled)
342 return -ENODEV;
343
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200344 if (!id)
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800345 return -EINVAL;
346
347 if (!strncmp(id, ACPI_SIG_MADT, 4))
348 instance = acpi_apic_instance;
349
350 acpi_get_table_with_size(id, instance, &table_header, &tbl_size);
351 if (!table_header) {
352 pr_warn("%4.4s not present\n", id);
353 return -ENODEV;
354 }
355
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200356 count = acpi_parse_entries_array(id, table_size, table_header,
357 proc, proc_num, max_entries);
Ashwin Chaugulef08bb472014-11-26 22:01:13 +0800358
Yinghai Lu7d972772009-02-07 15:39:41 -0800359 early_acpi_os_unmap_memory((char *)table_header, tbl_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 return count;
361}
362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363int __init
Lukasz Anaczkowski9b3fedd2015-09-09 15:47:28 +0200364acpi_table_parse_entries(char *id,
365 unsigned long table_size,
366 int entry_id,
367 acpi_tbl_entry_handler handler,
368 unsigned int max_entries)
369{
370 struct acpi_subtable_proc proc = {
371 .id = entry_id,
372 .handler = handler,
373 };
374
375 return acpi_table_parse_entries_array(id, table_size, &proc, 1,
376 max_entries);
377}
378
379int __init
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300380acpi_table_parse_madt(enum acpi_madt_type id,
Lv Zhengb43e1062013-01-12 15:29:38 +0000381 acpi_tbl_entry_handler handler, unsigned int max_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382{
Len Brown6eb87fe2007-02-10 22:17:07 -0500383 return acpi_table_parse_entries(ACPI_SIG_MADT,
Len Brown4be44fc2005-08-05 00:44:28 -0400384 sizeof(struct acpi_table_madt), id,
385 handler, max_entries);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386}
387
Len Brown7f8f97c2007-02-10 21:28:03 -0500388/**
389 * acpi_table_parse - find table with @id, run @handler on it
Len Brown7f8f97c2007-02-10 21:28:03 -0500390 * @id: table id to find
391 * @handler: handler to run
392 *
393 * Scan the ACPI System Descriptor Table (STD) for a table matching @id,
tangchenf8a571b2014-01-06 16:47:59 +0800394 * run @handler on it.
395 *
396 * Return 0 if table found, -errno if not.
Len Brown7f8f97c2007-02-10 21:28:03 -0500397 */
Lv Zhengb43e1062013-01-12 15:29:38 +0000398int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399{
Alexey Starikovskiyceb6c462007-02-02 19:48:22 +0300400 struct acpi_table_header *table = NULL;
Yinghai Lu7d972772009-02-07 15:39:41 -0800401 acpi_size tbl_size;
Len Browna1fdcc02007-03-11 03:26:14 -0400402
Len Brown68ca4062010-02-19 00:09:22 -0500403 if (acpi_disabled)
Len Browne5b8fc62009-07-07 23:22:58 -0400404 return -ENODEV;
405
tangchende2d1a72014-01-06 16:43:54 +0800406 if (!id || !handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return -EINVAL;
408
Len Browna1fdcc02007-03-11 03:26:14 -0400409 if (strncmp(id, ACPI_SIG_MADT, 4) == 0)
Yinghai Lu7d972772009-02-07 15:39:41 -0800410 acpi_get_table_with_size(id, acpi_apic_instance, &table, &tbl_size);
Len Browna1fdcc02007-03-11 03:26:14 -0400411 else
Yinghai Lu7d972772009-02-07 15:39:41 -0800412 acpi_get_table_with_size(id, 0, &table, &tbl_size);
Len Browna1fdcc02007-03-11 03:26:14 -0400413
Alexey Starikovskiyceb6c462007-02-02 19:48:22 +0300414 if (table) {
415 handler(table);
Yinghai Lu7d972772009-02-07 15:39:41 -0800416 early_acpi_os_unmap_memory(table, tbl_size);
Alexey Starikovskiyceb6c462007-02-02 19:48:22 +0300417 return 0;
Len Brown7f8f97c2007-02-10 21:28:03 -0500418 } else
Hanjun Guo95df8122013-12-05 23:42:38 +0800419 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420}
421
Len Browna1fdcc02007-03-11 03:26:14 -0400422/*
423 * The BIOS is supposed to supply a single APIC/MADT,
424 * but some report two. Provide a knob to use either.
425 * (don't you wish instance 0 and 1 were not the same?)
426 */
427static void __init check_multiple_madt(void)
428{
429 struct acpi_table_header *table = NULL;
Yinghai Lu7d972772009-02-07 15:39:41 -0800430 acpi_size tbl_size;
Len Browna1fdcc02007-03-11 03:26:14 -0400431
Yinghai Lu7d972772009-02-07 15:39:41 -0800432 acpi_get_table_with_size(ACPI_SIG_MADT, 2, &table, &tbl_size);
Len Browna1fdcc02007-03-11 03:26:14 -0400433 if (table) {
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800434 pr_warn("BIOS bug: multiple APIC/MADT found, using %d\n",
435 acpi_apic_instance);
436 pr_warn("If \"acpi_apic_instance=%d\" works better, "
437 "notify linux-acpi@vger.kernel.org\n",
438 acpi_apic_instance ? 0 : 2);
Yinghai Lu7d972772009-02-07 15:39:41 -0800439 early_acpi_os_unmap_memory(table, tbl_size);
Len Browna1fdcc02007-03-11 03:26:14 -0400440
441 } else
442 acpi_apic_instance = 0;
443
444 return;
445}
446
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800447static void acpi_table_taint(struct acpi_table_header *table)
448{
449 pr_warn("Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",
450 table->signature, table->oem_table_id);
451 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
452}
453
Lv Zheng5d881322016-04-11 10:13:33 +0800454#ifdef CONFIG_ACPI_TABLE_UPGRADE
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800455static u64 acpi_tables_addr;
456static int all_tables_size;
457
458/* Copied from acpica/tbutils.c:acpi_tb_checksum() */
459static u8 __init acpi_table_checksum(u8 *buffer, u32 length)
460{
461 u8 sum = 0;
462 u8 *end = buffer + length;
463
464 while (buffer < end)
465 sum = (u8) (sum + *(buffer++));
466 return sum;
467}
468
469/* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */
470static const char * const table_sigs[] = {
471 ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ,
472 ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT,
473 ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF,
474 ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET,
475 ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI,
476 ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA,
477 ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT,
478 ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
479 ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
480
481#define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
482
Lv Zheng5d881322016-04-11 10:13:33 +0800483#define NR_ACPI_INITRD_TABLES 64
484static struct cpio_data __initdata acpi_initrd_files[NR_ACPI_INITRD_TABLES];
485static DECLARE_BITMAP(acpi_initrd_installed, NR_ACPI_INITRD_TABLES);
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800486
487#define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT)
488
Aleksey Makarovda3d3f92016-06-20 13:56:10 +0300489void __init acpi_table_upgrade(void)
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800490{
Aleksey Makarovda3d3f92016-06-20 13:56:10 +0300491 void *data = (void *)initrd_start;
492 size_t size = initrd_end - initrd_start;
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800493 int sig, no, table_nr = 0, total_offset = 0;
494 long offset = 0;
495 struct acpi_table_header *table;
496 char cpio_path[32] = "kernel/firmware/acpi/";
497 struct cpio_data file;
498
499 if (data == NULL || size == 0)
500 return;
501
Lv Zheng5d881322016-04-11 10:13:33 +0800502 for (no = 0; no < NR_ACPI_INITRD_TABLES; no++) {
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800503 file = find_cpio_data(cpio_path, data, size, &offset);
504 if (!file.data)
505 break;
506
507 data += offset;
508 size -= offset;
509
510 if (file.size < sizeof(struct acpi_table_header)) {
511 pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n",
512 cpio_path, file.name);
513 continue;
514 }
515
516 table = file.data;
517
518 for (sig = 0; table_sigs[sig]; sig++)
519 if (!memcmp(table->signature, table_sigs[sig], 4))
520 break;
521
522 if (!table_sigs[sig]) {
523 pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n",
524 cpio_path, file.name);
525 continue;
526 }
527 if (file.size != table->length) {
528 pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n",
529 cpio_path, file.name);
530 continue;
531 }
532 if (acpi_table_checksum(file.data, table->length)) {
533 pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n",
534 cpio_path, file.name);
535 continue;
536 }
537
538 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
539 table->signature, cpio_path, file.name, table->length);
540
541 all_tables_size += table->length;
542 acpi_initrd_files[table_nr].data = file.data;
543 acpi_initrd_files[table_nr].size = file.size;
544 table_nr++;
545 }
546 if (table_nr == 0)
547 return;
548
549 acpi_tables_addr =
Aleksey Makarov84b06ca2016-06-20 13:56:11 +0300550 memblock_find_in_range(0, ACPI_TABLE_UPGRADE_MAX_PHYS,
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800551 all_tables_size, PAGE_SIZE);
552 if (!acpi_tables_addr) {
553 WARN_ON(1);
554 return;
555 }
556 /*
557 * Only calling e820_add_reserve does not work and the
558 * tables are invalid (memory got used) later.
559 * memblock_reserve works as expected and the tables won't get modified.
560 * But it's not enough on X86 because ioremap will
561 * complain later (used by acpi_os_map_memory) that the pages
562 * that should get mapped are not marked "reserved".
563 * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area)
564 * works fine.
565 */
566 memblock_reserve(acpi_tables_addr, all_tables_size);
567 arch_reserve_mem_area(acpi_tables_addr, all_tables_size);
568
569 /*
570 * early_ioremap only can remap 256k one time. If we map all
571 * tables one time, we will hit the limit. Need to map chunks
572 * one by one during copying the same as that in relocate_initrd().
573 */
574 for (no = 0; no < table_nr; no++) {
575 unsigned char *src_p = acpi_initrd_files[no].data;
576 phys_addr_t size = acpi_initrd_files[no].size;
577 phys_addr_t dest_addr = acpi_tables_addr + total_offset;
578 phys_addr_t slop, clen;
579 char *dest_p;
580
581 total_offset += size;
582
583 while (size) {
584 slop = dest_addr & ~PAGE_MASK;
585 clen = size;
586 if (clen > MAP_CHUNK_SIZE - slop)
587 clen = MAP_CHUNK_SIZE - slop;
Aleksey Makarovce0c1fc2016-06-20 13:56:09 +0300588 dest_p = early_memremap(dest_addr & PAGE_MASK,
589 clen + slop);
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800590 memcpy(dest_p + slop, src_p, clen);
Aleksey Makarovce0c1fc2016-06-20 13:56:09 +0300591 early_memunmap(dest_p, clen + slop);
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800592 src_p += clen;
593 dest_addr += clen;
594 size -= clen;
595 }
596 }
597}
598
599static acpi_status
600acpi_table_initrd_override(struct acpi_table_header *existing_table,
601 acpi_physical_address *address, u32 *length)
602{
603 int table_offset = 0;
604 int table_index = 0;
605 struct acpi_table_header *table;
606 u32 table_length;
607
608 *length = 0;
609 *address = 0;
610 if (!acpi_tables_addr)
611 return AE_OK;
612
613 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) {
614 table = acpi_os_map_memory(acpi_tables_addr + table_offset,
615 ACPI_HEADER_SIZE);
616 if (table_offset + table->length > all_tables_size) {
617 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
618 WARN_ON(1);
619 return AE_OK;
620 }
621
622 table_length = table->length;
623
624 /* Only override tables matched */
Lv Zheng5d881322016-04-11 10:13:33 +0800625 if (memcmp(existing_table->signature, table->signature, 4) ||
626 memcmp(table->oem_id, existing_table->oem_id,
627 ACPI_OEM_ID_SIZE) ||
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800628 memcmp(table->oem_table_id, existing_table->oem_table_id,
629 ACPI_OEM_TABLE_ID_SIZE)) {
630 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
631 goto next_table;
632 }
Lv Zheng5d881322016-04-11 10:13:33 +0800633 /*
634 * Mark the table to avoid being used in
635 * acpi_table_initrd_scan() and check the revision.
636 */
637 if (test_and_set_bit(table_index, acpi_initrd_installed) ||
638 existing_table->oem_revision >= table->oem_revision) {
639 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
640 goto next_table;
641 }
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800642
643 *length = table_length;
644 *address = acpi_tables_addr + table_offset;
Lv Zheng5d881322016-04-11 10:13:33 +0800645 pr_info("Table Upgrade: override [%4.4s-%6.6s-%8.8s]\n",
646 table->signature, table->oem_id,
647 table->oem_table_id);
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800648 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800649 break;
650
651next_table:
652 table_offset += table_length;
653 table_index++;
654 }
655 return AE_OK;
656}
657
658static void __init acpi_table_initrd_scan(void)
659{
660 int table_offset = 0;
661 int table_index = 0;
662 u32 table_length;
663 struct acpi_table_header *table;
664
665 if (!acpi_tables_addr)
666 return;
667
668 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) {
669 table = acpi_os_map_memory(acpi_tables_addr + table_offset,
670 ACPI_HEADER_SIZE);
671 if (table_offset + table->length > all_tables_size) {
672 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
673 WARN_ON(1);
674 return;
675 }
676
677 table_length = table->length;
678
679 /* Skip RSDT/XSDT which should only be used for override */
Lv Zheng5d881322016-04-11 10:13:33 +0800680 if (ACPI_COMPARE_NAME(table->signature, ACPI_SIG_RSDT) ||
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800681 ACPI_COMPARE_NAME(table->signature, ACPI_SIG_XSDT)) {
682 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
683 goto next_table;
684 }
Lv Zheng5d881322016-04-11 10:13:33 +0800685 /*
686 * Mark the table to avoid being used in
687 * acpi_table_initrd_override(). Though this is not possible
688 * because override is disabled in acpi_install_table().
689 */
690 if (test_and_set_bit(table_index, acpi_initrd_installed)) {
691 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
692 goto next_table;
693 }
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800694
Lv Zheng5d881322016-04-11 10:13:33 +0800695 pr_info("Table Upgrade: install [%4.4s-%6.6s-%8.8s]\n",
696 table->signature, table->oem_id,
697 table->oem_table_id);
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800698 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
699 acpi_install_table(acpi_tables_addr + table_offset, TRUE);
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800700next_table:
701 table_offset += table_length;
702 table_index++;
703 }
704}
705#else
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800706static acpi_status
707acpi_table_initrd_override(struct acpi_table_header *existing_table,
708 acpi_physical_address *address,
709 u32 *table_length)
710{
711 *table_length = 0;
712 *address = 0;
713 return AE_OK;
714}
715
716static void __init acpi_table_initrd_scan(void)
717{
718}
Lv Zheng5d881322016-04-11 10:13:33 +0800719#endif /* CONFIG_ACPI_TABLE_UPGRADE */
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800720
721acpi_status
722acpi_os_physical_table_override(struct acpi_table_header *existing_table,
723 acpi_physical_address *address,
724 u32 *table_length)
725{
726 return acpi_table_initrd_override(existing_table, address,
727 table_length);
728}
729
730acpi_status
731acpi_os_table_override(struct acpi_table_header *existing_table,
732 struct acpi_table_header **new_table)
733{
734 if (!existing_table || !new_table)
735 return AE_BAD_PARAMETER;
736
737 *new_table = NULL;
738
739#ifdef CONFIG_ACPI_CUSTOM_DSDT
740 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
741 *new_table = (struct acpi_table_header *)AmlCode;
742#endif
743 if (*new_table != NULL)
744 acpi_table_taint(existing_table);
745 return AE_OK;
746}
747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748/*
749 * acpi_table_init()
750 *
751 * find RSDP, find and checksum SDT/XSDT.
752 * checksum all tables, print SDT/XSDT
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300753 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 * result: sdt_entry[] is initialized
755 */
756
Len Brown4be44fc2005-08-05 00:44:28 -0400757int __init acpi_table_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758{
Len Brown9e3a9d12009-02-06 14:00:56 -0500759 acpi_status status;
760
Lv Zheng4fc0a7e2014-05-31 08:15:02 +0800761 if (acpi_verify_table_checksum) {
762 pr_info("Early table checksum verification enabled\n");
763 acpi_gbl_verify_table_checksum = TRUE;
764 } else {
765 pr_info("Early table checksum verification disabled\n");
766 acpi_gbl_verify_table_checksum = FALSE;
767 }
768
Len Brown9e3a9d12009-02-06 14:00:56 -0500769 status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0);
770 if (ACPI_FAILURE(status))
Hanjun Guo95df8122013-12-05 23:42:38 +0800771 return -EINVAL;
Lv Zheng5ae74f2c2016-04-11 10:13:18 +0800772 acpi_table_initrd_scan();
Len Brown9e3a9d12009-02-06 14:00:56 -0500773
Len Browna1fdcc02007-03-11 03:26:14 -0400774 check_multiple_madt();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 return 0;
776}
Len Browna1fdcc02007-03-11 03:26:14 -0400777
778static int __init acpi_parse_apic_instance(char *str)
779{
Cyrill Gorcunovf0df2d62008-08-20 16:41:45 -0700780 if (!str)
781 return -EINVAL;
Len Browna1fdcc02007-03-11 03:26:14 -0400782
Christoph Jaeger3d915892014-06-13 21:49:58 +0200783 if (kstrtoint(str, 0, &acpi_apic_instance))
784 return -EINVAL;
Len Browna1fdcc02007-03-11 03:26:14 -0400785
Hanjun Guo730bf5e2014-02-20 15:45:33 +0800786 pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance);
Len Browna1fdcc02007-03-11 03:26:14 -0400787
788 return 0;
789}
790
791early_param("acpi_apic_instance", acpi_parse_apic_instance);
Lv Zheng4fc0a7e2014-05-31 08:15:02 +0800792
793static int __init acpi_force_table_verification_setup(char *s)
794{
795 acpi_verify_table_checksum = true;
796
797 return 0;
798}
799
800early_param("acpi_force_table_verification", acpi_force_table_verification_setup);
Colin Ian Kingb2ca5da2016-01-21 17:05:47 +0000801
802static int __init acpi_force_32bit_fadt_addr(char *s)
803{
804 pr_info("Forcing 32 Bit FADT addresses\n");
805 acpi_gbl_use32_bit_fadt_addresses = TRUE;
806
807 return 0;
808}
809
810early_param("acpi_force_32bit_fadt_addr", acpi_force_32bit_fadt_addr);