?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[POWERPC] ps3: bind interrupt to cpu
[linux-2.6.git] / arch / powerpc / kernel / rtas.c
blob76b5d7ebdcc681fe0b8f4730300b90bc55827fce
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 #include <linux/capability.h>
21 #include <linux/delay.h>
22
23 #include <asm/prom.h>
24 #include <asm/rtas.h>
25 #include <asm/hvcall.h>
26 #include <asm/semaphore.h>
27 #include <asm/machdep.h>
28 #include <asm/firmware.h>
29 #include <asm/page.h>
30 #include <asm/param.h>
31 #include <asm/system.h>
32 #include <asm/delay.h>
33 #include <asm/uaccess.h>
34 #include <asm/lmb.h>
35 #include <asm/udbg.h>
36 #include <asm/syscalls.h>
37
38 struct rtas_t rtas = {
39 .lock = SPIN_LOCK_UNLOCKED
40 };
41 EXPORT_SYMBOL(rtas);
42
43 struct rtas_suspend_me_data {
44 long waiting;
45 struct rtas_args *args;
46 };
47
48 DEFINE_SPINLOCK(rtas_data_buf_lock);
49 EXPORT_SYMBOL(rtas_data_buf_lock);
50
51 char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned;
52 EXPORT_SYMBOL(rtas_data_buf);
53
54 unsigned long rtas_rmo_buf;
55
56 /*
57 * If non-NULL, this gets called when the kernel terminates.
58 * This is done like this so rtas_flash can be a module.
59 */
60 void (*rtas_flash_term_hook)(int);
61 EXPORT_SYMBOL(rtas_flash_term_hook);
62
63 /*
64 * call_rtas_display_status and call_rtas_display_status_delay
65 * are designed only for very early low-level debugging, which
66 * is why the token is hard-coded to 10.
67 */
68 static void call_rtas_display_status(char c)
69 {
70 struct rtas_args *args = &rtas.args;
71 unsigned long s;
72
73 if (!rtas.base)
74 return;
75 spin_lock_irqsave(&rtas.lock, s);
76
77 args->token = 10;
78 args->nargs = 1;
79 args->nret = 1;
80 args->rets = (rtas_arg_t *)&(args->args[1]);
81 args->args[0] = (unsigned char)c;
82
83 enter_rtas(__pa(args));
84
85 spin_unlock_irqrestore(&rtas.lock, s);
86 }
87
88 static void call_rtas_display_status_delay(char c)
89 {
90 static int pending_newline = 0; /* did last write end with unprinted newline? */
91 static int width = 16;
92
93 if (c == '\n') {
94 while (width-- > 0)
95 call_rtas_display_status(' ');
96 width = 16;
97 mdelay(500);
98 pending_newline = 1;
99 } else {
100 if (pending_newline) {
101 call_rtas_display_status('\r');
102 call_rtas_display_status('\n');
103 }
104 pending_newline = 0;
105 if (width--) {
106 call_rtas_display_status(c);
107 udelay(10000);
108 }
109 }
110 }
111
112 void __init udbg_init_rtas_panel(void)
113 {
114 udbg_putc = call_rtas_display_status_delay;
115 }
116
117 #ifdef CONFIG_UDBG_RTAS_CONSOLE
118
119 /* If you think you're dying before early_init_dt_scan_rtas() does its
120 * work, you can hard code the token values for your firmware here and
121 * hardcode rtas.base/entry etc.
122 */
123 static unsigned int rtas_putchar_token = RTAS_UNKNOWN_SERVICE;
124 static unsigned int rtas_getchar_token = RTAS_UNKNOWN_SERVICE;
125
126 static void udbg_rtascon_putc(char c)
127 {
128 int tries;
129
130 if (!rtas.base)
131 return;
132
133 /* Add CRs before LFs */
134 if (c == '\n')
135 udbg_rtascon_putc('\r');
136
137 /* if there is more than one character to be displayed, wait a bit */
138 for (tries = 0; tries < 16; tries++) {
139 if (rtas_call(rtas_putchar_token, 1, 1, NULL, c) == 0)
140 break;
141 udelay(1000);
142 }
143 }
144
145 static int udbg_rtascon_getc_poll(void)
146 {
147 int c;
148
149 if (!rtas.base)
150 return -1;
151
152 if (rtas_call(rtas_getchar_token, 0, 2, &c))
153 return -1;
154
155 return c;
156 }
157
158 static int udbg_rtascon_getc(void)
159 {
160 int c;
161
162 while ((c = udbg_rtascon_getc_poll()) == -1)
163 ;
164
165 return c;
166 }
167
168
169 void __init udbg_init_rtas_console(void)
170 {
171 udbg_putc = udbg_rtascon_putc;
172 udbg_getc = udbg_rtascon_getc;
173 udbg_getc_poll = udbg_rtascon_getc_poll;
174 }
175 #endif /* CONFIG_UDBG_RTAS_CONSOLE */
176
177 void rtas_progress(char *s, unsigned short hex)
178 {
179 struct device_node *root;
180 int width;
181 const int *p;
182 char *os;
183 static int display_character, set_indicator;
184 static int display_width, display_lines, form_feed;
185 const static int *row_width;
186 static DEFINE_SPINLOCK(progress_lock);
187 static int current_line;
188 static int pending_newline = 0; /* did last write end with unprinted newline? */
189
190 if (!rtas.base)
191 return;
192
193 if (display_width == 0) {
194 display_width = 0x10;
195 if ((root = find_path_device("/rtas"))) {
196 if ((p = get_property(root,
197 "ibm,display-line-length", NULL)))
198 display_width = *p;
199 if ((p = get_property(root,
200 "ibm,form-feed", NULL)))
201 form_feed = *p;
202 if ((p = get_property(root,
203 "ibm,display-number-of-lines", NULL)))
204 display_lines = *p;
205 row_width = get_property(root,
206 "ibm,display-truncation-length", NULL);
207 }
208 display_character = rtas_token("display-character");
209 set_indicator = rtas_token("set-indicator");
210 }
211
212 if (display_character == RTAS_UNKNOWN_SERVICE) {
213 /* use hex display if available */
214 if (set_indicator != RTAS_UNKNOWN_SERVICE)
215 rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
216 return;
217 }
218
219 spin_lock(&progress_lock);
220
221 /*
222 * Last write ended with newline, but we didn't print it since
223 * it would just clear the bottom line of output. Print it now
224 * instead.
225 *
226 * If no newline is pending and form feed is supported, clear the
227 * display with a form feed; otherwise, print a CR to start output
228 * at the beginning of the line.
229 */
230 if (pending_newline) {
231 rtas_call(display_character, 1, 1, NULL, '\r');
232 rtas_call(display_character, 1, 1, NULL, '\n');
233 pending_newline = 0;
234 } else {
235 current_line = 0;
236 if (form_feed)
237 rtas_call(display_character, 1, 1, NULL,
238 (char)form_feed);
239 else
240 rtas_call(display_character, 1, 1, NULL, '\r');
241 }
242
243 if (row_width)
244 width = row_width[current_line];
245 else
246 width = display_width;
247 os = s;
248 while (*os) {
249 if (*os == '\n' || *os == '\r') {
250 /* If newline is the last character, save it
251 * until next call to avoid bumping up the
252 * display output.
253 */
254 if (*os == '\n' && !os[1]) {
255 pending_newline = 1;
256 current_line++;
257 if (current_line > display_lines-1)
258 current_line = display_lines-1;
259 spin_unlock(&progress_lock);
260 return;
261 }
262
263 /* RTAS wants CR-LF, not just LF */
264
265 if (*os == '\n') {
266 rtas_call(display_character, 1, 1, NULL, '\r');
267 rtas_call(display_character, 1, 1, NULL, '\n');
268 } else {
269 /* CR might be used to re-draw a line, so we'll
270 * leave it alone and not add LF.
271 */
272 rtas_call(display_character, 1, 1, NULL, *os);
273 }
274
275 if (row_width)
276 width = row_width[current_line];
277 else
278 width = display_width;
279 } else {
280 width--;
281 rtas_call(display_character, 1, 1, NULL, *os);
282 }
283
284 os++;
285
286 /* if we overwrite the screen length */
287 if (width <= 0)
288 while ((*os != 0) && (*os != '\n') && (*os != '\r'))
289 os++;
290 }
291
292 spin_unlock(&progress_lock);
293 }
294 EXPORT_SYMBOL(rtas_progress); /* needed by rtas_flash module */
295
296 int rtas_token(const char *service)
297 {
298 const int *tokp;
299 if (rtas.dev == NULL)
300 return RTAS_UNKNOWN_SERVICE;
301 tokp = get_property(rtas.dev, service, NULL);
302 return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
303 }
304 EXPORT_SYMBOL(rtas_token);
305
306 int rtas_service_present(const char *service)
307 {
308 return rtas_token(service) != RTAS_UNKNOWN_SERVICE;
309 }
310 EXPORT_SYMBOL(rtas_service_present);
311
312 #ifdef CONFIG_RTAS_ERROR_LOGGING
313 /*
314 * Return the firmware-specified size of the error log buffer
315 * for all rtas calls that require an error buffer argument.
316 * This includes 'check-exception' and 'rtas-last-error'.
317 */
318 int rtas_get_error_log_max(void)
319 {
320 static int rtas_error_log_max;
321 if (rtas_error_log_max)
322 return rtas_error_log_max;
323
324 rtas_error_log_max = rtas_token ("rtas-error-log-max");
325 if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
326 (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
327 printk (KERN_WARNING "RTAS: bad log buffer size %d\n",
328 rtas_error_log_max);
329 rtas_error_log_max = RTAS_ERROR_LOG_MAX;
330 }
331 return rtas_error_log_max;
332 }
333 EXPORT_SYMBOL(rtas_get_error_log_max);
334
335
336 char rtas_err_buf[RTAS_ERROR_LOG_MAX];
337 int rtas_last_error_token;
338
339 /** Return a copy of the detailed error text associated with the
340 * most recent failed call to rtas. Because the error text
341 * might go stale if there are any other intervening rtas calls,
342 * this routine must be called atomically with whatever produced
343 * the error (i.e. with rtas.lock still held from the previous call).
344 */
345 static char *__fetch_rtas_last_error(char *altbuf)
346 {
347 struct rtas_args err_args, save_args;
348 u32 bufsz;
349 char *buf = NULL;
350
351 if (rtas_last_error_token == -1)
352 return NULL;
353
354 bufsz = rtas_get_error_log_max();
355
356 err_args.token = rtas_last_error_token;
357 err_args.nargs = 2;
358 err_args.nret = 1;
359 err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
360 err_args.args[1] = bufsz;
361 err_args.args[2] = 0;
362
363 save_args = rtas.args;
364 rtas.args = err_args;
365
366 enter_rtas(__pa(&rtas.args));
367
368 err_args = rtas.args;
369 rtas.args = save_args;
370
371 /* Log the error in the unlikely case that there was one. */
372 if (unlikely(err_args.args[2] == 0)) {
373 if (altbuf) {
374 buf = altbuf;
375 } else {
376 buf = rtas_err_buf;
377 if (mem_init_done)
378 buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
379 }
380 if (buf)
381 memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX);
382 }
383
384 return buf;
385 }
386
387 #define get_errorlog_buffer() kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL)
388
389 #else /* CONFIG_RTAS_ERROR_LOGGING */
390 #define __fetch_rtas_last_error(x) NULL
391 #define get_errorlog_buffer() NULL
392 #endif
393
394 int rtas_call(int token, int nargs, int nret, int *outputs, ...)
395 {
396 va_list list;
397 int i;
398 unsigned long s;
399 struct rtas_args *rtas_args;
400 char *buff_copy = NULL;
401 int ret;
402
403 if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE)
404 return -1;
405
406 /* Gotta do something different here, use global lock for now... */
407 spin_lock_irqsave(&rtas.lock, s);
408 rtas_args = &rtas.args;
409
410 rtas_args->token = token;
411 rtas_args->nargs = nargs;
412 rtas_args->nret = nret;
413 rtas_args->rets = (rtas_arg_t *)&(rtas_args->args[nargs]);
414 va_start(list, outputs);
415 for (i = 0; i < nargs; ++i)
416 rtas_args->args[i] = va_arg(list, rtas_arg_t);
417 va_end(list);
418
419 for (i = 0; i < nret; ++i)
420 rtas_args->rets[i] = 0;
421
422 enter_rtas(__pa(rtas_args));
423
424 /* A -1 return code indicates that the last command couldn't
425 be completed due to a hardware error. */
426 if (rtas_args->rets[0] == -1)
427 buff_copy = __fetch_rtas_last_error(NULL);
428
429 if (nret > 1 && outputs != NULL)
430 for (i = 0; i < nret-1; ++i)
431 outputs[i] = rtas_args->rets[i+1];
432 ret = (nret > 0)? rtas_args->rets[0]: 0;
433
434 /* Gotta do something different here, use global lock for now... */
435 spin_unlock_irqrestore(&rtas.lock, s);
436
437 if (buff_copy) {
438 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
439 if (mem_init_done)
440 kfree(buff_copy);
441 }
442 return ret;
443 }
444 EXPORT_SYMBOL(rtas_call);
445
446 /* For RTAS_BUSY (-2), delay for 1 millisecond. For an extended busy status
447 * code of 990n, perform the hinted delay of 10^n (last digit) milliseconds.
448 */
449 unsigned int rtas_busy_delay_time(int status)
450 {
451 int order;
452 unsigned int ms = 0;
453
454 if (status == RTAS_BUSY) {
455 ms = 1;
456 } else if (status >= 9900 && status <= 9905) {
457 order = status - 9900;
458 for (ms = 1; order > 0; order--)
459 ms *= 10;
460 }
461
462 return ms;
463 }
464 EXPORT_SYMBOL(rtas_busy_delay_time);
465
466 /* For an RTAS busy status code, perform the hinted delay. */
467 unsigned int rtas_busy_delay(int status)
468 {
469 unsigned int ms;
470
471 might_sleep();
472 ms = rtas_busy_delay_time(status);
473 if (ms)
474 msleep(ms);
475
476 return ms;
477 }
478 EXPORT_SYMBOL(rtas_busy_delay);
479
480 int rtas_error_rc(int rtas_rc)
481 {
482 int rc;
483
484 switch (rtas_rc) {
485 case -1: /* Hardware Error */
486 rc = -EIO;
487 break;
488 case -3: /* Bad indicator/domain/etc */
489 rc = -EINVAL;
490 break;
491 case -9000: /* Isolation error */
492 rc = -EFAULT;
493 break;
494 case -9001: /* Outstanding TCE/PTE */
495 rc = -EEXIST;
496 break;
497 case -9002: /* No usable slot */
498 rc = -ENODEV;
499 break;
500 default:
501 printk(KERN_ERR "%s: unexpected RTAS error %d\n",
502 __FUNCTION__, rtas_rc);
503 rc = -ERANGE;
504 break;
505 }
506 return rc;
507 }
508
509 int rtas_get_power_level(int powerdomain, int *level)
510 {
511 int token = rtas_token("get-power-level");
512 int rc;
513
514 if (token == RTAS_UNKNOWN_SERVICE)
515 return -ENOENT;
516
517 while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
518 udelay(1);
519
520 if (rc < 0)
521 return rtas_error_rc(rc);
522 return rc;
523 }
524 EXPORT_SYMBOL(rtas_get_power_level);
525
526 int rtas_set_power_level(int powerdomain, int level, int *setlevel)
527 {
528 int token = rtas_token("set-power-level");
529 int rc;
530
531 if (token == RTAS_UNKNOWN_SERVICE)
532 return -ENOENT;
533
534 do {
535 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
536 } while (rtas_busy_delay(rc));
537
538 if (rc < 0)
539 return rtas_error_rc(rc);
540 return rc;
541 }
542 EXPORT_SYMBOL(rtas_set_power_level);
543
544 int rtas_get_sensor(int sensor, int index, int *state)
545 {
546 int token = rtas_token("get-sensor-state");
547 int rc;
548
549 if (token == RTAS_UNKNOWN_SERVICE)
550 return -ENOENT;
551
552 do {
553 rc = rtas_call(token, 2, 2, state, sensor, index);
554 } while (rtas_busy_delay(rc));
555
556 if (rc < 0)
557 return rtas_error_rc(rc);
558 return rc;
559 }
560 EXPORT_SYMBOL(rtas_get_sensor);
561
562 int rtas_set_indicator(int indicator, int index, int new_value)
563 {
564 int token = rtas_token("set-indicator");
565 int rc;
566
567 if (token == RTAS_UNKNOWN_SERVICE)
568 return -ENOENT;
569
570 do {
571 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
572 } while (rtas_busy_delay(rc));
573
574 if (rc < 0)
575 return rtas_error_rc(rc);
576 return rc;
577 }
578 EXPORT_SYMBOL(rtas_set_indicator);
579
580 /*
581 * Ignoring RTAS extended delay
582 */
583 int rtas_set_indicator_fast(int indicator, int index, int new_value)
584 {
585 int rc;
586 int token = rtas_token("set-indicator");
587
588 if (token == RTAS_UNKNOWN_SERVICE)
589 return -ENOENT;
590
591 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
592
593 WARN_ON(rc == -2 || (rc >= 9900 && rc <= 9905));
594
595 if (rc < 0)
596 return rtas_error_rc(rc);
597
598 return rc;
599 }
600
601 void rtas_restart(char *cmd)
602 {
603 if (rtas_flash_term_hook)
604 rtas_flash_term_hook(SYS_RESTART);
605 printk("RTAS system-reboot returned %d\n",
606 rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
607 for (;;);
608 }
609
610 void rtas_power_off(void)
611 {
612 if (rtas_flash_term_hook)
613 rtas_flash_term_hook(SYS_POWER_OFF);
614 /* allow power on only with power button press */
615 printk("RTAS power-off returned %d\n",
616 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
617 for (;;);
618 }
619
620 void rtas_halt(void)
621 {
622 if (rtas_flash_term_hook)
623 rtas_flash_term_hook(SYS_HALT);
624 /* allow power on only with power button press */
625 printk("RTAS power-off returned %d\n",
626 rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
627 for (;;);
628 }
629
630 /* Must be in the RMO region, so we place it here */
631 static char rtas_os_term_buf[2048];
632
633 void rtas_os_term(char *str)
634 {
635 int status;
636
637 if (panic_timeout)
638 return;
639
640 if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term"))
641 return;
642
643 snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
644
645 do {
646 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
647 __pa(rtas_os_term_buf));
648 } while (rtas_busy_delay(status));
649
650 if (status != 0)
651 printk(KERN_EMERG "ibm,os-term call failed %d\n",
652 status);
653 }
654
655 static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
656 #ifdef CONFIG_PPC_PSERIES
657 static void rtas_percpu_suspend_me(void *info)
658 {
659 int i;
660 long rc;
661 long flags;
662 struct rtas_suspend_me_data *data =
663 (struct rtas_suspend_me_data *)info;
664
665 /*
666 * We use "waiting" to indicate our state. As long
667 * as it is >0, we are still trying to all join up.
668 * If it goes to 0, we have successfully joined up and
669 * one thread got H_CONTINUE. If any error happens,
670 * we set it to <0.
671 */
672 local_irq_save(flags);
673 do {
674 rc = plpar_hcall_norets(H_JOIN);
675 smp_rmb();
676 } while (rc == H_SUCCESS && data->waiting > 0);
677 if (rc == H_SUCCESS)
678 goto out;
679
680 if (rc == H_CONTINUE) {
681 data->waiting = 0;
682 data->args->args[data->args->nargs] =
683 rtas_call(ibm_suspend_me_token, 0, 1, NULL);
684 for_each_possible_cpu(i)
685 plpar_hcall_norets(H_PROD,i);
686 } else {
687 data->waiting = -EBUSY;
688 printk(KERN_ERR "Error on H_JOIN hypervisor call\n");
689 }
690
691 out:
692 local_irq_restore(flags);
693 return;
694 }
695
696 static int rtas_ibm_suspend_me(struct rtas_args *args)
697 {
698 int i;
699 long state;
700 long rc;
701 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
702 struct rtas_suspend_me_data data;
703
704 /* Make sure the state is valid */
705 rc = plpar_hcall(H_VASI_STATE, retbuf,
706 ((u64)args->args[0] << 32) | args->args[1]);
707
708 state = retbuf[0];
709
710 if (rc) {
711 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
712 return rc;
713 } else if (state == H_VASI_ENABLED) {
714 args->args[args->nargs] = RTAS_NOT_SUSPENDABLE;
715 return 0;
716 } else if (state != H_VASI_SUSPENDING) {
717 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n",
718 state);
719 args->args[args->nargs] = -1;
720 return 0;
721 }
722
723 data.waiting = 1;
724 data.args = args;
725
726 /* Call function on all CPUs. One of us will make the
727 * rtas call
728 */
729 if (on_each_cpu(rtas_percpu_suspend_me, &data, 1, 0))
730 data.waiting = -EINVAL;
731
732 if (data.waiting != 0)
733 printk(KERN_ERR "Error doing global join\n");
734
735 /* Prod each CPU. This won't hurt, and will wake
736 * anyone we successfully put to sleep with H_JOIN.
737 */
738 for_each_possible_cpu(i)
739 plpar_hcall_norets(H_PROD, i);
740
741 return data.waiting;
742 }
743 #else /* CONFIG_PPC_PSERIES */
744 static int rtas_ibm_suspend_me(struct rtas_args *args)
745 {
746 return -ENOSYS;
747 }
748 #endif
749
750 asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
751 {
752 struct rtas_args args;
753 unsigned long flags;
754 char *buff_copy, *errbuf = NULL;
755 int nargs;
756 int rc;
757
758 if (!capable(CAP_SYS_ADMIN))
759 return -EPERM;
760
761 if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
762 return -EFAULT;
763
764 nargs = args.nargs;
765 if (nargs > ARRAY_SIZE(args.args)
766 || args.nret > ARRAY_SIZE(args.args)
767 || nargs + args.nret > ARRAY_SIZE(args.args))
768 return -EINVAL;
769
770 /* Copy in args. */
771 if (copy_from_user(args.args, uargs->args,
772 nargs * sizeof(rtas_arg_t)) != 0)
773 return -EFAULT;
774
775 if (args.token == RTAS_UNKNOWN_SERVICE)
776 return -EINVAL;
777
778 /* Need to handle ibm,suspend_me call specially */
779 if (args.token == ibm_suspend_me_token) {
780 rc = rtas_ibm_suspend_me(&args);
781 if (rc)
782 return rc;
783 goto copy_return;
784 }
785
786 buff_copy = get_errorlog_buffer();
787
788 spin_lock_irqsave(&rtas.lock, flags);
789
790 rtas.args = args;
791 enter_rtas(__pa(&rtas.args));
792 args = rtas.args;
793
794 args.rets = &args.args[nargs];
795
796 /* A -1 return code indicates that the last command couldn't
797 be completed due to a hardware error. */
798 if (args.rets[0] == -1)
799 errbuf = __fetch_rtas_last_error(buff_copy);
800
801 spin_unlock_irqrestore(&rtas.lock, flags);
802
803 if (buff_copy) {
804 if (errbuf)
805 log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
806 kfree(buff_copy);
807 }
808
809 copy_return:
810 /* Copy out args. */
811 if (copy_to_user(uargs->args + nargs,
812 args.args + nargs,
813 args.nret * sizeof(rtas_arg_t)) != 0)
814 return -EFAULT;
815
816 return 0;
817 }
818
819 /*
820 * Call early during boot, before mem init or bootmem, to retrieve the RTAS
821 * informations from the device-tree and allocate the RMO buffer for userland
822 * accesses.
823 */
824 void __init rtas_initialize(void)
825 {
826 unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
827
828 /* Get RTAS dev node and fill up our "rtas" structure with infos
829 * about it.
830 */
831 rtas.dev = of_find_node_by_name(NULL, "rtas");
832 if (rtas.dev) {
833 const u32 *basep, *entryp, *sizep;
834
835 basep = get_property(rtas.dev, "linux,rtas-base", NULL);
836 sizep = get_property(rtas.dev, "rtas-size", NULL);
837 if (basep != NULL && sizep != NULL) {
838 rtas.base = *basep;
839 rtas.size = *sizep;
840 entryp = get_property(rtas.dev,
841 "linux,rtas-entry", NULL);
842 if (entryp == NULL) /* Ugh */
843 rtas.entry = rtas.base;
844 else
845 rtas.entry = *entryp;
846 } else
847 rtas.dev = NULL;
848 }
849 if (!rtas.dev)
850 return;
851
852 /* If RTAS was found, allocate the RMO buffer for it and look for
853 * the stop-self token if any
854 */
855 #ifdef CONFIG_PPC64
856 if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR)) {
857 rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
858 ibm_suspend_me_token = rtas_token("ibm,suspend-me");
859 }
860 #endif
861 rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
862
863 #ifdef CONFIG_RTAS_ERROR_LOGGING
864 rtas_last_error_token = rtas_token("rtas-last-error");
865 #endif
866 }
867
868 int __init early_init_dt_scan_rtas(unsigned long node,
869 const char *uname, int depth, void *data)
870 {
871 u32 *basep, *entryp, *sizep;
872
873 if (depth != 1 || strcmp(uname, "rtas") != 0)
874 return 0;
875
876 basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL);
877 entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL);
878 sizep = of_get_flat_dt_prop(node, "rtas-size", NULL);
879
880 if (basep && entryp && sizep) {
881 rtas.base = *basep;
882 rtas.entry = *entryp;
883 rtas.size = *sizep;
884 }
885
886 #ifdef CONFIG_UDBG_RTAS_CONSOLE
887 basep = of_get_flat_dt_prop(node, "put-term-char", NULL);
888 if (basep)
889 rtas_putchar_token = *basep;
890
891 basep = of_get_flat_dt_prop(node, "get-term-char", NULL);
892 if (basep)
893 rtas_getchar_token = *basep;
894
895 if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE &&
896 rtas_getchar_token != RTAS_UNKNOWN_SERVICE)
897 udbg_init_rtas_console();
898
899 #endif
900
901 /* break now */
902 return 1;
903 }
Linus' kernel tree