Back to home page

LXR
 
 

    

File indexing completed on 2025-05-11 08:23:09 

0001 /**
0002   ******************************************************************************
0003   * @file    stm32h7xx_ll_dma2d.c
0004   * @author  MCD Application Team
0005   * @brief   DMA2D LL module driver.
0006   ******************************************************************************
0007   * @attention
0008   *
0009   * Copyright (c) 2017 STMicroelectronics.
0010   * All rights reserved.
0011   *
0012   * This software is licensed under terms that can be found in the LICENSE file
0013   * in the root directory of this software component.
0014   * If no LICENSE file comes with this software, it is provided AS-IS.
0015   *
0016   ******************************************************************************
0017   */
0018 #if defined(USE_FULL_LL_DRIVER) || defined(__rtems__)
0019 
0020 /* Includes ------------------------------------------------------------------*/
0021 #include "stm32h7xx_ll_dma2d.h"
0022 #include "stm32h7xx_ll_bus.h"
0023 #ifdef  USE_FULL_ASSERT
0024 #include "stm32_assert.h"
0025 #else
0026 #define assert_param(expr) ((void)0U)
0027 #endif  /* USE_FULL_ASSERT */
0028 
0029 /** @addtogroup STM32H7xx_LL_Driver
0030   * @{
0031   */
0032 
0033 #if defined (DMA2D)
0034 
0035 /** @addtogroup DMA2D_LL
0036   * @{
0037   */
0038 
0039 /* Private types -------------------------------------------------------------*/
0040 /* Private variables ---------------------------------------------------------*/
0041 /* Private constants ---------------------------------------------------------*/
0042 /** @addtogroup DMA2D_LL_Private_Constants DMA2D Private Constants
0043   * @{
0044   */
0045 #define LL_DMA2D_COLOR            0xFFU                                      /*!< Maximum output color setting                   */
0046 #define LL_DMA2D_NUMBEROFLINES    DMA2D_NLR_NL                               /*!< Maximum number of lines                        */
0047 #define LL_DMA2D_NUMBEROFPIXELS   (DMA2D_NLR_PL >> DMA2D_NLR_PL_Pos)         /*!< Maximum number of pixels per lines             */
0048 #define LL_DMA2D_OFFSET_MAX       0x3FFFU                                    /*!< Maximum output line offset expressed in pixels */
0049 #define LL_DMA2D_CLUTSIZE_MAX     0xFFU                                      /*!< Maximum CLUT size                              */
0050 /**
0051   * @}
0052   */
0053 /* Private macros ------------------------------------------------------------*/
0054 /** @addtogroup DMA2D_LL_Private_Macros
0055   * @{
0056   */
0057 #define IS_LL_DMA2D_MODE(MODE)          (((MODE) == LL_DMA2D_MODE_M2M)                      || \
0058                                          ((MODE) == LL_DMA2D_MODE_M2M_PFC)                  || \
0059                                          ((MODE) == LL_DMA2D_MODE_M2M_BLEND)                || \
0060                                          ((MODE) == LL_DMA2D_MODE_M2M_BLEND_FIXED_COLOR_FG) || \
0061                                          ((MODE) == LL_DMA2D_MODE_M2M_BLEND_FIXED_COLOR_BG) || \
0062                                          ((MODE) == LL_DMA2D_MODE_R2M))
0063 
0064 #define IS_LL_DMA2D_OCMODE(MODE_ARGB)   (((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB8888) || \
0065                                          ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_RGB888)   || \
0066                                          ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_RGB565)   || \
0067                                          ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB1555) || \
0068                                          ((MODE_ARGB) == LL_DMA2D_OUTPUT_MODE_ARGB4444))
0069 
0070 #define IS_LL_DMA2D_GREEN(GREEN)        ((GREEN) <= LL_DMA2D_COLOR)
0071 #define IS_LL_DMA2D_RED(RED)            ((RED)   <= LL_DMA2D_COLOR)
0072 #define IS_LL_DMA2D_BLUE(BLUE)          ((BLUE)  <= LL_DMA2D_COLOR)
0073 #define IS_LL_DMA2D_ALPHA(ALPHA)        ((ALPHA) <= LL_DMA2D_COLOR)
0074 
0075 #define IS_LL_DMA2D_OFFSET_MODE(MODE)   (((MODE) == LL_DMA2D_LINE_OFFSET_PIXELS) || \
0076                                          ((MODE) == LL_DMA2D_LINE_OFFSET_BYTES))
0077 
0078 #define IS_LL_DMA2D_OFFSET(OFFSET)      ((OFFSET) <= LL_DMA2D_OFFSET_MAX)
0079 
0080 #define IS_LL_DMA2D_LINE(LINES)         ((LINES)  <= LL_DMA2D_NUMBEROFLINES)
0081 #define IS_LL_DMA2D_PIXEL(PIXELS)       ((PIXELS) <= LL_DMA2D_NUMBEROFPIXELS)
0082 
0083 #define IS_LL_DMA2D_SWAP_MODE(MODE)     (((MODE) == LL_DMA2D_SWAP_MODE_REGULAR) || \
0084                                          ((MODE) == LL_DMA2D_SWAP_MODE_TWO_BY_TWO))
0085 
0086 #define IS_LL_DMA2D_ALPHAINV(ALPHA)     (((ALPHA) == LL_DMA2D_ALPHA_REGULAR) || \
0087                                          ((ALPHA) == LL_DMA2D_ALPHA_INVERTED))
0088 
0089 #define IS_LL_DMA2D_RBSWAP(RBSWAP)      (((RBSWAP) == LL_DMA2D_RB_MODE_REGULAR) || \
0090                                          ((RBSWAP) == LL_DMA2D_RB_MODE_SWAP))
0091 
0092 #define IS_LL_DMA2D_LCMODE(MODE_ARGB)   (((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB8888) || \
0093                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_RGB888)   || \
0094                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_RGB565)   || \
0095                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB1555) || \
0096                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_ARGB4444) || \
0097                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_L8)       || \
0098                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_AL44)     || \
0099                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_AL88)     || \
0100                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_L4)       || \
0101                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_A8)       || \
0102                                          ((MODE_ARGB) == LL_DMA2D_INPUT_MODE_A4))
0103 
0104 #define IS_LL_DMA2D_CLUTCMODE(CLUTCMODE) (((CLUTCMODE) == LL_DMA2D_CLUT_COLOR_MODE_ARGB8888) || \
0105                                           ((CLUTCMODE) == LL_DMA2D_CLUT_COLOR_MODE_RGB888))
0106 
0107 #define IS_LL_DMA2D_CLUTSIZE(SIZE)      ((SIZE) <= LL_DMA2D_CLUTSIZE_MAX)
0108 
0109 #define IS_LL_DMA2D_ALPHAMODE(MODE)     (((MODE) == LL_DMA2D_ALPHA_MODE_NO_MODIF) || \
0110                                          ((MODE) == LL_DMA2D_ALPHA_MODE_REPLACE)  || \
0111                                          ((MODE) == LL_DMA2D_ALPHA_MODE_COMBINE))
0112 
0113 #define IS_LL_DMA2D_CHROMA_SUB_SAMPLING(CSS) (((CSS) == LL_DMA2D_CSS_444) || \
0114                                               ((CSS) == LL_DMA2D_CSS_422) || \
0115                                               ((CSS) == LL_DMA2D_CSS_420))
0116 
0117 /**
0118   * @}
0119   */
0120 
0121 /* Private function prototypes -----------------------------------------------*/
0122 
0123 /* Exported functions --------------------------------------------------------*/
0124 /** @addtogroup DMA2D_LL_Exported_Functions
0125   * @{
0126   */
0127 
0128 /** @addtogroup DMA2D_LL_EF_Init_Functions Initialization and De-initialization Functions
0129   * @{
0130   */
0131 
0132 /**
0133   * @brief  De-initialize DMA2D registers (registers restored to their default values).
0134   * @param  DMA2Dx DMA2D Instance
0135   * @retval An ErrorStatus enumeration value:
0136   *          - SUCCESS: DMA2D registers are de-initialized
0137   *          - ERROR: DMA2D registers are not de-initialized
0138   */
0139 ErrorStatus LL_DMA2D_DeInit(DMA2D_TypeDef *DMA2Dx)
0140 {
0141   ErrorStatus status = SUCCESS;
0142 
0143   /* Check the parameters */
0144   assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx));
0145 
0146   if (DMA2Dx == DMA2D)
0147   {
0148     /* Force reset of DMA2D clock */
0149     LL_AHB3_GRP1_ForceReset(LL_AHB3_GRP1_PERIPH_DMA2D);
0150 
0151     /* Release reset of DMA2D clock */
0152     LL_AHB3_GRP1_ReleaseReset(LL_AHB3_GRP1_PERIPH_DMA2D);
0153 
0154   }
0155   else
0156   {
0157     status = ERROR;
0158   }
0159 
0160   return (status);
0161 }
0162 
0163 /**
0164   * @brief  Initialize DMA2D registers according to the specified parameters in DMA2D_InitStruct.
0165   * @note   DMA2D transfers must be disabled to set initialization bits in configuration registers,
0166   *         otherwise ERROR result is returned.
0167   * @param  DMA2Dx DMA2D Instance
0168   * @param  DMA2D_InitStruct  pointer to a LL_DMA2D_InitTypeDef structure
0169   *         that contains the configuration information for the specified DMA2D peripheral.
0170   * @retval An ErrorStatus enumeration value:
0171   *          - SUCCESS: DMA2D registers are initialized according to DMA2D_InitStruct content
0172   *          - ERROR: Issue occurred during DMA2D registers initialization
0173   */
0174 ErrorStatus LL_DMA2D_Init(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_InitTypeDef *DMA2D_InitStruct)
0175 {
0176   ErrorStatus status = ERROR;
0177   LL_DMA2D_ColorTypeDef dma2d_colorstruct;
0178   uint32_t tmp;
0179   uint32_t tmp1;
0180   uint32_t tmp2;
0181   uint32_t regMask;
0182   uint32_t regValue;
0183 
0184   /* Check the parameters */
0185   assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx));
0186   assert_param(IS_LL_DMA2D_MODE(DMA2D_InitStruct->Mode));
0187   assert_param(IS_LL_DMA2D_OCMODE(DMA2D_InitStruct->ColorMode));
0188   assert_param(IS_LL_DMA2D_LINE(DMA2D_InitStruct->NbrOfLines));
0189   assert_param(IS_LL_DMA2D_PIXEL(DMA2D_InitStruct->NbrOfPixelsPerLines));
0190   assert_param(IS_LL_DMA2D_GREEN(DMA2D_InitStruct->OutputGreen));
0191   assert_param(IS_LL_DMA2D_RED(DMA2D_InitStruct->OutputRed));
0192   assert_param(IS_LL_DMA2D_BLUE(DMA2D_InitStruct->OutputBlue));
0193   assert_param(IS_LL_DMA2D_ALPHA(DMA2D_InitStruct->OutputAlpha));
0194   assert_param(IS_LL_DMA2D_SWAP_MODE(DMA2D_InitStruct->OutputSwapMode));
0195   assert_param(IS_LL_DMA2D_OFFSET_MODE(DMA2D_InitStruct->LineOffsetMode));
0196   assert_param(IS_LL_DMA2D_OFFSET(DMA2D_InitStruct->LineOffset));
0197   assert_param(IS_LL_DMA2D_ALPHAINV(DMA2D_InitStruct->AlphaInversionMode));
0198   assert_param(IS_LL_DMA2D_RBSWAP(DMA2D_InitStruct->RBSwapMode));
0199 
0200   /* DMA2D transfers must be disabled to configure bits in initialization registers */
0201   tmp = LL_DMA2D_IsTransferOngoing(DMA2Dx);
0202   tmp1 = LL_DMA2D_FGND_IsEnabledCLUTLoad(DMA2Dx);
0203   tmp2 = LL_DMA2D_BGND_IsEnabledCLUTLoad(DMA2Dx);
0204   if ((tmp == 0U) && (tmp1 == 0U) && (tmp2 == 0U))
0205   {
0206     /* DMA2D CR register configuration -------------------------------------------*/
0207     MODIFY_REG(DMA2Dx->CR, (DMA2D_CR_MODE | DMA2D_CR_LOM), \
0208                (DMA2D_InitStruct->Mode | DMA2D_InitStruct->LineOffsetMode));
0209 
0210     /* DMA2D OPFCCR register configuration ---------------------------------------*/
0211     regMask = DMA2D_OPFCCR_CM;
0212     regValue = DMA2D_InitStruct->ColorMode;
0213 
0214     regMask |= DMA2D_OPFCCR_SB;
0215     regValue |= DMA2D_InitStruct->OutputSwapMode;
0216 
0217     regMask |= (DMA2D_OPFCCR_RBS | DMA2D_OPFCCR_AI);
0218     regValue |= (DMA2D_InitStruct->AlphaInversionMode | DMA2D_InitStruct->RBSwapMode);
0219 
0220 
0221     MODIFY_REG(DMA2Dx->OPFCCR, regMask, regValue);
0222 
0223     /* DMA2D OOR register configuration ------------------------------------------*/
0224     LL_DMA2D_SetLineOffset(DMA2Dx, DMA2D_InitStruct->LineOffset);
0225 
0226     /* DMA2D NLR register configuration ------------------------------------------*/
0227     LL_DMA2D_ConfigSize(DMA2Dx, DMA2D_InitStruct->NbrOfLines, DMA2D_InitStruct->NbrOfPixelsPerLines);
0228 
0229     /* DMA2D OMAR register configuration ------------------------------------------*/
0230     LL_DMA2D_SetOutputMemAddr(DMA2Dx, DMA2D_InitStruct->OutputMemoryAddress);
0231 
0232     /* DMA2D OCOLR register configuration ------------------------------------------*/
0233     dma2d_colorstruct.ColorMode   = DMA2D_InitStruct->ColorMode;
0234     dma2d_colorstruct.OutputBlue  = DMA2D_InitStruct->OutputBlue;
0235     dma2d_colorstruct.OutputGreen = DMA2D_InitStruct->OutputGreen;
0236     dma2d_colorstruct.OutputRed   = DMA2D_InitStruct->OutputRed;
0237     dma2d_colorstruct.OutputAlpha = DMA2D_InitStruct->OutputAlpha;
0238     LL_DMA2D_ConfigOutputColor(DMA2Dx, &dma2d_colorstruct);
0239 
0240     status = SUCCESS;
0241   }
0242   /* If DMA2D transfers are not disabled, return ERROR */
0243 
0244   return (status);
0245 }
0246 
0247 /**
0248   * @brief Set each @ref LL_DMA2D_InitTypeDef field to default value.
0249   * @param DMA2D_InitStruct  pointer to a @ref LL_DMA2D_InitTypeDef structure
0250   *                          whose fields will be set to default values.
0251   * @retval None
0252   */
0253 void LL_DMA2D_StructInit(LL_DMA2D_InitTypeDef *DMA2D_InitStruct)
0254 {
0255   /* Set DMA2D_InitStruct fields to default values */
0256   DMA2D_InitStruct->Mode                = LL_DMA2D_MODE_M2M;
0257   DMA2D_InitStruct->ColorMode           = LL_DMA2D_OUTPUT_MODE_ARGB8888;
0258   DMA2D_InitStruct->NbrOfLines          = 0x0U;
0259   DMA2D_InitStruct->NbrOfPixelsPerLines = 0x0U;
0260   DMA2D_InitStruct->LineOffsetMode      = LL_DMA2D_LINE_OFFSET_PIXELS;
0261   DMA2D_InitStruct->LineOffset          = 0x0U;
0262   DMA2D_InitStruct->OutputBlue          = 0x0U;
0263   DMA2D_InitStruct->OutputGreen         = 0x0U;
0264   DMA2D_InitStruct->OutputRed           = 0x0U;
0265   DMA2D_InitStruct->OutputAlpha         = 0x0U;
0266   DMA2D_InitStruct->OutputMemoryAddress = 0x0U;
0267   DMA2D_InitStruct->OutputSwapMode      = LL_DMA2D_SWAP_MODE_REGULAR;
0268   DMA2D_InitStruct->AlphaInversionMode  = LL_DMA2D_ALPHA_REGULAR;
0269   DMA2D_InitStruct->RBSwapMode          = LL_DMA2D_RB_MODE_REGULAR;
0270 }
0271 
0272 /**
0273   * @brief  Configure the foreground or background according to the specified parameters
0274   *         in the LL_DMA2D_LayerCfgTypeDef structure.
0275   * @param  DMA2Dx DMA2D Instance
0276   * @param  DMA2D_LayerCfg  pointer to a LL_DMA2D_LayerCfgTypeDef structure that contains
0277   *         the configuration information for the specified layer.
0278   * @param  LayerIdx  DMA2D Layer index.
0279   *                   This parameter can be one of the following values:
0280   *                   0(background) / 1(foreground)
0281   * @retval None
0282   */
0283 void LL_DMA2D_ConfigLayer(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_LayerCfgTypeDef *DMA2D_LayerCfg, uint32_t LayerIdx)
0284 {
0285   /* Check the parameters */
0286   assert_param(IS_LL_DMA2D_OFFSET(DMA2D_LayerCfg->LineOffset));
0287   assert_param(IS_LL_DMA2D_LCMODE(DMA2D_LayerCfg->ColorMode));
0288   assert_param(IS_LL_DMA2D_CLUTCMODE(DMA2D_LayerCfg->CLUTColorMode));
0289   assert_param(IS_LL_DMA2D_CLUTSIZE(DMA2D_LayerCfg->CLUTSize));
0290   assert_param(IS_LL_DMA2D_ALPHAMODE(DMA2D_LayerCfg->AlphaMode));
0291   assert_param(IS_LL_DMA2D_GREEN(DMA2D_LayerCfg->Green));
0292   assert_param(IS_LL_DMA2D_RED(DMA2D_LayerCfg->Red));
0293   assert_param(IS_LL_DMA2D_BLUE(DMA2D_LayerCfg->Blue));
0294   assert_param(IS_LL_DMA2D_ALPHA(DMA2D_LayerCfg->Alpha));
0295   assert_param(IS_LL_DMA2D_ALPHAINV(DMA2D_LayerCfg->AlphaInversionMode));
0296   assert_param(IS_LL_DMA2D_RBSWAP(DMA2D_LayerCfg->RBSwapMode));
0297   assert_param(IS_LL_DMA2D_CHROMA_SUB_SAMPLING(DMA2D_LayerCfg->ChromaSubSampling));
0298 
0299 
0300   if (LayerIdx == 0U)
0301   {
0302     /* Configure the background memory address */
0303     LL_DMA2D_BGND_SetMemAddr(DMA2Dx, DMA2D_LayerCfg->MemoryAddress);
0304 
0305     /* Configure the background line offset */
0306     LL_DMA2D_BGND_SetLineOffset(DMA2Dx, DMA2D_LayerCfg->LineOffset);
0307 
0308     /* Configure the background Alpha value, Alpha mode, RB swap, Alpha inversion
0309        CLUT size, CLUT Color mode and Color mode */
0310     MODIFY_REG(DMA2Dx->BGPFCCR, \
0311                (DMA2D_BGPFCCR_ALPHA | DMA2D_BGPFCCR_RBS | DMA2D_BGPFCCR_AI | DMA2D_BGPFCCR_AM | \
0312                 DMA2D_BGPFCCR_CS | DMA2D_BGPFCCR_CCM | DMA2D_BGPFCCR_CM), \
0313                ((DMA2D_LayerCfg->Alpha << DMA2D_BGPFCCR_ALPHA_Pos) | DMA2D_LayerCfg->RBSwapMode | \
0314                 DMA2D_LayerCfg->AlphaInversionMode | DMA2D_LayerCfg->AlphaMode | \
0315                 (DMA2D_LayerCfg->CLUTSize << DMA2D_BGPFCCR_CS_Pos) | DMA2D_LayerCfg->CLUTColorMode | \
0316                 DMA2D_LayerCfg->ColorMode));
0317 
0318     /* Configure the background color */
0319     LL_DMA2D_BGND_SetColor(DMA2Dx, DMA2D_LayerCfg->Red, DMA2D_LayerCfg->Green, DMA2D_LayerCfg->Blue);
0320 
0321     /* Configure the background CLUT memory address */
0322     LL_DMA2D_BGND_SetCLUTMemAddr(DMA2Dx, DMA2D_LayerCfg->CLUTMemoryAddress);
0323   }
0324   else
0325   {
0326     /* Configure the foreground memory address */
0327     LL_DMA2D_FGND_SetMemAddr(DMA2Dx, DMA2D_LayerCfg->MemoryAddress);
0328 
0329     /* Configure the foreground line offset */
0330     LL_DMA2D_FGND_SetLineOffset(DMA2Dx, DMA2D_LayerCfg->LineOffset);
0331 
0332     /* Configure the foreground Alpha value, Alpha mode, RB swap, Alpha inversion
0333        CLUT size, CLUT Color mode and Color mode */
0334     MODIFY_REG(DMA2Dx->FGPFCCR, \
0335                (DMA2D_FGPFCCR_ALPHA | DMA2D_FGPFCCR_RBS | DMA2D_FGPFCCR_AI | DMA2D_FGPFCCR_CSS | DMA2D_FGPFCCR_AM | \
0336                 DMA2D_FGPFCCR_CS | DMA2D_FGPFCCR_CCM | DMA2D_FGPFCCR_CM), \
0337                ((DMA2D_LayerCfg->Alpha << DMA2D_FGPFCCR_ALPHA_Pos) | DMA2D_LayerCfg->RBSwapMode | \
0338                 DMA2D_LayerCfg->AlphaInversionMode | DMA2D_LayerCfg->ChromaSubSampling | \
0339                 DMA2D_LayerCfg->AlphaMode | (DMA2D_LayerCfg->CLUTSize << DMA2D_FGPFCCR_CS_Pos) | \
0340                 DMA2D_LayerCfg->CLUTColorMode | DMA2D_LayerCfg->ColorMode));
0341 
0342     /* Configure the foreground color */
0343     LL_DMA2D_FGND_SetColor(DMA2Dx, DMA2D_LayerCfg->Red, DMA2D_LayerCfg->Green, DMA2D_LayerCfg->Blue);
0344 
0345     /* Configure the foreground CLUT memory address */
0346     LL_DMA2D_FGND_SetCLUTMemAddr(DMA2Dx, DMA2D_LayerCfg->CLUTMemoryAddress);
0347   }
0348 }
0349 
0350 /**
0351   * @brief Set each @ref LL_DMA2D_LayerCfgTypeDef field to default value.
0352   * @param DMA2D_LayerCfg  pointer to a @ref LL_DMA2D_LayerCfgTypeDef structure
0353   *                        whose fields will be set to default values.
0354   * @retval None
0355   */
0356 void LL_DMA2D_LayerCfgStructInit(LL_DMA2D_LayerCfgTypeDef *DMA2D_LayerCfg)
0357 {
0358   /* Set DMA2D_LayerCfg fields to default values */
0359   DMA2D_LayerCfg->MemoryAddress      = 0x0U;
0360   DMA2D_LayerCfg->ColorMode          = LL_DMA2D_INPUT_MODE_ARGB8888;
0361   DMA2D_LayerCfg->LineOffset         = 0x0U;
0362   DMA2D_LayerCfg->CLUTColorMode      = LL_DMA2D_CLUT_COLOR_MODE_ARGB8888;
0363   DMA2D_LayerCfg->CLUTSize           = 0x0U;
0364   DMA2D_LayerCfg->AlphaMode          = LL_DMA2D_ALPHA_MODE_NO_MODIF;
0365   DMA2D_LayerCfg->Alpha              = 0x0U;
0366   DMA2D_LayerCfg->Blue               = 0x0U;
0367   DMA2D_LayerCfg->Green              = 0x0U;
0368   DMA2D_LayerCfg->Red                = 0x0U;
0369   DMA2D_LayerCfg->CLUTMemoryAddress  = 0x0U;
0370   DMA2D_LayerCfg->AlphaInversionMode = LL_DMA2D_ALPHA_REGULAR;
0371   DMA2D_LayerCfg->RBSwapMode         = LL_DMA2D_RB_MODE_REGULAR;
0372   DMA2D_LayerCfg->ChromaSubSampling  = LL_DMA2D_CSS_444;
0373 }
0374 
0375 /**
0376   * @brief  Initialize DMA2D output color register according to the specified parameters
0377   *         in DMA2D_ColorStruct.
0378   * @param  DMA2Dx DMA2D Instance
0379   * @param  DMA2D_ColorStruct  pointer to a LL_DMA2D_ColorTypeDef structure that contains
0380   *         the color configuration information for the specified DMA2D peripheral.
0381   * @retval None
0382   */
0383 void LL_DMA2D_ConfigOutputColor(DMA2D_TypeDef *DMA2Dx, LL_DMA2D_ColorTypeDef *DMA2D_ColorStruct)
0384 {
0385   uint32_t outgreen;
0386   uint32_t outred;
0387   uint32_t outalpha;
0388 
0389   /* Check the parameters */
0390   assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx));
0391   assert_param(IS_LL_DMA2D_OCMODE(DMA2D_ColorStruct->ColorMode));
0392   assert_param(IS_LL_DMA2D_GREEN(DMA2D_ColorStruct->OutputGreen));
0393   assert_param(IS_LL_DMA2D_RED(DMA2D_ColorStruct->OutputRed));
0394   assert_param(IS_LL_DMA2D_BLUE(DMA2D_ColorStruct->OutputBlue));
0395   assert_param(IS_LL_DMA2D_ALPHA(DMA2D_ColorStruct->OutputAlpha));
0396 
0397   /* DMA2D OCOLR register configuration ------------------------------------------*/
0398   if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888)
0399   {
0400     outgreen = DMA2D_ColorStruct->OutputGreen << 8U;
0401     outred = DMA2D_ColorStruct->OutputRed << 16U;
0402     outalpha = DMA2D_ColorStruct->OutputAlpha << 24U;
0403   }
0404   else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888)
0405   {
0406     outgreen = DMA2D_ColorStruct->OutputGreen << 8U;
0407     outred = DMA2D_ColorStruct->OutputRed << 16U;
0408     outalpha = 0x00000000U;
0409   }
0410   else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565)
0411   {
0412     outgreen = DMA2D_ColorStruct->OutputGreen << 5U;
0413     outred = DMA2D_ColorStruct->OutputRed << 11U;
0414     outalpha = 0x00000000U;
0415   }
0416   else if (DMA2D_ColorStruct->ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555)
0417   {
0418     outgreen = DMA2D_ColorStruct->OutputGreen << 5U;
0419     outred = DMA2D_ColorStruct->OutputRed << 10U;
0420     outalpha = DMA2D_ColorStruct->OutputAlpha << 15U;
0421   }
0422   else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */
0423   {
0424     outgreen = DMA2D_ColorStruct->OutputGreen << 4U;
0425     outred = DMA2D_ColorStruct->OutputRed << 8U;
0426     outalpha = DMA2D_ColorStruct->OutputAlpha << 12U;
0427   }
0428   LL_DMA2D_SetOutputColor(DMA2Dx, (outgreen | outred | DMA2D_ColorStruct->OutputBlue | outalpha));
0429 }
0430 
0431 /**
0432   * @brief  Return DMA2D output Blue color.
0433   * @param  DMA2Dx DMA2D Instance.
0434   * @param  ColorMode This parameter can be one of the following values:
0435   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888
0436   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888
0437   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565
0438   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555
0439   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444
0440   * @retval Output Blue color value between Min_Data=0 and Max_Data=0xFF
0441   */
0442 uint32_t LL_DMA2D_GetOutputBlueColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode)
0443 {
0444   uint32_t color;
0445 
0446   /* Check the parameters */
0447   assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx));
0448   assert_param(IS_LL_DMA2D_OCMODE(ColorMode));
0449 
0450   /* DMA2D OCOLR register reading ------------------------------------------*/
0451   if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888)
0452   {
0453     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFFU));
0454   }
0455   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888)
0456   {
0457     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFFU));
0458   }
0459   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565)
0460   {
0461     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x1FU));
0462   }
0463   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555)
0464   {
0465     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x1FU));
0466   }
0467   else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */
0468   {
0469     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFU));
0470   }
0471 
0472   return color;
0473 }
0474 
0475 /**
0476   * @brief  Return DMA2D output Green color.
0477   * @param  DMA2Dx DMA2D Instance.
0478   * @param  ColorMode This parameter can be one of the following values:
0479   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888
0480   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888
0481   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565
0482   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555
0483   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444
0484   * @retval Output Green color value between Min_Data=0 and Max_Data=0xFF
0485   */
0486 uint32_t LL_DMA2D_GetOutputGreenColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode)
0487 {
0488   uint32_t color;
0489 
0490   /* Check the parameters */
0491   assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx));
0492   assert_param(IS_LL_DMA2D_OCMODE(ColorMode));
0493 
0494   /* DMA2D OCOLR register reading ------------------------------------------*/
0495   if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888)
0496   {
0497     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF00U) >> 8U);
0498   }
0499   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888)
0500   {
0501     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF00U) >> 8U);
0502   }
0503   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565)
0504   {
0505     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x7E0U) >> 5U);
0506   }
0507   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555)
0508   {
0509     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x3E0U) >> 5U);
0510   }
0511   else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */
0512   {
0513     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF0U) >> 4U);
0514   }
0515 
0516   return color;
0517 }
0518 
0519 /**
0520   * @brief  Return DMA2D output Red color.
0521   * @param  DMA2Dx DMA2D Instance.
0522   * @param  ColorMode This parameter can be one of the following values:
0523   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888
0524   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888
0525   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565
0526   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555
0527   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444
0528   * @retval Output Red color value between Min_Data=0 and Max_Data=0xFF
0529   */
0530 uint32_t LL_DMA2D_GetOutputRedColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode)
0531 {
0532   uint32_t color;
0533 
0534   /* Check the parameters */
0535   assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx));
0536   assert_param(IS_LL_DMA2D_OCMODE(ColorMode));
0537 
0538   /* DMA2D OCOLR register reading ------------------------------------------*/
0539   if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888)
0540   {
0541     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF0000U) >> 16U);
0542   }
0543   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888)
0544   {
0545     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF0000U) >> 16U);
0546   }
0547   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565)
0548   {
0549     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF800U) >> 11U);
0550   }
0551   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555)
0552   {
0553     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x7C00U) >> 10U);
0554   }
0555   else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */
0556   {
0557     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF00U) >> 8U);
0558   }
0559 
0560   return color;
0561 }
0562 
0563 /**
0564   * @brief  Return DMA2D output Alpha color.
0565   * @param  DMA2Dx DMA2D Instance.
0566   * @param  ColorMode This parameter can be one of the following values:
0567   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB8888
0568   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB888
0569   *         @arg @ref LL_DMA2D_OUTPUT_MODE_RGB565
0570   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB1555
0571   *         @arg @ref LL_DMA2D_OUTPUT_MODE_ARGB4444
0572   * @retval Output Alpha color value between Min_Data=0 and Max_Data=0xFF
0573   */
0574 uint32_t LL_DMA2D_GetOutputAlphaColor(DMA2D_TypeDef *DMA2Dx, uint32_t ColorMode)
0575 {
0576   uint32_t color;
0577 
0578   /* Check the parameters */
0579   assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx));
0580   assert_param(IS_LL_DMA2D_OCMODE(ColorMode));
0581 
0582   /* DMA2D OCOLR register reading ------------------------------------------*/
0583   if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB8888)
0584   {
0585     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xFF000000U) >> 24U);
0586   }
0587   else if ((ColorMode == LL_DMA2D_OUTPUT_MODE_RGB888) || (ColorMode == LL_DMA2D_OUTPUT_MODE_RGB565))
0588   {
0589     color = 0x0U;
0590   }
0591   else if (ColorMode == LL_DMA2D_OUTPUT_MODE_ARGB1555)
0592   {
0593     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0x8000U) >> 15U);
0594   }
0595   else /* ColorMode = LL_DMA2D_OUTPUT_MODE_ARGB4444 */
0596   {
0597     color = (uint32_t)(READ_BIT(DMA2Dx->OCOLR, 0xF000U) >> 12U);
0598   }
0599 
0600   return color;
0601 }
0602 
0603 /**
0604   * @brief  Configure DMA2D transfer size.
0605   * @param  DMA2Dx DMA2D Instance
0606   * @param  NbrOfLines Value between Min_Data=0 and Max_Data=0xFFFF
0607   * @param  NbrOfPixelsPerLines Value between Min_Data=0 and Max_Data=0x3FFF
0608   * @retval None
0609   */
0610 void LL_DMA2D_ConfigSize(DMA2D_TypeDef *DMA2Dx, uint32_t NbrOfLines, uint32_t NbrOfPixelsPerLines)
0611 {
0612   MODIFY_REG(DMA2Dx->NLR, (DMA2D_NLR_PL | DMA2D_NLR_NL), \
0613              ((NbrOfPixelsPerLines << DMA2D_NLR_PL_Pos) | NbrOfLines));
0614 }
0615 
0616 /**
0617   * @}
0618   */
0619 
0620 /**
0621   * @}
0622   */
0623 
0624 /**
0625   * @}
0626   */
0627 
0628 #endif /* defined (DMA2D) */
0629 
0630 /**
0631   * @}
0632   */
0633 
0634 #endif /* USE_FULL_LL_DRIVER */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!