em_ebi.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_EBI_H
#define EM_EBI_H

#include "em_device.h"
#if defined(EBI_COUNT) && (EBI_COUNT > 0)

#include <stdint.h>
#include <stdbool.h>
#include "em_assert.h"

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************/
/***************************************************************************/
/***************************************************************************/
/*******************************************************************************
 *******************************   DEFINES   ***********************************
 ******************************************************************************/

#define EBI_BANK0    (uint32_t)(1 << 1) 
#define EBI_BANK1    (uint32_t)(1 << 2) 
#define EBI_BANK2    (uint32_t)(1 << 3) 
#define EBI_BANK3    (uint32_t)(1 << 4) 
#define EBI_CS0      (uint32_t)(1 << 1) 
#define EBI_CS1      (uint32_t)(1 << 2) 
#define EBI_CS2      (uint32_t)(1 << 3) 
#define EBI_CS3      (uint32_t)(1 << 4) 
/*******************************************************************************
 ********************************   ENUMS   ************************************
 ******************************************************************************/

typedef enum
{
  ebiModeD8A8      = EBI_CTRL_MODE_D8A8,
  ebiModeD16A16ALE = EBI_CTRL_MODE_D16A16ALE,
  ebiModeD8A24ALE  = EBI_CTRL_MODE_D8A24ALE,
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

  ebiModeD16       = EBI_CTRL_MODE_D16,
#endif
} EBI_Mode_TypeDef;

typedef enum
{
  ebiActiveLow  = 0,
  ebiActiveHigh = 1
} EBI_Polarity_TypeDef;

typedef enum
{
  ebiLineARDY,
  ebiLineALE,
  ebiLineWE,
  ebiLineRE,
  ebiLineCS,
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

  ebiLineBL,
#endif
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

  ebiLineTFTVSync,
  ebiLineTFTHSync,
  ebiLineTFTDataEn,
  ebiLineTFTDClk,
  ebiLineTFTCS,
#endif
} EBI_Line_TypeDef;

#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

typedef enum
{
  ebiALowA0 = EBI_ROUTE_ALB_A0,
  ebiALowA8 = EBI_ROUTE_ALB_A8,
  ebiALowA16 = EBI_ROUTE_ALB_A16,
  ebiALowA24 = EBI_ROUTE_ALB_A24,
} EBI_ALow_TypeDef;

typedef enum
{
  ebiAHighA0 = EBI_ROUTE_APEN_A0,
  ebiAHighA5 = EBI_ROUTE_APEN_A5,
  ebiAHighA6 = EBI_ROUTE_APEN_A6,
  ebiAHighA7 = EBI_ROUTE_APEN_A7,
  ebiAHighA8 = EBI_ROUTE_APEN_A8,
  ebiAHighA9 = EBI_ROUTE_APEN_A9,
  ebiAHighA10 = EBI_ROUTE_APEN_A10,
  ebiAHighA11 = EBI_ROUTE_APEN_A11,
  ebiAHighA12 = EBI_ROUTE_APEN_A12,
  ebiAHighA13 = EBI_ROUTE_APEN_A13,
  ebiAHighA14 = EBI_ROUTE_APEN_A14,
  ebiAHighA15 = EBI_ROUTE_APEN_A15,
  ebiAHighA16 = EBI_ROUTE_APEN_A16,
  ebiAHighA17 = EBI_ROUTE_APEN_A17,
  ebiAHighA18 = EBI_ROUTE_APEN_A18,
  ebiAHighA19 = EBI_ROUTE_APEN_A19,
  ebiAHighA20 = EBI_ROUTE_APEN_A20,
  ebiAHighA21 = EBI_ROUTE_APEN_A21,
  ebiAHighA22 = EBI_ROUTE_APEN_A22,
  ebiAHighA23 = EBI_ROUTE_APEN_A23,
  ebiAHighA24 = EBI_ROUTE_APEN_A24,
  ebiAHighA25 = EBI_ROUTE_APEN_A25,
  ebiAHighA26 = EBI_ROUTE_APEN_A26,
  ebiAHighA27 = EBI_ROUTE_APEN_A27,
  ebiAHighA28 = EBI_ROUTE_APEN_A28,
} EBI_AHigh_TypeDef;

