1 /*
2 * PowerNV OPAL high level interfaces
3 *
4 * Copyright 2011 IBM Corp.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12 #define pr_fmt(fmt) "opal: " fmt
13
14 #include <linux/printk.h>
15 #include <linux/types.h>
16 #include <linux/of.h>
17 #include <linux/of_fdt.h>
18 #include <linux/of_platform.h>
19 #include <linux/interrupt.h>
20 #include <linux/notifier.h>
21 #include <linux/slab.h>
22 #include <linux/sched.h>
23 #include <linux/kobject.h>
24 #include <linux/delay.h>
25 #include <linux/memblock.h>
26 #include <linux/kthread.h>
27 #include <linux/freezer.h>
28
29 #include <asm/machdep.h>
30 #include <asm/opal.h>
31 #include <asm/firmware.h>
32 #include <asm/mce.h>
33
34 #include "powernv.h"
35
36 /* /sys/firmware/opal */
37 struct kobject *opal_kobj;
38
39 struct opal {
40 u64 base;
41 u64 entry;
42 u64 size;
43 } opal;
44
45 struct mcheck_recoverable_range {
46 u64 start_addr;
47 u64 end_addr;
48 u64 recover_addr;
49 };
50
51 static struct mcheck_recoverable_range *mc_recoverable_range;
52 static int mc_recoverable_range_len;
53
54 struct device_node *opal_node;
55 static DEFINE_SPINLOCK(opal_write_lock);
56 static struct atomic_notifier_head opal_msg_notifier_head[OPAL_MSG_TYPE_MAX];
57 static uint32_t opal_heartbeat;
58
opal_reinit_cores(void)59 static void opal_reinit_cores(void)
60 {
61 /* Do the actual re-init, This will clobber all FPRs, VRs, etc...
62 *
63 * It will preserve non volatile GPRs and HSPRG0/1. It will
64 * also restore HIDs and other SPRs to their original value
65 * but it might clobber a bunch.
66 */
67 #ifdef __BIG_ENDIAN__
68 opal_reinit_cpus(OPAL_REINIT_CPUS_HILE_BE);
69 #else
70 opal_reinit_cpus(OPAL_REINIT_CPUS_HILE_LE);
71 #endif
72 }
73
early_init_dt_scan_opal(unsigned long node,const char * uname,int depth,void * data)74 int __init early_init_dt_scan_opal(unsigned long node,
75 const char *uname, int depth, void *data)
76 {
77 const void *basep, *entryp, *sizep;
78 int basesz, entrysz, runtimesz;
79
80 if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
81 return 0;
82
83 basep = of_get_flat_dt_prop(node, "opal-base-address", &basesz);
84 entryp = of_get_flat_dt_prop(node, "opal-entry-address", &entrysz);
85 sizep = of_get_flat_dt_prop(node, "opal-runtime-size", &runtimesz);
86
87 if (!basep || !entryp || !sizep)
88 return 1;
89
90 opal.base = of_read_number(basep, basesz/4);
91 opal.entry = of_read_number(entryp, entrysz/4);
92 opal.size = of_read_number(sizep, runtimesz/4);
93
94 pr_debug("OPAL Base = 0x%llx (basep=%p basesz=%d)\n",
95 opal.base, basep, basesz);
96 pr_debug("OPAL Entry = 0x%llx (entryp=%p basesz=%d)\n",
97 opal.entry, entryp, entrysz);
98 pr_debug("OPAL Entry = 0x%llx (sizep=%p runtimesz=%d)\n",
99 opal.size, sizep, runtimesz);
100
101 if (of_flat_dt_is_compatible(node, "ibm,opal-v3")) {
102 powerpc_firmware_features |= FW_FEATURE_OPAL;
103 pr_info("OPAL detected !\n");
104 } else {
105 panic("OPAL != V3 detected, no longer supported.\n");
106 }
107
108 /* Reinit all cores with the right endian */
109 opal_reinit_cores();
110
111 /* Restore some bits */
112 if (cur_cpu_spec->cpu_restore)
113 cur_cpu_spec->cpu_restore();
114
115 return 1;
116 }
117
early_init_dt_scan_recoverable_ranges(unsigned long node,const char * uname,int depth,void * data)118 int __init early_init_dt_scan_recoverable_ranges(unsigned long node,
119 const char *uname, int depth, void *data)
120 {
121 int i, psize, size;
122 const __be32 *prop;
123
124 if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
125 return 0;
126
127 prop = of_get_flat_dt_prop(node, "mcheck-recoverable-ranges", &psize);
128
129 if (!prop)
130 return 1;
131
132 pr_debug("Found machine check recoverable ranges.\n");
133
134 /*
135 * Calculate number of available entries.
136 *
137 * Each recoverable address range entry is (start address, len,
138 * recovery address), 2 cells each for start and recovery address,
139 * 1 cell for len, totalling 5 cells per entry.
140 */
141 mc_recoverable_range_len = psize / (sizeof(*prop) * 5);
142
143 /* Sanity check */
144 if (!mc_recoverable_range_len)
145 return 1;
146
147 /* Size required to hold all the entries. */
148 size = mc_recoverable_range_len *
149 sizeof(struct mcheck_recoverable_range);
150
151 /*
152 * Allocate a buffer to hold the MC recoverable ranges. We would be
153 * accessing them in real mode, hence it needs to be within
154 * RMO region.
155 */
156 mc_recoverable_range =__va(memblock_alloc_base(size, __alignof__(u64),
157 ppc64_rma_size));
158 memset(mc_recoverable_range, 0, size);
159
160 for (i = 0; i < mc_recoverable_range_len; i++) {
161 mc_recoverable_range[i].start_addr =
162 of_read_number(prop + (i * 5) + 0, 2);
163 mc_recoverable_range[i].end_addr =
164 mc_recoverable_range[i].start_addr +
165 of_read_number(prop + (i * 5) + 2, 1);
166 mc_recoverable_range[i].recover_addr =
167 of_read_number(prop + (i * 5) + 3, 2);
168
169 pr_debug("Machine check recoverable range: %llx..%llx: %llx\n",
170 mc_recoverable_range[i].start_addr,
171 mc_recoverable_range[i].end_addr,
172 mc_recoverable_range[i].recover_addr);
173 }
174 return 1;
175 }
176
opal_register_exception_handlers(void)177 static int __init opal_register_exception_handlers(void)
178 {
179 #ifdef __BIG_ENDIAN__
180 u64 glue;
181
182 if (!(powerpc_firmware_features & FW_FEATURE_OPAL))
183 return -ENODEV;
184
185 /* Hookup some exception handlers except machine check. We use the
186 * fwnmi area at 0x7000 to provide the glue space to OPAL
187 */
188 glue = 0x7000;
189
190 /*
191 * Check if we are running on newer firmware that exports
192 * OPAL_HANDLE_HMI token. If yes, then don't ask OPAL to patch
193 * the HMI interrupt and we catch it directly in Linux.
194 *
195 * For older firmware (i.e currently released POWER8 System Firmware
196 * as of today <= SV810_087), we fallback to old behavior and let OPAL
197 * patch the HMI vector and handle it inside OPAL firmware.
198 *
199 * For newer firmware (in development/yet to be released) we will
200 * start catching/handling HMI directly in Linux.
201 */
202 if (!opal_check_token(OPAL_HANDLE_HMI)) {
203 pr_info("Old firmware detected, OPAL handles HMIs.\n");
204 opal_register_exception_handler(
205 OPAL_HYPERVISOR_MAINTENANCE_HANDLER,
206 0, glue);
207 glue += 128;
208 }
209
210 opal_register_exception_handler(OPAL_SOFTPATCH_HANDLER, 0, glue);
211 #endif
212
213 return 0;
214 }
215 machine_early_initcall(powernv, opal_register_exception_handlers);
216
217 /*
218 * Opal message notifier based on message type. Allow subscribers to get
219 * notified for specific messgae type.
220 */
opal_message_notifier_register(enum opal_msg_type msg_type,struct notifier_block * nb)221 int opal_message_notifier_register(enum opal_msg_type msg_type,
222 struct notifier_block *nb)
223 {
224 if (!nb || msg_type >= OPAL_MSG_TYPE_MAX) {
225 pr_warning("%s: Invalid arguments, msg_type:%d\n",
226 __func__, msg_type);
227 return -EINVAL;
228 }
229
230 return atomic_notifier_chain_register(
231 &opal_msg_notifier_head[msg_type], nb);
232 }
233 EXPORT_SYMBOL_GPL(opal_message_notifier_register);
234
opal_message_notifier_unregister(enum opal_msg_type msg_type,struct notifier_block * nb)235 int opal_message_notifier_unregister(enum opal_msg_type msg_type,
236 struct notifier_block *nb)
237 {
238 return atomic_notifier_chain_unregister(
239 &opal_msg_notifier_head[msg_type], nb);
240 }
241 EXPORT_SYMBOL_GPL(opal_message_notifier_unregister);
242
opal_message_do_notify(uint32_t msg_type,void * msg)243 static void opal_message_do_notify(uint32_t msg_type, void *msg)
244 {
245 /* notify subscribers */
246 atomic_notifier_call_chain(&opal_msg_notifier_head[msg_type],
247 msg_type, msg);
248 }
249
opal_handle_message(void)250 static void opal_handle_message(void)
251 {
252 s64 ret;
253 /*
254 * TODO: pre-allocate a message buffer depending on opal-msg-size
255 * value in /proc/device-tree.
256 */
257 static struct opal_msg msg;
258 u32 type;
259
260 ret = opal_get_msg(__pa(&msg), sizeof(msg));
261 /* No opal message pending. */
262 if (ret == OPAL_RESOURCE)
263 return;
264
265 /* check for errors. */
266 if (ret) {
267 pr_warning("%s: Failed to retrieve opal message, err=%lld\n",
268 __func__, ret);
269 return;
270 }
271
272 type = be32_to_cpu(msg.msg_type);
273
274 /* Sanity check */
275 if (type >= OPAL_MSG_TYPE_MAX) {
276 pr_warn_once("%s: Unknown message type: %u\n", __func__, type);
277 return;
278 }
279 opal_message_do_notify(type, (void *)&msg);
280 }
281
opal_message_notify(int irq,void * data)282 static irqreturn_t opal_message_notify(int irq, void *data)
283 {
284 opal_handle_message();
285 return IRQ_HANDLED;
286 }
287
opal_message_init(void)288 static int __init opal_message_init(void)
289 {
290 int ret, i, irq;
291
292 for (i = 0; i < OPAL_MSG_TYPE_MAX; i++)
293 ATOMIC_INIT_NOTIFIER_HEAD(&opal_msg_notifier_head[i]);
294
295 irq = opal_event_request(ilog2(OPAL_EVENT_MSG_PENDING));
296 if (!irq) {
297 pr_err("%s: Can't register OPAL event irq (%d)\n",
298 __func__, irq);
299 return irq;
300 }
301
302 ret = request_irq(irq, opal_message_notify,
303 IRQ_TYPE_LEVEL_HIGH, "opal-msg", NULL);
304 if (ret) {
305 pr_err("%s: Can't request OPAL event irq (%d)\n",
306 __func__, ret);
307 return ret;
308 }
309
310 return 0;
311 }
312
opal_get_chars(uint32_t vtermno,char * buf,int count)313 int opal_get_chars(uint32_t vtermno, char *buf, int count)
314 {
315 s64 rc;
316 __be64 evt, len;
317
318 if (!opal.entry)
319 return -ENODEV;
320 opal_poll_events(&evt);
321 if ((be64_to_cpu(evt) & OPAL_EVENT_CONSOLE_INPUT) == 0)
322 return 0;
323 len = cpu_to_be64(count);
324 rc = opal_console_read(vtermno, &len, buf);
325 if (rc == OPAL_SUCCESS)
326 return be64_to_cpu(len);
327 return 0;
328 }
329
opal_put_chars(uint32_t vtermno,const char * data,int total_len)330 int opal_put_chars(uint32_t vtermno, const char *data, int total_len)
331 {
332 int written = 0;
333 __be64 olen;
334 s64 len, rc;
335 unsigned long flags;
336 __be64 evt;
337
338 if (!opal.entry)
339 return -ENODEV;
340
341 /* We want put_chars to be atomic to avoid mangling of hvsi
342 * packets. To do that, we first test for room and return
343 * -EAGAIN if there isn't enough.
344 *
345 * Unfortunately, opal_console_write_buffer_space() doesn't
346 * appear to work on opal v1, so we just assume there is
347 * enough room and be done with it
348 */
349 spin_lock_irqsave(&opal_write_lock, flags);
350 rc = opal_console_write_buffer_space(vtermno, &olen);
351 len = be64_to_cpu(olen);
352 if (rc || len < total_len) {
353 spin_unlock_irqrestore(&opal_write_lock, flags);
354 /* Closed -> drop characters */
355 if (rc)
356 return total_len;
357 opal_poll_events(NULL);
358 return -EAGAIN;
359 }
360
361 /* We still try to handle partial completions, though they
362 * should no longer happen.
363 */
364 rc = OPAL_BUSY;
365 while(total_len > 0 && (rc == OPAL_BUSY ||
366 rc == OPAL_BUSY_EVENT || rc == OPAL_SUCCESS)) {
367 olen = cpu_to_be64(total_len);
368 rc = opal_console_write(vtermno, &olen, data);
369 len = be64_to_cpu(olen);
370
371 /* Closed or other error drop */
372 if (rc != OPAL_SUCCESS && rc != OPAL_BUSY &&
373 rc != OPAL_BUSY_EVENT) {
374 written += total_len;
375 break;
376 }
377 if (rc == OPAL_SUCCESS) {
378 total_len -= len;
379 data += len;
380 written += len;
381 }
382 /* This is a bit nasty but we need that for the console to
383 * flush when there aren't any interrupts. We will clean
384 * things a bit later to limit that to synchronous path
385 * such as the kernel console and xmon/udbg
386 */
387 do
388 opal_poll_events(&evt);
389 while(rc == OPAL_SUCCESS &&
390 (be64_to_cpu(evt) & OPAL_EVENT_CONSOLE_OUTPUT));
391 }
392 spin_unlock_irqrestore(&opal_write_lock, flags);
393 return written;
394 }
395
opal_recover_mce(struct pt_regs * regs,struct machine_check_event * evt)396 static int opal_recover_mce(struct pt_regs *regs,
397 struct machine_check_event *evt)
398 {
399 int recovered = 0;
400 uint64_t ea = get_mce_fault_addr(evt);
401
402 if (!(regs->msr & MSR_RI)) {
403 /* If MSR_RI isn't set, we cannot recover */
404 pr_err("Machine check interrupt unrecoverable: MSR(RI=0)\n");
405 recovered = 0;
406 } else if (evt->disposition == MCE_DISPOSITION_RECOVERED) {
407 /* Platform corrected itself */
408 recovered = 1;
409 } else if (ea && !is_kernel_addr(ea)) {
410 /*
411 * Faulting address is not in kernel text. We should be fine.
412 * We need to find which process uses this address.
413 * For now, kill the task if we have received exception when
414 * in userspace.
415 *
416 * TODO: Queue up this address for hwpoisioning later.
417 */
418 if (user_mode(regs) && !is_global_init(current)) {
419 _exception(SIGBUS, regs, BUS_MCEERR_AR, regs->nip);
420 recovered = 1;
421 } else
422 recovered = 0;
423 } else if (user_mode(regs) && !is_global_init(current) &&
424 evt->severity == MCE_SEV_ERROR_SYNC) {
425 /*
426 * If we have received a synchronous error when in userspace
427 * kill the task.
428 */
429 _exception(SIGBUS, regs, BUS_MCEERR_AR, regs->nip);
430 recovered = 1;
431 }
432 return recovered;
433 }
434
opal_machine_check(struct pt_regs * regs)435 int opal_machine_check(struct pt_regs *regs)
436 {
437 struct machine_check_event evt;
438 int ret;
439
440 if (!get_mce_event(&evt, MCE_EVENT_RELEASE))
441 return 0;
442
443 /* Print things out */
444 if (evt.version != MCE_V1) {
445 pr_err("Machine Check Exception, Unknown event version %d !\n",
446 evt.version);
447 return 0;
448 }
449 machine_check_print_event_info(&evt);
450
451 if (opal_recover_mce(regs, &evt))
452 return 1;
453
454 /*
455 * Unrecovered machine check, we are heading to panic path.
456 *
457 * We may have hit this MCE in very early stage of kernel
458 * initialization even before opal-prd has started running. If
459 * this is the case then this MCE error may go un-noticed or
460 * un-analyzed if we go down panic path. We need to inform
461 * BMC/OCC about this error so that they can collect relevant
462 * data for error analysis before rebooting.
463 * Use opal_cec_reboot2(OPAL_REBOOT_PLATFORM_ERROR) to do so.
464 * This function may not return on BMC based system.
465 */
466 ret = opal_cec_reboot2(OPAL_REBOOT_PLATFORM_ERROR,
467 "Unrecoverable Machine Check exception");
468 if (ret == OPAL_UNSUPPORTED) {
469 pr_emerg("Reboot type %d not supported\n",
470 OPAL_REBOOT_PLATFORM_ERROR);
471 }
472
473 /*
474 * We reached here. There can be three possibilities:
475 * 1. We are running on a firmware level that do not support
476 * opal_cec_reboot2()
477 * 2. We are running on a firmware level that do not support
478 * OPAL_REBOOT_PLATFORM_ERROR reboot type.
479 * 3. We are running on FSP based system that does not need opal
480 * to trigger checkstop explicitly for error analysis. The FSP
481 * PRD component would have already got notified about this
482 * error through other channels.
483 *
484 * If hardware marked this as an unrecoverable MCE, we are
485 * going to panic anyway. Even if it didn't, it's not safe to
486 * continue at this point, so we should explicitly panic.
487 */
488
489 panic("PowerNV Unrecovered Machine Check");
490 return 0;
491 }
492
493 /* Early hmi handler called in real mode. */
opal_hmi_exception_early(struct pt_regs * regs)494 int opal_hmi_exception_early(struct pt_regs *regs)
495 {
496 s64 rc;
497
498 /*
499 * call opal hmi handler. Pass paca address as token.
500 * The return value OPAL_SUCCESS is an indication that there is
501 * an HMI event generated waiting to pull by Linux.
502 */
503 rc = opal_handle_hmi();
504 if (rc == OPAL_SUCCESS) {
505 local_paca->hmi_event_available = 1;
506 return 1;
507 }
508 return 0;
509 }
510
511 /* HMI exception handler called in virtual mode during check_irq_replay. */
opal_handle_hmi_exception(struct pt_regs * regs)512 int opal_handle_hmi_exception(struct pt_regs *regs)
513 {
514 s64 rc;
515 __be64 evt = 0;
516
517 /*
518 * Check if HMI event is available.
519 * if Yes, then call opal_poll_events to pull opal messages and
520 * process them.
521 */
522 if (!local_paca->hmi_event_available)
523 return 0;
524
525 local_paca->hmi_event_available = 0;
526 rc = opal_poll_events(&evt);
527 if (rc == OPAL_SUCCESS && evt)
528 opal_handle_events(be64_to_cpu(evt));
529
530 return 1;
531 }
532
find_recovery_address(uint64_t nip)533 static uint64_t find_recovery_address(uint64_t nip)
534 {
535 int i;
536
537 for (i = 0; i < mc_recoverable_range_len; i++)
538 if ((nip >= mc_recoverable_range[i].start_addr) &&
539 (nip < mc_recoverable_range[i].end_addr))
540 return mc_recoverable_range[i].recover_addr;
541 return 0;
542 }
543
opal_mce_check_early_recovery(struct pt_regs * regs)544 bool opal_mce_check_early_recovery(struct pt_regs *regs)
545 {
546 uint64_t recover_addr = 0;
547
548 if (!opal.base || !opal.size)
549 goto out;
550
551 if ((regs->nip >= opal.base) &&
552 (regs->nip <= (opal.base + opal.size)))
553 recover_addr = find_recovery_address(regs->nip);
554
555 /*
556 * Setup regs->nip to rfi into fixup address.
557 */
558 if (recover_addr)
559 regs->nip = recover_addr;
560
561 out:
562 return !!recover_addr;
563 }
564
opal_sysfs_init(void)565 static int opal_sysfs_init(void)
566 {
567 opal_kobj = kobject_create_and_add("opal", firmware_kobj);
568 if (!opal_kobj) {
569 pr_warn("kobject_create_and_add opal failed\n");
570 return -ENOMEM;
571 }
572
573 return 0;
574 }
575
symbol_map_read(struct file * fp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)576 static ssize_t symbol_map_read(struct file *fp, struct kobject *kobj,
577 struct bin_attribute *bin_attr,
578 char *buf, loff_t off, size_t count)
579 {
580 return memory_read_from_buffer(buf, count, &off, bin_attr->private,
581 bin_attr->size);
582 }
583
584 static struct bin_attribute symbol_map_attr = {
585 .attr = {.name = "symbol_map", .mode = 0400},
586 .read = symbol_map_read
587 };
588
opal_export_symmap(void)589 static void opal_export_symmap(void)
590 {
591 const __be64 *syms;
592 unsigned int size;
593 struct device_node *fw;
594 int rc;
595
596 fw = of_find_node_by_path("/ibm,opal/firmware");
597 if (!fw)
598 return;
599 syms = of_get_property(fw, "symbol-map", &size);
600 if (!syms || size != 2 * sizeof(__be64))
601 return;
602
603 /* Setup attributes */
604 symbol_map_attr.private = __va(be64_to_cpu(syms[0]));
605 symbol_map_attr.size = be64_to_cpu(syms[1]);
606
607 rc = sysfs_create_bin_file(opal_kobj, &symbol_map_attr);
608 if (rc)
609 pr_warn("Error %d creating OPAL symbols file\n", rc);
610 }
611
opal_dump_region_init(void)612 static void __init opal_dump_region_init(void)
613 {
614 void *addr;
615 uint64_t size;
616 int rc;
617
618 if (!opal_check_token(OPAL_REGISTER_DUMP_REGION))
619 return;
620
621 /* Register kernel log buffer */
622 addr = log_buf_addr_get();
623 if (addr == NULL)
624 return;
625
626 size = log_buf_len_get();
627 if (size == 0)
628 return;
629
630 rc = opal_register_dump_region(OPAL_DUMP_REGION_LOG_BUF,
631 __pa(addr), size);
632 /* Don't warn if this is just an older OPAL that doesn't
633 * know about that call
634 */
635 if (rc && rc != OPAL_UNSUPPORTED)
636 pr_warn("DUMP: Failed to register kernel log buffer. "
637 "rc = %d\n", rc);
638 }
639
opal_pdev_init(struct device_node * opal_node,const char * compatible)640 static void opal_pdev_init(struct device_node *opal_node,
641 const char *compatible)
642 {
643 struct device_node *np;
644
645 for_each_child_of_node(opal_node, np)
646 if (of_device_is_compatible(np, compatible))
647 of_platform_device_create(np, NULL, NULL);
648 }
649
opal_i2c_create_devs(void)650 static void opal_i2c_create_devs(void)
651 {
652 struct device_node *np;
653
654 for_each_compatible_node(np, NULL, "ibm,opal-i2c")
655 of_platform_device_create(np, NULL, NULL);
656 }
657
kopald(void * unused)658 static int kopald(void *unused)
659 {
660 __be64 events;
661
662 set_freezable();
663 do {
664 try_to_freeze();
665 opal_poll_events(&events);
666 opal_handle_events(be64_to_cpu(events));
667 msleep_interruptible(opal_heartbeat);
668 } while (!kthread_should_stop());
669
670 return 0;
671 }
672
opal_init_heartbeat(void)673 static void opal_init_heartbeat(void)
674 {
675 /* Old firwmware, we assume the HVC heartbeat is sufficient */
676 if (of_property_read_u32(opal_node, "ibm,heartbeat-ms",
677 &opal_heartbeat) != 0)
678 opal_heartbeat = 0;
679
680 if (opal_heartbeat)
681 kthread_run(kopald, NULL, "kopald");
682 }
683
opal_init(void)684 static int __init opal_init(void)
685 {
686 struct device_node *np, *consoles, *leds;
687 int rc;
688
689 opal_node = of_find_node_by_path("/ibm,opal");
690 if (!opal_node) {
691 pr_warn("Device node not found\n");
692 return -ENODEV;
693 }
694
695 /* Register OPAL consoles if any ports */
696 consoles = of_find_node_by_path("/ibm,opal/consoles");
697 if (consoles) {
698 for_each_child_of_node(consoles, np) {
699 if (strcmp(np->name, "serial"))
700 continue;
701 of_platform_device_create(np, NULL, NULL);
702 }
703 of_node_put(consoles);
704 }
705
706 /* Initialise OPAL messaging system */
707 opal_message_init();
708
709 /* Initialise OPAL asynchronous completion interface */
710 opal_async_comp_init();
711
712 /* Initialise OPAL sensor interface */
713 opal_sensor_init();
714
715 /* Initialise OPAL hypervisor maintainence interrupt handling */
716 opal_hmi_handler_init();
717
718 /* Create i2c platform devices */
719 opal_i2c_create_devs();
720
721 /* Setup a heatbeat thread if requested by OPAL */
722 opal_init_heartbeat();
723
724 /* Create leds platform devices */
725 leds = of_find_node_by_path("/ibm,opal/leds");
726 if (leds) {
727 of_platform_device_create(leds, "opal_leds", NULL);
728 of_node_put(leds);
729 }
730
731 /* Create "opal" kobject under /sys/firmware */
732 rc = opal_sysfs_init();
733 if (rc == 0) {
734 /* Export symbol map to userspace */
735 opal_export_symmap();
736 /* Setup dump region interface */
737 opal_dump_region_init();
738 /* Setup error log interface */
739 rc = opal_elog_init();
740 /* Setup code update interface */
741 opal_flash_update_init();
742 /* Setup platform dump extract interface */
743 opal_platform_dump_init();
744 /* Setup system parameters interface */
745 opal_sys_param_init();
746 /* Setup message log interface. */
747 opal_msglog_init();
748 }
749
750 /* Initialize platform devices: IPMI backend, PRD & flash interface */
751 opal_pdev_init(opal_node, "ibm,opal-ipmi");
752 opal_pdev_init(opal_node, "ibm,opal-flash");
753 opal_pdev_init(opal_node, "ibm,opal-prd");
754
755 /* Initialise OPAL kmsg dumper for flushing console on panic */
756 opal_kmsg_init();
757
758 return 0;
759 }
760 machine_subsys_initcall(powernv, opal_init);
761
opal_shutdown(void)762 void opal_shutdown(void)
763 {
764 long rc = OPAL_BUSY;
765
766 opal_event_shutdown();
767
768 /*
769 * Then sync with OPAL which ensure anything that can
770 * potentially write to our memory has completed such
771 * as an ongoing dump retrieval
772 */
773 while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
774 rc = opal_sync_host_reboot();
775 if (rc == OPAL_BUSY)
776 opal_poll_events(NULL);
777 else
778 mdelay(10);
779 }
780
781 /* Unregister memory dump region */
782 if (opal_check_token(OPAL_UNREGISTER_DUMP_REGION))
783 opal_unregister_dump_region(OPAL_DUMP_REGION_LOG_BUF);
784 }
785
786 /* Export this so that test modules can use it */
787 EXPORT_SYMBOL_GPL(opal_invalid_call);
788 EXPORT_SYMBOL_GPL(opal_xscom_read);
789 EXPORT_SYMBOL_GPL(opal_xscom_write);
790 EXPORT_SYMBOL_GPL(opal_ipmi_send);
791 EXPORT_SYMBOL_GPL(opal_ipmi_recv);
792 EXPORT_SYMBOL_GPL(opal_flash_read);
793 EXPORT_SYMBOL_GPL(opal_flash_write);
794 EXPORT_SYMBOL_GPL(opal_flash_erase);
795 EXPORT_SYMBOL_GPL(opal_prd_msg);
796
797 /* Convert a region of vmalloc memory to an opal sg list */
opal_vmalloc_to_sg_list(void * vmalloc_addr,unsigned long vmalloc_size)798 struct opal_sg_list *opal_vmalloc_to_sg_list(void *vmalloc_addr,
799 unsigned long vmalloc_size)
800 {
801 struct opal_sg_list *sg, *first = NULL;
802 unsigned long i = 0;
803
804 sg = kzalloc(PAGE_SIZE, GFP_KERNEL);
805 if (!sg)
806 goto nomem;
807
808 first = sg;
809
810 while (vmalloc_size > 0) {
811 uint64_t data = vmalloc_to_pfn(vmalloc_addr) << PAGE_SHIFT;
812 uint64_t length = min(vmalloc_size, PAGE_SIZE);
813
814 sg->entry[i].data = cpu_to_be64(data);
815 sg->entry[i].length = cpu_to_be64(length);
816 i++;
817
818 if (i >= SG_ENTRIES_PER_NODE) {
819 struct opal_sg_list *next;
820
821 next = kzalloc(PAGE_SIZE, GFP_KERNEL);
822 if (!next)
823 goto nomem;
824
825 sg->length = cpu_to_be64(
826 i * sizeof(struct opal_sg_entry) + 16);
827 i = 0;
828 sg->next = cpu_to_be64(__pa(next));
829 sg = next;
830 }
831
832 vmalloc_addr += length;
833 vmalloc_size -= length;
834 }
835
836 sg->length = cpu_to_be64(i * sizeof(struct opal_sg_entry) + 16);
837
838 return first;
839
840 nomem:
841 pr_err("%s : Failed to allocate memory\n", __func__);
842 opal_free_sg_list(first);
843 return NULL;
844 }
845
opal_free_sg_list(struct opal_sg_list * sg)846 void opal_free_sg_list(struct opal_sg_list *sg)
847 {
848 while (sg) {
849 uint64_t next = be64_to_cpu(sg->next);
850
851 kfree(sg);
852
853 if (next)
854 sg = __va(next);
855 else
856 sg = NULL;
857 }
858 }
859
opal_error_code(int rc)860 int opal_error_code(int rc)
861 {
862 switch (rc) {
863 case OPAL_SUCCESS: return 0;
864
865 case OPAL_PARAMETER: return -EINVAL;
866 case OPAL_ASYNC_COMPLETION: return -EINPROGRESS;
867 case OPAL_BUSY_EVENT: return -EBUSY;
868 case OPAL_NO_MEM: return -ENOMEM;
869 case OPAL_PERMISSION: return -EPERM;
870
871 case OPAL_UNSUPPORTED: return -EIO;
872 case OPAL_HARDWARE: return -EIO;
873 case OPAL_INTERNAL_ERROR: return -EIO;
874 default:
875 pr_err("%s: unexpected OPAL error %d\n", __func__, rc);
876 return -EIO;
877 }
878 }
879
880 EXPORT_SYMBOL_GPL(opal_poll_events);
881 EXPORT_SYMBOL_GPL(opal_rtc_read);
882 EXPORT_SYMBOL_GPL(opal_rtc_write);
883 EXPORT_SYMBOL_GPL(opal_tpo_read);
884 EXPORT_SYMBOL_GPL(opal_tpo_write);
885 EXPORT_SYMBOL_GPL(opal_i2c_request);
886 /* Export these symbols for PowerNV LED class driver */
887 EXPORT_SYMBOL_GPL(opal_leds_get_ind);
888 EXPORT_SYMBOL_GPL(opal_leds_set_ind);
889