hal_arch.h

ecos移植到R8H系列的源码。源码包来自http://www.cetoni.de/develop/develop_ecosh8s_en.html

#define HAL_BREAKPOINT(_label_)                                \
asm volatile (" .globl  " __HAL_BREAKPOINT(_label_) "\n"       \
              __HAL_BREAKPOINT(_label_) ":\n\t"                \
              "trapa #3\n"                                     \
              )
#define HAL_BREAKINST           0x5730
#define HAL_BREAKINST_SIZE      2


//===========================================================================
//                              GDB SUPPORT
// DESCRIPTION:
//     The following macros provide support for interfacing GDB to the HAL.
//===========================================================================


//===========================================================================
//                     HAL_THREAD_GET_SAVED_REGISTERS
// DESCRIPTION:
//     Extracts a pointer to a HAL_SavedRegisters structure from a stack
//     pointer value. The stack pointer passed in should be the value saved 
//     by the thread context macros. The macro will assign a pointer to the
//     HAL_SavedRegisters structure to the variable passed as the second 
//     argument.
//
// PARAMETERS:
//     '_sp_'    Pointer to top of saved thred context
//     '_regs_'  Pointer to HAL_SavedRegisters structure
//===========================================================================
#define HAL_THREAD_GET_SAVED_REGISTERS(_sp_, _regs_)                     \
        (_regs_) = (HAL_SavedRegisters *)(_sp_)


//===========================================================================
//                     SET AND GET EXTRA REGISTERS FOR GDB
// DESCRIPTION:
//     Used for MAC register of H8S
//===========================================================================
#if defined(CYGHWR_HAL_H8S_USE_MAC)
//
// if we use MAC register then we also have to store and restore it for
// GDB - we will do this here
//
#ifndef HAL_GET_GDB_EXTRA_REGISTERS
    #define HAL_GET_GDB_EXTRA_REGISTERS( _regval_, _regs_ )  \
    {                                                        \
        _regval_[TICK]        = 0;                           \
        _regval_[INST]        = 0;                           \
        _regval_[MACH]        = (_regs_)->mach;              \
        _regval_[MACL]        = (_regs_)->macl;              \
    }
#endif // HAL_GET_GDB_EXTRA_REGISTERS

#ifndef HAL_SET_GDB_EXTRA_REGISTERS
    #define HAL_SET_GDB_EXTRA_REGISTERS( _regs_, _regval_ ) \
    {                                                       \
        (_regs_)->mach        = _regval_[MACH];             \
        (_regs_)->macl        = _regval_[MACL];             \
    }
#endif // HAL_SET_GDB_EXTRA_REGISTERS
#else // !defined(CYGHWR_HAL_H8S_USE_MAC)
//
// if we do not use the MAC register then we also do not have to make it
// available for GDB - therefore we leave the following two macros empty
//
#ifndef HAL_GET_GDB_EXTRA_REGISTERS
    #define HAL_GET_GDB_EXTRA_REGISTERS( _regval_, _regs_ )
#endif 

#ifndef HAL_SET_GDB_EXTRA_REGISTERS
    #define HAL_SET_GDB_EXTRA_REGISTERS( _regs_, _regval_ )
#endif 
#endif // !defined(CYGHWR_HAL_H8S_USE_MAC)


//===========================================================================
//                    TRANSLATE REGISTERS INTO GDB FORMAT
// DESCRIPTION:
//     Translates a register state as saved by the HAL and into a register 
//     dump in the format expected by GDB. 
//
// PARAMETERS:
//     '_aregval_'    pointer to a HAL_SavedRegisters structure
//     '_regs_'       pointer to the memory to contain the GDB register dump
//===========================================================================
#define HAL_GET_GDB_REGISTERS(_aregval_ , _regs_)                     \
{                                                                     \
    target_register_t *_regval_ = (target_register_t *)(_aregval_);   \
                                                                      \
    _regval_[ER0]         = (_regs_)->er0;                            \
    _regval_[ER1]         = (_regs_)->er1;                            \
    _regval_[ER2]         = (_regs_)->er2;                            \
    _regval_[ER3]         = (_regs_)->er3;                            \
    _regval_[ER4]         = (_regs_)->er4;                            \
    _regval_[ER5]         = (_regs_)->er5;                            \
    _regval_[ER6]         = (_regs_)->er6;                            \
                                                                      \
    _regval_[SP]          = (_regs_)->sp;                             \
    _regval_[CCR]         = (_regs_)->ccr;                            \
    _regval_[PC]          = (_regs_)->pc;                             \
    _regval_[CYCL]        = 0;                                        \
    _regval_[EXR]         = (_regs_)->exr;                            \
                                                                      \
    HAL_GET_GDB_EXTRA_REGISTERS(_regval_, _regs_);                    \
}


