2 * apei-base.c - ACPI Platform Error Interface (APEI) supporting
5 * APEI allows to report errors (for example from the chipset) to the
6 * the operating system. This improves NMI handling especially. In
7 * addition it supports error serialization and error injection.
9 * For more information about APEI, please refer to ACPI Specification
10 * version 4.0, chapter 17.
12 * This file has Common functions used by more than one APEI table,
13 * including framework of interpreter for ERST and EINJ; resource
14 * management for APEI registers.
16 * Copyright (C) 2009, Intel Corp.
17 * Author: Huang Ying <ying.huang@intel.com>
19 * This program is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU General Public License version
21 * 2 as published by the Free Software Foundation.
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/acpi.h>
38 #include <linux/kref.h>
39 #include <linux/rculist.h>
40 #include <linux/interrupt.h>
41 #include <linux/debugfs.h>
42 #include <acpi/atomicio.h>
44 #include "apei-internal.h"
46 #define APEI_PFX "APEI: "
49 * APEI ERST (Error Record Serialization Table) and EINJ (Error
50 * INJection) interpreter framework.
53 #define APEI_EXEC_PRESERVE_REGISTER 0x1
55 void apei_exec_ctx_init(struct apei_exec_context *ctx,
56 struct apei_exec_ins_type *ins_table,
58 struct acpi_whea_header *action_table,
61 ctx->ins_table = ins_table;
62 ctx->instructions = instructions;
63 ctx->action_table = action_table;
64 ctx->entries = entries;
66 EXPORT_SYMBOL_GPL(apei_exec_ctx_init);
68 int __apei_exec_read_register(struct acpi_whea_header *entry, u64 *val)
72 rc = acpi_atomic_read(val, &entry->register_region);
75 *val >>= entry->register_region.bit_offset;
81 int apei_exec_read_register(struct apei_exec_context *ctx,
82 struct acpi_whea_header *entry)
87 rc = __apei_exec_read_register(entry, &val);
94 EXPORT_SYMBOL_GPL(apei_exec_read_register);
96 int apei_exec_read_register_value(struct apei_exec_context *ctx,
97 struct acpi_whea_header *entry)
101 rc = apei_exec_read_register(ctx, entry);
104 ctx->value = (ctx->value == entry->value);
108 EXPORT_SYMBOL_GPL(apei_exec_read_register_value);
110 int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val)
115 val <<= entry->register_region.bit_offset;
116 if (entry->flags & APEI_EXEC_PRESERVE_REGISTER) {
118 rc = acpi_atomic_read(&valr, &entry->register_region);
121 valr &= ~(entry->mask << entry->register_region.bit_offset);
124 rc = acpi_atomic_write(val, &entry->register_region);
129 int apei_exec_write_register(struct apei_exec_context *ctx,
130 struct acpi_whea_header *entry)
132 return __apei_exec_write_register(entry, ctx->value);
134 EXPORT_SYMBOL_GPL(apei_exec_write_register);
136 int apei_exec_write_register_value(struct apei_exec_context *ctx,
137 struct acpi_whea_header *entry)
141 ctx->value = entry->value;
142 rc = apei_exec_write_register(ctx, entry);
146 EXPORT_SYMBOL_GPL(apei_exec_write_register_value);
148 int apei_exec_noop(struct apei_exec_context *ctx,
149 struct acpi_whea_header *entry)
153 EXPORT_SYMBOL_GPL(apei_exec_noop);
156 * Interpret the specified action. Go through whole action table,
157 * execute all instructions belong to the action.
159 int apei_exec_run(struct apei_exec_context *ctx, u8 action)
163 struct acpi_whea_header *entry;
164 apei_exec_ins_func_t run;
169 * "ip" is the instruction pointer of current instruction,
170 * "ctx->ip" specifies the next instruction to executed,
171 * instruction "run" function may change the "ctx->ip" to
172 * implement "goto" semantics.
176 for (i = 0; i < ctx->entries; i++) {
177 entry = &ctx->action_table[i];
178 if (entry->action != action)
181 if (entry->instruction >= ctx->instructions ||
182 !ctx->ins_table[entry->instruction].run) {
183 pr_warning(FW_WARN APEI_PFX
184 "Invalid action table, unknown instruction type: %d\n",
188 run = ctx->ins_table[entry->instruction].run;
189 rc = run(ctx, entry);
192 else if (rc != APEI_EXEC_SET_IP)
202 EXPORT_SYMBOL_GPL(apei_exec_run);
204 typedef int (*apei_exec_entry_func_t)(struct apei_exec_context *ctx,
205 struct acpi_whea_header *entry,
208 static int apei_exec_for_each_entry(struct apei_exec_context *ctx,
209 apei_exec_entry_func_t func,
215 struct acpi_whea_header *entry;
216 struct apei_exec_ins_type *ins_table = ctx->ins_table;
218 for (i = 0; i < ctx->entries; i++) {
219 entry = ctx->action_table + i;
220 ins = entry->instruction;
223 if (ins >= ctx->instructions || !ins_table[ins].run) {
224 pr_warning(FW_WARN APEI_PFX
225 "Invalid action table, unknown instruction type: %d\n",
229 rc = func(ctx, entry, data);
237 static int pre_map_gar_callback(struct apei_exec_context *ctx,
238 struct acpi_whea_header *entry,
241 u8 ins = entry->instruction;
243 if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
244 return acpi_pre_map_gar(&entry->register_region);
250 * Pre-map all GARs in action table to make it possible to access them
253 int apei_exec_pre_map_gars(struct apei_exec_context *ctx)
257 rc = apei_exec_for_each_entry(ctx, pre_map_gar_callback,
260 struct apei_exec_context ctx_unmap;
261 memcpy(&ctx_unmap, ctx, sizeof(*ctx));
262 ctx_unmap.entries = end;
263 apei_exec_post_unmap_gars(&ctx_unmap);
268 EXPORT_SYMBOL_GPL(apei_exec_pre_map_gars);
270 static int post_unmap_gar_callback(struct apei_exec_context *ctx,
271 struct acpi_whea_header *entry,
274 u8 ins = entry->instruction;
276 if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
277 acpi_post_unmap_gar(&entry->register_region);
282 /* Post-unmap all GAR in action table. */
283 int apei_exec_post_unmap_gars(struct apei_exec_context *ctx)
285 return apei_exec_for_each_entry(ctx, post_unmap_gar_callback,
288 EXPORT_SYMBOL_GPL(apei_exec_post_unmap_gars);
291 * Resource management for GARs in APEI
294 struct list_head list;
299 /* Collect all resources requested, to avoid conflict */
300 struct apei_resources apei_resources_all = {
301 .iomem = LIST_HEAD_INIT(apei_resources_all.iomem),
302 .ioport = LIST_HEAD_INIT(apei_resources_all.ioport),
305 static int apei_res_add(struct list_head *res_list,
306 unsigned long start, unsigned long size)
308 struct apei_res *res, *resn, *res_ins = NULL;
309 unsigned long end = start + size;
314 list_for_each_entry_safe(res, resn, res_list, list) {
315 if (res->start > end || res->end < start)
317 else if (end <= res->end && start >= res->start) {
321 list_del(&res->list);
322 res->start = start = min(res->start, start);
323 res->end = end = max(res->end, end);
330 list_add(&res_ins->list, res_list);
332 res_ins = kmalloc(sizeof(*res), GFP_KERNEL);
335 res_ins->start = start;
337 list_add(&res_ins->list, res_list);
343 static int apei_res_sub(struct list_head *res_list1,
344 struct list_head *res_list2)
346 struct apei_res *res1, *resn1, *res2, *res;
347 res1 = list_entry(res_list1->next, struct apei_res, list);
348 resn1 = list_entry(res1->list.next, struct apei_res, list);
349 while (&res1->list != res_list1) {
350 list_for_each_entry(res2, res_list2, list) {
351 if (res1->start >= res2->end ||
352 res1->end <= res2->start)
354 else if (res1->end <= res2->end &&
355 res1->start >= res2->start) {
356 list_del(&res1->list);
359 } else if (res1->end > res2->end &&
360 res1->start < res2->start) {
361 res = kmalloc(sizeof(*res), GFP_KERNEL);
364 res->start = res2->end;
365 res->end = res1->end;
366 res1->end = res2->start;
367 list_add(&res->list, &res1->list);
370 if (res1->start < res2->start)
371 res1->end = res2->start;
373 res1->start = res2->end;
377 resn1 = list_entry(resn1->list.next, struct apei_res, list);
383 static void apei_res_clean(struct list_head *res_list)
385 struct apei_res *res, *resn;
387 list_for_each_entry_safe(res, resn, res_list, list) {
388 list_del(&res->list);
393 void apei_resources_fini(struct apei_resources *resources)
395 apei_res_clean(&resources->iomem);
396 apei_res_clean(&resources->ioport);
398 EXPORT_SYMBOL_GPL(apei_resources_fini);
400 static int apei_resources_merge(struct apei_resources *resources1,
401 struct apei_resources *resources2)
404 struct apei_res *res;
406 list_for_each_entry(res, &resources2->iomem, list) {
407 rc = apei_res_add(&resources1->iomem, res->start,
408 res->end - res->start);
412 list_for_each_entry(res, &resources2->ioport, list) {
413 rc = apei_res_add(&resources1->ioport, res->start,
414 res->end - res->start);
423 * EINJ has two groups of GARs (EINJ table entry and trigger table
424 * entry), so common resources are subtracted from the trigger table
425 * resources before the second requesting.
427 int apei_resources_sub(struct apei_resources *resources1,
428 struct apei_resources *resources2)
432 rc = apei_res_sub(&resources1->iomem, &resources2->iomem);
435 return apei_res_sub(&resources1->ioport, &resources2->ioport);
437 EXPORT_SYMBOL_GPL(apei_resources_sub);
440 * IO memory/port rersource management mechanism is used to check
441 * whether memory/port area used by GARs conflicts with normal memory
442 * or IO memory/port of devices.
444 int apei_resources_request(struct apei_resources *resources,
447 struct apei_res *res, *res_bak;
450 apei_resources_sub(resources, &apei_resources_all);
452 list_for_each_entry(res, &resources->iomem, list) {
453 r = request_mem_region(res->start, res->end - res->start,
457 "Can not request iomem region <%016llx-%016llx> for GARs.\n",
458 (unsigned long long)res->start,
459 (unsigned long long)res->end);
461 goto err_unmap_iomem;
465 list_for_each_entry(res, &resources->ioport, list) {
466 r = request_region(res->start, res->end - res->start, desc);
469 "Can not request ioport region <%016llx-%016llx> for GARs.\n",
470 (unsigned long long)res->start,
471 (unsigned long long)res->end);
473 goto err_unmap_ioport;
477 apei_resources_merge(&apei_resources_all, resources);
481 list_for_each_entry(res, &resources->ioport, list) {
484 release_mem_region(res->start, res->end - res->start);
488 list_for_each_entry(res, &resources->iomem, list) {
491 release_region(res->start, res->end - res->start);
495 EXPORT_SYMBOL_GPL(apei_resources_request);
497 void apei_resources_release(struct apei_resources *resources)
499 struct apei_res *res;
501 list_for_each_entry(res, &resources->iomem, list)
502 release_mem_region(res->start, res->end - res->start);
503 list_for_each_entry(res, &resources->ioport, list)
504 release_region(res->start, res->end - res->start);
506 apei_resources_sub(&apei_resources_all, resources);
508 EXPORT_SYMBOL_GPL(apei_resources_release);
510 static int apei_check_gar(struct acpi_generic_address *reg, u64 *paddr)
514 width = reg->bit_width;
515 space_id = reg->space_id;
516 /* Handle possible alignment issues */
517 memcpy(paddr, ®->address, sizeof(*paddr));
519 pr_warning(FW_BUG APEI_PFX
520 "Invalid physical address in GAR [0x%llx/%u/%u]\n",
521 *paddr, width, space_id);
525 if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) {
526 pr_warning(FW_BUG APEI_PFX
527 "Invalid bit width in GAR [0x%llx/%u/%u]\n",
528 *paddr, width, space_id);
532 if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
533 space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
534 pr_warning(FW_BUG APEI_PFX
535 "Invalid address space type in GAR [0x%llx/%u/%u]\n",
536 *paddr, width, space_id);
543 static int collect_res_callback(struct apei_exec_context *ctx,
544 struct acpi_whea_header *entry,
547 struct apei_resources *resources = data;
548 struct acpi_generic_address *reg = &entry->register_region;
549 u8 ins = entry->instruction;
553 if (!(ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER))
556 rc = apei_check_gar(reg, &paddr);
560 switch (reg->space_id) {
561 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
562 return apei_res_add(&resources->iomem, paddr,
564 case ACPI_ADR_SPACE_SYSTEM_IO:
565 return apei_res_add(&resources->ioport, paddr,
573 * Same register may be used by multiple instructions in GARs, so
574 * resources are collected before requesting.
576 int apei_exec_collect_resources(struct apei_exec_context *ctx,
577 struct apei_resources *resources)
579 return apei_exec_for_each_entry(ctx, collect_res_callback,
582 EXPORT_SYMBOL_GPL(apei_exec_collect_resources);
584 struct dentry *apei_get_debugfs_dir(void)
586 static struct dentry *dapei;
589 dapei = debugfs_create_dir("apei", NULL);
593 EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);