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>
37 #include <linux/slab.h>
39 #include <linux/kref.h>
40 #include <linux/rculist.h>
41 #include <linux/interrupt.h>
42 #include <linux/debugfs.h>
43 #include <acpi/atomicio.h>
45 #include "apei-internal.h"
47 #define APEI_PFX "APEI: "
50 * APEI ERST (Error Record Serialization Table) and EINJ (Error
51 * INJection) interpreter framework.
54 #define APEI_EXEC_PRESERVE_REGISTER 0x1
56 void apei_exec_ctx_init(struct apei_exec_context
*ctx
,
57 struct apei_exec_ins_type
*ins_table
,
59 struct acpi_whea_header
*action_table
,
62 ctx
->ins_table
= ins_table
;
63 ctx
->instructions
= instructions
;
64 ctx
->action_table
= action_table
;
65 ctx
->entries
= entries
;
67 EXPORT_SYMBOL_GPL(apei_exec_ctx_init
);
69 int __apei_exec_read_register(struct acpi_whea_header
*entry
, u64
*val
)
73 rc
= acpi_atomic_read(val
, &entry
->register_region
);
76 *val
>>= entry
->register_region
.bit_offset
;
82 int apei_exec_read_register(struct apei_exec_context
*ctx
,
83 struct acpi_whea_header
*entry
)
88 rc
= __apei_exec_read_register(entry
, &val
);
95 EXPORT_SYMBOL_GPL(apei_exec_read_register
);
97 int apei_exec_read_register_value(struct apei_exec_context
*ctx
,
98 struct acpi_whea_header
*entry
)
102 rc
= apei_exec_read_register(ctx
, entry
);
105 ctx
->value
= (ctx
->value
== entry
->value
);
109 EXPORT_SYMBOL_GPL(apei_exec_read_register_value
);
111 int __apei_exec_write_register(struct acpi_whea_header
*entry
, u64 val
)
116 val
<<= entry
->register_region
.bit_offset
;
117 if (entry
->flags
& APEI_EXEC_PRESERVE_REGISTER
) {
119 rc
= acpi_atomic_read(&valr
, &entry
->register_region
);
122 valr
&= ~(entry
->mask
<< entry
->register_region
.bit_offset
);
125 rc
= acpi_atomic_write(val
, &entry
->register_region
);
130 int apei_exec_write_register(struct apei_exec_context
*ctx
,
131 struct acpi_whea_header
*entry
)
133 return __apei_exec_write_register(entry
, ctx
->value
);
135 EXPORT_SYMBOL_GPL(apei_exec_write_register
);
137 int apei_exec_write_register_value(struct apei_exec_context
*ctx
,
138 struct acpi_whea_header
*entry
)
142 ctx
->value
= entry
->value
;
143 rc
= apei_exec_write_register(ctx
, entry
);
147 EXPORT_SYMBOL_GPL(apei_exec_write_register_value
);
149 int apei_exec_noop(struct apei_exec_context
*ctx
,
150 struct acpi_whea_header
*entry
)
154 EXPORT_SYMBOL_GPL(apei_exec_noop
);
157 * Interpret the specified action. Go through whole action table,
158 * execute all instructions belong to the action.
160 int apei_exec_run(struct apei_exec_context
*ctx
, u8 action
)
164 struct acpi_whea_header
*entry
;
165 apei_exec_ins_func_t run
;
170 * "ip" is the instruction pointer of current instruction,
171 * "ctx->ip" specifies the next instruction to executed,
172 * instruction "run" function may change the "ctx->ip" to
173 * implement "goto" semantics.
177 for (i
= 0; i
< ctx
->entries
; i
++) {
178 entry
= &ctx
->action_table
[i
];
179 if (entry
->action
!= action
)
182 if (entry
->instruction
>= ctx
->instructions
||
183 !ctx
->ins_table
[entry
->instruction
].run
) {
184 pr_warning(FW_WARN APEI_PFX
185 "Invalid action table, unknown instruction type: %d\n",
189 run
= ctx
->ins_table
[entry
->instruction
].run
;
190 rc
= run(ctx
, entry
);
193 else if (rc
!= APEI_EXEC_SET_IP
)
203 EXPORT_SYMBOL_GPL(apei_exec_run
);
205 typedef int (*apei_exec_entry_func_t
)(struct apei_exec_context
*ctx
,
206 struct acpi_whea_header
*entry
,
209 static int apei_exec_for_each_entry(struct apei_exec_context
*ctx
,
210 apei_exec_entry_func_t func
,
216 struct acpi_whea_header
*entry
;
217 struct apei_exec_ins_type
*ins_table
= ctx
->ins_table
;
219 for (i
= 0; i
< ctx
->entries
; i
++) {
220 entry
= ctx
->action_table
+ i
;
221 ins
= entry
->instruction
;
224 if (ins
>= ctx
->instructions
|| !ins_table
[ins
].run
) {
225 pr_warning(FW_WARN APEI_PFX
226 "Invalid action table, unknown instruction type: %d\n",
230 rc
= func(ctx
, entry
, data
);
238 static int pre_map_gar_callback(struct apei_exec_context
*ctx
,
239 struct acpi_whea_header
*entry
,
242 u8 ins
= entry
->instruction
;
244 if (ctx
->ins_table
[ins
].flags
& APEI_EXEC_INS_ACCESS_REGISTER
)
245 return acpi_pre_map_gar(&entry
->register_region
);
251 * Pre-map all GARs in action table to make it possible to access them
254 int apei_exec_pre_map_gars(struct apei_exec_context
*ctx
)
258 rc
= apei_exec_for_each_entry(ctx
, pre_map_gar_callback
,
261 struct apei_exec_context ctx_unmap
;
262 memcpy(&ctx_unmap
, ctx
, sizeof(*ctx
));
263 ctx_unmap
.entries
= end
;
264 apei_exec_post_unmap_gars(&ctx_unmap
);
269 EXPORT_SYMBOL_GPL(apei_exec_pre_map_gars
);
271 static int post_unmap_gar_callback(struct apei_exec_context
*ctx
,
272 struct acpi_whea_header
*entry
,
275 u8 ins
= entry
->instruction
;
277 if (ctx
->ins_table
[ins
].flags
& APEI_EXEC_INS_ACCESS_REGISTER
)
278 acpi_post_unmap_gar(&entry
->register_region
);
283 /* Post-unmap all GAR in action table. */
284 int apei_exec_post_unmap_gars(struct apei_exec_context
*ctx
)
286 return apei_exec_for_each_entry(ctx
, post_unmap_gar_callback
,
289 EXPORT_SYMBOL_GPL(apei_exec_post_unmap_gars
);
292 * Resource management for GARs in APEI
295 struct list_head list
;
300 /* Collect all resources requested, to avoid conflict */
301 struct apei_resources apei_resources_all
= {
302 .iomem
= LIST_HEAD_INIT(apei_resources_all
.iomem
),
303 .ioport
= LIST_HEAD_INIT(apei_resources_all
.ioport
),
306 static int apei_res_add(struct list_head
*res_list
,
307 unsigned long start
, unsigned long size
)
309 struct apei_res
*res
, *resn
, *res_ins
= NULL
;
310 unsigned long end
= start
+ size
;
315 list_for_each_entry_safe(res
, resn
, res_list
, list
) {
316 if (res
->start
> end
|| res
->end
< start
)
318 else if (end
<= res
->end
&& start
>= res
->start
) {
322 list_del(&res
->list
);
323 res
->start
= start
= min(res
->start
, start
);
324 res
->end
= end
= max(res
->end
, end
);
331 list_add(&res_ins
->list
, res_list
);
333 res_ins
= kmalloc(sizeof(*res
), GFP_KERNEL
);
336 res_ins
->start
= start
;
338 list_add(&res_ins
->list
, res_list
);
344 static int apei_res_sub(struct list_head
*res_list1
,
345 struct list_head
*res_list2
)
347 struct apei_res
*res1
, *resn1
, *res2
, *res
;
348 res1
= list_entry(res_list1
->next
, struct apei_res
, list
);
349 resn1
= list_entry(res1
->list
.next
, struct apei_res
, list
);
350 while (&res1
->list
!= res_list1
) {
351 list_for_each_entry(res2
, res_list2
, list
) {
352 if (res1
->start
>= res2
->end
||
353 res1
->end
<= res2
->start
)
355 else if (res1
->end
<= res2
->end
&&
356 res1
->start
>= res2
->start
) {
357 list_del(&res1
->list
);
360 } else if (res1
->end
> res2
->end
&&
361 res1
->start
< res2
->start
) {
362 res
= kmalloc(sizeof(*res
), GFP_KERNEL
);
365 res
->start
= res2
->end
;
366 res
->end
= res1
->end
;
367 res1
->end
= res2
->start
;
368 list_add(&res
->list
, &res1
->list
);
371 if (res1
->start
< res2
->start
)
372 res1
->end
= res2
->start
;
374 res1
->start
= res2
->end
;
378 resn1
= list_entry(resn1
->list
.next
, struct apei_res
, list
);
384 static void apei_res_clean(struct list_head
*res_list
)
386 struct apei_res
*res
, *resn
;
388 list_for_each_entry_safe(res
, resn
, res_list
, list
) {
389 list_del(&res
->list
);
394 void apei_resources_fini(struct apei_resources
*resources
)
396 apei_res_clean(&resources
->iomem
);
397 apei_res_clean(&resources
->ioport
);
399 EXPORT_SYMBOL_GPL(apei_resources_fini
);
401 static int apei_resources_merge(struct apei_resources
*resources1
,
402 struct apei_resources
*resources2
)
405 struct apei_res
*res
;
407 list_for_each_entry(res
, &resources2
->iomem
, list
) {
408 rc
= apei_res_add(&resources1
->iomem
, res
->start
,
409 res
->end
- res
->start
);
413 list_for_each_entry(res
, &resources2
->ioport
, list
) {
414 rc
= apei_res_add(&resources1
->ioport
, res
->start
,
415 res
->end
- res
->start
);
424 * EINJ has two groups of GARs (EINJ table entry and trigger table
425 * entry), so common resources are subtracted from the trigger table
426 * resources before the second requesting.
428 int apei_resources_sub(struct apei_resources
*resources1
,
429 struct apei_resources
*resources2
)
433 rc
= apei_res_sub(&resources1
->iomem
, &resources2
->iomem
);
436 return apei_res_sub(&resources1
->ioport
, &resources2
->ioport
);
438 EXPORT_SYMBOL_GPL(apei_resources_sub
);
441 * IO memory/port rersource management mechanism is used to check
442 * whether memory/port area used by GARs conflicts with normal memory
443 * or IO memory/port of devices.
445 int apei_resources_request(struct apei_resources
*resources
,
448 struct apei_res
*res
, *res_bak
;
451 apei_resources_sub(resources
, &apei_resources_all
);
453 list_for_each_entry(res
, &resources
->iomem
, list
) {
454 r
= request_mem_region(res
->start
, res
->end
- res
->start
,
458 "Can not request iomem region <%016llx-%016llx> for GARs.\n",
459 (unsigned long long)res
->start
,
460 (unsigned long long)res
->end
);
462 goto err_unmap_iomem
;
466 list_for_each_entry(res
, &resources
->ioport
, list
) {
467 r
= request_region(res
->start
, res
->end
- res
->start
, desc
);
470 "Can not request ioport region <%016llx-%016llx> for GARs.\n",
471 (unsigned long long)res
->start
,
472 (unsigned long long)res
->end
);
474 goto err_unmap_ioport
;
478 apei_resources_merge(&apei_resources_all
, resources
);
482 list_for_each_entry(res
, &resources
->ioport
, list
) {
485 release_mem_region(res
->start
, res
->end
- res
->start
);
489 list_for_each_entry(res
, &resources
->iomem
, list
) {
492 release_region(res
->start
, res
->end
- res
->start
);
496 EXPORT_SYMBOL_GPL(apei_resources_request
);
498 void apei_resources_release(struct apei_resources
*resources
)
500 struct apei_res
*res
;
502 list_for_each_entry(res
, &resources
->iomem
, list
)
503 release_mem_region(res
->start
, res
->end
- res
->start
);
504 list_for_each_entry(res
, &resources
->ioport
, list
)
505 release_region(res
->start
, res
->end
- res
->start
);
507 apei_resources_sub(&apei_resources_all
, resources
);
509 EXPORT_SYMBOL_GPL(apei_resources_release
);
511 static int apei_check_gar(struct acpi_generic_address
*reg
, u64
*paddr
)
515 width
= reg
->bit_width
;
516 space_id
= reg
->space_id
;
517 /* Handle possible alignment issues */
518 memcpy(paddr
, ®
->address
, sizeof(*paddr
));
520 pr_warning(FW_BUG APEI_PFX
521 "Invalid physical address in GAR [0x%llx/%u/%u]\n",
522 *paddr
, width
, space_id
);
526 if ((width
!= 8) && (width
!= 16) && (width
!= 32) && (width
!= 64)) {
527 pr_warning(FW_BUG APEI_PFX
528 "Invalid bit width in GAR [0x%llx/%u/%u]\n",
529 *paddr
, width
, space_id
);
533 if (space_id
!= ACPI_ADR_SPACE_SYSTEM_MEMORY
&&
534 space_id
!= ACPI_ADR_SPACE_SYSTEM_IO
) {
535 pr_warning(FW_BUG APEI_PFX
536 "Invalid address space type in GAR [0x%llx/%u/%u]\n",
537 *paddr
, width
, space_id
);
544 static int collect_res_callback(struct apei_exec_context
*ctx
,
545 struct acpi_whea_header
*entry
,
548 struct apei_resources
*resources
= data
;
549 struct acpi_generic_address
*reg
= &entry
->register_region
;
550 u8 ins
= entry
->instruction
;
554 if (!(ctx
->ins_table
[ins
].flags
& APEI_EXEC_INS_ACCESS_REGISTER
))
557 rc
= apei_check_gar(reg
, &paddr
);
561 switch (reg
->space_id
) {
562 case ACPI_ADR_SPACE_SYSTEM_MEMORY
:
563 return apei_res_add(&resources
->iomem
, paddr
,
565 case ACPI_ADR_SPACE_SYSTEM_IO
:
566 return apei_res_add(&resources
->ioport
, paddr
,
574 * Same register may be used by multiple instructions in GARs, so
575 * resources are collected before requesting.
577 int apei_exec_collect_resources(struct apei_exec_context
*ctx
,
578 struct apei_resources
*resources
)
580 return apei_exec_for_each_entry(ctx
, collect_res_callback
,
583 EXPORT_SYMBOL_GPL(apei_exec_collect_resources
);
585 struct dentry
*apei_get_debugfs_dir(void)
587 static struct dentry
*dapei
;
590 dapei
= debugfs_create_dir("apei", NULL
);
594 EXPORT_SYMBOL_GPL(apei_get_debugfs_dir
);