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