1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * 4 * Procedures for interfacing to the RTAS on CHRP machines. 5 * 6 * Peter Bergner, IBM March 2001. 7 * Copyright (C) 2001 IBM. 8 */ 9 10 #define pr_fmt(fmt) "rtas: " fmt 11 12 #include <linux/capability.h> 13 #include <linux/delay.h> 14 #include <linux/export.h> 15 #include <linux/init.h> 16 #include <linux/kernel.h> 17 #include <linux/memblock.h> 18 #include <linux/of.h> 19 #include <linux/of_fdt.h> 20 #include <linux/reboot.h> 21 #include <linux/sched.h> 22 #include <linux/security.h> 23 #include <linux/slab.h> 24 #include <linux/spinlock.h> 25 #include <linux/stdarg.h> 26 #include <linux/syscalls.h> 27 #include <linux/types.h> 28 #include <linux/uaccess.h> 29 30 #include <asm/delay.h> 31 #include <asm/firmware.h> 32 #include <asm/interrupt.h> 33 #include <asm/machdep.h> 34 #include <asm/mmu.h> 35 #include <asm/page.h> 36 #include <asm/rtas.h> 37 #include <asm/time.h> 38 #include <asm/udbg.h> 39 40 /* This is here deliberately so it's only used in this file */ 41 void enter_rtas(unsigned long); 42 43 static inline void do_enter_rtas(unsigned long args) 44 { 45 unsigned long msr; 46 47 /* 48 * Make sure MSR[RI] is currently enabled as it will be forced later 49 * in enter_rtas. 50 */ 51 msr = mfmsr(); 52 BUG_ON(!(msr & MSR_RI)); 53 54 BUG_ON(!irqs_disabled()); 55 56 hard_irq_disable(); /* Ensure MSR[EE] is disabled on PPC64 */ 57 58 enter_rtas(args); 59 60 srr_regs_clobbered(); /* rtas uses SRRs, invalidate */ 61 } 62 63 struct rtas_t rtas = { 64 .lock = __ARCH_SPIN_LOCK_UNLOCKED 65 }; 66 EXPORT_SYMBOL(rtas); 67 68 DEFINE_SPINLOCK(rtas_data_buf_lock); 69 EXPORT_SYMBOL(rtas_data_buf_lock); 70 71 char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned; 72 EXPORT_SYMBOL(rtas_data_buf); 73 74 unsigned long rtas_rmo_buf; 75 76 /* 77 * If non-NULL, this gets called when the kernel terminates. 78 * This is done like this so rtas_flash can be a module. 79 */ 80 void (*rtas_flash_term_hook)(int); 81 EXPORT_SYMBOL(rtas_flash_term_hook); 82 83 /* RTAS use home made raw locking instead of spin_lock_irqsave 84 * because those can be called from within really nasty contexts 85 * such as having the timebase stopped which would lockup with 86 * normal locks and spinlock debugging enabled 87 */ 88 static unsigned long lock_rtas(void) 89 { 90 unsigned long flags; 91 92 local_irq_save(flags); 93 preempt_disable(); 94 arch_spin_lock(&rtas.lock); 95 return flags; 96 } 97 98 static void unlock_rtas(unsigned long flags) 99 { 100 arch_spin_unlock(&rtas.lock); 101 local_irq_restore(flags); 102 preempt_enable(); 103 } 104 105 /* 106 * call_rtas_display_status and call_rtas_display_status_delay 107 * are designed only for very early low-level debugging, which 108 * is why the token is hard-coded to 10. 109 */ 110 static void call_rtas_display_status(unsigned char c) 111 { 112 unsigned long s; 113 114 if (!rtas.base) 115 return; 116 117 s = lock_rtas(); 118 rtas_call_unlocked(&rtas.args, 10, 1, 1, NULL, c); 119 unlock_rtas(s); 120 } 121 122 static void call_rtas_display_status_delay(char c) 123 { 124 static int pending_newline = 0; /* did last write end with unprinted newline? */ 125 static int width = 16; 126 127 if (c == '\n') { 128 while (width-- > 0) 129 call_rtas_display_status(' '); 130 width = 16; 131 mdelay(500); 132 pending_newline = 1; 133 } else { 134 if (pending_newline) { 135 call_rtas_display_status('\r'); 136 call_rtas_display_status('\n'); 137 } 138 pending_newline = 0; 139 if (width--) { 140 call_rtas_display_status(c); 141 udelay(10000); 142 } 143 } 144 } 145 146 void __init udbg_init_rtas_panel(void) 147 { 148 udbg_putc = call_rtas_display_status_delay; 149 } 150 151 #ifdef CONFIG_UDBG_RTAS_CONSOLE 152 153 /* If you think you're dying before early_init_dt_scan_rtas() does its 154 * work, you can hard code the token values for your firmware here and 155 * hardcode rtas.base/entry etc. 156 */ 157 static unsigned int rtas_putchar_token = RTAS_UNKNOWN_SERVICE; 158 static unsigned int rtas_getchar_token = RTAS_UNKNOWN_SERVICE; 159 160 static void udbg_rtascon_putc(char c) 161 { 162 int tries; 163 164 if (!rtas.base) 165 return; 166 167 /* Add CRs before LFs */ 168 if (c == '\n') 169 udbg_rtascon_putc('\r'); 170 171 /* if there is more than one character to be displayed, wait a bit */ 172 for (tries = 0; tries < 16; tries++) { 173 if (rtas_call(rtas_putchar_token, 1, 1, NULL, c) == 0) 174 break; 175 udelay(1000); 176 } 177 } 178 179 static int udbg_rtascon_getc_poll(void) 180 { 181 int c; 182 183 if (!rtas.base) 184 return -1; 185 186 if (rtas_call(rtas_getchar_token, 0, 2, &c)) 187 return -1; 188 189 return c; 190 } 191 192 static int udbg_rtascon_getc(void) 193 { 194 int c; 195 196 while ((c = udbg_rtascon_getc_poll()) == -1) 197 ; 198 199 return c; 200 } 201 202 203 void __init udbg_init_rtas_console(void) 204 { 205 udbg_putc = udbg_rtascon_putc; 206 udbg_getc = udbg_rtascon_getc; 207 udbg_getc_poll = udbg_rtascon_getc_poll; 208 } 209 #endif /* CONFIG_UDBG_RTAS_CONSOLE */ 210 211 void rtas_progress(char *s, unsigned short hex) 212 { 213 struct device_node *root; 214 int width; 215 const __be32 *p; 216 char *os; 217 static int display_character, set_indicator; 218 static int display_width, display_lines, form_feed; 219 static const int *row_width; 220 static DEFINE_SPINLOCK(progress_lock); 221 static int current_line; 222 static int pending_newline = 0; /* did last write end with unprinted newline? */ 223 224 if (!rtas.base) 225 return; 226 227 if (display_width == 0) { 228 display_width = 0x10; 229 if ((root = of_find_node_by_path("/rtas"))) { 230 if ((p = of_get_property(root, 231 "ibm,display-line-length", NULL))) 232 display_width = be32_to_cpu(*p); 233 if ((p = of_get_property(root, 234 "ibm,form-feed", NULL))) 235 form_feed = be32_to_cpu(*p); 236 if ((p = of_get_property(root, 237 "ibm,display-number-of-lines", NULL))) 238 display_lines = be32_to_cpu(*p); 239 row_width = of_get_property(root, 240 "ibm,display-truncation-length", NULL); 241 of_node_put(root); 242 } 243 display_character = rtas_token("display-character"); 244 set_indicator = rtas_token("set-indicator"); 245 } 246 247 if (display_character == RTAS_UNKNOWN_SERVICE) { 248 /* use hex display if available */ 249 if (set_indicator != RTAS_UNKNOWN_SERVICE) 250 rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex); 251 return; 252 } 253 254 spin_lock(&progress_lock); 255 256 /* 257 * Last write ended with newline, but we didn't print it since 258 * it would just clear the bottom line of output. Print it now 259 * instead. 260 * 261 * If no newline is pending and form feed is supported, clear the 262 * display with a form feed; otherwise, print a CR to start output 263 * at the beginning of the line. 264 */ 265 if (pending_newline) { 266 rtas_call(display_character, 1, 1, NULL, '\r'); 267 rtas_call(display_character, 1, 1, NULL, '\n'); 268 pending_newline = 0; 269 } else { 270 current_line = 0; 271 if (form_feed) 272 rtas_call(display_character, 1, 1, NULL, 273 (char)form_feed); 274 else 275 rtas_call(display_character, 1, 1, NULL, '\r'); 276 } 277 278 if (row_width) 279 width = row_width[current_line]; 280 else 281 width = display_width; 282 os = s; 283 while (*os) { 284 if (*os == '\n' || *os == '\r') { 285 /* If newline is the last character, save it 286 * until next call to avoid bumping up the 287 * display output. 288 */ 289 if (*os == '\n' && !os[1]) { 290 pending_newline = 1; 291 current_line++; 292 if (current_line > display_lines-1) 293 current_line = display_lines-1; 294 spin_unlock(&progress_lock); 295 return; 296 } 297 298 /* RTAS wants CR-LF, not just LF */ 299 300 if (*os == '\n') { 301 rtas_call(display_character, 1, 1, NULL, '\r'); 302 rtas_call(display_character, 1, 1, NULL, '\n'); 303 } else { 304 /* CR might be used to re-draw a line, so we'll 305 * leave it alone and not add LF. 306 */ 307 rtas_call(display_character, 1, 1, NULL, *os); 308 } 309 310 if (row_width) 311 width = row_width[current_line]; 312 else 313 width = display_width; 314 } else { 315 width--; 316 rtas_call(display_character, 1, 1, NULL, *os); 317 } 318 319 os++; 320 321 /* if we overwrite the screen length */ 322 if (width <= 0) 323 while ((*os != 0) && (*os != '\n') && (*os != '\r')) 324 os++; 325 } 326 327 spin_unlock(&progress_lock); 328 } 329 EXPORT_SYMBOL(rtas_progress); /* needed by rtas_flash module */ 330 331 int rtas_token(const char *service) 332 { 333 const __be32 *tokp; 334 if (rtas.dev == NULL) 335 return RTAS_UNKNOWN_SERVICE; 336 tokp = of_get_property(rtas.dev, service, NULL); 337 return tokp ? be32_to_cpu(*tokp) : RTAS_UNKNOWN_SERVICE; 338 } 339 EXPORT_SYMBOL(rtas_token); 340 341 int rtas_service_present(const char *service) 342 { 343 return rtas_token(service) != RTAS_UNKNOWN_SERVICE; 344 } 345 EXPORT_SYMBOL(rtas_service_present); 346 347 #ifdef CONFIG_RTAS_ERROR_LOGGING 348 349 static u32 rtas_error_log_max __ro_after_init = RTAS_ERROR_LOG_MAX; 350 351 /* 352 * Return the firmware-specified size of the error log buffer 353 * for all rtas calls that require an error buffer argument. 354 * This includes 'check-exception' and 'rtas-last-error'. 355 */ 356 int rtas_get_error_log_max(void) 357 { 358 return rtas_error_log_max; 359 } 360 EXPORT_SYMBOL(rtas_get_error_log_max); 361 362 static void __init init_error_log_max(void) 363 { 364 static const char propname[] __initconst = "rtas-error-log-max"; 365 u32 max; 366 367 if (of_property_read_u32(rtas.dev, propname, &max)) { 368 pr_warn("%s not found, using default of %u\n", 369 propname, RTAS_ERROR_LOG_MAX); 370 max = RTAS_ERROR_LOG_MAX; 371 } 372 373 if (max > RTAS_ERROR_LOG_MAX) { 374 pr_warn("%s = %u, clamping max error log size to %u\n", 375 propname, max, RTAS_ERROR_LOG_MAX); 376 max = RTAS_ERROR_LOG_MAX; 377 } 378 379 rtas_error_log_max = max; 380 } 381 382 383 static char rtas_err_buf[RTAS_ERROR_LOG_MAX]; 384 static int rtas_last_error_token; 385 386 /** Return a copy of the detailed error text associated with the 387 * most recent failed call to rtas. Because the error text 388 * might go stale if there are any other intervening rtas calls, 389 * this routine must be called atomically with whatever produced 390 * the error (i.e. with rtas.lock still held from the previous call). 391 */ 392 static char *__fetch_rtas_last_error(char *altbuf) 393 { 394 struct rtas_args err_args, save_args; 395 u32 bufsz; 396 char *buf = NULL; 397 398 if (rtas_last_error_token == -1) 399 return NULL; 400 401 bufsz = rtas_get_error_log_max(); 402 403 err_args.token = cpu_to_be32(rtas_last_error_token); 404 err_args.nargs = cpu_to_be32(2); 405 err_args.nret = cpu_to_be32(1); 406 err_args.args[0] = cpu_to_be32(__pa(rtas_err_buf)); 407 err_args.args[1] = cpu_to_be32(bufsz); 408 err_args.args[2] = 0; 409 410 save_args = rtas.args; 411 rtas.args = err_args; 412 413 do_enter_rtas(__pa(&rtas.args)); 414 415 err_args = rtas.args; 416 rtas.args = save_args; 417 418 /* Log the error in the unlikely case that there was one. */ 419 if (unlikely(err_args.args[2] == 0)) { 420 if (altbuf) { 421 buf = altbuf; 422 } else { 423 buf = rtas_err_buf; 424 if (slab_is_available()) 425 buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC); 426 } 427 if (buf) 428 memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX); 429 } 430 431 return buf; 432 } 433 434 #define get_errorlog_buffer() kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL) 435 436 #else /* CONFIG_RTAS_ERROR_LOGGING */ 437 #define __fetch_rtas_last_error(x) NULL 438 #define get_errorlog_buffer() NULL 439 static void __init init_error_log_max(void) {} 440 #endif 441 442 443 static void 444 va_rtas_call_unlocked(struct rtas_args *args, int token, int nargs, int nret, 445 va_list list) 446 { 447 int i; 448 449 args->token = cpu_to_be32(token); 450 args->nargs = cpu_to_be32(nargs); 451 args->nret = cpu_to_be32(nret); 452 args->rets = &(args->args[nargs]); 453 454 for (i = 0; i < nargs; ++i) 455 args->args[i] = cpu_to_be32(va_arg(list, __u32)); 456 457 for (i = 0; i < nret; ++i) 458 args->rets[i] = 0; 459 460 do_enter_rtas(__pa(args)); 461 } 462 463 void rtas_call_unlocked(struct rtas_args *args, int token, int nargs, int nret, ...) 464 { 465 va_list list; 466 467 va_start(list, nret); 468 va_rtas_call_unlocked(args, token, nargs, nret, list); 469 va_end(list); 470 } 471 472 static int ibm_open_errinjct_token; 473 static int ibm_errinjct_token; 474 475 /** 476 * rtas_call() - Invoke an RTAS firmware function. 477 * @token: Identifies the function being invoked. 478 * @nargs: Number of input parameters. Does not include token. 479 * @nret: Number of output parameters, including the call status. 480 * @outputs: Array of @nret output words. 481 * @....: List of @nargs input parameters. 482 * 483 * Invokes the RTAS function indicated by @token, which the caller 484 * should obtain via rtas_token(). 485 * 486 * The @nargs and @nret arguments must match the number of input and 487 * output parameters specified for the RTAS function. 488 * 489 * rtas_call() returns RTAS status codes, not conventional Linux errno 490 * values. Callers must translate any failure to an appropriate errno 491 * in syscall context. Most callers of RTAS functions that can return 492 * -2 or 990x should use rtas_busy_delay() to correctly handle those 493 * statuses before calling again. 494 * 495 * The return value descriptions are adapted from 7.2.8 [RTAS] Return 496 * Codes of the PAPR and CHRP specifications. 497 * 498 * Context: Process context preferably, interrupt context if 499 * necessary. Acquires an internal spinlock and may perform 500 * GFP_ATOMIC slab allocation in error path. Unsafe for NMI 501 * context. 502 * Return: 503 * * 0 - RTAS function call succeeded. 504 * * -1 - RTAS function encountered a hardware or 505 * platform error, or the token is invalid, 506 * or the function is restricted by kernel policy. 507 * * -2 - Specs say "A necessary hardware device was busy, 508 * and the requested function could not be 509 * performed. The operation should be retried at 510 * a later time." This is misleading, at least with 511 * respect to current RTAS implementations. What it 512 * usually means in practice is that the function 513 * could not be completed while meeting RTAS's 514 * deadline for returning control to the OS (250us 515 * for PAPR/PowerVM, typically), but the call may be 516 * immediately reattempted to resume work on it. 517 * * -3 - Parameter error. 518 * * -7 - Unexpected state change. 519 * * 9000...9899 - Vendor-specific success codes. 520 * * 9900...9905 - Advisory extended delay. Caller should try 521 * again after ~10^x ms has elapsed, where x is 522 * the last digit of the status [0-5]. Again going 523 * beyond the PAPR text, 990x on PowerVM indicates 524 * contention for RTAS-internal resources. Other 525 * RTAS call sequences in progress should be 526 * allowed to complete before reattempting the 527 * call. 528 * * -9000 - Multi-level isolation error. 529 * * -9999...-9004 - Vendor-specific error codes. 530 * * Additional negative values - Function-specific error. 531 * * Additional positive values - Function-specific success. 532 */ 533 int rtas_call(int token, int nargs, int nret, int *outputs, ...) 534 { 535 va_list list; 536 int i; 537 unsigned long s; 538 struct rtas_args *rtas_args; 539 char *buff_copy = NULL; 540 int ret; 541 542 if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE) 543 return -1; 544 545 if (token == ibm_open_errinjct_token || token == ibm_errinjct_token) { 546 /* 547 * It would be nicer to not discard the error value 548 * from security_locked_down(), but callers expect an 549 * RTAS status, not an errno. 550 */ 551 if (security_locked_down(LOCKDOWN_RTAS_ERROR_INJECTION)) 552 return -1; 553 } 554 555 if ((mfmsr() & (MSR_IR|MSR_DR)) != (MSR_IR|MSR_DR)) { 556 WARN_ON_ONCE(1); 557 return -1; 558 } 559 560 s = lock_rtas(); 561 562 /* We use the global rtas args buffer */ 563 rtas_args = &rtas.args; 564 565 va_start(list, outputs); 566 va_rtas_call_unlocked(rtas_args, token, nargs, nret, list); 567 va_end(list); 568 569 /* A -1 return code indicates that the last command couldn't 570 be completed due to a hardware error. */ 571 if (be32_to_cpu(rtas_args->rets[0]) == -1) 572 buff_copy = __fetch_rtas_last_error(NULL); 573 574 if (nret > 1 && outputs != NULL) 575 for (i = 0; i < nret-1; ++i) 576 outputs[i] = be32_to_cpu(rtas_args->rets[i+1]); 577 ret = (nret > 0)? be32_to_cpu(rtas_args->rets[0]): 0; 578 579 unlock_rtas(s); 580 581 if (buff_copy) { 582 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0); 583 if (slab_is_available()) 584 kfree(buff_copy); 585 } 586 return ret; 587 } 588 EXPORT_SYMBOL(rtas_call); 589 590 /** 591 * rtas_busy_delay_time() - From an RTAS status value, calculate the 592 * suggested delay time in milliseconds. 593 * 594 * @status: a value returned from rtas_call() or similar APIs which return 595 * the status of a RTAS function call. 596 * 597 * Context: Any context. 598 * 599 * Return: 600 * * 100000 - If @status is 9905. 601 * * 10000 - If @status is 9904. 602 * * 1000 - If @status is 9903. 603 * * 100 - If @status is 9902. 604 * * 10 - If @status is 9901. 605 * * 1 - If @status is either 9900 or -2. This is "wrong" for -2, but 606 * some callers depend on this behavior, and the worst outcome 607 * is that they will delay for longer than necessary. 608 * * 0 - If @status is not a busy or extended delay value. 609 */ 610 unsigned int rtas_busy_delay_time(int status) 611 { 612 int order; 613 unsigned int ms = 0; 614 615 if (status == RTAS_BUSY) { 616 ms = 1; 617 } else if (status >= RTAS_EXTENDED_DELAY_MIN && 618 status <= RTAS_EXTENDED_DELAY_MAX) { 619 order = status - RTAS_EXTENDED_DELAY_MIN; 620 for (ms = 1; order > 0; order--) 621 ms *= 10; 622 } 623 624 return ms; 625 } 626 EXPORT_SYMBOL(rtas_busy_delay_time); 627 628 /** 629 * rtas_busy_delay() - helper for RTAS busy and extended delay statuses 630 * 631 * @status: a value returned from rtas_call() or similar APIs which return 632 * the status of a RTAS function call. 633 * 634 * Context: Process context. May sleep or schedule. 635 * 636 * Return: 637 * * true - @status is RTAS_BUSY or an extended delay hint. The 638 * caller may assume that the CPU has been yielded if necessary, 639 * and that an appropriate delay for @status has elapsed. 640 * Generally the caller should reattempt the RTAS call which 641 * yielded @status. 642 * 643 * * false - @status is not @RTAS_BUSY nor an extended delay hint. The 644 * caller is responsible for handling @status. 645 */ 646 bool rtas_busy_delay(int status) 647 { 648 unsigned int ms; 649 bool ret; 650 651 switch (status) { 652 case RTAS_EXTENDED_DELAY_MIN...RTAS_EXTENDED_DELAY_MAX: 653 ret = true; 654 ms = rtas_busy_delay_time(status); 655 /* 656 * The extended delay hint can be as high as 100 seconds. 657 * Surely any function returning such a status is either 658 * buggy or isn't going to be significantly slowed by us 659 * polling at 1HZ. Clamp the sleep time to one second. 660 */ 661 ms = clamp(ms, 1U, 1000U); 662 /* 663 * The delay hint is an order-of-magnitude suggestion, not 664 * a minimum. It is fine, possibly even advantageous, for 665 * us to pause for less time than hinted. For small values, 666 * use usleep_range() to ensure we don't sleep much longer 667 * than actually needed. 668 * 669 * See Documentation/timers/timers-howto.rst for 670 * explanation of the threshold used here. In effect we use 671 * usleep_range() for 9900 and 9901, msleep() for 672 * 9902-9905. 673 */ 674 if (ms <= 20) 675 usleep_range(ms * 100, ms * 1000); 676 else 677 msleep(ms); 678 break; 679 case RTAS_BUSY: 680 ret = true; 681 /* 682 * We should call again immediately if there's no other 683 * work to do. 684 */ 685 cond_resched(); 686 break; 687 default: 688 ret = false; 689 /* 690 * Not a busy or extended delay status; the caller should 691 * handle @status itself. Ensure we warn on misuses in 692 * atomic context regardless. 693 */ 694 might_sleep(); 695 break; 696 } 697 698 return ret; 699 } 700 EXPORT_SYMBOL(rtas_busy_delay); 701 702 static int rtas_error_rc(int rtas_rc) 703 { 704 int rc; 705 706 switch (rtas_rc) { 707 case -1: /* Hardware Error */ 708 rc = -EIO; 709 break; 710 case -3: /* Bad indicator/domain/etc */ 711 rc = -EINVAL; 712 break; 713 case -9000: /* Isolation error */ 714 rc = -EFAULT; 715 break; 716 case -9001: /* Outstanding TCE/PTE */ 717 rc = -EEXIST; 718 break; 719 case -9002: /* No usable slot */ 720 rc = -ENODEV; 721 break; 722 default: 723 pr_err("%s: unexpected error %d\n", __func__, rtas_rc); 724 rc = -ERANGE; 725 break; 726 } 727 return rc; 728 } 729 730 int rtas_get_power_level(int powerdomain, int *level) 731 { 732 int token = rtas_token("get-power-level"); 733 int rc; 734 735 if (token == RTAS_UNKNOWN_SERVICE) 736 return -ENOENT; 737 738 while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY) 739 udelay(1); 740 741 if (rc < 0) 742 return rtas_error_rc(rc); 743 return rc; 744 } 745 EXPORT_SYMBOL(rtas_get_power_level); 746 747 int rtas_set_power_level(int powerdomain, int level, int *setlevel) 748 { 749 int token = rtas_token("set-power-level"); 750 int rc; 751 752 if (token == RTAS_UNKNOWN_SERVICE) 753 return -ENOENT; 754 755 do { 756 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level); 757 } while (rtas_busy_delay(rc)); 758 759 if (rc < 0) 760 return rtas_error_rc(rc); 761 return rc; 762 } 763 EXPORT_SYMBOL(rtas_set_power_level); 764 765 int rtas_get_sensor(int sensor, int index, int *state) 766 { 767 int token = rtas_token("get-sensor-state"); 768 int rc; 769 770 if (token == RTAS_UNKNOWN_SERVICE) 771 return -ENOENT; 772 773 do { 774 rc = rtas_call(token, 2, 2, state, sensor, index); 775 } while (rtas_busy_delay(rc)); 776 777 if (rc < 0) 778 return rtas_error_rc(rc); 779 return rc; 780 } 781 EXPORT_SYMBOL(rtas_get_sensor); 782 783 int rtas_get_sensor_fast(int sensor, int index, int *state) 784 { 785 int token = rtas_token("get-sensor-state"); 786 int rc; 787 788 if (token == RTAS_UNKNOWN_SERVICE) 789 return -ENOENT; 790 791 rc = rtas_call(token, 2, 2, state, sensor, index); 792 WARN_ON(rc == RTAS_BUSY || (rc >= RTAS_EXTENDED_DELAY_MIN && 793 rc <= RTAS_EXTENDED_DELAY_MAX)); 794 795 if (rc < 0) 796 return rtas_error_rc(rc); 797 return rc; 798 } 799 800 bool rtas_indicator_present(int token, int *maxindex) 801 { 802 int proplen, count, i; 803 const struct indicator_elem { 804 __be32 token; 805 __be32 maxindex; 806 } *indicators; 807 808 indicators = of_get_property(rtas.dev, "rtas-indicators", &proplen); 809 if (!indicators) 810 return false; 811 812 count = proplen / sizeof(struct indicator_elem); 813 814 for (i = 0; i < count; i++) { 815 if (__be32_to_cpu(indicators[i].token) != token) 816 continue; 817 if (maxindex) 818 *maxindex = __be32_to_cpu(indicators[i].maxindex); 819 return true; 820 } 821 822 return false; 823 } 824 EXPORT_SYMBOL(rtas_indicator_present); 825 826 int rtas_set_indicator(int indicator, int index, int new_value) 827 { 828 int token = rtas_token("set-indicator"); 829 int rc; 830 831 if (token == RTAS_UNKNOWN_SERVICE) 832 return -ENOENT; 833 834 do { 835 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value); 836 } while (rtas_busy_delay(rc)); 837 838 if (rc < 0) 839 return rtas_error_rc(rc); 840 return rc; 841 } 842 EXPORT_SYMBOL(rtas_set_indicator); 843 844 /* 845 * Ignoring RTAS extended delay 846 */ 847 int rtas_set_indicator_fast(int indicator, int index, int new_value) 848 { 849 int rc; 850 int token = rtas_token("set-indicator"); 851 852 if (token == RTAS_UNKNOWN_SERVICE) 853 return -ENOENT; 854 855 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value); 856 857 WARN_ON(rc == RTAS_BUSY || (rc >= RTAS_EXTENDED_DELAY_MIN && 858 rc <= RTAS_EXTENDED_DELAY_MAX)); 859 860 if (rc < 0) 861 return rtas_error_rc(rc); 862 863 return rc; 864 } 865 866 /** 867 * rtas_ibm_suspend_me() - Call ibm,suspend-me to suspend the LPAR. 868 * 869 * @fw_status: RTAS call status will be placed here if not NULL. 870 * 871 * rtas_ibm_suspend_me() should be called only on a CPU which has 872 * received H_CONTINUE from the H_JOIN hcall. All other active CPUs 873 * should be waiting to return from H_JOIN. 874 * 875 * rtas_ibm_suspend_me() may suspend execution of the OS 876 * indefinitely. Callers should take appropriate measures upon return, such as 877 * resetting watchdog facilities. 878 * 879 * Callers may choose to retry this call if @fw_status is 880 * %RTAS_THREADS_ACTIVE. 881 * 882 * Return: 883 * 0 - The partition has resumed from suspend, possibly after 884 * migration to a different host. 885 * -ECANCELED - The operation was aborted. 886 * -EAGAIN - There were other CPUs not in H_JOIN at the time of the call. 887 * -EBUSY - Some other condition prevented the suspend from succeeding. 888 * -EIO - Hardware/platform error. 889 */ 890 int rtas_ibm_suspend_me(int *fw_status) 891 { 892 int fwrc; 893 int ret; 894 895 fwrc = rtas_call(rtas_token("ibm,suspend-me"), 0, 1, NULL); 896 897 switch (fwrc) { 898 case 0: 899 ret = 0; 900 break; 901 case RTAS_SUSPEND_ABORTED: 902 ret = -ECANCELED; 903 break; 904 case RTAS_THREADS_ACTIVE: 905 ret = -EAGAIN; 906 break; 907 case RTAS_NOT_SUSPENDABLE: 908 case RTAS_OUTSTANDING_COPROC: 909 ret = -EBUSY; 910 break; 911 case -1: 912 default: 913 ret = -EIO; 914 break; 915 } 916 917 if (fw_status) 918 *fw_status = fwrc; 919 920 return ret; 921 } 922 923 void __noreturn rtas_restart(char *cmd) 924 { 925 if (rtas_flash_term_hook) 926 rtas_flash_term_hook(SYS_RESTART); 927 pr_emerg("system-reboot returned %d\n", 928 rtas_call(rtas_token("system-reboot"), 0, 1, NULL)); 929 for (;;); 930 } 931 932 void rtas_power_off(void) 933 { 934 if (rtas_flash_term_hook) 935 rtas_flash_term_hook(SYS_POWER_OFF); 936 /* allow power on only with power button press */ 937 pr_emerg("power-off returned %d\n", 938 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1)); 939 for (;;); 940 } 941 942 void __noreturn rtas_halt(void) 943 { 944 if (rtas_flash_term_hook) 945 rtas_flash_term_hook(SYS_HALT); 946 /* allow power on only with power button press */ 947 pr_emerg("power-off returned %d\n", 948 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1)); 949 for (;;); 950 } 951 952 /* Must be in the RMO region, so we place it here */ 953 static char rtas_os_term_buf[2048]; 954 static s32 ibm_os_term_token = RTAS_UNKNOWN_SERVICE; 955 956 void rtas_os_term(char *str) 957 { 958 int status; 959 960 /* 961 * Firmware with the ibm,extended-os-term property is guaranteed 962 * to always return from an ibm,os-term call. Earlier versions without 963 * this property may terminate the partition which we want to avoid 964 * since it interferes with panic_timeout. 965 */ 966 if (ibm_os_term_token == RTAS_UNKNOWN_SERVICE) 967 return; 968 969 snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str); 970 971 /* 972 * Keep calling as long as RTAS returns a "try again" status, 973 * but don't use rtas_busy_delay(), which potentially 974 * schedules. 975 */ 976 do { 977 status = rtas_call(ibm_os_term_token, 1, 1, NULL, 978 __pa(rtas_os_term_buf)); 979 } while (rtas_busy_delay_time(status)); 980 981 if (status != 0) 982 pr_emerg("ibm,os-term call failed %d\n", status); 983 } 984 985 /** 986 * rtas_activate_firmware() - Activate a new version of firmware. 987 * 988 * Context: This function may sleep. 989 * 990 * Activate a new version of partition firmware. The OS must call this 991 * after resuming from a partition hibernation or migration in order 992 * to maintain the ability to perform live firmware updates. It's not 993 * catastrophic for this method to be absent or to fail; just log the 994 * condition in that case. 995 */ 996 void rtas_activate_firmware(void) 997 { 998 int token; 999 int fwrc; 1000 1001 token = rtas_token("ibm,activate-firmware"); 1002 if (token == RTAS_UNKNOWN_SERVICE) { 1003 pr_notice("ibm,activate-firmware method unavailable\n"); 1004 return; 1005 } 1006 1007 do { 1008 fwrc = rtas_call(token, 0, 1, NULL); 1009 } while (rtas_busy_delay(fwrc)); 1010 1011 if (fwrc) 1012 pr_err("ibm,activate-firmware failed (%i)\n", fwrc); 1013 } 1014 1015 /** 1016 * get_pseries_errorlog() - Find a specific pseries error log in an RTAS 1017 * extended event log. 1018 * @log: RTAS error/event log 1019 * @section_id: two character section identifier 1020 * 1021 * Return: A pointer to the specified errorlog or NULL if not found. 1022 */ 1023 noinstr struct pseries_errorlog *get_pseries_errorlog(struct rtas_error_log *log, 1024 uint16_t section_id) 1025 { 1026 struct rtas_ext_event_log_v6 *ext_log = 1027 (struct rtas_ext_event_log_v6 *)log->buffer; 1028 struct pseries_errorlog *sect; 1029 unsigned char *p, *log_end; 1030 uint32_t ext_log_length = rtas_error_extended_log_length(log); 1031 uint8_t log_format = rtas_ext_event_log_format(ext_log); 1032 uint32_t company_id = rtas_ext_event_company_id(ext_log); 1033 1034 /* Check that we understand the format */ 1035 if (ext_log_length < sizeof(struct rtas_ext_event_log_v6) || 1036 log_format != RTAS_V6EXT_LOG_FORMAT_EVENT_LOG || 1037 company_id != RTAS_V6EXT_COMPANY_ID_IBM) 1038 return NULL; 1039 1040 log_end = log->buffer + ext_log_length; 1041 p = ext_log->vendor_log; 1042 1043 while (p < log_end) { 1044 sect = (struct pseries_errorlog *)p; 1045 if (pseries_errorlog_id(sect) == section_id) 1046 return sect; 1047 p += pseries_errorlog_length(sect); 1048 } 1049 1050 return NULL; 1051 } 1052 1053 /* 1054 * The sys_rtas syscall, as originally designed, allows root to pass 1055 * arbitrary physical addresses to RTAS calls. A number of RTAS calls 1056 * can be abused to write to arbitrary memory and do other things that 1057 * are potentially harmful to system integrity, and thus should only 1058 * be used inside the kernel and not exposed to userspace. 1059 * 1060 * All known legitimate users of the sys_rtas syscall will only ever 1061 * pass addresses that fall within the RMO buffer, and use a known 1062 * subset of RTAS calls. 1063 * 1064 * Accordingly, we filter RTAS requests to check that the call is 1065 * permitted, and that provided pointers fall within the RMO buffer. 1066 * The rtas_filters list contains an entry for each permitted call, 1067 * with the indexes of the parameters which are expected to contain 1068 * addresses and sizes of buffers allocated inside the RMO buffer. 1069 */ 1070 struct rtas_filter { 1071 const char *name; 1072 int token; 1073 /* Indexes into the args buffer, -1 if not used */ 1074 int buf_idx1; 1075 int size_idx1; 1076 int buf_idx2; 1077 int size_idx2; 1078 1079 int fixed_size; 1080 }; 1081 1082 static struct rtas_filter rtas_filters[] __ro_after_init = { 1083 { "ibm,activate-firmware", -1, -1, -1, -1, -1 }, 1084 { "ibm,configure-connector", -1, 0, -1, 1, -1, 4096 }, /* Special cased */ 1085 { "display-character", -1, -1, -1, -1, -1 }, 1086 { "ibm,display-message", -1, 0, -1, -1, -1 }, 1087 { "ibm,errinjct", -1, 2, -1, -1, -1, 1024 }, 1088 { "ibm,close-errinjct", -1, -1, -1, -1, -1 }, 1089 { "ibm,open-errinjct", -1, -1, -1, -1, -1 }, 1090 { "ibm,get-config-addr-info2", -1, -1, -1, -1, -1 }, 1091 { "ibm,get-dynamic-sensor-state", -1, 1, -1, -1, -1 }, 1092 { "ibm,get-indices", -1, 2, 3, -1, -1 }, 1093 { "get-power-level", -1, -1, -1, -1, -1 }, 1094 { "get-sensor-state", -1, -1, -1, -1, -1 }, 1095 { "ibm,get-system-parameter", -1, 1, 2, -1, -1 }, 1096 { "get-time-of-day", -1, -1, -1, -1, -1 }, 1097 { "ibm,get-vpd", -1, 0, -1, 1, 2 }, 1098 { "ibm,lpar-perftools", -1, 2, 3, -1, -1 }, 1099 { "ibm,platform-dump", -1, 4, 5, -1, -1 }, /* Special cased */ 1100 { "ibm,read-slot-reset-state", -1, -1, -1, -1, -1 }, 1101 { "ibm,scan-log-dump", -1, 0, 1, -1, -1 }, 1102 { "ibm,set-dynamic-indicator", -1, 2, -1, -1, -1 }, 1103 { "ibm,set-eeh-option", -1, -1, -1, -1, -1 }, 1104 { "set-indicator", -1, -1, -1, -1, -1 }, 1105 { "set-power-level", -1, -1, -1, -1, -1 }, 1106 { "set-time-for-power-on", -1, -1, -1, -1, -1 }, 1107 { "ibm,set-system-parameter", -1, 1, -1, -1, -1 }, 1108 { "set-time-of-day", -1, -1, -1, -1, -1 }, 1109 #ifdef CONFIG_CPU_BIG_ENDIAN 1110 { "ibm,suspend-me", -1, -1, -1, -1, -1 }, 1111 { "ibm,update-nodes", -1, 0, -1, -1, -1, 4096 }, 1112 { "ibm,update-properties", -1, 0, -1, -1, -1, 4096 }, 1113 #endif 1114 { "ibm,physical-attestation", -1, 0, 1, -1, -1 }, 1115 }; 1116 1117 static bool in_rmo_buf(u32 base, u32 end) 1118 { 1119 return base >= rtas_rmo_buf && 1120 base < (rtas_rmo_buf + RTAS_USER_REGION_SIZE) && 1121 base <= end && 1122 end >= rtas_rmo_buf && 1123 end < (rtas_rmo_buf + RTAS_USER_REGION_SIZE); 1124 } 1125 1126 static bool block_rtas_call(int token, int nargs, 1127 struct rtas_args *args) 1128 { 1129 int i; 1130 1131 for (i = 0; i < ARRAY_SIZE(rtas_filters); i++) { 1132 struct rtas_filter *f = &rtas_filters[i]; 1133 u32 base, size, end; 1134 1135 if (token != f->token) 1136 continue; 1137 1138 if (f->buf_idx1 != -1) { 1139 base = be32_to_cpu(args->args[f->buf_idx1]); 1140 if (f->size_idx1 != -1) 1141 size = be32_to_cpu(args->args[f->size_idx1]); 1142 else if (f->fixed_size) 1143 size = f->fixed_size; 1144 else 1145 size = 1; 1146 1147 end = base + size - 1; 1148 1149 /* 1150 * Special case for ibm,platform-dump - NULL buffer 1151 * address is used to indicate end of dump processing 1152 */ 1153 if (!strcmp(f->name, "ibm,platform-dump") && 1154 base == 0) 1155 return false; 1156 1157 if (!in_rmo_buf(base, end)) 1158 goto err; 1159 } 1160 1161 if (f->buf_idx2 != -1) { 1162 base = be32_to_cpu(args->args[f->buf_idx2]); 1163 if (f->size_idx2 != -1) 1164 size = be32_to_cpu(args->args[f->size_idx2]); 1165 else if (f->fixed_size) 1166 size = f->fixed_size; 1167 else 1168 size = 1; 1169 end = base + size - 1; 1170 1171 /* 1172 * Special case for ibm,configure-connector where the 1173 * address can be 0 1174 */ 1175 if (!strcmp(f->name, "ibm,configure-connector") && 1176 base == 0) 1177 return false; 1178 1179 if (!in_rmo_buf(base, end)) 1180 goto err; 1181 } 1182 1183 return false; 1184 } 1185 1186 err: 1187 pr_err_ratelimited("sys_rtas: RTAS call blocked - exploit attempt?\n"); 1188 pr_err_ratelimited("sys_rtas: token=0x%x, nargs=%d (called by %s)\n", 1189 token, nargs, current->comm); 1190 return true; 1191 } 1192 1193 static void __init rtas_syscall_filter_init(void) 1194 { 1195 unsigned int i; 1196 1197 for (i = 0; i < ARRAY_SIZE(rtas_filters); i++) 1198 rtas_filters[i].token = rtas_token(rtas_filters[i].name); 1199 } 1200 1201 /* We assume to be passed big endian arguments */ 1202 SYSCALL_DEFINE1(rtas, struct rtas_args __user *, uargs) 1203 { 1204 struct rtas_args args; 1205 unsigned long flags; 1206 char *buff_copy, *errbuf = NULL; 1207 int nargs, nret, token; 1208 1209 if (!capable(CAP_SYS_ADMIN)) 1210 return -EPERM; 1211 1212 if (!rtas.entry) 1213 return -EINVAL; 1214 1215 if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0) 1216 return -EFAULT; 1217 1218 nargs = be32_to_cpu(args.nargs); 1219 nret = be32_to_cpu(args.nret); 1220 token = be32_to_cpu(args.token); 1221 1222 if (nargs >= ARRAY_SIZE(args.args) 1223 || nret > ARRAY_SIZE(args.args) 1224 || nargs + nret > ARRAY_SIZE(args.args)) 1225 return -EINVAL; 1226 1227 /* Copy in args. */ 1228 if (copy_from_user(args.args, uargs->args, 1229 nargs * sizeof(rtas_arg_t)) != 0) 1230 return -EFAULT; 1231 1232 if (token == RTAS_UNKNOWN_SERVICE) 1233 return -EINVAL; 1234 1235 args.rets = &args.args[nargs]; 1236 memset(args.rets, 0, nret * sizeof(rtas_arg_t)); 1237 1238 if (block_rtas_call(token, nargs, &args)) 1239 return -EINVAL; 1240 1241 if (token == ibm_open_errinjct_token || token == ibm_errinjct_token) { 1242 int err; 1243 1244 err = security_locked_down(LOCKDOWN_RTAS_ERROR_INJECTION); 1245 if (err) 1246 return err; 1247 } 1248 1249 /* Need to handle ibm,suspend_me call specially */ 1250 if (token == rtas_token("ibm,suspend-me")) { 1251 1252 /* 1253 * rtas_ibm_suspend_me assumes the streamid handle is in cpu 1254 * endian, or at least the hcall within it requires it. 1255 */ 1256 int rc = 0; 1257 u64 handle = ((u64)be32_to_cpu(args.args[0]) << 32) 1258 | be32_to_cpu(args.args[1]); 1259 rc = rtas_syscall_dispatch_ibm_suspend_me(handle); 1260 if (rc == -EAGAIN) 1261 args.rets[0] = cpu_to_be32(RTAS_NOT_SUSPENDABLE); 1262 else if (rc == -EIO) 1263 args.rets[0] = cpu_to_be32(-1); 1264 else if (rc) 1265 return rc; 1266 goto copy_return; 1267 } 1268 1269 buff_copy = get_errorlog_buffer(); 1270 1271 flags = lock_rtas(); 1272 1273 rtas.args = args; 1274 do_enter_rtas(__pa(&rtas.args)); 1275 args = rtas.args; 1276 1277 /* A -1 return code indicates that the last command couldn't 1278 be completed due to a hardware error. */ 1279 if (be32_to_cpu(args.rets[0]) == -1) 1280 errbuf = __fetch_rtas_last_error(buff_copy); 1281 1282 unlock_rtas(flags); 1283 1284 if (buff_copy) { 1285 if (errbuf) 1286 log_error(errbuf, ERR_TYPE_RTAS_LOG, 0); 1287 kfree(buff_copy); 1288 } 1289 1290 copy_return: 1291 /* Copy out args. */ 1292 if (copy_to_user(uargs->args + nargs, 1293 args.args + nargs, 1294 nret * sizeof(rtas_arg_t)) != 0) 1295 return -EFAULT; 1296 1297 return 0; 1298 } 1299 1300 /* 1301 * Call early during boot, before mem init, to retrieve the RTAS 1302 * information from the device-tree and allocate the RMO buffer for userland 1303 * accesses. 1304 */ 1305 void __init rtas_initialize(void) 1306 { 1307 unsigned long rtas_region = RTAS_INSTANTIATE_MAX; 1308 u32 base, size, entry; 1309 int no_base, no_size, no_entry; 1310 1311 /* Get RTAS dev node and fill up our "rtas" structure with infos 1312 * about it. 1313 */ 1314 rtas.dev = of_find_node_by_name(NULL, "rtas"); 1315 if (!rtas.dev) 1316 return; 1317 1318 no_base = of_property_read_u32(rtas.dev, "linux,rtas-base", &base); 1319 no_size = of_property_read_u32(rtas.dev, "rtas-size", &size); 1320 if (no_base || no_size) { 1321 of_node_put(rtas.dev); 1322 rtas.dev = NULL; 1323 return; 1324 } 1325 1326 rtas.base = base; 1327 rtas.size = size; 1328 no_entry = of_property_read_u32(rtas.dev, "linux,rtas-entry", &entry); 1329 rtas.entry = no_entry ? rtas.base : entry; 1330 1331 init_error_log_max(); 1332 1333 /* 1334 * Discover these now to avoid device tree lookups in the 1335 * panic path. 1336 */ 1337 if (of_property_read_bool(rtas.dev, "ibm,extended-os-term")) 1338 ibm_os_term_token = rtas_token("ibm,os-term"); 1339 1340 /* If RTAS was found, allocate the RMO buffer for it and look for 1341 * the stop-self token if any 1342 */ 1343 #ifdef CONFIG_PPC64 1344 if (firmware_has_feature(FW_FEATURE_LPAR)) 1345 rtas_region = min(ppc64_rma_size, RTAS_INSTANTIATE_MAX); 1346 #endif 1347 rtas_rmo_buf = memblock_phys_alloc_range(RTAS_USER_REGION_SIZE, PAGE_SIZE, 1348 0, rtas_region); 1349 if (!rtas_rmo_buf) 1350 panic("ERROR: RTAS: Failed to allocate %lx bytes below %pa\n", 1351 PAGE_SIZE, &rtas_region); 1352 1353 #ifdef CONFIG_RTAS_ERROR_LOGGING 1354 rtas_last_error_token = rtas_token("rtas-last-error"); 1355 #endif 1356 ibm_open_errinjct_token = rtas_token("ibm,open-errinjct"); 1357 ibm_errinjct_token = rtas_token("ibm,errinjct"); 1358 rtas_syscall_filter_init(); 1359 } 1360 1361 int __init early_init_dt_scan_rtas(unsigned long node, 1362 const char *uname, int depth, void *data) 1363 { 1364 const u32 *basep, *entryp, *sizep; 1365 1366 if (depth != 1 || strcmp(uname, "rtas") != 0) 1367 return 0; 1368 1369 basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL); 1370 entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL); 1371 sizep = of_get_flat_dt_prop(node, "rtas-size", NULL); 1372 1373 #ifdef CONFIG_PPC64 1374 /* need this feature to decide the crashkernel offset */ 1375 if (of_get_flat_dt_prop(node, "ibm,hypertas-functions", NULL)) 1376 powerpc_firmware_features |= FW_FEATURE_LPAR; 1377 #endif 1378 1379 if (basep && entryp && sizep) { 1380 rtas.base = *basep; 1381 rtas.entry = *entryp; 1382 rtas.size = *sizep; 1383 } 1384 1385 #ifdef CONFIG_UDBG_RTAS_CONSOLE 1386 basep = of_get_flat_dt_prop(node, "put-term-char", NULL); 1387 if (basep) 1388 rtas_putchar_token = *basep; 1389 1390 basep = of_get_flat_dt_prop(node, "get-term-char", NULL); 1391 if (basep) 1392 rtas_getchar_token = *basep; 1393 1394 if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE && 1395 rtas_getchar_token != RTAS_UNKNOWN_SERVICE) 1396 udbg_init_rtas_console(); 1397 1398 #endif 1399 1400 /* break now */ 1401 return 1; 1402 } 1403 1404 static arch_spinlock_t timebase_lock; 1405 static u64 timebase = 0; 1406 1407 void rtas_give_timebase(void) 1408 { 1409 unsigned long flags; 1410 1411 local_irq_save(flags); 1412 hard_irq_disable(); 1413 arch_spin_lock(&timebase_lock); 1414 rtas_call(rtas_token("freeze-time-base"), 0, 1, NULL); 1415 timebase = get_tb(); 1416 arch_spin_unlock(&timebase_lock); 1417 1418 while (timebase) 1419 barrier(); 1420 rtas_call(rtas_token("thaw-time-base"), 0, 1, NULL); 1421 local_irq_restore(flags); 1422 } 1423 1424 void rtas_take_timebase(void) 1425 { 1426 while (!timebase) 1427 barrier(); 1428 arch_spin_lock(&timebase_lock); 1429 set_tb(timebase >> 32, timebase & 0xffffffff); 1430 timebase = 0; 1431 arch_spin_unlock(&timebase_lock); 1432 } 1433