1/* 2 * linux/arch/cris/kernel/process.c 3 * 4 * Copyright (C) 1995 Linus Torvalds 5 * Copyright (C) 2000-2002 Axis Communications AB 6 * 7 * Authors: Bjorn Wesen (bjornw@axis.com) 8 * Mikael Starvik (starvik@axis.com) 9 * 10 * This file handles the architecture-dependent parts of process handling.. 11 */ 12 13#include <linux/sched.h> 14#include <linux/slab.h> 15#include <linux/err.h> 16#include <linux/fs.h> 17#include <arch/svinto.h> 18#include <linux/init.h> 19 20#ifdef CONFIG_ETRAX_GPIO 21void etrax_gpio_wake_up_check(void); /* drivers/gpio.c */ 22#endif 23 24/* 25 * We use this if we don't have any better 26 * idle routine.. 27 */ 28void default_idle(void) 29{ 30#ifdef CONFIG_ETRAX_GPIO 31 etrax_gpio_wake_up_check(); 32#endif 33} 34 35/* 36 * Free current thread data structures etc.. 37 */ 38 39void exit_thread(void) 40{ 41 /* Nothing needs to be done. */ 42} 43 44/* if the watchdog is enabled, we can simply disable interrupts and go 45 * into an eternal loop, and the watchdog will reset the CPU after 0.1s 46 * if on the other hand the watchdog wasn't enabled, we just enable it and wait 47 */ 48 49void hard_reset_now (void) 50{ 51 /* 52 * Don't declare this variable elsewhere. We don't want any other 53 * code to know about it than the watchdog handler in entry.S and 54 * this code, implementing hard reset through the watchdog. 55 */ 56#if defined(CONFIG_ETRAX_WATCHDOG) && !defined(CONFIG_SVINTO_SIM) 57 extern int cause_of_death; 58#endif 59 60 printk("*** HARD RESET ***\n"); 61 local_irq_disable(); 62 63#if defined(CONFIG_ETRAX_WATCHDOG) && !defined(CONFIG_SVINTO_SIM) 64 cause_of_death = 0xbedead; 65#else 66 /* Since we dont plan to keep on resetting the watchdog, 67 the key can be arbitrary hence three */ 68 *R_WATCHDOG = IO_FIELD(R_WATCHDOG, key, 3) | 69 IO_STATE(R_WATCHDOG, enable, start); 70#endif 71 72 while(1) /* waiting for RETRIBUTION! */ ; 73} 74 75/* 76 * Return saved PC of a blocked thread. 77 */ 78unsigned long thread_saved_pc(struct task_struct *t) 79{ 80 return task_pt_regs(t)->irp; 81} 82 83static void kernel_thread_helper(void* dummy, int (*fn)(void *), void * arg) 84{ 85 fn(arg); 86 do_exit(-1); /* Should never be called, return bad exit value */ 87} 88 89/* 90 * Create a kernel thread 91 */ 92int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) 93{ 94 struct pt_regs regs; 95 96 memset(®s, 0, sizeof(regs)); 97 98 /* Don't use r10 since that is set to 0 in copy_thread */ 99 regs.r11 = (unsigned long)fn; 100 regs.r12 = (unsigned long)arg; 101 regs.irp = (unsigned long)kernel_thread_helper; 102 regs.dccr = 1 << I_DCCR_BITNR; 103 104 /* Ok, create the new process.. */ 105 return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, ®s, 0, NULL, NULL); 106} 107 108/* setup the child's kernel stack with a pt_regs and switch_stack on it. 109 * it will be un-nested during _resume and _ret_from_sys_call when the 110 * new thread is scheduled. 111 * 112 * also setup the thread switching structure which is used to keep 113 * thread-specific data during _resumes. 114 * 115 */ 116asmlinkage void ret_from_fork(void); 117 118int copy_thread(unsigned long clone_flags, unsigned long usp, 119 unsigned long unused, 120 struct task_struct *p, struct pt_regs *regs) 121{ 122 struct pt_regs * childregs; 123 struct switch_stack *swstack; 124 125 /* put the pt_regs structure at the end of the new kernel stack page and fix it up 126 * remember that the task_struct doubles as the kernel stack for the task 127 */ 128 129 childregs = task_pt_regs(p); 130 131 *childregs = *regs; /* struct copy of pt_regs */ 132 133 p->set_child_tid = p->clear_child_tid = NULL; 134 135 childregs->r10 = 0; /* child returns 0 after a fork/clone */ 136 137 /* put the switch stack right below the pt_regs */ 138 139 swstack = ((struct switch_stack *)childregs) - 1; 140 141 swstack->r9 = 0; /* parameter to ret_from_sys_call, 0 == dont restart the syscall */ 142 143 /* we want to return into ret_from_sys_call after the _resume */ 144 145 swstack->return_ip = (unsigned long) ret_from_fork; /* Will call ret_from_sys_call */ 146 147 /* fix the user-mode stackpointer */ 148 149 p->thread.usp = usp; 150 151 /* and the kernel-mode one */ 152 153 p->thread.ksp = (unsigned long) swstack; 154 155#ifdef DEBUG 156 printk("copy_thread: new regs at 0x%p, as shown below:\n", childregs); 157 show_registers(childregs); 158#endif 159 160 return 0; 161} 162 163/* 164 * Be aware of the "magic" 7th argument in the four system-calls below. 165 * They need the latest stackframe, which is put as the 7th argument by 166 * entry.S. The previous arguments are dummies or actually used, but need 167 * to be defined to reach the 7th argument. 168 * 169 * N.B.: Another method to get the stackframe is to use current_regs(). But 170 * it returns the latest stack-frame stacked when going from _user mode_ and 171 * some of these (at least sys_clone) are called from kernel-mode sometimes 172 * (for example during kernel_thread, above) and thus cannot use it. Thus, 173 * to be sure not to get any surprises, we use the method for the other calls 174 * as well. 175 */ 176 177asmlinkage int sys_fork(long r10, long r11, long r12, long r13, long mof, long srp, 178 struct pt_regs *regs) 179{ 180 return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL); 181} 182 183/* if newusp is 0, we just grab the old usp */ 184asmlinkage int sys_clone(unsigned long newusp, unsigned long flags, 185 int* parent_tid, int* child_tid, long mof, long srp, 186 struct pt_regs *regs) 187{ 188 if (!newusp) 189 newusp = rdusp(); 190 return do_fork(flags, newusp, regs, 0, parent_tid, child_tid); 191} 192 193/* vfork is a system call in i386 because of register-pressure - maybe 194 * we can remove it and handle it in libc but we put it here until then. 195 */ 196 197asmlinkage int sys_vfork(long r10, long r11, long r12, long r13, long mof, long srp, 198 struct pt_regs *regs) 199{ 200 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL); 201} 202 203/* 204 * sys_execve() executes a new program. 205 */ 206asmlinkage int sys_execve(const char *fname, 207 const char *const *argv, 208 const char *const *envp, 209 long r13, long mof, long srp, 210 struct pt_regs *regs) 211{ 212 int error; 213 char *filename; 214 215 filename = getname(fname); 216 error = PTR_ERR(filename); 217 218 if (IS_ERR(filename)) 219 goto out; 220 error = do_execve(filename, argv, envp, regs); 221 putname(filename); 222 out: 223 return error; 224} 225 226unsigned long get_wchan(struct task_struct *p) 227{ 228 return 0; 229} 230#undef last_sched 231#undef first_sched 232 233void show_regs(struct pt_regs * regs) 234{ 235 unsigned long usp = rdusp(); 236 printk("IRP: %08lx SRP: %08lx DCCR: %08lx USP: %08lx MOF: %08lx\n", 237 regs->irp, regs->srp, regs->dccr, usp, regs->mof ); 238 printk(" r0: %08lx r1: %08lx r2: %08lx r3: %08lx\n", 239 regs->r0, regs->r1, regs->r2, regs->r3); 240 printk(" r4: %08lx r5: %08lx r6: %08lx r7: %08lx\n", 241 regs->r4, regs->r5, regs->r6, regs->r7); 242 printk(" r8: %08lx r9: %08lx r10: %08lx r11: %08lx\n", 243 regs->r8, regs->r9, regs->r10, regs->r11); 244 printk("r12: %08lx r13: %08lx oR10: %08lx\n", 245 regs->r12, regs->r13, regs->orig_r10); 246} 247