cpu.h

Go to the documentation of this file.

/*
 *  COPYRIGHT (c) 1989-2011.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.org/license/LICENSE.
 */

#ifndef _RTEMS_SCORE_CPU_H
#define _RTEMS_SCORE_CPU_H

#ifdef __cplusplus
extern "C" {
#endif

#include <rtems/score/basedefs.h>
#include <rtems/score/sparc.h>

/* conditional compilation parameters */

/*
 * The SPARC ABI is a bit special with respect to the floating point context.
 * The complete floating point context is volatile.  Thus, from an ABI point
 * of view nothing needs to be saved and restored during a context switch.
 * Instead the floating point context must be saved and restored during
 * interrupt processing.  Historically, the deferred floating point switch was
 * used for SPARC and the complete floating point context is saved and
 * restored during a context switch to the new floating point unit owner.
 * This is a bit dangerous since post-switch actions (e.g. signal handlers)
 * and context switch extensions may silently corrupt the floating point
 * context.
 *
 * The floating point unit is disabled for interrupt handlers.  Thus, in case
 * an interrupt handler uses the floating point unit then this will result in a
 * trap (INTERNAL_ERROR_ILLEGAL_USE_OF_FLOATING_POINT_UNIT).
 *
 * In uniprocessor configurations, a lazy floating point context switch is
 * used.  In case an active floating point thread is interrupted (PSR[EF] == 1)
 * and a thread dispatch is carried out, then this thread is registered as the
 * floating point owner.  When a floating point owner is present during a
 * context switch, the floating point unit is disabled for the heir thread
 * (PSR[EF] == 0).  The floating point disabled trap checks that the use of the
 * floating point unit is allowed and saves/restores the floating point context
 * on demand.
 *
 * In SMP configurations, the deferred floating point switch is not supported
 * in principle.  So, use here a synchronous floating point switching.
 * Synchronous means that the volatile floating point context is saved and
 * restored around a thread dispatch issued during interrupt processing.  Thus
 * post-switch actions and context switch extensions may safely use the
 * floating point unit.
 */
#if SPARC_HAS_FPU == 1
  #if defined(RTEMS_SMP)
    #define SPARC_USE_SYNCHRONOUS_FP_SWITCH
  #else
    #define SPARC_USE_LAZY_FP_SWITCH
  #endif
#endif

#define CPU_SIMPLE_VECTORED_INTERRUPTS TRUE

#define CPU_ISR_PASSES_FRAME_POINTER FALSE

#if ( SPARC_HAS_FPU == 1 ) && !defined(SPARC_USE_SYNCHRONOUS_FP_SWITCH)
  #define CPU_HARDWARE_FP     TRUE
#else
  #define CPU_HARDWARE_FP     FALSE
#endif

#define CPU_SOFTWARE_FP     FALSE

#define CPU_ALL_TASKS_ARE_FP     FALSE

#define CPU_IDLE_TASK_IS_FP      FALSE

#define CPU_USE_DEFERRED_FP_SWITCH FALSE

#define CPU_ENABLE_ROBUST_THREAD_DISPATCH FALSE

#define CPU_STACK_GROWS_UP               FALSE

/* LEON3 systems may use a cache line size of 64 */
#define CPU_CACHE_LINE_BYTES 64

#define CPU_STRUCTURE_ALIGNMENT RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES )

#define CPU_MODES_INTERRUPT_MASK   0x0000000F

#ifndef ASM

typedef struct {
  uint32_t    l0;
  uint32_t    l1;
  uint32_t    l2;
  uint32_t    l3;
  uint32_t    l4;
  uint32_t    l5;
  uint32_t    l6;
  uint32_t    l7;
  uint32_t    i0;
  uint32_t    i1;
  uint32_t    i2;
  uint32_t    i3;
  uint32_t    i4;
  uint32_t    i5;
  uint32_t    i6_fp;
  uint32_t    i7;
  void       *structure_return_address;

  /*
   * The following are for the callee to save the register arguments in
   * should this be necessary.
   */
  uint32_t    saved_arg0;
  uint32_t    saved_arg1;
  uint32_t    saved_arg2;
  uint32_t    saved_arg3;
  uint32_t    saved_arg4;
  uint32_t    saved_arg5;
  uint32_t    pad0;
} SPARC_Minimum_stack_frame;

#endif /* ASM */

#define CPU_STACK_FRAME_L0_OFFSET             0x00

#define CPU_STACK_FRAME_L1_OFFSET             0x04

#define CPU_STACK_FRAME_L2_OFFSET             0x08

#define CPU_STACK_FRAME_L3_OFFSET             0x0c

#define CPU_STACK_FRAME_L4_OFFSET             0x10

#define CPU_STACK_FRAME_L5_OFFSET             0x14

#define CPU_STACK_FRAME_L6_OFFSET             0x18

#define CPU_STACK_FRAME_L7_OFFSET             0x1c

#define CPU_STACK_FRAME_I0_OFFSET             0x20

#define CPU_STACK_FRAME_I1_OFFSET             0x24

#define CPU_STACK_FRAME_I2_OFFSET             0x28

#define CPU_STACK_FRAME_I3_OFFSET             0x2c

#define CPU_STACK_FRAME_I4_OFFSET             0x30

#define CPU_STACK_FRAME_I5_OFFSET             0x34

#define CPU_STACK_FRAME_I6_FP_OFFSET          0x38

#define CPU_STACK_FRAME_I7_OFFSET             0x3c

#define CPU_STRUCTURE_RETURN_ADDRESS_OFFSET   0x40

#define CPU_STACK_FRAME_SAVED_ARG0_OFFSET     0x44

#define CPU_STACK_FRAME_SAVED_ARG1_OFFSET     0x48

#define CPU_STACK_FRAME_SAVED_ARG2_OFFSET     0x4c

#define CPU_STACK_FRAME_SAVED_ARG3_OFFSET     0x50

#define CPU_STACK_FRAME_SAVED_ARG4_OFFSET     0x54

#define CPU_STACK_FRAME_SAVED_ARG5_OFFSET     0x58

#define CPU_STACK_FRAME_PAD0_OFFSET           0x5c

#define CPU_MAXIMUM_PROCESSORS 32

#ifndef ASM
typedef struct Context_Control_fp Context_Control_fp;

typedef struct {
  uint32_t   g5;
  uint32_t   g7;

  double     l0_and_l1;
  uint32_t   l2;
  uint32_t   l3;
  uint32_t   l4;
  uint32_t   l5;
  uint32_t   l6;
  uint32_t   l7;

  uint32_t   i0;
  uint32_t   i1;
  uint32_t   i2;
  uint32_t   i3;
  uint32_t   i4;
  uint32_t   i5;
  uint32_t   i6_fp;
  uint32_t   i7;

  uint32_t   o6_sp;
  uint32_t   o7;

  uint32_t   psr;
  uint32_t   isr_dispatch_disable;

#if defined(SPARC_USE_LAZY_FP_SWITCH)
  Context_Control_fp *fp_context;
#endif

#if defined(RTEMS_SMP)
  volatile uint32_t is_executing;
#endif
} Context_Control;

#define _CPU_Context_Get_SP( _context ) \
  (_context)->o6_sp

#ifdef RTEMS_SMP
  static inline bool _CPU_Context_Get_is_executing(
    const Context_Control *context
  )
  {
    return context->is_executing;
  }

  static inline void _CPU_Context_Set_is_executing(
    Context_Control *context,
    bool is_executing
  )
  {
    context->is_executing = is_executing;
  }
#endif

#endif /* ASM */

/*
 *  Offsets of fields with Context_Control for assembly routines.
 */

#define G5_OFFSET    0x00

#define G7_OFFSET    0x04

#define L0_OFFSET    0x08

#define L1_OFFSET    0x0C

#define L2_OFFSET    0x10

#define L3_OFFSET    0x14

#define L4_OFFSET    0x18

#define L5_OFFSET    0x1C

#define L6_OFFSET    0x20

#define L7_OFFSET    0x24

#define I0_OFFSET    0x28

#define I1_OFFSET    0x2C

#define I2_OFFSET    0x30

#define I3_OFFSET    0x34

#define I4_OFFSET    0x38

#define I5_OFFSET    0x3C

#define I6_FP_OFFSET 0x40

#define I7_OFFSET    0x44

#define O6_SP_OFFSET 0x48

#define O7_OFFSET    0x4C

#define PSR_OFFSET   0x50

#define ISR_DISPATCH_DISABLE_STACK_OFFSET 0x54

#if defined(RTEMS_SMP)
  #define SPARC_CONTEXT_CONTROL_IS_EXECUTING_OFFSET 0x58
#endif

#ifndef ASM

struct Context_Control_fp {
  double      f0_f1;
  double      f2_f3;
  double      f4_f5;
  double      f6_f7;
  double      f8_f9;
  double      f10_f11;
  double      f12_f13;
  double      f14_f15;
  double      f16_f17;
  double      f18_f19;
  double      f20_f21;
  double      f22_f23;
  double      f24_f25;
  double      f26_f27;
  double      f28_f29;
  double      f30_f31;
  uint32_t    fsr;
};

#endif /* ASM */

/*
 *  Offsets of fields with Context_Control_fp for assembly routines.
 */

#define FO_F1_OFFSET     0x00

#define F2_F3_OFFSET     0x08

#define F4_F5_OFFSET     0x10

#define F6_F7_OFFSET     0x18

#define F8_F9_OFFSET     0x20

#define F1O_F11_OFFSET   0x28

#define F12_F13_OFFSET   0x30

#define F14_F15_OFFSET   0x38

#define F16_F17_OFFSET   0x40

#define F18_F19_OFFSET   0x48

#define F2O_F21_OFFSET   0x50

#define F22_F23_OFFSET   0x58

#define F24_F25_OFFSET   0x60

#define F26_F27_OFFSET   0x68

#define F28_F29_OFFSET   0x70

#define F3O_F31_OFFSET   0x78

#define FSR_OFFSET       0x80

#define CONTEXT_CONTROL_FP_SIZE 0x84

#ifndef ASM

typedef struct {
  SPARC_Minimum_stack_frame Stack_frame;
  uint32_t                 psr;
  uint32_t                 pc;
  uint32_t                 npc;
  uint32_t                 g1;
  uint32_t                 g2;
  uint32_t                 g3;
  uint32_t                 g4;
  uint32_t                 g5;
  uint32_t                 reserved_for_alignment;
  uint32_t                 g7;
  uint32_t                 i0;
  uint32_t                 i1;
  uint32_t                 i2;
  uint32_t                 i3;
  uint32_t                 i4;
  uint32_t                 i5;
  uint32_t                 i6_fp;
  uint32_t                 i7;
  uint32_t                 y;
  uint32_t                 tpc;
} CPU_Interrupt_frame;

#endif /* ASM */

#ifndef ASM

typedef struct {
  uint32_t     mov_psr_l0;
  uint32_t     sethi_of_handler_to_l4;
  uint32_t     jmp_to_low_of_handler_plus_l4;
  uint32_t     mov_vector_l3;
} CPU_Trap_table_entry;

extern const CPU_Trap_table_entry _CPU_Trap_slot_template;

#define CPU_CONTEXT_FP_SIZE sizeof( Context_Control_fp )

#endif

#define CPU_MPCI_RECEIVE_SERVER_EXTRA_STACK 1024

#define CPU_INTERRUPT_NUMBER_OF_VECTORS     256

#define CPU_INTERRUPT_MAXIMUM_VECTOR_NUMBER 511

#define SPARC_SYNCHRONOUS_TRAP_BIT_MASK     0x100

#define SPARC_ASYNCHRONOUS_TRAP( _trap )    (_trap)

#define SPARC_SYNCHRONOUS_TRAP( _trap )     ((_trap) + 256 )

#define SPARC_REAL_TRAP_NUMBER( _trap )     ((_trap) % 256)

#define CPU_PROVIDES_ISR_IS_IN_PROGRESS FALSE

#define CPU_STACK_MINIMUM_SIZE  (1024*4)

#define CPU_SIZEOF_POINTER 4

#define CPU_ALIGNMENT      8

#define CPU_HEAP_ALIGNMENT         CPU_ALIGNMENT

#define CPU_STACK_ALIGNMENT CPU_ALIGNMENT

#define CPU_INTERRUPT_STACK_ALIGNMENT CPU_CACHE_LINE_BYTES

#ifndef ASM

/*
 *  ISR handler macros
 */

#define _CPU_Initialize_vectors()

#define _CPU_ISR_Disable( _level ) \
  (_level) = sparc_disable_interrupts()

#define _CPU_ISR_Enable( _level ) \
  sparc_enable_interrupts( _level )

#define _CPU_ISR_Flash( _level ) \
  sparc_flash_interrupts( _level )

#define _CPU_ISR_Is_enabled( _isr_cookie ) \
  sparc_interrupt_is_enabled( _isr_cookie )

RTEMS_INLINE_ROUTINE bool _CPU_ISR_Is_enabled( uint32_t level )
{
  return ( level & SPARC_PSR_PIL_MASK ) == 0;
}

#define _CPU_ISR_Set_level( _newlevel ) \
   sparc_enable_interrupts( _newlevel << 8)

uint32_t   _CPU_ISR_Get_level( void );

/* end of ISR handler macros */

/* Context handler macros */

void _CPU_Context_Initialize(
  Context_Control  *the_context,
  uint32_t         *stack_base,
  uint32_t          size,
  uint32_t          new_level,
  void             *entry_point,
  bool              is_fp,
  void             *tls_area
);

#define _CPU_Context_Initialization_at_thread_begin() \
  do { \
    __asm__ volatile ("set _Thread_Handler,%%i7\n"::); \
  } while (0)

#define _CPU_Context_Restart_self( _the_context ) \
   _CPU_Context_restore( (_the_context) );

#define _CPU_Context_Initialize_fp( _destination ) \
  do { } while ( 0 )

#define _CPU_Context_save_fp( _fp_context_ptr ) \
  do { } while ( 0 )

#define _CPU_Context_restore_fp( _fp_context_ptr ) \
  do { } while ( 0 )
/* end of Context handler macros */

/* Fatal Error manager macros */

extern void _CPU_Fatal_halt(uint32_t source, uint32_t error)
  RTEMS_NO_RETURN;

/* end of Fatal Error manager macros */

/* Bitfield handler macros */

#if ( SPARC_HAS_BITSCAN == 0 )

  #define CPU_USE_GENERIC_BITFIELD_CODE TRUE
#else
  #error "scan instruction not currently supported by RTEMS!!"
#endif

/* end of Bitfield handler macros */

/* functions */

void _CPU_Initialize(void);

typedef void ( *CPU_ISR_raw_handler )( void );

void _CPU_ISR_install_raw_handler(
  uint32_t             vector,
  CPU_ISR_raw_handler  new_handler,
  CPU_ISR_raw_handler *old_handler
);

typedef void ( *CPU_ISR_handler )( uint32_t );

void _CPU_ISR_install_vector(
  uint32_t         vector,
  CPU_ISR_handler  new_handler,
  CPU_ISR_handler *old_handler
);

void *_CPU_Thread_Idle_body( uintptr_t ignored );

void _CPU_Context_switch(
  Context_Control  *run,
  Context_Control  *heir
);

void _CPU_Context_restore(
  Context_Control *new_context
) RTEMS_NO_RETURN;

#if defined(RTEMS_SMP)
  uint32_t _CPU_SMP_Initialize( void );

  bool _CPU_SMP_Start_processor( uint32_t cpu_index );

  void _CPU_SMP_Finalize_initialization( uint32_t cpu_count );

  void _CPU_SMP_Prepare_start_multitasking( void );

  #if defined(__leon__) && !defined(RTEMS_PARAVIRT)
    static inline uint32_t _CPU_SMP_Get_current_processor( void )
    {
      return _LEON3_Get_current_processor();
    }
  #else
    uint32_t _CPU_SMP_Get_current_processor( void );
  #endif

  void _CPU_SMP_Send_interrupt( uint32_t target_processor_index );

  static inline void _CPU_SMP_Processor_event_broadcast( void )
  {
    __asm__ volatile ( "" : : : "memory" );
  }

  static inline void _CPU_SMP_Processor_event_receive( void )
  {
    __asm__ volatile ( "" : : : "memory" );
  }
#endif

#if defined(SPARC_USE_LAZY_FP_SWITCH)
#define _CPU_Context_Destroy( _the_thread, _the_context ) \
  do { \
    Per_CPU_Control *cpu_self = _Per_CPU_Get(); \
    Thread_Control *_fp_owner = cpu_self->cpu_per_cpu.fp_owner; \
    if ( _fp_owner == _the_thread ) { \
      cpu_self->cpu_per_cpu.fp_owner = NULL; \
    } \
  } while ( 0 )
#endif

typedef struct {
  uint32_t trap;
  CPU_Interrupt_frame *isf;
} CPU_Exception_frame;

void _CPU_Exception_frame_print( const CPU_Exception_frame *frame );

static inline uint32_t CPU_swap_u32(
  uint32_t value
)
{
  uint32_t   byte1, byte2, byte3, byte4, swapped;

  byte4 = (value >> 24) & 0xff;
  byte3 = (value >> 16) & 0xff;
  byte2 = (value >> 8)  & 0xff;
  byte1 =  value        & 0xff;

  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
  return( swapped );
}

#define CPU_swap_u16( value ) \
  (((value&0xff) << 8) | ((value >> 8)&0xff))

typedef uint32_t CPU_Counter_ticks;

uint32_t _CPU_Counter_frequency( void );

typedef CPU_Counter_ticks ( *SPARC_Counter_read )( void );

/*
 * The SPARC processors supported by RTEMS have no built-in CPU counter
 * support.  We have to use some hardware counter module for this purpose, for
 * example the GPTIMER instance used by the clock driver.  The BSP must provide
 * an implementation of the CPU counter read function.  This allows the use of
 * dynamic hardware enumeration.
 */
typedef struct {
  SPARC_Counter_read                read_isr_disabled;
  SPARC_Counter_read                read;
  volatile const CPU_Counter_ticks *counter_register;
  volatile const uint32_t          *pending_register;
  uint32_t                          pending_mask;
  CPU_Counter_ticks                 accumulated;
  CPU_Counter_ticks                 interval;
} SPARC_Counter;

extern const SPARC_Counter _SPARC_Counter;

static inline CPU_Counter_ticks _CPU_Counter_read( void )
{
  return ( *_SPARC_Counter.read )();
}

static inline CPU_Counter_ticks _CPU_Counter_difference(
  CPU_Counter_ticks second,
  CPU_Counter_ticks first
)
{
  return second - first;
}

typedef uintptr_t CPU_Uint32ptr;

#endif /* ASM */

#ifdef __cplusplus
}
#endif

#endif