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