Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * include/asm-sh/processor.h |
| 3 | * |
| 4 | * Copyright (C) 1999, 2000 Niibe Yutaka |
| 5 | * Copyright (C) 2002, 2003 Paul Mundt |
| 6 | */ |
| 7 | |
| 8 | #ifndef __ASM_SH_PROCESSOR_H |
| 9 | #define __ASM_SH_PROCESSOR_H |
| 10 | #ifdef __KERNEL__ |
| 11 | |
Chase Venters | f6dc8c5 | 2006-07-08 11:10:29 -0500 | [diff] [blame] | 12 | #include <linux/compiler.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <asm/page.h> |
| 14 | #include <asm/types.h> |
| 15 | #include <asm/cache.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | #include <asm/ptrace.h> |
Paul Mundt | 315bb96 | 2006-09-27 18:22:53 +0900 | [diff] [blame^] | 17 | #include <asm/cpu-features.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
| 19 | /* |
| 20 | * Default implementation of macro that returns current |
| 21 | * instruction pointer ("program counter"). |
| 22 | */ |
| 23 | #define current_text_addr() ({ void *pc; __asm__("mova 1f, %0\n1:":"=z" (pc)); pc; }) |
| 24 | |
| 25 | /* Core Processor Version Register */ |
| 26 | #define CCN_PVR 0xff000030 |
| 27 | #define CCN_CVR 0xff000040 |
| 28 | #define CCN_PRR 0xff000044 |
| 29 | |
| 30 | /* |
| 31 | * CPU type and hardware bug flags. Kept separately for each CPU. |
| 32 | * |
| 33 | * Each one of these also needs a CONFIG_CPU_SUBTYPE_xxx entry |
Paul Mundt | de02797 | 2006-02-01 03:06:02 -0800 | [diff] [blame] | 34 | * in arch/sh/mm/Kconfig, as well as an entry in arch/sh/kernel/setup.c |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | * for parsing the subtype in get_cpu_subtype(). |
| 36 | */ |
| 37 | enum cpu_type { |
| 38 | /* SH-2 types */ |
| 39 | CPU_SH7604, |
| 40 | |
| 41 | /* SH-3 types */ |
Paul Mundt | e5723e0 | 2006-09-27 17:38:11 +0900 | [diff] [blame] | 42 | CPU_SH7705, CPU_SH7706, CPU_SH7707, |
| 43 | CPU_SH7708, CPU_SH7708S, CPU_SH7708R, |
| 44 | CPU_SH7709, CPU_SH7709A, CPU_SH7710, |
| 45 | CPU_SH7729, CPU_SH7300, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | |
| 47 | /* SH-4 types */ |
| 48 | CPU_SH7750, CPU_SH7750S, CPU_SH7750R, CPU_SH7751, CPU_SH7751R, |
| 49 | CPU_SH7760, CPU_ST40RA, CPU_ST40GX1, CPU_SH4_202, CPU_SH4_501, |
Paul Mundt | e5723e0 | 2006-09-27 17:38:11 +0900 | [diff] [blame] | 50 | CPU_SH73180, CPU_SH7343, CPU_SH7770, CPU_SH7780, CPU_SH7781, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | |
| 52 | /* Unknown subtype */ |
| 53 | CPU_SH_NONE |
| 54 | }; |
| 55 | |
| 56 | struct sh_cpuinfo { |
| 57 | enum cpu_type type; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | unsigned long loops_per_jiffy; |
| 59 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | struct cache_info icache; |
| 61 | struct cache_info dcache; |
| 62 | |
| 63 | unsigned long flags; |
| 64 | }; |
| 65 | |
| 66 | extern struct sh_cpuinfo boot_cpu_data; |
| 67 | |
| 68 | #ifdef CONFIG_SMP |
| 69 | extern struct sh_cpuinfo cpu_data[]; |
| 70 | #define current_cpu_data cpu_data[smp_processor_id()] |
| 71 | #else |
| 72 | #define cpu_data (&boot_cpu_data) |
| 73 | #define current_cpu_data boot_cpu_data |
| 74 | #endif |
| 75 | |
| 76 | /* |
| 77 | * User space process size: 2GB. |
| 78 | * |
| 79 | * Since SH7709 and SH7750 have "area 7", we can't use 0x7c000000--0x7fffffff |
| 80 | */ |
| 81 | #define TASK_SIZE 0x7c000000UL |
| 82 | |
| 83 | /* This decides where the kernel will search for a free chunk of vm |
| 84 | * space during mmap's. |
| 85 | */ |
| 86 | #define TASK_UNMAPPED_BASE (TASK_SIZE / 3) |
| 87 | |
| 88 | /* |
| 89 | * Bit of SR register |
| 90 | * |
| 91 | * FD-bit: |
| 92 | * When it's set, it means the processor doesn't have right to use FPU, |
| 93 | * and it results exception when the floating operation is executed. |
| 94 | * |
| 95 | * IMASK-bit: |
| 96 | * Interrupt level mask |
| 97 | */ |
| 98 | #define SR_FD 0x00008000 |
| 99 | #define SR_DSP 0x00001000 |
| 100 | #define SR_IMASK 0x000000f0 |
| 101 | |
| 102 | /* |
| 103 | * FPU structure and data |
| 104 | */ |
| 105 | |
| 106 | struct sh_fpu_hard_struct { |
| 107 | unsigned long fp_regs[16]; |
| 108 | unsigned long xfp_regs[16]; |
| 109 | unsigned long fpscr; |
| 110 | unsigned long fpul; |
| 111 | |
| 112 | long status; /* software status information */ |
| 113 | }; |
| 114 | |
| 115 | /* Dummy fpu emulator */ |
| 116 | struct sh_fpu_soft_struct { |
| 117 | unsigned long fp_regs[16]; |
| 118 | unsigned long xfp_regs[16]; |
| 119 | unsigned long fpscr; |
| 120 | unsigned long fpul; |
| 121 | |
| 122 | unsigned char lookahead; |
| 123 | unsigned long entry_pc; |
| 124 | }; |
| 125 | |
| 126 | union sh_fpu_union { |
| 127 | struct sh_fpu_hard_struct hard; |
| 128 | struct sh_fpu_soft_struct soft; |
| 129 | }; |
| 130 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | struct thread_struct { |
| 132 | unsigned long sp; |
| 133 | unsigned long pc; |
| 134 | |
| 135 | unsigned long trap_no, error_code; |
| 136 | unsigned long address; |
| 137 | /* Hardware debugging registers may come here */ |
| 138 | unsigned long ubc_pc; |
| 139 | |
| 140 | /* floating point info */ |
| 141 | union sh_fpu_union fpu; |
| 142 | }; |
| 143 | |
Paul Mundt | 2991be7 | 2006-09-27 17:07:07 +0900 | [diff] [blame] | 144 | typedef struct { |
| 145 | unsigned long seg; |
| 146 | } mm_segment_t; |
| 147 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | /* Count of active tasks with UBC settings */ |
| 149 | extern int ubc_usercnt; |
| 150 | |
| 151 | #define INIT_THREAD { \ |
| 152 | sizeof(init_stack) + (long) &init_stack, /* sp */ \ |
| 153 | 0, /* pc */ \ |
Paul Mundt | de02797 | 2006-02-01 03:06:02 -0800 | [diff] [blame] | 154 | 0, 0, \ |
| 155 | 0, \ |
| 156 | 0, \ |
| 157 | {{{0,}},} /* fpu state */ \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | /* |
| 161 | * Do necessary setup to start up a newly executed thread. |
| 162 | */ |
| 163 | #define start_thread(regs, new_pc, new_sp) \ |
| 164 | set_fs(USER_DS); \ |
Paul Mundt | de02797 | 2006-02-01 03:06:02 -0800 | [diff] [blame] | 165 | regs->pr = 0; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | regs->sr = SR_FD; /* User mode. */ \ |
| 167 | regs->pc = new_pc; \ |
| 168 | regs->regs[15] = new_sp |
| 169 | |
| 170 | /* Forward declaration, a strange C thing */ |
| 171 | struct task_struct; |
| 172 | struct mm_struct; |
| 173 | |
| 174 | /* Free all resources held by a thread. */ |
| 175 | extern void release_thread(struct task_struct *); |
| 176 | |
| 177 | /* Prepare to copy thread state - unlazy all lazy status */ |
| 178 | #define prepare_to_copy(tsk) do { } while (0) |
| 179 | |
| 180 | /* |
| 181 | * create a kernel thread without removing it from tasklists |
| 182 | */ |
| 183 | extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags); |
| 184 | |
| 185 | /* Copy and release all segment info associated with a VM */ |
| 186 | #define copy_segments(p, mm) do { } while(0) |
| 187 | #define release_segments(mm) do { } while(0) |
| 188 | |
| 189 | /* |
| 190 | * FPU lazy state save handling. |
| 191 | */ |
| 192 | |
| 193 | static __inline__ void disable_fpu(void) |
| 194 | { |
| 195 | unsigned long __dummy; |
| 196 | |
| 197 | /* Set FD flag in SR */ |
| 198 | __asm__ __volatile__("stc sr, %0\n\t" |
| 199 | "or %1, %0\n\t" |
| 200 | "ldc %0, sr" |
| 201 | : "=&r" (__dummy) |
| 202 | : "r" (SR_FD)); |
| 203 | } |
| 204 | |
| 205 | static __inline__ void enable_fpu(void) |
| 206 | { |
| 207 | unsigned long __dummy; |
| 208 | |
| 209 | /* Clear out FD flag in SR */ |
| 210 | __asm__ __volatile__("stc sr, %0\n\t" |
| 211 | "and %1, %0\n\t" |
| 212 | "ldc %0, sr" |
| 213 | : "=&r" (__dummy) |
| 214 | : "r" (~SR_FD)); |
| 215 | } |
| 216 | |
| 217 | static __inline__ void release_fpu(struct pt_regs *regs) |
| 218 | { |
| 219 | regs->sr |= SR_FD; |
| 220 | } |
| 221 | |
| 222 | static __inline__ void grab_fpu(struct pt_regs *regs) |
| 223 | { |
| 224 | regs->sr &= ~SR_FD; |
| 225 | } |
| 226 | |
| 227 | #ifdef CONFIG_CPU_SH4 |
| 228 | extern void save_fpu(struct task_struct *__tsk, struct pt_regs *regs); |
| 229 | #else |
| 230 | #define save_fpu(tsk) do { } while (0) |
| 231 | #endif |
| 232 | |
Paul Mundt | de02797 | 2006-02-01 03:06:02 -0800 | [diff] [blame] | 233 | #define unlazy_fpu(tsk, regs) do { \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | if (test_tsk_thread_flag(tsk, TIF_USEDFPU)) { \ |
Paul Mundt | de02797 | 2006-02-01 03:06:02 -0800 | [diff] [blame] | 235 | save_fpu(tsk, regs); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | } \ |
| 237 | } while (0) |
| 238 | |
Paul Mundt | de02797 | 2006-02-01 03:06:02 -0800 | [diff] [blame] | 239 | #define clear_fpu(tsk, regs) do { \ |
| 240 | if (test_tsk_thread_flag(tsk, TIF_USEDFPU)) { \ |
| 241 | clear_tsk_thread_flag(tsk, TIF_USEDFPU); \ |
| 242 | release_fpu(regs); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | } \ |
| 244 | } while (0) |
| 245 | |
| 246 | /* Double presision, NANS as NANS, rounding to nearest, no exceptions */ |
| 247 | #define FPSCR_INIT 0x00080000 |
| 248 | |
| 249 | #define FPSCR_CAUSE_MASK 0x0001f000 /* Cause bits */ |
| 250 | #define FPSCR_FLAG_MASK 0x0000007c /* Flag bits */ |
| 251 | |
| 252 | /* |
| 253 | * Return saved PC of a blocked thread. |
| 254 | */ |
| 255 | #define thread_saved_pc(tsk) (tsk->thread.pc) |
| 256 | |
| 257 | extern unsigned long get_wchan(struct task_struct *p); |
| 258 | |
| 259 | #define KSTK_EIP(tsk) ((tsk)->thread.pc) |
| 260 | #define KSTK_ESP(tsk) ((tsk)->thread.sp) |
| 261 | |
| 262 | #define cpu_sleep() __asm__ __volatile__ ("sleep" : : : "memory") |
Chase Venters | f6dc8c5 | 2006-07-08 11:10:29 -0500 | [diff] [blame] | 263 | #define cpu_relax() barrier() |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | |
Paul Mundt | e86d6b6 | 2006-09-27 14:20:54 +0900 | [diff] [blame] | 265 | #if defined(CONFIG_CPU_SH2A) || defined(CONFIG_CPU_SH3) || \ |
| 266 | defined(CONFIG_CPU_SH4) |
| 267 | #define PREFETCH_STRIDE L1_CACHE_BYTES |
| 268 | #define ARCH_HAS_PREFETCH |
| 269 | #define ARCH_HAS_PREFETCHW |
| 270 | static inline void prefetch(void *x) |
| 271 | { |
| 272 | __asm__ __volatile__ ("pref @%0\n\t" : : "r" (x) : "memory"); |
| 273 | } |
| 274 | |
| 275 | #define prefetchw(x) prefetch(x) |
| 276 | #endif |
| 277 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | #endif /* __KERNEL__ */ |
| 279 | #endif /* __ASM_SH_PROCESSOR_H */ |