The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.
Dependents: hello SerialTestv11 SerialTestv12 Sierpinski ... more
mbed 2
This is the mbed 2 library. If you'd like to learn about Mbed OS please see the mbed-os docs.
Diff: TARGET_EFM32HG_STK3400/TOOLCHAIN_GCC_ARM/em_ebi.h
- Revision:
- 171:3a7713b1edbc
- Parent:
- 160:5571c4ff569f
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TARGET_EFM32HG_STK3400/TOOLCHAIN_GCC_ARM/em_ebi.h Thu Nov 08 11:45:42 2018 +0000 @@ -0,0 +1,931 @@ +/***************************************************************************//** + * @file em_ebi.h + * @brief External Bus Iterface (EBI) peripheral API + * @version 5.3.3 + ******************************************************************************* + * # License + * <b>Copyright 2016 Silicon Laboratories, Inc. http://www.silabs.com</b> + ******************************************************************************* + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + * DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no + * obligation to support this Software. Silicon Labs is providing the + * Software "AS IS", with no express or implied warranties of any kind, + * including, but not limited to, any implied warranties of merchantability + * or fitness for any particular purpose or warranties against infringement + * of any proprietary rights of a third party. + * + * Silicon Labs will not be liable for any consequential, incidental, or + * special damages, or any other relief, or for any claim by any third party, + * arising from your use of this Software. + * + ******************************************************************************/ + +#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 + +/***************************************************************************//** + * @addtogroup emlib + * @{ + ******************************************************************************/ + +/***************************************************************************//** + * @addtogroup EBI + * @{ + ******************************************************************************/ + +/***************************************************************************//** + * @verbatim + * + * --------- --------- + * | | /| |\ | Ext. | + * | EBI | / --------- \ | Async | + * | | \ --------- / | Device| + * | | \| |/ | | + * --------- --------- + * Parallel interface + * + * @endverbatim + ******************************************************************************/ + +/******************************************************************************* + ******************************* DEFINES *********************************** + ******************************************************************************/ + +#define EBI_BANK0 (uint32_t)(1 << 1) /**< EBI address bank 0 */ +#define EBI_BANK1 (uint32_t)(1 << 2) /**< EBI address bank 1 */ +#define EBI_BANK2 (uint32_t)(1 << 3) /**< EBI address bank 2 */ +#define EBI_BANK3 (uint32_t)(1 << 4) /**< EBI address bank 3 */ + +#define EBI_CS0 (uint32_t)(1 << 1) /**< EBI chip select line 0 */ +#define EBI_CS1 (uint32_t)(1 << 2) /**< EBI chip select line 1 */ +#define EBI_CS2 (uint32_t)(1 << 3) /**< EBI chip select line 2 */ +#define EBI_CS3 (uint32_t)(1 << 4) /**< EBI chip select line 3 */ + +#if defined(_EBI_ROUTE_MASK) && defined(_EBI_ROUTE_APEN_MASK) +#define EBI_GENERIC_ALB_A0 EBI_ROUTE_ALB_A0 +#define EBI_GENERIC_ALB_A8 EBI_ROUTE_ALB_A8 +#define EBI_GENERIC_ALB_A16 EBI_ROUTE_ALB_A16 +#define EBI_GENERIC_ALB_A24 EBI_ROUTE_ALB_A24 +#define EBI_GENERIC_APEN_A0 EBI_ROUTE_APEN_A0 +#define EBI_GENERIC_APEN_A5 EBI_ROUTE_APEN_A5 +#define EBI_GENERIC_APEN_A6 EBI_ROUTE_APEN_A6 +#define EBI_GENERIC_APEN_A7 EBI_ROUTE_APEN_A7 +#define EBI_GENERIC_APEN_A8 EBI_ROUTE_APEN_A8 +#define EBI_GENERIC_APEN_A9 EBI_ROUTE_APEN_A9 +#define EBI_GENERIC_APEN_A10 EBI_ROUTE_APEN_A10 +#define EBI_GENERIC_APEN_A11 EBI_ROUTE_APEN_A11 +#define EBI_GENERIC_APEN_A12 EBI_ROUTE_APEN_A12 +#define EBI_GENERIC_APEN_A13 EBI_ROUTE_APEN_A13 +#define EBI_GENERIC_APEN_A14 EBI_ROUTE_APEN_A14 +#define EBI_GENERIC_APEN_A15 EBI_ROUTE_APEN_A15 +#define EBI_GENERIC_APEN_A16 EBI_ROUTE_APEN_A16 +#define EBI_GENERIC_APEN_A17 EBI_ROUTE_APEN_A17 +#define EBI_GENERIC_APEN_A18 EBI_ROUTE_APEN_A18 +#define EBI_GENERIC_APEN_A19 EBI_ROUTE_APEN_A19 +#define EBI_GENERIC_APEN_A20 EBI_ROUTE_APEN_A20 +#define EBI_GENERIC_APEN_A21 EBI_ROUTE_APEN_A21 +#define EBI_GENERIC_APEN_A22 EBI_ROUTE_APEN_A22 +#define EBI_GENERIC_APEN_A23 EBI_ROUTE_APEN_A23 +#define EBI_GENERIC_APEN_A24 EBI_ROUTE_APEN_A24 +#define EBI_GENERIC_APEN_A25 EBI_ROUTE_APEN_A25 +#define EBI_GENERIC_APEN_A26 EBI_ROUTE_APEN_A26 +#define EBI_GENERIC_APEN_A27 EBI_ROUTE_APEN_A27 +#define EBI_GENERIC_APEN_A28 EBI_ROUTE_APEN_A28 +#elif defined(_EBI_ROUTEPEN_MASK) +#define EBI_GENERIC_ALB_A0 EBI_ROUTEPEN_ALB_A0 +#define EBI_GENERIC_ALB_A8 EBI_ROUTEPEN_ALB_A8 +#define EBI_GENERIC_ALB_A16 EBI_ROUTEPEN_ALB_A16 +#define EBI_GENERIC_ALB_A24 EBI_ROUTEPEN_ALB_A24 +#define EBI_GENERIC_APEN_A0 EBI_ROUTEPEN_APEN_A0 +#define EBI_GENERIC_APEN_A5 EBI_ROUTEPEN_APEN_A5 +#define EBI_GENERIC_APEN_A6 EBI_ROUTEPEN_APEN_A6 +#define EBI_GENERIC_APEN_A7 EBI_ROUTEPEN_APEN_A7 +#define EBI_GENERIC_APEN_A8 EBI_ROUTEPEN_APEN_A8 +#define EBI_GENERIC_APEN_A9 EBI_ROUTEPEN_APEN_A9 +#define EBI_GENERIC_APEN_A10 EBI_ROUTEPEN_APEN_A10 +#define EBI_GENERIC_APEN_A11 EBI_ROUTEPEN_APEN_A11 +#define EBI_GENERIC_APEN_A12 EBI_ROUTEPEN_APEN_A12 +#define EBI_GENERIC_APEN_A13 EBI_ROUTEPEN_APEN_A13 +#define EBI_GENERIC_APEN_A14 EBI_ROUTEPEN_APEN_A14 +#define EBI_GENERIC_APEN_A15 EBI_ROUTEPEN_APEN_A15 +#define EBI_GENERIC_APEN_A16 EBI_ROUTEPEN_APEN_A16 +#define EBI_GENERIC_APEN_A17 EBI_ROUTEPEN_APEN_A17 +#define EBI_GENERIC_APEN_A18 EBI_ROUTEPEN_APEN_A18 +#define EBI_GENERIC_APEN_A19 EBI_ROUTEPEN_APEN_A19 +#define EBI_GENERIC_APEN_A20 EBI_ROUTEPEN_APEN_A20 +#define EBI_GENERIC_APEN_A21 EBI_ROUTEPEN_APEN_A21 +#define EBI_GENERIC_APEN_A22 EBI_ROUTEPEN_APEN_A22 +#define EBI_GENERIC_APEN_A23 EBI_ROUTEPEN_APEN_A23 +#define EBI_GENERIC_APEN_A24 EBI_ROUTEPEN_APEN_A24 +#define EBI_GENERIC_APEN_A25 EBI_ROUTEPEN_APEN_A25 +#define EBI_GENERIC_APEN_A26 EBI_ROUTEPEN_APEN_A26 +#define EBI_GENERIC_APEN_A27 EBI_ROUTEPEN_APEN_A27 +#define EBI_GENERIC_APEN_A28 EBI_ROUTEPEN_APEN_A28 +#endif + +/******************************************************************************* + ******************************** ENUMS ************************************ + ******************************************************************************/ + +/** EBI Mode of operation */ +typedef enum { + /** 8 data bits, 8 address bits */ + ebiModeD8A8 = EBI_CTRL_MODE_D8A8, + /** 16 data bits, 16 address bits, using address latch enable */ + ebiModeD16A16ALE = EBI_CTRL_MODE_D16A16ALE, + /** 8 data bits, 24 address bits, using address latch enable */ + ebiModeD8A24ALE = EBI_CTRL_MODE_D8A24ALE, +#if defined(EBI_CTRL_MODE_D16) + /** Mode D16 */ + ebiModeD16 = EBI_CTRL_MODE_D16, +#endif +} EBI_Mode_TypeDef; + +/** EBI Polarity configuration */ +typedef enum { + /** Active Low */ + ebiActiveLow = 0, + /** Active High */ + ebiActiveHigh = 1 +} EBI_Polarity_TypeDef; + +/** EBI Pin Line types */ +typedef enum { + /** Address Ready line */ + ebiLineARDY, + /** Address Latch Enable line */ + ebiLineALE, + /** Write Enable line */ + ebiLineWE, + /** Read Enable line */ + ebiLineRE, + /** Chip Select line */ + ebiLineCS, +#if defined(_EBI_POLARITY_BLPOL_MASK) + /** BL line */ + ebiLineBL, +#endif +#if defined(_EBI_TFTPOLARITY_MASK) + /** TFT VSYNC line */ + ebiLineTFTVSync, + /** TFT HSYNC line */ + ebiLineTFTHSync, + /** TFT Data enable line */ + ebiLineTFTDataEn, + /** TFT DCLK line */ + ebiLineTFTDClk, + /** TFT Chip select line */ + ebiLineTFTCS, +#endif +} EBI_Line_TypeDef; + +#if !defined(_EFM32_GECKO_FAMILY) +/** Address Pin Enable, lower limit - lower range of pins to enable */ +typedef enum { + /** Adress lines EBI_A[0] and upwards are enabled by APEN */ + ebiALowA0 = EBI_GENERIC_ALB_A0, + /** Adress lines EBI_A[8] and upwards are enabled by APEN */ + ebiALowA8 = EBI_GENERIC_ALB_A8, + /** Adress lines EBI_A[16] and upwards are enabled by APEN */ + ebiALowA16 = EBI_GENERIC_ALB_A16, + /** Adress lines EBI_A[24] and upwards are enabled by APEN */ + ebiALowA24 = EBI_GENERIC_ALB_A24, +} EBI_ALow_TypeDef; + +/** Adress Pin Enable, high limit - higher limit of pins to enable */ +typedef enum { + /** All EBI_A pins are disabled */ + ebiAHighA0 = EBI_GENERIC_APEN_A0, + /** All EBI_A[4:ALow] are enabled */ + ebiAHighA5 = EBI_GENERIC_APEN_A5, + /** All EBI_A[5:ALow] are enabled */ + ebiAHighA6 = EBI_GENERIC_APEN_A6, + /** All EBI_A[6:ALow] are enabled */ + ebiAHighA7 = EBI_GENERIC_APEN_A7, + /** All EBI_A[7:ALow] are enabled */ + ebiAHighA8 = EBI_GENERIC_APEN_A8, + /** All EBI_A[8:ALow] are enabled */ + ebiAHighA9 = EBI_GENERIC_APEN_A9, + /** All EBI_A[9:ALow] are enabled */ + ebiAHighA10 = EBI_GENERIC_APEN_A10, + /** All EBI_A[10:ALow] are enabled */ + ebiAHighA11 = EBI_GENERIC_APEN_A11, + /** All EBI_A[11:ALow] are enabled */ + ebiAHighA12 = EBI_GENERIC_APEN_A12, + /** All EBI_A[12:ALow] are enabled */ + ebiAHighA13 = EBI_GENERIC_APEN_A13, + /** All EBI_A[13:ALow] are enabled */ + ebiAHighA14 = EBI_GENERIC_APEN_A14, + /** All EBI_A[14:ALow] are enabled */ + ebiAHighA15 = EBI_GENERIC_APEN_A15, + /** All EBI_A[15:ALow] are enabled */ + ebiAHighA16 = EBI_GENERIC_APEN_A16, + /** All EBI_A[16:ALow] are enabled */ + ebiAHighA17 = EBI_GENERIC_APEN_A17, + /** All EBI_A[17:ALow] are enabled */ + ebiAHighA18 = EBI_GENERIC_APEN_A18, + /** All EBI_A[18:ALow] are enabled */ + ebiAHighA19 = EBI_GENERIC_APEN_A19, + /** All EBI_A[19:ALow] are enabled */ + ebiAHighA20 = EBI_GENERIC_APEN_A20, + /** All EBI_A[20:ALow] are enabled */ + ebiAHighA21 = EBI_GENERIC_APEN_A21, + /** All EBI_A[21:ALow] are enabled */ + ebiAHighA22 = EBI_GENERIC_APEN_A22, + /** All EBI_A[22:ALow] are enabled */ + ebiAHighA23 = EBI_GENERIC_APEN_A23, + /** All EBI_A[23:ALow] are enabled */ + ebiAHighA24 = EBI_GENERIC_APEN_A24, + /** All EBI_A[24:ALow] are enabled */ + ebiAHighA25 = EBI_GENERIC_APEN_A25, + /** All EBI_A[25:ALow] are enabled */ + ebiAHighA26 = EBI_GENERIC_APEN_A26, + /** All EBI_A[26:ALow] are enabled */ + ebiAHighA27 = EBI_GENERIC_APEN_A27, + /** All EBI_A[27:ALow] are enabled */ + ebiAHighA28 = EBI_GENERIC_APEN_A28, +} EBI_AHigh_TypeDef; +#endif + +#if defined(_EBI_ROUTE_LOCATION_MASK) +/** EBI I/O Alternate Pin Location */ +typedef enum { + /** EBI PIN I/O Location 0 */ + ebiLocation0 = EBI_ROUTE_LOCATION_LOC0, + /** EBI PIN I/O Location 1 */ + ebiLocation1 = EBI_ROUTE_LOCATION_LOC1, + /** EBI PIN I/O Location 2 */ + ebiLocation2 = EBI_ROUTE_LOCATION_LOC2 +} EBI_Location_TypeDef; +#endif + +#if defined(_EBI_TFTCTRL_MASK) +/* TFT support */ + +/** EBI TFT Graphics Bank Select */ +typedef enum { + /** Memory BANK0 contains frame buffer */ + ebiTFTBank0 = EBI_TFTCTRL_BANKSEL_BANK0, + /** Memory BANK1 contains frame buffer */ + ebiTFTBank1 = EBI_TFTCTRL_BANKSEL_BANK1, + /** Memory BANK2 contains frame buffer */ + ebiTFTBank2 = EBI_TFTCTRL_BANKSEL_BANK2, + /** Memory BANK3 contains frame buffer */ + ebiTFTBank3 = EBI_TFTCTRL_BANKSEL_BANK3 +} EBI_TFTBank_TypeDef; + +/** Masking and Alpha blending source color*/ +typedef enum { + /** Use memory as source color for masking/alpha blending */ + ebiTFTColorSrcMem = EBI_TFTCTRL_COLOR1SRC_MEM, + /** Use PIXEL1 register as source color for masking/alpha blending */ + ebiTFTColorSrcPixel1 = EBI_TFTCTRL_COLOR1SRC_PIXEL1, +} EBI_TFTColorSrc_TypeDef; + +/** Bus Data Interleave Mode */ +typedef enum { + /** Unlimited interleaved accesses per EBI_DCLK period. Can cause jitter */ + ebiTFTInterleaveUnlimited = EBI_TFTCTRL_INTERLEAVE_UNLIMITED, + /** Allow 1 interleaved access per EBI_DCLK period */ + ebiTFTInterleaveOnePerDClk = EBI_TFTCTRL_INTERLEAVE_ONEPERDCLK, + /** Only allow accesses during porch periods */ + ebiTFTInterleavePorch = EBI_TFTCTRL_INTERLEAVE_PORCH, +} EBI_TFTInterleave_TypeDef; + +/** Control frame base pointer copy */ +typedef enum { + /** Trigger update of frame buffer pointer on vertical sync */ + ebiTFTFrameBufTriggerVSync = EBI_TFTCTRL_FBCTRIG_VSYNC, + /** Trigger update of frame buffer pointer on horizontal sync */ + ebiTFTFrameBufTriggerHSync = EBI_TFTCTRL_FBCTRIG_HSYNC, +} EBI_TFTFrameBufTrigger_TypeDef; + +/** Control of mask and alpha blending mode */ +typedef enum { + /** Masking and blending are disabled */ + ebiTFTMBDisabled = EBI_TFTCTRL_MASKBLEND_DISABLED, + /** Internal masking */ + ebiTFTMBIMask = EBI_TFTCTRL_MASKBLEND_IMASK, + /** Internal alpha blending */ + ebiTFTMBIAlpha = EBI_TFTCTRL_MASKBLEND_IALPHA, + /** Internal masking and alpha blending are enabled */ +#if defined(EBI_TFTCTRL_MASKBLEND_IMASKIALPHA) + ebiTFTMBIMaskAlpha = EBI_TFTCTRL_MASKBLEND_IMASKIALPHA, +#else + ebiTFTMBIMaskAlpha = EBI_TFTCTRL_MASKBLEND_IMASKALPHA, +#endif +#if defined(EBI_TFTCTRL_MASKBLEND_EMASK) + /** External masking */ + ebiTFTMBEMask = EBI_TFTCTRL_MASKBLEND_EMASK, + /** External alpha blending */ + ebiTFTMBEAlpha = EBI_TFTCTRL_MASKBLEND_EALPHA, + /** External masking and alpha blending */ + ebiTFTMBEMaskAlpha = EBI_TFTCTRL_MASKBLEND_EMASKEALPHA, +#else + /** External masking */ + ebiTFTMBEMask = EBI_TFTCTRL_MASKBLEND_EFBMASK, + /** External alpha blending */ + ebiTFTMBEAlpha = EBI_TFTCTRL_MASKBLEND_EFBALPHA, + /** External masking and alpha blending */ + ebiTFTMBEMaskAlpha = EBI_TFTCTRL_MASKBLEND_EFBMASKALPHA, +#endif +} EBI_TFTMaskBlend_TypeDef; + +/** TFT Direct Drive mode */ +typedef enum { + /** Disabled */ + ebiTFTDDModeDisabled = EBI_TFTCTRL_DD_DISABLED, + /** Direct Drive from internal memory */ + ebiTFTDDModeInternal = EBI_TFTCTRL_DD_INTERNAL, + /** Direct Drive from external memory */ + ebiTFTDDModeExternal = EBI_TFTCTRL_DD_EXTERNAL, +} EBI_TFTDDMode_TypeDef; + +/** TFT Data Increment Width */ +typedef enum { + /** Pixel increments are 1 byte at a time */ + ebiTFTWidthByte = EBI_TFTCTRL_WIDTH_BYTE, + /** Pixel increments are 2 bytes (half word) */ + ebiTFTWidthHalfWord = EBI_TFTCTRL_WIDTH_HALFWORD, +} EBI_TFTWidth_TypeDef; + +#endif // _EBI_TFTCTRL_MASK + +/******************************************************************************* + ******************************* STRUCTS *********************************** + ******************************************************************************/ + +/** EBI Initialization structure */ +typedef struct { + /** EBI operation mode, data and address limits */ + EBI_Mode_TypeDef mode; + /** Address Ready pin polarity, active high or low */ + EBI_Polarity_TypeDef ardyPolarity; + /** Address Latch Enable pin polarity, active high or low */ + EBI_Polarity_TypeDef alePolarity; + /** Write Enable pin polarity, active high or low */ + EBI_Polarity_TypeDef wePolarity; + /** Read Enable pin polarity, active high or low */ + EBI_Polarity_TypeDef rePolarity; + /** Chip Select pin polarity, active high or low */ + EBI_Polarity_TypeDef csPolarity; +#if !defined(_EFM32_GECKO_FAMILY) + /** Byte Lane pin polarity, active high or low */ + EBI_Polarity_TypeDef blPolarity; + /** Flag to enable or disable Byte Lane support */ + bool blEnable; + /** Flag to enable or disable idle state insertion between transfers */ + bool noIdle; +#endif + /** Flag to enable or disable Address Ready support */ + bool ardyEnable; + /** Set to turn off 32 cycle timeout ability */ + bool ardyDisableTimeout; + /** Mask of flags which selects address banks to configure EBI_BANK<0-3> */ + uint32_t banks; + /** Mask of flags which selects chip select lines to configure EBI_CS<0-3> */ + uint32_t csLines; + /** Number of cycles address is held after Adress Latch Enable is asserted */ + int addrSetupCycles; + /** Number of cycles address is driven onto the ADDRDAT bus before ALE is asserted */ + int addrHoldCycles; +#if !defined(_EFM32_GECKO_FAMILY) + /** Enable or disables half cycle duration of the ALE strobe in the last address setup cycle */ + bool addrHalfALE; +#endif + /** Number of cycles for address setup before REn is asserted */ + int readSetupCycles; + /** Number of cycles REn is held active */ + int readStrobeCycles; + /** Number of cycles CSn is held active after REn is deasserted */ + int readHoldCycles; +#if !defined(_EFM32_GECKO_FAMILY) + /** Enable or disable page mode reads */ + bool readPageMode; + /** Enables or disable prefetching from sequential addresses */ + bool readPrefetch; + /** Enabled or disables half cycle duration of the REn signal in the last strobe cycle */ + bool readHalfRE; +#endif + /** Number of cycles for address setup before WEn is asserted */ + int writeSetupCycles; + /** Number of cycles WEn is held active */ + int writeStrobeCycles; + /** Number of cycles CSn is held active after WEn is deasserted */ + int writeHoldCycles; +#if !defined(_EFM32_GECKO_FAMILY) + /** Enable or disable the write buffer */ + bool writeBufferDisable; + /** Enables or disables half cycle duration of the WEn signal in the last strobe cycle */ + bool writeHalfWE; + /** Lower address pin limit to enable */ + EBI_ALow_TypeDef aLow; + /** High address pin limit to enable */ + EBI_AHigh_TypeDef aHigh; +#endif +#if defined(_EBI_ROUTE_LOCATION_MASK) + /** Pin Location */ + EBI_Location_TypeDef location; +#endif + /** Flag, if EBI should be enabled after configuration */ + bool enable; +} EBI_Init_TypeDef; + +/** Default config for EBI init structures */ +#if defined(_SILICON_LABS_32B_SERIES_1) +#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 */ \ + true, /* enable EBI */ \ + } +#elif !defined(_EFM32_GECKO_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(_EBI_TFTCTRL_MASK) + +/** TFT Initialization structure */ +typedef struct { + /** External memory bank for driving display */ + EBI_TFTBank_TypeDef bank; + /** Width */ + EBI_TFTWidth_TypeDef width; + /** Color source for masking and alpha blending */ + EBI_TFTColorSrc_TypeDef colSrc; + /** Bus Interleave mode */ + EBI_TFTInterleave_TypeDef interleave; + /** Trigger for updating frame buffer pointer */ + EBI_TFTFrameBufTrigger_TypeDef fbTrigger; + /** Drive DCLK from negative clock edge of internal clock */ + bool shiftDClk; + /** Masking and alpha blending mode */ + EBI_TFTMaskBlend_TypeDef maskBlend; + /** TFT Direct Drive mode */ + EBI_TFTDDMode_TypeDef driveMode; + /** TFT Polarity for Chip Select (CS) Line */ + EBI_Polarity_TypeDef csPolarity; + /** TFT Polarity for Data Clock (DCLK) Line */ + EBI_Polarity_TypeDef dclkPolarity; + /** TFT Polarity for Data Enable (DATAEN) Line */ + EBI_Polarity_TypeDef dataenPolarity; + /** TFT Polarity for Horizontal Sync (HSYNC) Line */ + EBI_Polarity_TypeDef hsyncPolarity; + /** TFT Polarity for Vertical Sync (VSYNC) Line */ + EBI_Polarity_TypeDef vsyncPolarity; + /** Horizontal size in pixels */ + int hsize; + /** Horizontal Front Porch Size */ + int hPorchFront; + /** Horizontal Back Porch Size */ + int hPorchBack; + /** Horizontal Synchronization Pulse Width */ + int hPulseWidth; + /** Vertical size in pixels */ + int vsize; + /** Vertical Front Porch Size */ + int vPorchFront; + /** Vertical Back Porch Size */ + int vPorchBack; + /** Vertical Synchronization Pulse Width */ + int vPulseWidth; + /** TFT Frame Buffer address, offset to EBI bank base address */ + uint32_t addressOffset; + /** TFT DCLK period in internal cycles */ + int dclkPeriod; + /** Starting position of External Direct Drive relative to DCLK inactive edge */ + int startPosition; + /** Number of cycles RGB data is driven before active edge of DCLK */ + int setupCycles; + /** Number of cycles RGB data is held after active edge of DCLK */ + int holdCycles; +} EBI_TFTInit_TypeDef; + +/** Default configuration for EBI TFT init structure */ +#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(_EBI_TFTCTRL_MASK) +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_GECKO_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); +#endif + +#if defined(_EBI_TFTCTRL_MASK) +/***************************************************************************//** + * @brief + * Enable or disable TFT Direct Drive + * + * @param[in] mode + * Drive from Internal or External memory, or Disable Direct Drive + ******************************************************************************/ +__STATIC_INLINE void EBI_TFTEnable(EBI_TFTDDMode_TypeDef mode) +{ + EBI->TFTCTRL = (EBI->TFTCTRL & ~(_EBI_TFTCTRL_DD_MASK)) | (uint32_t) mode; +} + +/***************************************************************************//** + * @brief + * Configure frame buffer pointer + * + * @param[in] address + * Frame pointer address, as offset by EBI base address + ******************************************************************************/ +__STATIC_INLINE void EBI_TFTFrameBaseSet(uint32_t address) +{ + EBI->TFTFRAMEBASE = (uint32_t) address; +} + +/***************************************************************************//** + * @brief Set TFT Pixel Color 0 or 1 + * + * @param[in] pixel + * Which pixel instance to set + * @param[in] color + * Color of pixel, 16-bit value + ******************************************************************************/ +__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; + } +} + +/***************************************************************************//** + * @brief Masking and Blending Mode Set + * + * @param[in] maskBlend + * Masking and alpha blending mode + ******************************************************************************/ +__STATIC_INLINE void EBI_TFTMaskBlendMode(EBI_TFTMaskBlend_TypeDef maskBlend) +{ + EBI->TFTCTRL = (EBI->TFTCTRL & (~_EBI_TFTCTRL_MASKBLEND_MASK)) | maskBlend; +} + +/***************************************************************************//** + * @brief Set TFT Alpha Blending Factor + * + * @param[in] alpha + * 8-bit value indicating blending factor + ******************************************************************************/ +__STATIC_INLINE void EBI_TFTAlphaBlendSet(uint8_t alpha) +{ + EBI->TFTALPHA = alpha; +} + +/***************************************************************************//** + * @brief Set TFT mask value + * Data accesses that matches this value are suppressed + * @param[in] mask + ******************************************************************************/ +__STATIC_INLINE void EBI_TFTMaskSet(uint32_t mask) +{ + EBI->TFTMASK = mask; +} + +/***************************************************************************//** + * @brief Get current vertical position counter + * @return + * Returns the current line position for the visible part of a frame + ******************************************************************************/ +__STATIC_INLINE uint32_t EBI_TFTVCount(void) +{ + return((EBI->TFTSTATUS & _EBI_TFTSTATUS_VCNT_MASK) >> _EBI_TFTSTATUS_VCNT_SHIFT); +} + +/***************************************************************************//** + * @brief Get current horizontal position counter + * @return + * Returns the current horizontal pixel position within a visible line + ******************************************************************************/ +__STATIC_INLINE uint32_t EBI_TFTHCount(void) +{ + return((EBI->TFTSTATUS & _EBI_TFTSTATUS_HCNT_MASK) >> _EBI_TFTSTATUS_HCNT_SHIFT); +} + +/***************************************************************************//** + * @brief Set Frame Buffer Trigger + * + * @details + * Frame buffer pointer will be updated either on each horizontal line (hsync) + * or vertical update (vsync). + * + * @param[in] sync + * Trigger update of frame buffer pointer on vertical or horisontal sync. + ******************************************************************************/ +__STATIC_INLINE void EBI_TFTFBTriggerSet(EBI_TFTFrameBufTrigger_TypeDef sync) +{ + EBI->TFTCTRL = ((EBI->TFTCTRL & ~_EBI_TFTCTRL_FBCTRIG_MASK) | sync); +} + +/***************************************************************************//** + * @brief Set horizontal TFT stride value in number of bytes + * + * @param[in] nbytes + * Number of bytes to add to frame buffer pointer after each horizontal line + * update + ******************************************************************************/ +__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); +} +#endif // _EBI_TFTCTRL_MASK + +#if defined(_EBI_IF_MASK) +/***************************************************************************//** + * @brief + * Clear one or more pending EBI interrupts. + * @param[in] flags + * Pending EBI interrupt source to clear. Use a logical OR combination + * of valid interrupt flags for the EBI module (EBI_IF_nnn). + ******************************************************************************/ +__STATIC_INLINE void EBI_IntClear(uint32_t flags) +{ + EBI->IFC = flags; +} + +/***************************************************************************//** + * @brief + * Set one or more pending EBI interrupts. + * + * @param[in] flags + * EBI interrupt sources to set to pending. Use a logical OR combination of + * valid interrupt flags for the EBI module (EBI_IF_nnn). + ******************************************************************************/ +__STATIC_INLINE void EBI_IntSet(uint32_t flags) +{ + EBI->IFS = flags; +} + +/***************************************************************************//** + * @brief + * Disable one or more EBI interrupts. + * + * @param[in] flags + * EBI interrupt sources to disable. Use logical OR combination of valid + * interrupt flags for the EBI module (EBI_IF_nnn) + ******************************************************************************/ +__STATIC_INLINE void EBI_IntDisable(uint32_t flags) +{ + EBI->IEN &= ~(flags); +} + +/***************************************************************************//** + * @brief + * Enable one or more EBI interrupts. + * + * @param[in] flags + * EBI interrupt sources to enable. Use logical OR combination of valid + * interrupt flags for the EBI module (EBI_IF_nnn) + ******************************************************************************/ +__STATIC_INLINE void EBI_IntEnable(uint32_t flags) +{ + EBI->IEN |= flags; +} + +/***************************************************************************//** + * @brief + * Get pending EBI interrupt flags. + * + * @note + * The event bits are not cleared by the use of this function + * + * @return + * EBI interrupt sources pending, a logical combination of valid EBI + * interrupt flags, EBI_IF_nnn + ******************************************************************************/ +__STATIC_INLINE uint32_t EBI_IntGet(void) +{ + return EBI->IF; +} + +/***************************************************************************//** + * @brief + * Get enabled and pending EBI interrupt flags. + * Useful for handling more interrupt sources in the same interrupt handler. + * + * @note + * Interrupt flags are not cleared by the use of this function. + * + * @return + * Pending and enabled EBI interrupt sources + * The return value is the bitwise AND of + * - the enabled interrupt sources in EBI_IEN and + * - the pending interrupt flags EBI_IF + ******************************************************************************/ +__STATIC_INLINE uint32_t EBI_IntGetEnabled(void) +{ + uint32_t ien; + + ien = EBI->IEN; + return EBI->IF & ien; +} +#endif // _EBI_IF_MASK + +#if defined(_EBI_CMD_MASK) +/***************************************************************************//** + * @brief + * Start ECC generator on NAND flash transfers. + ******************************************************************************/ +__STATIC_INLINE void EBI_StartNandEccGen(void) +{ + EBI->CMD = EBI_CMD_ECCSTART | EBI_CMD_ECCCLEAR; +} + +/***************************************************************************//** + * @brief + * Stop NAND flash ECC generator and return generated ECC. + * + * @return + * The generated ECC. + ******************************************************************************/ +__STATIC_INLINE uint32_t EBI_StopNandEccGen(void) +{ + EBI->CMD = EBI_CMD_ECCSTOP; + return EBI->ECCPARITY; +} +#endif // _EBI_CMD_MASK + +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); + +/** @} (end addtogroup EBI) */ +/** @} (end addtogroup emlib) */ + +#ifdef __cplusplus +} +#endif + +#endif /* defined(EBI_COUNT) && (EBI_COUNT > 0) */ + +#endif /* EM_EBI_H */