drivers/acpi/apei/apei-base.c

   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>
  37 #include <linux/slab.h>
  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 <asm/unaligned.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 = apei_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 = apei_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 = apei_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  */
 160 int __apei_exec_run(struct apei_exec_context *ctx, u8 action,
 161                     bool optional)
 162 {
 163         int rc = -ENOENT;
 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
 202         return !optional && rc < 0 ? rc : 0;
 203 }
 204 EXPORT_SYMBOL_GPL(__apei_exec_run);
 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 apei_map_generic_address(&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                 apei_unmap_generic_address(&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 int apei_resources_add(struct apei_resources *resources,
 425                        unsigned long start, unsigned long size,
 426                        bool iomem)
 427 {
 428         if (iomem)
 429                 return apei_res_add(&resources->iomem, start, size);
 430         else
 431                 return apei_res_add(&resources->ioport, start, size);
 432 }
 433 EXPORT_SYMBOL_GPL(apei_resources_add);
 434
 435 /*
 436  * EINJ has two groups of GARs (EINJ table entry and trigger table
 437  * entry), so common resources are subtracted from the trigger table
 438  * resources before the second requesting.
 439  */
 440 int apei_resources_sub(struct apei_resources *resources1,
 441                        struct apei_resources *resources2)
 442 {
 443         int rc;
 444
 445         rc = apei_res_sub(&resources1->iomem, &resources2->iomem);
 446         if (rc)
 447                 return rc;
 448         return apei_res_sub(&resources1->ioport, &resources2->ioport);
 449 }
 450 EXPORT_SYMBOL_GPL(apei_resources_sub);
 451
 452 static int apei_get_res_callback(__u64 start, __u64 size, void *data)
 453 {
 454         struct apei_resources *resources = data;
 455         return apei_res_add(&resources->iomem, start, size);
 456 }
 457
 458 static int apei_get_nvs_resources(struct apei_resources *resources)
 459 {
 460         return acpi_nvs_for_each_region(apei_get_res_callback, resources);
 461 }
 462
 463 int (*arch_apei_filter_addr)(int (*func)(__u64 start, __u64 size,
 464                                      void *data), void *data);
 465 static int apei_get_arch_resources(struct apei_resources *resources)
 466
 467 {
 468         return arch_apei_filter_addr(apei_get_res_callback, resources);
 469 }
 470
 471 /*
 472  * IO memory/port resource management mechanism is used to check
 473  * whether memory/port area used by GARs conflicts with normal memory
 474  * or IO memory/port of devices.
 475  */
 476 int apei_resources_request(struct apei_resources *resources,
 477                            const char *desc)
 478 {
 479         struct apei_res *res, *res_bak = NULL;
 480         struct resource *r;
 481         struct apei_resources nvs_resources, arch_res;
 482         int rc;
 483
 484         rc = apei_resources_sub(resources, &apei_resources_all);
 485         if (rc)
 486                 return rc;
 487
 488         /*
 489          * Some firmware uses ACPI NVS region, that has been marked as
 490          * busy, so exclude it from APEI resources to avoid false
 491          * conflict.
 492          */
 493         apei_resources_init(&nvs_resources);
 494         rc = apei_get_nvs_resources(&nvs_resources);
 495         if (rc)
 496                 goto nvs_res_fini;
 497         rc = apei_resources_sub(resources, &nvs_resources);
 498         if (rc)
 499                 goto nvs_res_fini;
 500
 501         if (arch_apei_filter_addr) {
 502                 apei_resources_init(&arch_res);
 503                 rc = apei_get_arch_resources(&arch_res);
 504                 if (rc)
 505                         goto arch_res_fini;
 506                 rc = apei_resources_sub(resources, &arch_res);
 507                 if (rc)
 508                         goto arch_res_fini;
 509         }
 510
 511         rc = -EINVAL;
 512         list_for_each_entry(res, &resources->iomem, list) {
 513                 r = request_mem_region(res->start, res->end - res->start,
 514                                        desc);
 515                 if (!r) {
 516                         pr_err(APEI_PFX
 517                 "Can not request [mem %#010llx-%#010llx] 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_iomem;
 522                 }
 523         }
 524
 525         list_for_each_entry(res, &resources->ioport, list) {
 526                 r = request_region(res->start, res->end - res->start, desc);
 527                 if (!r) {
 528                         pr_err(APEI_PFX
 529                 "Can not request [io  %#06llx-%#06llx] for %s registers\n",
 530                                (unsigned long long)res->start,
 531                                (unsigned long long)res->end - 1, desc);
 532                         res_bak = res;
 533                         goto err_unmap_ioport;
 534                 }
 535         }
 536
 537         rc = apei_resources_merge(&apei_resources_all, resources);
 538         if (rc) {
 539                 pr_err(APEI_PFX "Fail to merge resources!\n");
 540                 goto err_unmap_ioport;
 541         }
 542
 543         return 0;
 544 err_unmap_ioport:
 545         list_for_each_entry(res, &resources->ioport, list) {
 546                 if (res == res_bak)
 547                         break;
 548                 release_region(res->start, res->end - res->start);
 549         }
 550         res_bak = NULL;
 551 err_unmap_iomem:
 552         list_for_each_entry(res, &resources->iomem, list) {
 553                 if (res == res_bak)
 554                         break;
 555                 release_mem_region(res->start, res->end - res->start);
 556         }
 557 arch_res_fini:
 558         apei_resources_fini(&arch_res);
 559 nvs_res_fini:
 560         apei_resources_fini(&nvs_resources);
 561         return rc;
 562 }
 563 EXPORT_SYMBOL_GPL(apei_resources_request);
 564
 565 void apei_resources_release(struct apei_resources *resources)
 566 {
 567         int rc;
 568         struct apei_res *res;
 569
 570         list_for_each_entry(res, &resources->iomem, list)
 571                 release_mem_region(res->start, res->end - res->start);
 572         list_for_each_entry(res, &resources->ioport, list)
 573                 release_region(res->start, res->end - res->start);
 574
 575         rc = apei_resources_sub(&apei_resources_all, resources);
 576         if (rc)
 577                 pr_err(APEI_PFX "Fail to sub resources!\n");
 578 }
 579 EXPORT_SYMBOL_GPL(apei_resources_release);
 580
 581 static int apei_check_gar(struct acpi_generic_address *reg, u64 *paddr,
 582                                 u32 *access_bit_width)
 583 {
 584         u32 bit_width, bit_offset, access_size_code, space_id;
 585
 586         bit_width = reg->bit_width;
 587         bit_offset = reg->bit_offset;
 588         access_size_code = reg->access_width;
 589         space_id = reg->space_id;
 590         *paddr = get_unaligned(&reg->address);
 591         if (!*paddr) {
 592                 pr_warning(FW_BUG APEI_PFX
 593                            "Invalid physical address in GAR [0x%llx/%u/%u/%u/%u]\n",
 594                            *paddr, bit_width, bit_offset, access_size_code,
 595                            space_id);
 596                 return -EINVAL;
 597         }
 598
 599         if (access_size_code < 1 || access_size_code > 4) {
 600                 pr_warning(FW_BUG APEI_PFX
 601                            "Invalid access size code in GAR [0x%llx/%u/%u/%u/%u]\n",
 602                            *paddr, bit_width, bit_offset, access_size_code,
 603                            space_id);
 604                 return -EINVAL;
 605         }
 606         *access_bit_width = 1UL << (access_size_code + 2);
 607
 608         /* Fixup common BIOS bug */
 609         if (bit_width == 32 && bit_offset == 0 && (*paddr & 0x03) == 0 &&
 610             *access_bit_width < 32)
 611                 *access_bit_width = 32;
 612         else if (bit_width == 64 && bit_offset == 0 && (*paddr & 0x07) == 0 &&
 613             *access_bit_width < 64)
 614                 *access_bit_width = 64;
 615
 616         if ((bit_width + bit_offset) > *access_bit_width) {
 617                 pr_warning(FW_BUG APEI_PFX
 618                            "Invalid bit width + offset in GAR [0x%llx/%u/%u/%u/%u]\n",
 619                            *paddr, bit_width, bit_offset, access_size_code,
 620                            space_id);
 621                 return -EINVAL;
 622         }
 623
 624         if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
 625             space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
 626                 pr_warning(FW_BUG APEI_PFX
 627                            "Invalid address space type in GAR [0x%llx/%u/%u/%u/%u]\n",
 628                            *paddr, bit_width, bit_offset, access_size_code,
 629                            space_id);
 630                 return -EINVAL;
 631         }
 632
 633         return 0;
 634 }
 635
 636 int apei_map_generic_address(struct acpi_generic_address *reg)
 637 {
 638         int rc;
 639         u32 access_bit_width;
 640         u64 address;
 641
 642         rc = apei_check_gar(reg, &address, &access_bit_width);
 643         if (rc)
 644                 return rc;
 645         return acpi_os_map_generic_address(reg);
 646 }
 647 EXPORT_SYMBOL_GPL(apei_map_generic_address);
 648
 649 /* read GAR in interrupt (including NMI) or process context */
 650 int apei_read(u64 *val, struct acpi_generic_address *reg)
 651 {
 652         int rc;
 653         u32 access_bit_width;
 654         u64 address;
 655         acpi_status status;
 656
 657         rc = apei_check_gar(reg, &address, &access_bit_width);
 658         if (rc)
 659                 return rc;
 660
 661         *val = 0;
 662         switch(reg->space_id) {
 663         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 664                 status = acpi_os_read_memory((acpi_physical_address) address,
 665                                                val, access_bit_width);
 666                 if (ACPI_FAILURE(status))
 667                         return -EIO;
 668                 break;
 669         case ACPI_ADR_SPACE_SYSTEM_IO:
 670                 status = acpi_os_read_port(address, (u32 *)val,
 671                                            access_bit_width);
 672                 if (ACPI_FAILURE(status))
 673                         return -EIO;
 674                 break;
 675         default:
 676                 return -EINVAL;
 677         }
 678
 679         return 0;
 680 }
 681 EXPORT_SYMBOL_GPL(apei_read);
 682
 683 /* write GAR in interrupt (including NMI) or process context */
 684 int apei_write(u64 val, struct acpi_generic_address *reg)
 685 {
 686         int rc;
 687         u32 access_bit_width;
 688         u64 address;
 689         acpi_status status;
 690
 691         rc = apei_check_gar(reg, &address, &access_bit_width);
 692         if (rc)
 693                 return rc;
 694
 695         switch (reg->space_id) {
 696         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 697                 status = acpi_os_write_memory((acpi_physical_address) address,
 698                                                 val, access_bit_width);
 699                 if (ACPI_FAILURE(status))
 700                         return -EIO;
 701                 break;
 702         case ACPI_ADR_SPACE_SYSTEM_IO:
 703                 status = acpi_os_write_port(address, val, access_bit_width);
 704                 if (ACPI_FAILURE(status))
 705                         return -EIO;
 706                 break;
 707         default:
 708                 return -EINVAL;
 709         }
 710
 711         return 0;
 712 }
 713 EXPORT_SYMBOL_GPL(apei_write);
 714
 715 static int collect_res_callback(struct apei_exec_context *ctx,
 716                                 struct acpi_whea_header *entry,
 717                                 void *data)
 718 {
 719         struct apei_resources *resources = data;
 720         struct acpi_generic_address *reg = &entry->register_region;
 721         u8 ins = entry->instruction;
 722         u32 access_bit_width;
 723         u64 paddr;
 724         int rc;
 725
 726         if (!(ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER))
 727                 return 0;
 728
 729         rc = apei_check_gar(reg, &paddr, &access_bit_width);
 730         if (rc)
 731                 return rc;
 732
 733         switch (reg->space_id) {
 734         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 735                 return apei_res_add(&resources->iomem, paddr,
 736                                     access_bit_width / 8);
 737         case ACPI_ADR_SPACE_SYSTEM_IO:
 738                 return apei_res_add(&resources->ioport, paddr,
 739                                     access_bit_width / 8);
 740         default:
 741                 return -EINVAL;
 742         }
 743 }
 744
 745 /*
 746  * Same register may be used by multiple instructions in GARs, so
 747  * resources are collected before requesting.
 748  */
 749 int apei_exec_collect_resources(struct apei_exec_context *ctx,
 750                                 struct apei_resources *resources)
 751 {
 752         return apei_exec_for_each_entry(ctx, collect_res_callback,
 753                                         resources, NULL);
 754 }
 755 EXPORT_SYMBOL_GPL(apei_exec_collect_resources);
 756
 757 struct dentry *apei_get_debugfs_dir(void)
 758 {
 759         static struct dentry *dapei;
 760
 761         if (!dapei)
 762                 dapei = debugfs_create_dir("apei", NULL);
 763
 764         return dapei;
 765 }
 766 EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);
 767
 768 int __weak arch_apei_enable_cmcff(struct acpi_hest_header *hest_hdr,
 769                                   void *data)
 770 {
 771         return 1;
 772 }
 773 EXPORT_SYMBOL_GPL(arch_apei_enable_cmcff);
 774
 775 void __weak arch_apei_report_mem_error(int sev,
 776                                        struct cper_sec_mem_err *mem_err)
 777 {
 778 }
 779 EXPORT_SYMBOL_GPL(arch_apei_report_mem_error);
 780
 781 int apei_osc_setup(void)
 782 {
 783         static u8 whea_uuid_str[] = "ed855e0c-6c90-47bf-a62a-26de0fc5ad5c";
 784         acpi_handle handle;
 785         u32 capbuf[3];
 786         struct acpi_osc_context context = {
 787                 .uuid_str       = whea_uuid_str,
 788                 .rev            = 1,
 789                 .cap.length     = sizeof(capbuf),
 790                 .cap.pointer    = capbuf,
 791         };
 792
 793         capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
 794         capbuf[OSC_SUPPORT_DWORD] = 1;
 795         capbuf[OSC_CONTROL_DWORD] = 0;
 796
 797         if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))
 798             || ACPI_FAILURE(acpi_run_osc(handle, &context)))
 799                 return -EIO;
 800         else {
 801                 kfree(context.ret.pointer);
 802                 return 0;
 803         }
 804 }
 805 EXPORT_SYMBOL_GPL(apei_osc_setup);