drivers/acpi/apei/erst.c

   1 /*
   2  * APEI Error Record Serialization Table support
   3  *
   4  * ERST is a way provided by APEI to save and retrieve hardware error
   5  * infomation to and from a persistent store.
   6  *
   7  * For more information about ERST, please refer to ACPI Specification
   8  * version 4.0, section 17.4.
   9  *
  10  * Copyright 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/delay.h>
  31 #include <linux/io.h>
  32 #include <linux/acpi.h>
  33 #include <linux/uaccess.h>
  34 #include <linux/cper.h>
  35 #include <linux/nmi.h>
  36 #include <acpi/apei.h>
  37
  38 #include "apei-internal.h"
  39
  40 #define ERST_PFX "ERST: "
  41
  42 /* ERST command status */
  43 #define ERST_STATUS_SUCCESS                     0x0
  44 #define ERST_STATUS_NOT_ENOUGH_SPACE            0x1
  45 #define ERST_STATUS_HARDWARE_NOT_AVAILABLE      0x2
  46 #define ERST_STATUS_FAILED                      0x3
  47 #define ERST_STATUS_RECORD_STORE_EMPTY          0x4
  48 #define ERST_STATUS_RECORD_NOT_FOUND            0x5
  49
  50 #define ERST_TAB_ENTRY(tab)                                             \
  51         ((struct acpi_whea_header *)((char *)(tab) +                    \
  52                                      sizeof(struct acpi_table_erst)))
  53
  54 #define SPIN_UNIT               100                     /* 100ns */
  55 /* Firmware should respond within 1 miliseconds */
  56 #define FIRMWARE_TIMEOUT        (1 * NSEC_PER_MSEC)
  57 #define FIRMWARE_MAX_STALL      50                      /* 50us */
  58
  59 int erst_disable;
  60 EXPORT_SYMBOL_GPL(erst_disable);
  61
  62 static struct acpi_table_erst *erst_tab;
  63
  64 /* ERST Error Log Address Range atrributes */
  65 #define ERST_RANGE_RESERVED     0x0001
  66 #define ERST_RANGE_NVRAM        0x0002
  67 #define ERST_RANGE_SLOW         0x0004
  68
  69 /*
  70  * ERST Error Log Address Range, used as buffer for reading/writing
  71  * error records.
  72  */
  73 static struct erst_erange {
  74         u64 base;
  75         u64 size;
  76         void __iomem *vaddr;
  77         u32 attr;
  78 } erst_erange;
  79
  80 /*
  81  * Prevent ERST interpreter to run simultaneously, because the
  82  * corresponding firmware implementation may not work properly when
  83  * invoked simultaneously.
  84  *
  85  * It is used to provide exclusive accessing for ERST Error Log
  86  * Address Range too.
  87  */
  88 static DEFINE_SPINLOCK(erst_lock);
  89
  90 static inline int erst_errno(int command_status)
  91 {
  92         switch (command_status) {
  93         case ERST_STATUS_SUCCESS:
  94                 return 0;
  95         case ERST_STATUS_HARDWARE_NOT_AVAILABLE:
  96                 return -ENODEV;
  97         case ERST_STATUS_NOT_ENOUGH_SPACE:
  98                 return -ENOSPC;
  99         case ERST_STATUS_RECORD_STORE_EMPTY:
 100         case ERST_STATUS_RECORD_NOT_FOUND:
 101                 return -ENOENT;
 102         default:
 103                 return -EINVAL;
 104         }
 105 }
 106
 107 static int erst_timedout(u64 *t, u64 spin_unit)
 108 {
 109         if ((s64)*t < spin_unit) {
 110                 pr_warning(FW_WARN ERST_PFX
 111                            "Firmware does not respond in time\n");
 112                 return 1;
 113         }
 114         *t -= spin_unit;
 115         ndelay(spin_unit);
 116         touch_nmi_watchdog();
 117         return 0;
 118 }
 119
 120 static int erst_exec_load_var1(struct apei_exec_context *ctx,
 121                                struct acpi_whea_header *entry)
 122 {
 123         return __apei_exec_read_register(entry, &ctx->var1);
 124 }
 125
 126 static int erst_exec_load_var2(struct apei_exec_context *ctx,
 127                                struct acpi_whea_header *entry)
 128 {
 129         return __apei_exec_read_register(entry, &ctx->var2);
 130 }
 131
 132 static int erst_exec_store_var1(struct apei_exec_context *ctx,
 133                                 struct acpi_whea_header *entry)
 134 {
 135         return __apei_exec_write_register(entry, ctx->var1);
 136 }
 137
 138 static int erst_exec_add(struct apei_exec_context *ctx,
 139                          struct acpi_whea_header *entry)
 140 {
 141         ctx->var1 += ctx->var2;
 142         return 0;
 143 }
 144
 145 static int erst_exec_subtract(struct apei_exec_context *ctx,
 146                               struct acpi_whea_header *entry)
 147 {
 148         ctx->var1 -= ctx->var2;
 149         return 0;
 150 }
 151
 152 static int erst_exec_add_value(struct apei_exec_context *ctx,
 153                                struct acpi_whea_header *entry)
 154 {
 155         int rc;
 156         u64 val;
 157
 158         rc = __apei_exec_read_register(entry, &val);
 159         if (rc)
 160                 return rc;
 161         val += ctx->value;
 162         rc = __apei_exec_write_register(entry, val);
 163         return rc;
 164 }
 165
 166 static int erst_exec_subtract_value(struct apei_exec_context *ctx,
 167                                     struct acpi_whea_header *entry)
 168 {
 169         int rc;
 170         u64 val;
 171
 172         rc = __apei_exec_read_register(entry, &val);
 173         if (rc)
 174                 return rc;
 175         val -= ctx->value;
 176         rc = __apei_exec_write_register(entry, val);
 177         return rc;
 178 }
 179
 180 static int erst_exec_stall(struct apei_exec_context *ctx,
 181                            struct acpi_whea_header *entry)
 182 {
 183         u64 stall_time;
 184
 185         if (ctx->value > FIRMWARE_MAX_STALL) {
 186                 if (!in_nmi())
 187                         pr_warning(FW_WARN ERST_PFX
 188                         "Too long stall time for stall instruction: %llx.\n",
 189                                    ctx->value);
 190                 stall_time = FIRMWARE_MAX_STALL;
 191         } else
 192                 stall_time = ctx->value;
 193         udelay(stall_time);
 194         return 0;
 195 }
 196
 197 static int erst_exec_stall_while_true(struct apei_exec_context *ctx,
 198                                       struct acpi_whea_header *entry)
 199 {
 200         int rc;
 201         u64 val;
 202         u64 timeout = FIRMWARE_TIMEOUT;
 203         u64 stall_time;
 204
 205         if (ctx->var1 > FIRMWARE_MAX_STALL) {
 206                 if (!in_nmi())
 207                         pr_warning(FW_WARN ERST_PFX
 208                 "Too long stall time for stall while true instruction: %llx.\n",
 209                                    ctx->var1);
 210                 stall_time = FIRMWARE_MAX_STALL;
 211         } else
 212                 stall_time = ctx->var1;
 213
 214         for (;;) {
 215                 rc = __apei_exec_read_register(entry, &val);
 216                 if (rc)
 217                         return rc;
 218                 if (val != ctx->value)
 219                         break;
 220                 if (erst_timedout(&timeout, stall_time * NSEC_PER_USEC))
 221                         return -EIO;
 222         }
 223         return 0;
 224 }
 225
 226 static int erst_exec_skip_next_instruction_if_true(
 227         struct apei_exec_context *ctx,
 228         struct acpi_whea_header *entry)
 229 {
 230         int rc;
 231         u64 val;
 232
 233         rc = __apei_exec_read_register(entry, &val);
 234         if (rc)
 235                 return rc;
 236         if (val == ctx->value) {
 237                 ctx->ip += 2;
 238                 return APEI_EXEC_SET_IP;
 239         }
 240
 241         return 0;
 242 }
 243
 244 static int erst_exec_goto(struct apei_exec_context *ctx,
 245                           struct acpi_whea_header *entry)
 246 {
 247         ctx->ip = ctx->value;
 248         return APEI_EXEC_SET_IP;
 249 }
 250
 251 static int erst_exec_set_src_address_base(struct apei_exec_context *ctx,
 252                                           struct acpi_whea_header *entry)
 253 {
 254         return __apei_exec_read_register(entry, &ctx->src_base);
 255 }
 256
 257 static int erst_exec_set_dst_address_base(struct apei_exec_context *ctx,
 258                                           struct acpi_whea_header *entry)
 259 {
 260         return __apei_exec_read_register(entry, &ctx->dst_base);
 261 }
 262
 263 static int erst_exec_move_data(struct apei_exec_context *ctx,
 264                                struct acpi_whea_header *entry)
 265 {
 266         int rc;
 267         u64 offset;
 268
 269         rc = __apei_exec_read_register(entry, &offset);
 270         if (rc)
 271                 return rc;
 272         memmove((void *)ctx->dst_base + offset,
 273                 (void *)ctx->src_base + offset,
 274                 ctx->var2);
 275
 276         return 0;
 277 }
 278
 279 static struct apei_exec_ins_type erst_ins_type[] = {
 280         [ACPI_ERST_READ_REGISTER] = {
 281                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 282                 .run = apei_exec_read_register,
 283         },
 284         [ACPI_ERST_READ_REGISTER_VALUE] = {
 285                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 286                 .run = apei_exec_read_register_value,
 287         },
 288         [ACPI_ERST_WRITE_REGISTER] = {
 289                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 290                 .run = apei_exec_write_register,
 291         },
 292         [ACPI_ERST_WRITE_REGISTER_VALUE] = {
 293                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 294                 .run = apei_exec_write_register_value,
 295         },
 296         [ACPI_ERST_NOOP] = {
 297                 .flags = 0,
 298                 .run = apei_exec_noop,
 299         },
 300         [ACPI_ERST_LOAD_VAR1] = {
 301                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 302                 .run = erst_exec_load_var1,
 303         },
 304         [ACPI_ERST_LOAD_VAR2] = {
 305                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 306                 .run = erst_exec_load_var2,
 307         },
 308         [ACPI_ERST_STORE_VAR1] = {
 309                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 310                 .run = erst_exec_store_var1,
 311         },
 312         [ACPI_ERST_ADD] = {
 313                 .flags = 0,
 314                 .run = erst_exec_add,
 315         },
 316         [ACPI_ERST_SUBTRACT] = {
 317                 .flags = 0,
 318                 .run = erst_exec_subtract,
 319         },
 320         [ACPI_ERST_ADD_VALUE] = {
 321                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 322                 .run = erst_exec_add_value,
 323         },
 324         [ACPI_ERST_SUBTRACT_VALUE] = {
 325                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 326                 .run = erst_exec_subtract_value,
 327         },
 328         [ACPI_ERST_STALL] = {
 329                 .flags = 0,
 330                 .run = erst_exec_stall,
 331         },
 332         [ACPI_ERST_STALL_WHILE_TRUE] = {
 333                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 334                 .run = erst_exec_stall_while_true,
 335         },
 336         [ACPI_ERST_SKIP_NEXT_IF_TRUE] = {
 337                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 338                 .run = erst_exec_skip_next_instruction_if_true,
 339         },
 340         [ACPI_ERST_GOTO] = {
 341                 .flags = 0,
 342                 .run = erst_exec_goto,
 343         },
 344         [ACPI_ERST_SET_SRC_ADDRESS_BASE] = {
 345                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 346                 .run = erst_exec_set_src_address_base,
 347         },
 348         [ACPI_ERST_SET_DST_ADDRESS_BASE] = {
 349                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 350                 .run = erst_exec_set_dst_address_base,
 351         },
 352         [ACPI_ERST_MOVE_DATA] = {
 353                 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
 354                 .run = erst_exec_move_data,
 355         },
 356 };
 357
 358 static inline void erst_exec_ctx_init(struct apei_exec_context *ctx)
 359 {
 360         apei_exec_ctx_init(ctx, erst_ins_type, ARRAY_SIZE(erst_ins_type),
 361                            ERST_TAB_ENTRY(erst_tab), erst_tab->entries);
 362 }
 363
 364 static int erst_get_erange(struct erst_erange *range)
 365 {
 366         struct apei_exec_context ctx;
 367         int rc;
 368
 369         erst_exec_ctx_init(&ctx);
 370         rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_RANGE);
 371         if (rc)
 372                 return rc;
 373         range->base = apei_exec_ctx_get_output(&ctx);
 374         rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_LENGTH);
 375         if (rc)
 376                 return rc;
 377         range->size = apei_exec_ctx_get_output(&ctx);
 378         rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_ATTRIBUTES);
 379         if (rc)
 380                 return rc;
 381         range->attr = apei_exec_ctx_get_output(&ctx);
 382
 383         return 0;
 384 }
 385
 386 static ssize_t __erst_get_record_count(void)
 387 {
 388         struct apei_exec_context ctx;
 389         int rc;
 390
 391         erst_exec_ctx_init(&ctx);
 392         rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_COUNT);
 393         if (rc)
 394                 return rc;
 395         return apei_exec_ctx_get_output(&ctx);
 396 }
 397
 398 ssize_t erst_get_record_count(void)
 399 {
 400         ssize_t count;
 401         unsigned long flags;
 402
 403         if (erst_disable)
 404                 return -ENODEV;
 405
 406         spin_lock_irqsave(&erst_lock, flags);
 407         count = __erst_get_record_count();
 408         spin_unlock_irqrestore(&erst_lock, flags);
 409
 410         return count;
 411 }
 412 EXPORT_SYMBOL_GPL(erst_get_record_count);
 413
 414 static int __erst_get_next_record_id(u64 *record_id)
 415 {
 416         struct apei_exec_context ctx;
 417         int rc;
 418
 419         erst_exec_ctx_init(&ctx);
 420         rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_ID);
 421         if (rc)
 422                 return rc;
 423         *record_id = apei_exec_ctx_get_output(&ctx);
 424
 425         return 0;
 426 }
 427
 428 /*
 429  * Get the record ID of an existing error record on the persistent
 430  * storage. If there is no error record on the persistent storage, the
 431  * returned record_id is APEI_ERST_INVALID_RECORD_ID.
 432  */
 433 int erst_get_next_record_id(u64 *record_id)
 434 {
 435         int rc;
 436         unsigned long flags;
 437
 438         if (erst_disable)
 439                 return -ENODEV;
 440
 441         spin_lock_irqsave(&erst_lock, flags);
 442         rc = __erst_get_next_record_id(record_id);
 443         spin_unlock_irqrestore(&erst_lock, flags);
 444
 445         return rc;
 446 }
 447 EXPORT_SYMBOL_GPL(erst_get_next_record_id);
 448
 449 static int __erst_write_to_storage(u64 offset)
 450 {
 451         struct apei_exec_context ctx;
 452         u64 timeout = FIRMWARE_TIMEOUT;
 453         u64 val;
 454         int rc;
 455
 456         erst_exec_ctx_init(&ctx);
 457         rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_WRITE);
 458         if (rc)
 459                 return rc;
 460         apei_exec_ctx_set_input(&ctx, offset);
 461         rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
 462         if (rc)
 463                 return rc;
 464         rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
 465         if (rc)
 466                 return rc;
 467         for (;;) {
 468                 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
 469                 if (rc)
 470                         return rc;
 471                 val = apei_exec_ctx_get_output(&ctx);
 472                 if (!val)
 473                         break;
 474                 if (erst_timedout(&timeout, SPIN_UNIT))
 475                         return -EIO;
 476         }
 477         rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
 478         if (rc)
 479                 return rc;
 480         val = apei_exec_ctx_get_output(&ctx);
 481         rc = apei_exec_run(&ctx, ACPI_ERST_END);
 482         if (rc)
 483                 return rc;
 484
 485         return erst_errno(val);
 486 }
 487
 488 static int __erst_read_from_storage(u64 record_id, u64 offset)
 489 {
 490         struct apei_exec_context ctx;
 491         u64 timeout = FIRMWARE_TIMEOUT;
 492         u64 val;
 493         int rc;
 494
 495         erst_exec_ctx_init(&ctx);
 496         rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_READ);
 497         if (rc)
 498                 return rc;
 499         apei_exec_ctx_set_input(&ctx, offset);
 500         rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
 501         if (rc)
 502                 return rc;
 503         apei_exec_ctx_set_input(&ctx, record_id);
 504         rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
 505         if (rc)
 506                 return rc;
 507         rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
 508         if (rc)
 509                 return rc;
 510         for (;;) {
 511                 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
 512                 if (rc)
 513                         return rc;
 514                 val = apei_exec_ctx_get_output(&ctx);
 515                 if (!val)
 516                         break;
 517                 if (erst_timedout(&timeout, SPIN_UNIT))
 518                         return -EIO;
 519         };
 520         rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
 521         if (rc)
 522                 return rc;
 523         val = apei_exec_ctx_get_output(&ctx);
 524         rc = apei_exec_run(&ctx, ACPI_ERST_END);
 525         if (rc)
 526                 return rc;
 527
 528         return erst_errno(val);
 529 }
 530
 531 static int __erst_clear_from_storage(u64 record_id)
 532 {
 533         struct apei_exec_context ctx;
 534         u64 timeout = FIRMWARE_TIMEOUT;
 535         u64 val;
 536         int rc;
 537
 538         erst_exec_ctx_init(&ctx);
 539         rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_CLEAR);
 540         if (rc)
 541                 return rc;
 542         apei_exec_ctx_set_input(&ctx, record_id);
 543         rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
 544         if (rc)
 545                 return rc;
 546         rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
 547         if (rc)
 548                 return rc;
 549         for (;;) {
 550                 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
 551                 if (rc)
 552                         return rc;
 553                 val = apei_exec_ctx_get_output(&ctx);
 554                 if (!val)
 555                         break;
 556                 if (erst_timedout(&timeout, SPIN_UNIT))
 557                         return -EIO;
 558         }
 559         rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
 560         if (rc)
 561                 return rc;
 562         val = apei_exec_ctx_get_output(&ctx);
 563         rc = apei_exec_run(&ctx, ACPI_ERST_END);
 564         if (rc)
 565                 return rc;
 566
 567         return erst_errno(val);
 568 }
 569
 570 /* NVRAM ERST Error Log Address Range is not supported yet */
 571 static void pr_unimpl_nvram(void)
 572 {
 573         if (printk_ratelimit())
 574                 pr_warning(ERST_PFX
 575                 "NVRAM ERST Log Address Range is not implemented yet\n");
 576 }
 577
 578 static int __erst_write_to_nvram(const struct cper_record_header *record)
 579 {
 580         /* do not print message, because printk is not safe for NMI */
 581         return -ENOSYS;
 582 }
 583
 584 static int __erst_read_to_erange_from_nvram(u64 record_id, u64 *offset)
 585 {
 586         pr_unimpl_nvram();
 587         return -ENOSYS;
 588 }
 589
 590 static int __erst_clear_from_nvram(u64 record_id)
 591 {
 592         pr_unimpl_nvram();
 593         return -ENOSYS;
 594 }
 595
 596 int erst_write(const struct cper_record_header *record)
 597 {
 598         int rc;
 599         unsigned long flags;
 600         struct cper_record_header *rcd_erange;
 601
 602         if (erst_disable)
 603                 return -ENODEV;
 604
 605         if (memcmp(record->signature, CPER_SIG_RECORD, CPER_SIG_SIZE))
 606                 return -EINVAL;
 607
 608         if (erst_erange.attr & ERST_RANGE_NVRAM) {
 609                 if (!spin_trylock_irqsave(&erst_lock, flags))
 610                         return -EBUSY;
 611                 rc = __erst_write_to_nvram(record);
 612                 spin_unlock_irqrestore(&erst_lock, flags);
 613                 return rc;
 614         }
 615
 616         if (record->record_length > erst_erange.size)
 617                 return -EINVAL;
 618
 619         if (!spin_trylock_irqsave(&erst_lock, flags))
 620                 return -EBUSY;
 621         memcpy(erst_erange.vaddr, record, record->record_length);
 622         rcd_erange = erst_erange.vaddr;
 623         /* signature for serialization system */
 624         memcpy(&rcd_erange->persistence_information, "ER", 2);
 625
 626         rc = __erst_write_to_storage(0);
 627         spin_unlock_irqrestore(&erst_lock, flags);
 628
 629         return rc;
 630 }
 631 EXPORT_SYMBOL_GPL(erst_write);
 632
 633 static int __erst_read_to_erange(u64 record_id, u64 *offset)
 634 {
 635         int rc;
 636
 637         if (erst_erange.attr & ERST_RANGE_NVRAM)
 638                 return __erst_read_to_erange_from_nvram(
 639                         record_id, offset);
 640
 641         rc = __erst_read_from_storage(record_id, 0);
 642         if (rc)
 643                 return rc;
 644         *offset = 0;
 645
 646         return 0;
 647 }
 648
 649 static ssize_t __erst_read(u64 record_id, struct cper_record_header *record,
 650                            size_t buflen)
 651 {
 652         int rc;
 653         u64 offset, len = 0;
 654         struct cper_record_header *rcd_tmp;
 655
 656         rc = __erst_read_to_erange(record_id, &offset);
 657         if (rc)
 658                 return rc;
 659         rcd_tmp = erst_erange.vaddr + offset;
 660         len = rcd_tmp->record_length;
 661         if (len <= buflen)
 662                 memcpy(record, rcd_tmp, len);
 663
 664         return len;
 665 }
 666
 667 /*
 668  * If return value > buflen, the buffer size is not big enough,
 669  * else if return value < 0, something goes wrong,
 670  * else everything is OK, and return value is record length
 671  */
 672 ssize_t erst_read(u64 record_id, struct cper_record_header *record,
 673                   size_t buflen)
 674 {
 675         ssize_t len;
 676         unsigned long flags;
 677
 678         if (erst_disable)
 679                 return -ENODEV;
 680
 681         spin_lock_irqsave(&erst_lock, flags);
 682         len = __erst_read(record_id, record, buflen);
 683         spin_unlock_irqrestore(&erst_lock, flags);
 684         return len;
 685 }
 686 EXPORT_SYMBOL_GPL(erst_read);
 687
 688 /*
 689  * If return value > buflen, the buffer size is not big enough,
 690  * else if return value = 0, there is no more record to read,
 691  * else if return value < 0, something goes wrong,
 692  * else everything is OK, and return value is record length
 693  */
 694 ssize_t erst_read_next(struct cper_record_header *record, size_t buflen)
 695 {
 696         int rc;
 697         ssize_t len;
 698         unsigned long flags;
 699         u64 record_id;
 700
 701         if (erst_disable)
 702                 return -ENODEV;
 703
 704         spin_lock_irqsave(&erst_lock, flags);
 705         rc = __erst_get_next_record_id(&record_id);
 706         if (rc) {
 707                 spin_unlock_irqrestore(&erst_lock, flags);
 708                 return rc;
 709         }
 710         /* no more record */
 711         if (record_id == APEI_ERST_INVALID_RECORD_ID) {
 712                 spin_unlock_irqrestore(&erst_lock, flags);
 713                 return 0;
 714         }
 715
 716         len = __erst_read(record_id, record, buflen);
 717         spin_unlock_irqrestore(&erst_lock, flags);
 718
 719         return len;
 720 }
 721 EXPORT_SYMBOL_GPL(erst_read_next);
 722
 723 int erst_clear(u64 record_id)
 724 {
 725         int rc;
 726         unsigned long flags;
 727
 728         if (erst_disable)
 729                 return -ENODEV;
 730
 731         spin_lock_irqsave(&erst_lock, flags);
 732         if (erst_erange.attr & ERST_RANGE_NVRAM)
 733                 rc = __erst_clear_from_nvram(record_id);
 734         else
 735                 rc = __erst_clear_from_storage(record_id);
 736         spin_unlock_irqrestore(&erst_lock, flags);
 737
 738         return rc;
 739 }
 740 EXPORT_SYMBOL_GPL(erst_clear);
 741
 742 static int __init setup_erst_disable(char *str)
 743 {
 744         erst_disable = 1;
 745         return 0;
 746 }
 747
 748 __setup("erst_disable", setup_erst_disable);
 749
 750 static int erst_check_table(struct acpi_table_erst *erst_tab)
 751 {
 752         if (erst_tab->header_length != sizeof(struct acpi_table_erst))
 753                 return -EINVAL;
 754         if (erst_tab->header.length < sizeof(struct acpi_table_erst))
 755                 return -EINVAL;
 756         if (erst_tab->entries !=
 757             (erst_tab->header.length - sizeof(struct acpi_table_erst)) /
 758             sizeof(struct acpi_erst_entry))
 759                 return -EINVAL;
 760
 761         return 0;
 762 }
 763
 764 static int __init erst_init(void)
 765 {
 766         int rc = 0;
 767         acpi_status status;
 768         struct apei_exec_context ctx;
 769         struct apei_resources erst_resources;
 770         struct resource *r;
 771
 772         if (acpi_disabled)
 773                 goto err;
 774
 775         if (erst_disable) {
 776                 pr_info(ERST_PFX
 777         "Error Record Serialization Table (ERST) support is disabled.\n");
 778                 goto err;
 779         }
 780
 781         status = acpi_get_table(ACPI_SIG_ERST, 0,
 782                                 (struct acpi_table_header **)&erst_tab);
 783         if (status == AE_NOT_FOUND) {
 784                 pr_err(ERST_PFX "Table is not found!\n");
 785                 goto err;
 786         } else if (ACPI_FAILURE(status)) {
 787                 const char *msg = acpi_format_exception(status);
 788                 pr_err(ERST_PFX "Failed to get table, %s\n", msg);
 789                 rc = -EINVAL;
 790                 goto err;
 791         }
 792
 793         rc = erst_check_table(erst_tab);
 794         if (rc) {
 795                 pr_err(FW_BUG ERST_PFX "ERST table is invalid\n");
 796                 goto err;
 797         }
 798
 799         apei_resources_init(&erst_resources);
 800         erst_exec_ctx_init(&ctx);
 801         rc = apei_exec_collect_resources(&ctx, &erst_resources);
 802         if (rc)
 803                 goto err_fini;
 804         rc = apei_resources_request(&erst_resources, "APEI ERST");
 805         if (rc)
 806                 goto err_fini;
 807         rc = apei_exec_pre_map_gars(&ctx);
 808         if (rc)
 809                 goto err_release;
 810         rc = erst_get_erange(&erst_erange);
 811         if (rc) {
 812                 if (rc == -ENODEV)
 813                         pr_info(ERST_PFX
 814         "The corresponding hardware device or firmware implementation "
 815         "is not available.\n");
 816                 else
 817                         pr_err(ERST_PFX
 818                                "Failed to get Error Log Address Range.\n");
 819                 goto err_unmap_reg;
 820         }
 821
 822         r = request_mem_region(erst_erange.base, erst_erange.size, "APEI ERST");
 823         if (!r) {
 824                 pr_err(ERST_PFX
 825                 "Can not request iomem region <0x%16llx-0x%16llx> for ERST.\n",
 826                 (unsigned long long)erst_erange.base,
 827                 (unsigned long long)erst_erange.base + erst_erange.size);
 828                 rc = -EIO;
 829                 goto err_unmap_reg;
 830         }
 831         rc = -ENOMEM;
 832         erst_erange.vaddr = ioremap_cache(erst_erange.base,
 833                                           erst_erange.size);
 834         if (!erst_erange.vaddr)
 835                 goto err_release_erange;
 836
 837         pr_info(ERST_PFX
 838         "Error Record Serialization Table (ERST) support is initialized.\n");
 839
 840         return 0;
 841
 842 err_release_erange:
 843         release_mem_region(erst_erange.base, erst_erange.size);
 844 err_unmap_reg:
 845         apei_exec_post_unmap_gars(&ctx);
 846 err_release:
 847         apei_resources_release(&erst_resources);
 848 err_fini:
 849         apei_resources_fini(&erst_resources);
 850 err:
 851         erst_disable = 1;
 852         return rc;
 853 }
 854
 855 device_initcall(erst_init);