2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Procedures for interfacing to the RTAS on CHRP machines.
|
|
|
|
*
|
|
|
|
* Peter Bergner, IBM March 2001.
|
|
|
|
* Copyright (C) 2001 IBM.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/spinlock.h>
|
2011-07-22 22:24:23 +00:00
|
|
|
#include <linux/export.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/init.h>
|
2006-01-11 20:17:48 +00:00
|
|
|
#include <linux/capability.h>
|
2005-11-07 05:41:59 +00:00
|
|
|
#include <linux/delay.h>
|
2013-05-07 04:34:11 +00:00
|
|
|
#include <linux/cpu.h>
|
2007-11-13 16:15:13 +00:00
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/cpumask.h>
|
2010-07-12 04:36:09 +00:00
|
|
|
#include <linux/memblock.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-07-26 00:13:10 +00:00
|
|
|
#include <linux/reboot.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/rtas.h>
|
2006-01-31 06:17:47 +00:00
|
|
|
#include <asm/hvcall.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/machdep.h>
|
2006-03-28 12:15:54 +00:00
|
|
|
#include <asm/firmware.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/param.h>
|
|
|
|
#include <asm/delay.h>
|
|
|
|
#include <asm/uaccess.h>
|
2006-01-11 00:54:09 +00:00
|
|
|
#include <asm/udbg.h>
|
2006-03-22 23:00:08 +00:00
|
|
|
#include <asm/syscalls.h>
|
2007-11-13 16:15:13 +00:00
|
|
|
#include <asm/smp.h>
|
2011-07-26 23:09:06 +00:00
|
|
|
#include <linux/atomic.h>
|
2009-06-16 16:42:50 +00:00
|
|
|
#include <asm/time.h>
|
2009-08-28 12:06:29 +00:00
|
|
|
#include <asm/mmu.h>
|
2010-12-01 12:31:26 +00:00
|
|
|
#include <asm/topology.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
struct rtas_t rtas = {
|
2009-12-03 11:38:57 +00:00
|
|
|
.lock = __ARCH_SPIN_LOCK_UNLOCKED
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
DEFINE_SPINLOCK(rtas_data_buf_lock);
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_data_buf_lock);
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
char rtas_data_buf[RTAS_DATA_BUF_SIZE] __cacheline_aligned;
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_data_buf);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long rtas_rmo_buf;
|
|
|
|
|
2005-11-03 03:41:19 +00:00
|
|
|
/*
|
|
|
|
* If non-NULL, this gets called when the kernel terminates.
|
|
|
|
* This is done like this so rtas_flash can be a module.
|
|
|
|
*/
|
|
|
|
void (*rtas_flash_term_hook)(int);
|
|
|
|
EXPORT_SYMBOL(rtas_flash_term_hook);
|
|
|
|
|
2009-06-16 16:42:49 +00:00
|
|
|
/* RTAS use home made raw locking instead of spin_lock_irqsave
|
|
|
|
* because those can be called from within really nasty contexts
|
|
|
|
* such as having the timebase stopped which would lockup with
|
|
|
|
* normal locks and spinlock debugging enabled
|
|
|
|
*/
|
|
|
|
static unsigned long lock_rtas(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
preempt_disable();
|
2009-12-02 19:01:25 +00:00
|
|
|
arch_spin_lock_flags(&rtas.lock, flags);
|
2009-06-16 16:42:49 +00:00
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unlock_rtas(unsigned long flags)
|
|
|
|
{
|
2009-12-02 19:01:25 +00:00
|
|
|
arch_spin_unlock(&rtas.lock);
|
2009-06-16 16:42:49 +00:00
|
|
|
local_irq_restore(flags);
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
/*
|
|
|
|
* call_rtas_display_status and call_rtas_display_status_delay
|
|
|
|
* are designed only for very early low-level debugging, which
|
|
|
|
* is why the token is hard-coded to 10.
|
|
|
|
*/
|
2006-01-11 00:54:09 +00:00
|
|
|
static void call_rtas_display_status(char c)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct rtas_args *args = &rtas.args;
|
|
|
|
unsigned long s;
|
|
|
|
|
|
|
|
if (!rtas.base)
|
|
|
|
return;
|
2009-06-16 16:42:49 +00:00
|
|
|
s = lock_rtas();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
args->token = 10;
|
|
|
|
args->nargs = 1;
|
|
|
|
args->nret = 1;
|
|
|
|
args->rets = (rtas_arg_t *)&(args->args[1]);
|
2006-01-11 00:54:09 +00:00
|
|
|
args->args[0] = (unsigned char)c;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
enter_rtas(__pa(args));
|
|
|
|
|
2009-06-16 16:42:49 +00:00
|
|
|
unlock_rtas(s);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-11 00:54:09 +00:00
|
|
|
static void call_rtas_display_status_delay(char c)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
static int pending_newline = 0; /* did last write end with unprinted newline? */
|
|
|
|
static int width = 16;
|
|
|
|
|
|
|
|
if (c == '\n') {
|
|
|
|
while (width-- > 0)
|
|
|
|
call_rtas_display_status(' ');
|
|
|
|
width = 16;
|
2005-11-07 05:41:59 +00:00
|
|
|
mdelay(500);
|
2005-04-16 22:20:36 +00:00
|
|
|
pending_newline = 1;
|
|
|
|
} else {
|
|
|
|
if (pending_newline) {
|
|
|
|
call_rtas_display_status('\r');
|
|
|
|
call_rtas_display_status('\n');
|
|
|
|
}
|
|
|
|
pending_newline = 0;
|
|
|
|
if (width--) {
|
|
|
|
call_rtas_display_status(c);
|
|
|
|
udelay(10000);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-23 08:20:16 +00:00
|
|
|
void __init udbg_init_rtas_panel(void)
|
2006-01-11 00:54:09 +00:00
|
|
|
{
|
|
|
|
udbg_putc = call_rtas_display_status_delay;
|
|
|
|
}
|
|
|
|
|
2006-06-23 08:20:16 +00:00
|
|
|
#ifdef CONFIG_UDBG_RTAS_CONSOLE
|
|
|
|
|
|
|
|
/* If you think you're dying before early_init_dt_scan_rtas() does its
|
|
|
|
* work, you can hard code the token values for your firmware here and
|
|
|
|
* hardcode rtas.base/entry etc.
|
|
|
|
*/
|
|
|
|
static unsigned int rtas_putchar_token = RTAS_UNKNOWN_SERVICE;
|
|
|
|
static unsigned int rtas_getchar_token = RTAS_UNKNOWN_SERVICE;
|
|
|
|
|
|
|
|
static void udbg_rtascon_putc(char c)
|
|
|
|
{
|
|
|
|
int tries;
|
|
|
|
|
|
|
|
if (!rtas.base)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Add CRs before LFs */
|
|
|
|
if (c == '\n')
|
|
|
|
udbg_rtascon_putc('\r');
|
|
|
|
|
|
|
|
/* if there is more than one character to be displayed, wait a bit */
|
|
|
|
for (tries = 0; tries < 16; tries++) {
|
|
|
|
if (rtas_call(rtas_putchar_token, 1, 1, NULL, c) == 0)
|
|
|
|
break;
|
|
|
|
udelay(1000);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int udbg_rtascon_getc_poll(void)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
|
|
|
|
if (!rtas.base)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (rtas_call(rtas_getchar_token, 0, 2, &c))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int udbg_rtascon_getc(void)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
|
|
|
|
while ((c = udbg_rtascon_getc_poll()) == -1)
|
|
|
|
;
|
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __init udbg_init_rtas_console(void)
|
|
|
|
{
|
|
|
|
udbg_putc = udbg_rtascon_putc;
|
|
|
|
udbg_getc = udbg_rtascon_getc;
|
|
|
|
udbg_getc_poll = udbg_rtascon_getc_poll;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_UDBG_RTAS_CONSOLE */
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
void rtas_progress(char *s, unsigned short hex)
|
2005-06-22 23:43:28 +00:00
|
|
|
{
|
|
|
|
struct device_node *root;
|
2006-07-12 05:35:54 +00:00
|
|
|
int width;
|
|
|
|
const int *p;
|
2005-06-22 23:43:28 +00:00
|
|
|
char *os;
|
|
|
|
static int display_character, set_indicator;
|
2006-07-12 05:35:54 +00:00
|
|
|
static int display_width, display_lines, form_feed;
|
2007-02-17 19:11:19 +00:00
|
|
|
static const int *row_width;
|
2005-06-22 23:43:28 +00:00
|
|
|
static DEFINE_SPINLOCK(progress_lock);
|
2005-06-23 06:09:41 +00:00
|
|
|
static int current_line;
|
2005-06-22 23:43:28 +00:00
|
|
|
static int pending_newline = 0; /* did last write end with unprinted newline? */
|
|
|
|
|
|
|
|
if (!rtas.base)
|
|
|
|
return;
|
|
|
|
|
2005-06-23 06:09:41 +00:00
|
|
|
if (display_width == 0) {
|
|
|
|
display_width = 0x10;
|
2007-04-24 03:50:55 +00:00
|
|
|
if ((root = of_find_node_by_path("/rtas"))) {
|
2007-04-03 12:26:41 +00:00
|
|
|
if ((p = of_get_property(root,
|
2005-06-23 06:09:41 +00:00
|
|
|
"ibm,display-line-length", NULL)))
|
|
|
|
display_width = *p;
|
2007-04-03 12:26:41 +00:00
|
|
|
if ((p = of_get_property(root,
|
2005-06-23 06:09:41 +00:00
|
|
|
"ibm,form-feed", NULL)))
|
|
|
|
form_feed = *p;
|
2007-04-03 12:26:41 +00:00
|
|
|
if ((p = of_get_property(root,
|
2005-06-23 06:09:41 +00:00
|
|
|
"ibm,display-number-of-lines", NULL)))
|
|
|
|
display_lines = *p;
|
2007-04-03 12:26:41 +00:00
|
|
|
row_width = of_get_property(root,
|
2005-06-23 06:09:41 +00:00
|
|
|
"ibm,display-truncation-length", NULL);
|
2007-04-24 03:50:55 +00:00
|
|
|
of_node_put(root);
|
2005-06-23 06:09:41 +00:00
|
|
|
}
|
2005-06-22 23:43:28 +00:00
|
|
|
display_character = rtas_token("display-character");
|
|
|
|
set_indicator = rtas_token("set-indicator");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (display_character == RTAS_UNKNOWN_SERVICE) {
|
|
|
|
/* use hex display if available */
|
|
|
|
if (set_indicator != RTAS_UNKNOWN_SERVICE)
|
|
|
|
rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&progress_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Last write ended with newline, but we didn't print it since
|
|
|
|
* it would just clear the bottom line of output. Print it now
|
|
|
|
* instead.
|
|
|
|
*
|
2005-06-23 06:09:41 +00:00
|
|
|
* If no newline is pending and form feed is supported, clear the
|
|
|
|
* display with a form feed; otherwise, print a CR to start output
|
|
|
|
* at the beginning of the line.
|
2005-06-22 23:43:28 +00:00
|
|
|
*/
|
|
|
|
if (pending_newline) {
|
|
|
|
rtas_call(display_character, 1, 1, NULL, '\r');
|
|
|
|
rtas_call(display_character, 1, 1, NULL, '\n');
|
|
|
|
pending_newline = 0;
|
|
|
|
} else {
|
2005-06-23 06:09:41 +00:00
|
|
|
current_line = 0;
|
|
|
|
if (form_feed)
|
|
|
|
rtas_call(display_character, 1, 1, NULL,
|
|
|
|
(char)form_feed);
|
|
|
|
else
|
|
|
|
rtas_call(display_character, 1, 1, NULL, '\r');
|
2005-06-22 23:43:28 +00:00
|
|
|
}
|
|
|
|
|
2005-06-23 06:09:41 +00:00
|
|
|
if (row_width)
|
|
|
|
width = row_width[current_line];
|
|
|
|
else
|
|
|
|
width = display_width;
|
2005-06-22 23:43:28 +00:00
|
|
|
os = s;
|
|
|
|
while (*os) {
|
|
|
|
if (*os == '\n' || *os == '\r') {
|
|
|
|
/* If newline is the last character, save it
|
|
|
|
* until next call to avoid bumping up the
|
|
|
|
* display output.
|
|
|
|
*/
|
|
|
|
if (*os == '\n' && !os[1]) {
|
|
|
|
pending_newline = 1;
|
2005-06-23 06:09:41 +00:00
|
|
|
current_line++;
|
|
|
|
if (current_line > display_lines-1)
|
|
|
|
current_line = display_lines-1;
|
2005-06-22 23:43:28 +00:00
|
|
|
spin_unlock(&progress_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* RTAS wants CR-LF, not just LF */
|
|
|
|
|
|
|
|
if (*os == '\n') {
|
|
|
|
rtas_call(display_character, 1, 1, NULL, '\r');
|
|
|
|
rtas_call(display_character, 1, 1, NULL, '\n');
|
|
|
|
} else {
|
|
|
|
/* CR might be used to re-draw a line, so we'll
|
|
|
|
* leave it alone and not add LF.
|
|
|
|
*/
|
|
|
|
rtas_call(display_character, 1, 1, NULL, *os);
|
|
|
|
}
|
|
|
|
|
2005-06-23 06:09:41 +00:00
|
|
|
if (row_width)
|
|
|
|
width = row_width[current_line];
|
|
|
|
else
|
|
|
|
width = display_width;
|
2005-06-22 23:43:28 +00:00
|
|
|
} else {
|
|
|
|
width--;
|
|
|
|
rtas_call(display_character, 1, 1, NULL, *os);
|
|
|
|
}
|
|
|
|
|
|
|
|
os++;
|
|
|
|
|
|
|
|
/* if we overwrite the screen length */
|
|
|
|
if (width <= 0)
|
|
|
|
while ((*os != 0) && (*os != '\n') && (*os != '\r'))
|
|
|
|
os++;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&progress_lock);
|
|
|
|
}
|
2005-11-03 03:41:19 +00:00
|
|
|
EXPORT_SYMBOL(rtas_progress); /* needed by rtas_flash module */
|
2005-06-22 23:43:28 +00:00
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
int rtas_token(const char *service)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-07-12 05:35:54 +00:00
|
|
|
const int *tokp;
|
2005-10-26 07:05:24 +00:00
|
|
|
if (rtas.dev == NULL)
|
2005-04-16 22:20:36 +00:00
|
|
|
return RTAS_UNKNOWN_SERVICE;
|
2007-04-03 12:26:41 +00:00
|
|
|
tokp = of_get_property(rtas.dev, service, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
|
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_token);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-07 00:50:45 +00:00
|
|
|
int rtas_service_present(const char *service)
|
|
|
|
{
|
|
|
|
return rtas_token(service) != RTAS_UNKNOWN_SERVICE;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rtas_service_present);
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
#ifdef CONFIG_RTAS_ERROR_LOGGING
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Return the firmware-specified size of the error log buffer
|
|
|
|
* for all rtas calls that require an error buffer argument.
|
|
|
|
* This includes 'check-exception' and 'rtas-last-error'.
|
|
|
|
*/
|
|
|
|
int rtas_get_error_log_max(void)
|
|
|
|
{
|
|
|
|
static int rtas_error_log_max;
|
|
|
|
if (rtas_error_log_max)
|
|
|
|
return rtas_error_log_max;
|
|
|
|
|
|
|
|
rtas_error_log_max = rtas_token ("rtas-error-log-max");
|
|
|
|
if ((rtas_error_log_max == RTAS_UNKNOWN_SERVICE) ||
|
|
|
|
(rtas_error_log_max > RTAS_ERROR_LOG_MAX)) {
|
2005-10-26 07:05:24 +00:00
|
|
|
printk (KERN_WARNING "RTAS: bad log buffer size %d\n",
|
|
|
|
rtas_error_log_max);
|
2005-04-16 22:20:36 +00:00
|
|
|
rtas_error_log_max = RTAS_ERROR_LOG_MAX;
|
|
|
|
}
|
|
|
|
return rtas_error_log_max;
|
|
|
|
}
|
2005-10-26 07:05:24 +00:00
|
|
|
EXPORT_SYMBOL(rtas_get_error_log_max);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
2008-05-08 04:27:19 +00:00
|
|
|
static char rtas_err_buf[RTAS_ERROR_LOG_MAX];
|
|
|
|
static int rtas_last_error_token;
|
2005-10-26 07:05:24 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/** Return a copy of the detailed error text associated with the
|
|
|
|
* most recent failed call to rtas. Because the error text
|
|
|
|
* might go stale if there are any other intervening rtas calls,
|
|
|
|
* this routine must be called atomically with whatever produced
|
|
|
|
* the error (i.e. with rtas.lock still held from the previous call).
|
|
|
|
*/
|
2005-10-26 07:05:24 +00:00
|
|
|
static char *__fetch_rtas_last_error(char *altbuf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct rtas_args err_args, save_args;
|
|
|
|
u32 bufsz;
|
2005-10-26 07:05:24 +00:00
|
|
|
char *buf = NULL;
|
|
|
|
|
|
|
|
if (rtas_last_error_token == -1)
|
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
bufsz = rtas_get_error_log_max();
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
err_args.token = rtas_last_error_token;
|
2005-04-16 22:20:36 +00:00
|
|
|
err_args.nargs = 2;
|
|
|
|
err_args.nret = 1;
|
|
|
|
err_args.args[0] = (rtas_arg_t)__pa(rtas_err_buf);
|
|
|
|
err_args.args[1] = bufsz;
|
|
|
|
err_args.args[2] = 0;
|
|
|
|
|
|
|
|
save_args = rtas.args;
|
|
|
|
rtas.args = err_args;
|
|
|
|
|
|
|
|
enter_rtas(__pa(&rtas.args));
|
|
|
|
|
|
|
|
err_args = rtas.args;
|
|
|
|
rtas.args = save_args;
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
/* Log the error in the unlikely case that there was one. */
|
|
|
|
if (unlikely(err_args.args[2] == 0)) {
|
|
|
|
if (altbuf) {
|
|
|
|
buf = altbuf;
|
|
|
|
} else {
|
|
|
|
buf = rtas_err_buf;
|
|
|
|
if (mem_init_done)
|
|
|
|
buf = kmalloc(RTAS_ERROR_LOG_MAX, GFP_ATOMIC);
|
|
|
|
}
|
|
|
|
if (buf)
|
|
|
|
memcpy(buf, rtas_err_buf, RTAS_ERROR_LOG_MAX);
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
#define get_errorlog_buffer() kmalloc(RTAS_ERROR_LOG_MAX, GFP_KERNEL)
|
|
|
|
|
|
|
|
#else /* CONFIG_RTAS_ERROR_LOGGING */
|
|
|
|
#define __fetch_rtas_last_error(x) NULL
|
|
|
|
#define get_errorlog_buffer() NULL
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int rtas_call(int token, int nargs, int nret, int *outputs, ...)
|
|
|
|
{
|
|
|
|
va_list list;
|
2005-10-26 07:05:24 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long s;
|
|
|
|
struct rtas_args *rtas_args;
|
2005-10-26 07:05:24 +00:00
|
|
|
char *buff_copy = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-06-23 08:20:10 +00:00
|
|
|
if (!rtas.entry || token == RTAS_UNKNOWN_SERVICE)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -1;
|
|
|
|
|
2009-06-16 16:42:49 +00:00
|
|
|
s = lock_rtas();
|
2005-04-16 22:20:36 +00:00
|
|
|
rtas_args = &rtas.args;
|
|
|
|
|
|
|
|
rtas_args->token = token;
|
|
|
|
rtas_args->nargs = nargs;
|
|
|
|
rtas_args->nret = nret;
|
|
|
|
rtas_args->rets = (rtas_arg_t *)&(rtas_args->args[nargs]);
|
|
|
|
va_start(list, outputs);
|
2005-10-26 07:05:24 +00:00
|
|
|
for (i = 0; i < nargs; ++i)
|
2005-04-16 22:20:36 +00:00
|
|
|
rtas_args->args[i] = va_arg(list, rtas_arg_t);
|
|
|
|
va_end(list);
|
|
|
|
|
|
|
|
for (i = 0; i < nret; ++i)
|
|
|
|
rtas_args->rets[i] = 0;
|
|
|
|
|
|
|
|
enter_rtas(__pa(rtas_args));
|
|
|
|
|
|
|
|
/* A -1 return code indicates that the last command couldn't
|
|
|
|
be completed due to a hardware error. */
|
|
|
|
if (rtas_args->rets[0] == -1)
|
2005-10-26 07:05:24 +00:00
|
|
|
buff_copy = __fetch_rtas_last_error(NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (nret > 1 && outputs != NULL)
|
|
|
|
for (i = 0; i < nret-1; ++i)
|
|
|
|
outputs[i] = rtas_args->rets[i+1];
|
|
|
|
ret = (nret > 0)? rtas_args->rets[0]: 0;
|
|
|
|
|
2009-06-16 16:42:49 +00:00
|
|
|
unlock_rtas(s);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (buff_copy) {
|
|
|
|
log_error(buff_copy, ERR_TYPE_RTAS_LOG, 0);
|
|
|
|
if (mem_init_done)
|
|
|
|
kfree(buff_copy);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_call);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
/* For RTAS_BUSY (-2), delay for 1 millisecond. For an extended busy status
|
|
|
|
* code of 990n, perform the hinted delay of 10^n (last digit) milliseconds.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-06-05 21:31:48 +00:00
|
|
|
unsigned int rtas_busy_delay_time(int status)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-06-05 21:31:48 +00:00
|
|
|
int order;
|
|
|
|
unsigned int ms = 0;
|
|
|
|
|
|
|
|
if (status == RTAS_BUSY) {
|
|
|
|
ms = 1;
|
|
|
|
} else if (status >= 9900 && status <= 9905) {
|
|
|
|
order = status - 9900;
|
|
|
|
for (ms = 1; order > 0; order--)
|
|
|
|
ms *= 10;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
return ms;
|
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_busy_delay_time);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
/* For an RTAS busy status code, perform the hinted delay. */
|
|
|
|
unsigned int rtas_busy_delay(int status)
|
|
|
|
{
|
|
|
|
unsigned int ms;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
might_sleep();
|
|
|
|
ms = rtas_busy_delay_time(status);
|
2011-04-07 01:54:07 +00:00
|
|
|
if (ms && need_resched())
|
2006-06-05 21:31:48 +00:00
|
|
|
msleep(ms);
|
|
|
|
|
|
|
|
return ms;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_busy_delay);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-05-08 04:27:19 +00:00
|
|
|
static int rtas_error_rc(int rtas_rc)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
switch (rtas_rc) {
|
|
|
|
case -1: /* Hardware Error */
|
|
|
|
rc = -EIO;
|
|
|
|
break;
|
|
|
|
case -3: /* Bad indicator/domain/etc */
|
|
|
|
rc = -EINVAL;
|
|
|
|
break;
|
|
|
|
case -9000: /* Isolation error */
|
|
|
|
rc = -EFAULT;
|
|
|
|
break;
|
|
|
|
case -9001: /* Outstanding TCE/PTE */
|
|
|
|
rc = -EEXIST;
|
|
|
|
break;
|
|
|
|
case -9002: /* No usable slot */
|
|
|
|
rc = -ENODEV;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "%s: unexpected RTAS error %d\n",
|
2008-03-28 21:21:07 +00:00
|
|
|
__func__, rtas_rc);
|
2005-04-16 22:20:36 +00:00
|
|
|
rc = -ERANGE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int rtas_get_power_level(int powerdomain, int *level)
|
|
|
|
{
|
|
|
|
int token = rtas_token("get-power-level");
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (token == RTAS_UNKNOWN_SERVICE)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
|
|
|
|
udelay(1);
|
|
|
|
|
|
|
|
if (rc < 0)
|
|
|
|
return rtas_error_rc(rc);
|
|
|
|
return rc;
|
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_get_power_level);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
int rtas_set_power_level(int powerdomain, int level, int *setlevel)
|
|
|
|
{
|
|
|
|
int token = rtas_token("set-power-level");
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (token == RTAS_UNKNOWN_SERVICE)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
do {
|
2005-04-16 22:20:36 +00:00
|
|
|
rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
|
2006-06-05 21:31:48 +00:00
|
|
|
} while (rtas_busy_delay(rc));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (rc < 0)
|
|
|
|
return rtas_error_rc(rc);
|
|
|
|
return rc;
|
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_set_power_level);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
int rtas_get_sensor(int sensor, int index, int *state)
|
|
|
|
{
|
|
|
|
int token = rtas_token("get-sensor-state");
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (token == RTAS_UNKNOWN_SERVICE)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
do {
|
2005-04-16 22:20:36 +00:00
|
|
|
rc = rtas_call(token, 2, 2, state, sensor, index);
|
2006-06-05 21:31:48 +00:00
|
|
|
} while (rtas_busy_delay(rc));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (rc < 0)
|
|
|
|
return rtas_error_rc(rc);
|
|
|
|
return rc;
|
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_get_sensor);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-11 09:14:25 +00:00
|
|
|
bool rtas_indicator_present(int token, int *maxindex)
|
|
|
|
{
|
|
|
|
int proplen, count, i;
|
|
|
|
const struct indicator_elem {
|
|
|
|
u32 token;
|
|
|
|
u32 maxindex;
|
|
|
|
} *indicators;
|
|
|
|
|
|
|
|
indicators = of_get_property(rtas.dev, "rtas-indicators", &proplen);
|
|
|
|
if (!indicators)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
count = proplen / sizeof(struct indicator_elem);
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
if (indicators[i].token != token)
|
|
|
|
continue;
|
|
|
|
if (maxindex)
|
|
|
|
*maxindex = indicators[i].maxindex;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rtas_indicator_present);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int rtas_set_indicator(int indicator, int index, int new_value)
|
|
|
|
{
|
|
|
|
int token = rtas_token("set-indicator");
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (token == RTAS_UNKNOWN_SERVICE)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
do {
|
2005-04-16 22:20:36 +00:00
|
|
|
rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
|
2006-06-05 21:31:48 +00:00
|
|
|
} while (rtas_busy_delay(rc));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (rc < 0)
|
|
|
|
return rtas_error_rc(rc);
|
|
|
|
return rc;
|
|
|
|
}
|
2006-06-23 08:20:11 +00:00
|
|
|
EXPORT_SYMBOL(rtas_set_indicator);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-07-27 21:29:00 +00:00
|
|
|
/*
|
|
|
|
* Ignoring RTAS extended delay
|
|
|
|
*/
|
|
|
|
int rtas_set_indicator_fast(int indicator, int index, int new_value)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
int token = rtas_token("set-indicator");
|
|
|
|
|
|
|
|
if (token == RTAS_UNKNOWN_SERVICE)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
|
|
|
|
|
|
|
|
WARN_ON(rc == -2 || (rc >= 9900 && rc <= 9905));
|
|
|
|
|
|
|
|
if (rc < 0)
|
|
|
|
return rtas_error_rc(rc);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
void rtas_restart(char *cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-11-03 03:41:19 +00:00
|
|
|
if (rtas_flash_term_hook)
|
|
|
|
rtas_flash_term_hook(SYS_RESTART);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("RTAS system-reboot returned %d\n",
|
|
|
|
rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
|
|
|
|
for (;;);
|
|
|
|
}
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
void rtas_power_off(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-11-03 03:41:19 +00:00
|
|
|
if (rtas_flash_term_hook)
|
|
|
|
rtas_flash_term_hook(SYS_POWER_OFF);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* allow power on only with power button press */
|
|
|
|
printk("RTAS power-off returned %d\n",
|
|
|
|
rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
|
|
|
|
for (;;);
|
|
|
|
}
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
void rtas_halt(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-11-03 03:41:19 +00:00
|
|
|
if (rtas_flash_term_hook)
|
|
|
|
rtas_flash_term_hook(SYS_HALT);
|
|
|
|
/* allow power on only with power button press */
|
|
|
|
printk("RTAS power-off returned %d\n",
|
|
|
|
rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
|
|
|
|
for (;;);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Must be in the RMO region, so we place it here */
|
|
|
|
static char rtas_os_term_buf[2048];
|
|
|
|
|
2007-12-02 22:30:04 +00:00
|
|
|
void rtas_os_term(char *str)
|
2007-11-20 01:28:15 +00:00
|
|
|
{
|
|
|
|
int status;
|
2006-08-21 16:11:32 +00:00
|
|
|
|
powerpc/pseries: Call ibm,os-term if the ibm,extended-os-term is present
We have had issues in the past with ibm,os-term initiating shutdown of a
partition. This is confusing to the user, especially if panic_timeout is
non zero.
The temporary fix was to avoid calling ibm,os-term if a panic_timeout was set
and since we set it on every boot we basically never call ibm,os-term.
An extended version of ibm,os-term has since been implemented which gives us
the behaviour we want:
"When the platform supports extended ibm,os-term behavior, the return to the
RTAS will always occur unless there is a kernel assisted dump active as
initiated by an ibm,configure-kernel-dump call."
This patch checks for the ibm,extended-os-term property and calls ibm,os-term
if it exists.
Signed-off-by: Anton Blanchard <anton@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-02-18 12:11:51 +00:00
|
|
|
/*
|
|
|
|
* Firmware with the ibm,extended-os-term property is guaranteed
|
|
|
|
* to always return from an ibm,os-term call. Earlier versions without
|
|
|
|
* this property may terminate the partition which we want to avoid
|
|
|
|
* since it interferes with panic_timeout.
|
|
|
|
*/
|
|
|
|
if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term") ||
|
|
|
|
RTAS_UNKNOWN_SERVICE == rtas_token("ibm,extended-os-term"))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
2007-12-02 22:30:04 +00:00
|
|
|
snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
do {
|
|
|
|
status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
|
|
|
|
__pa(rtas_os_term_buf));
|
2006-06-05 21:31:48 +00:00
|
|
|
} while (rtas_busy_delay(status));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-05 21:31:48 +00:00
|
|
|
if (status != 0)
|
powerpc/pseries: Call ibm,os-term if the ibm,extended-os-term is present
We have had issues in the past with ibm,os-term initiating shutdown of a
partition. This is confusing to the user, especially if panic_timeout is
non zero.
The temporary fix was to avoid calling ibm,os-term if a panic_timeout was set
and since we set it on every boot we basically never call ibm,os-term.
An extended version of ibm,os-term has since been implemented which gives us
the behaviour we want:
"When the platform supports extended ibm,os-term behavior, the return to the
RTAS will always occur unless there is a kernel assisted dump active as
initiated by an ibm,configure-kernel-dump call."
This patch checks for the ibm,extended-os-term property and calls ibm,os-term
if it exists.
Signed-off-by: Anton Blanchard <anton@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-02-18 12:11:51 +00:00
|
|
|
printk(KERN_EMERG "ibm,os-term call failed %d\n", status);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-14 00:39:24 +00:00
|
|
|
static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
|
|
|
|
#ifdef CONFIG_PPC_PSERIES
|
2010-07-07 12:31:01 +00:00
|
|
|
static int __rtas_suspend_last_cpu(struct rtas_suspend_me_data *data, int wake_when_done)
|
|
|
|
{
|
|
|
|
u16 slb_size = mmu_slb_size;
|
|
|
|
int rc = H_MULTI_THREADS_ACTIVE;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
slb_set_size(SLB_MIN_SIZE);
|
|
|
|
printk(KERN_DEBUG "calling ibm,suspend-me on cpu %i\n", smp_processor_id());
|
|
|
|
|
|
|
|
while (rc == H_MULTI_THREADS_ACTIVE && !atomic_read(&data->done) &&
|
|
|
|
!atomic_read(&data->error))
|
|
|
|
rc = rtas_call(data->token, 0, 1, NULL);
|
|
|
|
|
|
|
|
if (rc || atomic_read(&data->error)) {
|
|
|
|
printk(KERN_DEBUG "ibm,suspend-me returned %d\n", rc);
|
|
|
|
slb_set_size(slb_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atomic_read(&data->error))
|
|
|
|
rc = atomic_read(&data->error);
|
|
|
|
|
|
|
|
atomic_set(&data->error, rc);
|
2011-05-04 06:01:20 +00:00
|
|
|
pSeries_coalesce_init();
|
2010-07-07 12:31:01 +00:00
|
|
|
|
|
|
|
if (wake_when_done) {
|
|
|
|
atomic_set(&data->done, 1);
|
|
|
|
|
|
|
|
for_each_online_cpu(cpu)
|
|
|
|
plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atomic_dec_return(&data->working) == 0)
|
|
|
|
complete(data->complete);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int rtas_suspend_last_cpu(struct rtas_suspend_me_data *data)
|
|
|
|
{
|
|
|
|
atomic_inc(&data->working);
|
|
|
|
return __rtas_suspend_last_cpu(data, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __rtas_suspend_cpu(struct rtas_suspend_me_data *data, int wake_when_done)
|
2006-01-14 00:39:24 +00:00
|
|
|
{
|
2009-02-17 06:49:50 +00:00
|
|
|
long rc = H_SUCCESS;
|
2007-11-13 16:15:13 +00:00
|
|
|
unsigned long msr_save;
|
|
|
|
int cpu;
|
2006-01-14 00:39:24 +00:00
|
|
|
|
2007-11-13 16:15:13 +00:00
|
|
|
atomic_inc(&data->working);
|
|
|
|
|
|
|
|
/* really need to ensure MSR.EE is off for H_JOIN */
|
|
|
|
msr_save = mfmsr();
|
|
|
|
mtmsr(msr_save & ~(MSR_EE));
|
|
|
|
|
2010-07-07 12:31:01 +00:00
|
|
|
while (rc == H_SUCCESS && !atomic_read(&data->done) && !atomic_read(&data->error))
|
2009-02-17 06:49:50 +00:00
|
|
|
rc = plpar_hcall_norets(H_JOIN);
|
2007-11-13 16:15:13 +00:00
|
|
|
|
|
|
|
mtmsr(msr_save);
|
2006-01-14 00:39:24 +00:00
|
|
|
|
2007-11-13 16:15:13 +00:00
|
|
|
if (rc == H_SUCCESS) {
|
|
|
|
/* This cpu was prodded and the suspend is complete. */
|
|
|
|
goto out;
|
|
|
|
} else if (rc == H_CONTINUE) {
|
|
|
|
/* All other cpus are in H_JOIN, this cpu does
|
|
|
|
* the suspend.
|
|
|
|
*/
|
2010-07-07 12:31:01 +00:00
|
|
|
return __rtas_suspend_last_cpu(data, wake_when_done);
|
2006-01-14 00:39:24 +00:00
|
|
|
} else {
|
2007-11-13 16:15:13 +00:00
|
|
|
printk(KERN_ERR "H_JOIN on cpu %i failed with rc = %ld\n",
|
|
|
|
smp_processor_id(), rc);
|
2010-07-07 12:31:01 +00:00
|
|
|
atomic_set(&data->error, rc);
|
2006-01-14 00:39:24 +00:00
|
|
|
}
|
2009-02-17 06:49:50 +00:00
|
|
|
|
2010-07-07 12:31:01 +00:00
|
|
|
if (wake_when_done) {
|
|
|
|
atomic_set(&data->done, 1);
|
2009-02-17 06:49:50 +00:00
|
|
|
|
2010-07-07 12:31:01 +00:00
|
|
|
/* This cpu did the suspend or got an error; in either case,
|
|
|
|
* we need to prod all other other cpus out of join state.
|
|
|
|
* Extra prods are harmless.
|
|
|
|
*/
|
|
|
|
for_each_online_cpu(cpu)
|
|
|
|
plpar_hcall_norets(H_PROD, get_hard_smp_processor_id(cpu));
|
|
|
|
}
|
2006-01-14 00:39:24 +00:00
|
|
|
out:
|
2007-11-13 16:15:13 +00:00
|
|
|
if (atomic_dec_return(&data->working) == 0)
|
|
|
|
complete(data->complete);
|
2010-07-07 12:31:01 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int rtas_suspend_cpu(struct rtas_suspend_me_data *data)
|
|
|
|
{
|
|
|
|
return __rtas_suspend_cpu(data, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rtas_percpu_suspend_me(void *info)
|
|
|
|
{
|
|
|
|
__rtas_suspend_cpu((struct rtas_suspend_me_data *)info, 1);
|
2006-01-14 00:39:24 +00:00
|
|
|
}
|
|
|
|
|
2013-05-07 04:34:11 +00:00
|
|
|
enum rtas_cpu_state {
|
|
|
|
DOWN,
|
|
|
|
UP,
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
static int rtas_cpu_state_change_mask(enum rtas_cpu_state state,
|
|
|
|
cpumask_var_t cpus)
|
|
|
|
{
|
|
|
|
if (!cpumask_empty(cpus)) {
|
|
|
|
cpumask_clear(cpus);
|
|
|
|
return -EINVAL;
|
|
|
|
} else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/* On return cpumask will be altered to indicate CPUs changed.
|
|
|
|
* CPUs with states changed will be set in the mask,
|
|
|
|
* CPUs with status unchanged will be unset in the mask. */
|
|
|
|
static int rtas_cpu_state_change_mask(enum rtas_cpu_state state,
|
|
|
|
cpumask_var_t cpus)
|
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
int cpuret = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (cpumask_empty(cpus))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for_each_cpu(cpu, cpus) {
|
|
|
|
switch (state) {
|
|
|
|
case DOWN:
|
|
|
|
cpuret = cpu_down(cpu);
|
|
|
|
break;
|
|
|
|
case UP:
|
|
|
|
cpuret = cpu_up(cpu);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cpuret) {
|
|
|
|
pr_debug("%s: cpu_%s for cpu#%d returned %d.\n",
|
|
|
|
__func__,
|
|
|
|
((state == UP) ? "up" : "down"),
|
|
|
|
cpu, cpuret);
|
|
|
|
if (!ret)
|
|
|
|
ret = cpuret;
|
|
|
|
if (state == UP) {
|
|
|
|
/* clear bits for unchanged cpus, return */
|
|
|
|
cpumask_shift_right(cpus, cpus, cpu);
|
|
|
|
cpumask_shift_left(cpus, cpus, cpu);
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
/* clear bit for unchanged cpu, continue */
|
|
|
|
cpumask_clear_cpu(cpu, cpus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int rtas_online_cpus_mask(cpumask_var_t cpus)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = rtas_cpu_state_change_mask(UP, cpus);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
cpumask_var_t tmp_mask;
|
|
|
|
|
|
|
|
if (!alloc_cpumask_var(&tmp_mask, GFP_TEMPORARY))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Use tmp_mask to preserve cpus mask from first failure */
|
|
|
|
cpumask_copy(tmp_mask, cpus);
|
|
|
|
rtas_offline_cpus_mask(tmp_mask);
|
|
|
|
free_cpumask_var(tmp_mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rtas_online_cpus_mask);
|
|
|
|
|
|
|
|
int rtas_offline_cpus_mask(cpumask_var_t cpus)
|
|
|
|
{
|
|
|
|
return rtas_cpu_state_change_mask(DOWN, cpus);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rtas_offline_cpus_mask);
|
|
|
|
|
2010-09-10 09:41:35 +00:00
|
|
|
int rtas_ibm_suspend_me(struct rtas_args *args)
|
2006-01-14 00:39:24 +00:00
|
|
|
{
|
2006-06-13 00:49:20 +00:00
|
|
|
long state;
|
|
|
|
long rc;
|
2006-07-18 22:01:28 +00:00
|
|
|
unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
|
2006-01-14 00:39:24 +00:00
|
|
|
struct rtas_suspend_me_data data;
|
2007-11-13 16:15:13 +00:00
|
|
|
DECLARE_COMPLETION_ONSTACK(done);
|
2013-05-07 04:34:11 +00:00
|
|
|
cpumask_var_t offline_mask;
|
|
|
|
int cpuret;
|
2007-11-13 16:15:13 +00:00
|
|
|
|
|
|
|
if (!rtas_service_present("ibm,suspend-me"))
|
|
|
|
return -ENOSYS;
|
2006-01-14 00:39:24 +00:00
|
|
|
|
2006-06-13 00:49:20 +00:00
|
|
|
/* Make sure the state is valid */
|
2006-07-18 22:01:28 +00:00
|
|
|
rc = plpar_hcall(H_VASI_STATE, retbuf,
|
|
|
|
((u64)args->args[0] << 32) | args->args[1]);
|
|
|
|
|
|
|
|
state = retbuf[0];
|
2006-06-13 00:49:20 +00:00
|
|
|
|
|
|
|
if (rc) {
|
|
|
|
printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
|
|
|
|
return rc;
|
|
|
|
} else if (state == H_VASI_ENABLED) {
|
|
|
|
args->args[args->nargs] = RTAS_NOT_SUSPENDABLE;
|
|
|
|
return 0;
|
|
|
|
} else if (state != H_VASI_SUSPENDING) {
|
|
|
|
printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n",
|
|
|
|
state);
|
|
|
|
args->args[args->nargs] = -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-07 04:34:11 +00:00
|
|
|
if (!alloc_cpumask_var(&offline_mask, GFP_TEMPORARY))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-11-13 16:15:13 +00:00
|
|
|
atomic_set(&data.working, 0);
|
2009-02-17 06:49:50 +00:00
|
|
|
atomic_set(&data.done, 0);
|
2010-07-07 12:31:01 +00:00
|
|
|
atomic_set(&data.error, 0);
|
2007-11-13 16:15:13 +00:00
|
|
|
data.token = rtas_token("ibm,suspend-me");
|
|
|
|
data.complete = &done;
|
2013-05-07 04:34:11 +00:00
|
|
|
|
|
|
|
/* All present CPUs must be online */
|
|
|
|
cpumask_andnot(offline_mask, cpu_present_mask, cpu_online_mask);
|
|
|
|
cpuret = rtas_online_cpus_mask(offline_mask);
|
|
|
|
if (cpuret) {
|
|
|
|
pr_err("%s: Could not bring present CPUs online.\n", __func__);
|
|
|
|
atomic_set(&data.error, cpuret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-01-11 06:56:04 +00:00
|
|
|
stop_topology_update();
|
2006-01-14 00:39:24 +00:00
|
|
|
|
|
|
|
/* Call function on all CPUs. One of us will make the
|
|
|
|
* rtas call
|
|
|
|
*/
|
2008-05-09 07:39:44 +00:00
|
|
|
if (on_each_cpu(rtas_percpu_suspend_me, &data, 0))
|
2010-07-07 12:31:01 +00:00
|
|
|
atomic_set(&data.error, -EINVAL);
|
2006-01-14 00:39:24 +00:00
|
|
|
|
2007-11-13 16:15:13 +00:00
|
|
|
wait_for_completion(&done);
|
2006-01-14 00:39:24 +00:00
|
|
|
|
2010-07-07 12:31:01 +00:00
|
|
|
if (atomic_read(&data.error) != 0)
|
2007-11-13 16:15:13 +00:00
|
|
|
printk(KERN_ERR "Error doing global join\n");
|
2006-01-14 00:39:24 +00:00
|
|
|
|
2012-01-11 06:56:04 +00:00
|
|
|
start_topology_update();
|
|
|
|
|
2013-05-07 04:34:11 +00:00
|
|
|
/* Take down CPUs not online prior to suspend */
|
|
|
|
cpuret = rtas_offline_cpus_mask(offline_mask);
|
|
|
|
if (cpuret)
|
|
|
|
pr_warn("%s: Could not restore CPUs to offline state.\n",
|
|
|
|
__func__);
|
|
|
|
|
|
|
|
out:
|
|
|
|
free_cpumask_var(offline_mask);
|
2010-07-07 12:31:01 +00:00
|
|
|
return atomic_read(&data.error);
|
2006-01-14 00:39:24 +00:00
|
|
|
}
|
|
|
|
#else /* CONFIG_PPC_PSERIES */
|
2010-09-10 09:41:35 +00:00
|
|
|
int rtas_ibm_suspend_me(struct rtas_args *args)
|
2006-01-14 00:39:24 +00:00
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-21 15:47:07 +00:00
|
|
|
/**
|
|
|
|
* Find a specific pseries error log in an RTAS extended event log.
|
|
|
|
* @log: RTAS error/event log
|
|
|
|
* @section_id: two character section identifier
|
|
|
|
*
|
|
|
|
* Returns a pointer to the specified errorlog or NULL if not found.
|
|
|
|
*/
|
|
|
|
struct pseries_errorlog *get_pseries_errorlog(struct rtas_error_log *log,
|
|
|
|
uint16_t section_id)
|
|
|
|
{
|
|
|
|
struct rtas_ext_event_log_v6 *ext_log =
|
|
|
|
(struct rtas_ext_event_log_v6 *)log->buffer;
|
|
|
|
struct pseries_errorlog *sect;
|
|
|
|
unsigned char *p, *log_end;
|
|
|
|
|
|
|
|
/* Check that we understand the format */
|
|
|
|
if (log->extended_log_length < sizeof(struct rtas_ext_event_log_v6) ||
|
|
|
|
ext_log->log_format != RTAS_V6EXT_LOG_FORMAT_EVENT_LOG ||
|
|
|
|
ext_log->company_id != RTAS_V6EXT_COMPANY_ID_IBM)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
log_end = log->buffer + log->extended_log_length;
|
|
|
|
p = ext_log->vendor_log;
|
|
|
|
|
|
|
|
while (p < log_end) {
|
|
|
|
sect = (struct pseries_errorlog *)p;
|
|
|
|
if (sect->id == section_id)
|
|
|
|
return sect;
|
|
|
|
p += sect->length;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
|
|
|
|
{
|
|
|
|
struct rtas_args args;
|
|
|
|
unsigned long flags;
|
2005-10-26 07:05:24 +00:00
|
|
|
char *buff_copy, *errbuf = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
int nargs;
|
2006-01-14 00:39:24 +00:00
|
|
|
int rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
nargs = args.nargs;
|
|
|
|
if (nargs > ARRAY_SIZE(args.args)
|
|
|
|
|| args.nret > ARRAY_SIZE(args.args)
|
|
|
|
|| nargs + args.nret > ARRAY_SIZE(args.args))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Copy in args. */
|
|
|
|
if (copy_from_user(args.args, uargs->args,
|
|
|
|
nargs * sizeof(rtas_arg_t)) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
|
2006-01-14 00:39:24 +00:00
|
|
|
if (args.token == RTAS_UNKNOWN_SERVICE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-07-30 16:23:27 +00:00
|
|
|
args.rets = &args.args[nargs];
|
|
|
|
memset(args.rets, 0, args.nret * sizeof(rtas_arg_t));
|
|
|
|
|
2006-01-14 00:39:24 +00:00
|
|
|
/* Need to handle ibm,suspend_me call specially */
|
|
|
|
if (args.token == ibm_suspend_me_token) {
|
|
|
|
rc = rtas_ibm_suspend_me(&args);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
goto copy_return;
|
|
|
|
}
|
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
buff_copy = get_errorlog_buffer();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-16 16:42:49 +00:00
|
|
|
flags = lock_rtas();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
rtas.args = args;
|
|
|
|
enter_rtas(__pa(&rtas.args));
|
|
|
|
args = rtas.args;
|
|
|
|
|
|
|
|
/* A -1 return code indicates that the last command couldn't
|
|
|
|
be completed due to a hardware error. */
|
2005-10-26 07:05:24 +00:00
|
|
|
if (args.rets[0] == -1)
|
|
|
|
errbuf = __fetch_rtas_last_error(buff_copy);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-16 16:42:49 +00:00
|
|
|
unlock_rtas(flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (buff_copy) {
|
2005-10-26 07:05:24 +00:00
|
|
|
if (errbuf)
|
|
|
|
log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(buff_copy);
|
|
|
|
}
|
|
|
|
|
2006-01-14 00:39:24 +00:00
|
|
|
copy_return:
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Copy out args. */
|
|
|
|
if (copy_to_user(uargs->args + nargs,
|
|
|
|
args.args + nargs,
|
|
|
|
args.nret * sizeof(rtas_arg_t)) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-01-09 23:10:13 +00:00
|
|
|
* Call early during boot, before mem init or bootmem, to retrieve the RTAS
|
2005-04-16 22:20:36 +00:00
|
|
|
* informations from the device-tree and allocate the RMO buffer for userland
|
|
|
|
* accesses.
|
|
|
|
*/
|
|
|
|
void __init rtas_initialize(void)
|
|
|
|
{
|
2005-10-26 07:05:24 +00:00
|
|
|
unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Get RTAS dev node and fill up our "rtas" structure with infos
|
|
|
|
* about it.
|
|
|
|
*/
|
|
|
|
rtas.dev = of_find_node_by_name(NULL, "rtas");
|
|
|
|
if (rtas.dev) {
|
2006-07-12 05:35:54 +00:00
|
|
|
const u32 *basep, *entryp, *sizep;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-04-03 12:26:41 +00:00
|
|
|
basep = of_get_property(rtas.dev, "linux,rtas-base", NULL);
|
|
|
|
sizep = of_get_property(rtas.dev, "rtas-size", NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (basep != NULL && sizep != NULL) {
|
|
|
|
rtas.base = *basep;
|
|
|
|
rtas.size = *sizep;
|
2007-04-03 12:26:41 +00:00
|
|
|
entryp = of_get_property(rtas.dev,
|
2006-07-12 05:35:54 +00:00
|
|
|
"linux,rtas-entry", NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (entryp == NULL) /* Ugh */
|
|
|
|
rtas.entry = rtas.base;
|
|
|
|
else
|
|
|
|
rtas.entry = *entryp;
|
|
|
|
} else
|
|
|
|
rtas.dev = NULL;
|
|
|
|
}
|
2005-10-26 07:05:24 +00:00
|
|
|
if (!rtas.dev)
|
|
|
|
return;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* If RTAS was found, allocate the RMO buffer for it and look for
|
|
|
|
* the stop-self token if any
|
|
|
|
*/
|
2005-10-26 07:05:24 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
2006-03-28 12:15:54 +00:00
|
|
|
if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR)) {
|
2010-07-06 22:39:02 +00:00
|
|
|
rtas_region = min(ppc64_rma_size, RTAS_INSTANTIATE_MAX);
|
2006-01-14 00:39:24 +00:00
|
|
|
ibm_suspend_me_token = rtas_token("ibm,suspend-me");
|
|
|
|
}
|
2005-10-26 07:05:24 +00:00
|
|
|
#endif
|
2010-07-12 04:36:09 +00:00
|
|
|
rtas_rmo_buf = memblock_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-26 07:05:24 +00:00
|
|
|
#ifdef CONFIG_RTAS_ERROR_LOGGING
|
|
|
|
rtas_last_error_token = rtas_token("rtas-last-error");
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-06-23 08:20:13 +00:00
|
|
|
|
|
|
|
int __init early_init_dt_scan_rtas(unsigned long node,
|
|
|
|
const char *uname, int depth, void *data)
|
|
|
|
{
|
|
|
|
u32 *basep, *entryp, *sizep;
|
|
|
|
|
|
|
|
if (depth != 1 || strcmp(uname, "rtas") != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL);
|
|
|
|
entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL);
|
|
|
|
sizep = of_get_flat_dt_prop(node, "rtas-size", NULL);
|
|
|
|
|
|
|
|
if (basep && entryp && sizep) {
|
|
|
|
rtas.base = *basep;
|
|
|
|
rtas.entry = *entryp;
|
|
|
|
rtas.size = *sizep;
|
|
|
|
}
|
|
|
|
|
2006-06-23 08:20:16 +00:00
|
|
|
#ifdef CONFIG_UDBG_RTAS_CONSOLE
|
|
|
|
basep = of_get_flat_dt_prop(node, "put-term-char", NULL);
|
|
|
|
if (basep)
|
|
|
|
rtas_putchar_token = *basep;
|
|
|
|
|
|
|
|
basep = of_get_flat_dt_prop(node, "get-term-char", NULL);
|
|
|
|
if (basep)
|
|
|
|
rtas_getchar_token = *basep;
|
2006-08-17 04:12:14 +00:00
|
|
|
|
|
|
|
if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE &&
|
|
|
|
rtas_getchar_token != RTAS_UNKNOWN_SERVICE)
|
|
|
|
udbg_init_rtas_console();
|
|
|
|
|
2006-06-23 08:20:16 +00:00
|
|
|
#endif
|
|
|
|
|
2006-06-23 08:20:13 +00:00
|
|
|
/* break now */
|
|
|
|
return 1;
|
|
|
|
}
|
2009-06-16 16:42:50 +00:00
|
|
|
|
2009-12-02 18:49:50 +00:00
|
|
|
static arch_spinlock_t timebase_lock;
|
2009-06-16 16:42:50 +00:00
|
|
|
static u64 timebase = 0;
|
|
|
|
|
2013-06-24 19:30:09 +00:00
|
|
|
void rtas_give_timebase(void)
|
2009-06-16 16:42:50 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
hard_irq_disable();
|
2009-12-02 19:01:25 +00:00
|
|
|
arch_spin_lock(&timebase_lock);
|
2009-06-16 16:42:50 +00:00
|
|
|
rtas_call(rtas_token("freeze-time-base"), 0, 1, NULL);
|
|
|
|
timebase = get_tb();
|
2009-12-02 19:01:25 +00:00
|
|
|
arch_spin_unlock(&timebase_lock);
|
2009-06-16 16:42:50 +00:00
|
|
|
|
|
|
|
while (timebase)
|
|
|
|
barrier();
|
|
|
|
rtas_call(rtas_token("thaw-time-base"), 0, 1, NULL);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
2013-06-24 19:30:09 +00:00
|
|
|
void rtas_take_timebase(void)
|
2009-06-16 16:42:50 +00:00
|
|
|
{
|
|
|
|
while (!timebase)
|
|
|
|
barrier();
|
2009-12-02 19:01:25 +00:00
|
|
|
arch_spin_lock(&timebase_lock);
|
2009-06-16 16:42:50 +00:00
|
|
|
set_tb(timebase >> 32, timebase & 0xffffffff);
|
|
|
|
timebase = 0;
|
2009-12-02 19:01:25 +00:00
|
|
|
arch_spin_unlock(&timebase_lock);
|
2009-06-16 16:42:50 +00:00
|
|
|
}
|