1 /** 2 ****************************************************************************** 3 * @file stm32u5xx_ll_dma2d.c 4 * @author MCD Application Team 5 * @brief DMA2D LL module driver. 6 ****************************************************************************** 7 * @attention 8 * 9 * Copyright (c) 2021 STMicroelectronics. 10 * All rights reserved. 11 * 12 * This software is licensed under terms that can be found in the LICENSE file 13 * in the root directory of this software component. 14 * If no LICENSE file comes with this software, it is provided AS-IS. 15 * 16 ****************************************************************************** 17 */ 18 #if defined(USE_FULL_LL_DRIVER) 19 20 /* Includes ------------------------------------------------------------------*/ 21 #include "stm32u5xx_ll_dma2d.h" 22 #include "stm32u5xx_ll_bus.h" 23 #ifdef USE_FULL_ASSERT 24 #include "stm32_assert.h" 25 #else 26 #define assert_param(expr) ((void)0U) 27 #endif /* USE_FULL_ASSERT */ 28 29 /** @addtogroup STM32U5xx_LL_Driver 30 * @{ 31 */ 32 33 #if defined (DMA2D) 34 35 /** @addtogroup DMA2D_LL 36 * @{ 37 */ 38 39 /* Private types -------------------------------------------------------------*/ 40 /* Private variables ---------------------------------------------------------*/ 41 /* Private constants ---------------------------------------------------------*/ 42 /** @addtogroup DMA2D_LL_Private_Constants DMA2D Private Constants 43 * @{ 44 */ 45 #define LL_DMA2D_COLOR 0xFFU /*!< Maximum output color setting */ 46 #define LL_DMA2D_NUMBEROFLINES DMA2D_NLR_NL /*!< Maximum number of lines */ 47 #define LL_DMA2D_NUMBEROFPIXELS (DMA2D_NLR_PL >> DMA2D_NLR_PL_Pos) /*!< Maximum number of pixels per lines */ 48 #define LL_DMA2D_OFFSET_MAX 0x3FFFU /*!< Maximum output line offset expressed in pixels */ 49 #define LL_DMA2D_CLUTSIZE_MAX 0xFFU /*!< Maximum CLUT size */ 50 /** 51 * @} 52 */ 53 /* Private macros ------------------------------------------------------------*/ 54 /** @addtogroup DMA2D_LL_Private_Macros 55 * @{ 56 */ 57 #define IS_LL_DMA2D_MODE(MODE) (((MODE) == LL_DMA2D_MODE_M2M) || \ 58 ((MODE) == LL_DMA2D_MODE_M2M_PFC) || \ 59 ((MODE) == LL_DMA2D_MODE_M2M_BLEND) || \ 60 ((MODE) == LL_DMA2D_MODE_M2M_BLEND_FIXED_COLOR_FG) || \ 61 ((MODE) == LL_DMA2D_MODE_M2M_BLEND_FIXED_COLOR_BG) || \ 62 ((MODE) == LL_DMA2D_MODE_R2M)) 63 64 #define IS_LL_DMA2D_OCMODE(MODE_ARGB) (((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB8888) || \ 65 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_RGB888) || \ 66 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_RGB565) || \ 67 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB1555) || \ 68 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB4444)) 69 70 #define IS_LL_DMA2D_GREEN(GREEN) ((GREEN) <= LL_DMA2D_COLOR) 71 #define IS_LL_DMA2D_RED(RED) ((RED) <= LL_DMA2D_COLOR) 72 #define IS_LL_DMA2D_BLUE(BLUE) ((BLUE) <= LL_DMA2D_COLOR) 73 #define IS_LL_DMA2D_ALPHA(ALPHA) ((ALPHA) <= LL_DMA2D_COLOR) 74 75 #define IS_LL_DMA2D_OFFSET_MODE(MODE) (((MODE) == LL_DMA2D_LINE_OFFSET_PIXELS) || \ 76 ((MODE) == LL_DMA2D_LINE_OFFSET_BYTES)) 77 78 #define IS_LL_DMA2D_OFFSET(OFFSET) ((OFFSET) <= LL_DMA2D_OFFSET_MAX) 79 80 #define IS_LL_DMA2D_LINE(LINES) ((LINES) <= LL_DMA2D_NUMBEROFLINES) 81 #define IS_LL_DMA2D_PIXEL(PIXELS) ((PIXELS) <= LL_DMA2D_NUMBEROFPIXELS) 82 83 #define IS_LL_DMA2D_SWAP_MODE(MODE) (((MODE) == LL_DMA2D_SWAP_MODE_REGULAR) || \ 84 ((MODE) == LL_DMA2D_SWAP_MODE_TWO_BY_TWO)) 85 86 #define IS_LL_DMA2D_ALPHAINV(ALPHA) (((ALPHA) == LL_DMA2D_ALPHA_REGULAR) || \ 87 ((ALPHA) == LL_DMA2D_ALPHA_INVERTED)) 88 89 #define IS_LL_DMA2D_RBSWAP(RBSWAP) (((RBSWAP) == LL_DMA2D_RB_MODE_REGULAR) || \ 90 ((RBSWAP) == LL_DMA2D_RB_MODE_SWAP)) 91 92 #define IS_LL_DMA2D_LCMODE(MODE_ARGB) (((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB8888) || \ 93 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_RGB888) || \ 94 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_RGB565) || \ 95 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB1555) || \ 96 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB4444) || \ 97 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_L8) || \ 98 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_AL44) || \ 99 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_AL88) || \ 100 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_L4) || \ 101 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_A8) || \ 102 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_A4)) 103 104 #define IS_LL_DMA2D_CLUTCMODE(CLUTCMODE) (((CLUTCMODE) == LL_DMA2D_CLUT_COLOR_MODE_ARGB8888) || \ 105 ((CLUTCMODE) == LL_DMA2D_CLUT_COLOR_MODE_RGB888)) 106 107 #define IS_LL_DMA2D_CLUTSIZE(SIZE) ((SIZE) <= LL_DMA2D_CLUTSIZE_MAX) 108 109 #define IS_LL_DMA2D_ALPHAMODE(MODE) (((MODE) == LL_DMA2D_ALPHA_MODE_NO_MODIF) || \ 110 ((MODE) == LL_DMA2D_ALPHA_MODE_REPLACE) || \ 111 ((MODE) == LL_DMA2D_ALPHA_MODE_COMBINE)) 112 113 #if defined(DMA2D_FGPFCCR_CSS) 114 #define IS_LL_DMA2D_CHROMA_SUB_SAMPLING(CSS) (((CSS) == LL_DMA2D_CSS_444) || \ 115 ((CSS) == LL_DMA2D_CSS_422) || \ 116 ((CSS) == LL_DMA2D_CSS_420)) 117 #endif /* DMA2D_FGPFCCR_CSS */ 118 119 /** 120 * @} 121 */ 122 123 /* Private function prototypes -----------------------------------------------*/ 124 125 /* Exported functions --------------------------------------------------------*/ 126 /** @addtogroup DMA2D_LL_Exported_Functions 127 * @{ 128 */ 129 130 /** @addtogroup DMA2D_LL_EF_Init_Functions Initialization and De-initialization Functions 131 * @{ 132 */ 133 134 /** 135 * @brief De-initialize DMA2D registers (registers restored to their default values). 136 * @param DMA2Dx DMA2D Instance 137 * @retval An ErrorStatus enumeration value: 138 * - SUCCESS: DMA2D registers are de-initialized 139 * - ERROR: DMA2D registers are not de-initialized 140 */ LL_DMA2D_DeInit(const DMA2D_TypeDef * DMA2Dx)141 ErrorStatus LL_DMA2D_DeInit(const DMA2D_TypeDef *DMA2Dx) 142 { 143 ErrorStatus status = SUCCESS; 144 145 /* Check the parameters */ 146 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 147 148 if (DMA2Dx == DMA2D) 149 { 150 /* Force reset of DMA2D clock */ 151 LL_AHB1_GRP1_ForceReset(LL_AHB1_GRP1_PERIPH_DMA2D); 152 153 /* Release reset of DMA2D clock */ 154 LL_AHB1_GRP1_ReleaseReset(LL_AHB1_GRP1_PERIPH_DMA2D); 155 } 156 else 157 { 158 status = ERROR; 159 } 160 161 return (status); 162 } 163 164 /** 165 * @brief Initialize DMA2D registers according to the specified parameters in DMA2D_InitStruct. 166 * @note DMA2D transfers must be disabled to set initialization bits in configuration registers, 167 * otherwise ERROR result is returned. 168 * @param DMA2Dx DMA2D Instance 169 * @param DMA2D_InitStruct pointer to a LL_DMA2D_InitTypeDef structure 170 * that contains the configuration information for the specified DMA2D peripheral. 171 * @retval An ErrorStatus enumeration value: 172 * - SUCCESS: DMA2D registers are initialized according to DMA2D_InitStruct content 173 * - ERROR: Issue occurred during DMA2D registers initialization 174 */ LL_DMA2D_Init(DMA2D_TypeDef * DMA2Dx,LL_DMA2D_InitTypeDef * DMA2D_InitStruct)175 ErrorStatus LL_DMA2D_Init(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_InitTypeDef *DMA2D_InitStruct) 176 { 177 ErrorStatus status = ERROR; 178 LL_DMA2D_ColorTypeDef dma2d_colorstruct; 179 uint32_t tmp; 180 uint32_t tmp1; 181 uint32_t tmp2; 182 uint32_t regMask; 183 uint32_t regValue; 184 185 /* Check the parameters */ 186 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 187 assert_param(IS_LL_DMA2D_MODE(DMA2D_InitStruct->Mode)); 188 assert_param(IS_LL_DMA2D_OCMODE(DMA2D_InitStruct->ColorMode)); 189 assert_param(IS_LL_DMA2D_LINE(DMA2D_InitStruct->NbrOfLines)); 190 assert_param(IS_LL_DMA2D_PIXEL(DMA2D_InitStruct->NbrOfPixelsPerLines)); 191 assert_param(IS_LL_DMA2D_GREEN(DMA2D_InitStruct->OutputGreen)); 192 assert_param(IS_LL_DMA2D_RED(DMA2D_InitStruct->OutputRed)); 193 assert_param(IS_LL_DMA2D_BLUE(DMA2D_InitStruct->OutputBlue)); 194 assert_param(IS_LL_DMA2D_ALPHA(DMA2D_InitStruct->OutputAlpha)); 195 assert_param(IS_LL_DMA2D_SWAP_MODE(DMA2D_InitStruct->OutputSwapMode)); 196 assert_param(IS_LL_DMA2D_OFFSET_MODE(DMA2D_InitStruct->LineOffsetMode)); 197 assert_param(IS_LL_DMA2D_OFFSET(DMA2D_InitStruct->LineOffset)); 198 assert_param(IS_LL_DMA2D_ALPHAINV(DMA2D_InitStruct->AlphaInversionMode)); 199 assert_param(IS_LL_DMA2D_RBSWAP(DMA2D_InitStruct->RBSwapMode)); 200 201 /* DMA2D transfers must be disabled to configure bits in initialization registers */ 202 tmp = LL_DMA2D_IsTransferOngoing(DMA2Dx); 203 tmp1 = LL_DMA2D_FGND_IsEnabledCLUTLoad(DMA2Dx); 204 tmp2 = LL_DMA2D_BGND_IsEnabledCLUTLoad(DMA2Dx); 205 if ((tmp == 0U) && (tmp1 == 0U) && (tmp2 == 0U)) 206 { 207 /* DMA2D CR register configuration -------------------------------------------*/ 208 MODIFY_REG(DMA2Dx->CR, (DMA2D_CR_MODE | DMA2D_CR_LOM), \ 209 (DMA2D_InitStruct->Mode | DMA2D_InitStruct->LineOffsetMode)); 210 211 /* DMA2D OPFCCR register configuration ---------------------------------------*/ 212 regMask = DMA2D_OPFCCR_CM; 213 regValue = DMA2D_InitStruct->ColorMode; 214 215 regMask |= DMA2D_OPFCCR_SB; 216 regValue |= DMA2D_InitStruct->OutputSwapMode; 217 218 regMask |= (DMA2D_OPFCCR_RBS | DMA2D_OPFCCR_AI); 219 regValue |= (DMA2D_InitStruct->AlphaInversionMode | DMA2D_InitStruct->RBSwapMode); 220 221 222 MODIFY_REG(DMA2Dx->OPFCCR, regMask, regValue); 223 224 /* DMA2D OOR register configuration ------------------------------------------*/ 225 LL_DMA2D_SetLineOffset(DMA2Dx, DMA2D_InitStruct->LineOffset); 226 227 /* DMA2D NLR register configuration ------------------------------------------*/ 228 LL_DMA2D_ConfigSize(DMA2Dx, DMA2D_InitStruct->NbrOfLines, DMA2D_InitStruct->NbrOfPixelsPerLines); 229 230 /* DMA2D OMAR register configuration ------------------------------------------*/ 231 LL_DMA2D_SetOutputMemAddr(DMA2Dx, DMA2D_InitStruct->OutputMemoryAddress); 232 233 /* DMA2D OCOLR register configuration ------------------------------------------*/ 234 dma2d_colorstruct.ColorMode = DMA2D_InitStruct->ColorMode; 235 dma2d_colorstruct.OutputBlue = DMA2D_InitStruct->OutputBlue; 236 dma2d_colorstruct.OutputGreen = DMA2D_InitStruct->OutputGreen; 237 dma2d_colorstruct.OutputRed = DMA2D_InitStruct->OutputRed; 238 dma2d_colorstruct.OutputAlpha = DMA2D_InitStruct->OutputAlpha; 239 LL_DMA2D_ConfigOutputColor(DMA2Dx, &dma2d_colorstruct); 240 241 status = SUCCESS; 242 } 243 /* If DMA2D transfers are not disabled, return ERROR */ 244 245 return (status); 246 } 247 248 /** 249 * @brief Set each @ref LL_DMA2D_InitTypeDef field to default value. 250 * @param DMA2D_InitStruct pointer to a @ref LL_DMA2D_InitTypeDef structure 251 * whose fields will be set to default values. 252 * @retval None 253 */ LL_DMA2D_StructInit(LL_DMA2D_InitTypeDef * DMA2D_InitStruct)254 void LL_DMA2D_StructInit(LL_DMA2D_InitTypeDef *DMA2D_InitStruct) 255 { 256 /* Set DMA2D_InitStruct fields to default values */ 257 DMA2D_InitStruct->Mode = LL_DMA2D_MODE_M2M; 258 DMA2D_InitStruct->ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB8888; 259 DMA2D_InitStruct->NbrOfLines = 0x0U; 260 DMA2D_InitStruct->NbrOfPixelsPerLines = 0x0U; 261 DMA2D_InitStruct->LineOffsetMode = LL_DMA2D_LINE_OFFSET_PIXELS; 262 DMA2D_InitStruct->LineOffset = 0x0U; 263 DMA2D_InitStruct->OutputBlue = 0x0U; 264 DMA2D_InitStruct->OutputGreen = 0x0U; 265 DMA2D_InitStruct->OutputRed = 0x0U; 266 DMA2D_InitStruct->OutputAlpha = 0x0U; 267 DMA2D_InitStruct->OutputMemoryAddress = 0x0U; 268 DMA2D_InitStruct->OutputSwapMode = LL_DMA2D_SWAP_MODE_REGULAR; 269 DMA2D_InitStruct->AlphaInversionMode = LL_DMA2D_ALPHA_REGULAR; 270 DMA2D_InitStruct->RBSwapMode = LL_DMA2D_RB_MODE_REGULAR; 271 } 272 273 /** 274 * @brief Configure the foreground or background according to the specified parameters 275 * in the LL_DMA2D_LayerCfgTypeDef structure. 276 * @param DMA2Dx DMA2D Instance 277 * @param DMA2D_LayerCfg pointer to a LL_DMA2D_LayerCfgTypeDef structure that contains 278 * the configuration information for the specified layer. 279 * @param LayerIdx DMA2D Layer index. 280 * This parameter can be one of the following values: 281 * 0(background) / 1(foreground) 282 * @retval None 283 */ LL_DMA2D_ConfigLayer(DMA2D_TypeDef * DMA2Dx,LL_DMA2D_LayerCfgTypeDef * DMA2D_LayerCfg,uint32_t LayerIdx)284 void LL_DMA2D_ConfigLayer(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_LayerCfgTypeDef *DMA2D_LayerCfg, uint32_t LayerIdx) 285 { 286 /* Check the parameters */ 287 assert_param(IS_LL_DMA2D_OFFSET(DMA2D_LayerCfg->LineOffset)); 288 assert_param(IS_LL_DMA2D_LCMODE(DMA2D_LayerCfg->ColorMode)); 289 assert_param(IS_LL_DMA2D_CLUTCMODE(DMA2D_LayerCfg->CLUTColorMode)); 290 assert_param(IS_LL_DMA2D_CLUTSIZE(DMA2D_LayerCfg->CLUTSize)); 291 assert_param(IS_LL_DMA2D_ALPHAMODE(DMA2D_LayerCfg->AlphaMode)); 292 assert_param(IS_LL_DMA2D_GREEN(DMA2D_LayerCfg->Green)); 293 assert_param(IS_LL_DMA2D_RED(DMA2D_LayerCfg->Red)); 294 assert_param(IS_LL_DMA2D_BLUE(DMA2D_LayerCfg->Blue)); 295 assert_param(IS_LL_DMA2D_ALPHA(DMA2D_LayerCfg->Alpha)); 296 assert_param(IS_LL_DMA2D_ALPHAINV(DMA2D_LayerCfg->AlphaInversionMode)); 297 assert_param(IS_LL_DMA2D_RBSWAP(DMA2D_LayerCfg->RBSwapMode)); 298 #if defined(DMA2D_FGPFCCR_CSS) 299 assert_param(IS_LL_DMA2D_CHROMA_SUB_SAMPLING(DMA2D_LayerCfg->ChromaSubSampling)); 300 #endif /* DMA2D_FGPFCCR_CSS */ 301 302 303 if (LayerIdx == 0U) 304 { 305 /* Configure the background memory address */ 306 LL_DMA2D_BGND_SetMemAddr(DMA2Dx, DMA2D_LayerCfg->MemoryAddress); 307 308 /* Configure the background line offset */ 309 LL_DMA2D_BGND_SetLineOffset(DMA2Dx, DMA2D_LayerCfg->LineOffset); 310 311 /* Configure the background Alpha value, Alpha mode, RB swap, Alpha inversion 312 CLUT size, CLUT Color mode and Color mode */ 313 MODIFY_REG(DMA2Dx->BGPFCCR, \ 314 (DMA2D_BGPFCCR_ALPHA | DMA2D_BGPFCCR_RBS | DMA2D_BGPFCCR_AI | DMA2D_BGPFCCR_AM | \ 315 DMA2D_BGPFCCR_CS | DMA2D_BGPFCCR_CCM | DMA2D_BGPFCCR_CM), \ 316 ((DMA2D_LayerCfg->Alpha << DMA2D_BGPFCCR_ALPHA_Pos) | DMA2D_LayerCfg->RBSwapMode | \ 317 DMA2D_LayerCfg->AlphaInversionMode | DMA2D_LayerCfg->AlphaMode | \ 318 (DMA2D_LayerCfg->CLUTSize << DMA2D_BGPFCCR_CS_Pos) | DMA2D_LayerCfg->CLUTColorMode | \ 319 DMA2D_LayerCfg->ColorMode)); 320 321 /* Configure the background color */ 322 LL_DMA2D_BGND_SetColor(DMA2Dx, DMA2D_LayerCfg->Red, DMA2D_LayerCfg->Green, DMA2D_LayerCfg->Blue); 323 324 /* Configure the background CLUT memory address */ 325 LL_DMA2D_BGND_SetCLUTMemAddr(DMA2Dx, DMA2D_LayerCfg->CLUTMemoryAddress); 326 } 327 else 328 { 329 /* Configure the foreground memory address */ 330 LL_DMA2D_FGND_SetMemAddr(DMA2Dx, DMA2D_LayerCfg->MemoryAddress); 331 332 /* Configure the foreground line offset */ 333 LL_DMA2D_FGND_SetLineOffset(DMA2Dx, DMA2D_LayerCfg->LineOffset); 334 335 #if defined(DMA2D_FGPFCCR_CSS) 336 /* Configure the foreground Alpha value, Alpha mode, RB swap, Alpha inversion 337 CLUT size, CLUT Color mode and Color mode */ 338 MODIFY_REG(DMA2Dx->FGPFCCR, \ 339 (DMA2D_FGPFCCR_ALPHA | DMA2D_FGPFCCR_RBS | DMA2D_FGPFCCR_AI | DMA2D_FGPFCCR_CSS | DMA2D_FGPFCCR_AM | \ 340 DMA2D_FGPFCCR_CS | DMA2D_FGPFCCR_CCM | DMA2D_FGPFCCR_CM), \ 341 ((DMA2D_LayerCfg->Alpha << DMA2D_FGPFCCR_ALPHA_Pos) | DMA2D_LayerCfg->RBSwapMode | \ 342 DMA2D_LayerCfg->AlphaInversionMode | DMA2D_LayerCfg->ChromaSubSampling | \ 343 DMA2D_LayerCfg->AlphaMode | (DMA2D_LayerCfg->CLUTSize << DMA2D_FGPFCCR_CS_Pos) | \ 344 DMA2D_LayerCfg->CLUTColorMode | DMA2D_LayerCfg->ColorMode)); 345 #else 346 /* Configure the foreground Alpha value, Alpha mode, RB swap, Alpha inversion 347 CLUT size, CLUT Color mode and Color mode */ 348 MODIFY_REG(DMA2Dx->FGPFCCR, \ 349 (DMA2D_FGPFCCR_ALPHA | DMA2D_FGPFCCR_RBS | DMA2D_FGPFCCR_AI | DMA2D_FGPFCCR_AM | \ 350 DMA2D_FGPFCCR_CS | DMA2D_FGPFCCR_CCM | DMA2D_FGPFCCR_CM), \ 351 ((DMA2D_LayerCfg->Alpha << DMA2D_FGPFCCR_ALPHA_Pos) | DMA2D_LayerCfg->RBSwapMode | \ 352 DMA2D_LayerCfg->AlphaInversionMode | DMA2D_LayerCfg->AlphaMode | \ 353 (DMA2D_LayerCfg->CLUTSize << DMA2D_FGPFCCR_CS_Pos) | DMA2D_LayerCfg->CLUTColorMode | \ 354 DMA2D_LayerCfg->ColorMode)); 355 #endif /* DMA2D_FGPFCCR_CSS */ 356 357 /* Configure the foreground color */ 358 LL_DMA2D_FGND_SetColor(DMA2Dx, DMA2D_LayerCfg->Red, DMA2D_LayerCfg->Green, DMA2D_LayerCfg->Blue); 359 360 /* Configure the foreground CLUT memory address */ 361 LL_DMA2D_FGND_SetCLUTMemAddr(DMA2Dx, DMA2D_LayerCfg->CLUTMemoryAddress); 362 } 363 } 364 365 /** 366 * @brief Set each @ref LL_DMA2D_LayerCfgTypeDef field to default value. 367 * @param DMA2D_LayerCfg pointer to a @ref LL_DMA2D_LayerCfgTypeDef structure 368 * whose fields will be set to default values. 369 * @retval None 370 */ LL_DMA2D_LayerCfgStructInit(LL_DMA2D_LayerCfgTypeDef * DMA2D_LayerCfg)371 void LL_DMA2D_LayerCfgStructInit(LL_DMA2D_LayerCfgTypeDef *DMA2D_LayerCfg) 372 { 373 /* Set DMA2D_LayerCfg fields to default values */ 374 DMA2D_LayerCfg->MemoryAddress = 0x0U; 375 DMA2D_LayerCfg->ColorMode = LL_DMA2D_INPUT_MODE_ARGB8888; 376 DMA2D_LayerCfg->LineOffset = 0x0U; 377 DMA2D_LayerCfg->CLUTColorMode = LL_DMA2D_CLUT_COLOR_MODE_ARGB8888; 378 DMA2D_LayerCfg->CLUTSize = 0x0U; 379 DMA2D_LayerCfg->AlphaMode = LL_DMA2D_ALPHA_MODE_NO_MODIF; 380 DMA2D_LayerCfg->Alpha = 0x0U; 381 DMA2D_LayerCfg->Blue = 0x0U; 382 DMA2D_LayerCfg->Green = 0x0U; 383 DMA2D_LayerCfg->Red = 0x0U; 384 DMA2D_LayerCfg->CLUTMemoryAddress = 0x0U; 385 DMA2D_LayerCfg->AlphaInversionMode = LL_DMA2D_ALPHA_REGULAR; 386 DMA2D_LayerCfg->RBSwapMode = LL_DMA2D_RB_MODE_REGULAR; 387 #if defined(DMA2D_FGPFCCR_CSS) 388 DMA2D_LayerCfg->ChromaSubSampling = LL_DMA2D_CSS_444; 389 #endif /* DMA2D_FGPFCCR_CSS */ 390 } 391 392 /** 393 * @brief Initialize DMA2D output color register according to the specified parameters 394 * in DMA2D_ColorStruct. 395 * @param DMA2Dx DMA2D Instance 396 * @param DMA2D_ColorStruct pointer to a LL_DMA2D_ColorTypeDef structure that contains 397 * the color configuration information for the specified DMA2D peripheral. 398 * @retval None 399 */ LL_DMA2D_ConfigOutputColor(DMA2D_TypeDef * DMA2Dx,LL_DMA2D_ColorTypeDef * DMA2D_ColorStruct)400 void LL_DMA2D_ConfigOutputColor(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_ColorTypeDef *DMA2D_ColorStruct) 401 { 402 uint32_t outgreen; 403 uint32_t outred; 404 uint32_t outalpha; 405 406 /* Check the parameters */ 407 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 408 assert_param(IS_LL_DMA2D_OCMODE(DMA2D_ColorStruct->ColorMode)); 409 assert_param(IS_LL_DMA2D_GREEN(DMA2D_ColorStruct->OutputGreen)); 410 assert_param(IS_LL_DMA2D_RED(DMA2D_ColorStruct->OutputRed)); 411 assert_param(IS_LL_DMA2D_BLUE(DMA2D_ColorStruct->OutputBlue)); 412 assert_param(IS_LL_DMA2D_ALPHA(DMA2D_ColorStruct->OutputAlpha)); 413 414 /* DMA2D OCOLR register configuration ------------------------------------------*/ 415 if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 416 { 417 outgreen = DMA2D_ColorStruct->OutputGreen << 8U; 418 outred = DMA2D_ColorStruct->OutputRed << 16U; 419 outalpha = DMA2D_ColorStruct->OutputAlpha << 24U; 420 } 421 else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 422 { 423 outgreen = DMA2D_ColorStruct->OutputGreen << 8U; 424 outred = DMA2D_ColorStruct->OutputRed << 16U; 425 outalpha = 0x00000000U; 426 } 427 else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 428 { 429 outgreen = DMA2D_ColorStruct->OutputGreen << 5U; 430 outred = DMA2D_ColorStruct->OutputRed << 11U; 431 outalpha = 0x00000000U; 432 } 433 else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 434 { 435 outgreen = DMA2D_ColorStruct->OutputGreen << 5U; 436 outred = DMA2D_ColorStruct->OutputRed << 10U; 437 outalpha = DMA2D_ColorStruct->OutputAlpha << 15U; 438 } 439 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 440 { 441 outgreen = DMA2D_ColorStruct->OutputGreen << 4U; 442 outred = DMA2D_ColorStruct->OutputRed << 8U; 443 outalpha = DMA2D_ColorStruct->OutputAlpha << 12U; 444 } 445 LL_DMA2D_SetOutputColor(DMA2Dx, (outgreen | outred | DMA2D_ColorStruct->OutputBlue | outalpha)); 446 } 447 448 /** 449 * @brief Return DMA2D output Blue color. 450 * @param DMA2Dx DMA2D Instance. 451 * @param ColorMode This parameter can be one of the following values: 452 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 453 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 454 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 455 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 456 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 457 * @retval Output Blue color value between Min_Data=0 and Max_Data=0xFF 458 */ LL_DMA2D_GetOutputBlueColor(const DMA2D_TypeDef * DMA2Dx,uint32_t ColorMode)459 uint32_t LL_DMA2D_GetOutputBlueColor(const DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 460 { 461 uint32_t color; 462 463 /* Check the parameters */ 464 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 465 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 466 467 /* DMA2D OCOLR register reading ------------------------------------------*/ 468 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 469 { 470 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFFU)); 471 } 472 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 473 { 474 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFFU)); 475 } 476 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 477 { 478 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x1FU)); 479 } 480 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 481 { 482 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x1FU)); 483 } 484 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 485 { 486 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFU)); 487 } 488 489 return color; 490 } 491 492 /** 493 * @brief Return DMA2D output Green color. 494 * @param DMA2Dx DMA2D Instance. 495 * @param ColorMode This parameter can be one of the following values: 496 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 497 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 498 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 499 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 500 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 501 * @retval Output Green color value between Min_Data=0 and Max_Data=0xFF 502 */ LL_DMA2D_GetOutputGreenColor(const DMA2D_TypeDef * DMA2Dx,uint32_t ColorMode)503 uint32_t LL_DMA2D_GetOutputGreenColor(const DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 504 { 505 uint32_t color; 506 507 /* Check the parameters */ 508 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 509 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 510 511 /* DMA2D OCOLR register reading ------------------------------------------*/ 512 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 513 { 514 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF00U) >> 8U); 515 } 516 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 517 { 518 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF00U) >> 8U); 519 } 520 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 521 { 522 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x7E0U) >> 5U); 523 } 524 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 525 { 526 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x3E0U) >> 5U); 527 } 528 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 529 { 530 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF0U) >> 4U); 531 } 532 533 return color; 534 } 535 536 /** 537 * @brief Return DMA2D output Red color. 538 * @param DMA2Dx DMA2D Instance. 539 * @param ColorMode This parameter can be one of the following values: 540 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 541 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 542 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 543 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 544 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 545 * @retval Output Red color value between Min_Data=0 and Max_Data=0xFF 546 */ LL_DMA2D_GetOutputRedColor(const DMA2D_TypeDef * DMA2Dx,uint32_t ColorMode)547 uint32_t LL_DMA2D_GetOutputRedColor(const DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 548 { 549 uint32_t color; 550 551 /* Check the parameters */ 552 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 553 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 554 555 /* DMA2D OCOLR register reading ------------------------------------------*/ 556 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 557 { 558 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF0000U) >> 16U); 559 } 560 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 561 { 562 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF0000U) >> 16U); 563 } 564 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 565 { 566 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF800U) >> 11U); 567 } 568 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 569 { 570 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x7C00U) >> 10U); 571 } 572 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 573 { 574 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF00U) >> 8U); 575 } 576 577 return color; 578 } 579 580 /** 581 * @brief Return DMA2D output Alpha color. 582 * @param DMA2Dx DMA2D Instance. 583 * @param ColorMode This parameter can be one of the following values: 584 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 585 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 586 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 587 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 588 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 589 * @retval Output Alpha color value between Min_Data=0 and Max_Data=0xFF 590 */ LL_DMA2D_GetOutputAlphaColor(const DMA2D_TypeDef * DMA2Dx,uint32_t ColorMode)591 uint32_t LL_DMA2D_GetOutputAlphaColor(const DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 592 { 593 uint32_t color; 594 595 /* Check the parameters */ 596 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 597 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 598 599 /* DMA2D OCOLR register reading ------------------------------------------*/ 600 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 601 { 602 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF000000U) >> 24U); 603 } 604 else if ((ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) || (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565)) 605 { 606 color = 0x0U; 607 } 608 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 609 { 610 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x8000U) >> 15U); 611 } 612 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 613 { 614 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF000U) >> 12U); 615 } 616 617 return color; 618 } 619 620 /** 621 * @brief Configure DMA2D transfer size. 622 * @param DMA2Dx DMA2D Instance 623 * @param NbrOfLines Value between Min_Data=0 and Max_Data=0xFFFF 624 * @param NbrOfPixelsPerLines Value between Min_Data=0 and Max_Data=0x3FFF 625 * @retval None 626 */ LL_DMA2D_ConfigSize(DMA2D_TypeDef * DMA2Dx,uint32_t NbrOfLines,uint32_t NbrOfPixelsPerLines)627 void LL_DMA2D_ConfigSize(DMA2D_TypeDef *DMA2Dx, uint32_t NbrOfLines, uint32_t NbrOfPixelsPerLines) 628 { 629 MODIFY_REG(DMA2Dx->NLR, (DMA2D_NLR_PL | DMA2D_NLR_NL), \ 630 ((NbrOfPixelsPerLines << DMA2D_NLR_PL_Pos) | NbrOfLines)); 631 } 632 633 /** 634 * @} 635 */ 636 637 /** 638 * @} 639 */ 640 641 /** 642 * @} 643 */ 644 645 #endif /* defined (DMA2D) */ 646 647 /** 648 * @} 649 */ 650 651 #endif /* USE_FULL_LL_DRIVER */ 652