//===========================================================================
//                    TRANSLATE REGISTERS INTO GDB FORMAT
// DESCRIPTION:
//     translates a GDB format register dump into a the format expected by 
//     the HAL. 
//
// PARAMETERS:
//     '_regs_'       pointer to the memory containing the GDB register dump
//     '_aregval_'    pointer to a HAL_SavedRegisters structure
//===========================================================================
#define HAL_SET_GDB_REGISTERS(_regs_ , _aregval_)                       \
{                                                                       \
    target_register_t *_regval_ = (target_register_t *)(_aregval_);     \
                                                                        \
    (_regs_)->er0            = _regval_[ER0];                           \
    (_regs_)->er1            = _regval_[ER1];                           \
    (_regs_)->er2            = _regval_[ER2];                           \
    (_regs_)->er3            = _regval_[ER3];                           \
    (_regs_)->er4            = _regval_[ER4];                           \
    (_regs_)->er5            = _regval_[ER5];                           \
    (_regs_)->er6            = _regval_[ER6];                           \
                                                                        \
    (_regs_)->sp             = _regval_[SP];                            \
    (_regs_)->ccr            = _regval_[CCR];                           \
    (_regs_)->pc             = _regval_[PC];                            \
    (_regs_)->exr            = _regval_[EXR];                           \
                                                                        \
                                                                        \
     HAL_SET_GDB_EXTRA_REGISTERS( _regs_, _regval_ );                   \
}


//===========================================================================
//                    TRANSLATE REGISTERS INTO GDB FORMAT
// DESCRIPTION:
//     Get PC from HAL_SavedRegisters structure
//
// PARAMETERS:
//     '_regs_'   Pointer to HAL_SavedRegisters structure
//     '_val_'    Stores PC value
//===========================================================================
#ifndef CYGARC_HAL_GET_PC_REG
   #define CYGARC_HAL_GET_PC_REG(_regs_, _val_) (_val_) = (_regs_)->pc
#endif


//===========================================================================
//                    SETJMP AND LONGJMP SUPPORT
// DESCRIPTION:
//     These functions provide support for the C setjmp() and longjmp()
//     functions. Refer to the C library for further information.
//
// NOTES:
//     These definitions are repeated in context.S. If changes are required
//     remember to update both sets
//===========================================================================
#define CYGARC_JMP_BUF_SP        0
#define CYGARC_JMP_BUF_ER3       1
#define CYGARC_JMP_BUF_ER4       2
#define CYGARC_JMP_BUF_ER5       3
#define CYGARC_JMP_BUF_ER6       4
#define CYGARC_JMP_BUF_PC        5

#define CYGARC_JMP_BUF_SIZE      6

///
/// Buffer for hal_setjmp(hal_jmp_buf) / hal_longjmp(hal_jmp_buf, int) call.
/// This buffer stores the register content during the longjump calls
///
typedef cyg_uint32 hal_jmp_buf[CYGARC_JMP_BUF_SIZE];


//---------------------------------------------------------------------------
///
///  Sets jump label for later longjmp call.
///  setjmp / lonjmp enables non local long jumps.
///
/// \param  env   Buffer stores current registers for later restore
///
/// \retval zero     When this function is called directly
/// \retval nonzero  When returning from longjmp call
///
externC int hal_setjmp(hal_jmp_buf env);


//---------------------------------------------------------------------------
///
///  longjmp call for non local long jumps.
///  Forces a return to previously set jump label by setjmp call.
///
/// \param  val   Value that will be returned by setjmp when returning.
/// \param  env   Buffer containig previously stored register set.
///
externC void hal_longjmp(hal_jmp_buf env, int val);


//===========================================================================
//                    SETJMP AND LONGJMP SUPPORT
// DESCRIPTION:
//     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_)


//===========================================================================
//                             STACK SIZES
// DESCRIPTION:
//     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!
//
//     We define quite large stack needs for SPARClite, for it requires 576
//     bytes (144 words) to process an interrupt and thread-switch, and
//     momentarily, but needed in case of recursive interrupts, it needs 208
//     words - if a sequence of saves to push out other regsets is interrupted.
//
//     This is not a config option because it should not be adjusted except
//     under "enough rope" sort of disclaimers.
//===========================================================================
//
// Worst case stack frame size: return link + 4 args + 4 pushed registers.
//
#define CYGNUM_HAL_STACK_FRAME_SIZE (40)

//
// Stack needed for a context switch:
//
#define CYGNUM_HAL_STACK_CONTEXT_SIZE (60)

//
// Interrupt + call to ISR, interrupt_end() and the DSR
//
#define CYGNUM_HAL_STACK_INTERRUPT_SIZE (128)

#ifdef CYGIMP_HAL_COMMON_INTERRUPTS_USE_INTERRUPT_STACK
//
// An interrupt stack which is large enough for all possible interrupt
// conditions (and only used for that purpose) exists.  "User" stacks
// can be much smaller
//
#define CYGNUM_HAL_STACK_SIZE_MINIMUM (CYGNUM_HAL_STACK_CONTEXT_SIZE+      \
                                       CYGNUM_HAL_STACK_INTERRUPT_SIZE*2+  \
                                       CYGNUM_HAL_STACK_FRAME_SIZE*16)
#define CYGNUM_HAL_STACK_SIZE_TYPICAL (2048)

#else // CYGIMP_HAL_COMMON_INTERRUPTS_USE_INTERRUPT_STACK
//
// No separate interrupt stack exists.  Make sure all threads contain
// a stack sufficiently large.
//
#define CYGNUM_HAL_STACK_SIZE_MINIMUM (4096)
#define CYGNUM_HAL_STACK_SIZE_TYPICAL (4096)
#endif


//===========================================================================
//                     GLOBAL POINTER SAVE RESTORE MACROS
// DESCRIPTION:
//     Not required in this architecture
//===========================================================================
#define CYGARC_HAL_SAVE_GP()
#define CYGARC_HAL_RESTORE_GP()

//--------------------------------------------------------------------------
#endif // CYGONCE_HAL_HAL_ARCH_H
// EOF hal_arch.h