drivers/acpi/apei/apei-base.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * apei-base.c - ACPI Platform Error Interface (APEI) supporting
   4  * infrastructure
   5  *
   6  * APEI allows to report errors (for example from the chipset) to the
   7  * the operating system. This improves NMI handling especially. In
   8  * addition it supports error serialization and error injection.
   9  *
  10  * For more information about APEI, please refer to ACPI Specification
  11  * version 4.0, chapter 17.
  12  *
  13  * This file has Common functions used by more than one APEI table,
  14  * including framework of interpreter for ERST and EINJ; resource
  15  * management for APEI registers.
  16  *
  17  * Copyright (C) 2009, Intel Corp.
  18  *      Author: Huang Ying <ying.huang@intel.com>
  19  */
  20
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/init.h>
  24 #include <linux/acpi.h>
  25 #include <linux/slab.h>
  26 #include <linux/io.h>
  27 #include <linux/kref.h>
  28 #include <linux/rculist.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/debugfs.h>
  31 #include <asm/unaligned.h>
  32
  33 #include "apei-internal.h"
  34
  35 #define APEI_PFX "APEI: "
  36
  37 /*
  38  * APEI ERST (Error Record Serialization Table) and EINJ (Error
  39  * INJection) interpreter framework.
  40  */
  41
  42 #define APEI_EXEC_PRESERVE_REGISTER     0x1
  43
  44 void apei_exec_ctx_init(struct apei_exec_context *ctx,
  45                         struct apei_exec_ins_type *ins_table,
  46                         u32 instructions,
  47                         struct acpi_whea_header *action_table,
  48                         u32 entries)
  49 {
  50         ctx->ins_table = ins_table;
  51         ctx->instructions = instructions;
  52         ctx->action_table = action_table;
  53         ctx->entries = entries;
  54 }
  55 EXPORT_SYMBOL_GPL(apei_exec_ctx_init);
  56
  57 int __apei_exec_read_register(struct acpi_whea_header *entry, u64 *val)
  58 {
  59         int rc;
  60
  61         rc = apei_read(val, &entry->register_region);
  62         if (rc)
  63                 return rc;
  64         *val >>= entry->register_region.bit_offset;
  65         *val &= entry->mask;
  66
  67         return 0;
  68 }
  69
  70 int apei_exec_read_register(struct apei_exec_context *ctx,
  71                             struct acpi_whea_header *entry)
  72 {
  73         int rc;
  74         u64 val = 0;
  75
  76         rc = __apei_exec_read_register(entry, &val);
  77         if (rc)
  78                 return rc;
  79         ctx->value = val;
  80
  81         return 0;
  82 }
  83 EXPORT_SYMBOL_GPL(apei_exec_read_register);
  84
  85 int apei_exec_read_register_value(struct apei_exec_context *ctx,
  86                                   struct acpi_whea_header *entry)
  87 {
  88         int rc;
  89
  90         rc = apei_exec_read_register(ctx, entry);
  91         if (rc)
  92                 return rc;
  93         ctx->value = (ctx->value == entry->value);
  94
  95         return 0;
  96 }
  97 EXPORT_SYMBOL_GPL(apei_exec_read_register_value);
  98
  99 int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val)
 100 {
 101         int rc;
 102
 103         val &= entry->mask;
 104         val <<= entry->register_region.bit_offset;
 105         if (entry->flags & APEI_EXEC_PRESERVE_REGISTER) {
 106                 u64 valr = 0;
 107                 rc = apei_read(&valr, &entry->register_region);
 108                 if (rc)
 109                         return rc;
 110                 valr &= ~(entry->mask << entry->register_region.bit_offset);
 111                 val |= valr;
 112         }
 113         rc = apei_write(val, &entry->register_region);
 114
 115         return rc;
 116 }
 117
 118 int apei_exec_write_register(struct apei_exec_context *ctx,
 119                              struct acpi_whea_header *entry)
 120 {
 121         return __apei_exec_write_register(entry, ctx->value);
 122 }
 123 EXPORT_SYMBOL_GPL(apei_exec_write_register);
 124
 125 int apei_exec_write_register_value(struct apei_exec_context *ctx,
 126                                    struct acpi_whea_header *entry)
 127 {
 128         int rc;
 129
 130         ctx->value = entry->value;
 131         rc = apei_exec_write_register(ctx, entry);
 132
 133         return rc;
 134 }
 135 EXPORT_SYMBOL_GPL(apei_exec_write_register_value);
 136
 137 int apei_exec_noop(struct apei_exec_context *ctx,
 138                    struct acpi_whea_header *entry)
 139 {
 140         return 0;
 141 }
 142 EXPORT_SYMBOL_GPL(apei_exec_noop);
 143
 144 /*
 145  * Interpret the specified action. Go through whole action table,
 146  * execute all instructions belong to the action.
 147  */
 148 int __apei_exec_run(struct apei_exec_context *ctx, u8 action,
 149                     bool optional)
 150 {
 151         int rc = -ENOENT;
 152         u32 i, ip;
 153         struct acpi_whea_header *entry;
 154         apei_exec_ins_func_t run;
 155
 156         ctx->ip = 0;
 157
 158         /*
 159          * "ip" is the instruction pointer of current instruction,
 160          * "ctx->ip" specifies the next instruction to executed,
 161          * instruction "run" function may change the "ctx->ip" to
 162          * implement "goto" semantics.
 163          */
 164 rewind:
 165         ip = 0;
 166         for (i = 0; i < ctx->entries; i++) {
 167                 entry = &ctx->action_table[i];
 168                 if (entry->action != action)
 169                         continue;
 170                 if (ip == ctx->ip) {
 171                         if (entry->instruction >= ctx->instructions ||
 172                             !ctx->ins_table[entry->instruction].run) {
 173                                 pr_warn(FW_WARN APEI_PFX
 174                                         "Invalid action table, unknown instruction type: %d\n",
 175                                         entry->instruction);
 176                                 return -EINVAL;
 177                         }
 178                         run = ctx->ins_table[entry->instruction].run;
 179                         rc = run(ctx, entry);
 180                         if (rc < 0)
 181                                 return rc;
 182                         else if (rc != APEI_EXEC_SET_IP)
 183                                 ctx->ip++;
 184                 }
 185                 ip++;
 186                 if (ctx->ip < ip)
 187                         goto rewind;
 188         }
 189
 190         return !optional && rc < 0 ? rc : 0;
 191 }
 192 EXPORT_SYMBOL_GPL(__apei_exec_run);
 193
 194 typedef int (*apei_exec_entry_func_t)(struct apei_exec_context *ctx,
 195                                       struct acpi_whea_header *entry,
 196                                       void *data);
 197
 198 static int apei_exec_for_each_entry(struct apei_exec_context *ctx,
 199                                     apei_exec_entry_func_t func,
 200                                     void *data,
 201                                     int *end)
 202 {
 203         u8 ins;
 204         int i, rc;
 205         struct acpi_whea_header *entry;
 206         struct apei_exec_ins_type *ins_table = ctx->ins_table;
 207
 208         for (i = 0; i < ctx->entries; i++) {
 209                 entry = ctx->action_table + i;
 210                 ins = entry->instruction;
 211                 if (end)
 212                         *end = i;
 213                 if (ins >= ctx->instructions || !ins_table[ins].run) {
 214                         pr_warn(FW_WARN APEI_PFX
 215                                 "Invalid action table, unknown instruction type: %d\n",
 216                                 ins);
 217                         return -EINVAL;
 218                 }
 219                 rc = func(ctx, entry, data);
 220                 if (rc)
 221                         return rc;
 222         }
 223
 224         return 0;
 225 }
 226
 227 static int pre_map_gar_callback(struct apei_exec_context *ctx,
 228                                 struct acpi_whea_header *entry,
 229                                 void *data)
 230 {
 231         u8 ins = entry->instruction;
 232
 233         if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
 234                 return apei_map_generic_address(&entry->register_region);
 235
 236         return 0;
 237 }
 238
 239 /*
 240  * Pre-map all GARs in action table to make it possible to access them
 241  * in NMI handler.
 242  */
 243 int apei_exec_pre_map_gars(struct apei_exec_context *ctx)
 244 {
 245         int rc, end;
 246
 247         rc = apei_exec_for_each_entry(ctx, pre_map_gar_callback,
 248                                       NULL, &end);
 249         if (rc) {
 250                 struct apei_exec_context ctx_unmap;
 251                 memcpy(&ctx_unmap, ctx, sizeof(*ctx));
 252                 ctx_unmap.entries = end;
 253                 apei_exec_post_unmap_gars(&ctx_unmap);
 254         }
 255
 256         return rc;
 257 }
 258 EXPORT_SYMBOL_GPL(apei_exec_pre_map_gars);
 259
 260 static int post_unmap_gar_callback(struct apei_exec_context *ctx,
 261                                    struct acpi_whea_header *entry,
 262                                    void *data)
 263 {
 264         u8 ins = entry->instruction;
 265
 266         if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
 267                 apei_unmap_generic_address(&entry->register_region);
 268
 269         return 0;
 270 }
 271
 272 /* Post-unmap all GAR in action table. */
 273 int apei_exec_post_unmap_gars(struct apei_exec_context *ctx)
 274 {
 275         return apei_exec_for_each_entry(ctx, post_unmap_gar_callback,
 276                                         NULL, NULL);
 277 }
 278 EXPORT_SYMBOL_GPL(apei_exec_post_unmap_gars);
 279
 280 /*
 281  * Resource management for GARs in APEI
 282  */
 283 struct apei_res {
 284         struct list_head list;
 285         unsigned long start;
 286         unsigned long end;
 287 };
 288
 289 /* Collect all resources requested, to avoid conflict */
 290 static struct apei_resources apei_resources_all = {
 291         .iomem = LIST_HEAD_INIT(apei_resources_all.iomem),
 292         .ioport = LIST_HEAD_INIT(apei_resources_all.ioport),
 293 };
 294
 295 static int apei_res_add(struct list_head *res_list,
 296                         unsigned long start, unsigned long size)
 297 {
 298         struct apei_res *res, *resn, *res_ins = NULL;
 299         unsigned long end = start + size;
 300
 301         if (end <= start)
 302                 return 0;
 303 repeat:
 304         list_for_each_entry_safe(res, resn, res_list, list) {
 305                 if (res->start > end || res->end < start)
 306                         continue;
 307                 else if (end <= res->end && start >= res->start) {
 308                         kfree(res_ins);
 309                         return 0;
 310                 }
 311                 list_del(&res->list);
 312                 res->start = start = min(res->start, start);
 313                 res->end = end = max(res->end, end);
 314                 kfree(res_ins);
 315                 res_ins = res;
 316                 goto repeat;
 317         }
 318
 319         if (res_ins)
 320                 list_add(&res_ins->list, res_list);
 321         else {
 322                 res_ins = kmalloc(sizeof(*res), GFP_KERNEL);
 323                 if (!res_ins)
 324                         return -ENOMEM;
 325                 res_ins->start = start;
 326                 res_ins->end = end;
 327                 list_add(&res_ins->list, res_list);
 328         }
 329
 330         return 0;
 331 }
 332
 333 static int apei_res_sub(struct list_head *res_list1,
 334                         struct list_head *res_list2)
 335 {
 336         struct apei_res *res1, *resn1, *res2, *res;
 337         res1 = list_entry(res_list1->next, struct apei_res, list);
 338         resn1 = list_entry(res1->list.next, struct apei_res, list);
 339         while (&res1->list != res_list1) {
 340                 list_for_each_entry(res2, res_list2, list) {
 341                         if (res1->start >= res2->end ||
 342                             res1->end <= res2->start)
 343                                 continue;
 344                         else if (res1->end <= res2->end &&
 345                                  res1->start >= res2->start) {
 346                                 list_del(&res1->list);
 347                                 kfree(res1);
 348                                 break;
 349                         } else if (res1->end > res2->end &&
 350                                    res1->start < res2->start) {
 351                                 res = kmalloc(sizeof(*res), GFP_KERNEL);
 352                                 if (!res)
 353                                         return -ENOMEM;
 354                                 res->start = res2->end;
 355                                 res->end = res1->end;
 356                                 res1->end = res2->start;
 357                                 list_add(&res->list, &res1->list);
 358                                 resn1 = res;
 359                         } else {
 360                                 if (res1->start < res2->start)
 361                                         res1->end = res2->start;
 362                                 else
 363                                         res1->start = res2->end;
 364                         }
 365                 }
 366                 res1 = resn1;
 367                 resn1 = list_entry(resn1->list.next, struct apei_res, list);
 368         }
 369
 370         return 0;
 371 }
 372
 373 static void apei_res_clean(struct list_head *res_list)
 374 {
 375         struct apei_res *res, *resn;
 376
 377         list_for_each_entry_safe(res, resn, res_list, list) {
 378                 list_del(&res->list);
 379                 kfree(res);
 380         }
 381 }
 382
 383 void apei_resources_fini(struct apei_resources *resources)
 384 {
 385         apei_res_clean(&resources->iomem);
 386         apei_res_clean(&resources->ioport);
 387 }
 388 EXPORT_SYMBOL_GPL(apei_resources_fini);
 389
 390 static int apei_resources_merge(struct apei_resources *resources1,
 391                                 struct apei_resources *resources2)
 392 {
 393         int rc;
 394         struct apei_res *res;
 395
 396         list_for_each_entry(res, &resources2->iomem, list) {
 397                 rc = apei_res_add(&resources1->iomem, res->start,
 398                                   res->end - res->start);
 399                 if (rc)
 400                         return rc;
 401         }
 402         list_for_each_entry(res, &resources2->ioport, list) {
 403                 rc = apei_res_add(&resources1->ioport, res->start,
 404                                   res->end - res->start);
 405                 if (rc)
 406                         return rc;
 407         }
 408
 409         return 0;
 410 }
 411
 412 int apei_resources_add(struct apei_resources *resources,
 413                        unsigned long start, unsigned long size,
 414                        bool iomem)
 415 {
 416         if (iomem)
 417                 return apei_res_add(&resources->iomem, start, size);
 418         else
 419                 return apei_res_add(&resources->ioport, start, size);
 420 }
 421 EXPORT_SYMBOL_GPL(apei_resources_add);
 422
 423 /*
 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.
 427  */
 428 int apei_resources_sub(struct apei_resources *resources1,
 429                        struct apei_resources *resources2)
 430 {
 431         int rc;
 432
 433         rc = apei_res_sub(&resources1->iomem, &resources2->iomem);
 434         if (rc)
 435                 return rc;
 436         return apei_res_sub(&resources1->ioport, &resources2->ioport);
 437 }
 438 EXPORT_SYMBOL_GPL(apei_resources_sub);
 439
 440 static int apei_get_res_callback(__u64 start, __u64 size, void *data)
 441 {
 442         struct apei_resources *resources = data;
 443         return apei_res_add(&resources->iomem, start, size);
 444 }
 445
 446 static int apei_get_nvs_resources(struct apei_resources *resources)
 447 {
 448         return acpi_nvs_for_each_region(apei_get_res_callback, resources);
 449 }
 450
 451 int (*arch_apei_filter_addr)(int (*func)(__u64 start, __u64 size,
 452                                      void *data), void *data);
 453 static int apei_get_arch_resources(struct apei_resources *resources)
 454
 455 {
 456         return arch_apei_filter_addr(apei_get_res_callback, resources);
 457 }
 458
 459 /*
 460  * IO memory/port resource management mechanism is used to check
 461  * whether memory/port area used by GARs conflicts with normal memory
 462  * or IO memory/port of devices.
 463  */
 464 int apei_resources_request(struct apei_resources *resources,
 465                            const char *desc)
 466 {
 467         struct apei_res *res, *res_bak = NULL;
 468         struct resource *r;
 469         struct apei_resources nvs_resources, arch_res;
 470         int rc;
 471
 472         rc = apei_resources_sub(resources, &apei_resources_all);
 473         if (rc)
 474                 return rc;
 475
 476         /*
 477          * Some firmware uses ACPI NVS region, that has been marked as
 478          * busy, so exclude it from APEI resources to avoid false
 479          * conflict.
 480          */
 481         apei_resources_init(&nvs_resources);
 482         rc = apei_get_nvs_resources(&nvs_resources);
 483         if (rc)
 484                 goto nvs_res_fini;
 485         rc = apei_resources_sub(resources, &nvs_resources);
 486         if (rc)
 487                 goto nvs_res_fini;
 488
 489         if (arch_apei_filter_addr) {
 490                 apei_resources_init(&arch_res);
 491                 rc = apei_get_arch_resources(&arch_res);
 492                 if (rc)
 493                         goto arch_res_fini;
 494                 rc = apei_resources_sub(resources, &arch_res);
 495                 if (rc)
 496                         goto arch_res_fini;
 497         }
 498
 499         rc = -EINVAL;
 500         list_for_each_entry(res, &resources->iomem, list) {
 501                 r = request_mem_region(res->start, res->end - res->start,
 502                                        desc);
 503                 if (!r) {
 504                         pr_err(APEI_PFX
 505                 "Can not request [mem %#010llx-%#010llx] for %s registers\n",
 506                                (unsigned long long)res->start,
 507                                (unsigned long long)res->end - 1, desc);
 508                         res_bak = res;
 509                         goto err_unmap_iomem;
 510                 }
 511         }
 512
 513         list_for_each_entry(res, &resources->ioport, list) {
 514                 r = request_region(res->start, res->end - res->start, desc);
 515                 if (!r) {
 516                         pr_err(APEI_PFX
 517                 "Can not request [io  %#06llx-%#06llx] for %s registers\n",
 518                                (unsigned long long)res->start,
 519                                (unsigned long long)res->end - 1, desc);
 520                         res_bak = res;
 521                         goto err_unmap_ioport;
 522                 }
 523         }
 524
 525         rc = apei_resources_merge(&apei_resources_all, resources);
 526         if (rc) {
 527                 pr_err(APEI_PFX "Fail to merge resources!\n");
 528                 goto err_unmap_ioport;
 529         }
 530
 531         goto arch_res_fini;
 532
 533 err_unmap_ioport:
 534         list_for_each_entry(res, &resources->ioport, list) {
 535                 if (res == res_bak)
 536                         break;
 537                 release_region(res->start, res->end - res->start);
 538         }
 539         res_bak = NULL;
 540 err_unmap_iomem:
 541         list_for_each_entry(res, &resources->iomem, list) {
 542                 if (res == res_bak)
 543                         break;
 544                 release_mem_region(res->start, res->end - res->start);
 545         }
 546 arch_res_fini:
 547         if (arch_apei_filter_addr)
 548                 apei_resources_fini(&arch_res);
 549 nvs_res_fini:
 550         apei_resources_fini(&nvs_resources);
 551         return rc;
 552 }
 553 EXPORT_SYMBOL_GPL(apei_resources_request);
 554
 555 void apei_resources_release(struct apei_resources *resources)
 556 {
 557         int rc;
 558         struct apei_res *res;
 559
 560         list_for_each_entry(res, &resources->iomem, list)
 561                 release_mem_region(res->start, res->end - res->start);
 562         list_for_each_entry(res, &resources->ioport, list)
 563                 release_region(res->start, res->end - res->start);
 564
 565         rc = apei_resources_sub(&apei_resources_all, resources);
 566         if (rc)
 567                 pr_err(APEI_PFX "Fail to sub resources!\n");
 568 }
 569 EXPORT_SYMBOL_GPL(apei_resources_release);
 570
 571 static int apei_check_gar(struct acpi_generic_address *reg, u64 *paddr,
 572                                 u32 *access_bit_width)
 573 {
 574         u32 bit_width, bit_offset, access_size_code, space_id;
 575
 576         bit_width = reg->bit_width;
 577         bit_offset = reg->bit_offset;
 578         access_size_code = reg->access_width;
 579         space_id = reg->space_id;
 580         *paddr = get_unaligned(&reg->address);
 581         if (!*paddr) {
 582                 pr_warn(FW_BUG APEI_PFX
 583                         "Invalid physical address in GAR [0x%llx/%u/%u/%u/%u]\n",
 584                         *paddr, bit_width, bit_offset, access_size_code,
 585                         space_id);
 586                 return -EINVAL;
 587         }
 588
 589         if (access_size_code < 1 || access_size_code > 4) {
 590                 pr_warn(FW_BUG APEI_PFX
 591                         "Invalid access size code in GAR [0x%llx/%u/%u/%u/%u]\n",
 592                         *paddr, bit_width, bit_offset, access_size_code,
 593                         space_id);
 594                 return -EINVAL;
 595         }
 596         *access_bit_width = 1UL << (access_size_code + 2);
 597
 598         /* Fixup common BIOS bug */
 599         if (bit_width == 32 && bit_offset == 0 && (*paddr & 0x03) == 0 &&
 600             *access_bit_width < 32)
 601                 *access_bit_width = 32;
 602         else if (bit_width == 64 && bit_offset == 0 && (*paddr & 0x07) == 0 &&
 603             *access_bit_width < 64)
 604                 *access_bit_width = 64;
 605
 606         if ((bit_width + bit_offset) > *access_bit_width) {
 607                 pr_warn(FW_BUG APEI_PFX
 608                         "Invalid bit width + offset in GAR [0x%llx/%u/%u/%u/%u]\n",
 609                         *paddr, bit_width, bit_offset, access_size_code,
 610                         space_id);
 611                 return -EINVAL;
 612         }
 613
 614         if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
 615             space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
 616                 pr_warn(FW_BUG APEI_PFX
 617                         "Invalid address space type in GAR [0x%llx/%u/%u/%u/%u]\n",
 618                         *paddr, bit_width, bit_offset, access_size_code,
 619                         space_id);
 620                 return -EINVAL;
 621         }
 622
 623         return 0;
 624 }
 625
 626 int apei_map_generic_address(struct acpi_generic_address *reg)
 627 {
 628         int rc;
 629         u32 access_bit_width;
 630         u64 address;
 631
 632         rc = apei_check_gar(reg, &address, &access_bit_width);
 633         if (rc)
 634                 return rc;
 635
 636         /* IO space doesn't need mapping */
 637         if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
 638                 return 0;
 639
 640         if (!acpi_os_map_generic_address(reg))
 641                 return -ENXIO;
 642
 643         return 0;
 644 }
 645 EXPORT_SYMBOL_GPL(apei_map_generic_address);
 646
 647 /* read GAR in interrupt (including NMI) or process context */
 648 int apei_read(u64 *val, struct acpi_generic_address *reg)
 649 {
 650         int rc;
 651         u32 access_bit_width;
 652         u64 address;
 653         acpi_status status;
 654
 655         rc = apei_check_gar(reg, &address, &access_bit_width);
 656         if (rc)
 657                 return rc;
 658
 659         *val = 0;
 660         switch(reg->space_id) {
 661         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 662                 status = acpi_os_read_memory((acpi_physical_address) address,
 663                                                val, access_bit_width);
 664                 if (ACPI_FAILURE(status))
 665                         return -EIO;
 666                 break;
 667         case ACPI_ADR_SPACE_SYSTEM_IO:
 668                 status = acpi_os_read_port(address, (u32 *)val,
 669                                            access_bit_width);
 670                 if (ACPI_FAILURE(status))
 671                         return -EIO;
 672                 break;
 673         default:
 674                 return -EINVAL;
 675         }
 676
 677         return 0;
 678 }
 679 EXPORT_SYMBOL_GPL(apei_read);
 680
 681 /* write GAR in interrupt (including NMI) or process context */
 682 int apei_write(u64 val, struct acpi_generic_address *reg)
 683 {
 684         int rc;
 685         u32 access_bit_width;
 686         u64 address;
 687         acpi_status status;
 688
 689         rc = apei_check_gar(reg, &address, &access_bit_width);
 690         if (rc)
 691                 return rc;
 692
 693         switch (reg->space_id) {
 694         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 695                 status = acpi_os_write_memory((acpi_physical_address) address,
 696                                                 val, access_bit_width);
 697                 if (ACPI_FAILURE(status))
 698                         return -EIO;
 699                 break;
 700         case ACPI_ADR_SPACE_SYSTEM_IO:
 701                 status = acpi_os_write_port(address, val, access_bit_width);
 702                 if (ACPI_FAILURE(status))
 703                         return -EIO;
 704                 break;
 705         default:
 706                 return -EINVAL;
 707         }
 708
 709         return 0;
 710 }
 711 EXPORT_SYMBOL_GPL(apei_write);
 712
 713 static int collect_res_callback(struct apei_exec_context *ctx,
 714                                 struct acpi_whea_header *entry,
 715                                 void *data)
 716 {
 717         struct apei_resources *resources = data;
 718         struct acpi_generic_address *reg = &entry->register_region;
 719         u8 ins = entry->instruction;
 720         u32 access_bit_width;
 721         u64 paddr;
 722         int rc;
 723
 724         if (!(ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER))
 725                 return 0;
 726
 727         rc = apei_check_gar(reg, &paddr, &access_bit_width);
 728         if (rc)
 729                 return rc;
 730
 731         switch (reg->space_id) {
 732         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 733                 return apei_res_add(&resources->iomem, paddr,
 734                                     access_bit_width / 8);
 735         case ACPI_ADR_SPACE_SYSTEM_IO:
 736                 return apei_res_add(&resources->ioport, paddr,
 737                                     access_bit_width / 8);
 738         default:
 739                 return -EINVAL;
 740         }
 741 }
 742
 743 /*
 744  * Same register may be used by multiple instructions in GARs, so
 745  * resources are collected before requesting.
 746  */
 747 int apei_exec_collect_resources(struct apei_exec_context *ctx,
 748                                 struct apei_resources *resources)
 749 {
 750         return apei_exec_for_each_entry(ctx, collect_res_callback,
 751                                         resources, NULL);
 752 }
 753 EXPORT_SYMBOL_GPL(apei_exec_collect_resources);
 754
 755 struct dentry *apei_get_debugfs_dir(void)
 756 {
 757         static struct dentry *dapei;
 758
 759         if (!dapei)
 760                 dapei = debugfs_create_dir("apei", NULL);
 761
 762         return dapei;
 763 }
 764 EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);
 765
 766 int __weak arch_apei_enable_cmcff(struct acpi_hest_header *hest_hdr,
 767                                   void *data)
 768 {
 769         return 1;
 770 }
 771 EXPORT_SYMBOL_GPL(arch_apei_enable_cmcff);
 772
 773 void __weak arch_apei_report_mem_error(int sev,
 774                                        struct cper_sec_mem_err *mem_err)
 775 {
 776 }
 777 EXPORT_SYMBOL_GPL(arch_apei_report_mem_error);
 778
 779 int apei_osc_setup(void)
 780 {
 781         static u8 whea_uuid_str[] = "ed855e0c-6c90-47bf-a62a-26de0fc5ad5c";
 782         acpi_handle handle;
 783         u32 capbuf[3];
 784         struct acpi_osc_context context = {
 785                 .uuid_str       = whea_uuid_str,
 786                 .rev            = 1,
 787                 .cap.length     = sizeof(capbuf),
 788                 .cap.pointer    = capbuf,
 789         };
 790
 791         capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
 792         capbuf[OSC_SUPPORT_DWORD] = 1;
 793         capbuf[OSC_CONTROL_DWORD] = 0;
 794
 795         if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))
 796             || ACPI_FAILURE(acpi_run_osc(handle, &context)))
 797                 return -EIO;
 798         else {
 799                 kfree(context.ret.pointer);
 800                 return 0;
 801         }
 802 }
 803 EXPORT_SYMBOL_GPL(apei_osc_setup);