893 lines
30 KiB
C
893 lines
30 KiB
C
/**
|
|
******************************************************************************
|
|
* @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 addresses.
|
|
* + Modify cache and pre-fetch parameters.
|
|
* + Error management.
|
|
*
|
|
******************************************************************************
|
|
* @attention
|
|
*
|
|
* Copyright (c) 2017 STMicroelectronics.
|
|
* All rights reserved.
|
|
*
|
|
* This software is licensed under terms that can be found in the LICENSE file
|
|
* in the root directory of this software component.
|
|
* If no LICENSE file comes with this software, it is provided AS-IS.
|
|
*
|
|
******************************************************************************
|
|
@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 addresses ***
|
|
=======================================
|
|
[..]
|
|
(#) 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
|
|
******************************************************************************
|
|
*/
|
|
|
|
/* 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 addresses 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 addresses.
|
|
(+) 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 addresses 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 */
|
|
/**
|
|
* @}
|
|
*/
|
|
|