Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 1 | #ifndef _ASM_POWERPC_PROCESSOR_H |
| 2 | #define _ASM_POWERPC_PROCESSOR_H |
| 3 | |
| 4 | /* |
| 5 | * Copyright (C) 2001 PPC 64 Team, IBM Corp |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU General Public License |
| 9 | * as published by the Free Software Foundation; either version |
| 10 | * 2 of the License, or (at your option) any later version. |
| 11 | */ |
| 12 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 13 | #include <asm/reg.h> |
| 14 | |
Michael Neuling | 9c75a31 | 2008-06-26 17:07:48 +1000 | [diff] [blame] | 15 | #define TS_FPRWIDTH 1 |
| 16 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 17 | #ifndef __ASSEMBLY__ |
| 18 | #include <linux/compiler.h> |
| 19 | #include <asm/ptrace.h> |
| 20 | #include <asm/types.h> |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 21 | |
Paul Mackerras | 799d604 | 2005-11-10 13:37:51 +1100 | [diff] [blame] | 22 | /* We do _not_ want to define new machine types at all, those must die |
| 23 | * in favor of using the device-tree |
| 24 | * -- BenH. |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 25 | */ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 26 | |
Paul Mackerras | 799d604 | 2005-11-10 13:37:51 +1100 | [diff] [blame] | 27 | /* PREP sub-platform types see residual.h for these */ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 28 | #define _PREP_Motorola 0x01 /* motorola prep */ |
| 29 | #define _PREP_Firm 0x02 /* firmworks prep */ |
| 30 | #define _PREP_IBM 0x00 /* ibm prep */ |
| 31 | #define _PREP_Bull 0x03 /* bull prep */ |
| 32 | |
Paul Mackerras | 799d604 | 2005-11-10 13:37:51 +1100 | [diff] [blame] | 33 | /* CHRP sub-platform types. These are arbitrary */ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 34 | #define _CHRP_Motorola 0x04 /* motorola chrp, the cobra */ |
| 35 | #define _CHRP_IBM 0x05 /* IBM chrp, the longtrail and longtrail 2 */ |
| 36 | #define _CHRP_Pegasos 0x06 /* Genesi/bplan's Pegasos and Pegasos2 */ |
Benjamin Herrenschmidt | 26c5032 | 2006-07-04 14:16:28 +1000 | [diff] [blame] | 37 | #define _CHRP_briq 0x07 /* TotalImpact's briQ */ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 38 | |
Benjamin Herrenschmidt | e822250 | 2006-03-28 23:15:54 +1100 | [diff] [blame] | 39 | #if defined(__KERNEL__) && defined(CONFIG_PPC32) |
| 40 | |
| 41 | extern int _chrp_type; |
Paul Mackerras | 799d604 | 2005-11-10 13:37:51 +1100 | [diff] [blame] | 42 | |
Paul Mackerras | 0a26b13 | 2006-03-28 10:22:10 +1100 | [diff] [blame] | 43 | #ifdef CONFIG_PPC_PREP |
Paul Mackerras | 799d604 | 2005-11-10 13:37:51 +1100 | [diff] [blame] | 44 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 45 | /* what kind of prep workstation we are */ |
| 46 | extern int _prep_type; |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 47 | |
Paul Mackerras | 0a26b13 | 2006-03-28 10:22:10 +1100 | [diff] [blame] | 48 | #endif /* CONFIG_PPC_PREP */ |
| 49 | |
Benjamin Herrenschmidt | e822250 | 2006-03-28 23:15:54 +1100 | [diff] [blame] | 50 | #endif /* defined(__KERNEL__) && defined(CONFIG_PPC32) */ |
| 51 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 52 | /* |
| 53 | * Default implementation of macro that returns current |
| 54 | * instruction pointer ("program counter"). |
| 55 | */ |
| 56 | #define current_text_addr() ({ __label__ _l; _l: &&_l;}) |
| 57 | |
| 58 | /* Macros for adjusting thread priority (hardware multi-threading) */ |
| 59 | #define HMT_very_low() asm volatile("or 31,31,31 # very low priority") |
| 60 | #define HMT_low() asm volatile("or 1,1,1 # low priority") |
| 61 | #define HMT_medium_low() asm volatile("or 6,6,6 # medium low priority") |
| 62 | #define HMT_medium() asm volatile("or 2,2,2 # medium priority") |
| 63 | #define HMT_medium_high() asm volatile("or 5,5,5 # medium high priority") |
| 64 | #define HMT_high() asm volatile("or 3,3,3 # high priority") |
| 65 | |
| 66 | #ifdef __KERNEL__ |
| 67 | |
| 68 | extern int have_of; |
| 69 | |
| 70 | struct task_struct; |
| 71 | void start_thread(struct pt_regs *regs, unsigned long fdptr, unsigned long sp); |
| 72 | void release_thread(struct task_struct *); |
| 73 | |
| 74 | /* Prepare to copy thread state - unlazy all lazy status */ |
| 75 | extern void prepare_to_copy(struct task_struct *tsk); |
| 76 | |
| 77 | /* Create a new kernel thread. */ |
| 78 | extern long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags); |
| 79 | |
| 80 | /* Lazy FPU handling on uni-processor */ |
| 81 | extern struct task_struct *last_task_used_math; |
| 82 | extern struct task_struct *last_task_used_altivec; |
| 83 | extern struct task_struct *last_task_used_spe; |
| 84 | |
| 85 | #ifdef CONFIG_PPC32 |
Rune Torgersen | 7c4f10b | 2008-05-24 01:59:15 +1000 | [diff] [blame] | 86 | |
| 87 | #if CONFIG_TASK_SIZE > CONFIG_KERNEL_START |
| 88 | #error User TASK_SIZE overlaps with KERNEL_START address |
| 89 | #endif |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 90 | #define TASK_SIZE (CONFIG_TASK_SIZE) |
| 91 | |
| 92 | /* This decides where the kernel will search for a free chunk of vm |
| 93 | * space during mmap's. |
| 94 | */ |
| 95 | #define TASK_UNMAPPED_BASE (TASK_SIZE / 8 * 3) |
| 96 | #endif |
| 97 | |
| 98 | #ifdef CONFIG_PPC64 |
| 99 | /* 64-bit user address space is 44-bits (16TB user VM) */ |
| 100 | #define TASK_SIZE_USER64 (0x0000100000000000UL) |
| 101 | |
| 102 | /* |
| 103 | * 32-bit user address space is 4GB - 1 page |
| 104 | * (this 1 page is needed so referencing of 0xFFFFFFFF generates EFAULT |
| 105 | */ |
| 106 | #define TASK_SIZE_USER32 (0x0000000100000000UL - (1*PAGE_SIZE)) |
| 107 | |
Dave Hansen | 8245525 | 2008-02-04 22:28:59 -0800 | [diff] [blame] | 108 | #define TASK_SIZE_OF(tsk) (test_tsk_thread_flag(tsk, TIF_32BIT) ? \ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 109 | TASK_SIZE_USER32 : TASK_SIZE_USER64) |
Dave Hansen | 8245525 | 2008-02-04 22:28:59 -0800 | [diff] [blame] | 110 | #define TASK_SIZE TASK_SIZE_OF(current) |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 111 | |
| 112 | /* This decides where the kernel will search for a free chunk of vm |
| 113 | * space during mmap's. |
| 114 | */ |
| 115 | #define TASK_UNMAPPED_BASE_USER32 (PAGE_ALIGN(TASK_SIZE_USER32 / 4)) |
| 116 | #define TASK_UNMAPPED_BASE_USER64 (PAGE_ALIGN(TASK_SIZE_USER64 / 4)) |
| 117 | |
| 118 | #define TASK_UNMAPPED_BASE ((test_thread_flag(TIF_32BIT)) ? \ |
| 119 | TASK_UNMAPPED_BASE_USER32 : TASK_UNMAPPED_BASE_USER64 ) |
| 120 | #endif |
| 121 | |
David Howells | 922a70d | 2008-02-08 04:19:26 -0800 | [diff] [blame] | 122 | #ifdef __KERNEL__ |
| 123 | #ifdef __powerpc64__ |
| 124 | |
| 125 | #define STACK_TOP_USER64 TASK_SIZE_USER64 |
| 126 | #define STACK_TOP_USER32 TASK_SIZE_USER32 |
| 127 | |
| 128 | #define STACK_TOP (test_thread_flag(TIF_32BIT) ? \ |
| 129 | STACK_TOP_USER32 : STACK_TOP_USER64) |
| 130 | |
| 131 | #define STACK_TOP_MAX STACK_TOP_USER64 |
| 132 | |
| 133 | #else /* __powerpc64__ */ |
| 134 | |
| 135 | #define STACK_TOP TASK_SIZE |
| 136 | #define STACK_TOP_MAX STACK_TOP |
| 137 | |
| 138 | #endif /* __powerpc64__ */ |
| 139 | #endif /* __KERNEL__ */ |
| 140 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 141 | typedef struct { |
| 142 | unsigned long seg; |
| 143 | } mm_segment_t; |
| 144 | |
Michael Neuling | 9c75a31 | 2008-06-26 17:07:48 +1000 | [diff] [blame] | 145 | #define TS_FPR(i) fpr[i] |
| 146 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 147 | struct thread_struct { |
| 148 | unsigned long ksp; /* Kernel stack pointer */ |
Kumar Gala | 8521882 | 2008-04-28 16:21:22 +1000 | [diff] [blame] | 149 | unsigned long ksp_limit; /* if ksp <= ksp_limit stack overflow */ |
| 150 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 151 | #ifdef CONFIG_PPC64 |
| 152 | unsigned long ksp_vsid; |
| 153 | #endif |
| 154 | struct pt_regs *regs; /* Pointer to saved register state */ |
| 155 | mm_segment_t fs; /* for get_fs() validation */ |
| 156 | #ifdef CONFIG_PPC32 |
| 157 | void *pgdir; /* root of page-table tree */ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 158 | #endif |
| 159 | #if defined(CONFIG_4xx) || defined (CONFIG_BOOKE) |
| 160 | unsigned long dbcr0; /* debug control register values */ |
| 161 | unsigned long dbcr1; |
| 162 | #endif |
| 163 | double fpr[32]; /* Complete floating point set */ |
David Gibson | 25c8a78 | 2005-10-27 16:27:25 +1000 | [diff] [blame] | 164 | struct { /* fpr ... fpscr must be contiguous */ |
| 165 | |
| 166 | unsigned int pad; |
| 167 | unsigned int val; /* Floating point status */ |
| 168 | } fpscr; |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 169 | int fpexc_mode; /* floating-point exception mode */ |
Paul Mackerras | e9370ae | 2006-06-07 16:15:39 +1000 | [diff] [blame] | 170 | unsigned int align_ctl; /* alignment handling control */ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 171 | #ifdef CONFIG_PPC64 |
| 172 | unsigned long start_tb; /* Start purr when proc switched in */ |
| 173 | unsigned long accum_tb; /* Total accumilated purr for process */ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 174 | #endif |
| 175 | unsigned long dabr; /* Data address breakpoint register */ |
| 176 | #ifdef CONFIG_ALTIVEC |
| 177 | /* Complete AltiVec register set */ |
Mike Frysinger | fc624ea | 2007-07-15 13:36:09 +1000 | [diff] [blame] | 178 | vector128 vr[32] __attribute__((aligned(16))); |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 179 | /* AltiVec status */ |
Mike Frysinger | fc624ea | 2007-07-15 13:36:09 +1000 | [diff] [blame] | 180 | vector128 vscr __attribute__((aligned(16))); |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 181 | unsigned long vrsave; |
| 182 | int used_vr; /* set if process has used altivec */ |
| 183 | #endif /* CONFIG_ALTIVEC */ |
| 184 | #ifdef CONFIG_SPE |
| 185 | unsigned long evr[32]; /* upper 32-bits of SPE regs */ |
| 186 | u64 acc; /* Accumulator */ |
| 187 | unsigned long spefscr; /* SPE & eFP status */ |
| 188 | int used_spe; /* set if process has used spe */ |
| 189 | #endif /* CONFIG_SPE */ |
| 190 | }; |
| 191 | |
| 192 | #define ARCH_MIN_TASKALIGN 16 |
| 193 | |
| 194 | #define INIT_SP (sizeof(init_stack) + (unsigned long) &init_stack) |
Kumar Gala | 8521882 | 2008-04-28 16:21:22 +1000 | [diff] [blame] | 195 | #define INIT_SP_LIMIT \ |
| 196 | (_ALIGN_UP(sizeof(init_thread_info), 16) + (unsigned long) &init_stack) |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 197 | |
| 198 | |
| 199 | #ifdef CONFIG_PPC32 |
| 200 | #define INIT_THREAD { \ |
| 201 | .ksp = INIT_SP, \ |
Kumar Gala | 8521882 | 2008-04-28 16:21:22 +1000 | [diff] [blame] | 202 | .ksp_limit = INIT_SP_LIMIT, \ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 203 | .fs = KERNEL_DS, \ |
| 204 | .pgdir = swapper_pg_dir, \ |
| 205 | .fpexc_mode = MSR_FE0 | MSR_FE1, \ |
| 206 | } |
| 207 | #else |
| 208 | #define INIT_THREAD { \ |
| 209 | .ksp = INIT_SP, \ |
Kumar Gala | 8521882 | 2008-04-28 16:21:22 +1000 | [diff] [blame] | 210 | .ksp_limit = INIT_SP_LIMIT, \ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 211 | .regs = (struct pt_regs *)INIT_SP - 1, /* XXX bogus, I think */ \ |
| 212 | .fs = KERNEL_DS, \ |
| 213 | .fpr = {0}, \ |
David Gibson | 25c8a78 | 2005-10-27 16:27:25 +1000 | [diff] [blame] | 214 | .fpscr = { .val = 0, }, \ |
Arnd Bergmann | ddf5f75 | 2006-06-20 02:30:33 +0200 | [diff] [blame] | 215 | .fpexc_mode = 0, \ |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 216 | } |
| 217 | #endif |
| 218 | |
| 219 | /* |
| 220 | * Return saved PC of a blocked thread. For now, this is the "user" PC |
| 221 | */ |
| 222 | #define thread_saved_pc(tsk) \ |
| 223 | ((tsk)->thread.regs? (tsk)->thread.regs->nip: 0) |
| 224 | |
| 225 | unsigned long get_wchan(struct task_struct *p); |
| 226 | |
| 227 | #define KSTK_EIP(tsk) ((tsk)->thread.regs? (tsk)->thread.regs->nip: 0) |
| 228 | #define KSTK_ESP(tsk) ((tsk)->thread.regs? (tsk)->thread.regs->gpr[1]: 0) |
| 229 | |
| 230 | /* Get/set floating-point exception mode */ |
| 231 | #define GET_FPEXC_CTL(tsk, adr) get_fpexc_mode((tsk), (adr)) |
| 232 | #define SET_FPEXC_CTL(tsk, val) set_fpexc_mode((tsk), (val)) |
| 233 | |
| 234 | extern int get_fpexc_mode(struct task_struct *tsk, unsigned long adr); |
| 235 | extern int set_fpexc_mode(struct task_struct *tsk, unsigned int val); |
| 236 | |
Paul Mackerras | fab5db9 | 2006-06-07 16:14:40 +1000 | [diff] [blame] | 237 | #define GET_ENDIAN(tsk, adr) get_endian((tsk), (adr)) |
| 238 | #define SET_ENDIAN(tsk, val) set_endian((tsk), (val)) |
| 239 | |
| 240 | extern int get_endian(struct task_struct *tsk, unsigned long adr); |
| 241 | extern int set_endian(struct task_struct *tsk, unsigned int val); |
| 242 | |
Paul Mackerras | e9370ae | 2006-06-07 16:15:39 +1000 | [diff] [blame] | 243 | #define GET_UNALIGN_CTL(tsk, adr) get_unalign_ctl((tsk), (adr)) |
| 244 | #define SET_UNALIGN_CTL(tsk, val) set_unalign_ctl((tsk), (val)) |
| 245 | |
| 246 | extern int get_unalign_ctl(struct task_struct *tsk, unsigned long adr); |
| 247 | extern int set_unalign_ctl(struct task_struct *tsk, unsigned int val); |
| 248 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 249 | static inline unsigned int __unpack_fe01(unsigned long msr_bits) |
| 250 | { |
| 251 | return ((msr_bits & MSR_FE0) >> 10) | ((msr_bits & MSR_FE1) >> 8); |
| 252 | } |
| 253 | |
| 254 | static inline unsigned long __pack_fe01(unsigned int fpmode) |
| 255 | { |
| 256 | return ((fpmode << 10) & MSR_FE0) | ((fpmode << 8) & MSR_FE1); |
| 257 | } |
| 258 | |
| 259 | #ifdef CONFIG_PPC64 |
| 260 | #define cpu_relax() do { HMT_low(); HMT_medium(); barrier(); } while (0) |
| 261 | #else |
| 262 | #define cpu_relax() barrier() |
| 263 | #endif |
| 264 | |
Anton Blanchard | 2f25194 | 2006-03-27 11:46:18 +1100 | [diff] [blame] | 265 | /* Check that a certain kernel stack pointer is valid in task_struct p */ |
| 266 | int validate_sp(unsigned long sp, struct task_struct *p, |
| 267 | unsigned long nbytes); |
| 268 | |
Paul Mackerras | 9f04b9e | 2005-10-10 14:19:43 +1000 | [diff] [blame] | 269 | /* |
| 270 | * Prefetch macros. |
| 271 | */ |
| 272 | #define ARCH_HAS_PREFETCH |
| 273 | #define ARCH_HAS_PREFETCHW |
| 274 | #define ARCH_HAS_SPINLOCK_PREFETCH |
| 275 | |
| 276 | static inline void prefetch(const void *x) |
| 277 | { |
| 278 | if (unlikely(!x)) |
| 279 | return; |
| 280 | |
| 281 | __asm__ __volatile__ ("dcbt 0,%0" : : "r" (x)); |
| 282 | } |
| 283 | |
| 284 | static inline void prefetchw(const void *x) |
| 285 | { |
| 286 | if (unlikely(!x)) |
| 287 | return; |
| 288 | |
| 289 | __asm__ __volatile__ ("dcbtst 0,%0" : : "r" (x)); |
| 290 | } |
| 291 | |
| 292 | #define spin_lock_prefetch(x) prefetchw(x) |
| 293 | |
| 294 | #ifdef CONFIG_PPC64 |
| 295 | #define HAVE_ARCH_PICK_MMAP_LAYOUT |
| 296 | #endif |
| 297 | |
| 298 | #endif /* __KERNEL__ */ |
| 299 | #endif /* __ASSEMBLY__ */ |
| 300 | #endif /* _ASM_POWERPC_PROCESSOR_H */ |