Subversion Repositories openrisc

#ifndef CYGONCE_HAL_ARCH_H
#define CYGONCE_HAL_ARCH_H
 
//=============================================================================
//
//      hal_arch.h
//
//      Architecture specific abstractions
//
//=============================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later version.
//
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//=============================================================================
 
#include <pkgconf/hal.h>
#include <cyg/infra/cyg_type.h>
 
// Include some variant specific architectural defines.
#include <cyg/hal/var_arch.h>
 
#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
#include <cyg/hal/m68k_stub.h>
#endif // CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 
#ifndef HAL_NORMAL_SAVED_CONTEXT
/*****************************************************************************
HAL_NORMAL_SAVED_CONTEXT -- Saved by a normal context switch
 
     Define  a  generic   structure  to  save   a  thread  context.    Some
architecture variants will want to redefine this.
 
*****************************************************************************/
typedef struct
{
 
    //   Data regs D0-D7
 
    #define HAL_NORMAL_SAVED_NUM_D_REGS 8
    CYG_WORD32 d[HAL_NORMAL_SAVED_NUM_D_REGS];
 
    //   Address regs A0-A6
 
    #define HAL_NORMAL_SAVED_NUM_A_REGS 7
    CYG_ADDRESS a[HAL_NORMAL_SAVED_NUM_A_REGS];
 
    //   Program Counter
 
    CYG_ADDRESS pc;
 
} __attribute__ ((aligned, packed)) HAL_SavedRegisters_normal;
#endif // HAL_NORMAL_SAVED_CONTEXT
 
#ifndef HAL_GENERIC_SAVED_CONTEXT
/*****************************************************************************
HAL_GENERIC_SAVED_CONTEXT -- Generic saved context structure
 
     This is  a  generic  structure  that  should  describe  various  saved
processor contexts on this platform.
 
     If the variant HAL does not define this, just define a saved  register
structure with a normal context.
 
*****************************************************************************/
#define HAL_GENERIC_SAVED_CONTEXT \
typedef union \
{ \
    HAL_SavedRegisters_normal normal; \
} __attribute__ ((aligned, packed)) HAL_SavedRegisters;
#endif // HAL_GENERIC_SAVED_CONTEXT
HAL_GENERIC_SAVED_CONTEXT;
 
#ifndef HAL_THREAD_SWITCH_CONTEXT
/*****************************************************************************
HAL_THREAD_SWITCH_CONTEXT
 
     This macro saves the state of the currently running thread and  writes
its stack pointer to *(_fspptr_).
 
     It then switches to the thread context that *(_tspptr_) points to.
 
INPUT:
 
     _fspptr_: A pointer to the location to save the current thread's stack
pointer to.
 
     _tspptr_: A pointer to  the location containing  the stack pointer  of
the thread context to switch to.
 
OUTPUT:
 
     *(_fspptr_): Contains the  stack  pointer  of  the  previous  thread's
context.
 
*****************************************************************************/
#define HAL_THREAD_SWITCH_CONTEXT(_fspptr_,_tspptr_) \
CYG_MACRO_START \
    asm volatile (" pea     1f(%%pc)\n" \
                  " lea     -(8+7)*4(%%sp),%%sp\n" \
                  " movem.l %%d0-%%d7/%%a0-%%a6,(%%sp)\n" \
                  " move.l  %%sp,%0\n" \
                  " move.l  %1,%%sp\n" \
                  " movem.l (%%sp),%%d0-%%d7/%%a0-%%a6\n" \
                  " lea     (8+7)*4(%%sp),%%sp\n" \
                  " rts\n" \
                  "1:\n" \
                  : "=g" (*(_fspptr_)) \
                  : "g" (*(_tspptr_)) \
                  : "memory"); \
CYG_MACRO_END
#if HAL_NORMAL_SAVED_NUM_D_REGS != 8
    #error
#endif
#if HAL_NORMAL_SAVED_NUM_A_REGS != 7
    #error
#endif
#endif // HAL_THREAD_SWITCH_CONTEXT
 
#ifndef HAL_THREAD_LOAD_CONTEXT
/*****************************************************************************
HAL_THREAD_LOAD_CONTEXT
 
     This macro loads the thread context that *(_tspptr_) points to.
 
     This macro does not return.
 
INPUT:
 
     _tspptr_: A pointer to  the location containing  the stack pointer  of
the thread context to switch to.
 
*****************************************************************************/
#define HAL_THREAD_LOAD_CONTEXT(_tspptr_) \
CYG_MACRO_START \
    asm volatile (" move.l  %0,%%sp\n" \
                  " movem.l (%%sp),%%d0-%%d7/%%a0-%%a6\n" \
                  " lea     (8+7)*4(%%sp),%%sp\n" \
                  " rts\n" \
                  : \
                  : "g" (*(_tspptr_)) \
                  : "memory"); \
