linux/arch/powerpc/kernel/rtas.c
<<
>>
Prefs
   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/export.h>
  19#include <linux/init.h>
  20#include <linux/capability.h>
  21#include <linux/delay.h>
  22#include <linux/cpu.h>
  23#include <linux/smp.h>
  24#include <linux/completion.h>
  25#include <linux/cpumask.h>
  26#include <linux/memblock.h>
  27#include <linux/slab.h>
  28#include <linux/reboot.h>
  29
  30#include <asm/prom.h>
  31#include <asm/rtas.h>
  32#include <asm/hvcall.h>
  33#include <asm/machdep.h>
  34#include <asm/firmware.h>
  35#include <asm/page.h>
  36#include <asm/param.h>
  37#include <asm/delay.h>
  38#include <linux/uaccess.h>
  39#include <asm/udbg.h>
  40#include <asm/syscalls.h>
  41#include <asm/smp.h>
  42#include <linux/atomic.h>
  43#include <asm/time.h>
  44#include <asm/mmu.h>
  45#include <asm/topology.h>
  46
  47/* This is here deliberately so it's only used in this file */
  48void enter_rtas(unsigned long);
  49
  50struct rtas_t rtas = {
  51        .lock = __ARCH_SPIN_LOCK_UNLOCKED
  52};
  53EXPORT_SYMBOL(rtas);
  54
  55DEFINE_SPINLOCK(rtas_data_buf_lock);
  56EXPORT_SYMBOL(rtas_data_buf_lock);
  57
  58char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned;
  59EXPORT_SYMBOL(rtas_data_buf);
  60
  61unsigned 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 */
  67void (*rtas_flash_term_hook)(int);
  68EXPORT_SYMBOL(rtas_flash_term_hook);
  69
  70/* RTAS use home made raw locking instead of spin_lock_irqsave
  71 * because those can be called from within really nasty contexts
  72 * such as having the timebase stopped which would lockup with
  73 * normal locks and spinlock debugging enabled
  74 */
  75static unsigned long lock_rtas(void)
  76{
  77        unsigned long flags;
  78
  79        local_irq_save(flags);
  80        preempt_disable();
  81        arch_spin_lock_flags(&rtas.lock, flags);
  82        return flags;
  83}
  84
  85static void unlock_rtas(unsigned long flags)
  86{
  87        arch_spin_unlock(&rtas.lock);
  88        local_irq_restore(flags);
  89        preempt_enable();
  90}
  91
  92/*
  93 * call_rtas_display_status and call_rtas_display_status_delay
  94 * are designed only for very early low-level debugging, which
  95 * is why the token is hard-coded to 10.
  96 */
  97static void call_rtas_display_status(unsigned char c)
  98{
  99        unsigned long s;
 100
 101        if (!rtas.base)
 102                return;
 103
 104        s = lock_rtas();
 105        rtas_call_unlocked(&rtas.args, 10, 1, 1, NULL, c);
 106        unlock_rtas(s);
 107}
 108
 109static void call_rtas_display_status_delay(char c)
 110{
 111        static int pending_newline = 0;  /* did last write end with unprinted newline? */
 112        static int width = 16;
 113
 114        if (c == '\n') {        
 115                while (width-- > 0)
 116                        call_rtas_display_status(' ');
 117                width = 16;
 118                mdelay(500);
 119                pending_newline = 1;
 120        } else {
 121                if (pending_newline) {
 122                        call_rtas_display_status('\r');
 123                        call_rtas_display_status('\n');
 124                } 
 125                pending_newline = 0;
 126                if (width--) {
 127                        call_rtas_display_status(c);
 128                        udelay(10000);
 129                }
 130        }
 131}
 132
 133void __init udbg_init_rtas_panel(void)
 134{
 135        udbg_putc = call_rtas_display_status_delay;
 136}
 137
 138#ifdef CONFIG_UDBG_RTAS_CONSOLE
 139
 140/* If you think you're dying before early_init_dt_scan_rtas() does its
 141 * work, you can hard code the token values for your firmware here and
 142 * hardcode rtas.base/entry etc.
 143 */
 144static unsigned int rtas_putchar_token = RTAS_UNKNOWN_SERVICE;
 145static unsigned int rtas_getchar_token = RTAS_UNKNOWN_SERVICE;
 146
 147static void udbg_rtascon_putc(char c)
 148{
 149        int tries;
 150
 151        if (!rtas.base)
 152                return;
 153
 154        /* Add CRs before LFs */
 155        if (c == '\n')
 156                udbg_rtascon_putc('\r');
 157
 158        /* if there is more than one character to be displayed, wait a bit */
 159        for (tries = 0; tries < 16; tries++) {
 160                if (rtas_call(rtas_putchar_token, 1, 1, NULL, c) == 0)
 161                        break;
 162                udelay(1000);
 163        }
 164}
 165
 166static int udbg_rtascon_getc_poll(void)
 167{
 168        int c;
 169
 170        if (!rtas.base)
 171                return -1;
 172
 173        if (rtas_call(rtas_getchar_token, 0, 2, &c))
 174                return -1;
 175
 176        return c;
 177}
 178
 179static int udbg_rtascon_getc(void)
 180{
 181        int c;
 182
 183        while ((c = udbg_rtascon_getc_poll()) == -1)
 184                ;
 185
 186        return c;
 187}
 188
 189
 190void __init udbg_init_rtas_console(void)
 191{
 192        udbg_putc = udbg_rtascon_putc;
 193        udbg_getc = udbg_rtascon_getc;
 194        udbg_getc_poll = udbg_rtascon_getc_poll;
 195}
 196#endif /* CONFIG_UDBG_RTAS_CONSOLE */
 197
 198void rtas_progress(char *s, unsigned short hex)
 199{
 200        struct device_node *root;
 201        int width;
 202        const __be32 *p;
 203        char *os;
 204        static int display_character, set_indicator;
 205        static int display_width, display_lines, form_feed;
 206        static const int *row_width;
 207        static DEFINE_SPINLOCK(progress_lock);
 208        static int current_line;
 209        static int pending_newline = 0;  /* did last write end with unprinted newline? */
 210
 211        if (!rtas.base)
 212                return;
 213
 214        if (display_width == 0) {
 215                display_width = 0x10;
 216                if ((root = of_find_node_by_path("/rtas"))) {
 217                        if ((p = of_get_property(root,
 218                                        "ibm,display-line-length", NULL)))
 219                                display_width = be32_to_cpu(*p);
 220                        if ((p = of_get_property(root,
 221                                        "ibm,form-feed", NULL)))
 222                                form_feed = be32_to_cpu(*p);
 223                        if ((p = of_get_property(root,
 224                                        "ibm,display-number-of-lines", NULL)))
 225                                display_lines = be32_to_cpu(*p);
 226                        row_width = of_get_property(root,
 227                                        "ibm,display-truncation-length", NULL);
 228                        of_node_put(root);
 229                }
 230                display_character = rtas_token("display-character");
 231                set_indicator = rtas_token("set-indicator");
 232        }
 233
 234        if (display_character == RTAS_UNKNOWN_SERVICE) {
 235                /* use hex display if available */
 236                if (set_indicator != RTAS_UNKNOWN_SERVICE)
 237                        rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
 238                return;
 239        }
 240
 241        spin_lock(&progress_lock);
 242
 243        /*
 244         * Last write ended with newline, but we didn't print it since
 245         * it would just clear the bottom line of output. Print it now
 246         * instead.
 247         *
 248         * If no newline is pending and form feed is supported, clear the
 249         * display with a form feed; otherwise, print a CR to start output
 250         * at the beginning of the line.
 251         */
 252        if (pending_newline) {
 253                rtas_call(display_character, 1, 1, NULL, '\r');
 254                rtas_call(display_character, 1, 1, NULL, '\n');
 255                pending_newline = 0;
 256        } else {
 257                current_line = 0;
 258                if (form_feed)
 259                        rtas_call(display_character, 1, 1, NULL,
 260                                  (char)form_feed);
 261                else
 262                        rtas_call(display_character, 1, 1, NULL, '\r');
 263        }
 264 
 265        if (row_width)
 266                width = row_width[current_line];
 267        else
 268                width = display_width;
 269        os = s;
 270        while (*os) {
 271                if (*os == '\n' || *os == '\r') {
 272                        /* If newline is the last character, save it
 273                         * until next call to avoid bumping up the
 274                         * display output.
 275                         */
 276                        if (*os == '\n' && !os[1]) {
 277                                pending_newline = 1;
 278                                current_line++;
 279                                if (current_line > display_lines-1)
 280                                        current_line = display_lines-1;
 281                                spin_unlock(&progress_lock);
 282                                return;
 283                        }
 284 
 285                        /* RTAS wants CR-LF, not just LF */
 286 
 287                        if (*os == '\n') {
 288                                rtas_call(display_character, 1, 1, NULL, '\r');
 289                                rtas_call(display_character, 1, 1, NULL, '\n');
 290                        } else {
 291                                /* CR might be used to re-draw a line, so we'll
 292                                 * leave it alone and not add LF.
 293                                 */
 294                                rtas_call(display_character, 1, 1, NULL, *os);
 295                        }
 296 
 297                        if (row_width)
 298                                width = row_width[current_line];
 299                        else
 300                                width = display_width;
 301                } else {
 302                        width--;
 303                        rtas_call(display_character, 1, 1, NULL, *os);
 304                }
 305 
 306                os++;
 307 
 308                /* if we overwrite the screen length */
 309                if (width <= 0)
 310                        while ((*os != 0) && (*os != '\n') && (*os != '\r'))
 311                                os++;
 312        }
 313 
 314        spin_unlock(&progress_lock);
 315}
 316EXPORT_SYMBOL(rtas_progress);           /* needed by rtas_flash module */
 317
 318int rtas_token(const char *service)
 319{
 320        const __be32 *tokp;
 321        if (rtas.dev == NULL)
 322                return RTAS_UNKNOWN_SERVICE;
 323        tokp = of_get_property(rtas.dev, service, NULL);
 324        return tokp ? be32_to_cpu(*tokp) : RTAS_UNKNOWN_SERVICE;
 325}
 326EXPORT_SYMBOL(rtas_token);
 327
 328int rtas_service_present(const char *service)
 329{
 330        return rtas_token(service) != RTAS_UNKNOWN_SERVICE;
 331}
 332EXPORT_SYMBOL(rtas_service_present);
 333
 334#ifdef CONFIG_RTAS_ERROR_LOGGING
 335/*
 336 * Return the firmware-specified size of the error log buffer
 337 *  for all rtas calls that require an error buffer argument.
 338 *  This includes 'check-exception' and 'rtas-last-error'.
 339 */
 340int rtas_get_error_log_max(void)
 341{
 342        static int rtas_error_log_max;
 343        if (rtas_error_log_max)
 344                return rtas_error_log_max;
 345
 346        rtas_error_log_max = rtas_token ("rtas-error-log-max");
 347        if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
 348            (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
 349                printk (KERN_WARNING "RTAS: bad log buffer size %d\n",
 350                        rtas_error_log_max);
 351                rtas_error_log_max = RTAS_ERROR_LOG_MAX;
 352        }
 353        return rtas_error_log_max;
 354}
 355EXPORT_SYMBOL(rtas_get_error_log_max);
 356
 357
 358static char rtas_err_buf[RTAS_ERROR_LOG_MAX];
 359static int rtas_last_error_token;
 360
 361/** Return a copy of the detailed error text associated with the
 362 *  most recent failed call to rtas.  Because the error text
 363 *  might go stale if there are any other intervening rtas calls,
 364 *  this routine must be called atomically with whatever produced
 365 *  the error (i.e. with rtas.lock still held from the previous call).
 366 */
 367static char *__fetch_rtas_last_error(char *altbuf)
 368{
 369        struct rtas_args err_args, save_args;
 370        u32 bufsz;
 371        char *buf = NULL;
 372
 373        if (rtas_last_error_token == -1)
 374                return NULL;
 375
 376        bufsz = rtas_get_error_log_max();
 377
 378        err_args.token = cpu_to_be32(rtas_last_error_token);
 379        err_args.nargs = cpu_to_be32(2);
 380        err_args.nret = cpu_to_be32(1);
 381        err_args.args[0] = cpu_to_be32(__pa(rtas_err_buf));
 382        err_args.args[1] = cpu_to_be32(bufsz);
 383        err_args.args[2] = 0;
 384
 385        save_args = rtas.args;
 386        rtas.args = err_args;
 387
 388        enter_rtas(__pa(&rtas.args));
 389
 390        err_args = rtas.args;
 391        rtas.args = save_args;
 392
 393        /* Log the error in the unlikely case that there was one. */
 394        if (unlikely(err_args.args[2] == 0)) {
 395                if (altbuf) {
 396                        buf = altbuf;
 397                } else {
 398                        buf = rtas_err_buf;
 399                        if (slab_is_available())
 400                                buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
 401                }
 402                if (buf)
 403                        memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX);
 404        }
 405
 406        return buf;
 407}
 408
 409#define get_errorlog_buffer()   kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL)
 410
 411#else /* CONFIG_RTAS_ERROR_LOGGING */
 412#define __fetch_rtas_last_error(x)      NULL
 413#define get_errorlog_buffer()           NULL
 414#endif
 415
 416
 417static void
 418va_rtas_call_unlocked(struct rtas_args *args, int token, int nargs, int nret,
 419                      va_list list)
 420{
 421        int i;
 422
 423        args->token = cpu_to_be32(token);
 424        args->nargs = cpu_to_be32(nargs);
 425        args->nret  = cpu_to_be32(nret);
 426        args->rets  = &(args->args[nargs]);
 427
 428        for (i = 0; i < nargs; ++i)
 429                args->args[i] = cpu_to_be32(va_arg(list, __u32));
 430
 431        for (i = 0; i < nret; ++i)
 432                args->rets[i] = 0;
 433
 434        enter_rtas(__pa(args));
 435}
 436
 437void rtas_call_unlocked(struct rtas_args *args, int token, int nargs, int nret, ...)
 438{
 439        va_list list;
 440
 441        va_start(list, nret);
 442        va_rtas_call_unlocked(args, token, nargs, nret, list);
 443        va_end(list);
 444}
 445
 446int rtas_call(int token, int nargs, int nret, int *outputs, ...)
 447{
 448        va_list list;
 449        int i;
 450        unsigned long s;
 451        struct rtas_args *rtas_args;
 452        char *buff_copy = NULL;
 453        int ret;
 454
 455        if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE)
 456                return -1;
 457
 458        s = lock_rtas();
 459
 460        /* We use the global rtas args buffer */
 461        rtas_args = &rtas.args;
 462
 463        va_start(list, outputs);
 464        va_rtas_call_unlocked(rtas_args, token, nargs, nret, list);
 465        va_end(list);
 466
 467        /* A -1 return code indicates that the last command couldn't
 468           be completed due to a hardware error. */
 469        if (be32_to_cpu(rtas_args->rets[0]) == -1)
 470                buff_copy = __fetch_rtas_last_error(NULL);
 471
 472        if (nret > 1 && outputs != NULL)
 473                for (i = 0; i < nret-1; ++i)
 474                        outputs[i] = be32_to_cpu(rtas_args->rets[i+1]);
 475        ret = (nret > 0)? be32_to_cpu(rtas_args->rets[0]): 0;
 476
 477        unlock_rtas(s);
 478
 479        if (buff_copy) {
 480                log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
 481                if (slab_is_available())
 482                        kfree(buff_copy);
 483        }
 484        return ret;
 485}
 486EXPORT_SYMBOL(rtas_call);
 487
 488/* For RTAS_BUSY (-2), delay for 1 millisecond.  For an extended busy status
 489 * code of 990n, perform the hinted delay of 10^n (last digit) milliseconds.
 490 */
 491unsigned int rtas_busy_delay_time(int status)
 492{
 493        int order;
 494        unsigned int ms = 0;
 495
 496        if (status == RTAS_BUSY) {
 497                ms = 1;
 498        } else if (status >= RTAS_EXTENDED_DELAY_MIN &&
 499                   status <= RTAS_EXTENDED_DELAY_MAX) {
 500                order = status - RTAS_EXTENDED_DELAY_MIN;
 501                for (ms = 1; order > 0; order--)
 502                        ms *= 10;
 503        }
 504
 505        return ms;
 506}
 507EXPORT_SYMBOL(rtas_busy_delay_time);
 508
 509/* For an RTAS busy status code, perform the hinted delay. */
 510unsigned int rtas_busy_delay(int status)
 511{
 512        unsigned int ms;
 513
 514        might_sleep();
 515        ms = rtas_busy_delay_time(status);
 516        if (ms && need_resched())
 517                msleep(ms);
 518
 519        return ms;
 520}
 521EXPORT_SYMBOL(rtas_busy_delay);
 522
 523static int rtas_error_rc(int rtas_rc)
 524{
 525        int rc;
 526
 527        switch (rtas_rc) {
 528                case -1:                /* Hardware Error */
 529                        rc = -EIO;
 530                        break;
 531                case -3:                /* Bad indicator/domain/etc */
 532                        rc = -EINVAL;
 533                        break;
 534                case -9000:             /* Isolation error */
 535                        rc = -EFAULT;
 536                        break;
 537                case -9001:             /* Outstanding TCE/PTE */
 538                        rc = -EEXIST;
 539                        break;
 540                case -9002:             /* No usable slot */
 541                        rc = -ENODEV;
 542                        break;
 543                default:
 544                        printk(KERN_ERR "%s: unexpected RTAS error %d\n",
 545                                        __func__, rtas_rc);
 546                        rc = -ERANGE;
 547                        break;
 548        }
 549        return rc;
 550}
 551
 552int rtas_get_power_level(int powerdomain, int *level)
 553{
 554        int token = rtas_token("get-power-level");
 555        int rc;
 556
 557        if (token == RTAS_UNKNOWN_SERVICE)
 558                return -ENOENT;
 559
 560        while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
 561                udelay(1);
 562
 563        if (rc < 0)
 564                return rtas_error_rc(rc);
 565        return rc;
 566}
 567EXPORT_SYMBOL(rtas_get_power_level);
 568
 569int rtas_set_power_level(int powerdomain, int level, int *setlevel)
 570{
 571        int token = rtas_token("set-power-level");
 572        int rc;
 573
 574        if (token == RTAS_UNKNOWN_SERVICE)
 575                return -ENOENT;
 576
 577        do {
 578                rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
 579        } while (rtas_busy_delay(rc));
 580
 581        if (rc < 0)
 582                return rtas_error_rc(rc);
 583        return rc;
 584}
 585EXPORT_SYMBOL(rtas_set_power_level);
 586
 587int rtas_get_sensor(int sensor, int index, int *state)
 588{
 589        int token = rtas_token("get-sensor-state");
 590        int rc;
 591
 592        if (token == RTAS_UNKNOWN_SERVICE)
 593                return -ENOENT;
 594
 595        do {
 596                rc = rtas_call(token, 2, 2, state, sensor, index);
 597        } while (rtas_busy_delay(rc));
 598
 599        if (rc < 0)
 600                return rtas_error_rc(rc);
 601        return rc;
 602}
 603EXPORT_SYMBOL(rtas_get_sensor);
 604
 605int rtas_get_sensor_fast(int sensor, int index, int *state)
 606{
 607        int token = rtas_token("get-sensor-state");
 608        int rc;
 609
 610        if (token == RTAS_UNKNOWN_SERVICE)
 611                return -ENOENT;
 612
 613        rc = rtas_call(token, 2, 2, state, sensor, index);
 614        WARN_ON(rc == RTAS_BUSY || (rc >= RTAS_EXTENDED_DELAY_MIN &&
 615                                    rc <= RTAS_EXTENDED_DELAY_MAX));
 616
 617        if (rc < 0)
 618                return rtas_error_rc(rc);
 619        return rc;
 620}
 621
 622bool rtas_indicator_present(int token, int *maxindex)
 623{
 624        int proplen, count, i;
 625        const struct indicator_elem {
 626                __be32 token;
 627                __be32 maxindex;
 628        } *indicators;
 629
 630        indicators = of_get_property(rtas.dev, "rtas-indicators", &proplen);
 631        if (!indicators)
 632                return false;
 633
 634        count = proplen / sizeof(struct indicator_elem);
 635
 636        for (i = 0; i < count; i++) {
 637                if (__be32_to_cpu(indicators[i].token) != token)
 638                        continue;
 639                if (maxindex)
 640                        *maxindex = __be32_to_cpu(indicators[i].maxindex);
 641                return true;
 642        }
 643
 644        return false;
 645}
 646EXPORT_SYMBOL(rtas_indicator_present);
 647
 648int rtas_set_indicator(int indicator, int index, int new_value)
 649{
 650        int token = rtas_token("set-indicator");
 651        int rc;
 652
 653        if (token == RTAS_UNKNOWN_SERVICE)
 654                return -ENOENT;
 655
 656        do {
 657                rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
 658        } while (rtas_busy_delay(rc));
 659
 660        if (rc < 0)
 661                return rtas_error_rc(rc);
 662        return rc;
 663}
 664EXPORT_SYMBOL(rtas_set_indicator);
 665
 666/*
 667 * Ignoring RTAS extended delay
 668 */
 669int rtas_set_indicator_fast(int indicator, int index, int new_value)
 670{
 671        int rc;
 672        int token = rtas_token("set-indicator");
 673
 674        if (token == RTAS_UNKNOWN_SERVICE)
 675                return -ENOENT;
 676
 677        rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
 678
 679        WARN_ON(rc == RTAS_BUSY || (rc >= RTAS_EXTENDED_DELAY_MIN &&
 680                                    rc <= RTAS_EXTENDED_DELAY_MAX));
 681
 682        if (rc < 0)
 683                return rtas_error_rc(rc);
 684
 685        return rc;
 686}
 687
 688void __noreturn rtas_restart(char *cmd)
 689{
 690        if (rtas_flash_term_hook)
 691                rtas_flash_term_hook(SYS_RESTART);
 692        printk("RTAS system-reboot returned %d\n",
 693               rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
 694        for (;;);
 695}
 696
 697void rtas_power_off(void)
 698{
 699        if (rtas_flash_term_hook)
 700                rtas_flash_term_hook(SYS_POWER_OFF);
 701        /* allow power on only with power button press */
 702        printk("RTAS power-off returned %d\n",
 703               rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
 704        for (;;);
 705}
 706
 707void __noreturn rtas_halt(void)
 708{
 709        if (rtas_flash_term_hook)
 710                rtas_flash_term_hook(SYS_HALT);
 711        /* allow power on only with power button press */
 712        printk("RTAS power-off returned %d\n",
 713               rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
 714        for (;;);
 715}
 716
 717/* Must be in the RMO region, so we place it here */
 718static char rtas_os_term_buf[2048];
 719
 720void rtas_os_term(char *str)
 721{
 722        int status;
 723
 724        /*
 725         * Firmware with the ibm,extended-os-term property is guaranteed
 726         * to always return from an ibm,os-term call. Earlier versions without
 727         * this property may terminate the partition which we want to avoid
 728         * since it interferes with panic_timeout.
 729         */
 730        if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term") ||
 731            RTAS_UNKNOWN_SERVICE == rtas_token("ibm,extended-os-term"))
 732                return;
 733
 734        snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
 735
 736        do {
 737                status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
 738                                   __pa(rtas_os_term_buf));
 739        } while (rtas_busy_delay(status));
 740
 741        if (status != 0)
 742                printk(KERN_EMERG "ibm,os-term call failed %d\n", status);
 743}
 744
 745static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
 746#ifdef CONFIG_PPC_PSERIES
 747static int __rtas_suspend_last_cpu(struct rtas_suspend_me_data *data, int wake_when_done)
 748{
 749        u16 slb_size = mmu_slb_size;
 750        int rc = H_MULTI_THREADS_ACTIVE;
 751        int cpu;
 752
 753        slb_set_size(SLB_MIN_SIZE);
 754        printk(KERN_DEBUG "calling ibm,suspend-me on cpu %i\n", smp_processor_id());
 755
 756        while (rc == H_MULTI_THREADS_ACTIVE && !atomic_read(&data->done) &&
 757               !atomic_read(&data->error))
 758                rc = rtas_call(data->token, 0, 1, NULL);
 759
 760        if (rc || atomic_read(&data->error)) {
 761                printk(KERN_DEBUG "ibm,suspend-me returned %d\n", rc);
 762                slb_set_size(slb_size);
 763        }
 764
 765        if (atomic_read(&data->error))
 766                rc = atomic_read(&data->error);
 767
 768        atomic_set(&data->error, rc);
 769        pSeries_coalesce_init();
 770
 771        if (wake_when_done) {
 772                atomic_set(&data->done, 1);
 773
 774                for_each_online_cpu(cpu)
 775                        plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu));
 776        }
 777
 778        if (atomic_dec_return(&data->working) == 0)
 779                complete(data->complete);
 780
 781        return rc;
 782}
 783
 784int rtas_suspend_last_cpu(struct rtas_suspend_me_data *data)
 785{
 786        atomic_inc(&data->working);
 787        return __rtas_suspend_last_cpu(data, 0);
 788}
 789
 790static int __rtas_suspend_cpu(struct rtas_suspend_me_data *data, int wake_when_done)
 791{
 792        long rc = H_SUCCESS;
 793        unsigned long msr_save;
 794        int cpu;
 795
 796        atomic_inc(&data->working);
 797
 798        /* really need to ensure MSR.EE is off for H_JOIN */
 799        msr_save = mfmsr();
 800        mtmsr(msr_save & ~(MSR_EE));
 801
 802        while (rc == H_SUCCESS && !atomic_read(&data->done) && !atomic_read(&data->error))
 803                rc = plpar_hcall_norets(H_JOIN);
 804
 805        mtmsr(msr_save);
 806
 807        if (rc == H_SUCCESS) {
 808                /* This cpu was prodded and the suspend is complete. */
 809                goto out;
 810        } else if (rc == H_CONTINUE) {
 811                /* All other cpus are in H_JOIN, this cpu does
 812                 * the suspend.
 813                 */
 814                return __rtas_suspend_last_cpu(data, wake_when_done);
 815        } else {
 816                printk(KERN_ERR "H_JOIN on cpu %i failed with rc = %ld\n",
 817                       smp_processor_id(), rc);
 818                atomic_set(&data->error, rc);
 819        }
 820
 821        if (wake_when_done) {
 822                atomic_set(&data->done, 1);
 823
 824                /* This cpu did the suspend or got an error; in either case,
 825                 * we need to prod all other other cpus out of join state.
 826                 * Extra prods are harmless.
 827                 */
 828                for_each_online_cpu(cpu)
 829                        plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu));
 830        }
 831out:
 832        if (atomic_dec_return(&data->working) == 0)
 833                complete(data->complete);
 834        return rc;
 835}
 836
 837int rtas_suspend_cpu(struct rtas_suspend_me_data *data)
 838{
 839        return __rtas_suspend_cpu(data, 0);
 840}
 841
 842static void rtas_percpu_suspend_me(void *info)
 843{
 844        __rtas_suspend_cpu((struct rtas_suspend_me_data *)info, 1);
 845}
 846
 847enum rtas_cpu_state {
 848        DOWN,
 849        UP,
 850};
 851
 852#ifndef CONFIG_SMP
 853static int rtas_cpu_state_change_mask(enum rtas_cpu_state state,
 854                                cpumask_var_t cpus)
 855{
 856        if (!cpumask_empty(cpus)) {
 857                cpumask_clear(cpus);
 858                return -EINVAL;
 859        } else
 860                return 0;
 861}
 862#else
 863/* On return cpumask will be altered to indicate CPUs changed.
 864 * CPUs with states changed will be set in the mask,
 865 * CPUs with status unchanged will be unset in the mask. */
 866static int rtas_cpu_state_change_mask(enum rtas_cpu_state state,
 867                                cpumask_var_t cpus)
 868{
 869        int cpu;
 870        int cpuret = 0;
 871        int ret = 0;
 872
 873        if (cpumask_empty(cpus))
 874                return 0;
 875
 876        for_each_cpu(cpu, cpus) {
 877                switch (state) {
 878                case DOWN:
 879                        cpuret = cpu_down(cpu);
 880                        break;
 881                case UP:
 882                        cpuret = cpu_up(cpu);
 883                        break;
 884                }
 885                if (cpuret) {
 886                        pr_debug("%s: cpu_%s for cpu#%d returned %d.\n",
 887                                        __func__,
 888                                        ((state == UP) ? "up" : "down"),
 889                                        cpu, cpuret);
 890                        if (!ret)
 891                                ret = cpuret;
 892                        if (state == UP) {
 893                                /* clear bits for unchanged cpus, return */
 894                                cpumask_shift_right(cpus, cpus, cpu);
 895                                cpumask_shift_left(cpus, cpus, cpu);
 896                                break;
 897                        } else {
 898                                /* clear bit for unchanged cpu, continue */
 899                                cpumask_clear_cpu(cpu, cpus);
 900                        }
 901                }
 902        }
 903
 904        return ret;
 905}
 906#endif
 907
 908int rtas_online_cpus_mask(cpumask_var_t cpus)
 909{
 910        int ret;
 911
 912        ret = rtas_cpu_state_change_mask(UP, cpus);
 913
 914        if (ret) {
 915                cpumask_var_t tmp_mask;
 916
 917                if (!alloc_cpumask_var(&tmp_mask, GFP_TEMPORARY))
 918                        return ret;
 919
 920                /* Use tmp_mask to preserve cpus mask from first failure */
 921                cpumask_copy(tmp_mask, cpus);
 922                rtas_offline_cpus_mask(tmp_mask);
 923                free_cpumask_var(tmp_mask);
 924        }
 925
 926        return ret;
 927}
 928EXPORT_SYMBOL(rtas_online_cpus_mask);
 929
 930int rtas_offline_cpus_mask(cpumask_var_t cpus)
 931{
 932        return rtas_cpu_state_change_mask(DOWN, cpus);
 933}
 934EXPORT_SYMBOL(rtas_offline_cpus_mask);
 935
 936int rtas_ibm_suspend_me(u64 handle)
 937{
 938        long state;
 939        long rc;
 940        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
 941        struct rtas_suspend_me_data data;
 942        DECLARE_COMPLETION_ONSTACK(done);
 943        cpumask_var_t offline_mask;
 944        int cpuret;
 945
 946        if (!rtas_service_present("ibm,suspend-me"))
 947                return -ENOSYS;
 948
 949        /* Make sure the state is valid */
 950        rc = plpar_hcall(H_VASI_STATE, retbuf, handle);
 951
 952        state = retbuf[0];
 953
 954        if (rc) {
 955                printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
 956                return rc;
 957        } else if (state == H_VASI_ENABLED) {
 958                return -EAGAIN;
 959        } else if (state != H_VASI_SUSPENDING) {
 960                printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n",
 961                       state);
 962                return -EIO;
 963        }
 964
 965        if (!alloc_cpumask_var(&offline_mask, GFP_TEMPORARY))
 966                return -ENOMEM;
 967
 968        atomic_set(&data.working, 0);
 969        atomic_set(&data.done, 0);
 970        atomic_set(&data.error, 0);
 971        data.token = rtas_token("ibm,suspend-me");
 972        data.complete = &done;
 973
 974        /* All present CPUs must be online */
 975        cpumask_andnot(offline_mask, cpu_present_mask, cpu_online_mask);
 976        cpuret = rtas_online_cpus_mask(offline_mask);
 977        if (cpuret) {
 978                pr_err("%s: Could not bring present CPUs online.\n", __func__);
 979                atomic_set(&data.error, cpuret);
 980                goto out;
 981        }
 982
 983        stop_topology_update();
 984
 985        /* Call function on all CPUs.  One of us will make the
 986         * rtas call
 987         */
 988        if (on_each_cpu(rtas_percpu_suspend_me, &data, 0))
 989                atomic_set(&data.error, -EINVAL);
 990
 991        wait_for_completion(&done);
 992
 993        if (atomic_read(&data.error) != 0)
 994                printk(KERN_ERR "Error doing global join\n");
 995
 996        start_topology_update();
 997
 998        /* Take down CPUs not online prior to suspend */
 999        cpuret = rtas_offline_cpus_mask(offline_mask);
