mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F7/device/stm32f7xx_hal_ltdc.c@149:156823d33999, 2016-10-28 (annotated)

Committer:
<>
Date:
Fri Oct 28 11:17:30 2016 +0100
Revision:
149:156823d33999
Parent:
targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_ltdc.c@144:ef7eb2e8f9f7
Child:
157:ff67d9f36b67
This updates the lib to the mbed lib v128



NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f7xx_hal_ltdc.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @version V1.1.0
<> 144:ef7eb2e8f9f7 6 * @date 22-April-2016
<> 144:ef7eb2e8f9f7 7 * @brief LTDC HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 9 * functionalities of the LTDC peripheral:
<> 144:ef7eb2e8f9f7 10 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 11 * + IO operation functions
<> 144:ef7eb2e8f9f7 12 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 13 * + Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 @verbatim
<> 144:ef7eb2e8f9f7 16 ==============================================================================
<> 144:ef7eb2e8f9f7 17 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 18 ==============================================================================
<> 144:ef7eb2e8f9f7 19 [..]
<> 144:ef7eb2e8f9f7 20 (#) Program the required configuration through the following parameters:
<> 144:ef7eb2e8f9f7 21 the LTDC timing, the horizontal and vertical polarity,
<> 144:ef7eb2e8f9f7 22 the pixel clock polarity, Data Enable polarity and the LTDC background color value
<> 144:ef7eb2e8f9f7 23 using HAL_LTDC_Init() function
<> 144:ef7eb2e8f9f7 24
<> 144:ef7eb2e8f9f7 25 (#) Program the required configuration through the following parameters:
<> 144:ef7eb2e8f9f7 26 the pixel format, the blending factors, input alpha value, the window size
<> 144:ef7eb2e8f9f7 27 and the image size using HAL_LTDC_ConfigLayer() function for foreground
<> 144:ef7eb2e8f9f7 28 or/and background layer.
<> 144:ef7eb2e8f9f7 29
<> 144:ef7eb2e8f9f7 30 (#) Optionally, configure and enable the CLUT using HAL_LTDC_ConfigCLUT() and
<> 144:ef7eb2e8f9f7 31 HAL_LTDC_EnableCLUT functions.
<> 144:ef7eb2e8f9f7 32
<> 144:ef7eb2e8f9f7 33 (#) Optionally, enable the Dither using HAL_LTDC_EnableDither().
<> 144:ef7eb2e8f9f7 34
<> 144:ef7eb2e8f9f7 35 (#) Optionally, configure and enable the Color keying using HAL_LTDC_ConfigColorKeying()
<> 144:ef7eb2e8f9f7 36 and HAL_LTDC_EnableColorKeying functions.
<> 144:ef7eb2e8f9f7 37
<> 144:ef7eb2e8f9f7 38 (#) Optionally, configure LineInterrupt using HAL_LTDC_ProgramLineEvent()
<> 144:ef7eb2e8f9f7 39 function
<> 144:ef7eb2e8f9f7 40
<> 144:ef7eb2e8f9f7 41 (#) If needed, reconfigure and change the pixel format value, the alpha value
<> 144:ef7eb2e8f9f7 42 value, the window size, the window position and the layer start address
<> 144:ef7eb2e8f9f7 43 for foreground or/and background layer using respectively the following
<> 144:ef7eb2e8f9f7 44 functions: HAL_LTDC_SetPixelFormat(), HAL_LTDC_SetAlpha(), HAL_LTDC_SetWindowSize(),
<> 144:ef7eb2e8f9f7 45 HAL_LTDC_SetWindowPosition(), HAL_LTDC_SetAddress.
<> 144:ef7eb2e8f9f7 46
<> 144:ef7eb2e8f9f7 47 (#) Variant functions with “_NoReload” post fix allows to set the LTDC configuration/settings without immediate reload.
<> 144:ef7eb2e8f9f7 48 This is useful in case when the program requires to modify serval LTDC settings (on one or both layers)
<> 144:ef7eb2e8f9f7 49 then applying(reload) these settings in one shot by calling the function “HAL_LTDC_Reload”
<> 144:ef7eb2e8f9f7 50
<> 144:ef7eb2e8f9f7 51 After calling the “_NoReload” functions to set different color/format/layer settings,
<> 144:ef7eb2e8f9f7 52 the program can call the function “HAL_LTDC_Reload” To apply(Reload) these settings.
<> 144:ef7eb2e8f9f7 53 Function “HAL_LTDC_Reload” can be called with the parameter “ReloadType”
<> 144:ef7eb2e8f9f7 54 set to LTDC_RELOAD_IMMEDIATE if an immediate reload is required.
<> 144:ef7eb2e8f9f7 55 Function “HAL_LTDC_Reload” can be called with the parameter “ReloadType”
<> 144:ef7eb2e8f9f7 56 set to LTDC_RELOAD_VERTICAL_BLANKING if the reload should be done in the next vertical blanking period,
<> 144:ef7eb2e8f9f7 57 this option allows to avoid display flicker by applying the new settings during the vertical blanking period.
<> 144:ef7eb2e8f9f7 58
<> 144:ef7eb2e8f9f7 59
<> 144:ef7eb2e8f9f7 60 (#) To control LTDC state you can use the following function: HAL_LTDC_GetState()
<> 144:ef7eb2e8f9f7 61
<> 144:ef7eb2e8f9f7 62 *** LTDC HAL driver macros list ***
<> 144:ef7eb2e8f9f7 63 =============================================
<> 144:ef7eb2e8f9f7 64 [..]
<> 144:ef7eb2e8f9f7 65 Below the list of most used macros in LTDC HAL driver.
<> 144:ef7eb2e8f9f7 66
<> 144:ef7eb2e8f9f7 67 (+) __HAL_LTDC_ENABLE: Enable the LTDC.
<> 144:ef7eb2e8f9f7 68 (+) __HAL_LTDC_DISABLE: Disable the LTDC.
<> 144:ef7eb2e8f9f7 69 (+) __HAL_LTDC_LAYER_ENABLE: Enable the LTDC Layer.
<> 144:ef7eb2e8f9f7 70 (+) __HAL_LTDC_LAYER_DISABLE: Disable the LTDC Layer.
<> 144:ef7eb2e8f9f7 71 (+) __HAL_LTDC_RELOAD_CONFIG: Reload Layer Configuration.
<> 144:ef7eb2e8f9f7 72 (+) __HAL_LTDC_GET_FLAG: Get the LTDC pending flags.
<> 144:ef7eb2e8f9f7 73 (+) __HAL_LTDC_CLEAR_FLAG: Clear the LTDC pending flags.
<> 144:ef7eb2e8f9f7 74 (+) __HAL_LTDC_ENABLE_IT: Enable the specified LTDC interrupts.
<> 144:ef7eb2e8f9f7 75 (+) __HAL_LTDC_DISABLE_IT: Disable the specified LTDC interrupts.
<> 144:ef7eb2e8f9f7 76 (+) __HAL_LTDC_GET_IT_SOURCE: Check whether the specified LTDC interrupt has occurred or not.
<> 144:ef7eb2e8f9f7 77
<> 144:ef7eb2e8f9f7 78 [..]
<> 144:ef7eb2e8f9f7 79 (@) You can refer to the LTDC HAL driver header file for more useful macros
<> 144:ef7eb2e8f9f7 80
<> 144:ef7eb2e8f9f7 81 @endverbatim
<> 144:ef7eb2e8f9f7 82 ******************************************************************************
<> 144:ef7eb2e8f9f7 83 * @attention
<> 144:ef7eb2e8f9f7 84 *
<> 144:ef7eb2e8f9f7 85 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 86 *
<> 144:ef7eb2e8f9f7 87 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 88 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 89 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 90 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 91 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 92 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 93 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 94 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 95 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 96 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 97 *
<> 144:ef7eb2e8f9f7 98 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 99 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 100 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 101 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 102 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 103 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 104 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 105 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 106 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 107 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 108 *
<> 144:ef7eb2e8f9f7 109 ******************************************************************************
<> 144:ef7eb2e8f9f7 110 */
<> 144:ef7eb2e8f9f7 111
<> 144:ef7eb2e8f9f7 112 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 113 #include "stm32f7xx_hal.h"
<> 144:ef7eb2e8f9f7 114
<> 144:ef7eb2e8f9f7 115 /** @addtogroup STM32F7xx_HAL_Driver
<> 144:ef7eb2e8f9f7 116 * @{
<> 144:ef7eb2e8f9f7 117 */
<> 144:ef7eb2e8f9f7 118 #if defined (STM32F746xx) || defined (STM32F756xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx)
<> 144:ef7eb2e8f9f7 119
<> 144:ef7eb2e8f9f7 120 /** @defgroup LTDC LTDC
<> 144:ef7eb2e8f9f7 121 * @brief LTDC HAL module driver
<> 144:ef7eb2e8f9f7 122 * @{
<> 144:ef7eb2e8f9f7 123 */
<> 144:ef7eb2e8f9f7 124
<> 144:ef7eb2e8f9f7 125 #ifdef HAL_LTDC_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 126
<> 144:ef7eb2e8f9f7 127 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 128 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 129 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 130 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 131 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 132 static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx);
<> 144:ef7eb2e8f9f7 133 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 134
<> 144:ef7eb2e8f9f7 135 /** @defgroup LTDC_Exported_Functions LTDC Exported Functions
<> 144:ef7eb2e8f9f7 136 * @{
<> 144:ef7eb2e8f9f7 137 */
<> 144:ef7eb2e8f9f7 138
<> 144:ef7eb2e8f9f7 139 /** @defgroup LTDC_Exported_Functions_Group1 Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 140 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 141 *
<> 144:ef7eb2e8f9f7 142 @verbatim
<> 144:ef7eb2e8f9f7 143 ===============================================================================
<> 144:ef7eb2e8f9f7 144 ##### Initialization and Configuration functions #####
<> 144:ef7eb2e8f9f7 145 ===============================================================================
<> 144:ef7eb2e8f9f7 146 [..] This section provides functions allowing to:
<> 144:ef7eb2e8f9f7 147 (+) Initialize and configure the LTDC
<> 144:ef7eb2e8f9f7 148 (+) De-initialize the LTDC
<> 144:ef7eb2e8f9f7 149
<> 144:ef7eb2e8f9f7 150 @endverbatim
<> 144:ef7eb2e8f9f7 151 * @{
<> 144:ef7eb2e8f9f7 152 */
<> 144:ef7eb2e8f9f7 153
<> 144:ef7eb2e8f9f7 154 /**
<> 144:ef7eb2e8f9f7 155 * @brief Initializes the LTDC according to the specified
<> 144:ef7eb2e8f9f7 156 * parameters in the LTDC_InitTypeDef and create the associated handle.
<> 144:ef7eb2e8f9f7 157 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 158 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 159 * @retval HAL status
<> 144:ef7eb2e8f9f7 160 */
<> 144:ef7eb2e8f9f7 161 HAL_StatusTypeDef HAL_LTDC_Init(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 162 {
<> 144:ef7eb2e8f9f7 163 uint32_t tmp = 0, tmp1 = 0;
<> 144:ef7eb2e8f9f7 164
<> 144:ef7eb2e8f9f7 165 /* Check the LTDC peripheral state */
<> 144:ef7eb2e8f9f7 166 if(hltdc == NULL)
<> 144:ef7eb2e8f9f7 167 {
<> 144:ef7eb2e8f9f7 168 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 169 }
<> 144:ef7eb2e8f9f7 170
<> 144:ef7eb2e8f9f7 171 /* Check function parameters */
<> 144:ef7eb2e8f9f7 172 assert_param(IS_LTDC_ALL_INSTANCE(hltdc->Instance));
<> 144:ef7eb2e8f9f7 173 assert_param(IS_LTDC_HSYNC(hltdc->Init.HorizontalSync));
<> 144:ef7eb2e8f9f7 174 assert_param(IS_LTDC_VSYNC(hltdc->Init.VerticalSync));
<> 144:ef7eb2e8f9f7 175 assert_param(IS_LTDC_AHBP(hltdc->Init.AccumulatedHBP));
<> 144:ef7eb2e8f9f7 176 assert_param(IS_LTDC_AVBP(hltdc->Init.AccumulatedVBP));
<> 144:ef7eb2e8f9f7 177 assert_param(IS_LTDC_AAH(hltdc->Init.AccumulatedActiveH));
<> 144:ef7eb2e8f9f7 178 assert_param(IS_LTDC_AAW(hltdc->Init.AccumulatedActiveW));
<> 144:ef7eb2e8f9f7 179 assert_param(IS_LTDC_TOTALH(hltdc->Init.TotalHeigh));
<> 144:ef7eb2e8f9f7 180 assert_param(IS_LTDC_TOTALW(hltdc->Init.TotalWidth));
<> 144:ef7eb2e8f9f7 181 assert_param(IS_LTDC_HSPOL(hltdc->Init.HSPolarity));
<> 144:ef7eb2e8f9f7 182 assert_param(IS_LTDC_VSPOL(hltdc->Init.VSPolarity));
<> 144:ef7eb2e8f9f7 183 assert_param(IS_LTDC_DEPOL(hltdc->Init.DEPolarity));
<> 144:ef7eb2e8f9f7 184 assert_param(IS_LTDC_PCPOL(hltdc->Init.PCPolarity));
<> 144:ef7eb2e8f9f7 185
<> 144:ef7eb2e8f9f7 186 if(hltdc->State == HAL_LTDC_STATE_RESET)
<> 144:ef7eb2e8f9f7 187 {
<> 144:ef7eb2e8f9f7 188 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 189 hltdc->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 190 /* Init the low level hardware */
<> 144:ef7eb2e8f9f7 191 HAL_LTDC_MspInit(hltdc);
<> 144:ef7eb2e8f9f7 192 }
<> 144:ef7eb2e8f9f7 193
<> 144:ef7eb2e8f9f7 194 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 195 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 196
<> 144:ef7eb2e8f9f7 197 /* Configures the HS, VS, DE and PC polarity */
<> 144:ef7eb2e8f9f7 198 hltdc->Instance->GCR &= ~(LTDC_GCR_HSPOL | LTDC_GCR_VSPOL | LTDC_GCR_DEPOL | LTDC_GCR_PCPOL);
<> 144:ef7eb2e8f9f7 199 hltdc->Instance->GCR |= (uint32_t)(hltdc->Init.HSPolarity | hltdc->Init.VSPolarity | \
<> 144:ef7eb2e8f9f7 200 hltdc->Init.DEPolarity | hltdc->Init.PCPolarity);
<> 144:ef7eb2e8f9f7 201
<> 144:ef7eb2e8f9f7 202 /* Sets Synchronization size */
<> 144:ef7eb2e8f9f7 203 hltdc->Instance->SSCR &= ~(LTDC_SSCR_VSH | LTDC_SSCR_HSW);
<> 144:ef7eb2e8f9f7 204 tmp = (hltdc->Init.HorizontalSync << 16);
<> 144:ef7eb2e8f9f7 205 hltdc->Instance->SSCR |= (tmp | hltdc->Init.VerticalSync);
<> 144:ef7eb2e8f9f7 206
<> 144:ef7eb2e8f9f7 207 /* Sets Accumulated Back porch */
<> 144:ef7eb2e8f9f7 208 hltdc->Instance->BPCR &= ~(LTDC_BPCR_AVBP | LTDC_BPCR_AHBP);
<> 144:ef7eb2e8f9f7 209 tmp = (hltdc->Init.AccumulatedHBP << 16);
<> 144:ef7eb2e8f9f7 210 hltdc->Instance->BPCR |= (tmp | hltdc->Init.AccumulatedVBP);
<> 144:ef7eb2e8f9f7 211
<> 144:ef7eb2e8f9f7 212 /* Sets Accumulated Active Width */
<> 144:ef7eb2e8f9f7 213 hltdc->Instance->AWCR &= ~(LTDC_AWCR_AAH | LTDC_AWCR_AAW);
<> 144:ef7eb2e8f9f7 214 tmp = (hltdc->Init.AccumulatedActiveW << 16);
<> 144:ef7eb2e8f9f7 215 hltdc->Instance->AWCR |= (tmp | hltdc->Init.AccumulatedActiveH);
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 /* Sets Total Width */
<> 144:ef7eb2e8f9f7 218 hltdc->Instance->TWCR &= ~(LTDC_TWCR_TOTALH | LTDC_TWCR_TOTALW);
<> 144:ef7eb2e8f9f7 219 tmp = (hltdc->Init.TotalWidth << 16);
<> 144:ef7eb2e8f9f7 220 hltdc->Instance->TWCR |= (tmp | hltdc->Init.TotalHeigh);
<> 144:ef7eb2e8f9f7 221
<> 144:ef7eb2e8f9f7 222 /* Sets the background color value */
<> 144:ef7eb2e8f9f7 223 tmp = ((uint32_t)(hltdc->Init.Backcolor.Green) << 8);
<> 144:ef7eb2e8f9f7 224 tmp1 = ((uint32_t)(hltdc->Init.Backcolor.Red) << 16);
<> 144:ef7eb2e8f9f7 225 hltdc->Instance->BCCR &= ~(LTDC_BCCR_BCBLUE | LTDC_BCCR_BCGREEN | LTDC_BCCR_BCRED);
<> 144:ef7eb2e8f9f7 226 hltdc->Instance->BCCR |= (tmp1 | tmp | hltdc->Init.Backcolor.Blue);
<> 144:ef7eb2e8f9f7 227
<> 144:ef7eb2e8f9f7 228 /* Enable the transfer Error interrupt */
<> 144:ef7eb2e8f9f7 229 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_TE);
<> 144:ef7eb2e8f9f7 230
<> 144:ef7eb2e8f9f7 231 /* Enable the FIFO underrun interrupt */
<> 144:ef7eb2e8f9f7 232 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_FU);
<> 144:ef7eb2e8f9f7 233
<> 144:ef7eb2e8f9f7 234 /* Enable LTDC by setting LTDCEN bit */
<> 144:ef7eb2e8f9f7 235 __HAL_LTDC_ENABLE(hltdc);
<> 144:ef7eb2e8f9f7 236
<> 144:ef7eb2e8f9f7 237 /* Initialize the error code */
<> 144:ef7eb2e8f9f7 238 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE;
<> 144:ef7eb2e8f9f7 239
<> 144:ef7eb2e8f9f7 240 /* Initialize the LTDC state*/
<> 144:ef7eb2e8f9f7 241 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 242
<> 144:ef7eb2e8f9f7 243 return HAL_OK;
<> 144:ef7eb2e8f9f7 244 }
<> 144:ef7eb2e8f9f7 245
<> 144:ef7eb2e8f9f7 246 /**
<> 144:ef7eb2e8f9f7 247 * @brief Deinitializes the LTDC peripheral registers to their default reset
<> 144:ef7eb2e8f9f7 248 * values.
<> 144:ef7eb2e8f9f7 249 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 250 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 251 * @retval None
<> 144:ef7eb2e8f9f7 252 */
<> 144:ef7eb2e8f9f7 253
<> 144:ef7eb2e8f9f7 254 HAL_StatusTypeDef HAL_LTDC_DeInit(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 255 {
<> 144:ef7eb2e8f9f7 256 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 257 HAL_LTDC_MspDeInit(hltdc);
<> 144:ef7eb2e8f9f7 258
<> 144:ef7eb2e8f9f7 259 /* Initialize the error code */
<> 144:ef7eb2e8f9f7 260 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE;
<> 144:ef7eb2e8f9f7 261
<> 144:ef7eb2e8f9f7 262 /* Initialize the LTDC state*/
<> 144:ef7eb2e8f9f7 263 hltdc->State = HAL_LTDC_STATE_RESET;
<> 144:ef7eb2e8f9f7 264
<> 144:ef7eb2e8f9f7 265 /* Release Lock */
<> 144:ef7eb2e8f9f7 266 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 267
<> 144:ef7eb2e8f9f7 268 return HAL_OK;
<> 144:ef7eb2e8f9f7 269 }
<> 144:ef7eb2e8f9f7 270
<> 144:ef7eb2e8f9f7 271 /**
<> 144:ef7eb2e8f9f7 272 * @brief Initializes the LTDC MSP.
<> 144:ef7eb2e8f9f7 273 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 274 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 275 * @retval None
<> 144:ef7eb2e8f9f7 276 */
<> 144:ef7eb2e8f9f7 277 __weak void HAL_LTDC_MspInit(LTDC_HandleTypeDef* hltdc)
<> 144:ef7eb2e8f9f7 278 {
<> 144:ef7eb2e8f9f7 279 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 280 UNUSED(hltdc);
<> 144:ef7eb2e8f9f7 281
<> 144:ef7eb2e8f9f7 282 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 283 the HAL_LTDC_MspInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 284 */
<> 144:ef7eb2e8f9f7 285 }
<> 144:ef7eb2e8f9f7 286
<> 144:ef7eb2e8f9f7 287 /**
<> 144:ef7eb2e8f9f7 288 * @brief DeInitializes the LTDC MSP.
<> 144:ef7eb2e8f9f7 289 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 290 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 291 * @retval None
<> 144:ef7eb2e8f9f7 292 */
<> 144:ef7eb2e8f9f7 293 __weak void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef* hltdc)
<> 144:ef7eb2e8f9f7 294 {
<> 144:ef7eb2e8f9f7 295 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 296 UNUSED(hltdc);
<> 144:ef7eb2e8f9f7 297
<> 144:ef7eb2e8f9f7 298 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 299 the HAL_LTDC_MspDeInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 300 */
<> 144:ef7eb2e8f9f7 301 }
<> 144:ef7eb2e8f9f7 302
<> 144:ef7eb2e8f9f7 303 /**
<> 144:ef7eb2e8f9f7 304 * @}
<> 144:ef7eb2e8f9f7 305 */
<> 144:ef7eb2e8f9f7 306
<> 144:ef7eb2e8f9f7 307 /** @defgroup LTDC_Exported_Functions_Group2 IO operation functions
<> 144:ef7eb2e8f9f7 308 * @brief IO operation functions
<> 144:ef7eb2e8f9f7 309 *
<> 144:ef7eb2e8f9f7 310 @verbatim
<> 144:ef7eb2e8f9f7 311 ===============================================================================
<> 144:ef7eb2e8f9f7 312 ##### IO operation functions #####
<> 144:ef7eb2e8f9f7 313 ===============================================================================
<> 144:ef7eb2e8f9f7 314 [..] This section provides function allowing to:
<> 144:ef7eb2e8f9f7 315 (+) Handle LTDC interrupt request
<> 144:ef7eb2e8f9f7 316
<> 144:ef7eb2e8f9f7 317 @endverbatim
<> 144:ef7eb2e8f9f7 318 * @{
<> 144:ef7eb2e8f9f7 319 */
<> 144:ef7eb2e8f9f7 320 /**
<> 144:ef7eb2e8f9f7 321 * @brief Handles LTDC interrupt request.
<> 144:ef7eb2e8f9f7 322 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 323 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 324 * @retval HAL status
<> 144:ef7eb2e8f9f7 325 */
<> 144:ef7eb2e8f9f7 326 void HAL_LTDC_IRQHandler(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 327 {
<> 144:ef7eb2e8f9f7 328 /* Transfer Error Interrupt management ***************************************/
<> 144:ef7eb2e8f9f7 329 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_TE) != RESET)
<> 144:ef7eb2e8f9f7 330 {
<> 144:ef7eb2e8f9f7 331 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_TE) != RESET)
<> 144:ef7eb2e8f9f7 332 {
<> 144:ef7eb2e8f9f7 333 /* Disable the transfer Error interrupt */
<> 144:ef7eb2e8f9f7 334 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_TE);
<> 144:ef7eb2e8f9f7 335
<> 144:ef7eb2e8f9f7 336 /* Clear the transfer error flag */
<> 144:ef7eb2e8f9f7 337 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_TE);
<> 144:ef7eb2e8f9f7 338
<> 144:ef7eb2e8f9f7 339 /* Update error code */
<> 144:ef7eb2e8f9f7 340 hltdc->ErrorCode |= HAL_LTDC_ERROR_TE;
<> 144:ef7eb2e8f9f7 341
<> 144:ef7eb2e8f9f7 342 /* Change LTDC state */
<> 144:ef7eb2e8f9f7 343 hltdc->State = HAL_LTDC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 344
<> 144:ef7eb2e8f9f7 345 /* Process unlocked */
<> 144:ef7eb2e8f9f7 346 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 347
<> 144:ef7eb2e8f9f7 348 /* Transfer error Callback */
<> 144:ef7eb2e8f9f7 349 HAL_LTDC_ErrorCallback(hltdc);
<> 144:ef7eb2e8f9f7 350 }
<> 144:ef7eb2e8f9f7 351 }
<> 144:ef7eb2e8f9f7 352 /* FIFO underrun Interrupt management ***************************************/
<> 144:ef7eb2e8f9f7 353 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_FU) != RESET)
<> 144:ef7eb2e8f9f7 354 {
<> 144:ef7eb2e8f9f7 355 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_FU) != RESET)
<> 144:ef7eb2e8f9f7 356 {
<> 144:ef7eb2e8f9f7 357 /* Disable the FIFO underrun interrupt */
<> 144:ef7eb2e8f9f7 358 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_FU);
<> 144:ef7eb2e8f9f7 359
<> 144:ef7eb2e8f9f7 360 /* Clear the FIFO underrun flag */
<> 144:ef7eb2e8f9f7 361 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_FU);
<> 144:ef7eb2e8f9f7 362
<> 144:ef7eb2e8f9f7 363 /* Update error code */
<> 144:ef7eb2e8f9f7 364 hltdc->ErrorCode |= HAL_LTDC_ERROR_FU;
<> 144:ef7eb2e8f9f7 365
<> 144:ef7eb2e8f9f7 366 /* Change LTDC state */
<> 144:ef7eb2e8f9f7 367 hltdc->State = HAL_LTDC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 368
<> 144:ef7eb2e8f9f7 369 /* Process unlocked */
<> 144:ef7eb2e8f9f7 370 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 371
<> 144:ef7eb2e8f9f7 372 /* Transfer error Callback */
<> 144:ef7eb2e8f9f7 373 HAL_LTDC_ErrorCallback(hltdc);
<> 144:ef7eb2e8f9f7 374 }
<> 144:ef7eb2e8f9f7 375 }
<> 144:ef7eb2e8f9f7 376 /* Line Interrupt management ************************************************/
<> 144:ef7eb2e8f9f7 377 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_LI) != RESET)
<> 144:ef7eb2e8f9f7 378 {
<> 144:ef7eb2e8f9f7 379 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_LI) != RESET)
<> 144:ef7eb2e8f9f7 380 {
<> 144:ef7eb2e8f9f7 381 /* Disable the Line interrupt */
<> 144:ef7eb2e8f9f7 382 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_LI);
<> 144:ef7eb2e8f9f7 383
<> 144:ef7eb2e8f9f7 384 /* Clear the Line interrupt flag */
<> 144:ef7eb2e8f9f7 385 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_LI);
<> 144:ef7eb2e8f9f7 386
<> 144:ef7eb2e8f9f7 387 /* Change LTDC state */
<> 144:ef7eb2e8f9f7 388 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 389
<> 144:ef7eb2e8f9f7 390 /* Process unlocked */
<> 144:ef7eb2e8f9f7 391 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 392
<> 144:ef7eb2e8f9f7 393 /* Line interrupt Callback */
<> 144:ef7eb2e8f9f7 394 HAL_LTDC_LineEvenCallback(hltdc);
<> 144:ef7eb2e8f9f7 395 }
<> 144:ef7eb2e8f9f7 396 }
<> 144:ef7eb2e8f9f7 397 /* Register reload Interrupt management ***************************************/
<> 144:ef7eb2e8f9f7 398 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_RR) != RESET)
<> 144:ef7eb2e8f9f7 399 {
<> 144:ef7eb2e8f9f7 400 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_RR) != RESET)
<> 144:ef7eb2e8f9f7 401 {
<> 144:ef7eb2e8f9f7 402 /* Disable the register reload interrupt */
<> 144:ef7eb2e8f9f7 403 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_RR);
<> 144:ef7eb2e8f9f7 404
<> 144:ef7eb2e8f9f7 405 /* Clear the register reload flag */
<> 144:ef7eb2e8f9f7 406 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_RR);
<> 144:ef7eb2e8f9f7 407
<> 144:ef7eb2e8f9f7 408 /* Change LTDC state */
<> 144:ef7eb2e8f9f7 409 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 410
<> 144:ef7eb2e8f9f7 411 /* Process unlocked */
<> 144:ef7eb2e8f9f7 412 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 413
<> 144:ef7eb2e8f9f7 414 /* Register reload interrupt Callback */
<> 144:ef7eb2e8f9f7 415 HAL_LTDC_ReloadEventCallback(hltdc);
<> 144:ef7eb2e8f9f7 416 }
<> 144:ef7eb2e8f9f7 417 }
<> 144:ef7eb2e8f9f7 418 }
<> 144:ef7eb2e8f9f7 419
<> 144:ef7eb2e8f9f7 420 /**
<> 144:ef7eb2e8f9f7 421 * @brief Error LTDC callback.
<> 144:ef7eb2e8f9f7 422 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 423 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 424 * @retval None
<> 144:ef7eb2e8f9f7 425 */
<> 144:ef7eb2e8f9f7 426 __weak void HAL_LTDC_ErrorCallback(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 427 {
<> 144:ef7eb2e8f9f7 428 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 429 UNUSED(hltdc);
<> 144:ef7eb2e8f9f7 430
<> 144:ef7eb2e8f9f7 431 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 432 the HAL_LTDC_ErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 433 */
<> 144:ef7eb2e8f9f7 434 }
<> 144:ef7eb2e8f9f7 435
<> 144:ef7eb2e8f9f7 436 /**
<> 144:ef7eb2e8f9f7 437 * @brief Line Event callback.
<> 144:ef7eb2e8f9f7 438 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 439 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 440 * @retval None
<> 144:ef7eb2e8f9f7 441 */
<> 144:ef7eb2e8f9f7 442 __weak void HAL_LTDC_LineEvenCallback(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 443 {
<> 144:ef7eb2e8f9f7 444 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 445 UNUSED(hltdc);
<> 144:ef7eb2e8f9f7 446
<> 144:ef7eb2e8f9f7 447 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 448 the HAL_LTDC_LineEvenCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 449 */
<> 144:ef7eb2e8f9f7 450 }
<> 144:ef7eb2e8f9f7 451
<> 144:ef7eb2e8f9f7 452 /**
<> 144:ef7eb2e8f9f7 453 * @brief Reload Event callback.
<> 144:ef7eb2e8f9f7 454 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 455 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 456 * @retval None
<> 144:ef7eb2e8f9f7 457 */
<> 144:ef7eb2e8f9f7 458 __weak void HAL_LTDC_ReloadEventCallback(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 459 {
<> 144:ef7eb2e8f9f7 460 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 461 UNUSED(hltdc);
<> 144:ef7eb2e8f9f7 462
<> 144:ef7eb2e8f9f7 463 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 464 the HAL_LTDC_ReloadEvenCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 465 */
<> 144:ef7eb2e8f9f7 466 }
<> 144:ef7eb2e8f9f7 467
<> 144:ef7eb2e8f9f7 468 /**
<> 144:ef7eb2e8f9f7 469 * @}
<> 144:ef7eb2e8f9f7 470 */
<> 144:ef7eb2e8f9f7 471
<> 144:ef7eb2e8f9f7 472 /** @defgroup LTDC_Exported_Functions_Group3 Peripheral Control functions
<> 144:ef7eb2e8f9f7 473 * @brief Peripheral Control functions
<> 144:ef7eb2e8f9f7 474 *
<> 144:ef7eb2e8f9f7 475 @verbatim
<> 144:ef7eb2e8f9f7 476 ===============================================================================
<> 144:ef7eb2e8f9f7 477 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 478 ===============================================================================
<> 144:ef7eb2e8f9f7 479 [..] This section provides functions allowing to:
<> 144:ef7eb2e8f9f7 480 (+) Configure the LTDC foreground or/and background parameters.
<> 144:ef7eb2e8f9f7 481 (+) Set the active layer.
<> 144:ef7eb2e8f9f7 482 (+) Configure the color keying.
<> 144:ef7eb2e8f9f7 483 (+) Configure the C-LUT.
<> 144:ef7eb2e8f9f7 484 (+) Enable / Disable the color keying.
<> 144:ef7eb2e8f9f7 485 (+) Enable / Disable the C-LUT.
<> 144:ef7eb2e8f9f7 486 (+) Update the layer position.
<> 144:ef7eb2e8f9f7 487 (+) Update the layer size.
<> 144:ef7eb2e8f9f7 488 (+) Update pixel format on the fly.
<> 144:ef7eb2e8f9f7 489 (+) Update transparency on the fly.
<> 144:ef7eb2e8f9f7 490 (+) Update address on the fly.
<> 144:ef7eb2e8f9f7 491
<> 144:ef7eb2e8f9f7 492 @endverbatim
<> 144:ef7eb2e8f9f7 493 * @{
<> 144:ef7eb2e8f9f7 494 */
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 /**
<> 144:ef7eb2e8f9f7 497 * @brief Configure the LTDC Layer according to the specified
<> 144:ef7eb2e8f9f7 498 * parameters in the LTDC_InitTypeDef and create the associated handle.
<> 144:ef7eb2e8f9f7 499 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 500 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 501 * @param pLayerCfg: pointer to a LTDC_LayerCfgTypeDef structure that contains
<> 144:ef7eb2e8f9f7 502 * the configuration information for the Layer.
<> 144:ef7eb2e8f9f7 503 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 504 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 505 * 0 or 1
<> 144:ef7eb2e8f9f7 506 * @retval HAL status
<> 144:ef7eb2e8f9f7 507 */
<> 144:ef7eb2e8f9f7 508 HAL_StatusTypeDef HAL_LTDC_ConfigLayer(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 509 {
<> 144:ef7eb2e8f9f7 510 /* Process locked */
<> 144:ef7eb2e8f9f7 511 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 512
<> 144:ef7eb2e8f9f7 513 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 514 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 515
<> 144:ef7eb2e8f9f7 516 /* Check the parameters */
<> 144:ef7eb2e8f9f7 517 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 518 assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat));
<> 144:ef7eb2e8f9f7 519 assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1));
<> 144:ef7eb2e8f9f7 520 assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2));
<> 144:ef7eb2e8f9f7 521 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
<> 144:ef7eb2e8f9f7 522 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
<> 144:ef7eb2e8f9f7 523 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
<> 144:ef7eb2e8f9f7 524 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
<> 144:ef7eb2e8f9f7 525 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0));
<> 144:ef7eb2e8f9f7 526 assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth));
<> 144:ef7eb2e8f9f7 527 assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight));
<> 144:ef7eb2e8f9f7 528
<> 144:ef7eb2e8f9f7 529 /* Copy new layer configuration into handle structure */
<> 144:ef7eb2e8f9f7 530 hltdc->LayerCfg[LayerIdx] = *pLayerCfg;
<> 144:ef7eb2e8f9f7 531
<> 144:ef7eb2e8f9f7 532 /* Configure the LTDC Layer */
<> 144:ef7eb2e8f9f7 533 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 534
<> 144:ef7eb2e8f9f7 535 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 536 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 537
<> 144:ef7eb2e8f9f7 538 /* Initialize the LTDC state*/
<> 144:ef7eb2e8f9f7 539 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 540
<> 144:ef7eb2e8f9f7 541 /* Process unlocked */
<> 144:ef7eb2e8f9f7 542 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 543
<> 144:ef7eb2e8f9f7 544 return HAL_OK;
<> 144:ef7eb2e8f9f7 545 }
<> 144:ef7eb2e8f9f7 546
<> 144:ef7eb2e8f9f7 547 /**
<> 144:ef7eb2e8f9f7 548 * @brief Configure the color keying.
<> 144:ef7eb2e8f9f7 549 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 550 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 551 * @param RGBValue: the color key value
<> 144:ef7eb2e8f9f7 552 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 553 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 554 * 0 or 1
<> 144:ef7eb2e8f9f7 555 * @retval HAL status
<> 144:ef7eb2e8f9f7 556 */
<> 144:ef7eb2e8f9f7 557 HAL_StatusTypeDef HAL_LTDC_ConfigColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t RGBValue, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 558 {
<> 144:ef7eb2e8f9f7 559 /* Process locked */
<> 144:ef7eb2e8f9f7 560 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 561
<> 144:ef7eb2e8f9f7 562 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 563 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 564
<> 144:ef7eb2e8f9f7 565 /* Check the parameters */
<> 144:ef7eb2e8f9f7 566 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 567
<> 144:ef7eb2e8f9f7 568 /* Configures the default color values */
<> 144:ef7eb2e8f9f7 569 LTDC_LAYER(hltdc, LayerIdx)->CKCR &= ~(LTDC_LxCKCR_CKBLUE | LTDC_LxCKCR_CKGREEN | LTDC_LxCKCR_CKRED);
<> 144:ef7eb2e8f9f7 570 LTDC_LAYER(hltdc, LayerIdx)->CKCR = RGBValue;
<> 144:ef7eb2e8f9f7 571
<> 144:ef7eb2e8f9f7 572 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 573 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 574
<> 144:ef7eb2e8f9f7 575 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 576 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 577
<> 144:ef7eb2e8f9f7 578 /* Process unlocked */
<> 144:ef7eb2e8f9f7 579 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 580
<> 144:ef7eb2e8f9f7 581 return HAL_OK;
<> 144:ef7eb2e8f9f7 582 }
<> 144:ef7eb2e8f9f7 583
<> 144:ef7eb2e8f9f7 584 /**
<> 144:ef7eb2e8f9f7 585 * @brief Load the color lookup table.
<> 144:ef7eb2e8f9f7 586 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 587 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 588 * @param pCLUT: pointer to the color lookup table address.
<> 144:ef7eb2e8f9f7 589 * @param CLUTSize: the color lookup table size.
<> 144:ef7eb2e8f9f7 590 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 591 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 592 * 0 or 1
<> 144:ef7eb2e8f9f7 593 * @retval HAL status
<> 144:ef7eb2e8f9f7 594 */
<> 144:ef7eb2e8f9f7 595 HAL_StatusTypeDef HAL_LTDC_ConfigCLUT(LTDC_HandleTypeDef *hltdc, uint32_t *pCLUT, uint32_t CLUTSize, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 596 {
<> 144:ef7eb2e8f9f7 597 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 598 uint32_t counter = 0;
<> 144:ef7eb2e8f9f7 599 uint32_t pcounter = 0;
<> 144:ef7eb2e8f9f7 600
<> 144:ef7eb2e8f9f7 601 /* Process locked */
<> 144:ef7eb2e8f9f7 602 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 603
<> 144:ef7eb2e8f9f7 604 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 605 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 606
<> 144:ef7eb2e8f9f7 607 /* Check the parameters */
<> 144:ef7eb2e8f9f7 608 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 609
<> 144:ef7eb2e8f9f7 610 for(counter = 0; (counter < CLUTSize); counter++)
<> 144:ef7eb2e8f9f7 611 {
<> 144:ef7eb2e8f9f7 612 if(hltdc->LayerCfg[LayerIdx].PixelFormat == LTDC_PIXEL_FORMAT_AL44)
<> 144:ef7eb2e8f9f7 613 {
<> 144:ef7eb2e8f9f7 614 tmp = (((counter + 16*counter) << 24) | ((uint32_t)(*pCLUT) & 0xFF) | ((uint32_t)(*pCLUT) & 0xFF00) | ((uint32_t)(*pCLUT) & 0xFF0000));
<> 144:ef7eb2e8f9f7 615 }
<> 144:ef7eb2e8f9f7 616 else
<> 144:ef7eb2e8f9f7 617 {
<> 144:ef7eb2e8f9f7 618 tmp = ((counter << 24) | ((uint32_t)(*pCLUT) & 0xFF) | ((uint32_t)(*pCLUT) & 0xFF00) | ((uint32_t)(*pCLUT) & 0xFF0000));
<> 144:ef7eb2e8f9f7 619 }
<> 144:ef7eb2e8f9f7 620 pcounter = (uint32_t)pCLUT + sizeof(*pCLUT);
<> 144:ef7eb2e8f9f7 621 pCLUT = (uint32_t *)pcounter;
<> 144:ef7eb2e8f9f7 622
<> 144:ef7eb2e8f9f7 623 /* Specifies the C-LUT address and RGB value */
<> 144:ef7eb2e8f9f7 624 LTDC_LAYER(hltdc, LayerIdx)->CLUTWR = tmp;
<> 144:ef7eb2e8f9f7 625 }
<> 144:ef7eb2e8f9f7 626
<> 144:ef7eb2e8f9f7 627 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 628 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 629
<> 144:ef7eb2e8f9f7 630 /* Process unlocked */
<> 144:ef7eb2e8f9f7 631 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 632
<> 144:ef7eb2e8f9f7 633 return HAL_OK;
<> 144:ef7eb2e8f9f7 634 }
<> 144:ef7eb2e8f9f7 635
<> 144:ef7eb2e8f9f7 636 /**
<> 144:ef7eb2e8f9f7 637 * @brief Enable the color keying.
<> 144:ef7eb2e8f9f7 638 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 639 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 640 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 641 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 642 * 0 or 1
<> 144:ef7eb2e8f9f7 643 * @retval HAL status
<> 144:ef7eb2e8f9f7 644 */
<> 144:ef7eb2e8f9f7 645 HAL_StatusTypeDef HAL_LTDC_EnableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 646 {
<> 144:ef7eb2e8f9f7 647 /* Process locked */
<> 144:ef7eb2e8f9f7 648 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 649
<> 144:ef7eb2e8f9f7 650 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 651 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 652
<> 144:ef7eb2e8f9f7 653 /* Check the parameters */
<> 144:ef7eb2e8f9f7 654 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 655
<> 144:ef7eb2e8f9f7 656 /* Enable LTDC color keying by setting COLKEN bit */
<> 144:ef7eb2e8f9f7 657 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_COLKEN;
<> 144:ef7eb2e8f9f7 658
<> 144:ef7eb2e8f9f7 659 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 660 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 661
<> 144:ef7eb2e8f9f7 662 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 663 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 664
<> 144:ef7eb2e8f9f7 665 /* Process unlocked */
<> 144:ef7eb2e8f9f7 666 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 667
<> 144:ef7eb2e8f9f7 668 return HAL_OK;
<> 144:ef7eb2e8f9f7 669 }
<> 144:ef7eb2e8f9f7 670
<> 144:ef7eb2e8f9f7 671 /**
<> 144:ef7eb2e8f9f7 672 * @brief Disable the color keying.
<> 144:ef7eb2e8f9f7 673 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 674 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 675 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 676 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 677 * 0 or 1
<> 144:ef7eb2e8f9f7 678 * @retval HAL status
<> 144:ef7eb2e8f9f7 679 */
<> 144:ef7eb2e8f9f7 680 HAL_StatusTypeDef HAL_LTDC_DisableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 681 {
<> 144:ef7eb2e8f9f7 682 /* Process locked */
<> 144:ef7eb2e8f9f7 683 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 684
<> 144:ef7eb2e8f9f7 685 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 686 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 687
<> 144:ef7eb2e8f9f7 688 /* Check the parameters */
<> 144:ef7eb2e8f9f7 689 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 690
<> 144:ef7eb2e8f9f7 691 /* Disable LTDC color keying by setting COLKEN bit */
<> 144:ef7eb2e8f9f7 692 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_COLKEN;
<> 144:ef7eb2e8f9f7 693
<> 144:ef7eb2e8f9f7 694 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 695 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 696
<> 144:ef7eb2e8f9f7 697 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 698 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 699
<> 144:ef7eb2e8f9f7 700 /* Process unlocked */
<> 144:ef7eb2e8f9f7 701 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 702
<> 144:ef7eb2e8f9f7 703 return HAL_OK;
<> 144:ef7eb2e8f9f7 704 }
<> 144:ef7eb2e8f9f7 705
<> 144:ef7eb2e8f9f7 706 /**
<> 144:ef7eb2e8f9f7 707 * @brief Enable the color lookup table.
<> 144:ef7eb2e8f9f7 708 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 709 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 710 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 711 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 712 * 0 or 1
<> 144:ef7eb2e8f9f7 713 * @retval HAL status
<> 144:ef7eb2e8f9f7 714 */
<> 144:ef7eb2e8f9f7 715 HAL_StatusTypeDef HAL_LTDC_EnableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 716 {
<> 144:ef7eb2e8f9f7 717
<> 144:ef7eb2e8f9f7 718 /* Process locked */
<> 144:ef7eb2e8f9f7 719 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 720
<> 144:ef7eb2e8f9f7 721 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 722 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 723
<> 144:ef7eb2e8f9f7 724 /* Check the parameters */
<> 144:ef7eb2e8f9f7 725 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 726
<> 144:ef7eb2e8f9f7 727 /* Disable LTDC color lookup table by setting CLUTEN bit */
<> 144:ef7eb2e8f9f7 728 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_CLUTEN;
<> 144:ef7eb2e8f9f7 729
<> 144:ef7eb2e8f9f7 730 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 731 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 732
<> 144:ef7eb2e8f9f7 733 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 734 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 735
<> 144:ef7eb2e8f9f7 736 /* Process unlocked */
<> 144:ef7eb2e8f9f7 737 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 738
<> 144:ef7eb2e8f9f7 739 return HAL_OK;
<> 144:ef7eb2e8f9f7 740 }
<> 144:ef7eb2e8f9f7 741
<> 144:ef7eb2e8f9f7 742 /**
<> 144:ef7eb2e8f9f7 743 * @brief Disable the color lookup table.
<> 144:ef7eb2e8f9f7 744 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 745 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 746 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 747 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 748 * 0 or 1
<> 144:ef7eb2e8f9f7 749 * @retval HAL status
<> 144:ef7eb2e8f9f7 750 */
<> 144:ef7eb2e8f9f7 751 HAL_StatusTypeDef HAL_LTDC_DisableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 752 {
<> 144:ef7eb2e8f9f7 753
<> 144:ef7eb2e8f9f7 754 /* Process locked */
<> 144:ef7eb2e8f9f7 755 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 756
<> 144:ef7eb2e8f9f7 757 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 758 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 759
<> 144:ef7eb2e8f9f7 760 /* Check the parameters */
<> 144:ef7eb2e8f9f7 761 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 762
<> 144:ef7eb2e8f9f7 763 /* Disable LTDC color lookup table by setting CLUTEN bit */
<> 144:ef7eb2e8f9f7 764 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_CLUTEN;
<> 144:ef7eb2e8f9f7 765
<> 144:ef7eb2e8f9f7 766 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 767 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 768
<> 144:ef7eb2e8f9f7 769 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 770 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 771
<> 144:ef7eb2e8f9f7 772 /* Process unlocked */
<> 144:ef7eb2e8f9f7 773 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 774
<> 144:ef7eb2e8f9f7 775 return HAL_OK;
<> 144:ef7eb2e8f9f7 776 }
<> 144:ef7eb2e8f9f7 777
<> 144:ef7eb2e8f9f7 778 /**
<> 144:ef7eb2e8f9f7 779 * @brief Enables Dither.
<> 144:ef7eb2e8f9f7 780 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 781 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 782 * @retval HAL status
<> 144:ef7eb2e8f9f7 783 */
<> 144:ef7eb2e8f9f7 784
<> 144:ef7eb2e8f9f7 785 HAL_StatusTypeDef HAL_LTDC_EnableDither(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 786 {
<> 144:ef7eb2e8f9f7 787 /* Process locked */
<> 144:ef7eb2e8f9f7 788 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 789
<> 144:ef7eb2e8f9f7 790 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 791 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 792
<> 144:ef7eb2e8f9f7 793 /* Enable Dither by setting DTEN bit */
<> 144:ef7eb2e8f9f7 794 LTDC->GCR |= (uint32_t)LTDC_GCR_DEN;
<> 144:ef7eb2e8f9f7 795
<> 144:ef7eb2e8f9f7 796 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 797 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 798
<> 144:ef7eb2e8f9f7 799 /* Process unlocked */
<> 144:ef7eb2e8f9f7 800 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 801
<> 144:ef7eb2e8f9f7 802 return HAL_OK;
<> 144:ef7eb2e8f9f7 803 }
<> 144:ef7eb2e8f9f7 804
<> 144:ef7eb2e8f9f7 805 /**
<> 144:ef7eb2e8f9f7 806 * @brief Disables Dither.
<> 144:ef7eb2e8f9f7 807 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 808 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 809 * @retval HAL status
<> 144:ef7eb2e8f9f7 810 */
<> 144:ef7eb2e8f9f7 811
<> 144:ef7eb2e8f9f7 812 HAL_StatusTypeDef HAL_LTDC_DisableDither(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 813 {
<> 144:ef7eb2e8f9f7 814 /* Process locked */
<> 144:ef7eb2e8f9f7 815 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 816
<> 144:ef7eb2e8f9f7 817 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 818 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 819
<> 144:ef7eb2e8f9f7 820 /* Disable Dither by setting DTEN bit */
<> 144:ef7eb2e8f9f7 821 LTDC->GCR &= ~(uint32_t)LTDC_GCR_DEN;
<> 144:ef7eb2e8f9f7 822
<> 144:ef7eb2e8f9f7 823 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 824 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 825
<> 144:ef7eb2e8f9f7 826 /* Process unlocked */
<> 144:ef7eb2e8f9f7 827 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 828
<> 144:ef7eb2e8f9f7 829 return HAL_OK;
<> 144:ef7eb2e8f9f7 830 }
<> 144:ef7eb2e8f9f7 831
<> 144:ef7eb2e8f9f7 832 /**
<> 144:ef7eb2e8f9f7 833 * @brief Set the LTDC window size.
<> 144:ef7eb2e8f9f7 834 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 835 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 836 * @param XSize: LTDC Pixel per line
<> 144:ef7eb2e8f9f7 837 * @param YSize: LTDC Line number
<> 144:ef7eb2e8f9f7 838 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 839 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 840 * 0 or 1
<> 144:ef7eb2e8f9f7 841 * @retval HAL status
<> 144:ef7eb2e8f9f7 842 */
<> 144:ef7eb2e8f9f7 843 HAL_StatusTypeDef HAL_LTDC_SetWindowSize(LTDC_HandleTypeDef *hltdc, uint32_t XSize, uint32_t YSize, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 844 {
<> 144:ef7eb2e8f9f7 845 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 846
<> 144:ef7eb2e8f9f7 847 /* Process locked */
<> 144:ef7eb2e8f9f7 848 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 849
<> 144:ef7eb2e8f9f7 850 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 851 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 852
<> 144:ef7eb2e8f9f7 853 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 854 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 855
<> 144:ef7eb2e8f9f7 856 /* Check the parameters (Layers parameters)*/
<> 144:ef7eb2e8f9f7 857 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 858 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
<> 144:ef7eb2e8f9f7 859 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
<> 144:ef7eb2e8f9f7 860 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
<> 144:ef7eb2e8f9f7 861 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
<> 144:ef7eb2e8f9f7 862 assert_param(IS_LTDC_CFBLL(XSize));
<> 144:ef7eb2e8f9f7 863 assert_param(IS_LTDC_CFBLNBR(YSize));
<> 144:ef7eb2e8f9f7 864
<> 144:ef7eb2e8f9f7 865 /* update horizontal start/stop */
<> 144:ef7eb2e8f9f7 866 pLayerCfg->WindowX0 = 0;
<> 144:ef7eb2e8f9f7 867 pLayerCfg->WindowX1 = XSize + pLayerCfg->WindowX0;
<> 144:ef7eb2e8f9f7 868
<> 144:ef7eb2e8f9f7 869 /* update vertical start/stop */
<> 144:ef7eb2e8f9f7 870 pLayerCfg->WindowY0 = 0;
<> 144:ef7eb2e8f9f7 871 pLayerCfg->WindowY1 = YSize + pLayerCfg->WindowY0;
<> 144:ef7eb2e8f9f7 872
<> 144:ef7eb2e8f9f7 873 /* Reconfigures the color frame buffer pitch in byte */
<> 144:ef7eb2e8f9f7 874 pLayerCfg->ImageWidth = XSize;
<> 144:ef7eb2e8f9f7 875
<> 144:ef7eb2e8f9f7 876 /* Reconfigures the frame buffer line number */
<> 144:ef7eb2e8f9f7 877 pLayerCfg->ImageHeight = YSize;
<> 144:ef7eb2e8f9f7 878
<> 144:ef7eb2e8f9f7 879 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 880 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 881
<> 144:ef7eb2e8f9f7 882 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 883 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 884
<> 144:ef7eb2e8f9f7 885 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 886 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 887
<> 144:ef7eb2e8f9f7 888 /* Process unlocked */
<> 144:ef7eb2e8f9f7 889 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 890
<> 144:ef7eb2e8f9f7 891 return HAL_OK;
<> 144:ef7eb2e8f9f7 892 }
<> 144:ef7eb2e8f9f7 893
<> 144:ef7eb2e8f9f7 894 /**
<> 144:ef7eb2e8f9f7 895 * @brief Set the LTDC window position.
<> 144:ef7eb2e8f9f7 896 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 897 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 898 * @param X0: LTDC window X offset
<> 144:ef7eb2e8f9f7 899 * @param Y0: LTDC window Y offset
<> 144:ef7eb2e8f9f7 900 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 901 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 902 * 0 or 1
<> 144:ef7eb2e8f9f7 903 * @retval HAL status
<> 144:ef7eb2e8f9f7 904 */
<> 144:ef7eb2e8f9f7 905 HAL_StatusTypeDef HAL_LTDC_SetWindowPosition(LTDC_HandleTypeDef *hltdc, uint32_t X0, uint32_t Y0, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 906 {
<> 144:ef7eb2e8f9f7 907 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 908
<> 144:ef7eb2e8f9f7 909 /* Process locked */
<> 144:ef7eb2e8f9f7 910 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 911
<> 144:ef7eb2e8f9f7 912 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 913 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 914
<> 144:ef7eb2e8f9f7 915 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 916 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 917
<> 144:ef7eb2e8f9f7 918 /* Check the parameters */
<> 144:ef7eb2e8f9f7 919 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 920 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
<> 144:ef7eb2e8f9f7 921 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
<> 144:ef7eb2e8f9f7 922 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
<> 144:ef7eb2e8f9f7 923 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
<> 144:ef7eb2e8f9f7 924
<> 144:ef7eb2e8f9f7 925 /* update horizontal start/stop */
<> 144:ef7eb2e8f9f7 926 pLayerCfg->WindowX0 = X0;
<> 144:ef7eb2e8f9f7 927 pLayerCfg->WindowX1 = X0 + pLayerCfg->ImageWidth;
<> 144:ef7eb2e8f9f7 928
<> 144:ef7eb2e8f9f7 929 /* update vertical start/stop */
<> 144:ef7eb2e8f9f7 930 pLayerCfg->WindowY0 = Y0;
<> 144:ef7eb2e8f9f7 931 pLayerCfg->WindowY1 = Y0 + pLayerCfg->ImageHeight;
<> 144:ef7eb2e8f9f7 932
<> 144:ef7eb2e8f9f7 933 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 934 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 935
<> 144:ef7eb2e8f9f7 936 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 937 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 938
<> 144:ef7eb2e8f9f7 939 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 940 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 941
<> 144:ef7eb2e8f9f7 942 /* Process unlocked */
<> 144:ef7eb2e8f9f7 943 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 944
<> 144:ef7eb2e8f9f7 945 return HAL_OK;
<> 144:ef7eb2e8f9f7 946 }
<> 144:ef7eb2e8f9f7 947
<> 144:ef7eb2e8f9f7 948 /**
<> 144:ef7eb2e8f9f7 949 * @brief Reconfigure the pixel format.
<> 144:ef7eb2e8f9f7 950 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 951 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 952 * @param Pixelformat: new pixel format value.
<> 144:ef7eb2e8f9f7 953 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 954 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 955 * 0 or 1.
<> 144:ef7eb2e8f9f7 956 * @retval HAL status
<> 144:ef7eb2e8f9f7 957 */
<> 144:ef7eb2e8f9f7 958 HAL_StatusTypeDef HAL_LTDC_SetPixelFormat(LTDC_HandleTypeDef *hltdc, uint32_t Pixelformat, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 959 {
<> 144:ef7eb2e8f9f7 960 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 961
<> 144:ef7eb2e8f9f7 962 /* Process locked */
<> 144:ef7eb2e8f9f7 963 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 964
<> 144:ef7eb2e8f9f7 965 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 966 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 967
<> 144:ef7eb2e8f9f7 968 /* Check the parameters */
<> 144:ef7eb2e8f9f7 969 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 970 assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat));
<> 144:ef7eb2e8f9f7 971
<> 144:ef7eb2e8f9f7 972 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 973 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 974
<> 144:ef7eb2e8f9f7 975 /* Reconfigure the pixel format */
<> 144:ef7eb2e8f9f7 976 pLayerCfg->PixelFormat = Pixelformat;
<> 144:ef7eb2e8f9f7 977
<> 144:ef7eb2e8f9f7 978 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 979 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 980
<> 144:ef7eb2e8f9f7 981 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 982 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 983
<> 144:ef7eb2e8f9f7 984 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 985 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 986
<> 144:ef7eb2e8f9f7 987 /* Process unlocked */
<> 144:ef7eb2e8f9f7 988 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 989
<> 144:ef7eb2e8f9f7 990 return HAL_OK;
<> 144:ef7eb2e8f9f7 991 }
<> 144:ef7eb2e8f9f7 992
<> 144:ef7eb2e8f9f7 993 /**
<> 144:ef7eb2e8f9f7 994 * @brief Reconfigure the layer alpha value.
<> 144:ef7eb2e8f9f7 995 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 996 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 997 * @param Alpha: new alpha value.
<> 144:ef7eb2e8f9f7 998 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 999 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1000 * 0 or 1
<> 144:ef7eb2e8f9f7 1001 * @retval HAL status
<> 144:ef7eb2e8f9f7 1002 */
<> 144:ef7eb2e8f9f7 1003 HAL_StatusTypeDef HAL_LTDC_SetAlpha(LTDC_HandleTypeDef *hltdc, uint32_t Alpha, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1004 {
<> 144:ef7eb2e8f9f7 1005 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 1006
<> 144:ef7eb2e8f9f7 1007 /* Process locked */
<> 144:ef7eb2e8f9f7 1008 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1009
<> 144:ef7eb2e8f9f7 1010 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1011 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1012
<> 144:ef7eb2e8f9f7 1013 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1014 assert_param(IS_LTDC_ALPHA(Alpha));
<> 144:ef7eb2e8f9f7 1015 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1016
<> 144:ef7eb2e8f9f7 1017 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 1018 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 1019
<> 144:ef7eb2e8f9f7 1020 /* Reconfigure the Alpha value */
<> 144:ef7eb2e8f9f7 1021 pLayerCfg->Alpha = Alpha;
<> 144:ef7eb2e8f9f7 1022
<> 144:ef7eb2e8f9f7 1023 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 1024 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1025
<> 144:ef7eb2e8f9f7 1026 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 1027 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 1028
<> 144:ef7eb2e8f9f7 1029 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1030 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1031
<> 144:ef7eb2e8f9f7 1032 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1033 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1034
<> 144:ef7eb2e8f9f7 1035 return HAL_OK;
<> 144:ef7eb2e8f9f7 1036 }
<> 144:ef7eb2e8f9f7 1037 /**
<> 144:ef7eb2e8f9f7 1038 * @brief Reconfigure the frame buffer Address.
<> 144:ef7eb2e8f9f7 1039 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1040 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1041 * @param Address: new address value.
<> 144:ef7eb2e8f9f7 1042 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1043 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1044 * 0 or 1.
<> 144:ef7eb2e8f9f7 1045 * @retval HAL status
<> 144:ef7eb2e8f9f7 1046 */
<> 144:ef7eb2e8f9f7 1047 HAL_StatusTypeDef HAL_LTDC_SetAddress(LTDC_HandleTypeDef *hltdc, uint32_t Address, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1048 {
<> 144:ef7eb2e8f9f7 1049 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 1050
<> 144:ef7eb2e8f9f7 1051 /* Process locked */
<> 144:ef7eb2e8f9f7 1052 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1053
<> 144:ef7eb2e8f9f7 1054 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1055 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1056
<> 144:ef7eb2e8f9f7 1057 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1058 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1059
<> 144:ef7eb2e8f9f7 1060 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 1061 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 1062
<> 144:ef7eb2e8f9f7 1063 /* Reconfigure the Address */
<> 144:ef7eb2e8f9f7 1064 pLayerCfg->FBStartAdress = Address;
<> 144:ef7eb2e8f9f7 1065
<> 144:ef7eb2e8f9f7 1066 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 1067 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1068
<> 144:ef7eb2e8f9f7 1069 /* Sets the Reload type */
<> 144:ef7eb2e8f9f7 1070 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 1071
<> 144:ef7eb2e8f9f7 1072 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1073 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1074
<> 144:ef7eb2e8f9f7 1075 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1076 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1077
<> 144:ef7eb2e8f9f7 1078 return HAL_OK;
<> 144:ef7eb2e8f9f7 1079 }
<> 144:ef7eb2e8f9f7 1080
<> 144:ef7eb2e8f9f7 1081 /**
<> 144:ef7eb2e8f9f7 1082 * @brief Function used to reconfigure the pitch for specific cases where the attached LayerIdx buffer have a width that is
<> 144:ef7eb2e8f9f7 1083 * larger than the one intended to be displayed on screen. Example of a buffer 800x480 attached to layer for which we
<> 144:ef7eb2e8f9f7 1084 * want to read and display on screen only a portion 320x240 taken in the center of the buffer. The pitch in pixels
<> 144:ef7eb2e8f9f7 1085 * will be in that case 800 pixels and not 320 pixels as initially configured by previous call to HAL_LTDC_ConfigLayer().
<> 144:ef7eb2e8f9f7 1086 * Note : this function should be called only after a previous call to HAL_LTDC_ConfigLayer() to modify the default pitch
<> 144:ef7eb2e8f9f7 1087 * configured by HAL_LTDC_ConfigLayer() when required (refer to example described just above).
<> 144:ef7eb2e8f9f7 1088 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1089 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1090 * @param LinePitchInPixels: New line pitch in pixels to configure for LTDC layer 'LayerIdx'.
<> 144:ef7eb2e8f9f7 1091 * @param LayerIdx: LTDC layer index concerned by the modification of line pitch.
<> 144:ef7eb2e8f9f7 1092 * @retval HAL status
<> 144:ef7eb2e8f9f7 1093 */
<> 144:ef7eb2e8f9f7 1094 HAL_StatusTypeDef HAL_LTDC_SetPitch(LTDC_HandleTypeDef *hltdc, uint32_t LinePitchInPixels, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1095 {
<> 144:ef7eb2e8f9f7 1096 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 1097 uint32_t pitchUpdate = 0;
<> 144:ef7eb2e8f9f7 1098 uint32_t pixelFormat = 0;
<> 144:ef7eb2e8f9f7 1099
<> 144:ef7eb2e8f9f7 1100 /* Process locked */
<> 144:ef7eb2e8f9f7 1101 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1102
<> 144:ef7eb2e8f9f7 1103 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1104 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1105
<> 144:ef7eb2e8f9f7 1106 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1107 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1108
<> 144:ef7eb2e8f9f7 1109 /* get LayerIdx used pixel format */
<> 144:ef7eb2e8f9f7 1110 pixelFormat = hltdc->LayerCfg[LayerIdx].PixelFormat;
<> 144:ef7eb2e8f9f7 1111
<> 144:ef7eb2e8f9f7 1112 if(pixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
<> 144:ef7eb2e8f9f7 1113 {
<> 144:ef7eb2e8f9f7 1114 tmp = 4;
<> 144:ef7eb2e8f9f7 1115 }
<> 144:ef7eb2e8f9f7 1116 else if (pixelFormat == LTDC_PIXEL_FORMAT_RGB888)
<> 144:ef7eb2e8f9f7 1117 {
<> 144:ef7eb2e8f9f7 1118 tmp = 3;
<> 144:ef7eb2e8f9f7 1119 }
<> 144:ef7eb2e8f9f7 1120 else if((pixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
<> 144:ef7eb2e8f9f7 1121 (pixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
<> 144:ef7eb2e8f9f7 1122 (pixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \
<> 144:ef7eb2e8f9f7 1123 (pixelFormat == LTDC_PIXEL_FORMAT_AL88))
<> 144:ef7eb2e8f9f7 1124 {
<> 144:ef7eb2e8f9f7 1125 tmp = 2;
<> 144:ef7eb2e8f9f7 1126 }
<> 144:ef7eb2e8f9f7 1127 else
<> 144:ef7eb2e8f9f7 1128 {
<> 144:ef7eb2e8f9f7 1129 tmp = 1;
<> 144:ef7eb2e8f9f7 1130 }
<> 144:ef7eb2e8f9f7 1131
<> 144:ef7eb2e8f9f7 1132 pitchUpdate = ((LinePitchInPixels * tmp) << 16);
<> 144:ef7eb2e8f9f7 1133
<> 144:ef7eb2e8f9f7 1134 /* Clear previously set standard pitch */
<> 144:ef7eb2e8f9f7 1135 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~LTDC_LxCFBLR_CFBP;
<> 144:ef7eb2e8f9f7 1136
<> 144:ef7eb2e8f9f7 1137 /* Sets the Reload type as immediate update of LTDC pitch configured above */
<> 144:ef7eb2e8f9f7 1138 LTDC->SRCR |= LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 1139
<> 144:ef7eb2e8f9f7 1140 /* Set new line pitch value */
<> 144:ef7eb2e8f9f7 1141 LTDC_LAYER(hltdc, LayerIdx)->CFBLR |= pitchUpdate;
<> 144:ef7eb2e8f9f7 1142
<> 144:ef7eb2e8f9f7 1143 /* Sets the Reload type as immediate update of LTDC pitch configured above */
<> 144:ef7eb2e8f9f7 1144 LTDC->SRCR |= LTDC_SRCR_IMR;
<> 144:ef7eb2e8f9f7 1145
<> 144:ef7eb2e8f9f7 1146 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1147 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1148
<> 144:ef7eb2e8f9f7 1149 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1150 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1151
<> 144:ef7eb2e8f9f7 1152 return HAL_OK;
<> 144:ef7eb2e8f9f7 1153 }
<> 144:ef7eb2e8f9f7 1154
<> 144:ef7eb2e8f9f7 1155 /**
<> 144:ef7eb2e8f9f7 1156 * @brief Define the position of the line interrupt.
<> 144:ef7eb2e8f9f7 1157 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1158 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1159 * @param Line: Line Interrupt Position.
<> 144:ef7eb2e8f9f7 1160 * @retval HAL status
<> 144:ef7eb2e8f9f7 1161 */
<> 144:ef7eb2e8f9f7 1162 HAL_StatusTypeDef HAL_LTDC_ProgramLineEvent(LTDC_HandleTypeDef *hltdc, uint32_t Line)
<> 144:ef7eb2e8f9f7 1163 {
<> 144:ef7eb2e8f9f7 1164 /* Process locked */
<> 144:ef7eb2e8f9f7 1165 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1166
<> 144:ef7eb2e8f9f7 1167 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1168 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1169
<> 144:ef7eb2e8f9f7 1170 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1171 assert_param(IS_LTDC_LIPOS(Line));
<> 144:ef7eb2e8f9f7 1172
<> 144:ef7eb2e8f9f7 1173 /* Enable the Line interrupt */
<> 144:ef7eb2e8f9f7 1174 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_LI);
<> 144:ef7eb2e8f9f7 1175
<> 144:ef7eb2e8f9f7 1176 /* Sets the Line Interrupt position */
<> 144:ef7eb2e8f9f7 1177 LTDC->LIPCR = (uint32_t)Line;
<> 144:ef7eb2e8f9f7 1178
<> 144:ef7eb2e8f9f7 1179 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1180 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1181
<> 144:ef7eb2e8f9f7 1182 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1183 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1184
<> 144:ef7eb2e8f9f7 1185 return HAL_OK;
<> 144:ef7eb2e8f9f7 1186 }
<> 144:ef7eb2e8f9f7 1187
<> 144:ef7eb2e8f9f7 1188 /**
<> 144:ef7eb2e8f9f7 1189 * @brief LTDC configuration reload.
<> 144:ef7eb2e8f9f7 1190 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1191 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1192 * @param ReloadType: This parameter can be one of the following values :
<> 144:ef7eb2e8f9f7 1193 * LTDC_RELOAD_IMMEDIATE : Immediate Reload
<> 144:ef7eb2e8f9f7 1194 * LTDC_RELOAD_VERTICAL_BLANKING : Reload in the next Vertical Blanking
<> 144:ef7eb2e8f9f7 1195 * @retval HAL status
<> 144:ef7eb2e8f9f7 1196 */
<> 144:ef7eb2e8f9f7 1197 HAL_StatusTypeDef HAL_LTDC_Reload(LTDC_HandleTypeDef *hltdc, uint32_t ReloadType)
<> 144:ef7eb2e8f9f7 1198 {
<> 144:ef7eb2e8f9f7 1199 assert_param(IS_LTDC_RELAOD(ReloadType));
<> 144:ef7eb2e8f9f7 1200
<> 144:ef7eb2e8f9f7 1201 /* Process locked */
<> 144:ef7eb2e8f9f7 1202 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1203
<> 144:ef7eb2e8f9f7 1204 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1205 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1206
<> 144:ef7eb2e8f9f7 1207 /* Enable the Reload interrupt */
<> 144:ef7eb2e8f9f7 1208 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_RR);
<> 144:ef7eb2e8f9f7 1209
<> 144:ef7eb2e8f9f7 1210 /* Apply Reload type */
<> 144:ef7eb2e8f9f7 1211 hltdc->Instance->SRCR = ReloadType;
<> 144:ef7eb2e8f9f7 1212
<> 144:ef7eb2e8f9f7 1213 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1214 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1215
<> 144:ef7eb2e8f9f7 1216 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1217 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1218
<> 144:ef7eb2e8f9f7 1219 return HAL_OK;
<> 144:ef7eb2e8f9f7 1220 }
<> 144:ef7eb2e8f9f7 1221
<> 144:ef7eb2e8f9f7 1222 /**
<> 144:ef7eb2e8f9f7 1223 * @brief Configure the LTDC Layer according to the specified without reloading
<> 144:ef7eb2e8f9f7 1224 * parameters in the LTDC_InitTypeDef and create the associated handle.
<> 144:ef7eb2e8f9f7 1225 * Variant of the function HAL_LTDC_ConfigLayer without immediate reload
<> 144:ef7eb2e8f9f7 1226 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1227 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1228 * @param pLayerCfg: pointer to a LTDC_LayerCfgTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1229 * the configuration information for the Layer.
<> 144:ef7eb2e8f9f7 1230 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1231 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1232 * 0 or 1
<> 144:ef7eb2e8f9f7 1233 * @retval HAL status
<> 144:ef7eb2e8f9f7 1234 */
<> 144:ef7eb2e8f9f7 1235 HAL_StatusTypeDef HAL_LTDC_ConfigLayer_NoReload(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1236 {
<> 144:ef7eb2e8f9f7 1237 /* Process locked */
<> 144:ef7eb2e8f9f7 1238 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1239
<> 144:ef7eb2e8f9f7 1240 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1241 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1242
<> 144:ef7eb2e8f9f7 1243 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1244 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1245 assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat));
<> 144:ef7eb2e8f9f7 1246 assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1));
<> 144:ef7eb2e8f9f7 1247 assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2));
<> 144:ef7eb2e8f9f7 1248 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
<> 144:ef7eb2e8f9f7 1249 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
<> 144:ef7eb2e8f9f7 1250 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
<> 144:ef7eb2e8f9f7 1251 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
<> 144:ef7eb2e8f9f7 1252 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0));
<> 144:ef7eb2e8f9f7 1253 assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth));
<> 144:ef7eb2e8f9f7 1254 assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight));
<> 144:ef7eb2e8f9f7 1255
<> 144:ef7eb2e8f9f7 1256 /* Copy new layer configuration into handle structure */
<> 144:ef7eb2e8f9f7 1257 hltdc->LayerCfg[LayerIdx] = *pLayerCfg;
<> 144:ef7eb2e8f9f7 1258
<> 144:ef7eb2e8f9f7 1259 /* Configure the LTDC Layer */
<> 144:ef7eb2e8f9f7 1260 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1261
<> 144:ef7eb2e8f9f7 1262 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1263
<> 144:ef7eb2e8f9f7 1264 /* Initialize the LTDC state*/
<> 144:ef7eb2e8f9f7 1265 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1266
<> 144:ef7eb2e8f9f7 1267 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1268 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1269
<> 144:ef7eb2e8f9f7 1270 return HAL_OK;
<> 144:ef7eb2e8f9f7 1271 }
<> 144:ef7eb2e8f9f7 1272
<> 144:ef7eb2e8f9f7 1273 /**
<> 144:ef7eb2e8f9f7 1274 * @brief Set the LTDC window size without reloading.
<> 144:ef7eb2e8f9f7 1275 * Variant of the function HAL_LTDC_SetWindowSize without immediate reload
<> 144:ef7eb2e8f9f7 1276 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1277 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1278 * @param XSize: LTDC Pixel per line
<> 144:ef7eb2e8f9f7 1279 * @param YSize: LTDC Line number
<> 144:ef7eb2e8f9f7 1280 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1281 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1282 * 0 or 1
<> 144:ef7eb2e8f9f7 1283 * @retval HAL status
<> 144:ef7eb2e8f9f7 1284 */
<> 144:ef7eb2e8f9f7 1285 HAL_StatusTypeDef HAL_LTDC_SetWindowSize_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t XSize, uint32_t YSize, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1286 {
<> 144:ef7eb2e8f9f7 1287 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 1288
<> 144:ef7eb2e8f9f7 1289 /* Process locked */
<> 144:ef7eb2e8f9f7 1290 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1291
<> 144:ef7eb2e8f9f7 1292 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1293 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1294
<> 144:ef7eb2e8f9f7 1295 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 1296 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 1297
<> 144:ef7eb2e8f9f7 1298 /* Check the parameters (Layers parameters)*/
<> 144:ef7eb2e8f9f7 1299 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1300 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
<> 144:ef7eb2e8f9f7 1301 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
<> 144:ef7eb2e8f9f7 1302 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
<> 144:ef7eb2e8f9f7 1303 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
<> 144:ef7eb2e8f9f7 1304 assert_param(IS_LTDC_CFBLL(XSize));
<> 144:ef7eb2e8f9f7 1305 assert_param(IS_LTDC_CFBLNBR(YSize));
<> 144:ef7eb2e8f9f7 1306
<> 144:ef7eb2e8f9f7 1307 /* update horizontal start/stop */
<> 144:ef7eb2e8f9f7 1308 pLayerCfg->WindowX0 = 0;
<> 144:ef7eb2e8f9f7 1309 pLayerCfg->WindowX1 = XSize + pLayerCfg->WindowX0;
<> 144:ef7eb2e8f9f7 1310
<> 144:ef7eb2e8f9f7 1311 /* update vertical start/stop */
<> 144:ef7eb2e8f9f7 1312 pLayerCfg->WindowY0 = 0;
<> 144:ef7eb2e8f9f7 1313 pLayerCfg->WindowY1 = YSize + pLayerCfg->WindowY0;
<> 144:ef7eb2e8f9f7 1314
<> 144:ef7eb2e8f9f7 1315 /* Reconfigures the color frame buffer pitch in byte */
<> 144:ef7eb2e8f9f7 1316 pLayerCfg->ImageWidth = XSize;
<> 144:ef7eb2e8f9f7 1317
<> 144:ef7eb2e8f9f7 1318 /* Reconfigures the frame buffer line number */
<> 144:ef7eb2e8f9f7 1319 pLayerCfg->ImageHeight = YSize;
<> 144:ef7eb2e8f9f7 1320
<> 144:ef7eb2e8f9f7 1321 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 1322 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1323
<> 144:ef7eb2e8f9f7 1324 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1325
<> 144:ef7eb2e8f9f7 1326 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1327 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1328
<> 144:ef7eb2e8f9f7 1329 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1330 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1331
<> 144:ef7eb2e8f9f7 1332 return HAL_OK;
<> 144:ef7eb2e8f9f7 1333 }
<> 144:ef7eb2e8f9f7 1334
<> 144:ef7eb2e8f9f7 1335 /**
<> 144:ef7eb2e8f9f7 1336 * @brief Set the LTDC window position without reloading.
<> 144:ef7eb2e8f9f7 1337 * Variant of the function HAL_LTDC_SetWindowPosition without immediate reload
<> 144:ef7eb2e8f9f7 1338 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1339 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1340 * @param X0: LTDC window X offset
<> 144:ef7eb2e8f9f7 1341 * @param Y0: LTDC window Y offset
<> 144:ef7eb2e8f9f7 1342 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1343 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1344 * 0 or 1
<> 144:ef7eb2e8f9f7 1345 * @retval HAL status
<> 144:ef7eb2e8f9f7 1346 */
<> 144:ef7eb2e8f9f7 1347 HAL_StatusTypeDef HAL_LTDC_SetWindowPosition_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t X0, uint32_t Y0, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1348 {
<> 144:ef7eb2e8f9f7 1349 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 1350
<> 144:ef7eb2e8f9f7 1351 /* Process locked */
<> 144:ef7eb2e8f9f7 1352 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1353
<> 144:ef7eb2e8f9f7 1354 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1355 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1356
<> 144:ef7eb2e8f9f7 1357 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 1358 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 1359
<> 144:ef7eb2e8f9f7 1360 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1361 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1362 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
<> 144:ef7eb2e8f9f7 1363 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
<> 144:ef7eb2e8f9f7 1364 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
<> 144:ef7eb2e8f9f7 1365 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
<> 144:ef7eb2e8f9f7 1366
<> 144:ef7eb2e8f9f7 1367 /* update horizontal start/stop */
<> 144:ef7eb2e8f9f7 1368 pLayerCfg->WindowX0 = X0;
<> 144:ef7eb2e8f9f7 1369 pLayerCfg->WindowX1 = X0 + pLayerCfg->ImageWidth;
<> 144:ef7eb2e8f9f7 1370
<> 144:ef7eb2e8f9f7 1371 /* update vertical start/stop */
<> 144:ef7eb2e8f9f7 1372 pLayerCfg->WindowY0 = Y0;
<> 144:ef7eb2e8f9f7 1373 pLayerCfg->WindowY1 = Y0 + pLayerCfg->ImageHeight;
<> 144:ef7eb2e8f9f7 1374
<> 144:ef7eb2e8f9f7 1375 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 1376 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1377
<> 144:ef7eb2e8f9f7 1378 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1379
<> 144:ef7eb2e8f9f7 1380 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1381 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1382
<> 144:ef7eb2e8f9f7 1383 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1384 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1385
<> 144:ef7eb2e8f9f7 1386 return HAL_OK;
<> 144:ef7eb2e8f9f7 1387 }
<> 144:ef7eb2e8f9f7 1388
<> 144:ef7eb2e8f9f7 1389 /**
<> 144:ef7eb2e8f9f7 1390 * @brief Reconfigure the pixel format without reloading.
<> 144:ef7eb2e8f9f7 1391 * Variant of the function HAL_LTDC_SetPixelFormat without immediate reload
<> 144:ef7eb2e8f9f7 1392 * @param hltdc: pointer to a LTDC_HandleTypeDfef structure that contains
<> 144:ef7eb2e8f9f7 1393 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1394 * @param Pixelformat: new pixel format value.
<> 144:ef7eb2e8f9f7 1395 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1396 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1397 * 0 or 1.
<> 144:ef7eb2e8f9f7 1398 * @retval HAL status
<> 144:ef7eb2e8f9f7 1399 */
<> 144:ef7eb2e8f9f7 1400 HAL_StatusTypeDef HAL_LTDC_SetPixelFormat_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t Pixelformat, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1401 {
<> 144:ef7eb2e8f9f7 1402 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 1403
<> 144:ef7eb2e8f9f7 1404 /* Process locked */
<> 144:ef7eb2e8f9f7 1405 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1406
<> 144:ef7eb2e8f9f7 1407 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1408 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1409
<> 144:ef7eb2e8f9f7 1410 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1411 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1412 assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat));
<> 144:ef7eb2e8f9f7 1413
<> 144:ef7eb2e8f9f7 1414 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 1415 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 1416
<> 144:ef7eb2e8f9f7 1417 /* Reconfigure the pixel format */
<> 144:ef7eb2e8f9f7 1418 pLayerCfg->PixelFormat = Pixelformat;
<> 144:ef7eb2e8f9f7 1419
<> 144:ef7eb2e8f9f7 1420 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 1421 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1422
<> 144:ef7eb2e8f9f7 1423 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1424
<> 144:ef7eb2e8f9f7 1425 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1426 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1427
<> 144:ef7eb2e8f9f7 1428 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1429 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1430
<> 144:ef7eb2e8f9f7 1431 return HAL_OK;
<> 144:ef7eb2e8f9f7 1432 }
<> 144:ef7eb2e8f9f7 1433
<> 144:ef7eb2e8f9f7 1434 /**
<> 144:ef7eb2e8f9f7 1435 * @brief Reconfigure the layer alpha value without reloading.
<> 144:ef7eb2e8f9f7 1436 * Variant of the function HAL_LTDC_SetAlpha without immediate reload
<> 144:ef7eb2e8f9f7 1437 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1438 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1439 * @param Alpha: new alpha value.
<> 144:ef7eb2e8f9f7 1440 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1441 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1442 * 0 or 1
<> 144:ef7eb2e8f9f7 1443 * @retval HAL status
<> 144:ef7eb2e8f9f7 1444 */
<> 144:ef7eb2e8f9f7 1445 HAL_StatusTypeDef HAL_LTDC_SetAlpha_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t Alpha, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1446 {
<> 144:ef7eb2e8f9f7 1447 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 1448
<> 144:ef7eb2e8f9f7 1449 /* Process locked */
<> 144:ef7eb2e8f9f7 1450 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1451
<> 144:ef7eb2e8f9f7 1452 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1453 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1454
<> 144:ef7eb2e8f9f7 1455 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1456 assert_param(IS_LTDC_ALPHA(Alpha));
<> 144:ef7eb2e8f9f7 1457 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1458
<> 144:ef7eb2e8f9f7 1459 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 1460 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 1461
<> 144:ef7eb2e8f9f7 1462 /* Reconfigure the Alpha value */
<> 144:ef7eb2e8f9f7 1463 pLayerCfg->Alpha = Alpha;
<> 144:ef7eb2e8f9f7 1464
<> 144:ef7eb2e8f9f7 1465 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 1466 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1467
<> 144:ef7eb2e8f9f7 1468 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1469
<> 144:ef7eb2e8f9f7 1470 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1471 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1472
<> 144:ef7eb2e8f9f7 1473 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1474 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1475
<> 144:ef7eb2e8f9f7 1476 return HAL_OK;
<> 144:ef7eb2e8f9f7 1477 }
<> 144:ef7eb2e8f9f7 1478
<> 144:ef7eb2e8f9f7 1479 /**
<> 144:ef7eb2e8f9f7 1480 * @brief Reconfigure the frame buffer Address without reloading.
<> 144:ef7eb2e8f9f7 1481 * Variant of the function HAL_LTDC_SetAddress without immediate reload
<> 144:ef7eb2e8f9f7 1482 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1483 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1484 * @param Address: new address value.
<> 144:ef7eb2e8f9f7 1485 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1486 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1487 * 0 or 1.
<> 144:ef7eb2e8f9f7 1488 * @retval HAL status
<> 144:ef7eb2e8f9f7 1489 */
<> 144:ef7eb2e8f9f7 1490 HAL_StatusTypeDef HAL_LTDC_SetAddress_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t Address, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1491 {
<> 144:ef7eb2e8f9f7 1492 LTDC_LayerCfgTypeDef *pLayerCfg;
<> 144:ef7eb2e8f9f7 1493
<> 144:ef7eb2e8f9f7 1494 /* Process locked */
<> 144:ef7eb2e8f9f7 1495 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1496
<> 144:ef7eb2e8f9f7 1497 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1498 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1499
<> 144:ef7eb2e8f9f7 1500 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1501 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1502
<> 144:ef7eb2e8f9f7 1503 /* Get layer configuration from handle structure */
<> 144:ef7eb2e8f9f7 1504 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
<> 144:ef7eb2e8f9f7 1505
<> 144:ef7eb2e8f9f7 1506 /* Reconfigure the Address */
<> 144:ef7eb2e8f9f7 1507 pLayerCfg->FBStartAdress = Address;
<> 144:ef7eb2e8f9f7 1508
<> 144:ef7eb2e8f9f7 1509 /* Set LTDC parameters */
<> 144:ef7eb2e8f9f7 1510 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
<> 144:ef7eb2e8f9f7 1511
<> 144:ef7eb2e8f9f7 1512 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1513
<> 144:ef7eb2e8f9f7 1514 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1515 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1516
<> 144:ef7eb2e8f9f7 1517 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1518 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1519
<> 144:ef7eb2e8f9f7 1520 return HAL_OK;
<> 144:ef7eb2e8f9f7 1521 }
<> 144:ef7eb2e8f9f7 1522
<> 144:ef7eb2e8f9f7 1523 /**
<> 144:ef7eb2e8f9f7 1524 * @brief Function used to reconfigure the pitch for specific cases where the attached LayerIdx buffer have a width that is
<> 144:ef7eb2e8f9f7 1525 * larger than the one intended to be displayed on screen. Example of a buffer 800x480 attached to layer for which we
<> 144:ef7eb2e8f9f7 1526 * want to read and display on screen only a portion 320x240 taken in the center of the buffer. The pitch in pixels
<> 144:ef7eb2e8f9f7 1527 * will be in that case 800 pixels and not 320 pixels as initially configured by previous call to HAL_LTDC_ConfigLayer().
<> 144:ef7eb2e8f9f7 1528 * Note : this function should be called only after a previous call to HAL_LTDC_ConfigLayer() to modify the default pitch
<> 144:ef7eb2e8f9f7 1529 * configured by HAL_LTDC_ConfigLayer() when required (refer to example described just above).
<> 144:ef7eb2e8f9f7 1530 * Variant of the function HAL_LTDC_SetPitch without immediate reload
<> 144:ef7eb2e8f9f7 1531 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1532 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1533 * @param LinePitchInPixels: New line pitch in pixels to configure for LTDC layer 'LayerIdx'.
<> 144:ef7eb2e8f9f7 1534 * @param LayerIdx: LTDC layer index concerned by the modification of line pitch.
<> 144:ef7eb2e8f9f7 1535 * @retval HAL status
<> 144:ef7eb2e8f9f7 1536 */
<> 144:ef7eb2e8f9f7 1537 HAL_StatusTypeDef HAL_LTDC_SetPitch_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LinePitchInPixels, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1538 {
<> 144:ef7eb2e8f9f7 1539 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 1540 uint32_t pitchUpdate = 0;
<> 144:ef7eb2e8f9f7 1541 uint32_t pixelFormat = 0;
<> 144:ef7eb2e8f9f7 1542
<> 144:ef7eb2e8f9f7 1543 /* Process locked */
<> 144:ef7eb2e8f9f7 1544 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1545
<> 144:ef7eb2e8f9f7 1546 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1547 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1548
<> 144:ef7eb2e8f9f7 1549 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1550 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1551
<> 144:ef7eb2e8f9f7 1552 /* get LayerIdx used pixel format */
<> 144:ef7eb2e8f9f7 1553 pixelFormat = hltdc->LayerCfg[LayerIdx].PixelFormat;
<> 144:ef7eb2e8f9f7 1554
<> 144:ef7eb2e8f9f7 1555 if(pixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
<> 144:ef7eb2e8f9f7 1556 {
<> 144:ef7eb2e8f9f7 1557 tmp = 4;
<> 144:ef7eb2e8f9f7 1558 }
<> 144:ef7eb2e8f9f7 1559 else if (pixelFormat == LTDC_PIXEL_FORMAT_RGB888)
<> 144:ef7eb2e8f9f7 1560 {
<> 144:ef7eb2e8f9f7 1561 tmp = 3;
<> 144:ef7eb2e8f9f7 1562 }
<> 144:ef7eb2e8f9f7 1563 else if((pixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
<> 144:ef7eb2e8f9f7 1564 (pixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
<> 144:ef7eb2e8f9f7 1565 (pixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \
<> 144:ef7eb2e8f9f7 1566 (pixelFormat == LTDC_PIXEL_FORMAT_AL88))
<> 144:ef7eb2e8f9f7 1567 {
<> 144:ef7eb2e8f9f7 1568 tmp = 2;
<> 144:ef7eb2e8f9f7 1569 }
<> 144:ef7eb2e8f9f7 1570 else
<> 144:ef7eb2e8f9f7 1571 {
<> 144:ef7eb2e8f9f7 1572 tmp = 1;
<> 144:ef7eb2e8f9f7 1573 }
<> 144:ef7eb2e8f9f7 1574
<> 144:ef7eb2e8f9f7 1575 pitchUpdate = ((LinePitchInPixels * tmp) << 16);
<> 144:ef7eb2e8f9f7 1576
<> 144:ef7eb2e8f9f7 1577 /* Clear previously set standard pitch */
<> 144:ef7eb2e8f9f7 1578 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~LTDC_LxCFBLR_CFBP;
<> 144:ef7eb2e8f9f7 1579
<> 144:ef7eb2e8f9f7 1580 /* Set new line pitch value */
<> 144:ef7eb2e8f9f7 1581 LTDC_LAYER(hltdc, LayerIdx)->CFBLR |= pitchUpdate;
<> 144:ef7eb2e8f9f7 1582
<> 144:ef7eb2e8f9f7 1583 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1584
<> 144:ef7eb2e8f9f7 1585 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1586 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1587
<> 144:ef7eb2e8f9f7 1588 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1589 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1590
<> 144:ef7eb2e8f9f7 1591 return HAL_OK;
<> 144:ef7eb2e8f9f7 1592 }
<> 144:ef7eb2e8f9f7 1593
<> 144:ef7eb2e8f9f7 1594
<> 144:ef7eb2e8f9f7 1595 /**
<> 144:ef7eb2e8f9f7 1596 * @brief Configure the color keying without reloading.
<> 144:ef7eb2e8f9f7 1597 * Variant of the function HAL_LTDC_ConfigColorKeying without immediate reload
<> 144:ef7eb2e8f9f7 1598 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1599 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1600 * @param RGBValue: the color key value
<> 144:ef7eb2e8f9f7 1601 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1602 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1603 * 0 or 1
<> 144:ef7eb2e8f9f7 1604 * @retval HAL status
<> 144:ef7eb2e8f9f7 1605 */
<> 144:ef7eb2e8f9f7 1606 HAL_StatusTypeDef HAL_LTDC_ConfigColorKeying_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t RGBValue, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1607 {
<> 144:ef7eb2e8f9f7 1608 /* Process locked */
<> 144:ef7eb2e8f9f7 1609 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1610
<> 144:ef7eb2e8f9f7 1611 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1612 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1613
<> 144:ef7eb2e8f9f7 1614 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1615 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1616
<> 144:ef7eb2e8f9f7 1617 /* Configures the default color values */
<> 144:ef7eb2e8f9f7 1618 LTDC_LAYER(hltdc, LayerIdx)->CKCR &= ~(LTDC_LxCKCR_CKBLUE | LTDC_LxCKCR_CKGREEN | LTDC_LxCKCR_CKRED);
<> 144:ef7eb2e8f9f7 1619 LTDC_LAYER(hltdc, LayerIdx)->CKCR = RGBValue;
<> 144:ef7eb2e8f9f7 1620
<> 144:ef7eb2e8f9f7 1621 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1622
<> 144:ef7eb2e8f9f7 1623 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1624 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1625
<> 144:ef7eb2e8f9f7 1626 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1627 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1628
<> 144:ef7eb2e8f9f7 1629 return HAL_OK;
<> 144:ef7eb2e8f9f7 1630 }
<> 144:ef7eb2e8f9f7 1631
<> 144:ef7eb2e8f9f7 1632 /**
<> 144:ef7eb2e8f9f7 1633 * @brief Enable the color keying without reloading.
<> 144:ef7eb2e8f9f7 1634 * Variant of the function HAL_LTDC_EnableColorKeying without immediate reload
<> 144:ef7eb2e8f9f7 1635 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1636 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1637 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1638 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1639 * 0 or 1
<> 144:ef7eb2e8f9f7 1640 * @retval HAL status
<> 144:ef7eb2e8f9f7 1641 */
<> 144:ef7eb2e8f9f7 1642 HAL_StatusTypeDef HAL_LTDC_EnableColorKeying_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1643 {
<> 144:ef7eb2e8f9f7 1644 /* Process locked */
<> 144:ef7eb2e8f9f7 1645 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1646
<> 144:ef7eb2e8f9f7 1647 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1648 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1649
<> 144:ef7eb2e8f9f7 1650 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1651 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1652
<> 144:ef7eb2e8f9f7 1653 /* Enable LTDC color keying by setting COLKEN bit */
<> 144:ef7eb2e8f9f7 1654 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_COLKEN;
<> 144:ef7eb2e8f9f7 1655
<> 144:ef7eb2e8f9f7 1656 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1657
<> 144:ef7eb2e8f9f7 1658 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1659 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1660
<> 144:ef7eb2e8f9f7 1661 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1662 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1663
<> 144:ef7eb2e8f9f7 1664 return HAL_OK;
<> 144:ef7eb2e8f9f7 1665 }
<> 144:ef7eb2e8f9f7 1666
<> 144:ef7eb2e8f9f7 1667 /**
<> 144:ef7eb2e8f9f7 1668 * @brief Disable the color keying without reloading.
<> 144:ef7eb2e8f9f7 1669 * Variant of the function HAL_LTDC_DisableColorKeying without immediate reload
<> 144:ef7eb2e8f9f7 1670 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1671 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1672 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1673 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1674 * 0 or 1
<> 144:ef7eb2e8f9f7 1675 * @retval HAL status
<> 144:ef7eb2e8f9f7 1676 */
<> 144:ef7eb2e8f9f7 1677 HAL_StatusTypeDef HAL_LTDC_DisableColorKeying_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1678 {
<> 144:ef7eb2e8f9f7 1679 /* Process locked */
<> 144:ef7eb2e8f9f7 1680 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1681
<> 144:ef7eb2e8f9f7 1682 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1683 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1684
<> 144:ef7eb2e8f9f7 1685 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1686 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1687
<> 144:ef7eb2e8f9f7 1688 /* Disable LTDC color keying by setting COLKEN bit */
<> 144:ef7eb2e8f9f7 1689 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_COLKEN;
<> 144:ef7eb2e8f9f7 1690
<> 144:ef7eb2e8f9f7 1691 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1692
<> 144:ef7eb2e8f9f7 1693 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1694 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1695
<> 144:ef7eb2e8f9f7 1696 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1697 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1698
<> 144:ef7eb2e8f9f7 1699 return HAL_OK;
<> 144:ef7eb2e8f9f7 1700 }
<> 144:ef7eb2e8f9f7 1701
<> 144:ef7eb2e8f9f7 1702 /**
<> 144:ef7eb2e8f9f7 1703 * @brief Enable the color lookup table without reloading.
<> 144:ef7eb2e8f9f7 1704 * Variant of the function HAL_LTDC_EnableCLUT without immediate reload
<> 144:ef7eb2e8f9f7 1705 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1706 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1707 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1708 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1709 * 0 or 1
<> 144:ef7eb2e8f9f7 1710 * @retval HAL status
<> 144:ef7eb2e8f9f7 1711 */
<> 144:ef7eb2e8f9f7 1712 HAL_StatusTypeDef HAL_LTDC_EnableCLUT_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1713 {
<> 144:ef7eb2e8f9f7 1714
<> 144:ef7eb2e8f9f7 1715 /* Process locked */
<> 144:ef7eb2e8f9f7 1716 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1717
<> 144:ef7eb2e8f9f7 1718 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1719 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1720
<> 144:ef7eb2e8f9f7 1721 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1722 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1723
<> 144:ef7eb2e8f9f7 1724 /* Disable LTDC color lookup table by setting CLUTEN bit */
<> 144:ef7eb2e8f9f7 1725 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_CLUTEN;
<> 144:ef7eb2e8f9f7 1726
<> 144:ef7eb2e8f9f7 1727 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1728
<> 144:ef7eb2e8f9f7 1729 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1730 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1731
<> 144:ef7eb2e8f9f7 1732 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1733 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1734
<> 144:ef7eb2e8f9f7 1735 return HAL_OK;
<> 144:ef7eb2e8f9f7 1736 }
<> 144:ef7eb2e8f9f7 1737
<> 144:ef7eb2e8f9f7 1738 /**
<> 144:ef7eb2e8f9f7 1739 * @brief Disable the color lookup table without reloading.
<> 144:ef7eb2e8f9f7 1740 * Variant of the function HAL_LTDC_DisableCLUT without immediate reload
<> 144:ef7eb2e8f9f7 1741 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1742 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1743 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1744 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1745 * 0 or 1
<> 144:ef7eb2e8f9f7 1746 * @retval HAL status
<> 144:ef7eb2e8f9f7 1747 */
<> 144:ef7eb2e8f9f7 1748 HAL_StatusTypeDef HAL_LTDC_DisableCLUT_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1749 {
<> 144:ef7eb2e8f9f7 1750
<> 144:ef7eb2e8f9f7 1751 /* Process locked */
<> 144:ef7eb2e8f9f7 1752 __HAL_LOCK(hltdc);
<> 144:ef7eb2e8f9f7 1753
<> 144:ef7eb2e8f9f7 1754 /* Change LTDC peripheral state */
<> 144:ef7eb2e8f9f7 1755 hltdc->State = HAL_LTDC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1756
<> 144:ef7eb2e8f9f7 1757 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1758 assert_param(IS_LTDC_LAYER(LayerIdx));
<> 144:ef7eb2e8f9f7 1759
<> 144:ef7eb2e8f9f7 1760 /* Disable LTDC color lookup table by setting CLUTEN bit */
<> 144:ef7eb2e8f9f7 1761 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_CLUTEN;
<> 144:ef7eb2e8f9f7 1762
<> 144:ef7eb2e8f9f7 1763 /* Do not Sets the Reload */
<> 144:ef7eb2e8f9f7 1764
<> 144:ef7eb2e8f9f7 1765 /* Change the LTDC state*/
<> 144:ef7eb2e8f9f7 1766 hltdc->State = HAL_LTDC_STATE_READY;
<> 144:ef7eb2e8f9f7 1767
<> 144:ef7eb2e8f9f7 1768 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1769 __HAL_UNLOCK(hltdc);
<> 144:ef7eb2e8f9f7 1770
<> 144:ef7eb2e8f9f7 1771 return HAL_OK;
<> 144:ef7eb2e8f9f7 1772 }
<> 144:ef7eb2e8f9f7 1773
<> 144:ef7eb2e8f9f7 1774 /**
<> 144:ef7eb2e8f9f7 1775 * @}
<> 144:ef7eb2e8f9f7 1776 */
<> 144:ef7eb2e8f9f7 1777
<> 144:ef7eb2e8f9f7 1778 /** @defgroup LTDC_Exported_Functions_Group4 Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 1779 * @brief Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 1780 *
<> 144:ef7eb2e8f9f7 1781 @verbatim
<> 144:ef7eb2e8f9f7 1782 ===============================================================================
<> 144:ef7eb2e8f9f7 1783 ##### Peripheral State and Errors functions #####
<> 144:ef7eb2e8f9f7 1784 ===============================================================================
<> 144:ef7eb2e8f9f7 1785 [..]
<> 144:ef7eb2e8f9f7 1786 This subsection provides functions allowing to
<> 144:ef7eb2e8f9f7 1787 (+) Check the LTDC state.
<> 144:ef7eb2e8f9f7 1788 (+) Get error code.
<> 144:ef7eb2e8f9f7 1789
<> 144:ef7eb2e8f9f7 1790 @endverbatim
<> 144:ef7eb2e8f9f7 1791 * @{
<> 144:ef7eb2e8f9f7 1792 */
<> 144:ef7eb2e8f9f7 1793
<> 144:ef7eb2e8f9f7 1794 /**
<> 144:ef7eb2e8f9f7 1795 * @brief Return the LTDC state
<> 144:ef7eb2e8f9f7 1796 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1797 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1798 * @retval HAL state
<> 144:ef7eb2e8f9f7 1799 */
<> 144:ef7eb2e8f9f7 1800 HAL_LTDC_StateTypeDef HAL_LTDC_GetState(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 1801 {
<> 144:ef7eb2e8f9f7 1802 return hltdc->State;
<> 144:ef7eb2e8f9f7 1803 }
<> 144:ef7eb2e8f9f7 1804
<> 144:ef7eb2e8f9f7 1805 /**
<> 144:ef7eb2e8f9f7 1806 * @brief Return the LTDC error code
<> 144:ef7eb2e8f9f7 1807 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1808 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1809 * @retval LTDC Error Code
<> 144:ef7eb2e8f9f7 1810 */
<> 144:ef7eb2e8f9f7 1811 uint32_t HAL_LTDC_GetError(LTDC_HandleTypeDef *hltdc)
<> 144:ef7eb2e8f9f7 1812 {
<> 144:ef7eb2e8f9f7 1813 return hltdc->ErrorCode;
<> 144:ef7eb2e8f9f7 1814 }
<> 144:ef7eb2e8f9f7 1815
<> 144:ef7eb2e8f9f7 1816 /**
<> 144:ef7eb2e8f9f7 1817 * @}
<> 144:ef7eb2e8f9f7 1818 */
<> 144:ef7eb2e8f9f7 1819
<> 144:ef7eb2e8f9f7 1820 /**
<> 144:ef7eb2e8f9f7 1821 * @brief Configures the LTDC peripheral
<> 144:ef7eb2e8f9f7 1822 * @param hltdc : Pointer to a LTDC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1823 * the configuration information for the LTDC.
<> 144:ef7eb2e8f9f7 1824 * @param pLayerCfg: Pointer LTDC Layer Configuration structure
<> 144:ef7eb2e8f9f7 1825 * @param LayerIdx: LTDC Layer index.
<> 144:ef7eb2e8f9f7 1826 * This parameter can be one of the following values: 0 or 1
<> 144:ef7eb2e8f9f7 1827 * @retval None
<> 144:ef7eb2e8f9f7 1828 */
<> 144:ef7eb2e8f9f7 1829 static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx)
<> 144:ef7eb2e8f9f7 1830 {
<> 144:ef7eb2e8f9f7 1831 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 1832 uint32_t tmp1 = 0;
<> 144:ef7eb2e8f9f7 1833 uint32_t tmp2 = 0;
<> 144:ef7eb2e8f9f7 1834
<> 144:ef7eb2e8f9f7 1835 /* Configures the horizontal start and stop position */
<> 144:ef7eb2e8f9f7 1836 tmp = ((pLayerCfg->WindowX1 + ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16)) << 16);
<> 144:ef7eb2e8f9f7 1837 LTDC_LAYER(hltdc, LayerIdx)->WHPCR &= ~(LTDC_LxWHPCR_WHSTPOS | LTDC_LxWHPCR_WHSPPOS);
<> 144:ef7eb2e8f9f7 1838 LTDC_LAYER(hltdc, LayerIdx)->WHPCR = ((pLayerCfg->WindowX0 + ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16) + 1) | tmp);
<> 144:ef7eb2e8f9f7 1839
<> 144:ef7eb2e8f9f7 1840 /* Configures the vertical start and stop position */
<> 144:ef7eb2e8f9f7 1841 tmp = ((pLayerCfg->WindowY1 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP)) << 16);
<> 144:ef7eb2e8f9f7 1842 LTDC_LAYER(hltdc, LayerIdx)->WVPCR &= ~(LTDC_LxWVPCR_WVSTPOS | LTDC_LxWVPCR_WVSPPOS);
<> 144:ef7eb2e8f9f7 1843 LTDC_LAYER(hltdc, LayerIdx)->WVPCR = ((pLayerCfg->WindowY0 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP) + 1) | tmp);
<> 144:ef7eb2e8f9f7 1844
<> 144:ef7eb2e8f9f7 1845 /* Specifies the pixel format */
<> 144:ef7eb2e8f9f7 1846 LTDC_LAYER(hltdc, LayerIdx)->PFCR &= ~(LTDC_LxPFCR_PF);
<> 144:ef7eb2e8f9f7 1847 LTDC_LAYER(hltdc, LayerIdx)->PFCR = (pLayerCfg->PixelFormat);
<> 144:ef7eb2e8f9f7 1848
<> 144:ef7eb2e8f9f7 1849 /* Configures the default color values */
<> 144:ef7eb2e8f9f7 1850 tmp = ((uint32_t)(pLayerCfg->Backcolor.Green) << 8);
<> 144:ef7eb2e8f9f7 1851 tmp1 = ((uint32_t)(pLayerCfg->Backcolor.Red) << 16);
<> 144:ef7eb2e8f9f7 1852 tmp2 = (pLayerCfg->Alpha0 << 24);
<> 144:ef7eb2e8f9f7 1853 LTDC_LAYER(hltdc, LayerIdx)->DCCR &= ~(LTDC_LxDCCR_DCBLUE | LTDC_LxDCCR_DCGREEN | LTDC_LxDCCR_DCRED | LTDC_LxDCCR_DCALPHA);
<> 144:ef7eb2e8f9f7 1854 LTDC_LAYER(hltdc, LayerIdx)->DCCR = (pLayerCfg->Backcolor.Blue | tmp | tmp1 | tmp2);
<> 144:ef7eb2e8f9f7 1855
<> 144:ef7eb2e8f9f7 1856 /* Specifies the constant alpha value */
<> 144:ef7eb2e8f9f7 1857 LTDC_LAYER(hltdc, LayerIdx)->CACR &= ~(LTDC_LxCACR_CONSTA);
<> 144:ef7eb2e8f9f7 1858 LTDC_LAYER(hltdc, LayerIdx)->CACR = (pLayerCfg->Alpha);
<> 144:ef7eb2e8f9f7 1859
<> 144:ef7eb2e8f9f7 1860 /* Specifies the blending factors */
<> 144:ef7eb2e8f9f7 1861 LTDC_LAYER(hltdc, LayerIdx)->BFCR &= ~(LTDC_LxBFCR_BF2 | LTDC_LxBFCR_BF1);
<> 144:ef7eb2e8f9f7 1862 LTDC_LAYER(hltdc, LayerIdx)->BFCR = (pLayerCfg->BlendingFactor1 | pLayerCfg->BlendingFactor2);
<> 144:ef7eb2e8f9f7 1863
<> 144:ef7eb2e8f9f7 1864 /* Configures the color frame buffer start address */
<> 144:ef7eb2e8f9f7 1865 LTDC_LAYER(hltdc, LayerIdx)->CFBAR &= ~(LTDC_LxCFBAR_CFBADD);
<> 144:ef7eb2e8f9f7 1866 LTDC_LAYER(hltdc, LayerIdx)->CFBAR = (pLayerCfg->FBStartAdress);
<> 144:ef7eb2e8f9f7 1867
<> 144:ef7eb2e8f9f7 1868 if(pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
<> 144:ef7eb2e8f9f7 1869 {
<> 144:ef7eb2e8f9f7 1870 tmp = 4;
<> 144:ef7eb2e8f9f7 1871 }
<> 144:ef7eb2e8f9f7 1872 else if (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB888)
<> 144:ef7eb2e8f9f7 1873 {
<> 144:ef7eb2e8f9f7 1874 tmp = 3;
<> 144:ef7eb2e8f9f7 1875 }
<> 144:ef7eb2e8f9f7 1876 else if((pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
<> 144:ef7eb2e8f9f7 1877 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
<> 144:ef7eb2e8f9f7 1878 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \
<> 144:ef7eb2e8f9f7 1879 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_AL88))
<> 144:ef7eb2e8f9f7 1880 {
<> 144:ef7eb2e8f9f7 1881 tmp = 2;
<> 144:ef7eb2e8f9f7 1882 }
<> 144:ef7eb2e8f9f7 1883 else
<> 144:ef7eb2e8f9f7 1884 {
<> 144:ef7eb2e8f9f7 1885 tmp = 1;
<> 144:ef7eb2e8f9f7 1886 }
<> 144:ef7eb2e8f9f7 1887
<> 144:ef7eb2e8f9f7 1888 /* Configures the color frame buffer pitch in byte */
<> 144:ef7eb2e8f9f7 1889 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~(LTDC_LxCFBLR_CFBLL | LTDC_LxCFBLR_CFBP);
<> 144:ef7eb2e8f9f7 1890 LTDC_LAYER(hltdc, LayerIdx)->CFBLR = (((pLayerCfg->ImageWidth * tmp) << 16) | (((pLayerCfg->WindowX1 - pLayerCfg->WindowX0) * tmp) + 3));
<> 144:ef7eb2e8f9f7 1891
<> 144:ef7eb2e8f9f7 1892 /* Configures the frame buffer line number */
<> 144:ef7eb2e8f9f7 1893 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR &= ~(LTDC_LxCFBLNR_CFBLNBR);
<> 144:ef7eb2e8f9f7 1894 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR = (pLayerCfg->ImageHeight);
<> 144:ef7eb2e8f9f7 1895
<> 144:ef7eb2e8f9f7 1896 /* Enable LTDC_Layer by setting LEN bit */
<> 144:ef7eb2e8f9f7 1897 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_LEN;
<> 144:ef7eb2e8f9f7 1898 }
<> 144:ef7eb2e8f9f7 1899
<> 144:ef7eb2e8f9f7 1900 /**
<> 144:ef7eb2e8f9f7 1901 * @}
<> 144:ef7eb2e8f9f7 1902 */
<> 144:ef7eb2e8f9f7 1903
<> 144:ef7eb2e8f9f7 1904 #endif /* HAL_LTDC_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 1905
<> 144:ef7eb2e8f9f7 1906 /**
<> 144:ef7eb2e8f9f7 1907 * @}
<> 144:ef7eb2e8f9f7 1908 */
<> 144:ef7eb2e8f9f7 1909 #endif /* STM32F746xx || STM32F756xx || STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx */
<> 144:ef7eb2e8f9f7 1910
<> 144:ef7eb2e8f9f7 1911 /**
<> 144:ef7eb2e8f9f7 1912 * @}
<> 144:ef7eb2e8f9f7 1913 */
<> 144:ef7eb2e8f9f7 1914
<> 144:ef7eb2e8f9f7 1915 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/