STM32L486xx HAL User Manual
|
00001 /** 00002 ****************************************************************************** 00003 * @file stm32l4xx_ll_dma2d.c 00004 * @author MCD Application Team 00005 * @brief DMA2D LL module driver. 00006 ****************************************************************************** 00007 * @attention 00008 * 00009 * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2> 00010 * 00011 * Redistribution and use in source and binary forms, with or without modification, 00012 * are permitted provided that the following conditions are met: 00013 * 1. Redistributions of source code must retain the above copyright notice, 00014 * this list of conditions and the following disclaimer. 00015 * 2. Redistributions in binary form must reproduce the above copyright notice, 00016 * this list of conditions and the following disclaimer in the documentation 00017 * and/or other materials provided with the distribution. 00018 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00019 * may be used to endorse or promote products derived from this software 00020 * without specific prior written permission. 00021 * 00022 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00023 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00024 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00025 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00026 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00027 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00028 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00029 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00030 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00031 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00032 * 00033 ****************************************************************************** 00034 */ 00035 #if defined(USE_FULL_LL_DRIVER) 00036 00037 /* Includes ------------------------------------------------------------------*/ 00038 #include "stm32l4xx_ll_dma2d.h" 00039 #include "stm32l4xx_ll_bus.h" 00040 #ifdef USE_FULL_ASSERT 00041 #include "stm32_assert.h" 00042 #else 00043 #define assert_param(expr) ((void)0U) 00044 #endif 00045 00046 /** @addtogroup STM32L4xx_LL_Driver 00047 * @{ 00048 */ 00049 00050 #if defined (DMA2D) 00051 00052 /** @addtogroup DMA2D_LL 00053 * @{ 00054 */ 00055 00056 /* Private types -------------------------------------------------------------*/ 00057 /* Private variables ---------------------------------------------------------*/ 00058 /* Private constants ---------------------------------------------------------*/ 00059 /** @addtogroup DMA2D_LL_Private_Constants DMA2D Private Constants 00060 * @{ 00061 */ 00062 #define LL_DMA2D_COLOR 0xFFU /*!< Maximum output color setting */ 00063 #define LL_DMA2D_NUMBEROFLINES DMA2D_NLR_NL /*!< Maximum number of lines */ 00064 #define LL_DMA2D_NUMBEROFPIXELS (DMA2D_NLR_PL >> DMA2D_NLR_PL_Pos) /*!< Maximum number of pixels per lines */ 00065 #define LL_DMA2D_OFFSET_MAX 0x3FFFU /*!< Maximum output line offset expressed in pixels */ 00066 #define LL_DMA2D_CLUTSIZE_MAX 0xFFU /*!< Maximum CLUT size */ 00067 /** 00068 * @} 00069 */ 00070 /* Private macros ------------------------------------------------------------*/ 00071 /** @addtogroup DMA2D_LL_Private_Macros 00072 * @{ 00073 */ 00074 #if defined(DMA2D_M2M_BLEND_FIXED_COLOR_FG_BG_SUPPORT) 00075 #define IS_LL_DMA2D_MODE(MODE) (((MODE) == LL_DMA2D_MODE_M2M) || \ 00076 ((MODE) == LL_DMA2D_MODE_M2M_PFC) || \ 00077 ((MODE) == LL_DMA2D_MODE_M2M_BLEND) || \ 00078 ((MODE) == LL_DMA2D_MODE_M2M_BLEND_FIXED_COLOR_FG) || \ 00079 ((MODE) == LL_DMA2D_MODE_M2M_BLEND_FIXED_COLOR_BG) || \ 00080 ((MODE) == LL_DMA2D_MODE_R2M)) 00081 #else 00082 #define IS_LL_DMA2D_MODE(MODE) (((MODE) == LL_DMA2D_MODE_M2M) || \ 00083 ((MODE) == LL_DMA2D_MODE_M2M_PFC) || \ 00084 ((MODE) == LL_DMA2D_MODE_M2M_BLEND) || \ 00085 ((MODE) == LL_DMA2D_MODE_R2M)) 00086 #endif /*DMA2D_M2M_BLEND_FIXED_COLOR_FG_BG_SUPPORT*/ 00087 00088 #define IS_LL_DMA2D_OCMODE(MODE_ARGB) (((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB8888) || \ 00089 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_RGB888) || \ 00090 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_RGB565) || \ 00091 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB1555) || \ 00092 ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB4444)) 00093 00094 #define IS_LL_DMA2D_GREEN(GREEN) ((GREEN) <= LL_DMA2D_COLOR) 00095 #define IS_LL_DMA2D_RED(RED) ((RED) <= LL_DMA2D_COLOR) 00096 #define IS_LL_DMA2D_BLUE(BLUE) ((BLUE) <= LL_DMA2D_COLOR) 00097 #define IS_LL_DMA2D_ALPHA(ALPHA) ((ALPHA) <= LL_DMA2D_COLOR) 00098 00099 #if defined(DMA2D_LINE_OFFSET_MODE_SUPPORT) 00100 #define IS_LL_DMA2D_OFFSET_MODE(MODE) (((MODE) == LL_DMA2D_LINE_OFFSET_PIXELS) || \ 00101 ((MODE) == LL_DMA2D_LINE_OFFSET_BYTES)) 00102 #endif /* DMA2D_LINE_OFFSET_MODE_SUPPORT */ 00103 00104 #define IS_LL_DMA2D_OFFSET(OFFSET) ((OFFSET) <= LL_DMA2D_OFFSET_MAX) 00105 00106 #define IS_LL_DMA2D_LINE(LINES) ((LINES) <= LL_DMA2D_NUMBEROFLINES) 00107 #define IS_LL_DMA2D_PIXEL(PIXELS) ((PIXELS) <= LL_DMA2D_NUMBEROFPIXELS) 00108 00109 #if defined(DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT) 00110 #define IS_LL_DMA2D_SWAP_MODE(MODE) (((MODE) == LL_DMA2D_SWAP_MODE_REGULAR) || \ 00111 ((MODE) == LL_DMA2D_SWAP_MODE_TWO_BY_TWO)) 00112 #endif /* DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT */ 00113 00114 #define IS_LL_DMA2D_ALPHAINV(ALPHA) (((ALPHA) == LL_DMA2D_ALPHA_REGULAR) || \ 00115 ((ALPHA) == LL_DMA2D_ALPHA_INVERTED)) 00116 00117 #define IS_LL_DMA2D_RBSWAP(RBSWAP) (((RBSWAP) == LL_DMA2D_RB_MODE_REGULAR) || \ 00118 ((RBSWAP) == LL_DMA2D_RB_MODE_SWAP)) 00119 00120 #define IS_LL_DMA2D_LCMODE(MODE_ARGB) (((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB8888) || \ 00121 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_RGB888) || \ 00122 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_RGB565) || \ 00123 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB1555) || \ 00124 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB4444) || \ 00125 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_L8) || \ 00126 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_AL44) || \ 00127 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_AL88) || \ 00128 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_L4) || \ 00129 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_A8) || \ 00130 ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_A4)) 00131 00132 #define IS_LL_DMA2D_CLUTCMODE(CLUTCMODE) (((CLUTCMODE) == LL_DMA2D_CLUT_COLOR_MODE_ARGB8888) || \ 00133 ((CLUTCMODE) == LL_DMA2D_CLUT_COLOR_MODE_RGB888)) 00134 00135 #define IS_LL_DMA2D_CLUTSIZE(SIZE) ((SIZE) <= LL_DMA2D_CLUTSIZE_MAX) 00136 00137 #define IS_LL_DMA2D_ALPHAMODE(MODE) (((MODE) == LL_DMA2D_ALPHA_MODE_NO_MODIF) || \ 00138 ((MODE) == LL_DMA2D_ALPHA_MODE_REPLACE) || \ 00139 ((MODE) == LL_DMA2D_ALPHA_MODE_COMBINE)) 00140 00141 00142 /** 00143 * @} 00144 */ 00145 00146 /* Private function prototypes -----------------------------------------------*/ 00147 00148 /* Exported functions --------------------------------------------------------*/ 00149 /** @addtogroup DMA2D_LL_Exported_Functions 00150 * @{ 00151 */ 00152 00153 /** @addtogroup DMA2D_LL_EF_Init_Functions Initialization and De-initialization Functions 00154 * @{ 00155 */ 00156 00157 /** 00158 * @brief De-initialize DMA2D registers (registers restored to their default values). 00159 * @param DMA2Dx DMA2D Instance 00160 * @retval An ErrorStatus enumeration value: 00161 * - SUCCESS: DMA2D registers are de-initialized 00162 * - ERROR: DMA2D registers are not de-initialized 00163 */ 00164 ErrorStatus LL_DMA2D_DeInit(DMA2D_TypeDef *DMA2Dx) 00165 { 00166 ErrorStatus status = SUCCESS; 00167 00168 /* Check the parameters */ 00169 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 00170 00171 if (DMA2Dx == DMA2D) 00172 { 00173 /* Force reset of DMA2D clock */ 00174 LL_AHB1_GRP1_ForceReset(LL_AHB1_GRP1_PERIPH_DMA2D); 00175 00176 /* Release reset of DMA2D clock */ 00177 LL_AHB1_GRP1_ReleaseReset(LL_AHB1_GRP1_PERIPH_DMA2D); 00178 } 00179 else 00180 { 00181 status = ERROR; 00182 } 00183 00184 return (status); 00185 } 00186 00187 /** 00188 * @brief Initialize DMA2D registers according to the specified parameters in DMA2D_InitStruct. 00189 * @note DMA2D transfers must be disabled to set initialization bits in configuration registers, 00190 * otherwise ERROR result is returned. 00191 * @param DMA2Dx DMA2D Instance 00192 * @param DMA2D_InitStruct pointer to a LL_DMA2D_InitTypeDef structure 00193 * that contains the configuration information for the specified DMA2D peripheral. 00194 * @retval An ErrorStatus enumeration value: 00195 * - SUCCESS: DMA2D registers are initialized according to DMA2D_InitStruct content 00196 * - ERROR: Issue occurred during DMA2D registers initialization 00197 */ 00198 ErrorStatus LL_DMA2D_Init(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_InitTypeDef *DMA2D_InitStruct) 00199 { 00200 ErrorStatus status = ERROR; 00201 LL_DMA2D_ColorTypeDef DMA2D_ColorStruct; 00202 uint32_t tmp, tmp1, tmp2; 00203 uint32_t regMask, regValue; 00204 00205 /* Check the parameters */ 00206 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 00207 assert_param(IS_LL_DMA2D_MODE(DMA2D_InitStruct->Mode)); 00208 assert_param(IS_LL_DMA2D_OCMODE(DMA2D_InitStruct->ColorMode)); 00209 assert_param(IS_LL_DMA2D_LINE(DMA2D_InitStruct->NbrOfLines)); 00210 assert_param(IS_LL_DMA2D_PIXEL(DMA2D_InitStruct->NbrOfPixelsPerLines)); 00211 assert_param(IS_LL_DMA2D_GREEN(DMA2D_InitStruct->OutputGreen)); 00212 assert_param(IS_LL_DMA2D_RED(DMA2D_InitStruct->OutputRed)); 00213 assert_param(IS_LL_DMA2D_BLUE(DMA2D_InitStruct->OutputBlue)); 00214 assert_param(IS_LL_DMA2D_ALPHA(DMA2D_InitStruct->OutputAlpha)); 00215 #if defined(DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT) 00216 assert_param(IS_LL_DMA2D_SWAP_MODE(DMA2D_InitStruct->OutputSwapMode)); 00217 #endif /* DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT */ 00218 #if defined(DMA2D_LINE_OFFSET_MODE_SUPPORT) 00219 assert_param(IS_LL_DMA2D_OFFSET_MODE(DMA2D_InitStruct->LineOffsetMode)); 00220 #endif /* DMA2D_LINE_OFFSET_MODE_SUPPORT */ 00221 assert_param(IS_LL_DMA2D_OFFSET(DMA2D_InitStruct->LineOffset)); 00222 assert_param(IS_LL_DMA2D_ALPHAINV(DMA2D_InitStruct->AlphaInversionMode)); 00223 assert_param(IS_LL_DMA2D_RBSWAP(DMA2D_InitStruct->RBSwapMode)); 00224 00225 /* DMA2D transfers must be disabled to configure bits in initialization registers */ 00226 tmp = LL_DMA2D_IsTransferOngoing(DMA2Dx); 00227 tmp1 = LL_DMA2D_FGND_IsEnabledCLUTLoad(DMA2Dx); 00228 tmp2 = LL_DMA2D_BGND_IsEnabledCLUTLoad(DMA2Dx); 00229 if ((tmp == 0U) && (tmp1 == 0U) && (tmp2 == 0U)) 00230 { 00231 /* DMA2D CR register configuration -------------------------------------------*/ 00232 #if defined(DMA2D_LINE_OFFSET_MODE_SUPPORT) 00233 MODIFY_REG(DMA2Dx->CR, (DMA2D_CR_MODE | DMA2D_CR_LOM), \ 00234 (DMA2D_InitStruct->Mode | DMA2D_InitStruct->LineOffsetMode)); 00235 #else 00236 LL_DMA2D_SetMode(DMA2Dx, DMA2D_InitStruct->Mode); 00237 #endif /* DMA2D_LINE_OFFSET_MODE_SUPPORT */ 00238 00239 /* DMA2D OPFCCR register configuration ---------------------------------------*/ 00240 regMask = DMA2D_OPFCCR_CM; 00241 regValue = DMA2D_InitStruct->ColorMode; 00242 00243 #if defined(DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT) 00244 regMask |= DMA2D_OPFCCR_SB; 00245 regValue |= DMA2D_InitStruct->OutputSwapMode; 00246 #endif /* DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT */ 00247 00248 regMask |= (DMA2D_OPFCCR_RBS | DMA2D_OPFCCR_AI); 00249 regValue |= (DMA2D_InitStruct->AlphaInversionMode | DMA2D_InitStruct->RBSwapMode); 00250 00251 00252 MODIFY_REG(DMA2Dx->OPFCCR, regMask, regValue); 00253 00254 /* DMA2D OOR register configuration ------------------------------------------*/ 00255 LL_DMA2D_SetLineOffset(DMA2Dx, DMA2D_InitStruct->LineOffset); 00256 00257 /* DMA2D NLR register configuration ------------------------------------------*/ 00258 LL_DMA2D_ConfigSize(DMA2Dx, DMA2D_InitStruct->NbrOfLines, DMA2D_InitStruct->NbrOfPixelsPerLines); 00259 00260 /* DMA2D OMAR register configuration ------------------------------------------*/ 00261 LL_DMA2D_SetOutputMemAddr(DMA2Dx, DMA2D_InitStruct->OutputMemoryAddress); 00262 00263 /* DMA2D OCOLR register configuration ------------------------------------------*/ 00264 DMA2D_ColorStruct.ColorMode = DMA2D_InitStruct->ColorMode; 00265 DMA2D_ColorStruct.OutputBlue = DMA2D_InitStruct->OutputBlue; 00266 DMA2D_ColorStruct.OutputGreen = DMA2D_InitStruct->OutputGreen; 00267 DMA2D_ColorStruct.OutputRed = DMA2D_InitStruct->OutputRed; 00268 DMA2D_ColorStruct.OutputAlpha = DMA2D_InitStruct->OutputAlpha; 00269 LL_DMA2D_ConfigOutputColor(DMA2Dx, &DMA2D_ColorStruct); 00270 00271 status = SUCCESS; 00272 } 00273 /* If DMA2D transfers are not disabled, return ERROR */ 00274 00275 return (status); 00276 } 00277 00278 /** 00279 * @brief Set each @ref LL_DMA2D_InitTypeDef field to default value. 00280 * @param DMA2D_InitStruct pointer to a @ref LL_DMA2D_InitTypeDef structure 00281 * whose fields will be set to default values. 00282 * @retval None 00283 */ 00284 void LL_DMA2D_StructInit(LL_DMA2D_InitTypeDef *DMA2D_InitStruct) 00285 { 00286 /* Set DMA2D_InitStruct fields to default values */ 00287 DMA2D_InitStruct->Mode = LL_DMA2D_MODE_M2M; 00288 DMA2D_InitStruct->ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB8888; 00289 DMA2D_InitStruct->NbrOfLines = 0x0U; 00290 DMA2D_InitStruct->NbrOfPixelsPerLines = 0x0U; 00291 #if defined(DMA2D_LINE_OFFSET_MODE_SUPPORT) 00292 DMA2D_InitStruct->LineOffsetMode = LL_DMA2D_LINE_OFFSET_PIXELS; 00293 #endif /* DMA2D_LINE_OFFSET_MODE_SUPPORT */ 00294 DMA2D_InitStruct->LineOffset = 0x0U; 00295 DMA2D_InitStruct->OutputBlue = 0x0U; 00296 DMA2D_InitStruct->OutputGreen = 0x0U; 00297 DMA2D_InitStruct->OutputRed = 0x0U; 00298 DMA2D_InitStruct->OutputAlpha = 0x0U; 00299 DMA2D_InitStruct->OutputMemoryAddress = 0x0U; 00300 #if defined(DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT) 00301 DMA2D_InitStruct->OutputSwapMode = LL_DMA2D_SWAP_MODE_REGULAR; 00302 #endif /* DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT */ 00303 DMA2D_InitStruct->AlphaInversionMode = LL_DMA2D_ALPHA_REGULAR; 00304 DMA2D_InitStruct->RBSwapMode = LL_DMA2D_RB_MODE_REGULAR; 00305 } 00306 00307 /** 00308 * @brief Configure the foreground or background according to the specified parameters 00309 * in the LL_DMA2D_LayerCfgTypeDef structure. 00310 * @param DMA2Dx DMA2D Instance 00311 * @param DMA2D_LayerCfg pointer to a LL_DMA2D_LayerCfgTypeDef structure that contains 00312 * the configuration information for the specified layer. 00313 * @param LayerIdx DMA2D Layer index. 00314 * This parameter can be one of the following values: 00315 * 0(background) / 1(foreground) 00316 * @retval None 00317 */ 00318 void LL_DMA2D_ConfigLayer(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_LayerCfgTypeDef *DMA2D_LayerCfg, uint32_t LayerIdx) 00319 { 00320 /* Check the parameters */ 00321 assert_param(IS_LL_DMA2D_OFFSET(DMA2D_LayerCfg->LineOffset)); 00322 assert_param(IS_LL_DMA2D_LCMODE(DMA2D_LayerCfg->ColorMode)); 00323 assert_param(IS_LL_DMA2D_CLUTCMODE(DMA2D_LayerCfg->CLUTColorMode)); 00324 assert_param(IS_LL_DMA2D_CLUTSIZE(DMA2D_LayerCfg->CLUTSize)); 00325 assert_param(IS_LL_DMA2D_ALPHAMODE(DMA2D_LayerCfg->AlphaMode)); 00326 assert_param(IS_LL_DMA2D_GREEN(DMA2D_LayerCfg->Green)); 00327 assert_param(IS_LL_DMA2D_RED(DMA2D_LayerCfg->Red)); 00328 assert_param(IS_LL_DMA2D_BLUE(DMA2D_LayerCfg->Blue)); 00329 assert_param(IS_LL_DMA2D_ALPHA(DMA2D_LayerCfg->Alpha)); 00330 assert_param(IS_LL_DMA2D_ALPHAINV(DMA2D_LayerCfg->AlphaInversionMode)); 00331 assert_param(IS_LL_DMA2D_RBSWAP(DMA2D_LayerCfg->RBSwapMode)); 00332 00333 00334 if (LayerIdx == 0U) 00335 { 00336 /* Configure the background memory address */ 00337 LL_DMA2D_BGND_SetMemAddr(DMA2Dx, DMA2D_LayerCfg->MemoryAddress); 00338 00339 /* Configure the background line offset */ 00340 LL_DMA2D_BGND_SetLineOffset(DMA2Dx, DMA2D_LayerCfg->LineOffset); 00341 00342 /* Configure the background Alpha value, Alpha mode, RB swap, Alpha inversion 00343 CLUT size, CLUT Color mode and Color mode */ 00344 MODIFY_REG(DMA2Dx->BGPFCCR, \ 00345 (DMA2D_BGPFCCR_ALPHA | DMA2D_BGPFCCR_RBS | DMA2D_BGPFCCR_AI | DMA2D_BGPFCCR_AM | \ 00346 DMA2D_BGPFCCR_CS | DMA2D_BGPFCCR_CCM | DMA2D_BGPFCCR_CM), \ 00347 ((DMA2D_LayerCfg->Alpha << DMA2D_BGPFCCR_ALPHA_Pos) | DMA2D_LayerCfg->RBSwapMode | \ 00348 DMA2D_LayerCfg->AlphaInversionMode | DMA2D_LayerCfg->AlphaMode | \ 00349 (DMA2D_LayerCfg->CLUTSize << DMA2D_BGPFCCR_CS_Pos) | DMA2D_LayerCfg->CLUTColorMode | \ 00350 DMA2D_LayerCfg->ColorMode)); 00351 00352 /* Configure the background color */ 00353 LL_DMA2D_BGND_SetColor(DMA2Dx, DMA2D_LayerCfg->Red, DMA2D_LayerCfg->Green, DMA2D_LayerCfg->Blue); 00354 00355 /* Configure the background CLUT memory address */ 00356 LL_DMA2D_BGND_SetCLUTMemAddr(DMA2Dx, DMA2D_LayerCfg->CLUTMemoryAddress); 00357 } 00358 else 00359 { 00360 /* Configure the foreground memory address */ 00361 LL_DMA2D_FGND_SetMemAddr(DMA2Dx, DMA2D_LayerCfg->MemoryAddress); 00362 00363 /* Configure the foreground line offset */ 00364 LL_DMA2D_FGND_SetLineOffset(DMA2Dx, DMA2D_LayerCfg->LineOffset); 00365 00366 /* Configure the foreground Alpha value, Alpha mode, RB swap, Alpha inversion 00367 CLUT size, CLUT Color mode and Color mode */ 00368 MODIFY_REG(DMA2Dx->FGPFCCR, \ 00369 (DMA2D_FGPFCCR_ALPHA | DMA2D_FGPFCCR_RBS | DMA2D_FGPFCCR_AI | DMA2D_FGPFCCR_AM | \ 00370 DMA2D_FGPFCCR_CS | DMA2D_FGPFCCR_CCM | DMA2D_FGPFCCR_CM), \ 00371 ((DMA2D_LayerCfg->Alpha << DMA2D_FGPFCCR_ALPHA_Pos) | DMA2D_LayerCfg->RBSwapMode | \ 00372 DMA2D_LayerCfg->AlphaInversionMode | DMA2D_LayerCfg->AlphaMode | \ 00373 (DMA2D_LayerCfg->CLUTSize << DMA2D_FGPFCCR_CS_Pos) | DMA2D_LayerCfg->CLUTColorMode | \ 00374 DMA2D_LayerCfg->ColorMode)); 00375 00376 /* Configure the foreground color */ 00377 LL_DMA2D_FGND_SetColor(DMA2Dx, DMA2D_LayerCfg->Red, DMA2D_LayerCfg->Green, DMA2D_LayerCfg->Blue); 00378 00379 /* Configure the foreground CLUT memory address */ 00380 LL_DMA2D_FGND_SetCLUTMemAddr(DMA2Dx, DMA2D_LayerCfg->CLUTMemoryAddress); 00381 } 00382 } 00383 00384 /** 00385 * @brief Set each @ref LL_DMA2D_LayerCfgTypeDef field to default value. 00386 * @param DMA2D_LayerCfg pointer to a @ref LL_DMA2D_LayerCfgTypeDef structure 00387 * whose fields will be set to default values. 00388 * @retval None 00389 */ 00390 void LL_DMA2D_LayerCfgStructInit(LL_DMA2D_LayerCfgTypeDef *DMA2D_LayerCfg) 00391 { 00392 /* Set DMA2D_LayerCfg fields to default values */ 00393 DMA2D_LayerCfg->MemoryAddress = 0x0U; 00394 DMA2D_LayerCfg->ColorMode = LL_DMA2D_INPUT_MODE_ARGB8888; 00395 DMA2D_LayerCfg->LineOffset = 0x0U; 00396 DMA2D_LayerCfg->CLUTColorMode = LL_DMA2D_CLUT_COLOR_MODE_ARGB8888; 00397 DMA2D_LayerCfg->CLUTSize = 0x0U; 00398 DMA2D_LayerCfg->AlphaMode = LL_DMA2D_ALPHA_MODE_NO_MODIF; 00399 DMA2D_LayerCfg->Alpha = 0x0U; 00400 DMA2D_LayerCfg->Blue = 0x0U; 00401 DMA2D_LayerCfg->Green = 0x0U; 00402 DMA2D_LayerCfg->Red = 0x0U; 00403 DMA2D_LayerCfg->CLUTMemoryAddress = 0x0U; 00404 DMA2D_LayerCfg->AlphaInversionMode = LL_DMA2D_ALPHA_REGULAR; 00405 DMA2D_LayerCfg->RBSwapMode = LL_DMA2D_RB_MODE_REGULAR; 00406 } 00407 00408 /** 00409 * @brief Initialize DMA2D output color register according to the specified parameters 00410 * in DMA2D_ColorStruct. 00411 * @param DMA2Dx DMA2D Instance 00412 * @param DMA2D_ColorStruct pointer to a LL_DMA2D_ColorTypeDef structure that contains 00413 * the color configuration information for the specified DMA2D peripheral. 00414 * @retval None 00415 */ 00416 void LL_DMA2D_ConfigOutputColor(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_ColorTypeDef *DMA2D_ColorStruct) 00417 { 00418 uint32_t outgreen; 00419 uint32_t outred; 00420 uint32_t outalpha; 00421 00422 /* Check the parameters */ 00423 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 00424 assert_param(IS_LL_DMA2D_OCMODE(DMA2D_ColorStruct->ColorMode)); 00425 assert_param(IS_LL_DMA2D_GREEN(DMA2D_ColorStruct->OutputGreen)); 00426 assert_param(IS_LL_DMA2D_RED(DMA2D_ColorStruct->OutputRed)); 00427 assert_param(IS_LL_DMA2D_BLUE(DMA2D_ColorStruct->OutputBlue)); 00428 assert_param(IS_LL_DMA2D_ALPHA(DMA2D_ColorStruct->OutputAlpha)); 00429 00430 /* DMA2D OCOLR register configuration ------------------------------------------*/ 00431 if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 00432 { 00433 outgreen = DMA2D_ColorStruct->OutputGreen << 8U; 00434 outred = DMA2D_ColorStruct->OutputRed << 16U; 00435 outalpha = DMA2D_ColorStruct->OutputAlpha << 24U; 00436 } 00437 else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 00438 { 00439 outgreen = DMA2D_ColorStruct->OutputGreen << 8U; 00440 outred = DMA2D_ColorStruct->OutputRed << 16U; 00441 outalpha = 0x00000000U; 00442 } 00443 else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 00444 { 00445 outgreen = DMA2D_ColorStruct->OutputGreen << 5U; 00446 outred = DMA2D_ColorStruct->OutputRed << 11U; 00447 outalpha = 0x00000000U; 00448 } 00449 else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 00450 { 00451 outgreen = DMA2D_ColorStruct->OutputGreen << 5U; 00452 outred = DMA2D_ColorStruct->OutputRed << 10U; 00453 outalpha = DMA2D_ColorStruct->OutputAlpha << 15U; 00454 } 00455 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 00456 { 00457 outgreen = DMA2D_ColorStruct->OutputGreen << 4U; 00458 outred = DMA2D_ColorStruct->OutputRed << 8U; 00459 outalpha = DMA2D_ColorStruct->OutputAlpha << 12U; 00460 } 00461 LL_DMA2D_SetOutputColor(DMA2Dx, (outgreen | outred | DMA2D_ColorStruct->OutputBlue | outalpha)); 00462 } 00463 00464 /** 00465 * @brief Return DMA2D output Blue color. 00466 * @param DMA2Dx DMA2D Instance. 00467 * @param ColorMode This parameter can be one of the following values: 00468 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 00469 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 00470 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 00471 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 00472 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 00473 * @retval Output Blue color value between Min_Data=0 and Max_Data=0xFF 00474 */ 00475 uint32_t LL_DMA2D_GetOutputBlueColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 00476 { 00477 uint32_t color; 00478 00479 /* Check the parameters */ 00480 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 00481 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 00482 00483 /* DMA2D OCOLR register reading ------------------------------------------*/ 00484 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 00485 { 00486 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFFU)); 00487 } 00488 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 00489 { 00490 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFFU)); 00491 } 00492 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 00493 { 00494 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x1FU)); 00495 } 00496 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 00497 { 00498 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x1FU)); 00499 } 00500 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 00501 { 00502 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFU)); 00503 } 00504 00505 return color; 00506 } 00507 00508 /** 00509 * @brief Return DMA2D output Green color. 00510 * @param DMA2Dx DMA2D Instance. 00511 * @param ColorMode This parameter can be one of the following values: 00512 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 00513 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 00514 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 00515 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 00516 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 00517 * @retval Output Green color value between Min_Data=0 and Max_Data=0xFF 00518 */ 00519 uint32_t LL_DMA2D_GetOutputGreenColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 00520 { 00521 uint32_t color; 00522 00523 /* Check the parameters */ 00524 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 00525 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 00526 00527 /* DMA2D OCOLR register reading ------------------------------------------*/ 00528 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 00529 { 00530 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF00U) >> 8U); 00531 } 00532 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 00533 { 00534 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF00U) >> 8U); 00535 } 00536 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 00537 { 00538 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x7E0U) >> 5U); 00539 } 00540 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 00541 { 00542 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x3E0U) >> 5U); 00543 } 00544 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 00545 { 00546 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF0U) >> 4U); 00547 } 00548 00549 return color; 00550 } 00551 00552 /** 00553 * @brief Return DMA2D output Red color. 00554 * @param DMA2Dx DMA2D Instance. 00555 * @param ColorMode This parameter can be one of the following values: 00556 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 00557 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 00558 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 00559 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 00560 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 00561 * @retval Output Red color value between Min_Data=0 and Max_Data=0xFF 00562 */ 00563 uint32_t LL_DMA2D_GetOutputRedColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 00564 { 00565 uint32_t color; 00566 00567 /* Check the parameters */ 00568 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 00569 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 00570 00571 /* DMA2D OCOLR register reading ------------------------------------------*/ 00572 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 00573 { 00574 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF0000U) >> 16U); 00575 } 00576 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) 00577 { 00578 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF0000U) >> 16U); 00579 } 00580 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565) 00581 { 00582 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF800U) >> 11U); 00583 } 00584 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 00585 { 00586 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x7C00U) >> 10U); 00587 } 00588 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 00589 { 00590 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF00U) >> 8U); 00591 } 00592 00593 return color; 00594 } 00595 00596 /** 00597 * @brief Return DMA2D output Alpha color. 00598 * @param DMA2Dx DMA2D Instance. 00599 * @param ColorMode This parameter can be one of the following values: 00600 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888 00601 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888 00602 * @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565 00603 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555 00604 * @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444 00605 * @retval Output Alpha color value between Min_Data=0 and Max_Data=0xFF 00606 */ 00607 uint32_t LL_DMA2D_GetOutputAlphaColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode) 00608 { 00609 uint32_t color; 00610 00611 /* Check the parameters */ 00612 assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); 00613 assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); 00614 00615 /* DMA2D OCOLR register reading ------------------------------------------*/ 00616 if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888) 00617 { 00618 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF000000U) >> 24U); 00619 } 00620 else if ((ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) || (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565)) 00621 { 00622 color = 0x0U; 00623 } 00624 else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555) 00625 { 00626 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x8000U) >> 15U); 00627 } 00628 else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */ 00629 { 00630 color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF000U) >> 12U); 00631 } 00632 00633 return color; 00634 } 00635 00636 /** 00637 * @brief Configure DMA2D transfer size. 00638 * @param DMA2Dx DMA2D Instance 00639 * @param NbrOfLines Value between Min_Data=0 and Max_Data=0xFFFF 00640 * @param NbrOfPixelsPerLines Value between Min_Data=0 and Max_Data=0x3FFF 00641 * @retval None 00642 */ 00643 void LL_DMA2D_ConfigSize(DMA2D_TypeDef *DMA2Dx, uint32_t NbrOfLines, uint32_t NbrOfPixelsPerLines) 00644 { 00645 MODIFY_REG(DMA2Dx->NLR, (DMA2D_NLR_PL | DMA2D_NLR_NL), \ 00646 ((NbrOfPixelsPerLines << DMA2D_NLR_PL_Pos) | NbrOfLines)); 00647 } 00648 00649 /** 00650 * @} 00651 */ 00652 00653 /** 00654 * @} 00655 */ 00656 00657 /** 00658 * @} 00659 */ 00660 00661 #endif /* defined (DMA2D) */ 00662 00663 /** 00664 * @} 00665 */ 00666 00667 #endif /* USE_FULL_LL_DRIVER */ 00668 00669 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ 00670