Subversion Repositories or1k

/*

 *  linux/arch/or32/kernel/process.c

 *

 *  or32 version

 *    author(s): Matjaz Breskvar (phoenix@opencores.org)

 *

 *  derived from cris, i386, m68k, ppc, sh ports.

 *

 *  changes:

 *  18. 11. 2003: Matjaz Breskvar (phoenix@opencores.org)

 *    initial port to or32 architecture

 *

 * This file handles the architecture-dependent parts of process handling..

 * Based on m86k.

 */

#define __KERNEL_SYSCALLS__

#include <stdarg.h>

#include <linux/errno.h>

#include <linux/sched.h>

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/stddef.h>

#include <linux/unistd.h>

#include <linux/ptrace.h>

#include <linux/slab.h>

#include <linux/user.h>

#include <linux/a.out.h>

#include <linux/elfcore.h>

#include <linux/interrupt.h>

#include <linux/delay.h>

#include <asm/uaccess.h>

#include <asm/pgtable.h>

#include <asm/system.h>

#include <asm/io.h>

#include <asm/processor.h>

#include <asm/spr_defs.h>

#include <asm/or32-hf.h>

#include <linux/smp.h>

/*

 * Initial task structure. Make this a per-architecture thing,

 * because different architectures tend to have different

 * alignment requirements and potentially different initial

 * setup.

 */

static struct fs_struct init_fs = INIT_FS;

static struct files_struct init_files = INIT_FILES;

static struct signal_struct init_signals = INIT_SIGNALS;

struct mm_struct init_mm = INIT_MM(init_mm);

struct task_struct *current_set[NR_CPUS] = {&init_task, };

union task_union  __attribute((aligned(PAGE_SIZE))) init_task_union = {

        INIT_TASK(init_task_union.task) };

void show_regs(struct pt_regs *regs)

{

        extern void show_registers(struct pt_regs *regs);

        show_registers(regs);

#if 0

        printk("CPU #: %d\n",  smp_processor_id());

        printk("   PC: %08lx    SR: %08lx    SP: %08lx\n",

               regs->pc, regs->sr, regs->sp);

        printk("GPR00: %08lx GPR01: %08lx GPR02: %08lx GPR03: %08lx\n",

               0L, regs->sp, regs->gprs[0], regs->gprs[1]);

        printk("GPR04: %08lx GPR05: %08lx GPR06: %08lx GPR07: %08lx\n",

               regs->gprs[2], regs->gprs[3], regs->gprs[4], regs->gprs[5]);

        printk("GPR08: %08lx GPR09: %08lx GPR10: %08lx GPR11: %08lx\n",

               regs->gprs[6], regs->gprs[7], regs->gprs[8], regs->gprs[9]);

        printk("GPR12: %08lx GPR13: %08lx GPR14: %08lx GPR15: %08lx\n",

               regs->gprs[10], regs->gprs[11], regs->gprs[12], regs->gprs[13]);

        printk("GPR16: %08lx GPR17: %08lx GPR18: %08lx GPR19: %08lx\n",

               regs->gprs[14], regs->gprs[15], regs->gprs[16], regs->gprs[17]);

        printk("GPR20: %08lx GPR21: %08lx GPR22: %08lx GPR23: %08lx\n",

               regs->gprs[18], regs->gprs[19], regs->gprs[20], regs->gprs[21]);

        printk("GPR24: %08lx GPR25: %08lx GPR26: %08lx GPR27: %08lx\n",

               regs->gprs[22], regs->gprs[23], regs->gprs[24], regs->gprs[25]);

        printk("GPR28: %08lx GPR29: %08lx GPR30: %08lx GPR31: %08lx\n",

               regs->gprs[26], regs->gprs[27], regs->gprs[28], regs->gprs[29]);

        printk("  RES: %08lx oGPR3: %08lx dummy: %08lx\n",

               regs->result, regs->orig_gpr3, regs->dummy);

        printk("Process %s (pid: %d, stackpage=%08lx)\n",

               current->comm, current->pid, (unsigned long)current);

#endif

}

/*

 * The idle loop on an or32..

 */

asmlinkage int sys_idle(void)

{

        if (current->pid != 0)

                return -EPERM;

        /* endless idle loop with no priority at all */

        current->counter = -100;

        for (;;) {

                schedule();

        }

}

void hard_reset_now(void)

{

        printk("***HARD_RESET_NOW***\n");

        __asm__("l.ori r31,r0,0x100;"

                "l.jr  r31         ;"

                "l.nop             ;");

}

void machine_restart(void)

{

        hard_reset_now();

}

/*

 * Similar to machine_power_off, but don't shut off power.  Add code

 * here to freeze the system for e.g. post-mortem debug purpose when

 * possible.  This halt has nothing to do with the idle halt.

 */

void machine_halt(void)

{

        printk("***MACHINE_HALT***\n");

        __asm__("l.nop 1");

}

/* If or when software power-off is implemented, add code here.  */

void machine_power_off(void)

{

        __asm__("l.nop 1");

}

/*

 * Free current thread data structures etc..

 */

void exit_thread(void)

{

}

/*

 * When a process does an "exec", machine state like FPU and debug

 * registers need to be reset.  This is a hook function for that.

 * Currently we don't have any such state to reset, so this is empty.

 */

void flush_thread(void)

{

}

asmlinkage int sys_fork(int r3, int r4, int r5, int r6, int r7, struct pt_regs *regs)

