Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*
 *  linux/arch/or32/kernel/process.c
 *
 *  or32 version
 *    author(s): Matjaz Breskvar (phoenix@bsemi.com)
 *
 *  derived from cris, i386, m68k, ppc, sh ports.
 *
 *  changes:
 *  18. 11. 2003: Matjaz Breskvar (phoenix@bsemi.com)
 *    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/module.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/elfcore.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/init_task.h>
#include <linux/mqueue.h>
#include <linux/fs.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(init_signals);
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
 
EXPORT_SYMBOL(init_mm);
 
/*
 * Initial thread structure.
 *
 * We need to make sure that this is 8192-byte aligned due to the
 * way process stacks are handled. This is done by having a special
 * "init_task" linker map entry..
 */
union thread_union init_thread_union 
	__attribute__((__section__(".data.init_task"))) =
		{ INIT_THREAD_INFO(init_task) };
 
/*
 * Pointer to Current thread info structure.
 *
 * Used at user space -> kernel transitions. 
 */
struct thread_info *current_thread_info_set[NR_CPUS] = {&init_thread_info, };
 
/*
 * Initial task structure.
 *
 * All other task structs will be allocated on slabs in fork.c
 */
struct task_struct init_task = INIT_TASK(init_task);
 
EXPORT_SYMBOL(init_task);
 
/*
 * The hlt_counter, disable_hlt and enable_hlt is just here as a hook if
 * there would ever be a halt sequence (for power save when idle) with
 * some largish delay when halting or resuming *and* a driver that can't
 * afford that delay.  The hlt_counter would then be checked before
 * executing the halt sequence, and the driver marks the unhaltable
 * region by enable_hlt/disable_hlt.
 */
 
static int hlt_counter=0;
 
void disable_hlt(void)
{
	hlt_counter++;
}
 
EXPORT_SYMBOL(disable_hlt);
 
void enable_hlt(void)
{
	hlt_counter--;
}
 
EXPORT_SYMBOL(enable_hlt);
 
void machine_restart(void)
{
	printk("*** MACHINE RESTART ***\n");
	__asm__("l.nop 1");
}
 
EXPORT_SYMBOL(machine_restart);
 
/*
 * 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");
}
 
EXPORT_SYMBOL(machine_halt);
 
/* If or when software power-off is implemented, add code here.  */
 
void machine_power_off(void)
{
	printk("*** MACHINE POWER OFF ***\n");
	__asm__("l.nop 1");
}
 
EXPORT_SYMBOL(machine_power_off);
 
void (*pm_power_off)(void) = machine_power_off;
EXPORT_SYMBOL(pm_power_off);
 
/*
 * 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)
{
}
 
void show_regs(struct pt_regs *regs)
{
	extern void show_registers(struct pt_regs *regs);
 
	/* __PHX__ cleanup this mess */
	show_registers(regs);
}
 
asmlinkage int sys_fork(int r3, int r4, int r5, int r6, int r7, struct pt_regs *regs)
{
	return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
}
 
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, NULL, NULL);
}
 
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, NULL, NULL);
}
 
unsigned long thread_saved_pc(struct task_struct *t)
{
	return (unsigned long)user_regs(t->stack)->pc;
}
 
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->stack + THREAD_SIZE;
        unsigned long childframe;
        struct thread_info *tmp;
	p->set_child_tid = p->clear_child_tid = NULL;
 
        /* 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[8] = (unsigned long)p->stack;
                /* __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;
        tmp = (struct thread_info*)p->stack;
        tmp->ksp = sp;
 
	kregs->sr = regs->sr | SPR_SR_SM;
	kregs->sp = sp + sizeof(struct pt_regs);
	kregs->gprs[1] = (unsigned long)p;              /* for schedule_tail */
	kregs->gprs[8] = (unsigned long)p->stack; /* current           */
        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: %lx, SP: %lx", 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("FPU :: TODO");
	return 0;
} 
 
void _switch_to(struct task_struct *old, 
		struct task_struct *new,
		struct task_struct **last)
{
	extern struct thread_info *_switch(struct thread_info *old_ti,
					   struct thread_info *new_ti);
	struct thread_info *new_ti, *old_ti;
	long flags;
 
	local_irq_save(flags);
	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_ti = new->stack;
	old_ti = old->stack;
 
	current_thread_info_set[smp_processor_id()] = new_ti;
	*last = (_switch(old_ti, new_ti))->task;
 
	check_stack(NULL, __FILE__, __FUNCTION__, __LINE__);
	local_irq_restore(flags);
} 
 
/*
 * fill in the user structure for a core dump..
 */
void dump_thread(struct pt_regs *regs, struct user *dump)
{
	phx_warn("TODO");
}
 
/*
 * 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);
	putname(filename);
 
out:	
	return error;
}
 
unsigned long get_wchan(struct task_struct *p)
{
	phx_warn("TODO");
 
	return 0;
}
 
int kernel_execve(const char *filename, char *const argv[], char *const 
envp[])
{
  register long __res asm("r11") = __NR_execve;
  register long __a asm("r3") = (long)(filename);
  register long __b asm("r4") = (long)(argv);
  register long __c asm("r5") = (long)(envp);
  __asm__ volatile ("l.sys 1" : "=r" (__res)
           : "r" (__res), "r" (__a), "r" (__b), "r" (__c));
  __asm__ volatile("l.nop");
  return __res;
}