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