diff options
Diffstat (limited to 'bsps/arm/stm32h7/hal/stm32h7xx_hal_gfxmmu.c')
| -rw-r--r-- | bsps/arm/stm32h7/hal/stm32h7xx_hal_gfxmmu.c | 893 |
1 files changed, 893 insertions, 0 deletions
diff --git a/bsps/arm/stm32h7/hal/stm32h7xx_hal_gfxmmu.c b/bsps/arm/stm32h7/hal/stm32h7xx_hal_gfxmmu.c new file mode 100644 index 0000000000..b873c73bfd --- /dev/null +++ b/bsps/arm/stm32h7/hal/stm32h7xx_hal_gfxmmu.c @@ -0,0 +1,893 @@ +/**
+ ******************************************************************************
+ * @file stm32h7xx_hal_gfxmmu.c
+ * @author MCD Application Team
+ * @brief This file provides firmware functions to manage the following
+ * functionalities of the Graphic MMU (GFXMMU) peripheral:
+ * + Initialization and De-initialization.
+ * + LUT configuration.
+ * + Force flush and/or invalidate of cache.
+ * + Modify physical buffer adresses.
+ * + Modify cache and pre-fetch parameters.
+ * + Error management.
+ *
+ @verbatim
+ ==============================================================================
+ ##### How to use this driver #####
+ ==============================================================================
+ [..]
+ *** Initialization ***
+ ======================
+ [..]
+ (#) As prerequisite, fill in the HAL_GFXMMU_MspInit() :
+ (++) Enable GFXMMU clock interface with __HAL_RCC_GFXMMU_CLK_ENABLE().
+ (++) If interrupts are used, enable and configure GFXMMU global
+ interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
+ (#) Configure the number of blocks per line, default value, physical
+ buffer addresses, cache and pre-fetch parameters and interrupts
+ using the HAL_GFXMMU_Init() function.
+
+ *** LUT configuration ***
+ =========================
+ [..]
+ (#) Use HAL_GFXMMU_DisableLutLines() to deactivate all LUT lines (or a
+ range of lines).
+ (#) Use HAL_GFXMMU_ConfigLut() to copy LUT from flash to look up RAM.
+ (#) Use HAL_GFXMMU_ConfigLutLine() to configure one line of LUT.
+
+ *** Force flush and/or invalidate of cache ***
+ ==============================================
+ [..]
+ (#) Use HAL_GFXMMU_ConfigForceCache() to flush and/or invalidate cache.
+
+ *** Modify physical buffer adresses ***
+ =======================================
+ [..]
+ (#) Use HAL_GFXMMU_ModifyBuffers() to modify physical buffer addresses.
+
+ *** Modify cache and pre-fetch parameters ***
+ =============================================
+ [..]
+ (#) Use HAL_GFXMMU_ModifyCachePrefetch() to modify cache and pre-fetch
+ parameters.
+
+ *** Error management ***
+ ========================
+ [..]
+ (#) If interrupts are used, HAL_GFXMMU_IRQHandler() will be called when
+ an error occurs. This function will call HAL_GFXMMU_ErrorCallback().
+ Use HAL_GFXMMU_GetError() to get the error code.
+
+ *** De-initialization ***
+ =========================
+ [..]
+ (#) As prerequisite, fill in the HAL_GFXMMU_MspDeInit() :
+ (++) Disable GFXMMU clock interface with __HAL_RCC_GFXMMU_CLK_ENABLE().
+ (++) If interrupts has been used, disable GFXMMU global interrupt with
+ HAL_NVIC_DisableIRQ().
+ (#) De-initialize GFXMMU using the HAL_GFXMMU_DeInit() function.
+
+ *** Callback registration ***
+ =============================
+
+ [..]
+ The compilation define USE_HAL_GFXMMU_REGISTER_CALLBACKS when set to 1
+ allows the user to configure dynamically the driver callbacks.
+ Use functions HAL_GFXMMU_RegisterCallback() to register a user callback.
+
+ [..]
+ Function HAL_GFXMMU_RegisterCallback() allows to register following callbacks:
+ (+) ErrorCallback : GFXMMU error.
+ (+) MspInitCallback : GFXMMU MspInit.
+ (+) MspDeInitCallback : GFXMMU MspDeInit.
+ [..]
+ This function takes as parameters the HAL peripheral handle, the callback ID
+ and a pointer to the user callback function.
+
+ [..]
+ Use function HAL_GFXMMU_UnRegisterCallback() to reset a callback to the default
+ weak (surcharged) function.
+ HAL_GFXMMU_UnRegisterCallback() takes as parameters the HAL peripheral handle,
+ and the callback ID.
+ [..]
+ This function allows to reset following callbacks:
+ (+) ErrorCallback : GFXMMU error.
+ (+) MspInitCallback : GFXMMU MspInit.
+ (+) MspDeInitCallback : GFXMMU MspDeInit.
+
+ [..]
+ By default, after the HAL_GFXMMU_Init and if the state is HAL_GFXMMU_STATE_RESET
+ all callbacks are reset to the corresponding legacy weak (surcharged) functions:
+ examples HAL_GFXMMU_ErrorCallback().
+ Exception done for MspInit and MspDeInit callbacks that are respectively
+ reset to the legacy weak (surcharged) functions in the HAL_GFXMMU_Init
+ and HAL_GFXMMU_DeInit only when these callbacks are null (not registered beforehand).
+ If not, MspInit or MspDeInit are not null, the HAL_GFXMMU_Init and HAL_GFXMMU_DeInit
+ keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
+
+ [..]
+ Callbacks can be registered/unregistered in READY state only.
+ Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
+ in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
+ during the Init/DeInit.
+ In that case first register the MspInit/MspDeInit user callbacks
+ using HAL_GFXMMU_RegisterCallback before calling HAL_GFXMMU_DeInit
+ or HAL_GFXMMU_Init function.
+
+ [..]
+ When the compilation define USE_HAL_GFXMMU_REGISTER_CALLBACKS is set to 0 or
+ not defined, the callback registering feature is not available
+ and weak (surcharged) callbacks are used.
+
+ @endverbatim
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© Copyright (c) 2017 STMicroelectronics.
+ * All rights reserved.</center></h2>
+ *
+ * This software component is licensed by ST under BSD 3-Clause license,
+ * the "License"; You may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at:
+ * opensource.org/licenses/BSD-3-Clause
+ *
+ ******************************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32h7xx_hal.h"
+
+/** @addtogroup STM32H7xx_HAL_Driver
+ * @{
+ */
+#ifdef HAL_GFXMMU_MODULE_ENABLED
+#if defined(GFXMMU)
+/** @defgroup GFXMMU GFXMMU
+ * @brief GFXMMU HAL driver module
+ * @{
+ */
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+#define GFXMMU_LUTXL_FVB_OFFSET 8U
+#define GFXMMU_LUTXL_LVB_OFFSET 16U
+#define GFXMMU_CR_ITS_MASK 0x1FU
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
+/* Exported functions --------------------------------------------------------*/
+/** @defgroup GFXMMU_Exported_Functions GFXMMU Exported Functions
+ * @{
+ */
+
+/** @defgroup GFXMMU_Exported_Functions_Group1 Initialization and de-initialization functions
+ * @brief Initialization and de-initialization functions
+ *
+@verbatim
+ ==============================================================================
+ ##### Initialization and de-initialization functions #####
+ ==============================================================================
+ [..] This section provides functions allowing to:
+ (+) Initialize the GFXMMU.
+ (+) De-initialize the GFXMMU.
+@endverbatim
+ * @{
+ */
+
+/**
+ * @brief Initialize the GFXMMU according to the specified parameters in the
+ * GFXMMU_InitTypeDef structure and initialize the associated handle.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_Init(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ /* Check GFXMMU handle */
+ if(hgfxmmu == NULL)
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+ assert_param(IS_GFXMMU_BLOCKS_PER_LINE(hgfxmmu->Init.BlocksPerLine));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(hgfxmmu->Init.Buffers.Buf0Address));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(hgfxmmu->Init.Buffers.Buf1Address));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(hgfxmmu->Init.Buffers.Buf2Address));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(hgfxmmu->Init.Buffers.Buf3Address));
+ assert_param(IS_FUNCTIONAL_STATE(hgfxmmu->Init.CachePrefetch.Activation));
+ assert_param(IS_FUNCTIONAL_STATE(hgfxmmu->Init.Interrupts.Activation));
+
+#if (USE_HAL_GFXMMU_REGISTER_CALLBACKS == 1)
+ /* Reset callback pointers to the weak predefined callbacks */
+ hgfxmmu->ErrorCallback = HAL_GFXMMU_ErrorCallback;
+
+ /* Call GFXMMU MSP init function */
+ if(hgfxmmu->MspInitCallback == NULL)
+ {
+ hgfxmmu->MspInitCallback = HAL_GFXMMU_MspInit;
+ }
+ hgfxmmu->MspInitCallback(hgfxmmu);
+#else
+ /* Call GFXMMU MSP init function */
+ HAL_GFXMMU_MspInit(hgfxmmu);
+#endif
+
+ /* Configure blocks per line, cache and interrupts parameters on GFXMMU_CR register */
+ hgfxmmu->Instance->CR &= ~(GFXMMU_CR_B0OIE | GFXMMU_CR_B1OIE | GFXMMU_CR_B2OIE | GFXMMU_CR_B3OIE |
+ GFXMMU_CR_AMEIE | GFXMMU_CR_192BM | GFXMMU_CR_CE | GFXMMU_CR_CL |
+ GFXMMU_CR_CLB | GFXMMU_CR_FC | GFXMMU_CR_PD | GFXMMU_CR_OC |
+ GFXMMU_CR_OB);
+ hgfxmmu->Instance->CR |= (hgfxmmu->Init.BlocksPerLine);
+ if(hgfxmmu->Init.CachePrefetch.Activation == ENABLE)
+ {
+ assert_param(IS_GFXMMU_CACHE_LOCK(hgfxmmu->Init.CachePrefetch.CacheLock));
+ assert_param(IS_GFXMMU_PREFETCH(hgfxmmu->Init.CachePrefetch.Prefetch));
+ assert_param(IS_GFXMMU_OUTTER_BUFFERABILITY(hgfxmmu->Init.CachePrefetch.OutterBufferability));
+ assert_param(IS_GFXMMU_OUTTER_CACHABILITY(hgfxmmu->Init.CachePrefetch.OutterCachability));
+ hgfxmmu->Instance->CR |= (GFXMMU_CR_CE |
+ hgfxmmu->Init.CachePrefetch.CacheLock |
+ hgfxmmu->Init.CachePrefetch.Prefetch |
+ hgfxmmu->Init.CachePrefetch.OutterBufferability |
+ hgfxmmu->Init.CachePrefetch.OutterCachability);
+ if(hgfxmmu->Init.CachePrefetch.CacheLock == GFXMMU_CACHE_LOCK_ENABLE)
+ {
+ assert_param(IS_GFXMMU_CACHE_LOCK_BUFFER(hgfxmmu->Init.CachePrefetch.CacheLockBuffer));
+ assert_param(IS_GFXMMU_CACHE_FORCE(hgfxmmu->Init.CachePrefetch.CacheForce));
+ hgfxmmu->Instance->CR |= (hgfxmmu->Init.CachePrefetch.CacheLockBuffer |
+ hgfxmmu->Init.CachePrefetch.CacheForce);
+ }
+ }
+ if(hgfxmmu->Init.Interrupts.Activation == ENABLE)
+ {
+ assert_param(IS_GFXMMU_INTERRUPTS(hgfxmmu->Init.Interrupts.UsedInterrupts));
+ hgfxmmu->Instance->CR |= hgfxmmu->Init.Interrupts.UsedInterrupts;
+ }
+
+ /* Configure default value on GFXMMU_DVR register */
+ hgfxmmu->Instance->DVR = hgfxmmu->Init.DefaultValue;
+
+ /* Configure physical buffer adresses on GFXMMU_BxCR registers */
+ hgfxmmu->Instance->B0CR = hgfxmmu->Init.Buffers.Buf0Address;
+ hgfxmmu->Instance->B1CR = hgfxmmu->Init.Buffers.Buf1Address;
+ hgfxmmu->Instance->B2CR = hgfxmmu->Init.Buffers.Buf2Address;
+ hgfxmmu->Instance->B3CR = hgfxmmu->Init.Buffers.Buf3Address;
+
+ /* Force invalidate cache if cache is enabled */
+ if(hgfxmmu->Init.CachePrefetch.Activation == ENABLE)
+ {
+ hgfxmmu->Instance->CCR |= GFXMMU_CACHE_FORCE_INVALIDATE;
+ }
+
+ /* Reset GFXMMU error code */
+ hgfxmmu->ErrorCode = GFXMMU_ERROR_NONE;
+
+ /* Set GFXMMU to ready state */
+ hgfxmmu->State = HAL_GFXMMU_STATE_READY;
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief De-initialize the GFXMMU.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_DeInit(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ /* Check GFXMMU handle */
+ if(hgfxmmu == NULL)
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+
+ /* Disable all interrupts on GFXMMU_CR register */
+ hgfxmmu->Instance->CR &= ~(GFXMMU_CR_B0OIE | GFXMMU_CR_B1OIE | GFXMMU_CR_B2OIE | GFXMMU_CR_B3OIE |
+ GFXMMU_CR_AMEIE);
+
+ /* Call GFXMMU MSP de-init function */
+#if (USE_HAL_GFXMMU_REGISTER_CALLBACKS == 1)
+ if(hgfxmmu->MspDeInitCallback == NULL)
+ {
+ hgfxmmu->MspDeInitCallback = HAL_GFXMMU_MspDeInit;
+ }
+ hgfxmmu->MspDeInitCallback(hgfxmmu);
+#else
+ HAL_GFXMMU_MspDeInit(hgfxmmu);
+#endif
+
+ /* Set GFXMMU to reset state */
+ hgfxmmu->State = HAL_GFXMMU_STATE_RESET;
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief Initialize the GFXMMU MSP.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval None.
+ */
+__weak void HAL_GFXMMU_MspInit(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hgfxmmu);
+
+ /* NOTE : This function should not be modified, when the function is needed,
+ the HAL_GFXMMU_MspInit could be implemented in the user file.
+ */
+}
+
+/**
+ * @brief De-initialize the GFXMMU MSP.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval None.
+ */
+__weak void HAL_GFXMMU_MspDeInit(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hgfxmmu);
+
+ /* NOTE : This function should not be modified, when the function is needed,
+ the HAL_GFXMMU_MspDeInit could be implemented in the user file.
+ */
+}
+
+#if (USE_HAL_GFXMMU_REGISTER_CALLBACKS == 1)
+/**
+ * @brief Register a user GFXMMU callback
+ * to be used instead of the weak predefined callback.
+ * @param hgfxmmu GFXMMU handle.
+ * @param CallbackID ID of the callback to be registered.
+ * This parameter can be one of the following values:
+ * @arg @ref HAL_GFXMMU_ERROR_CB_ID error callback ID.
+ * @arg @ref HAL_GFXMMU_MSPINIT_CB_ID MSP init callback ID.
+ * @arg @ref HAL_GFXMMU_MSPDEINIT_CB_ID MSP de-init callback ID.
+ * @param pCallback pointer to the callback function.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_RegisterCallback(GFXMMU_HandleTypeDef *hgfxmmu,
+ HAL_GFXMMU_CallbackIDTypeDef CallbackID,
+ pGFXMMU_CallbackTypeDef pCallback)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ if(pCallback == NULL)
+ {
+ /* update the error code */
+ hgfxmmu->ErrorCode |= GFXMMU_ERROR_INVALID_CALLBACK;
+ /* update return status */
+ status = HAL_ERROR;
+ }
+ else
+ {
+ if(HAL_GFXMMU_STATE_READY == hgfxmmu->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_GFXMMU_ERROR_CB_ID :
+ hgfxmmu->ErrorCallback = pCallback;
+ break;
+ case HAL_GFXMMU_MSPINIT_CB_ID :
+ hgfxmmu->MspInitCallback = pCallback;
+ break;
+ case HAL_GFXMMU_MSPDEINIT_CB_ID :
+ hgfxmmu->MspDeInitCallback = pCallback;
+ break;
+ default :
+ /* update the error code */
+ hgfxmmu->ErrorCode |= GFXMMU_ERROR_INVALID_CALLBACK;
+ /* update return status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else if(HAL_GFXMMU_STATE_RESET == hgfxmmu->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_GFXMMU_MSPINIT_CB_ID :
+ hgfxmmu->MspInitCallback = pCallback;
+ break;
+ case HAL_GFXMMU_MSPDEINIT_CB_ID :
+ hgfxmmu->MspDeInitCallback = pCallback;
+ break;
+ default :
+ /* update the error code */
+ hgfxmmu->ErrorCode |= GFXMMU_ERROR_INVALID_CALLBACK;
+ /* update return status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else
+ {
+ /* update the error code */
+ hgfxmmu->ErrorCode |= GFXMMU_ERROR_INVALID_CALLBACK;
+ /* update return status */
+ status = HAL_ERROR;
+ }
+ }
+ return status;
+}
+
+/**
+ * @brief Unregister a user GFXMMU callback.
+ * GFXMMU callback is redirected to the weak predefined callback.
+ * @param hgfxmmu GFXMMU handle.
+ * @param CallbackID ID of the callback to be unregistered.
+ * This parameter can be one of the following values:
+ * @arg @ref HAL_GFXMMU_ERROR_CB_ID error callback ID.
+ * @arg @ref HAL_GFXMMU_MSPINIT_CB_ID MSP init callback ID.
+ * @arg @ref HAL_GFXMMU_MSPDEINIT_CB_ID MSP de-init callback ID.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_UnRegisterCallback(GFXMMU_HandleTypeDef *hgfxmmu,
+ HAL_GFXMMU_CallbackIDTypeDef CallbackID)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ if(HAL_GFXMMU_STATE_READY == hgfxmmu->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_GFXMMU_ERROR_CB_ID :
+ hgfxmmu->ErrorCallback = HAL_GFXMMU_ErrorCallback;
+ break;
+ case HAL_GFXMMU_MSPINIT_CB_ID :
+ hgfxmmu->MspInitCallback = HAL_GFXMMU_MspInit;
+ break;
+ case HAL_GFXMMU_MSPDEINIT_CB_ID :
+ hgfxmmu->MspDeInitCallback = HAL_GFXMMU_MspDeInit;
+ break;
+ default :
+ /* update the error code */
+ hgfxmmu->ErrorCode |= GFXMMU_ERROR_INVALID_CALLBACK;
+ /* update return status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else if(HAL_GFXMMU_STATE_RESET == hgfxmmu->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_GFXMMU_MSPINIT_CB_ID :
+ hgfxmmu->MspInitCallback = HAL_GFXMMU_MspInit;
+ break;
+ case HAL_GFXMMU_MSPDEINIT_CB_ID :
+ hgfxmmu->MspDeInitCallback = HAL_GFXMMU_MspDeInit;
+ break;
+ default :
+ /* update the error code */
+ hgfxmmu->ErrorCode |= GFXMMU_ERROR_INVALID_CALLBACK;
+ /* update return status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else
+ {
+ /* update the error code */
+ hgfxmmu->ErrorCode |= GFXMMU_ERROR_INVALID_CALLBACK;
+ /* update return status */
+ status = HAL_ERROR;
+ }
+ return status;
+}
+#endif /* USE_HAL_GFXMMU_REGISTER_CALLBACKS */
+
+/**
+ * @}
+ */
+
+/** @defgroup GFXMMU_Exported_Functions_Group2 Operations functions
+ * @brief GFXMMU operation functions
+ *
+@verbatim
+ ==============================================================================
+ ##### Operation functions #####
+ ==============================================================================
+ [..] This section provides functions allowing to:
+ (+) Configure LUT.
+ (+) Force flush and/or invalidate of cache.
+ (+) Modify physical buffer adresses.
+ (+) Modify cache and pre-fetch parameters.
+ (+) Manage error.
+@endverbatim
+ * @{
+ */
+
+/**
+ * @brief This function allows to copy LUT from flash to look up RAM.
+ * @param hgfxmmu GFXMMU handle.
+ * @param FirstLine First line enabled on LUT.
+ * This parameter must be a number between Min_Data = 0 and Max_Data = 1023.
+ * @param LinesNumber Number of lines enabled on LUT.
+ * This parameter must be a number between Min_Data = 1 and Max_Data = 1024.
+ * @param Address Start address of LUT in flash.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_ConfigLut(GFXMMU_HandleTypeDef *hgfxmmu,
+ uint32_t FirstLine,
+ uint32_t LinesNumber,
+ uint32_t Address)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+ assert_param(IS_GFXMMU_LUT_LINE(FirstLine));
+ assert_param(IS_GFXMMU_LUT_LINES_NUMBER(LinesNumber));
+
+ /* Check GFXMMU state and coherent parameters */
+ if((hgfxmmu->State != HAL_GFXMMU_STATE_READY) || ((FirstLine + LinesNumber) > 1024U))
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ uint32_t current_address, current_line, lutxl_address, lutxh_address;
+
+ /* Initialize local variables */
+ current_address = Address;
+ current_line = 0U;
+ lutxl_address = (uint32_t) &(hgfxmmu->Instance->LUT[2U * FirstLine]);
+ lutxh_address = (uint32_t) &(hgfxmmu->Instance->LUT[(2U * FirstLine) + 1U]);
+
+ /* Copy LUT from flash to look up RAM */
+ while(current_line < LinesNumber)
+ {
+ *((uint32_t *)lutxl_address) = *((uint32_t *)current_address);
+ current_address += 4U;
+ *((uint32_t *)lutxh_address) = *((uint32_t *)current_address);
+ current_address += 4U;
+ lutxl_address += 8U;
+ lutxh_address += 8U;
+ current_line++;
+ }
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief This function allows to disable a range of LUT lines.
+ * @param hgfxmmu GFXMMU handle.
+ * @param FirstLine First line to disable on LUT.
+ * This parameter must be a number between Min_Data = 0 and Max_Data = 1023.
+ * @param LinesNumber Number of lines to disable on LUT.
+ * This parameter must be a number between Min_Data = 1 and Max_Data = 1024.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_DisableLutLines(GFXMMU_HandleTypeDef *hgfxmmu,
+ uint32_t FirstLine,
+ uint32_t LinesNumber)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+ assert_param(IS_GFXMMU_LUT_LINE(FirstLine));
+ assert_param(IS_GFXMMU_LUT_LINES_NUMBER(LinesNumber));
+
+ /* Check GFXMMU state and coherent parameters */
+ if((hgfxmmu->State != HAL_GFXMMU_STATE_READY) || ((FirstLine + LinesNumber) > 1024U))
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ uint32_t current_line, lutxl_address, lutxh_address;
+
+ /* Initialize local variables */
+ current_line = 0U;
+ lutxl_address = (uint32_t) &(hgfxmmu->Instance->LUT[2U * FirstLine]);
+ lutxh_address = (uint32_t) &(hgfxmmu->Instance->LUT[(2U * FirstLine) + 1U]);
+
+ /* Disable LUT lines */
+ while(current_line < LinesNumber)
+ {
+ *((uint32_t *)lutxl_address) = 0U;
+ *((uint32_t *)lutxh_address) = 0U;
+ lutxl_address += 8U;
+ lutxh_address += 8U;
+ current_line++;
+ }
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief This function allows to configure one line of LUT.
+ * @param hgfxmmu GFXMMU handle.
+ * @param lutLine LUT line parameters.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_ConfigLutLine(GFXMMU_HandleTypeDef *hgfxmmu, GFXMMU_LutLineTypeDef *lutLine)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+ assert_param(IS_GFXMMU_LUT_LINE(lutLine->LineNumber));
+ assert_param(IS_GFXMMU_LUT_LINE_STATUS(lutLine->LineStatus));
+ assert_param(IS_GFXMMU_LUT_BLOCK(lutLine->FirstVisibleBlock));
+ assert_param(IS_GFXMMU_LUT_BLOCK(lutLine->LastVisibleBlock));
+ assert_param(IS_GFXMMU_LUT_LINE_OFFSET(lutLine->LineOffset));
+
+ /* Check GFXMMU state */
+ if(hgfxmmu->State != HAL_GFXMMU_STATE_READY)
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ uint32_t lutxl_address, lutxh_address;
+
+ /* Initialize local variables */
+ lutxl_address = (uint32_t) &(hgfxmmu->Instance->LUT[2U * lutLine->LineNumber]);
+ lutxh_address = (uint32_t) &(hgfxmmu->Instance->LUT[(2U * lutLine->LineNumber) + 1U]);
+
+ /* Configure LUT line */
+ if(lutLine->LineStatus == GFXMMU_LUT_LINE_ENABLE)
+ {
+ /* Enable and configure LUT line */
+ *((uint32_t *)lutxl_address) = (lutLine->LineStatus |
+ (lutLine->FirstVisibleBlock << GFXMMU_LUTXL_FVB_OFFSET) |
+ (lutLine->LastVisibleBlock << GFXMMU_LUTXL_LVB_OFFSET));
+ *((uint32_t *)lutxh_address) = (uint32_t) lutLine->LineOffset;
+ }
+ else
+ {
+ /* Disable LUT line */
+ *((uint32_t *)lutxl_address) = 0U;
+ *((uint32_t *)lutxh_address) = 0U;
+ }
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief This function allows to force flush and/or invalidate of cache.
+ * @param hgfxmmu GFXMMU handle.
+ * @param ForceParam Force cache parameter.
+ * This parameter can be a values combination of @ref GFXMMU_CacheForceParam.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_ConfigForceCache(GFXMMU_HandleTypeDef *hgfxmmu, uint32_t ForceParam)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+ assert_param(IS_GFXMMU_CACHE_FORCE_ACTION(ForceParam));
+
+ /* Check GFXMMU state and cache status */
+ if(((hgfxmmu->Instance->CR & GFXMMU_CR_CE) != GFXMMU_CR_CE) || (hgfxmmu->State != HAL_GFXMMU_STATE_READY))
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ /* Force flush and/or invalidate cache on GFXMMU_CCR register */
+ hgfxmmu->Instance->CCR |= ForceParam;
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief This function allows to modify physical buffer addresses.
+ * @param hgfxmmu GFXMMU handle.
+ * @param Buffers Buffers parameters.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_ModifyBuffers(GFXMMU_HandleTypeDef *hgfxmmu, GFXMMU_BuffersTypeDef *Buffers)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(Buffers->Buf0Address));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(Buffers->Buf1Address));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(Buffers->Buf2Address));
+ assert_param(IS_GFXMMU_BUFFER_ADDRESS(Buffers->Buf3Address));
+
+ /* Check GFXMMU state */
+ if(hgfxmmu->State != HAL_GFXMMU_STATE_READY)
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ /* Modify physical buffer adresses on GFXMMU_BxCR registers */
+ hgfxmmu->Instance->B0CR = Buffers->Buf0Address;
+ hgfxmmu->Instance->B1CR = Buffers->Buf1Address;
+ hgfxmmu->Instance->B2CR = Buffers->Buf2Address;
+ hgfxmmu->Instance->B3CR = Buffers->Buf3Address;
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief This function allows to modify cache and pre-fetch parameters.
+ * @param hgfxmmu GFXMMU handle.
+ * @param CachePrefetch Cache and pre-fetch parameters.
+ * @retval HAL status.
+ */
+HAL_StatusTypeDef HAL_GFXMMU_ModifyCachePrefetch(GFXMMU_HandleTypeDef *hgfxmmu,
+ GFXMMU_CachePrefetchTypeDef *CachePrefetch)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+ assert_param(IS_FUNCTIONAL_STATE(CachePrefetch->Activation));
+
+ /* Check parameters */
+ assert_param(IS_GFXMMU_ALL_INSTANCE(hgfxmmu->Instance));
+
+ /* Check GFXMMU state */
+ if(hgfxmmu->State != HAL_GFXMMU_STATE_READY)
+ {
+ status = HAL_ERROR;
+ }
+ else
+ {
+ /* Modify cache and pre-fetch parameters on GFXMMU_CR register */
+ hgfxmmu->Instance->CR &= ~(GFXMMU_CR_CE | GFXMMU_CR_CL | GFXMMU_CR_CLB | GFXMMU_CR_FC |
+ GFXMMU_CR_PD | GFXMMU_CR_OC | GFXMMU_CR_OB);
+ if(CachePrefetch->Activation == ENABLE)
+ {
+ assert_param(IS_GFXMMU_CACHE_LOCK(CachePrefetch->CacheLock));
+ assert_param(IS_GFXMMU_PREFETCH(CachePrefetch->Prefetch));
+ assert_param(IS_GFXMMU_OUTTER_BUFFERABILITY(CachePrefetch->OutterBufferability));
+ assert_param(IS_GFXMMU_OUTTER_CACHABILITY(CachePrefetch->OutterCachability));
+ hgfxmmu->Instance->CR |= (GFXMMU_CR_CE |
+ CachePrefetch->CacheLock |
+ CachePrefetch->Prefetch |
+ CachePrefetch->OutterBufferability |
+ CachePrefetch->OutterCachability);
+ if(CachePrefetch->CacheLock == GFXMMU_CACHE_LOCK_ENABLE)
+ {
+ assert_param(IS_GFXMMU_CACHE_LOCK_BUFFER(CachePrefetch->CacheLockBuffer));
+ assert_param(IS_GFXMMU_CACHE_FORCE(CachePrefetch->CacheForce));
+ hgfxmmu->Instance->CR |= (CachePrefetch->CacheLockBuffer |
+ CachePrefetch->CacheForce);
+ }
+ }
+ }
+ /* Return function status */
+ return status;
+}
+
+/**
+ * @brief This function handles the GFXMMU interrupts.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval None.
+ */
+void HAL_GFXMMU_IRQHandler(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ uint32_t flags, interrupts, error;
+
+ /* Read current flags and interrupts and determine which error occurs */
+ flags = hgfxmmu->Instance->SR;
+ interrupts = (hgfxmmu->Instance->CR & GFXMMU_CR_ITS_MASK);
+ error = (flags & interrupts);
+
+ if(error != 0U)
+ {
+ /* Clear flags on GFXMMU_FCR register */
+ hgfxmmu->Instance->FCR = error;
+
+ /* Update GFXMMU error code */
+ hgfxmmu->ErrorCode |= error;
+
+ /* Call GFXMMU error callback */
+#if (USE_HAL_GFXMMU_REGISTER_CALLBACKS == 1)
+ hgfxmmu->ErrorCallback(hgfxmmu);
+#else
+ HAL_GFXMMU_ErrorCallback(hgfxmmu);
+#endif
+ }
+}
+
+/**
+ * @brief Error callback.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval None.
+ */
+__weak void HAL_GFXMMU_ErrorCallback(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hgfxmmu);
+
+ /* NOTE : This function should not be modified, when the callback is needed,
+ the HAL_GFXMMU_ErrorCallback could be implemented in the user file.
+ */
+}
+
+/**
+ * @}
+ */
+
+/** @defgroup GFXMMU_Exported_Functions_Group3 State functions
+ * @brief GFXMMU state functions
+ *
+@verbatim
+ ==============================================================================
+ ##### State functions #####
+ ==============================================================================
+ [..] This section provides functions allowing to:
+ (+) Get GFXMMU handle state.
+ (+) Get GFXMMU error code.
+@endverbatim
+ * @{
+ */
+
+/**
+ * @brief This function allows to get the current GFXMMU handle state.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval GFXMMU state.
+ */
+HAL_GFXMMU_StateTypeDef HAL_GFXMMU_GetState(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ /* Return GFXMMU handle state */
+ return hgfxmmu->State;
+}
+
+/**
+ * @brief This function allows to get the current GFXMMU error code.
+ * @param hgfxmmu GFXMMU handle.
+ * @retval GFXMMU error code.
+ */
+uint32_t HAL_GFXMMU_GetError(GFXMMU_HandleTypeDef *hgfxmmu)
+{
+ uint32_t error_code;
+
+ /* Enter in critical section */
+ __disable_irq();
+
+ /* Store and reset GFXMMU error code */
+ error_code = hgfxmmu->ErrorCode;
+ hgfxmmu->ErrorCode = GFXMMU_ERROR_NONE;
+
+ /* Exit from critical section */
+ __enable_irq();
+
+ /* Return GFXMMU error code */
+ return error_code;
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+/* End of exported functions -------------------------------------------------*/
+/* Private functions ---------------------------------------------------------*/
+/* End of private functions --------------------------------------------------*/
+
+/**
+ * @}
+ */
+#endif /* GFXMMU */
+#endif /* HAL_GFXMMU_MODULE_ENABLED */
+/**
+ * @}
+ */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|