hal_arch.h

开放源码实时操作系统源码.

#define HAL_BREAKINST_SIZE               2
#define HAL_BREAKINST_TYPE               unsigned short

//-----------------------------------------------------------------------------
// Thread register state manipulation for GDB support.

// Default to a 32 bit register size for GDB register dumps.
#ifndef CYG_HAL_GDB_REG
#define CYG_HAL_GDB_REG CYG_WORD32
#endif

// Register layout expected by GDB
typedef struct 
{
    CYG_HAL_FR30_REG    r[16];          // was: r[0] GPR regs
    CYG_HAL_FR30_REG    pc;
    CYG_HAL_FR30_REG    ps;
    CYG_HAL_FR30_REG    tbr;
    CYG_HAL_FR30_REG    rp;
    CYG_HAL_FR30_REG    ssp;
    CYG_HAL_FR30_REG    usp;
    CYG_HAL_FR30_REG    mdh;
    CYG_HAL_FR30_REG    mdl;
} GDB_Registers;

// Translate a stack pointer as saved by the thread context macros above into
// a pointer to a HAL_SavedRegisters structure declared in src/fr30_stub.h

#define HAL_THREAD_GET_SAVED_REGISTERS( _sp_, _regs_ )  \
         (_regs_) = (HAL_SavedRegisters *)(_sp_)

// Copy a set of registers from a HAL_SavedRegisters structure into a
// GDB ordered array.
#define HAL_GET_GDB_REGISTERS( _aregval_, _regs_ )              \
    CYG_MACRO_START                                             \
    GDB_Registers *_gdb_ = (GDB_Registers *)(_aregval_);        \
    int _i_;                                                    \
                                                                \
    for( _i_ = 0; _i_ <  16; _i_++ ) {                          \
        _gdb_->r[_i_] = (_regs_)->r[_i_];                       \
    }                                                           \
                                                                \
    _gdb_->pc = (_regs_)->pc;                                   \
    _gdb_->ps = (_regs_)->ps;                                   \
    _gdb_->tbr = (_regs_)->tbr;                                 \
    _gdb_->rp = (_regs_)->rp;                                   \
    _gdb_->ssp = (_regs_)->ssp;                                 \
    _gdb_->usp = (_regs_)->usp;                                 \
    _gdb_->mdh = (_regs_)->mdh;                                 \
    _gdb_->mdl = (_regs_)->mdl;                                 \
    CYG_MACRO_END

// Copy a set of registers from a GDB_Registers structure into a
// HAL_SavedRegisters structure.
#define HAL_SET_GDB_REGISTERS( _regs_ , _aregval_ )             \
    CYG_MACRO_START                                             \
    GDB_Registers *_gdb_ = (GDB_Registers *)(_aregval_);        \
    int _i_;                                                    \
                                                                \
    for( _i_ = 0; _i_ <  16; _i_++ )                            \
        (_regs_)->r[_i_] = _gdb_->r[_i_];                       \
                                                                \
    (_regs_)->pc = _gdb_->pc;                                   \
    (_regs_)->ps = _gdb_->ps;                                   \
    (_regs_)->tbr = _gdb_->tbr;                                 \
    (_regs_)->rp = _gdb_->rp;                                   \
    (_regs_)->ssp = _gdb_->ssp;                                 \
    (_regs_)->usp = _gdb_->usp;                                 \
    (_regs_)->mdh = _gdb_->mdh;                                 \
    (_regs_)->mdl = _gdb_->mdl;                                 \
    CYG_MACRO_END


// -------------------------------------------------------------------------
// hal_setjmp/hal_longjmp


// 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 {
    // registers
    cyg_uint32 r8;
    cyg_uint32 r9;
    cyg_uint32 r10;
    cyg_uint32 r11;
    cyg_uint32 r14;

    // SP and PC
    cyg_uint32 r15; //USP
    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_setjmp(hal_jmp_buf env);
externC void hal_longjmp(hal_jmp_buf env, int val);
//-----------------------------------------------------------------------------
// 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. (contains an empty function call at the moment)
// declared in src/hal_misc.c

externC void hal_idle_thread_action(cyg_uint32 loop_count);

#define HAL_IDLE_THREAD_ACTION(_count_) hal_idle_thread_action(_count_)

//-----------------------------------------------------------------------------
// 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.  13 registers (which is a maximum FIXME),
// 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 ((13 + 1 + 1) * 4)

// Stack needed for a context switch.
// it should be sizeof(HAL_SavedRegisters)
//      All registers + PC + PS + RP + MDH + MDL

#ifndef CYGNUM_HAL_STACK_CONTEXT_SIZE
#define CYGNUM_HAL_STACK_CONTEXT_SIZE ((16+1+1+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) + (4*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

#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))))

//--------------------------------------------------------------------------
// Memory access macros

#define CYGARC_CACHED_ADDRESS(x)                       (x)
#define CYGARC_UNCACHED_ADDRESS(x)                     (x)
#define CYGARC_PHYSICAL_ADDRESS(x)                     (x)
#define CYGARC_VIRTUAL_ADDRESS(x)                      (x)

//--------------------------------------------------------------------------
// 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()

//--------------------------------------------------------------------------
#endif // CYGONCE_HAL_HAL_ARCH_H
// End of hal_arch.h