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