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