xref: /openbmc/linux/arch/sh/kernel/process_32.c (revision e23feb16)
1 /*
2  * arch/sh/kernel/process.c
3  *
4  * This file handles the architecture-dependent parts of process handling..
5  *
6  *  Copyright (C) 1995  Linus Torvalds
7  *
8  *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
9  *		     Copyright (C) 2006 Lineo Solutions Inc. support SH4A UBC
10  *		     Copyright (C) 2002 - 2008  Paul Mundt
11  *
12  * This file is subject to the terms and conditions of the GNU General Public
13  * License.  See the file "COPYING" in the main directory of this archive
14  * for more details.
15  */
16 #include <linux/module.h>
17 #include <linux/mm.h>
18 #include <linux/slab.h>
19 #include <linux/elfcore.h>
20 #include <linux/kallsyms.h>
21 #include <linux/fs.h>
22 #include <linux/ftrace.h>
23 #include <linux/hw_breakpoint.h>
24 #include <linux/prefetch.h>
25 #include <linux/stackprotector.h>
26 #include <asm/uaccess.h>
27 #include <asm/mmu_context.h>
28 #include <asm/fpu.h>
29 #include <asm/syscalls.h>
30 #include <asm/switch_to.h>
31 
32 void show_regs(struct pt_regs * regs)
33 {
34 	printk("\n");
35 	show_regs_print_info(KERN_DEFAULT);
36 
37 	print_symbol("PC is at %s\n", instruction_pointer(regs));
38 	print_symbol("PR is at %s\n", regs->pr);
39 
40 	printk("PC  : %08lx SP  : %08lx SR  : %08lx ",
41 	       regs->pc, regs->regs[15], regs->sr);
42 #ifdef CONFIG_MMU
43 	printk("TEA : %08x\n", __raw_readl(MMU_TEA));
44 #else
45 	printk("\n");
46 #endif
47 
48 	printk("R0  : %08lx R1  : %08lx R2  : %08lx R3  : %08lx\n",
49 	       regs->regs[0],regs->regs[1],
50 	       regs->regs[2],regs->regs[3]);
51 	printk("R4  : %08lx R5  : %08lx R6  : %08lx R7  : %08lx\n",
52 	       regs->regs[4],regs->regs[5],
53 	       regs->regs[6],regs->regs[7]);
54 	printk("R8  : %08lx R9  : %08lx R10 : %08lx R11 : %08lx\n",
55 	       regs->regs[8],regs->regs[9],
56 	       regs->regs[10],regs->regs[11]);
57 	printk("R12 : %08lx R13 : %08lx R14 : %08lx\n",
58 	       regs->regs[12],regs->regs[13],
59 	       regs->regs[14]);
60 	printk("MACH: %08lx MACL: %08lx GBR : %08lx PR  : %08lx\n",
61 	       regs->mach, regs->macl, regs->gbr, regs->pr);
62 
63 	show_trace(NULL, (unsigned long *)regs->regs[15], regs);
64 	show_code(regs);
65 }
66 
67 void start_thread(struct pt_regs *regs, unsigned long new_pc,
68 		  unsigned long new_sp)
69 {
70 	regs->pr = 0;
71 	regs->sr = SR_FD;
72 	regs->pc = new_pc;
73 	regs->regs[15] = new_sp;
74 
75 	free_thread_xstate(current);
76 }
77 EXPORT_SYMBOL(start_thread);
78 
79 /*
80  * Free current thread data structures etc..
81  */
82 void exit_thread(void)
83 {
84 }
85 
86 void flush_thread(void)
87 {
88 	struct task_struct *tsk = current;
89 
90 	flush_ptrace_hw_breakpoint(tsk);
91 
92 #if defined(CONFIG_SH_FPU)
93 	/* Forget lazy FPU state */
94 	clear_fpu(tsk, task_pt_regs(tsk));
95 	clear_used_math();
96 #endif
97 }
98 
99 void release_thread(struct task_struct *dead_task)
100 {
101 	/* do nothing */
102 }
103 
104 /* Fill in the fpu structure for a core dump.. */
105 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
106 {
107 	int fpvalid = 0;
108 
109 #if defined(CONFIG_SH_FPU)
110 	struct task_struct *tsk = current;
111 
112 	fpvalid = !!tsk_used_math(tsk);
113 	if (fpvalid)
114 		fpvalid = !fpregs_get(tsk, NULL, 0,
115 				      sizeof(struct user_fpu_struct),
116 				      fpu, NULL);
117 #endif
118 
119 	return fpvalid;
120 }
121 EXPORT_SYMBOL(dump_fpu);
122 
123 asmlinkage void ret_from_fork(void);
124 asmlinkage void ret_from_kernel_thread(void);
125 
126 int copy_thread(unsigned long clone_flags, unsigned long usp,
127 		unsigned long arg, struct task_struct *p)
128 {
129 	struct thread_info *ti = task_thread_info(p);
130 	struct pt_regs *childregs;
131 
132 #if defined(CONFIG_SH_DSP)
133 	struct task_struct *tsk = current;
134 
135 	if (is_dsp_enabled(tsk)) {
136 		/* We can use the __save_dsp or just copy the struct:
137 		 * __save_dsp(p);
138 		 * p->thread.dsp_status.status |= SR_DSP
139 		 */
140 		p->thread.dsp_status = tsk->thread.dsp_status;
141 	}
142 #endif
143 
144 	memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
145 
146 	childregs = task_pt_regs(p);
147 	p->thread.sp = (unsigned long) childregs;
148 	if (unlikely(p->flags & PF_KTHREAD)) {
149 		memset(childregs, 0, sizeof(struct pt_regs));
150 		p->thread.pc = (unsigned long) ret_from_kernel_thread;
151 		childregs->regs[4] = arg;
152 		childregs->regs[5] = usp;
153 		childregs->sr = SR_MD;
154 #if defined(CONFIG_SH_FPU)
155 		childregs->sr |= SR_FD;
156 #endif
157 		ti->addr_limit = KERNEL_DS;
158 		ti->status &= ~TS_USEDFPU;
159 		p->fpu_counter = 0;
160 		return 0;
161 	}
162 	*childregs = *current_pt_regs();
163 
164 	if (usp)
165 		childregs->regs[15] = usp;
166 	ti->addr_limit = USER_DS;
167 
168 	if (clone_flags & CLONE_SETTLS)
169 		childregs->gbr = childregs->regs[0];
170 
171 	childregs->regs[0] = 0; /* Set return value for child */
172 	p->thread.pc = (unsigned long) ret_from_fork;
173 	return 0;
174 }
175 
176 /*
177  *	switch_to(x,y) should switch tasks from x to y.
178  *
179  */
180 __notrace_funcgraph struct task_struct *
181 __switch_to(struct task_struct *prev, struct task_struct *next)
182 {
183 	struct thread_struct *next_t = &next->thread;
184 
185 #if defined(CONFIG_CC_STACKPROTECTOR) && !defined(CONFIG_SMP)
186 	__stack_chk_guard = next->stack_canary;
187 #endif
188 
189 	unlazy_fpu(prev, task_pt_regs(prev));
190 
191 	/* we're going to use this soon, after a few expensive things */
192 	if (next->fpu_counter > 5)
193 		prefetch(next_t->xstate);
194 
195 #ifdef CONFIG_MMU
196 	/*
197 	 * Restore the kernel mode register
198 	 *	k7 (r7_bank1)
199 	 */
200 	asm volatile("ldc	%0, r7_bank"
201 		     : /* no output */
202 		     : "r" (task_thread_info(next)));
203 #endif
204 
205 	/*
206 	 * If the task has used fpu the last 5 timeslices, just do a full
207 	 * restore of the math state immediately to avoid the trap; the
208 	 * chances of needing FPU soon are obviously high now
209 	 */
210 	if (next->fpu_counter > 5)
211 		__fpu_state_restore();
212 
213 	return prev;
214 }
215 
216 unsigned long get_wchan(struct task_struct *p)
217 {
218 	unsigned long pc;
219 
220 	if (!p || p == current || p->state == TASK_RUNNING)
221 		return 0;
222 
223 	/*
224 	 * The same comment as on the Alpha applies here, too ...
225 	 */
226 	pc = thread_saved_pc(p);
227 
228 #ifdef CONFIG_FRAME_POINTER
229 	if (in_sched_functions(pc)) {
230 		unsigned long schedule_frame = (unsigned long)p->thread.sp;
231 		return ((unsigned long *)schedule_frame)[21];
232 	}
233 #endif
234 
235 	return pc;
236 }
237