arch/sh/include/asm/processor_64.h

   1 #ifndef __ASM_SH_PROCESSOR_64_H
   2 #define __ASM_SH_PROCESSOR_64_H
   3
   4 /*
   5  * include/asm-sh/processor_64.h
   6  *
   7  * Copyright (C) 2000, 2001  Paolo Alberelli
   8  * Copyright (C) 2003  Paul Mundt
   9  * Copyright (C) 2004  Richard Curnow
  10  *
  11  * This file is subject to the terms and conditions of the GNU General Public
  12  * License.  See the file "COPYING" in the main directory of this archive
  13  * for more details.
  14  */
  15 #ifndef __ASSEMBLY__
  16
  17 #include <linux/compiler.h>
  18 #include <asm/page.h>
  19 #include <asm/types.h>
  20 #include <cpu/registers.h>
  21
  22 #endif
  23
  24 /*
  25  * User space process size: 2GB - 4k.
  26  */
  27 #define TASK_SIZE       0x7ffff000UL
  28
  29 #define STACK_TOP       TASK_SIZE
  30 #define STACK_TOP_MAX   STACK_TOP
  31
  32 /* This decides where the kernel will search for a free chunk of vm
  33  * space during mmap's.
  34  */
  35 #define TASK_UNMAPPED_BASE      PAGE_ALIGN(TASK_SIZE / 3)
  36
  37 /*
  38  * Bit of SR register
  39  *
  40  * FD-bit:
  41  *     When it's set, it means the processor doesn't have right to use FPU,
  42  *     and it results exception when the floating operation is executed.
  43  *
  44  * IMASK-bit:
  45  *     Interrupt level mask
  46  *
  47  * STEP-bit:
  48  *     Single step bit
  49  *
  50  */
  51 #if defined(CONFIG_SH64_SR_WATCH)
  52 #define SR_MMU   0x84000000
  53 #else
  54 #define SR_MMU   0x80000000
  55 #endif
  56
  57 #define SR_IMASK 0x000000f0
  58 #define SR_FD    0x00008000
  59 #define SR_SSTEP 0x08000000
  60
  61 #ifndef __ASSEMBLY__
  62
  63 /*
  64  * FPU structure and data : require 8-byte alignment as we need to access it
  65    with fld.p, fst.p
  66  */
  67
  68 struct sh_fpu_hard_struct {
  69         unsigned long fp_regs[64];
  70         unsigned int fpscr;
  71         /* long status; * software status information */
  72 };
  73
  74 /* Dummy fpu emulator  */
  75 struct sh_fpu_soft_struct {
  76         unsigned long fp_regs[64];
  77         unsigned int fpscr;
  78         unsigned char lookahead;
  79         unsigned long entry_pc;
  80 };
  81
  82 union thread_xstate {
  83         struct sh_fpu_hard_struct hardfpu;
  84         struct sh_fpu_soft_struct softfpu;
  85         /*
  86          * The structure definitions only produce 32 bit alignment, yet we need
  87          * to access them using 64 bit load/store as well.
  88          */
  89         unsigned long long alignment_dummy;
  90 };
  91
  92 struct thread_struct {
  93         unsigned long sp;
  94         unsigned long pc;
  95
  96         /* Various thread flags, see SH_THREAD_xxx */
  97         unsigned long flags;
  98
  99         /* This stores the address of the pt_regs built during a context
 100            switch, or of the register save area built for a kernel mode
 101            exception.  It is used for backtracing the stack of a sleeping task
 102            or one that traps in kernel mode. */
 103         struct pt_regs *kregs;
 104         /* This stores the address of the pt_regs constructed on entry from
 105            user mode.  It is a fixed value over the lifetime of a process, or
 106            NULL for a kernel thread. */
 107         struct pt_regs *uregs;
 108
 109         unsigned long address;
 110         /* Hardware debugging registers may come here */
 111
 112         /* floating point info */
 113         union thread_xstate *xstate;
 114
 115         /*
 116          * fpu_counter contains the number of consecutive context switches
 117          * that the FPU is used. If this is over a threshold, the lazy fpu
 118          * saving becomes unlazy to save the trap. This is an unsigned char
 119          * so that after 256 times the counter wraps and the behavior turns
 120          * lazy again; this to deal with bursty apps that only use FPU for
 121          * a short time
 122          */
 123         unsigned char fpu_counter;
 124 };
 125
 126 #define INIT_MMAP \
 127 { &init_mm, 0, 0, NULL, PAGE_SHARED, VM_READ | VM_WRITE | VM_EXEC, 1, NULL, NULL }
 128
 129 #define INIT_THREAD  {                          \
 130         .sp             = sizeof(init_stack) +  \
 131                           (long) &init_stack,   \
 132         .pc             = 0,                    \
 133         .kregs          = &fake_swapper_regs,   \
 134         .uregs          = NULL,                 \
 135         .address        = 0,                    \
 136         .flags          = 0,                    \
 137 }
 138
 139 /*
 140  * Do necessary setup to start up a newly executed thread.
 141  */
 142 #define SR_USER (SR_MMU | SR_FD)
 143
 144 #define start_thread(_regs, new_pc, new_sp)                     \
 145         _regs->sr = SR_USER;    /* User mode. */                \
 146         _regs->pc = new_pc - 4; /* Compensate syscall exit */   \
 147         _regs->pc |= 1;         /* Set SHmedia ! */             \
 148         _regs->regs[18] = 0;                                    \
 149         _regs->regs[15] = new_sp
 150
 151 /* Forward declaration, a strange C thing */
 152 struct task_struct;
 153 struct mm_struct;
 154
 155 /* Free all resources held by a thread. */
 156 extern void release_thread(struct task_struct *);
 157
 158 /*
 159  * FPU lazy state save handling.
 160  */
 161
 162 static inline void disable_fpu(void)
 163 {
 164         unsigned long long __dummy;
 165
 166         /* Set FD flag in SR */
 167         __asm__ __volatile__("getcon    " __SR ", %0\n\t"
 168                              "or        %0, %1, %0\n\t"
 169                              "putcon    %0, " __SR "\n\t"
 170                              : "=&r" (__dummy)
 171                              : "r" (SR_FD));
 172 }
 173
 174 static inline void enable_fpu(void)
 175 {
 176         unsigned long long __dummy;
 177
 178         /* Clear out FD flag in SR */
 179         __asm__ __volatile__("getcon    " __SR ", %0\n\t"
 180                              "and       %0, %1, %0\n\t"
 181                              "putcon    %0, " __SR "\n\t"
 182                              : "=&r" (__dummy)
 183                              : "r" (~SR_FD));
 184 }
 185
 186 /* Round to nearest, no exceptions on inexact, overflow, underflow,
 187    zero-divide, invalid.  Configure option for whether to flush denorms to
 188    zero, or except if a denorm is encountered.  */
 189 #if defined(CONFIG_SH64_FPU_DENORM_FLUSH)
 190 #define FPSCR_INIT  0x00040000
 191 #else
 192 #define FPSCR_INIT  0x00000000
 193 #endif
 194
 195 #ifdef CONFIG_SH_FPU
 196 /* Initialise the FP state of a task */
 197 void fpinit(struct sh_fpu_hard_struct *fpregs);
 198 #else
 199 #define fpinit(fpregs)  do { } while (0)
 200 #endif
 201
 202 extern struct task_struct *last_task_used_math;
 203
 204 /*
 205  * Return saved PC of a blocked thread.
 206  */
 207 #define thread_saved_pc(tsk)    (tsk->thread.pc)
 208
 209 extern unsigned long get_wchan(struct task_struct *p);
 210
 211 #define KSTK_EIP(tsk)  ((tsk)->thread.pc)
 212 #define KSTK_ESP(tsk)  ((tsk)->thread.sp)
 213
 214 #endif  /* __ASSEMBLY__ */
 215 #endif /* __ASM_SH_PROCESSOR_64_H */