arch/c6x/kernel/process.c

   1 /*
   2  *  Port on Texas Instruments TMS320C6x architecture
   3  *
   4  *  Copyright (C) 2004, 2006, 2009, 2010, 2011 Texas Instruments Incorporated
   5  *  Author: Aurelien Jacquiot (aurelien.jacquiot@jaluna.com)
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  */
  12 #include <linux/module.h>
  13 #include <linux/unistd.h>
  14 #include <linux/ptrace.h>
  15 #include <linux/init_task.h>
  16 #include <linux/tick.h>
  17 #include <linux/mqueue.h>
  18 #include <linux/syscalls.h>
  19 #include <linux/reboot.h>
  20
  21 #include <asm/syscalls.h>
  22
  23 /* hooks for board specific support */
  24 void    (*c6x_restart)(void);
  25 void    (*c6x_halt)(void);
  26
  27 extern asmlinkage void ret_from_fork(void);
  28
  29 static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
  30 static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
  31
  32 /*
  33  * Initial thread structure.
  34  */
  35 union thread_union init_thread_union __init_task_data = {
  36         INIT_THREAD_INFO(init_task)
  37 };
  38
  39 /*
  40  * Initial task structure.
  41  */
  42 struct task_struct init_task = INIT_TASK(init_task);
  43 EXPORT_SYMBOL(init_task);
  44
  45 /*
  46  * power off function, if any
  47  */
  48 void (*pm_power_off)(void);
  49 EXPORT_SYMBOL(pm_power_off);
  50
  51 static void c6x_idle(void)
  52 {
  53         unsigned long tmp;
  54
  55         /*
  56          * Put local_irq_enable and idle in same execute packet
  57          * to make them atomic and avoid race to idle with
  58          * interrupts enabled.
  59          */
  60         asm volatile ("   mvc .s2 CSR,%0\n"
  61                       "   or  .d2 1,%0,%0\n"
  62                       "   mvc .s2 %0,CSR\n"
  63                       "|| idle\n"
  64                       : "=b"(tmp));
  65 }
  66
  67 /*
  68  * The idle loop for C64x
  69  */
  70 void cpu_idle(void)
  71 {
  72         /* endless idle loop with no priority at all */
  73         while (1) {
  74                 tick_nohz_idle_enter();
  75                 rcu_idle_enter();
  76                 while (1) {
  77                         local_irq_disable();
  78                         if (need_resched()) {
  79                                 local_irq_enable();
  80                                 break;
  81                         }
  82                         c6x_idle(); /* enables local irqs */
  83                 }
  84                 rcu_idle_exit();
  85                 tick_nohz_idle_exit();
  86
  87                 preempt_enable_no_resched();
  88                 schedule();
  89                 preempt_disable();
  90         }
  91 }
  92
  93 static void halt_loop(void)
  94 {
  95         printk(KERN_EMERG "System Halted, OK to turn off power\n");
  96         local_irq_disable();
  97         while (1)
  98                 asm volatile("idle\n");
  99 }
 100
 101 void machine_restart(char *__unused)
 102 {
 103         if (c6x_restart)
 104                 c6x_restart();
 105         halt_loop();
 106 }
 107
 108 void machine_halt(void)
 109 {
 110         if (c6x_halt)
 111                 c6x_halt();
 112         halt_loop();
 113 }
 114
 115 void machine_power_off(void)
 116 {
 117         if (pm_power_off)
 118                 pm_power_off();
 119         halt_loop();
 120 }
 121
 122 static void kernel_thread_helper(int dummy, void *arg, int (*fn)(void *))
 123 {
 124         do_exit(fn(arg));
 125 }
 126
 127 /*
 128  * Create a kernel thread
 129  */
 130 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 131 {
 132         struct pt_regs regs;
 133
 134         /*
 135          * copy_thread sets a4 to zero (child return from fork)
 136          * so we can't just set things up to directly return to
 137          * fn.
 138          */
 139         memset(&regs, 0, sizeof(regs));
 140         regs.b4 = (unsigned long) arg;
 141         regs.a6 = (unsigned long) fn;
 142         regs.pc = (unsigned long) kernel_thread_helper;
 143         local_save_flags(regs.csr);
 144         regs.csr |= 1;
 145         regs.tsr = 5; /* Set GEE and GIE in TSR */
 146
 147         /* Ok, create the new process.. */
 148         return do_fork(flags | CLONE_VM | CLONE_UNTRACED, -1, &regs,
 149                        0, NULL, NULL);
 150 }
 151 EXPORT_SYMBOL(kernel_thread);
 152
 153 void flush_thread(void)
 154 {
 155 }
 156
 157 void exit_thread(void)
 158 {
 159 }
 160
 161 SYSCALL_DEFINE1(c6x_clone, struct pt_regs *, regs)
 162 {
 163         unsigned long clone_flags;
 164         unsigned long newsp;
 165
 166         /* syscall puts clone_flags in A4 and usp in B4 */
 167         clone_flags = regs->orig_a4;
 168         if (regs->b4)
 169                 newsp = regs->b4;
 170         else
 171                 newsp = regs->sp;
 172
 173         return do_fork(clone_flags, newsp, regs, 0, (int __user *)regs->a6,
 174                        (int __user *)regs->b6);
 175 }
 176
 177 /*
 178  * Do necessary setup to start up a newly executed thread.
 179  */
 180 void start_thread(struct pt_regs *regs, unsigned int pc, unsigned long usp)
 181 {
 182         /*
 183          * The binfmt loader will setup a "full" stack, but the C6X
 184          * operates an "empty" stack. So we adjust the usp so that
 185          * argc doesn't get destroyed if an interrupt is taken before
 186          * it is read from the stack.
 187          *
 188          * NB: Library startup code needs to match this.
 189          */
 190         usp -= 8;
 191
 192         set_fs(USER_DS);
 193         regs->pc  = pc;
 194         regs->sp  = usp;
 195         regs->tsr |= 0x40; /* set user mode */
 196         current->thread.usp = usp;
 197 }
 198
 199 /*
 200  * Copy a new thread context in its stack.
 201  */
 202 int copy_thread(unsigned long clone_flags, unsigned long usp,
 203                 unsigned long ustk_size,
 204                 struct task_struct *p, struct pt_regs *regs)
 205 {
 206         struct pt_regs *childregs;
 207
 208         childregs = task_pt_regs(p);
 209
 210         *childregs = *regs;
 211         childregs->a4 = 0;
 212
 213         if (usp == -1)
 214                 /* case of  __kernel_thread: we return to supervisor space */
 215                 childregs->sp = (unsigned long)(childregs + 1);
 216         else
 217                 /* Otherwise use the given stack */
 218                 childregs->sp = usp;
 219
 220         /* Set usp/ksp */
 221         p->thread.usp = childregs->sp;
 222         /* switch_to uses stack to save/restore 14 callee-saved regs */
 223         thread_saved_ksp(p) = (unsigned long)childregs - 8;
 224         p->thread.pc = (unsigned int) ret_from_fork;
 225         p->thread.wchan = (unsigned long) ret_from_fork;
 226 #ifdef __DSBT__
 227         {
 228                 unsigned long dp;
 229
 230                 asm volatile ("mv .S2 b14,%0\n" : "=b"(dp));
 231
 232                 thread_saved_dp(p) = dp;
 233                 if (usp == -1)
 234                         childregs->dp = dp;
 235         }
 236 #endif
 237         return 0;
 238 }
 239
 240 /*
 241  * c6x_execve() executes a new program.
 242  */
 243 SYSCALL_DEFINE4(c6x_execve, const char __user *, name,
 244                 const char __user *const __user *, argv,
 245                 const char __user *const __user *, envp,
 246                 struct pt_regs *, regs)
 247 {
 248         int error;
 249         char *filename;
 250
 251         filename = getname(name);
 252         error = PTR_ERR(filename);
 253         if (IS_ERR(filename))
 254                 goto out;
 255
 256         error = do_execve(filename, argv, envp, regs);
 257         putname(filename);
 258 out:
 259         return error;
 260 }
 261
 262 unsigned long get_wchan(struct task_struct *p)
 263 {
 264         return p->thread.wchan;
 265 }