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