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