1 /* 2 * 3 * Procedures for interfacing to the RTAS on CHRP machines. 4 * 5 * Peter Bergner, IBM March 2001. 6 * Copyright (C) 2001 IBM. 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 */ 13 14 #include <stdarg.h> 15 #include <linux/kernel.h> 16 #include <linux/types.h> 17 #include <linux/spinlock.h> 18 #include <linux/module.h> 19 #include <linux/init.h> 20 #include <linux/capability.h> 21 #include <linux/delay.h> 22 #include <linux/smp.h> 23 #include <linux/completion.h> 24 #include <linux/cpumask.h> 25 #include <linux/memblock.h> 26 #include <linux/slab.h> 27 28 #include <asm/prom.h> 29 #include <asm/rtas.h> 30 #include <asm/hvcall.h> 31 #include <asm/machdep.h> 32 #include <asm/firmware.h> 33 #include <asm/page.h> 34 #include <asm/param.h> 35 #include <asm/system.h> 36 #include <asm/delay.h> 37 #include <asm/uaccess.h> 38 #include <asm/udbg.h> 39 #include <asm/syscalls.h> 40 #include <asm/smp.h> 41 #include <asm/atomic.h> 42 #include <asm/time.h> 43 #include <asm/mmu.h> 44 45 struct rtas_t rtas = { 46 .lock = __ARCH_SPIN_LOCK_UNLOCKED 47 }; 48 EXPORT_SYMBOL(rtas); 49 50 DEFINE_SPINLOCK(rtas_data_buf_lock); 51 EXPORT_SYMBOL(rtas_data_buf_lock); 52 53 char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned; 54 EXPORT_SYMBOL(rtas_data_buf); 55 56 unsigned long rtas_rmo_buf; 57 58 /* 59 * If non-NULL, this gets called when the kernel terminates. 60 * This is done like this so rtas_flash can be a module. 61 */ 62 void (*rtas_flash_term_hook)(int); 63 EXPORT_SYMBOL(rtas_flash_term_hook); 64 65 /* RTAS use home made raw locking instead of spin_lock_irqsave 66 * because those can be called from within really nasty contexts 67 * such as having the timebase stopped which would lockup with 68 * normal locks and spinlock debugging enabled 69 */ 70 static unsigned long lock_rtas(void) 71 { 72 unsigned long flags; 73 74 local_irq_save(flags); 75 preempt_disable(); 76 arch_spin_lock_flags(&rtas.lock, flags); 77 return flags; 78 } 79 80 static void unlock_rtas(unsigned long flags) 81 { 82 arch_spin_unlock(&rtas.lock); 83 local_irq_restore(flags); 84 preempt_enable(); 85 } 86 87 /* 88 * call_rtas_display_status and call_rtas_display_status_delay 89 * are designed only for very early low-level debugging, which 90 * is why the token is hard-coded to 10. 91 */ 92 static void call_rtas_display_status(char c) 93 { 94 struct rtas_args *args = &rtas.args; 95 unsigned long s; 96 97 if (!rtas.base) 98 return; 99 s = lock_rtas(); 100 101 args->token = 10; 102 args->nargs = 1; 103 args->nret = 1; 104 args->rets = (rtas_arg_t *)&(args->args[1]); 105 args->args[0] = (unsigned char)c; 106 107 enter_rtas(__pa(args)); 108 109 unlock_rtas(s); 110 } 111 112 static void call_rtas_display_status_delay(char c) 113 { 114 static int pending_newline = 0; /* did last write end with unprinted newline? */ 115 static int width = 16; 116 117 if (c == '\n') { 118 while (width-- > 0) 119 call_rtas_display_status(' '); 120 width = 16; 121 mdelay(500); 122 pending_newline = 1; 123 } else { 124 if (pending_newline) { 125 call_rtas_display_status('\r'); 126 call_rtas_display_status('\n'); 127 } 128 pending_newline = 0; 129 if (width--) { 130 call_rtas_display_status(c); 131 udelay(10000); 132 } 133 } 134 } 135 136 void __init udbg_init_rtas_panel(void) 137 { 138 udbg_putc = call_rtas_display_status_delay; 139 } 140 141 #ifdef CONFIG_UDBG_RTAS_CONSOLE 142 143 /* If you think you're dying before early_init_dt_scan_rtas() does its 144 * work, you can hard code the token values for your firmware here and 145 * hardcode rtas.base/entry etc. 146 */ 147 static unsigned int rtas_putchar_token = RTAS_UNKNOWN_SERVICE; 148 static unsigned int rtas_getchar_token = RTAS_UNKNOWN_SERVICE; 149 150 static void udbg_rtascon_putc(char c) 151 { 152 int tries; 153 154 if (!rtas.base) 155 return; 156 157 /* Add CRs before LFs */ 158 if (c == '\n') 159 udbg_rtascon_putc('\r'); 160 161 /* if there is more than one character to be displayed, wait a bit */ 162 for (tries = 0; tries < 16; tries++) { 163 if (rtas_call(rtas_putchar_token, 1, 1, NULL, c) == 0) 164 break; 165 udelay(1000); 166 } 167 } 168 169 static int udbg_rtascon_getc_poll(void) 170 { 171 int c; 172 173 if (!rtas.base) 174 return -1; 175 176 if (rtas_call(rtas_getchar_token, 0, 2, &c)) 177 return -1; 178 179 return c; 180 } 181 182 static int udbg_rtascon_getc(void) 183 { 184 int c; 185 186 while ((c = udbg_rtascon_getc_poll()) == -1) 187 ; 188 189 return c; 190 } 191 192 193 void __init udbg_init_rtas_console(void) 194 { 195 udbg_putc = udbg_rtascon_putc; 196 udbg_getc = udbg_rtascon_getc; 197 udbg_getc_poll = udbg_rtascon_getc_poll; 198 } 199 #endif /* CONFIG_UDBG_RTAS_CONSOLE */ 200 201 void rtas_progress(char *s, unsigned short hex) 202 { 203 struct device_node *root; 204 int width; 205 const int *p; 206 char *os; 207 static int display_character, set_indicator; 208 static int display_width, display_lines, form_feed; 209 static const int *row_width; 210 static DEFINE_SPINLOCK(progress_lock); 211 static int current_line; 212 static int pending_newline = 0; /* did last write end with unprinted newline? */ 213 214 if (!rtas.base) 215 return; 216 217 if (display_width == 0) { 218 display_width = 0x10; 219 if ((root = of_find_node_by_path("/rtas"))) { 220 if ((p = of_get_property(root, 221 "ibm,display-line-length", NULL))) 222 display_width = *p; 223 if ((p = of_get_property(root, 224 "ibm,form-feed", NULL))) 225 form_feed = *p; 226 if ((p = of_get_property(root, 227 "ibm,display-number-of-lines", NULL))) 228 display_lines = *p; 229 row_width = of_get_property(root, 230 "ibm,display-truncation-length", NULL); 231 of_node_put(root); 232 } 233 display_character = rtas_token("display-character"); 234 set_indicator = rtas_token("set-indicator"); 235 } 236 237 if (display_character == RTAS_UNKNOWN_SERVICE) { 238 /* use hex display if available */ 239 if (set_indicator != RTAS_UNKNOWN_SERVICE) 240 rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex); 241 return; 242 } 243 244 spin_lock(&progress_lock); 245 246 /* 247 * Last write ended with newline, but we didn't print it since 248 * it would just clear the bottom line of output. Print it now 249 * instead. 250 * 251 * If no newline is pending and form feed is supported, clear the 252 * display with a form feed; otherwise, print a CR to start output 253 * at the beginning of the line. 254 */ 255 if (pending_newline) { 256 rtas_call(display_character, 1, 1, NULL, '\r'); 257 rtas_call(display_character, 1, 1, NULL, '\n'); 258 pending_newline = 0; 259 } else { 260 current_line = 0; 261 if (form_feed) 262 rtas_call(display_character, 1, 1, NULL, 263 (char)form_feed); 264 else 265 rtas_call(display_character, 1, 1, NULL, '\r'); 266 } 267 268 if (row_width) 269 width = row_width[current_line]; 270 else 271 width = display_width; 272 os = s; 273 while (*os) { 274 if (*os == '\n' || *os == '\r') { 275 /* If newline is the last character, save it 276 * until next call to avoid bumping up the 277 * display output. 278 */ 279 if (*os == '\n' && !os[1]) { 280 pending_newline = 1; 281 current_line++; 282 if (current_line > display_lines-1) 283 current_line = display_lines-1; 284 spin_unlock(&progress_lock); 285 return; 286 } 287 288 /* RTAS wants CR-LF, not just LF */ 289 290 if (*os == '\n') { 291 rtas_call(display_character, 1, 1, NULL, '\r'); 292 rtas_call(display_character, 1, 1, NULL, '\n'); 293 } else { 294 /* CR might be used to re-draw a line, so we'll 295 * leave it alone and not add LF. 296 */ 297 rtas_call(display_character, 1, 1, NULL, *os); 298 } 299 300 if (row_width) 301 width = row_width[current_line]; 302 else 303 width = display_width; 304 } else { 305 width--; 306 rtas_call(display_character, 1, 1, NULL, *os); 307 } 308 309 os++; 310 311 /* if we overwrite the screen length */ 312 if (width <= 0) 313 while ((*os != 0) && (*os != '\n') && (*os != '\r')) 314 os++; 315 } 316 317 spin_unlock(&progress_lock); 318 } 319 EXPORT_SYMBOL(rtas_progress); /* needed by rtas_flash module */ 320 321 int rtas_token(const char *service) 322 { 323 const int *tokp; 324 if (rtas.dev == NULL) 325 return RTAS_UNKNOWN_SERVICE; 326 tokp = of_get_property(rtas.dev, service, NULL); 327 return tokp ? *tokp : RTAS_UNKNOWN_SERVICE; 328 } 329 EXPORT_SYMBOL(rtas_token); 330 331 int rtas_service_present(const char *service) 332 { 333 return rtas_token(service) != RTAS_UNKNOWN_SERVICE; 334 } 335 EXPORT_SYMBOL(rtas_service_present); 336 337 #ifdef CONFIG_RTAS_ERROR_LOGGING 338 /* 339 * Return the firmware-specified size of the error log buffer 340 * for all rtas calls that require an error buffer argument. 341 * This includes 'check-exception' and 'rtas-last-error'. 342 */ 343 int rtas_get_error_log_max(void) 344 { 345 static int rtas_error_log_max; 346 if (rtas_error_log_max) 347 return rtas_error_log_max; 348 349 rtas_error_log_max = rtas_token ("rtas-error-log-max"); 350 if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) || 351 (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) { 352 printk (KERN_WARNING "RTAS: bad log buffer size %d\n", 353 rtas_error_log_max); 354 rtas_error_log_max = RTAS_ERROR_LOG_MAX; 355 } 356 return rtas_error_log_max; 357 } 358 EXPORT_SYMBOL(rtas_get_error_log_max); 359 360 361 static char rtas_err_buf[RTAS_ERROR_LOG_MAX]; 362 static int rtas_last_error_token; 363 364 /** Return a copy of the detailed error text associated with the 365 * most recent failed call to rtas. Because the error text 366 * might go stale if there are any other intervening rtas calls, 367 * this routine must be called atomically with whatever produced 368 * the error (i.e. with rtas.lock still held from the previous call). 369 */ 370 static char *__fetch_rtas_last_error(char *altbuf) 371 { 372 struct rtas_args err_args, save_args; 373 u32 bufsz; 374 char *buf = NULL; 375 376 if (rtas_last_error_token == -1) 377 return NULL; 378 379 bufsz = rtas_get_error_log_max(); 380 381 err_args.token = rtas_last_error_token; 382 err_args.nargs = 2; 383 err_args.nret = 1; 384 err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf); 385 err_args.args[1] = bufsz; 386 err_args.args[2] = 0; 387 388 save_args = rtas.args; 389 rtas.args = err_args; 390 391 enter_rtas(__pa(&rtas.args)); 392 393 err_args = rtas.args; 394 rtas.args = save_args; 395 396 /* Log the error in the unlikely case that there was one. */ 397 if (unlikely(err_args.args[2] == 0)) { 398 if (altbuf) { 399 buf = altbuf; 400 } else { 401 buf = rtas_err_buf; 402 if (mem_init_done) 403 buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC); 404 } 405 if (buf) 406 memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX); 407 } 408 409 return buf; 410 } 411 412 #define get_errorlog_buffer() kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL) 413 414 #else /* CONFIG_RTAS_ERROR_LOGGING */ 415 #define __fetch_rtas_last_error(x) NULL 416 #define get_errorlog_buffer() NULL 417 #endif 418 419 int rtas_call(int token, int nargs, int nret, int *outputs, ...) 420 { 421 va_list list; 422 int i; 423 unsigned long s; 424 struct rtas_args *rtas_args; 425 char *buff_copy = NULL; 426 int ret; 427 428 if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE) 429 return -1; 430 431 s = lock_rtas(); 432 rtas_args = &rtas.args; 433 434 rtas_args->token = token; 435 rtas_args->nargs = nargs; 436 rtas_args->nret = nret; 437 rtas_args->rets = (rtas_arg_t *)&(rtas_args->args[nargs]); 438 va_start(list, outputs); 439 for (i = 0; i < nargs; ++i) 440 rtas_args->args[i] = va_arg(list, rtas_arg_t); 441 va_end(list); 442 443 for (i = 0; i < nret; ++i) 444 rtas_args->rets[i] = 0; 445 446 enter_rtas(__pa(rtas_args)); 447 448 /* A -1 return code indicates that the last command couldn't 449 be completed due to a hardware error. */ 450 if (rtas_args->rets[0] == -1) 451 buff_copy = __fetch_rtas_last_error(NULL); 452 453 if (nret > 1 && outputs != NULL) 454 for (i = 0; i < nret-1; ++i) 455 outputs[i] = rtas_args->rets[i+1]; 456 ret = (nret > 0)? rtas_args->rets[0]: 0; 457 458 unlock_rtas(s); 459 460 if (buff_copy) { 461 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0); 462 if (mem_init_done) 463 kfree(buff_copy); 464 } 465 return ret; 466 } 467 EXPORT_SYMBOL(rtas_call); 468 469 /* For RTAS_BUSY (-2), delay for 1 millisecond. For an extended busy status 470 * code of 990n, perform the hinted delay of 10^n (last digit) milliseconds. 471 */ 472 unsigned int rtas_busy_delay_time(int status) 473 { 474 int order; 475 unsigned int ms = 0; 476 477 if (status == RTAS_BUSY) { 478 ms = 1; 479 } else if (status >= 9900 && status <= 9905) { 480 order = status - 9900; 481 for (ms = 1; order > 0; order--) 482 ms *= 10; 483 } 484 485 return ms; 486 } 487 EXPORT_SYMBOL(rtas_busy_delay_time); 488 489 /* For an RTAS busy status code, perform the hinted delay. */ 490 unsigned int rtas_busy_delay(int status) 491 { 492 unsigned int ms; 493 494 might_sleep(); 495 ms = rtas_busy_delay_time(status); 496 if (ms) 497 msleep(ms); 498 499 return ms; 500 } 501 EXPORT_SYMBOL(rtas_busy_delay); 502 503 static int rtas_error_rc(int rtas_rc) 504 { 505 int rc; 506 507 switch (rtas_rc) { 508 case -1: /* Hardware Error */ 509 rc = -EIO; 510 break; 511 case -3: /* Bad indicator/domain/etc */ 512 rc = -EINVAL; 513 break; 514 case -9000: /* Isolation error */ 515 rc = -EFAULT; 516 break; 517 case -9001: /* Outstanding TCE/PTE */ 518 rc = -EEXIST; 519 break; 520 case -9002: /* No usable slot */ 521 rc = -ENODEV; 522 break; 523 default: 524 printk(KERN_ERR "%s: unexpected RTAS error %d\n", 525 __func__, rtas_rc); 526 rc = -ERANGE; 527 break; 528 } 529 return rc; 530 } 531 532 int rtas_get_power_level(int powerdomain, int *level) 533 { 534 int token = rtas_token("get-power-level"); 535 int rc; 536 537 if (token == RTAS_UNKNOWN_SERVICE) 538 return -ENOENT; 539 540 while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY) 541 udelay(1); 542 543 if (rc < 0) 544 return rtas_error_rc(rc); 545 return rc; 546 } 547 EXPORT_SYMBOL(rtas_get_power_level); 548 549 int rtas_set_power_level(int powerdomain, int level, int *setlevel) 550 { 551 int token = rtas_token("set-power-level"); 552 int rc; 553 554 if (token == RTAS_UNKNOWN_SERVICE) 555 return -ENOENT; 556 557 do { 558 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level); 559 } while (rtas_busy_delay(rc)); 560 561 if (rc < 0) 562 return rtas_error_rc(rc); 563 return rc; 564 } 565 EXPORT_SYMBOL(rtas_set_power_level); 566 567 int rtas_get_sensor(int sensor, int index, int *state) 568 { 569 int token = rtas_token("get-sensor-state"); 570 int rc; 571 572 if (token == RTAS_UNKNOWN_SERVICE) 573 return -ENOENT; 574 575 do { 576 rc = rtas_call(token, 2, 2, state, sensor, index); 577 } while (rtas_busy_delay(rc)); 578 579 if (rc < 0) 580 return rtas_error_rc(rc); 581 return rc; 582 } 583 EXPORT_SYMBOL(rtas_get_sensor); 584 585 bool rtas_indicator_present(int token, int *maxindex) 586 { 587 int proplen, count, i; 588 const struct indicator_elem { 589 u32 token; 590 u32 maxindex; 591 } *indicators; 592 593 indicators = of_get_property(rtas.dev, "rtas-indicators", &proplen); 594 if (!indicators) 595 return false; 596 597 count = proplen / sizeof(struct indicator_elem); 598 599 for (i = 0; i < count; i++) { 600 if (indicators[i].token != token) 601 continue; 602 if (maxindex) 603 *maxindex = indicators[i].maxindex; 604 return true; 605 } 606 607 return false; 608 } 609 EXPORT_SYMBOL(rtas_indicator_present); 610 611 int rtas_set_indicator(int indicator, int index, int new_value) 612 { 613 int token = rtas_token("set-indicator"); 614 int rc; 615 616 if (token == RTAS_UNKNOWN_SERVICE) 617 return -ENOENT; 618 619 do { 620 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value); 621 } while (rtas_busy_delay(rc)); 622 623 if (rc < 0) 624 return rtas_error_rc(rc); 625 return rc; 626 } 627 EXPORT_SYMBOL(rtas_set_indicator); 628 629 /* 630 * Ignoring RTAS extended delay 631 */ 632 int rtas_set_indicator_fast(int indicator, int index, int new_value) 633 { 634 int rc; 635 int token = rtas_token("set-indicator"); 636 637 if (token == RTAS_UNKNOWN_SERVICE) 638 return -ENOENT; 639 640 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value); 641 642 WARN_ON(rc == -2 || (rc >= 9900 && rc <= 9905)); 643 644 if (rc < 0) 645 return rtas_error_rc(rc); 646 647 return rc; 648 } 649 650 void rtas_restart(char *cmd) 651 { 652 if (rtas_flash_term_hook) 653 rtas_flash_term_hook(SYS_RESTART); 654 printk("RTAS system-reboot returned %d\n", 655 rtas_call(rtas_token("system-reboot"), 0, 1, NULL)); 656 for (;;); 657 } 658 659 void rtas_power_off(void) 660 { 661 if (rtas_flash_term_hook) 662 rtas_flash_term_hook(SYS_POWER_OFF); 663 /* allow power on only with power button press */ 664 printk("RTAS power-off returned %d\n", 665 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1)); 666 for (;;); 667 } 668 669 void rtas_halt(void) 670 { 671 if (rtas_flash_term_hook) 672 rtas_flash_term_hook(SYS_HALT); 673 /* allow power on only with power button press */ 674 printk("RTAS power-off returned %d\n", 675 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1)); 676 for (;;); 677 } 678 679 /* Must be in the RMO region, so we place it here */ 680 static char rtas_os_term_buf[2048]; 681 682 void rtas_os_term(char *str) 683 { 684 int status; 685 686 /* 687 * Firmware with the ibm,extended-os-term property is guaranteed 688 * to always return from an ibm,os-term call. Earlier versions without 689 * this property may terminate the partition which we want to avoid 690 * since it interferes with panic_timeout. 691 */ 692 if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term") || 693 RTAS_UNKNOWN_SERVICE == rtas_token("ibm,extended-os-term")) 694 return; 695 696 snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str); 697 698 do { 699 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL, 700 __pa(rtas_os_term_buf)); 701 } while (rtas_busy_delay(status)); 702 703 if (status != 0) 704 printk(KERN_EMERG "ibm,os-term call failed %d\n", status); 705 } 706 707 static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE; 708 #ifdef CONFIG_PPC_PSERIES 709 static int __rtas_suspend_last_cpu(struct rtas_suspend_me_data *data, int wake_when_done) 710 { 711 u16 slb_size = mmu_slb_size; 712 int rc = H_MULTI_THREADS_ACTIVE; 713 int cpu; 714 715 slb_set_size(SLB_MIN_SIZE); 716 printk(KERN_DEBUG "calling ibm,suspend-me on cpu %i\n", smp_processor_id()); 717 718 while (rc == H_MULTI_THREADS_ACTIVE && !atomic_read(&data->done) && 719 !atomic_read(&data->error)) 720 rc = rtas_call(data->token, 0, 1, NULL); 721 722 if (rc || atomic_read(&data->error)) { 723 printk(KERN_DEBUG "ibm,suspend-me returned %d\n", rc); 724 slb_set_size(slb_size); 725 } 726 727 if (atomic_read(&data->error)) 728 rc = atomic_read(&data->error); 729 730 atomic_set(&data->error, rc); 731 732 if (wake_when_done) { 733 atomic_set(&data->done, 1); 734 735 for_each_online_cpu(cpu) 736 plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu)); 737 } 738 739 if (atomic_dec_return(&data->working) == 0) 740 complete(data->complete); 741 742 return rc; 743 } 744 745 int rtas_suspend_last_cpu(struct rtas_suspend_me_data *data) 746 { 747 atomic_inc(&data->working); 748 return __rtas_suspend_last_cpu(data, 0); 749 } 750 751 static int __rtas_suspend_cpu(struct rtas_suspend_me_data *data, int wake_when_done) 752 { 753 long rc = H_SUCCESS; 754 unsigned long msr_save; 755 int cpu; 756 757 atomic_inc(&data->working); 758 759 /* really need to ensure MSR.EE is off for H_JOIN */ 760 msr_save = mfmsr(); 761 mtmsr(msr_save & ~(MSR_EE)); 762 763 while (rc == H_SUCCESS && !atomic_read(&data->done) && !atomic_read(&data->error)) 764 rc = plpar_hcall_norets(H_JOIN); 765 766 mtmsr(msr_save); 767 768 if (rc == H_SUCCESS) { 769 /* This cpu was prodded and the suspend is complete. */ 770 goto out; 771 } else if (rc == H_CONTINUE) { 772 /* All other cpus are in H_JOIN, this cpu does 773 * the suspend. 774 */ 775 return __rtas_suspend_last_cpu(data, wake_when_done); 776 } else { 777 printk(KERN_ERR "H_JOIN on cpu %i failed with rc = %ld\n", 778 smp_processor_id(), rc); 779 atomic_set(&data->error, rc); 780 } 781 782 if (wake_when_done) { 783 atomic_set(&data->done, 1); 784 785 /* This cpu did the suspend or got an error; in either case, 786 * we need to prod all other other cpus out of join state. 787 * Extra prods are harmless. 788 */ 789 for_each_online_cpu(cpu) 790 plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu)); 791 } 792 out: 793 if (atomic_dec_return(&data->working) == 0) 794 complete(data->complete); 795 return rc; 796 } 797 798 int rtas_suspend_cpu(struct rtas_suspend_me_data *data) 799 { 800 return __rtas_suspend_cpu(data, 0); 801 } 802 803 static void rtas_percpu_suspend_me(void *info) 804 { 805 __rtas_suspend_cpu((struct rtas_suspend_me_data *)info, 1); 806 } 807 808 int rtas_ibm_suspend_me(struct rtas_args *args) 809 { 810 long state; 811 long rc; 812 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 813 struct rtas_suspend_me_data data; 814 DECLARE_COMPLETION_ONSTACK(done); 815 816 if (!rtas_service_present("ibm,suspend-me")) 817 return -ENOSYS; 818 819 /* Make sure the state is valid */ 820 rc = plpar_hcall(H_VASI_STATE, retbuf, 821 ((u64)args->args[0] << 32) | args->args[1]); 822 823 state = retbuf[0]; 824 825 if (rc) { 826 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc); 827 return rc; 828 } else if (state == H_VASI_ENABLED) { 829 args->args[args->nargs] = RTAS_NOT_SUSPENDABLE; 830 return 0; 831 } else if (state != H_VASI_SUSPENDING) { 832 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n", 833 state); 834 args->args[args->nargs] = -1; 835 return 0; 836 } 837 838 atomic_set(&data.working, 0); 839 atomic_set(&data.done, 0); 840 atomic_set(&data.error, 0); 841 data.token = rtas_token("ibm,suspend-me"); 842 data.complete = &done; 843 844 /* Call function on all CPUs. One of us will make the 845 * rtas call 846 */ 847 if (on_each_cpu(rtas_percpu_suspend_me, &data, 0)) 848 atomic_set(&data.error, -EINVAL); 849 850 wait_for_completion(&done); 851 852 if (atomic_read(&data.error) != 0) 853 printk(KERN_ERR "Error doing global join\n"); 854 855 return atomic_read(&data.error); 856 } 857 #else /* CONFIG_PPC_PSERIES */ 858 int rtas_ibm_suspend_me(struct rtas_args *args) 859 { 860 return -ENOSYS; 861 } 862 #endif 863 864 asmlinkage int ppc_rtas(struct rtas_args __user *uargs) 865 { 866 struct rtas_args args; 867 unsigned long flags; 868 char *buff_copy, *errbuf = NULL; 869 int nargs; 870 int rc; 871 872 if (!capable(CAP_SYS_ADMIN)) 873 return -EPERM; 874 875 if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0) 876 return -EFAULT; 877 878 nargs = args.nargs; 879 if (nargs > ARRAY_SIZE(args.args) 880 || args.nret > ARRAY_SIZE(args.args) 881 || nargs + args.nret > ARRAY_SIZE(args.args)) 882 return -EINVAL; 883 884 /* Copy in args. */ 885 if (copy_from_user(args.args, uargs->args, 886 nargs * sizeof(rtas_arg_t)) != 0) 887 return -EFAULT; 888 889 if (args.token == RTAS_UNKNOWN_SERVICE) 890 return -EINVAL; 891 892 args.rets = &args.args[nargs]; 893 memset(args.rets, 0, args.nret * sizeof(rtas_arg_t)); 894 895 /* Need to handle ibm,suspend_me call specially */ 896 if (args.token == ibm_suspend_me_token) { 897 rc = rtas_ibm_suspend_me(&args); 898 if (rc) 899 return rc; 900 goto copy_return; 901 } 902 903 buff_copy = get_errorlog_buffer(); 904 905 flags = lock_rtas(); 906 907 rtas.args = args; 908 enter_rtas(__pa(&rtas.args)); 909 args = rtas.args; 910 911 /* A -1 return code indicates that the last command couldn't 912 be completed due to a hardware error. */ 913 if (args.rets[0] == -1) 914 errbuf = __fetch_rtas_last_error(buff_copy); 915 916 unlock_rtas(flags); 917 918 if (buff_copy) { 919 if (errbuf) 920 log_error(errbuf, ERR_TYPE_RTAS_LOG, 0); 921 kfree(buff_copy); 922 } 923 924 copy_return: 925 /* Copy out args. */ 926 if (copy_to_user(uargs->args + nargs, 927 args.args + nargs, 928 args.nret * sizeof(rtas_arg_t)) != 0) 929 return -EFAULT; 930 931 return 0; 932 } 933 934 /* 935 * Call early during boot, before mem init or bootmem, to retrieve the RTAS 936 * informations from the device-tree and allocate the RMO buffer for userland 937 * accesses. 938 */ 939 void __init rtas_initialize(void) 940 { 941 unsigned long rtas_region = RTAS_INSTANTIATE_MAX; 942 943 /* Get RTAS dev node and fill up our "rtas" structure with infos 944 * about it. 945 */ 946 rtas.dev = of_find_node_by_name(NULL, "rtas"); 947 if (rtas.dev) { 948 const u32 *basep, *entryp, *sizep; 949 950 basep = of_get_property(rtas.dev, "linux,rtas-base", NULL); 951 sizep = of_get_property(rtas.dev, "rtas-size", NULL); 952 if (basep != NULL && sizep != NULL) { 953 rtas.base = *basep; 954 rtas.size = *sizep; 955 entryp = of_get_property(rtas.dev, 956 "linux,rtas-entry", NULL); 957 if (entryp == NULL) /* Ugh */ 958 rtas.entry = rtas.base; 959 else 960 rtas.entry = *entryp; 961 } else 962 rtas.dev = NULL; 963 } 964 if (!rtas.dev) 965 return; 966 967 /* If RTAS was found, allocate the RMO buffer for it and look for 968 * the stop-self token if any 969 */ 970 #ifdef CONFIG_PPC64 971 if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR)) { 972 rtas_region = min(ppc64_rma_size, RTAS_INSTANTIATE_MAX); 973 ibm_suspend_me_token = rtas_token("ibm,suspend-me"); 974 } 975 #endif 976 rtas_rmo_buf = memblock_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region); 977 978 #ifdef CONFIG_RTAS_ERROR_LOGGING 979 rtas_last_error_token = rtas_token("rtas-last-error"); 980 #endif 981 } 982 983 int __init early_init_dt_scan_rtas(unsigned long node, 984 const char *uname, int depth, void *data) 985 { 986 u32 *basep, *entryp, *sizep; 987 988 if (depth != 1 || strcmp(uname, "rtas") != 0) 989 return 0; 990 991 basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL); 992 entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL); 993 sizep = of_get_flat_dt_prop(node, "rtas-size", NULL); 994 995 if (basep && entryp && sizep) { 996 rtas.base = *basep; 997 rtas.entry = *entryp; 998 rtas.size = *sizep; 999 } 1000 1001 #ifdef CONFIG_UDBG_RTAS_CONSOLE 1002 basep = of_get_flat_dt_prop(node, "put-term-char", NULL); 1003 if (basep) 1004 rtas_putchar_token = *basep; 1005 1006 basep = of_get_flat_dt_prop(node, "get-term-char", NULL); 1007 if (basep) 1008 rtas_getchar_token = *basep; 1009 1010 if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE && 1011 rtas_getchar_token != RTAS_UNKNOWN_SERVICE) 1012 udbg_init_rtas_console(); 1013 1014 #endif 1015 1016 /* break now */ 1017 return 1; 1018 } 1019 1020 static arch_spinlock_t timebase_lock; 1021 static u64 timebase = 0; 1022 1023 void __cpuinit rtas_give_timebase(void) 1024 { 1025 unsigned long flags; 1026 1027 local_irq_save(flags); 1028 hard_irq_disable(); 1029 arch_spin_lock(&timebase_lock); 1030 rtas_call(rtas_token("freeze-time-base"), 0, 1, NULL); 1031 timebase = get_tb(); 1032 arch_spin_unlock(&timebase_lock); 1033 1034 while (timebase) 1035 barrier(); 1036 rtas_call(rtas_token("thaw-time-base"), 0, 1, NULL); 1037 local_irq_restore(flags); 1038 } 1039 1040 void __cpuinit rtas_take_timebase(void) 1041 { 1042 while (!timebase) 1043 barrier(); 1044 arch_spin_lock(&timebase_lock); 1045 set_tb(timebase >> 32, timebase & 0xffffffff); 1046 timebase = 0; 1047 arch_spin_unlock(&timebase_lock); 1048 } 1049