Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 1 | /* |
| 2 | * apei-base.c - ACPI Platform Error Interface (APEI) supporting |
| 3 | * infrastructure |
| 4 | * |
| 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. |
| 8 | * |
| 9 | * For more information about APEI, please refer to ACPI Specification |
| 10 | * version 4.0, chapter 17. |
| 11 | * |
| 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. |
| 15 | * |
| 16 | * Copyright (C) 2009, Intel Corp. |
| 17 | * Author: Huang Ying <ying.huang@intel.com> |
| 18 | * |
| 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. |
| 22 | * |
| 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. |
| 27 | * |
| 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 |
| 31 | */ |
| 32 | |
| 33 | #include <linux/kernel.h> |
| 34 | #include <linux/module.h> |
| 35 | #include <linux/init.h> |
| 36 | #include <linux/acpi.h> |
Tejun Heo | e0fb8c4 | 2010-03-30 02:52:44 +0900 | [diff] [blame] | 37 | #include <linux/slab.h> |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 38 | #include <linux/io.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> |
| 44 | |
| 45 | #include "apei-internal.h" |
| 46 | |
| 47 | #define APEI_PFX "APEI: " |
| 48 | |
| 49 | /* |
| 50 | * APEI ERST (Error Record Serialization Table) and EINJ (Error |
| 51 | * INJection) interpreter framework. |
| 52 | */ |
| 53 | |
| 54 | #define APEI_EXEC_PRESERVE_REGISTER 0x1 |
| 55 | |
| 56 | void apei_exec_ctx_init(struct apei_exec_context *ctx, |
| 57 | struct apei_exec_ins_type *ins_table, |
| 58 | u32 instructions, |
| 59 | struct acpi_whea_header *action_table, |
| 60 | u32 entries) |
| 61 | { |
| 62 | ctx->ins_table = ins_table; |
| 63 | ctx->instructions = instructions; |
| 64 | ctx->action_table = action_table; |
| 65 | ctx->entries = entries; |
| 66 | } |
| 67 | EXPORT_SYMBOL_GPL(apei_exec_ctx_init); |
| 68 | |
| 69 | int __apei_exec_read_register(struct acpi_whea_header *entry, u64 *val) |
| 70 | { |
| 71 | int rc; |
| 72 | |
| 73 | rc = acpi_atomic_read(val, &entry->register_region); |
| 74 | if (rc) |
| 75 | return rc; |
| 76 | *val >>= entry->register_region.bit_offset; |
| 77 | *val &= entry->mask; |
| 78 | |
| 79 | return 0; |
| 80 | } |
| 81 | |
| 82 | int apei_exec_read_register(struct apei_exec_context *ctx, |
| 83 | struct acpi_whea_header *entry) |
| 84 | { |
| 85 | int rc; |
| 86 | u64 val = 0; |
| 87 | |
| 88 | rc = __apei_exec_read_register(entry, &val); |
| 89 | if (rc) |
| 90 | return rc; |
| 91 | ctx->value = val; |
| 92 | |
| 93 | return 0; |
| 94 | } |
| 95 | EXPORT_SYMBOL_GPL(apei_exec_read_register); |
| 96 | |
| 97 | int apei_exec_read_register_value(struct apei_exec_context *ctx, |
| 98 | struct acpi_whea_header *entry) |
| 99 | { |
| 100 | int rc; |
| 101 | |
| 102 | rc = apei_exec_read_register(ctx, entry); |
| 103 | if (rc) |
| 104 | return rc; |
| 105 | ctx->value = (ctx->value == entry->value); |
| 106 | |
| 107 | return 0; |
| 108 | } |
| 109 | EXPORT_SYMBOL_GPL(apei_exec_read_register_value); |
| 110 | |
| 111 | int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val) |
| 112 | { |
| 113 | int rc; |
| 114 | |
| 115 | val &= entry->mask; |
| 116 | val <<= entry->register_region.bit_offset; |
| 117 | if (entry->flags & APEI_EXEC_PRESERVE_REGISTER) { |
| 118 | u64 valr = 0; |
| 119 | rc = acpi_atomic_read(&valr, &entry->register_region); |
| 120 | if (rc) |
| 121 | return rc; |
| 122 | valr &= ~(entry->mask << entry->register_region.bit_offset); |
| 123 | val |= valr; |
| 124 | } |
| 125 | rc = acpi_atomic_write(val, &entry->register_region); |
| 126 | |
| 127 | return rc; |
| 128 | } |
| 129 | |
| 130 | int apei_exec_write_register(struct apei_exec_context *ctx, |
| 131 | struct acpi_whea_header *entry) |
| 132 | { |
| 133 | return __apei_exec_write_register(entry, ctx->value); |
| 134 | } |
| 135 | EXPORT_SYMBOL_GPL(apei_exec_write_register); |
| 136 | |
| 137 | int apei_exec_write_register_value(struct apei_exec_context *ctx, |
| 138 | struct acpi_whea_header *entry) |
| 139 | { |
| 140 | int rc; |
| 141 | |
| 142 | ctx->value = entry->value; |
| 143 | rc = apei_exec_write_register(ctx, entry); |
| 144 | |
| 145 | return rc; |
| 146 | } |
| 147 | EXPORT_SYMBOL_GPL(apei_exec_write_register_value); |
| 148 | |
| 149 | int apei_exec_noop(struct apei_exec_context *ctx, |
| 150 | struct acpi_whea_header *entry) |
| 151 | { |
| 152 | return 0; |
| 153 | } |
| 154 | EXPORT_SYMBOL_GPL(apei_exec_noop); |
| 155 | |
| 156 | /* |
| 157 | * Interpret the specified action. Go through whole action table, |
| 158 | * execute all instructions belong to the action. |
| 159 | */ |
Huang Ying | eecf2f7 | 2011-07-13 13:14:16 +0800 | [diff] [blame] | 160 | int __apei_exec_run(struct apei_exec_context *ctx, u8 action, |
| 161 | bool optional) |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 162 | { |
Huang Ying | eecf2f7 | 2011-07-13 13:14:16 +0800 | [diff] [blame] | 163 | int rc = -ENOENT; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 164 | u32 i, ip; |
| 165 | struct acpi_whea_header *entry; |
| 166 | apei_exec_ins_func_t run; |
| 167 | |
| 168 | ctx->ip = 0; |
| 169 | |
| 170 | /* |
| 171 | * "ip" is the instruction pointer of current instruction, |
| 172 | * "ctx->ip" specifies the next instruction to executed, |
| 173 | * instruction "run" function may change the "ctx->ip" to |
| 174 | * implement "goto" semantics. |
| 175 | */ |
| 176 | rewind: |
| 177 | ip = 0; |
| 178 | for (i = 0; i < ctx->entries; i++) { |
| 179 | entry = &ctx->action_table[i]; |
| 180 | if (entry->action != action) |
| 181 | continue; |
| 182 | if (ip == ctx->ip) { |
| 183 | if (entry->instruction >= ctx->instructions || |
| 184 | !ctx->ins_table[entry->instruction].run) { |
| 185 | pr_warning(FW_WARN APEI_PFX |
| 186 | "Invalid action table, unknown instruction type: %d\n", |
| 187 | entry->instruction); |
| 188 | return -EINVAL; |
| 189 | } |
| 190 | run = ctx->ins_table[entry->instruction].run; |
| 191 | rc = run(ctx, entry); |
| 192 | if (rc < 0) |
| 193 | return rc; |
| 194 | else if (rc != APEI_EXEC_SET_IP) |
| 195 | ctx->ip++; |
| 196 | } |
| 197 | ip++; |
| 198 | if (ctx->ip < ip) |
| 199 | goto rewind; |
| 200 | } |
| 201 | |
Huang Ying | eecf2f7 | 2011-07-13 13:14:16 +0800 | [diff] [blame] | 202 | return !optional && rc < 0 ? rc : 0; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 203 | } |
Huang Ying | eecf2f7 | 2011-07-13 13:14:16 +0800 | [diff] [blame] | 204 | EXPORT_SYMBOL_GPL(__apei_exec_run); |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 205 | |
| 206 | typedef int (*apei_exec_entry_func_t)(struct apei_exec_context *ctx, |
| 207 | struct acpi_whea_header *entry, |
| 208 | void *data); |
| 209 | |
| 210 | static int apei_exec_for_each_entry(struct apei_exec_context *ctx, |
| 211 | apei_exec_entry_func_t func, |
| 212 | void *data, |
| 213 | int *end) |
| 214 | { |
| 215 | u8 ins; |
| 216 | int i, rc; |
| 217 | struct acpi_whea_header *entry; |
| 218 | struct apei_exec_ins_type *ins_table = ctx->ins_table; |
| 219 | |
| 220 | for (i = 0; i < ctx->entries; i++) { |
| 221 | entry = ctx->action_table + i; |
| 222 | ins = entry->instruction; |
| 223 | if (end) |
| 224 | *end = i; |
| 225 | if (ins >= ctx->instructions || !ins_table[ins].run) { |
| 226 | pr_warning(FW_WARN APEI_PFX |
| 227 | "Invalid action table, unknown instruction type: %d\n", |
| 228 | ins); |
| 229 | return -EINVAL; |
| 230 | } |
| 231 | rc = func(ctx, entry, data); |
| 232 | if (rc) |
| 233 | return rc; |
| 234 | } |
| 235 | |
| 236 | return 0; |
| 237 | } |
| 238 | |
| 239 | static int pre_map_gar_callback(struct apei_exec_context *ctx, |
| 240 | struct acpi_whea_header *entry, |
| 241 | void *data) |
| 242 | { |
| 243 | u8 ins = entry->instruction; |
| 244 | |
| 245 | if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER) |
| 246 | return acpi_pre_map_gar(&entry->register_region); |
| 247 | |
| 248 | return 0; |
| 249 | } |
| 250 | |
| 251 | /* |
| 252 | * Pre-map all GARs in action table to make it possible to access them |
| 253 | * in NMI handler. |
| 254 | */ |
| 255 | int apei_exec_pre_map_gars(struct apei_exec_context *ctx) |
| 256 | { |
| 257 | int rc, end; |
| 258 | |
| 259 | rc = apei_exec_for_each_entry(ctx, pre_map_gar_callback, |
| 260 | NULL, &end); |
| 261 | if (rc) { |
| 262 | struct apei_exec_context ctx_unmap; |
| 263 | memcpy(&ctx_unmap, ctx, sizeof(*ctx)); |
| 264 | ctx_unmap.entries = end; |
| 265 | apei_exec_post_unmap_gars(&ctx_unmap); |
| 266 | } |
| 267 | |
| 268 | return rc; |
| 269 | } |
| 270 | EXPORT_SYMBOL_GPL(apei_exec_pre_map_gars); |
| 271 | |
| 272 | static int post_unmap_gar_callback(struct apei_exec_context *ctx, |
| 273 | struct acpi_whea_header *entry, |
| 274 | void *data) |
| 275 | { |
| 276 | u8 ins = entry->instruction; |
| 277 | |
| 278 | if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER) |
| 279 | acpi_post_unmap_gar(&entry->register_region); |
| 280 | |
| 281 | return 0; |
| 282 | } |
| 283 | |
| 284 | /* Post-unmap all GAR in action table. */ |
| 285 | int apei_exec_post_unmap_gars(struct apei_exec_context *ctx) |
| 286 | { |
| 287 | return apei_exec_for_each_entry(ctx, post_unmap_gar_callback, |
| 288 | NULL, NULL); |
| 289 | } |
| 290 | EXPORT_SYMBOL_GPL(apei_exec_post_unmap_gars); |
| 291 | |
| 292 | /* |
| 293 | * Resource management for GARs in APEI |
| 294 | */ |
| 295 | struct apei_res { |
| 296 | struct list_head list; |
| 297 | unsigned long start; |
| 298 | unsigned long end; |
| 299 | }; |
| 300 | |
| 301 | /* Collect all resources requested, to avoid conflict */ |
| 302 | struct apei_resources apei_resources_all = { |
| 303 | .iomem = LIST_HEAD_INIT(apei_resources_all.iomem), |
| 304 | .ioport = LIST_HEAD_INIT(apei_resources_all.ioport), |
| 305 | }; |
| 306 | |
| 307 | static int apei_res_add(struct list_head *res_list, |
| 308 | unsigned long start, unsigned long size) |
| 309 | { |
| 310 | struct apei_res *res, *resn, *res_ins = NULL; |
| 311 | unsigned long end = start + size; |
| 312 | |
| 313 | if (end <= start) |
| 314 | return 0; |
| 315 | repeat: |
| 316 | list_for_each_entry_safe(res, resn, res_list, list) { |
| 317 | if (res->start > end || res->end < start) |
| 318 | continue; |
| 319 | else if (end <= res->end && start >= res->start) { |
| 320 | kfree(res_ins); |
| 321 | return 0; |
| 322 | } |
| 323 | list_del(&res->list); |
| 324 | res->start = start = min(res->start, start); |
| 325 | res->end = end = max(res->end, end); |
| 326 | kfree(res_ins); |
| 327 | res_ins = res; |
| 328 | goto repeat; |
| 329 | } |
| 330 | |
| 331 | if (res_ins) |
| 332 | list_add(&res_ins->list, res_list); |
| 333 | else { |
| 334 | res_ins = kmalloc(sizeof(*res), GFP_KERNEL); |
| 335 | if (!res_ins) |
| 336 | return -ENOMEM; |
| 337 | res_ins->start = start; |
| 338 | res_ins->end = end; |
| 339 | list_add(&res_ins->list, res_list); |
| 340 | } |
| 341 | |
| 342 | return 0; |
| 343 | } |
| 344 | |
| 345 | static int apei_res_sub(struct list_head *res_list1, |
| 346 | struct list_head *res_list2) |
| 347 | { |
| 348 | struct apei_res *res1, *resn1, *res2, *res; |
| 349 | res1 = list_entry(res_list1->next, struct apei_res, list); |
| 350 | resn1 = list_entry(res1->list.next, struct apei_res, list); |
| 351 | while (&res1->list != res_list1) { |
| 352 | list_for_each_entry(res2, res_list2, list) { |
| 353 | if (res1->start >= res2->end || |
| 354 | res1->end <= res2->start) |
| 355 | continue; |
| 356 | else if (res1->end <= res2->end && |
| 357 | res1->start >= res2->start) { |
| 358 | list_del(&res1->list); |
| 359 | kfree(res1); |
| 360 | break; |
| 361 | } else if (res1->end > res2->end && |
| 362 | res1->start < res2->start) { |
| 363 | res = kmalloc(sizeof(*res), GFP_KERNEL); |
| 364 | if (!res) |
| 365 | return -ENOMEM; |
| 366 | res->start = res2->end; |
| 367 | res->end = res1->end; |
| 368 | res1->end = res2->start; |
| 369 | list_add(&res->list, &res1->list); |
| 370 | resn1 = res; |
| 371 | } else { |
| 372 | if (res1->start < res2->start) |
| 373 | res1->end = res2->start; |
| 374 | else |
| 375 | res1->start = res2->end; |
| 376 | } |
| 377 | } |
| 378 | res1 = resn1; |
| 379 | resn1 = list_entry(resn1->list.next, struct apei_res, list); |
| 380 | } |
| 381 | |
| 382 | return 0; |
| 383 | } |
| 384 | |
| 385 | static void apei_res_clean(struct list_head *res_list) |
| 386 | { |
| 387 | struct apei_res *res, *resn; |
| 388 | |
| 389 | list_for_each_entry_safe(res, resn, res_list, list) { |
| 390 | list_del(&res->list); |
| 391 | kfree(res); |
| 392 | } |
| 393 | } |
| 394 | |
| 395 | void apei_resources_fini(struct apei_resources *resources) |
| 396 | { |
| 397 | apei_res_clean(&resources->iomem); |
| 398 | apei_res_clean(&resources->ioport); |
| 399 | } |
| 400 | EXPORT_SYMBOL_GPL(apei_resources_fini); |
| 401 | |
| 402 | static int apei_resources_merge(struct apei_resources *resources1, |
| 403 | struct apei_resources *resources2) |
| 404 | { |
| 405 | int rc; |
| 406 | struct apei_res *res; |
| 407 | |
| 408 | list_for_each_entry(res, &resources2->iomem, list) { |
| 409 | rc = apei_res_add(&resources1->iomem, res->start, |
| 410 | res->end - res->start); |
| 411 | if (rc) |
| 412 | return rc; |
| 413 | } |
| 414 | list_for_each_entry(res, &resources2->ioport, list) { |
| 415 | rc = apei_res_add(&resources1->ioport, res->start, |
| 416 | res->end - res->start); |
| 417 | if (rc) |
| 418 | return rc; |
| 419 | } |
| 420 | |
| 421 | return 0; |
| 422 | } |
| 423 | |
| 424 | /* |
| 425 | * EINJ has two groups of GARs (EINJ table entry and trigger table |
| 426 | * entry), so common resources are subtracted from the trigger table |
| 427 | * resources before the second requesting. |
| 428 | */ |
| 429 | int apei_resources_sub(struct apei_resources *resources1, |
| 430 | struct apei_resources *resources2) |
| 431 | { |
| 432 | int rc; |
| 433 | |
| 434 | rc = apei_res_sub(&resources1->iomem, &resources2->iomem); |
| 435 | if (rc) |
| 436 | return rc; |
| 437 | return apei_res_sub(&resources1->ioport, &resources2->ioport); |
| 438 | } |
| 439 | EXPORT_SYMBOL_GPL(apei_resources_sub); |
| 440 | |
| 441 | /* |
| 442 | * IO memory/port rersource management mechanism is used to check |
| 443 | * whether memory/port area used by GARs conflicts with normal memory |
| 444 | * or IO memory/port of devices. |
| 445 | */ |
| 446 | int apei_resources_request(struct apei_resources *resources, |
| 447 | const char *desc) |
| 448 | { |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 449 | struct apei_res *res, *res_bak = NULL; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 450 | struct resource *r; |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 451 | int rc; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 452 | |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 453 | rc = apei_resources_sub(resources, &apei_resources_all); |
| 454 | if (rc) |
| 455 | return rc; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 456 | |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 457 | rc = -EINVAL; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 458 | list_for_each_entry(res, &resources->iomem, list) { |
| 459 | r = request_mem_region(res->start, res->end - res->start, |
| 460 | desc); |
| 461 | if (!r) { |
| 462 | pr_err(APEI_PFX |
| 463 | "Can not request iomem region <%016llx-%016llx> for GARs.\n", |
| 464 | (unsigned long long)res->start, |
| 465 | (unsigned long long)res->end); |
| 466 | res_bak = res; |
| 467 | goto err_unmap_iomem; |
| 468 | } |
| 469 | } |
| 470 | |
| 471 | list_for_each_entry(res, &resources->ioport, list) { |
| 472 | r = request_region(res->start, res->end - res->start, desc); |
| 473 | if (!r) { |
| 474 | pr_err(APEI_PFX |
| 475 | "Can not request ioport region <%016llx-%016llx> for GARs.\n", |
| 476 | (unsigned long long)res->start, |
| 477 | (unsigned long long)res->end); |
| 478 | res_bak = res; |
| 479 | goto err_unmap_ioport; |
| 480 | } |
| 481 | } |
| 482 | |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 483 | rc = apei_resources_merge(&apei_resources_all, resources); |
| 484 | if (rc) { |
| 485 | pr_err(APEI_PFX "Fail to merge resources!\n"); |
| 486 | goto err_unmap_ioport; |
| 487 | } |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 488 | |
| 489 | return 0; |
| 490 | err_unmap_ioport: |
| 491 | list_for_each_entry(res, &resources->ioport, list) { |
| 492 | if (res == res_bak) |
| 493 | break; |
Huang Ying | 2663b3f | 2010-08-02 15:48:22 +0800 | [diff] [blame] | 494 | release_region(res->start, res->end - res->start); |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 495 | } |
| 496 | res_bak = NULL; |
| 497 | err_unmap_iomem: |
| 498 | list_for_each_entry(res, &resources->iomem, list) { |
| 499 | if (res == res_bak) |
| 500 | break; |
Huang Ying | 2663b3f | 2010-08-02 15:48:22 +0800 | [diff] [blame] | 501 | release_mem_region(res->start, res->end - res->start); |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 502 | } |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 503 | return rc; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 504 | } |
| 505 | EXPORT_SYMBOL_GPL(apei_resources_request); |
| 506 | |
| 507 | void apei_resources_release(struct apei_resources *resources) |
| 508 | { |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 509 | int rc; |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 510 | struct apei_res *res; |
| 511 | |
| 512 | list_for_each_entry(res, &resources->iomem, list) |
| 513 | release_mem_region(res->start, res->end - res->start); |
| 514 | list_for_each_entry(res, &resources->ioport, list) |
| 515 | release_region(res->start, res->end - res->start); |
| 516 | |
Huang Ying | 23f124c | 2010-09-29 19:53:54 +0800 | [diff] [blame] | 517 | rc = apei_resources_sub(&apei_resources_all, resources); |
| 518 | if (rc) |
| 519 | pr_err(APEI_PFX "Fail to sub resources!\n"); |
Huang Ying | a643ce2 | 2010-05-18 14:35:12 +0800 | [diff] [blame] | 520 | } |
| 521 | EXPORT_SYMBOL_GPL(apei_resources_release); |
| 522 | |
| 523 | static int apei_check_gar(struct acpi_generic_address *reg, u64 *paddr) |
| 524 | { |
| 525 | u32 width, space_id; |
| 526 | |
| 527 | width = reg->bit_width; |
| 528 | space_id = reg->space_id; |
| 529 | /* Handle possible alignment issues */ |
| 530 | memcpy(paddr, ®->address, sizeof(*paddr)); |
| 531 | if (!*paddr) { |
| 532 | pr_warning(FW_BUG APEI_PFX |
| 533 | "Invalid physical address in GAR [0x%llx/%u/%u]\n", |
| 534 | *paddr, width, space_id); |
| 535 | return -EINVAL; |
| 536 | } |
| 537 | |
| 538 | if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) { |
| 539 | pr_warning(FW_BUG APEI_PFX |
| 540 | "Invalid bit width in GAR [0x%llx/%u/%u]\n", |
| 541 | *paddr, width, space_id); |
| 542 | return -EINVAL; |
| 543 | } |
| 544 | |
| 545 | if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY && |
| 546 | space_id != ACPI_ADR_SPACE_SYSTEM_IO) { |
| 547 | pr_warning(FW_BUG APEI_PFX |
| 548 | "Invalid address space type in GAR [0x%llx/%u/%u]\n", |
| 549 | *paddr, width, space_id); |
| 550 | return -EINVAL; |
| 551 | } |
| 552 | |
| 553 | return 0; |
| 554 | } |
| 555 | |
| 556 | static int collect_res_callback(struct apei_exec_context *ctx, |
| 557 | struct acpi_whea_header *entry, |
| 558 | void *data) |
| 559 | { |
| 560 | struct apei_resources *resources = data; |
| 561 | struct acpi_generic_address *reg = &entry->register_region; |
| 562 | u8 ins = entry->instruction; |
| 563 | u64 paddr; |
| 564 | int rc; |
| 565 | |
| 566 | if (!(ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)) |
| 567 | return 0; |
| 568 | |
| 569 | rc = apei_check_gar(reg, &paddr); |
| 570 | if (rc) |
| 571 | return rc; |
| 572 | |
| 573 | switch (reg->space_id) { |
| 574 | case ACPI_ADR_SPACE_SYSTEM_MEMORY: |
| 575 | return apei_res_add(&resources->iomem, paddr, |
| 576 | reg->bit_width / 8); |
| 577 | case ACPI_ADR_SPACE_SYSTEM_IO: |
| 578 | return apei_res_add(&resources->ioport, paddr, |
| 579 | reg->bit_width / 8); |
| 580 | default: |
| 581 | return -EINVAL; |
| 582 | } |
| 583 | } |
| 584 | |
| 585 | /* |
| 586 | * Same register may be used by multiple instructions in GARs, so |
| 587 | * resources are collected before requesting. |
| 588 | */ |
| 589 | int apei_exec_collect_resources(struct apei_exec_context *ctx, |
| 590 | struct apei_resources *resources) |
| 591 | { |
| 592 | return apei_exec_for_each_entry(ctx, collect_res_callback, |
| 593 | resources, NULL); |
| 594 | } |
| 595 | EXPORT_SYMBOL_GPL(apei_exec_collect_resources); |
| 596 | |
| 597 | struct dentry *apei_get_debugfs_dir(void) |
| 598 | { |
| 599 | static struct dentry *dapei; |
| 600 | |
| 601 | if (!dapei) |
| 602 | dapei = debugfs_create_dir("apei", NULL); |
| 603 | |
| 604 | return dapei; |
| 605 | } |
| 606 | EXPORT_SYMBOL_GPL(apei_get_debugfs_dir); |
Huang Ying | 9fb0bfe | 2011-07-13 13:14:21 +0800 | [diff] [blame] | 607 | |
| 608 | int apei_osc_setup(void) |
| 609 | { |
| 610 | static u8 whea_uuid_str[] = "ed855e0c-6c90-47bf-a62a-26de0fc5ad5c"; |
| 611 | acpi_handle handle; |
| 612 | u32 capbuf[3]; |
| 613 | struct acpi_osc_context context = { |
| 614 | .uuid_str = whea_uuid_str, |
| 615 | .rev = 1, |
| 616 | .cap.length = sizeof(capbuf), |
| 617 | .cap.pointer = capbuf, |
| 618 | }; |
| 619 | |
| 620 | capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE; |
| 621 | capbuf[OSC_SUPPORT_TYPE] = 0; |
| 622 | capbuf[OSC_CONTROL_TYPE] = 0; |
| 623 | |
| 624 | if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)) |
| 625 | || ACPI_FAILURE(acpi_run_osc(handle, &context))) |
| 626 | return -EIO; |
| 627 | else { |
| 628 | kfree(context.ret.pointer); |
| 629 | return 0; |
| 630 | } |
| 631 | } |
| 632 | EXPORT_SYMBOL_GPL(apei_osc_setup); |