1 /* 2 * APEI Error INJection support 3 * 4 * EINJ provides a hardware error injection mechanism, this is useful 5 * for debugging and testing of other APEI and RAS features. 6 * 7 * For more information about EINJ, please refer to ACPI Specification 8 * version 4.0, section 17.5. 9 * 10 * Copyright 2009-2010 Intel Corp. 11 * Author: Huang Ying <ying.huang@intel.com> 12 * 13 * This program is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU General Public License version 15 * 2 as published by the Free Software Foundation. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 25 */ 26 27 #include <linux/kernel.h> 28 #include <linux/module.h> 29 #include <linux/init.h> 30 #include <linux/io.h> 31 #include <linux/debugfs.h> 32 #include <linux/seq_file.h> 33 #include <linux/nmi.h> 34 #include <linux/delay.h> 35 #include <acpi/acpi.h> 36 37 #include "apei-internal.h" 38 39 #define EINJ_PFX "EINJ: " 40 41 #define SPIN_UNIT 100 /* 100ns */ 42 /* Firmware should respond within 1 milliseconds */ 43 #define FIRMWARE_TIMEOUT (1 * NSEC_PER_MSEC) 44 45 /* 46 * ACPI version 5 provides a SET_ERROR_TYPE_WITH_ADDRESS action. 47 */ 48 static int acpi5; 49 50 struct set_error_type_with_address { 51 u32 type; 52 u32 vendor_extension; 53 u32 flags; 54 u32 apicid; 55 u64 memory_address; 56 u64 memory_address_range; 57 u32 pcie_sbdf; 58 }; 59 enum { 60 SETWA_FLAGS_APICID = 1, 61 SETWA_FLAGS_MEM = 2, 62 SETWA_FLAGS_PCIE_SBDF = 4, 63 }; 64 65 /* 66 * Vendor extensions for platform specific operations 67 */ 68 struct vendor_error_type_extension { 69 u32 length; 70 u32 pcie_sbdf; 71 u16 vendor_id; 72 u16 device_id; 73 u8 rev_id; 74 u8 reserved[3]; 75 }; 76 77 static u32 notrigger; 78 79 static u32 vendor_flags; 80 static struct debugfs_blob_wrapper vendor_blob; 81 static char vendor_dev[64]; 82 83 /* 84 * Some BIOSes allow parameters to the SET_ERROR_TYPE entries in the 85 * EINJ table through an unpublished extension. Use with caution as 86 * most will ignore the parameter and make their own choice of address 87 * for error injection. This extension is used only if 88 * param_extension module parameter is specified. 89 */ 90 struct einj_parameter { 91 u64 type; 92 u64 reserved1; 93 u64 reserved2; 94 u64 param1; 95 u64 param2; 96 }; 97 98 #define EINJ_OP_BUSY 0x1 99 #define EINJ_STATUS_SUCCESS 0x0 100 #define EINJ_STATUS_FAIL 0x1 101 #define EINJ_STATUS_INVAL 0x2 102 103 #define EINJ_TAB_ENTRY(tab) \ 104 ((struct acpi_whea_header *)((char *)(tab) + \ 105 sizeof(struct acpi_table_einj))) 106 107 static bool param_extension; 108 module_param(param_extension, bool, 0); 109 110 static struct acpi_table_einj *einj_tab; 111 112 static struct apei_resources einj_resources; 113 114 static struct apei_exec_ins_type einj_ins_type[] = { 115 [ACPI_EINJ_READ_REGISTER] = { 116 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 117 .run = apei_exec_read_register, 118 }, 119 [ACPI_EINJ_READ_REGISTER_VALUE] = { 120 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 121 .run = apei_exec_read_register_value, 122 }, 123 [ACPI_EINJ_WRITE_REGISTER] = { 124 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 125 .run = apei_exec_write_register, 126 }, 127 [ACPI_EINJ_WRITE_REGISTER_VALUE] = { 128 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 129 .run = apei_exec_write_register_value, 130 }, 131 [ACPI_EINJ_NOOP] = { 132 .flags = 0, 133 .run = apei_exec_noop, 134 }, 135 }; 136 137 /* 138 * Prevent EINJ interpreter to run simultaneously, because the 139 * corresponding firmware implementation may not work properly when 140 * invoked simultaneously. 141 */ 142 static DEFINE_MUTEX(einj_mutex); 143 144 static void *einj_param; 145 146 static void einj_exec_ctx_init(struct apei_exec_context *ctx) 147 { 148 apei_exec_ctx_init(ctx, einj_ins_type, ARRAY_SIZE(einj_ins_type), 149 EINJ_TAB_ENTRY(einj_tab), einj_tab->entries); 150 } 151 152 static int __einj_get_available_error_type(u32 *type) 153 { 154 struct apei_exec_context ctx; 155 int rc; 156 157 einj_exec_ctx_init(&ctx); 158 rc = apei_exec_run(&ctx, ACPI_EINJ_GET_ERROR_TYPE); 159 if (rc) 160 return rc; 161 *type = apei_exec_ctx_get_output(&ctx); 162 163 return 0; 164 } 165 166 /* Get error injection capabilities of the platform */ 167 static int einj_get_available_error_type(u32 *type) 168 { 169 int rc; 170 171 mutex_lock(&einj_mutex); 172 rc = __einj_get_available_error_type(type); 173 mutex_unlock(&einj_mutex); 174 175 return rc; 176 } 177 178 static int einj_timedout(u64 *t) 179 { 180 if ((s64)*t < SPIN_UNIT) { 181 pr_warning(FW_WARN EINJ_PFX 182 "Firmware does not respond in time\n"); 183 return 1; 184 } 185 *t -= SPIN_UNIT; 186 ndelay(SPIN_UNIT); 187 touch_nmi_watchdog(); 188 return 0; 189 } 190 191 static void check_vendor_extension(u64 paddr, 192 struct set_error_type_with_address *v5param) 193 { 194 int offset = v5param->vendor_extension; 195 struct vendor_error_type_extension *v; 196 u32 sbdf; 197 198 if (!offset) 199 return; 200 v = acpi_os_map_memory(paddr + offset, sizeof(*v)); 201 if (!v) 202 return; 203 sbdf = v->pcie_sbdf; 204 sprintf(vendor_dev, "%x:%x:%x.%x vendor_id=%x device_id=%x rev_id=%x\n", 205 sbdf >> 24, (sbdf >> 16) & 0xff, 206 (sbdf >> 11) & 0x1f, (sbdf >> 8) & 0x7, 207 v->vendor_id, v->device_id, v->rev_id); 208 acpi_os_unmap_memory(v, sizeof(*v)); 209 } 210 211 static void *einj_get_parameter_address(void) 212 { 213 int i; 214 u64 paddrv4 = 0, paddrv5 = 0; 215 struct acpi_whea_header *entry; 216 217 entry = EINJ_TAB_ENTRY(einj_tab); 218 for (i = 0; i < einj_tab->entries; i++) { 219 if (entry->action == ACPI_EINJ_SET_ERROR_TYPE && 220 entry->instruction == ACPI_EINJ_WRITE_REGISTER && 221 entry->register_region.space_id == 222 ACPI_ADR_SPACE_SYSTEM_MEMORY) 223 memcpy(&paddrv4, &entry->register_region.address, 224 sizeof(paddrv4)); 225 if (entry->action == ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS && 226 entry->instruction == ACPI_EINJ_WRITE_REGISTER && 227 entry->register_region.space_id == 228 ACPI_ADR_SPACE_SYSTEM_MEMORY) 229 memcpy(&paddrv5, &entry->register_region.address, 230 sizeof(paddrv5)); 231 entry++; 232 } 233 if (paddrv5) { 234 struct set_error_type_with_address *v5param; 235 236 v5param = acpi_os_map_memory(paddrv5, sizeof(*v5param)); 237 if (v5param) { 238 acpi5 = 1; 239 check_vendor_extension(paddrv5, v5param); 240 return v5param; 241 } 242 } 243 if (param_extension && paddrv4) { 244 struct einj_parameter *v4param; 245 246 v4param = acpi_os_map_memory(paddrv4, sizeof(*v4param)); 247 if (!v4param) 248 return NULL; 249 if (v4param->reserved1 || v4param->reserved2) { 250 acpi_os_unmap_memory(v4param, sizeof(*v4param)); 251 return NULL; 252 } 253 return v4param; 254 } 255 256 return NULL; 257 } 258 259 /* do sanity check to trigger table */ 260 static int einj_check_trigger_header(struct acpi_einj_trigger *trigger_tab) 261 { 262 if (trigger_tab->header_size != sizeof(struct acpi_einj_trigger)) 263 return -EINVAL; 264 if (trigger_tab->table_size > PAGE_SIZE || 265 trigger_tab->table_size < trigger_tab->header_size) 266 return -EINVAL; 267 if (trigger_tab->entry_count != 268 (trigger_tab->table_size - trigger_tab->header_size) / 269 sizeof(struct acpi_einj_entry)) 270 return -EINVAL; 271 272 return 0; 273 } 274 275 static struct acpi_generic_address *einj_get_trigger_parameter_region( 276 struct acpi_einj_trigger *trigger_tab, u64 param1, u64 param2) 277 { 278 int i; 279 struct acpi_whea_header *entry; 280 281 entry = (struct acpi_whea_header *) 282 ((char *)trigger_tab + sizeof(struct acpi_einj_trigger)); 283 for (i = 0; i < trigger_tab->entry_count; i++) { 284 if (entry->action == ACPI_EINJ_TRIGGER_ERROR && 285 entry->instruction == ACPI_EINJ_WRITE_REGISTER_VALUE && 286 entry->register_region.space_id == 287 ACPI_ADR_SPACE_SYSTEM_MEMORY && 288 (entry->register_region.address & param2) == (param1 & param2)) 289 return &entry->register_region; 290 entry++; 291 } 292 293 return NULL; 294 } 295 /* Execute instructions in trigger error action table */ 296 static int __einj_error_trigger(u64 trigger_paddr, u32 type, 297 u64 param1, u64 param2) 298 { 299 struct acpi_einj_trigger *trigger_tab = NULL; 300 struct apei_exec_context trigger_ctx; 301 struct apei_resources trigger_resources; 302 struct acpi_whea_header *trigger_entry; 303 struct resource *r; 304 u32 table_size; 305 int rc = -EIO; 306 struct acpi_generic_address *trigger_param_region = NULL; 307 308 r = request_mem_region(trigger_paddr, sizeof(*trigger_tab), 309 "APEI EINJ Trigger Table"); 310 if (!r) { 311 pr_err(EINJ_PFX 312 "Can not request [mem %#010llx-%#010llx] for Trigger table\n", 313 (unsigned long long)trigger_paddr, 314 (unsigned long long)trigger_paddr + 315 sizeof(*trigger_tab) - 1); 316 goto out; 317 } 318 trigger_tab = ioremap_cache(trigger_paddr, sizeof(*trigger_tab)); 319 if (!trigger_tab) { 320 pr_err(EINJ_PFX "Failed to map trigger table!\n"); 321 goto out_rel_header; 322 } 323 rc = einj_check_trigger_header(trigger_tab); 324 if (rc) { 325 pr_warning(FW_BUG EINJ_PFX 326 "The trigger error action table is invalid\n"); 327 goto out_rel_header; 328 } 329 330 /* No action structures in the TRIGGER_ERROR table, nothing to do */ 331 if (!trigger_tab->entry_count) 332 goto out_rel_header; 333 334 rc = -EIO; 335 table_size = trigger_tab->table_size; 336 r = request_mem_region(trigger_paddr + sizeof(*trigger_tab), 337 table_size - sizeof(*trigger_tab), 338 "APEI EINJ Trigger Table"); 339 if (!r) { 340 pr_err(EINJ_PFX 341 "Can not request [mem %#010llx-%#010llx] for Trigger Table Entry\n", 342 (unsigned long long)trigger_paddr + sizeof(*trigger_tab), 343 (unsigned long long)trigger_paddr + table_size - 1); 344 goto out_rel_header; 345 } 346 iounmap(trigger_tab); 347 trigger_tab = ioremap_cache(trigger_paddr, table_size); 348 if (!trigger_tab) { 349 pr_err(EINJ_PFX "Failed to map trigger table!\n"); 350 goto out_rel_entry; 351 } 352 trigger_entry = (struct acpi_whea_header *) 353 ((char *)trigger_tab + sizeof(struct acpi_einj_trigger)); 354 apei_resources_init(&trigger_resources); 355 apei_exec_ctx_init(&trigger_ctx, einj_ins_type, 356 ARRAY_SIZE(einj_ins_type), 357 trigger_entry, trigger_tab->entry_count); 358 rc = apei_exec_collect_resources(&trigger_ctx, &trigger_resources); 359 if (rc) 360 goto out_fini; 361 rc = apei_resources_sub(&trigger_resources, &einj_resources); 362 if (rc) 363 goto out_fini; 364 /* 365 * Some firmware will access target address specified in 366 * param1 to trigger the error when injecting memory error. 367 * This will cause resource conflict with regular memory. So 368 * remove it from trigger table resources. 369 */ 370 if ((param_extension || acpi5) && (type & 0x0038) && param2) { 371 struct apei_resources addr_resources; 372 apei_resources_init(&addr_resources); 373 trigger_param_region = einj_get_trigger_parameter_region( 374 trigger_tab, param1, param2); 375 if (trigger_param_region) { 376 rc = apei_resources_add(&addr_resources, 377 trigger_param_region->address, 378 trigger_param_region->bit_width/8, true); 379 if (rc) 380 goto out_fini; 381 rc = apei_resources_sub(&trigger_resources, 382 &addr_resources); 383 } 384 apei_resources_fini(&addr_resources); 385 if (rc) 386 goto out_fini; 387 } 388 rc = apei_resources_request(&trigger_resources, "APEI EINJ Trigger"); 389 if (rc) 390 goto out_fini; 391 rc = apei_exec_pre_map_gars(&trigger_ctx); 392 if (rc) 393 goto out_release; 394 395 rc = apei_exec_run(&trigger_ctx, ACPI_EINJ_TRIGGER_ERROR); 396 397 apei_exec_post_unmap_gars(&trigger_ctx); 398 out_release: 399 apei_resources_release(&trigger_resources); 400 out_fini: 401 apei_resources_fini(&trigger_resources); 402 out_rel_entry: 403 release_mem_region(trigger_paddr + sizeof(*trigger_tab), 404 table_size - sizeof(*trigger_tab)); 405 out_rel_header: 406 release_mem_region(trigger_paddr, sizeof(*trigger_tab)); 407 out: 408 if (trigger_tab) 409 iounmap(trigger_tab); 410 411 return rc; 412 } 413 414 static int __einj_error_inject(u32 type, u64 param1, u64 param2) 415 { 416 struct apei_exec_context ctx; 417 u64 val, trigger_paddr, timeout = FIRMWARE_TIMEOUT; 418 int rc; 419 420 einj_exec_ctx_init(&ctx); 421 422 rc = apei_exec_run_optional(&ctx, ACPI_EINJ_BEGIN_OPERATION); 423 if (rc) 424 return rc; 425 apei_exec_ctx_set_input(&ctx, type); 426 if (acpi5) { 427 struct set_error_type_with_address *v5param = einj_param; 428 429 v5param->type = type; 430 if (type & 0x80000000) { 431 switch (vendor_flags) { 432 case SETWA_FLAGS_APICID: 433 v5param->apicid = param1; 434 break; 435 case SETWA_FLAGS_MEM: 436 v5param->memory_address = param1; 437 v5param->memory_address_range = param2; 438 break; 439 case SETWA_FLAGS_PCIE_SBDF: 440 v5param->pcie_sbdf = param1; 441 break; 442 } 443 v5param->flags = vendor_flags; 444 } else { 445 switch (type) { 446 case ACPI_EINJ_PROCESSOR_CORRECTABLE: 447 case ACPI_EINJ_PROCESSOR_UNCORRECTABLE: 448 case ACPI_EINJ_PROCESSOR_FATAL: 449 v5param->apicid = param1; 450 v5param->flags = SETWA_FLAGS_APICID; 451 break; 452 case ACPI_EINJ_MEMORY_CORRECTABLE: 453 case ACPI_EINJ_MEMORY_UNCORRECTABLE: 454 case ACPI_EINJ_MEMORY_FATAL: 455 v5param->memory_address = param1; 456 v5param->memory_address_range = param2; 457 v5param->flags = SETWA_FLAGS_MEM; 458 break; 459 case ACPI_EINJ_PCIX_CORRECTABLE: 460 case ACPI_EINJ_PCIX_UNCORRECTABLE: 461 case ACPI_EINJ_PCIX_FATAL: 462 v5param->pcie_sbdf = param1; 463 v5param->flags = SETWA_FLAGS_PCIE_SBDF; 464 break; 465 } 466 } 467 } else { 468 rc = apei_exec_run(&ctx, ACPI_EINJ_SET_ERROR_TYPE); 469 if (rc) 470 return rc; 471 if (einj_param) { 472 struct einj_parameter *v4param = einj_param; 473 v4param->param1 = param1; 474 v4param->param2 = param2; 475 } 476 } 477 rc = apei_exec_run(&ctx, ACPI_EINJ_EXECUTE_OPERATION); 478 if (rc) 479 return rc; 480 for (;;) { 481 rc = apei_exec_run(&ctx, ACPI_EINJ_CHECK_BUSY_STATUS); 482 if (rc) 483 return rc; 484 val = apei_exec_ctx_get_output(&ctx); 485 if (!(val & EINJ_OP_BUSY)) 486 break; 487 if (einj_timedout(&timeout)) 488 return -EIO; 489 } 490 rc = apei_exec_run(&ctx, ACPI_EINJ_GET_COMMAND_STATUS); 491 if (rc) 492 return rc; 493 val = apei_exec_ctx_get_output(&ctx); 494 if (val != EINJ_STATUS_SUCCESS) 495 return -EBUSY; 496 497 rc = apei_exec_run(&ctx, ACPI_EINJ_GET_TRIGGER_TABLE); 498 if (rc) 499 return rc; 500 trigger_paddr = apei_exec_ctx_get_output(&ctx); 501 if (notrigger == 0) { 502 rc = __einj_error_trigger(trigger_paddr, type, param1, param2); 503 if (rc) 504 return rc; 505 } 506 rc = apei_exec_run_optional(&ctx, ACPI_EINJ_END_OPERATION); 507 508 return rc; 509 } 510 511 /* Inject the specified hardware error */ 512 static int einj_error_inject(u32 type, u64 param1, u64 param2) 513 { 514 int rc; 515 516 mutex_lock(&einj_mutex); 517 rc = __einj_error_inject(type, param1, param2); 518 mutex_unlock(&einj_mutex); 519 520 return rc; 521 } 522 523 static u32 error_type; 524 static u64 error_param1; 525 static u64 error_param2; 526 static struct dentry *einj_debug_dir; 527 528 static int available_error_type_show(struct seq_file *m, void *v) 529 { 530 int rc; 531 u32 available_error_type = 0; 532 533 rc = einj_get_available_error_type(&available_error_type); 534 if (rc) 535 return rc; 536 if (available_error_type & 0x0001) 537 seq_printf(m, "0x00000001\tProcessor Correctable\n"); 538 if (available_error_type & 0x0002) 539 seq_printf(m, "0x00000002\tProcessor Uncorrectable non-fatal\n"); 540 if (available_error_type & 0x0004) 541 seq_printf(m, "0x00000004\tProcessor Uncorrectable fatal\n"); 542 if (available_error_type & 0x0008) 543 seq_printf(m, "0x00000008\tMemory Correctable\n"); 544 if (available_error_type & 0x0010) 545 seq_printf(m, "0x00000010\tMemory Uncorrectable non-fatal\n"); 546 if (available_error_type & 0x0020) 547 seq_printf(m, "0x00000020\tMemory Uncorrectable fatal\n"); 548 if (available_error_type & 0x0040) 549 seq_printf(m, "0x00000040\tPCI Express Correctable\n"); 550 if (available_error_type & 0x0080) 551 seq_printf(m, "0x00000080\tPCI Express Uncorrectable non-fatal\n"); 552 if (available_error_type & 0x0100) 553 seq_printf(m, "0x00000100\tPCI Express Uncorrectable fatal\n"); 554 if (available_error_type & 0x0200) 555 seq_printf(m, "0x00000200\tPlatform Correctable\n"); 556 if (available_error_type & 0x0400) 557 seq_printf(m, "0x00000400\tPlatform Uncorrectable non-fatal\n"); 558 if (available_error_type & 0x0800) 559 seq_printf(m, "0x00000800\tPlatform Uncorrectable fatal\n"); 560 561 return 0; 562 } 563 564 static int available_error_type_open(struct inode *inode, struct file *file) 565 { 566 return single_open(file, available_error_type_show, NULL); 567 } 568 569 static const struct file_operations available_error_type_fops = { 570 .open = available_error_type_open, 571 .read = seq_read, 572 .llseek = seq_lseek, 573 .release = single_release, 574 }; 575 576 static int error_type_get(void *data, u64 *val) 577 { 578 *val = error_type; 579 580 return 0; 581 } 582 583 static int error_type_set(void *data, u64 val) 584 { 585 int rc; 586 u32 available_error_type = 0; 587 u32 tval, vendor; 588 589 /* 590 * Vendor defined types have 0x80000000 bit set, and 591 * are not enumerated by ACPI_EINJ_GET_ERROR_TYPE 592 */ 593 vendor = val & 0x80000000; 594 tval = val & 0x7fffffff; 595 596 /* Only one error type can be specified */ 597 if (tval & (tval - 1)) 598 return -EINVAL; 599 if (!vendor) { 600 rc = einj_get_available_error_type(&available_error_type); 601 if (rc) 602 return rc; 603 if (!(val & available_error_type)) 604 return -EINVAL; 605 } 606 error_type = val; 607 608 return 0; 609 } 610 611 DEFINE_SIMPLE_ATTRIBUTE(error_type_fops, error_type_get, 612 error_type_set, "0x%llx\n"); 613 614 static int error_inject_set(void *data, u64 val) 615 { 616 if (!error_type) 617 return -EINVAL; 618 619 return einj_error_inject(error_type, error_param1, error_param2); 620 } 621 622 DEFINE_SIMPLE_ATTRIBUTE(error_inject_fops, NULL, 623 error_inject_set, "%llu\n"); 624 625 static int einj_check_table(struct acpi_table_einj *einj_tab) 626 { 627 if ((einj_tab->header_length != 628 (sizeof(struct acpi_table_einj) - sizeof(einj_tab->header))) 629 && (einj_tab->header_length != sizeof(struct acpi_table_einj))) 630 return -EINVAL; 631 if (einj_tab->header.length < sizeof(struct acpi_table_einj)) 632 return -EINVAL; 633 if (einj_tab->entries != 634 (einj_tab->header.length - sizeof(struct acpi_table_einj)) / 635 sizeof(struct acpi_einj_entry)) 636 return -EINVAL; 637 638 return 0; 639 } 640 641 static int __init einj_init(void) 642 { 643 int rc; 644 acpi_status status; 645 struct dentry *fentry; 646 struct apei_exec_context ctx; 647 648 if (acpi_disabled) 649 return -ENODEV; 650 651 status = acpi_get_table(ACPI_SIG_EINJ, 0, 652 (struct acpi_table_header **)&einj_tab); 653 if (status == AE_NOT_FOUND) 654 return -ENODEV; 655 else if (ACPI_FAILURE(status)) { 656 const char *msg = acpi_format_exception(status); 657 pr_err(EINJ_PFX "Failed to get table, %s\n", msg); 658 return -EINVAL; 659 } 660 661 rc = einj_check_table(einj_tab); 662 if (rc) { 663 pr_warning(FW_BUG EINJ_PFX "EINJ table is invalid\n"); 664 return -EINVAL; 665 } 666 667 rc = -ENOMEM; 668 einj_debug_dir = debugfs_create_dir("einj", apei_get_debugfs_dir()); 669 if (!einj_debug_dir) 670 goto err_cleanup; 671 fentry = debugfs_create_file("available_error_type", S_IRUSR, 672 einj_debug_dir, NULL, 673 &available_error_type_fops); 674 if (!fentry) 675 goto err_cleanup; 676 fentry = debugfs_create_file("error_type", S_IRUSR | S_IWUSR, 677 einj_debug_dir, NULL, &error_type_fops); 678 if (!fentry) 679 goto err_cleanup; 680 fentry = debugfs_create_file("error_inject", S_IWUSR, 681 einj_debug_dir, NULL, &error_inject_fops); 682 if (!fentry) 683 goto err_cleanup; 684 685 apei_resources_init(&einj_resources); 686 einj_exec_ctx_init(&ctx); 687 rc = apei_exec_collect_resources(&ctx, &einj_resources); 688 if (rc) 689 goto err_fini; 690 rc = apei_resources_request(&einj_resources, "APEI EINJ"); 691 if (rc) 692 goto err_fini; 693 rc = apei_exec_pre_map_gars(&ctx); 694 if (rc) 695 goto err_release; 696 697 einj_param = einj_get_parameter_address(); 698 if ((param_extension || acpi5) && einj_param) { 699 fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR, 700 einj_debug_dir, &error_param1); 701 if (!fentry) 702 goto err_unmap; 703 fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR, 704 einj_debug_dir, &error_param2); 705 if (!fentry) 706 goto err_unmap; 707 708 fentry = debugfs_create_x32("notrigger", S_IRUSR | S_IWUSR, 709 einj_debug_dir, ¬rigger); 710 if (!fentry) 711 goto err_unmap; 712 } 713 714 if (vendor_dev[0]) { 715 vendor_blob.data = vendor_dev; 716 vendor_blob.size = strlen(vendor_dev); 717 fentry = debugfs_create_blob("vendor", S_IRUSR, 718 einj_debug_dir, &vendor_blob); 719 if (!fentry) 720 goto err_unmap; 721 fentry = debugfs_create_x32("vendor_flags", S_IRUSR | S_IWUSR, 722 einj_debug_dir, &vendor_flags); 723 if (!fentry) 724 goto err_unmap; 725 } 726 727 pr_info(EINJ_PFX "Error INJection is initialized.\n"); 728 729 return 0; 730 731 err_unmap: 732 if (einj_param) { 733 acpi_size size = (acpi5) ? 734 sizeof(struct set_error_type_with_address) : 735 sizeof(struct einj_parameter); 736 737 acpi_os_unmap_memory(einj_param, size); 738 } 739 apei_exec_post_unmap_gars(&ctx); 740 err_release: 741 apei_resources_release(&einj_resources); 742 err_fini: 743 apei_resources_fini(&einj_resources); 744 err_cleanup: 745 debugfs_remove_recursive(einj_debug_dir); 746 747 return rc; 748 } 749 750 static void __exit einj_exit(void) 751 { 752 struct apei_exec_context ctx; 753 754 if (einj_param) { 755 acpi_size size = (acpi5) ? 756 sizeof(struct set_error_type_with_address) : 757 sizeof(struct einj_parameter); 758 759 acpi_os_unmap_memory(einj_param, size); 760 } 761 einj_exec_ctx_init(&ctx); 762 apei_exec_post_unmap_gars(&ctx); 763 apei_resources_release(&einj_resources); 764 apei_resources_fini(&einj_resources); 765 debugfs_remove_recursive(einj_debug_dir); 766 } 767 768 module_init(einj_init); 769 module_exit(einj_exit); 770 771 MODULE_AUTHOR("Huang Ying"); 772 MODULE_DESCRIPTION("APEI Error INJection support"); 773 MODULE_LICENSE("GPL"); 774