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