blob: 1f8505c235482c5fea77a9f3fd1ec175a526a202 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Randy Dunlapa9415642006-01-11 12:17:48 -080020#include <linux/capability.h>
Benjamin Herrenschmidt21fe3302005-11-07 16:41:59 +110021#include <linux/delay.h>
Nathan Lynch8f5c7572007-11-14 03:15:13 +110022#include <linux/smp.h>
23#include <linux/completion.h>
24#include <linux/cpumask.h>
David S. Millerd9b2b2a2008-02-13 16:56:49 -080025#include <linux/lmb.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#include <asm/prom.h>
28#include <asm/rtas.h>
Michael Ellerman31a7f672006-01-31 17:17:47 +110029#include <asm/hvcall.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/machdep.h>
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +110031#include <asm/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <asm/page.h>
33#include <asm/param.h>
34#include <asm/system.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/delay.h>
36#include <asm/uaccess.h>
Michael Ellerman296167a2006-01-11 11:54:09 +110037#include <asm/udbg.h>
Arnd Bergmanna7f31842006-03-23 00:00:08 +010038#include <asm/syscalls.h>
Nathan Lynch8f5c7572007-11-14 03:15:13 +110039#include <asm/smp.h>
40#include <asm/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Paul Mackerras033ef332005-10-26 17:05:24 +100042struct rtas_t rtas = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 .lock = SPIN_LOCK_UNLOCKED
44};
Michael Ellermanab3ab742006-06-23 18:20:11 +100045EXPORT_SYMBOL(rtas);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Dave C Boutcher91dc1822006-01-13 18:39:24 -060047struct rtas_suspend_me_data {
Nathan Lynch8f5c7572007-11-14 03:15:13 +110048 atomic_t working; /* number of cpus accessing this struct */
49 int token; /* ibm,suspend-me */
50 int error;
51 struct completion *complete; /* wait on this until working == 0 */
Dave C Boutcher91dc1822006-01-13 18:39:24 -060052};
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054DEFINE_SPINLOCK(rtas_data_buf_lock);
Michael Ellermanab3ab742006-06-23 18:20:11 +100055EXPORT_SYMBOL(rtas_data_buf_lock);
56
Paul Mackerras033ef332005-10-26 17:05:24 +100057char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned;
Michael Ellermanab3ab742006-06-23 18:20:11 +100058EXPORT_SYMBOL(rtas_data_buf);
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060unsigned long rtas_rmo_buf;
61
Paul Mackerras033ef332005-10-26 17:05:24 +100062/*
Paul Mackerrasf4fcbbe2005-11-03 14:41:19 +110063 * If non-NULL, this gets called when the kernel terminates.
64 * This is done like this so rtas_flash can be a module.
65 */
66void (*rtas_flash_term_hook)(int);
67EXPORT_SYMBOL(rtas_flash_term_hook);
68
69/*
Paul Mackerras033ef332005-10-26 17:05:24 +100070 * call_rtas_display_status and call_rtas_display_status_delay
71 * are designed only for very early low-level debugging, which
72 * is why the token is hard-coded to 10.
73 */
Michael Ellerman296167a2006-01-11 11:54:09 +110074static void call_rtas_display_status(char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
76 struct rtas_args *args = &rtas.args;
77 unsigned long s;
78
79 if (!rtas.base)
80 return;
81 spin_lock_irqsave(&rtas.lock, s);
82
83 args->token = 10;
84 args->nargs = 1;
85 args->nret = 1;
86 args->rets = (rtas_arg_t *)&(args->args[1]);
Michael Ellerman296167a2006-01-11 11:54:09 +110087 args->args[0] = (unsigned char)c;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 enter_rtas(__pa(args));
90
91 spin_unlock_irqrestore(&rtas.lock, s);
92}
93
Michael Ellerman296167a2006-01-11 11:54:09 +110094static void call_rtas_display_status_delay(char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
96 static int pending_newline = 0; /* did last write end with unprinted newline? */
97 static int width = 16;
98
99 if (c == '\n') {
100 while (width-- > 0)
101 call_rtas_display_status(' ');
102 width = 16;
Benjamin Herrenschmidt21fe3302005-11-07 16:41:59 +1100103 mdelay(500);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 pending_newline = 1;
105 } else {
106 if (pending_newline) {
107 call_rtas_display_status('\r');
108 call_rtas_display_status('\n');
109 }
110 pending_newline = 0;
111 if (width--) {
112 call_rtas_display_status(c);
113 udelay(10000);
114 }
115 }
116}
117
Michael Ellermancc46bb92006-06-23 18:20:16 +1000118void __init udbg_init_rtas_panel(void)
Michael Ellerman296167a2006-01-11 11:54:09 +1100119{
120 udbg_putc = call_rtas_display_status_delay;
121}
122
Michael Ellermancc46bb92006-06-23 18:20:16 +1000123#ifdef CONFIG_UDBG_RTAS_CONSOLE
124
125/* If you think you're dying before early_init_dt_scan_rtas() does its
126 * work, you can hard code the token values for your firmware here and
127 * hardcode rtas.base/entry etc.
128 */
129static unsigned int rtas_putchar_token = RTAS_UNKNOWN_SERVICE;
130static unsigned int rtas_getchar_token = RTAS_UNKNOWN_SERVICE;
131
132static void udbg_rtascon_putc(char c)
133{
134 int tries;
135
136 if (!rtas.base)
137 return;
138
139 /* Add CRs before LFs */
140 if (c == '\n')
141 udbg_rtascon_putc('\r');
142
143 /* if there is more than one character to be displayed, wait a bit */
144 for (tries = 0; tries < 16; tries++) {
145 if (rtas_call(rtas_putchar_token, 1, 1, NULL, c) == 0)
146 break;
147 udelay(1000);
148 }
149}
150
151static int udbg_rtascon_getc_poll(void)
152{
153 int c;
154
155 if (!rtas.base)
156 return -1;
157
158 if (rtas_call(rtas_getchar_token, 0, 2, &c))
159 return -1;
160
161 return c;
162}
163
164static int udbg_rtascon_getc(void)
165{
166 int c;
167
168 while ((c = udbg_rtascon_getc_poll()) == -1)
169 ;
170
171 return c;
172}
173
174
175void __init udbg_init_rtas_console(void)
176{
177 udbg_putc = udbg_rtascon_putc;
178 udbg_getc = udbg_rtascon_getc;
179 udbg_getc_poll = udbg_rtascon_getc_poll;
180}
181#endif /* CONFIG_UDBG_RTAS_CONSOLE */
182
Paul Mackerras033ef332005-10-26 17:05:24 +1000183void rtas_progress(char *s, unsigned short hex)
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000184{
185 struct device_node *root;
Jeremy Kerra7f67bd2006-07-12 15:35:54 +1000186 int width;
187 const int *p;
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000188 char *os;
189 static int display_character, set_indicator;
Jeremy Kerra7f67bd2006-07-12 15:35:54 +1000190 static int display_width, display_lines, form_feed;
Tobias Klauserc5a69d52007-02-17 20:11:19 +0100191 static const int *row_width;
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000192 static DEFINE_SPINLOCK(progress_lock);
Mike Strosaker8f586b22005-06-23 16:09:41 +1000193 static int current_line;
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000194 static int pending_newline = 0; /* did last write end with unprinted newline? */
195
196 if (!rtas.base)
197 return;
198
Mike Strosaker8f586b22005-06-23 16:09:41 +1000199 if (display_width == 0) {
200 display_width = 0x10;
Stephen Rothwell8c8dc322007-04-24 13:50:55 +1000201 if ((root = of_find_node_by_path("/rtas"))) {
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000202 if ((p = of_get_property(root,
Mike Strosaker8f586b22005-06-23 16:09:41 +1000203 "ibm,display-line-length", NULL)))
204 display_width = *p;
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000205 if ((p = of_get_property(root,
Mike Strosaker8f586b22005-06-23 16:09:41 +1000206 "ibm,form-feed", NULL)))
207 form_feed = *p;
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000208 if ((p = of_get_property(root,
Mike Strosaker8f586b22005-06-23 16:09:41 +1000209 "ibm,display-number-of-lines", NULL)))
210 display_lines = *p;
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000211 row_width = of_get_property(root,
Mike Strosaker8f586b22005-06-23 16:09:41 +1000212 "ibm,display-truncation-length", NULL);
Stephen Rothwell8c8dc322007-04-24 13:50:55 +1000213 of_node_put(root);
Mike Strosaker8f586b22005-06-23 16:09:41 +1000214 }
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000215 display_character = rtas_token("display-character");
216 set_indicator = rtas_token("set-indicator");
217 }
218
219 if (display_character == RTAS_UNKNOWN_SERVICE) {
220 /* use hex display if available */
221 if (set_indicator != RTAS_UNKNOWN_SERVICE)
222 rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
223 return;
224 }
225
226 spin_lock(&progress_lock);
227
228 /*
229 * Last write ended with newline, but we didn't print it since
230 * it would just clear the bottom line of output. Print it now
231 * instead.
232 *
Mike Strosaker8f586b22005-06-23 16:09:41 +1000233 * If no newline is pending and form feed is supported, clear the
234 * display with a form feed; otherwise, print a CR to start output
235 * at the beginning of the line.
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000236 */
237 if (pending_newline) {
238 rtas_call(display_character, 1, 1, NULL, '\r');
239 rtas_call(display_character, 1, 1, NULL, '\n');
240 pending_newline = 0;
241 } else {
Mike Strosaker8f586b22005-06-23 16:09:41 +1000242 current_line = 0;
243 if (form_feed)
244 rtas_call(display_character, 1, 1, NULL,
245 (char)form_feed);
246 else
247 rtas_call(display_character, 1, 1, NULL, '\r');
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000248 }
249
Mike Strosaker8f586b22005-06-23 16:09:41 +1000250 if (row_width)
251 width = row_width[current_line];
252 else
253 width = display_width;
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000254 os = s;
255 while (*os) {
256 if (*os == '\n' || *os == '\r') {
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000257 /* If newline is the last character, save it
258 * until next call to avoid bumping up the
259 * display output.
260 */
261 if (*os == '\n' && !os[1]) {
262 pending_newline = 1;
Mike Strosaker8f586b22005-06-23 16:09:41 +1000263 current_line++;
264 if (current_line > display_lines-1)
265 current_line = display_lines-1;
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000266 spin_unlock(&progress_lock);
267 return;
268 }
269
270 /* RTAS wants CR-LF, not just LF */
271
272 if (*os == '\n') {
273 rtas_call(display_character, 1, 1, NULL, '\r');
274 rtas_call(display_character, 1, 1, NULL, '\n');
275 } else {
276 /* CR might be used to re-draw a line, so we'll
277 * leave it alone and not add LF.
278 */
279 rtas_call(display_character, 1, 1, NULL, *os);
280 }
281
Mike Strosaker8f586b22005-06-23 16:09:41 +1000282 if (row_width)
283 width = row_width[current_line];
284 else
285 width = display_width;
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000286 } else {
287 width--;
288 rtas_call(display_character, 1, 1, NULL, *os);
289 }
290
291 os++;
292
293 /* if we overwrite the screen length */
294 if (width <= 0)
295 while ((*os != 0) && (*os != '\n') && (*os != '\r'))
296 os++;
297 }
298
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000299 spin_unlock(&progress_lock);
300}
Paul Mackerrasf4fcbbe2005-11-03 14:41:19 +1100301EXPORT_SYMBOL(rtas_progress); /* needed by rtas_flash module */
Arnd Bergmann6566c6f2005-06-23 09:43:28 +1000302
Paul Mackerras033ef332005-10-26 17:05:24 +1000303int rtas_token(const char *service)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
Jeremy Kerra7f67bd2006-07-12 15:35:54 +1000305 const int *tokp;
Paul Mackerras033ef332005-10-26 17:05:24 +1000306 if (rtas.dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 return RTAS_UNKNOWN_SERVICE;
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000308 tokp = of_get_property(rtas.dev, service, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
310}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000311EXPORT_SYMBOL(rtas_token);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
Nathan Lynchf2d6d2d2006-12-06 18:50:45 -0600313int rtas_service_present(const char *service)
314{
315 return rtas_token(service) != RTAS_UNKNOWN_SERVICE;
316}
317EXPORT_SYMBOL(rtas_service_present);
318
Paul Mackerras033ef332005-10-26 17:05:24 +1000319#ifdef CONFIG_RTAS_ERROR_LOGGING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320/*
321 * Return the firmware-specified size of the error log buffer
322 * for all rtas calls that require an error buffer argument.
323 * This includes 'check-exception' and 'rtas-last-error'.
324 */
325int rtas_get_error_log_max(void)
326{
327 static int rtas_error_log_max;
328 if (rtas_error_log_max)
329 return rtas_error_log_max;
330
331 rtas_error_log_max = rtas_token ("rtas-error-log-max");
332 if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
333 (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
Paul Mackerras033ef332005-10-26 17:05:24 +1000334 printk (KERN_WARNING "RTAS: bad log buffer size %d\n",
335 rtas_error_log_max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 rtas_error_log_max = RTAS_ERROR_LOG_MAX;
337 }
338 return rtas_error_log_max;
339}
Paul Mackerras033ef332005-10-26 17:05:24 +1000340EXPORT_SYMBOL(rtas_get_error_log_max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342
Michael Ellerman1c21a292008-05-08 14:27:19 +1000343static char rtas_err_buf[RTAS_ERROR_LOG_MAX];
344static int rtas_last_error_token;
Paul Mackerras033ef332005-10-26 17:05:24 +1000345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346/** Return a copy of the detailed error text associated with the
347 * most recent failed call to rtas. Because the error text
348 * might go stale if there are any other intervening rtas calls,
349 * this routine must be called atomically with whatever produced
350 * the error (i.e. with rtas.lock still held from the previous call).
351 */
Paul Mackerras033ef332005-10-26 17:05:24 +1000352static char *__fetch_rtas_last_error(char *altbuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353{
354 struct rtas_args err_args, save_args;
355 u32 bufsz;
Paul Mackerras033ef332005-10-26 17:05:24 +1000356 char *buf = NULL;
357
358 if (rtas_last_error_token == -1)
359 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 bufsz = rtas_get_error_log_max();
362
Paul Mackerras033ef332005-10-26 17:05:24 +1000363 err_args.token = rtas_last_error_token;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 err_args.nargs = 2;
365 err_args.nret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
367 err_args.args[1] = bufsz;
368 err_args.args[2] = 0;
369
370 save_args = rtas.args;
371 rtas.args = err_args;
372
373 enter_rtas(__pa(&rtas.args));
374
375 err_args = rtas.args;
376 rtas.args = save_args;
377
Paul Mackerras033ef332005-10-26 17:05:24 +1000378 /* Log the error in the unlikely case that there was one. */
379 if (unlikely(err_args.args[2] == 0)) {
380 if (altbuf) {
381 buf = altbuf;
382 } else {
383 buf = rtas_err_buf;
384 if (mem_init_done)
385 buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
386 }
387 if (buf)
388 memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX);
389 }
390
391 return buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392}
393
Paul Mackerras033ef332005-10-26 17:05:24 +1000394#define get_errorlog_buffer() kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL)
395
396#else /* CONFIG_RTAS_ERROR_LOGGING */
397#define __fetch_rtas_last_error(x) NULL
398#define get_errorlog_buffer() NULL
399#endif
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401int rtas_call(int token, int nargs, int nret, int *outputs, ...)
402{
403 va_list list;
Paul Mackerras033ef332005-10-26 17:05:24 +1000404 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 unsigned long s;
406 struct rtas_args *rtas_args;
Paul Mackerras033ef332005-10-26 17:05:24 +1000407 char *buff_copy = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 int ret;
409
Michael Ellerman24da3dd2006-06-23 18:20:10 +1000410 if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 return -1;
412
413 /* Gotta do something different here, use global lock for now... */
414 spin_lock_irqsave(&rtas.lock, s);
415 rtas_args = &rtas.args;
416
417 rtas_args->token = token;
418 rtas_args->nargs = nargs;
419 rtas_args->nret = nret;
420 rtas_args->rets = (rtas_arg_t *)&(rtas_args->args[nargs]);
421 va_start(list, outputs);
Paul Mackerras033ef332005-10-26 17:05:24 +1000422 for (i = 0; i < nargs; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 rtas_args->args[i] = va_arg(list, rtas_arg_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 va_end(list);
425
426 for (i = 0; i < nret; ++i)
427 rtas_args->rets[i] = 0;
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 enter_rtas(__pa(rtas_args));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 /* A -1 return code indicates that the last command couldn't
432 be completed due to a hardware error. */
433 if (rtas_args->rets[0] == -1)
Paul Mackerras033ef332005-10-26 17:05:24 +1000434 buff_copy = __fetch_rtas_last_error(NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436 if (nret > 1 && outputs != NULL)
437 for (i = 0; i < nret-1; ++i)
438 outputs[i] = rtas_args->rets[i+1];
439 ret = (nret > 0)? rtas_args->rets[0]: 0;
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 /* Gotta do something different here, use global lock for now... */
442 spin_unlock_irqrestore(&rtas.lock, s);
443
444 if (buff_copy) {
445 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
446 if (mem_init_done)
447 kfree(buff_copy);
448 }
449 return ret;
450}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000451EXPORT_SYMBOL(rtas_call);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
John Rose507279d2006-06-05 16:31:48 -0500453/* For RTAS_BUSY (-2), delay for 1 millisecond. For an extended busy status
454 * code of 990n, perform the hinted delay of 10^n (last digit) milliseconds.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 */
John Rose507279d2006-06-05 16:31:48 -0500456unsigned int rtas_busy_delay_time(int status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
John Rose507279d2006-06-05 16:31:48 -0500458 int order;
459 unsigned int ms = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
John Rose507279d2006-06-05 16:31:48 -0500461 if (status == RTAS_BUSY) {
462 ms = 1;
463 } else if (status >= 9900 && status <= 9905) {
464 order = status - 9900;
465 for (ms = 1; order > 0; order--)
466 ms *= 10;
467 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
John Rose507279d2006-06-05 16:31:48 -0500469 return ms;
470}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000471EXPORT_SYMBOL(rtas_busy_delay_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
John Rose507279d2006-06-05 16:31:48 -0500473/* For an RTAS busy status code, perform the hinted delay. */
474unsigned int rtas_busy_delay(int status)
475{
476 unsigned int ms;
477
478 might_sleep();
479 ms = rtas_busy_delay_time(status);
480 if (ms)
481 msleep(ms);
482
483 return ms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000485EXPORT_SYMBOL(rtas_busy_delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
Michael Ellerman1c21a292008-05-08 14:27:19 +1000487static int rtas_error_rc(int rtas_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
489 int rc;
490
491 switch (rtas_rc) {
492 case -1: /* Hardware Error */
493 rc = -EIO;
494 break;
495 case -3: /* Bad indicator/domain/etc */
496 rc = -EINVAL;
497 break;
498 case -9000: /* Isolation error */
499 rc = -EFAULT;
500 break;
501 case -9001: /* Outstanding TCE/PTE */
502 rc = -EEXIST;
503 break;
504 case -9002: /* No usable slot */
505 rc = -ENODEV;
506 break;
507 default:
508 printk(KERN_ERR "%s: unexpected RTAS error %d\n",
Harvey Harrisone48b1b42008-03-29 08:21:07 +1100509 __func__, rtas_rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 rc = -ERANGE;
511 break;
512 }
513 return rc;
514}
515
516int rtas_get_power_level(int powerdomain, int *level)
517{
518 int token = rtas_token("get-power-level");
519 int rc;
520
521 if (token == RTAS_UNKNOWN_SERVICE)
522 return -ENOENT;
523
524 while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
525 udelay(1);
526
527 if (rc < 0)
528 return rtas_error_rc(rc);
529 return rc;
530}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000531EXPORT_SYMBOL(rtas_get_power_level);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533int rtas_set_power_level(int powerdomain, int level, int *setlevel)
534{
535 int token = rtas_token("set-power-level");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 int rc;
537
538 if (token == RTAS_UNKNOWN_SERVICE)
539 return -ENOENT;
540
John Rose507279d2006-06-05 16:31:48 -0500541 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
John Rose507279d2006-06-05 16:31:48 -0500543 } while (rtas_busy_delay(rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 if (rc < 0)
546 return rtas_error_rc(rc);
547 return rc;
548}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000549EXPORT_SYMBOL(rtas_set_power_level);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
551int rtas_get_sensor(int sensor, int index, int *state)
552{
553 int token = rtas_token("get-sensor-state");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 int rc;
555
556 if (token == RTAS_UNKNOWN_SERVICE)
557 return -ENOENT;
558
John Rose507279d2006-06-05 16:31:48 -0500559 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 rc = rtas_call(token, 2, 2, state, sensor, index);
John Rose507279d2006-06-05 16:31:48 -0500561 } while (rtas_busy_delay(rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
563 if (rc < 0)
564 return rtas_error_rc(rc);
565 return rc;
566}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000567EXPORT_SYMBOL(rtas_get_sensor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569int rtas_set_indicator(int indicator, int index, int new_value)
570{
571 int token = rtas_token("set-indicator");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 int rc;
573
574 if (token == RTAS_UNKNOWN_SERVICE)
575 return -ENOENT;
576
John Rose507279d2006-06-05 16:31:48 -0500577 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
John Rose507279d2006-06-05 16:31:48 -0500579 } while (rtas_busy_delay(rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 if (rc < 0)
582 return rtas_error_rc(rc);
583 return rc;
584}
Michael Ellermanab3ab742006-06-23 18:20:11 +1000585EXPORT_SYMBOL(rtas_set_indicator);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
Haren Myneni81b73dd2006-07-27 14:29:00 -0700587/*
588 * Ignoring RTAS extended delay
589 */
590int rtas_set_indicator_fast(int indicator, int index, int new_value)
591{
592 int rc;
593 int token = rtas_token("set-indicator");
594
595 if (token == RTAS_UNKNOWN_SERVICE)
596 return -ENOENT;
597
598 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
599
600 WARN_ON(rc == -2 || (rc >= 9900 && rc <= 9905));
601
602 if (rc < 0)
603 return rtas_error_rc(rc);
604
605 return rc;
606}
607
Paul Mackerras033ef332005-10-26 17:05:24 +1000608void rtas_restart(char *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
Paul Mackerrasf4fcbbe2005-11-03 14:41:19 +1100610 if (rtas_flash_term_hook)
611 rtas_flash_term_hook(SYS_RESTART);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 printk("RTAS system-reboot returned %d\n",
613 rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
614 for (;;);
615}
616
Paul Mackerras033ef332005-10-26 17:05:24 +1000617void rtas_power_off(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
Paul Mackerrasf4fcbbe2005-11-03 14:41:19 +1100619 if (rtas_flash_term_hook)
620 rtas_flash_term_hook(SYS_POWER_OFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 /* allow power on only with power button press */
622 printk("RTAS power-off returned %d\n",
623 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
624 for (;;);
625}
626
Paul Mackerras033ef332005-10-26 17:05:24 +1000627void rtas_halt(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628{
Paul Mackerrasf4fcbbe2005-11-03 14:41:19 +1100629 if (rtas_flash_term_hook)
630 rtas_flash_term_hook(SYS_HALT);
631 /* allow power on only with power button press */
632 printk("RTAS power-off returned %d\n",
633 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
634 for (;;);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635}
636
637/* Must be in the RMO region, so we place it here */
638static char rtas_os_term_buf[2048];
639
Paul Mackerras8f515062007-12-03 09:30:04 +1100640void rtas_os_term(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641{
642 int status;
643
Paul Mackerras8f515062007-12-03 09:30:04 +1100644 if (panic_timeout)
645 return;
646
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term"))
648 return;
649
Paul Mackerras8f515062007-12-03 09:30:04 +1100650 snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 do {
653 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
654 __pa(rtas_os_term_buf));
John Rose507279d2006-06-05 16:31:48 -0500655 } while (rtas_busy_delay(status));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
John Rose507279d2006-06-05 16:31:48 -0500657 if (status != 0)
658 printk(KERN_EMERG "ibm,os-term call failed %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660}
661
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600662static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
663#ifdef CONFIG_PPC_PSERIES
664static void rtas_percpu_suspend_me(void *info)
665{
666 long rc;
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100667 unsigned long msr_save;
668 int cpu;
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600669 struct rtas_suspend_me_data *data =
670 (struct rtas_suspend_me_data *)info;
671
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100672 atomic_inc(&data->working);
673
674 /* really need to ensure MSR.EE is off for H_JOIN */
675 msr_save = mfmsr();
676 mtmsr(msr_save & ~(MSR_EE));
677
678 rc = plpar_hcall_norets(H_JOIN);
679
680 mtmsr(msr_save);
681
682 if (rc == H_SUCCESS) {
683 /* This cpu was prodded and the suspend is complete. */
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600684 goto out;
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100685 } else if (rc == H_CONTINUE) {
686 /* All other cpus are in H_JOIN, this cpu does
687 * the suspend.
688 */
689 printk(KERN_DEBUG "calling ibm,suspend-me on cpu %i\n",
690 smp_processor_id());
691 data->error = rtas_call(data->token, 0, 1, NULL);
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600692
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100693 if (data->error)
694 printk(KERN_DEBUG "ibm,suspend-me returned %d\n",
695 data->error);
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600696 } else {
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100697 printk(KERN_ERR "H_JOIN on cpu %i failed with rc = %ld\n",
698 smp_processor_id(), rc);
699 data->error = rc;
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600700 }
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100701 /* This cpu did the suspend or got an error; in either case,
702 * we need to prod all other other cpus out of join state.
703 * Extra prods are harmless.
704 */
705 for_each_online_cpu(cpu)
706 plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu));
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600707out:
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100708 if (atomic_dec_return(&data->working) == 0)
709 complete(data->complete);
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600710}
711
712static int rtas_ibm_suspend_me(struct rtas_args *args)
713{
Dave C Boutcher368a6ba2006-06-12 19:49:20 -0500714 long state;
715 long rc;
Anton Blanchardb9377ff2006-07-19 08:01:28 +1000716 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600717 struct rtas_suspend_me_data data;
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100718 DECLARE_COMPLETION_ONSTACK(done);
719
720 if (!rtas_service_present("ibm,suspend-me"))
721 return -ENOSYS;
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600722
Dave C Boutcher368a6ba2006-06-12 19:49:20 -0500723 /* Make sure the state is valid */
Anton Blanchardb9377ff2006-07-19 08:01:28 +1000724 rc = plpar_hcall(H_VASI_STATE, retbuf,
725 ((u64)args->args[0] << 32) | args->args[1]);
726
727 state = retbuf[0];
Dave C Boutcher368a6ba2006-06-12 19:49:20 -0500728
729 if (rc) {
730 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
731 return rc;
732 } else if (state == H_VASI_ENABLED) {
733 args->args[args->nargs] = RTAS_NOT_SUSPENDABLE;
734 return 0;
735 } else if (state != H_VASI_SUSPENDING) {
736 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n",
737 state);
738 args->args[args->nargs] = -1;
739 return 0;
740 }
741
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100742 atomic_set(&data.working, 0);
743 data.token = rtas_token("ibm,suspend-me");
744 data.error = 0;
745 data.complete = &done;
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600746
747 /* Call function on all CPUs. One of us will make the
748 * rtas call
749 */
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200750 if (on_each_cpu(rtas_percpu_suspend_me, &data, 0))
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100751 data.error = -EINVAL;
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600752
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100753 wait_for_completion(&done);
754
755 if (data.error != 0)
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600756 printk(KERN_ERR "Error doing global join\n");
757
Nathan Lynch8f5c7572007-11-14 03:15:13 +1100758 return data.error;
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600759}
760#else /* CONFIG_PPC_PSERIES */
761static int rtas_ibm_suspend_me(struct rtas_args *args)
762{
763 return -ENOSYS;
764}
765#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
768{
769 struct rtas_args args;
770 unsigned long flags;
Paul Mackerras033ef332005-10-26 17:05:24 +1000771 char *buff_copy, *errbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 int nargs;
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600773 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
775 if (!capable(CAP_SYS_ADMIN))
776 return -EPERM;
777
778 if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
779 return -EFAULT;
780
781 nargs = args.nargs;
782 if (nargs > ARRAY_SIZE(args.args)
783 || args.nret > ARRAY_SIZE(args.args)
784 || nargs + args.nret > ARRAY_SIZE(args.args))
785 return -EINVAL;
786
787 /* Copy in args. */
788 if (copy_from_user(args.args, uargs->args,
789 nargs * sizeof(rtas_arg_t)) != 0)
790 return -EFAULT;
791
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600792 if (args.token == RTAS_UNKNOWN_SERVICE)
793 return -EINVAL;
794
Nathan Fontenotb79998f2008-07-31 02:23:27 +1000795 args.rets = &args.args[nargs];
796 memset(args.rets, 0, args.nret * sizeof(rtas_arg_t));
797
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600798 /* Need to handle ibm,suspend_me call specially */
799 if (args.token == ibm_suspend_me_token) {
800 rc = rtas_ibm_suspend_me(&args);
801 if (rc)
802 return rc;
803 goto copy_return;
804 }
805
Paul Mackerras033ef332005-10-26 17:05:24 +1000806 buff_copy = get_errorlog_buffer();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
808 spin_lock_irqsave(&rtas.lock, flags);
809
810 rtas.args = args;
811 enter_rtas(__pa(&rtas.args));
812 args = rtas.args;
813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 /* A -1 return code indicates that the last command couldn't
815 be completed due to a hardware error. */
Paul Mackerras033ef332005-10-26 17:05:24 +1000816 if (args.rets[0] == -1)
817 errbuf = __fetch_rtas_last_error(buff_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
819 spin_unlock_irqrestore(&rtas.lock, flags);
820
821 if (buff_copy) {
Paul Mackerras033ef332005-10-26 17:05:24 +1000822 if (errbuf)
823 log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 kfree(buff_copy);
825 }
826
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600827 copy_return:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 /* Copy out args. */
829 if (copy_to_user(uargs->args + nargs,
830 args.args + nargs,
831 args.nret * sizeof(rtas_arg_t)) != 0)
832 return -EFAULT;
833
834 return 0;
835}
836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837/*
Adrian Bunk943ffb52006-01-10 00:10:13 +0100838 * Call early during boot, before mem init or bootmem, to retrieve the RTAS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 * informations from the device-tree and allocate the RMO buffer for userland
840 * accesses.
841 */
842void __init rtas_initialize(void)
843{
Paul Mackerras033ef332005-10-26 17:05:24 +1000844 unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 /* Get RTAS dev node and fill up our "rtas" structure with infos
847 * about it.
848 */
849 rtas.dev = of_find_node_by_name(NULL, "rtas");
850 if (rtas.dev) {
Jeremy Kerra7f67bd2006-07-12 15:35:54 +1000851 const u32 *basep, *entryp, *sizep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000853 basep = of_get_property(rtas.dev, "linux,rtas-base", NULL);
854 sizep = of_get_property(rtas.dev, "rtas-size", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (basep != NULL && sizep != NULL) {
856 rtas.base = *basep;
857 rtas.size = *sizep;
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000858 entryp = of_get_property(rtas.dev,
Jeremy Kerra7f67bd2006-07-12 15:35:54 +1000859 "linux,rtas-entry", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 if (entryp == NULL) /* Ugh */
861 rtas.entry = rtas.base;
862 else
863 rtas.entry = *entryp;
864 } else
865 rtas.dev = NULL;
866 }
Paul Mackerras033ef332005-10-26 17:05:24 +1000867 if (!rtas.dev)
868 return;
869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 /* If RTAS was found, allocate the RMO buffer for it and look for
871 * the stop-self token if any
872 */
Paul Mackerras033ef332005-10-26 17:05:24 +1000873#ifdef CONFIG_PPC64
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +1100874 if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR)) {
Paul Mackerras033ef332005-10-26 17:05:24 +1000875 rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
Dave C Boutcher91dc1822006-01-13 18:39:24 -0600876 ibm_suspend_me_token = rtas_token("ibm,suspend-me");
877 }
Paul Mackerras033ef332005-10-26 17:05:24 +1000878#endif
879 rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
Paul Mackerras033ef332005-10-26 17:05:24 +1000881#ifdef CONFIG_RTAS_ERROR_LOGGING
882 rtas_last_error_token = rtas_token("rtas-last-error");
883#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884}
Michael Ellerman458148c2006-06-23 18:20:13 +1000885
886int __init early_init_dt_scan_rtas(unsigned long node,
887 const char *uname, int depth, void *data)
888{
889 u32 *basep, *entryp, *sizep;
890
891 if (depth != 1 || strcmp(uname, "rtas") != 0)
892 return 0;
893
894 basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL);
895 entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL);
896 sizep = of_get_flat_dt_prop(node, "rtas-size", NULL);
897
898 if (basep && entryp && sizep) {
899 rtas.base = *basep;
900 rtas.entry = *entryp;
901 rtas.size = *sizep;
902 }
903
Michael Ellermancc46bb92006-06-23 18:20:16 +1000904#ifdef CONFIG_UDBG_RTAS_CONSOLE
905 basep = of_get_flat_dt_prop(node, "put-term-char", NULL);
906 if (basep)
907 rtas_putchar_token = *basep;
908
909 basep = of_get_flat_dt_prop(node, "get-term-char", NULL);
910 if (basep)
911 rtas_getchar_token = *basep;
Michael Neuling9a2ded52006-08-16 23:12:14 -0500912
913 if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE &&
914 rtas_getchar_token != RTAS_UNKNOWN_SERVICE)
915 udbg_init_rtas_console();
916
Michael Ellermancc46bb92006-06-23 18:20:16 +1000917#endif
918
Michael Ellerman458148c2006-06-23 18:20:13 +1000919 /* break now */
920 return 1;
921}