typedef enum {
  ebiLocation0 = EBI_ROUTE_LOCATION_LOC0,
  ebiLocation1 = EBI_ROUTE_LOCATION_LOC1,
  ebiLocation2 = EBI_ROUTE_LOCATION_LOC2
} EBI_Location_TypeDef;
#endif

/* TFT support */
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

typedef enum
{
  ebiTFTBank0 = EBI_TFTCTRL_BANKSEL_BANK0,
  ebiTFTBank1 = EBI_TFTCTRL_BANKSEL_BANK1,
  ebiTFTBank2 = EBI_TFTCTRL_BANKSEL_BANK2,
  ebiTFTBank3 = EBI_TFTCTRL_BANKSEL_BANK3
} EBI_TFTBank_TypeDef;

typedef enum
{
  ebiTFTColorSrcMem    = EBI_TFTCTRL_COLOR1SRC_MEM,
  ebiTFTColorSrcPixel1 = EBI_TFTCTRL_COLOR1SRC_PIXEL1,
} EBI_TFTColorSrc_TypeDef;

typedef enum
{
  ebiTFTInterleaveUnlimited  = EBI_TFTCTRL_INTERLEAVE_UNLIMITED,
  ebiTFTInterleaveOnePerDClk = EBI_TFTCTRL_INTERLEAVE_ONEPERDCLK,
  ebiTFTInterleavePorch      = EBI_TFTCTRL_INTERLEAVE_PORCH,
} EBI_TFTInterleave_TypeDef;

typedef enum
{
  ebiTFTFrameBufTriggerVSync = EBI_TFTCTRL_FBCTRIG_VSYNC,
  ebiTFTFrameBufTriggerHSync = EBI_TFTCTRL_FBCTRIG_HSYNC,
} EBI_TFTFrameBufTrigger_TypeDef;

typedef enum
{
  ebiTFTMBDisabled   = EBI_TFTCTRL_MASKBLEND_DISABLED,
  ebiTFTMBIMask      = EBI_TFTCTRL_MASKBLEND_IMASK,
  ebiTFTMBIAlpha     = EBI_TFTCTRL_MASKBLEND_IALPHA,
  ebiTFTMBIMaskAlpha = EBI_TFTCTRL_MASKBLEND_IMASKIALPHA,
  ebiTFTMBEMask      = EBI_TFTCTRL_MASKBLEND_EMASK,
  ebiTFTMBEAlpha     = EBI_TFTCTRL_MASKBLEND_EALPHA,
  ebiTFTMBEMaskAlpha = EBI_TFTCTRL_MASKBLEND_EMASKEALPHA,
} EBI_TFTMaskBlend_TypeDef;

typedef enum
{
  ebiTFTDDModeDisabled = EBI_TFTCTRL_DD_DISABLED,
  ebiTFTDDModeInternal = EBI_TFTCTRL_DD_INTERNAL,
  ebiTFTDDModeExternal = EBI_TFTCTRL_DD_EXTERNAL,
} EBI_TFTDDMode_TypeDef;

typedef enum
{
  ebiTFTWidthByte = EBI_TFTCTRL_WIDTH_BYTE,
  ebiTFTWidthHalfWord = EBI_TFTCTRL_WIDTH_HALFWORD,
} EBI_TFTWidth_TypeDef;

#endif

/*******************************************************************************
 *******************************   STRUCTS   ***********************************
 ******************************************************************************/

typedef struct
{
  EBI_Mode_TypeDef     mode;
  EBI_Polarity_TypeDef ardyPolarity;
  EBI_Polarity_TypeDef alePolarity;
  EBI_Polarity_TypeDef wePolarity;
  EBI_Polarity_TypeDef rePolarity;
  EBI_Polarity_TypeDef csPolarity;
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

  EBI_Polarity_TypeDef blPolarity;
  bool                 blEnable;
  bool                 noIdle;
#endif

  bool                 ardyEnable;
  bool                 ardyDisableTimeout;
  uint32_t             banks;
  uint32_t             csLines;
  int                  addrSetupCycles;
  int                  addrHoldCycles;
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

  bool                 addrHalfALE;
#endif

  int                  readSetupCycles;
  int                  readStrobeCycles;
  int                  readHoldCycles;
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

  bool                 readPageMode;
  bool                 readPrefetch;
  bool                 readHalfRE;
#endif

  int                  writeSetupCycles;
  int                  writeStrobeCycles;
  int                  writeHoldCycles;
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

  bool                 writeBufferDisable;
  bool                 writeHalfWE;
  EBI_ALow_TypeDef     aLow;
  EBI_AHigh_TypeDef    aHigh;
  EBI_Location_TypeDef location;
#endif

  bool                 enable;
} EBI_Init_TypeDef;