CYG_MACRO_END
#if HAL_NORMAL_SAVED_NUM_D_REGS != 8
    #error
#endif
#if HAL_NORMAL_SAVED_NUM_A_REGS != 7
    #error
#endif
#endif // HAL_THREAD_LOAD_CONTEXT
 
#ifndef HAL_THREAD_INIT_CONTEXT
/*****************************************************************************
HAL_THREAD_INIT_CONTEXT -- Context Initialization
 
     Initialize the context of a thread.
 
INPUT:
 
     _sparg_: The name of  the variable  containing the  current sp.   This
will be written with the new sp.
 
     _thread_: The thread object  address,  passed  as  argument  to  entry
point.
 
     _entry_: The thread's entry point address.
 
     _id_: A bit pattern used in initializing registers, for debugging.
 
OUTPUT:
 
     _sparg_: Updated with the value of the new sp.
 
*****************************************************************************/
#define HAL_THREAD_INIT_CONTEXT(_sparg_, _thread_, _entry_, _id_) \
    CYG_MACRO_START \
    CYG_WORD32 * _sp_ = ((CYG_WORD32*)((CYG_WORD32)(_sparg_) & ~15)); \
    HAL_SavedRegisters_normal * _regs_; \
    int _i_; \
 \
    *(--_sp_) = (CYG_WORD32)(_thread_); /* Thread's parameter. */ \
    *(--_sp_) = (CYG_WORD32)0xDEADC0DE; /* Thread's return addr. */ \
 \
    _regs_ = (HAL_SavedRegisters_normal*) \
              ((CYG_WORD32)_sp_ - sizeof(HAL_SavedRegisters_normal)); \
 \
    for (_i_=0; _i_ < HAL_NORMAL_SAVED_NUM_A_REGS; _i_++) \
        _regs_->a[_i_] = _regs_->d[_i_] = (_id_); \
    _regs_->d[_i_] = (_id_); /* D7 */ \
    /* A6, initial frame pointer should be null */ \
    _regs_->a[HAL_NORMAL_SAVED_NUM_A_REGS-1] = (CYG_ADDRESS)0; \
    /* Thread's starting PC */ \
    _regs_->pc = (CYG_ADDRESS)(_entry_); \
 \
    (_sparg_) = (CYG_ADDRESS)_regs_; \
    CYG_MACRO_END
#endif // HAL_THREAD_INIT_CONTEXT
 
//-----------------------------------------------------------------------------
// Bit manipulation routines
 
externC cyg_uint32 hal_lsbit_index(cyg_uint32 mask);
externC cyg_uint32 hal_msbit_index(cyg_uint32 mask);
 
#define HAL_LSBIT_INDEX(index, mask) (index) = hal_lsbit_index(mask);
 
#define HAL_MSBIT_INDEX(index, mask) (index) = hal_msbit_index(mask);
 
//-----------------------------------------------------------------------------
// Idle thread code.
// This macro is called in the idle thread loop, and gives the HAL the
// chance to insert code. Typical idle thread behaviour might be to halt the
// processor.
 
externC void hal_idle_thread_action(cyg_uint32 loop_count);
 
#define HAL_IDLE_THREAD_ACTION(_count_) hal_idle_thread_action(_count_)
 
//-----------------------------------------------------------------------------
// Execution reorder barrier.
// When optimizing the compiler can reorder code. In multithreaded systems
// where the order of actions is vital, this can sometimes cause problems.
// This macro may be inserted into places where reordering should not happen.
 
#define HAL_REORDER_BARRIER() asm volatile ( "" : : : "memory" )
 
//-----------------------------------------------------------------------------
// Breakpoint support
// HAL_BREAKPOINT() is a code sequence that will cause a breakpoint to happen
// if executed.
// HAL_BREAKINST is the value of the breakpoint instruction and
// HAL_BREAKINST_SIZE is its size in bytes.
 
#define HAL_BREAKPOINT(_label_)                 \
asm volatile (" .globl  " #_label_ ";"          \
              #_label_":"                       \
              " trap #1"                        \
    );
 
#define HAL_BREAKINST           0x4E41
 
#define HAL_BREAKINST_SIZE      2
 
#if defined(CYGFUN_HAL_COMMON_KERNEL_SUPPORT) && \
      defined(CYGPKG_HAL_EXCEPTIONS)
 
//-----------------------------------------------------------------------------
// Exception handling function.
// This function is defined by the kernel according to this prototype. It is
// invoked from the HAL to deal with any CPU exceptions that the HAL does
// not want to deal with itself. It usually invokes the kernel's exception
// delivery mechanism.
 
