6b0699b82b41a3f01259aef4350d4a91a1730d98
[linux-2.6.git] / arch / powerpc / kernel / rtas.c
1 /*
2  *
3  * Procedures for interfacing to the RTAS on CHRP machines.
4  *
5  * Peter Bergner, IBM   March 2001.
6  * Copyright (C) 2001 IBM.
7  *
8  *      This program is free software; you can redistribute it and/or
9  *      modify it under the terms of the GNU General Public License
10  *      as published by the Free Software Foundation; either version
11  *      2 of the License, or (at your option) any later version.
12  */
13
14 #include <stdarg.h>
15 #include <linux/kernel.h>
16 #include <linux/types.h>
17 #include <linux/spinlock.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #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 #ifdef CONFIG_RTAS_ERROR_LOGGING
307 /*
308  * Return the firmware-specified size of the error log buffer
309  *  for all rtas calls that require an error buffer argument.
310  *  This includes 'check-exception' and 'rtas-last-error'.
311  */
312 int rtas_get_error_log_max(void)
313 {
314         static int rtas_error_log_max;
315         if (rtas_error_log_max)
316                 return rtas_error_log_max;
317
318         rtas_error_log_max = rtas_token ("rtas-error-log-max");
319         if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
320             (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
321                 printk (KERN_WARNING "RTAS: bad log buffer size %d\n",
322                         rtas_error_log_max);
323                 rtas_error_log_max = RTAS_ERROR_LOG_MAX;
324         }
325         return rtas_error_log_max;
326 }
327 EXPORT_SYMBOL(rtas_get_error_log_max);
328
329
330 char rtas_err_buf[RTAS_ERROR_LOG_MAX];
331 int rtas_last_error_token;
332
333 /** Return a copy of the detailed error text associated with the
334  *  most recent failed call to rtas.  Because the error text
335  *  might go stale if there are any other intervening rtas calls,
336  *  this routine must be called atomically with whatever produced
337  *  the error (i.e. with rtas.lock still held from the previous call).
338  */
339 static char *__fetch_rtas_last_error(char *altbuf)
340 {
341         struct rtas_args err_args, save_args;
342         u32 bufsz;
343         char *buf = NULL;
344
345         if (rtas_last_error_token == -1)
346                 return NULL;
347
348         bufsz = rtas_get_error_log_max();
349
350         err_args.token = rtas_last_error_token;
351         err_args.nargs = 2;
352         err_args.nret = 1;
353         err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
354         err_args.args[1] = bufsz;
355         err_args.args[2] = 0;
356
357         save_args = rtas.args;
358         rtas.args = err_args;
359
360         enter_rtas(__pa(&rtas.args));
361
362         err_args = rtas.args;
363         rtas.args = save_args;
364
365         /* Log the error in the unlikely case that there was one. */
366         if (unlikely(err_args.args[2] == 0)) {
367                 if (altbuf) {
368                         buf = altbuf;
369                 } else {
370                         buf = rtas_err_buf;
371                         if (mem_init_done)
372                                 buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
373                 }
374                 if (buf)
375                         memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX);
376         }
377
378         return buf;
379 }
380
381 #define get_errorlog_buffer()   kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL)
382
383 #else /* CONFIG_RTAS_ERROR_LOGGING */
384 #define __fetch_rtas_last_error(x)      NULL
385 #define get_errorlog_buffer()           NULL
386 #endif
387
388 int rtas_call(int token, int nargs, int nret, int *outputs, ...)
389 {
390         va_list list;
391         int i;
392         unsigned long s;
393         struct rtas_args *rtas_args;
394         char *buff_copy = NULL;
395         int ret;
396
397         if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE)
398                 return -1;
399
400         /* Gotta do something different here, use global lock for now... */
401         spin_lock_irqsave(&rtas.lock, s);
402         rtas_args = &rtas.args;
403
404         rtas_args->token = token;
405         rtas_args->nargs = nargs;
406         rtas_args->nret  = nret;
407         rtas_args->rets  = (rtas_arg_t *)&(rtas_args->args[nargs]);
408         va_start(list, outputs);
409         for (i = 0; i < nargs; ++i)
410                 rtas_args->args[i] = va_arg(list, rtas_arg_t);
411         va_end(list);
412
413         for (i = 0; i < nret; ++i)
414                 rtas_args->rets[i] = 0;
415
416         enter_rtas(__pa(rtas_args));
417
418         /* A -1 return code indicates that the last command couldn't
419            be completed due to a hardware error. */
420         if (rtas_args->rets[0] == -1)
421                 buff_copy = __fetch_rtas_last_error(NULL);
422
423         if (nret > 1 && outputs != NULL)
424                 for (i = 0; i < nret-1; ++i)
425                         outputs[i] = rtas_args->rets[i+1];
426         ret = (nret > 0)? rtas_args->rets[0]: 0;
427
428         /* Gotta do something different here, use global lock for now... */
429         spin_unlock_irqrestore(&rtas.lock, s);
430
431         if (buff_copy) {
432                 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
433                 if (mem_init_done)
434                         kfree(buff_copy);
435         }
436         return ret;
437 }
438 EXPORT_SYMBOL(rtas_call);
439
440 /* For RTAS_BUSY (-2), delay for 1 millisecond.  For an extended busy status
441  * code of 990n, perform the hinted delay of 10^n (last digit) milliseconds.
442  */
443 unsigned int rtas_busy_delay_time(int status)
444 {
445         int order;
446         unsigned int ms = 0;
447
448         if (status == RTAS_BUSY) {
449                 ms = 1;
450         } else if (status >= 9900 && status <= 9905) {
451                 order = status - 9900;
452                 for (ms = 1; order > 0; order--)
453                         ms *= 10;
454         }
455
456         return ms;
457 }
458 EXPORT_SYMBOL(rtas_busy_delay_time);
459
460 /* For an RTAS busy status code, perform the hinted delay. */
461 unsigned int rtas_busy_delay(int status)
462 {
463         unsigned int ms;
464
465         might_sleep();
466         ms = rtas_busy_delay_time(status);
467         if (ms)
468                 msleep(ms);
469
470         return ms;
471 }
472 EXPORT_SYMBOL(rtas_busy_delay);
473
474 int rtas_error_rc(int rtas_rc)
475 {
476         int rc;
477
478         switch (rtas_rc) {
479                 case -1:                /* Hardware Error */
480                         rc = -EIO;
481                         break;
482                 case -3:                /* Bad indicator/domain/etc */
483                         rc = -EINVAL;
484                         break;
485                 case -9000:             /* Isolation error */
486                         rc = -EFAULT;
487                         break;
488                 case -9001:             /* Outstanding TCE/PTE */
489                         rc = -EEXIST;
490                         break;
491                 case -9002:             /* No usable slot */
492                         rc = -ENODEV;
493                         break;
494                 default:
495                         printk(KERN_ERR "%s: unexpected RTAS error %d\n",
496                                         __FUNCTION__, rtas_rc);
497                         rc = -ERANGE;
498                         break;
499         }
500         return rc;
501 }
502
503 int rtas_get_power_level(int powerdomain, int *level)
504 {
505         int token = rtas_token("get-power-level");
506         int rc;
507
508         if (token == RTAS_UNKNOWN_SERVICE)
509                 return -ENOENT;
510
511         while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
512                 udelay(1);
513
514         if (rc < 0)
515                 return rtas_error_rc(rc);
516         return rc;
517 }
518 EXPORT_SYMBOL(rtas_get_power_level);
519
520 int rtas_set_power_level(int powerdomain, int level, int *setlevel)
521 {
522         int token = rtas_token("set-power-level");
523         int rc;
524
525         if (token == RTAS_UNKNOWN_SERVICE)
526                 return -ENOENT;
527
528         do {
529                 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
530         } while (rtas_busy_delay(rc));
531
532         if (rc < 0)
533                 return rtas_error_rc(rc);
534         return rc;
535 }
536 EXPORT_SYMBOL(rtas_set_power_level);
537
538 int rtas_get_sensor(int sensor, int index, int *state)
539 {
540         int token = rtas_token("get-sensor-state");
541         int rc;
542
543         if (token == RTAS_UNKNOWN_SERVICE)
544                 return -ENOENT;
545
546         do {
547                 rc = rtas_call(token, 2, 2, state, sensor, index);
548         } while (rtas_busy_delay(rc));
549
550         if (rc < 0)
551                 return rtas_error_rc(rc);
552         return rc;
553 }
554 EXPORT_SYMBOL(rtas_get_sensor);
555
556 int rtas_set_indicator(int indicator, int index, int new_value)
557 {
558         int token = rtas_token("set-indicator");
559         int rc;
560
561         if (token == RTAS_UNKNOWN_SERVICE)
562                 return -ENOENT;
563
564         do {
565                 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
566         } while (rtas_busy_delay(rc));
567
568         if (rc < 0)
569                 return rtas_error_rc(rc);
570         return rc;
571 }
572 EXPORT_SYMBOL(rtas_set_indicator);
573
574 /*
575  * Ignoring RTAS extended delay
576  */
577 int rtas_set_indicator_fast(int indicator, int index, int new_value)
578 {
579         int rc;
580         int token = rtas_token("set-indicator");
581
582         if (token == RTAS_UNKNOWN_SERVICE)
583                 return -ENOENT;
584
585         rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
586
587         WARN_ON(rc == -2 || (rc >= 9900 && rc <= 9905));
588
589         if (rc < 0)
590                 return rtas_error_rc(rc);
591
592         return rc;
593 }
594
595 void rtas_restart(char *cmd)
596 {
597         if (rtas_flash_term_hook)
598                 rtas_flash_term_hook(SYS_RESTART);
599         printk("RTAS system-reboot returned %d\n",
600                rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
601         for (;;);
602 }
603
604 void rtas_power_off(void)
605 {
606         if (rtas_flash_term_hook)
607                 rtas_flash_term_hook(SYS_POWER_OFF);
608         /* allow power on only with power button press */
609         printk("RTAS power-off returned %d\n",
610                rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
611         for (;;);
612 }
613
614 void rtas_halt(void)
615 {
616         if (rtas_flash_term_hook)
617                 rtas_flash_term_hook(SYS_HALT);
618         /* allow power on only with power button press */
619         printk("RTAS power-off returned %d\n",
620                rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
621         for (;;);
622 }
623
624 /* Must be in the RMO region, so we place it here */
625 static char rtas_os_term_buf[2048];
626
627 void rtas_os_term(char *str)
628 {
629         int status;
630
631         if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term"))
632                 return;
633
634         snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
635
636         do {
637                 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
638                                    __pa(rtas_os_term_buf));
639         } while (rtas_busy_delay(status));
640
641         if (status != 0)
642                 printk(KERN_EMERG "ibm,os-term call failed %d\n",
643                                status);
644 }
645
646 static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
647 #ifdef CONFIG_PPC_PSERIES
648 static void rtas_percpu_suspend_me(void *info)
649 {
650         int i;
651         long rc;
652         long flags;
653         struct rtas_suspend_me_data *data =
654                 (struct rtas_suspend_me_data *)info;
655
656         /*
657          * We use "waiting" to indicate our state.  As long
658          * as it is >0, we are still trying to all join up.
659          * If it goes to 0, we have successfully joined up and
660          * one thread got H_CONTINUE.  If any error happens,
661          * we set it to <0.
662          */
663         local_irq_save(flags);
664         do {
665                 rc = plpar_hcall_norets(H_JOIN);
666                 smp_rmb();
667         } while (rc == H_SUCCESS && data->waiting > 0);
668         if (rc == H_SUCCESS)
669                 goto out;
670
671         if (rc == H_CONTINUE) {
672                 data->waiting = 0;
673                 data->args->args[data->args->nargs] =
674                         rtas_call(ibm_suspend_me_token, 0, 1, NULL);
675                 for_each_possible_cpu(i)
676                         plpar_hcall_norets(H_PROD,i);
677         } else {
678                 data->waiting = -EBUSY;
679                 printk(KERN_ERR "Error on H_JOIN hypervisor call\n");
680         }
681
682 out:
683         local_irq_restore(flags);
684         return;
685 }
686
687 static int rtas_ibm_suspend_me(struct rtas_args *args)
688 {
689         int i;
690         long state;
691         long rc;
692         unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
693         struct rtas_suspend_me_data data;
694
695         /* Make sure the state is valid */
696         rc = plpar_hcall(H_VASI_STATE, retbuf,
697                          ((u64)args->args[0] << 32) | args->args[1]);
698
699         state = retbuf[0];
700
701         if (rc) {
702                 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
703                 return rc;
704         } else if (state == H_VASI_ENABLED) {
705                 args->args[args->nargs] = RTAS_NOT_SUSPENDABLE;
706                 return 0;
707         } else if (state != H_VASI_SUSPENDING) {
708                 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n",
709                        state);
710                 args->args[args->nargs] = -1;
711                 return 0;
712         }
713
714         data.waiting = 1;
715         data.args = args;
716
717         /* Call function on all CPUs.  One of us will make the
718          * rtas call
719          */
720         if (on_each_cpu(rtas_percpu_suspend_me, &data, 1, 0))
721                 data.waiting = -EINVAL;
722
723         if (data.waiting != 0)
724                 printk(KERN_ERR "Error doing global join\n");
725
726         /* Prod each CPU.  This won't hurt, and will wake
727          * anyone we successfully put to sleep with H_JOIN.
728          */
729         for_each_possible_cpu(i)
730                 plpar_hcall_norets(H_PROD, i);
731
732         return data.waiting;
733 }
734 #else /* CONFIG_PPC_PSERIES */
735 static int rtas_ibm_suspend_me(struct rtas_args *args)
736 {
737         return -ENOSYS;
738 }
739 #endif
740
741 asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
742 {
743         struct rtas_args args;
744         unsigned long flags;
745         char *buff_copy, *errbuf = NULL;
746         int nargs;
747         int rc;
748
749         if (!capable(CAP_SYS_ADMIN))
750                 return -EPERM;
751
752         if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
753                 return -EFAULT;
754
755         nargs = args.nargs;
756         if (nargs > ARRAY_SIZE(args.args)
757             || args.nret > ARRAY_SIZE(args.args)
758             || nargs + args.nret > ARRAY_SIZE(args.args))
759                 return -EINVAL;
760
761         /* Copy in args. */
762         if (copy_from_user(args.args, uargs->args,
763                            nargs * sizeof(rtas_arg_t)) != 0)
764                 return -EFAULT;
765
766         if (args.token == RTAS_UNKNOWN_SERVICE)
767                 return -EINVAL;
768
769         /* Need to handle ibm,suspend_me call specially */
770         if (args.token == ibm_suspend_me_token) {
771                 rc = rtas_ibm_suspend_me(&args);
772                 if (rc)
773                         return rc;
774                 goto copy_return;
775         }
776
777         buff_copy = get_errorlog_buffer();
778
779         spin_lock_irqsave(&rtas.lock, flags);
780
781         rtas.args = args;
782         enter_rtas(__pa(&rtas.args));
783         args = rtas.args;
784
785         args.rets = &args.args[nargs];
786
787         /* A -1 return code indicates that the last command couldn't
788            be completed due to a hardware error. */
789         if (args.rets[0] == -1)
790                 errbuf = __fetch_rtas_last_error(buff_copy);
791
792         spin_unlock_irqrestore(&rtas.lock, flags);
793
794         if (buff_copy) {
795                 if (errbuf)
796                         log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
797                 kfree(buff_copy);
798         }
799
800  copy_return:
801         /* Copy out args. */
802         if (copy_to_user(uargs->args + nargs,
803                          args.args + nargs,
804                          args.nret * sizeof(rtas_arg_t)) != 0)
805                 return -EFAULT;
806
807         return 0;
808 }
809
810 /* This version can't take the spinlock, because it never returns */
811
812 struct rtas_args rtas_stop_self_args = {
813         /* The token is initialized for real in setup_system() */
814         .token = RTAS_UNKNOWN_SERVICE,
815         .nargs = 0,
816         .nret = 1,
817         .rets = &rtas_stop_self_args.args[0],
818 };
819
820 void rtas_stop_self(void)
821 {
822         struct rtas_args *rtas_args = &rtas_stop_self_args;
823
824         local_irq_disable();
825
826         BUG_ON(rtas_args->token == RTAS_UNKNOWN_SERVICE);
827
828         printk("cpu %u (hwid %u) Ready to die...\n",
829                smp_processor_id(), hard_smp_processor_id());
830         enter_rtas(__pa(rtas_args));
831
832         panic("Alas, I survived.\n");
833 }
834
835 /*
836  * Call early during boot, before mem init or bootmem, to retrieve the RTAS
837  * informations from the device-tree and allocate the RMO buffer for userland
838  * accesses.
839  */
840 void __init rtas_initialize(void)
841 {
842         unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
843
844         /* Get RTAS dev node and fill up our "rtas" structure with infos
845          * about it.
846          */
847         rtas.dev = of_find_node_by_name(NULL, "rtas");
848         if (rtas.dev) {
849                 const u32 *basep, *entryp, *sizep;
850
851                 basep = get_property(rtas.dev, "linux,rtas-base", NULL);
852                 sizep = get_property(rtas.dev, "rtas-size", NULL);
853                 if (basep != NULL && sizep != NULL) {
854                         rtas.base = *basep;
855                         rtas.size = *sizep;
856                         entryp = get_property(rtas.dev,
857                                         "linux,rtas-entry", NULL);
858                         if (entryp == NULL) /* Ugh */
859                                 rtas.entry = rtas.base;
860                         else
861                                 rtas.entry = *entryp;
862                 } else
863                         rtas.dev = NULL;
864         }
865         if (!rtas.dev)
866                 return;
867
868         /* If RTAS was found, allocate the RMO buffer for it and look for
869          * the stop-self token if any
870          */
871 #ifdef CONFIG_PPC64
872         if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR)) {
873                 rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
874                 ibm_suspend_me_token = rtas_token("ibm,suspend-me");
875         }
876 #endif
877         rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
878
879 #ifdef CONFIG_HOTPLUG_CPU
880         rtas_stop_self_args.token = rtas_token("stop-self");
881 #endif /* CONFIG_HOTPLUG_CPU */
882 #ifdef CONFIG_RTAS_ERROR_LOGGING
883         rtas_last_error_token = rtas_token("rtas-last-error");
884 #endif
885 }
886
887 int __init early_init_dt_scan_rtas(unsigned long node,
888                 const char *uname, int depth, void *data)
889 {
890         u32 *basep, *entryp, *sizep;
891
892         if (depth != 1 || strcmp(uname, "rtas") != 0)
893                 return 0;
894
895         basep  = of_get_flat_dt_prop(node, "linux,rtas-base", NULL);
896         entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL);
897         sizep  = of_get_flat_dt_prop(node, "rtas-size", NULL);
898
899         if (basep && entryp && sizep) {
900                 rtas.base = *basep;
901                 rtas.entry = *entryp;
902                 rtas.size = *sizep;
903         }
904
905 #ifdef CONFIG_UDBG_RTAS_CONSOLE
906         basep = of_get_flat_dt_prop(node, "put-term-char", NULL);
907         if (basep)
908                 rtas_putchar_token = *basep;
909
910         basep = of_get_flat_dt_prop(node, "get-term-char", NULL);
911         if (basep)
912                 rtas_getchar_token = *basep;
913
914         if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE &&
915             rtas_getchar_token != RTAS_UNKNOWN_SERVICE)
916                 udbg_init_rtas_console();
917
918 #endif
919
920         /* break now */
921         return 1;
922 }