3 * Procedures for interfacing to the RTAS on CHRP machines.
5 * Peter Bergner, IBM March 2001.
6 * Copyright (C) 2001 IBM.
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.
15 #include <linux/kernel.h>
16 #include <linux/types.h>
17 #include <linux/spinlock.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/capability.h>
21 #include <linux/delay.h>
22 #include <linux/smp.h>
23 #include <linux/completion.h>
24 #include <linux/cpumask.h>
25 #include <linux/lmb.h>
29 #include <asm/hvcall.h>
30 #include <asm/machdep.h>
31 #include <asm/firmware.h>
33 #include <asm/param.h>
34 #include <asm/system.h>
35 #include <asm/delay.h>
36 #include <asm/uaccess.h>
38 #include <asm/syscalls.h>
40 #include <asm/atomic.h>
42 struct rtas_t rtas = {
43 .lock = __RAW_SPIN_LOCK_UNLOCKED
47 struct rtas_suspend_me_data {
48 atomic_t working; /* number of cpus accessing this struct */
50 int token; /* ibm,suspend-me */
52 struct completion *complete; /* wait on this until working == 0 */
55 DEFINE_SPINLOCK(rtas_data_buf_lock);
56 EXPORT_SYMBOL(rtas_data_buf_lock);
58 char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned;
59 EXPORT_SYMBOL(rtas_data_buf);
61 unsigned long rtas_rmo_buf;
64 * If non-NULL, this gets called when the kernel terminates.
65 * This is done like this so rtas_flash can be a module.
67 void (*rtas_flash_term_hook)(int);
68 EXPORT_SYMBOL(rtas_flash_term_hook);
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
75 static unsigned long lock_rtas(void)
79 local_irq_save(flags);
81 __raw_spin_lock_flags(&rtas.lock, flags);
85 static void unlock_rtas(unsigned long flags)
87 __raw_spin_unlock(&rtas.lock);
88 local_irq_restore(flags);
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.
97 static void call_rtas_display_status(char c)
99 struct rtas_args *args = &rtas.args;
109 args->rets = (rtas_arg_t *)&(args->args[1]);
110 args->args[0] = (unsigned char)c;
112 enter_rtas(__pa(args));
117 static void call_rtas_display_status_delay(char c)
119 static int pending_newline = 0; /* did last write end with unprinted newline? */
120 static int width = 16;
124 call_rtas_display_status(' ');
129 if (pending_newline) {
130 call_rtas_display_status('\r');
131 call_rtas_display_status('\n');
135 call_rtas_display_status(c);
141 void __init udbg_init_rtas_panel(void)
143 udbg_putc = call_rtas_display_status_delay;
146 #ifdef CONFIG_UDBG_RTAS_CONSOLE
148 /* If you think you're dying before early_init_dt_scan_rtas() does its
149 * work, you can hard code the token values for your firmware here and
150 * hardcode rtas.base/entry etc.
152 static unsigned int rtas_putchar_token = RTAS_UNKNOWN_SERVICE;
153 static unsigned int rtas_getchar_token = RTAS_UNKNOWN_SERVICE;
155 static void udbg_rtascon_putc(char c)
162 /* Add CRs before LFs */
164 udbg_rtascon_putc('\r');
166 /* if there is more than one character to be displayed, wait a bit */
167 for (tries = 0; tries < 16; tries++) {
168 if (rtas_call(rtas_putchar_token, 1, 1, NULL, c) == 0)
174 static int udbg_rtascon_getc_poll(void)
181 if (rtas_call(rtas_getchar_token, 0, 2, &c))
187 static int udbg_rtascon_getc(void)
191 while ((c = udbg_rtascon_getc_poll()) == -1)
198 void __init udbg_init_rtas_console(void)
200 udbg_putc = udbg_rtascon_putc;
201 udbg_getc = udbg_rtascon_getc;
202 udbg_getc_poll = udbg_rtascon_getc_poll;
204 #endif /* CONFIG_UDBG_RTAS_CONSOLE */
206 void rtas_progress(char *s, unsigned short hex)
208 struct device_node *root;
212 static int display_character, set_indicator;
213 static int display_width, display_lines, form_feed;
214 static const int *row_width;
215 static DEFINE_SPINLOCK(progress_lock);
216 static int current_line;
217 static int pending_newline = 0; /* did last write end with unprinted newline? */
222 if (display_width == 0) {
223 display_width = 0x10;
224 if ((root = of_find_node_by_path("/rtas"))) {
225 if ((p = of_get_property(root,
226 "ibm,display-line-length", NULL)))
228 if ((p = of_get_property(root,
229 "ibm,form-feed", NULL)))
231 if ((p = of_get_property(root,
232 "ibm,display-number-of-lines", NULL)))
234 row_width = of_get_property(root,
235 "ibm,display-truncation-length", NULL);
238 display_character = rtas_token("display-character");
239 set_indicator = rtas_token("set-indicator");
242 if (display_character == RTAS_UNKNOWN_SERVICE) {
243 /* use hex display if available */
244 if (set_indicator != RTAS_UNKNOWN_SERVICE)
245 rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
249 spin_lock(&progress_lock);
252 * Last write ended with newline, but we didn't print it since
253 * it would just clear the bottom line of output. Print it now
256 * If no newline is pending and form feed is supported, clear the
257 * display with a form feed; otherwise, print a CR to start output
258 * at the beginning of the line.
260 if (pending_newline) {
261 rtas_call(display_character, 1, 1, NULL, '\r');
262 rtas_call(display_character, 1, 1, NULL, '\n');
267 rtas_call(display_character, 1, 1, NULL,
270 rtas_call(display_character, 1, 1, NULL, '\r');
274 width = row_width[current_line];
276 width = display_width;
279 if (*os == '\n' || *os == '\r') {
280 /* If newline is the last character, save it
281 * until next call to avoid bumping up the
284 if (*os == '\n' && !os[1]) {
287 if (current_line > display_lines-1)
288 current_line = display_lines-1;
289 spin_unlock(&progress_lock);
293 /* RTAS wants CR-LF, not just LF */
296 rtas_call(display_character, 1, 1, NULL, '\r');
297 rtas_call(display_character, 1, 1, NULL, '\n');
299 /* CR might be used to re-draw a line, so we'll
300 * leave it alone and not add LF.
302 rtas_call(display_character, 1, 1, NULL, *os);
306 width = row_width[current_line];
308 width = display_width;
311 rtas_call(display_character, 1, 1, NULL, *os);
316 /* if we overwrite the screen length */
318 while ((*os != 0) && (*os != '\n') && (*os != '\r'))
322 spin_unlock(&progress_lock);
324 EXPORT_SYMBOL(rtas_progress); /* needed by rtas_flash module */
326 int rtas_token(const char *service)
329 if (rtas.dev == NULL)
330 return RTAS_UNKNOWN_SERVICE;
331 tokp = of_get_property(rtas.dev, service, NULL);
332 return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
334 EXPORT_SYMBOL(rtas_token);
336 int rtas_service_present(const char *service)
338 return rtas_token(service) != RTAS_UNKNOWN_SERVICE;
340 EXPORT_SYMBOL(rtas_service_present);
342 #ifdef CONFIG_RTAS_ERROR_LOGGING
344 * Return the firmware-specified size of the error log buffer
345 * for all rtas calls that require an error buffer argument.
346 * This includes 'check-exception' and 'rtas-last-error'.
348 int rtas_get_error_log_max(void)
350 static int rtas_error_log_max;
351 if (rtas_error_log_max)
352 return rtas_error_log_max;
354 rtas_error_log_max = rtas_token ("rtas-error-log-max");
355 if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
356 (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
357 printk (KERN_WARNING "RTAS: bad log buffer size %d\n",
359 rtas_error_log_max = RTAS_ERROR_LOG_MAX;
361 return rtas_error_log_max;
363 EXPORT_SYMBOL(rtas_get_error_log_max);
366 static char rtas_err_buf[RTAS_ERROR_LOG_MAX];
367 static int rtas_last_error_token;
369 /** Return a copy of the detailed error text associated with the
370 * most recent failed call to rtas. Because the error text
371 * might go stale if there are any other intervening rtas calls,
372 * this routine must be called atomically with whatever produced
373 * the error (i.e. with rtas.lock still held from the previous call).
375 static char *__fetch_rtas_last_error(char *altbuf)
377 struct rtas_args err_args, save_args;
381 if (rtas_last_error_token == -1)
384 bufsz = rtas_get_error_log_max();
386 err_args.token = rtas_last_error_token;
389 err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
390 err_args.args[1] = bufsz;
391 err_args.args[2] = 0;
393 save_args = rtas.args;
394 rtas.args = err_args;
396 enter_rtas(__pa(&rtas.args));
398 err_args = rtas.args;
399 rtas.args = save_args;
401 /* Log the error in the unlikely case that there was one. */
402 if (unlikely(err_args.args[2] == 0)) {
408 buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
411 memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX);
417 #define get_errorlog_buffer() kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL)
419 #else /* CONFIG_RTAS_ERROR_LOGGING */
420 #define __fetch_rtas_last_error(x) NULL
421 #define get_errorlog_buffer() NULL
424 int rtas_call(int token, int nargs, int nret, int *outputs, ...)
429 struct rtas_args *rtas_args;
430 char *buff_copy = NULL;
433 if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE)
437 rtas_args = &rtas.args;
439 rtas_args->token = token;
440 rtas_args->nargs = nargs;
441 rtas_args->nret = nret;
442 rtas_args->rets = (rtas_arg_t *)&(rtas_args->args[nargs]);
443 va_start(list, outputs);
444 for (i = 0; i < nargs; ++i)
445 rtas_args->args[i] = va_arg(list, rtas_arg_t);
448 for (i = 0; i < nret; ++i)
449 rtas_args->rets[i] = 0;
451 enter_rtas(__pa(rtas_args));
453 /* A -1 return code indicates that the last command couldn't
454 be completed due to a hardware error. */
455 if (rtas_args->rets[0] == -1)
456 buff_copy = __fetch_rtas_last_error(NULL);
458 if (nret > 1 && outputs != NULL)
459 for (i = 0; i < nret-1; ++i)
460 outputs[i] = rtas_args->rets[i+1];
461 ret = (nret > 0)? rtas_args->rets[0]: 0;
466 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
472 EXPORT_SYMBOL(rtas_call);
474 /* For RTAS_BUSY (-2), delay for 1 millisecond. For an extended busy status
475 * code of 990n, perform the hinted delay of 10^n (last digit) milliseconds.
477 unsigned int rtas_busy_delay_time(int status)
482 if (status == RTAS_BUSY) {
484 } else if (status >= 9900 && status <= 9905) {
485 order = status - 9900;
486 for (ms = 1; order > 0; order--)
492 EXPORT_SYMBOL(rtas_busy_delay_time);
494 /* For an RTAS busy status code, perform the hinted delay. */
495 unsigned int rtas_busy_delay(int status)
500 ms = rtas_busy_delay_time(status);
506 EXPORT_SYMBOL(rtas_busy_delay);
508 static int rtas_error_rc(int rtas_rc)
513 case -1: /* Hardware Error */
516 case -3: /* Bad indicator/domain/etc */
519 case -9000: /* Isolation error */
522 case -9001: /* Outstanding TCE/PTE */
525 case -9002: /* No usable slot */
529 printk(KERN_ERR "%s: unexpected RTAS error %d\n",
537 int rtas_get_power_level(int powerdomain, int *level)
539 int token = rtas_token("get-power-level");
542 if (token == RTAS_UNKNOWN_SERVICE)
545 while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
549 return rtas_error_rc(rc);
552 EXPORT_SYMBOL(rtas_get_power_level);
554 int rtas_set_power_level(int powerdomain, int level, int *setlevel)
556 int token = rtas_token("set-power-level");
559 if (token == RTAS_UNKNOWN_SERVICE)
563 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
564 } while (rtas_busy_delay(rc));
567 return rtas_error_rc(rc);
570 EXPORT_SYMBOL(rtas_set_power_level);
572 int rtas_get_sensor(int sensor, int index, int *state)
574 int token = rtas_token("get-sensor-state");
577 if (token == RTAS_UNKNOWN_SERVICE)
581 rc = rtas_call(token, 2, 2, state, sensor, index);
582 } while (rtas_busy_delay(rc));
585 return rtas_error_rc(rc);
588 EXPORT_SYMBOL(rtas_get_sensor);
590 bool rtas_indicator_present(int token, int *maxindex)
592 int proplen, count, i;
593 const struct indicator_elem {
598 indicators = of_get_property(rtas.dev, "rtas-indicators", &proplen);
602 count = proplen / sizeof(struct indicator_elem);
604 for (i = 0; i < count; i++) {
605 if (indicators[i].token != token)
608 *maxindex = indicators[i].maxindex;
614 EXPORT_SYMBOL(rtas_indicator_present);
616 int rtas_set_indicator(int indicator, int index, int new_value)
618 int token = rtas_token("set-indicator");
621 if (token == RTAS_UNKNOWN_SERVICE)
625 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
626 } while (rtas_busy_delay(rc));
629 return rtas_error_rc(rc);
632 EXPORT_SYMBOL(rtas_set_indicator);
635 * Ignoring RTAS extended delay
637 int rtas_set_indicator_fast(int indicator, int index, int new_value)
640 int token = rtas_token("set-indicator");
642 if (token == RTAS_UNKNOWN_SERVICE)
645 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
647 WARN_ON(rc == -2 || (rc >= 9900 && rc <= 9905));
650 return rtas_error_rc(rc);
655 void rtas_restart(char *cmd)
657 if (rtas_flash_term_hook)
658 rtas_flash_term_hook(SYS_RESTART);
659 printk("RTAS system-reboot returned %d\n",
660 rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
664 void rtas_power_off(void)
666 if (rtas_flash_term_hook)
667 rtas_flash_term_hook(SYS_POWER_OFF);
668 /* allow power on only with power button press */
669 printk("RTAS power-off returned %d\n",
670 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
676 if (rtas_flash_term_hook)
677 rtas_flash_term_hook(SYS_HALT);
678 /* allow power on only with power button press */
679 printk("RTAS power-off returned %d\n",
680 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
684 /* Must be in the RMO region, so we place it here */
685 static char rtas_os_term_buf[2048];
687 void rtas_os_term(char *str)
694 if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term"))
697 snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
700 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
701 __pa(rtas_os_term_buf));
702 } while (rtas_busy_delay(status));
705 printk(KERN_EMERG "ibm,os-term call failed %d\n",
709 static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
710 #ifdef CONFIG_PPC_PSERIES
711 static void rtas_percpu_suspend_me(void *info)
714 unsigned long msr_save;
716 struct rtas_suspend_me_data *data =
717 (struct rtas_suspend_me_data *)info;
719 atomic_inc(&data->working);
721 /* really need to ensure MSR.EE is off for H_JOIN */
723 mtmsr(msr_save & ~(MSR_EE));
725 while (rc == H_SUCCESS && !atomic_read(&data->done))
726 rc = plpar_hcall_norets(H_JOIN);
730 if (rc == H_SUCCESS) {
731 /* This cpu was prodded and the suspend is complete. */
733 } else if (rc == H_CONTINUE) {
734 /* All other cpus are in H_JOIN, this cpu does
737 printk(KERN_DEBUG "calling ibm,suspend-me on cpu %i\n",
739 data->error = rtas_call(data->token, 0, 1, NULL);
742 printk(KERN_DEBUG "ibm,suspend-me returned %d\n",
745 printk(KERN_ERR "H_JOIN on cpu %i failed with rc = %ld\n",
746 smp_processor_id(), rc);
750 atomic_set(&data->done, 1);
752 /* This cpu did the suspend or got an error; in either case,
753 * we need to prod all other other cpus out of join state.
754 * Extra prods are harmless.
756 for_each_online_cpu(cpu)
757 plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu));
759 if (atomic_dec_return(&data->working) == 0)
760 complete(data->complete);
763 static int rtas_ibm_suspend_me(struct rtas_args *args)
767 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
768 struct rtas_suspend_me_data data;
769 DECLARE_COMPLETION_ONSTACK(done);
771 if (!rtas_service_present("ibm,suspend-me"))
774 /* Make sure the state is valid */
775 rc = plpar_hcall(H_VASI_STATE, retbuf,
776 ((u64)args->args[0] << 32) | args->args[1]);
781 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
783 } else if (state == H_VASI_ENABLED) {
784 args->args[args->nargs] = RTAS_NOT_SUSPENDABLE;
786 } else if (state != H_VASI_SUSPENDING) {
787 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n",
789 args->args[args->nargs] = -1;
793 atomic_set(&data.working, 0);
794 atomic_set(&data.done, 0);
795 data.token = rtas_token("ibm,suspend-me");
797 data.complete = &done;
799 /* Call function on all CPUs. One of us will make the
802 if (on_each_cpu(rtas_percpu_suspend_me, &data, 0))
803 data.error = -EINVAL;
805 wait_for_completion(&done);
808 printk(KERN_ERR "Error doing global join\n");
812 #else /* CONFIG_PPC_PSERIES */
813 static int rtas_ibm_suspend_me(struct rtas_args *args)
819 asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
821 struct rtas_args args;
823 char *buff_copy, *errbuf = NULL;
827 if (!capable(CAP_SYS_ADMIN))
830 if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
834 if (nargs > ARRAY_SIZE(args.args)
835 || args.nret > ARRAY_SIZE(args.args)
836 || nargs + args.nret > ARRAY_SIZE(args.args))
840 if (copy_from_user(args.args, uargs->args,
841 nargs * sizeof(rtas_arg_t)) != 0)
844 if (args.token == RTAS_UNKNOWN_SERVICE)
847 args.rets = &args.args[nargs];
848 memset(args.rets, 0, args.nret * sizeof(rtas_arg_t));
850 /* Need to handle ibm,suspend_me call specially */
851 if (args.token == ibm_suspend_me_token) {
852 rc = rtas_ibm_suspend_me(&args);
858 buff_copy = get_errorlog_buffer();
863 enter_rtas(__pa(&rtas.args));
866 /* A -1 return code indicates that the last command couldn't
867 be completed due to a hardware error. */
868 if (args.rets[0] == -1)
869 errbuf = __fetch_rtas_last_error(buff_copy);
875 log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
881 if (copy_to_user(uargs->args + nargs,
883 args.nret * sizeof(rtas_arg_t)) != 0)
890 * Call early during boot, before mem init or bootmem, to retrieve the RTAS
891 * informations from the device-tree and allocate the RMO buffer for userland
894 void __init rtas_initialize(void)
896 unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
898 /* Get RTAS dev node and fill up our "rtas" structure with infos
901 rtas.dev = of_find_node_by_name(NULL, "rtas");
903 const u32 *basep, *entryp, *sizep;
905 basep = of_get_property(rtas.dev, "linux,rtas-base", NULL);
906 sizep = of_get_property(rtas.dev, "rtas-size", NULL);
907 if (basep != NULL && sizep != NULL) {
910 entryp = of_get_property(rtas.dev,
911 "linux,rtas-entry", NULL);
912 if (entryp == NULL) /* Ugh */
913 rtas.entry = rtas.base;
915 rtas.entry = *entryp;
922 /* If RTAS was found, allocate the RMO buffer for it and look for
923 * the stop-self token if any
926 if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR)) {
927 rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
928 ibm_suspend_me_token = rtas_token("ibm,suspend-me");
931 rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
933 #ifdef CONFIG_RTAS_ERROR_LOGGING
934 rtas_last_error_token = rtas_token("rtas-last-error");
938 int __init early_init_dt_scan_rtas(unsigned long node,
939 const char *uname, int depth, void *data)
941 u32 *basep, *entryp, *sizep;
943 if (depth != 1 || strcmp(uname, "rtas") != 0)
946 basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL);
947 entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL);
948 sizep = of_get_flat_dt_prop(node, "rtas-size", NULL);
950 if (basep && entryp && sizep) {
952 rtas.entry = *entryp;
956 #ifdef CONFIG_UDBG_RTAS_CONSOLE
957 basep = of_get_flat_dt_prop(node, "put-term-char", NULL);
959 rtas_putchar_token = *basep;
961 basep = of_get_flat_dt_prop(node, "get-term-char", NULL);
963 rtas_getchar_token = *basep;
965 if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE &&
966 rtas_getchar_token != RTAS_UNKNOWN_SERVICE)
967 udbg_init_rtas_console();