训练营PLSR题目
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
 
 
 
 
 
 

595 linhas
22 KiB

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