verif_common.h

飞思卡尔imx27 wince5.0 bootloader源代码

#ifndef VERIF_COMMON_H
#define VERIF_COMMON_H

#ifndef DEVEL_DONE
#define DEVEL_DONE
#endif

#ifndef DEVEL_DONE
#include "hal_reg_if.h"
#endif

#define MINIMUM_AMOUNT(a,b) (((a) <= (b)) ? (a) : (b))

#ifdef __cplusplus
extern "C" {
#endif


/* -------------------------------------------------------------------------- */
/** @name Basic data types */
/*@{ BEGIN  ----------------------------------------------------------------- */

/** Datatype to be used for 8 bit accesses */
typedef  unsigned char  UINT08;

/** Datatype to be used for 16 bit accesses */
typedef  unsigned short  UINT16;

/** Datatype to be used for 32 bit accesses */
typedef  unsigned long  UINT32;


/** Datatype to be used to define the address of an 8 bit wide access */
typedef  volatile UINT08*  REG_ADDR08;

/** Datatype to be used to define the address of an 16 bit wide access */
typedef  volatile UINT16*  REG_ADDR16;

/** Datatype to be used to define the address of an 32 bit wide access */
typedef  volatile UINT32*  REG_ADDR32;

/*@} END -------------------------------------------------------------------- */


/* -------------------------------------------------------------------------- */
/** @name Register read/write functionality */
/*@{ BEGIN  ----------------------------------------------------------------- */

/** Macro/function to be used for reading an 8-bit register */
#ifdef DEVEL_DONE
#define  reg08read(addr)  (*((REG_ADDR08)(addr)))
#else
#define  reg08read(addr)  hal_reg8_read((REG_ADDR08)(addr))
#endif

/** Macro/function to be used for reading an 16-bit register */
#ifdef DEVEL_DONE
#define  reg16read(addr)  (*((REG_ADDR16)(addr)))
#else
#define  reg16read(addr)  hal_reg16_read((REG_ADDR16)(addr))
#endif

/** Macro/function to be used for reading an 32-bit register */
#ifdef DEVEL_DONE
#define  reg32read(addr)  (*((REG_ADDR32)(addr)))
#else
#define  reg32read(addr)  hal_reg32_read((REG_ADDR32)(addr))
#endif

/** Macro/function to be used for writing into a 8-bit register */
#ifdef DEVEL_DONE
#define  reg08write(addr,newvalue) \
         (*((REG_ADDR08)(addr)) = (newvalue))
#else
#define  reg08write(addr,newvalue) \
   hal_reg8_write(((REG_ADDR08)(addr)), (newvalue))
#endif

/** Macro/function to be used for writing into a 16-bit register */
#ifdef DEVEL_DONE
#define  reg16write(addr,newvalue) \
         (*((REG_ADDR16)(addr)) = (newvalue))
#else
#define  reg16write(addr,newvalue) \
   hal_reg16_write(((REG_ADDR16)(addr)),(newvalue))
#endif

/** Macro/function to be used for writing into a 32-bit register */
#ifdef DEVEL_DONE
#define  reg32write(addr,newvalue) \
         (*((REG_ADDR32)(addr)) = (newvalue))
#else
#define  reg32write(addr,newvalue) \
   hal_reg32_write(((REG_ADDR32)(addr)), (newvalue))
#endif

/*@} END -------------------------------------------------------------------- */


/* -------------------------------------------------------------------------- */
/** @name Set/clear bit functionality */
/*@{ BEGIN  ----------------------------------------------------------------- */

/** Macro to be used for setting a bit within a 32-bit register */
#define  reg32setb(addr,bitpos) \
         reg32write((addr),(reg32read((addr)) | (1<<(bitpos))))

/** Macro to be used for setting a bit within a 16-bit register */
#define  reg16setb(addr,bitpos) \
         reg16write((addr),(reg16read((addr)) | (1<<(bitpos))))

/** Macro to be used for setting a bit within a 8-bit register */
#define  reg08setb(addr,bitpos) \
         reg08write((addr),(reg16read((addr)) | (1<<(bitpos))))

/** Macro to be used for clearing a bit within a 32-bit register */
#define  reg32clrb(addr,bitpos) \
         reg32write((addr),(reg32read((addr)) & (0xFFFFFFFF ^ (1<<(bitpos)))))

/** Macro to be used for clearing a bit within a 16-bit register */
#define  reg16clrb(addr,bitpos) \
         reg16write((addr),(reg16read((addr)) & (0xFFFF ^ (1<<(bitpos)))))

/** Macro to be used for clearing a bit within a 8-bit register */
#define  reg08clrb(addr,bitpos) \
         reg08write((addr),(reg08read((addr)) & (0xFF ^ (1<<(bitpos)))))

/*@} END -------------------------------------------------------------------- */






/* -------------------------------------------------------------------------- */
/** @name CheckTest() support code 

   These macros and parameters are intended to make the usage of CheckTest()
    easier and more fail-safe.
    PutCheck08(addr, expvalue) - compare  8-bit at addr against expvalue
    PutCheck16(addr, expvalue) - compare 16-bit at addr against expvalue
    PutCheck32(addr, expvalue) - compare 32-bit at addr against expvalue
   An info trigger followed by an error porthole is used to signal an attempt
    to exceed the provided comparison arrays (search for pattern F0F0F0F0).
 */
/*@{ BEGIN  ----------------------------------------------------------------- */


/** Requests the validation of the given value against the given expected value.
    Comparison is made by CheckTest() upon terminating the test.
 */
#ifdef DEVEL_DONE
#define CheckValue(actvalue, expvalue) \
   act_data_array[fill_level] = (actvalue); \
   exp_data_array[fill_level++] = (expvalue);
#else
#define CheckValue(actvalue, expvalue) \
   if (fill_level < TEST_SIZE) \
   { \
      act_data_array[fill_level] = (actvalue); \
      exp_data_array[fill_level] = (expvalue); \
      fill_level++; \
   } \
   else \
   { \
	  test_exit(1);
   }
#endif


/** Requests the validation of the content of a 32 bit register against the
    given expected value. Comparison is made by CheckTest().
 */
#define PutCheck08(addr, expvalue) \
   CheckValue(reg08read(addr),(expvalue))

/** Requests the validation of the content of a 16 bit register against the
    given expected value. Comparison is made by CheckTest().
 */
#define PutCheck16(addr, expvalue) \
   CheckValue(reg16read(addr),(expvalue))

/** Requests the validation of the content of a 32 bit register against the
    given expected value. Comparison is made by CheckTest().
 */
#define PutCheck32(addr, expvalue) \
   CheckValue(reg32read(addr),(expvalue))


/*@} END -------------------------------------------------------------------- */


/** Only use when intended to use the user event #16 for checkpoint purposes
 */
//#define NextCheckPoint verilog_trigger(arm_vt_event16)



//void COUNT_LOOP( int CountValue )
//{
 //  int TempCountValue;

  // for (TempCountValue = CountValue+1; TempCountValue > 0; TempCountValue--)
   //   ; /* intentionally empty -- this is a simple count loop */
//}


#ifdef __cplusplus
} /*extern "C" */
#endif

#endif /* #ifndef VERIF_COMMON_H */