git.oblomov.eu Git - linux-2.6/blob - arch/ppc64/kernel/rtas.c

   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
  21 #include <asm/prom.h>
  22 #include <asm/rtas.h>
  23 #include <asm/semaphore.h>
  24 #include <asm/machdep.h>
  25 #include <asm/page.h>
  26 #include <asm/param.h>
  27 #include <asm/system.h>
  28 #include <asm/abs_addr.h>
  29 #include <asm/udbg.h>
  30 #include <asm/delay.h>
  31 #include <asm/uaccess.h>
  32 #include <asm/systemcfg.h>
  33
  34 struct flash_block_list_header rtas_firmware_flash_list = {0, NULL};
  35
  36 struct rtas_t rtas = {
  37         .lock = SPIN_LOCK_UNLOCKED
  38 };
  39
  40 EXPORT_SYMBOL(rtas);
  41
  42 char rtas_err_buf[RTAS_ERROR_LOG_MAX];
  43
  44 DEFINE_SPINLOCK(rtas_data_buf_lock);
  45 char rtas_data_buf[RTAS_DATA_BUF_SIZE]__page_aligned;
  46 unsigned long rtas_rmo_buf;
  47
  48 void
  49 call_rtas_display_status(unsigned char c)
  50 {
  51         struct rtas_args *args = &rtas.args;
  52         unsigned long s;
  53
  54         if (!rtas.base)
  55                 return;
  56         spin_lock_irqsave(&rtas.lock, s);
  57
  58         args->token = 10;
  59         args->nargs = 1;
  60         args->nret  = 1;
  61         args->rets  = (rtas_arg_t *)&(args->args[1]);
  62         args->args[0] = (int)c;
  63
  64         enter_rtas(__pa(args));
  65
  66         spin_unlock_irqrestore(&rtas.lock, s);
  67 }
  68
  69 void
  70 call_rtas_display_status_delay(unsigned char c)
  71 {
  72         static int pending_newline = 0;  /* did last write end with unprinted newline? */
  73         static int width = 16;
  74
  75         if (c == '\n') {
  76                 while (width-- > 0)
  77                         call_rtas_display_status(' ');
  78                 width = 16;
  79                 udelay(500000);
  80                 pending_newline = 1;
  81         } else {
  82                 if (pending_newline) {
  83                         call_rtas_display_status('\r');
  84                         call_rtas_display_status('\n');
  85                 }
  86                 pending_newline = 0;
  87                 if (width--) {
  88                         call_rtas_display_status(c);
  89                         udelay(10000);
  90                 }
  91         }
  92 }
  93
  94 void
  95 rtas_progress(char *s, unsigned short hex)
  96 {
  97         struct device_node *root;
  98         int width, *p;
  99         char *os;
 100         static int display_character, set_indicator;
 101         static int display_width, display_lines, *row_width, form_feed;
 102         static DEFINE_SPINLOCK(progress_lock);
 103         static int current_line;
 104         static int pending_newline = 0;  /* did last write end with unprinted newline? */
 105
 106         if (!rtas.base)
 107                 return;
 108
 109         if (display_width == 0) {
 110                 display_width = 0x10;
 111                 if ((root = find_path_device("/rtas"))) {
 112                         if ((p = (unsigned int *)get_property(root,
 113                                         "ibm,display-line-length", NULL)))
 114                                 display_width = *p;
 115                         if ((p = (unsigned int *)get_property(root,
 116                                         "ibm,form-feed", NULL)))
 117                                 form_feed = *p;
 118                         if ((p = (unsigned int *)get_property(root,
 119                                         "ibm,display-number-of-lines", NULL)))
 120                                 display_lines = *p;
 121                         row_width = (unsigned int *)get_property(root,
 122                                         "ibm,display-truncation-length", NULL);
 123                 }
 124                 display_character = rtas_token("display-character");
 125                 set_indicator = rtas_token("set-indicator");
 126         }
 127
 128         if (display_character == RTAS_UNKNOWN_SERVICE) {
 129                 /* use hex display if available */
 130                 if (set_indicator != RTAS_UNKNOWN_SERVICE)
 131                         rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
 132                 return;
 133         }
 134
 135         spin_lock(&progress_lock);
 136
 137         /*
 138          * Last write ended with newline, but we didn't print it since
 139          * it would just clear the bottom line of output. Print it now
 140          * instead.
 141          *
 142          * If no newline is pending and form feed is supported, clear the
 143          * display with a form feed; otherwise, print a CR to start output
 144          * at the beginning of the line.
 145          */
 146         if (pending_newline) {
 147                 rtas_call(display_character, 1, 1, NULL, '\r');
 148                 rtas_call(display_character, 1, 1, NULL, '\n');
 149                 pending_newline = 0;
 150         } else {
 151                 current_line = 0;
 152                 if (form_feed)
 153                         rtas_call(display_character, 1, 1, NULL,
 154                                   (char)form_feed);
 155                 else
 156                         rtas_call(display_character, 1, 1, NULL, '\r');
 157         }
 158
 159         if (row_width)
 160                 width = row_width[current_line];
 161         else
 162                 width = display_width;
 163         os = s;
 164         while (*os) {
 165                 if (*os == '\n' || *os == '\r') {
 166                         /* If newline is the last character, save it
 167                          * until next call to avoid bumping up the
 168                          * display output.
 169                          */
 170                         if (*os == '\n' && !os[1]) {
 171                                 pending_newline = 1;
 172                                 current_line++;
 173                                 if (current_line > display_lines-1)
 174                                         current_line = display_lines-1;
 175                                 spin_unlock(&progress_lock);
 176                                 return;
 177                         }
 178
 179                         /* RTAS wants CR-LF, not just LF */
 180
 181                         if (*os == '\n') {
 182                                 rtas_call(display_character, 1, 1, NULL, '\r');
 183                                 rtas_call(display_character, 1, 1, NULL, '\n');
 184                         } else {
 185                                 /* CR might be used to re-draw a line, so we'll
 186                                  * leave it alone and not add LF.
 187                                  */
 188                                 rtas_call(display_character, 1, 1, NULL, *os);
 189                         }
 190
 191                         if (row_width)
 192                                 width = row_width[current_line];
 193                         else
 194                                 width = display_width;
 195                 } else {
 196                         width--;
 197                         rtas_call(display_character, 1, 1, NULL, *os);
 198                 }
 199
 200                 os++;
 201
 202                 /* if we overwrite the screen length */
 203                 if (width <= 0)
 204                         while ((*os != 0) && (*os != '\n') && (*os != '\r'))
 205                                 os++;
 206         }
 207
 208         spin_unlock(&progress_lock);
 209 }
 210
 211 int
 212 rtas_token(const char *service)
 213 {
 214         int *tokp;
 215         if (rtas.dev == NULL) {
 216                 PPCDBG(PPCDBG_RTAS,"\tNo rtas device in device-tree...\n");
 217                 return RTAS_UNKNOWN_SERVICE;
 218         }
 219         tokp = (int *) get_property(rtas.dev, service, NULL);
 220         return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
 221 }
 222
 223 /*
 224  * Return the firmware-specified size of the error log buffer
 225  *  for all rtas calls that require an error buffer argument.
 226  *  This includes 'check-exception' and 'rtas-last-error'.
 227  */
 228 int rtas_get_error_log_max(void)
 229 {
 230         static int rtas_error_log_max;
 231         if (rtas_error_log_max)
 232                 return rtas_error_log_max;
 233
 234         rtas_error_log_max = rtas_token ("rtas-error-log-max");
 235         if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
 236             (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
 237                 printk (KERN_WARNING "RTAS: bad log buffer size %d\n", rtas_error_log_max);
 238                 rtas_error_log_max = RTAS_ERROR_LOG_MAX;
 239         }
 240         return rtas_error_log_max;
 241 }
 242
 243
 244 /** Return a copy of the detailed error text associated with the
 245  *  most recent failed call to rtas.  Because the error text
 246  *  might go stale if there are any other intervening rtas calls,
 247  *  this routine must be called atomically with whatever produced
 248  *  the error (i.e. with rtas.lock still held from the previous call).
 249  */
 250 static int
 251 __fetch_rtas_last_error(void)
 252 {
 253         struct rtas_args err_args, save_args;
 254         u32 bufsz;
 255
 256         bufsz = rtas_get_error_log_max();
 257
 258         err_args.token = rtas_token("rtas-last-error");
 259         err_args.nargs = 2;
 260         err_args.nret = 1;
 261
 262         err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
 263         err_args.args[1] = bufsz;
 264         err_args.args[2] = 0;
 265
 266         save_args = rtas.args;
 267         rtas.args = err_args;
 268
 269         enter_rtas(__pa(&rtas.args));
 270
 271         err_args = rtas.args;
 272         rtas.args = save_args;
 273
 274         return err_args.args[2];
 275 }
 276
 277 int rtas_call(int token, int nargs, int nret, int *outputs, ...)
 278 {
 279         va_list list;
 280         int i, logit = 0;
 281         unsigned long s;
 282         struct rtas_args *rtas_args;
 283         char * buff_copy = NULL;
 284         int ret;
 285
 286         PPCDBG(PPCDBG_RTAS, "Entering rtas_call\n");
 287         PPCDBG(PPCDBG_RTAS, "\ttoken    = 0x%x\n", token);
 288         PPCDBG(PPCDBG_RTAS, "\tnargs    = %d\n", nargs);
 289         PPCDBG(PPCDBG_RTAS, "\tnret     = %d\n", nret);
 290         PPCDBG(PPCDBG_RTAS, "\t&outputs = 0x%lx\n", outputs);
 291         if (token == RTAS_UNKNOWN_SERVICE)
 292                 return -1;
 293
 294         /* Gotta do something different here, use global lock for now... */
 295         spin_lock_irqsave(&rtas.lock, s);
 296         rtas_args = &rtas.args;
 297
 298         rtas_args->token = token;
 299         rtas_args->nargs = nargs;
 300         rtas_args->nret  = nret;
 301         rtas_args->rets  = (rtas_arg_t *)&(rtas_args->args[nargs]);
 302         va_start(list, outputs);
 303         for (i = 0; i < nargs; ++i) {
 304                 rtas_args->args[i] = va_arg(list, rtas_arg_t);
 305                 PPCDBG(PPCDBG_RTAS, "\tnarg[%d] = 0x%x\n", i, rtas_args->args[i]);
 306         }
 307         va_end(list);
 308
 309         for (i = 0; i < nret; ++i)
 310                 rtas_args->rets[i] = 0;
 311
 312         PPCDBG(PPCDBG_RTAS, "\tentering rtas with 0x%lx\n",
 313                 __pa(rtas_args));
 314         enter_rtas(__pa(rtas_args));
 315         PPCDBG(PPCDBG_RTAS, "\treturned from rtas ...\n");
 316
 317         /* A -1 return code indicates that the last command couldn't
 318            be completed due to a hardware error. */
 319         if (rtas_args->rets[0] == -1)
 320                 logit = (__fetch_rtas_last_error() == 0);
 321
 322         ifppcdebug(PPCDBG_RTAS) {
 323                 for(i=0; i < nret ;i++)
 324                         udbg_printf("\tnret[%d] = 0x%lx\n", i, (ulong)rtas_args->rets[i]);
 325         }
 326
 327         if (nret > 1 && outputs != NULL)
 328                 for (i = 0; i < nret-1; ++i)
 329                         outputs[i] = rtas_args->rets[i+1];
 330         ret = (nret > 0)? rtas_args->rets[0]: 0;
 331
 332         /* Log the error in the unlikely case that there was one. */
 333         if (unlikely(logit)) {
 334                 buff_copy = rtas_err_buf;
 335                 if (mem_init_done) {
 336                         buff_copy = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
 337                         if (buff_copy)
 338                                 memcpy(buff_copy, rtas_err_buf,
 339                                        RTAS_ERROR_LOG_MAX);
 340                 }
 341         }
 342
 343         /* Gotta do something different here, use global lock for now... */
 344         spin_unlock_irqrestore(&rtas.lock, s);
 345
 346         if (buff_copy) {
 347                 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
 348                 if (mem_init_done)
 349                         kfree(buff_copy);
 350         }
 351         return ret;
 352 }
 353
 354 /* Given an RTAS status code of 990n compute the hinted delay of 10^n
 355  * (last digit) milliseconds.  For now we bound at n=5 (100 sec).
 356  */
 357 unsigned int
 358 rtas_extended_busy_delay_time(int status)
 359 {
 360         int order = status - 9900;
 361         unsigned long ms;
 362
 363         if (order < 0)
 364                 order = 0;      /* RTC depends on this for -2 clock busy */
 365         else if (order > 5)
 366                 order = 5;      /* bound */
 367
 368         /* Use microseconds for reasonable accuracy */
 369         for (ms=1; order > 0; order--)
 370                 ms *= 10;
 371
 372         return ms;
 373 }
 374
 375 int rtas_error_rc(int rtas_rc)
 376 {
 377         int rc;
 378
 379         switch (rtas_rc) {
 380                 case -1:                /* Hardware Error */
 381                         rc = -EIO;
 382                         break;
 383                 case -3:                /* Bad indicator/domain/etc */
 384                         rc = -EINVAL;
 385                         break;
 386                 case -9000:             /* Isolation error */
 387                         rc = -EFAULT;
 388                         break;
 389                 case -9001:             /* Outstanding TCE/PTE */
 390                         rc = -EEXIST;
 391                         break;
 392                 case -9002:             /* No usable slot */
 393                         rc = -ENODEV;
 394                         break;
 395                 default:
 396                         printk(KERN_ERR "%s: unexpected RTAS error %d\n",
 397                                         __FUNCTION__, rtas_rc);
 398                         rc = -ERANGE;
 399                         break;
 400         }
 401         return rc;
 402 }
 403
 404 int rtas_get_power_level(int powerdomain, int *level)
 405 {
 406         int token = rtas_token("get-power-level");
 407         int rc;
 408
 409         if (token == RTAS_UNKNOWN_SERVICE)
 410                 return -ENOENT;
 411
 412         while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
 413                 udelay(1);
 414
 415         if (rc < 0)
 416                 return rtas_error_rc(rc);
 417         return rc;
 418 }
 419
 420 int rtas_set_power_level(int powerdomain, int level, int *setlevel)
 421 {
 422         int token = rtas_token("set-power-level");
 423         unsigned int wait_time;
 424         int rc;
 425
 426         if (token == RTAS_UNKNOWN_SERVICE)
 427                 return -ENOENT;
 428
 429         while (1) {
 430                 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
 431                 if (rc == RTAS_BUSY)
 432                         udelay(1);
 433                 else if (rtas_is_extended_busy(rc)) {
 434                         wait_time = rtas_extended_busy_delay_time(rc);
 435                         udelay(wait_time * 1000);
 436                 } else
 437                         break;
 438         }
 439
 440         if (rc < 0)
 441                 return rtas_error_rc(rc);
 442         return rc;
 443 }
 444
 445 int rtas_get_sensor(int sensor, int index, int *state)
 446 {
 447         int token = rtas_token("get-sensor-state");
 448         unsigned int wait_time;
 449         int rc;
 450
 451         if (token == RTAS_UNKNOWN_SERVICE)
 452                 return -ENOENT;
 453
 454         while (1) {
 455                 rc = rtas_call(token, 2, 2, state, sensor, index);
 456                 if (rc == RTAS_BUSY)
 457                         udelay(1);
 458                 else if (rtas_is_extended_busy(rc)) {
 459                         wait_time = rtas_extended_busy_delay_time(rc);
 460                         udelay(wait_time * 1000);
 461                 } else
 462                         break;
 463         }
 464
 465         if (rc < 0)
 466                 return rtas_error_rc(rc);
 467         return rc;
 468 }
 469
 470 int rtas_set_indicator(int indicator, int index, int new_value)
 471 {
 472         int token = rtas_token("set-indicator");
 473         unsigned int wait_time;
 474         int rc;
 475
 476         if (token == RTAS_UNKNOWN_SERVICE)
 477                 return -ENOENT;
 478
 479         while (1) {
 480                 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
 481                 if (rc == RTAS_BUSY)
 482                         udelay(1);
 483                 else if (rtas_is_extended_busy(rc)) {
 484                         wait_time = rtas_extended_busy_delay_time(rc);
 485                         udelay(wait_time * 1000);
 486                 }
 487                 else
 488                         break;
 489         }
 490
 491         if (rc < 0)
 492                 return rtas_error_rc(rc);
 493         return rc;
 494 }
 495
 496 #define FLASH_BLOCK_LIST_VERSION (1UL)
 497 static void
 498 rtas_flash_firmware(void)
 499 {
 500         unsigned long image_size;
 501         struct flash_block_list *f, *next, *flist;
 502         unsigned long rtas_block_list;
 503         int i, status, update_token;
 504
 505         update_token = rtas_token("ibm,update-flash-64-and-reboot");
 506         if (update_token == RTAS_UNKNOWN_SERVICE) {
 507                 printk(KERN_ALERT "FLASH: ibm,update-flash-64-and-reboot is not available -- not a service partition?\n");
 508                 printk(KERN_ALERT "FLASH: firmware will not be flashed\n");
 509                 return;
 510         }
 511
 512         /* NOTE: the "first" block list is a global var with no data
 513          * blocks in the kernel data segment.  We do this because
 514          * we want to ensure this block_list addr is under 4GB.
 515          */
 516         rtas_firmware_flash_list.num_blocks = 0;
 517         flist = (struct flash_block_list *)&rtas_firmware_flash_list;
 518         rtas_block_list = virt_to_abs(flist);
 519         if (rtas_block_list >= 4UL*1024*1024*1024) {
 520                 printk(KERN_ALERT "FLASH: kernel bug...flash list header addr above 4GB\n");
 521                 return;
 522         }
 523
 524         printk(KERN_ALERT "FLASH: preparing saved firmware image for flash\n");
 525         /* Update the block_list in place. */
 526         image_size = 0;
 527         for (f = flist; f; f = next) {
 528                 /* Translate data addrs to absolute */
 529                 for (i = 0; i < f->num_blocks; i++) {
 530                         f->blocks[i].data = (char *)virt_to_abs(f->blocks[i].data);
 531                         image_size += f->blocks[i].length;
 532                 }
 533                 next = f->next;
 534                 /* Don't translate NULL pointer for last entry */
 535                 if (f->next)
 536                         f->next = (struct flash_block_list *)virt_to_abs(f->next);
 537                 else
 538                         f->next = NULL;
 539                 /* make num_blocks into the version/length field */
 540                 f->num_blocks = (FLASH_BLOCK_LIST_VERSION << 56) | ((f->num_blocks+1)*16);
 541         }
 542
 543         printk(KERN_ALERT "FLASH: flash image is %ld bytes\n", image_size);
 544         printk(KERN_ALERT "FLASH: performing flash and reboot\n");
 545         rtas_progress("Flashing        \n", 0x0);
 546         rtas_progress("Please Wait...  ", 0x0);
 547         printk(KERN_ALERT "FLASH: this will take several minutes.  Do not power off!\n");
 548         status = rtas_call(update_token, 1, 1, NULL, rtas_block_list);
 549         switch (status) {       /* should only get "bad" status */
 550             case 0:
 551                 printk(KERN_ALERT "FLASH: success\n");
 552                 break;
 553             case -1:
 554                 printk(KERN_ALERT "FLASH: hardware error.  Firmware may not be not flashed\n");
 555                 break;
 556             case -3:
 557                 printk(KERN_ALERT "FLASH: image is corrupt or not correct for this platform.  Firmware not flashed\n");
 558                 break;
 559             case -4:
 560                 printk(KERN_ALERT "FLASH: flash failed when partially complete.  System may not reboot\n");
 561                 break;
 562             default:
 563                 printk(KERN_ALERT "FLASH: unknown flash return code %d\n", status);
 564                 break;
 565         }
 566 }
 567
 568 void rtas_flash_bypass_warning(void)
 569 {
 570         printk(KERN_ALERT "FLASH: firmware flash requires a reboot\n");
 571         printk(KERN_ALERT "FLASH: the firmware image will NOT be flashed\n");
 572 }
 573
 574
 575 void
 576 rtas_restart(char *cmd)
 577 {
 578         if (rtas_firmware_flash_list.next)
 579                 rtas_flash_firmware();
 580
 581         printk("RTAS system-reboot returned %d\n",
 582                rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
 583         for (;;);
 584 }
 585
 586 void
 587 rtas_power_off(void)
 588 {
 589         if (rtas_firmware_flash_list.next)
 590                 rtas_flash_bypass_warning();
 591         /* allow power on only with power button press */
 592         printk("RTAS power-off returned %d\n",
 593                rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
 594         for (;;);
 595 }
 596
 597 void
 598 rtas_halt(void)
 599 {
 600         if (rtas_firmware_flash_list.next)
 601                 rtas_flash_bypass_warning();
 602         rtas_power_off();
 603 }
 604
 605 /* Must be in the RMO region, so we place it here */
 606 static char rtas_os_term_buf[2048];
 607
 608 void rtas_os_term(char *str)
 609 {
 610         int status;
 611
 612         if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term"))
 613                 return;
 614
 615         snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
 616
 617         do {
 618                 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
 619                                    __pa(rtas_os_term_buf));
 620
 621                 if (status == RTAS_BUSY)
 622                         udelay(1);
 623                 else if (status != 0)
 624                         printk(KERN_EMERG "ibm,os-term call failed %d\n",
 625                                status);
 626         } while (status == RTAS_BUSY);
 627 }
 628
 629
 630 asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
 631 {
 632         struct rtas_args args;
 633         unsigned long flags;
 634         char * buff_copy;
 635         int nargs;
 636         int err_rc = 0;
 637
 638         if (!capable(CAP_SYS_ADMIN))
 639                 return -EPERM;
 640
 641         if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
 642                 return -EFAULT;
 643
 644         nargs = args.nargs;
 645         if (nargs > ARRAY_SIZE(args.args)
 646             || args.nret > ARRAY_SIZE(args.args)
 647             || nargs + args.nret > ARRAY_SIZE(args.args))
 648                 return -EINVAL;
 649
 650         /* Copy in args. */
 651         if (copy_from_user(args.args, uargs->args,
 652                            nargs * sizeof(rtas_arg_t)) != 0)
 653                 return -EFAULT;
 654
 655         buff_copy = kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL);
 656
 657         spin_lock_irqsave(&rtas.lock, flags);
 658
 659         rtas.args = args;
 660         enter_rtas(__pa(&rtas.args));
 661         args = rtas.args;
 662
 663         args.rets = &args.args[nargs];
 664
 665         /* A -1 return code indicates that the last command couldn't
 666            be completed due to a hardware error. */
 667         if (args.rets[0] == -1) {
 668                 err_rc = __fetch_rtas_last_error();
 669                 if ((err_rc == 0) && buff_copy) {
 670                         memcpy(buff_copy, rtas_err_buf, RTAS_ERROR_LOG_MAX);
 671                 }
 672         }
 673
 674         spin_unlock_irqrestore(&rtas.lock, flags);
 675
 676         if (buff_copy) {
 677                 if ((args.rets[0] == -1) && (err_rc == 0)) {
 678                         log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
 679                 }
 680                 kfree(buff_copy);
 681         }
 682
 683         /* Copy out args. */
 684         if (copy_to_user(uargs->args + nargs,
 685                          args.args + nargs,
 686                          args.nret * sizeof(rtas_arg_t)) != 0)
 687                 return -EFAULT;
 688
 689         return 0;
 690 }
 691
 692 /* This version can't take the spinlock, because it never returns */
 693
 694 struct rtas_args rtas_stop_self_args = {
 695         /* The token is initialized for real in setup_system() */
 696         .token = RTAS_UNKNOWN_SERVICE,
 697         .nargs = 0,
 698         .nret = 1,
 699         .rets = &rtas_stop_self_args.args[0],
 700 };
 701
 702 void rtas_stop_self(void)
 703 {
 704         struct rtas_args *rtas_args = &rtas_stop_self_args;
 705
 706         local_irq_disable();
 707
 708         BUG_ON(rtas_args->token == RTAS_UNKNOWN_SERVICE);
 709
 710         printk("cpu %u (hwid %u) Ready to die...\n",
 711                smp_processor_id(), hard_smp_processor_id());
 712         enter_rtas(__pa(rtas_args));
 713
 714         panic("Alas, I survived.\n");
 715 }
 716
 717 /*
 718  * Call early during boot, before mem init or bootmem, to retreive the RTAS
 719  * informations from the device-tree and allocate the RMO buffer for userland
 720  * accesses.
 721  */
 722 void __init rtas_initialize(void)
 723 {
 724         /* Get RTAS dev node and fill up our "rtas" structure with infos
 725          * about it.
 726          */
 727         rtas.dev = of_find_node_by_name(NULL, "rtas");
 728         if (rtas.dev) {
 729                 u32 *basep, *entryp;
 730                 u32 *sizep;
 731
 732                 basep = (u32 *)get_property(rtas.dev, "linux,rtas-base", NULL);
 733                 sizep = (u32 *)get_property(rtas.dev, "rtas-size", NULL);
 734                 if (basep != NULL && sizep != NULL) {
 735                         rtas.base = *basep;
 736                         rtas.size = *sizep;
 737                         entryp = (u32 *)get_property(rtas.dev, "linux,rtas-entry", NULL);
 738                         if (entryp == NULL) /* Ugh */
 739                                 rtas.entry = rtas.base;
 740                         else
 741                                 rtas.entry = *entryp;
 742                 } else
 743                         rtas.dev = NULL;
 744         }
 745         /* If RTAS was found, allocate the RMO buffer for it and look for
 746          * the stop-self token if any
 747          */
 748         if (rtas.dev) {
 749                 unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
 750                 if (systemcfg->platform == PLATFORM_PSERIES_LPAR)
 751                         rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
 752
 753                 rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE,
 754                                                         rtas_region);
 755
 756 #ifdef CONFIG_HOTPLUG_CPU
 757                 rtas_stop_self_args.token = rtas_token("stop-self");
 758 #endif /* CONFIG_HOTPLUG_CPU */
 759         }
 760
 761 }
 762
 763
 764 EXPORT_SYMBOL(rtas_firmware_flash_list);
 765 EXPORT_SYMBOL(rtas_token);
 766 EXPORT_SYMBOL(rtas_call);
 767 EXPORT_SYMBOL(rtas_data_buf);
 768 EXPORT_SYMBOL(rtas_data_buf_lock);
 769 EXPORT_SYMBOL(rtas_extended_busy_delay_time);
 770 EXPORT_SYMBOL(rtas_get_sensor);
 771 EXPORT_SYMBOL(rtas_get_power_level);
 772 EXPORT_SYMBOL(rtas_set_power_level);
 773 EXPORT_SYMBOL(rtas_set_indicator);
 774 EXPORT_SYMBOL(rtas_get_error_log_max);