1000        if (cpuret)
1001                pr_warn("%s: Could not restore CPUs to offline state.\n",
1002                                __func__);
1003
1004out:
1005        free_cpumask_var(offline_mask);
1006        return atomic_read(&data.error);
1007}
1008#else /* CONFIG_PPC_PSERIES */
1009int rtas_ibm_suspend_me(u64 handle)
1010{
1011        return -ENOSYS;
1012}
1013#endif
1014
1015/**
1016 * Find a specific pseries error log in an RTAS extended event log.
1017 * @log: RTAS error/event log
1018 * @section_id: two character section identifier
1019 *
1020 * Returns a pointer to the specified errorlog or NULL if not found.
1021 */
1022struct pseries_errorlog *get_pseries_errorlog(struct rtas_error_log *log,
1023                                              uint16_t section_id)
1024{
1025        struct rtas_ext_event_log_v6 *ext_log =
1026                (struct rtas_ext_event_log_v6 *)log->buffer;
1027        struct pseries_errorlog *sect;
1028        unsigned char *p, *log_end;
1029        uint32_t ext_log_length = rtas_error_extended_log_length(log);
1030        uint8_t log_format = rtas_ext_event_log_format(ext_log);
1031        uint32_t company_id = rtas_ext_event_company_id(ext_log);
1032
1033        /* Check that we understand the format */
1034        if (ext_log_length < sizeof(struct rtas_ext_event_log_v6) ||
1035            log_format != RTAS_V6EXT_LOG_FORMAT_EVENT_LOG ||
1036            company_id != RTAS_V6EXT_COMPANY_ID_IBM)
1037                return NULL;
1038
1039        log_end = log->buffer + ext_log_length;
1040        p = ext_log->vendor_log;
1041
1042        while (p < log_end) {
1043                sect = (struct pseries_errorlog *)p;
1044                if (pseries_errorlog_id(sect) == section_id)
1045                        return sect;
1046                p += pseries_errorlog_length(sect);
1047        }
1048
1049        return NULL;
1050}
1051
1052/* We assume to be passed big endian arguments */
1053asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
1054{
1055        struct rtas_args args;
1056        unsigned long flags;
1057        char *buff_copy, *errbuf = NULL;
1058        int nargs, nret, token;
1059
1060        if (!capable(CAP_SYS_ADMIN))
1061                return -EPERM;
1062
1063        if (!rtas.entry)
1064                return -EINVAL;
1065
1066        if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
1067                return -EFAULT;
1068
1069        nargs = be32_to_cpu(args.nargs);
1070        nret  = be32_to_cpu(args.nret);
1071        token = be32_to_cpu(args.token);
1072
1073        if (nargs >= ARRAY_SIZE(args.args)
1074            || nret > ARRAY_SIZE(args.args)
1075            || nargs + nret > ARRAY_SIZE(args.args))
1076                return -EINVAL;
1077
1078        /* Copy in args. */
1079        if (copy_from_user(args.args, uargs->args,
1080                           nargs * sizeof(rtas_arg_t)) != 0)
1081                return -EFAULT;
1082
1083        if (token == RTAS_UNKNOWN_SERVICE)
1084                return -EINVAL;
1085
1086        args.rets = &args.args[nargs];
1087        memset(args.rets, 0, nret * sizeof(rtas_arg_t));
1088
1089        /* Need to handle ibm,suspend_me call specially */
1090        if (token == ibm_suspend_me_token) {
1091
1092                /*
1093                 * rtas_ibm_suspend_me assumes the streamid handle is in cpu
1094                 * endian, or at least the hcall within it requires it.
1095                 */
1096                int rc = 0;
1097                u64 handle = ((u64)be32_to_cpu(args.args[0]) << 32)
1098                              | be32_to_cpu(args.args[1]);
1099                rc = rtas_ibm_suspend_me(handle);
1100                if (rc == -EAGAIN)
1101                        args.rets[0] = cpu_to_be32(RTAS_NOT_SUSPENDABLE);
1102                else if (rc == -EIO)
1103                        args.rets[0] = cpu_to_be32(-1);
1104                else if (rc)
1105                        return rc;
1106                goto copy_return;
1107        }
1108
1109        buff_copy = get_errorlog_buffer();
1110
1111        flags = lock_rtas();
1112
1113        rtas.args = args;
1114        enter_rtas(__pa(&rtas.args));
1115        args = rtas.args;
1116
1117        /* A -1 return code indicates that the last command couldn't
1118           be completed due to a hardware error. */
1119        if (be32_to_cpu(args.rets[0]) == -1)
1120                errbuf = __fetch_rtas_last_error(buff_copy);
1121
1122        unlock_rtas(flags);
1123
1124        if (buff_copy) {
1125                if (errbuf)
1126                        log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
1127                kfree(buff_copy);
1128        }
1129
1130 copy_return:
1131        /* Copy out args. */
1132        if (copy_to_user(uargs->args + nargs,
1133                         args.args + nargs,
1134                         nret * sizeof(rtas_arg_t)) != 0)
1135                return -EFAULT;
1136
1137        return 0;
1138}
1139
1140/*
1141 * Call early during boot, before mem init, to retrieve the RTAS
1142 * information from the device-tree and allocate the RMO buffer for userland
1143 * accesses.
1144 */
1145void __init rtas_initialize(void)
1146{
1147        unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
1148        u32 base, size, entry;
1149        int no_base, no_size, no_entry;
1150
1151        /* Get RTAS dev node and fill up our "rtas" structure with infos
1152         * about it.
1153         */
1154        rtas.dev = of_find_node_by_name(NULL, "rtas");
1155        if (!rtas.dev)
1156                return;
1157
1158        no_base = of_property_read_u32(rtas.dev, "linux,rtas-base", &base);
1159        no_size = of_property_read_u32(rtas.dev, "rtas-size", &size);
1160        if (no_base || no_size) {
1161                of_node_put(rtas.dev);
1162                rtas.dev = NULL;
1163                return;
1164        }
1165
1166        rtas.base = base;
1167        rtas.size = size;
1168        no_entry = of_property_read_u32(rtas.dev, "linux,rtas-entry", &entry);
1169        rtas.entry = no_entry ? rtas.base : entry;
1170
1171        /* If RTAS was found, allocate the RMO buffer for it and look for
1172         * the stop-self token if any
1173         */
1174#ifdef CONFIG_PPC64
1175        if (firmware_has_feature(FW_FEATURE_LPAR)) {
1176                rtas_region = min(ppc64_rma_size, RTAS_INSTANTIATE_MAX);
1177                ibm_suspend_me_token = rtas_token("ibm,suspend-me");
1178        }
1179#endif
1180        rtas_rmo_buf = memblock_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
1181
1182#ifdef CONFIG_RTAS_ERROR_LOGGING
1183        rtas_last_error_token = rtas_token("rtas-last-error");
1184#endif
1185}
1186
1187int __init early_init_dt_scan_rtas(unsigned long node,
1188                const char *uname, int depth, void *data)
1189{
1190        const u32 *basep, *entryp, *sizep;
1191
1192        if (depth != 1 || strcmp(uname, "rtas") != 0)
1193                return 0;
1194
1195        basep  = of_get_flat_dt_prop(node, "linux,rtas-base", NULL);
1196        entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL);
1197        sizep  = of_get_flat_dt_prop(node, "rtas-size", NULL);
1198
1199        if (basep && entryp && sizep) {
1200                rtas.base = *basep;
1201                rtas.entry = *entryp;
1202                rtas.size = *sizep;
1203        }
1204
1205#ifdef CONFIG_UDBG_RTAS_CONSOLE
1206        basep = of_get_flat_dt_prop(node, "put-term-char", NULL);
1207        if (basep)
1208                rtas_putchar_token = *basep;
1209
1210        basep = of_get_flat_dt_prop(node, "get-term-char", NULL);
1211        if (basep)
1212                rtas_getchar_token = *basep;
1213
1214        if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE &&
1215            rtas_getchar_token != RTAS_UNKNOWN_SERVICE)
1216                udbg_init_rtas_console();
1217
1218#endif
1219
1220        /* break now */
1221        return 1;
1222}
1223
1224static arch_spinlock_t timebase_lock;
1225static u64 timebase = 0;
1226
1227void rtas_give_timebase(void)
1228{
1229        unsigned long flags;
1230
1231        local_irq_save(flags);
1232        hard_irq_disable();
1233        arch_spin_lock(&timebase_lock);
1234        rtas_call(rtas_token("freeze-time-base"), 0, 1, NULL);
1235        timebase = get_tb();
1236        arch_spin_unlock(&timebase_lock);
1237
1238        while (timebase)
1239                barrier();
1240        rtas_call(rtas_token("thaw-time-base"), 0, 1, NULL);
1241        local_irq_restore(flags);
1242}
1243
1244void rtas_take_timebase(void)
1245{
1246        while (!timebase)
1247                barrier();
1248        arch_spin_lock(&timebase_lock);
1249        set_tb(timebase >> 32, timebase & 0xffffffff);
1250        timebase = 0;
1251        arch_spin_unlock(&timebase_lock);
1252}
1253