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