1#ifndef __ASM_SH64_PROCESSOR_H 2#define __ASM_SH64_PROCESSOR_H 3 4/* 5 * This file is subject to the terms and conditions of the GNU General Public 6 * License. See the file "COPYING" in the main directory of this archive 7 * for more details. 8 * 9 * include/asm-sh64/processor.h 10 * 11 * Copyright (C) 2000, 2001 Paolo Alberelli 12 * Copyright (C) 2003 Paul Mundt 13 * Copyright (C) 2004 Richard Curnow 14 * 15 */ 16 17#include <asm/page.h> 18 19#ifndef __ASSEMBLY__ 20 21#include <asm/types.h> 22#include <asm/cache.h> 23#include <asm/registers.h> 24#include <linux/threads.h> 25#include <linux/compiler.h> 26 27/* 28 * Default implementation of macro that returns current 29 * instruction pointer ("program counter"). 30 */ 31#define current_text_addr() ({ \ 32void *pc; \ 33unsigned long long __dummy = 0; \ 34__asm__("gettr tr0, %1\n\t" \ 35 "pta 4, tr0\n\t" \ 36 "gettr tr0, %0\n\t" \ 37 "ptabs %1, tr0\n\t" \ 38 :"=r" (pc), "=r" (__dummy) \ 39 : "1" (__dummy)); \ 40pc; }) 41 42/* 43 * CPU type and hardware bug flags. Kept separately for each CPU. 44 */ 45enum cpu_type { 46 CPU_SH5_101, 47 CPU_SH5_103, 48 CPU_SH_NONE 49}; 50 51/* 52 * TLB information structure 53 * 54 * Defined for both I and D tlb, per-processor. 55 */ 56struct tlb_info { 57 unsigned long long next; 58 unsigned long long first; 59 unsigned long long last; 60 61 unsigned int entries; 62 unsigned int step; 63 64 unsigned long flags; 65}; 66 67struct sh_cpuinfo { 68 enum cpu_type type; 69 unsigned long loops_per_jiffy; 70 71 char hard_math; 72 73 unsigned long *pgd_quick; 74 unsigned long *pmd_quick; 75 unsigned long *pte_quick; 76 unsigned long pgtable_cache_sz; 77 unsigned int cpu_clock, master_clock, bus_clock, module_clock; 78 79 /* Cache info */ 80 struct cache_info icache; 81 struct cache_info dcache; 82 83 /* TLB info */ 84 struct tlb_info itlb; 85 struct tlb_info dtlb; 86}; 87 88extern struct sh_cpuinfo boot_cpu_data; 89 90#define cpu_data (&boot_cpu_data) 91#define current_cpu_data boot_cpu_data 92 93#endif 94 95/* 96 * User space process size: 2GB - 4k. 97 */ 98#define TASK_SIZE 0x7ffff000UL 99 100/* This decides where the kernel will search for a free chunk of vm 101 * space during mmap's. 102 */ 103#define TASK_UNMAPPED_BASE (TASK_SIZE / 3) 104 105/* 106 * Bit of SR register 107 * 108 * FD-bit: 109 * When it's set, it means the processor doesn't have right to use FPU, 110 * and it results exception when the floating operation is executed. 111 * 112 * IMASK-bit: 113 * Interrupt level mask 114 * 115 * STEP-bit: 116 * Single step bit 117 * 118 */ 119#define SR_FD 0x00008000 120 121#if defined(CONFIG_SH64_SR_WATCH) 122#define SR_MMU 0x84000000 123#else 124#define SR_MMU 0x80000000 125#endif 126 127#define SR_IMASK 0x000000f0 128#define SR_SSTEP 0x08000000 129 130#ifndef __ASSEMBLY__ 131 132/* 133 * FPU structure and data : require 8-byte alignment as we need to access it 134 with fld.p, fst.p 135 */ 136 137struct sh_fpu_hard_struct { 138 unsigned long fp_regs[64]; 139 unsigned int fpscr; 140 /* long status; * software status information */ 141}; 142 143 144union sh_fpu_union { 145 struct sh_fpu_hard_struct hard; 146 /* 'hard' itself only produces 32 bit alignment, yet we need 147 to access it using 64 bit load/store as well. */ 148 unsigned long long alignment_dummy; 149}; 150 151struct thread_struct { 152 unsigned long sp; 153 unsigned long pc; 154 /* This stores the address of the pt_regs built during a context 155 switch, or of the register save area built for a kernel mode 156 exception. It is used for backtracing the stack of a sleeping task 157 or one that traps in kernel mode. */ 158 struct pt_regs *kregs; 159 /* This stores the address of the pt_regs constructed on entry from 160 user mode. It is a fixed value over the lifetime of a process, or 161 NULL for a kernel thread. */ 162 struct pt_regs *uregs; 163 164 unsigned long trap_no, error_code; 165 unsigned long address; 166 /* Hardware debugging registers may come here */ 167 168 /* floating point info */ 169 union sh_fpu_union fpu; 170}; 171 172#define INIT_MMAP \ 173{ &init_mm, 0, 0, NULL, PAGE_SHARED, VM_READ | VM_WRITE | VM_EXEC, 1, NULL, NULL } 174 175extern struct pt_regs fake_swapper_regs; 176 177#define INIT_THREAD { \ 178 .sp = sizeof(init_stack) + \ 179 (long) &init_stack, \ 180 .pc = 0, \ 181 .kregs = &fake_swapper_regs, \ 182 .uregs = NULL, \ 183 .trap_no = 0, \ 184 .error_code = 0, \ 185 .address = 0, \ 186 .fpu = { { { 0, } }, } \ 187} 188 189/* 190 * Do necessary setup to start up a newly executed thread. 191 */ 192#define SR_USER (SR_MMU | SR_FD) 193 194#define start_thread(regs, new_pc, new_sp) \ 195 set_fs(USER_DS); \ 196 regs->sr = SR_USER; /* User mode. */ \ 197 regs->pc = new_pc - 4; /* Compensate syscall exit */ \ 198 regs->pc |= 1; /* Set SHmedia ! */ \ 199 regs->regs[18] = 0; \ 200 regs->regs[15] = new_sp 201 202/* Forward declaration, a strange C thing */ 203struct task_struct; 204struct mm_struct; 205 206/* Free all resources held by a thread. */ 207extern void release_thread(struct task_struct *); 208/* 209 * create a kernel thread without removing it from tasklists 210 */ 211extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags); 212 213 214/* Copy and release all segment info associated with a VM */ 215#define copy_segments(p, mm) do { } while (0) 216#define release_segments(mm) do { } while (0) 217#define forget_segments() do { } while (0) 218#define prepare_to_copy(tsk) do { } while (0) 219/* 220 * FPU lazy state save handling. 221 */ 222 223static inline void release_fpu(void) 224{ 225 unsigned long long __dummy; 226 227 /* Set FD flag in SR */ 228 __asm__ __volatile__("getcon " __SR ", %0\n\t" 229 "or %0, %1, %0\n\t" 230 "putcon %0, " __SR "\n\t" 231 : "=&r" (__dummy) 232 : "r" (SR_FD)); 233} 234 235static inline void grab_fpu(void) 236{ 237 unsigned long long __dummy; 238 239 /* Clear out FD flag in SR */ 240 __asm__ __volatile__("getcon " __SR ", %0\n\t" 241 "and %0, %1, %0\n\t" 242 "putcon %0, " __SR "\n\t" 243 : "=&r" (__dummy) 244 : "r" (~SR_FD)); 245} 246 247/* Round to nearest, no exceptions on inexact, overflow, underflow, 248 zero-divide, invalid. Configure option for whether to flush denorms to 249 zero, or except if a denorm is encountered. */ 250#if defined(CONFIG_SH64_FPU_DENORM_FLUSH) 251#define FPSCR_INIT 0x00040000 252#else 253#define FPSCR_INIT 0x00000000 254#endif 255 256/* Save the current FP regs */ 257void fpsave(struct sh_fpu_hard_struct *fpregs); 258 259/* Initialise the FP state of a task */ 260void fpinit(struct sh_fpu_hard_struct *fpregs); 261 262extern struct task_struct *last_task_used_math; 263 264/* 265 * Return saved PC of a blocked thread. 266 */ 267#define thread_saved_pc(tsk) (tsk->thread.pc) 268 269extern unsigned long get_wchan(struct task_struct *p); 270 271#define KSTK_EIP(tsk) ((tsk)->thread.pc) 272#define KSTK_ESP(tsk) ((tsk)->thread.sp) 273 274#define cpu_relax() barrier() 275 276#endif /* __ASSEMBLY__ */ 277#endif /* __ASM_SH64_PROCESSOR_H */ 278