#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
#define EBI_INIT_DEFAULT                                      \
{                                                             \
  ebiModeD8A8,      /* 8 bit address, 8 bit data */           \
  ebiActiveLow,     /* ARDY polarity */                       \
  ebiActiveLow,     /* ALE polarity */                        \
  ebiActiveLow,     /* WE polarity */                         \
  ebiActiveLow,     /* RE polarity */                         \
  ebiActiveLow,     /* CS polarity */                         \
  ebiActiveLow,     /* BL polarity */                         \
  false,            /* enable BL */                           \
  false,            /* enable NOIDLE */                       \
  false,            /* enable ARDY */                         \
  false,            /* don't disable ARDY timeout */          \
  EBI_BANK0,        /* enable bank 0 */                       \
  EBI_CS0,          /* enable chip select 0 */                \
  0,                /* addr setup cycles */                   \
  1,                /* addr hold cycles */                    \
  false,            /* do not enable half cycle ALE strobe */ \
  0,                /* read setup cycles */                   \
  0,                /* read strobe cycles */                  \
  0,                /* read hold cycles */                    \
  false,            /* disable page mode */                   \
  false,            /* disable prefetch */                    \
  false,            /* do not enable half cycle REn strobe */ \
  0,                /* write setup cycles */                  \
  0,                /* write strobe cycles */                 \
  1,                /* write hold cycles */                   \
  false,            /* do not disable the write buffer */     \
  false,            /* do not enable halc cycle WEn strobe */ \
  ebiALowA0,        /* ALB - Low bound, address lines */      \
  ebiAHighA0,       /* APEN - High bound, address lines */    \
  ebiLocation0,     /* Use Location 0 */                      \
  true,             /* enable EBI */                          \
}
#else
#define EBI_INIT_DEFAULT                               \
{                                                      \
  ebiModeD8A8,        /* 8 bit address, 8 bit data */  \
  ebiActiveLow,       /* ARDY polarity */              \
  ebiActiveLow,       /* ALE polarity */               \
  ebiActiveLow,       /* WE polarity */                \
  ebiActiveLow,       /* RE polarity */                \
  ebiActiveLow,       /* CS polarity */                \
  false,              /* enable ARDY */                \
  false,              /* don't disable ARDY timeout */ \
  EBI_BANK0,          /* enable bank 0 */              \
  EBI_CS0,            /* enable chip select 0 */       \
  0,                  /* addr setup cycles */          \
  1,                  /* addr hold cycles */           \
  0,                  /* read setup cycles */          \
  0,                  /* read strobe cycles */         \
  0,                  /* read hold cycles */           \
  0,                  /* write setup cycles */         \
  0,                  /* write strobe cycles */        \
  1,                  /* write hold cycles */          \
  true,               /* enable EBI */                 \
}
#endif

#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)

typedef struct
{
  EBI_TFTBank_TypeDef            bank;
  EBI_TFTWidth_TypeDef           width;
  EBI_TFTColorSrc_TypeDef        colSrc;
  EBI_TFTInterleave_TypeDef      interleave;
  EBI_TFTFrameBufTrigger_TypeDef fbTrigger;
  bool                           shiftDClk;
  EBI_TFTMaskBlend_TypeDef       maskBlend;
  EBI_TFTDDMode_TypeDef          driveMode;
  EBI_Polarity_TypeDef           csPolarity;
  EBI_Polarity_TypeDef           dclkPolarity;
  EBI_Polarity_TypeDef           dataenPolarity;
  EBI_Polarity_TypeDef           hsyncPolarity;
  EBI_Polarity_TypeDef           vsyncPolarity;
  int                            hsize;
  int                            hPorchFront;
  int                            hPorchBack;
  int                            hPulseWidth;
  int                            vsize;
  int                            vPorchFront;
  int                            vPorchBack;
  int                            vPulseWidth;
  uint32_t                       addressOffset;
  int                            dclkPeriod;
  int                            startPosition;
  int                            setupCycles;
  int                            holdCycles;
} EBI_TFTInit_TypeDef;

