2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 1995-1999 Gary Thomas, Paul Mackerras, Cort Dougan.
|
|
|
|
|
*/
|
2005-09-10 03:02:25 +07:00
|
|
|
#ifndef _ASM_POWERPC_PPC_ASM_H
|
|
|
|
|
#define _ASM_POWERPC_PPC_ASM_H
|
|
|
|
|
|
2009-04-28 01:02:24 +07:00
|
|
|
#include <linux/init.h>
|
2005-10-10 19:50:37 +07:00
|
|
|
#include <linux/stringify.h>
|
[PATCH] powerpc: Consolidate asm compatibility macros
This patch consolidates macros used to generate assembly for
compatibility across different CPUs or configs. A new header,
asm-powerpc/asm-compat.h contains the main compatibility macros. It
uses some preprocessor magic to make the macros suitable both for use
in .S files, and in inline asm in .c files. Headers (bitops.h,
uaccess.h, atomic.h, bug.h) which had their own such compatibility
macros are changed to use asm-compat.h.
ppc_asm.h is now for use in .S files *only*, and a #error enforces
that. As such, we're a lot more careless about namespace pollution
here than in asm-compat.h.
While we're at it, this patch adds a call to the PPC405_ERR77 macro in
futex.h which should have had it already, but didn't.
Built and booted on pSeries, Maple and iSeries (ARCH=powerpc). Built
for 32-bit powermac (ARCH=powerpc) and Walnut (ARCH=ppc).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-10 08:56:55 +07:00
|
|
|
#include <asm/asm-compat.h>
|
2008-06-26 14:07:48 +07:00
|
|
|
#include <asm/processor.h>
|
2009-02-11 03:10:44 +07:00
|
|
|
#include <asm/ppc-opcode.h>
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 02:56:43 +07:00
|
|
|
#include <asm/firmware.h>
|
2005-10-10 19:50:37 +07:00
|
|
|
|
[PATCH] powerpc: Consolidate asm compatibility macros
This patch consolidates macros used to generate assembly for
compatibility across different CPUs or configs. A new header,
asm-powerpc/asm-compat.h contains the main compatibility macros. It
uses some preprocessor magic to make the macros suitable both for use
in .S files, and in inline asm in .c files. Headers (bitops.h,
uaccess.h, atomic.h, bug.h) which had their own such compatibility
macros are changed to use asm-compat.h.
ppc_asm.h is now for use in .S files *only*, and a #error enforces
that. As such, we're a lot more careless about namespace pollution
here than in asm-compat.h.
While we're at it, this patch adds a call to the PPC405_ERR77 macro in
futex.h which should have had it already, but didn't.
Built and booted on pSeries, Maple and iSeries (ARCH=powerpc). Built
for 32-bit powermac (ARCH=powerpc) and Walnut (ARCH=ppc).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-10 08:56:55 +07:00
|
|
|
#ifndef __ASSEMBLY__
|
|
|
|
|
#error __FILE__ should only be used in assembler files
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
#define SZL (BITS_PER_LONG/8)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 06:06:59 +07:00
|
|
|
/*
|
|
|
|
|
* Stuff for accurate CPU time accounting.
|
|
|
|
|
* These macros handle transitions between user and system state
|
|
|
|
|
* in exception entry and exit and accumulate time to the
|
|
|
|
|
* user_time and system_time fields in the paca.
|
|
|
|
|
*/
|
|
|
|
|
|
2012-07-25 12:56:04 +07:00
|
|
|
#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 06:06:59 +07:00
|
|
|
#define ACCOUNT_CPU_USER_ENTRY(ra, rb)
|
|
|
|
|
#define ACCOUNT_CPU_USER_EXIT(ra, rb)
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 02:56:43 +07:00
|
|
|
#define ACCOUNT_STOLEN_TIME
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 06:06:59 +07:00
|
|
|
#else
|
|
|
|
|
#define ACCOUNT_CPU_USER_ENTRY(ra, rb) \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 02:56:43 +07:00
|
|
|
MFTB(ra); /* get timebase */ \
|
|
|
|
|
ld rb,PACA_STARTTIME_USER(r13); \
|
|
|
|
|
std ra,PACA_STARTTIME(r13); \
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 06:06:59 +07:00
|
|
|
subf rb,rb,ra; /* subtract start value */ \
|
|
|
|
|
ld ra,PACA_USER_TIME(r13); \
|
|
|
|
|
add ra,ra,rb; /* add on to user time */ \
|
|
|
|
|
std ra,PACA_USER_TIME(r13); \
|
|
|
|
|
|
|
|
|
|
#define ACCOUNT_CPU_USER_EXIT(ra, rb) \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 02:56:43 +07:00
|
|
|
MFTB(ra); /* get timebase */ \
|
|
|
|
|
ld rb,PACA_STARTTIME(r13); \
|
|
|
|
|
std ra,PACA_STARTTIME_USER(r13); \
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 06:06:59 +07:00
|
|
|
subf rb,rb,ra; /* subtract start value */ \
|
|
|
|
|
ld ra,PACA_SYSTEM_TIME(r13); \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 02:56:43 +07:00
|
|
|
add ra,ra,rb; /* add on to system time */ \
|
|
|
|
|
std ra,PACA_SYSTEM_TIME(r13)
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_SPLPAR
|
|
|
|
|
#define ACCOUNT_STOLEN_TIME \
|
|
|
|
|
BEGIN_FW_FTR_SECTION; \
|
|
|
|
|
beq 33f; \
|
|
|
|
|
/* from user - see if there are any DTL entries to process */ \
|
|
|
|
|
ld r10,PACALPPACAPTR(r13); /* get ptr to VPA */ \
|
|
|
|
|
ld r11,PACA_DTL_RIDX(r13); /* get log read index */ \
|
2013-08-06 23:01:46 +07:00
|
|
|
addi r10,r10,LPPACA_DTLIDX; \
|
|
|
|
|
LDX_BE r10,0,r10; /* get log write index */ \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 02:56:43 +07:00
|
|
|
cmpd cr1,r11,r10; \
|
|
|
|
|
beq+ cr1,33f; \
|
|
|
|
|
bl .accumulate_stolen_time; \
|
2012-03-02 07:01:31 +07:00
|
|
|
ld r12,_MSR(r1); \
|
|
|
|
|
andi. r10,r12,MSR_PR; /* Restore cr0 (coming from user) */ \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 02:56:43 +07:00
|
|
|
33: \
|
|
|
|
|
END_FW_FTR_SECTION_IFSET(FW_FEATURE_SPLPAR)
|
|
|
|
|
|
|
|
|
|
#else /* CONFIG_PPC_SPLPAR */
|
|
|
|
|
#define ACCOUNT_STOLEN_TIME
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_PPC_SPLPAR */
|
|
|
|
|
|
2012-07-25 12:56:04 +07:00
|
|
|
#endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 06:06:59 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
|
* Macros for storing registers into and loading registers from
|
|
|
|
|
* exception frames.
|
|
|
|
|
*/
|
2005-09-10 03:02:25 +07:00
|
|
|
#ifdef __powerpc64__
|
|
|
|
|
#define SAVE_GPR(n, base) std n,GPR0+8*(n)(base)
|
|
|
|
|
#define REST_GPR(n, base) ld n,GPR0+8*(n)(base)
|
|
|
|
|
#define SAVE_NVGPRS(base) SAVE_8GPRS(14, base); SAVE_10GPRS(22, base)
|
|
|
|
|
#define REST_NVGPRS(base) REST_8GPRS(14, base); REST_10GPRS(22, base)
|
|
|
|
|
#else
|
2005-04-17 05:20:36 +07:00
|
|
|
#define SAVE_GPR(n, base) stw n,GPR0+4*(n)(base)
|
2005-09-10 03:02:25 +07:00
|
|
|
#define REST_GPR(n, base) lwz n,GPR0+4*(n)(base)
|
|
|
|
|
#define SAVE_NVGPRS(base) SAVE_GPR(13, base); SAVE_8GPRS(14, base); \
|
|
|
|
|
SAVE_10GPRS(22, base)
|
|
|
|
|
#define REST_NVGPRS(base) REST_GPR(13, base); REST_8GPRS(14, base); \
|
|
|
|
|
REST_10GPRS(22, base)
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define SAVE_2GPRS(n, base) SAVE_GPR(n, base); SAVE_GPR(n+1, base)
|
|
|
|
|
#define SAVE_4GPRS(n, base) SAVE_2GPRS(n, base); SAVE_2GPRS(n+2, base)
|
|
|
|
|
#define SAVE_8GPRS(n, base) SAVE_4GPRS(n, base); SAVE_4GPRS(n+4, base)
|
|
|
|
|
#define SAVE_10GPRS(n, base) SAVE_8GPRS(n, base); SAVE_2GPRS(n+8, base)
|
|
|
|
|
#define REST_2GPRS(n, base) REST_GPR(n, base); REST_GPR(n+1, base)
|
|
|
|
|
#define REST_4GPRS(n, base) REST_2GPRS(n, base); REST_2GPRS(n+2, base)
|
|
|
|
|
#define REST_8GPRS(n, base) REST_4GPRS(n, base); REST_4GPRS(n+4, base)
|
|
|
|
|
#define REST_10GPRS(n, base) REST_8GPRS(n, base); REST_2GPRS(n+8, base)
|
|
|
|
|
|
2008-06-26 14:07:48 +07:00
|
|
|
#define SAVE_FPR(n, base) stfd n,THREAD_FPR0+8*TS_FPRWIDTH*(n)(base)
|
2005-04-17 05:20:36 +07:00
|
|
|
#define SAVE_2FPRS(n, base) SAVE_FPR(n, base); SAVE_FPR(n+1, base)
|
|
|
|
|
#define SAVE_4FPRS(n, base) SAVE_2FPRS(n, base); SAVE_2FPRS(n+2, base)
|
|
|
|
|
#define SAVE_8FPRS(n, base) SAVE_4FPRS(n, base); SAVE_4FPRS(n+4, base)
|
|
|
|
|
#define SAVE_16FPRS(n, base) SAVE_8FPRS(n, base); SAVE_8FPRS(n+8, base)
|
|
|
|
|
#define SAVE_32FPRS(n, base) SAVE_16FPRS(n, base); SAVE_16FPRS(n+16, base)
|
2008-06-26 14:07:48 +07:00
|
|
|
#define REST_FPR(n, base) lfd n,THREAD_FPR0+8*TS_FPRWIDTH*(n)(base)
|
2005-04-17 05:20:36 +07:00
|
|
|
#define REST_2FPRS(n, base) REST_FPR(n, base); REST_FPR(n+1, base)
|
|
|
|
|
#define REST_4FPRS(n, base) REST_2FPRS(n, base); REST_2FPRS(n+2, base)
|
|
|
|
|
#define REST_8FPRS(n, base) REST_4FPRS(n, base); REST_4FPRS(n+4, base)
|
|
|
|
|
#define REST_16FPRS(n, base) REST_8FPRS(n, base); REST_8FPRS(n+8, base)
|
|
|
|
|
#define REST_32FPRS(n, base) REST_16FPRS(n, base); REST_16FPRS(n+16, base)
|
|
|
|
|
|
2009-08-20 20:21:45 +07:00
|
|
|
#define SAVE_VR(n,b,base) li b,THREAD_VR0+(16*(n)); stvx n,base,b
|
2005-09-10 03:02:25 +07:00
|
|
|
#define SAVE_2VRS(n,b,base) SAVE_VR(n,b,base); SAVE_VR(n+1,b,base)
|
|
|
|
|
#define SAVE_4VRS(n,b,base) SAVE_2VRS(n,b,base); SAVE_2VRS(n+2,b,base)
|
|
|
|
|
#define SAVE_8VRS(n,b,base) SAVE_4VRS(n,b,base); SAVE_4VRS(n+4,b,base)
|
|
|
|
|
#define SAVE_16VRS(n,b,base) SAVE_8VRS(n,b,base); SAVE_8VRS(n+8,b,base)
|
|
|
|
|
#define SAVE_32VRS(n,b,base) SAVE_16VRS(n,b,base); SAVE_16VRS(n+16,b,base)
|
2009-08-20 20:21:45 +07:00
|
|
|
#define REST_VR(n,b,base) li b,THREAD_VR0+(16*(n)); lvx n,base,b
|
2005-09-10 03:02:25 +07:00
|
|
|
#define REST_2VRS(n,b,base) REST_VR(n,b,base); REST_VR(n+1,b,base)
|
|
|
|
|
#define REST_4VRS(n,b,base) REST_2VRS(n,b,base); REST_2VRS(n+2,b,base)
|
|
|
|
|
#define REST_8VRS(n,b,base) REST_4VRS(n,b,base); REST_4VRS(n+4,b,base)
|
|
|
|
|
#define REST_16VRS(n,b,base) REST_8VRS(n,b,base); REST_8VRS(n+8,b,base)
|
|
|
|
|
#define REST_32VRS(n,b,base) REST_16VRS(n,b,base); REST_16VRS(n+16,b,base)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-02-13 23:21:32 +07:00
|
|
|
/* Save/restore FPRs, VRs and VSRs from their checkpointed backups in
|
|
|
|
|
* thread_struct:
|
|
|
|
|
*/
|
|
|
|
|
#define SAVE_FPR_TRANSACT(n, base) stfd n,THREAD_TRANSACT_FPR0+ \
|
|
|
|
|
8*TS_FPRWIDTH*(n)(base)
|
|
|
|
|
#define SAVE_2FPRS_TRANSACT(n, base) SAVE_FPR_TRANSACT(n, base); \
|
|
|
|
|
SAVE_FPR_TRANSACT(n+1, base)
|
|
|
|
|
#define SAVE_4FPRS_TRANSACT(n, base) SAVE_2FPRS_TRANSACT(n, base); \
|
|
|
|
|
SAVE_2FPRS_TRANSACT(n+2, base)
|
|
|
|
|
#define SAVE_8FPRS_TRANSACT(n, base) SAVE_4FPRS_TRANSACT(n, base); \
|
|
|
|
|
SAVE_4FPRS_TRANSACT(n+4, base)
|
|
|
|
|
#define SAVE_16FPRS_TRANSACT(n, base) SAVE_8FPRS_TRANSACT(n, base); \
|
|
|
|
|
SAVE_8FPRS_TRANSACT(n+8, base)
|
|
|
|
|
#define SAVE_32FPRS_TRANSACT(n, base) SAVE_16FPRS_TRANSACT(n, base); \
|
|
|
|
|
SAVE_16FPRS_TRANSACT(n+16, base)
|
|
|
|
|
|
|
|
|
|
#define REST_FPR_TRANSACT(n, base) lfd n,THREAD_TRANSACT_FPR0+ \
|
|
|
|
|
8*TS_FPRWIDTH*(n)(base)
|
|
|
|
|
#define REST_2FPRS_TRANSACT(n, base) REST_FPR_TRANSACT(n, base); \
|
|
|
|
|
REST_FPR_TRANSACT(n+1, base)
|
|
|
|
|
#define REST_4FPRS_TRANSACT(n, base) REST_2FPRS_TRANSACT(n, base); \
|
|
|
|
|
REST_2FPRS_TRANSACT(n+2, base)
|
|
|
|
|
#define REST_8FPRS_TRANSACT(n, base) REST_4FPRS_TRANSACT(n, base); \
|
|
|
|
|
REST_4FPRS_TRANSACT(n+4, base)
|
|
|
|
|
#define REST_16FPRS_TRANSACT(n, base) REST_8FPRS_TRANSACT(n, base); \
|
|
|
|
|
REST_8FPRS_TRANSACT(n+8, base)
|
|
|
|
|
#define REST_32FPRS_TRANSACT(n, base) REST_16FPRS_TRANSACT(n, base); \
|
|
|
|
|
REST_16FPRS_TRANSACT(n+16, base)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define SAVE_VR_TRANSACT(n,b,base) li b,THREAD_TRANSACT_VR0+(16*(n)); \
|
|
|
|
|
stvx n,b,base
|
|
|
|
|
#define SAVE_2VRS_TRANSACT(n,b,base) SAVE_VR_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_VR_TRANSACT(n+1,b,base)
|
|
|
|
|
#define SAVE_4VRS_TRANSACT(n,b,base) SAVE_2VRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_2VRS_TRANSACT(n+2,b,base)
|
|
|
|
|
#define SAVE_8VRS_TRANSACT(n,b,base) SAVE_4VRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_4VRS_TRANSACT(n+4,b,base)
|
|
|
|
|
#define SAVE_16VRS_TRANSACT(n,b,base) SAVE_8VRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_8VRS_TRANSACT(n+8,b,base)
|
|
|
|
|
#define SAVE_32VRS_TRANSACT(n,b,base) SAVE_16VRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_16VRS_TRANSACT(n+16,b,base)
|
|
|
|
|
|
|
|
|
|
#define REST_VR_TRANSACT(n,b,base) li b,THREAD_TRANSACT_VR0+(16*(n)); \
|
|
|
|
|
lvx n,b,base
|
|
|
|
|
#define REST_2VRS_TRANSACT(n,b,base) REST_VR_TRANSACT(n,b,base); \
|
|
|
|
|
REST_VR_TRANSACT(n+1,b,base)
|
|
|
|
|
#define REST_4VRS_TRANSACT(n,b,base) REST_2VRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_2VRS_TRANSACT(n+2,b,base)
|
|
|
|
|
#define REST_8VRS_TRANSACT(n,b,base) REST_4VRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_4VRS_TRANSACT(n+4,b,base)
|
|
|
|
|
#define REST_16VRS_TRANSACT(n,b,base) REST_8VRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_8VRS_TRANSACT(n+8,b,base)
|
|
|
|
|
#define REST_32VRS_TRANSACT(n,b,base) REST_16VRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_16VRS_TRANSACT(n+16,b,base)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define SAVE_VSR_TRANSACT(n,b,base) li b,THREAD_TRANSACT_VSR0+(16*(n)); \
|
|
|
|
|
STXVD2X(n,R##base,R##b)
|
|
|
|
|
#define SAVE_2VSRS_TRANSACT(n,b,base) SAVE_VSR_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_VSR_TRANSACT(n+1,b,base)
|
|
|
|
|
#define SAVE_4VSRS_TRANSACT(n,b,base) SAVE_2VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_2VSRS_TRANSACT(n+2,b,base)
|
|
|
|
|
#define SAVE_8VSRS_TRANSACT(n,b,base) SAVE_4VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_4VSRS_TRANSACT(n+4,b,base)
|
|
|
|
|
#define SAVE_16VSRS_TRANSACT(n,b,base) SAVE_8VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_8VSRS_TRANSACT(n+8,b,base)
|
|
|
|
|
#define SAVE_32VSRS_TRANSACT(n,b,base) SAVE_16VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
SAVE_16VSRS_TRANSACT(n+16,b,base)
|
|
|
|
|
|
|
|
|
|
#define REST_VSR_TRANSACT(n,b,base) li b,THREAD_TRANSACT_VSR0+(16*(n)); \
|
|
|
|
|
LXVD2X(n,R##base,R##b)
|
|
|
|
|
#define REST_2VSRS_TRANSACT(n,b,base) REST_VSR_TRANSACT(n,b,base); \
|
|
|
|
|
REST_VSR_TRANSACT(n+1,b,base)
|
|
|
|
|
#define REST_4VSRS_TRANSACT(n,b,base) REST_2VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_2VSRS_TRANSACT(n+2,b,base)
|
|
|
|
|
#define REST_8VSRS_TRANSACT(n,b,base) REST_4VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_4VSRS_TRANSACT(n+4,b,base)
|
|
|
|
|
#define REST_16VSRS_TRANSACT(n,b,base) REST_8VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_8VSRS_TRANSACT(n+8,b,base)
|
|
|
|
|
#define REST_32VSRS_TRANSACT(n,b,base) REST_16VSRS_TRANSACT(n,b,base); \
|
|
|
|
|
REST_16VSRS_TRANSACT(n+16,b,base)
|
|
|
|
|
|
2008-06-25 11:07:18 +07:00
|
|
|
/* Save the lower 32 VSRs in the thread VSR region */
|
2012-06-25 20:33:23 +07:00
|
|
|
#define SAVE_VSR(n,b,base) li b,THREAD_VSR0+(16*(n)); STXVD2X(n,R##base,R##b)
|
2008-06-25 11:07:18 +07:00
|
|
|
#define SAVE_2VSRS(n,b,base) SAVE_VSR(n,b,base); SAVE_VSR(n+1,b,base)
|
|
|
|
|
#define SAVE_4VSRS(n,b,base) SAVE_2VSRS(n,b,base); SAVE_2VSRS(n+2,b,base)
|
|
|
|
|
#define SAVE_8VSRS(n,b,base) SAVE_4VSRS(n,b,base); SAVE_4VSRS(n+4,b,base)
|
|
|
|
|
#define SAVE_16VSRS(n,b,base) SAVE_8VSRS(n,b,base); SAVE_8VSRS(n+8,b,base)
|
|
|
|
|
#define SAVE_32VSRS(n,b,base) SAVE_16VSRS(n,b,base); SAVE_16VSRS(n+16,b,base)
|
2012-06-25 20:33:23 +07:00
|
|
|
#define REST_VSR(n,b,base) li b,THREAD_VSR0+(16*(n)); LXVD2X(n,R##base,R##b)
|
2008-06-25 11:07:18 +07:00
|
|
|
#define REST_2VSRS(n,b,base) REST_VSR(n,b,base); REST_VSR(n+1,b,base)
|
|
|
|
|
#define REST_4VSRS(n,b,base) REST_2VSRS(n,b,base); REST_2VSRS(n+2,b,base)
|
|
|
|
|
#define REST_8VSRS(n,b,base) REST_4VSRS(n,b,base); REST_4VSRS(n+4,b,base)
|
|
|
|
|
#define REST_16VSRS(n,b,base) REST_8VSRS(n,b,base); REST_8VSRS(n+8,b,base)
|
|
|
|
|
#define REST_32VSRS(n,b,base) REST_16VSRS(n,b,base); REST_16VSRS(n+16,b,base)
|
|
|
|
|
|
2011-06-15 06:34:27 +07:00
|
|
|
/*
|
|
|
|
|
* b = base register for addressing, o = base offset from register of 1st EVR
|
|
|
|
|
* n = first EVR, s = scratch
|
|
|
|
|
*/
|
|
|
|
|
#define SAVE_EVR(n,s,b,o) evmergehi s,s,n; stw s,o+4*(n)(b)
|
|
|
|
|
#define SAVE_2EVRS(n,s,b,o) SAVE_EVR(n,s,b,o); SAVE_EVR(n+1,s,b,o)
|
|
|
|
|
#define SAVE_4EVRS(n,s,b,o) SAVE_2EVRS(n,s,b,o); SAVE_2EVRS(n+2,s,b,o)
|
|
|
|
|
#define SAVE_8EVRS(n,s,b,o) SAVE_4EVRS(n,s,b,o); SAVE_4EVRS(n+4,s,b,o)
|
|
|
|
|
#define SAVE_16EVRS(n,s,b,o) SAVE_8EVRS(n,s,b,o); SAVE_8EVRS(n+8,s,b,o)
|
|
|
|
|
#define SAVE_32EVRS(n,s,b,o) SAVE_16EVRS(n,s,b,o); SAVE_16EVRS(n+16,s,b,o)
|
|
|
|
|
#define REST_EVR(n,s,b,o) lwz s,o+4*(n)(b); evmergelo n,s,n
|
|
|
|
|
#define REST_2EVRS(n,s,b,o) REST_EVR(n,s,b,o); REST_EVR(n+1,s,b,o)
|
|
|
|
|
#define REST_4EVRS(n,s,b,o) REST_2EVRS(n,s,b,o); REST_2EVRS(n+2,s,b,o)
|
|
|
|
|
#define REST_8EVRS(n,s,b,o) REST_4EVRS(n,s,b,o); REST_4EVRS(n+4,s,b,o)
|
|
|
|
|
#define REST_16EVRS(n,s,b,o) REST_8EVRS(n,s,b,o); REST_8EVRS(n+8,s,b,o)
|
|
|
|
|
#define REST_32EVRS(n,s,b,o) REST_16EVRS(n,s,b,o); REST_16EVRS(n+16,s,b,o)
|
2005-09-10 03:02:25 +07:00
|
|
|
|
2005-10-24 12:07:27 +07:00
|
|
|
/* Macros to adjust thread priority for hardware multithreading */
|
|
|
|
|
#define HMT_VERY_LOW or 31,31,31 # very low priority
|
|
|
|
|
#define HMT_LOW or 1,1,1
|
|
|
|
|
#define HMT_MEDIUM_LOW or 6,6,6 # medium low priority
|
|
|
|
|
#define HMT_MEDIUM or 2,2,2
|
|
|
|
|
#define HMT_MEDIUM_HIGH or 5,5,5 # medium high priority
|
|
|
|
|
#define HMT_HIGH or 3,3,3
|
2011-01-12 13:41:28 +07:00
|
|
|
#define HMT_EXTRA_HIGH or 7,7,7 # power7 only
|
2005-09-10 03:02:25 +07:00
|
|
|
|
2012-06-25 20:33:15 +07:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
|
#define ULONG_SIZE 8
|
|
|
|
|
#else
|
|
|
|
|
#define ULONG_SIZE 4
|
|
|
|
|
#endif
|
2012-06-25 20:33:23 +07:00
|
|
|
#define __VCPU_GPR(n) (VCPU_GPRS + (n * ULONG_SIZE))
|
|
|
|
|
#define VCPU_GPR(n) __VCPU_GPR(__REG_##n)
|
2012-06-25 20:33:15 +07:00
|
|
|
|
2005-12-17 04:43:46 +07:00
|
|
|
#ifdef __KERNEL__
|
2005-10-10 19:50:37 +07:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
|
|
2012-06-25 20:33:14 +07:00
|
|
|
#define STACKFRAMESIZE 256
|
2012-06-25 20:33:23 +07:00
|
|
|
#define __STK_REG(i) (112 + ((i)-14)*8)
|
|
|
|
|
#define STK_REG(i) __STK_REG(__REG_##i)
|
2012-06-25 20:33:14 +07:00
|
|
|
|
2012-06-25 20:33:23 +07:00
|
|
|
#define __STK_PARAM(i) (48 + ((i)-3)*8)
|
|
|
|
|
#define STK_PARAM(i) __STK_PARAM(__REG_##i)
|
2012-06-25 20:33:14 +07:00
|
|
|
|
2005-10-10 19:50:37 +07:00
|
|
|
#define XGLUE(a,b) a##b
|
|
|
|
|
#define GLUE(a,b) XGLUE(a,b)
|
|
|
|
|
|
|
|
|
|
#define _GLOBAL(name) \
|
|
|
|
|
.section ".text"; \
|
|
|
|
|
.align 2 ; \
|
|
|
|
|
.globl name; \
|
|
|
|
|
.globl GLUE(.,name); \
|
|
|
|
|
.section ".opd","aw"; \
|
|
|
|
|
name: \
|
|
|
|
|
.quad GLUE(.,name); \
|
|
|
|
|
.quad .TOC.@tocbase; \
|
|
|
|
|
.quad 0; \
|
|
|
|
|
.previous; \
|
|
|
|
|
.type GLUE(.,name),@function; \
|
|
|
|
|
GLUE(.,name):
|
|
|
|
|
|
2007-08-22 10:44:58 +07:00
|
|
|
#define _INIT_GLOBAL(name) \
|
2009-04-28 01:02:24 +07:00
|
|
|
__REF; \
|
2007-08-22 10:44:58 +07:00
|
|
|
.align 2 ; \
|
|
|
|
|
.globl name; \
|
|
|
|
|
.globl GLUE(.,name); \
|
|
|
|
|
.section ".opd","aw"; \
|
|
|
|
|
name: \
|
|
|
|
|
.quad GLUE(.,name); \
|
|
|
|
|
.quad .TOC.@tocbase; \
|
|
|
|
|
.quad 0; \
|
|
|
|
|
.previous; \
|
|
|
|
|
.type GLUE(.,name),@function; \
|
|
|
|
|
GLUE(.,name):
|
|
|
|
|
|
2005-10-10 19:50:37 +07:00
|
|
|
#define _KPROBE(name) \
|
|
|
|
|
.section ".kprobes.text","a"; \
|
|
|
|
|
.align 2 ; \
|
|
|
|
|
.globl name; \
|
|
|
|
|
.globl GLUE(.,name); \
|
|
|
|
|
.section ".opd","aw"; \
|
|
|
|
|
name: \
|
|
|
|
|
.quad GLUE(.,name); \
|
|
|
|
|
.quad .TOC.@tocbase; \
|
|
|
|
|
.quad 0; \
|
|
|
|
|
.previous; \
|
|
|
|
|
.type GLUE(.,name),@function; \
|
|
|
|
|
GLUE(.,name):
|
|
|
|
|
|
|
|
|
|
#define _STATIC(name) \
|
|
|
|
|
.section ".text"; \
|
|
|
|
|
.align 2 ; \
|
|
|
|
|
.section ".opd","aw"; \
|
|
|
|
|
name: \
|
|
|
|
|
.quad GLUE(.,name); \
|
|
|
|
|
.quad .TOC.@tocbase; \
|
|
|
|
|
.quad 0; \
|
|
|
|
|
.previous; \
|
|
|
|
|
.type GLUE(.,name),@function; \
|
2007-07-25 06:27:35 +07:00
|
|
|
GLUE(.,name):
|
|
|
|
|
|
|
|
|
|
#define _INIT_STATIC(name) \
|
2009-04-28 01:02:24 +07:00
|
|
|
__REF; \
|
2007-07-25 06:27:35 +07:00
|
|
|
.align 2 ; \
|
|
|
|
|
.section ".opd","aw"; \
|
|
|
|
|
name: \
|
|
|
|
|
.quad GLUE(.,name); \
|
|
|
|
|
.quad .TOC.@tocbase; \
|
|
|
|
|
.quad 0; \
|
|
|
|
|
.previous; \
|
|
|
|
|
.type GLUE(.,name),@function; \
|
2005-10-10 19:50:37 +07:00
|
|
|
GLUE(.,name):
|
|
|
|
|
|
|
|
|
|
#else /* 32-bit */
|
|
|
|
|
|
2007-09-14 03:42:35 +07:00
|
|
|
#define _ENTRY(n) \
|
|
|
|
|
.globl n; \
|
|
|
|
|
n:
|
|
|
|
|
|
2005-10-10 19:50:37 +07:00
|
|
|
#define _GLOBAL(n) \
|
|
|
|
|
.text; \
|
|
|
|
|
.stabs __stringify(n:F-1),N_FUN,0,0,n;\
|
|
|
|
|
.globl n; \
|
|
|
|
|
n:
|
|
|
|
|
|
|
|
|
|
#define _KPROBE(n) \
|
|
|
|
|
.section ".kprobes.text","a"; \
|
|
|
|
|
.globl n; \
|
|
|
|
|
n:
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
/*
|
2006-01-13 10:56:25 +07:00
|
|
|
* LOAD_REG_IMMEDIATE(rn, expr)
|
|
|
|
|
* Loads the value of the constant expression 'expr' into register 'rn'
|
|
|
|
|
* using immediate instructions only. Use this when it's important not
|
|
|
|
|
* to reference other data (i.e. on ppc64 when the TOC pointer is not
|
2008-08-30 08:41:12 +07:00
|
|
|
* valid) and when 'expr' is a constant or absolute address.
|
2005-09-10 03:02:25 +07:00
|
|
|
*
|
2006-01-13 10:56:25 +07:00
|
|
|
* LOAD_REG_ADDR(rn, name)
|
|
|
|
|
* Loads the address of label 'name' into register 'rn'. Use this when
|
|
|
|
|
* you don't particularly need immediate instructions only, but you need
|
|
|
|
|
* the whole address in one register (e.g. it's a structure address and
|
|
|
|
|
* you want to access various offsets within it). On ppc32 this is
|
|
|
|
|
* identical to LOAD_REG_IMMEDIATE.
|
|
|
|
|
*
|
|
|
|
|
* LOAD_REG_ADDRBASE(rn, name)
|
|
|
|
|
* ADDROFF(name)
|
|
|
|
|
* LOAD_REG_ADDRBASE loads part of the address of label 'name' into
|
|
|
|
|
* register 'rn'. ADDROFF(name) returns the remainder of the address as
|
|
|
|
|
* a constant expression. ADDROFF(name) is a signed expression < 16 bits
|
|
|
|
|
* in size, so is suitable for use directly as an offset in load and store
|
|
|
|
|
* instructions. Use this when loading/storing a single word or less as:
|
|
|
|
|
* LOAD_REG_ADDRBASE(rX, name)
|
|
|
|
|
* ld rY,ADDROFF(name)(rX)
|
2005-09-10 03:02:25 +07:00
|
|
|
*/
|
|
|
|
|
#ifdef __powerpc64__
|
2006-01-13 10:56:25 +07:00
|
|
|
#define LOAD_REG_IMMEDIATE(reg,expr) \
|
2012-06-25 20:33:09 +07:00
|
|
|
lis reg,(expr)@highest; \
|
|
|
|
|
ori reg,reg,(expr)@higher; \
|
|
|
|
|
rldicr reg,reg,32,31; \
|
|
|
|
|
oris reg,reg,(expr)@h; \
|
|
|
|
|
ori reg,reg,(expr)@l;
|
2006-01-13 10:56:25 +07:00
|
|
|
|
|
|
|
|
#define LOAD_REG_ADDR(reg,name) \
|
2012-06-25 20:33:09 +07:00
|
|
|
ld reg,name@got(r2)
|
2006-01-13 10:56:25 +07:00
|
|
|
|
|
|
|
|
#define LOAD_REG_ADDRBASE(reg,name) LOAD_REG_ADDR(reg,name)
|
|
|
|
|
#define ADDROFF(name) 0
|
2005-10-06 07:59:19 +07:00
|
|
|
|
2005-10-28 19:53:37 +07:00
|
|
|
/* offsets for stack frame layout */
|
|
|
|
|
#define LRSAVE 16
|
2005-10-06 07:59:19 +07:00
|
|
|
|
|
|
|
|
#else /* 32-bit */
|
2005-10-12 14:44:55 +07:00
|
|
|
|
2006-01-13 10:56:25 +07:00
|
|
|
#define LOAD_REG_IMMEDIATE(reg,expr) \
|
2012-06-25 20:33:09 +07:00
|
|
|
lis reg,(expr)@ha; \
|
|
|
|
|
addi reg,reg,(expr)@l;
|
2006-01-13 10:56:25 +07:00
|
|
|
|
|
|
|
|
#define LOAD_REG_ADDR(reg,name) LOAD_REG_IMMEDIATE(reg, name)
|
2005-10-06 07:59:19 +07:00
|
|
|
|
2012-06-25 20:33:09 +07:00
|
|
|
#define LOAD_REG_ADDRBASE(reg, name) lis reg,name@ha
|
2006-01-13 10:56:25 +07:00
|
|
|
#define ADDROFF(name) name@l
|
2005-10-06 07:59:19 +07:00
|
|
|
|
2005-10-28 19:53:37 +07:00
|
|
|
/* offsets for stack frame layout */
|
|
|
|
|
#define LRSAVE 4
|
2005-10-06 07:59:19 +07:00
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
/* various errata or part fixups */
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_PPC601_SYNC_FIX
|
|
|
|
|
#define SYNC \
|
|
|
|
|
BEGIN_FTR_SECTION \
|
|
|
|
|
sync; \
|
|
|
|
|
isync; \
|
|
|
|
|
END_FTR_SECTION_IFSET(CPU_FTR_601)
|
|
|
|
|
#define SYNC_601 \
|
|
|
|
|
BEGIN_FTR_SECTION \
|
|
|
|
|
sync; \
|
|
|
|
|
END_FTR_SECTION_IFSET(CPU_FTR_601)
|
|
|
|
|
#define ISYNC_601 \
|
|
|
|
|
BEGIN_FTR_SECTION \
|
|
|
|
|
isync; \
|
|
|
|
|
END_FTR_SECTION_IFSET(CPU_FTR_601)
|
|
|
|
|
#else
|
|
|
|
|
#define SYNC
|
|
|
|
|
#define SYNC_601
|
|
|
|
|
#define ISYNC_601
|
|
|
|
|
#endif
|
|
|
|
|
|
2013-07-24 08:21:11 +07:00
|
|
|
#if defined(CONFIG_PPC_CELL) || defined(CONFIG_PPC_FSL_BOOK3E)
|
2006-10-20 11:37:05 +07:00
|
|
|
#define MFTB(dest) \
|
2013-08-21 07:33:12 +07:00
|
|
|
90: mfspr dest, SPRN_TBRL; \
|
2006-10-20 11:37:05 +07:00
|
|
|
BEGIN_FTR_SECTION_NESTED(96); \
|
|
|
|
|
cmpwi dest,0; \
|
|
|
|
|
beq- 90b; \
|
|
|
|
|
END_FTR_SECTION_NESTED(CPU_FTR_CELL_TB_BUG, CPU_FTR_CELL_TB_BUG, 96)
|
|
|
|
|
#else
|
2013-08-21 07:33:12 +07:00
|
|
|
#define MFTB(dest) mfspr dest, SPRN_TBRL
|
2006-10-20 11:37:05 +07:00
|
|
|
#endif
|
2005-09-10 03:02:25 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
|
#define TLBSYNC
|
|
|
|
|
#else /* CONFIG_SMP */
|
|
|
|
|
/* tlbsync is not implemented on 601 */
|
|
|
|
|
#define TLBSYNC \
|
|
|
|
|
BEGIN_FTR_SECTION \
|
|
|
|
|
tlbsync; \
|
|
|
|
|
sync; \
|
|
|
|
|
END_FTR_SECTION_IFCLR(CPU_FTR_601)
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-04-18 09:21:52 +07:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
|
#define MTOCRF(FXM, RS) \
|
|
|
|
|
BEGIN_FTR_SECTION_NESTED(848); \
|
2012-06-25 20:33:16 +07:00
|
|
|
mtcrf (FXM), RS; \
|
2012-04-18 09:21:52 +07:00
|
|
|
FTR_SECTION_ELSE_NESTED(848); \
|
2012-06-25 20:33:16 +07:00
|
|
|
mtocrf (FXM), RS; \
|
2012-04-18 09:21:52 +07:00
|
|
|
ALT_FTR_SECTION_END_NESTED_IFCLR(CPU_FTR_NOEXECUTE, 848)
|
2012-12-07 04:50:32 +07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* PPR restore macros used in entry_64.S
|
|
|
|
|
* Used for P7 or later processors
|
|
|
|
|
*/
|
|
|
|
|
#define HMT_MEDIUM_LOW_HAS_PPR \
|
|
|
|
|
BEGIN_FTR_SECTION_NESTED(944) \
|
|
|
|
|
HMT_MEDIUM_LOW; \
|
|
|
|
|
END_FTR_SECTION_NESTED(CPU_FTR_HAS_PPR,CPU_FTR_HAS_PPR,944)
|
|
|
|
|
|
|
|
|
|
#define SET_DEFAULT_THREAD_PPR(ra, rb) \
|
|
|
|
|
BEGIN_FTR_SECTION_NESTED(945) \
|
|
|
|
|
lis ra,INIT_PPR@highest; /* default ppr=3 */ \
|
|
|
|
|
ld rb,PACACURRENT(r13); \
|
|
|
|
|
sldi ra,ra,32; /* 11- 13 bits are used for ppr */ \
|
|
|
|
|
std ra,TASKTHREADPPR(rb); \
|
|
|
|
|
END_FTR_SECTION_NESTED(CPU_FTR_HAS_PPR,CPU_FTR_HAS_PPR,945)
|
|
|
|
|
|
|
|
|
|
#define RESTORE_PPR(ra, rb) \
|
|
|
|
|
BEGIN_FTR_SECTION_NESTED(946) \
|
|
|
|
|
ld ra,PACACURRENT(r13); \
|
|
|
|
|
ld rb,TASKTHREADPPR(ra); \
|
|
|
|
|
mtspr SPRN_PPR,rb; /* Restore PPR */ \
|
|
|
|
|
END_FTR_SECTION_NESTED(CPU_FTR_HAS_PPR,CPU_FTR_HAS_PPR,946)
|
|
|
|
|
|
2012-04-18 09:21:52 +07:00
|
|
|
#endif
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
|
* This instruction is not implemented on the PPC 603 or 601; however, on
|
|
|
|
|
* the 403GCX and 405GP tlbia IS defined and tlbie is not.
|
|
|
|
|
* All of these instructions exist in the 8xx, they have magical powers,
|
|
|
|
|
* and they must be used.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if !defined(CONFIG_4xx) && !defined(CONFIG_8xx)
|
|
|
|
|
#define tlbia \
|
|
|
|
|
li r4,1024; \
|
|
|
|
|
mtctr r4; \
|
|
|
|
|
lis r4,KERNELBASE@h; \
|
|
|
|
|
0: tlbie r4; \
|
|
|
|
|
addi r4,r4,0x1000; \
|
|
|
|
|
bdnz 0b
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_IBM440EP_ERR42
|
|
|
|
|
#define PPC440EP_ERR42 isync
|
|
|
|
|
#else
|
|
|
|
|
#define PPC440EP_ERR42
|
|
|
|
|
#endif
|
|
|
|
|
|
2013-05-30 02:34:27 +07:00
|
|
|
/* The following stops all load and store data streams associated with stream
|
|
|
|
|
* ID (ie. streams created explicitly). The embedded and server mnemonics for
|
|
|
|
|
* dcbt are different so we use machine "power4" here explicitly.
|
|
|
|
|
*/
|
|
|
|
|
#define DCBT_STOP_ALL_STREAM_IDS(scratch) \
|
|
|
|
|
.machine push ; \
|
|
|
|
|
.machine "power4" ; \
|
|
|
|
|
lis scratch,0x60000000@h; \
|
|
|
|
|
dcbt r0,scratch,0b01010; \
|
|
|
|
|
.machine pop
|
|
|
|
|
|
2009-07-24 06:15:20 +07:00
|
|
|
/*
|
|
|
|
|
* toreal/fromreal/tophys/tovirt macros. 32-bit BookE makes them
|
|
|
|
|
* keep the address intact to be compatible with code shared with
|
|
|
|
|
* 32-bit classic.
|
|
|
|
|
*
|
|
|
|
|
* On the other hand, I find it useful to have them behave as expected
|
|
|
|
|
* by their name (ie always do the addition) on 64-bit BookE
|
|
|
|
|
*/
|
|
|
|
|
#if defined(CONFIG_BOOKE) && !defined(CONFIG_PPC64)
|
2005-10-27 19:44:39 +07:00
|
|
|
#define toreal(rd)
|
|
|
|
|
#define fromreal(rd)
|
|
|
|
|
|
2008-05-11 07:40:47 +07:00
|
|
|
/*
|
|
|
|
|
* We use addis to ensure compatibility with the "classic" ppc versions of
|
|
|
|
|
* these macros, which use rs = 0 to get the tophys offset in rd, rather than
|
|
|
|
|
* converting the address in r0, and so this version has to do that too
|
|
|
|
|
* (i.e. set register rd to 0 when rs == 0).
|
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
#define tophys(rd,rs) \
|
|
|
|
|
addis rd,rs,0
|
|
|
|
|
|
|
|
|
|
#define tovirt(rd,rs) \
|
|
|
|
|
addis rd,rs,0
|
|
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
#elif defined(CONFIG_PPC64)
|
2005-10-27 19:44:39 +07:00
|
|
|
#define toreal(rd) /* we can access c000... in real mode */
|
|
|
|
|
#define fromreal(rd)
|
|
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
#define tophys(rd,rs) \
|
2005-10-27 19:44:39 +07:00
|
|
|
clrldi rd,rs,2
|
2005-09-10 03:02:25 +07:00
|
|
|
|
|
|
|
|
#define tovirt(rd,rs) \
|
2005-10-27 19:44:39 +07:00
|
|
|
rotldi rd,rs,16; \
|
|
|
|
|
ori rd,rd,((KERNELBASE>>48)&0xFFFF);\
|
|
|
|
|
rotldi rd,rd,48
|
2005-09-10 03:02:25 +07:00
|
|
|
#else
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
|
* On APUS (Amiga PowerPC cpu upgrade board), we don't know the
|
|
|
|
|
* physical base address of RAM at compile time.
|
|
|
|
|
*/
|
2005-10-27 19:44:39 +07:00
|
|
|
#define toreal(rd) tophys(rd,rd)
|
|
|
|
|
#define fromreal(rd) tovirt(rd,rd)
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define tophys(rd,rs) \
|
2008-12-17 17:09:13 +07:00
|
|
|
0: addis rd,rs,-PAGE_OFFSET@h; \
|
2005-04-17 05:20:36 +07:00
|
|
|
.section ".vtop_fixup","aw"; \
|
|
|
|
|
.align 1; \
|
|
|
|
|
.long 0b; \
|
|
|
|
|
.previous
|
|
|
|
|
|
|
|
|
|
#define tovirt(rd,rs) \
|
2008-12-17 17:09:13 +07:00
|
|
|
0: addis rd,rs,PAGE_OFFSET@h; \
|
2005-04-17 05:20:36 +07:00
|
|
|
.section ".ptov_fixup","aw"; \
|
|
|
|
|
.align 1; \
|
|
|
|
|
.long 0b; \
|
|
|
|
|
.previous
|
2005-09-10 03:02:25 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-07-24 06:15:20 +07:00
|
|
|
#ifdef CONFIG_PPC_BOOK3S_64
|
2005-10-10 19:50:37 +07:00
|
|
|
#define RFI rfid
|
|
|
|
|
#define MTMSRD(r) mtmsrd r
|
2012-07-04 11:49:12 +07:00
|
|
|
#define MTMSR_EERI(reg) mtmsrd reg,1
|
2005-04-17 05:20:36 +07:00
|
|
|
#else
|
|
|
|
|
#define FIX_SRR1(ra, rb)
|
|
|
|
|
#ifndef CONFIG_40x
|
|
|
|
|
#define RFI rfi
|
|
|
|
|
#else
|
|
|
|
|
#define RFI rfi; b . /* Prevent prefetch past rfi */
|
|
|
|
|
#endif
|
|
|
|
|
#define MTMSRD(r) mtmsr r
|
2012-07-04 11:49:12 +07:00
|
|
|
#define MTMSR_EERI(reg) mtmsr reg
|
2005-04-17 05:20:36 +07:00
|
|
|
#define CLR_TOP32(r)
|
2005-08-01 12:34:52 +07:00
|
|
|
#endif
|
|
|
|
|
|
2005-12-17 04:43:46 +07:00
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* The boring bits... */
|
|
|
|
|
|
|
|
|
|
/* Condition Register Bit Fields */
|
|
|
|
|
|
|
|
|
|
#define cr0 0
|
|
|
|
|
#define cr1 1
|
|
|
|
|
#define cr2 2
|
|
|
|
|
#define cr3 3
|
|
|
|
|
#define cr4 4
|
|
|
|
|
#define cr5 5
|
|
|
|
|
#define cr6 6
|
|
|
|
|
#define cr7 7
|
|
|
|
|
|
|
|
|
|
|
2012-06-25 20:33:12 +07:00
|
|
|
/*
|
|
|
|
|
* General Purpose Registers (GPRs)
|
|
|
|
|
*
|
|
|
|
|
* The lower case r0-r31 should be used in preference to the upper
|
|
|
|
|
* case R0-R31 as they provide more error checking in the assembler.
|
|
|
|
|
* Use R0-31 only when really nessesary.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define r0 %r0
|
|
|
|
|
#define r1 %r1
|
|
|
|
|
#define r2 %r2
|
|
|
|
|
#define r3 %r3
|
|
|
|
|
#define r4 %r4
|
|
|
|
|
#define r5 %r5
|
|
|
|
|
#define r6 %r6
|
|
|
|
|
#define r7 %r7
|
|
|
|
|
#define r8 %r8
|
|
|
|
|
#define r9 %r9
|
|
|
|
|
#define r10 %r10
|
|
|
|
|
#define r11 %r11
|
|
|
|
|
#define r12 %r12
|
|
|
|
|
#define r13 %r13
|
|
|
|
|
#define r14 %r14
|
|
|
|
|
#define r15 %r15
|
|
|
|
|
#define r16 %r16
|
|
|
|
|
#define r17 %r17
|
|
|
|
|
#define r18 %r18
|
|
|
|
|
#define r19 %r19
|
|
|
|
|
#define r20 %r20
|
|
|
|
|
#define r21 %r21
|
|
|
|
|
#define r22 %r22
|
|
|
|
|
#define r23 %r23
|
|
|
|
|
#define r24 %r24
|
|
|
|
|
#define r25 %r25
|
|
|
|
|
#define r26 %r26
|
|
|
|
|
#define r27 %r27
|
|
|
|
|
#define r28 %r28
|
|
|
|
|
#define r29 %r29
|
|
|
|
|
#define r30 %r30
|
|
|
|
|
#define r31 %r31
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Floating Point Registers (FPRs) */
|
|
|
|
|
|
|
|
|
|
#define fr0 0
|
|
|
|
|
#define fr1 1
|
|
|
|
|
#define fr2 2
|
|
|
|
|
#define fr3 3
|
|
|
|
|
#define fr4 4
|
|
|
|
|
#define fr5 5
|
|
|
|
|
#define fr6 6
|
|
|
|
|
#define fr7 7
|
|
|
|
|
#define fr8 8
|
|
|
|
|
#define fr9 9
|
|
|
|
|
#define fr10 10
|
|
|
|
|
#define fr11 11
|
|
|
|
|
#define fr12 12
|
|
|
|
|
#define fr13 13
|
|
|
|
|
#define fr14 14
|
|
|
|
|
#define fr15 15
|
|
|
|
|
#define fr16 16
|
|
|
|
|
#define fr17 17
|
|
|
|
|
#define fr18 18
|
|
|
|
|
#define fr19 19
|
|
|
|
|
#define fr20 20
|
|
|
|
|
#define fr21 21
|
|
|
|
|
#define fr22 22
|
|
|
|
|
#define fr23 23
|
|
|
|
|
#define fr24 24
|
|
|
|
|
#define fr25 25
|
|
|
|
|
#define fr26 26
|
|
|
|
|
#define fr27 27
|
|
|
|
|
#define fr28 28
|
|
|
|
|
#define fr29 29
|
|
|
|
|
#define fr30 30
|
|
|
|
|
#define fr31 31
|
|
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
/* AltiVec Registers (VPRs) */
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define vr0 0
|
|
|
|
|
#define vr1 1
|
|
|
|
|
#define vr2 2
|
|
|
|
|
#define vr3 3
|
|
|
|
|
#define vr4 4
|
|
|
|
|
#define vr5 5
|
|
|
|
|
#define vr6 6
|
|
|
|
|
#define vr7 7
|
|
|
|
|
#define vr8 8
|
|
|
|
|
#define vr9 9
|
|
|
|
|
#define vr10 10
|
|
|
|
|
#define vr11 11
|
|
|
|
|
#define vr12 12
|
|
|
|
|
#define vr13 13
|
|
|
|
|
#define vr14 14
|
|
|
|
|
#define vr15 15
|
|
|
|
|
#define vr16 16
|
|
|
|
|
#define vr17 17
|
|
|
|
|
#define vr18 18
|
|
|
|
|
#define vr19 19
|
|
|
|
|
#define vr20 20
|
|
|
|
|
#define vr21 21
|
|
|
|
|
#define vr22 22
|
|
|
|
|
#define vr23 23
|
|
|
|
|
#define vr24 24
|
|
|
|
|
#define vr25 25
|
|
|
|
|
#define vr26 26
|
|
|
|
|
#define vr27 27
|
|
|
|
|
#define vr28 28
|
|
|
|
|
#define vr29 29
|
|
|
|
|
#define vr30 30
|
|
|
|
|
#define vr31 31
|
|
|
|
|
|
2008-06-25 11:07:18 +07:00
|
|
|
/* VSX Registers (VSRs) */
|
|
|
|
|
|
|
|
|
|
#define vsr0 0
|
|
|
|
|
#define vsr1 1
|
|
|
|
|
#define vsr2 2
|
|
|
|
|
#define vsr3 3
|
|
|
|
|
#define vsr4 4
|
|
|
|
|
#define vsr5 5
|
|
|
|
|
#define vsr6 6
|
|
|
|
|
#define vsr7 7
|
|
|
|
|
#define vsr8 8
|
|
|
|
|
#define vsr9 9
|
|
|
|
|
#define vsr10 10
|
|
|
|
|
#define vsr11 11
|
|
|
|
|
#define vsr12 12
|
|
|
|
|
#define vsr13 13
|
|
|
|
|
#define vsr14 14
|
|
|
|
|
#define vsr15 15
|
|
|
|
|
#define vsr16 16
|
|
|
|
|
#define vsr17 17
|
|
|
|
|
#define vsr18 18
|
|
|
|
|
#define vsr19 19
|
|
|
|
|
#define vsr20 20
|
|
|
|
|
#define vsr21 21
|
|
|
|
|
#define vsr22 22
|
|
|
|
|
#define vsr23 23
|
|
|
|
|
#define vsr24 24
|
|
|
|
|
#define vsr25 25
|
|
|
|
|
#define vsr26 26
|
|
|
|
|
#define vsr27 27
|
|
|
|
|
#define vsr28 28
|
|
|
|
|
#define vsr29 29
|
|
|
|
|
#define vsr30 30
|
|
|
|
|
#define vsr31 31
|
|
|
|
|
#define vsr32 32
|
|
|
|
|
#define vsr33 33
|
|
|
|
|
#define vsr34 34
|
|
|
|
|
#define vsr35 35
|
|
|
|
|
#define vsr36 36
|
|
|
|
|
#define vsr37 37
|
|
|
|
|
#define vsr38 38
|
|
|
|
|
#define vsr39 39
|
|
|
|
|
#define vsr40 40
|
|
|
|
|
#define vsr41 41
|
|
|
|
|
#define vsr42 42
|
|
|
|
|
#define vsr43 43
|
|
|
|
|
#define vsr44 44
|
|
|
|
|
#define vsr45 45
|
|
|
|
|
#define vsr46 46
|
|
|
|
|
#define vsr47 47
|
|
|
|
|
#define vsr48 48
|
|
|
|
|
#define vsr49 49
|
|
|
|
|
#define vsr50 50
|
|
|
|
|
#define vsr51 51
|
|
|
|
|
#define vsr52 52
|
|
|
|
|
#define vsr53 53
|
|
|
|
|
#define vsr54 54
|
|
|
|
|
#define vsr55 55
|
|
|
|
|
#define vsr56 56
|
|
|
|
|
#define vsr57 57
|
|
|
|
|
#define vsr58 58
|
|
|
|
|
#define vsr59 59
|
|
|
|
|
#define vsr60 60
|
|
|
|
|
#define vsr61 61
|
|
|
|
|
#define vsr62 62
|
|
|
|
|
#define vsr63 63
|
|
|
|
|
|
2005-09-10 03:02:25 +07:00
|
|
|
/* SPE Registers (EVPRs) */
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define evr0 0
|
|
|
|
|
#define evr1 1
|
|
|
|
|
#define evr2 2
|
|
|
|
|
#define evr3 3
|
|
|
|
|
#define evr4 4
|
|
|
|
|
#define evr5 5
|
|
|
|
|
#define evr6 6
|
|
|
|
|
#define evr7 7
|
|
|
|
|
#define evr8 8
|
|
|
|
|
#define evr9 9
|
|
|
|
|
#define evr10 10
|
|
|
|
|
#define evr11 11
|
|
|
|
|
#define evr12 12
|
|
|
|
|
#define evr13 13
|
|
|
|
|
#define evr14 14
|
|
|
|
|
#define evr15 15
|
|
|
|
|
#define evr16 16
|
|
|
|
|
#define evr17 17
|
|
|
|
|
#define evr18 18
|
|
|
|
|
#define evr19 19
|
|
|
|
|
#define evr20 20
|
|
|
|
|
#define evr21 21
|
|
|
|
|
#define evr22 22
|
|
|
|
|
#define evr23 23
|
|
|
|
|
#define evr24 24
|
|
|
|
|
#define evr25 25
|
|
|
|
|
#define evr26 26
|
|
|
|
|
#define evr27 27
|
|
|
|
|
#define evr28 28
|
|
|
|
|
#define evr29 29
|
|
|
|
|
#define evr30 30
|
|
|
|
|
#define evr31 31
|
|
|
|
|
|
|
|
|
|
/* some stab codes */
|
|
|
|
|
#define N_FUN 36
|
|
|
|
|
#define N_RSYM 64
|
|
|
|
|
#define N_SLINE 68
|
|
|
|
|
#define N_SO 100
|
2005-09-10 03:02:25 +07:00
|
|
|
|
|
|
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
|
|
|
|
|
|
#endif /* _ASM_POWERPC_PPC_ASM_H */
|