diff options
author | Paul Mundt <lethal@linux-sh.org> | 2007-11-21 03:28:09 -0500 |
---|---|---|
committer | Paul Mundt <lethal@linux-sh.org> | 2008-01-27 23:18:53 -0500 |
commit | c8eef8800f1c693a2de6374b1948c8ea5e0ad75f (patch) | |
tree | b8f66bd608ae5aa22e2ef508ccf0536a137bd127 /include/asm-sh64 | |
parent | e150e7f25f7e3878cf2230193a5c708d99b9971e (diff) |
sh: Purge dead sh64 headers.
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
Diffstat (limited to 'include/asm-sh64')
78 files changed, 0 insertions, 2873 deletions
diff --git a/include/asm-sh64/Kbuild b/include/asm-sh64/Kbuild deleted file mode 100644 index c68e1680da01..000000000000 --- a/include/asm-sh64/Kbuild +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | include include/asm-generic/Kbuild.asm | ||
diff --git a/include/asm-sh64/a.out.h b/include/asm-sh64/a.out.h deleted file mode 100644 index 237ee4e5b72a..000000000000 --- a/include/asm-sh64/a.out.h +++ /dev/null | |||
@@ -1,38 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_A_OUT_H | ||
2 | #define __ASM_SH64_A_OUT_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/a.out.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | struct exec | ||
16 | { | ||
17 | unsigned long a_info; /* Use macros N_MAGIC, etc for access */ | ||
18 | unsigned a_text; /* length of text, in bytes */ | ||
19 | unsigned a_data; /* length of data, in bytes */ | ||
20 | unsigned a_bss; /* length of uninitialized data area for file, in bytes */ | ||
21 | unsigned a_syms; /* length of symbol table data in file, in bytes */ | ||
22 | unsigned a_entry; /* start address */ | ||
23 | unsigned a_trsize; /* length of relocation info for text, in bytes */ | ||
24 | unsigned a_drsize; /* length of relocation info for data, in bytes */ | ||
25 | }; | ||
26 | |||
27 | #define N_TRSIZE(a) ((a).a_trsize) | ||
28 | #define N_DRSIZE(a) ((a).a_drsize) | ||
29 | #define N_SYMSIZE(a) ((a).a_syms) | ||
30 | |||
31 | #ifdef __KERNEL__ | ||
32 | |||
33 | #define STACK_TOP TASK_SIZE | ||
34 | #define STACK_TOP_MAX STACK_TOP | ||
35 | |||
36 | #endif | ||
37 | |||
38 | #endif /* __ASM_SH64_A_OUT_H */ | ||
diff --git a/include/asm-sh64/atomic.h b/include/asm-sh64/atomic.h deleted file mode 100644 index 28f2ea9b567b..000000000000 --- a/include/asm-sh64/atomic.h +++ /dev/null | |||
@@ -1,158 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_ATOMIC_H | ||
2 | #define __ASM_SH64_ATOMIC_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/atomic.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003 Paul Mundt | ||
13 | * | ||
14 | */ | ||
15 | |||
16 | /* | ||
17 | * Atomic operations that C can't guarantee us. Useful for | ||
18 | * resource counting etc.. | ||
19 | * | ||
20 | */ | ||
21 | |||
22 | typedef struct { volatile int counter; } atomic_t; | ||
23 | |||
24 | #define ATOMIC_INIT(i) ( (atomic_t) { (i) } ) | ||
25 | |||
26 | #define atomic_read(v) ((v)->counter) | ||
27 | #define atomic_set(v,i) ((v)->counter = (i)) | ||
28 | |||
29 | #include <asm/system.h> | ||
30 | |||
31 | /* | ||
32 | * To get proper branch prediction for the main line, we must branch | ||
33 | * forward to code at the end of this object's .text section, then | ||
34 | * branch back to restart the operation. | ||
35 | */ | ||
36 | |||
37 | static __inline__ void atomic_add(int i, atomic_t * v) | ||
38 | { | ||
39 | unsigned long flags; | ||
40 | |||
41 | local_irq_save(flags); | ||
42 | *(long *)v += i; | ||
43 | local_irq_restore(flags); | ||
44 | } | ||
45 | |||
46 | static __inline__ void atomic_sub(int i, atomic_t *v) | ||
47 | { | ||
48 | unsigned long flags; | ||
49 | |||
50 | local_irq_save(flags); | ||
51 | *(long *)v -= i; | ||
52 | local_irq_restore(flags); | ||
53 | } | ||
54 | |||
55 | static __inline__ int atomic_add_return(int i, atomic_t * v) | ||
56 | { | ||
57 | unsigned long temp, flags; | ||
58 | |||
59 | local_irq_save(flags); | ||
60 | temp = *(long *)v; | ||
61 | temp += i; | ||
62 | *(long *)v = temp; | ||
63 | local_irq_restore(flags); | ||
64 | |||
65 | return temp; | ||
66 | } | ||
67 | |||
68 | #define atomic_add_negative(a, v) (atomic_add_return((a), (v)) < 0) | ||
69 | |||
70 | static __inline__ int atomic_sub_return(int i, atomic_t * v) | ||
71 | { | ||
72 | unsigned long temp, flags; | ||
73 | |||
74 | local_irq_save(flags); | ||
75 | temp = *(long *)v; | ||
76 | temp -= i; | ||
77 | *(long *)v = temp; | ||
78 | local_irq_restore(flags); | ||
79 | |||
80 | return temp; | ||
81 | } | ||
82 | |||
83 | #define atomic_dec_return(v) atomic_sub_return(1,(v)) | ||
84 | #define atomic_inc_return(v) atomic_add_return(1,(v)) | ||
85 | |||
86 | /* | ||
87 | * atomic_inc_and_test - increment and test | ||
88 | * @v: pointer of type atomic_t | ||
89 | * | ||
90 | * Atomically increments @v by 1 | ||
91 | * and returns true if the result is zero, or false for all | ||
92 | * other cases. | ||
93 | */ | ||
94 | #define atomic_inc_and_test(v) (atomic_inc_return(v) == 0) | ||
95 | |||
96 | #define atomic_sub_and_test(i,v) (atomic_sub_return((i), (v)) == 0) | ||
97 | #define atomic_dec_and_test(v) (atomic_sub_return(1, (v)) == 0) | ||
98 | |||
99 | #define atomic_inc(v) atomic_add(1,(v)) | ||
100 | #define atomic_dec(v) atomic_sub(1,(v)) | ||
101 | |||
102 | static inline int atomic_cmpxchg(atomic_t *v, int old, int new) | ||
103 | { | ||
104 | int ret; | ||
105 | unsigned long flags; | ||
106 | |||
107 | local_irq_save(flags); | ||
108 | ret = v->counter; | ||
109 | if (likely(ret == old)) | ||
110 | v->counter = new; | ||
111 | local_irq_restore(flags); | ||
112 | |||
113 | return ret; | ||
114 | } | ||
115 | |||
116 | #define atomic_xchg(v, new) (xchg(&((v)->counter), new)) | ||
117 | |||
118 | static inline int atomic_add_unless(atomic_t *v, int a, int u) | ||
119 | { | ||
120 | int ret; | ||
121 | unsigned long flags; | ||
122 | |||
123 | local_irq_save(flags); | ||
124 | ret = v->counter; | ||
125 | if (ret != u) | ||
126 | v->counter += a; | ||
127 | local_irq_restore(flags); | ||
128 | |||
129 | return ret != u; | ||
130 | } | ||
131 | #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0) | ||
132 | |||
133 | static __inline__ void atomic_clear_mask(unsigned int mask, atomic_t *v) | ||
134 | { | ||
135 | unsigned long flags; | ||
136 | |||
137 | local_irq_save(flags); | ||
138 | *(long *)v &= ~mask; | ||
139 | local_irq_restore(flags); | ||
140 | } | ||
141 | |||
142 | static __inline__ void atomic_set_mask(unsigned int mask, atomic_t *v) | ||
143 | { | ||
144 | unsigned long flags; | ||
145 | |||
146 | local_irq_save(flags); | ||
147 | *(long *)v |= mask; | ||
148 | local_irq_restore(flags); | ||
149 | } | ||
150 | |||
151 | /* Atomic operations are already serializing on SH */ | ||
152 | #define smp_mb__before_atomic_dec() barrier() | ||
153 | #define smp_mb__after_atomic_dec() barrier() | ||
154 | #define smp_mb__before_atomic_inc() barrier() | ||
155 | #define smp_mb__after_atomic_inc() barrier() | ||
156 | |||
157 | #include <asm-generic/atomic.h> | ||
158 | #endif /* __ASM_SH64_ATOMIC_H */ | ||
diff --git a/include/asm-sh64/auxvec.h b/include/asm-sh64/auxvec.h deleted file mode 100644 index 1ad5a44bdc76..000000000000 --- a/include/asm-sh64/auxvec.h +++ /dev/null | |||
@@ -1,4 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_AUXVEC_H | ||
2 | #define __ASM_SH64_AUXVEC_H | ||
3 | |||
4 | #endif /* __ASM_SH64_AUXVEC_H */ | ||
diff --git a/include/asm-sh64/bitops.h b/include/asm-sh64/bitops.h deleted file mode 100644 index 600c59efb4c2..000000000000 --- a/include/asm-sh64/bitops.h +++ /dev/null | |||
@@ -1,155 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_BITOPS_H | ||
2 | #define __ASM_SH64_BITOPS_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/bitops.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003 Paul Mundt | ||
13 | */ | ||
14 | |||
15 | #ifdef __KERNEL__ | ||
16 | |||
17 | #ifndef _LINUX_BITOPS_H | ||
18 | #error only <linux/bitops.h> can be included directly | ||
19 | #endif | ||
20 | |||
21 | #include <linux/compiler.h> | ||
22 | #include <asm/system.h> | ||
23 | /* For __swab32 */ | ||
24 | #include <asm/byteorder.h> | ||
25 | |||
26 | static __inline__ void set_bit(int nr, volatile void * addr) | ||
27 | { | ||
28 | int mask; | ||
29 | volatile unsigned int *a = addr; | ||
30 | unsigned long flags; | ||
31 | |||
32 | a += nr >> 5; | ||
33 | mask = 1 << (nr & 0x1f); | ||
34 | local_irq_save(flags); | ||
35 | *a |= mask; | ||
36 | local_irq_restore(flags); | ||
37 | } | ||
38 | |||
39 | /* | ||
40 | * clear_bit() doesn't provide any barrier for the compiler. | ||
41 | */ | ||
42 | #define smp_mb__before_clear_bit() barrier() | ||
43 | #define smp_mb__after_clear_bit() barrier() | ||
44 | static inline void clear_bit(int nr, volatile unsigned long *a) | ||
45 | { | ||
46 | int mask; | ||
47 | unsigned long flags; | ||
48 | |||
49 | a += nr >> 5; | ||
50 | mask = 1 << (nr & 0x1f); | ||
51 | local_irq_save(flags); | ||
52 | *a &= ~mask; | ||
53 | local_irq_restore(flags); | ||
54 | } | ||
55 | |||
56 | static __inline__ void change_bit(int nr, volatile void * addr) | ||
57 | { | ||
58 | int mask; | ||
59 | volatile unsigned int *a = addr; | ||
60 | unsigned long flags; | ||
61 | |||
62 | a += nr >> 5; | ||
63 | mask = 1 << (nr & 0x1f); | ||
64 | local_irq_save(flags); | ||
65 | *a ^= mask; | ||
66 | local_irq_restore(flags); | ||
67 | } | ||
68 | |||
69 | static __inline__ int test_and_set_bit(int nr, volatile void * addr) | ||
70 | { | ||
71 | int mask, retval; | ||
72 | volatile unsigned int *a = addr; | ||
73 | unsigned long flags; | ||
74 | |||
75 | a += nr >> 5; | ||
76 | mask = 1 << (nr & 0x1f); | ||
77 | local_irq_save(flags); | ||
78 | retval = (mask & *a) != 0; | ||
79 | *a |= mask; | ||
80 | local_irq_restore(flags); | ||
81 | |||
82 | return retval; | ||
83 | } | ||
84 | |||
85 | static __inline__ int test_and_clear_bit(int nr, volatile void * addr) | ||
86 | { | ||
87 | int mask, retval; | ||
88 | volatile unsigned int *a = addr; | ||
89 | unsigned long flags; | ||
90 | |||
91 | a += nr >> 5; | ||
92 | mask = 1 << (nr & 0x1f); | ||
93 | local_irq_save(flags); | ||
94 | retval = (mask & *a) != 0; | ||
95 | *a &= ~mask; | ||
96 | local_irq_restore(flags); | ||
97 | |||
98 | return retval; | ||
99 | } | ||
100 | |||
101 | static __inline__ int test_and_change_bit(int nr, volatile void * addr) | ||
102 | { | ||
103 | int mask, retval; | ||
104 | volatile unsigned int *a = addr; | ||
105 | unsigned long flags; | ||
106 | |||
107 | a += nr >> 5; | ||
108 | mask = 1 << (nr & 0x1f); | ||
109 | local_irq_save(flags); | ||
110 | retval = (mask & *a) != 0; | ||
111 | *a ^= mask; | ||
112 | local_irq_restore(flags); | ||
113 | |||
114 | return retval; | ||
115 | } | ||
116 | |||
117 | #include <asm-generic/bitops/non-atomic.h> | ||
118 | |||
119 | static __inline__ unsigned long ffz(unsigned long word) | ||
120 | { | ||
121 | unsigned long result, __d2, __d3; | ||
122 | |||
123 | __asm__("gettr tr0, %2\n\t" | ||
124 | "pta $+32, tr0\n\t" | ||
125 | "andi %1, 1, %3\n\t" | ||
126 | "beq %3, r63, tr0\n\t" | ||
127 | "pta $+4, tr0\n" | ||
128 | "0:\n\t" | ||
129 | "shlri.l %1, 1, %1\n\t" | ||
130 | "addi %0, 1, %0\n\t" | ||
131 | "andi %1, 1, %3\n\t" | ||
132 | "beqi %3, 1, tr0\n" | ||
133 | "1:\n\t" | ||
134 | "ptabs %2, tr0\n\t" | ||
135 | : "=r" (result), "=r" (word), "=r" (__d2), "=r" (__d3) | ||
136 | : "0" (0L), "1" (word)); | ||
137 | |||
138 | return result; | ||
139 | } | ||
140 | |||
141 | #include <asm-generic/bitops/__ffs.h> | ||
142 | #include <asm-generic/bitops/find.h> | ||
143 | #include <asm-generic/bitops/hweight.h> | ||
144 | #include <asm-generic/bitops/lock.h> | ||
145 | #include <asm-generic/bitops/sched.h> | ||
146 | #include <asm-generic/bitops/ffs.h> | ||
147 | #include <asm-generic/bitops/ext2-non-atomic.h> | ||
148 | #include <asm-generic/bitops/ext2-atomic.h> | ||
149 | #include <asm-generic/bitops/minix.h> | ||
150 | #include <asm-generic/bitops/fls.h> | ||
151 | #include <asm-generic/bitops/fls64.h> | ||
152 | |||
153 | #endif /* __KERNEL__ */ | ||
154 | |||
155 | #endif /* __ASM_SH64_BITOPS_H */ | ||
diff --git a/include/asm-sh64/bug.h b/include/asm-sh64/bug.h deleted file mode 100644 index f3a9c9248ef4..000000000000 --- a/include/asm-sh64/bug.h +++ /dev/null | |||
@@ -1,19 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_BUG_H | ||
2 | #define __ASM_SH64_BUG_H | ||
3 | |||
4 | #ifdef CONFIG_BUG | ||
5 | /* | ||
6 | * Tell the user there is some problem, then force a segfault (in process | ||
7 | * context) or a panic (interrupt context). | ||
8 | */ | ||
9 | #define BUG() do { \ | ||
10 | printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \ | ||
11 | *(volatile int *)0 = 0; \ | ||
12 | } while (0) | ||
13 | |||
14 | #define HAVE_ARCH_BUG | ||
15 | #endif | ||
16 | |||
17 | #include <asm-generic/bug.h> | ||
18 | |||
19 | #endif /* __ASM_SH64_BUG_H */ | ||
diff --git a/include/asm-sh64/bugs.h b/include/asm-sh64/bugs.h deleted file mode 100644 index 05554aaea672..000000000000 --- a/include/asm-sh64/bugs.h +++ /dev/null | |||
@@ -1,38 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_BUGS_H | ||
2 | #define __ASM_SH64_BUGS_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/bugs.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003 Paul Mundt | ||
13 | * | ||
14 | */ | ||
15 | |||
16 | /* | ||
17 | * This is included by init/main.c to check for architecture-dependent bugs. | ||
18 | * | ||
19 | * Needs: | ||
20 | * void check_bugs(void); | ||
21 | */ | ||
22 | |||
23 | /* | ||
24 | * I don't know of any Super-H bugs yet. | ||
25 | */ | ||
26 | |||
27 | #include <asm/processor.h> | ||
28 | |||
29 | static void __init check_bugs(void) | ||
30 | { | ||
31 | extern char *get_cpu_subtype(void); | ||
32 | extern unsigned long loops_per_jiffy; | ||
33 | |||
34 | cpu_data->loops_per_jiffy = loops_per_jiffy; | ||
35 | |||
36 | printk("CPU: %s\n", get_cpu_subtype()); | ||
37 | } | ||
38 | #endif /* __ASM_SH64_BUGS_H */ | ||
diff --git a/include/asm-sh64/byteorder.h b/include/asm-sh64/byteorder.h deleted file mode 100644 index 7419d78820ee..000000000000 --- a/include/asm-sh64/byteorder.h +++ /dev/null | |||
@@ -1,49 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_BYTEORDER_H | ||
2 | #define __ASM_SH64_BYTEORDER_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/byteorder.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #include <asm/types.h> | ||
16 | |||
17 | static inline __attribute_const__ __u32 ___arch__swab32(__u32 x) | ||
18 | { | ||
19 | __asm__("byterev %0, %0\n\t" | ||
20 | "shari %0, 32, %0" | ||
21 | : "=r" (x) | ||
22 | : "0" (x)); | ||
23 | return x; | ||
24 | } | ||
25 | |||
26 | static inline __attribute_const__ __u16 ___arch__swab16(__u16 x) | ||
27 | { | ||
28 | __asm__("byterev %0, %0\n\t" | ||
29 | "shari %0, 48, %0" | ||
30 | : "=r" (x) | ||
31 | : "0" (x)); | ||
32 | return x; | ||
33 | } | ||
34 | |||
35 | #define __arch__swab32(x) ___arch__swab32(x) | ||
36 | #define __arch__swab16(x) ___arch__swab16(x) | ||
37 | |||
38 | #if !defined(__STRICT_ANSI__) || defined(__KERNEL__) | ||
39 | # define __BYTEORDER_HAS_U64__ | ||
40 | # define __SWAB_64_THRU_32__ | ||
41 | #endif | ||
42 | |||
43 | #ifdef __LITTLE_ENDIAN__ | ||
44 | #include <linux/byteorder/little_endian.h> | ||
45 | #else | ||
46 | #include <linux/byteorder/big_endian.h> | ||
47 | #endif | ||
48 | |||
49 | #endif /* __ASM_SH64_BYTEORDER_H */ | ||
diff --git a/include/asm-sh64/cpumask.h b/include/asm-sh64/cpumask.h deleted file mode 100644 index b7b105dbedaf..000000000000 --- a/include/asm-sh64/cpumask.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_CPUMASK_H | ||
2 | #define __ASM_SH64_CPUMASK_H | ||
3 | |||
4 | #include <asm-generic/cpumask.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_CPUMASK_H */ | ||
diff --git a/include/asm-sh64/cputime.h b/include/asm-sh64/cputime.h deleted file mode 100644 index 0fd89da2aa86..000000000000 --- a/include/asm-sh64/cputime.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __SH64_CPUTIME_H | ||
2 | #define __SH64_CPUTIME_H | ||
3 | |||
4 | #include <asm-generic/cputime.h> | ||
5 | |||
6 | #endif /* __SH64_CPUTIME_H */ | ||
diff --git a/include/asm-sh64/current.h b/include/asm-sh64/current.h deleted file mode 100644 index 261224339d6f..000000000000 --- a/include/asm-sh64/current.h +++ /dev/null | |||
@@ -1,28 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_CURRENT_H | ||
2 | #define __ASM_SH64_CURRENT_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/current.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003 Paul Mundt | ||
13 | * | ||
14 | */ | ||
15 | |||
16 | #include <linux/thread_info.h> | ||
17 | |||
18 | struct task_struct; | ||
19 | |||
20 | static __inline__ struct task_struct * get_current(void) | ||
21 | { | ||
22 | return current_thread_info()->task; | ||
23 | } | ||
24 | |||
25 | #define current get_current() | ||
26 | |||
27 | #endif /* __ASM_SH64_CURRENT_H */ | ||
28 | |||
diff --git a/include/asm-sh64/delay.h b/include/asm-sh64/delay.h deleted file mode 100644 index 6ae31301a16a..000000000000 --- a/include/asm-sh64/delay.h +++ /dev/null | |||
@@ -1,11 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_DELAY_H | ||
2 | #define __ASM_SH64_DELAY_H | ||
3 | |||
4 | extern void __delay(int loops); | ||
5 | extern void __udelay(unsigned long long usecs, unsigned long lpj); | ||
6 | extern void __ndelay(unsigned long long nsecs, unsigned long lpj); | ||
7 | extern void udelay(unsigned long usecs); | ||
8 | extern void ndelay(unsigned long nsecs); | ||
9 | |||
10 | #endif /* __ASM_SH64_DELAY_H */ | ||
11 | |||
diff --git a/include/asm-sh64/device.h b/include/asm-sh64/device.h deleted file mode 100644 index d8f9872b0e2d..000000000000 --- a/include/asm-sh64/device.h +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | /* | ||
2 | * Arch specific extensions to struct device | ||
3 | * | ||
4 | * This file is released under the GPLv2 | ||
5 | */ | ||
6 | #include <asm-generic/device.h> | ||
7 | |||
diff --git a/include/asm-sh64/div64.h b/include/asm-sh64/div64.h deleted file mode 100644 index f75869565e2e..000000000000 --- a/include/asm-sh64/div64.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_DIV64_H | ||
2 | #define __ASM_SH64_DIV64_H | ||
3 | |||
4 | #include <asm-generic/div64.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_DIV64_H */ | ||
diff --git a/include/asm-sh64/dma-mapping.h b/include/asm-sh64/dma-mapping.h deleted file mode 100644 index 18f8dd642ac5..000000000000 --- a/include/asm-sh64/dma-mapping.h +++ /dev/null | |||
@@ -1,194 +0,0 @@ | |||
1 | #ifndef __ASM_SH_DMA_MAPPING_H | ||
2 | #define __ASM_SH_DMA_MAPPING_H | ||
3 | |||
4 | #include <linux/mm.h> | ||
5 | #include <linux/scatterlist.h> | ||
6 | #include <asm/io.h> | ||
7 | |||
8 | struct pci_dev; | ||
9 | extern void *consistent_alloc(struct pci_dev *hwdev, size_t size, | ||
10 | dma_addr_t *dma_handle); | ||
11 | extern void consistent_free(struct pci_dev *hwdev, size_t size, | ||
12 | void *vaddr, dma_addr_t dma_handle); | ||
13 | |||
14 | #define dma_supported(dev, mask) (1) | ||
15 | |||
16 | static inline int dma_set_mask(struct device *dev, u64 mask) | ||
17 | { | ||
18 | if (!dev->dma_mask || !dma_supported(dev, mask)) | ||
19 | return -EIO; | ||
20 | |||
21 | *dev->dma_mask = mask; | ||
22 | |||
23 | return 0; | ||
24 | } | ||
25 | |||
26 | static inline void *dma_alloc_coherent(struct device *dev, size_t size, | ||
27 | dma_addr_t *dma_handle, gfp_t flag) | ||
28 | { | ||
29 | return consistent_alloc(NULL, size, dma_handle); | ||
30 | } | ||
31 | |||
32 | static inline void dma_free_coherent(struct device *dev, size_t size, | ||
33 | void *vaddr, dma_addr_t dma_handle) | ||
34 | { | ||
35 | consistent_free(NULL, size, vaddr, dma_handle); | ||
36 | } | ||
37 | |||
38 | #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f) | ||
39 | #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h) | ||
40 | #define dma_is_consistent(d, h) (1) | ||
41 | |||
42 | static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size, | ||
43 | enum dma_data_direction dir) | ||
44 | { | ||
45 | unsigned long start = (unsigned long) vaddr; | ||
46 | unsigned long s = start & L1_CACHE_ALIGN_MASK; | ||
47 | unsigned long e = (start + size) & L1_CACHE_ALIGN_MASK; | ||
48 | |||
49 | for (; s <= e; s += L1_CACHE_BYTES) | ||
50 | asm volatile ("ocbp %0, 0" : : "r" (s)); | ||
51 | } | ||
52 | |||
53 | static inline dma_addr_t dma_map_single(struct device *dev, | ||
54 | void *ptr, size_t size, | ||
55 | enum dma_data_direction dir) | ||
56 | { | ||
57 | #if defined(CONFIG_PCI) && !defined(CONFIG_SH_PCIDMA_NONCOHERENT) | ||
58 | if (dev->bus == &pci_bus_type) | ||
59 | return virt_to_phys(ptr); | ||
60 | #endif | ||
61 | dma_cache_sync(dev, ptr, size, dir); | ||
62 | |||
63 | return virt_to_phys(ptr); | ||
64 | } | ||
65 | |||
66 | #define dma_unmap_single(dev, addr, size, dir) do { } while (0) | ||
67 | |||
68 | static inline int dma_map_sg(struct device *dev, struct scatterlist *sg, | ||
69 | int nents, enum dma_data_direction dir) | ||
70 | { | ||
71 | int i; | ||
72 | |||
73 | for (i = 0; i < nents; i++) { | ||
74 | #if !defined(CONFIG_PCI) || defined(CONFIG_SH_PCIDMA_NONCOHERENT) | ||
75 | dma_cache_sync(dev, sg_virt(&sg[i]), sg[i].length, dir); | ||
76 | #endif | ||
77 | sg[i].dma_address = sg_phys(&sg[i]); | ||
78 | } | ||
79 | |||
80 | return nents; | ||
81 | } | ||
82 | |||
83 | #define dma_unmap_sg(dev, sg, nents, dir) do { } while (0) | ||
84 | |||
85 | static inline dma_addr_t dma_map_page(struct device *dev, struct page *page, | ||
86 | unsigned long offset, size_t size, | ||
87 | enum dma_data_direction dir) | ||
88 | { | ||
89 | return dma_map_single(dev, page_address(page) + offset, size, dir); | ||
90 | } | ||
91 | |||
92 | static inline void dma_unmap_page(struct device *dev, dma_addr_t dma_address, | ||
93 | size_t size, enum dma_data_direction dir) | ||
94 | { | ||
95 | dma_unmap_single(dev, dma_address, size, dir); | ||
96 | } | ||
97 | |||
98 | static inline void dma_sync_single(struct device *dev, dma_addr_t dma_handle, | ||
99 | size_t size, enum dma_data_direction dir) | ||
100 | { | ||
101 | #if defined(CONFIG_PCI) && !defined(CONFIG_SH_PCIDMA_NONCOHERENT) | ||
102 | if (dev->bus == &pci_bus_type) | ||
103 | return; | ||
104 | #endif | ||
105 | dma_cache_sync(dev, phys_to_virt(dma_handle), size, dir); | ||
106 | } | ||
107 | |||
108 | static inline void dma_sync_single_range(struct device *dev, | ||
109 | dma_addr_t dma_handle, | ||
110 | unsigned long offset, size_t size, | ||
111 | enum dma_data_direction dir) | ||
112 | { | ||
113 | #if defined(CONFIG_PCI) && !defined(CONFIG_SH_PCIDMA_NONCOHERENT) | ||
114 | if (dev->bus == &pci_bus_type) | ||
115 | return; | ||
116 | #endif | ||
117 | dma_cache_sync(dev, phys_to_virt(dma_handle) + offset, size, dir); | ||
118 | } | ||
119 | |||
120 | static inline void dma_sync_sg(struct device *dev, struct scatterlist *sg, | ||
121 | int nelems, enum dma_data_direction dir) | ||
122 | { | ||
123 | int i; | ||
124 | |||
125 | for (i = 0; i < nelems; i++) { | ||
126 | #if !defined(CONFIG_PCI) || defined(CONFIG_SH_PCIDMA_NONCOHERENT) | ||
127 | dma_cache_sync(dev, sg_virt(&sg[i]), sg[i].length, dir); | ||
128 | #endif | ||
129 | sg[i].dma_address = sg_phys(&sg[i]); | ||
130 | } | ||
131 | } | ||
132 | |||
133 | static inline void dma_sync_single_for_cpu(struct device *dev, | ||
134 | dma_addr_t dma_handle, size_t size, | ||
135 | enum dma_data_direction dir) | ||
136 | { | ||
137 | dma_sync_single(dev, dma_handle, size, dir); | ||
138 | } | ||
139 | |||
140 | static inline void dma_sync_single_for_device(struct device *dev, | ||
141 | dma_addr_t dma_handle, size_t size, | ||
142 | enum dma_data_direction dir) | ||
143 | { | ||
144 | dma_sync_single(dev, dma_handle, size, dir); | ||
145 | } | ||
146 | |||
147 | static inline void dma_sync_single_range_for_cpu(struct device *dev, | ||
148 | dma_addr_t dma_handle, | ||
149 | unsigned long offset, | ||
150 | size_t size, | ||
151 | enum dma_data_direction direction) | ||
152 | { | ||
153 | dma_sync_single_for_cpu(dev, dma_handle+offset, size, direction); | ||
154 | } | ||
155 | |||
156 | static inline void dma_sync_single_range_for_device(struct device *dev, | ||
157 | dma_addr_t dma_handle, | ||
158 | unsigned long offset, | ||
159 | size_t size, | ||
160 | enum dma_data_direction direction) | ||
161 | { | ||
162 | dma_sync_single_for_device(dev, dma_handle+offset, size, direction); | ||
163 | } | ||
164 | |||
165 | static inline void dma_sync_sg_for_cpu(struct device *dev, | ||
166 | struct scatterlist *sg, int nelems, | ||
167 | enum dma_data_direction dir) | ||
168 | { | ||
169 | dma_sync_sg(dev, sg, nelems, dir); | ||
170 | } | ||
171 | |||
172 | static inline void dma_sync_sg_for_device(struct device *dev, | ||
173 | struct scatterlist *sg, int nelems, | ||
174 | enum dma_data_direction dir) | ||
175 | { | ||
176 | dma_sync_sg(dev, sg, nelems, dir); | ||
177 | } | ||
178 | |||
179 | static inline int dma_get_cache_alignment(void) | ||
180 | { | ||
181 | /* | ||
182 | * Each processor family will define its own L1_CACHE_SHIFT, | ||
183 | * L1_CACHE_BYTES wraps to this, so this is always safe. | ||
184 | */ | ||
185 | return L1_CACHE_BYTES; | ||
186 | } | ||
187 | |||
188 | static inline int dma_mapping_error(dma_addr_t dma_addr) | ||
189 | { | ||
190 | return dma_addr == 0; | ||
191 | } | ||
192 | |||
193 | #endif /* __ASM_SH_DMA_MAPPING_H */ | ||
194 | |||
diff --git a/include/asm-sh64/dma.h b/include/asm-sh64/dma.h deleted file mode 100644 index e701f39470a2..000000000000 --- a/include/asm-sh64/dma.h +++ /dev/null | |||
@@ -1,41 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_DMA_H | ||
2 | #define __ASM_SH64_DMA_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/dma.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003 Paul Mundt | ||
13 | * | ||
14 | */ | ||
15 | |||
16 | #include <linux/mm.h> | ||
17 | #include <asm/io.h> | ||
18 | #include <asm/pgtable.h> | ||
19 | |||
20 | #define MAX_DMA_CHANNELS 4 | ||
21 | |||
22 | /* | ||
23 | * SH5 can DMA in any memory area. | ||
24 | * | ||
25 | * The static definition is dodgy because it should limit | ||
26 | * the highest DMA-able address based on the actual | ||
27 | * Physical memory available. This is actually performed | ||
28 | * at run time in defining the memory allowed to DMA_ZONE. | ||
29 | */ | ||
30 | #define MAX_DMA_ADDRESS ~(NPHYS_MASK) | ||
31 | |||
32 | #define DMA_MODE_READ 0 | ||
33 | #define DMA_MODE_WRITE 1 | ||
34 | |||
35 | #ifdef CONFIG_PCI | ||
36 | extern int isa_dma_bridge_buggy; | ||
37 | #else | ||
38 | #define isa_dma_bridge_buggy (0) | ||
39 | #endif | ||
40 | |||
41 | #endif /* __ASM_SH64_DMA_H */ | ||
diff --git a/include/asm-sh64/elf.h b/include/asm-sh64/elf.h deleted file mode 100644 index f994286e1998..000000000000 --- a/include/asm-sh64/elf.h +++ /dev/null | |||
@@ -1,107 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_ELF_H | ||
2 | #define __ASM_SH64_ELF_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/elf.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | * ELF register definitions.. | ||
17 | */ | ||
18 | |||
19 | #include <asm/ptrace.h> | ||
20 | #include <asm/user.h> | ||
21 | #include <asm/byteorder.h> | ||
22 | |||
23 | typedef unsigned long elf_greg_t; | ||
24 | |||
25 | #define ELF_NGREG (sizeof (struct pt_regs) / sizeof(elf_greg_t)) | ||
26 | typedef elf_greg_t elf_gregset_t[ELF_NGREG]; | ||
27 | |||
28 | typedef struct user_fpu_struct elf_fpregset_t; | ||
29 | |||
30 | /* | ||
31 | * This is used to ensure we don't load something for the wrong architecture. | ||
32 | */ | ||
33 | #define elf_check_arch(x) ( (x)->e_machine == EM_SH ) | ||
34 | |||
35 | /* | ||
36 | * These are used to set parameters in the core dumps. | ||
37 | */ | ||
38 | #define ELF_CLASS ELFCLASS32 | ||
39 | #ifdef __LITTLE_ENDIAN__ | ||
40 | #define ELF_DATA ELFDATA2LSB | ||
41 | #else | ||
42 | #define ELF_DATA ELFDATA2MSB | ||
43 | #endif | ||
44 | #define ELF_ARCH EM_SH | ||
45 | |||
46 | #define USE_ELF_CORE_DUMP | ||
47 | #define ELF_EXEC_PAGESIZE 4096 | ||
48 | |||
49 | /* This is the location that an ET_DYN program is loaded if exec'ed. Typical | ||
50 | use of this is to invoke "./ld.so someprog" to test out a new version of | ||
51 | the loader. We need to make sure that it is out of the way of the program | ||
52 | that it will "exec", and that there is sufficient room for the brk. */ | ||
53 | |||
54 | #define ELF_ET_DYN_BASE (2 * TASK_SIZE / 3) | ||
55 | |||
56 | #define R_SH_DIR32 1 | ||
57 | #define R_SH_REL32 2 | ||
58 | #define R_SH_IMM_LOW16 246 | ||
59 | #define R_SH_IMM_LOW16_PCREL 247 | ||
60 | #define R_SH_IMM_MEDLOW16 248 | ||
61 | #define R_SH_IMM_MEDLOW16_PCREL 249 | ||
62 | |||
63 | #define ELF_CORE_COPY_REGS(_dest,_regs) \ | ||
64 | memcpy((char *) &_dest, (char *) _regs, \ | ||
65 | sizeof(struct pt_regs)); | ||
66 | |||
67 | /* This yields a mask that user programs can use to figure out what | ||
68 | instruction set this CPU supports. This could be done in user space, | ||
69 | but it's not easy, and we've already done it here. */ | ||
70 | |||
71 | #define ELF_HWCAP (0) | ||
72 | |||
73 | /* This yields a string that ld.so will use to load implementation | ||
74 | specific libraries for optimization. This is more specific in | ||
75 | intent than poking at uname or /proc/cpuinfo. | ||
76 | |||
77 | For the moment, we have only optimizations for the Intel generations, | ||
78 | but that could change... */ | ||
79 | |||
80 | #define ELF_PLATFORM (NULL) | ||
81 | |||
82 | #define ELF_PLAT_INIT(_r, load_addr) \ | ||
83 | do { _r->regs[0]=0; _r->regs[1]=0; _r->regs[2]=0; _r->regs[3]=0; \ | ||
84 | _r->regs[4]=0; _r->regs[5]=0; _r->regs[6]=0; _r->regs[7]=0; \ | ||
85 | _r->regs[8]=0; _r->regs[9]=0; _r->regs[10]=0; _r->regs[11]=0; \ | ||
86 | _r->regs[12]=0; _r->regs[13]=0; _r->regs[14]=0; _r->regs[15]=0; \ | ||
87 | _r->regs[16]=0; _r->regs[17]=0; _r->regs[18]=0; _r->regs[19]=0; \ | ||
88 | _r->regs[20]=0; _r->regs[21]=0; _r->regs[22]=0; _r->regs[23]=0; \ | ||
89 | _r->regs[24]=0; _r->regs[25]=0; _r->regs[26]=0; _r->regs[27]=0; \ | ||
90 | _r->regs[28]=0; _r->regs[29]=0; _r->regs[30]=0; _r->regs[31]=0; \ | ||
91 | _r->regs[32]=0; _r->regs[33]=0; _r->regs[34]=0; _r->regs[35]=0; \ | ||
92 | _r->regs[36]=0; _r->regs[37]=0; _r->regs[38]=0; _r->regs[39]=0; \ | ||
93 | _r->regs[40]=0; _r->regs[41]=0; _r->regs[42]=0; _r->regs[43]=0; \ | ||
94 | _r->regs[44]=0; _r->regs[45]=0; _r->regs[46]=0; _r->regs[47]=0; \ | ||
95 | _r->regs[48]=0; _r->regs[49]=0; _r->regs[50]=0; _r->regs[51]=0; \ | ||
96 | _r->regs[52]=0; _r->regs[53]=0; _r->regs[54]=0; _r->regs[55]=0; \ | ||
97 | _r->regs[56]=0; _r->regs[57]=0; _r->regs[58]=0; _r->regs[59]=0; \ | ||
98 | _r->regs[60]=0; _r->regs[61]=0; _r->regs[62]=0; \ | ||
99 | _r->tregs[0]=0; _r->tregs[1]=0; _r->tregs[2]=0; _r->tregs[3]=0; \ | ||
100 | _r->tregs[4]=0; _r->tregs[5]=0; _r->tregs[6]=0; _r->tregs[7]=0; \ | ||
101 | _r->sr = SR_FD | SR_MMU; } while (0) | ||
102 | |||
103 | #ifdef __KERNEL__ | ||
104 | #define SET_PERSONALITY(ex, ibcs2) set_personality(PER_LINUX_32BIT) | ||
105 | #endif | ||
106 | |||
107 | #endif /* __ASM_SH64_ELF_H */ | ||
diff --git a/include/asm-sh64/emergency-restart.h b/include/asm-sh64/emergency-restart.h deleted file mode 100644 index 108d8c48e42e..000000000000 --- a/include/asm-sh64/emergency-restart.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef _ASM_EMERGENCY_RESTART_H | ||
2 | #define _ASM_EMERGENCY_RESTART_H | ||
3 | |||
4 | #include <asm-generic/emergency-restart.h> | ||
5 | |||
6 | #endif /* _ASM_EMERGENCY_RESTART_H */ | ||
diff --git a/include/asm-sh64/errno.h b/include/asm-sh64/errno.h deleted file mode 100644 index 57b46d4bdd41..000000000000 --- a/include/asm-sh64/errno.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_ERRNO_H | ||
2 | #define __ASM_SH64_ERRNO_H | ||
3 | |||
4 | #include <asm-generic/errno.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_ERRNO_H */ | ||
diff --git a/include/asm-sh64/fb.h b/include/asm-sh64/fb.h deleted file mode 100644 index d92e99cd8c8a..000000000000 --- a/include/asm-sh64/fb.h +++ /dev/null | |||
@@ -1,19 +0,0 @@ | |||
1 | #ifndef _ASM_FB_H_ | ||
2 | #define _ASM_FB_H_ | ||
3 | |||
4 | #include <linux/fb.h> | ||
5 | #include <linux/fs.h> | ||
6 | #include <asm/page.h> | ||
7 | |||
8 | static inline void fb_pgprotect(struct file *file, struct vm_area_struct *vma, | ||
9 | unsigned long off) | ||
10 | { | ||
11 | vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); | ||
12 | } | ||
13 | |||
14 | static inline int fb_is_primary_device(struct fb_info *info) | ||
15 | { | ||
16 | return 0; | ||
17 | } | ||
18 | |||
19 | #endif /* _ASM_FB_H_ */ | ||
diff --git a/include/asm-sh64/fcntl.h b/include/asm-sh64/fcntl.h deleted file mode 100644 index 744dd79b9d5d..000000000000 --- a/include/asm-sh64/fcntl.h +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | #include <asm-sh/fcntl.h> | ||
diff --git a/include/asm-sh64/futex.h b/include/asm-sh64/futex.h deleted file mode 100644 index 6a332a9f099c..000000000000 --- a/include/asm-sh64/futex.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef _ASM_FUTEX_H | ||
2 | #define _ASM_FUTEX_H | ||
3 | |||
4 | #include <asm-generic/futex.h> | ||
5 | |||
6 | #endif | ||
diff --git a/include/asm-sh64/gpio.h b/include/asm-sh64/gpio.h deleted file mode 100644 index 6bc5a13d8415..000000000000 --- a/include/asm-sh64/gpio.h +++ /dev/null | |||
@@ -1,8 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_GPIO_H | ||
2 | #define __ASM_SH64_GPIO_H | ||
3 | |||
4 | /* | ||
5 | * This is just a stub, so that every arch using sh-sci has a gpio.h | ||
6 | */ | ||
7 | |||
8 | #endif /* __ASM_SH64_GPIO_H */ | ||
diff --git a/include/asm-sh64/hardirq.h b/include/asm-sh64/hardirq.h deleted file mode 100644 index 555fd7a35108..000000000000 --- a/include/asm-sh64/hardirq.h +++ /dev/null | |||
@@ -1,18 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_HARDIRQ_H | ||
2 | #define __ASM_SH64_HARDIRQ_H | ||
3 | |||
4 | #include <linux/threads.h> | ||
5 | #include <linux/irq.h> | ||
6 | |||
7 | /* entry.S is sensitive to the offsets of these fields */ | ||
8 | typedef struct { | ||
9 | unsigned int __softirq_pending; | ||
10 | } ____cacheline_aligned irq_cpustat_t; | ||
11 | |||
12 | #include <linux/irq_cpustat.h> /* Standard mappings for irq_cpustat_t above */ | ||
13 | |||
14 | /* arch/sh64/kernel/irq.c */ | ||
15 | extern void ack_bad_irq(unsigned int irq); | ||
16 | |||
17 | #endif /* __ASM_SH64_HARDIRQ_H */ | ||
18 | |||
diff --git a/include/asm-sh64/hw_irq.h b/include/asm-sh64/hw_irq.h deleted file mode 100644 index ebb39089b0ac..000000000000 --- a/include/asm-sh64/hw_irq.h +++ /dev/null | |||
@@ -1,15 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_HW_IRQ_H | ||
2 | #define __ASM_SH64_HW_IRQ_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/hw_irq.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #endif /* __ASM_SH64_HW_IRQ_H */ | ||
diff --git a/include/asm-sh64/ide.h b/include/asm-sh64/ide.h deleted file mode 100644 index b6e31e8b9410..000000000000 --- a/include/asm-sh64/ide.h +++ /dev/null | |||
@@ -1,29 +0,0 @@ | |||
1 | /* | ||
2 | * linux/include/asm-sh64/ide.h | ||
3 | * | ||
4 | * Copyright (C) 1994-1996 Linus Torvalds & authors | ||
5 | * | ||
6 | * sh64 version by Richard Curnow & Paul Mundt | ||
7 | */ | ||
8 | |||
9 | /* | ||
10 | * This file contains the sh64 architecture specific IDE code. | ||
11 | */ | ||
12 | |||
13 | #ifndef __ASM_SH64_IDE_H | ||
14 | #define __ASM_SH64_IDE_H | ||
15 | |||
16 | #ifdef __KERNEL__ | ||
17 | |||
18 | |||
19 | /* Without this, the initialisation of PCI IDE cards end up calling | ||
20 | * ide_init_hwif_ports, which won't work. */ | ||
21 | #ifdef CONFIG_BLK_DEV_IDEPCI | ||
22 | #define ide_default_io_ctl(base) (0) | ||
23 | #endif | ||
24 | |||
25 | #include <asm-generic/ide_iops.h> | ||
26 | |||
27 | #endif /* __KERNEL__ */ | ||
28 | |||
29 | #endif /* __ASM_SH64_IDE_H */ | ||
diff --git a/include/asm-sh64/ioctl.h b/include/asm-sh64/ioctl.h deleted file mode 100644 index b279fe06dfe5..000000000000 --- a/include/asm-sh64/ioctl.h +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | #include <asm-generic/ioctl.h> | ||
diff --git a/include/asm-sh64/ioctls.h b/include/asm-sh64/ioctls.h deleted file mode 100644 index 6b0c04f63c57..000000000000 --- a/include/asm-sh64/ioctls.h +++ /dev/null | |||
@@ -1,116 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_IOCTLS_H | ||
2 | #define __ASM_SH64_IOCTLS_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/ioctls.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2004 Richard Curnow | ||
13 | * | ||
14 | */ | ||
15 | |||
16 | #include <asm/ioctl.h> | ||
17 | |||
18 | #define FIOCLEX 0x6601 /* _IO('f', 1) */ | ||
19 | #define FIONCLEX 0x6602 /* _IO('f', 2) */ | ||
20 | #define FIOASYNC 0x4004667d /* _IOW('f', 125, int) */ | ||
21 | #define FIONBIO 0x4004667e /* _IOW('f', 126, int) */ | ||
22 | #define FIONREAD 0x8004667f /* _IOW('f', 127, int) */ | ||
23 | #define TIOCINQ FIONREAD | ||
24 | #define FIOQSIZE 0x80086680 /* _IOR('f', 128, loff_t) */ | ||
25 | |||
26 | #define TCGETS 0x5401 | ||
27 | #define TCSETS 0x5402 | ||
28 | #define TCSETSW 0x5403 | ||
29 | #define TCSETSF 0x5404 | ||
30 | |||
31 | #define TCGETA 0x80127417 /* _IOR('t', 23, struct termio) */ | ||
32 | #define TCSETA 0x40127418 /* _IOW('t', 24, struct termio) */ | ||
33 | #define TCSETAW 0x40127419 /* _IOW('t', 25, struct termio) */ | ||
34 | #define TCSETAF 0x4012741c /* _IOW('t', 28, struct termio) */ | ||
35 | |||
36 | #define TCSBRK 0x741d /* _IO('t', 29) */ | ||
37 | #define TCXONC 0x741e /* _IO('t', 30) */ | ||
38 | #define TCFLSH 0x741f /* _IO('t', 31) */ | ||
39 | |||
40 | #define TIOCSWINSZ 0x40087467 /* _IOW('t', 103, struct winsize) */ | ||
41 | #define TIOCGWINSZ 0x80087468 /* _IOR('t', 104, struct winsize) */ | ||
42 | #define TIOCSTART 0x746e /* _IO('t', 110) start output, like ^Q */ | ||
43 | #define TIOCSTOP 0x746f /* _IO('t', 111) stop output, like ^S */ | ||
44 | #define TIOCOUTQ 0x80047473 /* _IOR('t', 115, int) output queue size */ | ||
45 | |||
46 | #define TIOCSPGRP 0x40047476 /* _IOW('t', 118, int) */ | ||
47 | #define TIOCGPGRP 0x80047477 /* _IOR('t', 119, int) */ | ||
48 | |||
49 | #define TIOCEXCL 0x540c /* _IO('T', 12) */ | ||
50 | #define TIOCNXCL 0x540d /* _IO('T', 13) */ | ||
51 | #define TIOCSCTTY 0x540e /* _IO('T', 14) */ | ||
52 | |||
53 | #define TIOCSTI 0x40015412 /* _IOW('T', 18, char) 0x5412 */ | ||
54 | #define TIOCMGET 0x80045415 /* _IOR('T', 21, unsigned int) 0x5415 */ | ||
55 | #define TIOCMBIS 0x40045416 /* _IOW('T', 22, unsigned int) 0x5416 */ | ||
56 | #define TIOCMBIC 0x40045417 /* _IOW('T', 23, unsigned int) 0x5417 */ | ||
57 | #define TIOCMSET 0x40045418 /* _IOW('T', 24, unsigned int) 0x5418 */ | ||
58 | |||
59 | #define TIOCM_LE 0x001 | ||
60 | #define TIOCM_DTR 0x002 | ||
61 | #define TIOCM_RTS 0x004 | ||
62 | #define TIOCM_ST 0x008 | ||
63 | #define TIOCM_SR 0x010 | ||
64 | #define TIOCM_CTS 0x020 | ||
65 | #define TIOCM_CAR 0x040 | ||
66 | #define TIOCM_RNG 0x080 | ||
67 | #define TIOCM_DSR 0x100 | ||
68 | #define TIOCM_CD TIOCM_CAR | ||
69 | #define TIOCM_RI TIOCM_RNG | ||
70 | |||
71 | #define TIOCGSOFTCAR 0x80045419 /* _IOR('T', 25, unsigned int) 0x5419 */ | ||
72 | #define TIOCSSOFTCAR 0x4004541a /* _IOW('T', 26, unsigned int) 0x541A */ | ||
73 | #define TIOCLINUX 0x4004541c /* _IOW('T', 28, char) 0x541C */ | ||
74 | #define TIOCCONS 0x541d /* _IO('T', 29) */ | ||
75 | #define TIOCGSERIAL 0x803c541e /* _IOR('T', 30, struct serial_struct) 0x541E */ | ||
76 | #define TIOCSSERIAL 0x403c541f /* _IOW('T', 31, struct serial_struct) 0x541F */ | ||
77 | #define TIOCPKT 0x40045420 /* _IOW('T', 32, int) 0x5420 */ | ||
78 | |||
79 | #define TIOCPKT_DATA 0 | ||
80 | #define TIOCPKT_FLUSHREAD 1 | ||
81 | #define TIOCPKT_FLUSHWRITE 2 | ||
82 | #define TIOCPKT_STOP 4 | ||
83 | #define TIOCPKT_START 8 | ||
84 | #define TIOCPKT_NOSTOP 16 | ||
85 | #define TIOCPKT_DOSTOP 32 | ||
86 | |||
87 | |||
88 | #define TIOCNOTTY 0x5422 /* _IO('T', 34) */ | ||
89 | #define TIOCSETD 0x40045423 /* _IOW('T', 35, int) 0x5423 */ | ||
90 | #define TIOCGETD 0x80045424 /* _IOR('T', 36, int) 0x5424 */ | ||
91 | #define TCSBRKP 0x40045424 /* _IOW('T', 37, int) 0x5425 */ /* Needed for POSIX tcsendbreak() */ | ||
92 | #define TIOCTTYGSTRUCT 0x8c105426 /* _IOR('T', 38, struct tty_struct) 0x5426 */ /* For debugging only */ | ||
93 | #define TIOCSBRK 0x5427 /* _IO('T', 39) */ /* BSD compatibility */ | ||
94 | #define TIOCCBRK 0x5428 /* _IO('T', 40) */ /* BSD compatibility */ | ||
95 | #define TIOCGSID 0x80045429 /* _IOR('T', 41, pid_t) 0x5429 */ /* Return the session ID of FD */ | ||
96 | #define TIOCGPTN 0x80045430 /* _IOR('T',0x30, unsigned int) 0x5430 Get Pty Number (of pty-mux device) */ | ||
97 | #define TIOCSPTLCK 0x40045431 /* _IOW('T',0x31, int) Lock/unlock Pty */ | ||
98 | |||
99 | #define TIOCSERCONFIG 0x5453 /* _IO('T', 83) */ | ||
100 | #define TIOCSERGWILD 0x80045454 /* _IOR('T', 84, int) 0x5454 */ | ||
101 | #define TIOCSERSWILD 0x40045455 /* _IOW('T', 85, int) 0x5455 */ | ||
102 | #define TIOCGLCKTRMIOS 0x5456 | ||
103 | #define TIOCSLCKTRMIOS 0x5457 | ||
104 | #define TIOCSERGSTRUCT 0x80d85458 /* _IOR('T', 88, struct async_struct) 0x5458 */ /* For debugging only */ | ||
105 | #define TIOCSERGETLSR 0x80045459 /* _IOR('T', 89, unsigned int) 0x5459 */ /* Get line status register */ | ||
106 | |||
107 | /* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */ | ||
108 | #define TIOCSER_TEMT 0x01 /* Transmitter physically empty */ | ||
109 | |||
110 | #define TIOCSERGETMULTI 0x80a8545a /* _IOR('T', 90, struct serial_multiport_struct) 0x545A */ /* Get multiport config */ | ||
111 | #define TIOCSERSETMULTI 0x40a8545b /* _IOW('T', 91, struct serial_multiport_struct) 0x545B */ /* Set multiport config */ | ||
112 | |||
113 | #define TIOCMIWAIT 0x545c /* _IO('T', 92) wait for a change on serial input line(s) */ | ||
114 | #define TIOCGICOUNT 0x545d /* read serial port inline interrupt counts */ | ||
115 | |||
116 | #endif /* __ASM_SH64_IOCTLS_H */ | ||
diff --git a/include/asm-sh64/ipcbuf.h b/include/asm-sh64/ipcbuf.h deleted file mode 100644 index c441e35299c0..000000000000 --- a/include/asm-sh64/ipcbuf.h +++ /dev/null | |||
@@ -1,40 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_IPCBUF_H__ | ||
2 | #define __ASM_SH64_IPCBUF_H__ | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/ipcbuf.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | * The ipc64_perm structure for i386 architecture. | ||
17 | * Note extra padding because this structure is passed back and forth | ||
18 | * between kernel and user space. | ||
19 | * | ||
20 | * Pad space is left for: | ||
21 | * - 32-bit mode_t and seq | ||
22 | * - 2 miscellaneous 32-bit values | ||
23 | */ | ||
24 | |||
25 | struct ipc64_perm | ||
26 | { | ||
27 | __kernel_key_t key; | ||
28 | __kernel_uid32_t uid; | ||
29 | __kernel_gid32_t gid; | ||
30 | __kernel_uid32_t cuid; | ||
31 | __kernel_gid32_t cgid; | ||
32 | __kernel_mode_t mode; | ||
33 | unsigned short __pad1; | ||
34 | unsigned short seq; | ||
35 | unsigned short __pad2; | ||
36 | unsigned long __unused1; | ||
37 | unsigned long __unused2; | ||
38 | }; | ||
39 | |||
40 | #endif /* __ASM_SH64_IPCBUF_H__ */ | ||
diff --git a/include/asm-sh64/irq_regs.h b/include/asm-sh64/irq_regs.h deleted file mode 100644 index 3dd9c0b70270..000000000000 --- a/include/asm-sh64/irq_regs.h +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | #include <asm-generic/irq_regs.h> | ||
diff --git a/include/asm-sh64/kdebug.h b/include/asm-sh64/kdebug.h deleted file mode 100644 index 6ece1b037665..000000000000 --- a/include/asm-sh64/kdebug.h +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | #include <asm-generic/kdebug.h> | ||
diff --git a/include/asm-sh64/kmap_types.h b/include/asm-sh64/kmap_types.h deleted file mode 100644 index 2ae7c7587919..000000000000 --- a/include/asm-sh64/kmap_types.h +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_KMAP_TYPES_H | ||
2 | #define __ASM_SH64_KMAP_TYPES_H | ||
3 | |||
4 | #include <asm-sh/kmap_types.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_KMAP_TYPES_H */ | ||
7 | |||
diff --git a/include/asm-sh64/linkage.h b/include/asm-sh64/linkage.h deleted file mode 100644 index 1dd0e84a228d..000000000000 --- a/include/asm-sh64/linkage.h +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_LINKAGE_H | ||
2 | #define __ASM_SH64_LINKAGE_H | ||
3 | |||
4 | #include <asm-sh/linkage.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_LINKAGE_H */ | ||
7 | |||
diff --git a/include/asm-sh64/local.h b/include/asm-sh64/local.h deleted file mode 100644 index d9bd95dd36e2..000000000000 --- a/include/asm-sh64/local.h +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_LOCAL_H | ||
2 | #define __ASM_SH64_LOCAL_H | ||
3 | |||
4 | #include <asm-generic/local.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_LOCAL_H */ | ||
7 | |||
diff --git a/include/asm-sh64/mc146818rtc.h b/include/asm-sh64/mc146818rtc.h deleted file mode 100644 index 6cd3aec68dbe..000000000000 --- a/include/asm-sh64/mc146818rtc.h +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | /* | ||
2 | * linux/include/asm-sh64/mc146818rtc.h | ||
3 | * | ||
4 | */ | ||
5 | |||
6 | /* For now, an empty place-holder to get IDE to compile. */ | ||
7 | |||
diff --git a/include/asm-sh64/mman.h b/include/asm-sh64/mman.h deleted file mode 100644 index a9be6d885c3e..000000000000 --- a/include/asm-sh64/mman.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_MMAN_H | ||
2 | #define __ASM_SH64_MMAN_H | ||
3 | |||
4 | #include <asm-sh/mman.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_MMAN_H */ | ||
diff --git a/include/asm-sh64/mmu.h b/include/asm-sh64/mmu.h deleted file mode 100644 index ccd36d26615a..000000000000 --- a/include/asm-sh64/mmu.h +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | #ifndef __MMU_H | ||
2 | #define __MMU_H | ||
3 | |||
4 | /* Default "unsigned long" context */ | ||
5 | typedef unsigned long mm_context_t; | ||
6 | |||
7 | #endif | ||
diff --git a/include/asm-sh64/module.h b/include/asm-sh64/module.h deleted file mode 100644 index c313650d3d93..000000000000 --- a/include/asm-sh64/module.h +++ /dev/null | |||
@@ -1,20 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_MODULE_H | ||
2 | #define __ASM_SH64_MODULE_H | ||
3 | /* | ||
4 | * This file contains the SH architecture specific module code. | ||
5 | */ | ||
6 | |||
7 | struct mod_arch_specific { | ||
8 | /* empty */ | ||
9 | }; | ||
10 | |||
11 | #define Elf_Shdr Elf32_Shdr | ||
12 | #define Elf_Sym Elf32_Sym | ||
13 | #define Elf_Ehdr Elf32_Ehdr | ||
14 | |||
15 | #define module_map(x) vmalloc(x) | ||
16 | #define module_unmap(x) vfree(x) | ||
17 | #define module_arch_init(x) (0) | ||
18 | #define arch_init_modules(x) do { } while (0) | ||
19 | |||
20 | #endif /* __ASM_SH64_MODULE_H */ | ||
diff --git a/include/asm-sh64/msgbuf.h b/include/asm-sh64/msgbuf.h deleted file mode 100644 index cf0494ce0ba8..000000000000 --- a/include/asm-sh64/msgbuf.h +++ /dev/null | |||
@@ -1,42 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_MSGBUF_H | ||
2 | #define __ASM_SH64_MSGBUF_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/msgbuf.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | * The msqid64_ds structure for i386 architecture. | ||
17 | * Note extra padding because this structure is passed back and forth | ||
18 | * between kernel and user space. | ||
19 | * | ||
20 | * Pad space is left for: | ||
21 | * - 64-bit time_t to solve y2038 problem | ||
22 | * - 2 miscellaneous 32-bit values | ||
23 | */ | ||
24 | |||
25 | struct msqid64_ds { | ||
26 | struct ipc64_perm msg_perm; | ||
27 | __kernel_time_t msg_stime; /* last msgsnd time */ | ||
28 | unsigned long __unused1; | ||
29 | __kernel_time_t msg_rtime; /* last msgrcv time */ | ||
30 | unsigned long __unused2; | ||
31 | __kernel_time_t msg_ctime; /* last change time */ | ||
32 | unsigned long __unused3; | ||
33 | unsigned long msg_cbytes; /* current number of bytes on queue */ | ||
34 | unsigned long msg_qnum; /* number of messages in queue */ | ||
35 | unsigned long msg_qbytes; /* max number of bytes on queue */ | ||
36 | __kernel_pid_t msg_lspid; /* pid of last msgsnd */ | ||
37 | __kernel_pid_t msg_lrpid; /* last receive pid */ | ||
38 | unsigned long __unused4; | ||
39 | unsigned long __unused5; | ||
40 | }; | ||
41 | |||
42 | #endif /* __ASM_SH64_MSGBUF_H */ | ||
diff --git a/include/asm-sh64/mutex.h b/include/asm-sh64/mutex.h deleted file mode 100644 index 458c1f7fbc18..000000000000 --- a/include/asm-sh64/mutex.h +++ /dev/null | |||
@@ -1,9 +0,0 @@ | |||
1 | /* | ||
2 | * Pull in the generic implementation for the mutex fastpath. | ||
3 | * | ||
4 | * TODO: implement optimized primitives instead, or leave the generic | ||
5 | * implementation in place, or pick the atomic_xchg() based generic | ||
6 | * implementation. (see asm-generic/mutex-xchg.h for details) | ||
7 | */ | ||
8 | |||
9 | #include <asm-generic/mutex-dec.h> | ||
diff --git a/include/asm-sh64/namei.h b/include/asm-sh64/namei.h deleted file mode 100644 index 99d759a805ce..000000000000 --- a/include/asm-sh64/namei.h +++ /dev/null | |||
@@ -1,24 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_NAMEI_H | ||
2 | #define __ASM_SH64_NAMEI_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/namei.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | * Included from linux/fs/namei.c | ||
14 | * | ||
15 | */ | ||
16 | |||
17 | /* This dummy routine maybe changed to something useful | ||
18 | * for /usr/gnemul/ emulation stuff. | ||
19 | * Look at asm-sparc/namei.h for details. | ||
20 | */ | ||
21 | |||
22 | #define __emul_prefix() NULL | ||
23 | |||
24 | #endif /* __ASM_SH64_NAMEI_H */ | ||
diff --git a/include/asm-sh64/page.h b/include/asm-sh64/page.h deleted file mode 100644 index 472089aefc60..000000000000 --- a/include/asm-sh64/page.h +++ /dev/null | |||
@@ -1,119 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_PAGE_H | ||
2 | #define __ASM_SH64_PAGE_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/page.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003, 2004 Paul Mundt | ||
13 | * | ||
14 | * benedict.gaster@superh.com 19th, 24th July 2002. | ||
15 | * | ||
16 | * Modified to take account of enabling for D-CACHE support. | ||
17 | * | ||
18 | */ | ||
19 | |||
20 | |||
21 | /* PAGE_SHIFT determines the page size */ | ||
22 | #define PAGE_SHIFT 12 | ||
23 | #ifdef __ASSEMBLY__ | ||
24 | #define PAGE_SIZE 4096 | ||
25 | #else | ||
26 | #define PAGE_SIZE (1UL << PAGE_SHIFT) | ||
27 | #endif | ||
28 | #define PAGE_MASK (~(PAGE_SIZE-1)) | ||
29 | #define PTE_MASK PAGE_MASK | ||
30 | |||
31 | #if defined(CONFIG_HUGETLB_PAGE_SIZE_64K) | ||
32 | #define HPAGE_SHIFT 16 | ||
33 | #elif defined(CONFIG_HUGETLB_PAGE_SIZE_1MB) | ||
34 | #define HPAGE_SHIFT 20 | ||
35 | #elif defined(CONFIG_HUGETLB_PAGE_SIZE_512MB) | ||
36 | #define HPAGE_SHIFT 29 | ||
37 | #endif | ||
38 | |||
39 | #ifdef CONFIG_HUGETLB_PAGE | ||
40 | #define HPAGE_SIZE (1UL << HPAGE_SHIFT) | ||
41 | #define HPAGE_MASK (~(HPAGE_SIZE-1)) | ||
42 | #define HUGETLB_PAGE_ORDER (HPAGE_SHIFT-PAGE_SHIFT) | ||
43 | #define ARCH_HAS_SETCLEAR_HUGE_PTE | ||
44 | #endif | ||
45 | |||
46 | #ifdef __KERNEL__ | ||
47 | #ifndef __ASSEMBLY__ | ||
48 | |||
49 | extern struct page *mem_map; | ||
50 | extern void sh64_page_clear(void *page); | ||
51 | extern void sh64_page_copy(void *from, void *to); | ||
52 | |||
53 | #define clear_page(page) sh64_page_clear(page) | ||
54 | #define copy_page(to,from) sh64_page_copy(from, to) | ||
55 | |||
56 | #if defined(CONFIG_DCACHE_DISABLED) | ||
57 | |||
58 | #define clear_user_page(page, vaddr, pg) clear_page(page) | ||
59 | #define copy_user_page(to, from, vaddr, pg) copy_page(to, from) | ||
60 | |||
61 | #else | ||
62 | |||
63 | extern void clear_user_page(void *to, unsigned long address, struct page *pg); | ||
64 | extern void copy_user_page(void *to, void *from, unsigned long address, struct page *pg); | ||
65 | |||
66 | #endif /* defined(CONFIG_DCACHE_DISABLED) */ | ||
67 | |||
68 | /* | ||
69 | * These are used to make use of C type-checking.. | ||
70 | */ | ||
71 | typedef struct { unsigned long long pte; } pte_t; | ||
72 | typedef struct { unsigned long pmd; } pmd_t; | ||
73 | typedef struct { unsigned long pgd; } pgd_t; | ||
74 | typedef struct { unsigned long pgprot; } pgprot_t; | ||
75 | |||
76 | #define pte_val(x) ((x).pte) | ||
77 | #define pmd_val(x) ((x).pmd) | ||
78 | #define pgd_val(x) ((x).pgd) | ||
79 | #define pgprot_val(x) ((x).pgprot) | ||
80 | |||
81 | #define __pte(x) ((pte_t) { (x) } ) | ||
82 | #define __pmd(x) ((pmd_t) { (x) } ) | ||
83 | #define __pgd(x) ((pgd_t) { (x) } ) | ||
84 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ||
85 | |||
86 | #endif /* !__ASSEMBLY__ */ | ||
87 | |||
88 | /* to align the pointer to the (next) page boundary */ | ||
89 | #define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK) | ||
90 | |||
91 | /* | ||
92 | * Kconfig defined. | ||
93 | */ | ||
94 | #define __MEMORY_START (CONFIG_MEMORY_START) | ||
95 | #define PAGE_OFFSET (CONFIG_CACHED_MEMORY_OFFSET) | ||
96 | |||
97 | #define __pa(x) ((unsigned long)(x)-PAGE_OFFSET) | ||
98 | #define __va(x) ((void *)((unsigned long)(x)+PAGE_OFFSET)) | ||
99 | #define MAP_NR(addr) ((__pa(addr)-__MEMORY_START) >> PAGE_SHIFT) | ||
100 | #define VALID_PAGE(page) ((page - mem_map) < max_mapnr) | ||
101 | |||
102 | #define phys_to_page(phys) (mem_map + (((phys) - __MEMORY_START) >> PAGE_SHIFT)) | ||
103 | #define page_to_phys(page) (((page - mem_map) << PAGE_SHIFT) + __MEMORY_START) | ||
104 | |||
105 | /* PFN start number, because of __MEMORY_START */ | ||
106 | #define PFN_START (__MEMORY_START >> PAGE_SHIFT) | ||
107 | #define ARCH_PFN_OFFSET (PFN_START) | ||
108 | #define virt_to_page(kaddr) pfn_to_page(__pa(kaddr) >> PAGE_SHIFT) | ||
109 | #define pfn_valid(pfn) (((pfn) - PFN_START) < max_mapnr) | ||
110 | #define virt_addr_valid(kaddr) pfn_valid(__pa(kaddr) >> PAGE_SHIFT) | ||
111 | |||
112 | #define VM_DATA_DEFAULT_FLAGS (VM_READ | VM_WRITE | VM_EXEC | \ | ||
113 | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC) | ||
114 | |||
115 | #include <asm-generic/memory_model.h> | ||
116 | #include <asm-generic/page.h> | ||
117 | |||
118 | #endif /* __KERNEL__ */ | ||
119 | #endif /* __ASM_SH64_PAGE_H */ | ||
diff --git a/include/asm-sh64/param.h b/include/asm-sh64/param.h deleted file mode 100644 index f409adb41540..000000000000 --- a/include/asm-sh64/param.h +++ /dev/null | |||
@@ -1,42 +0,0 @@ | |||
1 | /* | ||
2 | * This file is subject to the terms and conditions of the GNU General Public | ||
3 | * License. See the file "COPYING" in the main directory of this archive | ||
4 | * for more details. | ||
5 | * | ||
6 | * include/asm-sh64/param.h | ||
7 | * | ||
8 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
9 | * Copyright (C) 2003 Paul Mundt | ||
10 | * | ||
11 | */ | ||
12 | #ifndef __ASM_SH64_PARAM_H | ||
13 | #define __ASM_SH64_PARAM_H | ||
14 | |||
15 | |||
16 | #ifdef __KERNEL__ | ||
17 | # ifdef CONFIG_SH_WDT | ||
18 | # define HZ 1000 /* Needed for high-res WOVF */ | ||
19 | # else | ||
20 | # define HZ 100 | ||
21 | # endif | ||
22 | # define USER_HZ 100 /* User interfaces are in "ticks" */ | ||
23 | # define CLOCKS_PER_SEC (USER_HZ) /* frequency at which times() counts */ | ||
24 | #endif | ||
25 | |||
26 | #ifndef HZ | ||
27 | #define HZ 100 | ||
28 | #endif | ||
29 | |||
30 | #define EXEC_PAGESIZE 4096 | ||
31 | |||
32 | #ifndef NGROUPS | ||
33 | #define NGROUPS 32 | ||
34 | #endif | ||
35 | |||
36 | #ifndef NOGROUP | ||
37 | #define NOGROUP (-1) | ||
38 | #endif | ||
39 | |||
40 | #define MAXHOSTNAMELEN 64 /* max length of hostname */ | ||
41 | |||
42 | #endif /* __ASM_SH64_PARAM_H */ | ||
diff --git a/include/asm-sh64/percpu.h b/include/asm-sh64/percpu.h deleted file mode 100644 index a01d16cd0e8c..000000000000 --- a/include/asm-sh64/percpu.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_PERCPU | ||
2 | #define __ASM_SH64_PERCPU | ||
3 | |||
4 | #include <asm-generic/percpu.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_PERCPU */ | ||
diff --git a/include/asm-sh64/pgalloc.h b/include/asm-sh64/pgalloc.h deleted file mode 100644 index 6eccab770a6d..000000000000 --- a/include/asm-sh64/pgalloc.h +++ /dev/null | |||
@@ -1,125 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_PGALLOC_H | ||
2 | #define __ASM_SH64_PGALLOC_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/pgalloc.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003, 2004 Paul Mundt | ||
13 | * Copyright (C) 2003, 2004 Richard Curnow | ||
14 | * | ||
15 | */ | ||
16 | |||
17 | #include <linux/mm.h> | ||
18 | #include <linux/quicklist.h> | ||
19 | #include <asm/page.h> | ||
20 | |||
21 | static inline void pgd_init(unsigned long page) | ||
22 | { | ||
23 | unsigned long *pgd = (unsigned long *)page; | ||
24 | extern pte_t empty_bad_pte_table[PTRS_PER_PTE]; | ||
25 | int i; | ||
26 | |||
27 | for (i = 0; i < USER_PTRS_PER_PGD; i++) | ||
28 | pgd[i] = (unsigned long)empty_bad_pte_table; | ||
29 | } | ||
30 | |||
31 | /* | ||
32 | * Allocate and free page tables. The xxx_kernel() versions are | ||
33 | * used to allocate a kernel page table - this turns on ASN bits | ||
34 | * if any. | ||
35 | */ | ||
36 | |||
37 | static inline pgd_t *get_pgd_slow(void) | ||
38 | { | ||
39 | unsigned int pgd_size = (USER_PTRS_PER_PGD * sizeof(pgd_t)); | ||
40 | pgd_t *ret = kmalloc(pgd_size, GFP_KERNEL); | ||
41 | return ret; | ||
42 | } | ||
43 | |||
44 | static inline pgd_t *pgd_alloc(struct mm_struct *mm) | ||
45 | { | ||
46 | return quicklist_alloc(0, GFP_KERNEL, NULL); | ||
47 | } | ||
48 | |||
49 | static inline void pgd_free(pgd_t *pgd) | ||
50 | { | ||
51 | quicklist_free(0, NULL, pgd); | ||
52 | } | ||
53 | |||
54 | static inline struct page *pte_alloc_one(struct mm_struct *mm, | ||
55 | unsigned long address) | ||
56 | { | ||
57 | void *pg = quicklist_alloc(0, GFP_KERNEL, NULL); | ||
58 | return pg ? virt_to_page(pg) : NULL; | ||
59 | } | ||
60 | |||
61 | static inline void pte_free_kernel(pte_t *pte) | ||
62 | { | ||
63 | quicklist_free(0, NULL, pte); | ||
64 | } | ||
65 | |||
66 | static inline void pte_free(struct page *pte) | ||
67 | { | ||
68 | quicklist_free_page(0, NULL, pte); | ||
69 | } | ||
70 | |||
71 | static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, | ||
72 | unsigned long address) | ||
73 | { | ||
74 | return quicklist_alloc(0, GFP_KERNEL, NULL); | ||
75 | } | ||
76 | |||
77 | #define __pte_free_tlb(tlb,pte) tlb_remove_page((tlb),(pte)) | ||
78 | |||
79 | /* | ||
80 | * allocating and freeing a pmd is trivial: the 1-entry pmd is | ||
81 | * inside the pgd, so has no extra memory associated with it. | ||
82 | */ | ||
83 | |||
84 | #if defined(CONFIG_SH64_PGTABLE_2_LEVEL) | ||
85 | |||
86 | #define pmd_alloc_one(mm, addr) ({ BUG(); ((pmd_t *)2); }) | ||
87 | #define pmd_free(x) do { } while (0) | ||
88 | #define pgd_populate(mm, pmd, pte) BUG() | ||
89 | #define __pte_free_tlb(tlb,pte) tlb_remove_page((tlb),(pte)) | ||
90 | #define __pmd_free_tlb(tlb,pmd) do { } while (0) | ||
91 | |||
92 | #elif defined(CONFIG_SH64_PGTABLE_3_LEVEL) | ||
93 | |||
94 | static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address) | ||
95 | { | ||
96 | return quicklist_alloc(0, GFP_KERNEL, NULL); | ||
97 | } | ||
98 | |||
99 | static inline void pmd_free(pmd_t *pmd) | ||
100 | { | ||
101 | quicklist_free(0, NULL, pmd); | ||
102 | } | ||
103 | |||
104 | #define pgd_populate(mm, pgd, pmd) pgd_set(pgd, pmd) | ||
105 | #define __pmd_free_tlb(tlb,pmd) pmd_free(pmd) | ||
106 | |||
107 | #else | ||
108 | #error "No defined page table size" | ||
109 | #endif | ||
110 | |||
111 | #define pmd_populate_kernel(mm, pmd, pte) \ | ||
112 | set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) (pte))) | ||
113 | |||
114 | static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmd, | ||
115 | struct page *pte) | ||
116 | { | ||
117 | set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) page_address (pte))); | ||
118 | } | ||
119 | |||
120 | static inline void check_pgt_cache(void) | ||
121 | { | ||
122 | quicklist_trim(0, NULL, 25, 16); | ||
123 | } | ||
124 | |||
125 | #endif /* __ASM_SH64_PGALLOC_H */ | ||
diff --git a/include/asm-sh64/poll.h b/include/asm-sh64/poll.h deleted file mode 100644 index ca2950267c53..000000000000 --- a/include/asm-sh64/poll.h +++ /dev/null | |||
@@ -1,8 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_POLL_H | ||
2 | #define __ASM_SH64_POLL_H | ||
3 | |||
4 | #include <asm-generic/poll.h> | ||
5 | |||
6 | #undef POLLREMOVE | ||
7 | |||
8 | #endif /* __ASM_SH64_POLL_H */ | ||
diff --git a/include/asm-sh64/posix_types.h b/include/asm-sh64/posix_types.h deleted file mode 100644 index 0620317a6f0f..000000000000 --- a/include/asm-sh64/posix_types.h +++ /dev/null | |||
@@ -1,131 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_POSIX_TYPES_H | ||
2 | #define __ASM_SH64_POSIX_TYPES_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/posix_types.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003 Paul Mundt | ||
13 | * | ||
14 | * This file is generally used by user-level software, so you need to | ||
15 | * be a little careful about namespace pollution etc. Also, we cannot | ||
16 | * assume GCC is being used. | ||
17 | */ | ||
18 | |||
19 | typedef unsigned long __kernel_ino_t; | ||
20 | typedef unsigned short __kernel_mode_t; | ||
21 | typedef unsigned short __kernel_nlink_t; | ||
22 | typedef long __kernel_off_t; | ||
23 | typedef int __kernel_pid_t; | ||
24 | typedef unsigned short __kernel_ipc_pid_t; | ||
25 | typedef unsigned short __kernel_uid_t; | ||
26 | typedef unsigned short __kernel_gid_t; | ||
27 | typedef long unsigned int __kernel_size_t; | ||
28 | typedef int __kernel_ssize_t; | ||
29 | typedef int __kernel_ptrdiff_t; | ||
30 | typedef long __kernel_time_t; | ||
31 | typedef long __kernel_suseconds_t; | ||
32 | typedef long __kernel_clock_t; | ||
33 | typedef int __kernel_timer_t; | ||
34 | typedef int __kernel_clockid_t; | ||
35 | typedef int __kernel_daddr_t; | ||
36 | typedef char * __kernel_caddr_t; | ||
37 | typedef unsigned short __kernel_uid16_t; | ||
38 | typedef unsigned short __kernel_gid16_t; | ||
39 | typedef unsigned int __kernel_uid32_t; | ||
40 | typedef unsigned int __kernel_gid32_t; | ||
41 | |||
42 | typedef unsigned short __kernel_old_uid_t; | ||
43 | typedef unsigned short __kernel_old_gid_t; | ||
44 | typedef unsigned short __kernel_old_dev_t; | ||
45 | |||
46 | #ifdef __GNUC__ | ||
47 | typedef long long __kernel_loff_t; | ||
48 | #endif | ||
49 | |||
50 | typedef struct { | ||
51 | #if defined(__KERNEL__) || defined(__USE_ALL) | ||
52 | int val[2]; | ||
53 | #else /* !defined(__KERNEL__) && !defined(__USE_ALL) */ | ||
54 | int __val[2]; | ||
55 | #endif /* !defined(__KERNEL__) && !defined(__USE_ALL) */ | ||
56 | } __kernel_fsid_t; | ||
57 | |||
58 | #if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2) | ||
59 | |||
60 | #undef __FD_SET | ||
61 | static __inline__ void __FD_SET(unsigned long __fd, __kernel_fd_set *__fdsetp) | ||
62 | { | ||
63 | unsigned long __tmp = __fd / __NFDBITS; | ||
64 | unsigned long __rem = __fd % __NFDBITS; | ||
65 | __fdsetp->fds_bits[__tmp] |= (1UL<<__rem); | ||
66 | } | ||
67 | |||
68 | #undef __FD_CLR | ||
69 | static __inline__ void __FD_CLR(unsigned long __fd, __kernel_fd_set *__fdsetp) | ||
70 | { | ||
71 | unsigned long __tmp = __fd / __NFDBITS; | ||
72 | unsigned long __rem = __fd % __NFDBITS; | ||
73 | __fdsetp->fds_bits[__tmp] &= ~(1UL<<__rem); | ||
74 | } | ||
75 | |||
76 | |||
77 | #undef __FD_ISSET | ||
78 | static __inline__ int __FD_ISSET(unsigned long __fd, const __kernel_fd_set *__p) | ||
79 | { | ||
80 | unsigned long __tmp = __fd / __NFDBITS; | ||
81 | unsigned long __rem = __fd % __NFDBITS; | ||
82 | return (__p->fds_bits[__tmp] & (1UL<<__rem)) != 0; | ||
83 | } | ||
84 | |||
85 | /* | ||
86 | * This will unroll the loop for the normal constant case (8 ints, | ||
87 | * for a 256-bit fd_set) | ||
88 | */ | ||
89 | #undef __FD_ZERO | ||
90 | static __inline__ void __FD_ZERO(__kernel_fd_set *__p) | ||
91 | { | ||
92 | unsigned long *__tmp = __p->fds_bits; | ||
93 | int __i; | ||
94 | |||
95 | if (__builtin_constant_p(__FDSET_LONGS)) { | ||
96 | switch (__FDSET_LONGS) { | ||
97 | case 16: | ||
98 | __tmp[ 0] = 0; __tmp[ 1] = 0; | ||
99 | __tmp[ 2] = 0; __tmp[ 3] = 0; | ||
100 | __tmp[ 4] = 0; __tmp[ 5] = 0; | ||
101 | __tmp[ 6] = 0; __tmp[ 7] = 0; | ||
102 | __tmp[ 8] = 0; __tmp[ 9] = 0; | ||
103 | __tmp[10] = 0; __tmp[11] = 0; | ||
104 | __tmp[12] = 0; __tmp[13] = 0; | ||
105 | __tmp[14] = 0; __tmp[15] = 0; | ||
106 | return; | ||
107 | |||
108 | case 8: | ||
109 | __tmp[ 0] = 0; __tmp[ 1] = 0; | ||
110 | __tmp[ 2] = 0; __tmp[ 3] = 0; | ||
111 | __tmp[ 4] = 0; __tmp[ 5] = 0; | ||
112 | __tmp[ 6] = 0; __tmp[ 7] = 0; | ||
113 | return; | ||
114 | |||
115 | case 4: | ||
116 | __tmp[ 0] = 0; __tmp[ 1] = 0; | ||
117 | __tmp[ 2] = 0; __tmp[ 3] = 0; | ||
118 | return; | ||
119 | } | ||
120 | } | ||
121 | __i = __FDSET_LONGS; | ||
122 | while (__i) { | ||
123 | __i--; | ||
124 | *__tmp = 0; | ||
125 | __tmp++; | ||
126 | } | ||
127 | } | ||
128 | |||
129 | #endif /* defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2) */ | ||
130 | |||
131 | #endif /* __ASM_SH64_POSIX_TYPES_H */ | ||
diff --git a/include/asm-sh64/ptrace.h b/include/asm-sh64/ptrace.h deleted file mode 100644 index c424f80e3ae0..000000000000 --- a/include/asm-sh64/ptrace.h +++ /dev/null | |||
@@ -1,35 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_PTRACE_H | ||
2 | #define __ASM_SH64_PTRACE_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/ptrace.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | * This struct defines the way the registers are stored on the | ||
17 | * kernel stack during a system call or other kernel entry. | ||
18 | */ | ||
19 | struct pt_regs { | ||
20 | unsigned long long pc; | ||
21 | unsigned long long sr; | ||
22 | unsigned long long syscall_nr; | ||
23 | unsigned long long regs[63]; | ||
24 | unsigned long long tregs[8]; | ||
25 | unsigned long long pad[2]; | ||
26 | }; | ||
27 | |||
28 | #ifdef __KERNEL__ | ||
29 | #define user_mode(regs) (((regs)->sr & 0x40000000)==0) | ||
30 | #define instruction_pointer(regs) ((regs)->pc) | ||
31 | #define profile_pc(regs) ((unsigned long)instruction_pointer(regs)) | ||
32 | extern void show_regs(struct pt_regs *); | ||
33 | #endif | ||
34 | |||
35 | #endif /* __ASM_SH64_PTRACE_H */ | ||
diff --git a/include/asm-sh64/resource.h b/include/asm-sh64/resource.h deleted file mode 100644 index 8ff93944ae66..000000000000 --- a/include/asm-sh64/resource.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_RESOURCE_H | ||
2 | #define __ASM_SH64_RESOURCE_H | ||
3 | |||
4 | #include <asm-sh/resource.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_RESOURCE_H */ | ||
diff --git a/include/asm-sh64/scatterlist.h b/include/asm-sh64/scatterlist.h deleted file mode 100644 index 7f729bbfce43..000000000000 --- a/include/asm-sh64/scatterlist.h +++ /dev/null | |||
@@ -1,37 +0,0 @@ | |||
1 | /* | ||
2 | * This file is subject to the terms and conditions of the GNU General Public | ||
3 | * License. See the file "COPYING" in the main directory of this archive | ||
4 | * for more details. | ||
5 | * | ||
6 | * include/asm-sh64/scatterlist.h | ||
7 | * | ||
8 | * Copyright (C) 2003 Paul Mundt | ||
9 | * | ||
10 | */ | ||
11 | #ifndef __ASM_SH64_SCATTERLIST_H | ||
12 | #define __ASM_SH64_SCATTERLIST_H | ||
13 | |||
14 | #include <asm/types.h> | ||
15 | |||
16 | struct scatterlist { | ||
17 | #ifdef CONFIG_DEBUG_SG | ||
18 | unsigned long sg_magic; | ||
19 | #endif | ||
20 | unsigned long page_link; | ||
21 | unsigned int offset;/* for highmem, page offset */ | ||
22 | dma_addr_t dma_address; | ||
23 | unsigned int length; | ||
24 | }; | ||
25 | |||
26 | /* These macros should be used after a pci_map_sg call has been done | ||
27 | * to get bus addresses of each of the SG entries and their lengths. | ||
28 | * You should only work with the number of sg entries pci_map_sg | ||
29 | * returns, or alternatively stop on the first sg_dma_len(sg) which | ||
30 | * is 0. | ||
31 | */ | ||
32 | #define sg_dma_address(sg) ((sg)->dma_address) | ||
33 | #define sg_dma_len(sg) ((sg)->length) | ||
34 | |||
35 | #define ISA_DMA_THRESHOLD (0xffffffff) | ||
36 | |||
37 | #endif /* !__ASM_SH64_SCATTERLIST_H */ | ||
diff --git a/include/asm-sh64/sci.h b/include/asm-sh64/sci.h deleted file mode 100644 index 793c568b7820..000000000000 --- a/include/asm-sh64/sci.h +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | #include <asm-sh/sci.h> | ||
diff --git a/include/asm-sh64/sections.h b/include/asm-sh64/sections.h deleted file mode 100644 index 897f36bcdf85..000000000000 --- a/include/asm-sh64/sections.h +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SECTIONS_H | ||
2 | #define __ASM_SH64_SECTIONS_H | ||
3 | |||
4 | #include <asm-sh/sections.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_SECTIONS_H */ | ||
7 | |||
diff --git a/include/asm-sh64/segment.h b/include/asm-sh64/segment.h deleted file mode 100644 index 92ac001fc483..000000000000 --- a/include/asm-sh64/segment.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef _ASM_SEGMENT_H | ||
2 | #define _ASM_SEGMENT_H | ||
3 | |||
4 | /* Only here because we have some old header files that expect it.. */ | ||
5 | |||
6 | #endif /* _ASM_SEGMENT_H */ | ||
diff --git a/include/asm-sh64/semaphore-helper.h b/include/asm-sh64/semaphore-helper.h deleted file mode 100644 index fcfafe263e86..000000000000 --- a/include/asm-sh64/semaphore-helper.h +++ /dev/null | |||
@@ -1,101 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SEMAPHORE_HELPER_H | ||
2 | #define __ASM_SH64_SEMAPHORE_HELPER_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/semaphore-helper.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | #include <asm/errno.h> | ||
15 | |||
16 | /* | ||
17 | * SMP- and interrupt-safe semaphores helper functions. | ||
18 | * | ||
19 | * (C) Copyright 1996 Linus Torvalds | ||
20 | * (C) Copyright 1999 Andrea Arcangeli | ||
21 | */ | ||
22 | |||
23 | /* | ||
24 | * These two _must_ execute atomically wrt each other. | ||
25 | * | ||
26 | * This is trivially done with load_locked/store_cond, | ||
27 | * which we have. Let the rest of the losers suck eggs. | ||
28 | */ | ||
29 | static __inline__ void wake_one_more(struct semaphore * sem) | ||
30 | { | ||
31 | atomic_inc((atomic_t *)&sem->sleepers); | ||
32 | } | ||
33 | |||
34 | static __inline__ int waking_non_zero(struct semaphore *sem) | ||
35 | { | ||
36 | unsigned long flags; | ||
37 | int ret = 0; | ||
38 | |||
39 | spin_lock_irqsave(&semaphore_wake_lock, flags); | ||
40 | if (sem->sleepers > 0) { | ||
41 | sem->sleepers--; | ||
42 | ret = 1; | ||
43 | } | ||
44 | spin_unlock_irqrestore(&semaphore_wake_lock, flags); | ||
45 | return ret; | ||
46 | } | ||
47 | |||
48 | /* | ||
49 | * waking_non_zero_interruptible: | ||
50 | * 1 got the lock | ||
51 | * 0 go to sleep | ||
52 | * -EINTR interrupted | ||
53 | * | ||
54 | * We must undo the sem->count down_interruptible() increment while we are | ||
55 | * protected by the spinlock in order to make atomic this atomic_inc() with the | ||
56 | * atomic_read() in wake_one_more(), otherwise we can race. -arca | ||
57 | */ | ||
58 | static __inline__ int waking_non_zero_interruptible(struct semaphore *sem, | ||
59 | struct task_struct *tsk) | ||
60 | { | ||
61 | unsigned long flags; | ||
62 | int ret = 0; | ||
63 | |||
64 | spin_lock_irqsave(&semaphore_wake_lock, flags); | ||
65 | if (sem->sleepers > 0) { | ||
66 | sem->sleepers--; | ||
67 | ret = 1; | ||
68 | } else if (signal_pending(tsk)) { | ||
69 | atomic_inc(&sem->count); | ||
70 | ret = -EINTR; | ||
71 | } | ||
72 | spin_unlock_irqrestore(&semaphore_wake_lock, flags); | ||
73 | return ret; | ||
74 | } | ||
75 | |||
76 | /* | ||
77 | * waking_non_zero_trylock: | ||
78 | * 1 failed to lock | ||
79 | * 0 got the lock | ||
80 | * | ||
81 | * We must undo the sem->count down_trylock() increment while we are | ||
82 | * protected by the spinlock in order to make atomic this atomic_inc() with the | ||
83 | * atomic_read() in wake_one_more(), otherwise we can race. -arca | ||
84 | */ | ||
85 | static __inline__ int waking_non_zero_trylock(struct semaphore *sem) | ||
86 | { | ||
87 | unsigned long flags; | ||
88 | int ret = 1; | ||
89 | |||
90 | spin_lock_irqsave(&semaphore_wake_lock, flags); | ||
91 | if (sem->sleepers <= 0) | ||
92 | atomic_inc(&sem->count); | ||
93 | else { | ||
94 | sem->sleepers--; | ||
95 | ret = 0; | ||
96 | } | ||
97 | spin_unlock_irqrestore(&semaphore_wake_lock, flags); | ||
98 | return ret; | ||
99 | } | ||
100 | |||
101 | #endif /* __ASM_SH64_SEMAPHORE_HELPER_H */ | ||
diff --git a/include/asm-sh64/semaphore.h b/include/asm-sh64/semaphore.h deleted file mode 100644 index f027cc14b55b..000000000000 --- a/include/asm-sh64/semaphore.h +++ /dev/null | |||
@@ -1,119 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SEMAPHORE_H | ||
2 | #define __ASM_SH64_SEMAPHORE_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/semaphore.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | * SMP- and interrupt-safe semaphores. | ||
14 | * | ||
15 | * (C) Copyright 1996 Linus Torvalds | ||
16 | * | ||
17 | * SuperH verison by Niibe Yutaka | ||
18 | * (Currently no asm implementation but generic C code...) | ||
19 | * | ||
20 | */ | ||
21 | |||
22 | #include <linux/linkage.h> | ||
23 | #include <linux/spinlock.h> | ||
24 | #include <linux/wait.h> | ||
25 | #include <linux/rwsem.h> | ||
26 | |||
27 | #include <asm/system.h> | ||
28 | #include <asm/atomic.h> | ||
29 | |||
30 | struct semaphore { | ||
31 | atomic_t count; | ||
32 | int sleepers; | ||
33 | wait_queue_head_t wait; | ||
34 | }; | ||
35 | |||
36 | #define __SEMAPHORE_INITIALIZER(name, n) \ | ||
37 | { \ | ||
38 | .count = ATOMIC_INIT(n), \ | ||
39 | .sleepers = 0, \ | ||
40 | .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \ | ||
41 | } | ||
42 | |||
43 | #define __DECLARE_SEMAPHORE_GENERIC(name,count) \ | ||
44 | struct semaphore name = __SEMAPHORE_INITIALIZER(name,count) | ||
45 | |||
46 | #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1) | ||
47 | |||
48 | static inline void sema_init (struct semaphore *sem, int val) | ||
49 | { | ||
50 | /* | ||
51 | * *sem = (struct semaphore)__SEMAPHORE_INITIALIZER((*sem),val); | ||
52 | * | ||
53 | * i'd rather use the more flexible initialization above, but sadly | ||
54 | * GCC 2.7.2.3 emits a bogus warning. EGCS doesnt. Oh well. | ||
55 | */ | ||
56 | atomic_set(&sem->count, val); | ||
57 | sem->sleepers = 0; | ||
58 | init_waitqueue_head(&sem->wait); | ||
59 | } | ||
60 | |||
61 | static inline void init_MUTEX (struct semaphore *sem) | ||
62 | { | ||
63 | sema_init(sem, 1); | ||
64 | } | ||
65 | |||
66 | static inline void init_MUTEX_LOCKED (struct semaphore *sem) | ||
67 | { | ||
68 | sema_init(sem, 0); | ||
69 | } | ||
70 | |||
71 | #if 0 | ||
72 | asmlinkage void __down_failed(void /* special register calling convention */); | ||
73 | asmlinkage int __down_failed_interruptible(void /* params in registers */); | ||
74 | asmlinkage int __down_failed_trylock(void /* params in registers */); | ||
75 | asmlinkage void __up_wakeup(void /* special register calling convention */); | ||
76 | #endif | ||
77 | |||
78 | asmlinkage void __down(struct semaphore * sem); | ||
79 | asmlinkage int __down_interruptible(struct semaphore * sem); | ||
80 | asmlinkage int __down_trylock(struct semaphore * sem); | ||
81 | asmlinkage void __up(struct semaphore * sem); | ||
82 | |||
83 | extern spinlock_t semaphore_wake_lock; | ||
84 | |||
85 | static inline void down(struct semaphore * sem) | ||
86 | { | ||
87 | if (atomic_dec_return(&sem->count) < 0) | ||
88 | __down(sem); | ||
89 | } | ||
90 | |||
91 | static inline int down_interruptible(struct semaphore * sem) | ||
92 | { | ||
93 | int ret = 0; | ||
94 | |||
95 | if (atomic_dec_return(&sem->count) < 0) | ||
96 | ret = __down_interruptible(sem); | ||
97 | return ret; | ||
98 | } | ||
99 | |||
100 | static inline int down_trylock(struct semaphore * sem) | ||
101 | { | ||
102 | int ret = 0; | ||
103 | |||
104 | if (atomic_dec_return(&sem->count) < 0) | ||
105 | ret = __down_trylock(sem); | ||
106 | return ret; | ||
107 | } | ||
108 | |||
109 | /* | ||
110 | * Note! This is subtle. We jump to wake people up only if | ||
111 | * the semaphore was negative (== somebody was waiting on it). | ||
112 | */ | ||
113 | static inline void up(struct semaphore * sem) | ||
114 | { | ||
115 | if (atomic_inc_return(&sem->count) <= 0) | ||
116 | __up(sem); | ||
117 | } | ||
118 | |||
119 | #endif /* __ASM_SH64_SEMAPHORE_H */ | ||
diff --git a/include/asm-sh64/sembuf.h b/include/asm-sh64/sembuf.h deleted file mode 100644 index ec4d9f143577..000000000000 --- a/include/asm-sh64/sembuf.h +++ /dev/null | |||
@@ -1,36 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SEMBUF_H | ||
2 | #define __ASM_SH64_SEMBUF_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/sembuf.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | * The semid64_ds structure for i386 architecture. | ||
17 | * Note extra padding because this structure is passed back and forth | ||
18 | * between kernel and user space. | ||
19 | * | ||
20 | * Pad space is left for: | ||
21 | * - 64-bit time_t to solve y2038 problem | ||
22 | * - 2 miscellaneous 32-bit values | ||
23 | */ | ||
24 | |||
25 | struct semid64_ds { | ||
26 | struct ipc64_perm sem_perm; /* permissions .. see ipc.h */ | ||
27 | __kernel_time_t sem_otime; /* last semop time */ | ||
28 | unsigned long __unused1; | ||
29 | __kernel_time_t sem_ctime; /* last change time */ | ||
30 | unsigned long __unused2; | ||
31 | unsigned long sem_nsems; /* no. of semaphores in array */ | ||
32 | unsigned long __unused3; | ||
33 | unsigned long __unused4; | ||
34 | }; | ||
35 | |||
36 | #endif /* __ASM_SH64_SEMBUF_H */ | ||
diff --git a/include/asm-sh64/serial.h b/include/asm-sh64/serial.h deleted file mode 100644 index e8d7b3f2da57..000000000000 --- a/include/asm-sh64/serial.h +++ /dev/null | |||
@@ -1,31 +0,0 @@ | |||
1 | /* | ||
2 | * include/asm-sh64/serial.h | ||
3 | * | ||
4 | * Configuration details for 8250, 16450, 16550, etc. serial ports | ||
5 | */ | ||
6 | |||
7 | #ifndef _ASM_SERIAL_H | ||
8 | #define _ASM_SERIAL_H | ||
9 | |||
10 | /* | ||
11 | * This assumes you have a 1.8432 MHz clock for your UART. | ||
12 | * | ||
13 | * It'd be nice if someone built a serial card with a 24.576 MHz | ||
14 | * clock, since the 16550A is capable of handling a top speed of 1.5 | ||
15 | * megabits/second; but this requires the faster clock. | ||
16 | */ | ||
17 | #define BASE_BAUD ( 1843200 / 16 ) | ||
18 | |||
19 | #define RS_TABLE_SIZE 2 | ||
20 | |||
21 | #define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST) | ||
22 | |||
23 | #define SERIAL_PORT_DFNS \ | ||
24 | /* UART CLK PORT IRQ FLAGS */ \ | ||
25 | { 0, BASE_BAUD, 0x3F8, 4, STD_COM_FLAGS }, /* ttyS0 */ \ | ||
26 | { 0, BASE_BAUD, 0x2F8, 3, STD_COM_FLAGS } /* ttyS1 */ | ||
27 | |||
28 | /* XXX: This should be moved ino irq.h */ | ||
29 | #define irq_cannonicalize(x) (x) | ||
30 | |||
31 | #endif /* _ASM_SERIAL_H */ | ||
diff --git a/include/asm-sh64/setup.h b/include/asm-sh64/setup.h deleted file mode 100644 index 5b07b14c2927..000000000000 --- a/include/asm-sh64/setup.h +++ /dev/null | |||
@@ -1,22 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SETUP_H | ||
2 | #define __ASM_SH64_SETUP_H | ||
3 | |||
4 | #define COMMAND_LINE_SIZE 256 | ||
5 | |||
6 | #ifdef __KERNEL__ | ||
7 | |||
8 | #define PARAM ((unsigned char *)empty_zero_page) | ||
9 | #define MOUNT_ROOT_RDONLY (*(unsigned long *) (PARAM+0x000)) | ||
10 | #define RAMDISK_FLAGS (*(unsigned long *) (PARAM+0x004)) | ||
11 | #define ORIG_ROOT_DEV (*(unsigned long *) (PARAM+0x008)) | ||
12 | #define LOADER_TYPE (*(unsigned long *) (PARAM+0x00c)) | ||
13 | #define INITRD_START (*(unsigned long *) (PARAM+0x010)) | ||
14 | #define INITRD_SIZE (*(unsigned long *) (PARAM+0x014)) | ||
15 | |||
16 | #define COMMAND_LINE ((char *) (PARAM+256)) | ||
17 | #define COMMAND_LINE_SIZE 256 | ||
18 | |||
19 | #endif /* __KERNEL__ */ | ||
20 | |||
21 | #endif /* __ASM_SH64_SETUP_H */ | ||
22 | |||
diff --git a/include/asm-sh64/shmbuf.h b/include/asm-sh64/shmbuf.h deleted file mode 100644 index 022f3494dd64..000000000000 --- a/include/asm-sh64/shmbuf.h +++ /dev/null | |||
@@ -1,53 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SHMBUF_H | ||
2 | #define __ASM_SH64_SHMBUF_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/shmbuf.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | * The shmid64_ds structure for i386 architecture. | ||
17 | * Note extra padding because this structure is passed back and forth | ||
18 | * between kernel and user space. | ||
19 | * | ||
20 | * Pad space is left for: | ||
21 | * - 64-bit time_t to solve y2038 problem | ||
22 | * - 2 miscellaneous 32-bit values | ||
23 | */ | ||
24 | |||
25 | struct shmid64_ds { | ||
26 | struct ipc64_perm shm_perm; /* operation perms */ | ||
27 | size_t shm_segsz; /* size of segment (bytes) */ | ||
28 | __kernel_time_t shm_atime; /* last attach time */ | ||
29 | unsigned long __unused1; | ||
30 | __kernel_time_t shm_dtime; /* last detach time */ | ||
31 | unsigned long __unused2; | ||
32 | __kernel_time_t shm_ctime; /* last change time */ | ||
33 | unsigned long __unused3; | ||
34 | __kernel_pid_t shm_cpid; /* pid of creator */ | ||
35 | __kernel_pid_t shm_lpid; /* pid of last operator */ | ||
36 | unsigned long shm_nattch; /* no. of current attaches */ | ||
37 | unsigned long __unused4; | ||
38 | unsigned long __unused5; | ||
39 | }; | ||
40 | |||
41 | struct shminfo64 { | ||
42 | unsigned long shmmax; | ||
43 | unsigned long shmmin; | ||
44 | unsigned long shmmni; | ||
45 | unsigned long shmseg; | ||
46 | unsigned long shmall; | ||
47 | unsigned long __unused1; | ||
48 | unsigned long __unused2; | ||
49 | unsigned long __unused3; | ||
50 | unsigned long __unused4; | ||
51 | }; | ||
52 | |||
53 | #endif /* __ASM_SH64_SHMBUF_H */ | ||
diff --git a/include/asm-sh64/shmparam.h b/include/asm-sh64/shmparam.h deleted file mode 100644 index 1bb820c833ee..000000000000 --- a/include/asm-sh64/shmparam.h +++ /dev/null | |||
@@ -1,12 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SHMPARAM_H | ||
2 | #define __ASM_SH64_SHMPARAM_H | ||
3 | |||
4 | /* | ||
5 | * Set this to a sensible safe default, we'll work out the specifics for the | ||
6 | * align mask from the cache descriptor at run-time. | ||
7 | */ | ||
8 | #define SHMLBA 0x4000 | ||
9 | |||
10 | #define __ARCH_FORCE_SHMLBA | ||
11 | |||
12 | #endif /* __ASM_SH64_SHMPARAM_H */ | ||
diff --git a/include/asm-sh64/sigcontext.h b/include/asm-sh64/sigcontext.h deleted file mode 100644 index 6293509d8cc1..000000000000 --- a/include/asm-sh64/sigcontext.h +++ /dev/null | |||
@@ -1,30 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SIGCONTEXT_H | ||
2 | #define __ASM_SH64_SIGCONTEXT_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/sigcontext.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | struct sigcontext { | ||
16 | unsigned long oldmask; | ||
17 | |||
18 | /* CPU registers */ | ||
19 | unsigned long long sc_regs[63]; | ||
20 | unsigned long long sc_tregs[8]; | ||
21 | unsigned long long sc_pc; | ||
22 | unsigned long long sc_sr; | ||
23 | |||
24 | /* FPU registers */ | ||
25 | unsigned long long sc_fpregs[32]; | ||
26 | unsigned int sc_fpscr; | ||
27 | unsigned int sc_fpvalid; | ||
28 | }; | ||
29 | |||
30 | #endif /* __ASM_SH64_SIGCONTEXT_H */ | ||
diff --git a/include/asm-sh64/siginfo.h b/include/asm-sh64/siginfo.h deleted file mode 100644 index 56ef1da534d7..000000000000 --- a/include/asm-sh64/siginfo.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SIGINFO_H | ||
2 | #define __ASM_SH64_SIGINFO_H | ||
3 | |||
4 | #include <asm-generic/siginfo.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_SIGINFO_H */ | ||
diff --git a/include/asm-sh64/signal.h b/include/asm-sh64/signal.h deleted file mode 100644 index 244e134730d9..000000000000 --- a/include/asm-sh64/signal.h +++ /dev/null | |||
@@ -1,159 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SIGNAL_H | ||
2 | #define __ASM_SH64_SIGNAL_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/signal.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #include <linux/types.h> | ||
16 | |||
17 | /* Avoid too many header ordering problems. */ | ||
18 | struct siginfo; | ||
19 | |||
20 | #define _NSIG 64 | ||
21 | #define _NSIG_BPW 32 | ||
22 | #define _NSIG_WORDS (_NSIG / _NSIG_BPW) | ||
23 | |||
24 | typedef unsigned long old_sigset_t; /* at least 32 bits */ | ||
25 | |||
26 | typedef struct { | ||
27 | unsigned long sig[_NSIG_WORDS]; | ||
28 | } sigset_t; | ||
29 | |||
30 | #define SIGHUP 1 | ||
31 | #define SIGINT 2 | ||
32 | #define SIGQUIT 3 | ||
33 | #define SIGILL 4 | ||
34 | #define SIGTRAP 5 | ||
35 | #define SIGABRT 6 | ||
36 | #define SIGIOT 6 | ||
37 | #define SIGBUS 7 | ||
38 | #define SIGFPE 8 | ||
39 | #define SIGKILL 9 | ||
40 | #define SIGUSR1 10 | ||
41 | #define SIGSEGV 11 | ||
42 | #define SIGUSR2 12 | ||
43 | #define SIGPIPE 13 | ||
44 | #define SIGALRM 14 | ||
45 | #define SIGTERM 15 | ||
46 | #define SIGSTKFLT 16 | ||
47 | #define SIGCHLD 17 | ||
48 | #define SIGCONT 18 | ||
49 | #define SIGSTOP 19 | ||
50 | #define SIGTSTP 20 | ||
51 | #define SIGTTIN 21 | ||
52 | #define SIGTTOU 22 | ||
53 | #define SIGURG 23 | ||
54 | #define SIGXCPU 24 | ||
55 | #define SIGXFSZ 25 | ||
56 | #define SIGVTALRM 26 | ||
57 | #define SIGPROF 27 | ||
58 | #define SIGWINCH 28 | ||
59 | #define SIGIO 29 | ||
60 | #define SIGPOLL SIGIO | ||
61 | /* | ||
62 | #define SIGLOST 29 | ||
63 | */ | ||
64 | #define SIGPWR 30 | ||
65 | #define SIGSYS 31 | ||
66 | #define SIGUNUSED 31 | ||
67 | |||
68 | /* These should not be considered constants from userland. */ | ||
69 | #define SIGRTMIN 32 | ||
70 | #define SIGRTMAX (_NSIG-1) | ||
71 | |||
72 | /* | ||
73 | * SA_FLAGS values: | ||
74 | * | ||
75 | * SA_ONSTACK indicates that a registered stack_t will be used. | ||
76 | * SA_RESTART flag to get restarting signals (which were the default long ago) | ||
77 | * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop. | ||
78 | * SA_RESETHAND clears the handler when the signal is delivered. | ||
79 | * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies. | ||
80 | * SA_NODEFER prevents the current signal from being masked in the handler. | ||
81 | * | ||
82 | * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single | ||
83 | * Unix names RESETHAND and NODEFER respectively. | ||
84 | */ | ||
85 | #define SA_NOCLDSTOP 0x00000001 | ||
86 | #define SA_NOCLDWAIT 0x00000002 /* not supported yet */ | ||
87 | #define SA_SIGINFO 0x00000004 | ||
88 | #define SA_ONSTACK 0x08000000 | ||
89 | #define SA_RESTART 0x10000000 | ||
90 | #define SA_NODEFER 0x40000000 | ||
91 | #define SA_RESETHAND 0x80000000 | ||
92 | |||
93 | #define SA_NOMASK SA_NODEFER | ||
94 | #define SA_ONESHOT SA_RESETHAND | ||
95 | |||
96 | #define SA_RESTORER 0x04000000 | ||
97 | |||
98 | /* | ||
99 | * sigaltstack controls | ||
100 | */ | ||
101 | #define SS_ONSTACK 1 | ||
102 | #define SS_DISABLE 2 | ||
103 | |||
104 | #define MINSIGSTKSZ 2048 | ||
105 | #define SIGSTKSZ THREAD_SIZE | ||
106 | |||
107 | #include <asm-generic/signal.h> | ||
108 | |||
109 | #ifdef __KERNEL__ | ||
110 | struct old_sigaction { | ||
111 | __sighandler_t sa_handler; | ||
112 | old_sigset_t sa_mask; | ||
113 | unsigned long sa_flags; | ||
114 | void (*sa_restorer)(void); | ||
115 | }; | ||
116 | |||
117 | struct sigaction { | ||
118 | __sighandler_t sa_handler; | ||
119 | unsigned long sa_flags; | ||
120 | void (*sa_restorer)(void); | ||
121 | sigset_t sa_mask; /* mask last for extensibility */ | ||
122 | }; | ||
123 | |||
124 | struct k_sigaction { | ||
125 | struct sigaction sa; | ||
126 | }; | ||
127 | #else | ||
128 | /* Here we must cater to libcs that poke about in kernel headers. */ | ||
129 | |||
130 | struct sigaction { | ||
131 | union { | ||
132 | __sighandler_t _sa_handler; | ||
133 | void (*_sa_sigaction)(int, struct siginfo *, void *); | ||
134 | } _u; | ||
135 | sigset_t sa_mask; | ||
136 | unsigned long sa_flags; | ||
137 | void (*sa_restorer)(void); | ||
138 | }; | ||
139 | |||
140 | #define sa_handler _u._sa_handler | ||
141 | #define sa_sigaction _u._sa_sigaction | ||
142 | |||
143 | #endif /* __KERNEL__ */ | ||
144 | |||
145 | typedef struct sigaltstack { | ||
146 | void *ss_sp; | ||
147 | int ss_flags; | ||
148 | size_t ss_size; | ||
149 | } stack_t; | ||
150 | |||
151 | #ifdef __KERNEL__ | ||
152 | #include <asm/sigcontext.h> | ||
153 | |||
154 | #define sigmask(sig) (1UL << ((sig) - 1)) | ||
155 | #define ptrace_signal_deliver(regs, cookie) do { } while (0) | ||
156 | |||
157 | #endif /* __KERNEL__ */ | ||
158 | |||
159 | #endif /* __ASM_SH64_SIGNAL_H */ | ||
diff --git a/include/asm-sh64/smp.h b/include/asm-sh64/smp.h deleted file mode 100644 index 4a4d0da39a84..000000000000 --- a/include/asm-sh64/smp.h +++ /dev/null | |||
@@ -1,15 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SMP_H | ||
2 | #define __ASM_SH64_SMP_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/smp.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #endif /* __ASM_SH64_SMP_H */ | ||
diff --git a/include/asm-sh64/socket.h b/include/asm-sh64/socket.h deleted file mode 100644 index 1853f7246ab0..000000000000 --- a/include/asm-sh64/socket.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SOCKET_H | ||
2 | #define __ASM_SH64_SOCKET_H | ||
3 | |||
4 | #include <asm-sh/socket.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_SOCKET_H */ | ||
diff --git a/include/asm-sh64/sockios.h b/include/asm-sh64/sockios.h deleted file mode 100644 index 419e76f12f41..000000000000 --- a/include/asm-sh64/sockios.h +++ /dev/null | |||
@@ -1,25 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SOCKIOS_H | ||
2 | #define __ASM_SH64_SOCKIOS_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/sockios.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | /* Socket-level I/O control calls. */ | ||
16 | #define FIOGETOWN _IOR('f', 123, int) | ||
17 | #define FIOSETOWN _IOW('f', 124, int) | ||
18 | |||
19 | #define SIOCATMARK _IOR('s', 7, int) | ||
20 | #define SIOCSPGRP _IOW('s', 8, pid_t) | ||
21 | #define SIOCGPGRP _IOR('s', 9, pid_t) | ||
22 | |||
23 | #define SIOCGSTAMP _IOR('s', 100, struct timeval) /* Get stamp (timeval) */ | ||
24 | #define SIOCGSTAMPNS _IOR('s', 101, struct timespec) /* Get stamp (timespec) */ | ||
25 | #endif /* __ASM_SH64_SOCKIOS_H */ | ||
diff --git a/include/asm-sh64/spinlock.h b/include/asm-sh64/spinlock.h deleted file mode 100644 index 296b0c9b24a2..000000000000 --- a/include/asm-sh64/spinlock.h +++ /dev/null | |||
@@ -1,17 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_SPINLOCK_H | ||
2 | #define __ASM_SH64_SPINLOCK_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/spinlock.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #error "No SMP on SH64" | ||
16 | |||
17 | #endif /* __ASM_SH64_SPINLOCK_H */ | ||
diff --git a/include/asm-sh64/stat.h b/include/asm-sh64/stat.h deleted file mode 100644 index 86f551b1987e..000000000000 --- a/include/asm-sh64/stat.h +++ /dev/null | |||
@@ -1,88 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_STAT_H | ||
2 | #define __ASM_SH64_STAT_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/stat.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | struct __old_kernel_stat { | ||
16 | unsigned short st_dev; | ||
17 | unsigned short st_ino; | ||
18 | unsigned short st_mode; | ||
19 | unsigned short st_nlink; | ||
20 | unsigned short st_uid; | ||
21 | unsigned short st_gid; | ||
22 | unsigned short st_rdev; | ||
23 | unsigned long st_size; | ||
24 | unsigned long st_atime; | ||
25 | unsigned long st_mtime; | ||
26 | unsigned long st_ctime; | ||
27 | }; | ||
28 | |||
29 | struct stat { | ||
30 | unsigned short st_dev; | ||
31 | unsigned short __pad1; | ||
32 | unsigned long st_ino; | ||
33 | unsigned short st_mode; | ||
34 | unsigned short st_nlink; | ||
35 | unsigned short st_uid; | ||
36 | unsigned short st_gid; | ||
37 | unsigned short st_rdev; | ||
38 | unsigned short __pad2; | ||
39 | unsigned long st_size; | ||
40 | unsigned long st_blksize; | ||
41 | unsigned long st_blocks; | ||
42 | unsigned long st_atime; | ||
43 | unsigned long st_atime_nsec; | ||
44 | unsigned long st_mtime; | ||
45 | unsigned long st_mtime_nsec; | ||
46 | unsigned long st_ctime; | ||
47 | unsigned long st_ctime_nsec; | ||
48 | unsigned long __unused4; | ||
49 | unsigned long __unused5; | ||
50 | }; | ||
51 | |||
52 | /* This matches struct stat64 in glibc2.1, hence the absolutely | ||
53 | * insane amounts of padding around dev_t's. | ||
54 | */ | ||
55 | struct stat64 { | ||
56 | unsigned short st_dev; | ||
57 | unsigned char __pad0[10]; | ||
58 | |||
59 | unsigned long st_ino; | ||
60 | unsigned int st_mode; | ||
61 | unsigned int st_nlink; | ||
62 | |||
63 | unsigned long st_uid; | ||
64 | unsigned long st_gid; | ||
65 | |||
66 | unsigned short st_rdev; | ||
67 | unsigned char __pad3[10]; | ||
68 | |||
69 | long long st_size; | ||
70 | unsigned long st_blksize; | ||
71 | |||
72 | unsigned long st_blocks; /* Number 512-byte blocks allocated. */ | ||
73 | unsigned long __pad4; /* future possible st_blocks high bits */ | ||
74 | |||
75 | unsigned long st_atime; | ||
76 | unsigned long st_atime_nsec; | ||
77 | |||
78 | unsigned long st_mtime; | ||
79 | unsigned long st_mtime_nsec; | ||
80 | |||
81 | unsigned long st_ctime; | ||
82 | unsigned long st_ctime_nsec; /* will be high 32 bits of ctime someday */ | ||
83 | |||
84 | unsigned long __unused1; | ||
85 | unsigned long __unused2; | ||
86 | }; | ||
87 | |||
88 | #endif /* __ASM_SH64_STAT_H */ | ||
diff --git a/include/asm-sh64/statfs.h b/include/asm-sh64/statfs.h deleted file mode 100644 index 083fd79b2417..000000000000 --- a/include/asm-sh64/statfs.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_STATFS_H | ||
2 | #define __ASM_SH64_STATFS_H | ||
3 | |||
4 | #include <asm-generic/statfs.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_STATFS_H */ | ||
diff --git a/include/asm-sh64/termbits.h b/include/asm-sh64/termbits.h deleted file mode 100644 index 86bde5ec1414..000000000000 --- a/include/asm-sh64/termbits.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_TERMBITS_H | ||
2 | #define __ASM_SH64_TERMBITS_H | ||
3 | |||
4 | #include <asm-sh/termbits.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_TERMBITS_H */ | ||
diff --git a/include/asm-sh64/termios.h b/include/asm-sh64/termios.h deleted file mode 100644 index dc44e6ed3a7c..000000000000 --- a/include/asm-sh64/termios.h +++ /dev/null | |||
@@ -1,99 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_TERMIOS_H | ||
2 | #define __ASM_SH64_TERMIOS_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/termios.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #include <asm/termbits.h> | ||
16 | #include <asm/ioctls.h> | ||
17 | |||
18 | struct winsize { | ||
19 | unsigned short ws_row; | ||
20 | unsigned short ws_col; | ||
21 | unsigned short ws_xpixel; | ||
22 | unsigned short ws_ypixel; | ||
23 | }; | ||
24 | |||
25 | #define NCC 8 | ||
26 | struct termio { | ||
27 | unsigned short c_iflag; /* input mode flags */ | ||
28 | unsigned short c_oflag; /* output mode flags */ | ||
29 | unsigned short c_cflag; /* control mode flags */ | ||
30 | unsigned short c_lflag; /* local mode flags */ | ||
31 | unsigned char c_line; /* line discipline */ | ||
32 | unsigned char c_cc[NCC]; /* control characters */ | ||
33 | }; | ||
34 | |||
35 | /* modem lines */ | ||
36 | #define TIOCM_LE 0x001 | ||
37 | #define TIOCM_DTR 0x002 | ||
38 | #define TIOCM_RTS 0x004 | ||
39 | #define TIOCM_ST 0x008 | ||
40 | #define TIOCM_SR 0x010 | ||
41 | #define TIOCM_CTS 0x020 | ||
42 | #define TIOCM_CAR 0x040 | ||
43 | #define TIOCM_RNG 0x080 | ||
44 | #define TIOCM_DSR 0x100 | ||
45 | #define TIOCM_CD TIOCM_CAR | ||
46 | #define TIOCM_RI TIOCM_RNG | ||
47 | #define TIOCM_OUT1 0x2000 | ||
48 | #define TIOCM_OUT2 0x4000 | ||
49 | #define TIOCM_LOOP 0x8000 | ||
50 | |||
51 | /* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */ | ||
52 | |||
53 | #ifdef __KERNEL__ | ||
54 | |||
55 | /* intr=^C quit=^\ erase=del kill=^U | ||
56 | eof=^D vtime=\0 vmin=\1 sxtc=\0 | ||
57 | start=^Q stop=^S susp=^Z eol=\0 | ||
58 | reprint=^R discard=^U werase=^W lnext=^V | ||
59 | eol2=\0 | ||
60 | */ | ||
61 | #define INIT_C_CC "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0" | ||
62 | |||
63 | /* | ||
64 | * Translate a "termio" structure into a "termios". Ugh. | ||
65 | */ | ||
66 | #define SET_LOW_TERMIOS_BITS(termios, termio, x) { \ | ||
67 | unsigned short __tmp; \ | ||
68 | get_user(__tmp,&(termio)->x); \ | ||
69 | *(unsigned short *) &(termios)->x = __tmp; \ | ||
70 | } | ||
71 | |||
72 | #define user_termio_to_kernel_termios(termios, termio) \ | ||
73 | ({ \ | ||
74 | SET_LOW_TERMIOS_BITS(termios, termio, c_iflag); \ | ||
75 | SET_LOW_TERMIOS_BITS(termios, termio, c_oflag); \ | ||
76 | SET_LOW_TERMIOS_BITS(termios, termio, c_cflag); \ | ||
77 | SET_LOW_TERMIOS_BITS(termios, termio, c_lflag); \ | ||
78 | copy_from_user((termios)->c_cc, (termio)->c_cc, NCC); \ | ||
79 | }) | ||
80 | |||
81 | /* | ||
82 | * Translate a "termios" structure into a "termio". Ugh. | ||
83 | */ | ||
84 | #define kernel_termios_to_user_termio(termio, termios) \ | ||
85 | ({ \ | ||
86 | put_user((termios)->c_iflag, &(termio)->c_iflag); \ | ||
87 | put_user((termios)->c_oflag, &(termio)->c_oflag); \ | ||
88 | put_user((termios)->c_cflag, &(termio)->c_cflag); \ | ||
89 | put_user((termios)->c_lflag, &(termio)->c_lflag); \ | ||
90 | put_user((termios)->c_line, &(termio)->c_line); \ | ||
91 | copy_to_user((termio)->c_cc, (termios)->c_cc, NCC); \ | ||
92 | }) | ||
93 | |||
94 | #define user_termios_to_kernel_termios(k, u) copy_from_user(k, u, sizeof(struct termios)) | ||
95 | #define kernel_termios_to_user_termios(u, k) copy_to_user(u, k, sizeof(struct termios)) | ||
96 | |||
97 | #endif /* __KERNEL__ */ | ||
98 | |||
99 | #endif /* __ASM_SH64_TERMIOS_H */ | ||
diff --git a/include/asm-sh64/timex.h b/include/asm-sh64/timex.h deleted file mode 100644 index 163e2b62fe27..000000000000 --- a/include/asm-sh64/timex.h +++ /dev/null | |||
@@ -1,31 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_TIMEX_H | ||
2 | #define __ASM_SH64_TIMEX_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/timex.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * Copyright (C) 2003 Paul Mundt | ||
13 | * | ||
14 | * sh-5 architecture timex specifications | ||
15 | * | ||
16 | */ | ||
17 | |||
18 | #define CLOCK_TICK_RATE 1193180 /* Underlying HZ */ | ||
19 | #define CLOCK_TICK_FACTOR 20 /* Factor of both 1000000 and CLOCK_TICK_RATE */ | ||
20 | |||
21 | typedef unsigned long cycles_t; | ||
22 | |||
23 | static __inline__ cycles_t get_cycles (void) | ||
24 | { | ||
25 | return 0; | ||
26 | } | ||
27 | |||
28 | #define vxtime_lock() do {} while (0) | ||
29 | #define vxtime_unlock() do {} while (0) | ||
30 | |||
31 | #endif /* __ASM_SH64_TIMEX_H */ | ||
diff --git a/include/asm-sh64/tlbflush.h b/include/asm-sh64/tlbflush.h deleted file mode 100644 index 16a164a23754..000000000000 --- a/include/asm-sh64/tlbflush.h +++ /dev/null | |||
@@ -1,27 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_TLBFLUSH_H | ||
2 | #define __ASM_SH64_TLBFLUSH_H | ||
3 | |||
4 | #include <asm/pgalloc.h> | ||
5 | |||
6 | /* | ||
7 | * TLB flushing: | ||
8 | * | ||
9 | * - flush_tlb() flushes the current mm struct TLBs | ||
10 | * - flush_tlb_all() flushes all processes TLBs | ||
11 | * - flush_tlb_mm(mm) flushes the specified mm context TLB's | ||
12 | * - flush_tlb_page(vma, vmaddr) flushes one page | ||
13 | * - flush_tlb_range(mm, start, end) flushes a range of pages | ||
14 | * | ||
15 | */ | ||
16 | |||
17 | extern void flush_tlb(void); | ||
18 | extern void flush_tlb_all(void); | ||
19 | extern void flush_tlb_mm(struct mm_struct *mm); | ||
20 | extern void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, | ||
21 | unsigned long end); | ||
22 | extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long page); | ||
23 | |||
24 | extern void flush_tlb_kernel_range(unsigned long start, unsigned long end); | ||
25 | |||
26 | #endif /* __ASM_SH64_TLBFLUSH_H */ | ||
27 | |||
diff --git a/include/asm-sh64/topology.h b/include/asm-sh64/topology.h deleted file mode 100644 index 34211787345f..000000000000 --- a/include/asm-sh64/topology.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_TOPOLOGY_H | ||
2 | #define __ASM_SH64_TOPOLOGY_H | ||
3 | |||
4 | #include <asm-generic/topology.h> | ||
5 | |||
6 | #endif /* __ASM_SH64_TOPOLOGY_H */ | ||
diff --git a/include/asm-sh64/types.h b/include/asm-sh64/types.h deleted file mode 100644 index 2c7ad73b3883..000000000000 --- a/include/asm-sh64/types.h +++ /dev/null | |||
@@ -1,74 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_TYPES_H | ||
2 | #define __ASM_SH64_TYPES_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/types.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #ifndef __ASSEMBLY__ | ||
16 | |||
17 | typedef unsigned short umode_t; | ||
18 | |||
19 | /* | ||
20 | * __xx is ok: it doesn't pollute the POSIX namespace. Use these in the | ||
21 | * header files exported to user space | ||
22 | */ | ||
23 | |||
24 | typedef __signed__ char __s8; | ||
25 | typedef unsigned char __u8; | ||
26 | |||
27 | typedef __signed__ short __s16; | ||
28 | typedef unsigned short __u16; | ||
29 | |||
30 | typedef __signed__ int __s32; | ||
31 | typedef unsigned int __u32; | ||
32 | |||
33 | #if defined(__GNUC__) | ||
34 | __extension__ typedef __signed__ long long __s64; | ||
35 | __extension__ typedef unsigned long long __u64; | ||
36 | #endif | ||
37 | |||
38 | #endif /* __ASSEMBLY__ */ | ||
39 | |||
40 | /* | ||
41 | * These aren't exported outside the kernel to avoid name space clashes | ||
42 | */ | ||
43 | #ifdef __KERNEL__ | ||
44 | |||
45 | #ifndef __ASSEMBLY__ | ||
46 | |||
47 | typedef __signed__ char s8; | ||
48 | typedef unsigned char u8; | ||
49 | |||
50 | typedef __signed__ short s16; | ||
51 | typedef unsigned short u16; | ||
52 | |||
53 | typedef __signed__ int s32; | ||
54 | typedef unsigned int u32; | ||
55 | |||
56 | typedef __signed__ long long s64; | ||
57 | typedef unsigned long long u64; | ||
58 | |||
59 | /* DMA addresses come in generic and 64-bit flavours. */ | ||
60 | |||
61 | #ifdef CONFIG_HIGHMEM64G | ||
62 | typedef u64 dma_addr_t; | ||
63 | #else | ||
64 | typedef u32 dma_addr_t; | ||
65 | #endif | ||
66 | typedef u64 dma64_addr_t; | ||
67 | |||
68 | #endif /* __ASSEMBLY__ */ | ||
69 | |||
70 | #define BITS_PER_LONG 32 | ||
71 | |||
72 | #endif /* __KERNEL__ */ | ||
73 | |||
74 | #endif /* __ASM_SH64_TYPES_H */ | ||
diff --git a/include/asm-sh64/ucontext.h b/include/asm-sh64/ucontext.h deleted file mode 100644 index cf77a08551ca..000000000000 --- a/include/asm-sh64/ucontext.h +++ /dev/null | |||
@@ -1,23 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_UCONTEXT_H | ||
2 | #define __ASM_SH64_UCONTEXT_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/ucontext.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | struct ucontext { | ||
16 | unsigned long uc_flags; | ||
17 | struct ucontext *uc_link; | ||
18 | stack_t uc_stack; | ||
19 | struct sigcontext uc_mcontext; | ||
20 | sigset_t uc_sigmask; /* mask last for extensibility */ | ||
21 | }; | ||
22 | |||
23 | #endif /* __ASM_SH64_UCONTEXT_H */ | ||
diff --git a/include/asm-sh64/unaligned.h b/include/asm-sh64/unaligned.h deleted file mode 100644 index 74481b186ae8..000000000000 --- a/include/asm-sh64/unaligned.h +++ /dev/null | |||
@@ -1,17 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_UNALIGNED_H | ||
2 | #define __ASM_SH64_UNALIGNED_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/unaligned.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #include <asm-generic/unaligned.h> | ||
16 | |||
17 | #endif /* __ASM_SH64_UNALIGNED_H */ | ||
diff --git a/include/asm-sh64/user.h b/include/asm-sh64/user.h deleted file mode 100644 index eb3b33edd73e..000000000000 --- a/include/asm-sh64/user.h +++ /dev/null | |||
@@ -1,70 +0,0 @@ | |||
1 | #ifndef __ASM_SH64_USER_H | ||
2 | #define __ASM_SH64_USER_H | ||
3 | |||
4 | /* | ||
5 | * This file is subject to the terms and conditions of the GNU General Public | ||
6 | * License. See the file "COPYING" in the main directory of this archive | ||
7 | * for more details. | ||
8 | * | ||
9 | * include/asm-sh64/user.h | ||
10 | * | ||
11 | * Copyright (C) 2000, 2001 Paolo Alberelli | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #include <linux/types.h> | ||
16 | #include <asm/ptrace.h> | ||
17 | #include <asm/page.h> | ||
18 | |||
19 | /* | ||
20 | * Core file format: The core file is written in such a way that gdb | ||
21 | * can understand it and provide useful information to the user (under | ||
22 | * linux we use the `trad-core' bfd). The file contents are as follows: | ||
23 | * | ||
24 | * upage: 1 page consisting of a user struct that tells gdb | ||
25 | * what is present in the file. Directly after this is a | ||
26 | * copy of the task_struct, which is currently not used by gdb, | ||
27 | * but it may come in handy at some point. All of the registers | ||
28 | * are stored as part of the upage. The upage should always be | ||
29 | * only one page long. | ||
30 | * data: The data segment follows next. We use current->end_text to | ||
31 | * current->brk to pick up all of the user variables, plus any memory | ||
32 | * that may have been sbrk'ed. No attempt is made to determine if a | ||
33 | * page is demand-zero or if a page is totally unused, we just cover | ||
34 | * the entire range. All of the addresses are rounded in such a way | ||
35 | * that an integral number of pages is written. | ||
36 | * stack: We need the stack information in order to get a meaningful | ||
37 | * backtrace. We need to write the data from usp to | ||
38 | * current->start_stack, so we round each of these in order to be able | ||
39 | * to write an integer number of pages. | ||
40 | */ | ||
41 | |||
42 | struct user_fpu_struct { | ||
43 | unsigned long long fp_regs[32]; | ||
44 | unsigned int fpscr; | ||
45 | }; | ||
46 | |||
47 | struct user { | ||
48 | struct pt_regs regs; /* entire machine state */ | ||
49 | struct user_fpu_struct fpu; /* Math Co-processor registers */ | ||
50 | int u_fpvalid; /* True if math co-processor being used */ | ||
51 | size_t u_tsize; /* text size (pages) */ | ||
52 | size_t u_dsize; /* data size (pages) */ | ||
53 | size_t u_ssize; /* stack size (pages) */ | ||
54 | unsigned long start_code; /* text starting address */ | ||
55 | unsigned long start_data; /* data starting address */ | ||
56 | unsigned long start_stack; /* stack starting address */ | ||
57 | long int signal; /* signal causing core dump */ | ||
58 | struct regs * u_ar0; /* help gdb find registers */ | ||
59 | struct user_fpu_struct* u_fpstate; /* Math Co-processor pointer */ | ||
60 | unsigned long magic; /* identifies a core file */ | ||
61 | char u_comm[32]; /* user command name */ | ||
62 | }; | ||
63 | |||
64 | #define NBPG PAGE_SIZE | ||
65 | #define UPAGES 1 | ||
66 | #define HOST_TEXT_START_ADDR (u.start_code) | ||
67 | #define HOST_DATA_START_ADDR (u.start_data) | ||
68 | #define HOST_STACK_END_ADDR (u.start_stack + u.u_ssize * NBPG) | ||
69 | |||
70 | #endif /* __ASM_SH64_USER_H */ | ||