Subversion Repositories or1k

/*

 * include/asm-or32/processor.h

 *

 * Based on:

 * include/asm-cris/processor.h

 * Copyright (C) 2000, 2001, 2002 Axis Communications AB

 *

 */

#ifndef _OR32_PROCESSOR_H

#define _OR32_PROCESSOR_H

#include <linux/config.h>

#include <asm/spr_defs.h>

#include <asm/ptrace.h>

/* Kernel and user SR register setting */

#define KERNEL_SR (SPR_SR_DME | SPR_SR_IME | SPR_SR_ICE | SPR_SR_DCE | SPR_SR_SM)

#define USER_SR   (SPR_SR_DME | SPR_SR_IME | SPR_SR_ICE | SPR_SR_DCE | SPR_SR_IEE | SPR_SR_TEE)

/*

 * Default implementation of macro that returns current

 * instruction pointer ("program counter").

 */

#define current_text_addr() ({ __label__ _l; _l: &&_l;})

/* or32has no problems with write protection */

#define wp_works_ok 1

/*

 * User space process size. This is hardcoded into a few places,

 * so don't change it unless you know what you are doing.

 */

#define TASK_SIZE       (0x80000000UL)

/* This decides where the kernel will search for a free chunk of vm

 * space during mmap's.

 */

#define TASK_UNMAPPED_BASE      (TASK_SIZE / 8 * 3)

/* THREAD_SIZE is the size of the task_struct/kernel_stack combo.

 * normally, the stack is found by doing something like p + THREAD_SIZE

 * in or32, a page is 8192 bytes, which seems like a sane size

 */

#define THREAD_SIZE       PAGE_SIZE

#ifndef __ASSEMBLY__

struct task_struct;

typedef struct {

        unsigned long seg;

} mm_segment_t;

struct thread_struct {

        unsigned long  usp;     /* user space pointer */

        unsigned long  ksp;     /* kernel stack pointer */

        struct pt_regs *regs;   /* pointer to saved register state */

        mm_segment_t   fs;      /* for get_fs() validation */

        signed long    last_syscall;

};

/*

 * At user->kernel entry, the pt_regs struct is stacked on the top of the kernel-stack.

 * This macro allows us to find those regs for a task.

 * Notice that subsequent pt_regs stackings, like recursive interrupts occuring while

 * we're in the kernel, won't affect this - only the first user->kernel transition

 * registers are reached by this.

 */

#define user_regs(task) (((struct pt_regs *)((unsigned long)(task) + THREAD_SIZE)) - 1)

/*

 * Dito but for the currently running task

 */

#define current_regs() user_regs(current)

#define INIT_SP         (sizeof(init_stack) + (unsigned long) &init_stack)

#define INIT_THREAD  { \

   0, INIT_SP, NULL, KERNEL_DS, 0 }

extern int arch_kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);

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

void release_thread(struct task_struct *);

unsigned long get_wchan(struct task_struct *p);

/*

 * Return saved PC of a blocked thread. For now, this is the "user" PC

 */

static inline unsigned long thread_saved_pc(struct thread_struct *t)

{

        return (t->regs) ? t->regs->pc : 0;

}

#define KSTK_EIP(tsk)  ((tsk)->thread.regs? (tsk)->thread.regs->pc: 0)

#define KSTK_ESP(tsk)  ((tsk)->thread.regs? (tsk)->thread.regs->sp: 0)

#define copy_segments(tsk, mm)          do { } while (0)

#define release_segments(mm)            do { } while (0)

#define alloc_task_struct() \

        ((struct task_struct *) __get_free_pages(GFP_KERNEL,1))

#define free_task_struct(p)     free_pages((unsigned long)(p),1)

#define get_task_struct(tsk)      atomic_inc(&virt_to_page(tsk)->count)

#define init_task       (init_task_union.task)

#define init_stack      (init_task_union.stack)

#define cpu_relax()     do { } while (0)

#endif /* __ASSEMBLY__ */

#endif /* _OR32_PROCESSOR_H */