769 lines
25 KiB
C
769 lines
25 KiB
C
/*
|
|
* The Clear BSD License
|
|
* Copyright (c) 2017, NXP Semiconductors, Inc.
|
|
* All rights reserved.
|
|
*
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted (subject to the limitations in the disclaimer below) provided
|
|
* that the following conditions are met:
|
|
*
|
|
* o Redistributions of source code must retain the above copyright notice, this list
|
|
* of conditions and the following disclaimer.
|
|
*
|
|
* o Redistributions in binary form must reproduce the above copyright notice, this
|
|
* list of conditions and the following disclaimer in the documentation and/or
|
|
* other materials provided with the distribution.
|
|
*
|
|
* o Neither the name of the copyright holder nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE.
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef _FSL_ELCDIF_H_
|
|
#define _FSL_ELCDIF_H_
|
|
|
|
#include "fsl_common.h"
|
|
|
|
/*!
|
|
* @addtogroup elcdif
|
|
* @{
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
* Definitions
|
|
******************************************************************************/
|
|
|
|
/*! @name Driver version */
|
|
/*@{*/
|
|
/*! @brief eLCDIF driver version */
|
|
#define FSL_ELCDIF_DRIVER_VERSION (MAKE_VERSION(2, 0, 0)) /*!< Version 2.0.0. */
|
|
/*@}*/
|
|
|
|
/* All IRQ flags in CTRL1 register. */
|
|
#define ELCDIF_CTRL1_IRQ_MASK \
|
|
(LCDIF_CTRL1_BM_ERROR_IRQ_MASK | LCDIF_CTRL1_OVERFLOW_IRQ_MASK | LCDIF_CTRL1_UNDERFLOW_IRQ_MASK | \
|
|
LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_MASK | LCDIF_CTRL1_VSYNC_EDGE_IRQ_MASK)
|
|
|
|
/* All IRQ enable control bits in CTRL1 register. */
|
|
#define ELCDIF_CTRL1_IRQ_EN_MASK \
|
|
(LCDIF_CTRL1_BM_ERROR_IRQ_EN_MASK | LCDIF_CTRL1_OVERFLOW_IRQ_EN_MASK | LCDIF_CTRL1_UNDERFLOW_IRQ_EN_MASK | \
|
|
LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_EN_MASK | LCDIF_CTRL1_VSYNC_EDGE_IRQ_EN_MASK)
|
|
|
|
/* All IRQ flags in AS_CTRL register. */
|
|
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK)
|
|
#define ELCDIF_AS_CTRL_IRQ_MASK (LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK)
|
|
#else
|
|
#define ELCDIF_AS_CTRL_IRQ_MASK 0U
|
|
#endif
|
|
|
|
/* All IRQ enable control bits in AS_CTRL register. */
|
|
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK)
|
|
#define ELCDIF_AS_CTRL_IRQ_EN_MASK (LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK)
|
|
#else
|
|
#define ELCDIF_AS_CTRL_IRQ_EN_MASK 0U
|
|
#endif
|
|
|
|
#if ((ELCDIF_CTRL1_IRQ_MASK & ELCDIF_AS_CTRL_IRQ_MASK) || (ELCDIF_AS_CTRL_IRQ_MASK & ELCDIF_AS_CTRL_IRQ_EN_MASK))
|
|
#error Interrupt bits overlap, need to update the interrupt functions.
|
|
#endif
|
|
|
|
/* LUT memory entery number. */
|
|
#define ELCDIF_LUT_ENTRY_NUM 256
|
|
|
|
/*!
|
|
* @brief eLCDIF signal polarity flags
|
|
*/
|
|
enum _elcdif_polarity_flags
|
|
{
|
|
kELCDIF_VsyncActiveLow = 0U, /*!< VSYNC active low. */
|
|
kELCDIF_VsyncActiveHigh = LCDIF_VDCTRL0_VSYNC_POL_MASK, /*!< VSYNC active high. */
|
|
kELCDIF_HsyncActiveLow = 0U, /*!< HSYNC active low. */
|
|
kELCDIF_HsyncActiveHigh = LCDIF_VDCTRL0_HSYNC_POL_MASK, /*!< HSYNC active high. */
|
|
kELCDIF_DataEnableActiveLow = 0U, /*!< Data enable line active low. */
|
|
kELCDIF_DataEnableActiveHigh = LCDIF_VDCTRL0_ENABLE_POL_MASK, /*!< Data enable line active high. */
|
|
kELCDIF_DriveDataOnFallingClkEdge = 0U, /*!< Drive data on falling clock edge, capture data
|
|
on rising clock edge. */
|
|
kELCDIF_DriveDataOnRisingClkEdge = LCDIF_VDCTRL0_DOTCLK_POL_MASK, /*!< Drive data on falling
|
|
clock edge, capture data
|
|
on rising clock edge. */
|
|
};
|
|
|
|
/*!
|
|
* @brief The eLCDIF interrupts to enable.
|
|
*/
|
|
enum _elcdif_interrupt_enable
|
|
{
|
|
kELCDIF_BusMasterErrorInterruptEnable = LCDIF_CTRL1_BM_ERROR_IRQ_EN_MASK, /*!< Bus master error interrupt. */
|
|
kELCDIF_TxFifoOverflowInterruptEnable = LCDIF_CTRL1_OVERFLOW_IRQ_EN_MASK, /*!< TXFIFO overflow interrupt. */
|
|
kELCDIF_TxFifoUnderflowInterruptEnable = LCDIF_CTRL1_UNDERFLOW_IRQ_EN_MASK, /*!< TXFIFO underflow interrupt. */
|
|
kELCDIF_CurFrameDoneInterruptEnable =
|
|
LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_EN_MASK, /*!< Interrupt when hardware enters vertical blanking state. */
|
|
kELCDIF_VsyncEdgeInterruptEnable =
|
|
LCDIF_CTRL1_VSYNC_EDGE_IRQ_EN_MASK, /*!< Interrupt when hardware encounters VSYNC edge. */
|
|
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK)
|
|
kELCDIF_SciSyncOnInterruptEnable =
|
|
LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK, /*!< Interrupt when eLCDIF lock with CSI input. */
|
|
#endif
|
|
};
|
|
|
|
/*!
|
|
* @brief The eLCDIF interrupt status flags.
|
|
*/
|
|
enum _elcdif_interrupt_flags
|
|
{
|
|
kELCDIF_BusMasterError = LCDIF_CTRL1_BM_ERROR_IRQ_MASK, /*!< Bus master error interrupt. */
|
|
kELCDIF_TxFifoOverflow = LCDIF_CTRL1_OVERFLOW_IRQ_MASK, /*!< TXFIFO overflow interrupt. */
|
|
kELCDIF_TxFifoUnderflow = LCDIF_CTRL1_UNDERFLOW_IRQ_MASK, /*!< TXFIFO underflow interrupt. */
|
|
kELCDIF_CurFrameDone =
|
|
LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_MASK, /*!< Interrupt when hardware enters vertical blanking state. */
|
|
kELCDIF_VsyncEdge = LCDIF_CTRL1_VSYNC_EDGE_IRQ_MASK, /*!< Interrupt when hardware encounters VSYNC edge. */
|
|
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK)
|
|
kELCDIF_SciSyncOn = LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK, /*!< Interrupt when eLCDIF lock with CSI input. */
|
|
#endif
|
|
};
|
|
|
|
/*!
|
|
* @brief eLCDIF status flags
|
|
*/
|
|
enum _elcdif_status_flags
|
|
{
|
|
kELCDIF_LFifoFull = LCDIF_STAT_LFIFO_FULL_MASK, /*!< LFIFO full. */
|
|
kELCDIF_LFifoEmpty = LCDIF_STAT_LFIFO_EMPTY_MASK, /*!< LFIFO empty. */
|
|
kELCDIF_TxFifoFull = LCDIF_STAT_TXFIFO_FULL_MASK, /*!< TXFIFO full. */
|
|
kELCDIF_TxFifoEmpty = LCDIF_STAT_TXFIFO_EMPTY_MASK, /*!< TXFIFO empty. */
|
|
#if defined(LCDIF_STAT_BUSY_MASK)
|
|
kELCDIF_LcdControllerBusy = LCDIF_STAT_BUSY_MASK, /*!< The external LCD controller busy signal. */
|
|
#endif
|
|
#if defined(LCDIF_STAT_DVI_CURRENT_FIELD_MASK)
|
|
kELCDIF_CurDviField2 = LCDIF_STAT_DVI_CURRENT_FIELD_MASK, /*!< Current DVI filed, if set, then current filed is 2,
|
|
otherwise current filed is 1. */
|
|
#endif
|
|
};
|
|
|
|
/*!
|
|
* @brief The pixel format.
|
|
*
|
|
* This enumerator should be defined together with the array s_pixelFormatReg.
|
|
* To support new pixel format, enhance this enumerator and s_pixelFormatReg.
|
|
*/
|
|
typedef enum _elcdif_pixel_format
|
|
{
|
|
kELCDIF_PixelFormatRAW8 = 0, /*!< RAW 8 bit, four data use 32 bits. */
|
|
kELCDIF_PixelFormatRGB565 = 1, /*!< RGB565, two pixel use 32 bits. */
|
|
kELCDIF_PixelFormatRGB666 = 2, /*!< RGB666 unpacked, one pixel uses 32 bits, high byte unused,
|
|
upper 2 bits of other bytes unused. */
|
|
kELCDIF_PixelFormatXRGB8888 = 3, /*!< XRGB8888 unpacked, one pixel uses 32 bits, high byte unused. */
|
|
kELCDIF_PixelFormatRGB888 = 4, /*!< RGB888 packed, one pixel uses 24 bits. */
|
|
} elcdif_pixel_format_t;
|
|
|
|
/*! @brief The LCD data bus type. */
|
|
typedef enum _elcdif_lcd_data_bus
|
|
{
|
|
kELCDIF_DataBus8Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(1), /*!< 8-bit data bus. */
|
|
kELCDIF_DataBus16Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(0), /*!< 16-bit data bus, support RGB565. */
|
|
kELCDIF_DataBus18Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(2), /*!< 18-bit data bus, support RGB666. */
|
|
kELCDIF_DataBus24Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(3), /*!< 24-bit data bus, support RGB888. */
|
|
} elcdif_lcd_data_bus_t;
|
|
|
|
/*!
|
|
* @brief The register value when using different pixel format.
|
|
*
|
|
* These register bits control the pixel format:
|
|
* - CTRL[DATA_FORMAT_24_BIT]
|
|
* - CTRL[DATA_FORMAT_18_BIT]
|
|
* - CTRL[DATA_FORMAT_16_BIT]
|
|
* - CTRL[WORD_LENGTH]
|
|
* - CTRL1[BYTE_PACKING_FORMAT]
|
|
*/
|
|
typedef struct _elcdif_pixel_format_reg
|
|
{
|
|
uint32_t regCtrl; /*!< Value of register CTRL. */
|
|
uint32_t regCtrl1; /*!< Value of register CTRL1. */
|
|
} elcdif_pixel_format_reg_t;
|
|
|
|
/*!
|
|
* @brief eLCDIF configure structure for RGB mode (DOTCLK mode).
|
|
*/
|
|
typedef struct _elcdif_rgb_mode_config
|
|
{
|
|
uint16_t panelWidth; /*!< Display panel width, pixels per line. */
|
|
uint16_t panelHeight; /*!< Display panel height, how many lines per panel. */
|
|
uint8_t hsw; /*!< HSYNC pulse width. */
|
|
uint8_t hfp; /*!< Horizontal front porch. */
|
|
uint8_t hbp; /*!< Horizontal back porch. */
|
|
uint8_t vsw; /*!< VSYNC pulse width. */
|
|
uint8_t vfp; /*!< Vrtical front porch. */
|
|
uint8_t vbp; /*!< Vertical back porch. */
|
|
uint32_t polarityFlags; /*!< OR'ed value of @ref _elcdif_polarity_flags, used to contol the signal polarity. */
|
|
uint32_t bufferAddr; /*!< Frame buffer address. */
|
|
elcdif_pixel_format_t pixelFormat; /*!< Pixel format. */
|
|
elcdif_lcd_data_bus_t dataBus; /*!< LCD data bus. */
|
|
} elcdif_rgb_mode_config_t;
|
|
|
|
/*!
|
|
* @brief eLCDIF alpha surface pixel format.
|
|
*/
|
|
typedef enum _elcdif_as_pixel_format
|
|
{
|
|
kELCDIF_AsPixelFormatARGB8888 = 0x0, /*!< 32-bit pixels with alpha. */
|
|
kELCDIF_AsPixelFormatRGB888 = 0x4, /*!< 32-bit pixels without alpha (unpacked 24-bit format) */
|
|
kELCDIF_AsPixelFormatARGB1555 = 0x8, /*!< 16-bit pixels with alpha. */
|
|
kELCDIF_AsPixelFormatARGB4444 = 0x9, /*!< 16-bit pixels with alpha. */
|
|
kELCDIF_AsPixelFormatRGB555 = 0xC, /*!< 16-bit pixels without alpha. */
|
|
kELCDIF_AsPixelFormatRGB444 = 0xD, /*!< 16-bit pixels without alpha. */
|
|
kELCDIF_AsPixelFormatRGB565 = 0xE, /*!< 16-bit pixels without alpha. */
|
|
} elcdif_as_pixel_format_t;
|
|
|
|
/*!
|
|
* @brief eLCDIF alpha surface buffer configuration.
|
|
*/
|
|
typedef struct _elcdif_as_buffer_config
|
|
{
|
|
uint32_t bufferAddr; /*!< Buffer address. */
|
|
elcdif_as_pixel_format_t pixelFormat; /*!< Pixel format. */
|
|
} elcdif_as_buffer_config_t;
|
|
|
|
/*!
|
|
* @brief eLCDIF alpha mode during blending.
|
|
*/
|
|
typedef enum _elcdif_alpha_mode
|
|
{
|
|
kELCDIF_AlphaEmbedded, /*!< The alpha surface pixel alpha value will be used for blend. */
|
|
kELCDIF_AlphaOverride, /*!< The user defined alpha value will be used for blend directly. */
|
|
kELCDIF_AlphaMultiply, /*!< The alpha surface pixel alpha value scaled the user defined
|
|
alpha value will be used for blend, for example, pixel alpha set
|
|
set to 200, user defined alpha set to 100, then the reault alpha
|
|
is 200 * 100 / 255. */
|
|
kELCDIF_AlphaRop /*!< Raster operation. */
|
|
} elcdif_alpha_mode_t;
|
|
|
|
/*!
|
|
* @brief eLCDIF ROP mode during blending.
|
|
*
|
|
* Explanation:
|
|
* - AS: Alpha surface
|
|
* - PS: Process surface
|
|
* - nAS: Alpha surface NOT value
|
|
* - nPS: Process surface NOT value
|
|
*/
|
|
typedef enum _elcdif_rop_mode
|
|
{
|
|
kELCDIF_RopMaskAs = 0x0, /*!< AS AND PS. */
|
|
kELCDIF_RopMaskNotAs = 0x1, /*!< nAS AND PS. */
|
|
kELCDIF_RopMaskAsNot = 0x2, /*!< AS AND nPS. */
|
|
kELCDIF_RopMergeAs = 0x3, /*!< AS OR PS. */
|
|
kELCDIF_RopMergeNotAs = 0x4, /*!< nAS OR PS. */
|
|
kELCDIF_RopMergeAsNot = 0x5, /*!< AS OR nPS. */
|
|
kELCDIF_RopNotCopyAs = 0x6, /*!< nAS. */
|
|
kELCDIF_RopNot = 0x7, /*!< nPS. */
|
|
kELCDIF_RopNotMaskAs = 0x8, /*!< AS NAND PS. */
|
|
kELCDIF_RopNotMergeAs = 0x9, /*!< AS NOR PS. */
|
|
kELCDIF_RopXorAs = 0xA, /*!< AS XOR PS. */
|
|
kELCDIF_RopNotXorAs = 0xB /*!< AS XNOR PS. */
|
|
} elcdif_rop_mode_t;
|
|
|
|
/*!
|
|
* @brief eLCDIF alpha surface blending configuration.
|
|
*/
|
|
typedef struct _elcdif_as_blend_config
|
|
{
|
|
uint8_t alpha; /*!< User defined alpha value, only used when @ref alphaMode is @ref kELCDIF_AlphaOverride or @ref
|
|
kELCDIF_AlphaRop. */
|
|
bool invertAlpha; /*!< Set true to invert the alpha. */
|
|
elcdif_alpha_mode_t alphaMode; /*!< Alpha mode. */
|
|
elcdif_rop_mode_t ropMode; /*!< ROP mode, only valid when @ref alphaMode is @ref kELCDIF_AlphaRop. */
|
|
} elcdif_as_blend_config_t;
|
|
|
|
/*!
|
|
* @brief eLCDIF LUT
|
|
*
|
|
* The Lookup Table (LUT) is used to expand the 8 bits pixel to 24 bits pixel
|
|
* before output to external displayer.
|
|
*
|
|
* There are two 256x24 bits LUT memory in LCDIF, the LSB of frame buffer address
|
|
* determins which memory to use.
|
|
*/
|
|
typedef enum _elcdif_lut
|
|
{
|
|
kELCDIF_Lut0 = 0, /*!< LUT 0. */
|
|
kELCDIF_Lut1, /*!< LUT 1. */
|
|
} elcdif_lut_t;
|
|
|
|
/*******************************************************************************
|
|
* APIs
|
|
******************************************************************************/
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
/*!
|
|
* @name eLCDIF initialization and de-initialization
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Initializes the eLCDIF to work in RGB mode (DOTCLK mode).
|
|
*
|
|
* This function ungates the eLCDIF clock and configures the eLCDIF peripheral according
|
|
* to the configuration structure.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param config Pointer to the configuration structure.
|
|
*/
|
|
void ELCDIF_RgbModeInit(LCDIF_Type *base, const elcdif_rgb_mode_config_t *config);
|
|
|
|
/*!
|
|
* @brief Gets the eLCDIF default configuration structure for RGB (DOTCLK) mode.
|
|
*
|
|
* This function sets the configuration structure to default values.
|
|
* The default configuration is set to the following values.
|
|
* @code
|
|
config->panelWidth = 480U;
|
|
config->panelHeight = 272U;
|
|
config->hsw = 41;
|
|
config->hfp = 4;
|
|
config->hbp = 8;
|
|
config->vsw = 10;
|
|
config->vfp = 4;
|
|
config->vbp = 2;
|
|
config->polarityFlags = kELCDIF_VsyncActiveLow |
|
|
kELCDIF_HsyncActiveLow |
|
|
kELCDIF_DataEnableActiveLow |
|
|
kELCDIF_DriveDataOnFallingClkEdge;
|
|
config->bufferAddr = 0U;
|
|
config->pixelFormat = kELCDIF_PixelFormatRGB888;
|
|
config->dataBus = kELCDIF_DataBus24Bit;
|
|
@code
|
|
*
|
|
* @param config Pointer to the eLCDIF configuration structure.
|
|
*/
|
|
void ELCDIF_RgbModeGetDefaultConfig(elcdif_rgb_mode_config_t *config);
|
|
|
|
/*!
|
|
* @brief Deinitializes the eLCDIF peripheral.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
*/
|
|
void ELCDIF_Deinit(LCDIF_Type *base);
|
|
|
|
/* @} */
|
|
|
|
/*!
|
|
* @name Module operation
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Start to display in RGB (DOTCLK) mode.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
*/
|
|
static inline void ELCDIF_RgbModeStart(LCDIF_Type *base)
|
|
{
|
|
base->CTRL_SET = LCDIF_CTRL_RUN_MASK | LCDIF_CTRL_DOTCLK_MODE_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Stop display in RGB (DOTCLK) mode and wait until finished.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
*/
|
|
void ELCDIF_RgbModeStop(LCDIF_Type *base);
|
|
|
|
/*!
|
|
* @brief Set the next frame buffer address to display.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param bufferAddr The frame buffer address to set.
|
|
*/
|
|
static inline void ELCDIF_SetNextBufferAddr(LCDIF_Type *base, uint32_t bufferAddr)
|
|
{
|
|
base->NEXT_BUF = bufferAddr;
|
|
}
|
|
|
|
/*!
|
|
* @brief Reset the eLCDIF peripheral.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
*/
|
|
void ELCDIF_Reset(LCDIF_Type *base);
|
|
|
|
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_RESET_PIN) && FSL_FEATURE_LCDIF_HAS_NO_RESET_PIN)
|
|
/*!
|
|
* @brief Pull up or down the reset pin for the externel LCD controller.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param pullUp True to pull up reset pin, false to pull down.
|
|
*/
|
|
static inline void ELCDIF_PullUpResetPin(LCDIF_Type *base, bool pullUp)
|
|
{
|
|
if (pullUp)
|
|
{
|
|
base->CTRL1_SET = LCDIF_CTRL1_RESET_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->CTRL1_CLR = LCDIF_CTRL1_RESET_MASK;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
* @brief Enable or disable the hand shake with PXP.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param enable True to enable, false to disable.
|
|
*/
|
|
static inline void ELCDIF_EnablePxpHandShake(LCDIF_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_SET = LCDIF_CTRL_ENABLE_PXP_HANDSHAKE_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_CLR = LCDIF_CTRL_ENABLE_PXP_HANDSHAKE_MASK;
|
|
}
|
|
}
|
|
|
|
/* @} */
|
|
|
|
/*!
|
|
* @name Status
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Get the CRC value of the frame sent out.
|
|
*
|
|
* When a frame is sent complete (the interrupt @ref kELCDIF_CurFrameDone assert), this function
|
|
* can be used to get the CRC value of the frame sent.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @return The CRC value.
|
|
*
|
|
* @note The CRC value is dependent on the LCD_DATABUS_WIDTH.
|
|
*/
|
|
static inline uint32_t ELCDIF_GetCrcValue(LCDIF_Type *base)
|
|
{
|
|
return base->CRC_STAT;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the bus master error virtual address.
|
|
*
|
|
* When bus master error occurs (the interrupt kELCDIF_BusMasterError assert), this function
|
|
* can get the virtual address at which the AXI master received an error
|
|
* response from the slave.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @return The error virtual address.
|
|
*/
|
|
static inline uint32_t ELCDIF_GetBusMasterErrorAddr(LCDIF_Type *base)
|
|
{
|
|
return base->BM_ERROR_STAT;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the eLCDIF status.
|
|
*
|
|
* The status flags are returned as a mask value, application could check the
|
|
* corresponding bit. Example:
|
|
*
|
|
* @code
|
|
uint32_t statusFlags;
|
|
statusFlags = ELCDIF_GetStatus(LCDIF);
|
|
|
|
// If LFIFO is full.
|
|
if (kELCDIF_LFifoFull & statusFlags)
|
|
{
|
|
// ...;
|
|
}
|
|
// If TXFIFO is empty.
|
|
if (kELCDIF_TxFifoEmpty & statusFlags)
|
|
{
|
|
// ...;
|
|
}
|
|
@endcode
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @return The mask value of status flags, it is OR'ed value of @ref _elcdif_status_flags.
|
|
*/
|
|
static inline uint32_t ELCDIF_GetStatus(LCDIF_Type *base)
|
|
{
|
|
return base->STAT & (LCDIF_STAT_LFIFO_FULL_MASK | LCDIF_STAT_LFIFO_EMPTY_MASK | LCDIF_STAT_TXFIFO_FULL_MASK |
|
|
LCDIF_STAT_TXFIFO_EMPTY_MASK
|
|
#if defined(LCDIF_STAT_BUSY_MASK)
|
|
| LCDIF_STAT_BUSY_MASK
|
|
#endif
|
|
#if defined(LCDIF_STAT_DVI_CURRENT_FIELD_MASK)
|
|
| LCDIF_STAT_DVI_CURRENT_FIELD_MASK
|
|
#endif
|
|
);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get current count in Latency buffer (LFIFO).
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @return The LFIFO current count
|
|
*/
|
|
static inline uint32_t ELCDIF_GetLFifoCount(LCDIF_Type *base)
|
|
{
|
|
return (base->STAT & LCDIF_STAT_LFIFO_COUNT_MASK) >> LCDIF_STAT_LFIFO_COUNT_SHIFT;
|
|
}
|
|
|
|
/* @} */
|
|
|
|
/*!
|
|
* @name Interrupts
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Enables eLCDIF interrupt requests.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param mask interrupt source, OR'ed value of _elcdif_interrupt_enable.
|
|
*/
|
|
static inline void ELCDIF_EnableInterrupts(LCDIF_Type *base, uint32_t mask)
|
|
{
|
|
base->CTRL1_SET = (mask & ELCDIF_CTRL1_IRQ_EN_MASK);
|
|
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS)
|
|
base->AS_CTRL |= (mask & ELCDIF_AS_CTRL_IRQ_EN_MASK);
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* @brief Disables eLCDIF interrupt requests.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param mask interrupt source, OR'ed value of _elcdif_interrupt_enable.
|
|
*/
|
|
static inline void ELCDIF_DisableInterrupts(LCDIF_Type *base, uint32_t mask)
|
|
{
|
|
base->CTRL1_CLR = (mask & ELCDIF_CTRL1_IRQ_EN_MASK);
|
|
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS)
|
|
base->AS_CTRL &= ~(mask & ELCDIF_AS_CTRL_IRQ_EN_MASK);
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* @brief Get eLCDIF interrupt peding status.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @return Interrupt pending status, OR'ed value of _elcdif_interrupt_flags.
|
|
*/
|
|
static inline uint32_t ELCDIF_GetInterruptStatus(LCDIF_Type *base)
|
|
{
|
|
uint32_t flags;
|
|
|
|
flags = (base->CTRL1 & ELCDIF_CTRL1_IRQ_MASK);
|
|
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS)
|
|
flags |= (base->AS_CTRL & ELCDIF_AS_CTRL_IRQ_MASK);
|
|
#endif
|
|
|
|
return flags;
|
|
}
|
|
|
|
/*!
|
|
* @brief Clear eLCDIF interrupt peding status.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param mask of the flags to clear, OR'ed value of _elcdif_interrupt_flags.
|
|
*/
|
|
static inline void ELCDIF_ClearInterruptStatus(LCDIF_Type *base, uint32_t mask)
|
|
{
|
|
base->CTRL1_CLR = (mask & ELCDIF_CTRL1_IRQ_MASK);
|
|
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS)
|
|
base->AS_CTRL &= ~(mask & ELCDIF_AS_CTRL_IRQ_MASK);
|
|
#endif
|
|
}
|
|
|
|
/* @} */
|
|
|
|
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS)
|
|
/*!
|
|
* @name Alpha surface
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Set the configuration for alpha surface buffer.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param config Pointer to the configuration structure.
|
|
*/
|
|
void ELCDIF_SetAlphaSurfaceBufferConfig(LCDIF_Type *base, const elcdif_as_buffer_config_t *config);
|
|
|
|
/*!
|
|
* @brief Set the alpha surface blending configuration.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param config Pointer to the configuration structure.
|
|
*/
|
|
void ELCDIF_SetAlphaSurfaceBlendConfig(LCDIF_Type *base, const elcdif_as_blend_config_t *config);
|
|
|
|
/*!
|
|
* @brief Set the next alpha surface buffer address.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param bufferAddr Alpha surface buffer address.
|
|
*/
|
|
static inline void ELCDIF_SetNextAlphaSurfaceBufferAddr(LCDIF_Type *base, uint32_t bufferAddr)
|
|
{
|
|
base->AS_NEXT_BUF = bufferAddr;
|
|
}
|
|
|
|
/*!
|
|
* @brief Set the overlay color key.
|
|
*
|
|
* If a pixel in the current overlay image with a color that falls in the range
|
|
* from the @p colorKeyLow to @p colorKeyHigh range, it will use the process surface
|
|
* pixel value for that location.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param colorKeyLow Color key low range.
|
|
* @param colorKeyHigh Color key high range.
|
|
*
|
|
* @note Colorkey operations are higher priority than alpha or ROP operations
|
|
*/
|
|
static inline void ELCDIF_SetOverlayColorKey(LCDIF_Type *base, uint32_t colorKeyLow, uint32_t colorKeyHigh)
|
|
{
|
|
base->AS_CLRKEYLOW = colorKeyLow;
|
|
base->AS_CLRKEYHIGH = colorKeyHigh;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable or disable the color key.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param enable True to enable, false to disable.
|
|
*/
|
|
static inline void ELCDIF_EnableOverlayColorKey(LCDIF_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->AS_CTRL |= LCDIF_AS_CTRL_ENABLE_COLORKEY_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->AS_CTRL &= ~LCDIF_AS_CTRL_ENABLE_COLORKEY_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable or disable the alpha surface.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param enable True to enable, false to disable.
|
|
*/
|
|
static inline void ELCDIF_EnableAlphaSurface(LCDIF_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->AS_CTRL |= LCDIF_AS_CTRL_AS_ENABLE_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->AS_CTRL &= ~LCDIF_AS_CTRL_AS_ENABLE_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable or disable the process surface.
|
|
*
|
|
* Process surface is the normal frame buffer. The process surface content
|
|
* is controlled by @ref ELCDIF_SetNextBufferAddr.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param enable True to enable, false to disable.
|
|
*/
|
|
static inline void ELCDIF_EnableProcessSurface(LCDIF_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->AS_CTRL &= ~LCDIF_AS_CTRL_PS_DISABLE_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->AS_CTRL |= LCDIF_AS_CTRL_PS_DISABLE_MASK;
|
|
}
|
|
}
|
|
|
|
/* @} */
|
|
#endif /* FSL_FEATURE_LCDIF_HAS_NO_AS */
|
|
|
|
#if (defined(FSL_FEATURE_LCDIF_HAS_LUT) && FSL_FEATURE_LCDIF_HAS_LUT)
|
|
/*!
|
|
* @name LUT
|
|
*
|
|
* The Lookup Table (LUT) is used to expand the 8 bits pixel to 24 bits pixel
|
|
* before output to external displayer.
|
|
*
|
|
* There are two 256x24 bits LUT memory in LCDIF, the LSB of frame buffer address
|
|
* determins which memory to use.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Enable or disable the LUT.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param enable True to enable, false to disable.
|
|
*/
|
|
static inline void ELCDIF_EnableLut(LCDIF_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->LUT_CTRL &= ~LCDIF_LUT_CTRL_LUT_BYPASS_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->LUT_CTRL |= LCDIF_LUT_CTRL_LUT_BYPASS_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Load the LUT value.
|
|
*
|
|
* This function loads the LUT value to the specific LUT memory, user can
|
|
* specify the start entry index.
|
|
*
|
|
* @param base eLCDIF peripheral base address.
|
|
* @param lut Which LUT to load.
|
|
* @param startIndex The start index of the LUT entry to update.
|
|
* @param lutData The LUT data to load.
|
|
* @param count Count of @p lutData.
|
|
* @retval kStatus_Success Initialization success.
|
|
* @retval kStatus_InvalidArgument Wrong argument.
|
|
*/
|
|
status_t ELCDIF_UpdateLut(
|
|
LCDIF_Type *base, elcdif_lut_t lut, uint16_t startIndex, const uint32_t *lutData, uint16_t count);
|
|
|
|
/* @} */
|
|
#endif /* FSL_FEATURE_LCDIF_HAS_LUT */
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
/* @} */
|
|
|
|
#endif /*_FSL_ELCDIF_H_*/
|