Merge branch 'master'
[linux-2.6] / 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/delay.h>
21
22 #include <asm/prom.h>
23 #include <asm/rtas.h>
24 #include <asm/semaphore.h>
25 #include <asm/machdep.h>
26 #include <asm/page.h>
27 #include <asm/param.h>
28 #include <asm/system.h>
29 #include <asm/delay.h>
30 #include <asm/uaccess.h>
31 #include <asm/lmb.h>
32 #ifdef CONFIG_PPC64
33 #include <asm/systemcfg.h>
34 #endif
35
36 struct rtas_t rtas = {
37         .lock = SPIN_LOCK_UNLOCKED
38 };
39
40 EXPORT_SYMBOL(rtas);
41
42 DEFINE_SPINLOCK(rtas_data_buf_lock);
43 char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned;
44 unsigned long rtas_rmo_buf;
45
46 /*
47  * If non-NULL, this gets called when the kernel terminates.
48  * This is done like this so rtas_flash can be a module.
49  */
50 void (*rtas_flash_term_hook)(int);
51 EXPORT_SYMBOL(rtas_flash_term_hook);
52
53 /*
54  * call_rtas_display_status and call_rtas_display_status_delay
55  * are designed only for very early low-level debugging, which
56  * is why the token is hard-coded to 10.
57  */
58 void call_rtas_display_status(unsigned char c)
59 {
60         struct rtas_args *args = &rtas.args;
61         unsigned long s;
62
63         if (!rtas.base)
64                 return;
65         spin_lock_irqsave(&rtas.lock, s);
66
67         args->token = 10;
68         args->nargs = 1;
69         args->nret  = 1;
70         args->rets  = (rtas_arg_t *)&(args->args[1]);
71         args->args[0] = (int)c;
72
73         enter_rtas(__pa(args));
74
75         spin_unlock_irqrestore(&rtas.lock, s);
76 }
77
78 void call_rtas_display_status_delay(unsigned char c)
79 {
80         static int pending_newline = 0;  /* did last write end with unprinted newline? */
81         static int width = 16;
82
83         if (c == '\n') {        
84                 while (width-- > 0)
85                         call_rtas_display_status(' ');
86                 width = 16;
87                 mdelay(500);
88                 pending_newline = 1;
89         } else {
90                 if (pending_newline) {
91                         call_rtas_display_status('\r');
92                         call_rtas_display_status('\n');
93                 } 
94                 pending_newline = 0;
95                 if (width--) {
96                         call_rtas_display_status(c);
97                         udelay(10000);
98                 }
99         }
100 }
101
102 void rtas_progress(char *s, unsigned short hex)
103 {
104         struct device_node *root;
105         int width, *p;
106         char *os;
107         static int display_character, set_indicator;
108         static int display_width, display_lines, *row_width, form_feed;
109         static DEFINE_SPINLOCK(progress_lock);
110         static int current_line;
111         static int pending_newline = 0;  /* did last write end with unprinted newline? */
112
113         if (!rtas.base)
114                 return;
115
116         if (display_width == 0) {
117                 display_width = 0x10;
118                 if ((root = find_path_device("/rtas"))) {
119                         if ((p = (unsigned int *)get_property(root,
120                                         "ibm,display-line-length", NULL)))
121                                 display_width = *p;
122                         if ((p = (unsigned int *)get_property(root,
123                                         "ibm,form-feed", NULL)))
124                                 form_feed = *p;
125                         if ((p = (unsigned int *)get_property(root,
126                                         "ibm,display-number-of-lines", NULL)))
127                                 display_lines = *p;
128                         row_width = (unsigned int *)get_property(root,
129                                         "ibm,display-truncation-length", NULL);
130                 }
131                 display_character = rtas_token("display-character");
132                 set_indicator = rtas_token("set-indicator");
133         }
134
135         if (display_character == RTAS_UNKNOWN_SERVICE) {
136                 /* use hex display if available */
137                 if (set_indicator != RTAS_UNKNOWN_SERVICE)
138                         rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
139                 return;
140         }
141
142         spin_lock(&progress_lock);
143
144         /*
145          * Last write ended with newline, but we didn't print it since
146          * it would just clear the bottom line of output. Print it now
147          * instead.
148          *
149          * If no newline is pending and form feed is supported, clear the
150          * display with a form feed; otherwise, print a CR to start output
151          * at the beginning of the line.
152          */
153         if (pending_newline) {
154                 rtas_call(display_character, 1, 1, NULL, '\r');
155                 rtas_call(display_character, 1, 1, NULL, '\n');
156                 pending_newline = 0;
157         } else {
158                 current_line = 0;
159                 if (form_feed)
160                         rtas_call(display_character, 1, 1, NULL,
161                                   (char)form_feed);
162                 else
163                         rtas_call(display_character, 1, 1, NULL, '\r');
164         }
165  
166         if (row_width)
167                 width = row_width[current_line];
168         else
169                 width = display_width;
170         os = s;
171         while (*os) {
172                 if (*os == '\n' || *os == '\r') {
173                         /* If newline is the last character, save it
174                          * until next call to avoid bumping up the
175                          * display output.
176                          */
177                         if (*os == '\n' && !os[1]) {
178                                 pending_newline = 1;
179                                 current_line++;
180                                 if (current_line > display_lines-1)
181                                         current_line = display_lines-1;
182                                 spin_unlock(&progress_lock);
183                                 return;
184                         }
185  
186                         /* RTAS wants CR-LF, not just LF */
187  
188                         if (*os == '\n') {
189                                 rtas_call(display_character, 1, 1, NULL, '\r');
190                                 rtas_call(display_character, 1, 1, NULL, '\n');
191                         } else {
192                                 /* CR might be used to re-draw a line, so we'll
193                                  * leave it alone and not add LF.
194                                  */
195                                 rtas_call(display_character, 1, 1, NULL, *os);
196                         }
197  
198                         if (row_width)
199                                 width = row_width[current_line];
200                         else
201                                 width = display_width;
202                 } else {
203                         width--;
204                         rtas_call(display_character, 1, 1, NULL, *os);
205                 }
206  
207                 os++;
208  
209                 /* if we overwrite the screen length */
210                 if (width <= 0)
211                         while ((*os != 0) && (*os != '\n') && (*os != '\r'))
212                                 os++;
213         }
214  
215         spin_unlock(&progress_lock);
216 }
217 EXPORT_SYMBOL(rtas_progress);           /* needed by rtas_flash module */
218
219 int rtas_token(const char *service)
220 {
221         int *tokp;
222         if (rtas.dev == NULL)
223                 return RTAS_UNKNOWN_SERVICE;
224         tokp = (int *) get_property(rtas.dev, service, NULL);
225         return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
226 }
227
228 #ifdef CONFIG_RTAS_ERROR_LOGGING
229 /*
230  * Return the firmware-specified size of the error log buffer
231  *  for all rtas calls that require an error buffer argument.
232  *  This includes 'check-exception' and 'rtas-last-error'.
233  */
234 int rtas_get_error_log_max(void)
235 {
236         static int rtas_error_log_max;
237         if (rtas_error_log_max)
238                 return rtas_error_log_max;
239
240         rtas_error_log_max = rtas_token ("rtas-error-log-max");
241         if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
242             (rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
243                 printk (KERN_WARNING "RTAS: bad log buffer size %d\n",
244                         rtas_error_log_max);
245                 rtas_error_log_max = RTAS_ERROR_LOG_MAX;
246         }
247         return rtas_error_log_max;
248 }
249 EXPORT_SYMBOL(rtas_get_error_log_max);
250
251
252 char rtas_err_buf[RTAS_ERROR_LOG_MAX];
253 int rtas_last_error_token;
254
255 /** Return a copy of the detailed error text associated with the
256  *  most recent failed call to rtas.  Because the error text
257  *  might go stale if there are any other intervening rtas calls,
258  *  this routine must be called atomically with whatever produced
259  *  the error (i.e. with rtas.lock still held from the previous call).
260  */
261 static char *__fetch_rtas_last_error(char *altbuf)
262 {
263         struct rtas_args err_args, save_args;
264         u32 bufsz;
265         char *buf = NULL;
266
267         if (rtas_last_error_token == -1)
268                 return NULL;
269
270         bufsz = rtas_get_error_log_max();
271
272         err_args.token = rtas_last_error_token;
273         err_args.nargs = 2;
274         err_args.nret = 1;
275         err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
276         err_args.args[1] = bufsz;
277         err_args.args[2] = 0;
278
279         save_args = rtas.args;
280         rtas.args = err_args;
281
282         enter_rtas(__pa(&rtas.args));
283
284         err_args = rtas.args;
285         rtas.args = save_args;
286
287         /* Log the error in the unlikely case that there was one. */
288         if (unlikely(err_args.args[2] == 0)) {
289                 if (altbuf) {
290                         buf = altbuf;
291                 } else {
292                         buf = rtas_err_buf;
293                         if (mem_init_done)
294                                 buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
295                 }
296                 if (buf)
297                         memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX);
298         }
299
300         return buf;
301 }
302
303 #define get_errorlog_buffer()   kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL)
304
305 #else /* CONFIG_RTAS_ERROR_LOGGING */
306 #define __fetch_rtas_last_error(x)      NULL
307 #define get_errorlog_buffer()           NULL
308 #endif
309
310 int rtas_call(int token, int nargs, int nret, int *outputs, ...)
311 {
312         va_list list;
313         int i;
314         unsigned long s;
315         struct rtas_args *rtas_args;
316         char *buff_copy = NULL;
317         int ret;
318
319         if (token == RTAS_UNKNOWN_SERVICE)
320                 return -1;
321
322         /* Gotta do something different here, use global lock for now... */
323         spin_lock_irqsave(&rtas.lock, s);
324         rtas_args = &rtas.args;
325
326         rtas_args->token = token;
327         rtas_args->nargs = nargs;
328         rtas_args->nret  = nret;
329         rtas_args->rets  = (rtas_arg_t *)&(rtas_args->args[nargs]);
330         va_start(list, outputs);
331         for (i = 0; i < nargs; ++i)
332                 rtas_args->args[i] = va_arg(list, rtas_arg_t);
333         va_end(list);
334
335         for (i = 0; i < nret; ++i)
336                 rtas_args->rets[i] = 0;
337
338         enter_rtas(__pa(rtas_args));
339
340         /* A -1 return code indicates that the last command couldn't
341            be completed due to a hardware error. */
342         if (rtas_args->rets[0] == -1)
343                 buff_copy = __fetch_rtas_last_error(NULL);
344
345         if (nret > 1 && outputs != NULL)
346                 for (i = 0; i < nret-1; ++i)
347                         outputs[i] = rtas_args->rets[i+1];
348         ret = (nret > 0)? rtas_args->rets[0]: 0;
349
350         /* Gotta do something different here, use global lock for now... */
351         spin_unlock_irqrestore(&rtas.lock, s);
352
353         if (buff_copy) {
354                 log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
355                 if (mem_init_done)
356                         kfree(buff_copy);
357         }
358         return ret;
359 }
360
361 /* Given an RTAS status code of 990n compute the hinted delay of 10^n
362  * (last digit) milliseconds.  For now we bound at n=5 (100 sec).
363  */
364 unsigned int rtas_extended_busy_delay_time(int status)
365 {
366         int order = status - 9900;
367         unsigned long ms;
368
369         if (order < 0)
370                 order = 0;      /* RTC depends on this for -2 clock busy */
371         else if (order > 5)
372                 order = 5;      /* bound */
373
374         /* Use microseconds for reasonable accuracy */
375         for (ms = 1; order > 0; order--)
376                 ms *= 10;
377
378         return ms; 
379 }
380
381 int rtas_error_rc(int rtas_rc)
382 {
383         int rc;
384
385         switch (rtas_rc) {
386                 case -1:                /* Hardware Error */
387                         rc = -EIO;
388                         break;
389                 case -3:                /* Bad indicator/domain/etc */
390                         rc = -EINVAL;
391                         break;
392                 case -9000:             /* Isolation error */
393                         rc = -EFAULT;
394                         break;
395                 case -9001:             /* Outstanding TCE/PTE */
396                         rc = -EEXIST;
397                         break;
398                 case -9002:             /* No usable slot */
399                         rc = -ENODEV;
400                         break;
401                 default:
402                         printk(KERN_ERR "%s: unexpected RTAS error %d\n",
403                                         __FUNCTION__, rtas_rc);
404                         rc = -ERANGE;
405                         break;
406         }
407         return rc;
408 }
409
410 int rtas_get_power_level(int powerdomain, int *level)
411 {
412         int token = rtas_token("get-power-level");
413         int rc;
414
415         if (token == RTAS_UNKNOWN_SERVICE)
416                 return -ENOENT;
417
418         while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
419                 udelay(1);
420
421         if (rc < 0)
422                 return rtas_error_rc(rc);
423         return rc;
424 }
425
426 int rtas_set_power_level(int powerdomain, int level, int *setlevel)
427 {
428         int token = rtas_token("set-power-level");
429         unsigned int wait_time;
430         int rc;
431
432         if (token == RTAS_UNKNOWN_SERVICE)
433                 return -ENOENT;
434
435         while (1) {
436                 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
437                 if (rc == RTAS_BUSY)
438                         udelay(1);
439                 else if (rtas_is_extended_busy(rc)) {
440                         wait_time = rtas_extended_busy_delay_time(rc);
441                         udelay(wait_time * 1000);
442                 } else
443                         break;
444         }
445
446         if (rc < 0)
447                 return rtas_error_rc(rc);
448         return rc;
449 }
450
451 int rtas_get_sensor(int sensor, int index, int *state)
452 {
453         int token = rtas_token("get-sensor-state");
454         unsigned int wait_time;
455         int rc;
456
457         if (token == RTAS_UNKNOWN_SERVICE)
458                 return -ENOENT;
459
460         while (1) {
461                 rc = rtas_call(token, 2, 2, state, sensor, index);
462                 if (rc == RTAS_BUSY)
463                         udelay(1);
464                 else if (rtas_is_extended_busy(rc)) {
465                         wait_time = rtas_extended_busy_delay_time(rc);
466                         udelay(wait_time * 1000);
467                 } else
468                         break;
469         }
470
471         if (rc < 0)
472                 return rtas_error_rc(rc);
473         return rc;
474 }
475
476 int rtas_set_indicator(int indicator, int index, int new_value)
477 {
478         int token = rtas_token("set-indicator");
479         unsigned int wait_time;
480         int rc;
481
482         if (token == RTAS_UNKNOWN_SERVICE)
483                 return -ENOENT;
484
485         while (1) {
486                 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
487                 if (rc == RTAS_BUSY)
488                         udelay(1);
489                 else if (rtas_is_extended_busy(rc)) {
490                         wait_time = rtas_extended_busy_delay_time(rc);
491                         udelay(wait_time * 1000);
492                 }
493                 else
494                         break;
495         }
496
497         if (rc < 0)
498                 return rtas_error_rc(rc);
499         return rc;
500 }
501
502 void rtas_restart(char *cmd)
503 {
504         if (rtas_flash_term_hook)
505                 rtas_flash_term_hook(SYS_RESTART);
506         printk("RTAS system-reboot returned %d\n",
507                rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
508         for (;;);
509 }
510
511 void rtas_power_off(void)
512 {
513         if (rtas_flash_term_hook)
514                 rtas_flash_term_hook(SYS_POWER_OFF);
515         /* allow power on only with power button press */
516         printk("RTAS power-off returned %d\n",
517                rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
518         for (;;);
519 }
520
521 void rtas_halt(void)
522 {
523         if (rtas_flash_term_hook)
524                 rtas_flash_term_hook(SYS_HALT);
525         /* allow power on only with power button press */
526         printk("RTAS power-off returned %d\n",
527                rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
528         for (;;);
529 }
530
531 /* Must be in the RMO region, so we place it here */
532 static char rtas_os_term_buf[2048];
533
534 void rtas_os_term(char *str)
535 {
536         int status;
537
538         if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term"))
539                 return;
540
541         snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
542
543         do {
544                 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
545                                    __pa(rtas_os_term_buf));
546
547                 if (status == RTAS_BUSY)
548                         udelay(1);
549                 else if (status != 0)
550                         printk(KERN_EMERG "ibm,os-term call failed %d\n",
551                                status);
552         } while (status == RTAS_BUSY);
553 }
554
555
556 asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
557 {
558         struct rtas_args args;
559         unsigned long flags;
560         char *buff_copy, *errbuf = NULL;
561         int nargs;
562
563         if (!capable(CAP_SYS_ADMIN))
564                 return -EPERM;
565
566         if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
567                 return -EFAULT;
568
569         nargs = args.nargs;
570         if (nargs > ARRAY_SIZE(args.args)
571             || args.nret > ARRAY_SIZE(args.args)
572             || nargs + args.nret > ARRAY_SIZE(args.args))
573                 return -EINVAL;
574
575         /* Copy in args. */
576         if (copy_from_user(args.args, uargs->args,
577                            nargs * sizeof(rtas_arg_t)) != 0)
578                 return -EFAULT;
579
580         buff_copy = get_errorlog_buffer();
581
582         spin_lock_irqsave(&rtas.lock, flags);
583
584         rtas.args = args;
585         enter_rtas(__pa(&rtas.args));
586         args = rtas.args;
587
588         args.rets = &args.args[nargs];
589
590         /* A -1 return code indicates that the last command couldn't
591            be completed due to a hardware error. */
592         if (args.rets[0] == -1)
593                 errbuf = __fetch_rtas_last_error(buff_copy);
594
595         spin_unlock_irqrestore(&rtas.lock, flags);
596
597         if (buff_copy) {
598                 if (errbuf)
599                         log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
600                 kfree(buff_copy);
601         }
602
603         /* Copy out args. */
604         if (copy_to_user(uargs->args + nargs,
605                          args.args + nargs,
606                          args.nret * sizeof(rtas_arg_t)) != 0)
607                 return -EFAULT;
608
609         return 0;
610 }
611
612 /* This version can't take the spinlock, because it never returns */
613
614 struct rtas_args rtas_stop_self_args = {
615         /* The token is initialized for real in setup_system() */
616         .token = RTAS_UNKNOWN_SERVICE,
617         .nargs = 0,
618         .nret = 1,
619         .rets = &rtas_stop_self_args.args[0],
620 };
621
622 void rtas_stop_self(void)
623 {
624         struct rtas_args *rtas_args = &rtas_stop_self_args;
625
626         local_irq_disable();
627
628         BUG_ON(rtas_args->token == RTAS_UNKNOWN_SERVICE);
629
630         printk("cpu %u (hwid %u) Ready to die...\n",
631                smp_processor_id(), hard_smp_processor_id());
632         enter_rtas(__pa(rtas_args));
633
634         panic("Alas, I survived.\n");
635 }
636
637 /*
638  * Call early during boot, before mem init or bootmem, to retreive the RTAS
639  * informations from the device-tree and allocate the RMO buffer for userland
640  * accesses.
641  */
642 void __init rtas_initialize(void)
643 {
644         unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
645
646         /* Get RTAS dev node and fill up our "rtas" structure with infos
647          * about it.
648          */
649         rtas.dev = of_find_node_by_name(NULL, "rtas");
650         if (rtas.dev) {
651                 u32 *basep, *entryp;
652                 u32 *sizep;
653
654                 basep = (u32 *)get_property(rtas.dev, "linux,rtas-base", NULL);
655                 sizep = (u32 *)get_property(rtas.dev, "rtas-size", NULL);
656                 if (basep != NULL && sizep != NULL) {
657                         rtas.base = *basep;
658                         rtas.size = *sizep;
659                         entryp = (u32 *)get_property(rtas.dev, "linux,rtas-entry", NULL);
660                         if (entryp == NULL) /* Ugh */
661                                 rtas.entry = rtas.base;
662                         else
663                                 rtas.entry = *entryp;
664                 } else
665                         rtas.dev = NULL;
666         }
667         if (!rtas.dev)
668                 return;
669
670         /* If RTAS was found, allocate the RMO buffer for it and look for
671          * the stop-self token if any
672          */
673 #ifdef CONFIG_PPC64
674         if (systemcfg->platform == PLATFORM_PSERIES_LPAR)
675                 rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
676 #endif
677         rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
678
679 #ifdef CONFIG_HOTPLUG_CPU
680         rtas_stop_self_args.token = rtas_token("stop-self");
681 #endif /* CONFIG_HOTPLUG_CPU */
682 #ifdef CONFIG_RTAS_ERROR_LOGGING
683         rtas_last_error_token = rtas_token("rtas-last-error");
684 #endif
685 }
686
687
688 EXPORT_SYMBOL(rtas_token);
689 EXPORT_SYMBOL(rtas_call);
690 EXPORT_SYMBOL(rtas_data_buf);
691 EXPORT_SYMBOL(rtas_data_buf_lock);
692 EXPORT_SYMBOL(rtas_extended_busy_delay_time);
693 EXPORT_SYMBOL(rtas_get_sensor);
694 EXPORT_SYMBOL(rtas_get_power_level);
695 EXPORT_SYMBOL(rtas_set_power_level);
696 EXPORT_SYMBOL(rtas_set_indicator);