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