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/elfcore.h> 19 #include <linux/pm.h> 20 #include <linux/kallsyms.h> 21 #include <linux/kexec.h> 22 #include <linux/kdebug.h> 23 #include <linux/tick.h> 24 #include <linux/reboot.h> 25 #include <linux/fs.h> 26 #include <linux/preempt.h> 27 #include <asm/uaccess.h> 28 #include <asm/mmu_context.h> 29 #include <asm/pgalloc.h> 30 #include <asm/system.h> 31 #include <asm/ubc.h> 32 #include <asm/fpu.h> 33 #include <asm/syscalls.h> 34 35 static int hlt_counter; 36 int ubc_usercnt = 0; 37 38 void (*pm_idle)(void); 39 void (*pm_power_off)(void); 40 EXPORT_SYMBOL(pm_power_off); 41 42 static int __init nohlt_setup(char *__unused) 43 { 44 hlt_counter = 1; 45 return 1; 46 } 47 __setup("nohlt", nohlt_setup); 48 49 static int __init hlt_setup(char *__unused) 50 { 51 hlt_counter = 0; 52 return 1; 53 } 54 __setup("hlt", hlt_setup); 55 56 static void default_idle(void) 57 { 58 if (!hlt_counter) { 59 clear_thread_flag(TIF_POLLING_NRFLAG); 60 smp_mb__after_clear_bit(); 61 set_bl_bit(); 62 while (!need_resched()) 63 cpu_sleep(); 64 clear_bl_bit(); 65 set_thread_flag(TIF_POLLING_NRFLAG); 66 } else 67 while (!need_resched()) 68 cpu_relax(); 69 } 70 71 void cpu_idle(void) 72 { 73 set_thread_flag(TIF_POLLING_NRFLAG); 74 75 /* endless idle loop with no priority at all */ 76 while (1) { 77 void (*idle)(void) = pm_idle; 78 79 if (!idle) 80 idle = default_idle; 81 82 tick_nohz_stop_sched_tick(1); 83 while (!need_resched()) 84 idle(); 85 tick_nohz_restart_sched_tick(); 86 87 preempt_enable_no_resched(); 88 schedule(); 89 preempt_disable(); 90 check_pgt_cache(); 91 } 92 } 93 94 void machine_restart(char * __unused) 95 { 96 /* SR.BL=1 and invoke address error to let CPU reset (manual reset) */ 97 asm volatile("ldc %0, sr\n\t" 98 "mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001)); 99 } 100 101 void machine_halt(void) 102 { 103 local_irq_disable(); 104 105 while (1) 106 cpu_sleep(); 107 } 108 109 void machine_power_off(void) 110 { 111 if (pm_power_off) 112 pm_power_off(); 113 } 114 115 void show_regs(struct pt_regs * regs) 116 { 117 printk("\n"); 118 printk("Pid : %d, Comm: %20s\n", task_pid_nr(current), current->comm); 119 printk("CPU : %d %s (%s %.*s)\n", 120 smp_processor_id(), print_tainted(), init_utsname()->release, 121 (int)strcspn(init_utsname()->version, " "), 122 init_utsname()->version); 123 124 print_symbol("PC is at %s\n", instruction_pointer(regs)); 125 print_symbol("PR is at %s\n", regs->pr); 126 127 printk("PC : %08lx SP : %08lx SR : %08lx ", 128 regs->pc, regs->regs[15], regs->sr); 129 #ifdef CONFIG_MMU 130 printk("TEA : %08x\n", ctrl_inl(MMU_TEA)); 131 #else 132 printk("\n"); 133 #endif 134 135 printk("R0 : %08lx R1 : %08lx R2 : %08lx R3 : %08lx\n", 136 regs->regs[0],regs->regs[1], 137 regs->regs[2],regs->regs[3]); 138 printk("R4 : %08lx R5 : %08lx R6 : %08lx R7 : %08lx\n", 139 regs->regs[4],regs->regs[5], 140 regs->regs[6],regs->regs[7]); 141 printk("R8 : %08lx R9 : %08lx R10 : %08lx R11 : %08lx\n", 142 regs->regs[8],regs->regs[9], 143 regs->regs[10],regs->regs[11]); 144 printk("R12 : %08lx R13 : %08lx R14 : %08lx\n", 145 regs->regs[12],regs->regs[13], 146 regs->regs[14]); 147 printk("MACH: %08lx MACL: %08lx GBR : %08lx PR : %08lx\n", 148 regs->mach, regs->macl, regs->gbr, regs->pr); 149 150 show_trace(NULL, (unsigned long *)regs->regs[15], regs); 151 } 152 153 /* 154 * Create a kernel thread 155 */ 156 157 /* 158 * This is the mechanism for creating a new kernel thread. 159 * 160 */ 161 extern void kernel_thread_helper(void); 162 __asm__(".align 5\n" 163 "kernel_thread_helper:\n\t" 164 "jsr @r5\n\t" 165 " nop\n\t" 166 "mov.l 1f, r1\n\t" 167 "jsr @r1\n\t" 168 " mov r0, r4\n\t" 169 ".align 2\n\t" 170 "1:.long do_exit"); 171 172 /* Don't use this in BL=1(cli). Or else, CPU resets! */ 173 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) 174 { 175 struct pt_regs regs; 176 int pid; 177 178 memset(®s, 0, sizeof(regs)); 179 regs.regs[4] = (unsigned long)arg; 180 regs.regs[5] = (unsigned long)fn; 181 182 regs.pc = (unsigned long)kernel_thread_helper; 183 regs.sr = (1 << 30); 184 185 /* Ok, create the new process.. */ 186 pid = do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, 187 ®s, 0, NULL, NULL); 188 189 trace_mark(kernel_arch_kthread_create, "pid %d fn %p", pid, fn); 190 191 return pid; 192 } 193 194 /* 195 * Free current thread data structures etc.. 196 */ 197 void exit_thread(void) 198 { 199 if (current->thread.ubc_pc) { 200 current->thread.ubc_pc = 0; 201 ubc_usercnt -= 1; 202 } 203 } 204 205 void flush_thread(void) 206 { 207 #if defined(CONFIG_SH_FPU) 208 struct task_struct *tsk = current; 209 /* Forget lazy FPU state */ 210 clear_fpu(tsk, task_pt_regs(tsk)); 211 clear_used_math(); 212 #endif 213 } 214 215 void release_thread(struct task_struct *dead_task) 216 { 217 /* do nothing */ 218 } 219 220 /* Fill in the fpu structure for a core dump.. */ 221 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu) 222 { 223 int fpvalid = 0; 224 225 #if defined(CONFIG_SH_FPU) 226 struct task_struct *tsk = current; 227 228 fpvalid = !!tsk_used_math(tsk); 229 if (fpvalid) 230 fpvalid = !fpregs_get(tsk, NULL, 0, 231 sizeof(struct user_fpu_struct), 232 fpu, NULL); 233 #endif 234 235 return fpvalid; 236 } 237 238 asmlinkage void ret_from_fork(void); 239 240 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp, 241 unsigned long unused, 242 struct task_struct *p, struct pt_regs *regs) 243 { 244 struct thread_info *ti = task_thread_info(p); 245 struct pt_regs *childregs; 246 #if defined(CONFIG_SH_FPU) 247 struct task_struct *tsk = current; 248 249 unlazy_fpu(tsk, regs); 250 p->thread.fpu = tsk->thread.fpu; 251 copy_to_stopped_child_used_math(p); 252 #endif 253 254 childregs = task_pt_regs(p); 255 *childregs = *regs; 256 257 if (user_mode(regs)) { 258 childregs->regs[15] = usp; 259 ti->addr_limit = USER_DS; 260 } else { 261 childregs->regs[15] = (unsigned long)childregs; 262 ti->addr_limit = KERNEL_DS; 263 } 264 265 if (clone_flags & CLONE_SETTLS) 266 childregs->gbr = childregs->regs[0]; 267 268 childregs->regs[0] = 0; /* Set return value for child */ 269 270 p->thread.sp = (unsigned long) childregs; 271 p->thread.pc = (unsigned long) ret_from_fork; 272 273 p->thread.ubc_pc = 0; 274 275 return 0; 276 } 277 278 /* Tracing by user break controller. */ 279 static void ubc_set_tracing(int asid, unsigned long pc) 280 { 281 #if defined(CONFIG_CPU_SH4A) 282 unsigned long val; 283 284 val = (UBC_CBR_ID_INST | UBC_CBR_RW_READ | UBC_CBR_CE); 285 val |= (UBC_CBR_AIE | UBC_CBR_AIV_SET(asid)); 286 287 ctrl_outl(val, UBC_CBR0); 288 ctrl_outl(pc, UBC_CAR0); 289 ctrl_outl(0x0, UBC_CAMR0); 290 ctrl_outl(0x0, UBC_CBCR); 291 292 val = (UBC_CRR_RES | UBC_CRR_PCB | UBC_CRR_BIE); 293 ctrl_outl(val, UBC_CRR0); 294 295 /* Read UBC register that we wrote last, for checking update */ 296 val = ctrl_inl(UBC_CRR0); 297 298 #else /* CONFIG_CPU_SH4A */ 299 ctrl_outl(pc, UBC_BARA); 300 301 #ifdef CONFIG_MMU 302 ctrl_outb(asid, UBC_BASRA); 303 #endif 304 305 ctrl_outl(0, UBC_BAMRA); 306 307 if (current_cpu_data.type == CPU_SH7729 || 308 current_cpu_data.type == CPU_SH7710 || 309 current_cpu_data.type == CPU_SH7712) { 310 ctrl_outw(BBR_INST | BBR_READ | BBR_CPU, UBC_BBRA); 311 ctrl_outl(BRCR_PCBA | BRCR_PCTE, UBC_BRCR); 312 } else { 313 ctrl_outw(BBR_INST | BBR_READ, UBC_BBRA); 314 ctrl_outw(BRCR_PCBA, UBC_BRCR); 315 } 316 #endif /* CONFIG_CPU_SH4A */ 317 } 318 319 /* 320 * switch_to(x,y) should switch tasks from x to y. 321 * 322 */ 323 struct task_struct *__switch_to(struct task_struct *prev, 324 struct task_struct *next) 325 { 326 #if defined(CONFIG_SH_FPU) 327 unlazy_fpu(prev, task_pt_regs(prev)); 328 #endif 329 330 #ifdef CONFIG_MMU 331 /* 332 * Restore the kernel mode register 333 * k7 (r7_bank1) 334 */ 335 asm volatile("ldc %0, r7_bank" 336 : /* no output */ 337 : "r" (task_thread_info(next))); 338 #endif 339 340 /* If no tasks are using the UBC, we're done */ 341 if (ubc_usercnt == 0) 342 /* If no tasks are using the UBC, we're done */; 343 else if (next->thread.ubc_pc && next->mm) { 344 int asid = 0; 345 #ifdef CONFIG_MMU 346 asid |= cpu_asid(smp_processor_id(), next->mm); 347 #endif 348 ubc_set_tracing(asid, next->thread.ubc_pc); 349 } else { 350 #if defined(CONFIG_CPU_SH4A) 351 ctrl_outl(UBC_CBR_INIT, UBC_CBR0); 352 ctrl_outl(UBC_CRR_INIT, UBC_CRR0); 353 #else 354 ctrl_outw(0, UBC_BBRA); 355 ctrl_outw(0, UBC_BBRB); 356 #endif 357 } 358 359 return prev; 360 } 361 362 asmlinkage int sys_fork(unsigned long r4, unsigned long r5, 363 unsigned long r6, unsigned long r7, 364 struct pt_regs __regs) 365 { 366 #ifdef CONFIG_MMU 367 struct pt_regs *regs = RELOC_HIDE(&__regs, 0); 368 return do_fork(SIGCHLD, regs->regs[15], regs, 0, NULL, NULL); 369 #else 370 /* fork almost works, enough to trick you into looking elsewhere :-( */ 371 return -EINVAL; 372 #endif 373 } 374 375 asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp, 376 unsigned long parent_tidptr, 377 unsigned long child_tidptr, 378 struct pt_regs __regs) 379 { 380 struct pt_regs *regs = RELOC_HIDE(&__regs, 0); 381 if (!newsp) 382 newsp = regs->regs[15]; 383 return do_fork(clone_flags, newsp, regs, 0, 384 (int __user *)parent_tidptr, 385 (int __user *)child_tidptr); 386 } 387 388 /* 389 * This is trivial, and on the face of it looks like it 390 * could equally well be done in user mode. 391 * 392 * Not so, for quite unobvious reasons - register pressure. 393 * In user mode vfork() cannot have a stack frame, and if 394 * done by calling the "clone()" system call directly, you 395 * do not have enough call-clobbered registers to hold all 396 * the information you need. 397 */ 398 asmlinkage int sys_vfork(unsigned long r4, unsigned long r5, 399 unsigned long r6, unsigned long r7, 400 struct pt_regs __regs) 401 { 402 struct pt_regs *regs = RELOC_HIDE(&__regs, 0); 403 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->regs[15], regs, 404 0, NULL, NULL); 405 } 406 407 /* 408 * sys_execve() executes a new program. 409 */ 410 asmlinkage int sys_execve(char __user *ufilename, char __user * __user *uargv, 411 char __user * __user *uenvp, unsigned long r7, 412 struct pt_regs __regs) 413 { 414 struct pt_regs *regs = RELOC_HIDE(&__regs, 0); 415 int error; 416 char *filename; 417 418 filename = getname(ufilename); 419 error = PTR_ERR(filename); 420 if (IS_ERR(filename)) 421 goto out; 422 423 error = do_execve(filename, uargv, uenvp, regs); 424 if (error == 0) { 425 task_lock(current); 426 current->ptrace &= ~PT_DTRACE; 427 task_unlock(current); 428 } 429 putname(filename); 430 out: 431 return error; 432 } 433 434 unsigned long get_wchan(struct task_struct *p) 435 { 436 unsigned long pc; 437 438 if (!p || p == current || p->state == TASK_RUNNING) 439 return 0; 440 441 /* 442 * The same comment as on the Alpha applies here, too ... 443 */ 444 pc = thread_saved_pc(p); 445 446 #ifdef CONFIG_FRAME_POINTER 447 if (in_sched_functions(pc)) { 448 unsigned long schedule_frame = (unsigned long)p->thread.sp; 449 return ((unsigned long *)schedule_frame)[21]; 450 } 451 #endif 452 453 return pc; 454 } 455 456 asmlinkage void break_point_trap(void) 457 { 458 /* Clear tracing. */ 459 #if defined(CONFIG_CPU_SH4A) 460 ctrl_outl(UBC_CBR_INIT, UBC_CBR0); 461 ctrl_outl(UBC_CRR_INIT, UBC_CRR0); 462 #else 463 ctrl_outw(0, UBC_BBRA); 464 ctrl_outw(0, UBC_BBRB); 465 #endif 466 current->thread.ubc_pc = 0; 467 ubc_usercnt -= 1; 468 469 force_sig(SIGTRAP, current); 470 } 471