Mercurial > public > ostc4
comparison Common/Drivers/STM32F4xx_HAL_DRIVER_v120/Src/stm32f4xx_hal_ltdc.c @ 38:5f11787b4f42
include in ostc4 repository
author | heinrichsweikamp |
---|---|
date | Sat, 28 Apr 2018 11:52:34 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
37:ccc45c0e1ea2 | 38:5f11787b4f42 |
---|---|
1 /** | |
2 ****************************************************************************** | |
3 * @file stm32f4xx_hal_ltdc.c | |
4 * @author MCD Application Team | |
5 * @version V1.2.0 | |
6 * @date 26-December-2014 | |
7 * @brief LTDC HAL module driver. | |
8 * This file provides firmware functions to manage the following | |
9 * functionalities of the LTDC peripheral: | |
10 * + Initialization and de-initialization functions | |
11 * + IO operation functions | |
12 * + Peripheral Control functions | |
13 * + Peripheral State and Errors functions | |
14 * | |
15 @verbatim | |
16 ============================================================================== | |
17 ##### How to use this driver ##### | |
18 ============================================================================== | |
19 [..] | |
20 (#) Program the required configuration through the following parameters: | |
21 the LTDC timing, the horizontal and vertical polarity, | |
22 the pixel clock polarity, Data Enable polarity and the LTDC background color value | |
23 using HAL_LTDC_Init() function | |
24 | |
25 (#) Program the required configuration through the following parameters: | |
26 the pixel format, the blending factors, input alpha value, the window size | |
27 and the image size using HAL_LTDC_ConfigLayer() function for foreground | |
28 or/and background layer. | |
29 | |
30 (#) Optionally, configure and enable the CLUT using HAL_LTDC_ConfigCLUT() and | |
31 HAL_LTDC_EnableCLUT functions. | |
32 | |
33 (#) Optionally, enable the Dither using HAL_LTDC_EnableDither(). | |
34 | |
35 (#) Optionally, configure and enable the Color keying using HAL_LTDC_ConfigColorKeying() | |
36 and HAL_LTDC_EnableColorKeying functions. | |
37 | |
38 (#) Optionally, configure LineInterrupt using HAL_LTDC_ProgramLineEvent() | |
39 function | |
40 | |
41 (#) If needed, reconfigure and change the pixel format value, the alpha value | |
42 value, the window size, the window position and the layer start address | |
43 for foreground or/and background layer using respectively the following | |
44 functions: HAL_LTDC_SetPixelFormat(), HAL_LTDC_SetAlpha(), HAL_LTDC_SetWindowSize(), | |
45 HAL_LTDC_SetWindowPosition(), HAL_LTDC_SetAddress. | |
46 | |
47 (#) To control LTDC state you can use the following function: HAL_LTDC_GetState() | |
48 | |
49 *** LTDC HAL driver macros list *** | |
50 ============================================= | |
51 [..] | |
52 Below the list of most used macros in LTDC HAL driver. | |
53 | |
54 (+) __HAL_LTDC_ENABLE: Enable the LTDC. | |
55 (+) __HAL_LTDC_DISABLE: Disable the LTDC. | |
56 (+) __HAL_LTDC_LAYER_ENABLE: Enable the LTDC Layer. | |
57 (+) __HAL_LTDC_LAYER_DISABLE: Disable the LTDC Layer. | |
58 (+) __HAL_LTDC_RELOAD_CONFIG: Reload Layer Configuration. | |
59 (+) __HAL_LTDC_GET_FLAG: Get the LTDC pending flags. | |
60 (+) __HAL_LTDC_CLEAR_FLAG: Clear the LTDC pending flags. | |
61 (+) __HAL_LTDC_ENABLE_IT: Enable the specified LTDC interrupts. | |
62 (+) __HAL_LTDC_DISABLE_IT: Disable the specified LTDC interrupts. | |
63 (+) __HAL_LTDC_GET_IT_SOURCE: Check whether the specified LTDC interrupt has occurred or not. | |
64 | |
65 [..] | |
66 (@) You can refer to the LTDC HAL driver header file for more useful macros | |
67 | |
68 @endverbatim | |
69 ****************************************************************************** | |
70 * @attention | |
71 * | |
72 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2> | |
73 * | |
74 * Redistribution and use in source and binary forms, with or without modification, | |
75 * are permitted provided that the following conditions are met: | |
76 * 1. Redistributions of source code must retain the above copyright notice, | |
77 * this list of conditions and the following disclaimer. | |
78 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
79 * this list of conditions and the following disclaimer in the documentation | |
80 * and/or other materials provided with the distribution. | |
81 * 3. Neither the name of STMicroelectronics nor the names of its contributors | |
82 * may be used to endorse or promote products derived from this software | |
83 * without specific prior written permission. | |
84 * | |
85 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
86 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
87 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
88 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
89 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
90 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
91 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
92 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
93 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
94 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
95 * | |
96 ****************************************************************************** | |
97 */ | |
98 | |
99 /* Includes ------------------------------------------------------------------*/ | |
100 #include "stm32f4xx_hal.h" | |
101 | |
102 /** @addtogroup STM32F4xx_HAL_Driver | |
103 * @{ | |
104 */ | |
105 /** @defgroup LTDC LTDC | |
106 * @brief LTDC HAL module driver | |
107 * @{ | |
108 */ | |
109 | |
110 #ifdef HAL_LTDC_MODULE_ENABLED | |
111 | |
112 #if defined(STM32F429xx) || defined(STM32F439xx) | |
113 | |
114 /* Private typedef -----------------------------------------------------------*/ | |
115 /* Private define ------------------------------------------------------------*/ | |
116 /* Private macro -------------------------------------------------------------*/ | |
117 /* Private variables ---------------------------------------------------------*/ | |
118 /* Private function prototypes -----------------------------------------------*/ | |
119 static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx); | |
120 /* Private functions ---------------------------------------------------------*/ | |
121 | |
122 /** @defgroup LTDC_Exported_Functions LTDC Exported Functions | |
123 * @{ | |
124 */ | |
125 | |
126 /** @defgroup LTDC_Exported_Functions_Group1 Initialization and Configuration functions | |
127 * @brief Initialization and Configuration functions | |
128 * | |
129 @verbatim | |
130 =============================================================================== | |
131 ##### Initialization and Configuration functions ##### | |
132 =============================================================================== | |
133 [..] This section provides functions allowing to: | |
134 (+) Initialize and configure the LTDC | |
135 (+) De-initialize the LTDC | |
136 | |
137 @endverbatim | |
138 * @{ | |
139 */ | |
140 | |
141 /** | |
142 * @brief Initializes the LTDC according to the specified | |
143 * parameters in the LTDC_InitTypeDef and create the associated handle. | |
144 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
145 * the configuration information for the LTDC. | |
146 * @retval HAL status | |
147 */ | |
148 HAL_StatusTypeDef HAL_LTDC_Init(LTDC_HandleTypeDef *hltdc) | |
149 { | |
150 uint32_t tmp = 0, tmp1 = 0; | |
151 | |
152 /* Check the LTDC peripheral state */ | |
153 if(hltdc == NULL) | |
154 { | |
155 return HAL_ERROR; | |
156 } | |
157 | |
158 /* Check function parameters */ | |
159 assert_param(IS_LTDC_ALL_INSTANCE(hltdc->Instance)); | |
160 assert_param(IS_LTDC_HSYNC(hltdc->Init.HorizontalSync)); | |
161 assert_param(IS_LTDC_VSYNC(hltdc->Init.VerticalSync)); | |
162 assert_param(IS_LTDC_AHBP(hltdc->Init.AccumulatedHBP)); | |
163 assert_param(IS_LTDC_AVBP(hltdc->Init.AccumulatedVBP)); | |
164 assert_param(IS_LTDC_AAH(hltdc->Init.AccumulatedActiveH)); | |
165 assert_param(IS_LTDC_AAW(hltdc->Init.AccumulatedActiveW)); | |
166 assert_param(IS_LTDC_TOTALH(hltdc->Init.TotalHeigh)); | |
167 assert_param(IS_LTDC_TOTALW(hltdc->Init.TotalWidth)); | |
168 assert_param(IS_LTDC_HSPOL(hltdc->Init.HSPolarity)); | |
169 assert_param(IS_LTDC_VSPOL(hltdc->Init.VSPolarity)); | |
170 assert_param(IS_LTDC_DEPOL(hltdc->Init.DEPolarity)); | |
171 assert_param(IS_LTDC_PCPOL(hltdc->Init.PCPolarity)); | |
172 | |
173 if(hltdc->State == HAL_LTDC_STATE_RESET) | |
174 { | |
175 /* Init the low level hardware */ | |
176 HAL_LTDC_MspInit(hltdc); | |
177 } | |
178 | |
179 /* Change LTDC peripheral state */ | |
180 hltdc->State = HAL_LTDC_STATE_BUSY; | |
181 | |
182 /* Configures the HS, VS, DE and PC polarity */ | |
183 hltdc->Instance->GCR &= ~(LTDC_GCR_HSPOL | LTDC_GCR_VSPOL | LTDC_GCR_DEPOL | LTDC_GCR_PCPOL); | |
184 hltdc->Instance->GCR |= (uint32_t)(hltdc->Init.HSPolarity | hltdc->Init.VSPolarity | \ | |
185 hltdc->Init.DEPolarity | hltdc->Init.PCPolarity); | |
186 | |
187 /* Sets Synchronization size */ | |
188 hltdc->Instance->SSCR &= ~(LTDC_SSCR_VSH | LTDC_SSCR_HSW); | |
189 tmp = (hltdc->Init.HorizontalSync << 16); | |
190 hltdc->Instance->SSCR |= (tmp | hltdc->Init.VerticalSync); | |
191 | |
192 /* Sets Accumulated Back porch */ | |
193 hltdc->Instance->BPCR &= ~(LTDC_BPCR_AVBP | LTDC_BPCR_AHBP); | |
194 tmp = (hltdc->Init.AccumulatedHBP << 16); | |
195 hltdc->Instance->BPCR |= (tmp | hltdc->Init.AccumulatedVBP); | |
196 | |
197 /* Sets Accumulated Active Width */ | |
198 hltdc->Instance->AWCR &= ~(LTDC_AWCR_AAH | LTDC_AWCR_AAW); | |
199 tmp = (hltdc->Init.AccumulatedActiveW << 16); | |
200 hltdc->Instance->AWCR |= (tmp | hltdc->Init.AccumulatedActiveH); | |
201 | |
202 /* Sets Total Width */ | |
203 hltdc->Instance->TWCR &= ~(LTDC_TWCR_TOTALH | LTDC_TWCR_TOTALW); | |
204 tmp = (hltdc->Init.TotalWidth << 16); | |
205 hltdc->Instance->TWCR |= (tmp | hltdc->Init.TotalHeigh); | |
206 | |
207 /* Sets the background color value */ | |
208 tmp = ((uint32_t)(hltdc->Init.Backcolor.Green) << 8); | |
209 tmp1 = ((uint32_t)(hltdc->Init.Backcolor.Red) << 16); | |
210 hltdc->Instance->BCCR &= ~(LTDC_BCCR_BCBLUE | LTDC_BCCR_BCGREEN | LTDC_BCCR_BCRED); | |
211 hltdc->Instance->BCCR |= (tmp1 | tmp | hltdc->Init.Backcolor.Blue); | |
212 | |
213 /* Enable the transfer Error interrupt */ | |
214 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_TE); | |
215 | |
216 /* Enable the FIFO underrun interrupt */ | |
217 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_FU); | |
218 | |
219 /* Enable LTDC by setting LTDCEN bit */ | |
220 __HAL_LTDC_ENABLE(hltdc); | |
221 | |
222 /* Initialize the error code */ | |
223 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE; | |
224 | |
225 /* Initialize the LTDC state*/ | |
226 hltdc->State = HAL_LTDC_STATE_READY; | |
227 | |
228 return HAL_OK; | |
229 } | |
230 | |
231 /** | |
232 * @brief Deinitializes the LTDC peripheral registers to their default reset | |
233 * values. | |
234 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
235 * the configuration information for the LTDC. | |
236 * @retval None | |
237 */ | |
238 | |
239 HAL_StatusTypeDef HAL_LTDC_DeInit(LTDC_HandleTypeDef *hltdc) | |
240 { | |
241 /* DeInit the low level hardware */ | |
242 HAL_LTDC_MspDeInit(hltdc); | |
243 | |
244 /* Initialize the error code */ | |
245 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE; | |
246 | |
247 /* Initialize the LTDC state*/ | |
248 hltdc->State = HAL_LTDC_STATE_RESET; | |
249 | |
250 /* Release Lock */ | |
251 __HAL_UNLOCK(hltdc); | |
252 | |
253 return HAL_OK; | |
254 } | |
255 | |
256 /** | |
257 * @brief Initializes the LTDC MSP. | |
258 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains | |
259 * the configuration information for the LTDC. | |
260 * @retval None | |
261 */ | |
262 __weak void HAL_LTDC_MspInit(LTDC_HandleTypeDef* hltdc) | |
263 { | |
264 /* NOTE : This function Should not be modified, when the callback is needed, | |
265 the HAL_LTDC_MspInit could be implemented in the user file | |
266 */ | |
267 } | |
268 | |
269 /** | |
270 * @brief DeInitializes the LTDC MSP. | |
271 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains | |
272 * the configuration information for the LTDC. | |
273 * @retval None | |
274 */ | |
275 __weak void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef* hltdc) | |
276 { | |
277 /* NOTE : This function Should not be modified, when the callback is needed, | |
278 the HAL_LTDC_MspDeInit could be implemented in the user file | |
279 */ | |
280 } | |
281 | |
282 /** | |
283 * @} | |
284 */ | |
285 | |
286 /** @defgroup LTDC_Exported_Functions_Group2 IO operation functions | |
287 * @brief IO operation functions | |
288 * | |
289 @verbatim | |
290 =============================================================================== | |
291 ##### IO operation functions ##### | |
292 =============================================================================== | |
293 [..] This section provides function allowing to: | |
294 (+) Handle LTDC interrupt request | |
295 | |
296 @endverbatim | |
297 * @{ | |
298 */ | |
299 /** | |
300 * @brief Handles LTDC interrupt request. | |
301 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
302 * the configuration information for the LTDC. | |
303 * @retval HAL status | |
304 */ | |
305 void HAL_LTDC_IRQHandler(LTDC_HandleTypeDef *hltdc) | |
306 { | |
307 /* Transfer Error Interrupt management ***************************************/ | |
308 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_TE) != RESET) | |
309 { | |
310 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_TE) != RESET) | |
311 { | |
312 /* Disable the transfer Error interrupt */ | |
313 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_TE); | |
314 | |
315 /* Clear the transfer error flag */ | |
316 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_TE); | |
317 | |
318 /* Update error code */ | |
319 hltdc->ErrorCode |= HAL_LTDC_ERROR_TE; | |
320 | |
321 /* Change LTDC state */ | |
322 hltdc->State = HAL_LTDC_STATE_ERROR; | |
323 | |
324 /* Process unlocked */ | |
325 __HAL_UNLOCK(hltdc); | |
326 | |
327 /* Transfer error Callback */ | |
328 HAL_LTDC_ErrorCallback(hltdc); | |
329 } | |
330 } | |
331 /* FIFO underrun Interrupt management ***************************************/ | |
332 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_FU) != RESET) | |
333 { | |
334 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_FU) != RESET) | |
335 { | |
336 /* Disable the FIFO underrun interrupt */ | |
337 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_FU); | |
338 | |
339 /* Clear the FIFO underrun flag */ | |
340 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_FU); | |
341 | |
342 /* Update error code */ | |
343 hltdc->ErrorCode |= HAL_LTDC_ERROR_FU; | |
344 | |
345 /* Change LTDC state */ | |
346 hltdc->State = HAL_LTDC_STATE_ERROR; | |
347 | |
348 /* Process unlocked */ | |
349 __HAL_UNLOCK(hltdc); | |
350 | |
351 /* Transfer error Callback */ | |
352 HAL_LTDC_ErrorCallback(hltdc); | |
353 } | |
354 } | |
355 /* Line Interrupt management ************************************************/ | |
356 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_LI) != RESET) | |
357 { | |
358 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_LI) != RESET) | |
359 { | |
360 /* Disable the Line interrupt */ | |
361 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_LI); | |
362 | |
363 /* Clear the Line interrupt flag */ | |
364 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_LI); | |
365 | |
366 /* Change LTDC state */ | |
367 hltdc->State = HAL_LTDC_STATE_READY; | |
368 | |
369 /* Process unlocked */ | |
370 __HAL_UNLOCK(hltdc); | |
371 | |
372 /* Line interrupt Callback */ | |
373 HAL_LTDC_LineEvenCallback(hltdc); | |
374 } | |
375 } | |
376 } | |
377 | |
378 /** | |
379 * @brief Error LTDC callback. | |
380 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
381 * the configuration information for the LTDC. | |
382 * @retval None | |
383 */ | |
384 __weak void HAL_LTDC_ErrorCallback(LTDC_HandleTypeDef *hltdc) | |
385 { | |
386 /* NOTE : This function Should not be modified, when the callback is needed, | |
387 the HAL_LTDC_ErrorCallback could be implemented in the user file | |
388 */ | |
389 } | |
390 | |
391 /** | |
392 * @brief Line Event callback. | |
393 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
394 * the configuration information for the LTDC. | |
395 * @retval None | |
396 */ | |
397 __weak void HAL_LTDC_LineEvenCallback(LTDC_HandleTypeDef *hltdc) | |
398 { | |
399 /* NOTE : This function Should not be modified, when the callback is needed, | |
400 the HAL_LTDC_LineEvenCallback could be implemented in the user file | |
401 */ | |
402 } | |
403 | |
404 /** | |
405 * @} | |
406 */ | |
407 | |
408 /** @defgroup LTDC_Exported_Functions_Group3 Peripheral Control functions | |
409 * @brief Peripheral Control functions | |
410 * | |
411 @verbatim | |
412 =============================================================================== | |
413 ##### Peripheral Control functions ##### | |
414 =============================================================================== | |
415 [..] This section provides functions allowing to: | |
416 (+) Configure the LTDC foreground or/and background parameters. | |
417 (+) Set the active layer. | |
418 (+) Configure the color keying. | |
419 (+) Configure the C-LUT. | |
420 (+) Enable / Disable the color keying. | |
421 (+) Enable / Disable the C-LUT. | |
422 (+) Update the layer position. | |
423 (+) Update the layer size. | |
424 (+) Update pixel format on the fly. | |
425 (+) Update transparency on the fly. | |
426 (+) Update address on the fly. | |
427 | |
428 @endverbatim | |
429 * @{ | |
430 */ | |
431 | |
432 /** | |
433 * @brief Configure the LTDC Layer according to the specified | |
434 * parameters in the LTDC_InitTypeDef and create the associated handle. | |
435 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
436 * the configuration information for the LTDC. | |
437 * @param pLayerCfg: pointer to a LTDC_LayerCfgTypeDef structure that contains | |
438 * the configuration information for the Layer. | |
439 * @param LayerIdx: LTDC Layer index. | |
440 * This parameter can be one of the following values: | |
441 * 0 or 1 | |
442 * @retval HAL status | |
443 */ | |
444 HAL_StatusTypeDef HAL_LTDC_ConfigLayer(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx) | |
445 { | |
446 /* Process locked */ | |
447 __HAL_LOCK(hltdc); | |
448 | |
449 /* Change LTDC peripheral state */ | |
450 hltdc->State = HAL_LTDC_STATE_BUSY; | |
451 | |
452 /* Check the parameters */ | |
453 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
454 assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat)); | |
455 assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1)); | |
456 assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2)); | |
457 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0)); | |
458 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1)); | |
459 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0)); | |
460 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1)); | |
461 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0)); | |
462 assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth)); | |
463 assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight)); | |
464 | |
465 /* Copy new layer configuration into handle structure */ | |
466 hltdc->LayerCfg[LayerIdx] = *pLayerCfg; | |
467 | |
468 /* Configure the LTDC Layer */ | |
469 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx); | |
470 | |
471 /* Sets the Reload type */ | |
472 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
473 | |
474 /* Initialize the LTDC state*/ | |
475 hltdc->State = HAL_LTDC_STATE_READY; | |
476 | |
477 /* Process unlocked */ | |
478 __HAL_UNLOCK(hltdc); | |
479 | |
480 return HAL_OK; | |
481 } | |
482 | |
483 /** | |
484 * @brief Configure the color keying. | |
485 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
486 * the configuration information for the LTDC. | |
487 * @param RGBValue: the color key value | |
488 * @param LayerIdx: LTDC Layer index. | |
489 * This parameter can be one of the following values: | |
490 * 0 or 1 | |
491 * @retval HAL status | |
492 */ | |
493 HAL_StatusTypeDef HAL_LTDC_ConfigColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t RGBValue, uint32_t LayerIdx) | |
494 { | |
495 /* Process locked */ | |
496 __HAL_LOCK(hltdc); | |
497 | |
498 /* Change LTDC peripheral state */ | |
499 hltdc->State = HAL_LTDC_STATE_BUSY; | |
500 | |
501 /* Check the parameters */ | |
502 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
503 | |
504 /* Configures the default color values */ | |
505 LTDC_LAYER(hltdc, LayerIdx)->CKCR &= ~(LTDC_LxCKCR_CKBLUE | LTDC_LxCKCR_CKGREEN | LTDC_LxCKCR_CKRED); | |
506 LTDC_LAYER(hltdc, LayerIdx)->CKCR = RGBValue; | |
507 | |
508 /* Sets the Reload type */ | |
509 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
510 | |
511 /* Change the LTDC state*/ | |
512 hltdc->State = HAL_LTDC_STATE_READY; | |
513 | |
514 /* Process unlocked */ | |
515 __HAL_UNLOCK(hltdc); | |
516 | |
517 return HAL_OK; | |
518 } | |
519 | |
520 /** | |
521 * @brief Load the color lookup table. | |
522 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
523 * the configuration information for the LTDC. | |
524 * @param pCLUT: pointer to the color lookup table address. | |
525 * @param CLUTSize: the color lookup table size. | |
526 * @param LayerIdx: LTDC Layer index. | |
527 * This parameter can be one of the following values: | |
528 * 0 or 1 | |
529 * @retval HAL status | |
530 */ | |
531 HAL_StatusTypeDef HAL_LTDC_ConfigCLUT(LTDC_HandleTypeDef *hltdc, uint32_t *pCLUT, uint32_t CLUTSize, uint32_t LayerIdx) | |
532 { | |
533 uint32_t tmp = 0; | |
534 uint32_t counter = 0; | |
535 uint32_t pcounter = 0; | |
536 | |
537 /* Process locked */ | |
538 __HAL_LOCK(hltdc); | |
539 | |
540 /* Change LTDC peripheral state */ | |
541 hltdc->State = HAL_LTDC_STATE_BUSY; | |
542 | |
543 /* Check the parameters */ | |
544 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
545 | |
546 for(counter = 0; (counter < CLUTSize); counter++) | |
547 { | |
548 if(hltdc->LayerCfg[LayerIdx].PixelFormat == LTDC_PIXEL_FORMAT_AL44) | |
549 { | |
550 tmp = (((counter + 16*counter) << 24) | ((uint32_t)(*pCLUT) & 0xFF) | ((uint32_t)(*pCLUT) & 0xFF00) | ((uint32_t)(*pCLUT) & 0xFF0000)); | |
551 } | |
552 else | |
553 { | |
554 tmp = ((counter << 24) | ((uint32_t)(*pCLUT) & 0xFF) | ((uint32_t)(*pCLUT) & 0xFF00) | ((uint32_t)(*pCLUT) & 0xFF0000)); | |
555 } | |
556 pcounter = (uint32_t)pCLUT + sizeof(*pCLUT); | |
557 pCLUT = (uint32_t *)pcounter; | |
558 | |
559 /* Specifies the C-LUT address and RGB value */ | |
560 LTDC_LAYER(hltdc, LayerIdx)->CLUTWR = tmp; | |
561 } | |
562 | |
563 /* Change the LTDC state*/ | |
564 hltdc->State = HAL_LTDC_STATE_READY; | |
565 | |
566 /* Process unlocked */ | |
567 __HAL_UNLOCK(hltdc); | |
568 | |
569 return HAL_OK; | |
570 } | |
571 | |
572 /** | |
573 * @brief Enable the color keying. | |
574 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
575 * the configuration information for the LTDC. | |
576 * @param LayerIdx: LTDC Layer index. | |
577 * This parameter can be one of the following values: | |
578 * 0 or 1 | |
579 * @retval HAL status | |
580 */ | |
581 HAL_StatusTypeDef HAL_LTDC_EnableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx) | |
582 { | |
583 /* Process locked */ | |
584 __HAL_LOCK(hltdc); | |
585 | |
586 /* Change LTDC peripheral state */ | |
587 hltdc->State = HAL_LTDC_STATE_BUSY; | |
588 | |
589 /* Check the parameters */ | |
590 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
591 | |
592 /* Enable LTDC color keying by setting COLKEN bit */ | |
593 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_COLKEN; | |
594 | |
595 /* Sets the Reload type */ | |
596 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
597 | |
598 /* Change the LTDC state*/ | |
599 hltdc->State = HAL_LTDC_STATE_READY; | |
600 | |
601 /* Process unlocked */ | |
602 __HAL_UNLOCK(hltdc); | |
603 | |
604 return HAL_OK; | |
605 } | |
606 | |
607 /** | |
608 * @brief Disable the color keying. | |
609 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
610 * the configuration information for the LTDC. | |
611 * @param LayerIdx: LTDC Layer index. | |
612 * This parameter can be one of the following values: | |
613 * 0 or 1 | |
614 * @retval HAL status | |
615 */ | |
616 HAL_StatusTypeDef HAL_LTDC_DisableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx) | |
617 { | |
618 /* Process locked */ | |
619 __HAL_LOCK(hltdc); | |
620 | |
621 /* Change LTDC peripheral state */ | |
622 hltdc->State = HAL_LTDC_STATE_BUSY; | |
623 | |
624 /* Check the parameters */ | |
625 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
626 | |
627 /* Disable LTDC color keying by setting COLKEN bit */ | |
628 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_COLKEN; | |
629 | |
630 /* Sets the Reload type */ | |
631 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
632 | |
633 /* Change the LTDC state*/ | |
634 hltdc->State = HAL_LTDC_STATE_READY; | |
635 | |
636 /* Process unlocked */ | |
637 __HAL_UNLOCK(hltdc); | |
638 | |
639 return HAL_OK; | |
640 } | |
641 | |
642 /** | |
643 * @brief Enable the color lookup table. | |
644 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
645 * the configuration information for the LTDC. | |
646 * @param LayerIdx: LTDC Layer index. | |
647 * This parameter can be one of the following values: | |
648 * 0 or 1 | |
649 * @retval HAL status | |
650 */ | |
651 HAL_StatusTypeDef HAL_LTDC_EnableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx) | |
652 { | |
653 | |
654 /* Process locked */ | |
655 __HAL_LOCK(hltdc); | |
656 | |
657 /* Change LTDC peripheral state */ | |
658 hltdc->State = HAL_LTDC_STATE_BUSY; | |
659 | |
660 /* Check the parameters */ | |
661 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
662 | |
663 /* Disable LTDC color lookup table by setting CLUTEN bit */ | |
664 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_CLUTEN; | |
665 | |
666 /* Sets the Reload type */ | |
667 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
668 | |
669 /* Change the LTDC state*/ | |
670 hltdc->State = HAL_LTDC_STATE_READY; | |
671 | |
672 /* Process unlocked */ | |
673 __HAL_UNLOCK(hltdc); | |
674 | |
675 return HAL_OK; | |
676 } | |
677 | |
678 /** | |
679 * @brief Disable the color lookup table. | |
680 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
681 * the configuration information for the LTDC. | |
682 * @param LayerIdx: LTDC Layer index. | |
683 * This parameter can be one of the following values: | |
684 * 0 or 1 | |
685 * @retval HAL status | |
686 */ | |
687 HAL_StatusTypeDef HAL_LTDC_DisableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx) | |
688 { | |
689 | |
690 /* Process locked */ | |
691 __HAL_LOCK(hltdc); | |
692 | |
693 /* Change LTDC peripheral state */ | |
694 hltdc->State = HAL_LTDC_STATE_BUSY; | |
695 | |
696 /* Check the parameters */ | |
697 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
698 | |
699 /* Disable LTDC color lookup table by setting CLUTEN bit */ | |
700 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_CLUTEN; | |
701 | |
702 /* Sets the Reload type */ | |
703 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
704 | |
705 /* Change the LTDC state*/ | |
706 hltdc->State = HAL_LTDC_STATE_READY; | |
707 | |
708 /* Process unlocked */ | |
709 __HAL_UNLOCK(hltdc); | |
710 | |
711 return HAL_OK; | |
712 } | |
713 | |
714 /** | |
715 * @brief Enables Dither. | |
716 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
717 * the configuration information for the LTDC. | |
718 * @retval HAL status | |
719 */ | |
720 | |
721 HAL_StatusTypeDef HAL_LTDC_EnableDither(LTDC_HandleTypeDef *hltdc) | |
722 { | |
723 /* Process locked */ | |
724 __HAL_LOCK(hltdc); | |
725 | |
726 /* Change LTDC peripheral state */ | |
727 hltdc->State = HAL_LTDC_STATE_BUSY; | |
728 | |
729 /* Enable Dither by setting DTEN bit */ | |
730 LTDC->GCR |= (uint32_t)LTDC_GCR_DTEN; | |
731 | |
732 /* Change the LTDC state*/ | |
733 hltdc->State = HAL_LTDC_STATE_READY; | |
734 | |
735 /* Process unlocked */ | |
736 __HAL_UNLOCK(hltdc); | |
737 | |
738 return HAL_OK; | |
739 } | |
740 | |
741 /** | |
742 * @brief Disables Dither. | |
743 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
744 * the configuration information for the LTDC. | |
745 * @retval HAL status | |
746 */ | |
747 | |
748 HAL_StatusTypeDef HAL_LTDC_DisableDither(LTDC_HandleTypeDef *hltdc) | |
749 { | |
750 /* Process locked */ | |
751 __HAL_LOCK(hltdc); | |
752 | |
753 /* Change LTDC peripheral state */ | |
754 hltdc->State = HAL_LTDC_STATE_BUSY; | |
755 | |
756 /* Disable Dither by setting DTEN bit */ | |
757 LTDC->GCR &= ~(uint32_t)LTDC_GCR_DTEN; | |
758 | |
759 /* Change the LTDC state*/ | |
760 hltdc->State = HAL_LTDC_STATE_READY; | |
761 | |
762 /* Process unlocked */ | |
763 __HAL_UNLOCK(hltdc); | |
764 | |
765 return HAL_OK; | |
766 } | |
767 | |
768 /** | |
769 * @brief Set the LTDC window size. | |
770 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
771 * the configuration information for the LTDC. | |
772 * @param XSize: LTDC Pixel per line | |
773 * @param YSize: LTDC Line number | |
774 * @param LayerIdx: LTDC Layer index. | |
775 * This parameter can be one of the following values: | |
776 * 0 or 1 | |
777 * @retval HAL status | |
778 */ | |
779 HAL_StatusTypeDef HAL_LTDC_SetWindowSize(LTDC_HandleTypeDef *hltdc, uint32_t XSize, uint32_t YSize, uint32_t LayerIdx) | |
780 { | |
781 LTDC_LayerCfgTypeDef *pLayerCfg; | |
782 | |
783 /* Process locked */ | |
784 __HAL_LOCK(hltdc); | |
785 | |
786 /* Change LTDC peripheral state */ | |
787 hltdc->State = HAL_LTDC_STATE_BUSY; | |
788 | |
789 /* Get layer configuration from handle structure */ | |
790 pLayerCfg = &hltdc->LayerCfg[LayerIdx]; | |
791 | |
792 /* Check the parameters (Layers parameters)*/ | |
793 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
794 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0)); | |
795 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1)); | |
796 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0)); | |
797 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1)); | |
798 assert_param(IS_LTDC_CFBLL(XSize)); | |
799 assert_param(IS_LTDC_CFBLNBR(YSize)); | |
800 | |
801 /* update horizontal start/stop */ | |
802 pLayerCfg->WindowX0 = 0; | |
803 pLayerCfg->WindowX1 = XSize + pLayerCfg->WindowX0; | |
804 | |
805 /* update vertical start/stop */ | |
806 pLayerCfg->WindowY0 = 0; | |
807 pLayerCfg->WindowY1 = YSize + pLayerCfg->WindowY0; | |
808 | |
809 /* Reconfigures the color frame buffer pitch in byte */ | |
810 pLayerCfg->ImageWidth = XSize; | |
811 | |
812 /* Reconfigures the frame buffer line number */ | |
813 pLayerCfg->ImageHeight = YSize; | |
814 | |
815 /* Set LTDC parameters */ | |
816 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx); | |
817 | |
818 /* Sets the Reload type */ | |
819 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
820 | |
821 /* Change the LTDC state*/ | |
822 hltdc->State = HAL_LTDC_STATE_READY; | |
823 | |
824 /* Process unlocked */ | |
825 __HAL_UNLOCK(hltdc); | |
826 | |
827 return HAL_OK; | |
828 } | |
829 | |
830 /** | |
831 * @brief Set the LTDC window position. | |
832 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
833 * the configuration information for the LTDC. | |
834 * @param X0: LTDC window X offset | |
835 * @param Y0: LTDC window Y offset | |
836 * @param LayerIdx: LTDC Layer index. | |
837 * This parameter can be one of the following values: | |
838 * 0 or 1 | |
839 * @retval HAL status | |
840 */ | |
841 HAL_StatusTypeDef HAL_LTDC_SetWindowPosition(LTDC_HandleTypeDef *hltdc, uint32_t X0, uint32_t Y0, uint32_t LayerIdx) | |
842 { | |
843 LTDC_LayerCfgTypeDef *pLayerCfg; | |
844 | |
845 /* Process locked */ | |
846 __HAL_LOCK(hltdc); | |
847 | |
848 /* Change LTDC peripheral state */ | |
849 hltdc->State = HAL_LTDC_STATE_BUSY; | |
850 | |
851 /* Get layer configuration from handle structure */ | |
852 pLayerCfg = &hltdc->LayerCfg[LayerIdx]; | |
853 | |
854 /* Check the parameters */ | |
855 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
856 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0)); | |
857 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1)); | |
858 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0)); | |
859 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1)); | |
860 | |
861 /* update horizontal start/stop */ | |
862 pLayerCfg->WindowX0 = X0; | |
863 pLayerCfg->WindowX1 = X0 + pLayerCfg->ImageWidth; | |
864 | |
865 /* update vertical start/stop */ | |
866 pLayerCfg->WindowY0 = Y0; | |
867 pLayerCfg->WindowY1 = Y0 + pLayerCfg->ImageHeight; | |
868 | |
869 /* Set LTDC parameters */ | |
870 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx); | |
871 | |
872 /* Sets the Reload type */ | |
873 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
874 | |
875 /* Change the LTDC state*/ | |
876 hltdc->State = HAL_LTDC_STATE_READY; | |
877 | |
878 /* Process unlocked */ | |
879 __HAL_UNLOCK(hltdc); | |
880 | |
881 return HAL_OK; | |
882 } | |
883 | |
884 /** | |
885 * @brief Reconfigure the pixel format. | |
886 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
887 * the configuration information for the LTDC. | |
888 * @param Pixelformat: new pixel format value. | |
889 * @param LayerIdx: LTDC Layer index. | |
890 * This parameter can be one of the following values: | |
891 * 0 or 1. | |
892 * @retval HAL status | |
893 */ | |
894 HAL_StatusTypeDef HAL_LTDC_SetPixelFormat(LTDC_HandleTypeDef *hltdc, uint32_t Pixelformat, uint32_t LayerIdx) | |
895 { | |
896 LTDC_LayerCfgTypeDef *pLayerCfg; | |
897 | |
898 /* Process locked */ | |
899 __HAL_LOCK(hltdc); | |
900 | |
901 /* Change LTDC peripheral state */ | |
902 hltdc->State = HAL_LTDC_STATE_BUSY; | |
903 | |
904 /* Check the parameters */ | |
905 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
906 assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat)); | |
907 | |
908 /* Get layer configuration from handle structure */ | |
909 pLayerCfg = &hltdc->LayerCfg[LayerIdx]; | |
910 | |
911 /* Reconfigure the pixel format */ | |
912 pLayerCfg->PixelFormat = Pixelformat; | |
913 | |
914 /* Set LTDC parameters */ | |
915 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx); | |
916 | |
917 /* Sets the Reload type */ | |
918 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
919 | |
920 /* Change the LTDC state*/ | |
921 hltdc->State = HAL_LTDC_STATE_READY; | |
922 | |
923 /* Process unlocked */ | |
924 __HAL_UNLOCK(hltdc); | |
925 | |
926 return HAL_OK; | |
927 } | |
928 | |
929 /** | |
930 * @brief Reconfigure the layer alpha value. | |
931 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
932 * the configuration information for the LTDC. | |
933 * @param Alpha: new alpha value. | |
934 * @param LayerIdx: LTDC Layer index. | |
935 * This parameter can be one of the following values: | |
936 * 0 or 1 | |
937 * @retval HAL status | |
938 */ | |
939 HAL_StatusTypeDef HAL_LTDC_SetAlpha(LTDC_HandleTypeDef *hltdc, uint32_t Alpha, uint32_t LayerIdx) | |
940 { | |
941 LTDC_LayerCfgTypeDef *pLayerCfg; | |
942 | |
943 /* Process locked */ | |
944 __HAL_LOCK(hltdc); | |
945 | |
946 /* Change LTDC peripheral state */ | |
947 hltdc->State = HAL_LTDC_STATE_BUSY; | |
948 | |
949 /* Check the parameters */ | |
950 assert_param(IS_LTDC_ALPHA(Alpha)); | |
951 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
952 | |
953 /* Get layer configuration from handle structure */ | |
954 pLayerCfg = &hltdc->LayerCfg[LayerIdx]; | |
955 | |
956 /* Reconfigure the Alpha value */ | |
957 pLayerCfg->Alpha = Alpha; | |
958 | |
959 /* Set LTDC parameters */ | |
960 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx); | |
961 | |
962 /* Sets the Reload type */ | |
963 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
964 | |
965 /* Change the LTDC state*/ | |
966 hltdc->State = HAL_LTDC_STATE_READY; | |
967 | |
968 /* Process unlocked */ | |
969 __HAL_UNLOCK(hltdc); | |
970 | |
971 return HAL_OK; | |
972 } | |
973 /** | |
974 * @brief Reconfigure the frame buffer Address. | |
975 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
976 * the configuration information for the LTDC. | |
977 * @param Address: new address value. | |
978 * @param LayerIdx: LTDC Layer index. | |
979 * This parameter can be one of the following values: | |
980 * 0 or 1. | |
981 * @retval HAL status | |
982 */ | |
983 HAL_StatusTypeDef HAL_LTDC_SetAddress(LTDC_HandleTypeDef *hltdc, uint32_t Address, uint32_t LayerIdx) | |
984 { | |
985 LTDC_LayerCfgTypeDef *pLayerCfg; | |
986 | |
987 /* Process locked */ | |
988 __HAL_LOCK(hltdc); | |
989 | |
990 /* Change LTDC peripheral state */ | |
991 hltdc->State = HAL_LTDC_STATE_BUSY; | |
992 | |
993 /* Check the parameters */ | |
994 assert_param(IS_LTDC_LAYER(LayerIdx)); | |
995 | |
996 /* Get layer configuration from handle structure */ | |
997 pLayerCfg = &hltdc->LayerCfg[LayerIdx]; | |
998 | |
999 /* Reconfigure the Address */ | |
1000 pLayerCfg->FBStartAdress = Address; | |
1001 | |
1002 /* Set LTDC parameters */ | |
1003 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx); | |
1004 | |
1005 /* Sets the Reload type */ | |
1006 hltdc->Instance->SRCR = LTDC_SRCR_IMR; | |
1007 | |
1008 /* Change the LTDC state*/ | |
1009 hltdc->State = HAL_LTDC_STATE_READY; | |
1010 | |
1011 /* Process unlocked */ | |
1012 __HAL_UNLOCK(hltdc); | |
1013 | |
1014 return HAL_OK; | |
1015 } | |
1016 | |
1017 /** | |
1018 * @brief Define the position of the line interrupt . | |
1019 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
1020 * the configuration information for the LTDC. | |
1021 * @param Line: Line Interrupt Position. | |
1022 * @retval HAL status | |
1023 */ | |
1024 HAL_StatusTypeDef HAL_LTDC_ProgramLineEvent(LTDC_HandleTypeDef *hltdc, uint32_t Line) | |
1025 { | |
1026 /* Process locked */ | |
1027 __HAL_LOCK(hltdc); | |
1028 | |
1029 /* Change LTDC peripheral state */ | |
1030 hltdc->State = HAL_LTDC_STATE_BUSY; | |
1031 | |
1032 /* Check the parameters */ | |
1033 assert_param(IS_LTDC_LIPOS(Line)); | |
1034 | |
1035 /* Enable the Line interrupt */ | |
1036 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_LI); | |
1037 | |
1038 /* Sets the Line Interrupt position */ | |
1039 LTDC->LIPCR = (uint32_t)Line; | |
1040 | |
1041 /* Change the LTDC state*/ | |
1042 hltdc->State = HAL_LTDC_STATE_READY; | |
1043 | |
1044 /* Process unlocked */ | |
1045 __HAL_UNLOCK(hltdc); | |
1046 | |
1047 return HAL_OK; | |
1048 } | |
1049 | |
1050 /** | |
1051 * @} | |
1052 */ | |
1053 | |
1054 /** @defgroup LTDC_Exported_Functions_Group4 Peripheral State and Errors functions | |
1055 * @brief Peripheral State and Errors functions | |
1056 * | |
1057 @verbatim | |
1058 =============================================================================== | |
1059 ##### Peripheral State and Errors functions ##### | |
1060 =============================================================================== | |
1061 [..] | |
1062 This subsection provides functions allowing to | |
1063 (+) Check the LTDC state. | |
1064 (+) Get error code. | |
1065 | |
1066 @endverbatim | |
1067 * @{ | |
1068 */ | |
1069 | |
1070 /** | |
1071 * @brief Return the LTDC state | |
1072 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains | |
1073 * the configuration information for the LTDC. | |
1074 * @retval HAL state | |
1075 */ | |
1076 HAL_LTDC_StateTypeDef HAL_LTDC_GetState(LTDC_HandleTypeDef *hltdc) | |
1077 { | |
1078 return hltdc->State; | |
1079 } | |
1080 | |
1081 /** | |
1082 * @brief Return the LTDC error code | |
1083 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains | |
1084 * the configuration information for the LTDC. | |
1085 * @retval LTDC Error Code | |
1086 */ | |
1087 uint32_t HAL_LTDC_GetError(LTDC_HandleTypeDef *hltdc) | |
1088 { | |
1089 return hltdc->ErrorCode; | |
1090 } | |
1091 | |
1092 /** | |
1093 * @} | |
1094 */ | |
1095 | |
1096 /** | |
1097 * @brief Configures the LTDC peripheral | |
1098 * @param hltdc : Pointer to a LTDC_HandleTypeDef structure that contains | |
1099 * the configuration information for the LTDC. | |
1100 * @param pLayerCfg: Pointer LTDC Layer Configuration structure | |
1101 * @param LayerIdx: LTDC Layer index. | |
1102 * This parameter can be one of the following values: 0 or 1 | |
1103 * @retval None | |
1104 */ | |
1105 static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx) | |
1106 { | |
1107 uint32_t tmp = 0; | |
1108 uint32_t tmp1 = 0; | |
1109 uint32_t tmp2 = 0; | |
1110 | |
1111 /* Configures the horizontal start and stop position */ | |
1112 tmp = ((pLayerCfg->WindowX1 + ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16)) << 16); | |
1113 LTDC_LAYER(hltdc, LayerIdx)->WHPCR &= ~(LTDC_LxWHPCR_WHSTPOS | LTDC_LxWHPCR_WHSPPOS); | |
1114 LTDC_LAYER(hltdc, LayerIdx)->WHPCR = ((pLayerCfg->WindowX0 + ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16) + 1) | tmp); | |
1115 | |
1116 /* Configures the vertical start and stop position */ | |
1117 tmp = ((pLayerCfg->WindowY1 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP)) << 16); | |
1118 LTDC_LAYER(hltdc, LayerIdx)->WVPCR &= ~(LTDC_LxWVPCR_WVSTPOS | LTDC_LxWVPCR_WVSPPOS); | |
1119 LTDC_LAYER(hltdc, LayerIdx)->WVPCR = ((pLayerCfg->WindowY0 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP) + 1) | tmp); | |
1120 | |
1121 /* Specifies the pixel format */ | |
1122 LTDC_LAYER(hltdc, LayerIdx)->PFCR &= ~(LTDC_LxPFCR_PF); | |
1123 LTDC_LAYER(hltdc, LayerIdx)->PFCR = (pLayerCfg->PixelFormat); | |
1124 | |
1125 /* Configures the default color values */ | |
1126 tmp = ((uint32_t)(pLayerCfg->Backcolor.Green) << 8); | |
1127 tmp1 = ((uint32_t)(pLayerCfg->Backcolor.Red) << 16); | |
1128 tmp2 = (pLayerCfg->Alpha0 << 24); | |
1129 LTDC_LAYER(hltdc, LayerIdx)->DCCR &= ~(LTDC_LxDCCR_DCBLUE | LTDC_LxDCCR_DCGREEN | LTDC_LxDCCR_DCRED | LTDC_LxDCCR_DCALPHA); | |
1130 LTDC_LAYER(hltdc, LayerIdx)->DCCR = (pLayerCfg->Backcolor.Blue | tmp | tmp1 | tmp2); | |
1131 | |
1132 /* Specifies the constant alpha value */ | |
1133 LTDC_LAYER(hltdc, LayerIdx)->CACR &= ~(LTDC_LxCACR_CONSTA); | |
1134 LTDC_LAYER(hltdc, LayerIdx)->CACR = (pLayerCfg->Alpha); | |
1135 | |
1136 /* Specifies the blending factors */ | |
1137 LTDC_LAYER(hltdc, LayerIdx)->BFCR &= ~(LTDC_LxBFCR_BF2 | LTDC_LxBFCR_BF1); | |
1138 LTDC_LAYER(hltdc, LayerIdx)->BFCR = (pLayerCfg->BlendingFactor1 | pLayerCfg->BlendingFactor2); | |
1139 | |
1140 /* Configures the color frame buffer start address */ | |
1141 LTDC_LAYER(hltdc, LayerIdx)->CFBAR &= ~(LTDC_LxCFBAR_CFBADD); | |
1142 LTDC_LAYER(hltdc, LayerIdx)->CFBAR = (pLayerCfg->FBStartAdress); | |
1143 | |
1144 if(pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888) | |
1145 { | |
1146 tmp = 4; | |
1147 } | |
1148 else if (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB888) | |
1149 { | |
1150 tmp = 3; | |
1151 } | |
1152 else if((pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \ | |
1153 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \ | |
1154 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \ | |
1155 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_AL88)) | |
1156 { | |
1157 tmp = 2; | |
1158 } | |
1159 else | |
1160 { | |
1161 tmp = 1; | |
1162 } | |
1163 | |
1164 /* Configures the color frame buffer pitch in byte */ | |
1165 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~(LTDC_LxCFBLR_CFBLL | LTDC_LxCFBLR_CFBP); | |
1166 LTDC_LAYER(hltdc, LayerIdx)->CFBLR = (((pLayerCfg->ImageWidth * tmp) << 16) | ((pLayerCfg->ImageWidth * tmp) + 3)); | |
1167 | |
1168 /* Configures the frame buffer line number */ | |
1169 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR &= ~(LTDC_LxCFBLNR_CFBLNBR); | |
1170 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR = (pLayerCfg->ImageHeight); | |
1171 | |
1172 /* Enable LTDC_Layer by setting LEN bit */ | |
1173 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_LEN; | |
1174 } | |
1175 | |
1176 /** | |
1177 * @} | |
1178 */ | |
1179 #endif /* STM32F429xx || STM32F439xx */ | |
1180 #endif /* HAL_LTDC_MODULE_ENABLED */ | |
1181 /** | |
1182 * @} | |
1183 */ | |
1184 | |
1185 /** | |
1186 * @} | |
1187 */ | |
1188 | |
1189 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |