diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2009-01-05 21:45:06 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2009-01-05 21:45:06 -0500 |
commit | 7a1fcd5f5130f173b5e824135735ec58f245563e (patch) | |
tree | fc21e9f5592ef58a5d98a4bf1ccd6f44010cbca3 /arch/sparc/include | |
parent | 15b0669072127f282896b3bef2e9df4ec5d7264f (diff) | |
parent | 4696b64d234b84b5b70ffd49a76833aa5c49cb61 (diff) |
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6: (30 commits)
sparc: Fix minor SPARC32 compile error
sparc: Remove reg*.h from Kbuild
sparc: Clean arch-specific code in prom_common.c
sparc: Kill asm/reg*.h
sparc: Use 64BIT config entry
MAINTAINERS: update sparc maintainer
sparc: unify ipcbuf.h
sparc: Update 64-bit defconfig.
sparc: remove NO_PROC_ID - it is no longer used
sparc: drop get_tbr() in traps.h
sparc: fix warning in userspace header traps.h
sparc: fix warnings in userspace header byteorder.h
sparc: fix warning in userspace header jsflash.h
sparc: unify openprom.h
sparc64: delete unused linux_prom64_ranges from openprom_64.h
sparc: prepare openprom for unification
sparc: remove linux_prom_pci_assigned_addresses from openprom_32.h
sparc: remove ebus definitions from openprom*.h
sparc: unify siginfo.h
sparc: unify ptrace.h
...
Diffstat (limited to 'arch/sparc/include')
34 files changed, 1353 insertions, 2328 deletions
diff --git a/arch/sparc/include/asm/Kbuild b/arch/sparc/include/asm/Kbuild index 89c260aab45c..deeb0fba8029 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild | |||
@@ -1,21 +1,6 @@ | |||
1 | # User exported sparc header files | 1 | # User exported sparc header files |
2 | include include/asm-generic/Kbuild.asm | 2 | include include/asm-generic/Kbuild.asm |
3 | 3 | ||
4 | header-y += ipcbuf_32.h | ||
5 | header-y += ipcbuf_64.h | ||
6 | header-y += posix_types_32.h | ||
7 | header-y += posix_types_64.h | ||
8 | header-y += ptrace_32.h | ||
9 | header-y += ptrace_64.h | ||
10 | header-y += sigcontext_32.h | ||
11 | header-y += sigcontext_64.h | ||
12 | header-y += siginfo_32.h | ||
13 | header-y += siginfo_64.h | ||
14 | header-y += signal_32.h | ||
15 | header-y += signal_64.h | ||
16 | header-y += stat_32.h | ||
17 | header-y += stat_64.h | ||
18 | |||
19 | header-y += apc.h | 4 | header-y += apc.h |
20 | header-y += asi.h | 5 | header-y += asi.h |
21 | header-y += display7seg.h | 6 | header-y += display7seg.h |
@@ -23,16 +8,11 @@ header-y += envctrl.h | |||
23 | header-y += fbio.h | 8 | header-y += fbio.h |
24 | header-y += jsflash.h | 9 | header-y += jsflash.h |
25 | header-y += openprom.h | 10 | header-y += openprom.h |
26 | header-y += openprom_32.h | ||
27 | header-y += openprom_64.h | ||
28 | header-y += openpromio.h | 11 | header-y += openpromio.h |
29 | header-y += perfctr.h | 12 | header-y += perfctr.h |
30 | header-y += psrcompat.h | 13 | header-y += psrcompat.h |
31 | header-y += psr.h | 14 | header-y += psr.h |
32 | header-y += pstate.h | 15 | header-y += pstate.h |
33 | header-y += reg.h | ||
34 | header-y += reg_32.h | ||
35 | header-y += reg_64.h | ||
36 | header-y += traps.h | 16 | header-y += traps.h |
37 | header-y += uctx.h | 17 | header-y += uctx.h |
38 | header-y += utrap.h | 18 | header-y += utrap.h |
diff --git a/arch/sparc/include/asm/byteorder.h b/arch/sparc/include/asm/byteorder.h index 5a70f137f1f7..738414b26558 100644 --- a/arch/sparc/include/asm/byteorder.h +++ b/arch/sparc/include/asm/byteorder.h | |||
@@ -1,16 +1,12 @@ | |||
1 | #ifndef _SPARC_BYTEORDER_H | 1 | #ifndef _SPARC_BYTEORDER_H |
2 | #define _SPARC_BYTEORDER_H | 2 | #define _SPARC_BYTEORDER_H |
3 | 3 | ||
4 | #include <asm/types.h> | 4 | #include <linux/types.h> |
5 | #include <asm/asi.h> | 5 | #include <asm/asi.h> |
6 | 6 | ||
7 | #define __BIG_ENDIAN | 7 | #define __BIG_ENDIAN |
8 | 8 | ||
9 | #ifdef CONFIG_SPARC32 | 9 | #if defined(__sparc__) && defined(__arch64__) |
10 | #define __SWAB_64_THRU_32__ | ||
11 | #endif | ||
12 | |||
13 | #ifdef CONFIG_SPARC64 | ||
14 | static inline __u16 __arch_swab16p(const __u16 *addr) | 10 | static inline __u16 __arch_swab16p(const __u16 *addr) |
15 | { | 11 | { |
16 | __u16 ret; | 12 | __u16 ret; |
@@ -44,7 +40,9 @@ static inline __u64 __arch_swab64p(const __u64 *addr) | |||
44 | } | 40 | } |
45 | #define __arch_swab64p __arch_swab64p | 41 | #define __arch_swab64p __arch_swab64p |
46 | 42 | ||
47 | #endif /* CONFIG_SPARC64 */ | 43 | #else |
44 | #define __SWAB_64_THRU_32__ | ||
45 | #endif /* defined(__sparc__) && defined(__arch64__) */ | ||
48 | 46 | ||
49 | #include <linux/byteorder.h> | 47 | #include <linux/byteorder.h> |
50 | 48 | ||
diff --git a/arch/sparc/include/asm/ipcbuf.h b/arch/sparc/include/asm/ipcbuf.h index 17d6ef7b23a4..66013b4fe10d 100644 --- a/arch/sparc/include/asm/ipcbuf.h +++ b/arch/sparc/include/asm/ipcbuf.h | |||
@@ -1,8 +1,32 @@ | |||
1 | #ifndef ___ASM_SPARC_IPCBUF_H | 1 | #ifndef __SPARC_IPCBUF_H |
2 | #define ___ASM_SPARC_IPCBUF_H | 2 | #define __SPARC_IPCBUF_H |
3 | #if defined(__sparc__) && defined(__arch64__) | 3 | |
4 | #include <asm/ipcbuf_64.h> | 4 | /* |
5 | #else | 5 | * The ipc64_perm structure for sparc/sparc64 architecture. |
6 | #include <asm/ipcbuf_32.h> | 6 | * Note extra padding because this structure is passed back and forth |
7 | #endif | 7 | * between kernel and user space. |
8 | * | ||
9 | * Pad space is left for: | ||
10 | * - 32-bit seq | ||
11 | * - on sparc for 32 bit mode (it is 32 bit on sparc64) | ||
12 | * - 2 miscellaneous 64-bit values | ||
13 | */ | ||
14 | |||
15 | struct ipc64_perm | ||
16 | { | ||
17 | __kernel_key_t key; | ||
18 | __kernel_uid_t uid; | ||
19 | __kernel_gid_t gid; | ||
20 | __kernel_uid_t cuid; | ||
21 | __kernel_gid_t cgid; | ||
22 | #ifndef __arch64__ | ||
23 | unsigned short __pad0; | ||
8 | #endif | 24 | #endif |
25 | __kernel_mode_t mode; | ||
26 | unsigned short __pad1; | ||
27 | unsigned short seq; | ||
28 | unsigned long long __unused1; | ||
29 | unsigned long long __unused2; | ||
30 | }; | ||
31 | |||
32 | #endif /* __SPARC_IPCBUF_H */ | ||
diff --git a/arch/sparc/include/asm/ipcbuf_32.h b/arch/sparc/include/asm/ipcbuf_32.h deleted file mode 100644 index 6387209518f2..000000000000 --- a/arch/sparc/include/asm/ipcbuf_32.h +++ /dev/null | |||
@@ -1,31 +0,0 @@ | |||
1 | #ifndef _SPARC_IPCBUF_H | ||
2 | #define _SPARC_IPCBUF_H | ||
3 | |||
4 | /* | ||
5 | * The ipc64_perm structure for sparc architecture. | ||
6 | * Note extra padding because this structure is passed back and forth | ||
7 | * between kernel and user space. | ||
8 | * | ||
9 | * Pad space is left for: | ||
10 | * - 32-bit mode | ||
11 | * - 32-bit seq | ||
12 | * - 2 miscellaneous 64-bit values (so that this structure matches | ||
13 | * sparc64 ipc64_perm) | ||
14 | */ | ||
15 | |||
16 | struct ipc64_perm | ||
17 | { | ||
18 | __kernel_key_t key; | ||
19 | __kernel_uid32_t uid; | ||
20 | __kernel_gid32_t gid; | ||
21 | __kernel_uid32_t cuid; | ||
22 | __kernel_gid32_t cgid; | ||
23 | unsigned short __pad1; | ||
24 | __kernel_mode_t mode; | ||
25 | unsigned short __pad2; | ||
26 | unsigned short seq; | ||
27 | unsigned long long __unused1; | ||
28 | unsigned long long __unused2; | ||
29 | }; | ||
30 | |||
31 | #endif /* _SPARC_IPCBUF_H */ | ||
diff --git a/arch/sparc/include/asm/ipcbuf_64.h b/arch/sparc/include/asm/ipcbuf_64.h deleted file mode 100644 index a44b855b98db..000000000000 --- a/arch/sparc/include/asm/ipcbuf_64.h +++ /dev/null | |||
@@ -1,28 +0,0 @@ | |||
1 | #ifndef _SPARC64_IPCBUF_H | ||
2 | #define _SPARC64_IPCBUF_H | ||
3 | |||
4 | /* | ||
5 | * The ipc64_perm structure for sparc64 architecture. | ||
6 | * Note extra padding because this structure is passed back and forth | ||
7 | * between kernel and user space. | ||
8 | * | ||
9 | * Pad space is left for: | ||
10 | * - 32-bit seq | ||
11 | * - 2 miscellaneous 64-bit values | ||
12 | */ | ||
13 | |||
14 | struct ipc64_perm | ||
15 | { | ||
16 | __kernel_key_t key; | ||
17 | __kernel_uid_t uid; | ||
18 | __kernel_gid_t gid; | ||
19 | __kernel_uid_t cuid; | ||
20 | __kernel_gid_t cgid; | ||
21 | __kernel_mode_t mode; | ||
22 | unsigned short __pad1; | ||
23 | unsigned short seq; | ||
24 | unsigned long __unused1; | ||
25 | unsigned long __unused2; | ||
26 | }; | ||
27 | |||
28 | #endif /* _SPARC64_IPCBUF_H */ | ||
diff --git a/arch/sparc/include/asm/jsflash.h b/arch/sparc/include/asm/jsflash.h index 3457f29bd73b..0717d9e39d2d 100644 --- a/arch/sparc/include/asm/jsflash.h +++ b/arch/sparc/include/asm/jsflash.h | |||
@@ -8,7 +8,7 @@ | |||
8 | #define _SPARC_JSFLASH_H | 8 | #define _SPARC_JSFLASH_H |
9 | 9 | ||
10 | #ifndef _SPARC_TYPES_H | 10 | #ifndef _SPARC_TYPES_H |
11 | #include <asm/types.h> | 11 | #include <linux/types.h> |
12 | #endif | 12 | #endif |
13 | 13 | ||
14 | /* | 14 | /* |
diff --git a/arch/sparc/include/asm/openprom.h b/arch/sparc/include/asm/openprom.h index aaeae905ed3f..963e1a45c35f 100644 --- a/arch/sparc/include/asm/openprom.h +++ b/arch/sparc/include/asm/openprom.h | |||
@@ -1,8 +1,277 @@ | |||
1 | #ifndef ___ASM_SPARC_OPENPROM_H | 1 | #ifndef __SPARC_OPENPROM_H |
2 | #define ___ASM_SPARC_OPENPROM_H | 2 | #define __SPARC_OPENPROM_H |
3 | |||
4 | /* openprom.h: Prom structures and defines for access to the OPENBOOT | ||
5 | * prom routines and data areas. | ||
6 | * | ||
7 | * Copyright (C) 1995,1996 David S. Miller (davem@caip.rutgers.edu) | ||
8 | */ | ||
9 | |||
10 | /* Empirical constants... */ | ||
11 | #define LINUX_OPPROM_MAGIC 0x10010407 | ||
12 | |||
13 | #ifndef __ASSEMBLY__ | ||
14 | /* V0 prom device operations. */ | ||
15 | struct linux_dev_v0_funcs { | ||
16 | int (*v0_devopen)(char *device_str); | ||
17 | int (*v0_devclose)(int dev_desc); | ||
18 | int (*v0_rdblkdev)(int dev_desc, int num_blks, int blk_st, char *buf); | ||
19 | int (*v0_wrblkdev)(int dev_desc, int num_blks, int blk_st, char *buf); | ||
20 | int (*v0_wrnetdev)(int dev_desc, int num_bytes, char *buf); | ||
21 | int (*v0_rdnetdev)(int dev_desc, int num_bytes, char *buf); | ||
22 | int (*v0_rdchardev)(int dev_desc, int num_bytes, int dummy, char *buf); | ||
23 | int (*v0_wrchardev)(int dev_desc, int num_bytes, int dummy, char *buf); | ||
24 | int (*v0_seekdev)(int dev_desc, long logical_offst, int from); | ||
25 | }; | ||
26 | |||
27 | /* V2 and later prom device operations. */ | ||
28 | struct linux_dev_v2_funcs { | ||
29 | int (*v2_inst2pkg)(int d); /* Convert ihandle to phandle */ | ||
30 | char * (*v2_dumb_mem_alloc)(char *va, unsigned sz); | ||
31 | void (*v2_dumb_mem_free)(char *va, unsigned sz); | ||
32 | |||
33 | /* To map devices into virtual I/O space. */ | ||
34 | char * (*v2_dumb_mmap)(char *virta, int which_io, unsigned paddr, unsigned sz); | ||
35 | void (*v2_dumb_munmap)(char *virta, unsigned size); | ||
36 | |||
37 | int (*v2_dev_open)(char *devpath); | ||
38 | void (*v2_dev_close)(int d); | ||
39 | int (*v2_dev_read)(int d, char *buf, int nbytes); | ||
40 | int (*v2_dev_write)(int d, char *buf, int nbytes); | ||
41 | int (*v2_dev_seek)(int d, int hi, int lo); | ||
42 | |||
43 | /* Never issued (multistage load support) */ | ||
44 | void (*v2_wheee2)(void); | ||
45 | void (*v2_wheee3)(void); | ||
46 | }; | ||
47 | |||
48 | struct linux_mlist_v0 { | ||
49 | struct linux_mlist_v0 *theres_more; | ||
50 | unsigned int start_adr; | ||
51 | unsigned num_bytes; | ||
52 | }; | ||
53 | |||
54 | struct linux_mem_v0 { | ||
55 | struct linux_mlist_v0 **v0_totphys; | ||
56 | struct linux_mlist_v0 **v0_prommap; | ||
57 | struct linux_mlist_v0 **v0_available; /* What we can use */ | ||
58 | }; | ||
59 | |||
60 | /* Arguments sent to the kernel from the boot prompt. */ | ||
61 | struct linux_arguments_v0 { | ||
62 | char *argv[8]; | ||
63 | char args[100]; | ||
64 | char boot_dev[2]; | ||
65 | int boot_dev_ctrl; | ||
66 | int boot_dev_unit; | ||
67 | int dev_partition; | ||
68 | char *kernel_file_name; | ||
69 | void *aieee1; /* XXX */ | ||
70 | }; | ||
71 | |||
72 | /* V2 and up boot things. */ | ||
73 | struct linux_bootargs_v2 { | ||
74 | char **bootpath; | ||
75 | char **bootargs; | ||
76 | int *fd_stdin; | ||
77 | int *fd_stdout; | ||
78 | }; | ||
79 | |||
80 | /* The top level PROM vector. */ | ||
81 | struct linux_romvec { | ||
82 | /* Version numbers. */ | ||
83 | unsigned int pv_magic_cookie; | ||
84 | unsigned int pv_romvers; | ||
85 | unsigned int pv_plugin_revision; | ||
86 | unsigned int pv_printrev; | ||
87 | |||
88 | /* Version 0 memory descriptors. */ | ||
89 | struct linux_mem_v0 pv_v0mem; | ||
90 | |||
91 | /* Node operations. */ | ||
92 | struct linux_nodeops *pv_nodeops; | ||
93 | |||
94 | char **pv_bootstr; | ||
95 | struct linux_dev_v0_funcs pv_v0devops; | ||
96 | |||
97 | char *pv_stdin; | ||
98 | char *pv_stdout; | ||
99 | #define PROMDEV_KBD 0 /* input from keyboard */ | ||
100 | #define PROMDEV_SCREEN 0 /* output to screen */ | ||
101 | #define PROMDEV_TTYA 1 /* in/out to ttya */ | ||
102 | #define PROMDEV_TTYB 2 /* in/out to ttyb */ | ||
103 | |||
104 | /* Blocking getchar/putchar. NOT REENTRANT! (grr) */ | ||
105 | int (*pv_getchar)(void); | ||
106 | void (*pv_putchar)(int ch); | ||
107 | |||
108 | /* Non-blocking variants. */ | ||
109 | int (*pv_nbgetchar)(void); | ||
110 | int (*pv_nbputchar)(int ch); | ||
111 | |||
112 | void (*pv_putstr)(char *str, int len); | ||
113 | |||
114 | /* Miscellany. */ | ||
115 | void (*pv_reboot)(char *bootstr); | ||
116 | void (*pv_printf)(__const__ char *fmt, ...); | ||
117 | void (*pv_abort)(void); | ||
118 | __volatile__ int *pv_ticks; | ||
119 | void (*pv_halt)(void); | ||
120 | void (**pv_synchook)(void); | ||
121 | |||
122 | /* Evaluate a forth string, not different proto for V0 and V2->up. */ | ||
123 | union { | ||
124 | void (*v0_eval)(int len, char *str); | ||
125 | void (*v2_eval)(char *str); | ||
126 | } pv_fortheval; | ||
127 | |||
128 | struct linux_arguments_v0 **pv_v0bootargs; | ||
129 | |||
130 | /* Get ether address. */ | ||
131 | unsigned int (*pv_enaddr)(int d, char *enaddr); | ||
132 | |||
133 | struct linux_bootargs_v2 pv_v2bootargs; | ||
134 | struct linux_dev_v2_funcs pv_v2devops; | ||
135 | |||
136 | int filler[15]; | ||
137 | |||
138 | /* This one is sun4c/sun4 only. */ | ||
139 | void (*pv_setctxt)(int ctxt, char *va, int pmeg); | ||
140 | |||
141 | /* Prom version 3 Multiprocessor routines. This stuff is crazy. | ||
142 | * No joke. Calling these when there is only one cpu probably | ||
143 | * crashes the machine, have to test this. :-) | ||
144 | */ | ||
145 | |||
146 | /* v3_cpustart() will start the cpu 'whichcpu' in mmu-context | ||
147 | * 'thiscontext' executing at address 'prog_counter' | ||
148 | */ | ||
149 | int (*v3_cpustart)(unsigned int whichcpu, int ctxtbl_ptr, | ||
150 | int thiscontext, char *prog_counter); | ||
151 | |||
152 | /* v3_cpustop() will cause cpu 'whichcpu' to stop executing | ||
153 | * until a resume cpu call is made. | ||
154 | */ | ||
155 | int (*v3_cpustop)(unsigned int whichcpu); | ||
156 | |||
157 | /* v3_cpuidle() will idle cpu 'whichcpu' until a stop or | ||
158 | * resume cpu call is made. | ||
159 | */ | ||
160 | int (*v3_cpuidle)(unsigned int whichcpu); | ||
161 | |||
162 | /* v3_cpuresume() will resume processor 'whichcpu' executing | ||
163 | * starting with whatever 'pc' and 'npc' were left at the | ||
164 | * last 'idle' or 'stop' call. | ||
165 | */ | ||
166 | int (*v3_cpuresume)(unsigned int whichcpu); | ||
167 | }; | ||
168 | |||
169 | /* Routines for traversing the prom device tree. */ | ||
170 | struct linux_nodeops { | ||
171 | int (*no_nextnode)(int node); | ||
172 | int (*no_child)(int node); | ||
173 | int (*no_proplen)(int node, const char *name); | ||
174 | int (*no_getprop)(int node, const char *name, char *val); | ||
175 | int (*no_setprop)(int node, const char *name, char *val, int len); | ||
176 | char * (*no_nextprop)(int node, char *name); | ||
177 | }; | ||
178 | |||
179 | /* More fun PROM structures for device probing. */ | ||
3 | #if defined(__sparc__) && defined(__arch64__) | 180 | #if defined(__sparc__) && defined(__arch64__) |
4 | #include <asm/openprom_64.h> | 181 | #define PROMREG_MAX 24 |
182 | #define PROMVADDR_MAX 16 | ||
183 | #define PROMINTR_MAX 32 | ||
5 | #else | 184 | #else |
6 | #include <asm/openprom_32.h> | 185 | #define PROMREG_MAX 16 |
186 | #define PROMVADDR_MAX 16 | ||
187 | #define PROMINTR_MAX 15 | ||
7 | #endif | 188 | #endif |
189 | |||
190 | struct linux_prom_registers { | ||
191 | unsigned int which_io; /* hi part of physical address */ | ||
192 | unsigned int phys_addr; /* The physical address of this register */ | ||
193 | unsigned int reg_size; /* How many bytes does this register take up? */ | ||
194 | }; | ||
195 | |||
196 | struct linux_prom64_registers { | ||
197 | unsigned long phys_addr; | ||
198 | unsigned long reg_size; | ||
199 | }; | ||
200 | |||
201 | struct linux_prom_irqs { | ||
202 | int pri; /* IRQ priority */ | ||
203 | int vector; /* This is foobar, what does it do? */ | ||
204 | }; | ||
205 | |||
206 | /* Element of the "ranges" vector */ | ||
207 | struct linux_prom_ranges { | ||
208 | unsigned int ot_child_space; | ||
209 | unsigned int ot_child_base; /* Bus feels this */ | ||
210 | unsigned int ot_parent_space; | ||
211 | unsigned int ot_parent_base; /* CPU looks from here */ | ||
212 | unsigned int or_size; | ||
213 | }; | ||
214 | |||
215 | /* | ||
216 | * Ranges and reg properties are a bit different for PCI. | ||
217 | */ | ||
218 | #if defined(__sparc__) && defined(__arch64__) | ||
219 | struct linux_prom_pci_registers { | ||
220 | unsigned int phys_hi; | ||
221 | unsigned int phys_mid; | ||
222 | unsigned int phys_lo; | ||
223 | |||
224 | unsigned int size_hi; | ||
225 | unsigned int size_lo; | ||
226 | }; | ||
227 | #else | ||
228 | struct linux_prom_pci_registers { | ||
229 | /* | ||
230 | * We don't know what information this field contain. | ||
231 | * We guess, PCI device function is in bits 15:8 | ||
232 | * So, ... | ||
233 | */ | ||
234 | unsigned int which_io; /* Let it be which_io */ | ||
235 | |||
236 | unsigned int phys_hi; | ||
237 | unsigned int phys_lo; | ||
238 | |||
239 | unsigned int size_hi; | ||
240 | unsigned int size_lo; | ||
241 | }; | ||
242 | |||
8 | #endif | 243 | #endif |
244 | |||
245 | struct linux_prom_pci_ranges { | ||
246 | unsigned int child_phys_hi; /* Only certain bits are encoded here. */ | ||
247 | unsigned int child_phys_mid; | ||
248 | unsigned int child_phys_lo; | ||
249 | |||
250 | unsigned int parent_phys_hi; | ||
251 | unsigned int parent_phys_lo; | ||
252 | |||
253 | unsigned int size_hi; | ||
254 | unsigned int size_lo; | ||
255 | }; | ||
256 | |||
257 | struct linux_prom_pci_intmap { | ||
258 | unsigned int phys_hi; | ||
259 | unsigned int phys_mid; | ||
260 | unsigned int phys_lo; | ||
261 | |||
262 | unsigned int interrupt; | ||
263 | |||
264 | int cnode; | ||
265 | unsigned int cinterrupt; | ||
266 | }; | ||
267 | |||
268 | struct linux_prom_pci_intmask { | ||
269 | unsigned int phys_hi; | ||
270 | unsigned int phys_mid; | ||
271 | unsigned int phys_lo; | ||
272 | unsigned int interrupt; | ||
273 | }; | ||
274 | |||
275 | #endif /* !(__ASSEMBLY__) */ | ||
276 | |||
277 | #endif /* !(__SPARC_OPENPROM_H) */ | ||
diff --git a/arch/sparc/include/asm/openprom_32.h b/arch/sparc/include/asm/openprom_32.h deleted file mode 100644 index 875da3552d80..000000000000 --- a/arch/sparc/include/asm/openprom_32.h +++ /dev/null | |||
@@ -1,255 +0,0 @@ | |||
1 | #ifndef __SPARC_OPENPROM_H | ||
2 | #define __SPARC_OPENPROM_H | ||
3 | |||
4 | /* openprom.h: Prom structures and defines for access to the OPENBOOT | ||
5 | * prom routines and data areas. | ||
6 | * | ||
7 | * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) | ||
8 | */ | ||
9 | |||
10 | /* Empirical constants... */ | ||
11 | #define LINUX_OPPROM_MAGIC 0x10010407 | ||
12 | |||
13 | #ifndef __ASSEMBLY__ | ||
14 | /* V0 prom device operations. */ | ||
15 | struct linux_dev_v0_funcs { | ||
16 | int (*v0_devopen)(char *device_str); | ||
17 | int (*v0_devclose)(int dev_desc); | ||
18 | int (*v0_rdblkdev)(int dev_desc, int num_blks, int blk_st, char *buf); | ||
19 | int (*v0_wrblkdev)(int dev_desc, int num_blks, int blk_st, char *buf); | ||
20 | int (*v0_wrnetdev)(int dev_desc, int num_bytes, char *buf); | ||
21 | int (*v0_rdnetdev)(int dev_desc, int num_bytes, char *buf); | ||
22 | int (*v0_rdchardev)(int dev_desc, int num_bytes, int dummy, char *buf); | ||
23 | int (*v0_wrchardev)(int dev_desc, int num_bytes, int dummy, char *buf); | ||
24 | int (*v0_seekdev)(int dev_desc, long logical_offst, int from); | ||
25 | }; | ||
26 | |||
27 | /* V2 and later prom device operations. */ | ||
28 | struct linux_dev_v2_funcs { | ||
29 | int (*v2_inst2pkg)(int d); /* Convert ihandle to phandle */ | ||
30 | char * (*v2_dumb_mem_alloc)(char *va, unsigned sz); | ||
31 | void (*v2_dumb_mem_free)(char *va, unsigned sz); | ||
32 | |||
33 | /* To map devices into virtual I/O space. */ | ||
34 | char * (*v2_dumb_mmap)(char *virta, int which_io, unsigned paddr, unsigned sz); | ||
35 | void (*v2_dumb_munmap)(char *virta, unsigned size); | ||
36 | |||
37 | int (*v2_dev_open)(char *devpath); | ||
38 | void (*v2_dev_close)(int d); | ||
39 | int (*v2_dev_read)(int d, char *buf, int nbytes); | ||
40 | int (*v2_dev_write)(int d, char *buf, int nbytes); | ||
41 | int (*v2_dev_seek)(int d, int hi, int lo); | ||
42 | |||
43 | /* Never issued (multistage load support) */ | ||
44 | void (*v2_wheee2)(void); | ||
45 | void (*v2_wheee3)(void); | ||
46 | }; | ||
47 | |||
48 | struct linux_mlist_v0 { | ||
49 | struct linux_mlist_v0 *theres_more; | ||
50 | char *start_adr; | ||
51 | unsigned num_bytes; | ||
52 | }; | ||
53 | |||
54 | struct linux_mem_v0 { | ||
55 | struct linux_mlist_v0 **v0_totphys; | ||
56 | struct linux_mlist_v0 **v0_prommap; | ||
57 | struct linux_mlist_v0 **v0_available; /* What we can use */ | ||
58 | }; | ||
59 | |||
60 | /* Arguments sent to the kernel from the boot prompt. */ | ||
61 | struct linux_arguments_v0 { | ||
62 | char *argv[8]; | ||
63 | char args[100]; | ||
64 | char boot_dev[2]; | ||
65 | int boot_dev_ctrl; | ||
66 | int boot_dev_unit; | ||
67 | int dev_partition; | ||
68 | char *kernel_file_name; | ||
69 | void *aieee1; /* XXX */ | ||
70 | }; | ||
71 | |||
72 | /* V2 and up boot things. */ | ||
73 | struct linux_bootargs_v2 { | ||
74 | char **bootpath; | ||
75 | char **bootargs; | ||
76 | int *fd_stdin; | ||
77 | int *fd_stdout; | ||
78 | }; | ||
79 | |||
80 | /* The top level PROM vector. */ | ||
81 | struct linux_romvec { | ||
82 | /* Version numbers. */ | ||
83 | unsigned int pv_magic_cookie; | ||
84 | unsigned int pv_romvers; | ||
85 | unsigned int pv_plugin_revision; | ||
86 | unsigned int pv_printrev; | ||
87 | |||
88 | /* Version 0 memory descriptors. */ | ||
89 | struct linux_mem_v0 pv_v0mem; | ||
90 | |||
91 | /* Node operations. */ | ||
92 | struct linux_nodeops *pv_nodeops; | ||
93 | |||
94 | char **pv_bootstr; | ||
95 | struct linux_dev_v0_funcs pv_v0devops; | ||
96 | |||
97 | char *pv_stdin; | ||
98 | char *pv_stdout; | ||
99 | #define PROMDEV_KBD 0 /* input from keyboard */ | ||
100 | #define PROMDEV_SCREEN 0 /* output to screen */ | ||
101 | #define PROMDEV_TTYA 1 /* in/out to ttya */ | ||
102 | #define PROMDEV_TTYB 2 /* in/out to ttyb */ | ||
103 | |||
104 | /* Blocking getchar/putchar. NOT REENTRANT! (grr) */ | ||
105 | int (*pv_getchar)(void); | ||
106 | void (*pv_putchar)(int ch); | ||
107 | |||
108 | /* Non-blocking variants. */ | ||
109 | int (*pv_nbgetchar)(void); | ||
110 | int (*pv_nbputchar)(int ch); | ||
111 | |||
112 | void (*pv_putstr)(char *str, int len); | ||
113 | |||
114 | /* Miscellany. */ | ||
115 | void (*pv_reboot)(char *bootstr); | ||
116 | void (*pv_printf)(__const__ char *fmt, ...); | ||
117 | void (*pv_abort)(void); | ||
118 | __volatile__ int *pv_ticks; | ||
119 | void (*pv_halt)(void); | ||
120 | void (**pv_synchook)(void); | ||
121 | |||
122 | /* Evaluate a forth string, not different proto for V0 and V2->up. */ | ||
123 | union { | ||
124 | void (*v0_eval)(int len, char *str); | ||
125 | void (*v2_eval)(char *str); | ||
126 | } pv_fortheval; | ||
127 | |||
128 | struct linux_arguments_v0 **pv_v0bootargs; | ||
129 | |||
130 | /* Get ether address. */ | ||
131 | unsigned int (*pv_enaddr)(int d, char *enaddr); | ||
132 | |||
133 | struct linux_bootargs_v2 pv_v2bootargs; | ||
134 | struct linux_dev_v2_funcs pv_v2devops; | ||
135 | |||
136 | int filler[15]; | ||
137 | |||
138 | /* This one is sun4c/sun4 only. */ | ||
139 | void (*pv_setctxt)(int ctxt, char *va, int pmeg); | ||
140 | |||
141 | /* Prom version 3 Multiprocessor routines. This stuff is crazy. | ||
142 | * No joke. Calling these when there is only one cpu probably | ||
143 | * crashes the machine, have to test this. :-) | ||
144 | */ | ||
145 | |||
146 | /* v3_cpustart() will start the cpu 'whichcpu' in mmu-context | ||
147 | * 'thiscontext' executing at address 'prog_counter' | ||
148 | */ | ||
149 | int (*v3_cpustart)(unsigned int whichcpu, int ctxtbl_ptr, | ||
150 | int thiscontext, char *prog_counter); | ||
151 | |||
152 | /* v3_cpustop() will cause cpu 'whichcpu' to stop executing | ||
153 | * until a resume cpu call is made. | ||
154 | */ | ||
155 | int (*v3_cpustop)(unsigned int whichcpu); | ||
156 | |||
157 | /* v3_cpuidle() will idle cpu 'whichcpu' until a stop or | ||
158 | * resume cpu call is made. | ||
159 | */ | ||
160 | int (*v3_cpuidle)(unsigned int whichcpu); | ||
161 | |||
162 | /* v3_cpuresume() will resume processor 'whichcpu' executing | ||
163 | * starting with whatever 'pc' and 'npc' were left at the | ||
164 | * last 'idle' or 'stop' call. | ||
165 | */ | ||
166 | int (*v3_cpuresume)(unsigned int whichcpu); | ||
167 | }; | ||
168 | |||
169 | /* Routines for traversing the prom device tree. */ | ||
170 | struct linux_nodeops { | ||
171 | int (*no_nextnode)(int node); | ||
172 | int (*no_child)(int node); | ||
173 | int (*no_proplen)(int node, const char *name); | ||
174 | int (*no_getprop)(int node, const char *name, char *val); | ||
175 | int (*no_setprop)(int node, const char *name, char *val, int len); | ||
176 | char * (*no_nextprop)(int node, char *name); | ||
177 | }; | ||
178 | |||
179 | /* More fun PROM structures for device probing. */ | ||
180 | #define PROMREG_MAX 16 | ||
181 | #define PROMVADDR_MAX 16 | ||
182 | #define PROMINTR_MAX 15 | ||
183 | |||
184 | struct linux_prom_registers { | ||
185 | unsigned int which_io; /* is this in OBIO space? */ | ||
186 | unsigned int phys_addr; /* The physical address of this register */ | ||
187 | unsigned int reg_size; /* How many bytes does this register take up? */ | ||
188 | }; | ||
189 | |||
190 | struct linux_prom_irqs { | ||
191 | int pri; /* IRQ priority */ | ||
192 | int vector; /* This is foobar, what does it do? */ | ||
193 | }; | ||
194 | |||
195 | /* Element of the "ranges" vector */ | ||
196 | struct linux_prom_ranges { | ||
197 | unsigned int ot_child_space; | ||
198 | unsigned int ot_child_base; /* Bus feels this */ | ||
199 | unsigned int ot_parent_space; | ||
200 | unsigned int ot_parent_base; /* CPU looks from here */ | ||
201 | unsigned int or_size; | ||
202 | }; | ||
203 | |||
204 | /* Ranges and reg properties are a bit different for PCI. */ | ||
205 | struct linux_prom_pci_registers { | ||
206 | /* | ||
207 | * We don't know what information this field contain. | ||
208 | * We guess, PCI device function is in bits 15:8 | ||
209 | * So, ... | ||
210 | */ | ||
211 | unsigned int which_io; /* Let it be which_io */ | ||
212 | |||
213 | unsigned int phys_hi; | ||
214 | unsigned int phys_lo; | ||
215 | |||
216 | unsigned int size_hi; | ||
217 | unsigned int size_lo; | ||
218 | }; | ||
219 | |||
220 | struct linux_prom_pci_ranges { | ||
221 | unsigned int child_phys_hi; /* Only certain bits are encoded here. */ | ||
222 | unsigned int child_phys_mid; | ||
223 | unsigned int child_phys_lo; | ||
224 | |||
225 | unsigned int parent_phys_hi; | ||
226 | unsigned int parent_phys_lo; | ||
227 | |||
228 | unsigned int size_hi; | ||
229 | unsigned int size_lo; | ||
230 | }; | ||
231 | |||
232 | struct linux_prom_pci_assigned_addresses { | ||
233 | unsigned int which_io; | ||
234 | |||
235 | unsigned int phys_hi; | ||
236 | unsigned int phys_lo; | ||
237 | |||
238 | unsigned int size_hi; | ||
239 | unsigned int size_lo; | ||
240 | }; | ||
241 | |||
242 | struct linux_prom_ebus_ranges { | ||
243 | unsigned int child_phys_hi; | ||
244 | unsigned int child_phys_lo; | ||
245 | |||
246 | unsigned int parent_phys_hi; | ||
247 | unsigned int parent_phys_mid; | ||
248 | unsigned int parent_phys_lo; | ||
249 | |||
250 | unsigned int size; | ||
251 | }; | ||
252 | |||
253 | #endif /* !(__ASSEMBLY__) */ | ||
254 | |||
255 | #endif /* !(__SPARC_OPENPROM_H) */ | ||
diff --git a/arch/sparc/include/asm/openprom_64.h b/arch/sparc/include/asm/openprom_64.h deleted file mode 100644 index b69e4a8c9170..000000000000 --- a/arch/sparc/include/asm/openprom_64.h +++ /dev/null | |||
@@ -1,280 +0,0 @@ | |||
1 | #ifndef __SPARC64_OPENPROM_H | ||
2 | #define __SPARC64_OPENPROM_H | ||
3 | |||
4 | /* openprom.h: Prom structures and defines for access to the OPENBOOT | ||
5 | * prom routines and data areas. | ||
6 | * | ||
7 | * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu) | ||
8 | */ | ||
9 | |||
10 | #ifndef __ASSEMBLY__ | ||
11 | /* V0 prom device operations. */ | ||
12 | struct linux_dev_v0_funcs { | ||
13 | int (*v0_devopen)(char *device_str); | ||
14 | int (*v0_devclose)(int dev_desc); | ||
15 | int (*v0_rdblkdev)(int dev_desc, int num_blks, int blk_st, char *buf); | ||
16 | int (*v0_wrblkdev)(int dev_desc, int num_blks, int blk_st, char *buf); | ||
17 | int (*v0_wrnetdev)(int dev_desc, int num_bytes, char *buf); | ||
18 | int (*v0_rdnetdev)(int dev_desc, int num_bytes, char *buf); | ||
19 | int (*v0_rdchardev)(int dev_desc, int num_bytes, int dummy, char *buf); | ||
20 | int (*v0_wrchardev)(int dev_desc, int num_bytes, int dummy, char *buf); | ||
21 | int (*v0_seekdev)(int dev_desc, long logical_offst, int from); | ||
22 | }; | ||
23 | |||
24 | /* V2 and later prom device operations. */ | ||
25 | struct linux_dev_v2_funcs { | ||
26 | int (*v2_inst2pkg)(int d); /* Convert ihandle to phandle */ | ||
27 | char * (*v2_dumb_mem_alloc)(char *va, unsigned sz); | ||
28 | void (*v2_dumb_mem_free)(char *va, unsigned sz); | ||
29 | |||
30 | /* To map devices into virtual I/O space. */ | ||
31 | char * (*v2_dumb_mmap)(char *virta, int which_io, unsigned paddr, unsigned sz); | ||
32 | void (*v2_dumb_munmap)(char *virta, unsigned size); | ||
33 | |||
34 | int (*v2_dev_open)(char *devpath); | ||
35 | void (*v2_dev_close)(int d); | ||
36 | int (*v2_dev_read)(int d, char *buf, int nbytes); | ||
37 | int (*v2_dev_write)(int d, char *buf, int nbytes); | ||
38 | int (*v2_dev_seek)(int d, int hi, int lo); | ||
39 | |||
40 | /* Never issued (multistage load support) */ | ||
41 | void (*v2_wheee2)(void); | ||
42 | void (*v2_wheee3)(void); | ||
43 | }; | ||
44 | |||
45 | struct linux_mlist_v0 { | ||
46 | struct linux_mlist_v0 *theres_more; | ||
47 | unsigned start_adr; | ||
48 | unsigned num_bytes; | ||
49 | }; | ||
50 | |||
51 | struct linux_mem_v0 { | ||
52 | struct linux_mlist_v0 **v0_totphys; | ||
53 | struct linux_mlist_v0 **v0_prommap; | ||
54 | struct linux_mlist_v0 **v0_available; /* What we can use */ | ||
55 | }; | ||
56 | |||
57 | /* Arguments sent to the kernel from the boot prompt. */ | ||
58 | struct linux_arguments_v0 { | ||
59 | char *argv[8]; | ||
60 | char args[100]; | ||
61 | char boot_dev[2]; | ||
62 | int boot_dev_ctrl; | ||
63 | int boot_dev_unit; | ||
64 | int dev_partition; | ||
65 | char *kernel_file_name; | ||
66 | void *aieee1; /* XXX */ | ||
67 | }; | ||
68 | |||
69 | /* V2 and up boot things. */ | ||
70 | struct linux_bootargs_v2 { | ||
71 | char **bootpath; | ||
72 | char **bootargs; | ||
73 | int *fd_stdin; | ||
74 | int *fd_stdout; | ||
75 | }; | ||
76 | |||
77 | /* The top level PROM vector. */ | ||
78 | struct linux_romvec { | ||
79 | /* Version numbers. */ | ||
80 | unsigned int pv_magic_cookie; | ||
81 | unsigned int pv_romvers; | ||
82 | unsigned int pv_plugin_revision; | ||
83 | unsigned int pv_printrev; | ||
84 | |||
85 | /* Version 0 memory descriptors. */ | ||
86 | struct linux_mem_v0 pv_v0mem; | ||
87 | |||
88 | /* Node operations. */ | ||
89 | struct linux_nodeops *pv_nodeops; | ||
90 | |||
91 | char **pv_bootstr; | ||
92 | struct linux_dev_v0_funcs pv_v0devops; | ||
93 | |||
94 | char *pv_stdin; | ||
95 | char *pv_stdout; | ||
96 | #define PROMDEV_KBD 0 /* input from keyboard */ | ||
97 | #define PROMDEV_SCREEN 0 /* output to screen */ | ||
98 | #define PROMDEV_TTYA 1 /* in/out to ttya */ | ||
99 | #define PROMDEV_TTYB 2 /* in/out to ttyb */ | ||
100 | |||
101 | /* Blocking getchar/putchar. NOT REENTRANT! (grr) */ | ||
102 | int (*pv_getchar)(void); | ||
103 | void (*pv_putchar)(int ch); | ||
104 | |||
105 | /* Non-blocking variants. */ | ||
106 | int (*pv_nbgetchar)(void); | ||
107 | int (*pv_nbputchar)(int ch); | ||
108 | |||
109 | void (*pv_putstr)(char *str, int len); | ||
110 | |||
111 | /* Miscellany. */ | ||
112 | void (*pv_reboot)(char *bootstr); | ||
113 | void (*pv_printf)(__const__ char *fmt, ...); | ||
114 | void (*pv_abort)(void); | ||
115 | __volatile__ int *pv_ticks; | ||
116 | void (*pv_halt)(void); | ||
117 | void (**pv_synchook)(void); | ||
118 | |||
119 | /* Evaluate a forth string, not different proto for V0 and V2->up. */ | ||
120 | union { | ||
121 | void (*v0_eval)(int len, char *str); | ||
122 | void (*v2_eval)(char *str); | ||
123 | } pv_fortheval; | ||
124 | |||
125 | struct linux_arguments_v0 **pv_v0bootargs; | ||
126 | |||
127 | /* Get ether address. */ | ||
128 | unsigned int (*pv_enaddr)(int d, char *enaddr); | ||
129 | |||
130 | struct linux_bootargs_v2 pv_v2bootargs; | ||
131 | struct linux_dev_v2_funcs pv_v2devops; | ||
132 | |||
133 | int filler[15]; | ||
134 | |||
135 | /* This one is sun4c/sun4 only. */ | ||
136 | void (*pv_setctxt)(int ctxt, char *va, int pmeg); | ||
137 | |||
138 | /* Prom version 3 Multiprocessor routines. This stuff is crazy. | ||
139 | * No joke. Calling these when there is only one cpu probably | ||
140 | * crashes the machine, have to test this. :-) | ||
141 | */ | ||
142 | |||
143 | /* v3_cpustart() will start the cpu 'whichcpu' in mmu-context | ||
144 | * 'thiscontext' executing at address 'prog_counter' | ||
145 | */ | ||
146 | int (*v3_cpustart)(unsigned int whichcpu, int ctxtbl_ptr, | ||
147 | int thiscontext, char *prog_counter); | ||
148 | |||
149 | /* v3_cpustop() will cause cpu 'whichcpu' to stop executing | ||
150 | * until a resume cpu call is made. | ||
151 | */ | ||
152 | int (*v3_cpustop)(unsigned int whichcpu); | ||
153 | |||
154 | /* v3_cpuidle() will idle cpu 'whichcpu' until a stop or | ||
155 | * resume cpu call is made. | ||
156 | */ | ||
157 | int (*v3_cpuidle)(unsigned int whichcpu); | ||
158 | |||
159 | /* v3_cpuresume() will resume processor 'whichcpu' executing | ||
160 | * starting with whatever 'pc' and 'npc' were left at the | ||
161 | * last 'idle' or 'stop' call. | ||
162 | */ | ||
163 | int (*v3_cpuresume)(unsigned int whichcpu); | ||
164 | }; | ||
165 | |||
166 | /* Routines for traversing the prom device tree. */ | ||
167 | struct linux_nodeops { | ||
168 | int (*no_nextnode)(int node); | ||
169 | int (*no_child)(int node); | ||
170 | int (*no_proplen)(int node, char *name); | ||
171 | int (*no_getprop)(int node, char *name, char *val); | ||
172 | int (*no_setprop)(int node, char *name, char *val, int len); | ||
173 | char * (*no_nextprop)(int node, char *name); | ||
174 | }; | ||
175 | |||
176 | /* More fun PROM structures for device probing. */ | ||
177 | #define PROMREG_MAX 24 | ||
178 | #define PROMVADDR_MAX 16 | ||
179 | #define PROMINTR_MAX 32 | ||
180 | |||
181 | struct linux_prom_registers { | ||
182 | unsigned which_io; /* hi part of physical address */ | ||
183 | unsigned phys_addr; /* The physical address of this register */ | ||
184 | int reg_size; /* How many bytes does this register take up? */ | ||
185 | }; | ||
186 | |||
187 | struct linux_prom64_registers { | ||
188 | unsigned long phys_addr; | ||
189 | unsigned long reg_size; | ||
190 | }; | ||
191 | |||
192 | struct linux_prom_irqs { | ||
193 | int pri; /* IRQ priority */ | ||
194 | int vector; /* This is foobar, what does it do? */ | ||
195 | }; | ||
196 | |||
197 | /* Element of the "ranges" vector */ | ||
198 | struct linux_prom_ranges { | ||
199 | unsigned int ot_child_space; | ||
200 | unsigned int ot_child_base; /* Bus feels this */ | ||
201 | unsigned int ot_parent_space; | ||
202 | unsigned int ot_parent_base; /* CPU looks from here */ | ||
203 | unsigned int or_size; | ||
204 | }; | ||
205 | |||
206 | struct linux_prom64_ranges { | ||
207 | unsigned long ot_child_base; /* Bus feels this */ | ||
208 | unsigned long ot_parent_base; /* CPU looks from here */ | ||
209 | unsigned long or_size; | ||
210 | }; | ||
211 | |||
212 | /* Ranges and reg properties are a bit different for PCI. */ | ||
213 | struct linux_prom_pci_registers { | ||
214 | unsigned int phys_hi; | ||
215 | unsigned int phys_mid; | ||
216 | unsigned int phys_lo; | ||
217 | |||
218 | unsigned int size_hi; | ||
219 | unsigned int size_lo; | ||
220 | }; | ||
221 | |||
222 | struct linux_prom_pci_ranges { | ||
223 | unsigned int child_phys_hi; /* Only certain bits are encoded here. */ | ||
224 | unsigned int child_phys_mid; | ||
225 | unsigned int child_phys_lo; | ||
226 | |||
227 | unsigned int parent_phys_hi; | ||
228 | unsigned int parent_phys_lo; | ||
229 | |||
230 | unsigned int size_hi; | ||
231 | unsigned int size_lo; | ||
232 | }; | ||
233 | |||
234 | struct linux_prom_pci_intmap { | ||
235 | unsigned int phys_hi; | ||
236 | unsigned int phys_mid; | ||
237 | unsigned int phys_lo; | ||
238 | |||
239 | unsigned int interrupt; | ||
240 | |||
241 | int cnode; | ||
242 | unsigned int cinterrupt; | ||
243 | }; | ||
244 | |||
245 | struct linux_prom_pci_intmask { | ||
246 | unsigned int phys_hi; | ||
247 | unsigned int phys_mid; | ||
248 | unsigned int phys_lo; | ||
249 | unsigned int interrupt; | ||
250 | }; | ||
251 | |||
252 | struct linux_prom_ebus_ranges { | ||
253 | unsigned int child_phys_hi; | ||
254 | unsigned int child_phys_lo; | ||
255 | |||
256 | unsigned int parent_phys_hi; | ||
257 | unsigned int parent_phys_mid; | ||
258 | unsigned int parent_phys_lo; | ||
259 | |||
260 | unsigned int size; | ||
261 | }; | ||
262 | |||
263 | struct linux_prom_ebus_intmap { | ||
264 | unsigned int phys_hi; | ||
265 | unsigned int phys_lo; | ||
266 | |||
267 | unsigned int interrupt; | ||
268 | |||
269 | int cnode; | ||
270 | unsigned int cinterrupt; | ||
271 | }; | ||
272 | |||
273 | struct linux_prom_ebus_intmask { | ||
274 | unsigned int phys_hi; | ||
275 | unsigned int phys_lo; | ||
276 | unsigned int interrupt; | ||
277 | }; | ||
278 | #endif /* !(__ASSEMBLY__) */ | ||
279 | |||
280 | #endif /* !(__SPARC64_OPENPROM_H) */ | ||
diff --git a/arch/sparc/include/asm/posix_types.h b/arch/sparc/include/asm/posix_types.h index 03a0e091a884..98d6ebb922fb 100644 --- a/arch/sparc/include/asm/posix_types.h +++ b/arch/sparc/include/asm/posix_types.h | |||
@@ -1,8 +1,155 @@ | |||
1 | #ifndef ___ASM_SPARC_POSIX_TYPES_H | 1 | /* |
2 | #define ___ASM_SPARC_POSIX_TYPES_H | 2 | * This file is generally used by user-level software, so you need to |
3 | * be a little careful about namespace pollution etc. Also, we cannot | ||
4 | * assume GCC is being used. | ||
5 | */ | ||
6 | |||
7 | #ifndef __SPARC_POSIX_TYPES_H | ||
8 | #define __SPARC_POSIX_TYPES_H | ||
9 | |||
3 | #if defined(__sparc__) && defined(__arch64__) | 10 | #if defined(__sparc__) && defined(__arch64__) |
4 | #include <asm/posix_types_64.h> | 11 | /* sparc 64 bit */ |
12 | typedef unsigned long __kernel_size_t; | ||
13 | typedef long __kernel_ssize_t; | ||
14 | typedef long __kernel_ptrdiff_t; | ||
15 | typedef long __kernel_time_t; | ||
16 | typedef long __kernel_clock_t; | ||
17 | typedef int __kernel_pid_t; | ||
18 | typedef int __kernel_ipc_pid_t; | ||
19 | typedef unsigned int __kernel_uid_t; | ||
20 | typedef unsigned int __kernel_gid_t; | ||
21 | typedef unsigned long __kernel_ino_t; | ||
22 | typedef unsigned int __kernel_mode_t; | ||
23 | typedef unsigned short __kernel_umode_t; | ||
24 | typedef unsigned int __kernel_nlink_t; | ||
25 | typedef int __kernel_daddr_t; | ||
26 | typedef long __kernel_off_t; | ||
27 | typedef char * __kernel_caddr_t; | ||
28 | typedef unsigned short __kernel_uid16_t; | ||
29 | typedef unsigned short __kernel_gid16_t; | ||
30 | typedef int __kernel_clockid_t; | ||
31 | typedef int __kernel_timer_t; | ||
32 | |||
33 | typedef unsigned short __kernel_old_uid_t; | ||
34 | typedef unsigned short __kernel_old_gid_t; | ||
35 | typedef __kernel_uid_t __kernel_uid32_t; | ||
36 | typedef __kernel_gid_t __kernel_gid32_t; | ||
37 | |||
38 | typedef unsigned int __kernel_old_dev_t; | ||
39 | |||
40 | /* Note this piece of asymmetry from the v9 ABI. */ | ||
41 | typedef int __kernel_suseconds_t; | ||
42 | |||
5 | #else | 43 | #else |
6 | #include <asm/posix_types_32.h> | 44 | /* sparc 32 bit */ |
7 | #endif | 45 | |
46 | typedef unsigned int __kernel_size_t; | ||
47 | typedef int __kernel_ssize_t; | ||
48 | typedef long int __kernel_ptrdiff_t; | ||
49 | typedef long __kernel_time_t; | ||
50 | typedef long __kernel_suseconds_t; | ||
51 | typedef long __kernel_clock_t; | ||
52 | typedef int __kernel_pid_t; | ||
53 | typedef unsigned short __kernel_ipc_pid_t; | ||
54 | typedef unsigned short __kernel_uid_t; | ||
55 | typedef unsigned short __kernel_gid_t; | ||
56 | typedef unsigned long __kernel_ino_t; | ||
57 | typedef unsigned short __kernel_mode_t; | ||
58 | typedef unsigned short __kernel_umode_t; | ||
59 | typedef short __kernel_nlink_t; | ||
60 | typedef long __kernel_daddr_t; | ||
61 | typedef long __kernel_off_t; | ||
62 | typedef char * __kernel_caddr_t; | ||
63 | typedef unsigned short __kernel_uid16_t; | ||
64 | typedef unsigned short __kernel_gid16_t; | ||
65 | typedef unsigned int __kernel_uid32_t; | ||
66 | typedef unsigned int __kernel_gid32_t; | ||
67 | typedef unsigned short __kernel_old_uid_t; | ||
68 | typedef unsigned short __kernel_old_gid_t; | ||
69 | typedef unsigned short __kernel_old_dev_t; | ||
70 | typedef int __kernel_clockid_t; | ||
71 | typedef int __kernel_timer_t; | ||
72 | |||
73 | #endif /* defined(__sparc__) && defined(__arch64__) */ | ||
74 | |||
75 | #ifdef __GNUC__ | ||
76 | typedef long long __kernel_loff_t; | ||
8 | #endif | 77 | #endif |
78 | |||
79 | typedef struct { | ||
80 | int val[2]; | ||
81 | } __kernel_fsid_t; | ||
82 | |||
83 | #ifdef __KERNEL__ | ||
84 | |||
85 | #undef __FD_SET | ||
86 | static inline void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp) | ||
87 | { | ||
88 | unsigned long _tmp = fd / __NFDBITS; | ||
89 | unsigned long _rem = fd % __NFDBITS; | ||
90 | fdsetp->fds_bits[_tmp] |= (1UL<<_rem); | ||
91 | } | ||
92 | |||
93 | #undef __FD_CLR | ||
94 | static inline void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp) | ||
95 | { | ||
96 | unsigned long _tmp = fd / __NFDBITS; | ||
97 | unsigned long _rem = fd % __NFDBITS; | ||
98 | fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem); | ||
99 | } | ||
100 | |||
101 | #undef __FD_ISSET | ||
102 | static inline int __FD_ISSET(unsigned long fd, __const__ __kernel_fd_set *p) | ||
103 | { | ||
104 | unsigned long _tmp = fd / __NFDBITS; | ||
105 | unsigned long _rem = fd % __NFDBITS; | ||
106 | return (p->fds_bits[_tmp] & (1UL<<_rem)) != 0; | ||
107 | } | ||
108 | |||
109 | /* | ||
110 | * This will unroll the loop for the normal constant cases (8 or 32 longs, | ||
111 | * for 256 and 1024-bit fd_sets respectively) | ||
112 | */ | ||
113 | #undef __FD_ZERO | ||
114 | static inline void __FD_ZERO(__kernel_fd_set *p) | ||
115 | { | ||
116 | unsigned long *tmp = p->fds_bits; | ||
117 | int i; | ||
118 | |||
119 | if (__builtin_constant_p(__FDSET_LONGS)) { | ||
120 | switch (__FDSET_LONGS) { | ||
121 | case 32: | ||
122 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
123 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
124 | tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0; | ||
125 | tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0; | ||
126 | tmp[16] = 0; tmp[17] = 0; tmp[18] = 0; tmp[19] = 0; | ||
127 | tmp[20] = 0; tmp[21] = 0; tmp[22] = 0; tmp[23] = 0; | ||
128 | tmp[24] = 0; tmp[25] = 0; tmp[26] = 0; tmp[27] = 0; | ||
129 | tmp[28] = 0; tmp[29] = 0; tmp[30] = 0; tmp[31] = 0; | ||
130 | return; | ||
131 | case 16: | ||
132 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
133 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
134 | tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0; | ||
135 | tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0; | ||
136 | return; | ||
137 | case 8: | ||
138 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
139 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
140 | return; | ||
141 | case 4: | ||
142 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
143 | return; | ||
144 | } | ||
145 | } | ||
146 | i = __FDSET_LONGS; | ||
147 | while (i) { | ||
148 | i--; | ||
149 | *tmp = 0; | ||
150 | tmp++; | ||
151 | } | ||
152 | } | ||
153 | |||
154 | #endif /* __KERNEL__ */ | ||
155 | #endif /* __SPARC_POSIX_TYPES_H */ | ||
diff --git a/arch/sparc/include/asm/posix_types_32.h b/arch/sparc/include/asm/posix_types_32.h deleted file mode 100644 index 6bb6eb1ca0f2..000000000000 --- a/arch/sparc/include/asm/posix_types_32.h +++ /dev/null | |||
@@ -1,118 +0,0 @@ | |||
1 | #ifndef __ARCH_SPARC_POSIX_TYPES_H | ||
2 | #define __ARCH_SPARC_POSIX_TYPES_H | ||
3 | |||
4 | /* | ||
5 | * This file is generally used by user-level software, so you need to | ||
6 | * be a little careful about namespace pollution etc. Also, we cannot | ||
7 | * assume GCC is being used. | ||
8 | */ | ||
9 | |||
10 | typedef unsigned int __kernel_size_t; | ||
11 | typedef int __kernel_ssize_t; | ||
12 | typedef long int __kernel_ptrdiff_t; | ||
13 | typedef long __kernel_time_t; | ||
14 | typedef long __kernel_suseconds_t; | ||
15 | typedef long __kernel_clock_t; | ||
16 | typedef int __kernel_pid_t; | ||
17 | typedef unsigned short __kernel_ipc_pid_t; | ||
18 | typedef unsigned short __kernel_uid_t; | ||
19 | typedef unsigned short __kernel_gid_t; | ||
20 | typedef unsigned long __kernel_ino_t; | ||
21 | typedef unsigned short __kernel_mode_t; | ||
22 | typedef unsigned short __kernel_umode_t; | ||
23 | typedef short __kernel_nlink_t; | ||
24 | typedef long __kernel_daddr_t; | ||
25 | typedef long __kernel_off_t; | ||
26 | typedef char * __kernel_caddr_t; | ||
27 | typedef unsigned short __kernel_uid16_t; | ||
28 | typedef unsigned short __kernel_gid16_t; | ||
29 | typedef unsigned int __kernel_uid32_t; | ||
30 | typedef unsigned int __kernel_gid32_t; | ||
31 | typedef unsigned short __kernel_old_uid_t; | ||
32 | typedef unsigned short __kernel_old_gid_t; | ||
33 | typedef unsigned short __kernel_old_dev_t; | ||
34 | typedef int __kernel_clockid_t; | ||
35 | typedef int __kernel_timer_t; | ||
36 | |||
37 | #ifdef __GNUC__ | ||
38 | typedef long long __kernel_loff_t; | ||
39 | #endif | ||
40 | |||
41 | typedef struct { | ||
42 | int val[2]; | ||
43 | } __kernel_fsid_t; | ||
44 | |||
45 | #if defined(__KERNEL__) | ||
46 | |||
47 | #undef __FD_SET | ||
48 | static inline void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp) | ||
49 | { | ||
50 | unsigned long _tmp = fd / __NFDBITS; | ||
51 | unsigned long _rem = fd % __NFDBITS; | ||
52 | fdsetp->fds_bits[_tmp] |= (1UL<<_rem); | ||
53 | } | ||
54 | |||
55 | #undef __FD_CLR | ||
56 | static inline void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp) | ||
57 | { | ||
58 | unsigned long _tmp = fd / __NFDBITS; | ||
59 | unsigned long _rem = fd % __NFDBITS; | ||
60 | fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem); | ||
61 | } | ||
62 | |||
63 | #undef __FD_ISSET | ||
64 | static inline int __FD_ISSET(unsigned long fd, __const__ __kernel_fd_set *p) | ||
65 | { | ||
66 | unsigned long _tmp = fd / __NFDBITS; | ||
67 | unsigned long _rem = fd % __NFDBITS; | ||
68 | return (p->fds_bits[_tmp] & (1UL<<_rem)) != 0; | ||
69 | } | ||
70 | |||
71 | /* | ||
72 | * This will unroll the loop for the normal constant cases (8 or 32 longs, | ||
73 | * for 256 and 1024-bit fd_sets respectively) | ||
74 | */ | ||
75 | #undef __FD_ZERO | ||
76 | static inline void __FD_ZERO(__kernel_fd_set *p) | ||
77 | { | ||
78 | unsigned long *tmp = p->fds_bits; | ||
79 | int i; | ||
80 | |||
81 | if (__builtin_constant_p(__FDSET_LONGS)) { | ||
82 | switch (__FDSET_LONGS) { | ||
83 | case 32: | ||
84 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
85 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
86 | tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0; | ||
87 | tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0; | ||
88 | tmp[16] = 0; tmp[17] = 0; tmp[18] = 0; tmp[19] = 0; | ||
89 | tmp[20] = 0; tmp[21] = 0; tmp[22] = 0; tmp[23] = 0; | ||
90 | tmp[24] = 0; tmp[25] = 0; tmp[26] = 0; tmp[27] = 0; | ||
91 | tmp[28] = 0; tmp[29] = 0; tmp[30] = 0; tmp[31] = 0; | ||
92 | return; | ||
93 | case 16: | ||
94 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
95 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
96 | tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0; | ||
97 | tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0; | ||
98 | return; | ||
99 | case 8: | ||
100 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
101 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
102 | return; | ||
103 | case 4: | ||
104 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
105 | return; | ||
106 | } | ||
107 | } | ||
108 | i = __FDSET_LONGS; | ||
109 | while (i) { | ||
110 | i--; | ||
111 | *tmp = 0; | ||
112 | tmp++; | ||
113 | } | ||
114 | } | ||
115 | |||
116 | #endif /* defined(__KERNEL__) */ | ||
117 | |||
118 | #endif /* !(__ARCH_SPARC_POSIX_TYPES_H) */ | ||
diff --git a/arch/sparc/include/asm/posix_types_64.h b/arch/sparc/include/asm/posix_types_64.h deleted file mode 100644 index ba8f93295763..000000000000 --- a/arch/sparc/include/asm/posix_types_64.h +++ /dev/null | |||
@@ -1,122 +0,0 @@ | |||
1 | #ifndef __ARCH_SPARC64_POSIX_TYPES_H | ||
2 | #define __ARCH_SPARC64_POSIX_TYPES_H | ||
3 | |||
4 | /* | ||
5 | * This file is generally used by user-level software, so you need to | ||
6 | * be a little careful about namespace pollution etc. Also, we cannot | ||
7 | * assume GCC is being used. | ||
8 | */ | ||
9 | |||
10 | typedef unsigned long __kernel_size_t; | ||
11 | typedef long __kernel_ssize_t; | ||
12 | typedef long __kernel_ptrdiff_t; | ||
13 | typedef long __kernel_time_t; | ||
14 | typedef long __kernel_clock_t; | ||
15 | typedef int __kernel_pid_t; | ||
16 | typedef int __kernel_ipc_pid_t; | ||
17 | typedef unsigned int __kernel_uid_t; | ||
18 | typedef unsigned int __kernel_gid_t; | ||
19 | typedef unsigned long __kernel_ino_t; | ||
20 | typedef unsigned int __kernel_mode_t; | ||
21 | typedef unsigned short __kernel_umode_t; | ||
22 | typedef unsigned int __kernel_nlink_t; | ||
23 | typedef int __kernel_daddr_t; | ||
24 | typedef long __kernel_off_t; | ||
25 | typedef char * __kernel_caddr_t; | ||
26 | typedef unsigned short __kernel_uid16_t; | ||
27 | typedef unsigned short __kernel_gid16_t; | ||
28 | typedef int __kernel_clockid_t; | ||
29 | typedef int __kernel_timer_t; | ||
30 | |||
31 | typedef unsigned short __kernel_old_uid_t; | ||
32 | typedef unsigned short __kernel_old_gid_t; | ||
33 | typedef __kernel_uid_t __kernel_uid32_t; | ||
34 | typedef __kernel_gid_t __kernel_gid32_t; | ||
35 | |||
36 | typedef unsigned int __kernel_old_dev_t; | ||
37 | |||
38 | /* Note this piece of asymmetry from the v9 ABI. */ | ||
39 | typedef int __kernel_suseconds_t; | ||
40 | |||
41 | #ifdef __GNUC__ | ||
42 | typedef long long __kernel_loff_t; | ||
43 | #endif | ||
44 | |||
45 | typedef struct { | ||
46 | int val[2]; | ||
47 | } __kernel_fsid_t; | ||
48 | |||
49 | #if defined(__KERNEL__) | ||
50 | |||
51 | #undef __FD_SET | ||
52 | static inline void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp) | ||
53 | { | ||
54 | unsigned long _tmp = fd / __NFDBITS; | ||
55 | unsigned long _rem = fd % __NFDBITS; | ||
56 | fdsetp->fds_bits[_tmp] |= (1UL<<_rem); | ||
57 | } | ||
58 | |||
59 | #undef __FD_CLR | ||
60 | static inline void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp) | ||
61 | { | ||
62 | unsigned long _tmp = fd / __NFDBITS; | ||
63 | unsigned long _rem = fd % __NFDBITS; | ||
64 | fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem); | ||
65 | } | ||
66 | |||
67 | #undef __FD_ISSET | ||
68 | static inline int __FD_ISSET(unsigned long fd, __const__ __kernel_fd_set *p) | ||
69 | { | ||
70 | unsigned long _tmp = fd / __NFDBITS; | ||
71 | unsigned long _rem = fd % __NFDBITS; | ||
72 | return (p->fds_bits[_tmp] & (1UL<<_rem)) != 0; | ||
73 | } | ||
74 | |||
75 | /* | ||
76 | * This will unroll the loop for the normal constant cases (8 or 32 longs, | ||
77 | * for 256 and 1024-bit fd_sets respectively) | ||
78 | */ | ||
79 | #undef __FD_ZERO | ||
80 | static inline void __FD_ZERO(__kernel_fd_set *p) | ||
81 | { | ||
82 | unsigned long *tmp = p->fds_bits; | ||
83 | int i; | ||
84 | |||
85 | if (__builtin_constant_p(__FDSET_LONGS)) { | ||
86 | switch (__FDSET_LONGS) { | ||
87 | case 32: | ||
88 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
89 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
90 | tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0; | ||
91 | tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0; | ||
92 | tmp[16] = 0; tmp[17] = 0; tmp[18] = 0; tmp[19] = 0; | ||
93 | tmp[20] = 0; tmp[21] = 0; tmp[22] = 0; tmp[23] = 0; | ||
94 | tmp[24] = 0; tmp[25] = 0; tmp[26] = 0; tmp[27] = 0; | ||
95 | tmp[28] = 0; tmp[29] = 0; tmp[30] = 0; tmp[31] = 0; | ||
96 | return; | ||
97 | case 16: | ||
98 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
99 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
100 | tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0; | ||
101 | tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0; | ||
102 | return; | ||
103 | case 8: | ||
104 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
105 | tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0; | ||
106 | return; | ||
107 | case 4: | ||
108 | tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0; | ||
109 | return; | ||
110 | } | ||
111 | } | ||
112 | i = __FDSET_LONGS; | ||
113 | while (i) { | ||
114 | i--; | ||
115 | *tmp = 0; | ||
116 | tmp++; | ||
117 | } | ||
118 | } | ||
119 | |||
120 | #endif /* defined(__KERNEL__) */ | ||
121 | |||
122 | #endif /* !(__ARCH_SPARC64_POSIX_TYPES_H) */ | ||
diff --git a/arch/sparc/include/asm/processor_32.h b/arch/sparc/include/asm/processor_32.h index 2ae67a2e7f3a..09521c6a5edb 100644 --- a/arch/sparc/include/asm/processor_32.h +++ b/arch/sparc/include/asm/processor_32.h | |||
@@ -99,7 +99,7 @@ static inline void start_thread(struct pt_regs * regs, unsigned long pc, | |||
99 | "st\t%%g0, [%0 + %3 + 0x3c]" | 99 | "st\t%%g0, [%0 + %3 + 0x3c]" |
100 | : /* no outputs */ | 100 | : /* no outputs */ |
101 | : "r" (regs), | 101 | : "r" (regs), |
102 | "r" (sp - sizeof(struct reg_window)), | 102 | "r" (sp - sizeof(struct reg_window32)), |
103 | "r" (zero), | 103 | "r" (zero), |
104 | "i" ((const unsigned long)(&((struct pt_regs *)0)->u_regs[0])) | 104 | "i" ((const unsigned long)(&((struct pt_regs *)0)->u_regs[0])) |
105 | : "memory"); | 105 | : "memory"); |
diff --git a/arch/sparc/include/asm/ptrace.h b/arch/sparc/include/asm/ptrace.h index 6dcbe2eed2e2..30b0b797dc0c 100644 --- a/arch/sparc/include/asm/ptrace.h +++ b/arch/sparc/include/asm/ptrace.h | |||
@@ -1,8 +1,448 @@ | |||
1 | #ifndef ___ASM_SPARC_PTRACE_H | 1 | #ifndef __SPARC_PTRACE_H |
2 | #define ___ASM_SPARC_PTRACE_H | 2 | #define __SPARC_PTRACE_H |
3 | |||
3 | #if defined(__sparc__) && defined(__arch64__) | 4 | #if defined(__sparc__) && defined(__arch64__) |
4 | #include <asm/ptrace_64.h> | 5 | /* 64 bit sparc */ |
6 | #include <asm/pstate.h> | ||
7 | |||
8 | /* This struct defines the way the registers are stored on the | ||
9 | * stack during a system call and basically all traps. | ||
10 | */ | ||
11 | |||
12 | /* This magic value must have the low 9 bits clear, | ||
13 | * as that is where we encode the %tt value, see below. | ||
14 | */ | ||
15 | #define PT_REGS_MAGIC 0x57ac6c00 | ||
16 | |||
17 | #ifndef __ASSEMBLY__ | ||
18 | |||
19 | #include <linux/types.h> | ||
20 | |||
21 | struct pt_regs { | ||
22 | unsigned long u_regs[16]; /* globals and ins */ | ||
23 | unsigned long tstate; | ||
24 | unsigned long tpc; | ||
25 | unsigned long tnpc; | ||
26 | unsigned int y; | ||
27 | |||
28 | /* We encode a magic number, PT_REGS_MAGIC, along | ||
29 | * with the %tt (trap type) register value at trap | ||
30 | * entry time. The magic number allows us to identify | ||
31 | * accurately a trap stack frame in the stack | ||
32 | * unwinder, and the %tt value allows us to test | ||
33 | * things like "in a system call" etc. for an arbitray | ||
34 | * process. | ||
35 | * | ||
36 | * The PT_REGS_MAGIC is choosen such that it can be | ||
37 | * loaded completely using just a sethi instruction. | ||
38 | */ | ||
39 | unsigned int magic; | ||
40 | }; | ||
41 | |||
42 | struct pt_regs32 { | ||
43 | unsigned int psr; | ||
44 | unsigned int pc; | ||
45 | unsigned int npc; | ||
46 | unsigned int y; | ||
47 | unsigned int u_regs[16]; /* globals and ins */ | ||
48 | }; | ||
49 | |||
50 | /* A V9 register window */ | ||
51 | struct reg_window { | ||
52 | unsigned long locals[8]; | ||
53 | unsigned long ins[8]; | ||
54 | }; | ||
55 | |||
56 | /* A 32-bit register window. */ | ||
57 | struct reg_window32 { | ||
58 | unsigned int locals[8]; | ||
59 | unsigned int ins[8]; | ||
60 | }; | ||
61 | |||
62 | /* A V9 Sparc stack frame */ | ||
63 | struct sparc_stackf { | ||
64 | unsigned long locals[8]; | ||
65 | unsigned long ins[6]; | ||
66 | struct sparc_stackf *fp; | ||
67 | unsigned long callers_pc; | ||
68 | char *structptr; | ||
69 | unsigned long xargs[6]; | ||
70 | unsigned long xxargs[1]; | ||
71 | }; | ||
72 | |||
73 | /* A 32-bit Sparc stack frame */ | ||
74 | struct sparc_stackf32 { | ||
75 | unsigned int locals[8]; | ||
76 | unsigned int ins[6]; | ||
77 | unsigned int fp; | ||
78 | unsigned int callers_pc; | ||
79 | unsigned int structptr; | ||
80 | unsigned int xargs[6]; | ||
81 | unsigned int xxargs[1]; | ||
82 | }; | ||
83 | |||
84 | struct sparc_trapf { | ||
85 | unsigned long locals[8]; | ||
86 | unsigned long ins[8]; | ||
87 | unsigned long _unused; | ||
88 | struct pt_regs *regs; | ||
89 | }; | ||
90 | #endif /* (!__ASSEMBLY__) */ | ||
5 | #else | 91 | #else |
6 | #include <asm/ptrace_32.h> | 92 | /* 32 bit sparc */ |
93 | |||
94 | #include <asm/psr.h> | ||
95 | |||
96 | /* This struct defines the way the registers are stored on the | ||
97 | * stack during a system call and basically all traps. | ||
98 | */ | ||
99 | #ifndef __ASSEMBLY__ | ||
100 | |||
101 | struct pt_regs { | ||
102 | unsigned long psr; | ||
103 | unsigned long pc; | ||
104 | unsigned long npc; | ||
105 | unsigned long y; | ||
106 | unsigned long u_regs[16]; /* globals and ins */ | ||
107 | }; | ||
108 | |||
109 | /* A 32-bit register window. */ | ||
110 | struct reg_window32 { | ||
111 | unsigned long locals[8]; | ||
112 | unsigned long ins[8]; | ||
113 | }; | ||
114 | |||
115 | /* A Sparc stack frame */ | ||
116 | struct sparc_stackf { | ||
117 | unsigned long locals[8]; | ||
118 | unsigned long ins[6]; | ||
119 | struct sparc_stackf *fp; | ||
120 | unsigned long callers_pc; | ||
121 | char *structptr; | ||
122 | unsigned long xargs[6]; | ||
123 | unsigned long xxargs[1]; | ||
124 | }; | ||
125 | #endif /* (!__ASSEMBLY__) */ | ||
126 | |||
127 | #endif /* (defined(__sparc__) && defined(__arch64__))*/ | ||
128 | |||
129 | #ifndef __ASSEMBLY__ | ||
130 | |||
131 | #define TRACEREG_SZ sizeof(struct pt_regs) | ||
132 | #define STACKFRAME_SZ sizeof(struct sparc_stackf) | ||
133 | |||
134 | #define TRACEREG32_SZ sizeof(struct pt_regs32) | ||
135 | #define STACKFRAME32_SZ sizeof(struct sparc_stackf32) | ||
136 | |||
137 | #endif /* (!__ASSEMBLY__) */ | ||
138 | |||
139 | #define UREG_G0 0 | ||
140 | #define UREG_G1 1 | ||
141 | #define UREG_G2 2 | ||
142 | #define UREG_G3 3 | ||
143 | #define UREG_G4 4 | ||
144 | #define UREG_G5 5 | ||
145 | #define UREG_G6 6 | ||
146 | #define UREG_G7 7 | ||
147 | #define UREG_I0 8 | ||
148 | #define UREG_I1 9 | ||
149 | #define UREG_I2 10 | ||
150 | #define UREG_I3 11 | ||
151 | #define UREG_I4 12 | ||
152 | #define UREG_I5 13 | ||
153 | #define UREG_I6 14 | ||
154 | #define UREG_I7 15 | ||
155 | #define UREG_FP UREG_I6 | ||
156 | #define UREG_RETPC UREG_I7 | ||
157 | |||
158 | #if defined(__sparc__) && defined(__arch64__) | ||
159 | /* 64 bit sparc */ | ||
160 | |||
161 | #ifndef __ASSEMBLY__ | ||
162 | |||
163 | #ifdef __KERNEL__ | ||
164 | |||
165 | #include <linux/threads.h> | ||
166 | #include <asm/system.h> | ||
167 | |||
168 | static inline int pt_regs_trap_type(struct pt_regs *regs) | ||
169 | { | ||
170 | return regs->magic & 0x1ff; | ||
171 | } | ||
172 | |||
173 | static inline bool pt_regs_is_syscall(struct pt_regs *regs) | ||
174 | { | ||
175 | return (regs->tstate & TSTATE_SYSCALL); | ||
176 | } | ||
177 | |||
178 | static inline bool pt_regs_clear_syscall(struct pt_regs *regs) | ||
179 | { | ||
180 | return (regs->tstate &= ~TSTATE_SYSCALL); | ||
181 | } | ||
182 | |||
183 | #define arch_ptrace_stop_needed(exit_code, info) \ | ||
184 | ({ flush_user_windows(); \ | ||
185 | get_thread_wsaved() != 0; \ | ||
186 | }) | ||
187 | |||
188 | #define arch_ptrace_stop(exit_code, info) \ | ||
189 | synchronize_user_stack() | ||
190 | |||
191 | struct global_reg_snapshot { | ||
192 | unsigned long tstate; | ||
193 | unsigned long tpc; | ||
194 | unsigned long tnpc; | ||
195 | unsigned long o7; | ||
196 | unsigned long i7; | ||
197 | unsigned long rpc; | ||
198 | struct thread_info *thread; | ||
199 | unsigned long pad1; | ||
200 | }; | ||
201 | extern struct global_reg_snapshot global_reg_snapshot[NR_CPUS]; | ||
202 | |||
203 | #define force_successful_syscall_return() \ | ||
204 | do { current_thread_info()->syscall_noerror = 1; \ | ||
205 | } while (0) | ||
206 | #define user_mode(regs) (!((regs)->tstate & TSTATE_PRIV)) | ||
207 | #define instruction_pointer(regs) ((regs)->tpc) | ||
208 | #define user_stack_pointer(regs) ((regs)->u_regs[UREG_FP]) | ||
209 | #define regs_return_value(regs) ((regs)->u_regs[UREG_I0]) | ||
210 | #ifdef CONFIG_SMP | ||
211 | extern unsigned long profile_pc(struct pt_regs *); | ||
212 | #else | ||
213 | #define profile_pc(regs) instruction_pointer(regs) | ||
7 | #endif | 214 | #endif |
215 | extern void show_regs(struct pt_regs *); | ||
216 | #endif /* (__KERNEL__) */ | ||
217 | |||
218 | #else /* __ASSEMBLY__ */ | ||
219 | /* For assembly code. */ | ||
220 | #define TRACEREG_SZ 0xa0 | ||
221 | #define STACKFRAME_SZ 0xc0 | ||
222 | |||
223 | #define TRACEREG32_SZ 0x50 | ||
224 | #define STACKFRAME32_SZ 0x60 | ||
225 | #endif /* __ASSEMBLY__ */ | ||
226 | |||
227 | #else /* (defined(__sparc__) && defined(__arch64__)) */ | ||
228 | |||
229 | /* 32 bit sparc */ | ||
230 | |||
231 | #ifndef __ASSEMBLY__ | ||
232 | |||
233 | #ifdef __KERNEL__ | ||
234 | |||
235 | #include <asm/system.h> | ||
236 | |||
237 | static inline bool pt_regs_is_syscall(struct pt_regs *regs) | ||
238 | { | ||
239 | return (regs->psr & PSR_SYSCALL); | ||
240 | } | ||
241 | |||
242 | static inline bool pt_regs_clear_syscall(struct pt_regs *regs) | ||
243 | { | ||
244 | return (regs->psr &= ~PSR_SYSCALL); | ||
245 | } | ||
246 | |||
247 | #define arch_ptrace_stop_needed(exit_code, info) \ | ||
248 | ({ flush_user_windows(); \ | ||
249 | current_thread_info()->w_saved != 0; \ | ||
250 | }) | ||
251 | |||
252 | #define arch_ptrace_stop(exit_code, info) \ | ||
253 | synchronize_user_stack() | ||
254 | |||
255 | #define user_mode(regs) (!((regs)->psr & PSR_PS)) | ||
256 | #define instruction_pointer(regs) ((regs)->pc) | ||
257 | #define user_stack_pointer(regs) ((regs)->u_regs[UREG_FP]) | ||
258 | unsigned long profile_pc(struct pt_regs *); | ||
259 | extern void show_regs(struct pt_regs *); | ||
260 | #endif /* (__KERNEL__) */ | ||
261 | |||
262 | #else /* (!__ASSEMBLY__) */ | ||
263 | /* For assembly code. */ | ||
264 | #define TRACEREG_SZ 0x50 | ||
265 | #define STACKFRAME_SZ 0x60 | ||
266 | #endif /* (!__ASSEMBLY__) */ | ||
267 | |||
268 | #endif /* (defined(__sparc__) && defined(__arch64__)) */ | ||
269 | |||
270 | #ifdef __KERNEL__ | ||
271 | #define STACK_BIAS 2047 | ||
8 | #endif | 272 | #endif |
273 | |||
274 | /* These are for pt_regs. */ | ||
275 | #define PT_V9_G0 0x00 | ||
276 | #define PT_V9_G1 0x08 | ||
277 | #define PT_V9_G2 0x10 | ||
278 | #define PT_V9_G3 0x18 | ||
279 | #define PT_V9_G4 0x20 | ||
280 | #define PT_V9_G5 0x28 | ||
281 | #define PT_V9_G6 0x30 | ||
282 | #define PT_V9_G7 0x38 | ||
283 | #define PT_V9_I0 0x40 | ||
284 | #define PT_V9_I1 0x48 | ||
285 | #define PT_V9_I2 0x50 | ||
286 | #define PT_V9_I3 0x58 | ||
287 | #define PT_V9_I4 0x60 | ||
288 | #define PT_V9_I5 0x68 | ||
289 | #define PT_V9_I6 0x70 | ||
290 | #define PT_V9_FP PT_V9_I6 | ||
291 | #define PT_V9_I7 0x78 | ||
292 | #define PT_V9_TSTATE 0x80 | ||
293 | #define PT_V9_TPC 0x88 | ||
294 | #define PT_V9_TNPC 0x90 | ||
295 | #define PT_V9_Y 0x98 | ||
296 | #define PT_V9_MAGIC 0x9c | ||
297 | #define PT_TSTATE PT_V9_TSTATE | ||
298 | #define PT_TPC PT_V9_TPC | ||
299 | #define PT_TNPC PT_V9_TNPC | ||
300 | |||
301 | /* These for pt_regs32. */ | ||
302 | #define PT_PSR 0x0 | ||
303 | #define PT_PC 0x4 | ||
304 | #define PT_NPC 0x8 | ||
305 | #define PT_Y 0xc | ||
306 | #define PT_G0 0x10 | ||
307 | #define PT_WIM PT_G0 | ||
308 | #define PT_G1 0x14 | ||
309 | #define PT_G2 0x18 | ||
310 | #define PT_G3 0x1c | ||
311 | #define PT_G4 0x20 | ||
312 | #define PT_G5 0x24 | ||
313 | #define PT_G6 0x28 | ||
314 | #define PT_G7 0x2c | ||
315 | #define PT_I0 0x30 | ||
316 | #define PT_I1 0x34 | ||
317 | #define PT_I2 0x38 | ||
318 | #define PT_I3 0x3c | ||
319 | #define PT_I4 0x40 | ||
320 | #define PT_I5 0x44 | ||
321 | #define PT_I6 0x48 | ||
322 | #define PT_FP PT_I6 | ||
323 | #define PT_I7 0x4c | ||
324 | |||
325 | /* Reg_window offsets */ | ||
326 | #define RW_V9_L0 0x00 | ||
327 | #define RW_V9_L1 0x08 | ||
328 | #define RW_V9_L2 0x10 | ||
329 | #define RW_V9_L3 0x18 | ||
330 | #define RW_V9_L4 0x20 | ||
331 | #define RW_V9_L5 0x28 | ||
332 | #define RW_V9_L6 0x30 | ||
333 | #define RW_V9_L7 0x38 | ||
334 | #define RW_V9_I0 0x40 | ||
335 | #define RW_V9_I1 0x48 | ||
336 | #define RW_V9_I2 0x50 | ||
337 | #define RW_V9_I3 0x58 | ||
338 | #define RW_V9_I4 0x60 | ||
339 | #define RW_V9_I5 0x68 | ||
340 | #define RW_V9_I6 0x70 | ||
341 | #define RW_V9_I7 0x78 | ||
342 | |||
343 | #define RW_L0 0x00 | ||
344 | #define RW_L1 0x04 | ||
345 | #define RW_L2 0x08 | ||
346 | #define RW_L3 0x0c | ||
347 | #define RW_L4 0x10 | ||
348 | #define RW_L5 0x14 | ||
349 | #define RW_L6 0x18 | ||
350 | #define RW_L7 0x1c | ||
351 | #define RW_I0 0x20 | ||
352 | #define RW_I1 0x24 | ||
353 | #define RW_I2 0x28 | ||
354 | #define RW_I3 0x2c | ||
355 | #define RW_I4 0x30 | ||
356 | #define RW_I5 0x34 | ||
357 | #define RW_I6 0x38 | ||
358 | #define RW_I7 0x3c | ||
359 | |||
360 | /* Stack_frame offsets */ | ||
361 | #define SF_V9_L0 0x00 | ||
362 | #define SF_V9_L1 0x08 | ||
363 | #define SF_V9_L2 0x10 | ||
364 | #define SF_V9_L3 0x18 | ||
365 | #define SF_V9_L4 0x20 | ||
366 | #define SF_V9_L5 0x28 | ||
367 | #define SF_V9_L6 0x30 | ||
368 | #define SF_V9_L7 0x38 | ||
369 | #define SF_V9_I0 0x40 | ||
370 | #define SF_V9_I1 0x48 | ||
371 | #define SF_V9_I2 0x50 | ||
372 | #define SF_V9_I3 0x58 | ||
373 | #define SF_V9_I4 0x60 | ||
374 | #define SF_V9_I5 0x68 | ||
375 | #define SF_V9_FP 0x70 | ||
376 | #define SF_V9_PC 0x78 | ||
377 | #define SF_V9_RETP 0x80 | ||
378 | #define SF_V9_XARG0 0x88 | ||
379 | #define SF_V9_XARG1 0x90 | ||
380 | #define SF_V9_XARG2 0x98 | ||
381 | #define SF_V9_XARG3 0xa0 | ||
382 | #define SF_V9_XARG4 0xa8 | ||
383 | #define SF_V9_XARG5 0xb0 | ||
384 | #define SF_V9_XXARG 0xb8 | ||
385 | |||
386 | #define SF_L0 0x00 | ||
387 | #define SF_L1 0x04 | ||
388 | #define SF_L2 0x08 | ||
389 | #define SF_L3 0x0c | ||
390 | #define SF_L4 0x10 | ||
391 | #define SF_L5 0x14 | ||
392 | #define SF_L6 0x18 | ||
393 | #define SF_L7 0x1c | ||
394 | #define SF_I0 0x20 | ||
395 | #define SF_I1 0x24 | ||
396 | #define SF_I2 0x28 | ||
397 | #define SF_I3 0x2c | ||
398 | #define SF_I4 0x30 | ||
399 | #define SF_I5 0x34 | ||
400 | #define SF_FP 0x38 | ||
401 | #define SF_PC 0x3c | ||
402 | #define SF_RETP 0x40 | ||
403 | #define SF_XARG0 0x44 | ||
404 | #define SF_XARG1 0x48 | ||
405 | #define SF_XARG2 0x4c | ||
406 | #define SF_XARG3 0x50 | ||
407 | #define SF_XARG4 0x54 | ||
408 | #define SF_XARG5 0x58 | ||
409 | #define SF_XXARG 0x5c | ||
410 | |||
411 | #ifdef __KERNEL__ | ||
412 | |||
413 | /* global_reg_snapshot offsets */ | ||
414 | #define GR_SNAP_TSTATE 0x00 | ||
415 | #define GR_SNAP_TPC 0x08 | ||
416 | #define GR_SNAP_TNPC 0x10 | ||
417 | #define GR_SNAP_O7 0x18 | ||
418 | #define GR_SNAP_I7 0x20 | ||
419 | #define GR_SNAP_RPC 0x28 | ||
420 | #define GR_SNAP_THREAD 0x30 | ||
421 | #define GR_SNAP_PAD1 0x38 | ||
422 | |||
423 | #endif /* __KERNEL__ */ | ||
424 | |||
425 | /* Stuff for the ptrace system call */ | ||
426 | #define PTRACE_SPARC_DETACH 11 | ||
427 | #define PTRACE_GETREGS 12 | ||
428 | #define PTRACE_SETREGS 13 | ||
429 | #define PTRACE_GETFPREGS 14 | ||
430 | #define PTRACE_SETFPREGS 15 | ||
431 | #define PTRACE_READDATA 16 | ||
432 | #define PTRACE_WRITEDATA 17 | ||
433 | #define PTRACE_READTEXT 18 | ||
434 | #define PTRACE_WRITETEXT 19 | ||
435 | #define PTRACE_GETFPAREGS 20 | ||
436 | #define PTRACE_SETFPAREGS 21 | ||
437 | |||
438 | /* There are for debugging 64-bit processes, either from a 32 or 64 bit | ||
439 | * parent. Thus their complements are for debugging 32-bit processes only. | ||
440 | */ | ||
441 | |||
442 | #define PTRACE_GETREGS64 22 | ||
443 | #define PTRACE_SETREGS64 23 | ||
444 | /* PTRACE_SYSCALL is 24 */ | ||
445 | #define PTRACE_GETFPREGS64 25 | ||
446 | #define PTRACE_SETFPREGS64 26 | ||
447 | |||
448 | #endif /* !(__SPARC_PTRACE_H) */ | ||
diff --git a/arch/sparc/include/asm/ptrace_32.h b/arch/sparc/include/asm/ptrace_32.h deleted file mode 100644 index 4cef450167dd..000000000000 --- a/arch/sparc/include/asm/ptrace_32.h +++ /dev/null | |||
@@ -1,186 +0,0 @@ | |||
1 | #ifndef _SPARC_PTRACE_H | ||
2 | #define _SPARC_PTRACE_H | ||
3 | |||
4 | #include <asm/psr.h> | ||
5 | |||
6 | /* This struct defines the way the registers are stored on the | ||
7 | * stack during a system call and basically all traps. | ||
8 | */ | ||
9 | |||
10 | #ifndef __ASSEMBLY__ | ||
11 | |||
12 | #include <linux/types.h> | ||
13 | |||
14 | struct pt_regs { | ||
15 | unsigned long psr; | ||
16 | unsigned long pc; | ||
17 | unsigned long npc; | ||
18 | unsigned long y; | ||
19 | unsigned long u_regs[16]; /* globals and ins */ | ||
20 | }; | ||
21 | |||
22 | #define UREG_G0 0 | ||
23 | #define UREG_G1 1 | ||
24 | #define UREG_G2 2 | ||
25 | #define UREG_G3 3 | ||
26 | #define UREG_G4 4 | ||
27 | #define UREG_G5 5 | ||
28 | #define UREG_G6 6 | ||
29 | #define UREG_G7 7 | ||
30 | #define UREG_I0 8 | ||
31 | #define UREG_I1 9 | ||
32 | #define UREG_I2 10 | ||
33 | #define UREG_I3 11 | ||
34 | #define UREG_I4 12 | ||
35 | #define UREG_I5 13 | ||
36 | #define UREG_I6 14 | ||
37 | #define UREG_I7 15 | ||
38 | #define UREG_WIM UREG_G0 | ||
39 | #define UREG_FADDR UREG_G0 | ||
40 | #define UREG_FP UREG_I6 | ||
41 | #define UREG_RETPC UREG_I7 | ||
42 | |||
43 | /* A register window */ | ||
44 | struct reg_window { | ||
45 | unsigned long locals[8]; | ||
46 | unsigned long ins[8]; | ||
47 | }; | ||
48 | |||
49 | /* A Sparc stack frame */ | ||
50 | struct sparc_stackf { | ||
51 | unsigned long locals[8]; | ||
52 | unsigned long ins[6]; | ||
53 | struct sparc_stackf *fp; | ||
54 | unsigned long callers_pc; | ||
55 | char *structptr; | ||
56 | unsigned long xargs[6]; | ||
57 | unsigned long xxargs[1]; | ||
58 | }; | ||
59 | |||
60 | #define TRACEREG_SZ sizeof(struct pt_regs) | ||
61 | #define STACKFRAME_SZ sizeof(struct sparc_stackf) | ||
62 | |||
63 | #ifdef __KERNEL__ | ||
64 | |||
65 | #include <asm/system.h> | ||
66 | |||
67 | static inline bool pt_regs_is_syscall(struct pt_regs *regs) | ||
68 | { | ||
69 | return (regs->psr & PSR_SYSCALL); | ||
70 | } | ||
71 | |||
72 | static inline bool pt_regs_clear_syscall(struct pt_regs *regs) | ||
73 | { | ||
74 | return (regs->psr &= ~PSR_SYSCALL); | ||
75 | } | ||
76 | |||
77 | #define arch_ptrace_stop_needed(exit_code, info) \ | ||
78 | ({ flush_user_windows(); \ | ||
79 | current_thread_info()->w_saved != 0; \ | ||
80 | }) | ||
81 | |||
82 | #define arch_ptrace_stop(exit_code, info) \ | ||
83 | synchronize_user_stack() | ||
84 | |||
85 | #define user_mode(regs) (!((regs)->psr & PSR_PS)) | ||
86 | #define instruction_pointer(regs) ((regs)->pc) | ||
87 | #define user_stack_pointer(regs) ((regs)->u_regs[UREG_FP]) | ||
88 | unsigned long profile_pc(struct pt_regs *); | ||
89 | extern void show_regs(struct pt_regs *); | ||
90 | #endif | ||
91 | |||
92 | #else /* __ASSEMBLY__ */ | ||
93 | /* For assembly code. */ | ||
94 | #define TRACEREG_SZ 0x50 | ||
95 | #define STACKFRAME_SZ 0x60 | ||
96 | #endif | ||
97 | |||
98 | /* | ||
99 | * The asm-offsets.h is a generated file, so we cannot include it. | ||
100 | * It may be OK for glibc headers, but it's utterly pointless for C code. | ||
101 | * The assembly code using those offsets has to include it explicitly. | ||
102 | */ | ||
103 | /* #include <asm/asm-offsets.h> */ | ||
104 | |||
105 | /* These are for pt_regs. */ | ||
106 | #define PT_PSR 0x0 | ||
107 | #define PT_PC 0x4 | ||
108 | #define PT_NPC 0x8 | ||
109 | #define PT_Y 0xc | ||
110 | #define PT_G0 0x10 | ||
111 | #define PT_WIM PT_G0 | ||
112 | #define PT_G1 0x14 | ||
113 | #define PT_G2 0x18 | ||
114 | #define PT_G3 0x1c | ||
115 | #define PT_G4 0x20 | ||
116 | #define PT_G5 0x24 | ||
117 | #define PT_G6 0x28 | ||
118 | #define PT_G7 0x2c | ||
119 | #define PT_I0 0x30 | ||
120 | #define PT_I1 0x34 | ||
121 | #define PT_I2 0x38 | ||
122 | #define PT_I3 0x3c | ||
123 | #define PT_I4 0x40 | ||
124 | #define PT_I5 0x44 | ||
125 | #define PT_I6 0x48 | ||
126 | #define PT_FP PT_I6 | ||
127 | #define PT_I7 0x4c | ||
128 | |||
129 | /* Reg_window offsets */ | ||
130 | #define RW_L0 0x00 | ||
131 | #define RW_L1 0x04 | ||
132 | #define RW_L2 0x08 | ||
133 | #define RW_L3 0x0c | ||
134 | #define RW_L4 0x10 | ||
135 | #define RW_L5 0x14 | ||
136 | #define RW_L6 0x18 | ||
137 | #define RW_L7 0x1c | ||
138 | #define RW_I0 0x20 | ||
139 | #define RW_I1 0x24 | ||
140 | #define RW_I2 0x28 | ||
141 | #define RW_I3 0x2c | ||
142 | #define RW_I4 0x30 | ||
143 | #define RW_I5 0x34 | ||
144 | #define RW_I6 0x38 | ||
145 | #define RW_I7 0x3c | ||
146 | |||
147 | /* Stack_frame offsets */ | ||
148 | #define SF_L0 0x00 | ||
149 | #define SF_L1 0x04 | ||
150 | #define SF_L2 0x08 | ||
151 | #define SF_L3 0x0c | ||
152 | #define SF_L4 0x10 | ||
153 | #define SF_L5 0x14 | ||
154 | #define SF_L6 0x18 | ||
155 | #define SF_L7 0x1c | ||
156 | #define SF_I0 0x20 | ||
157 | #define SF_I1 0x24 | ||
158 | #define SF_I2 0x28 | ||
159 | #define SF_I3 0x2c | ||
160 | #define SF_I4 0x30 | ||
161 | #define SF_I5 0x34 | ||
162 | #define SF_FP 0x38 | ||
163 | #define SF_PC 0x3c | ||
164 | #define SF_RETP 0x40 | ||
165 | #define SF_XARG0 0x44 | ||
166 | #define SF_XARG1 0x48 | ||
167 | #define SF_XARG2 0x4c | ||
168 | #define SF_XARG3 0x50 | ||
169 | #define SF_XARG4 0x54 | ||
170 | #define SF_XARG5 0x58 | ||
171 | #define SF_XXARG 0x5c | ||
172 | |||
173 | /* Stuff for the ptrace system call */ | ||
174 | #define PTRACE_SPARC_DETACH 11 | ||
175 | #define PTRACE_GETREGS 12 | ||
176 | #define PTRACE_SETREGS 13 | ||
177 | #define PTRACE_GETFPREGS 14 | ||
178 | #define PTRACE_SETFPREGS 15 | ||
179 | #define PTRACE_READDATA 16 | ||
180 | #define PTRACE_WRITEDATA 17 | ||
181 | #define PTRACE_READTEXT 18 | ||
182 | #define PTRACE_WRITETEXT 19 | ||
183 | #define PTRACE_GETFPAREGS 20 | ||
184 | #define PTRACE_SETFPAREGS 21 | ||
185 | |||
186 | #endif /* !(_SPARC_PTRACE_H) */ | ||
diff --git a/arch/sparc/include/asm/ptrace_64.h b/arch/sparc/include/asm/ptrace_64.h deleted file mode 100644 index cd6fbfc20435..000000000000 --- a/arch/sparc/include/asm/ptrace_64.h +++ /dev/null | |||
@@ -1,356 +0,0 @@ | |||
1 | #ifndef _SPARC64_PTRACE_H | ||
2 | #define _SPARC64_PTRACE_H | ||
3 | |||
4 | #include <asm/pstate.h> | ||
5 | |||
6 | /* This struct defines the way the registers are stored on the | ||
7 | * stack during a system call and basically all traps. | ||
8 | */ | ||
9 | |||
10 | /* This magic value must have the low 9 bits clear, | ||
11 | * as that is where we encode the %tt value, see below. | ||
12 | */ | ||
13 | #define PT_REGS_MAGIC 0x57ac6c00 | ||
14 | |||
15 | #ifndef __ASSEMBLY__ | ||
16 | |||
17 | #include <linux/types.h> | ||
18 | |||
19 | struct pt_regs { | ||
20 | unsigned long u_regs[16]; /* globals and ins */ | ||
21 | unsigned long tstate; | ||
22 | unsigned long tpc; | ||
23 | unsigned long tnpc; | ||
24 | unsigned int y; | ||
25 | |||
26 | /* We encode a magic number, PT_REGS_MAGIC, along | ||
27 | * with the %tt (trap type) register value at trap | ||
28 | * entry time. The magic number allows us to identify | ||
29 | * accurately a trap stack frame in the stack | ||
30 | * unwinder, and the %tt value allows us to test | ||
31 | * things like "in a system call" etc. for an arbitray | ||
32 | * process. | ||
33 | * | ||
34 | * The PT_REGS_MAGIC is choosen such that it can be | ||
35 | * loaded completely using just a sethi instruction. | ||
36 | */ | ||
37 | unsigned int magic; | ||
38 | }; | ||
39 | |||
40 | struct pt_regs32 { | ||
41 | unsigned int psr; | ||
42 | unsigned int pc; | ||
43 | unsigned int npc; | ||
44 | unsigned int y; | ||
45 | unsigned int u_regs[16]; /* globals and ins */ | ||
46 | }; | ||
47 | |||
48 | #define UREG_G0 0 | ||
49 | #define UREG_G1 1 | ||
50 | #define UREG_G2 2 | ||
51 | #define UREG_G3 3 | ||
52 | #define UREG_G4 4 | ||
53 | #define UREG_G5 5 | ||
54 | #define UREG_G6 6 | ||
55 | #define UREG_G7 7 | ||
56 | #define UREG_I0 8 | ||
57 | #define UREG_I1 9 | ||
58 | #define UREG_I2 10 | ||
59 | #define UREG_I3 11 | ||
60 | #define UREG_I4 12 | ||
61 | #define UREG_I5 13 | ||
62 | #define UREG_I6 14 | ||
63 | #define UREG_I7 15 | ||
64 | #define UREG_FP UREG_I6 | ||
65 | #define UREG_RETPC UREG_I7 | ||
66 | |||
67 | /* A V9 register window */ | ||
68 | struct reg_window { | ||
69 | unsigned long locals[8]; | ||
70 | unsigned long ins[8]; | ||
71 | }; | ||
72 | |||
73 | /* A 32-bit register window. */ | ||
74 | struct reg_window32 { | ||
75 | unsigned int locals[8]; | ||
76 | unsigned int ins[8]; | ||
77 | }; | ||
78 | |||
79 | /* A V9 Sparc stack frame */ | ||
80 | struct sparc_stackf { | ||
81 | unsigned long locals[8]; | ||
82 | unsigned long ins[6]; | ||
83 | struct sparc_stackf *fp; | ||
84 | unsigned long callers_pc; | ||
85 | char *structptr; | ||
86 | unsigned long xargs[6]; | ||
87 | unsigned long xxargs[1]; | ||
88 | }; | ||
89 | |||
90 | /* A 32-bit Sparc stack frame */ | ||
91 | struct sparc_stackf32 { | ||
92 | unsigned int locals[8]; | ||
93 | unsigned int ins[6]; | ||
94 | unsigned int fp; | ||
95 | unsigned int callers_pc; | ||
96 | unsigned int structptr; | ||
97 | unsigned int xargs[6]; | ||
98 | unsigned int xxargs[1]; | ||
99 | }; | ||
100 | |||
101 | struct sparc_trapf { | ||
102 | unsigned long locals[8]; | ||
103 | unsigned long ins[8]; | ||
104 | unsigned long _unused; | ||
105 | struct pt_regs *regs; | ||
106 | }; | ||
107 | |||
108 | #define TRACEREG_SZ sizeof(struct pt_regs) | ||
109 | #define STACKFRAME_SZ sizeof(struct sparc_stackf) | ||
110 | |||
111 | #define TRACEREG32_SZ sizeof(struct pt_regs32) | ||
112 | #define STACKFRAME32_SZ sizeof(struct sparc_stackf32) | ||
113 | |||
114 | #ifdef __KERNEL__ | ||
115 | |||
116 | #include <linux/threads.h> | ||
117 | #include <asm/system.h> | ||
118 | |||
119 | static inline int pt_regs_trap_type(struct pt_regs *regs) | ||
120 | { | ||
121 | return regs->magic & 0x1ff; | ||
122 | } | ||
123 | |||
124 | static inline bool pt_regs_is_syscall(struct pt_regs *regs) | ||
125 | { | ||
126 | return (regs->tstate & TSTATE_SYSCALL); | ||
127 | } | ||
128 | |||
129 | static inline bool pt_regs_clear_syscall(struct pt_regs *regs) | ||
130 | { | ||
131 | return (regs->tstate &= ~TSTATE_SYSCALL); | ||
132 | } | ||
133 | |||
134 | #define arch_ptrace_stop_needed(exit_code, info) \ | ||
135 | ({ flush_user_windows(); \ | ||
136 | get_thread_wsaved() != 0; \ | ||
137 | }) | ||
138 | |||
139 | #define arch_ptrace_stop(exit_code, info) \ | ||
140 | synchronize_user_stack() | ||
141 | |||
142 | struct global_reg_snapshot { | ||
143 | unsigned long tstate; | ||
144 | unsigned long tpc; | ||
145 | unsigned long tnpc; | ||
146 | unsigned long o7; | ||
147 | unsigned long i7; | ||
148 | unsigned long rpc; | ||
149 | struct thread_info *thread; | ||
150 | unsigned long pad1; | ||
151 | }; | ||
152 | extern struct global_reg_snapshot global_reg_snapshot[NR_CPUS]; | ||
153 | |||
154 | #define force_successful_syscall_return() \ | ||
155 | do { current_thread_info()->syscall_noerror = 1; \ | ||
156 | } while (0) | ||
157 | #define user_mode(regs) (!((regs)->tstate & TSTATE_PRIV)) | ||
158 | #define instruction_pointer(regs) ((regs)->tpc) | ||
159 | #define user_stack_pointer(regs) ((regs)->u_regs[UREG_FP]) | ||
160 | #define regs_return_value(regs) ((regs)->u_regs[UREG_I0]) | ||
161 | #ifdef CONFIG_SMP | ||
162 | extern unsigned long profile_pc(struct pt_regs *); | ||
163 | #else | ||
164 | #define profile_pc(regs) instruction_pointer(regs) | ||
165 | #endif | ||
166 | extern void show_regs(struct pt_regs *); | ||
167 | #endif | ||
168 | |||
169 | #else /* __ASSEMBLY__ */ | ||
170 | /* For assembly code. */ | ||
171 | #define TRACEREG_SZ 0xa0 | ||
172 | #define STACKFRAME_SZ 0xc0 | ||
173 | |||
174 | #define TRACEREG32_SZ 0x50 | ||
175 | #define STACKFRAME32_SZ 0x60 | ||
176 | #endif | ||
177 | |||
178 | #ifdef __KERNEL__ | ||
179 | #define STACK_BIAS 2047 | ||
180 | #endif | ||
181 | |||
182 | /* These are for pt_regs. */ | ||
183 | #define PT_V9_G0 0x00 | ||
184 | #define PT_V9_G1 0x08 | ||
185 | #define PT_V9_G2 0x10 | ||
186 | #define PT_V9_G3 0x18 | ||
187 | #define PT_V9_G4 0x20 | ||
188 | #define PT_V9_G5 0x28 | ||
189 | #define PT_V9_G6 0x30 | ||
190 | #define PT_V9_G7 0x38 | ||
191 | #define PT_V9_I0 0x40 | ||
192 | #define PT_V9_I1 0x48 | ||
193 | #define PT_V9_I2 0x50 | ||
194 | #define PT_V9_I3 0x58 | ||
195 | #define PT_V9_I4 0x60 | ||
196 | #define PT_V9_I5 0x68 | ||
197 | #define PT_V9_I6 0x70 | ||
198 | #define PT_V9_FP PT_V9_I6 | ||
199 | #define PT_V9_I7 0x78 | ||
200 | #define PT_V9_TSTATE 0x80 | ||
201 | #define PT_V9_TPC 0x88 | ||
202 | #define PT_V9_TNPC 0x90 | ||
203 | #define PT_V9_Y 0x98 | ||
204 | #define PT_V9_MAGIC 0x9c | ||
205 | #define PT_TSTATE PT_V9_TSTATE | ||
206 | #define PT_TPC PT_V9_TPC | ||
207 | #define PT_TNPC PT_V9_TNPC | ||
208 | |||
209 | /* These for pt_regs32. */ | ||
210 | #define PT_PSR 0x0 | ||
211 | #define PT_PC 0x4 | ||
212 | #define PT_NPC 0x8 | ||
213 | #define PT_Y 0xc | ||
214 | #define PT_G0 0x10 | ||
215 | #define PT_WIM PT_G0 | ||
216 | #define PT_G1 0x14 | ||
217 | #define PT_G2 0x18 | ||
218 | #define PT_G3 0x1c | ||
219 | #define PT_G4 0x20 | ||
220 | #define PT_G5 0x24 | ||
221 | #define PT_G6 0x28 | ||
222 | #define PT_G7 0x2c | ||
223 | #define PT_I0 0x30 | ||
224 | #define PT_I1 0x34 | ||
225 | #define PT_I2 0x38 | ||
226 | #define PT_I3 0x3c | ||
227 | #define PT_I4 0x40 | ||
228 | #define PT_I5 0x44 | ||
229 | #define PT_I6 0x48 | ||
230 | #define PT_FP PT_I6 | ||
231 | #define PT_I7 0x4c | ||
232 | |||
233 | /* Reg_window offsets */ | ||
234 | #define RW_V9_L0 0x00 | ||
235 | #define RW_V9_L1 0x08 | ||
236 | #define RW_V9_L2 0x10 | ||
237 | #define RW_V9_L3 0x18 | ||
238 | #define RW_V9_L4 0x20 | ||
239 | #define RW_V9_L5 0x28 | ||
240 | #define RW_V9_L6 0x30 | ||
241 | #define RW_V9_L7 0x38 | ||
242 | #define RW_V9_I0 0x40 | ||
243 | #define RW_V9_I1 0x48 | ||
244 | #define RW_V9_I2 0x50 | ||
245 | #define RW_V9_I3 0x58 | ||
246 | #define RW_V9_I4 0x60 | ||
247 | #define RW_V9_I5 0x68 | ||
248 | #define RW_V9_I6 0x70 | ||
249 | #define RW_V9_I7 0x78 | ||
250 | |||
251 | #define RW_L0 0x00 | ||
252 | #define RW_L1 0x04 | ||
253 | #define RW_L2 0x08 | ||
254 | #define RW_L3 0x0c | ||
255 | #define RW_L4 0x10 | ||
256 | #define RW_L5 0x14 | ||
257 | #define RW_L6 0x18 | ||
258 | #define RW_L7 0x1c | ||
259 | #define RW_I0 0x20 | ||
260 | #define RW_I1 0x24 | ||
261 | #define RW_I2 0x28 | ||
262 | #define RW_I3 0x2c | ||
263 | #define RW_I4 0x30 | ||
264 | #define RW_I5 0x34 | ||
265 | #define RW_I6 0x38 | ||
266 | #define RW_I7 0x3c | ||
267 | |||
268 | /* Stack_frame offsets */ | ||
269 | #define SF_V9_L0 0x00 | ||
270 | #define SF_V9_L1 0x08 | ||
271 | #define SF_V9_L2 0x10 | ||
272 | #define SF_V9_L3 0x18 | ||
273 | #define SF_V9_L4 0x20 | ||
274 | #define SF_V9_L5 0x28 | ||
275 | #define SF_V9_L6 0x30 | ||
276 | #define SF_V9_L7 0x38 | ||
277 | #define SF_V9_I0 0x40 | ||
278 | #define SF_V9_I1 0x48 | ||
279 | #define SF_V9_I2 0x50 | ||
280 | #define SF_V9_I3 0x58 | ||
281 | #define SF_V9_I4 0x60 | ||
282 | #define SF_V9_I5 0x68 | ||
283 | #define SF_V9_FP 0x70 | ||
284 | #define SF_V9_PC 0x78 | ||
285 | #define SF_V9_RETP 0x80 | ||
286 | #define SF_V9_XARG0 0x88 | ||
287 | #define SF_V9_XARG1 0x90 | ||
288 | #define SF_V9_XARG2 0x98 | ||
289 | #define SF_V9_XARG3 0xa0 | ||
290 | #define SF_V9_XARG4 0xa8 | ||
291 | #define SF_V9_XARG5 0xb0 | ||
292 | #define SF_V9_XXARG 0xb8 | ||
293 | |||
294 | #define SF_L0 0x00 | ||
295 | #define SF_L1 0x04 | ||
296 | #define SF_L2 0x08 | ||
297 | #define SF_L3 0x0c | ||
298 | #define SF_L4 0x10 | ||
299 | #define SF_L5 0x14 | ||
300 | #define SF_L6 0x18 | ||
301 | #define SF_L7 0x1c | ||
302 | #define SF_I0 0x20 | ||
303 | #define SF_I1 0x24 | ||
304 | #define SF_I2 0x28 | ||
305 | #define SF_I3 0x2c | ||
306 | #define SF_I4 0x30 | ||
307 | #define SF_I5 0x34 | ||
308 | #define SF_FP 0x38 | ||
309 | #define SF_PC 0x3c | ||
310 | #define SF_RETP 0x40 | ||
311 | #define SF_XARG0 0x44 | ||
312 | #define SF_XARG1 0x48 | ||
313 | #define SF_XARG2 0x4c | ||
314 | #define SF_XARG3 0x50 | ||
315 | #define SF_XARG4 0x54 | ||
316 | #define SF_XARG5 0x58 | ||
317 | #define SF_XXARG 0x5c | ||
318 | |||
319 | #ifdef __KERNEL__ | ||
320 | |||
321 | /* global_reg_snapshot offsets */ | ||
322 | #define GR_SNAP_TSTATE 0x00 | ||
323 | #define GR_SNAP_TPC 0x08 | ||
324 | #define GR_SNAP_TNPC 0x10 | ||
325 | #define GR_SNAP_O7 0x18 | ||
326 | #define GR_SNAP_I7 0x20 | ||
327 | #define GR_SNAP_RPC 0x28 | ||
328 | #define GR_SNAP_THREAD 0x30 | ||
329 | #define GR_SNAP_PAD1 0x38 | ||
330 | |||
331 | #endif /* __KERNEL__ */ | ||
332 | |||
333 | /* Stuff for the ptrace system call */ | ||
334 | #define PTRACE_SPARC_DETACH 11 | ||
335 | #define PTRACE_GETREGS 12 | ||
336 | #define PTRACE_SETREGS 13 | ||
337 | #define PTRACE_GETFPREGS 14 | ||
338 | #define PTRACE_SETFPREGS 15 | ||
339 | #define PTRACE_READDATA 16 | ||
340 | #define PTRACE_WRITEDATA 17 | ||
341 | #define PTRACE_READTEXT 18 | ||
342 | #define PTRACE_WRITETEXT 19 | ||
343 | #define PTRACE_GETFPAREGS 20 | ||
344 | #define PTRACE_SETFPAREGS 21 | ||
345 | |||
346 | /* There are for debugging 64-bit processes, either from a 32 or 64 bit | ||
347 | * parent. Thus their complements are for debugging 32-bit processes only. | ||
348 | */ | ||
349 | |||
350 | #define PTRACE_GETREGS64 22 | ||
351 | #define PTRACE_SETREGS64 23 | ||
352 | /* PTRACE_SYSCALL is 24 */ | ||
353 | #define PTRACE_GETFPREGS64 25 | ||
354 | #define PTRACE_SETFPREGS64 26 | ||
355 | |||
356 | #endif /* !(_SPARC64_PTRACE_H) */ | ||
diff --git a/arch/sparc/include/asm/reg.h b/arch/sparc/include/asm/reg.h deleted file mode 100644 index 0c16e19cae4d..000000000000 --- a/arch/sparc/include/asm/reg.h +++ /dev/null | |||
@@ -1,8 +0,0 @@ | |||
1 | #ifndef ___ASM_SPARC_REG_H | ||
2 | #define ___ASM_SPARC_REG_H | ||
3 | #if defined(__sparc__) && defined(__arch64__) | ||
4 | #include <asm/reg_64.h> | ||
5 | #else | ||
6 | #include <asm/reg_32.h> | ||
7 | #endif | ||
8 | #endif | ||
diff --git a/arch/sparc/include/asm/reg_32.h b/arch/sparc/include/asm/reg_32.h deleted file mode 100644 index 1efb056fb3d1..000000000000 --- a/arch/sparc/include/asm/reg_32.h +++ /dev/null | |||
@@ -1,79 +0,0 @@ | |||
1 | /* | ||
2 | * linux/include/asm/reg.h | ||
3 | * Layout of the registers as expected by gdb on the Sparc | ||
4 | * we should replace the user.h definitions with those in | ||
5 | * this file, we don't even use the other | ||
6 | * -miguel | ||
7 | * | ||
8 | * The names of the structures, constants and aliases in this file | ||
9 | * have the same names as the sunos ones, some programs rely on these | ||
10 | * names (gdb for example). | ||
11 | * | ||
12 | */ | ||
13 | |||
14 | #ifndef __SPARC_REG_H | ||
15 | #define __SPARC_REG_H | ||
16 | |||
17 | struct regs { | ||
18 | int r_psr; | ||
19 | #define r_ps r_psr | ||
20 | int r_pc; | ||
21 | int r_npc; | ||
22 | int r_y; | ||
23 | int r_g1; | ||
24 | int r_g2; | ||
25 | int r_g3; | ||
26 | int r_g4; | ||
27 | int r_g5; | ||
28 | int r_g6; | ||
29 | int r_g7; | ||
30 | int r_o0; | ||
31 | int r_o1; | ||
32 | int r_o2; | ||
33 | int r_o3; | ||
34 | int r_o4; | ||
35 | int r_o5; | ||
36 | int r_o6; | ||
37 | int r_o7; | ||
38 | }; | ||
39 | |||
40 | struct fpq { | ||
41 | unsigned long *addr; | ||
42 | unsigned long instr; | ||
43 | }; | ||
44 | |||
45 | struct fq { | ||
46 | union { | ||
47 | double whole; | ||
48 | struct fpq fpq; | ||
49 | } FQu; | ||
50 | }; | ||
51 | |||
52 | #define FPU_REGS_TYPE unsigned int | ||
53 | #define FPU_FSR_TYPE unsigned | ||
54 | |||
55 | struct fp_status { | ||
56 | union { | ||
57 | FPU_REGS_TYPE Fpu_regs[32]; | ||
58 | double Fpu_dregs[16]; | ||
59 | } fpu_fr; | ||
60 | FPU_FSR_TYPE Fpu_fsr; | ||
61 | unsigned Fpu_flags; | ||
62 | unsigned Fpu_extra; | ||
63 | unsigned Fpu_qcnt; | ||
64 | struct fq Fpu_q[16]; | ||
65 | }; | ||
66 | |||
67 | #define fpu_regs f_fpstatus.fpu_fr.Fpu_regs | ||
68 | #define fpu_dregs f_fpstatus.fpu_fr.Fpu_dregs | ||
69 | #define fpu_fsr f_fpstatus.Fpu_fsr | ||
70 | #define fpu_flags f_fpstatus.Fpu_flags | ||
71 | #define fpu_extra f_fpstatus.Fpu_extra | ||
72 | #define fpu_q f_fpstatus.Fpu_q | ||
73 | #define fpu_qcnt f_fpstatus.Fpu_qcnt | ||
74 | |||
75 | struct fpu { | ||
76 | struct fp_status f_fpstatus; | ||
77 | }; | ||
78 | |||
79 | #endif /* __SPARC_REG_H */ | ||
diff --git a/arch/sparc/include/asm/reg_64.h b/arch/sparc/include/asm/reg_64.h deleted file mode 100644 index 6f277d7c7d88..000000000000 --- a/arch/sparc/include/asm/reg_64.h +++ /dev/null | |||
@@ -1,56 +0,0 @@ | |||
1 | /* | ||
2 | * linux/asm/reg.h | ||
3 | * Layout of the registers as expected by gdb on the Sparc | ||
4 | * we should replace the user.h definitions with those in | ||
5 | * this file, we don't even use the other | ||
6 | * -miguel | ||
7 | * | ||
8 | * The names of the structures, constants and aliases in this file | ||
9 | * have the same names as the sunos ones, some programs rely on these | ||
10 | * names (gdb for example). | ||
11 | * | ||
12 | */ | ||
13 | |||
14 | #ifndef __SPARC64_REG_H | ||
15 | #define __SPARC64_REG_H | ||
16 | |||
17 | struct regs { | ||
18 | unsigned long r_g1; | ||
19 | unsigned long r_g2; | ||
20 | unsigned long r_g3; | ||
21 | unsigned long r_g4; | ||
22 | unsigned long r_g5; | ||
23 | unsigned long r_g6; | ||
24 | unsigned long r_g7; | ||
25 | unsigned long r_o0; | ||
26 | unsigned long r_o1; | ||
27 | unsigned long r_o2; | ||
28 | unsigned long r_o3; | ||
29 | unsigned long r_o4; | ||
30 | unsigned long r_o5; | ||
31 | unsigned long r_o6; | ||
32 | unsigned long r_o7; | ||
33 | unsigned long __pad; | ||
34 | unsigned long r_tstate; | ||
35 | unsigned long r_tpc; | ||
36 | unsigned long r_tnpc; | ||
37 | unsigned int r_y; | ||
38 | unsigned int r_fprs; | ||
39 | }; | ||
40 | |||
41 | #define FPU_REGS_TYPE unsigned int | ||
42 | #define FPU_FSR_TYPE unsigned long | ||
43 | |||
44 | struct fp_status { | ||
45 | unsigned long fpu_fr[32]; | ||
46 | unsigned long Fpu_fsr; | ||
47 | }; | ||
48 | |||
49 | struct fpu { | ||
50 | struct fp_status f_fpstatus; | ||
51 | }; | ||
52 | |||
53 | #define fpu_regs f_fpstatus.fpu_fr | ||
54 | #define fpu_fsr f_fpstatus.Fpu_fsr | ||
55 | |||
56 | #endif /* __SPARC64_REG_H */ | ||
diff --git a/arch/sparc/include/asm/sigcontext.h b/arch/sparc/include/asm/sigcontext.h index e92de7e286b5..a1607d180354 100644 --- a/arch/sparc/include/asm/sigcontext.h +++ b/arch/sparc/include/asm/sigcontext.h | |||
@@ -1,8 +1,96 @@ | |||
1 | #ifndef ___ASM_SPARC_SIGCONTEXT_H | 1 | #ifndef __SPARC_SIGCONTEXT_H |
2 | #define ___ASM_SPARC_SIGCONTEXT_H | 2 | #define __SPARC_SIGCONTEXT_H |
3 | #if defined(__sparc__) && defined(__arch64__) | 3 | |
4 | #include <asm/sigcontext_64.h> | 4 | #ifdef __KERNEL__ |
5 | #include <asm/ptrace.h> | ||
6 | |||
7 | #ifndef __ASSEMBLY__ | ||
8 | |||
9 | #define __SUNOS_MAXWIN 31 | ||
10 | |||
11 | /* This is what SunOS does, so shall I unless we use new 32bit signals or rt signals. */ | ||
12 | struct sigcontext32 { | ||
13 | int sigc_onstack; /* state to restore */ | ||
14 | int sigc_mask; /* sigmask to restore */ | ||
15 | int sigc_sp; /* stack pointer */ | ||
16 | int sigc_pc; /* program counter */ | ||
17 | int sigc_npc; /* next program counter */ | ||
18 | int sigc_psr; /* for condition codes etc */ | ||
19 | int sigc_g1; /* User uses these two registers */ | ||
20 | int sigc_o0; /* within the trampoline code. */ | ||
21 | |||
22 | /* Now comes information regarding the users window set | ||
23 | * at the time of the signal. | ||
24 | */ | ||
25 | int sigc_oswins; /* outstanding windows */ | ||
26 | |||
27 | /* stack ptrs for each regwin buf */ | ||
28 | unsigned sigc_spbuf[__SUNOS_MAXWIN]; | ||
29 | |||
30 | /* Windows to restore after signal */ | ||
31 | struct reg_window32 sigc_wbuf[__SUNOS_MAXWIN]; | ||
32 | }; | ||
33 | |||
34 | |||
35 | /* This is what we use for 32bit new non-rt signals. */ | ||
36 | |||
37 | typedef struct { | ||
38 | struct { | ||
39 | unsigned int psr; | ||
40 | unsigned int pc; | ||
41 | unsigned int npc; | ||
42 | unsigned int y; | ||
43 | unsigned int u_regs[16]; /* globals and ins */ | ||
44 | } si_regs; | ||
45 | int si_mask; | ||
46 | } __siginfo32_t; | ||
47 | |||
48 | #ifdef CONFIG_SPARC64 | ||
49 | typedef struct { | ||
50 | unsigned int si_float_regs [64]; | ||
51 | unsigned long si_fsr; | ||
52 | unsigned long si_gsr; | ||
53 | unsigned long si_fprs; | ||
54 | } __siginfo_fpu_t; | ||
55 | |||
56 | /* This is what SunOS doesn't, so we have to write this alone | ||
57 | and do it properly. */ | ||
58 | struct sigcontext { | ||
59 | /* The size of this array has to match SI_MAX_SIZE from siginfo.h */ | ||
60 | char sigc_info[128]; | ||
61 | struct { | ||
62 | unsigned long u_regs[16]; /* globals and ins */ | ||
63 | unsigned long tstate; | ||
64 | unsigned long tpc; | ||
65 | unsigned long tnpc; | ||
66 | unsigned int y; | ||
67 | unsigned int fprs; | ||
68 | } sigc_regs; | ||
69 | __siginfo_fpu_t * sigc_fpu_save; | ||
70 | struct { | ||
71 | void * ss_sp; | ||
72 | int ss_flags; | ||
73 | unsigned long ss_size; | ||
74 | } sigc_stack; | ||
75 | unsigned long sigc_mask; | ||
76 | }; | ||
77 | |||
5 | #else | 78 | #else |
6 | #include <asm/sigcontext_32.h> | 79 | |
7 | #endif | 80 | typedef struct { |
8 | #endif | 81 | unsigned long si_float_regs [32]; |
82 | unsigned long si_fsr; | ||
83 | unsigned long si_fpqdepth; | ||
84 | struct { | ||
85 | unsigned long *insn_addr; | ||
86 | unsigned long insn; | ||
87 | } si_fpqueue [16]; | ||
88 | } __siginfo_fpu_t; | ||
89 | #endif /* (CONFIG_SPARC64) */ | ||
90 | |||
91 | |||
92 | #endif /* !(__ASSEMBLY__) */ | ||
93 | |||
94 | #endif /* (__KERNEL__) */ | ||
95 | |||
96 | #endif /* !(__SPARC_SIGCONTEXT_H) */ | ||
diff --git a/arch/sparc/include/asm/sigcontext_32.h b/arch/sparc/include/asm/sigcontext_32.h deleted file mode 100644 index c5fb60dcbd75..000000000000 --- a/arch/sparc/include/asm/sigcontext_32.h +++ /dev/null | |||
@@ -1,62 +0,0 @@ | |||
1 | #ifndef __SPARC_SIGCONTEXT_H | ||
2 | #define __SPARC_SIGCONTEXT_H | ||
3 | |||
4 | #ifdef __KERNEL__ | ||
5 | #include <asm/ptrace.h> | ||
6 | |||
7 | #ifndef __ASSEMBLY__ | ||
8 | |||
9 | #define __SUNOS_MAXWIN 31 | ||
10 | |||
11 | /* This is what SunOS does, so shall I. */ | ||
12 | struct sigcontext { | ||
13 | int sigc_onstack; /* state to restore */ | ||
14 | int sigc_mask; /* sigmask to restore */ | ||
15 | int sigc_sp; /* stack pointer */ | ||
16 | int sigc_pc; /* program counter */ | ||
17 | int sigc_npc; /* next program counter */ | ||
18 | int sigc_psr; /* for condition codes etc */ | ||
19 | int sigc_g1; /* User uses these two registers */ | ||
20 | int sigc_o0; /* within the trampoline code. */ | ||
21 | |||
22 | /* Now comes information regarding the users window set | ||
23 | * at the time of the signal. | ||
24 | */ | ||
25 | int sigc_oswins; /* outstanding windows */ | ||
26 | |||
27 | /* stack ptrs for each regwin buf */ | ||
28 | char *sigc_spbuf[__SUNOS_MAXWIN]; | ||
29 | |||
30 | /* Windows to restore after signal */ | ||
31 | struct { | ||
32 | unsigned long locals[8]; | ||
33 | unsigned long ins[8]; | ||
34 | } sigc_wbuf[__SUNOS_MAXWIN]; | ||
35 | }; | ||
36 | |||
37 | typedef struct { | ||
38 | struct { | ||
39 | unsigned long psr; | ||
40 | unsigned long pc; | ||
41 | unsigned long npc; | ||
42 | unsigned long y; | ||
43 | unsigned long u_regs[16]; /* globals and ins */ | ||
44 | } si_regs; | ||
45 | int si_mask; | ||
46 | } __siginfo_t; | ||
47 | |||
48 | typedef struct { | ||
49 | unsigned long si_float_regs [32]; | ||
50 | unsigned long si_fsr; | ||
51 | unsigned long si_fpqdepth; | ||
52 | struct { | ||
53 | unsigned long *insn_addr; | ||
54 | unsigned long insn; | ||
55 | } si_fpqueue [16]; | ||
56 | } __siginfo_fpu_t; | ||
57 | |||
58 | #endif /* !(__ASSEMBLY__) */ | ||
59 | |||
60 | #endif /* (__KERNEL__) */ | ||
61 | |||
62 | #endif /* !(__SPARC_SIGCONTEXT_H) */ | ||
diff --git a/arch/sparc/include/asm/sigcontext_64.h b/arch/sparc/include/asm/sigcontext_64.h deleted file mode 100644 index 1c868d680cfc..000000000000 --- a/arch/sparc/include/asm/sigcontext_64.h +++ /dev/null | |||
@@ -1,87 +0,0 @@ | |||
1 | #ifndef __SPARC64_SIGCONTEXT_H | ||
2 | #define __SPARC64_SIGCONTEXT_H | ||
3 | |||
4 | #ifdef __KERNEL__ | ||
5 | #include <asm/ptrace.h> | ||
6 | #endif | ||
7 | |||
8 | #ifndef __ASSEMBLY__ | ||
9 | |||
10 | #ifdef __KERNEL__ | ||
11 | |||
12 | #define __SUNOS_MAXWIN 31 | ||
13 | |||
14 | /* This is what SunOS does, so shall I unless we use new 32bit signals or rt signals. */ | ||
15 | struct sigcontext32 { | ||
16 | int sigc_onstack; /* state to restore */ | ||
17 | int sigc_mask; /* sigmask to restore */ | ||
18 | int sigc_sp; /* stack pointer */ | ||
19 | int sigc_pc; /* program counter */ | ||
20 | int sigc_npc; /* next program counter */ | ||
21 | int sigc_psr; /* for condition codes etc */ | ||
22 | int sigc_g1; /* User uses these two registers */ | ||
23 | int sigc_o0; /* within the trampoline code. */ | ||
24 | |||
25 | /* Now comes information regarding the users window set | ||
26 | * at the time of the signal. | ||
27 | */ | ||
28 | int sigc_oswins; /* outstanding windows */ | ||
29 | |||
30 | /* stack ptrs for each regwin buf */ | ||
31 | unsigned sigc_spbuf[__SUNOS_MAXWIN]; | ||
32 | |||
33 | /* Windows to restore after signal */ | ||
34 | struct reg_window32 sigc_wbuf[__SUNOS_MAXWIN]; | ||
35 | }; | ||
36 | |||
37 | #endif | ||
38 | |||
39 | #ifdef __KERNEL__ | ||
40 | |||
41 | /* This is what we use for 32bit new non-rt signals. */ | ||
42 | |||
43 | typedef struct { | ||
44 | struct { | ||
45 | unsigned int psr; | ||
46 | unsigned int pc; | ||
47 | unsigned int npc; | ||
48 | unsigned int y; | ||
49 | unsigned int u_regs[16]; /* globals and ins */ | ||
50 | } si_regs; | ||
51 | int si_mask; | ||
52 | } __siginfo32_t; | ||
53 | |||
54 | #endif | ||
55 | |||
56 | typedef struct { | ||
57 | unsigned int si_float_regs [64]; | ||
58 | unsigned long si_fsr; | ||
59 | unsigned long si_gsr; | ||
60 | unsigned long si_fprs; | ||
61 | } __siginfo_fpu_t; | ||
62 | |||
63 | /* This is what SunOS doesn't, so we have to write this alone | ||
64 | and do it properly. */ | ||
65 | struct sigcontext { | ||
66 | /* The size of this array has to match SI_MAX_SIZE from siginfo.h */ | ||
67 | char sigc_info[128]; | ||
68 | struct { | ||
69 | unsigned long u_regs[16]; /* globals and ins */ | ||
70 | unsigned long tstate; | ||
71 | unsigned long tpc; | ||
72 | unsigned long tnpc; | ||
73 | unsigned int y; | ||
74 | unsigned int fprs; | ||
75 | } sigc_regs; | ||
76 | __siginfo_fpu_t * sigc_fpu_save; | ||
77 | struct { | ||
78 | void * ss_sp; | ||
79 | int ss_flags; | ||
80 | unsigned long ss_size; | ||
81 | } sigc_stack; | ||
82 | unsigned long sigc_mask; | ||
83 | }; | ||
84 | |||
85 | #endif /* !(__ASSEMBLY__) */ | ||
86 | |||
87 | #endif /* !(__SPARC64_SIGCONTEXT_H) */ | ||
diff --git a/arch/sparc/include/asm/siginfo.h b/arch/sparc/include/asm/siginfo.h index bd81f8d7f5ce..988e5d8ed11a 100644 --- a/arch/sparc/include/asm/siginfo.h +++ b/arch/sparc/include/asm/siginfo.h | |||
@@ -1,8 +1,37 @@ | |||
1 | #ifndef ___ASM_SPARC_SIGINFO_H | 1 | #ifndef __SPARC_SIGINFO_H |
2 | #define ___ASM_SPARC_SIGINFO_H | 2 | #define __SPARC_SIGINFO_H |
3 | |||
3 | #if defined(__sparc__) && defined(__arch64__) | 4 | #if defined(__sparc__) && defined(__arch64__) |
4 | #include <asm/siginfo_64.h> | 5 | |
5 | #else | 6 | #define SI_PAD_SIZE32 ((SI_MAX_SIZE/sizeof(int)) - 3) |
6 | #include <asm/siginfo_32.h> | 7 | #define __ARCH_SI_PREAMBLE_SIZE (4 * sizeof(int)) |
7 | #endif | 8 | #define __ARCH_SI_BAND_T int |
8 | #endif | 9 | |
10 | #endif /* defined(__sparc__) && defined(__arch64__) */ | ||
11 | |||
12 | |||
13 | #define __ARCH_SI_TRAPNO | ||
14 | |||
15 | #include <asm-generic/siginfo.h> | ||
16 | |||
17 | #ifdef __KERNEL__ | ||
18 | |||
19 | #include <linux/compat.h> | ||
20 | |||
21 | #ifdef CONFIG_COMPAT | ||
22 | |||
23 | struct compat_siginfo; | ||
24 | |||
25 | #endif /* CONFIG_COMPAT */ | ||
26 | |||
27 | #endif /* __KERNEL__ */ | ||
28 | |||
29 | #define SI_NOINFO 32767 /* no information in siginfo_t */ | ||
30 | |||
31 | /* | ||
32 | * SIGEMT si_codes | ||
33 | */ | ||
34 | #define EMT_TAGOVF (__SI_FAULT|1) /* tag overflow */ | ||
35 | #define NSIGEMT 1 | ||
36 | |||
37 | #endif /* !(__SPARC_SIGINFO_H) */ | ||
diff --git a/arch/sparc/include/asm/siginfo_32.h b/arch/sparc/include/asm/siginfo_32.h deleted file mode 100644 index 3c71af135c52..000000000000 --- a/arch/sparc/include/asm/siginfo_32.h +++ /dev/null | |||
@@ -1,17 +0,0 @@ | |||
1 | #ifndef _SPARC_SIGINFO_H | ||
2 | #define _SPARC_SIGINFO_H | ||
3 | |||
4 | #define __ARCH_SI_UID_T unsigned int | ||
5 | #define __ARCH_SI_TRAPNO | ||
6 | |||
7 | #include <asm-generic/siginfo.h> | ||
8 | |||
9 | #define SI_NOINFO 32767 /* no information in siginfo_t */ | ||
10 | |||
11 | /* | ||
12 | * SIGEMT si_codes | ||
13 | */ | ||
14 | #define EMT_TAGOVF (__SI_FAULT|1) /* tag overflow */ | ||
15 | #define NSIGEMT 1 | ||
16 | |||
17 | #endif /* !(_SPARC_SIGINFO_H) */ | ||
diff --git a/arch/sparc/include/asm/siginfo_64.h b/arch/sparc/include/asm/siginfo_64.h deleted file mode 100644 index c96e6c30f8b0..000000000000 --- a/arch/sparc/include/asm/siginfo_64.h +++ /dev/null | |||
@@ -1,32 +0,0 @@ | |||
1 | #ifndef _SPARC64_SIGINFO_H | ||
2 | #define _SPARC64_SIGINFO_H | ||
3 | |||
4 | #define SI_PAD_SIZE32 ((SI_MAX_SIZE/sizeof(int)) - 3) | ||
5 | |||
6 | #define __ARCH_SI_PREAMBLE_SIZE (4 * sizeof(int)) | ||
7 | #define __ARCH_SI_TRAPNO | ||
8 | #define __ARCH_SI_BAND_T int | ||
9 | |||
10 | #include <asm-generic/siginfo.h> | ||
11 | |||
12 | #ifdef __KERNEL__ | ||
13 | |||
14 | #include <linux/compat.h> | ||
15 | |||
16 | #ifdef CONFIG_COMPAT | ||
17 | |||
18 | struct compat_siginfo; | ||
19 | |||
20 | #endif /* CONFIG_COMPAT */ | ||
21 | |||
22 | #endif /* __KERNEL__ */ | ||
23 | |||
24 | #define SI_NOINFO 32767 /* no information in siginfo_t */ | ||
25 | |||
26 | /* | ||
27 | * SIGEMT si_codes | ||
28 | */ | ||
29 | #define EMT_TAGOVF (__SI_FAULT|1) /* tag overflow */ | ||
30 | #define NSIGEMT 1 | ||
31 | |||
32 | #endif | ||
diff --git a/arch/sparc/include/asm/signal.h b/arch/sparc/include/asm/signal.h index 27ab05dc203e..41535e77b255 100644 --- a/arch/sparc/include/asm/signal.h +++ b/arch/sparc/include/asm/signal.h | |||
@@ -1,8 +1,210 @@ | |||
1 | #ifndef ___ASM_SPARC_SIGNAL_H | 1 | #ifndef __SPARC_SIGNAL_H |
2 | #define ___ASM_SPARC_SIGNAL_H | 2 | #define __SPARC_SIGNAL_H |
3 | #if defined(__sparc__) && defined(__arch64__) | 3 | |
4 | #include <asm/signal_64.h> | 4 | #include <asm/sigcontext.h> |
5 | #include <linux/compiler.h> | ||
6 | |||
7 | #ifdef __KERNEL__ | ||
8 | #ifndef __ASSEMBLY__ | ||
9 | #include <linux/personality.h> | ||
10 | #include <linux/types.h> | ||
11 | #endif | ||
12 | #endif | ||
13 | |||
14 | /* On the Sparc the signal handlers get passed a 'sub-signal' code | ||
15 | * for certain signal types, which we document here. | ||
16 | */ | ||
17 | #define SIGHUP 1 | ||
18 | #define SIGINT 2 | ||
19 | #define SIGQUIT 3 | ||
20 | #define SIGILL 4 | ||
21 | #define SUBSIG_STACK 0 | ||
22 | #define SUBSIG_ILLINST 2 | ||
23 | #define SUBSIG_PRIVINST 3 | ||
24 | #define SUBSIG_BADTRAP(t) (0x80 + (t)) | ||
25 | |||
26 | #define SIGTRAP 5 | ||
27 | #define SIGABRT 6 | ||
28 | #define SIGIOT 6 | ||
29 | |||
30 | #define SIGEMT 7 | ||
31 | #define SUBSIG_TAG 10 | ||
32 | |||
33 | #define SIGFPE 8 | ||
34 | #define SUBSIG_FPDISABLED 0x400 | ||
35 | #define SUBSIG_FPERROR 0x404 | ||
36 | #define SUBSIG_FPINTOVFL 0x001 | ||
37 | #define SUBSIG_FPSTSIG 0x002 | ||
38 | #define SUBSIG_IDIVZERO 0x014 | ||
39 | #define SUBSIG_FPINEXACT 0x0c4 | ||
40 | #define SUBSIG_FPDIVZERO 0x0c8 | ||
41 | #define SUBSIG_FPUNFLOW 0x0cc | ||
42 | #define SUBSIG_FPOPERROR 0x0d0 | ||
43 | #define SUBSIG_FPOVFLOW 0x0d4 | ||
44 | |||
45 | #define SIGKILL 9 | ||
46 | #define SIGBUS 10 | ||
47 | #define SUBSIG_BUSTIMEOUT 1 | ||
48 | #define SUBSIG_ALIGNMENT 2 | ||
49 | #define SUBSIG_MISCERROR 5 | ||
50 | |||
51 | #define SIGSEGV 11 | ||
52 | #define SUBSIG_NOMAPPING 3 | ||
53 | #define SUBSIG_PROTECTION 4 | ||
54 | #define SUBSIG_SEGERROR 5 | ||
55 | |||
56 | #define SIGSYS 12 | ||
57 | |||
58 | #define SIGPIPE 13 | ||
59 | #define SIGALRM 14 | ||
60 | #define SIGTERM 15 | ||
61 | #define SIGURG 16 | ||
62 | |||
63 | /* SunOS values which deviate from the Linux/i386 ones */ | ||
64 | #define SIGSTOP 17 | ||
65 | #define SIGTSTP 18 | ||
66 | #define SIGCONT 19 | ||
67 | #define SIGCHLD 20 | ||
68 | #define SIGTTIN 21 | ||
69 | #define SIGTTOU 22 | ||
70 | #define SIGIO 23 | ||
71 | #define SIGPOLL SIGIO /* SysV name for SIGIO */ | ||
72 | #define SIGXCPU 24 | ||
73 | #define SIGXFSZ 25 | ||
74 | #define SIGVTALRM 26 | ||
75 | #define SIGPROF 27 | ||
76 | #define SIGWINCH 28 | ||
77 | #define SIGLOST 29 | ||
78 | #define SIGPWR SIGLOST | ||
79 | #define SIGUSR1 30 | ||
80 | #define SIGUSR2 31 | ||
81 | |||
82 | /* Most things should be clean enough to redefine this at will, if care | ||
83 | is taken to make libc match. */ | ||
84 | |||
85 | #define __OLD_NSIG 32 | ||
86 | #define __NEW_NSIG 64 | ||
87 | #define _NSIG_BPW 64 | ||
88 | #define _NSIG_WORDS (__NEW_NSIG / _NSIG_BPW) | ||
89 | |||
90 | #define SIGRTMIN 32 | ||
91 | #define SIGRTMAX __NEW_NSIG | ||
92 | |||
93 | #if defined(__KERNEL__) || defined(__WANT_POSIX1B_SIGNALS__) | ||
94 | #define _NSIG __NEW_NSIG | ||
95 | #define __new_sigset_t sigset_t | ||
96 | #define __new_sigaction sigaction | ||
97 | #define __new_sigaction32 sigaction32 | ||
98 | #define __old_sigset_t old_sigset_t | ||
99 | #define __old_sigaction old_sigaction | ||
100 | #define __old_sigaction32 old_sigaction32 | ||
5 | #else | 101 | #else |
6 | #include <asm/signal_32.h> | 102 | #define _NSIG __OLD_NSIG |
103 | #define NSIG _NSIG | ||
104 | #define __old_sigset_t sigset_t | ||
105 | #define __old_sigaction sigaction | ||
106 | #define __old_sigaction32 sigaction32 | ||
7 | #endif | 107 | #endif |
108 | |||
109 | #ifndef __ASSEMBLY__ | ||
110 | |||
111 | typedef unsigned long __old_sigset_t; /* at least 32 bits */ | ||
112 | |||
113 | typedef struct { | ||
114 | unsigned long sig[_NSIG_WORDS]; | ||
115 | } __new_sigset_t; | ||
116 | |||
117 | /* A SunOS sigstack */ | ||
118 | struct sigstack { | ||
119 | /* XXX 32-bit pointers pinhead XXX */ | ||
120 | char *the_stack; | ||
121 | int cur_status; | ||
122 | }; | ||
123 | |||
124 | /* Sigvec flags */ | ||
125 | #define _SV_SSTACK 1u /* This signal handler should use sig-stack */ | ||
126 | #define _SV_INTR 2u /* Sig return should not restart system call */ | ||
127 | #define _SV_RESET 4u /* Set handler to SIG_DFL upon taken signal */ | ||
128 | #define _SV_IGNCHILD 8u /* Do not send SIGCHLD */ | ||
129 | |||
130 | /* | ||
131 | * sa_flags values: SA_STACK is not currently supported, but will allow the | ||
132 | * usage of signal stacks by using the (now obsolete) sa_restorer field in | ||
133 | * the sigaction structure as a stack pointer. This is now possible due to | ||
134 | * the changes in signal handling. LBT 010493. | ||
135 | * SA_RESTART flag to get restarting signals (which were the default long ago) | ||
136 | */ | ||
137 | #define SA_NOCLDSTOP _SV_IGNCHILD | ||
138 | #define SA_STACK _SV_SSTACK | ||
139 | #define SA_ONSTACK _SV_SSTACK | ||
140 | #define SA_RESTART _SV_INTR | ||
141 | #define SA_ONESHOT _SV_RESET | ||
142 | #define SA_NOMASK 0x20u | ||
143 | #define SA_NOCLDWAIT 0x100u | ||
144 | #define SA_SIGINFO 0x200u | ||
145 | |||
146 | |||
147 | #define SIG_BLOCK 0x01 /* for blocking signals */ | ||
148 | #define SIG_UNBLOCK 0x02 /* for unblocking signals */ | ||
149 | #define SIG_SETMASK 0x04 /* for setting the signal mask */ | ||
150 | |||
151 | /* | ||
152 | * sigaltstack controls | ||
153 | */ | ||
154 | #define SS_ONSTACK 1 | ||
155 | #define SS_DISABLE 2 | ||
156 | |||
157 | #define MINSIGSTKSZ 4096 | ||
158 | #define SIGSTKSZ 16384 | ||
159 | |||
160 | #ifdef __KERNEL__ | ||
161 | /* | ||
162 | * DJHR | ||
163 | * SA_STATIC_ALLOC is used for the sparc32 system to indicate that this | ||
164 | * interrupt handler's irq structure should be statically allocated | ||
165 | * by the request_irq routine. | ||
166 | * The alternative is that arch/sparc/kernel/irq.c has carnal knowledge | ||
167 | * of interrupt usage and that sucks. Also without a flag like this | ||
168 | * it may be possible for the free_irq routine to attempt to free | ||
169 | * statically allocated data.. which is NOT GOOD. | ||
170 | * | ||
171 | */ | ||
172 | #define SA_STATIC_ALLOC 0x8000 | ||
8 | #endif | 173 | #endif |
174 | |||
175 | #include <asm-generic/signal.h> | ||
176 | |||
177 | struct __new_sigaction { | ||
178 | __sighandler_t sa_handler; | ||
179 | unsigned long sa_flags; | ||
180 | __sigrestore_t sa_restorer; /* not used by Linux/SPARC yet */ | ||
181 | __new_sigset_t sa_mask; | ||
182 | }; | ||
183 | |||
184 | struct __old_sigaction { | ||
185 | __sighandler_t sa_handler; | ||
186 | __old_sigset_t sa_mask; | ||
187 | unsigned long sa_flags; | ||
188 | void (*sa_restorer)(void); /* not used by Linux/SPARC yet */ | ||
189 | }; | ||
190 | |||
191 | typedef struct sigaltstack { | ||
192 | void __user *ss_sp; | ||
193 | int ss_flags; | ||
194 | size_t ss_size; | ||
195 | } stack_t; | ||
196 | |||
197 | #ifdef __KERNEL__ | ||
198 | |||
199 | struct k_sigaction { | ||
200 | struct __new_sigaction sa; | ||
201 | void __user *ka_restorer; | ||
202 | }; | ||
203 | |||
204 | #define ptrace_signal_deliver(regs, cookie) do { } while (0) | ||
205 | |||
206 | #endif /* !(__KERNEL__) */ | ||
207 | |||
208 | #endif /* !(__ASSEMBLY__) */ | ||
209 | |||
210 | #endif /* !(__SPARC_SIGNAL_H) */ | ||
diff --git a/arch/sparc/include/asm/signal_32.h b/arch/sparc/include/asm/signal_32.h deleted file mode 100644 index 96a60ab03ca1..000000000000 --- a/arch/sparc/include/asm/signal_32.h +++ /dev/null | |||
@@ -1,207 +0,0 @@ | |||
1 | #ifndef _ASMSPARC_SIGNAL_H | ||
2 | #define _ASMSPARC_SIGNAL_H | ||
3 | |||
4 | #include <asm/sigcontext.h> | ||
5 | #include <linux/compiler.h> | ||
6 | |||
7 | #ifdef __KERNEL__ | ||
8 | #ifndef __ASSEMBLY__ | ||
9 | #include <linux/personality.h> | ||
10 | #include <linux/types.h> | ||
11 | #endif | ||
12 | #endif | ||
13 | |||
14 | /* On the Sparc the signal handlers get passed a 'sub-signal' code | ||
15 | * for certain signal types, which we document here. | ||
16 | */ | ||
17 | #define SIGHUP 1 | ||
18 | #define SIGINT 2 | ||
19 | #define SIGQUIT 3 | ||
20 | #define SIGILL 4 | ||
21 | #define SUBSIG_STACK 0 | ||
22 | #define SUBSIG_ILLINST 2 | ||
23 | #define SUBSIG_PRIVINST 3 | ||
24 | #define SUBSIG_BADTRAP(t) (0x80 + (t)) | ||
25 | |||
26 | #define SIGTRAP 5 | ||
27 | #define SIGABRT 6 | ||
28 | #define SIGIOT 6 | ||
29 | |||
30 | #define SIGEMT 7 | ||
31 | #define SUBSIG_TAG 10 | ||
32 | |||
33 | #define SIGFPE 8 | ||
34 | #define SUBSIG_FPDISABLED 0x400 | ||
35 | #define SUBSIG_FPERROR 0x404 | ||
36 | #define SUBSIG_FPINTOVFL 0x001 | ||
37 | #define SUBSIG_FPSTSIG 0x002 | ||
38 | #define SUBSIG_IDIVZERO 0x014 | ||
39 | #define SUBSIG_FPINEXACT 0x0c4 | ||
40 | #define SUBSIG_FPDIVZERO 0x0c8 | ||
41 | #define SUBSIG_FPUNFLOW 0x0cc | ||
42 | #define SUBSIG_FPOPERROR 0x0d0 | ||
43 | #define SUBSIG_FPOVFLOW 0x0d4 | ||
44 | |||
45 | #define SIGKILL 9 | ||
46 | #define SIGBUS 10 | ||
47 | #define SUBSIG_BUSTIMEOUT 1 | ||
48 | #define SUBSIG_ALIGNMENT 2 | ||
49 | #define SUBSIG_MISCERROR 5 | ||
50 | |||
51 | #define SIGSEGV 11 | ||
52 | #define SUBSIG_NOMAPPING 3 | ||
53 | #define SUBSIG_PROTECTION 4 | ||
54 | #define SUBSIG_SEGERROR 5 | ||
55 | |||
56 | #define SIGSYS 12 | ||
57 | |||
58 | #define SIGPIPE 13 | ||
59 | #define SIGALRM 14 | ||
60 | #define SIGTERM 15 | ||
61 | #define SIGURG 16 | ||
62 | |||
63 | /* SunOS values which deviate from the Linux/i386 ones */ | ||
64 | #define SIGSTOP 17 | ||
65 | #define SIGTSTP 18 | ||
66 | #define SIGCONT 19 | ||
67 | #define SIGCHLD 20 | ||
68 | #define SIGTTIN 21 | ||
69 | #define SIGTTOU 22 | ||
70 | #define SIGIO 23 | ||
71 | #define SIGPOLL SIGIO /* SysV name for SIGIO */ | ||
72 | #define SIGXCPU 24 | ||
73 | #define SIGXFSZ 25 | ||
74 | #define SIGVTALRM 26 | ||
75 | #define SIGPROF 27 | ||
76 | #define SIGWINCH 28 | ||
77 | #define SIGLOST 29 | ||
78 | #define SIGPWR SIGLOST | ||
79 | #define SIGUSR1 30 | ||
80 | #define SIGUSR2 31 | ||
81 | |||
82 | /* Most things should be clean enough to redefine this at will, if care | ||
83 | * is taken to make libc match. | ||
84 | */ | ||
85 | |||
86 | #define __OLD_NSIG 32 | ||
87 | #define __NEW_NSIG 64 | ||
88 | #define _NSIG_BPW 32 | ||
89 | #define _NSIG_WORDS (__NEW_NSIG / _NSIG_BPW) | ||
90 | |||
91 | #define SIGRTMIN 32 | ||
92 | #define SIGRTMAX __NEW_NSIG | ||
93 | |||
94 | #if defined(__KERNEL__) || defined(__WANT_POSIX1B_SIGNALS__) | ||
95 | #define _NSIG __NEW_NSIG | ||
96 | #define __new_sigset_t sigset_t | ||
97 | #define __new_sigaction sigaction | ||
98 | #define __old_sigset_t old_sigset_t | ||
99 | #define __old_sigaction old_sigaction | ||
100 | #else | ||
101 | #define _NSIG __OLD_NSIG | ||
102 | #define __old_sigset_t sigset_t | ||
103 | #define __old_sigaction sigaction | ||
104 | #endif | ||
105 | |||
106 | #ifndef __ASSEMBLY__ | ||
107 | |||
108 | typedef unsigned long __old_sigset_t; | ||
109 | |||
110 | typedef struct { | ||
111 | unsigned long sig[_NSIG_WORDS]; | ||
112 | } __new_sigset_t; | ||
113 | |||
114 | |||
115 | #ifdef __KERNEL__ | ||
116 | /* A SunOS sigstack */ | ||
117 | struct sigstack { | ||
118 | char *the_stack; | ||
119 | int cur_status; | ||
120 | }; | ||
121 | #endif | ||
122 | |||
123 | /* Sigvec flags */ | ||
124 | #define _SV_SSTACK 1u /* This signal handler should use sig-stack */ | ||
125 | #define _SV_INTR 2u /* Sig return should not restart system call */ | ||
126 | #define _SV_RESET 4u /* Set handler to SIG_DFL upon taken signal */ | ||
127 | #define _SV_IGNCHILD 8u /* Do not send SIGCHLD */ | ||
128 | |||
129 | /* | ||
130 | * sa_flags values: SA_STACK is not currently supported, but will allow the | ||
131 | * usage of signal stacks by using the (now obsolete) sa_restorer field in | ||
132 | * the sigaction structure as a stack pointer. This is now possible due to | ||
133 | * the changes in signal handling. LBT 010493. | ||
134 | * SA_RESTART flag to get restarting signals (which were the default long ago) | ||
135 | */ | ||
136 | #define SA_NOCLDSTOP _SV_IGNCHILD | ||
137 | #define SA_STACK _SV_SSTACK | ||
138 | #define SA_ONSTACK _SV_SSTACK | ||
139 | #define SA_RESTART _SV_INTR | ||
140 | #define SA_ONESHOT _SV_RESET | ||
141 | #define SA_NOMASK 0x20u | ||
142 | #define SA_NOCLDWAIT 0x100u | ||
143 | #define SA_SIGINFO 0x200u | ||
144 | |||
145 | #define SIG_BLOCK 0x01 /* for blocking signals */ | ||
146 | #define SIG_UNBLOCK 0x02 /* for unblocking signals */ | ||
147 | #define SIG_SETMASK 0x04 /* for setting the signal mask */ | ||
148 | |||
149 | /* | ||
150 | * sigaltstack controls | ||
151 | */ | ||
152 | #define SS_ONSTACK 1 | ||
153 | #define SS_DISABLE 2 | ||
154 | |||
155 | #define MINSIGSTKSZ 4096 | ||
156 | #define SIGSTKSZ 16384 | ||
157 | |||
158 | #ifdef __KERNEL__ | ||
159 | /* | ||
160 | * DJHR | ||
161 | * SA_STATIC_ALLOC is used for the SPARC system to indicate that this | ||
162 | * interrupt handler's irq structure should be statically allocated | ||
163 | * by the request_irq routine. | ||
164 | * The alternative is that arch/sparc/kernel/irq.c has carnal knowledge | ||
165 | * of interrupt usage and that sucks. Also without a flag like this | ||
166 | * it may be possible for the free_irq routine to attempt to free | ||
167 | * statically allocated data.. which is NOT GOOD. | ||
168 | * | ||
169 | */ | ||
170 | #define SA_STATIC_ALLOC 0x8000 | ||
171 | #endif | ||
172 | |||
173 | #include <asm-generic/signal.h> | ||
174 | |||
175 | #ifdef __KERNEL__ | ||
176 | struct __new_sigaction { | ||
177 | __sighandler_t sa_handler; | ||
178 | unsigned long sa_flags; | ||
179 | void (*sa_restorer)(void); /* Not used by Linux/SPARC */ | ||
180 | __new_sigset_t sa_mask; | ||
181 | }; | ||
182 | |||
183 | struct k_sigaction { | ||
184 | struct __new_sigaction sa; | ||
185 | void __user *ka_restorer; | ||
186 | }; | ||
187 | |||
188 | struct __old_sigaction { | ||
189 | __sighandler_t sa_handler; | ||
190 | __old_sigset_t sa_mask; | ||
191 | unsigned long sa_flags; | ||
192 | void (*sa_restorer) (void); /* not used by Linux/SPARC */ | ||
193 | }; | ||
194 | |||
195 | typedef struct sigaltstack { | ||
196 | void __user *ss_sp; | ||
197 | int ss_flags; | ||
198 | size_t ss_size; | ||
199 | } stack_t; | ||
200 | |||
201 | #define ptrace_signal_deliver(regs, cookie) do { } while (0) | ||
202 | |||
203 | #endif /* !(__KERNEL__) */ | ||
204 | |||
205 | #endif /* !(__ASSEMBLY__) */ | ||
206 | |||
207 | #endif /* !(_ASMSPARC_SIGNAL_H) */ | ||
diff --git a/arch/sparc/include/asm/signal_64.h b/arch/sparc/include/asm/signal_64.h deleted file mode 100644 index ab1509a101c5..000000000000 --- a/arch/sparc/include/asm/signal_64.h +++ /dev/null | |||
@@ -1,194 +0,0 @@ | |||
1 | #ifndef _ASMSPARC64_SIGNAL_H | ||
2 | #define _ASMSPARC64_SIGNAL_H | ||
3 | |||
4 | #include <asm/sigcontext.h> | ||
5 | |||
6 | #ifdef __KERNEL__ | ||
7 | #ifndef __ASSEMBLY__ | ||
8 | #include <linux/personality.h> | ||
9 | #include <linux/types.h> | ||
10 | #endif | ||
11 | #endif | ||
12 | |||
13 | /* On the Sparc the signal handlers get passed a 'sub-signal' code | ||
14 | * for certain signal types, which we document here. | ||
15 | */ | ||
16 | #define SIGHUP 1 | ||
17 | #define SIGINT 2 | ||
18 | #define SIGQUIT 3 | ||
19 | #define SIGILL 4 | ||
20 | #define SUBSIG_STACK 0 | ||
21 | #define SUBSIG_ILLINST 2 | ||
22 | #define SUBSIG_PRIVINST 3 | ||
23 | #define SUBSIG_BADTRAP(t) (0x80 + (t)) | ||
24 | |||
25 | #define SIGTRAP 5 | ||
26 | #define SIGABRT 6 | ||
27 | #define SIGIOT 6 | ||
28 | |||
29 | #define SIGEMT 7 | ||
30 | #define SUBSIG_TAG 10 | ||
31 | |||
32 | #define SIGFPE 8 | ||
33 | #define SUBSIG_FPDISABLED 0x400 | ||
34 | #define SUBSIG_FPERROR 0x404 | ||
35 | #define SUBSIG_FPINTOVFL 0x001 | ||
36 | #define SUBSIG_FPSTSIG 0x002 | ||
37 | #define SUBSIG_IDIVZERO 0x014 | ||
38 | #define SUBSIG_FPINEXACT 0x0c4 | ||
39 | #define SUBSIG_FPDIVZERO 0x0c8 | ||
40 | #define SUBSIG_FPUNFLOW 0x0cc | ||
41 | #define SUBSIG_FPOPERROR 0x0d0 | ||
42 | #define SUBSIG_FPOVFLOW 0x0d4 | ||
43 | |||
44 | #define SIGKILL 9 | ||
45 | #define SIGBUS 10 | ||
46 | #define SUBSIG_BUSTIMEOUT 1 | ||
47 | #define SUBSIG_ALIGNMENT 2 | ||
48 | #define SUBSIG_MISCERROR 5 | ||
49 | |||
50 | #define SIGSEGV 11 | ||
51 | #define SUBSIG_NOMAPPING 3 | ||
52 | #define SUBSIG_PROTECTION 4 | ||
53 | #define SUBSIG_SEGERROR 5 | ||
54 | |||
55 | #define SIGSYS 12 | ||
56 | |||
57 | #define SIGPIPE 13 | ||
58 | #define SIGALRM 14 | ||
59 | #define SIGTERM 15 | ||
60 | #define SIGURG 16 | ||
61 | |||
62 | /* SunOS values which deviate from the Linux/i386 ones */ | ||
63 | #define SIGSTOP 17 | ||
64 | #define SIGTSTP 18 | ||
65 | #define SIGCONT 19 | ||
66 | #define SIGCHLD 20 | ||
67 | #define SIGTTIN 21 | ||
68 | #define SIGTTOU 22 | ||
69 | #define SIGIO 23 | ||
70 | #define SIGPOLL SIGIO /* SysV name for SIGIO */ | ||
71 | #define SIGXCPU 24 | ||
72 | #define SIGXFSZ 25 | ||
73 | #define SIGVTALRM 26 | ||
74 | #define SIGPROF 27 | ||
75 | #define SIGWINCH 28 | ||
76 | #define SIGLOST 29 | ||
77 | #define SIGPWR SIGLOST | ||
78 | #define SIGUSR1 30 | ||
79 | #define SIGUSR2 31 | ||
80 | |||
81 | /* Most things should be clean enough to redefine this at will, if care | ||
82 | is taken to make libc match. */ | ||
83 | |||
84 | #define __OLD_NSIG 32 | ||
85 | #define __NEW_NSIG 64 | ||
86 | #define _NSIG_BPW 64 | ||
87 | #define _NSIG_WORDS (__NEW_NSIG / _NSIG_BPW) | ||
88 | |||
89 | #define SIGRTMIN 32 | ||
90 | #define SIGRTMAX __NEW_NSIG | ||
91 | |||
92 | #if defined(__KERNEL__) || defined(__WANT_POSIX1B_SIGNALS__) | ||
93 | #define _NSIG __NEW_NSIG | ||
94 | #define __new_sigset_t sigset_t | ||
95 | #define __new_sigaction sigaction | ||
96 | #define __new_sigaction32 sigaction32 | ||
97 | #define __old_sigset_t old_sigset_t | ||
98 | #define __old_sigaction old_sigaction | ||
99 | #define __old_sigaction32 old_sigaction32 | ||
100 | #else | ||
101 | #define _NSIG __OLD_NSIG | ||
102 | #define NSIG _NSIG | ||
103 | #define __old_sigset_t sigset_t | ||
104 | #define __old_sigaction sigaction | ||
105 | #define __old_sigaction32 sigaction32 | ||
106 | #endif | ||
107 | |||
108 | #ifndef __ASSEMBLY__ | ||
109 | |||
110 | typedef unsigned long __old_sigset_t; /* at least 32 bits */ | ||
111 | |||
112 | typedef struct { | ||
113 | unsigned long sig[_NSIG_WORDS]; | ||
114 | } __new_sigset_t; | ||
115 | |||
116 | /* A SunOS sigstack */ | ||
117 | struct sigstack { | ||
118 | /* XXX 32-bit pointers pinhead XXX */ | ||
119 | char *the_stack; | ||
120 | int cur_status; | ||
121 | }; | ||
122 | |||
123 | /* Sigvec flags */ | ||
124 | #define _SV_SSTACK 1u /* This signal handler should use sig-stack */ | ||
125 | #define _SV_INTR 2u /* Sig return should not restart system call */ | ||
126 | #define _SV_RESET 4u /* Set handler to SIG_DFL upon taken signal */ | ||
127 | #define _SV_IGNCHILD 8u /* Do not send SIGCHLD */ | ||
128 | |||
129 | /* | ||
130 | * sa_flags values: SA_STACK is not currently supported, but will allow the | ||
131 | * usage of signal stacks by using the (now obsolete) sa_restorer field in | ||
132 | * the sigaction structure as a stack pointer. This is now possible due to | ||
133 | * the changes in signal handling. LBT 010493. | ||
134 | * SA_RESTART flag to get restarting signals (which were the default long ago) | ||
135 | */ | ||
136 | #define SA_NOCLDSTOP _SV_IGNCHILD | ||
137 | #define SA_STACK _SV_SSTACK | ||
138 | #define SA_ONSTACK _SV_SSTACK | ||
139 | #define SA_RESTART _SV_INTR | ||
140 | #define SA_ONESHOT _SV_RESET | ||
141 | #define SA_NOMASK 0x20u | ||
142 | #define SA_NOCLDWAIT 0x100u | ||
143 | #define SA_SIGINFO 0x200u | ||
144 | |||
145 | |||
146 | #define SIG_BLOCK 0x01 /* for blocking signals */ | ||
147 | #define SIG_UNBLOCK 0x02 /* for unblocking signals */ | ||
148 | #define SIG_SETMASK 0x04 /* for setting the signal mask */ | ||
149 | |||
150 | /* | ||
151 | * sigaltstack controls | ||
152 | */ | ||
153 | #define SS_ONSTACK 1 | ||
154 | #define SS_DISABLE 2 | ||
155 | |||
156 | #define MINSIGSTKSZ 4096 | ||
157 | #define SIGSTKSZ 16384 | ||
158 | |||
159 | #include <asm-generic/signal.h> | ||
160 | |||
161 | struct __new_sigaction { | ||
162 | __sighandler_t sa_handler; | ||
163 | unsigned long sa_flags; | ||
164 | __sigrestore_t sa_restorer; /* not used by Linux/SPARC yet */ | ||
165 | __new_sigset_t sa_mask; | ||
166 | }; | ||
167 | |||
168 | struct __old_sigaction { | ||
169 | __sighandler_t sa_handler; | ||
170 | __old_sigset_t sa_mask; | ||
171 | unsigned long sa_flags; | ||
172 | void (*sa_restorer)(void); /* not used by Linux/SPARC yet */ | ||
173 | }; | ||
174 | |||
175 | typedef struct sigaltstack { | ||
176 | void __user *ss_sp; | ||
177 | int ss_flags; | ||
178 | size_t ss_size; | ||
179 | } stack_t; | ||
180 | |||
181 | #ifdef __KERNEL__ | ||
182 | |||
183 | struct k_sigaction { | ||
184 | struct __new_sigaction sa; | ||
185 | void __user *ka_restorer; | ||
186 | }; | ||
187 | |||
188 | #define ptrace_signal_deliver(regs, cookie) do { } while (0) | ||
189 | |||
190 | #endif /* !(__KERNEL__) */ | ||
191 | |||
192 | #endif /* !(__ASSEMBLY__) */ | ||
193 | |||
194 | #endif /* !(_ASMSPARC64_SIGNAL_H) */ | ||
diff --git a/arch/sparc/include/asm/smp_32.h b/arch/sparc/include/asm/smp_32.h index 8408d9d2a662..58101dc70493 100644 --- a/arch/sparc/include/asm/smp_32.h +++ b/arch/sparc/include/asm/smp_32.h | |||
@@ -170,7 +170,4 @@ void smp_setup_cpu_possible_map(void); | |||
170 | #define smp_setup_cpu_possible_map() do { } while (0) | 170 | #define smp_setup_cpu_possible_map() do { } while (0) |
171 | 171 | ||
172 | #endif /* !(SMP) */ | 172 | #endif /* !(SMP) */ |
173 | |||
174 | #define NO_PROC_ID 0xFF | ||
175 | |||
176 | #endif /* !(_SPARC_SMP_H) */ | 173 | #endif /* !(_SPARC_SMP_H) */ |
diff --git a/arch/sparc/include/asm/stat.h b/arch/sparc/include/asm/stat.h index d8153013df72..55db5eca08e2 100644 --- a/arch/sparc/include/asm/stat.h +++ b/arch/sparc/include/asm/stat.h | |||
@@ -1,8 +1,107 @@ | |||
1 | #ifndef ___ASM_SPARC_STAT_H | 1 | #ifndef __SPARC_STAT_H |
2 | #define ___ASM_SPARC_STAT_H | 2 | #define __SPARC_STAT_H |
3 | |||
4 | #include <linux/types.h> | ||
5 | |||
3 | #if defined(__sparc__) && defined(__arch64__) | 6 | #if defined(__sparc__) && defined(__arch64__) |
4 | #include <asm/stat_64.h> | 7 | /* 64 bit sparc */ |
8 | struct stat { | ||
9 | unsigned st_dev; | ||
10 | ino_t st_ino; | ||
11 | mode_t st_mode; | ||
12 | short st_nlink; | ||
13 | uid_t st_uid; | ||
14 | gid_t st_gid; | ||
15 | unsigned st_rdev; | ||
16 | off_t st_size; | ||
17 | time_t st_atime; | ||
18 | time_t st_mtime; | ||
19 | time_t st_ctime; | ||
20 | off_t st_blksize; | ||
21 | off_t st_blocks; | ||
22 | unsigned long __unused4[2]; | ||
23 | }; | ||
24 | |||
25 | struct stat64 { | ||
26 | unsigned long st_dev; | ||
27 | unsigned long st_ino; | ||
28 | unsigned long st_nlink; | ||
29 | |||
30 | unsigned int st_mode; | ||
31 | unsigned int st_uid; | ||
32 | unsigned int st_gid; | ||
33 | unsigned int __pad0; | ||
34 | |||
35 | unsigned long st_rdev; | ||
36 | long st_size; | ||
37 | long st_blksize; | ||
38 | long st_blocks; | ||
39 | |||
40 | unsigned long st_atime; | ||
41 | unsigned long st_atime_nsec; | ||
42 | unsigned long st_mtime; | ||
43 | unsigned long st_mtime_nsec; | ||
44 | unsigned long st_ctime; | ||
45 | unsigned long st_ctime_nsec; | ||
46 | long __unused[3]; | ||
47 | }; | ||
48 | |||
5 | #else | 49 | #else |
6 | #include <asm/stat_32.h> | 50 | /* 32 bit sparc */ |
7 | #endif | 51 | struct stat { |
8 | #endif | 52 | unsigned short st_dev; |
53 | ino_t st_ino; | ||
54 | mode_t st_mode; | ||
55 | short st_nlink; | ||
56 | uid_t st_uid; | ||
57 | gid_t st_gid; | ||
58 | unsigned short st_rdev; | ||
59 | off_t st_size; | ||
60 | time_t st_atime; | ||
61 | unsigned long st_atime_nsec; | ||
62 | time_t st_mtime; | ||
63 | unsigned long st_mtime_nsec; | ||
64 | time_t st_ctime; | ||
65 | unsigned long st_ctime_nsec; | ||
66 | off_t st_blksize; | ||
67 | off_t st_blocks; | ||
68 | unsigned long __unused4[2]; | ||
69 | }; | ||
70 | |||
71 | #define STAT_HAVE_NSEC 1 | ||
72 | |||
73 | struct stat64 { | ||
74 | unsigned long long st_dev; | ||
75 | |||
76 | unsigned long long st_ino; | ||
77 | |||
78 | unsigned int st_mode; | ||
79 | unsigned int st_nlink; | ||
80 | |||
81 | unsigned int st_uid; | ||
82 | unsigned int st_gid; | ||
83 | |||
84 | unsigned long long st_rdev; | ||
85 | |||
86 | unsigned char __pad3[8]; | ||
87 | |||
88 | long long st_size; | ||
89 | unsigned int st_blksize; | ||
90 | |||
91 | unsigned char __pad4[8]; | ||
92 | unsigned int st_blocks; | ||
93 | |||
94 | unsigned int st_atime; | ||
95 | unsigned int st_atime_nsec; | ||
96 | |||
97 | unsigned int st_mtime; | ||
98 | unsigned int st_mtime_nsec; | ||
99 | |||
100 | unsigned int st_ctime; | ||
101 | unsigned int st_ctime_nsec; | ||
102 | |||
103 | unsigned int __unused4; | ||
104 | unsigned int __unused5; | ||
105 | }; | ||
106 | #endif /* defined(__sparc__) && defined(__arch64__) */ | ||
107 | #endif /* __SPARC_STAT_H */ | ||
diff --git a/arch/sparc/include/asm/stat_32.h b/arch/sparc/include/asm/stat_32.h deleted file mode 100644 index 2299e1d5d94c..000000000000 --- a/arch/sparc/include/asm/stat_32.h +++ /dev/null | |||
@@ -1,76 +0,0 @@ | |||
1 | #ifndef _SPARC_STAT_H | ||
2 | #define _SPARC_STAT_H | ||
3 | |||
4 | #include <linux/types.h> | ||
5 | |||
6 | struct __old_kernel_stat { | ||
7 | unsigned short st_dev; | ||
8 | unsigned short st_ino; | ||
9 | unsigned short st_mode; | ||
10 | unsigned short st_nlink; | ||
11 | unsigned short st_uid; | ||
12 | unsigned short st_gid; | ||
13 | unsigned short st_rdev; | ||
14 | unsigned long st_size; | ||
15 | unsigned long st_atime; | ||
16 | unsigned long st_mtime; | ||
17 | unsigned long st_ctime; | ||
18 | }; | ||
19 | |||
20 | struct stat { | ||
21 | unsigned short st_dev; | ||
22 | unsigned long st_ino; | ||
23 | unsigned short st_mode; | ||
24 | short st_nlink; | ||
25 | unsigned short st_uid; | ||
26 | unsigned short st_gid; | ||
27 | unsigned short st_rdev; | ||
28 | long st_size; | ||
29 | long st_atime; | ||
30 | unsigned long st_atime_nsec; | ||
31 | long st_mtime; | ||
32 | unsigned long st_mtime_nsec; | ||
33 | long st_ctime; | ||
34 | unsigned long st_ctime_nsec; | ||
35 | long st_blksize; | ||
36 | long st_blocks; | ||
37 | unsigned long __unused4[2]; | ||
38 | }; | ||
39 | |||
40 | #define STAT_HAVE_NSEC 1 | ||
41 | |||
42 | struct stat64 { | ||
43 | unsigned long long st_dev; | ||
44 | |||
45 | unsigned long long st_ino; | ||
46 | |||
47 | unsigned int st_mode; | ||
48 | unsigned int st_nlink; | ||
49 | |||
50 | unsigned int st_uid; | ||
51 | unsigned int st_gid; | ||
52 | |||
53 | unsigned long long st_rdev; | ||
54 | |||
55 | unsigned char __pad3[8]; | ||
56 | |||
57 | long long st_size; | ||
58 | unsigned int st_blksize; | ||
59 | |||
60 | unsigned char __pad4[8]; | ||
61 | unsigned int st_blocks; | ||
62 | |||
63 | unsigned int st_atime; | ||
64 | unsigned int st_atime_nsec; | ||
65 | |||
66 | unsigned int st_mtime; | ||
67 | unsigned int st_mtime_nsec; | ||
68 | |||
69 | unsigned int st_ctime; | ||
70 | unsigned int st_ctime_nsec; | ||
71 | |||
72 | unsigned int __unused4; | ||
73 | unsigned int __unused5; | ||
74 | }; | ||
75 | |||
76 | #endif | ||
diff --git a/arch/sparc/include/asm/stat_64.h b/arch/sparc/include/asm/stat_64.h deleted file mode 100644 index 9650fdea847f..000000000000 --- a/arch/sparc/include/asm/stat_64.h +++ /dev/null | |||
@@ -1,47 +0,0 @@ | |||
1 | #ifndef _SPARC64_STAT_H | ||
2 | #define _SPARC64_STAT_H | ||
3 | |||
4 | #include <linux/types.h> | ||
5 | |||
6 | struct stat { | ||
7 | unsigned st_dev; | ||
8 | ino_t st_ino; | ||
9 | mode_t st_mode; | ||
10 | short st_nlink; | ||
11 | uid_t st_uid; | ||
12 | gid_t st_gid; | ||
13 | unsigned st_rdev; | ||
14 | off_t st_size; | ||
15 | time_t st_atime; | ||
16 | time_t st_mtime; | ||
17 | time_t st_ctime; | ||
18 | off_t st_blksize; | ||
19 | off_t st_blocks; | ||
20 | unsigned long __unused4[2]; | ||
21 | }; | ||
22 | |||
23 | struct stat64 { | ||
24 | unsigned long st_dev; | ||
25 | unsigned long st_ino; | ||
26 | unsigned long st_nlink; | ||
27 | |||
28 | unsigned int st_mode; | ||
29 | unsigned int st_uid; | ||
30 | unsigned int st_gid; | ||
31 | unsigned int __pad0; | ||
32 | |||
33 | unsigned long st_rdev; | ||
34 | long st_size; | ||
35 | long st_blksize; | ||
36 | long st_blocks; | ||
37 | |||
38 | unsigned long st_atime; | ||
39 | unsigned long st_atime_nsec; | ||
40 | unsigned long st_mtime; | ||
41 | unsigned long st_mtime_nsec; | ||
42 | unsigned long st_ctime; | ||
43 | unsigned long st_ctime_nsec; | ||
44 | long __unused[3]; | ||
45 | }; | ||
46 | |||
47 | #endif | ||
diff --git a/arch/sparc/include/asm/thread_info_32.h b/arch/sparc/include/asm/thread_info_32.h index 80fe547c3f45..0f7b0e5fb1c7 100644 --- a/arch/sparc/include/asm/thread_info_32.h +++ b/arch/sparc/include/asm/thread_info_32.h | |||
@@ -45,7 +45,7 @@ struct thread_info { | |||
45 | /* A place to store user windows and stack pointers | 45 | /* A place to store user windows and stack pointers |
46 | * when the stack needs inspection. | 46 | * when the stack needs inspection. |
47 | */ | 47 | */ |
48 | struct reg_window reg_window[NSWINS]; /* align for ldd! */ | 48 | struct reg_window32 reg_window[NSWINS]; /* align for ldd! */ |
49 | unsigned long rwbuf_stkptrs[NSWINS]; | 49 | unsigned long rwbuf_stkptrs[NSWINS]; |
50 | unsigned long w_saved; | 50 | unsigned long w_saved; |
51 | 51 | ||
diff --git a/arch/sparc/include/asm/traps.h b/arch/sparc/include/asm/traps.h index bebdbf8f43a8..3aa62dde343f 100644 --- a/arch/sparc/include/asm/traps.h +++ b/arch/sparc/include/asm/traps.h | |||
@@ -10,7 +10,7 @@ | |||
10 | #define NUM_SPARC_TRAPS 255 | 10 | #define NUM_SPARC_TRAPS 255 |
11 | 11 | ||
12 | #ifndef __ASSEMBLY__ | 12 | #ifndef __ASSEMBLY__ |
13 | 13 | #ifdef __KERNEL__ | |
14 | /* This is for V8 compliant Sparc CPUS */ | 14 | /* This is for V8 compliant Sparc CPUS */ |
15 | struct tt_entry { | 15 | struct tt_entry { |
16 | unsigned long inst_one; | 16 | unsigned long inst_one; |
@@ -22,14 +22,7 @@ struct tt_entry { | |||
22 | /* We set this to _start in system setup. */ | 22 | /* We set this to _start in system setup. */ |
23 | extern struct tt_entry *sparc_ttable; | 23 | extern struct tt_entry *sparc_ttable; |
24 | 24 | ||
25 | static inline unsigned long get_tbr(void) | 25 | #endif /* (__KERNEL__) */ |
26 | { | ||
27 | unsigned long tbr; | ||
28 | |||
29 | __asm__ __volatile__("rd %%tbr, %0\n\t" : "=r" (tbr)); | ||
30 | return tbr; | ||
31 | } | ||
32 | |||
33 | #endif /* !(__ASSEMBLY__) */ | 26 | #endif /* !(__ASSEMBLY__) */ |
34 | 27 | ||
35 | /* For patching the trap table at boot time, we need to know how to | 28 | /* For patching the trap table at boot time, we need to know how to |