{

        unsigned long sp;

/*

 *      __PHX__ :: cleanup

 *

 *      printk("fork: current 0x%x, ksp 0x%x\n",

 *             current, &sp);

 */

        return do_fork(SIGCHLD, regs->sp, regs, 0);

}

asmlinkage int sys_clone(int r3, int r4, int r5, int r6, int r7, struct pt_regs *regs)

{

        unsigned long clone_flags = (unsigned long)r3;

        return do_fork(clone_flags, regs->sp, regs, 0);

}

asmlinkage int sys_vfork(int r3, int r4, int r5, int r6, int r7, struct pt_regs *regs)

{

        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gprs[1], regs, 0);

}

void release_thread(struct task_struct *dead_task)

{

}

int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,

                unsigned long unused, struct task_struct *p, struct pt_regs *regs)

{

        struct pt_regs *childregs, *kregs;

        extern void ret_from_fork(void);

        unsigned long sp = (unsigned long)p + sizeof(union task_union);

        unsigned long childframe;

        /* Copy registers */

        sp -= sizeof(struct pt_regs);

        childregs = (struct pt_regs *) sp;

        *childregs = *regs;

        if ((childregs->sr & SPR_SR_SM) == 1) {

                /* for kernel thread, set `current' and stackptr in new task */

                childregs->sp = sp + sizeof(struct pt_regs);

                childregs->gprs[0] = (unsigned long) p;

                /* __PHX__ :: i think this thread.regs is not needed */

                p->thread.regs = NULL;  /* no user register state */

        } else

                p->thread.regs = childregs;

        childregs->gprs[9] = 0;  /* Result from fork() */

//      sp -= STACK_FRAME_OVERHEAD;

        childframe = sp;

        /*

         * The way this works is that at some point in the future

         * some task will call _switch to switch to the new task.

         * That will pop off the stack frame created below and start

         * the new task running at ret_from_fork.  The new task will

         * do some house keeping and then return from the fork or clone

         * system call, using the stack frame created above.

         */

        sp -= sizeof(struct pt_regs);

        kregs = (struct pt_regs *) sp;

//      sp -= STACK_FRAME_OVERHEAD;

        p->thread.ksp = sp;

        kregs->sr = regs->sr | SPR_SR_SM;

        kregs->sp = sp + sizeof(struct pt_regs);

        kregs->gprs[0] = p; /* current           */

        kregs->gprs[1] = p; /* for schedule_tail */

        kregs->pc = (unsigned long)ret_from_fork;

        p->thread.last_syscall = -1;

        return 0;

}

/*

 * Set up a thread for executing a new program

 */

void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp)

{

        phx_warn("NIP: %x, SP: %x", pc, sp);

        set_fs(USER_DS);

        memset(regs->gprs, 0, sizeof(regs->gprs));

        regs->pc = pc;

        regs->sr = regs->sr & ~ SPR_SR_SM;

        regs->sp = sp;

}

/* Fill in the fpu structure for a core dump.  */

int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)

{

        phx_warn("TODO");

        /* __PHX__: __TODO__ for FPU */

        return 0;

}

void _switch_to(struct task_struct *prev, struct task_struct *new, struct task_struct **last)

{

        struct thread_struct *new_thread, *old_thread;

        long flags;

        save_flags(flags);

        cli();

        check_stack(NULL, __FILE__, __FUNCTION__, __LINE__);

        /* current_set is an array of saved current pointers

         * (one for each cpu). we need them at user->kernel transition,

         * while we save them at kernel->user transition

         */

        new_thread = &new->thread;

        old_thread = &current->thread;

        current_set[smp_processor_id()] = new;

        *last = _switch(old_thread, new_thread);

        check_stack(NULL, __FILE__, __FUNCTION__, __LINE__);

        restore_flags(flags);

}

/*

 * fill in the user structure for a core dump..

 */

void dump_thread(struct pt_regs *regs, struct user *dump)

{

        phx_warn("TODO");

        /* changed the size calculations - should hopefully work better. lbt */

        dump->magic = CMAGIC;

        dump->start_code = 0;

        dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);

        dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;

        dump->u_dsize = ((unsigned long) (current->mm->brk +

                                          (PAGE_SIZE-1))) >> PAGE_SHIFT;

        dump->u_dsize -= dump->u_tsize;

        dump->u_ssize = 0;

        /* __PHX__: FIXME !! i've just commented out this for now */

//      dump->u_ar0 = (struct pt_regs *)(((int)(&dump->regs)) -((int)(dump)));

        dump->regs = *regs;

        /* dump floating point stuff */

        /* __PHX__: __TODO__ FPU

         * dump->u_fpvalid = dump_fpu (regs, &dump->or32fp);

         */

}

/*

 * sys_execve() executes a new program.

 */

asmlinkage int sys_execve(char *name, char **argv, char **envp,

                          int r6, int r7, struct pt_regs *regs)

{

        int error;

        char * filename;

        filename = getname(name);

        error = PTR_ERR(filename);

        if (IS_ERR(filename))

          goto out;

        error = do_execve(filename, argv, envp, regs);

        if (error == 0) {

          current->ptrace &= ~PT_DTRACE;

        }

        putname(filename);

        out:

        return error;

}

unsigned long get_wchan(struct task_struct *p)

{

        /* __PHX__: TODO */

        phx_warn("TODO");

        return 0;

}