externC void cyg_hal_deliver_exception( CYG_WORD code, CYG_ADDRWORD data );
 
#endif /* defined(CYGFUN_HAL_COMMON_KERNEL_SUPPORT) */
 
//-----------------------------------------------------------------------------
// Minimal and sensible stack sizes: the intention is that applications
// will use these to provide a stack size in the first instance prior to
// proper analysis.  Idle thread stack should be this big.
 
//    THESE ARE NOT INTENDED TO BE MICROMETRICALLY ACCURATE FIGURES.
//           THEY ARE HOWEVER ENOUGH TO START PROGRAMMING.
// YOU MUST MAKE YOUR STACKS LARGER IF YOU HAVE LARGE "AUTO" VARIABLES!
 
// This is not a config option because it should not be adjusted except
// under "enough rope" sort of disclaimers.
 
//      Stack frame overhead per call.  6 data registers, 5 address registers,
// frame pointer, and return address.  We  can't guess the local variables  so
// just assume that using all of the registers averages out.
 
#define CYGNUM_HAL_STACK_FRAME_SIZE ((6 + 5 + 1 + 1) * 4)
 
// Stack needed for a context switch.
//      All registers + pc + sr + vector
 
#ifndef CYGNUM_HAL_STACK_CONTEXT_SIZE
#define CYGNUM_HAL_STACK_CONTEXT_SIZE ((8+8+1+1+1)*4)
#endif // CYGNUM_HAL_STACK_CONTEXT_SIZE
 
// Interrupt + call to ISR, interrupt_end() and the DSR
 
#define CYGNUM_HAL_STACK_INTERRUPT_SIZE \
    ((CYGNUM_HAL_STACK_CONTEXT_SIZE) + (8*CYGNUM_HAL_STACK_FRAME_SIZE))
 
// We define a minimum stack size as the minimum any thread could ever
// legitimately get away with. We can throw asserts if users ask for less
// than this. Allow enough for four interrupt sources - clock, serial,
// nic, and one other
 
// No separate interrupt stack exists.  Make sure all threads contain
// a stack sufficiently large
 
#define CYGNUM_HAL_STACK_SIZE_MINIMUM                   \
        ((4*CYGNUM_HAL_STACK_INTERRUPT_SIZE)            \
         + (16*CYGNUM_HAL_STACK_FRAME_SIZE))
 
// Now make a reasonable choice for a typical thread size. Pluck figures
// from thin air and say 30 call frames with an average of 16 words of
// automatic variables per call frame
 
#define CYGNUM_HAL_STACK_SIZE_TYPICAL                   \
        (CYGNUM_HAL_STACK_SIZE_MINIMUM +                \
         (30 * (CYGNUM_HAL_STACK_FRAME_SIZE+(16*4))))
 
//--------------------------------------------------------------------------
// Macros for switching context between two eCos instances (jump from
// code in ROM to code in RAM or vice versa).
#define CYGARC_HAL_SAVE_GP()
#define CYGARC_HAL_RESTORE_GP()
 
#ifndef HAL_SETJMP
#define HAL_SETJMP
/*****************************************************************************
hal_setjmp/hal_longjmp
 
     We do the best  we can to define  generic setjmp and longjmp  routines
for the m68k architecture.  Some architectures will need to override this.
 
*****************************************************************************/
 
//      We must save all of  the registers that  are preserved across  routine
// calls.  The assembly code assumes  that this  structure is  defined in  the
// following format.  Any changes to this structure will result in changes  to
// the assembly code!!
 
typedef struct {
    cyg_uint32 d2;
    cyg_uint32 d3;
    cyg_uint32 d4;
    cyg_uint32 d5;
    cyg_uint32 d6;
    cyg_uint32 d7;
    cyg_uint32 a2;
    cyg_uint32 a3;
    cyg_uint32 a4;
    cyg_uint32 a5;
    cyg_uint32 a6;
    cyg_uint32 sp;
    cyg_uint32 pc;
} hal_jmp_buf_t;
 
//      This type is used by normal  routines  to  pass  the  address  of  the
// structure into our routines without  having to explicitly take the  address
// of the structure.
 
typedef cyg_uint32 hal_jmp_buf[sizeof(hal_jmp_buf_t) / sizeof(cyg_uint32)];
 
//      Define the generic setjmp and longjmp routines.
 
externC int hal_m68k_setjmp(hal_jmp_buf env);
externC void hal_m68k_longjmp(hal_jmp_buf env, int val);
#define hal_setjmp(_env) hal_m68k_setjmp(_env)
#define hal_longjmp(_env, _val) hal_m68k_longjmp(_env, _val)
#endif // HAL_SETJMP
 
//-----------------------------------------------------------------------------
#endif // CYGONCE_HAL_ARCH_H
// End of hal_arch.h