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/paca.h>
  26 #include <asm/page.h>
  27 #include <asm/param.h>
  28 #include <asm/system.h>
  29 #include <asm/abs_addr.h>
  30 #include <asm/udbg.h>
  31 #include <asm/delay.h>
  32 #include <asm/uaccess.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 char rtas_err_buf[RTAS_ERROR_LOG_MAX];
  41
  42 spinlock_t rtas_data_buf_lock = SPIN_LOCK_UNLOCKED;
  43 char rtas_data_buf[RTAS_DATA_BUF_SIZE]__page_aligned;
  44
  45 void
  46 call_rtas_display_status(char c)
  47 {
  48         struct rtas_args *args = &rtas.args;
  49         unsigned long s;
  50
  51         spin_lock_irqsave(&rtas.lock, s);
  52
  53         args->token = 10;
  54         args->nargs = 1;
  55         args->nret  = 1;
  56         args->rets  = (rtas_arg_t *)&(args->args[1]);
  57         args->args[0] = (int)c;
  58
  59         enter_rtas(__pa(args));
  60
  61         spin_unlock_irqrestore(&rtas.lock, s);
  62 }
  63
  64 int
  65 rtas_token(const char *service)
  66 {
  67         int *tokp;
  68         if (rtas.dev == NULL) {
  69                 PPCDBG(PPCDBG_RTAS,"\tNo rtas device in device-tree...\n");
  70                 return RTAS_UNKNOWN_SERVICE;
  71         }
  72         tokp = (int *) get_property(rtas.dev, service, NULL);
  73         return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
  74 }
  75
  76
  77 /** Return a copy of the detailed error text associated with the
  78  *  most recent failed call to rtas.  Because the error text
  79  *  might go stale if there are any other intervening rtas calls,
  80  *  this routine must be called atomically with whatever produced
  81  *  the error (i.e. with rtas.lock still held from the previous call).
  82  */
  83 static int
  84 __fetch_rtas_last_error(void)
  85 {
  86         struct rtas_args err_args, save_args;
  87
  88         err_args.token = rtas_token("rtas-last-error");
  89         err_args.nargs = 2;
  90         err_args.nret = 1;
  91         err_args.rets = (rtas_arg_t *)&(err_args.args[2]);
  92
  93         err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
  94         err_args.args[1] = RTAS_ERROR_LOG_MAX;
  95         err_args.args[2] = 0;
  96
  97         save_args = rtas.args;
  98         rtas.args = err_args;
  99
 100         PPCDBG(PPCDBG_RTAS, "\tentering rtas with 0x%lx\n",
 101                __pa(&err_args));
 102         enter_rtas(__pa(&rtas.args));
 103         PPCDBG(PPCDBG_RTAS, "\treturned from rtas ...\n");
 104
 105         err_args = rtas.args;
 106         rtas.args = save_args;
 107
 108         return err_args.rets[0];
 109 }
 110
 111 int rtas_call(int token, int nargs, int nret, int *outputs, ...)
 112 {
 113         va_list list;
 114         int i, logit = 0;
 115         unsigned long s;
 116         struct rtas_args *rtas_args;
 117         char * buff_copy = NULL;
 118         int ret;
 119
 120         PPCDBG(PPCDBG_RTAS, "Entering rtas_call\n");
 121         PPCDBG(PPCDBG_RTAS, "\ttoken    = 0x%x\n", token);
 122         PPCDBG(PPCDBG_RTAS, "\tnargs    = %d\n", nargs);
 123         PPCDBG(PPCDBG_RTAS, "\tnret     = %d\n", nret);
 124         PPCDBG(PPCDBG_RTAS, "\t&outputs = 0x%lx\n", outputs);
 125         if (token == RTAS_UNKNOWN_SERVICE)
 126                 return -1;
 127
 128         /* Gotta do something different here, use global lock for now... */
 129         spin_lock_irqsave(&rtas.lock, s);
 130         rtas_args = &rtas.args;
 131
 132         rtas_args->token = token;
 133         rtas_args->nargs = nargs;
 134         rtas_args->nret  = nret;
 135         rtas_args->rets  = (rtas_arg_t *)&(rtas_args->args[nargs]);
 136         va_start(list, outputs);
 137         for (i = 0; i < nargs; ++i) {
 138                 rtas_args->args[i] = va_arg(list, rtas_arg_t);
 139                 PPCDBG(PPCDBG_RTAS, "\tnarg[%d] = 0x%x\n", i, rtas_args->args[i]);
 140         }
 141         va_end(list);
 142
 143         for (i = 0; i < nret; ++i)
 144                 rtas_args->rets[i] = 0;
 145
 146         PPCDBG(PPCDBG_RTAS, "\tentering rtas with 0x%lx\n",
 147                 __pa(rtas_args));
 148         enter_rtas(__pa(rtas_args));
 149         PPCDBG(PPCDBG_RTAS, "\treturned from rtas ...\n");
 150
 151         /* A -1 return code indicates that the last command couldn't
 152            be completed due to a hardware error. */
 153         if (rtas_args->rets[0] == -1)
 154                 logit = (__fetch_rtas_last_error() == 0);
 155
 156         ifppcdebug(PPCDBG_RTAS) {
 157                 for(i=0; i < nret ;i++)
 158                         udbg_printf("\tnret[%d] = 0x%lx\n", i, (ulong)rtas_args->rets[i]);
 159         }
 160
 161         if (nret > 1 && outputs != NULL)
 162                 for (i = 0; i < nret-1; ++i)
 163                         outputs[i] = rtas_args->rets[i+1];
 164         ret = (nret > 0)? rtas_args->rets[0]: 0;
 165
 166         /* Log the error in the unlikely case that there was one. */
 167         if (unlikely(logit)) {
 168                 buff_copy = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
 169                 if (buff_copy) {
 170                         memcpy(buff_copy, rtas_err_buf, RTAS_ERROR_LOG_MAX);
 171                 }
 172         }
 173
 174         /* Gotta do something different here, use global lock for now... */
 175         spin_unlock_irqrestore(&rtas.lock, s);
 176
 177         if (buff_copy) {
 178                 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
 179                 kfree(buff_copy);
 180         }
 181         return ret;
 182 }
 183
 184 /* Given an RTAS status code of 990n compute the hinted delay of 10^n
 185  * (last digit) milliseconds.  For now we bound at n=5 (100 sec).
 186  */
 187 unsigned int
 188 rtas_extended_busy_delay_time(int status)
 189 {
 190         int order = status - 9900;
 191         unsigned long ms;
 192
 193         if (order < 0)
 194                 order = 0;      /* RTC depends on this for -2 clock busy */
 195         else if (order > 5)
 196                 order = 5;      /* bound */
 197
 198         /* Use microseconds for reasonable accuracy */
 199         for (ms=1; order > 0; order--)
 200                 ms *= 10;
 201
 202         return ms;
 203 }
 204
 205 int
 206 rtas_get_power_level(int powerdomain, int *level)
 207 {
 208         int token = rtas_token("get-power-level");
 209         int rc;
 210
 211         if (token == RTAS_UNKNOWN_SERVICE)
 212                 return RTAS_UNKNOWN_OP;
 213
 214         while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
 215                 udelay(1);
 216         return rc;
 217 }
 218
 219 int
 220 rtas_set_power_level(int powerdomain, int level, int *setlevel)
 221 {
 222         int token = rtas_token("set-power-level");
 223         unsigned int wait_time;
 224         int rc;
 225
 226         if (token == RTAS_UNKNOWN_SERVICE)
 227                 return RTAS_UNKNOWN_OP;
 228
 229         while (1) {
 230                 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
 231                 if (rc == RTAS_BUSY)
 232                         udelay(1);
 233                 else if (rtas_is_extended_busy(rc)) {
 234                         wait_time = rtas_extended_busy_delay_time(rc);
 235                         udelay(wait_time * 1000);
 236                 } else
 237                         break;
 238         }
 239         return rc;
 240 }
 241
 242 int
 243 rtas_get_sensor(int sensor, int index, int *state)
 244 {
 245         int token = rtas_token("get-sensor-state");
 246         unsigned int wait_time;
 247         int rc;
 248
 249         if (token == RTAS_UNKNOWN_SERVICE)
 250                 return RTAS_UNKNOWN_OP;
 251
 252         while (1) {
 253                 rc = rtas_call(token, 2, 2, state, sensor, index);
 254                 if (rc == RTAS_BUSY)
 255                         udelay(1);
 256                 else if (rtas_is_extended_busy(rc)) {
 257                         wait_time = rtas_extended_busy_delay_time(rc);
 258                         udelay(wait_time * 1000);
 259                 } else
 260                         break;
 261         }
 262         return rc;
 263 }
 264
 265 int
 266 rtas_set_indicator(int indicator, int index, int new_value)
 267 {
 268         int token = rtas_token("set-indicator");
 269         unsigned int wait_time;
 270         int rc;
 271
 272         if (token == RTAS_UNKNOWN_SERVICE)
 273                 return RTAS_UNKNOWN_OP;
 274
 275         while (1) {
 276                 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
 277                 if (rc == RTAS_BUSY)
 278                         udelay(1);
 279                 else if (rtas_is_extended_busy(rc)) {
 280                         wait_time = rtas_extended_busy_delay_time(rc);
 281                         udelay(wait_time * 1000);
 282                 }
 283                 else
 284                         break;
 285         }
 286
 287         return rc;
 288 }
 289
 290 #define FLASH_BLOCK_LIST_VERSION (1UL)
 291 static void
 292 rtas_flash_firmware(void)
 293 {
 294         unsigned long image_size;
 295         struct flash_block_list *f, *next, *flist;
 296         unsigned long rtas_block_list;
 297         int i, status, update_token;
 298
 299         update_token = rtas_token("ibm,update-flash-64-and-reboot");
 300         if (update_token == RTAS_UNKNOWN_SERVICE) {
 301                 printk(KERN_ALERT "FLASH: ibm,update-flash-64-and-reboot is not available -- not a service partition?\n");
 302                 printk(KERN_ALERT "FLASH: firmware will not be flashed\n");
 303                 return;
 304         }
 305
 306         /* NOTE: the "first" block list is a global var with no data
 307          * blocks in the kernel data segment.  We do this because
 308          * we want to ensure this block_list addr is under 4GB.
 309          */
 310         rtas_firmware_flash_list.num_blocks = 0;
 311         flist = (struct flash_block_list *)&rtas_firmware_flash_list;
 312         rtas_block_list = virt_to_abs(flist);
 313         if (rtas_block_list >= 4UL*1024*1024*1024) {
 314                 printk(KERN_ALERT "FLASH: kernel bug...flash list header addr above 4GB\n");
 315                 return;
 316         }
 317
 318         printk(KERN_ALERT "FLASH: preparing saved firmware image for flash\n");
 319         /* Update the block_list in place. */
 320         image_size = 0;
 321         for (f = flist; f; f = next) {
 322                 /* Translate data addrs to absolute */
 323                 for (i = 0; i < f->num_blocks; i++) {
 324                         f->blocks[i].data = (char *)virt_to_abs(f->blocks[i].data);
 325                         image_size += f->blocks[i].length;
 326                 }
 327                 next = f->next;
 328                 /* Don't translate NULL pointer for last entry */
 329                 if (f->next)
 330                         f->next = (struct flash_block_list *)virt_to_abs(f->next);
 331                 else
 332                         f->next = NULL;
 333                 /* make num_blocks into the version/length field */
 334                 f->num_blocks = (FLASH_BLOCK_LIST_VERSION << 56) | ((f->num_blocks+1)*16);
 335         }
 336
 337         printk(KERN_ALERT "FLASH: flash image is %ld bytes\n", image_size);
 338         printk(KERN_ALERT "FLASH: performing flash and reboot\n");
 339         ppc_md.progress("Flashing        \n", 0x0);
 340         ppc_md.progress("Please Wait...  ", 0x0);
 341         printk(KERN_ALERT "FLASH: this will take several minutes.  Do not power off!\n");
 342         status = rtas_call(update_token, 1, 1, NULL, rtas_block_list);
 343         switch (status) {       /* should only get "bad" status */
 344             case 0:
 345                 printk(KERN_ALERT "FLASH: success\n");
 346                 break;
 347             case -1:
 348                 printk(KERN_ALERT "FLASH: hardware error.  Firmware may not be not flashed\n");
 349                 break;
 350             case -3:
 351                 printk(KERN_ALERT "FLASH: image is corrupt or not correct for this platform.  Firmware not flashed\n");
 352                 break;
 353             case -4:
 354                 printk(KERN_ALERT "FLASH: flash failed when partially complete.  System may not reboot\n");
 355                 break;
 356             default:
 357                 printk(KERN_ALERT "FLASH: unknown flash return code %d\n", status);
 358                 break;
 359         }
 360 }
 361
 362 void rtas_flash_bypass_warning(void)
 363 {
 364         printk(KERN_ALERT "FLASH: firmware flash requires a reboot\n");
 365         printk(KERN_ALERT "FLASH: the firmware image will NOT be flashed\n");
 366 }
 367
 368
 369 void
 370 rtas_restart(char *cmd)
 371 {
 372         if (rtas_firmware_flash_list.next)
 373                 rtas_flash_firmware();
 374
 375         printk("RTAS system-reboot returned %d\n",
 376                rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
 377         for (;;);
 378 }
 379
 380 void
 381 rtas_power_off(void)
 382 {
 383         if (rtas_firmware_flash_list.next)
 384                 rtas_flash_bypass_warning();
 385         /* allow power on only with power button press */
 386         printk("RTAS power-off returned %d\n",
 387                rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
 388         for (;;);
 389 }
 390
 391 void
 392 rtas_halt(void)
 393 {
 394         if (rtas_firmware_flash_list.next)
 395                 rtas_flash_bypass_warning();
 396         rtas_power_off();
 397 }
 398
 399 /* Must be in the RMO region, so we place it here */
 400 static char rtas_os_term_buf[2048];
 401
 402 void rtas_os_term(char *str)
 403 {
 404         int status;
 405
 406         snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
 407
 408         do {
 409                 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
 410                                    __pa(rtas_os_term_buf));
 411
 412                 if (status == RTAS_BUSY)
 413                         udelay(1);
 414                 else if (status != 0)
 415                         printk(KERN_EMERG "ibm,os-term call failed %d\n",
 416                                status);
 417         } while (status == RTAS_BUSY);
 418 }
 419
 420 unsigned long rtas_rmo_buf = 0;
 421
 422 asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
 423 {
 424         struct rtas_args args;
 425         unsigned long flags;
 426         char * buff_copy;
 427         int nargs;
 428         int err_rc = 0;
 429
 430         if (!capable(CAP_SYS_ADMIN))
 431                 return -EPERM;
 432
 433         if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
 434                 return -EFAULT;
 435
 436         nargs = args.nargs;
 437         if (nargs > ARRAY_SIZE(args.args)
 438             || args.nret > ARRAY_SIZE(args.args)
 439             || nargs + args.nret > ARRAY_SIZE(args.args))
 440                 return -EINVAL;
 441
 442         /* Copy in args. */
 443         if (copy_from_user(args.args, uargs->args,
 444                            nargs * sizeof(rtas_arg_t)) != 0)
 445                 return -EFAULT;
 446
 447         buff_copy = kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL);
 448
 449         spin_lock_irqsave(&rtas.lock, flags);
 450
 451         rtas.args = args;
 452         enter_rtas(__pa(&rtas.args));
 453         args = rtas.args;
 454
 455         args.rets = &args.args[nargs];
 456
 457         /* A -1 return code indicates that the last command couldn't
 458            be completed due to a hardware error. */
 459         if (args.rets[0] == -1) {
 460                 err_rc = __fetch_rtas_last_error();
 461                 if ((err_rc == 0) && buff_copy) {
 462                         memcpy(buff_copy, rtas_err_buf, RTAS_ERROR_LOG_MAX);
 463                 }
 464         }
 465
 466         spin_unlock_irqrestore(&rtas.lock, flags);
 467
 468         if (buff_copy) {
 469                 if ((args.rets[0] == -1) && (err_rc == 0)) {
 470                         log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
 471                 }
 472                 kfree(buff_copy);
 473         }
 474
 475         /* Copy out args. */
 476         if (copy_to_user(uargs->args + nargs,
 477                          args.args + nargs,
 478                          args.nret * sizeof(rtas_arg_t)) != 0)
 479                 return -EFAULT;
 480
 481         return 0;
 482 }
 483
 484 #ifdef CONFIG_HOTPLUG_CPU
 485 /* This version can't take the spinlock, because it never returns */
 486
 487 struct rtas_args rtas_stop_self_args = {
 488         /* The token is initialized for real in setup_system() */
 489         .token = RTAS_UNKNOWN_SERVICE,
 490         .nargs = 0,
 491         .nret = 1,
 492         .rets = &rtas_stop_self_args.args[0],
 493 };
 494
 495 void rtas_stop_self(void)
 496 {
 497         struct rtas_args *rtas_args = &rtas_stop_self_args;
 498
 499         local_irq_disable();
 500
 501         BUG_ON(rtas_args->token == RTAS_UNKNOWN_SERVICE);
 502
 503         printk("cpu %u (hwid %u) Ready to die...\n",
 504                smp_processor_id(), hard_smp_processor_id());
 505         enter_rtas(__pa(rtas_args));
 506
 507         panic("Alas, I survived.\n");
 508 }
 509 #endif /* CONFIG_HOTPLUG_CPU */
 510
 511 EXPORT_SYMBOL(rtas_firmware_flash_list);
 512 EXPORT_SYMBOL(rtas_token);
 513 EXPORT_SYMBOL(rtas_call);
 514 EXPORT_SYMBOL(rtas_data_buf);
 515 EXPORT_SYMBOL(rtas_data_buf_lock);
 516 EXPORT_SYMBOL(rtas_extended_busy_delay_time);
 517 EXPORT_SYMBOL(rtas_get_sensor);
 518 EXPORT_SYMBOL(rtas_get_power_level);
 519 EXPORT_SYMBOL(rtas_set_power_level);
 520 EXPORT_SYMBOL(rtas_set_indicator);