include/asm-powerpc/processor.h

   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
  13 #include <asm/reg.h>
  14
  15 #define TS_FPRWIDTH 1
  16
  17 #ifndef __ASSEMBLY__
  18 #include <linux/compiler.h>
  19 #include <asm/ptrace.h>
  20 #include <asm/types.h>
  21
  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.
  25  */
  26
  27 /* PREP sub-platform types see residual.h for these */
  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
  33 /* CHRP sub-platform types. These are arbitrary */
  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 */
  37 #define _CHRP_briq      0x07    /* TotalImpact's briQ */
  38
  39 #if defined(__KERNEL__) && defined(CONFIG_PPC32)
  40
  41 extern int _chrp_type;
  42
  43 #ifdef CONFIG_PPC_PREP
  44
  45 /* what kind of prep workstation we are */
  46 extern int _prep_type;
  47
  48 #endif /* CONFIG_PPC_PREP */
  49
  50 #endif /* defined(__KERNEL__) && defined(CONFIG_PPC32) */
  51
  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
  86
  87 #if CONFIG_TASK_SIZE > CONFIG_KERNEL_START
  88 #error User TASK_SIZE overlaps with KERNEL_START address
  89 #endif
  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
 108 #define TASK_SIZE_OF(tsk) (test_tsk_thread_flag(tsk, TIF_32BIT) ? \
 109                 TASK_SIZE_USER32 : TASK_SIZE_USER64)
 110 #define TASK_SIZE         TASK_SIZE_OF(current)
 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
 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
 141 typedef struct {
 142         unsigned long seg;
 143 } mm_segment_t;
 144
 145 #define TS_FPR(i) fpr[i]
 146
 147 struct thread_struct {
 148         unsigned long   ksp;            /* Kernel stack pointer */
 149         unsigned long   ksp_limit;      /* if ksp <= ksp_limit stack overflow */
 150
 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 */
 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 */
 164         struct {                        /* fpr ... fpscr must be contiguous */
 165
 166                 unsigned int pad;
 167                 unsigned int val;       /* Floating point status */
 168         } fpscr;
 169         int             fpexc_mode;     /* floating-point exception mode */
 170         unsigned int    align_ctl;      /* alignment handling control */
 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 */
 174 #endif
 175         unsigned long   dabr;           /* Data address breakpoint register */
 176 #ifdef CONFIG_ALTIVEC
 177         /* Complete AltiVec register set */
 178         vector128       vr[32] __attribute__((aligned(16)));
 179         /* AltiVec status */
 180         vector128       vscr __attribute__((aligned(16)));
 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)
 195 #define INIT_SP_LIMIT \
 196         (_ALIGN_UP(sizeof(init_thread_info), 16) + (unsigned long) &init_stack)
 197
 198
 199 #ifdef CONFIG_PPC32
 200 #define INIT_THREAD { \
 201         .ksp = INIT_SP, \
 202         .ksp_limit = INIT_SP_LIMIT, \
 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, \
 210         .ksp_limit = INIT_SP_LIMIT, \
 211         .regs = (struct pt_regs *)INIT_SP - 1, /* XXX bogus, I think */ \
 212         .fs = KERNEL_DS, \
 213         .fpr = {0}, \
 214         .fpscr = { .val = 0, }, \
 215         .fpexc_mode = 0, \
 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
 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
 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
 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
 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
 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 */