drivers/acpi/apei/einj.c

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