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