#define EBI_TFTINIT_DEFAULT                                                         \
{                                                                                   \
  ebiTFTBank0,                /* Select EBI Bank 0 */                               \
  ebiTFTWidthHalfWord,        /* Select 2-byte increments */                        \
  ebiTFTColorSrcMem,          /* Use memory as source for mask/blending */          \
  ebiTFTInterleaveUnlimited,  /* Unlimited interleaved accesses */                  \
  ebiTFTFrameBufTriggerVSync, /* VSYNC as frame buffer update trigger */            \
  false,                      /* Drive DCLK from negative edge of internal clock */ \
  ebiTFTMBDisabled,           /* No masking and alpha blending enabled */           \
  ebiTFTDDModeExternal,       /* Drive from external memory */                      \
  ebiActiveLow,               /* CS Active Low polarity */                          \
  ebiActiveLow,               /* DCLK Active Low polarity */                        \
  ebiActiveLow,               /* DATAEN Active Low polarity */                      \
  ebiActiveLow,               /* HSYNC Active Low polarity */                       \
  ebiActiveLow,               /* VSYNC Active Low polarity */                       \
  320,                        /* Horizontal size in pixels */                       \
  1,                          /* Horizontal Front Porch */                          \
  29,                         /* Horizontal Back Porch */                           \
  2,                          /* Horizontal Synchronization Pulse Width */          \
  240,                        /* Vertical size in pixels */                         \
  1,                          /* Vertical Front Porch */                            \
  4,                          /* Vertical Back Porch */                             \
  2,                          /* Vertical Synchronization Pulse Width */            \
  0x0000,                     /* Address offset to EBI memory base */               \
  5,                          /* DCLK Period */                                     \
  2,                          /* DCLK Start */                                      \
  1,                          /* DCLK Setup cycles */                               \
  1,                          /* DCLK Hold cycles */                                \
}

#endif
/*******************************************************************************
 *****************************   PROTOTYPES   **********************************
 ******************************************************************************/

void EBI_Init(const EBI_Init_TypeDef *ebiInit);
void EBI_Disable(void);
uint32_t EBI_BankAddress(uint32_t bank);
void EBI_BankEnable(uint32_t banks, bool enable);

#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
void EBI_TFTInit(const EBI_TFTInit_TypeDef *ebiTFTInit);
void EBI_TFTSizeSet(uint32_t horizontal, uint32_t vertical);
void EBI_TFTHPorchSet(int front, int back, int pulseWidth);
void EBI_TFTVPorchSet(int front, int back, int pulseWidth);
void EBI_TFTTimingSet(int dclkPeriod, int start, int setup, int hold);
#endif

#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
/* This functionality is only available on devices with independent timing support */
void EBI_BankReadTimingSet(uint32_t bank, int setupCycles, int strobeCycles, int holdCycles);
void EBI_BankReadTimingConfig(uint32_t bank, bool pageMode, bool prefetch, bool halfRE);

void EBI_BankWriteTimingSet(uint32_t bank, int setupCycles, int strobeCycles, int holdCycles);
void EBI_BankWriteTimingConfig(uint32_t bank, bool writeBufDisable, bool halfWE);

void EBI_BankAddressTimingSet(uint32_t bank, int setupCycles, int holdCycles);
void EBI_BankAddressTimingConfig(uint32_t bank, bool halfALE);

void EBI_BankPolaritySet(uint32_t bank, EBI_Line_TypeDef line, EBI_Polarity_TypeDef polarity);
void EBI_BankByteLaneEnable(uint32_t bank, bool enable);
void EBI_AltMapEnable(bool enable);

/***************************************************************************/
__STATIC_INLINE void EBI_TFTEnable(EBI_TFTDDMode_TypeDef mode)
{
  EBI->TFTCTRL = (EBI->TFTCTRL & ~(_EBI_TFTCTRL_DD_MASK)) | (uint32_t) mode;
}


/***************************************************************************/
__STATIC_INLINE void EBI_TFTFrameBaseSet(uint32_t address)
{
  EBI->TFTFRAMEBASE = (uint32_t) address;
}


