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