12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
214a43e69SBenjamin Herrenschmidt /*
314a43e69SBenjamin Herrenschmidt * PowerNV OPAL high level interfaces
414a43e69SBenjamin Herrenschmidt *
514a43e69SBenjamin Herrenschmidt * Copyright 2011 IBM Corp.
614a43e69SBenjamin Herrenschmidt */
714a43e69SBenjamin Herrenschmidt
8c8742f85SBenjamin Herrenschmidt #define pr_fmt(fmt) "opal: " fmt
914a43e69SBenjamin Herrenschmidt
10c8742f85SBenjamin Herrenschmidt #include <linux/printk.h>
1114a43e69SBenjamin Herrenschmidt #include <linux/types.h>
1214a43e69SBenjamin Herrenschmidt #include <linux/of.h>
1326a2056eSRob Herring #include <linux/of_fdt.h>
1414a43e69SBenjamin Herrenschmidt #include <linux/of_platform.h>
158f95faaaSMadhavan Srinivasan #include <linux/of_address.h>
16a125e092SBenjamin Herrenschmidt #include <linux/interrupt.h>
171bc98de2SGavin Shan #include <linux/notifier.h>
1873ed148aSBenjamin Herrenschmidt #include <linux/slab.h>
19b63a0ffeSMahesh Salgaonkar #include <linux/sched.h>
206f68b5e2SVasant Hegde #include <linux/kobject.h>
21f7d98d18SVasant Hegde #include <linux/delay.h>
2255672ecfSMahesh Salgaonkar #include <linux/memblock.h>
233bf57561SBenjamin Herrenschmidt #include <linux/kthread.h>
243bf57561SBenjamin Herrenschmidt #include <linux/freezer.h>
25b746e3e0SNicholas Piggin #include <linux/kmsg_dump.h>
26b746e3e0SNicholas Piggin #include <linux/console.h>
27b746e3e0SNicholas Piggin #include <linux/sched/debug.h>
28b14726c5SMichael Ellerman
29b14726c5SMichael Ellerman #include <asm/machdep.h>
3014a43e69SBenjamin Herrenschmidt #include <asm/opal.h>
3114a43e69SBenjamin Herrenschmidt #include <asm/firmware.h>
3236df96f8SMahesh Salgaonkar #include <asm/mce.h>
338f95faaaSMadhavan Srinivasan #include <asm/imc-pmu.h>
346fcd6baaSNicholas Piggin #include <asm/bug.h>
3514a43e69SBenjamin Herrenschmidt
3614a43e69SBenjamin Herrenschmidt #include "powernv.h"
3714a43e69SBenjamin Herrenschmidt
38a9336ddfSDeb McLemore #define OPAL_MSG_QUEUE_MAX 16
39a9336ddfSDeb McLemore
40a9336ddfSDeb McLemore struct opal_msg_node {
41a9336ddfSDeb McLemore struct list_head list;
42a9336ddfSDeb McLemore struct opal_msg msg;
43a9336ddfSDeb McLemore };
44a9336ddfSDeb McLemore
45a9336ddfSDeb McLemore static DEFINE_SPINLOCK(msg_list_lock);
46a9336ddfSDeb McLemore static LIST_HEAD(msg_list);
47a9336ddfSDeb McLemore
486f68b5e2SVasant Hegde /* /sys/firmware/opal */
496f68b5e2SVasant Hegde struct kobject *opal_kobj;
506f68b5e2SVasant Hegde
5114a43e69SBenjamin Herrenschmidt struct opal {
5214a43e69SBenjamin Herrenschmidt u64 base;
5314a43e69SBenjamin Herrenschmidt u64 entry;
5455672ecfSMahesh Salgaonkar u64 size;
5514a43e69SBenjamin Herrenschmidt } opal;
5614a43e69SBenjamin Herrenschmidt
5755672ecfSMahesh Salgaonkar struct mcheck_recoverable_range {
5855672ecfSMahesh Salgaonkar u64 start_addr;
5955672ecfSMahesh Salgaonkar u64 end_addr;
6055672ecfSMahesh Salgaonkar u64 recover_addr;
6155672ecfSMahesh Salgaonkar };
6255672ecfSMahesh Salgaonkar
63a9336ddfSDeb McLemore static int msg_list_size;
64a9336ddfSDeb McLemore
6555672ecfSMahesh Salgaonkar static struct mcheck_recoverable_range *mc_recoverable_range;
6655672ecfSMahesh Salgaonkar static int mc_recoverable_range_len;
6755672ecfSMahesh Salgaonkar
68bfc36894SJoel Stanley struct device_node *opal_node;
6914a43e69SBenjamin Herrenschmidt static DEFINE_SPINLOCK(opal_write_lock);
7024366360SMahesh Salgaonkar static struct atomic_notifier_head opal_msg_notifier_head[OPAL_MSG_TYPE_MAX];
713bf57561SBenjamin Herrenschmidt static uint32_t opal_heartbeat;
72a203658bSBenjamin Herrenschmidt static struct task_struct *kopald_tsk;
732be1d5d1SVasant Hegde static struct opal_msg *opal_msg;
742be1d5d1SVasant Hegde static u32 opal_msg_size __ro_after_init;
7514a43e69SBenjamin Herrenschmidt
opal_configure_cores(void)76e5913db1SNick Child void __init opal_configure_cores(void)
774926616cSBenjamin Herrenschmidt {
781c0eaf0fSBenjamin Herrenschmidt u64 reinit_flags = 0;
791c0eaf0fSBenjamin Herrenschmidt
804926616cSBenjamin Herrenschmidt /* Do the actual re-init, This will clobber all FPRs, VRs, etc...
814926616cSBenjamin Herrenschmidt *
824926616cSBenjamin Herrenschmidt * It will preserve non volatile GPRs and HSPRG0/1. It will
834926616cSBenjamin Herrenschmidt * also restore HIDs and other SPRs to their original value
844926616cSBenjamin Herrenschmidt * but it might clobber a bunch.
854926616cSBenjamin Herrenschmidt */
864926616cSBenjamin Herrenschmidt #ifdef __BIG_ENDIAN__
871c0eaf0fSBenjamin Herrenschmidt reinit_flags |= OPAL_REINIT_CPUS_HILE_BE;
884926616cSBenjamin Herrenschmidt #else
891c0eaf0fSBenjamin Herrenschmidt reinit_flags |= OPAL_REINIT_CPUS_HILE_LE;
904926616cSBenjamin Herrenschmidt #endif
91d3cbff1bSBenjamin Herrenschmidt
921c0eaf0fSBenjamin Herrenschmidt /*
931c0eaf0fSBenjamin Herrenschmidt * POWER9 always support running hash:
941c0eaf0fSBenjamin Herrenschmidt * ie. Host hash supports hash guests
951c0eaf0fSBenjamin Herrenschmidt * Host radix supports hash/radix guests
961c0eaf0fSBenjamin Herrenschmidt */
97a70b487bSMichael Ellerman if (early_cpu_has_feature(CPU_FTR_ARCH_300)) {
981c0eaf0fSBenjamin Herrenschmidt reinit_flags |= OPAL_REINIT_CPUS_MMU_HASH;
991c0eaf0fSBenjamin Herrenschmidt if (early_radix_enabled())
1001c0eaf0fSBenjamin Herrenschmidt reinit_flags |= OPAL_REINIT_CPUS_MMU_RADIX;
1011c0eaf0fSBenjamin Herrenschmidt }
1021c0eaf0fSBenjamin Herrenschmidt
1031c0eaf0fSBenjamin Herrenschmidt opal_reinit_cpus(reinit_flags);
1041c0eaf0fSBenjamin Herrenschmidt
105d3cbff1bSBenjamin Herrenschmidt /* Restore some bits */
106d3cbff1bSBenjamin Herrenschmidt if (cur_cpu_spec->cpu_restore)
107d3cbff1bSBenjamin Herrenschmidt cur_cpu_spec->cpu_restore();
1084926616cSBenjamin Herrenschmidt }
1094926616cSBenjamin Herrenschmidt
early_init_dt_scan_opal(unsigned long node,const char * uname,int depth,void * data)11014a43e69SBenjamin Herrenschmidt int __init early_init_dt_scan_opal(unsigned long node,
11114a43e69SBenjamin Herrenschmidt const char *uname, int depth, void *data)
11214a43e69SBenjamin Herrenschmidt {
11355672ecfSMahesh Salgaonkar const void *basep, *entryp, *sizep;
1149d0c4dfeSRob Herring int basesz, entrysz, runtimesz;
11514a43e69SBenjamin Herrenschmidt
11614a43e69SBenjamin Herrenschmidt if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
11714a43e69SBenjamin Herrenschmidt return 0;
11814a43e69SBenjamin Herrenschmidt
11914a43e69SBenjamin Herrenschmidt basep = of_get_flat_dt_prop(node, "opal-base-address", &basesz);
12014a43e69SBenjamin Herrenschmidt entryp = of_get_flat_dt_prop(node, "opal-entry-address", &entrysz);
12155672ecfSMahesh Salgaonkar sizep = of_get_flat_dt_prop(node, "opal-runtime-size", &runtimesz);
12214a43e69SBenjamin Herrenschmidt
12355672ecfSMahesh Salgaonkar if (!basep || !entryp || !sizep)
12414a43e69SBenjamin Herrenschmidt return 1;
12514a43e69SBenjamin Herrenschmidt
12614a43e69SBenjamin Herrenschmidt opal.base = of_read_number(basep, basesz/4);
12714a43e69SBenjamin Herrenschmidt opal.entry = of_read_number(entryp, entrysz/4);
12855672ecfSMahesh Salgaonkar opal.size = of_read_number(sizep, runtimesz/4);
12914a43e69SBenjamin Herrenschmidt
1309d0c4dfeSRob Herring pr_debug("OPAL Base = 0x%llx (basep=%p basesz=%d)\n",
13114a43e69SBenjamin Herrenschmidt opal.base, basep, basesz);
1329d0c4dfeSRob Herring pr_debug("OPAL Entry = 0x%llx (entryp=%p basesz=%d)\n",
13314a43e69SBenjamin Herrenschmidt opal.entry, entryp, entrysz);
1349d0c4dfeSRob Herring pr_debug("OPAL Entry = 0x%llx (sizep=%p runtimesz=%d)\n",
13555672ecfSMahesh Salgaonkar opal.size, sizep, runtimesz);
13614a43e69SBenjamin Herrenschmidt
13775b93da4SBenjamin Herrenschmidt if (of_flat_dt_is_compatible(node, "ibm,opal-v3")) {
138e4d54f71SStewart Smith powerpc_firmware_features |= FW_FEATURE_OPAL;
1395138b314SBenjamin Herrenschmidt pr_debug("OPAL detected !\n");
14014a43e69SBenjamin Herrenschmidt } else {
141786842b6SStewart Smith panic("OPAL != V3 detected, no longer supported.\n");
14214a43e69SBenjamin Herrenschmidt }
14314a43e69SBenjamin Herrenschmidt
144c4463b37SJeremy Kerr return 1;
145c4463b37SJeremy Kerr }
146c4463b37SJeremy Kerr
early_init_dt_scan_recoverable_ranges(unsigned long node,const char * uname,int depth,void * data)14755672ecfSMahesh Salgaonkar int __init early_init_dt_scan_recoverable_ranges(unsigned long node,
14855672ecfSMahesh Salgaonkar const char *uname, int depth, void *data)
14955672ecfSMahesh Salgaonkar {
1509d0c4dfeSRob Herring int i, psize, size;
15155672ecfSMahesh Salgaonkar const __be32 *prop;
15255672ecfSMahesh Salgaonkar
15355672ecfSMahesh Salgaonkar if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
15455672ecfSMahesh Salgaonkar return 0;
15555672ecfSMahesh Salgaonkar
1566e556b47SMahesh Salgaonkar prop = of_get_flat_dt_prop(node, "mcheck-recoverable-ranges", &psize);
15755672ecfSMahesh Salgaonkar
15855672ecfSMahesh Salgaonkar if (!prop)
15955672ecfSMahesh Salgaonkar return 1;
16055672ecfSMahesh Salgaonkar
16155672ecfSMahesh Salgaonkar pr_debug("Found machine check recoverable ranges.\n");
16255672ecfSMahesh Salgaonkar
16355672ecfSMahesh Salgaonkar /*
1646e556b47SMahesh Salgaonkar * Calculate number of available entries.
1656e556b47SMahesh Salgaonkar *
1666e556b47SMahesh Salgaonkar * Each recoverable address range entry is (start address, len,
1676e556b47SMahesh Salgaonkar * recovery address), 2 cells each for start and recovery address,
1686e556b47SMahesh Salgaonkar * 1 cell for len, totalling 5 cells per entry.
1696e556b47SMahesh Salgaonkar */
1706e556b47SMahesh Salgaonkar mc_recoverable_range_len = psize / (sizeof(*prop) * 5);
1716e556b47SMahesh Salgaonkar
1726e556b47SMahesh Salgaonkar /* Sanity check */
1736e556b47SMahesh Salgaonkar if (!mc_recoverable_range_len)
1746e556b47SMahesh Salgaonkar return 1;
1756e556b47SMahesh Salgaonkar
1766e556b47SMahesh Salgaonkar /* Size required to hold all the entries. */
1776e556b47SMahesh Salgaonkar size = mc_recoverable_range_len *
1786e556b47SMahesh Salgaonkar sizeof(struct mcheck_recoverable_range);
1796e556b47SMahesh Salgaonkar
1806e556b47SMahesh Salgaonkar /*
18176b42e28SNicholas Piggin * Allocate a buffer to hold the MC recoverable ranges.
18255672ecfSMahesh Salgaonkar */
183b63a07d6SMike Rapoport mc_recoverable_range = memblock_alloc(size, __alignof__(u64));
1848a7f97b9SMike Rapoport if (!mc_recoverable_range)
1858a7f97b9SMike Rapoport panic("%s: Failed to allocate %u bytes align=0x%lx\n",
1868a7f97b9SMike Rapoport __func__, size, __alignof__(u64));
18755672ecfSMahesh Salgaonkar
1886e556b47SMahesh Salgaonkar for (i = 0; i < mc_recoverable_range_len; i++) {
18955672ecfSMahesh Salgaonkar mc_recoverable_range[i].start_addr =
19055672ecfSMahesh Salgaonkar of_read_number(prop + (i * 5) + 0, 2);
19155672ecfSMahesh Salgaonkar mc_recoverable_range[i].end_addr =
19255672ecfSMahesh Salgaonkar mc_recoverable_range[i].start_addr +
19355672ecfSMahesh Salgaonkar of_read_number(prop + (i * 5) + 2, 1);
19455672ecfSMahesh Salgaonkar mc_recoverable_range[i].recover_addr =
19555672ecfSMahesh Salgaonkar of_read_number(prop + (i * 5) + 3, 2);
19655672ecfSMahesh Salgaonkar
19755672ecfSMahesh Salgaonkar pr_debug("Machine check recoverable range: %llx..%llx: %llx\n",
19855672ecfSMahesh Salgaonkar mc_recoverable_range[i].start_addr,
19955672ecfSMahesh Salgaonkar mc_recoverable_range[i].end_addr,
20055672ecfSMahesh Salgaonkar mc_recoverable_range[i].recover_addr);
20155672ecfSMahesh Salgaonkar }
20255672ecfSMahesh Salgaonkar return 1;
20355672ecfSMahesh Salgaonkar }
20455672ecfSMahesh Salgaonkar
opal_register_exception_handlers(void)205c4463b37SJeremy Kerr static int __init opal_register_exception_handlers(void)
206c4463b37SJeremy Kerr {
20729186097SBenjamin Herrenschmidt #ifdef __BIG_ENDIAN__
208c4463b37SJeremy Kerr u64 glue;
209c4463b37SJeremy Kerr
210c4463b37SJeremy Kerr if (!(powerpc_firmware_features & FW_FEATURE_OPAL))
211c4463b37SJeremy Kerr return -ENODEV;
212c4463b37SJeremy Kerr
21328446de2SMahesh Salgaonkar /* Hookup some exception handlers except machine check. We use the
21428446de2SMahesh Salgaonkar * fwnmi area at 0x7000 to provide the glue space to OPAL
215ed79ba9eSBenjamin Herrenschmidt */
216ed79ba9eSBenjamin Herrenschmidt glue = 0x7000;
2176507955cSMahesh Salgaonkar
2186507955cSMahesh Salgaonkar /*
2191549c42dSStewart Smith * Only ancient OPAL firmware requires this.
2201549c42dSStewart Smith * Specifically, firmware from FW810.00 (released June 2014)
2211549c42dSStewart Smith * through FW810.20 (Released October 2014).
2226507955cSMahesh Salgaonkar *
2231549c42dSStewart Smith * Check if we are running on newer (post Oct 2014) firmware that
2241549c42dSStewart Smith * exports the OPAL_HANDLE_HMI token. If yes, then don't ask OPAL to
2251549c42dSStewart Smith * patch the HMI interrupt and we catch it directly in Linux.
2266507955cSMahesh Salgaonkar *
2271549c42dSStewart Smith * For older firmware (i.e < FW810.20), we fallback to old behavior and
2281549c42dSStewart Smith * let OPAL patch the HMI vector and handle it inside OPAL firmware.
2291549c42dSStewart Smith *
2301549c42dSStewart Smith * For newer firmware we catch/handle the HMI directly in Linux.
2316507955cSMahesh Salgaonkar */
2326507955cSMahesh Salgaonkar if (!opal_check_token(OPAL_HANDLE_HMI)) {
23308135139SMichael Ellerman pr_info("Old firmware detected, OPAL handles HMIs.\n");
2346507955cSMahesh Salgaonkar opal_register_exception_handler(
2356507955cSMahesh Salgaonkar OPAL_HYPERVISOR_MAINTENANCE_HANDLER,
2366507955cSMahesh Salgaonkar 0, glue);
2376507955cSMahesh Salgaonkar glue += 128;
2386507955cSMahesh Salgaonkar }
2396507955cSMahesh Salgaonkar
2401549c42dSStewart Smith /*
2411549c42dSStewart Smith * Only applicable to ancient firmware, all modern
2421549c42dSStewart Smith * (post March 2015/skiboot 5.0) firmware will just return
2431549c42dSStewart Smith * OPAL_UNSUPPORTED.
2441549c42dSStewart Smith */
245ed79ba9eSBenjamin Herrenschmidt opal_register_exception_handler(OPAL_SOFTPATCH_HANDLER, 0, glue);
24629186097SBenjamin Herrenschmidt #endif
247ed79ba9eSBenjamin Herrenschmidt
248c4463b37SJeremy Kerr return 0;
24914a43e69SBenjamin Herrenschmidt }
250b14726c5SMichael Ellerman machine_early_initcall(powernv, opal_register_exception_handlers);
251c4463b37SJeremy Kerr
queue_replay_msg(void * msg)252a9336ddfSDeb McLemore static void queue_replay_msg(void *msg)
253a9336ddfSDeb McLemore {
254a9336ddfSDeb McLemore struct opal_msg_node *msg_node;
255a9336ddfSDeb McLemore
256a9336ddfSDeb McLemore if (msg_list_size < OPAL_MSG_QUEUE_MAX) {
257a9336ddfSDeb McLemore msg_node = kzalloc(sizeof(*msg_node), GFP_ATOMIC);
258a9336ddfSDeb McLemore if (msg_node) {
259a9336ddfSDeb McLemore INIT_LIST_HEAD(&msg_node->list);
260a9336ddfSDeb McLemore memcpy(&msg_node->msg, msg, sizeof(struct opal_msg));
261a9336ddfSDeb McLemore list_add_tail(&msg_node->list, &msg_list);
262a9336ddfSDeb McLemore msg_list_size++;
263a9336ddfSDeb McLemore } else
264a9336ddfSDeb McLemore pr_warn_once("message queue no memory\n");
265a9336ddfSDeb McLemore
266a9336ddfSDeb McLemore if (msg_list_size >= OPAL_MSG_QUEUE_MAX)
267a9336ddfSDeb McLemore pr_warn_once("message queue full\n");
268a9336ddfSDeb McLemore }
269a9336ddfSDeb McLemore }
270a9336ddfSDeb McLemore
dequeue_replay_msg(enum opal_msg_type msg_type)271a9336ddfSDeb McLemore static void dequeue_replay_msg(enum opal_msg_type msg_type)
272a9336ddfSDeb McLemore {
273a9336ddfSDeb McLemore struct opal_msg_node *msg_node, *tmp;
274a9336ddfSDeb McLemore
275a9336ddfSDeb McLemore list_for_each_entry_safe(msg_node, tmp, &msg_list, list) {
276a9336ddfSDeb McLemore if (be32_to_cpu(msg_node->msg.msg_type) != msg_type)
277a9336ddfSDeb McLemore continue;
278a9336ddfSDeb McLemore
279a9336ddfSDeb McLemore atomic_notifier_call_chain(&opal_msg_notifier_head[msg_type],
280a9336ddfSDeb McLemore msg_type,
281a9336ddfSDeb McLemore &msg_node->msg);
282a9336ddfSDeb McLemore
283a9336ddfSDeb McLemore list_del(&msg_node->list);
284a9336ddfSDeb McLemore kfree(msg_node);
285a9336ddfSDeb McLemore msg_list_size--;
286a9336ddfSDeb McLemore }
287a9336ddfSDeb McLemore }
288a9336ddfSDeb McLemore
28924366360SMahesh Salgaonkar /*
29024366360SMahesh Salgaonkar * Opal message notifier based on message type. Allow subscribers to get
29124366360SMahesh Salgaonkar * notified for specific messgae type.
29224366360SMahesh Salgaonkar */
opal_message_notifier_register(enum opal_msg_type msg_type,struct notifier_block * nb)293d7cf83fcSMichael Ellerman int opal_message_notifier_register(enum opal_msg_type msg_type,
29424366360SMahesh Salgaonkar struct notifier_block *nb)
29524366360SMahesh Salgaonkar {
296a9336ddfSDeb McLemore int ret;
297a9336ddfSDeb McLemore unsigned long flags;
298a9336ddfSDeb McLemore
299792f96e9SNeelesh Gupta if (!nb || msg_type >= OPAL_MSG_TYPE_MAX) {
300f2c2cbccSJoe Perches pr_warn("%s: Invalid arguments, msg_type:%d\n",
30124366360SMahesh Salgaonkar __func__, msg_type);
30224366360SMahesh Salgaonkar return -EINVAL;
30324366360SMahesh Salgaonkar }
304792f96e9SNeelesh Gupta
305a9336ddfSDeb McLemore spin_lock_irqsave(&msg_list_lock, flags);
306a9336ddfSDeb McLemore ret = atomic_notifier_chain_register(
30724366360SMahesh Salgaonkar &opal_msg_notifier_head[msg_type], nb);
308a9336ddfSDeb McLemore
309a9336ddfSDeb McLemore /*
310a9336ddfSDeb McLemore * If the registration succeeded, replay any queued messages that came
311a9336ddfSDeb McLemore * in prior to the notifier chain registration. msg_list_lock held here
312a9336ddfSDeb McLemore * to ensure they're delivered prior to any subsequent messages.
313a9336ddfSDeb McLemore */
314a9336ddfSDeb McLemore if (ret == 0)
315a9336ddfSDeb McLemore dequeue_replay_msg(msg_type);
316a9336ddfSDeb McLemore
317a9336ddfSDeb McLemore spin_unlock_irqrestore(&msg_list_lock, flags);
318a9336ddfSDeb McLemore
319a9336ddfSDeb McLemore return ret;
32024366360SMahesh Salgaonkar }
321594fcb9eSJeremy Kerr EXPORT_SYMBOL_GPL(opal_message_notifier_register);
32224366360SMahesh Salgaonkar
opal_message_notifier_unregister(enum opal_msg_type msg_type,struct notifier_block * nb)323df60f576SMichael Ellerman int opal_message_notifier_unregister(enum opal_msg_type msg_type,
324b921e902SNeelesh Gupta struct notifier_block *nb)
325b921e902SNeelesh Gupta {
326b921e902SNeelesh Gupta return atomic_notifier_chain_unregister(
327b921e902SNeelesh Gupta &opal_msg_notifier_head[msg_type], nb);
328b921e902SNeelesh Gupta }
329594fcb9eSJeremy Kerr EXPORT_SYMBOL_GPL(opal_message_notifier_unregister);
330b921e902SNeelesh Gupta
opal_message_do_notify(uint32_t msg_type,void * msg)33124366360SMahesh Salgaonkar static void opal_message_do_notify(uint32_t msg_type, void *msg)
33224366360SMahesh Salgaonkar {
333a9336ddfSDeb McLemore unsigned long flags;
334a9336ddfSDeb McLemore bool queued = false;
335a9336ddfSDeb McLemore
336a9336ddfSDeb McLemore spin_lock_irqsave(&msg_list_lock, flags);
337a9336ddfSDeb McLemore if (opal_msg_notifier_head[msg_type].head == NULL) {
338a9336ddfSDeb McLemore /*
339a9336ddfSDeb McLemore * Queue up the msg since no notifiers have registered
340a9336ddfSDeb McLemore * yet for this msg_type.
341a9336ddfSDeb McLemore */
342a9336ddfSDeb McLemore queue_replay_msg(msg);
343a9336ddfSDeb McLemore queued = true;
344a9336ddfSDeb McLemore }
345a9336ddfSDeb McLemore spin_unlock_irqrestore(&msg_list_lock, flags);
346a9336ddfSDeb McLemore
347a9336ddfSDeb McLemore if (queued)
348a9336ddfSDeb McLemore return;
349a9336ddfSDeb McLemore
35024366360SMahesh Salgaonkar /* notify subscribers */
35124366360SMahesh Salgaonkar atomic_notifier_call_chain(&opal_msg_notifier_head[msg_type],
35224366360SMahesh Salgaonkar msg_type, msg);
35324366360SMahesh Salgaonkar }
35424366360SMahesh Salgaonkar
opal_handle_message(void)35524366360SMahesh Salgaonkar static void opal_handle_message(void)
35624366360SMahesh Salgaonkar {
35724366360SMahesh Salgaonkar s64 ret;
358bb4398e1SAnton Blanchard u32 type;
35924366360SMahesh Salgaonkar
3602be1d5d1SVasant Hegde ret = opal_get_msg(__pa(opal_msg), opal_msg_size);
36124366360SMahesh Salgaonkar /* No opal message pending. */
36224366360SMahesh Salgaonkar if (ret == OPAL_RESOURCE)
36324366360SMahesh Salgaonkar return;
36424366360SMahesh Salgaonkar
36524366360SMahesh Salgaonkar /* check for errors. */
36624366360SMahesh Salgaonkar if (ret) {
367f2c2cbccSJoe Perches pr_warn("%s: Failed to retrieve opal message, err=%lld\n",
36824366360SMahesh Salgaonkar __func__, ret);
36924366360SMahesh Salgaonkar return;
37024366360SMahesh Salgaonkar }
37124366360SMahesh Salgaonkar
3722be1d5d1SVasant Hegde type = be32_to_cpu(opal_msg->msg_type);
373bb4398e1SAnton Blanchard
37424366360SMahesh Salgaonkar /* Sanity check */
375792f96e9SNeelesh Gupta if (type >= OPAL_MSG_TYPE_MAX) {
37698da62b7SStewart Smith pr_warn_once("%s: Unknown message type: %u\n", __func__, type);
37724366360SMahesh Salgaonkar return;
37824366360SMahesh Salgaonkar }
3792be1d5d1SVasant Hegde opal_message_do_notify(type, (void *)opal_msg);
38024366360SMahesh Salgaonkar }
38124366360SMahesh Salgaonkar
opal_message_notify(int irq,void * data)382a295af24SAlistair Popple static irqreturn_t opal_message_notify(int irq, void *data)
38324366360SMahesh Salgaonkar {
38424366360SMahesh Salgaonkar opal_handle_message();
385a295af24SAlistair Popple return IRQ_HANDLED;
38624366360SMahesh Salgaonkar }
38724366360SMahesh Salgaonkar
opal_message_init(struct device_node * opal_node)3882be1d5d1SVasant Hegde static int __init opal_message_init(struct device_node *opal_node)
38924366360SMahesh Salgaonkar {
390a295af24SAlistair Popple int ret, i, irq;
39124366360SMahesh Salgaonkar
3922be1d5d1SVasant Hegde ret = of_property_read_u32(opal_node, "opal-msg-size", &opal_msg_size);
3932be1d5d1SVasant Hegde if (ret) {
3942be1d5d1SVasant Hegde pr_notice("Failed to read opal-msg-size property\n");
3952be1d5d1SVasant Hegde opal_msg_size = sizeof(struct opal_msg);
3962be1d5d1SVasant Hegde }
3972be1d5d1SVasant Hegde
3982be1d5d1SVasant Hegde opal_msg = kmalloc(opal_msg_size, GFP_KERNEL);
3992be1d5d1SVasant Hegde if (!opal_msg) {
4002be1d5d1SVasant Hegde opal_msg_size = sizeof(struct opal_msg);
4012be1d5d1SVasant Hegde /* Try to allocate fixed message size */
4022be1d5d1SVasant Hegde opal_msg = kmalloc(opal_msg_size, GFP_KERNEL);
4032be1d5d1SVasant Hegde BUG_ON(opal_msg == NULL);
4042be1d5d1SVasant Hegde }
4052be1d5d1SVasant Hegde
40624366360SMahesh Salgaonkar for (i = 0; i < OPAL_MSG_TYPE_MAX; i++)
40724366360SMahesh Salgaonkar ATOMIC_INIT_NOTIFIER_HEAD(&opal_msg_notifier_head[i]);
40824366360SMahesh Salgaonkar
409a295af24SAlistair Popple irq = opal_event_request(ilog2(OPAL_EVENT_MSG_PENDING));
410a295af24SAlistair Popple if (!irq) {
411a295af24SAlistair Popple pr_err("%s: Can't register OPAL event irq (%d)\n",
412a295af24SAlistair Popple __func__, irq);
413a295af24SAlistair Popple return irq;
414a295af24SAlistair Popple }
415a295af24SAlistair Popple
416a295af24SAlistair Popple ret = request_irq(irq, opal_message_notify,
417a295af24SAlistair Popple IRQ_TYPE_LEVEL_HIGH, "opal-msg", NULL);
41824366360SMahesh Salgaonkar if (ret) {
419a295af24SAlistair Popple pr_err("%s: Can't request OPAL event irq (%d)\n",
42024366360SMahesh Salgaonkar __func__, ret);
42124366360SMahesh Salgaonkar return ret;
42224366360SMahesh Salgaonkar }
423a295af24SAlistair Popple
42424366360SMahesh Salgaonkar return 0;
42524366360SMahesh Salgaonkar }
42624366360SMahesh Salgaonkar
opal_get_chars(uint32_t vtermno,char * buf,int count)42714a43e69SBenjamin Herrenschmidt int opal_get_chars(uint32_t vtermno, char *buf, int count)
42814a43e69SBenjamin Herrenschmidt {
4294f89363bSBenjamin Herrenschmidt s64 rc;
4304f89363bSBenjamin Herrenschmidt __be64 evt, len;
43114a43e69SBenjamin Herrenschmidt
43214a43e69SBenjamin Herrenschmidt if (!opal.entry)
433daea1175SBenjamin Herrenschmidt return -ENODEV;
43414a43e69SBenjamin Herrenschmidt opal_poll_events(&evt);
4354f89363bSBenjamin Herrenschmidt if ((be64_to_cpu(evt) & OPAL_EVENT_CONSOLE_INPUT) == 0)
43614a43e69SBenjamin Herrenschmidt return 0;
4374f89363bSBenjamin Herrenschmidt len = cpu_to_be64(count);
43814a43e69SBenjamin Herrenschmidt rc = opal_console_read(vtermno, &len, buf);
43914a43e69SBenjamin Herrenschmidt if (rc == OPAL_SUCCESS)
4404f89363bSBenjamin Herrenschmidt return be64_to_cpu(len);
44114a43e69SBenjamin Herrenschmidt return 0;
44214a43e69SBenjamin Herrenschmidt }
44314a43e69SBenjamin Herrenschmidt
__opal_put_chars(uint32_t vtermno,const char * data,int total_len,bool atomic)44417cc1dd4SNicholas Piggin static int __opal_put_chars(uint32_t vtermno, const char *data, int total_len, bool atomic)
44514a43e69SBenjamin Herrenschmidt {
44617cc1dd4SNicholas Piggin unsigned long flags = 0 /* shut up gcc */;
447b74d2807SNicholas Piggin int written;
448b74d2807SNicholas Piggin __be64 olen;
449b74d2807SNicholas Piggin s64 rc;
45014a43e69SBenjamin Herrenschmidt
45114a43e69SBenjamin Herrenschmidt if (!opal.entry)
452daea1175SBenjamin Herrenschmidt return -ENODEV;
45314a43e69SBenjamin Herrenschmidt
45417cc1dd4SNicholas Piggin if (atomic)
45514a43e69SBenjamin Herrenschmidt spin_lock_irqsave(&opal_write_lock, flags);
4564f89363bSBenjamin Herrenschmidt rc = opal_console_write_buffer_space(vtermno, &olen);
457b74d2807SNicholas Piggin if (rc || be64_to_cpu(olen) < total_len) {
45814a43e69SBenjamin Herrenschmidt /* Closed -> drop characters */
45914a43e69SBenjamin Herrenschmidt if (rc)
460b74d2807SNicholas Piggin written = total_len;
461b74d2807SNicholas Piggin else
462b74d2807SNicholas Piggin written = -EAGAIN;
463b74d2807SNicholas Piggin goto out;
46414a43e69SBenjamin Herrenschmidt }
46514a43e69SBenjamin Herrenschmidt
466b74d2807SNicholas Piggin /* Should not get a partial write here because space is available. */
4674f89363bSBenjamin Herrenschmidt olen = cpu_to_be64(total_len);
4684f89363bSBenjamin Herrenschmidt rc = opal_console_write(vtermno, &olen, data);
469b74d2807SNicholas Piggin if (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
47095b861a7SNicholas Piggin if (rc == OPAL_BUSY_EVENT)
47136d2dabcSNicholas Piggin opal_poll_events(NULL);
472b74d2807SNicholas Piggin written = -EAGAIN;
473b74d2807SNicholas Piggin goto out;
47436d2dabcSNicholas Piggin }
47536d2dabcSNicholas Piggin
4761de1455fSBenjamin Herrenschmidt /* Closed or other error drop */
47736d2dabcSNicholas Piggin if (rc != OPAL_SUCCESS) {
478b74d2807SNicholas Piggin written = opal_error_code(rc);
479b74d2807SNicholas Piggin goto out;
4801de1455fSBenjamin Herrenschmidt }
48136d2dabcSNicholas Piggin
482b74d2807SNicholas Piggin written = be64_to_cpu(olen);
483b74d2807SNicholas Piggin if (written < total_len) {
48417cc1dd4SNicholas Piggin if (atomic) {
485b74d2807SNicholas Piggin /* Should not happen */
48617cc1dd4SNicholas Piggin pr_warn("atomic console write returned partial "
48717cc1dd4SNicholas Piggin "len=%d written=%d\n", total_len, written);
48817cc1dd4SNicholas Piggin }
489b74d2807SNicholas Piggin if (!written)
490b74d2807SNicholas Piggin written = -EAGAIN;
491b74d2807SNicholas Piggin }
492b74d2807SNicholas Piggin
493b74d2807SNicholas Piggin out:
49417cc1dd4SNicholas Piggin if (atomic)
495b74d2807SNicholas Piggin spin_unlock_irqrestore(&opal_write_lock, flags);
49636d2dabcSNicholas Piggin
497d2a2262eSNicholas Piggin return written;
498d2a2262eSNicholas Piggin }
499d2a2262eSNicholas Piggin
opal_put_chars(uint32_t vtermno,const char * data,int total_len)50017cc1dd4SNicholas Piggin int opal_put_chars(uint32_t vtermno, const char *data, int total_len)
50117cc1dd4SNicholas Piggin {
50217cc1dd4SNicholas Piggin return __opal_put_chars(vtermno, data, total_len, false);
50317cc1dd4SNicholas Piggin }
50417cc1dd4SNicholas Piggin
50517cc1dd4SNicholas Piggin /*
50617cc1dd4SNicholas Piggin * opal_put_chars_atomic will not perform partial-writes. Data will be
50717cc1dd4SNicholas Piggin * atomically written to the terminal or not at all. This is not strictly
50817cc1dd4SNicholas Piggin * true at the moment because console space can race with OPAL's console
50917cc1dd4SNicholas Piggin * writes.
51017cc1dd4SNicholas Piggin */
opal_put_chars_atomic(uint32_t vtermno,const char * data,int total_len)51117cc1dd4SNicholas Piggin int opal_put_chars_atomic(uint32_t vtermno, const char *data, int total_len)
51217cc1dd4SNicholas Piggin {
51317cc1dd4SNicholas Piggin return __opal_put_chars(vtermno, data, total_len, true);
51417cc1dd4SNicholas Piggin }
51517cc1dd4SNicholas Piggin
__opal_flush_console(uint32_t vtermno)51695b861a7SNicholas Piggin static s64 __opal_flush_console(uint32_t vtermno)
517d2a2262eSNicholas Piggin {
518d2a2262eSNicholas Piggin s64 rc;
519d2a2262eSNicholas Piggin
520d2a2262eSNicholas Piggin if (!opal_check_token(OPAL_CONSOLE_FLUSH)) {
521d2a2262eSNicholas Piggin __be64 evt;
522d2a2262eSNicholas Piggin
523d2a2262eSNicholas Piggin /*
524d2a2262eSNicholas Piggin * If OPAL_CONSOLE_FLUSH is not implemented in the firmware,
525d2a2262eSNicholas Piggin * the console can still be flushed by calling the polling
526d2a2262eSNicholas Piggin * function while it has OPAL_EVENT_CONSOLE_OUTPUT events.
527d2a2262eSNicholas Piggin */
52895b861a7SNicholas Piggin WARN_ONCE(1, "opal: OPAL_CONSOLE_FLUSH missing.\n");
52995b861a7SNicholas Piggin
53014a43e69SBenjamin Herrenschmidt opal_poll_events(&evt);
53195b861a7SNicholas Piggin if (!(be64_to_cpu(evt) & OPAL_EVENT_CONSOLE_OUTPUT))
532d2a2262eSNicholas Piggin return OPAL_SUCCESS;
53395b861a7SNicholas Piggin return OPAL_BUSY;
534d2a2262eSNicholas Piggin
53595b861a7SNicholas Piggin } else {
536d2a2262eSNicholas Piggin rc = opal_console_flush(vtermno);
537d2a2262eSNicholas Piggin if (rc == OPAL_BUSY_EVENT) {
538d2a2262eSNicholas Piggin opal_poll_events(NULL);
53995b861a7SNicholas Piggin rc = OPAL_BUSY;
540d2a2262eSNicholas Piggin }
54195b861a7SNicholas Piggin return rc;
542d2a2262eSNicholas Piggin }
54395b861a7SNicholas Piggin
54495b861a7SNicholas Piggin }
54595b861a7SNicholas Piggin
54695b861a7SNicholas Piggin /*
54795b861a7SNicholas Piggin * opal_flush_console spins until the console is flushed
54895b861a7SNicholas Piggin */
opal_flush_console(uint32_t vtermno)54995b861a7SNicholas Piggin int opal_flush_console(uint32_t vtermno)
55095b861a7SNicholas Piggin {
55195b861a7SNicholas Piggin for (;;) {
55295b861a7SNicholas Piggin s64 rc = __opal_flush_console(vtermno);
55395b861a7SNicholas Piggin
55495b861a7SNicholas Piggin if (rc == OPAL_BUSY || rc == OPAL_PARTIAL) {
55595b861a7SNicholas Piggin mdelay(1);
55695b861a7SNicholas Piggin continue;
55795b861a7SNicholas Piggin }
558d2a2262eSNicholas Piggin
559d2a2262eSNicholas Piggin return opal_error_code(rc);
56014a43e69SBenjamin Herrenschmidt }
56195b861a7SNicholas Piggin }
56295b861a7SNicholas Piggin
56395b861a7SNicholas Piggin /*
56495b861a7SNicholas Piggin * opal_flush_chars is an hvc interface that sleeps until the console is
56595b861a7SNicholas Piggin * flushed if wait, otherwise it will return -EBUSY if the console has data,
56695b861a7SNicholas Piggin * -EAGAIN if it has data and some of it was flushed.
56795b861a7SNicholas Piggin */
opal_flush_chars(uint32_t vtermno,bool wait)56895b861a7SNicholas Piggin int opal_flush_chars(uint32_t vtermno, bool wait)
56995b861a7SNicholas Piggin {
57095b861a7SNicholas Piggin for (;;) {
57195b861a7SNicholas Piggin s64 rc = __opal_flush_console(vtermno);
57295b861a7SNicholas Piggin
57395b861a7SNicholas Piggin if (rc == OPAL_BUSY || rc == OPAL_PARTIAL) {
57495b861a7SNicholas Piggin if (wait) {
57595b861a7SNicholas Piggin msleep(OPAL_BUSY_DELAY_MS);
57695b861a7SNicholas Piggin continue;
57795b861a7SNicholas Piggin }
57895b861a7SNicholas Piggin if (rc == OPAL_PARTIAL)
57995b861a7SNicholas Piggin return -EAGAIN;
58095b861a7SNicholas Piggin }
58195b861a7SNicholas Piggin
58295b861a7SNicholas Piggin return opal_error_code(rc);
58395b861a7SNicholas Piggin }
58495b861a7SNicholas Piggin }
58514a43e69SBenjamin Herrenschmidt
opal_recover_mce(struct pt_regs * regs,struct machine_check_event * evt)586b63a0ffeSMahesh Salgaonkar static int opal_recover_mce(struct pt_regs *regs,
587b63a0ffeSMahesh Salgaonkar struct machine_check_event *evt)
588b63a0ffeSMahesh Salgaonkar {
589b63a0ffeSMahesh Salgaonkar int recovered = 0;
590b63a0ffeSMahesh Salgaonkar
591806c0e6eSChristophe Leroy if (regs_is_unrecoverable(regs)) {
592b63a0ffeSMahesh Salgaonkar /* If MSR_RI isn't set, we cannot recover */
593c74dd88eSMahesh Salgaonkar pr_err("Machine check interrupt unrecoverable: MSR(RI=0)\n");
594b63a0ffeSMahesh Salgaonkar recovered = 0;
595b63a0ffeSMahesh Salgaonkar } else if (evt->disposition == MCE_DISPOSITION_RECOVERED) {
596b63a0ffeSMahesh Salgaonkar /* Platform corrected itself */
597b63a0ffeSMahesh Salgaonkar recovered = 1;
5981363875bSNicholas Piggin } else if (evt->severity == MCE_SEV_FATAL) {
5991363875bSNicholas Piggin /* Fatal machine check */
6001363875bSNicholas Piggin pr_err("Machine check interrupt is fatal\n");
6011363875bSNicholas Piggin recovered = 0;
6026fcd6baaSNicholas Piggin }
6036fcd6baaSNicholas Piggin
604cda6618dSMahesh Salgaonkar if (!recovered && evt->sync_error) {
605b63a0ffeSMahesh Salgaonkar /*
6066fcd6baaSNicholas Piggin * Try to kill processes if we get a synchronous machine check
6076fcd6baaSNicholas Piggin * (e.g., one caused by execution of this instruction). This
6086fcd6baaSNicholas Piggin * will devolve into a panic if we try to kill init or are in
6096fcd6baaSNicholas Piggin * an interrupt etc.
610b63a0ffeSMahesh Salgaonkar *
611b63a0ffeSMahesh Salgaonkar * TODO: Queue up this address for hwpoisioning later.
6126fcd6baaSNicholas Piggin * TODO: This is not quite right for d-side machine
6136fcd6baaSNicholas Piggin * checks ->nip is not necessarily the important
6146fcd6baaSNicholas Piggin * address.
615b63a0ffeSMahesh Salgaonkar */
6166fcd6baaSNicholas Piggin if ((user_mode(regs))) {
617b63a0ffeSMahesh Salgaonkar _exception(SIGBUS, regs, BUS_MCEERR_AR, regs->nip);
618b63a0ffeSMahesh Salgaonkar recovered = 1;
6196fcd6baaSNicholas Piggin } else if (die_will_crash()) {
6206fcd6baaSNicholas Piggin /*
6216fcd6baaSNicholas Piggin * die() would kill the kernel, so better to go via
6226fcd6baaSNicholas Piggin * the platform reboot code that will log the
6236fcd6baaSNicholas Piggin * machine check.
6246fcd6baaSNicholas Piggin */
6256fcd6baaSNicholas Piggin recovered = 0;
6266fcd6baaSNicholas Piggin } else {
627209e9d50SNicholas Piggin die_mce("Machine check", regs, SIGBUS);
6286fcd6baaSNicholas Piggin recovered = 1;
629b63a0ffeSMahesh Salgaonkar }
6306fcd6baaSNicholas Piggin }
6316fcd6baaSNicholas Piggin
632b63a0ffeSMahesh Salgaonkar return recovered;
633b63a0ffeSMahesh Salgaonkar }
634b63a0ffeSMahesh Salgaonkar
pnv_platform_error_reboot(struct pt_regs * regs,const char * msg)63562dea077SBreno Leitao void __noreturn pnv_platform_error_reboot(struct pt_regs *regs, const char *msg)
636b746e3e0SNicholas Piggin {
63735adacd6SNicholas Piggin panic_flush_kmsg_start();
63835adacd6SNicholas Piggin
639b746e3e0SNicholas Piggin pr_emerg("Hardware platform error: %s\n", msg);
640b746e3e0SNicholas Piggin if (regs)
641b746e3e0SNicholas Piggin show_regs(regs);
642b746e3e0SNicholas Piggin smp_send_stop();
64335adacd6SNicholas Piggin
64435adacd6SNicholas Piggin panic_flush_kmsg_end();
645b746e3e0SNicholas Piggin
646b746e3e0SNicholas Piggin /*
647b746e3e0SNicholas Piggin * Don't bother to shut things down because this will
648b746e3e0SNicholas Piggin * xstop the system.
649b746e3e0SNicholas Piggin */
650b746e3e0SNicholas Piggin if (opal_cec_reboot2(OPAL_REBOOT_PLATFORM_ERROR, msg)
651b746e3e0SNicholas Piggin == OPAL_UNSUPPORTED) {
652b746e3e0SNicholas Piggin pr_emerg("Reboot type %d not supported for %s\n",
653b746e3e0SNicholas Piggin OPAL_REBOOT_PLATFORM_ERROR, msg);
654b746e3e0SNicholas Piggin }
655b746e3e0SNicholas Piggin
656b746e3e0SNicholas Piggin /*
657b746e3e0SNicholas Piggin * We reached here. There can be three possibilities:
658b746e3e0SNicholas Piggin * 1. We are running on a firmware level that do not support
659b746e3e0SNicholas Piggin * opal_cec_reboot2()
660b746e3e0SNicholas Piggin * 2. We are running on a firmware level that do not support
661b746e3e0SNicholas Piggin * OPAL_REBOOT_PLATFORM_ERROR reboot type.
662b746e3e0SNicholas Piggin * 3. We are running on FSP based system that does not need
663b746e3e0SNicholas Piggin * opal to trigger checkstop explicitly for error analysis.
664b746e3e0SNicholas Piggin * The FSP PRD component would have already got notified
665b746e3e0SNicholas Piggin * about this error through other channels.
6665ee573e8SBalbir Singh * 4. We are running on a newer skiboot that by default does
6675ee573e8SBalbir Singh * not cause a checkstop, drops us back to the kernel to
6685ee573e8SBalbir Singh * extract context and state at the time of the error.
669b746e3e0SNicholas Piggin */
670b746e3e0SNicholas Piggin
6715ee573e8SBalbir Singh panic(msg);
672b746e3e0SNicholas Piggin }
673b746e3e0SNicholas Piggin
opal_machine_check(struct pt_regs * regs)674ed79ba9eSBenjamin Herrenschmidt int opal_machine_check(struct pt_regs *regs)
675ed79ba9eSBenjamin Herrenschmidt {
67636df96f8SMahesh Salgaonkar struct machine_check_event evt;
677ed79ba9eSBenjamin Herrenschmidt
67836df96f8SMahesh Salgaonkar if (!get_mce_event(&evt, MCE_EVENT_RELEASE))
67936df96f8SMahesh Salgaonkar return 0;
680ed79ba9eSBenjamin Herrenschmidt
681ed79ba9eSBenjamin Herrenschmidt /* Print things out */
68236df96f8SMahesh Salgaonkar if (evt.version != MCE_V1) {
683ed79ba9eSBenjamin Herrenschmidt pr_err("Machine Check Exception, Unknown event version %d !\n",
684ed79ba9eSBenjamin Herrenschmidt evt.version);
685ed79ba9eSBenjamin Herrenschmidt return 0;
686ed79ba9eSBenjamin Herrenschmidt }
687c0577201SPaul Mackerras machine_check_print_event_info(&evt, user_mode(regs), false);
688ed79ba9eSBenjamin Herrenschmidt
689b63a0ffeSMahesh Salgaonkar if (opal_recover_mce(regs, &evt))
690b63a0ffeSMahesh Salgaonkar return 1;
691e784b649SMahesh Salgaonkar
692b746e3e0SNicholas Piggin pnv_platform_error_reboot(regs, "Unrecoverable Machine Check exception");
693ed79ba9eSBenjamin Herrenschmidt }
694ed79ba9eSBenjamin Herrenschmidt
6950869b6fdSMahesh Salgaonkar /* Early hmi handler called in real mode. */
opal_hmi_exception_early(struct pt_regs * regs)6960869b6fdSMahesh Salgaonkar int opal_hmi_exception_early(struct pt_regs *regs)
6970869b6fdSMahesh Salgaonkar {
6980ef95b41SMahesh Salgaonkar s64 rc;
6990ef95b41SMahesh Salgaonkar
7000ef95b41SMahesh Salgaonkar /*
7010ef95b41SMahesh Salgaonkar * call opal hmi handler. Pass paca address as token.
7020ef95b41SMahesh Salgaonkar * The return value OPAL_SUCCESS is an indication that there is
7030ef95b41SMahesh Salgaonkar * an HMI event generated waiting to pull by Linux.
7040ef95b41SMahesh Salgaonkar */
7050ef95b41SMahesh Salgaonkar rc = opal_handle_hmi();
7060ef95b41SMahesh Salgaonkar if (rc == OPAL_SUCCESS) {
7070ef95b41SMahesh Salgaonkar local_paca->hmi_event_available = 1;
7080ef95b41SMahesh Salgaonkar return 1;
7090ef95b41SMahesh Salgaonkar }
7100869b6fdSMahesh Salgaonkar return 0;
7110869b6fdSMahesh Salgaonkar }
7120869b6fdSMahesh Salgaonkar
opal_hmi_exception_early2(struct pt_regs * regs)713de269129SMahesh Salgaonkar int opal_hmi_exception_early2(struct pt_regs *regs)
714de269129SMahesh Salgaonkar {
715de269129SMahesh Salgaonkar s64 rc;
716de269129SMahesh Salgaonkar __be64 out_flags;
717de269129SMahesh Salgaonkar
718de269129SMahesh Salgaonkar /*
719de269129SMahesh Salgaonkar * call opal hmi handler.
720de269129SMahesh Salgaonkar * Check 64-bit flag mask to find out if an event was generated,
721de269129SMahesh Salgaonkar * and whether TB is still valid or not etc.
722de269129SMahesh Salgaonkar */
723de269129SMahesh Salgaonkar rc = opal_handle_hmi2(&out_flags);
724de269129SMahesh Salgaonkar if (rc != OPAL_SUCCESS)
725de269129SMahesh Salgaonkar return 0;
726de269129SMahesh Salgaonkar
727de269129SMahesh Salgaonkar if (be64_to_cpu(out_flags) & OPAL_HMI_FLAGS_NEW_EVENT)
728de269129SMahesh Salgaonkar local_paca->hmi_event_available = 1;
729de269129SMahesh Salgaonkar if (be64_to_cpu(out_flags) & OPAL_HMI_FLAGS_TOD_TB_FAIL)
730de269129SMahesh Salgaonkar tb_invalid = true;
731de269129SMahesh Salgaonkar return 1;
732de269129SMahesh Salgaonkar }
733de269129SMahesh Salgaonkar
73459d512e4SNicholas Piggin /* HMI exception handler called in virtual mode when irqs are next enabled. */
opal_handle_hmi_exception(struct pt_regs * regs)7350869b6fdSMahesh Salgaonkar int opal_handle_hmi_exception(struct pt_regs *regs)
7360869b6fdSMahesh Salgaonkar {
7370ef95b41SMahesh Salgaonkar /*
7380ef95b41SMahesh Salgaonkar * Check if HMI event is available.
73956c0b48bSNicholas Piggin * if Yes, then wake kopald to process them.
7400ef95b41SMahesh Salgaonkar */
7410ef95b41SMahesh Salgaonkar if (!local_paca->hmi_event_available)
7420869b6fdSMahesh Salgaonkar return 0;
7430ef95b41SMahesh Salgaonkar
7440ef95b41SMahesh Salgaonkar local_paca->hmi_event_available = 0;
74556c0b48bSNicholas Piggin opal_wake_poller();
7460ef95b41SMahesh Salgaonkar
7470ef95b41SMahesh Salgaonkar return 1;
7480869b6fdSMahesh Salgaonkar }
7490869b6fdSMahesh Salgaonkar
find_recovery_address(uint64_t nip)75055672ecfSMahesh Salgaonkar static uint64_t find_recovery_address(uint64_t nip)
75155672ecfSMahesh Salgaonkar {
75255672ecfSMahesh Salgaonkar int i;
75355672ecfSMahesh Salgaonkar
75455672ecfSMahesh Salgaonkar for (i = 0; i < mc_recoverable_range_len; i++)
75555672ecfSMahesh Salgaonkar if ((nip >= mc_recoverable_range[i].start_addr) &&
75655672ecfSMahesh Salgaonkar (nip < mc_recoverable_range[i].end_addr))
75755672ecfSMahesh Salgaonkar return mc_recoverable_range[i].recover_addr;
75855672ecfSMahesh Salgaonkar return 0;
75955672ecfSMahesh Salgaonkar }
76055672ecfSMahesh Salgaonkar
opal_mce_check_early_recovery(struct pt_regs * regs)76155672ecfSMahesh Salgaonkar bool opal_mce_check_early_recovery(struct pt_regs *regs)
76255672ecfSMahesh Salgaonkar {
76355672ecfSMahesh Salgaonkar uint64_t recover_addr = 0;
76455672ecfSMahesh Salgaonkar
76555672ecfSMahesh Salgaonkar if (!opal.base || !opal.size)
76655672ecfSMahesh Salgaonkar goto out;
76755672ecfSMahesh Salgaonkar
76855672ecfSMahesh Salgaonkar if ((regs->nip >= opal.base) &&
769dc3799bbSAndrew Donnellan (regs->nip < (opal.base + opal.size)))
77055672ecfSMahesh Salgaonkar recover_addr = find_recovery_address(regs->nip);
77155672ecfSMahesh Salgaonkar
77255672ecfSMahesh Salgaonkar /*
77355672ecfSMahesh Salgaonkar * Setup regs->nip to rfi into fixup address.
77455672ecfSMahesh Salgaonkar */
77555672ecfSMahesh Salgaonkar if (recover_addr)
77659dc5bfcSNicholas Piggin regs_set_return_ip(regs, recover_addr);
77755672ecfSMahesh Salgaonkar
77855672ecfSMahesh Salgaonkar out:
77955672ecfSMahesh Salgaonkar return !!recover_addr;
78055672ecfSMahesh Salgaonkar }
78155672ecfSMahesh Salgaonkar
opal_sysfs_init(void)782e5913db1SNick Child static int __init opal_sysfs_init(void)
7836f68b5e2SVasant Hegde {
7846f68b5e2SVasant Hegde opal_kobj = kobject_create_and_add("opal", firmware_kobj);
7856f68b5e2SVasant Hegde if (!opal_kobj) {
7866f68b5e2SVasant Hegde pr_warn("kobject_create_and_add opal failed\n");
7876f68b5e2SVasant Hegde return -ENOMEM;
7886f68b5e2SVasant Hegde }
7896f68b5e2SVasant Hegde
7906f68b5e2SVasant Hegde return 0;
7916f68b5e2SVasant Hegde }
7926f68b5e2SVasant Hegde
export_attr_read(struct file * fp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)79311fe909dSMatt Brown static ssize_t export_attr_read(struct file *fp, struct kobject *kobj,
79411fe909dSMatt Brown struct bin_attribute *bin_attr, char *buf,
79511fe909dSMatt Brown loff_t off, size_t count)
79611fe909dSMatt Brown {
79711fe909dSMatt Brown return memory_read_from_buffer(buf, count, &off, bin_attr->private,
79811fe909dSMatt Brown bin_attr->size);
79911fe909dSMatt Brown }
80011fe909dSMatt Brown
opal_add_one_export(struct kobject * parent,const char * export_name,struct device_node * np,const char * prop_name)801db933612SOliver O'Halloran static int opal_add_one_export(struct kobject *parent, const char *export_name,
802db933612SOliver O'Halloran struct device_node *np, const char *prop_name)
803db933612SOliver O'Halloran {
804db933612SOliver O'Halloran struct bin_attribute *attr = NULL;
805db933612SOliver O'Halloran const char *name = NULL;
806db933612SOliver O'Halloran u64 vals[2];
807db933612SOliver O'Halloran int rc;
808db933612SOliver O'Halloran
809db933612SOliver O'Halloran rc = of_property_read_u64_array(np, prop_name, &vals[0], 2);
810db933612SOliver O'Halloran if (rc)
811db933612SOliver O'Halloran goto out;
812db933612SOliver O'Halloran
813db933612SOliver O'Halloran attr = kzalloc(sizeof(*attr), GFP_KERNEL);
814ceffa63aSChen Zhou if (!attr) {
815ceffa63aSChen Zhou rc = -ENOMEM;
816ceffa63aSChen Zhou goto out;
817ceffa63aSChen Zhou }
818db933612SOliver O'Halloran name = kstrdup(export_name, GFP_KERNEL);
819db933612SOliver O'Halloran if (!name) {
820db933612SOliver O'Halloran rc = -ENOMEM;
821db933612SOliver O'Halloran goto out;
822db933612SOliver O'Halloran }
823db933612SOliver O'Halloran
824db933612SOliver O'Halloran sysfs_bin_attr_init(attr);
825db933612SOliver O'Halloran attr->attr.name = name;
826db933612SOliver O'Halloran attr->attr.mode = 0400;
827db933612SOliver O'Halloran attr->read = export_attr_read;
828db933612SOliver O'Halloran attr->private = __va(vals[0]);
829db933612SOliver O'Halloran attr->size = vals[1];
830db933612SOliver O'Halloran
831db933612SOliver O'Halloran rc = sysfs_create_bin_file(parent, attr);
832db933612SOliver O'Halloran out:
833db933612SOliver O'Halloran if (rc) {
834db933612SOliver O'Halloran kfree(name);
835db933612SOliver O'Halloran kfree(attr);
836db933612SOliver O'Halloran }
837db933612SOliver O'Halloran
838db933612SOliver O'Halloran return rc;
839db933612SOliver O'Halloran }
840db933612SOliver O'Halloran
opal_add_exported_attrs(struct device_node * np,struct kobject * kobj)841db933612SOliver O'Halloran static void opal_add_exported_attrs(struct device_node *np,
842db933612SOliver O'Halloran struct kobject *kobj)
843db933612SOliver O'Halloran {
844db933612SOliver O'Halloran struct device_node *child;
845db933612SOliver O'Halloran struct property *prop;
846db933612SOliver O'Halloran
847db933612SOliver O'Halloran for_each_property_of_node(np, prop) {
848db933612SOliver O'Halloran int rc;
849db933612SOliver O'Halloran
850db933612SOliver O'Halloran if (!strcmp(prop->name, "name") ||
851db933612SOliver O'Halloran !strcmp(prop->name, "phandle"))
852db933612SOliver O'Halloran continue;
853db933612SOliver O'Halloran
854db933612SOliver O'Halloran rc = opal_add_one_export(kobj, prop->name, np, prop->name);
855db933612SOliver O'Halloran if (rc) {
856db933612SOliver O'Halloran pr_warn("Unable to add export %pOF/%s, rc = %d!\n",
857db933612SOliver O'Halloran np, prop->name, rc);
858db933612SOliver O'Halloran }
859db933612SOliver O'Halloran }
860db933612SOliver O'Halloran
861db933612SOliver O'Halloran for_each_child_of_node(np, child) {
862db933612SOliver O'Halloran struct kobject *child_kobj;
863db933612SOliver O'Halloran
864db933612SOliver O'Halloran child_kobj = kobject_create_and_add(child->name, kobj);
865db933612SOliver O'Halloran if (!child_kobj) {
866db933612SOliver O'Halloran pr_err("Unable to create export dir for %pOF\n", child);
867db933612SOliver O'Halloran continue;
868db933612SOliver O'Halloran }
869db933612SOliver O'Halloran
870db933612SOliver O'Halloran opal_add_exported_attrs(child, child_kobj);
871db933612SOliver O'Halloran }
872db933612SOliver O'Halloran }
873db933612SOliver O'Halloran
87411fe909dSMatt Brown /*
87511fe909dSMatt Brown * opal_export_attrs: creates a sysfs node for each property listed in
87611fe909dSMatt Brown * the device-tree under /ibm,opal/firmware/exports/
87711fe909dSMatt Brown * All new sysfs nodes are created under /opal/exports/.
87811fe909dSMatt Brown * This allows for reserved memory regions (e.g. HDAT) to be read.
87911fe909dSMatt Brown * The new sysfs nodes are only readable by root.
88011fe909dSMatt Brown */
opal_export_attrs(void)88111fe909dSMatt Brown static void opal_export_attrs(void)
88211fe909dSMatt Brown {
88311fe909dSMatt Brown struct device_node *np;
88411fe909dSMatt Brown struct kobject *kobj;
885846a17a5SOliver O'Halloran int rc;
88611fe909dSMatt Brown
88711fe909dSMatt Brown np = of_find_node_by_path("/ibm,opal/firmware/exports");
88811fe909dSMatt Brown if (!np)
88911fe909dSMatt Brown return;
89011fe909dSMatt Brown
89111fe909dSMatt Brown /* Create new 'exports' directory - /sys/firmware/opal/exports */
89211fe909dSMatt Brown kobj = kobject_create_and_add("exports", opal_kobj);
89311fe909dSMatt Brown if (!kobj) {
89411fe909dSMatt Brown pr_warn("kobject_create_and_add() of exports failed\n");
895*71a92e99SZheng Yongjun of_node_put(np);
89611fe909dSMatt Brown return;
89711fe909dSMatt Brown }
89811fe909dSMatt Brown
899db933612SOliver O'Halloran opal_add_exported_attrs(np, kobj);
90011fe909dSMatt Brown
901846a17a5SOliver O'Halloran /*
902846a17a5SOliver O'Halloran * NB: symbol_map existed before the generic export interface so it
903846a17a5SOliver O'Halloran * lives under the top level opal_kobj.
904846a17a5SOliver O'Halloran */
905846a17a5SOliver O'Halloran rc = opal_add_one_export(opal_kobj, "symbol_map",
906846a17a5SOliver O'Halloran np->parent, "symbol-map");
907846a17a5SOliver O'Halloran if (rc)
908846a17a5SOliver O'Halloran pr_warn("Error %d creating OPAL symbols file\n", rc);
909846a17a5SOliver O'Halloran
91011fe909dSMatt Brown of_node_put(np);
91111fe909dSMatt Brown }
91211fe909dSMatt Brown
opal_dump_region_init(void)913b09c2ec4SVasant Hegde static void __init opal_dump_region_init(void)
914b09c2ec4SVasant Hegde {
915b09c2ec4SVasant Hegde void *addr;
916b09c2ec4SVasant Hegde uint64_t size;
917b09c2ec4SVasant Hegde int rc;
918b09c2ec4SVasant Hegde
919b962f5a4SStewart Smith if (!opal_check_token(OPAL_REGISTER_DUMP_REGION))
920b962f5a4SStewart Smith return;
921b962f5a4SStewart Smith
922b09c2ec4SVasant Hegde /* Register kernel log buffer */
923b09c2ec4SVasant Hegde addr = log_buf_addr_get();
9246501ab5eSPranith Kumar if (addr == NULL)
9256501ab5eSPranith Kumar return;
9266501ab5eSPranith Kumar
927b09c2ec4SVasant Hegde size = log_buf_len_get();
9286501ab5eSPranith Kumar if (size == 0)
9296501ab5eSPranith Kumar return;
9306501ab5eSPranith Kumar
931b09c2ec4SVasant Hegde rc = opal_register_dump_region(OPAL_DUMP_REGION_LOG_BUF,
932b09c2ec4SVasant Hegde __pa(addr), size);
933b09c2ec4SVasant Hegde /* Don't warn if this is just an older OPAL that doesn't
934b09c2ec4SVasant Hegde * know about that call
935b09c2ec4SVasant Hegde */
936b09c2ec4SVasant Hegde if (rc && rc != OPAL_UNSUPPORTED)
937b09c2ec4SVasant Hegde pr_warn("DUMP: Failed to register kernel log buffer. "
938b09c2ec4SVasant Hegde "rc = %d\n", rc);
939b09c2ec4SVasant Hegde }
940608b286dSJeremy Kerr
opal_pdev_init(const char * compatible)941e5913db1SNick Child static void __init opal_pdev_init(const char *compatible)
942ed59190eSCyril Bur {
943ed59190eSCyril Bur struct device_node *np;
944ed59190eSCyril Bur
9459e4f51bdSJack Miller for_each_compatible_node(np, NULL, compatible)
94647083450SNeelesh Gupta of_platform_device_create(np, NULL, NULL);
94747083450SNeelesh Gupta }
94847083450SNeelesh Gupta
opal_imc_init_dev(void)9498f95faaaSMadhavan Srinivasan static void __init opal_imc_init_dev(void)
9508f95faaaSMadhavan Srinivasan {
9518f95faaaSMadhavan Srinivasan struct device_node *np;
9528f95faaaSMadhavan Srinivasan
9538f95faaaSMadhavan Srinivasan np = of_find_compatible_node(NULL, NULL, IMC_DTB_COMPAT);
9548f95faaaSMadhavan Srinivasan if (np)
9558f95faaaSMadhavan Srinivasan of_platform_device_create(np, NULL, NULL);
956605c27f3SLiang He
957605c27f3SLiang He of_node_put(np);
9588f95faaaSMadhavan Srinivasan }
9598f95faaaSMadhavan Srinivasan
kopald(void * unused)9603bf57561SBenjamin Herrenschmidt static int kopald(void *unused)
9613bf57561SBenjamin Herrenschmidt {
962a203658bSBenjamin Herrenschmidt unsigned long timeout = msecs_to_jiffies(opal_heartbeat) + 1;
9639f0fd049SAlistair Popple
9643bf57561SBenjamin Herrenschmidt set_freezable();
9653bf57561SBenjamin Herrenschmidt do {
9663bf57561SBenjamin Herrenschmidt try_to_freeze();
96756c0b48bSNicholas Piggin
96856c0b48bSNicholas Piggin opal_handle_events();
96956c0b48bSNicholas Piggin
97056c0b48bSNicholas Piggin set_current_state(TASK_INTERRUPTIBLE);
97156c0b48bSNicholas Piggin if (opal_have_pending_events())
97256c0b48bSNicholas Piggin __set_current_state(TASK_RUNNING);
97356c0b48bSNicholas Piggin else
97456c0b48bSNicholas Piggin schedule_timeout(timeout);
97556c0b48bSNicholas Piggin
9763bf57561SBenjamin Herrenschmidt } while (!kthread_should_stop());
9773bf57561SBenjamin Herrenschmidt
9783bf57561SBenjamin Herrenschmidt return 0;
9793bf57561SBenjamin Herrenschmidt }
9803bf57561SBenjamin Herrenschmidt
opal_wake_poller(void)981a203658bSBenjamin Herrenschmidt void opal_wake_poller(void)
982a203658bSBenjamin Herrenschmidt {
983a203658bSBenjamin Herrenschmidt if (kopald_tsk)
984a203658bSBenjamin Herrenschmidt wake_up_process(kopald_tsk);
985a203658bSBenjamin Herrenschmidt }
986a203658bSBenjamin Herrenschmidt
opal_init_heartbeat(void)987e5913db1SNick Child static void __init opal_init_heartbeat(void)
9883bf57561SBenjamin Herrenschmidt {
9893bf57561SBenjamin Herrenschmidt /* Old firwmware, we assume the HVC heartbeat is sufficient */
9903bf57561SBenjamin Herrenschmidt if (of_property_read_u32(opal_node, "ibm,heartbeat-ms",
9913bf57561SBenjamin Herrenschmidt &opal_heartbeat) != 0)
9923bf57561SBenjamin Herrenschmidt opal_heartbeat = 0;
9933bf57561SBenjamin Herrenschmidt
9943bf57561SBenjamin Herrenschmidt if (opal_heartbeat)
995a203658bSBenjamin Herrenschmidt kopald_tsk = kthread_run(kopald, NULL, "kopald");
9963bf57561SBenjamin Herrenschmidt }
9973bf57561SBenjamin Herrenschmidt
opal_init(void)99814a43e69SBenjamin Herrenschmidt static int __init opal_init(void)
99914a43e69SBenjamin Herrenschmidt {
1000c159b596SVasant Hegde struct device_node *np, *consoles, *leds;
1001c1c3a526SGavin Shan int rc;
100214a43e69SBenjamin Herrenschmidt
100314a43e69SBenjamin Herrenschmidt opal_node = of_find_node_by_path("/ibm,opal");
100414a43e69SBenjamin Herrenschmidt if (!opal_node) {
100508135139SMichael Ellerman pr_warn("Device node not found\n");
100614a43e69SBenjamin Herrenschmidt return -ENODEV;
100714a43e69SBenjamin Herrenschmidt }
10082db29d28SBenjamin Herrenschmidt
10092db29d28SBenjamin Herrenschmidt /* Register OPAL consoles if any ports */
101014a43e69SBenjamin Herrenschmidt consoles = of_find_node_by_path("/ibm,opal/consoles");
10112db29d28SBenjamin Herrenschmidt if (consoles) {
101214a43e69SBenjamin Herrenschmidt for_each_child_of_node(consoles, np) {
10132c8e65b5SRob Herring if (!of_node_name_eq(np, "serial"))
101414a43e69SBenjamin Herrenschmidt continue;
101514a43e69SBenjamin Herrenschmidt of_platform_device_create(np, NULL, NULL);
101614a43e69SBenjamin Herrenschmidt }
101714a43e69SBenjamin Herrenschmidt of_node_put(consoles);
10182db29d28SBenjamin Herrenschmidt }
1019a125e092SBenjamin Herrenschmidt
102096e023e7SAlistair Popple /* Initialise OPAL messaging system */
10212be1d5d1SVasant Hegde opal_message_init(opal_node);
102296e023e7SAlistair Popple
102396e023e7SAlistair Popple /* Initialise OPAL asynchronous completion interface */
102496e023e7SAlistair Popple opal_async_comp_init();
102596e023e7SAlistair Popple
102696e023e7SAlistair Popple /* Initialise OPAL sensor interface */
102796e023e7SAlistair Popple opal_sensor_init();
102896e023e7SAlistair Popple
102996e023e7SAlistair Popple /* Initialise OPAL hypervisor maintainence interrupt handling */
103096e023e7SAlistair Popple opal_hmi_handler_init();
103196e023e7SAlistair Popple
103247083450SNeelesh Gupta /* Create i2c platform devices */
10339e4f51bdSJack Miller opal_pdev_init("ibm,opal-i2c");
103447083450SNeelesh Gupta
10353013e173SOliver O'Halloran /* Handle non-volatile memory devices */
10363013e173SOliver O'Halloran opal_pdev_init("pmem-region");
10373013e173SOliver O'Halloran
10383bf57561SBenjamin Herrenschmidt /* Setup a heatbeat thread if requested by OPAL */
10393bf57561SBenjamin Herrenschmidt opal_init_heartbeat();
10403bf57561SBenjamin Herrenschmidt
10418f95faaaSMadhavan Srinivasan /* Detect In-Memory Collection counters and create devices*/
10428f95faaaSMadhavan Srinivasan opal_imc_init_dev();
10438f95faaaSMadhavan Srinivasan
1044c159b596SVasant Hegde /* Create leds platform devices */
1045c159b596SVasant Hegde leds = of_find_node_by_path("/ibm,opal/leds");
1046c159b596SVasant Hegde if (leds) {
1047c159b596SVasant Hegde of_platform_device_create(leds, "opal_leds", NULL);
1048c159b596SVasant Hegde of_node_put(leds);
1049c159b596SVasant Hegde }
1050c159b596SVasant Hegde
10519b4fffa1SAndrew Donnellan /* Initialise OPAL message log interface */
10529b4fffa1SAndrew Donnellan opal_msglog_init();
10539b4fffa1SAndrew Donnellan
10546f68b5e2SVasant Hegde /* Create "opal" kobject under /sys/firmware */
10556f68b5e2SVasant Hegde rc = opal_sysfs_init();
105650bd6153SVasant Hegde if (rc == 0) {
1057b09c2ec4SVasant Hegde /* Setup dump region interface */
1058b09c2ec4SVasant Hegde opal_dump_region_init();
1059774fea1aSStewart Smith /* Setup error log interface */
1060774fea1aSStewart Smith rc = opal_elog_init();
106150bd6153SVasant Hegde /* Setup code update interface */
1062ed59190eSCyril Bur opal_flash_update_init();
1063c7e64b9cSStewart Smith /* Setup platform dump extract interface */
1064c7e64b9cSStewart Smith opal_platform_dump_init();
10654029cd66SNeelesh Gupta /* Setup system parameters interface */
10664029cd66SNeelesh Gupta opal_sys_param_init();
10679b4fffa1SAndrew Donnellan /* Setup message log sysfs interface. */
10689b4fffa1SAndrew Donnellan opal_msglog_sysfs_init();
1069db933612SOliver O'Halloran /* Add all export properties*/
107011fe909dSMatt Brown opal_export_attrs();
1071db933612SOliver O'Halloran }
107211fe909dSMatt Brown
10730d7cd855SJeremy Kerr /* Initialize platform devices: IPMI backend, PRD & flash interface */
10749e4f51bdSJack Miller opal_pdev_init("ibm,opal-ipmi");
10759e4f51bdSJack Miller opal_pdev_init("ibm,opal-flash");
10769e4f51bdSJack Miller opal_pdev_init("ibm,opal-prd");
1077ed59190eSCyril Bur
107843a1dd9bSSuraj Jitindar Singh /* Initialise platform device: oppanel interface */
10799e4f51bdSJack Miller opal_pdev_init("ibm,opal-oppanel");
108043a1dd9bSSuraj Jitindar Singh
1081affddff6SRussell Currey /* Initialise OPAL kmsg dumper for flushing console on panic */
1082affddff6SRussell Currey opal_kmsg_init();
1083affddff6SRussell Currey
1084cb8b340dSShilpasri G Bhat /* Initialise OPAL powercap interface */
1085cb8b340dSShilpasri G Bhat opal_powercap_init();
1086cb8b340dSShilpasri G Bhat
10878e84b2d1SShilpasri G Bhat /* Initialise OPAL Power-Shifting-Ratio interface */
10888e84b2d1SShilpasri G Bhat opal_psr_init();
10898e84b2d1SShilpasri G Bhat
1090bf957155SShilpasri G Bhat /* Initialise OPAL sensor groups */
1091bf957155SShilpasri G Bhat opal_sensor_groups_init();
1092bf957155SShilpasri G Bhat
109308fb726dSMahesh Salgaonkar /* Initialise OPAL Power control interface */
109408fb726dSMahesh Salgaonkar opal_power_control_init();
109508fb726dSMahesh Salgaonkar
10969155e234SNayna Jain /* Initialize OPAL secure variables */
10979155e234SNayna Jain opal_pdev_init("ibm,secvar-backend");
10989155e234SNayna Jain
109914a43e69SBenjamin Herrenschmidt return 0;
110014a43e69SBenjamin Herrenschmidt }
1101b14726c5SMichael Ellerman machine_subsys_initcall(powernv, opal_init);
110273ed148aSBenjamin Herrenschmidt
opal_shutdown(void)110373ed148aSBenjamin Herrenschmidt void opal_shutdown(void)
110473ed148aSBenjamin Herrenschmidt {
1105f7d98d18SVasant Hegde long rc = OPAL_BUSY;
110673ed148aSBenjamin Herrenschmidt
11079f0fd049SAlistair Popple opal_event_shutdown();
1108f7d98d18SVasant Hegde
1109f7d98d18SVasant Hegde /*
1110f7d98d18SVasant Hegde * Then sync with OPAL which ensure anything that can
1111f7d98d18SVasant Hegde * potentially write to our memory has completed such
1112f7d98d18SVasant Hegde * as an ongoing dump retrieval
1113f7d98d18SVasant Hegde */
1114f7d98d18SVasant Hegde while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
1115f7d98d18SVasant Hegde rc = opal_sync_host_reboot();
1116f7d98d18SVasant Hegde if (rc == OPAL_BUSY)
1117f7d98d18SVasant Hegde opal_poll_events(NULL);
1118f7d98d18SVasant Hegde else
1119f7d98d18SVasant Hegde mdelay(10);
1120f7d98d18SVasant Hegde }
1121b09c2ec4SVasant Hegde
1122b09c2ec4SVasant Hegde /* Unregister memory dump region */
1123b962f5a4SStewart Smith if (opal_check_token(OPAL_UNREGISTER_DUMP_REGION))
1124b09c2ec4SVasant Hegde opal_unregister_dump_region(OPAL_DUMP_REGION_LOG_BUF);
112573ed148aSBenjamin Herrenschmidt }
1126e28b05e7SJoel Stanley
1127e28b05e7SJoel Stanley /* Export this so that test modules can use it */
1128e28b05e7SJoel Stanley EXPORT_SYMBOL_GPL(opal_invalid_call);
1129594fcb9eSJeremy Kerr EXPORT_SYMBOL_GPL(opal_xscom_read);
1130594fcb9eSJeremy Kerr EXPORT_SYMBOL_GPL(opal_xscom_write);
1131608b286dSJeremy Kerr EXPORT_SYMBOL_GPL(opal_ipmi_send);
1132608b286dSJeremy Kerr EXPORT_SYMBOL_GPL(opal_ipmi_recv);
1133ed59190eSCyril Bur EXPORT_SYMBOL_GPL(opal_flash_read);
1134ed59190eSCyril Bur EXPORT_SYMBOL_GPL(opal_flash_write);
1135ed59190eSCyril Bur EXPORT_SYMBOL_GPL(opal_flash_erase);
11360d7cd855SJeremy Kerr EXPORT_SYMBOL_GPL(opal_prd_msg);
11376e708000SHaren Myneni EXPORT_SYMBOL_GPL(opal_check_token);
11383441f04bSAnton Blanchard
11393441f04bSAnton Blanchard /* Convert a region of vmalloc memory to an opal sg list */
opal_vmalloc_to_sg_list(void * vmalloc_addr,unsigned long vmalloc_size)11403441f04bSAnton Blanchard struct opal_sg_list *opal_vmalloc_to_sg_list(void *vmalloc_addr,
11413441f04bSAnton Blanchard unsigned long vmalloc_size)
11423441f04bSAnton Blanchard {
11433441f04bSAnton Blanchard struct opal_sg_list *sg, *first = NULL;
11443441f04bSAnton Blanchard unsigned long i = 0;
11453441f04bSAnton Blanchard
11463441f04bSAnton Blanchard sg = kzalloc(PAGE_SIZE, GFP_KERNEL);
11473441f04bSAnton Blanchard if (!sg)
11483441f04bSAnton Blanchard goto nomem;
11493441f04bSAnton Blanchard
11503441f04bSAnton Blanchard first = sg;
11513441f04bSAnton Blanchard
11523441f04bSAnton Blanchard while (vmalloc_size > 0) {
11533441f04bSAnton Blanchard uint64_t data = vmalloc_to_pfn(vmalloc_addr) << PAGE_SHIFT;
11543441f04bSAnton Blanchard uint64_t length = min(vmalloc_size, PAGE_SIZE);
11553441f04bSAnton Blanchard
11563441f04bSAnton Blanchard sg->entry[i].data = cpu_to_be64(data);
11573441f04bSAnton Blanchard sg->entry[i].length = cpu_to_be64(length);
11583441f04bSAnton Blanchard i++;
11593441f04bSAnton Blanchard
11603441f04bSAnton Blanchard if (i >= SG_ENTRIES_PER_NODE) {
11613441f04bSAnton Blanchard struct opal_sg_list *next;
11623441f04bSAnton Blanchard
11633441f04bSAnton Blanchard next = kzalloc(PAGE_SIZE, GFP_KERNEL);
11643441f04bSAnton Blanchard if (!next)
11653441f04bSAnton Blanchard goto nomem;
11663441f04bSAnton Blanchard
11673441f04bSAnton Blanchard sg->length = cpu_to_be64(
11683441f04bSAnton Blanchard i * sizeof(struct opal_sg_entry) + 16);
11693441f04bSAnton Blanchard i = 0;
11703441f04bSAnton Blanchard sg->next = cpu_to_be64(__pa(next));
11713441f04bSAnton Blanchard sg = next;
11723441f04bSAnton Blanchard }
11733441f04bSAnton Blanchard
11743441f04bSAnton Blanchard vmalloc_addr += length;
11753441f04bSAnton Blanchard vmalloc_size -= length;
11763441f04bSAnton Blanchard }
11773441f04bSAnton Blanchard
11783441f04bSAnton Blanchard sg->length = cpu_to_be64(i * sizeof(struct opal_sg_entry) + 16);
11793441f04bSAnton Blanchard
11803441f04bSAnton Blanchard return first;
11813441f04bSAnton Blanchard
11823441f04bSAnton Blanchard nomem:
11833441f04bSAnton Blanchard pr_err("%s : Failed to allocate memory\n", __func__);
11843441f04bSAnton Blanchard opal_free_sg_list(first);
11853441f04bSAnton Blanchard return NULL;
11863441f04bSAnton Blanchard }
11873441f04bSAnton Blanchard
opal_free_sg_list(struct opal_sg_list * sg)11883441f04bSAnton Blanchard void opal_free_sg_list(struct opal_sg_list *sg)
11893441f04bSAnton Blanchard {
11903441f04bSAnton Blanchard while (sg) {
11913441f04bSAnton Blanchard uint64_t next = be64_to_cpu(sg->next);
11923441f04bSAnton Blanchard
11933441f04bSAnton Blanchard kfree(sg);
11943441f04bSAnton Blanchard
11953441f04bSAnton Blanchard if (next)
11963441f04bSAnton Blanchard sg = __va(next);
11973441f04bSAnton Blanchard else
11983441f04bSAnton Blanchard sg = NULL;
11993441f04bSAnton Blanchard }
12003441f04bSAnton Blanchard }
120116b1d26eSNeelesh Gupta
opal_error_code(int rc)1202e3c5c2e0SCédric Le Goater int opal_error_code(int rc)
1203e3c5c2e0SCédric Le Goater {
1204e3c5c2e0SCédric Le Goater switch (rc) {
1205e3c5c2e0SCédric Le Goater case OPAL_SUCCESS: return 0;
1206e3c5c2e0SCédric Le Goater
1207e3c5c2e0SCédric Le Goater case OPAL_PARAMETER: return -EINVAL;
1208e3c5c2e0SCédric Le Goater case OPAL_ASYNC_COMPLETION: return -EINPROGRESS;
120977adbd22SCyril Bur case OPAL_BUSY:
1210e3c5c2e0SCédric Le Goater case OPAL_BUSY_EVENT: return -EBUSY;
1211e3c5c2e0SCédric Le Goater case OPAL_NO_MEM: return -ENOMEM;
121214aae78fSCédric Le Goater case OPAL_PERMISSION: return -EPERM;
1213e3c5c2e0SCédric Le Goater
1214e3c5c2e0SCédric Le Goater case OPAL_UNSUPPORTED: return -EIO;
1215e3c5c2e0SCédric Le Goater case OPAL_HARDWARE: return -EIO;
1216e3c5c2e0SCédric Le Goater case OPAL_INTERNAL_ERROR: return -EIO;
1217cb8b340dSShilpasri G Bhat case OPAL_TIMEOUT: return -ETIMEDOUT;
1218e3c5c2e0SCédric Le Goater default:
1219e3c5c2e0SCédric Le Goater pr_err("%s: unexpected OPAL error %d\n", __func__, rc);
1220e3c5c2e0SCédric Le Goater return -EIO;
1221e3c5c2e0SCédric Le Goater }
1222e3c5c2e0SCédric Le Goater }
1223e3c5c2e0SCédric Le Goater
powernv_set_nmmu_ptcr(unsigned long ptcr)12241d0761d2SAlistair Popple void powernv_set_nmmu_ptcr(unsigned long ptcr)
12251d0761d2SAlistair Popple {
12261d0761d2SAlistair Popple int rc;
12271d0761d2SAlistair Popple
12281d0761d2SAlistair Popple if (firmware_has_feature(FW_FEATURE_OPAL)) {
12291d0761d2SAlistair Popple rc = opal_nmmu_set_ptcr(-1UL, ptcr);
12301d0761d2SAlistair Popple if (rc != OPAL_SUCCESS && rc != OPAL_UNSUPPORTED)
12311d0761d2SAlistair Popple pr_warn("%s: Unable to set nest mmu ptcr\n", __func__);
12321d0761d2SAlistair Popple }
12331d0761d2SAlistair Popple }
12341d0761d2SAlistair Popple
123516b1d26eSNeelesh Gupta EXPORT_SYMBOL_GPL(opal_poll_events);
123616b1d26eSNeelesh Gupta EXPORT_SYMBOL_GPL(opal_rtc_read);
123716b1d26eSNeelesh Gupta EXPORT_SYMBOL_GPL(opal_rtc_write);
123816b1d26eSNeelesh Gupta EXPORT_SYMBOL_GPL(opal_tpo_read);
123916b1d26eSNeelesh Gupta EXPORT_SYMBOL_GPL(opal_tpo_write);
124047083450SNeelesh Gupta EXPORT_SYMBOL_GPL(opal_i2c_request);
1241c159b596SVasant Hegde /* Export these symbols for PowerNV LED class driver */
1242c159b596SVasant Hegde EXPORT_SYMBOL_GPL(opal_leds_get_ind);
1243c159b596SVasant Hegde EXPORT_SYMBOL_GPL(opal_leds_set_ind);
124443a1dd9bSSuraj Jitindar Singh /* Export this symbol for PowerNV Operator Panel class driver */
124543a1dd9bSSuraj Jitindar Singh EXPORT_SYMBOL_GPL(opal_write_oppanel_async);
1246ffe6d810SPaul Mackerras /* Export this for KVM */
1247ffe6d810SPaul Mackerras EXPORT_SYMBOL_GPL(opal_int_set_mfrr);
12485af50993SBenjamin Herrenschmidt EXPORT_SYMBOL_GPL(opal_int_eoi);
124977adbd22SCyril Bur EXPORT_SYMBOL_GPL(opal_error_code);
1250656ecc16SHaren Myneni /* Export the below symbol for NX compression */
1251656ecc16SHaren Myneni EXPORT_SYMBOL(opal_nx_coproc_init);
1252