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