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