opal.c

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