/***************************************************************************/
__STATIC_INLINE void EBI_TFTPixelSet(int pixel, uint32_t color)
{
  EFM_ASSERT(pixel == 0 || pixel == 1);

  if (pixel == 0)
  {
    EBI->TFTPIXEL0 = color;
  }
  if (pixel == 1)
  {
    EBI->TFTPIXEL1 = color;
  }
}


/***************************************************************************/
__STATIC_INLINE void EBI_TFTMaskBlendMode(EBI_TFTMaskBlend_TypeDef maskBlend)
{
  EBI->TFTCTRL = (EBI->TFTCTRL & (~_EBI_TFTCTRL_MASKBLEND_MASK))|maskBlend;
}


/***************************************************************************/
__STATIC_INLINE void EBI_TFTAlphaBlendSet(uint8_t alpha)
{
  EBI->TFTALPHA = alpha;
}


/***************************************************************************/
__STATIC_INLINE void EBI_TFTMaskSet(uint32_t mask)
{
  EBI->TFTMASK = mask;
}


/***************************************************************************/
__STATIC_INLINE uint32_t EBI_TFTVCount(void)
{
  return((EBI->TFTSTATUS & _EBI_TFTSTATUS_VCNT_MASK) >> _EBI_TFTSTATUS_VCNT_SHIFT);
}


/***************************************************************************/
__STATIC_INLINE uint32_t EBI_TFTHCount(void)
{
  return((EBI->TFTSTATUS & _EBI_TFTSTATUS_HCNT_MASK) >> _EBI_TFTSTATUS_HCNT_SHIFT);
}


/***************************************************************************/
__STATIC_INLINE void EBI_TFTFBTriggerSet(EBI_TFTFrameBufTrigger_TypeDef sync)
{
  EBI->TFTCTRL = ((EBI->TFTCTRL & ~_EBI_TFTCTRL_FBCTRIG_MASK)|sync);
}


/***************************************************************************/
__STATIC_INLINE void EBI_TFTHStrideSet(uint32_t nbytes)
{
  EFM_ASSERT(nbytes < 0x1000);

  EBI->TFTSTRIDE = (EBI->TFTSTRIDE & ~(_EBI_TFTSTRIDE_HSTRIDE_MASK))|
    (nbytes<<_EBI_TFTSTRIDE_HSTRIDE_SHIFT);
}


/***************************************************************************/
__STATIC_INLINE void EBI_IntClear(uint32_t flags)
{
  EBI->IFC = flags;
}


/***************************************************************************/
__STATIC_INLINE void EBI_IntSet(uint32_t flags)
{
  EBI->IFS = flags;
}


/***************************************************************************/
__STATIC_INLINE void EBI_IntDisable(uint32_t flags)
{
  EBI->IEN &= ~(flags);
}


/***************************************************************************/
__STATIC_INLINE void EBI_IntEnable(uint32_t flags)
{
  EBI->IEN |= flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t EBI_IntGet(void)
{
  return EBI->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t EBI_IntGetEnabled(void)
{
  uint32_t ien;

  ien = EBI->IEN;
  return EBI->IF & ien;
}


/***************************************************************************/
__STATIC_INLINE void EBI_StartNandEccGen(void)
{
  EBI->CMD = EBI_CMD_ECCSTART | EBI_CMD_ECCCLEAR;
}


/***************************************************************************/
__STATIC_INLINE uint32_t EBI_StopNandEccGen( void )
{
  EBI->CMD = EBI_CMD_ECCSTOP;
  return EBI->ECCPARITY;
}
#endif

void EBI_ChipSelectEnable(uint32_t banks, bool enable);
void EBI_ReadTimingSet(int setupCycles, int strobeCycles, int holdCycles);
void EBI_WriteTimingSet(int setupCycles, int strobeCycles, int holdCycles);
void EBI_AddressTimingSet(int setupCycles, int holdCycles);
void EBI_PolaritySet(EBI_Line_TypeDef line, EBI_Polarity_TypeDef polarity);

#ifdef __cplusplus
}
#endif

#endif /* defined(EBI_COUNT) && (EBI_COUNT > 0) */

#endif /* EM_EBI_H */