rusefi
/
ChibiOS-Contrib
mirror of https://github.com/rusefi/ChibiOS-Contrib.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ChibiOS-Contrib/os/hal/ports/STM32/LLD/LTDCv1/stm32_ltdc.h

771 lines
30 KiB
C
Raw Blame History

/*
Copyright (C) 2013-2015 Andrea Zoppi
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @file stm32_ltdc.h
* @brief LCD-TFT Controller Driver.
*
* @addtogroup ltdc
* @{
*/
#ifndef _STM32_LTDC_H_
#define _STM32_LTDC_H_
/**
* @brief Using the LTDC driver.
*/
#if !defined(STM32_LTDC_USE_LTDC) || defined(__DOXYGEN__)
#define STM32_LTDC_USE_LTDC FALSE
#endif
#if (TRUE == STM32_LTDC_USE_LTDC) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver constants. */
/*===========================================================================*/
/**
* @name LTDC enable flags
* @{
*/
#define LTDC_EF_ENABLE (1 << 0) /**< LTDC enabled.*/
#define LTDC_EF_DITHER (1 << 16) /**< Dithering enabled.*/
#define LTDC_EF_PIXCLK_INVERT (1 << 28) /**< Inverted pixel clock.*/
#define LTDC_EF_DATAEN_HIGH (1 << 29) /**< Active-high data enable.*/
#define LTDC_EF_VSYNC_HIGH (1 << 30) /**< Active-high vsync.*/
#define LTDC_EF_HSYNC_HIGH (1 << 31) /**< Active-high hsync.*/
#define LTDC_EF_MASK \
(LTDC_EF_ENABLE | LTDC_EF_DITHER | LTDC_EF_PIXCLK_INVERT | \
LTDC_EF_DATAEN_HIGH | LTDC_EF_VSYNC_HIGH | LTDC_EF_HSYNC_HIGH)
/** @} */
/**
* @name LTDC layer enable flags
* @{
*/
#define LTDC_LEF_ENABLE (1 << 0) /**< Layer enabled*/
#define LTDC_LEF_KEYING (1 << 1) /**< Color keying enabled.*/
#define LTDC_LEF_PALETTE (1 << 4) /**< Palette enabled.*/
#define LTDC_LEF_MASK \
(LTDC_LEF_ENABLE | LTDC_LEF_KEYING | LTDC_LEF_PALETTE)
/** @} */
/**
* @name LTDC pixel formats
* @{
*/
#define LTDC_FMT_ARGB8888 0 /**< ARGB-8888 format.*/
#define LTDC_FMT_RGB888 1 /**< RGB-888 format.*/
#define LTDC_FMT_RGB565 2 /**< RGB-565 format.*/
#define LTDC_FMT_ARGB1555 3 /**< ARGB-1555 format.*/
#define LTDC_FMT_ARGB4444 4 /**< ARGB-4444 format.*/
#define LTDC_FMT_L8 5 /**< L-8 format.*/
#define LTDC_FMT_AL44 6 /**< AL-44 format.*/
#define LTDC_FMT_AL88 7 /**< AL-88 format.*/
/** @} */
/**
* @name LTDC pixel format aliased raw masks
* @{
*/
#define LTDC_XMASK_ARGB8888 0xFFFFFFFF /**< ARGB-8888 aliased mask.*/
#define LTDC_XMASK_RGB888 0x00FFFFFF /**< RGB-888 aliased mask.*/
#define LTDC_XMASK_RGB565 0x00F8FCF8 /**< RGB-565 aliased mask.*/
#define LTDC_XMASK_ARGB1555 0x80F8F8F8 /**< ARGB-1555 aliased mask.*/
#define LTDC_XMASK_ARGB4444 0xF0F0F0F0 /**< ARGB-4444 aliased mask.*/
#define LTDC_XMASK_L8 0x000000FF /**< L-8 aliased mask.*/
#define LTDC_XMASK_AL44 0xF00000F0 /**< AL-44 aliased mask.*/
#define LTDC_XMASK_AL88 0xFF0000FF /**< AL-88 aliased mask.*/
/** @} */
/**
* @name LTDC blending factors
* @{
*/
#define LTDC_BLEND_FIX1_FIX2 0x0405 /**< cnst1; 1 - cnst2 */
#define LTDC_BLEND_FIX1_MOD2 0x0407 /**< cnst1; 1 - a2 * cnst2 */
#define LTDC_BLEND_MOD1_FIX2 0x0605 /**< a1 * cnst1; 1 - cnst2 */
#define LTDC_BLEND_MOD1_MOD2 0x0607 /**< a1 * cnst1; 1 - a2 * cnst2 */
/** @} */
/**
* @name LTDC parameter bounds
* @{
*/
#define LTDC_MIN_SCREEN_WIDTH 1
#define LTDC_MIN_SCREEN_HEIGHT 1
#define LTDC_MAX_SCREEN_WIDTH 800
#define LTDC_MAX_SCREEN_HEIGHT 600
#define LTDC_MIN_HSYNC_WIDTH 1
#define LTDC_MIN_VSYNC_HEIGHT 1
#define LTDC_MAX_HSYNC_WIDTH (1 << 12)
#define LTDC_MAX_VSYNC_HEIGHT (1 << 11)
#define LTDC_MIN_HBP_WIDTH 0
#define LTDC_MIN_VBP_HEIGHT 0
#define LTDC_MAX_HBP_WIDTH (1 << 12)
#define LTDC_MAX_VBP_HEIGHT (1 << 11)
#define LTDC_MIN_ACC_HBP_WIDTH 1
#define LTDC_MIN_ACC_VBP_HEIGHT 1
#define LTDC_MAX_ACC_HBP_WIDTH (1 << 12)
#define LTDC_MAX_ACC_VBP_HEIGHT (1 << 11)
#define LTDC_MIN_HFP_WIDTH 0
#define LTDC_MIN_VFP_HEIGHT 0
#define LTDC_MAX_HFP_WIDTH (1 << 12)
#define LTDC_MAX_VFP_HEIGHT (1 << 11)
#define LTDC_MIN_ACTIVE_WIDTH 0
#define LTDC_MIN_ACTIVE_HEIGHT 0
#define LTDC_MAX_ACTIVE_WIDTH (1 << 12)
#define LTDC_MAX_ACTIVE_HEIGHT (1 << 11)
#define LTDC_MIN_ACC_ACTIVE_WIDTH 1
#define LTDC_MIN_ACC_ACTIVE_HEIGHT 1
#define LTDC_MAX_ACC_ACTIVE_WIDTH (1 << 12)
#define LTDC_MAX_ACC_ACTIVE_HEIGHT (1 << 11)
#define LTDC_MIN_ACC_TOTAL_WIDTH 1
#define LTDC_MIN_ACC_TOTAL_HEIGHT 1
#define LTDC_MAX_ACC_TOTAL_WIDTH (1 << 12)
#define LTDC_MAX_ACC_TOTAL_HEIGHT (1 << 11)
#define LTDC_MIN_LINE_INTERRUPT_POS 0
#define LTDC_MAX_LINE_INTERRUPT_POS ((1 << 11) - 1)
#define LTDC_MIN_WINDOW_HSTART 0
#define LTDC_MIN_WINDOW_HSTART 0
#define LTDC_MAX_WINDOW_HSTOP ((1 << 12) - 1)
#define LTDC_MAX_WINDOW_HSTOP ((1 << 12) - 1)
#define LTDC_MIN_WINDOW_VSTART 0
#define LTDC_MIN_WINDOW_VSTART 0
#define LTDC_MAX_WINDOW_VSTOP ((1 << 11) - 1)
#define LTDC_MAX_WINDOW_VSTOP ((1 << 11) - 1)
#define LTDC_MIN_FRAME_WIDTH_BYTES 0
#define LTDC_MIN_FRAME_HEIGHT_LINES 0
#define LTDC_MIN_FRAME_PITCH_BYTES 0
#define LTDC_MAX_FRAME_WIDTH_BYTES ((1 << 13) - 1 - 3)
#define LTDC_MAX_FRAME_HEIGHT_LINES ((1 << 11) - 1)
#define LTDC_MAX_FRAME_PITCH_BYTES ((1 << 13) - 1)
#define LTDC_MIN_PIXFMT_ID 0
#define LTDC_MAX_PIXFMT_ID 7
#define LTDC_MAX_PALETTE_LENGTH 256
/** @} */
/**
* @name LTDC basic ARGB-8888 colors.
* @{
*/
/* Microsoft Windows default 16-color palette.*/
#define LTDC_COLOR_BLACK 0xFF000000
#define LTDC_COLOR_MAROON 0xFF800000
#define LTDC_COLOR_GREEN 0xFF008000
#define LTDC_COLOR_OLIVE 0xFF808000
#define LTDC_COLOR_NAVY 0xFF000080
#define LTDC_COLOR_PURPLE 0xFF800080
#define LTDC_COLOR_TEAL 0xFF008080
#define LTDC_COLOR_SILVER 0xFFC0C0C0
#define LTDC_COLOR_GRAY 0xFF808080
#define LTDC_COLOR_RED 0xFFFF0000
#define LTDC_COLOR_LIME 0xFF00FF00
#define LTDC_COLOR_YELLOW 0xFFFFFF00
#define LTDC_COLOR_BLUE 0xFF0000FF
#define LTDC_COLOR_FUCHSIA 0xFFFF00FF
#define LTDC_COLOR_AQUA 0xFF00FFFF
#define LTDC_COLOR_WHITE 0xFFFFFFFF
/** @} */
/*===========================================================================*/
/* Driver pre-compile time settings. */
/*===========================================================================*/
/*
* These definitions should already be defined by stm32_isr.h
*/
#if !defined(STM32_LTDC_EV_NUMBER) && !defined(__DOXYGEN__)
#define STM32_LTDC_EV_NUMBER LTDC_IRQn
#endif
#if !defined(STM32_LTDC_ER_NUMBER) && !defined(__DOXYGEN__)
#define STM32_LTDC_ER_NUMBER LTDC_ER_IRQn
#endif
/*
* These definitions should already be defined by hal_lld.h
*/
#if !defined(STM32_LTDC_EV_HANDLER) && !defined(__DOXYGEN__)
#define STM32_LTDC_EV_HANDLER Vector1A0
#endif
#if !defined(STM32_LTDC_ER_HANDLER) && !defined(__DOXYGEN__)
#define STM32_LTDC_ER_HANDLER Vector1A4
#endif
#if !defined(STM32_HAS_LTDC) && !defined(__DOXYGEN__)
#ifdef STM32F429_439xx
#define STM32_HAS_LTDC TRUE
#else
#define STM32_HAS_LTDC FALSE
#endif
#endif
/**
* @name LTDC configuration options
* @{
*/
/**
* @brief LTDC event interrupt priority level setting.
*/
#if !defined(STM32_LTDC_EV_IRQ_PRIORITY) || defined(__DOXYGEN__)
#define STM32_LTDC_EV_IRQ_PRIORITY 11
#endif
/**
* @brief LTDC error interrupt priority level setting.
*/
#if !defined(STM32_LTDC_ER_IRQ_PRIORITY) || defined(__DOXYGEN__)
#define STM32_LTDC_ER_IRQ_PRIORITY 11
#endif
/**
* @brief Enables synchronous APIs.
* @note Disabling this option saves both code and data space.
*/
#if !defined(LTDC_USE_WAIT) || defined(__DOXYGEN__)
#define LTDC_USE_WAIT TRUE
#endif
/**
* @brief Enables the @p ltdcAcquireBus() and @p ltdcReleaseBus() APIs.
* @note Disabling this option saves both code and data space.
*/
#if !defined(LTDC_USE_MUTUAL_EXCLUSION) || defined(__DOXYGEN__)
#define LTDC_USE_MUTUAL_EXCLUSION TRUE
#endif
/**
* @brief Provides software color conversion functions.
* @note Disabling this option saves both code and data space.
*/
#if !defined(LTDC_USE_SOFTWARE_CONVERSIONS) || defined(__DOXYGEN__)
#define LTDC_USE_SOFTWARE_CONVERSIONS TRUE
#endif
/**
* @brief Enables checks for LTDC functions.
* @note Disabling this option saves both code and data space.
* @note Disabling checks by ChibiOS will automatically disable LTDC checks.
*/
#if !defined(LTDC_USE_CHECKS) || defined(__DOXYGEN__)
#define LTDC_USE_CHECKS TRUE
#endif
/** @} */
/*===========================================================================*/
/* Derived constants and error checks. */
/*===========================================================================*/
#ifndef STM32F429_439xx
#error "Currently only STM32F429xx and STM32F439xx are supported"
#endif
#if (TRUE != STM32_HAS_LTDC)
#error "LTDC must be present when using the LTDC subsystem"
#endif
#if (TRUE == STM32_LTDC_USE_LTDC) && (TRUE != STM32_HAS_LTDC)
#error "LTDC not present in the selected device"
#endif
#if (TRUE == LTDC_USE_MUTUAL_EXCLUSION)
#if (TRUE != CH_CFG_USE_MUTEXES) && (TRUE != CH_CFG_USE_SEMAPHORES)
#error "LTDC_USE_MUTUAL_EXCLUSION requires CH_CFG_USE_MUTEXES and/or CH_CFG_USE_SEMAPHORES"
#endif
#endif
/*===========================================================================*/
/* Driver data structures and types. */
/*===========================================================================*/
/* Complex types forwarding.*/
typedef union ltdc_coloralias_t ltdc_coloralias_t;
typedef struct ltdc_window_t ltdc_window_t;
typedef struct ltdc_frame_t ltdc_frame_t;
typedef struct ltdc_laycfg_t ltdc_laycfg_t;
typedef struct LTDCConfig LTDCConfig;
typedef enum ltdc_state_t ltdc_state_t;
typedef struct LTDCDriver LTDCDriver;
/**
* @name LTDC Data types
* @{
*/
/**
* @brief LTDC generic color.
*/
typedef uint32_t ltdc_color_t;
/**
* @brief LTDC color aliases.
* @detail Mapped with ARGB-8888, except for luminance (L mapped onto B).
* Padding fields prefixed with <tt>'x'</tt>, which should be clear
* (all 0) before compression and set (all 1) after expansion.
*/
typedef union ltdc_coloralias_t {
struct {
unsigned b : 8;
unsigned g : 8;
unsigned r : 8;
unsigned a : 8;
} argb8888; /**< Mapped ARGB-8888 bits.*/
struct {
unsigned b : 8;
unsigned g : 8;
unsigned r : 8;
unsigned xa : 8;
} rgb888; /**< Mapped RGB-888 bits.*/
struct {
unsigned xb : 3;
unsigned b : 5;
unsigned xg : 2;
unsigned g : 6;
unsigned xr : 3;
unsigned r : 5;
unsigned xa : 8;
} rgb565; /**< Mapped RGB-565 bits.*/
struct {
unsigned xb : 3;
unsigned b : 5;
unsigned xg : 3;
unsigned g : 5;
unsigned xr : 3;
unsigned r : 5;
unsigned xa : 7;
unsigned a : 1;
} argb1555; /**< Mapped ARGB-1555 values.*/
struct {
unsigned xb : 4;
unsigned b : 4;
unsigned xg : 4;
unsigned g : 4;
unsigned xr : 4;
unsigned r : 4;
unsigned xa : 4;
unsigned a : 4;
} argb4444; /**< Mapped ARGB-4444 values.*/
struct {
unsigned l : 8;
unsigned x : 16;
unsigned xa : 8;
} l8; /**< Mapped L-8 bits.*/
struct {
unsigned xl : 4;
unsigned l : 4;
unsigned x : 16;
unsigned xa : 4;
unsigned a : 4;
} al44; /**< Mapped AL-44 bits.*/
struct {
unsigned l : 8;
unsigned x : 16;
unsigned a : 8;
} al88; /**< Mapped AL-88 bits.*/
ltdc_color_t aliased; /**< Aliased raw bits.*/
} ltdc_coloralias_t;
/**
* @brief LTDC layer identifier.
*/
typedef uint32_t ltdc_layerid_t;
/**
* @brief LTDC pixel format.
*/
typedef uint32_t ltdc_pixfmt_t;
/**
* @brief LTDC blending factor.
*/
typedef uint32_t ltdc_blendf_t;
/**
* @brief LTDC ISR callback.
*/
typedef void (*ltdc_isrcb_t)(LTDCDriver *ltdcp);
/**
* @brief LTDC window specifications.
*/
typedef struct ltdc_window_t {
uint16_t hstart; /**< Horizontal start pixel (left).*/
uint16_t hstop; /**< Horizontal stop pixel (right).*/
uint16_t vstart; /**< Vertical start pixel (top).*/
uint16_t vstop; /**< Vertical stop pixel (bottom).*/
} ltdc_window_t;
/**
* @brief LTDC frame specifications.
*/
typedef struct ltdc_frame_t {
void *bufferp; /**< Frame buffer address.*/
uint16_t width; /**< Frame width, in pixels.*/
uint16_t height; /**< Frame height, in pixels.*/
size_t pitch; /**< Line pitch, in bytes.*/
ltdc_pixfmt_t fmt; /**< Pixel format.*/
} ltdc_frame_t;
/**
* @brief LTDC configuration flags.
*/
typedef uint8_t ltdc_flags_t;
/**
* @brief LTDC startup layer configuration.
*/
typedef struct ltdc_laycfg_t {
const ltdc_frame_t *frame; /**< Frame buffer specifications.*/
const ltdc_window_t *window; /**< Window specifications.*/
ltdc_color_t def_color; /**< Default color, ARGB-8888.*/
uint8_t const_alpha; /**< Constant alpha factor.*/
ltdc_color_t key_color; /**< Color key.*/
const ltdc_color_t *pal_colors; /**< Palette colors, or @p NULL.*/
uint16_t pal_length; /**< Palette length, or @p 0.*/
ltdc_blendf_t blending; /**< Blending factors.*/
ltdc_flags_t flags; /**< Layer configuration flags.*/
} ltdc_laycfg_t;
/**
* @brief LTDC driver configuration.
*/
typedef struct LTDCConfig {
/* Display specifications.*/
uint16_t screen_width; /**< Screen pixel width.*/
uint16_t screen_height; /**< Screen pixel height.*/
uint16_t hsync_width; /**< Horizontal sync pixel width.*/
uint16_t vsync_height; /**< Vertical sync pixel height.*/
uint16_t hbp_width; /**< Horizontal back porch pixel width.*/
uint16_t vbp_height; /**< Vertical back porch pixel height.*/
uint16_t hfp_width; /**< Horizontal front porch pixel width.*/
uint16_t vfp_height; /**< Vertical front porch pixel height.*/
ltdc_flags_t flags; /**< Driver configuration flags.*/
/* ISR callbacks.*/
ltdc_isrcb_t line_isr; /**< Line Interrupt ISR, or @p NULL.*/
ltdc_isrcb_t rr_isr; /**< Register Reload ISR, or @p NULL.*/
ltdc_isrcb_t fuerr_isr; /**< FIFO Underrun ISR, or @p NULL.*/
ltdc_isrcb_t terr_isr; /**< Transfer Error ISR, or @p NULL.*/
/* Layer and color settings.*/
ltdc_color_t clear_color; /**< Clear screen color, RGB-888.*/
const ltdc_laycfg_t *bg_laycfg; /**< Background layer specs, or @p NULL.*/
const ltdc_laycfg_t *fg_laycfg; /**< Foreground layer specs, or @p NULL.*/
} LTDCConfig;
/**
* @brief LTDC driver state.
*/
typedef enum ltdc_state_t {
LTDC_UNINIT = 0, /**< Not initialized.*/
LTDC_STOP = 1, /**< Stopped.*/
LTDC_READY = 2, /**< Ready.*/
LTDC_ACTIVE = 3, /**< Executing commands.*/
} ltdc_state_t;
/**
* @brief LTDC driver.
*/
typedef struct LTDCDriver {
ltdc_state_t state; /**< Driver state.*/
const LTDCConfig *config; /**< Driver configuration.*/
/* Handy computations.*/
ltdc_window_t active_window; /**< Active window coordinates.*/
/* Multithreading stuff.*/
#if (TRUE == LTDC_USE_WAIT) || defined(__DOXYGEN__)
thread_t *thread; /**< Waiting thread.*/
#endif /* LTDC_USE_WAIT */
#if (TRUE == LTDC_USE_MUTUAL_EXCLUSION)
#if (TRUE == CH_CFG_USE_MUTEXES)
mutex_t lock; /**< Multithreading lock.*/
#elif (TRUE == CH_CFG_USE_SEMAPHORES)
semaphore_t lock; /**< Multithreading lock.*/
#endif
#endif /* LTDC_USE_MUTUAL_EXCLUSION */
} LTDCDriver;
/** @} */
/*===========================================================================*/
/* Driver macros. */
/*===========================================================================*/
/**
* @brief Makes an ARGB-8888 value from byte components.
*
* @param[in] a alpha byte component
* @param[in] r red byte component
* @param[in] g green byte component
* @param[in] b blue byte component
*
* @return color in ARGB-8888 format
*
* @api
*/
#define ltdcMakeARGB8888(a, r, g, b) \
((((ltdc_color_t)(a) & 0xFF) << 24) | \
(((ltdc_color_t)(r) & 0xFF) << 16) | \
(((ltdc_color_t)(g) & 0xFF) << 8) | \
(((ltdc_color_t)(b) & 0xFF) << 0))
/**
* @brief Compute bytes per pixel.
* @details Computes the bytes per pixel for the specified pixel format.
* Rounds to the ceiling.
*
* @param[in] fmt pixel format
*
* @return bytes per pixel
*
* @api
*/
#define ltdcBytesPerPixel(fmt) \
((ltdcBitsPerPixel(fmt) + 7) >> 3)
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
extern LTDCDriver LTDCD1;
#ifdef __cplusplus
extern "C" {
#endif
/* Driver methods.*/
void ltdcInit(void);
void ltdcObjectInit(LTDCDriver *ltdcp);
ltdc_state_t ltdcGetStateI(LTDCDriver *ltdcp);
ltdc_state_t ltdcGetState(LTDCDriver *ltdcp);
void ltdcStart(LTDCDriver *ltdcp, const LTDCConfig *configp);
void ltdcStop(LTDCDriver *ltdcp);
#if (TRUE == LTDC_USE_MUTUAL_EXCLUSION)
void ltdcAcquireBusS(LTDCDriver *ltdcp);
void ltdcAcquireBus(LTDCDriver *ltdcp);
void ltdcReleaseBusS(LTDCDriver *ltdcp);
void ltdcReleaseBus(LTDCDriver *ltdcp);
#endif /* LTDC_USE_MUTUAL_EXCLUSION */
/* Global methods.*/
ltdc_flags_t ltdcGetEnableFlagsI(LTDCDriver *ltdcp);
ltdc_flags_t ltdcGetEnableFlags(LTDCDriver *ltdcp);
void ltdcSetEnableFlagsI(LTDCDriver *ltdcp, ltdc_flags_t flags);
void ltdcSetEnableFlags(LTDCDriver *ltdcp, ltdc_flags_t flags);
bool ltdcIsReloadingI(LTDCDriver *ltdcp);
bool ltdcIsReloading(LTDCDriver *ltdcp);
void ltdcStartReloadI(LTDCDriver *ltdcp, bool immediately);
void ltdcStartReload(LTDCDriver *ltdcp, bool immediately);
void ltdcReloadS(LTDCDriver *ltdcp, bool immediately);
void ltdcReload(LTDCDriver *ltdcp, bool immediately);
bool ltdcIsDitheringEnabledI(LTDCDriver *ltdcp);
bool ltdcIsDitheringEnabled(LTDCDriver *ltdcp);
void ltdcEnableDitheringI(LTDCDriver *ltdcp);
void ltdcEnableDithering(LTDCDriver *ltdcp);
void ltdcDisableDitheringI(LTDCDriver *ltdcp);
void ltdcDisableDithering(LTDCDriver *ltdcp);
ltdc_color_t ltdcGetClearColorI(LTDCDriver *ltdcp);
ltdc_color_t ltdcGetClearColor(LTDCDriver *ltdcp);
void ltdcSetClearColorI(LTDCDriver *ltdcp, ltdc_color_t c);
void ltdcSetClearColor(LTDCDriver *ltdcp, ltdc_color_t c);
uint16_t ltdcGetLineInterruptPosI(LTDCDriver *ltdcp);
uint16_t ltdcGetLineInterruptPos(LTDCDriver *ltdcp);
void ltdcSetLineInterruptPosI(LTDCDriver *ltdcp, uint16_t line);
void ltdcSetLineInterruptPos(LTDCDriver *ltdcp, uint16_t line);
bool ltdcIsLineInterruptEnabledI(LTDCDriver *ltdcp);
bool ltdcIsLineInterruptEnabled(LTDCDriver *ltdcp);
void ltdcEnableLineInterruptI(LTDCDriver *ltdcp);
void ltdcEnableLineInterrupt(LTDCDriver *ltdcp);
void ltdcDisableLineInterruptI(LTDCDriver *ltdcp);
void ltdcDisableLineInterrupt(LTDCDriver *ltdcp);
void ltdcGetCurrentPosI(LTDCDriver *ltdcp, uint16_t *xp, uint16_t *yp);
void ltdcGetCurrentPos(LTDCDriver *ltdcp, uint16_t *xp, uint16_t *yp);
/* Background layer methods.*/
ltdc_flags_t ltdcBgGetEnableFlagsI(LTDCDriver *ltdcp);
ltdc_flags_t ltdcBgGetEnableFlags(LTDCDriver *ltdcp);
void ltdcBgSetEnableFlagsI(LTDCDriver *ltdcp, ltdc_flags_t flags);
void ltdcBgSetEnableFlags(LTDCDriver *ltdcp, ltdc_flags_t flags);
bool ltdcBgIsEnabledI(LTDCDriver *ltdcp);
bool ltdcBgIsEnabled(LTDCDriver *ltdcp);
void ltdcBgEnableI(LTDCDriver *ltdcp);
void ltdcBgEnable(LTDCDriver *ltdcp);
void ltdcBgDisableI(LTDCDriver *ltdcp);
void ltdcBgDisable(LTDCDriver *ltdcp);
bool ltdcBgIsPaletteEnabledI(LTDCDriver *ltdcp);
bool ltdcBgIsPaletteEnabled(LTDCDriver *ltdcp);
void ltdcBgEnablePaletteI(LTDCDriver *ltdcp);
void ltdcBgEnablePalette(LTDCDriver *ltdcp);
void ltdcBgDisablePaletteI(LTDCDriver *ltdcp);
void ltdcBgDisablePalette(LTDCDriver *ltdcp);
void ltdcBgSetPaletteColorI(LTDCDriver *ltdcp, uint8_t slot, ltdc_color_t c);
void ltdcBgSetPaletteColor(LTDCDriver *ltdcp, uint8_t slot, ltdc_color_t c);
void ltdcBgSetPaletteI(LTDCDriver *ltdcp, const ltdc_color_t colors[],
uint16_t length);
void ltdcBgSetPalette(LTDCDriver *ltdcp, const ltdc_color_t colors[],
uint16_t length);
ltdc_pixfmt_t ltdcBgGetPixelFormatI(LTDCDriver *ltdcp);
ltdc_pixfmt_t ltdcBgGetPixelFormat(LTDCDriver *ltdcp);
void ltdcBgSetPixelFormatI(LTDCDriver *ltdcp, ltdc_pixfmt_t fmt);
void ltdcBgSetPixelFormat(LTDCDriver *ltdcp, ltdc_pixfmt_t fmt);
bool ltdcBgIsKeyingEnabledI(LTDCDriver *ltdcp);
bool ltdcBgIsKeyingEnabled(LTDCDriver *ltdcp);
void ltdcBgEnableKeyingI(LTDCDriver *ltdcp);
void ltdcBgEnableKeying(LTDCDriver *ltdcp);
void ltdcBgDisableKeyingI(LTDCDriver *ltdcp);
void ltdcBgDisableKeying(LTDCDriver *ltdcp);
ltdc_color_t ltdcBgGetKeyingColorI(LTDCDriver *ltdcp);
ltdc_color_t ltdcBgGetKeyingColor(LTDCDriver *ltdcp);
void ltdcBgSetKeyingColorI(LTDCDriver *ltdcp, ltdc_color_t c);
void ltdcBgSetKeyingColor(LTDCDriver *ltdcp, ltdc_color_t c);
uint8_t ltdcBgGetConstantAlphaI(LTDCDriver *ltdcp);
uint8_t ltdcBgGetConstantAlpha(LTDCDriver *ltdcp);
void ltdcBgSetConstantAlphaI(LTDCDriver *ltdcp, uint8_t a);
void ltdcBgSetConstantAlpha(LTDCDriver *ltdcp, uint8_t a);
ltdc_color_t ltdcBgGetDefaultColorI(LTDCDriver *ltdcp);
ltdc_color_t ltdcBgGetDefaultColor(LTDCDriver *ltdcp);
void ltdcBgSetDefaultColorI(LTDCDriver *ltdcp, ltdc_color_t c);
void ltdcBgSetDefaultColor(LTDCDriver *ltdcp, ltdc_color_t c);
ltdc_blendf_t ltdcBgGetBlendingFactorsI(LTDCDriver *ltdcp);
ltdc_blendf_t ltdcBgGetBlendingFactors(LTDCDriver *ltdcp);
void ltdcBgSetBlendingFactorsI(LTDCDriver *ltdcp, ltdc_blendf_t bf);
void ltdcBgSetBlendingFactors(LTDCDriver *ltdcp, ltdc_blendf_t bf);
void ltdcBgGetWindowI(LTDCDriver *ltdcp, ltdc_window_t *windowp);
void ltdcBgGetWindow(LTDCDriver *ltdcp, ltdc_window_t *windowp);
void ltdcBgSetWindowI(LTDCDriver *ltdcp, const ltdc_window_t *windowp);
void ltdcBgSetWindow(LTDCDriver *ltdcp, const ltdc_window_t *windowp);
void ltdcBgSetInvalidWindowI(LTDCDriver *ltdcp);
void ltdcBgSetInvalidWindow(LTDCDriver *ltdcp);
void ltdcBgGetFrameI(LTDCDriver *ltdcp, ltdc_frame_t *framep);
void ltdcBgGetFrame(LTDCDriver *ltdcp, ltdc_frame_t *framep);
void ltdcBgSetFrameI(LTDCDriver *ltdcp, const ltdc_frame_t *framep);
void ltdcBgSetFrame(LTDCDriver *ltdcp, const ltdc_frame_t *framep);
void *ltdcBgGetFrameAddressI(LTDCDriver *ltdcp);
void *ltdcBgGetFrameAddress(LTDCDriver *ltdcp);
void ltdcBgSetFrameAddressI(LTDCDriver *ltdcp, void *bufferp);
void ltdcBgSetFrameAddress(LTDCDriver *ltdcp, void *bufferp);
void ltdcBgGetLayerI(LTDCDriver *ltdcp, ltdc_laycfg_t *cfgp);
void ltdcBgGetLayer(LTDCDriver *ltdcp, ltdc_laycfg_t *cfgp);
void ltdcBgSetConfigI(LTDCDriver *ltdcp, const ltdc_laycfg_t *cfgp);
void ltdcBgSetConfig(LTDCDriver *ltdcp, const ltdc_laycfg_t *cfgp);
/* Foreground layer methods.*/
ltdc_flags_t ltdcFgGetEnableFlagsI(LTDCDriver *ltdcp);
ltdc_flags_t ltdcFgGetEnableFlags(LTDCDriver *ltdcp);
void ltdcFgSetEnableFlagsI(LTDCDriver *ltdcp, ltdc_flags_t flags);
void ltdcFgSetEnableFlags(LTDCDriver *ltdcp, ltdc_flags_t flags);
bool ltdcFgIsEnabledI(LTDCDriver *ltdcp);
bool ltdcFgIsEnabled(LTDCDriver *ltdcp);
void ltdcFgEnableI(LTDCDriver *ltdcp);
void ltdcFgEnable(LTDCDriver *ltdcp);
void ltdcFgDisableI(LTDCDriver *ltdcp);
void ltdcFgDisable(LTDCDriver *ltdcp);
bool ltdcFgIsPaletteEnabledI(LTDCDriver *ltdcp);
bool ltdcFgIsPaletteEnabled(LTDCDriver *ltdcp);
void ltdcFgEnablePaletteI(LTDCDriver *ltdcp);
void ltdcFgEnablePalette(LTDCDriver *ltdcp);
void ltdcFgDisablePaletteI(LTDCDriver *ltdcp);
void ltdcFgDisablePalette(LTDCDriver *ltdcp);
void ltdcFgSetPaletteColorI(LTDCDriver *ltdcp, uint8_t slot, ltdc_color_t c);
void ltdcFgSetPaletteColor(LTDCDriver *ltdcp, uint8_t slot, ltdc_color_t c);
void ltdcFgSetPaletteI(LTDCDriver *ltdcp, const ltdc_color_t colors[],
uint16_t length);
void ltdcFgSetPalette(LTDCDriver *ltdcp, const ltdc_color_t colors[],
uint16_t length);
ltdc_pixfmt_t ltdcFgGetPixelFormatI(LTDCDriver *ltdcp);
ltdc_pixfmt_t ltdcFgGetPixelFormat(LTDCDriver *ltdcp);
void ltdcFgSetPixelFormatI(LTDCDriver *ltdcp, ltdc_pixfmt_t fmt);
void ltdcFgSetPixelFormat(LTDCDriver *ltdcp, ltdc_pixfmt_t fmt);
bool ltdcFgIsKeyingEnabledI(LTDCDriver *ltdcp);
bool ltdcFgIsKeyingEnabled(LTDCDriver *ltdcp);
void ltdcFgEnableKeyingI(LTDCDriver *ltdcp);
void ltdcFgEnableKeying(LTDCDriver *ltdcp);
void ltdcFgDisableKeyingI(LTDCDriver *ltdcp);
void ltdcFgDisableKeying(LTDCDriver *ltdcp);
ltdc_color_t ltdcFgGetKeyingColorI(LTDCDriver *ltdcp);
ltdc_color_t ltdcFgGetKeyingColor(LTDCDriver *ltdcp);
void ltdcFgSetKeyingColorI(LTDCDriver *ltdcp, ltdc_color_t c);
void ltdcFgSetKeyingColor(LTDCDriver *ltdcp, ltdc_color_t c);
uint8_t ltdcFgGetConstantAlphaI(LTDCDriver *ltdcp);
uint8_t ltdcFgGetConstantAlpha(LTDCDriver *ltdcp);
void ltdcFgSetConstantAlphaI(LTDCDriver *ltdcp, uint8_t a);
void ltdcFgSetConstantAlpha(LTDCDriver *ltdcp, uint8_t a);
ltdc_color_t ltdcFgGetDefaultColorI(LTDCDriver *ltdcp);
ltdc_color_t ltdcFgGetDefaultColor(LTDCDriver *ltdcp);
void ltdcFgSetDefaultColorI(LTDCDriver *ltdcp, ltdc_color_t c);
void ltdcFgSetDefaultColor(LTDCDriver *ltdcp, ltdc_color_t c);
ltdc_blendf_t ltdcFgGetBlendingFactorsI(LTDCDriver *ltdcp);
ltdc_blendf_t ltdcFgGetBlendingFactors(LTDCDriver *ltdcp);
void ltdcFgSetBlendingFactorsI(LTDCDriver *ltdcp, ltdc_blendf_t bf);
void ltdcFgSetBlendingFactors(LTDCDriver *ltdcp, ltdc_blendf_t bf);
void ltdcFgGetWindowI(LTDCDriver *ltdcp, ltdc_window_t *windowp);
void ltdcFgGetWindow(LTDCDriver *ltdcp, ltdc_window_t *windowp);
void ltdcFgSetWindowI(LTDCDriver *ltdcp, const ltdc_window_t *windowp);
void ltdcFgSetWindow(LTDCDriver *ltdcp, const ltdc_window_t *windowp);
void ltdcFgSetInvalidWindowI(LTDCDriver *ltdcp);
void ltdcFgSetInvalidWindow(LTDCDriver *ltdcp);
void ltdcFgGetFrameI(LTDCDriver *ltdcp, ltdc_frame_t *framep);
void ltdcFgGetFrame(LTDCDriver *ltdcp, ltdc_frame_t *framep);
void ltdcFgSetFrameI(LTDCDriver *ltdcp, const ltdc_frame_t *framep);
void ltdcFgSetFrame(LTDCDriver *ltdcp, const ltdc_frame_t *framep);
void *ltdcFgGetFrameAddressI(LTDCDriver *ltdcp);
void *ltdcFgGetFrameAddress(LTDCDriver *ltdcp);
void ltdcFgSetFrameAddressI(LTDCDriver *ltdcp, void *bufferp);
void ltdcFgSetFrameAddress(LTDCDriver *ltdcp, void *bufferp);
void ltdcFgGetLayerI(LTDCDriver *ltdcp, ltdc_laycfg_t *cfgp);
void ltdcFgGetLayer(LTDCDriver *ltdcp, ltdc_laycfg_t *cfgp);
void ltdcFgSetConfigI(LTDCDriver *ltdcp, const ltdc_laycfg_t *cfgp);
void ltdcFgSetConfig(LTDCDriver *ltdcp, const ltdc_laycfg_t *cfgp);
/* Helper functions.*/
size_t ltdcBitsPerPixel(ltdc_pixfmt_t fmt);
#if (TRUE == LTDC_USE_SOFTWARE_CONVERSIONS) || defined(__DOXYGEN__)
ltdc_color_t ltdcFromARGB8888(ltdc_color_t c, ltdc_pixfmt_t fmt);
ltdc_color_t ltdcToARGB8888(ltdc_color_t c, ltdc_pixfmt_t fmt);
#endif /* LTDC_USE_SOFTWARE_CONVERSIONS */
#ifdef __cplusplus
}
#endif
#endif /* STM32_LTDC_USE_LTDC */
#endif /* _STM32_LTDC_H_ */
/** @} */
Reference in New Issue View Git Blame Copy Permalink