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