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 <asm/ptrace.h> 21#include <cpu/registers.h> 22 23/* 24 * Default implementation of macro that returns current 25 * instruction pointer ("program counter"). 26 */ 27#define current_text_addr() ({ \ 28void *pc; \ 29unsigned long long __dummy = 0; \ 30__asm__("gettr tr0, %1\n\t" \ 31 "pta 4, tr0\n\t" \ 32 "gettr tr0, %0\n\t" \ 33 "ptabs %1, tr0\n\t" \ 34 :"=r" (pc), "=r" (__dummy) \ 35 : "1" (__dummy)); \ 36pc; }) 37 38#endif 39 40/* 41 * User space process size: 2GB - 4k. 42 */ 43#define TASK_SIZE 0x7ffff000UL 44 45#define STACK_TOP TASK_SIZE 46#define STACK_TOP_MAX STACK_TOP 47 48/* This decides where the kernel will search for a free chunk of vm 49 * space during mmap's. 50 */ 51#define TASK_UNMAPPED_BASE (TASK_SIZE / 3) 52 53/* 54 * Bit of SR register 55 * 56 * FD-bit: 57 * When it's set, it means the processor doesn't have right to use FPU, 58 * and it results exception when the floating operation is executed. 59 * 60 * IMASK-bit: 61 * Interrupt level mask 62 * 63 * STEP-bit: 64 * Single step bit 65 * 66 */ 67#if defined(CONFIG_SH64_SR_WATCH) 68#define SR_MMU 0x84000000 69#else 70#define SR_MMU 0x80000000 71#endif 72 73#define SR_IMASK 0x000000f0 74#define SR_FD 0x00008000 75#define SR_SSTEP 0x08000000 76 77#ifndef __ASSEMBLY__ 78 79/* 80 * FPU structure and data : require 8-byte alignment as we need to access it 81 with fld.p, fst.p 82 */ 83 84struct sh_fpu_hard_struct { 85 unsigned long fp_regs[64]; 86 unsigned int fpscr; 87 /* long status; * software status information */ 88}; 89 90/* Dummy fpu emulator */ 91struct sh_fpu_soft_struct { 92 unsigned long fp_regs[64]; 93 unsigned int fpscr; 94 unsigned char lookahead; 95 unsigned long entry_pc; 96}; 97 98union thread_xstate { 99 struct sh_fpu_hard_struct hardfpu; 100 struct sh_fpu_soft_struct softfpu; 101 /* 102 * The structure definitions only produce 32 bit alignment, yet we need 103 * to access them using 64 bit load/store as well. 104 */ 105 unsigned long long alignment_dummy; 106}; 107 108struct thread_struct { 109 unsigned long sp; 110 unsigned long pc; 111 112 /* Various thread flags, see SH_THREAD_xxx */ 113 unsigned long flags; 114 115 /* This stores the address of the pt_regs built during a context 116 switch, or of the register save area built for a kernel mode 117 exception. It is used for backtracing the stack of a sleeping task 118 or one that traps in kernel mode. */ 119 struct pt_regs *kregs; 120 /* This stores the address of the pt_regs constructed on entry from 121 user mode. It is a fixed value over the lifetime of a process, or 122 NULL for a kernel thread. */ 123 struct pt_regs *uregs; 124 125 unsigned long trap_no, error_code; 126 unsigned long address; 127 /* Hardware debugging registers may come here */ 128 129 /* floating point info */ 130 union thread_xstate *xstate; 131}; 132 133#define INIT_MMAP \ 134{ &init_mm, 0, 0, NULL, PAGE_SHARED, VM_READ | VM_WRITE | VM_EXEC, 1, NULL, NULL } 135 136#define INIT_THREAD { \ 137 .sp = sizeof(init_stack) + \ 138 (long) &init_stack, \ 139 .pc = 0, \ 140 .kregs = &fake_swapper_regs, \ 141 .uregs = NULL, \ 142 .trap_no = 0, \ 143 .error_code = 0, \ 144 .address = 0, \ 145 .flags = 0, \ 146} 147 148/* 149 * Do necessary setup to start up a newly executed thread. 150 */ 151#define SR_USER (SR_MMU | SR_FD) 152 153#define start_thread(_regs, new_pc, new_sp) \ 154 set_fs(USER_DS); \ 155 _regs->sr = SR_USER; /* User mode. */ \ 156 _regs->pc = new_pc - 4; /* Compensate syscall exit */ \ 157 _regs->pc |= 1; /* Set SHmedia ! */ \ 158 _regs->regs[18] = 0; \ 159 _regs->regs[15] = new_sp 160 161/* Forward declaration, a strange C thing */ 162struct task_struct; 163struct mm_struct; 164 165/* Free all resources held by a thread. */ 166extern void release_thread(struct task_struct *); 167/* 168 * create a kernel thread without removing it from tasklists 169 */ 170extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags); 171 172 173/* Copy and release all segment info associated with a VM */ 174#define copy_segments(p, mm) do { } while (0) 175#define release_segments(mm) do { } while (0) 176#define forget_segments() do { } while (0) 177#define prepare_to_copy(tsk) do { } while (0) 178/* 179 * FPU lazy state save handling. 180 */ 181 182static inline void disable_fpu(void) 183{ 184 unsigned long long __dummy; 185 186 /* Set FD flag in SR */ 187 __asm__ __volatile__("getcon " __SR ", %0\n\t" 188 "or %0, %1, %0\n\t" 189 "putcon %0, " __SR "\n\t" 190 : "=&r" (__dummy) 191 : "r" (SR_FD)); 192} 193 194static inline void enable_fpu(void) 195{ 196 unsigned long long __dummy; 197 198 /* Clear out FD flag in SR */ 199 __asm__ __volatile__("getcon " __SR ", %0\n\t" 200 "and %0, %1, %0\n\t" 201 "putcon %0, " __SR "\n\t" 202 : "=&r" (__dummy) 203 : "r" (~SR_FD)); 204} 205 206/* Round to nearest, no exceptions on inexact, overflow, underflow, 207 zero-divide, invalid. Configure option for whether to flush denorms to 208 zero, or except if a denorm is encountered. */ 209#if defined(CONFIG_SH64_FPU_DENORM_FLUSH) 210#define FPSCR_INIT 0x00040000 211#else 212#define FPSCR_INIT 0x00000000 213#endif 214 215#ifdef CONFIG_SH_FPU 216/* Initialise the FP state of a task */ 217void fpinit(struct sh_fpu_hard_struct *fpregs); 218#else 219#define fpinit(fpregs) do { } while (0) 220#endif 221 222extern struct task_struct *last_task_used_math; 223 224/* 225 * Return saved PC of a blocked thread. 226 */ 227#define thread_saved_pc(tsk) (tsk->thread.pc) 228 229extern unsigned long get_wchan(struct task_struct *p); 230 231#define KSTK_EIP(tsk) ((tsk)->thread.pc) 232#define KSTK_ESP(tsk) ((tsk)->thread.sp) 233 234#define user_stack_pointer(_regs) ((_regs)->regs[15]) 235 236#endif /* __ASSEMBLY__ */ 237#endif /* __ASM_SH_PROCESSOR_64_H */ 238