diff options
| author | joshua <joshua@joshuayun.com> | 2023-12-30 23:54:31 -0500 |
|---|---|---|
| committer | joshua <joshua@joshuayun.com> | 2023-12-30 23:54:31 -0500 |
| commit | 86608c6770cf08c138a2bdab5855072f64be09ef (patch) | |
| tree | 494a61b3ef37e76f9235a0d10f5c93d97290a35f /Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pssi.c | |
| download | sdr-software-master.tar.gz | |
Diffstat (limited to 'Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pssi.c')
| -rw-r--r-- | Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pssi.c | 1799 |
1 files changed, 1799 insertions, 0 deletions
diff --git a/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pssi.c b/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pssi.c new file mode 100644 index 0000000..345a770 --- /dev/null +++ b/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pssi.c @@ -0,0 +1,1799 @@ +/**
+ ******************************************************************************
+ * @file stm32h7xx_hal_pssi.c
+ * @author MCD Application Team
+ * @brief PSSI HAL module driver.
+ * This file provides firmware functions to manage the following
+ * functionalities of the Parallel Synchronous Slave Interface (PSSI) peripheral:
+ * + Initialization and de-initialization functions
+ * + IO operation functions
+ * + Peripheral State and Errors functions
+ *
+ ******************************************************************************
+ * @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 #####
+ ==============================================================================
+ [..]
+ The PSSI HAL driver can be used as follows:
+
+ (#) Declare a PSSI_HandleTypeDef handle structure, for example:
+ PSSI_HandleTypeDef hpssi;
+
+ (#) Initialize the PSSI low level resources by implementing the @ref HAL_PSSI_MspInit() API:
+ (##) Enable the PSSIx interface clock
+ (##) PSSI pins configuration
+ (+++) Enable the clock for the PSSI GPIOs
+ (+++) Configure PSSI pins as alternate function open-drain
+ (##) NVIC configuration if you need to use interrupt process
+ (+++) Configure the PSSIx interrupt priority
+ (+++) Enable the NVIC PSSI IRQ Channel
+ (##) DMA Configuration if you need to use DMA process
+ (+++) Declare DMA_HandleTypeDef handles structure for the transmit and receive
+ (+++) Enable the DMAx interface clock
+ (+++) Configure the DMA handle parameters
+ (+++) Configure the DMA Tx and Rx
+ (+++) Associate the initialized DMA handle to the hpssi DMA Tx and Rx handle
+ (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on
+ the DMA Tx and Rx
+
+ (#) Configure the Communication Bus Width, Control Signals, Input Polarity and Output Polarity
+ in the hpssi Init structure.
+
+ (#) Initialize the PSSI registers by calling the @ref HAL_PSSI_Init(), configure also the low level Hardware
+ (GPIO, CLOCK, NVIC...etc) by calling the customized @ref HAL_PSSI_MspInit(&hpssi) API.
+
+
+ (#) For PSSI IO operations, two operation modes are available within this driver :
+
+ *** Polling mode IO operation ***
+ =================================
+ [..]
+ (+) Transmit an amount of data by byte in blocking mode using @ref HAL_PSSI_Transmit()
+ (+) Receive an amount of data by byte in blocking mode using @ref HAL_PSSI_Receive()
+
+ *** DMA mode IO operation ***
+ ==============================
+ [..]
+ (+) Transmit an amount of data in non-blocking mode (DMA) using
+ @ref HAL_PSSI_Transmit_DMA()
+ (+) At transmission end of transfer, @ref HAL_PSSI_TxCpltCallback() is executed and user can
+ add his own code by customization of function pointer @ref HAL_PSSI_TxCpltCallback()
+ (+) Receive an amount of data in non-blocking mode (DMA) using
+ @ref HAL_PSSI_Receive_DMA()
+ (+) At reception end of transfer, @ref HAL_PSSI_RxCpltCallback() is executed and user can
+ add his own code by customization of function pointer @ref HAL_PSSI_RxCpltCallback()
+ (+) In case of transfer Error, @ref HAL_PSSI_ErrorCallback() function is executed and user can
+ add his own code by customization of function pointer @ref HAL_PSSI_ErrorCallback()
+ (+) Abort a PSSI process communication with Interrupt using @ref HAL_PSSI_Abort_IT()
+ (+) End of abort process, @ref HAL_PSSI_AbortCpltCallback() is executed and user can
+ add his own code by customization of function pointer @ref HAL_PSSI_AbortCpltCallback()
+
+ *** PSSI HAL driver macros list ***
+ ==================================
+ [..]
+ Below the list of most used macros in PSSI HAL driver.
+
+ (+) @ref HAL_PSSI_ENABLE : Enable the PSSI peripheral
+ (+) @ref HAL_PSSI_DISABLE : Disable the PSSI peripheral
+ (+) @ref HAL_PSSI_GET_FLAG : Check whether the specified PSSI flag is set or not
+ (+) @ref HAL_PSSI_CLEAR_FLAG : Clear the specified PSSI pending flag
+ (+) @ref HAL_PSSI_ENABLE_IT : Enable the specified PSSI interrupt
+ (+) @ref HAL_PSSI_DISABLE_IT : Disable the specified PSSI interrupt
+
+ *** Callback registration ***
+ =============================================
+ Use Functions @ref HAL_PSSI_RegisterCallback() or @ref HAL_PSSI_RegisterAddrCallback()
+ to register an interrupt callback.
+
+ Function @ref HAL_PSSI_RegisterCallback() allows to register following callbacks:
+ (+) TxCpltCallback : callback for transmission end of transfer.
+ (+) RxCpltCallback : callback for reception end of transfer.
+ (+) ErrorCallback : callback for error detection.
+ (+) AbortCpltCallback : callback for abort completion process.
+ (+) MspInitCallback : callback for Msp Init.
+ (+) MspDeInitCallback : callback for Msp DeInit.
+ This function takes as parameters the HAL peripheral handle, the Callback ID
+ and a pointer to the user callback function.
+
+
+ Use function @ref HAL_PSSI_UnRegisterCallback to reset a callback to the default
+ weak function.
+ @ref HAL_PSSI_UnRegisterCallback takes as parameters the HAL peripheral handle,
+ and the Callback ID.
+ This function allows to reset following callbacks:
+ (+) TxCpltCallback : callback for transmission end of transfer.
+ (+) RxCpltCallback : callback for reception end of transfer.
+ (+) ErrorCallback : callback for error detection.
+ (+) AbortCpltCallback : callback for abort completion process.
+ (+) MspInitCallback : callback for Msp Init.
+ (+) MspDeInitCallback : callback for Msp DeInit.
+
+
+ By default, after the @ref HAL_PSSI_Init() and when the state is @ref HAL_PSSI_STATE_RESET
+ all callbacks are set to the corresponding weak functions:
+ examples @ref HAL_PSSI_TxCpltCallback(), @ref HAL_PSSI_RxCpltCallback().
+ Exception done for MspInit and MspDeInit functions that are
+ reset to the legacy weak functions in the @ref HAL_PSSI_Init()/ @ref HAL_PSSI_DeInit() only when
+ these callbacks are null (not registered beforehand).
+ If MspInit or MspDeInit are not null, the @ref HAL_PSSI_Init()/ @ref HAL_PSSI_DeInit()
+ keep and use the user MspInit/MspDeInit callbacks (registered beforehand) whatever the state.
+
+ Callbacks can be registered/unregistered in @ref HAL_PSSI_STATE_READY state only.
+ Exception done MspInit/MspDeInit functions that can be registered/unregistered
+ in @ref HAL_PSSI_STATE_READY or @ref HAL_PSSI_STATE_RESET state,
+ thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit.
+ Then, the user first registers the MspInit/MspDeInit user callbacks
+ using @ref HAL_PSSI_RegisterCallback() before calling @ref HAL_PSSI_DeInit()
+ or @ref HAL_PSSI_Init() function.
+
+
+ [..]
+ (@) You can refer to the PSSI HAL driver header file for more useful macros
+
+ @endverbatim
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32h7xx_hal.h"
+
+/** @addtogroup STM32H7xx_HAL_Driver
+ * @{
+ */
+
+/** @defgroup PSSI PSSI
+ * @brief PSSI HAL module driver
+ * @{
+ */
+
+#ifdef HAL_PSSI_MODULE_ENABLED
+#if defined(PSSI)
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+
+/** @defgroup PSSI_Private_Define PSSI Private Define
+ * @{
+ */
+
+
+
+/**
+ * @}
+ */
+
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
+
+/** @defgroup PSSI_Private_Functions PSSI Private Functions
+ * @{
+ */
+/* Private functions to handle DMA transfer */
+void PSSI_DMATransmitCplt(DMA_HandleTypeDef *hdma);
+void PSSI_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
+void PSSI_DMAError(DMA_HandleTypeDef *hdma);
+void PSSI_DMAAbort(DMA_HandleTypeDef *hdma);
+
+
+/* Private functions to handle IT transfer */
+static void PSSI_Error(PSSI_HandleTypeDef *hpssi, uint32_t ErrorCode);
+
+
+/* Private functions for PSSI transfer IRQ handler */
+
+
+/* Private functions to handle flags during polling transfer */
+static HAL_StatusTypeDef PSSI_WaitOnStatusUntilTimeout(PSSI_HandleTypeDef *hpssi, uint32_t Flag, FlagStatus Status,
+ uint32_t Timeout, uint32_t Tickstart);
+
+/* Private functions to centralize the enable/disable of Interrupts */
+
+
+/**
+ * @}
+ */
+
+/* Exported functions --------------------------------------------------------*/
+
+/** @defgroup PSSI_Exported_Functions PSSI Exported Functions
+ * @{
+ */
+
+/** @defgroup PSSI_Exported_Functions_Group1 Initialization and de-initialization functions
+ * @brief Initialization and Configuration functions
+ *
+@verbatim
+ ===============================================================================
+ ##### Initialization and de-initialization functions #####
+ ===============================================================================
+ [..] This subsection provides a set of functions allowing to initialize and
+ deinitialize the PSSIx peripheral:
+
+ (+) User must implement HAL_PSSI_MspInit() function in which he configures
+ all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC ).
+
+ (+) Call the function HAL_PSSI_Init() to configure the selected device with
+ the selected configuration:
+ (++) Data Width
+ (++) Control Signals
+ (++) Input Clock polarity
+ (++) Output Clock polarity
+
+ (+) Call the function HAL_PSSI_DeInit() to restore the default configuration
+ of the selected PSSIx peripheral.
+
+@endverbatim
+ * @{
+ */
+
+/**
+ * @brief Initializes the PSSI according to the specified parameters
+ * in the PSSI_InitTypeDef and initialize the associated handle.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_Init(PSSI_HandleTypeDef *hpssi)
+{
+ /* Check the PSSI handle allocation */
+ if (hpssi == NULL)
+ {
+ return HAL_ERROR;
+ }
+
+ /* Check the parameters */
+ assert_param(IS_PSSI_ALL_INSTANCE(hpssi->Instance));
+ assert_param(IS_PSSI_CONTROL_SIGNAL(hpssi->Init.ControlSignal));
+ assert_param(IS_PSSI_BUSWIDTH(hpssi->Init.BusWidth));
+ assert_param(IS_PSSI_CLOCK_POLARITY(hpssi->Init.ClockPolarity));
+ assert_param(IS_PSSI_DE_POLARITY(hpssi->Init.DataEnablePolarity));
+ assert_param(IS_PSSI_RDY_POLARITY(hpssi->Init.ReadyPolarity));
+
+ if (hpssi->State == HAL_PSSI_STATE_RESET)
+ {
+ /* Allocate lock resource and initialize it */
+ hpssi->Lock = HAL_UNLOCKED;
+
+ /* Init the PSSI Callback settings */
+ hpssi->TxCpltCallback = HAL_PSSI_TxCpltCallback; /* Legacy weak TxCpltCallback */
+ hpssi->RxCpltCallback = HAL_PSSI_RxCpltCallback; /* Legacy weak RxCpltCallback */
+ hpssi->ErrorCallback = HAL_PSSI_ErrorCallback; /* Legacy weak ErrorCallback */
+ hpssi->AbortCpltCallback = HAL_PSSI_AbortCpltCallback; /* Legacy weak AbortCpltCallback */
+
+ if (hpssi->MspInitCallback == NULL)
+ {
+ hpssi->MspInitCallback = HAL_PSSI_MspInit; /* Legacy weak MspInit */
+ }
+
+ /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
+ hpssi->MspInitCallback(hpssi);
+
+ }
+
+ hpssi->State = HAL_PSSI_STATE_BUSY;
+
+ /* Disable the selected PSSI peripheral */
+ HAL_PSSI_DISABLE(hpssi);
+
+ /*---------------------------- PSSIx CR Configuration ----------------------*/
+ /* Configure PSSIx: Control Signal and Bus Width*/
+
+ MODIFY_REG(hpssi->Instance->CR, PSSI_CR_DERDYCFG | PSSI_CR_EDM | PSSI_CR_DEPOL | PSSI_CR_RDYPOL,
+ hpssi->Init.ControlSignal | hpssi->Init.DataEnablePolarity |
+ hpssi->Init.ReadyPolarity | hpssi->Init.BusWidth);
+
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NONE;
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ return HAL_OK;
+}
+
+/**
+ * @brief DeInitialize the PSSI peripheral.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_DeInit(PSSI_HandleTypeDef *hpssi)
+{
+ /* Check the PSSI handle allocation */
+ if (hpssi == NULL)
+ {
+ return HAL_ERROR;
+ }
+
+ /* Check the parameters */
+ assert_param(IS_PSSI_ALL_INSTANCE(hpssi->Instance));
+
+ hpssi->State = HAL_PSSI_STATE_BUSY;
+
+ /* Disable the PSSI Peripheral Clock */
+ HAL_PSSI_DISABLE(hpssi);
+
+ if (hpssi->MspDeInitCallback == NULL)
+ {
+ hpssi->MspDeInitCallback = HAL_PSSI_MspDeInit; /* Legacy weak MspDeInit */
+ }
+
+ /* DeInit the low level hardware: GPIO, CLOCK, NVIC */
+ hpssi->MspDeInitCallback(hpssi);
+
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NONE;
+ hpssi->State = HAL_PSSI_STATE_RESET;
+
+ /* Release Lock */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_OK;
+}
+
+/**
+ * @brief Initialize the PSSI MSP.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval None
+ */
+__weak void HAL_PSSI_MspInit(PSSI_HandleTypeDef *hpssi)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hpssi);
+
+ /* NOTE : This function should not be modified, when the callback is needed,
+ the HAL_PSSI_MspInit can be implemented in the user file
+ */
+}
+
+/**
+ * @brief DeInitialize the PSSI MSP.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval None
+ */
+__weak void HAL_PSSI_MspDeInit(PSSI_HandleTypeDef *hpssi)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hpssi);
+
+ /* NOTE : This function should not be modified, when the callback is needed,
+ the HAL_PSSI_MspDeInit can be implemented in the user file
+ */
+}
+
+/**
+ * @brief Register a User PSSI Callback
+ * To be used instead of the weak predefined callback
+ * @note The HAL_PSSI_RegisterCallback() may be called before HAL_PSSI_Init() in
+ * HAL_PSSI_STATE_RESET to register callbacks for HAL_PSSI_MSPINIT_CB_ID
+ * and HAL_PSSI_MSPDEINIT_CB_ID.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @param CallbackID ID of the callback to be registered
+ * This parameter can be one of the following values:
+ * @arg @ref HAL_PSSI_TX_COMPLETE_CB_ID Tx Transfer completed callback ID
+ * @arg @ref HAL_PSSI_RX_COMPLETE_CB_ID Rx Transfer completed callback ID
+ * @arg @ref HAL_PSSI_ERROR_CB_ID Error callback ID
+ * @arg @ref HAL_PSSI_ABORT_CB_ID Abort callback ID
+ * @arg @ref HAL_PSSI_MSPINIT_CB_ID MspInit callback ID
+ * @arg @ref HAL_PSSI_MSPDEINIT_CB_ID MspDeInit callback ID
+ * @param pCallback pointer to the Callback function
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_RegisterCallback(PSSI_HandleTypeDef *hpssi, HAL_PSSI_CallbackIDTypeDef CallbackID,
+ pPSSI_CallbackTypeDef pCallback)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ if (pCallback == NULL)
+ {
+ /* Update the error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_INVALID_CALLBACK;
+
+ return HAL_ERROR;
+ }
+
+ if (HAL_PSSI_STATE_READY == hpssi->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_PSSI_TX_COMPLETE_CB_ID :
+ hpssi->TxCpltCallback = pCallback;
+ break;
+
+ case HAL_PSSI_RX_COMPLETE_CB_ID :
+ hpssi->RxCpltCallback = pCallback;
+ break;
+
+ case HAL_PSSI_ERROR_CB_ID :
+ hpssi->ErrorCallback = pCallback;
+ break;
+
+ case HAL_PSSI_ABORT_CB_ID :
+ hpssi->AbortCpltCallback = pCallback;
+ break;
+
+ case HAL_PSSI_MSPINIT_CB_ID :
+ hpssi->MspInitCallback = pCallback;
+ break;
+
+ case HAL_PSSI_MSPDEINIT_CB_ID :
+ hpssi->MspDeInitCallback = pCallback;
+ break;
+
+ default :
+ /* Update the error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_INVALID_CALLBACK;
+
+ /* Return error status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else if (HAL_PSSI_STATE_RESET == hpssi->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_PSSI_MSPINIT_CB_ID :
+ hpssi->MspInitCallback = pCallback;
+ break;
+
+ case HAL_PSSI_MSPDEINIT_CB_ID :
+ hpssi->MspDeInitCallback = pCallback;
+ break;
+
+ default :
+ /* Update the error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_INVALID_CALLBACK;
+
+ /* Return error status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else
+ {
+ /* Update the error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_INVALID_CALLBACK;
+
+ /* Return error status */
+ status = HAL_ERROR;
+ }
+
+ return status;
+}
+
+/**
+ * @brief Unregister an PSSI Callback
+ * PSSI callback is redirected to the weak predefined callback
+ * @note The HAL_PSSI_UnRegisterCallback() may be called before HAL_PSSI_Init() in
+ * HAL_PSSI_STATE_RESET to un-register callbacks for HAL_PSSI_MSPINIT_CB_ID
+ * and HAL_PSSI_MSPDEINIT_CB_ID.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @param CallbackID ID of the callback to be unregistered
+ * This parameter can be one of the following values:
+ * @arg @ref HAL_PSSI_TX_COMPLETE_CB_ID Tx Transfer completed callback ID
+ * @arg @ref HAL_PSSI_RX_COMPLETE_CB_ID Rx Transfer completed callback ID
+ * @arg @ref HAL_PSSI_ERROR_CB_ID Error callback ID
+ * @arg @ref HAL_PSSI_ABORT_CB_ID Abort callback ID
+ * @arg @ref HAL_PSSI_MSPINIT_CB_ID MspInit callback ID
+ * @arg @ref HAL_PSSI_MSPDEINIT_CB_ID MspDeInit callback ID
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_UnRegisterCallback(PSSI_HandleTypeDef *hpssi, HAL_PSSI_CallbackIDTypeDef CallbackID)
+{
+ HAL_StatusTypeDef status = HAL_OK;
+
+ if (HAL_PSSI_STATE_READY == hpssi->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_PSSI_TX_COMPLETE_CB_ID :
+ hpssi->TxCpltCallback = HAL_PSSI_TxCpltCallback; /* Legacy weak TxCpltCallback */
+ break;
+
+ case HAL_PSSI_RX_COMPLETE_CB_ID :
+ hpssi->RxCpltCallback = HAL_PSSI_RxCpltCallback; /* Legacy weak RxCpltCallback */
+ break;
+
+ case HAL_PSSI_ERROR_CB_ID :
+ hpssi->ErrorCallback = HAL_PSSI_ErrorCallback; /* Legacy weak ErrorCallback */
+ break;
+
+ case HAL_PSSI_ABORT_CB_ID :
+ hpssi->AbortCpltCallback = HAL_PSSI_AbortCpltCallback; /* Legacy weak AbortCpltCallback */
+ break;
+
+ case HAL_PSSI_MSPINIT_CB_ID :
+ hpssi->MspInitCallback = HAL_PSSI_MspInit; /* Legacy weak MspInit */
+ break;
+
+ case HAL_PSSI_MSPDEINIT_CB_ID :
+ hpssi->MspDeInitCallback = HAL_PSSI_MspDeInit; /* Legacy weak MspDeInit */
+ break;
+
+ default :
+ /* Update the error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_INVALID_CALLBACK;
+
+ /* Return error status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else if (HAL_PSSI_STATE_RESET == hpssi->State)
+ {
+ switch (CallbackID)
+ {
+ case HAL_PSSI_MSPINIT_CB_ID :
+ hpssi->MspInitCallback = HAL_PSSI_MspInit; /* Legacy weak MspInit */
+ break;
+
+ case HAL_PSSI_MSPDEINIT_CB_ID :
+ hpssi->MspDeInitCallback = HAL_PSSI_MspDeInit; /* Legacy weak MspDeInit */
+ break;
+
+ default :
+ /* Update the error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_INVALID_CALLBACK;
+
+ /* Return error status */
+ status = HAL_ERROR;
+ break;
+ }
+ }
+ else
+ {
+ /* Update the error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_INVALID_CALLBACK;
+
+ /* Return error status */
+ status = HAL_ERROR;
+ }
+
+ return status;
+}
+
+
+/**
+ * @}
+ */
+
+/** @defgroup PSSI_Exported_Functions_Group2 Input and Output operation functions
+ * @brief Data transfers functions
+ *
+@verbatim
+ ===============================================================================
+ ##### IO operation functions #####
+ ===============================================================================
+ [..]
+ This subsection provides a set of functions allowing to manage the PSSI data
+ transfers.
+
+ (#) There are two modes of transfer:
+ (++) Blocking mode : The communication is performed in the polling mode.
+ The status of all data processing is returned by the same function
+ after finishing transfer.
+ (++) No-Blocking mode : The communication is performed using DMA.
+ These functions return the status of the transfer startup.
+ The end of the data processing will be indicated through the
+ dedicated the DMA IRQ .
+
+ (#) Blocking mode functions are :
+ (++) HAL_PSSI_Transmit()
+ (++) HAL_PSSI_Receive()
+
+ (#) No-Blocking mode functions with DMA are :
+ (++) HAL_PSSI_Transmit_DMA()
+ (++) HAL_PSSI_Receive_DMA()
+
+ (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
+ (++) HAL_PSSI_TxCpltCallback()
+ (++) HAL_PSSI_RxCpltCallback()
+ (++) HAL_PSSI_ErrorCallback()
+ (++) HAL_PSSI_AbortCpltCallback()
+
+@endverbatim
+ * @{
+ */
+
+/**
+ * @brief Transmits in master mode an amount of data in blocking mode.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @param pData Pointer to data buffer
+ * @param Size Amount of data to be sent (in bytes)
+ * @param Timeout Timeout duration
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_Transmit(PSSI_HandleTypeDef *hpssi, uint8_t *pData, uint32_t Size, uint32_t Timeout)
+{
+ uint32_t tickstart;
+ uint32_t transfer_size = Size;
+
+ if (((hpssi->Init.DataWidth == HAL_PSSI_8BITS) && (hpssi->Init.BusWidth != HAL_PSSI_8LINES)) ||
+ ((hpssi->Init.DataWidth == HAL_PSSI_16BITS) && ((Size % 2U) != 0U)) ||
+ ((hpssi->Init.DataWidth == HAL_PSSI_32BITS) && ((Size % 4U) != 0U)))
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NOT_SUPPORTED;
+ return HAL_ERROR;
+ }
+ if (hpssi->State == HAL_PSSI_STATE_READY)
+ {
+ /* Process Locked */
+ __HAL_LOCK(hpssi);
+
+ hpssi->State = HAL_PSSI_STATE_BUSY;
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NONE;
+
+ /* Disable the selected PSSI peripheral */
+ HAL_PSSI_DISABLE(hpssi);
+
+ /* Configure transfer parameters */
+ hpssi->Instance->CR |= PSSI_CR_OUTEN_OUTPUT |
+ ((hpssi->Init.ClockPolarity == HAL_PSSI_RISING_EDGE) ? 0U : PSSI_CR_CKPOL);
+ /* DMA Disable */
+ hpssi->Instance->CR &= PSSI_CR_DMA_DISABLE;
+
+ /* Enable the selected PSSI peripheral */
+ HAL_PSSI_ENABLE(hpssi);
+
+ if (hpssi->Init.DataWidth == HAL_PSSI_8BITS)
+ {
+ uint8_t *pbuffer = pData;
+ while (transfer_size > 0U)
+ {
+ /* Init tickstart for timeout management*/
+ tickstart = HAL_GetTick();
+ /* Wait until Fifo is ready to transfer one byte flag is set */
+ if (PSSI_WaitOnStatusUntilTimeout(hpssi, PSSI_FLAG_RTT1B, RESET, Timeout, tickstart) != HAL_OK)
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_TIMEOUT;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+ /* Write data to DR */
+ *(__IO uint8_t *)(&hpssi->Instance->DR) = *(uint8_t *)pbuffer;
+
+ /* Increment Buffer pointer */
+ pbuffer++;
+
+ transfer_size--;
+ }
+ }
+ else if (hpssi->Init.DataWidth == HAL_PSSI_16BITS)
+ {
+ uint16_t *pbuffer = (uint16_t *)pData;
+ __IO uint16_t *dr = (__IO uint16_t *)(&hpssi->Instance->DR);
+
+ while (transfer_size > 0U)
+ {
+ /* Init tickstart for timeout management*/
+ tickstart = HAL_GetTick();
+ /* Wait until Fifo is ready to transfer four bytes flag is set */
+ if (PSSI_WaitOnStatusUntilTimeout(hpssi, PSSI_FLAG_RTT4B, RESET, Timeout, tickstart) != HAL_OK)
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_TIMEOUT;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+ /* Write data to DR */
+ *dr = *pbuffer;
+
+ /* Increment Buffer pointer */
+ pbuffer++;
+ transfer_size -= 2U;
+
+ }
+ }
+ else if (hpssi->Init.DataWidth == HAL_PSSI_32BITS)
+ {
+ uint32_t *pbuffer = (uint32_t *)pData;
+ while (transfer_size > 0U)
+ {
+ /* Init tickstart for timeout management*/
+ tickstart = HAL_GetTick();
+ /* Wait until Fifo is ready to transfer four bytes flag is set */
+ if (PSSI_WaitOnStatusUntilTimeout(hpssi, PSSI_FLAG_RTT4B, RESET, Timeout, tickstart) != HAL_OK)
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_TIMEOUT;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+ /* Write data to DR */
+ *(__IO uint32_t *)(&hpssi->Instance->DR) = *pbuffer;
+
+ /* Increment Buffer pointer */
+ pbuffer++;
+ transfer_size -= 4U;
+ }
+
+ }
+ else
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NOT_SUPPORTED;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+
+ /* Check Errors Flags */
+ if (HAL_PSSI_GET_FLAG(hpssi, PSSI_FLAG_OVR_RIS) != 0U)
+ {
+ HAL_PSSI_CLEAR_FLAG(hpssi, PSSI_FLAG_OVR_RIS);
+ HAL_PSSI_DISABLE(hpssi);
+ hpssi->ErrorCode = HAL_PSSI_ERROR_UNDER_RUN;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_OK;
+ }
+ else
+ {
+ return HAL_BUSY;
+ }
+}
+
+
+/**
+ * @brief Receives an amount of data in blocking mode.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @param pData Pointer to data buffer
+ * @param Size Amount of data to be received (in bytes)
+ * @param Timeout Timeout duration
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_Receive(PSSI_HandleTypeDef *hpssi, uint8_t *pData, uint32_t Size, uint32_t Timeout)
+{
+ uint32_t tickstart;
+ uint32_t transfer_size = Size;
+
+ if (((hpssi->Init.DataWidth == HAL_PSSI_8BITS) && (hpssi->Init.BusWidth != HAL_PSSI_8LINES)) ||
+ ((hpssi->Init.DataWidth == HAL_PSSI_16BITS) && ((Size % 2U) != 0U)) ||
+ ((hpssi->Init.DataWidth == HAL_PSSI_32BITS) && ((Size % 4U) != 0U)))
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NOT_SUPPORTED;
+ return HAL_ERROR;
+ }
+
+ if (hpssi->State == HAL_PSSI_STATE_READY)
+ {
+ /* Process Locked */
+ __HAL_LOCK(hpssi);
+
+ hpssi->State = HAL_PSSI_STATE_BUSY;
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NONE;
+
+ /* Disable the selected PSSI peripheral */
+ HAL_PSSI_DISABLE(hpssi);
+ /* Configure transfer parameters */
+ hpssi->Instance->CR |= PSSI_CR_OUTEN_INPUT |
+ ((hpssi->Init.ClockPolarity == HAL_PSSI_FALLING_EDGE) ? 0U : PSSI_CR_CKPOL);
+
+ /* DMA Disable */
+ hpssi->Instance->CR &= PSSI_CR_DMA_DISABLE;
+
+ /* Enable the selected PSSI peripheral */
+ HAL_PSSI_ENABLE(hpssi);
+ if (hpssi->Init.DataWidth == HAL_PSSI_8BITS)
+ {
+ uint8_t *pbuffer = pData;
+
+ while (transfer_size > 0U)
+ {
+ /* Init tickstart for timeout management*/
+ tickstart = HAL_GetTick();
+ /* Wait until Fifo is ready to receive one byte flag is set */
+ if (PSSI_WaitOnStatusUntilTimeout(hpssi, PSSI_FLAG_RTT1B, RESET, Timeout, tickstart) != HAL_OK)
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_TIMEOUT;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+ /* Read data from DR */
+ *pbuffer = *(__IO uint8_t *)(&hpssi->Instance->DR);
+ pbuffer++;
+ transfer_size--;
+ }
+ }
+ else if (hpssi->Init.DataWidth == HAL_PSSI_16BITS)
+ {
+ uint16_t *pbuffer = (uint16_t *)pData;
+ __IO uint16_t *dr = (__IO uint16_t *)(&hpssi->Instance->DR);
+
+ while (transfer_size > 0U)
+ {
+ /* Init tickstart for timeout management*/
+ tickstart = HAL_GetTick();
+ /* Wait until Fifo is ready to receive four bytes flag is set */
+ if (PSSI_WaitOnStatusUntilTimeout(hpssi, PSSI_FLAG_RTT4B, RESET, Timeout, tickstart) != HAL_OK)
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_TIMEOUT;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+
+ /* Read data from DR */
+ *pbuffer = *dr;
+ pbuffer++;
+ transfer_size -= 2U;
+
+ }
+ }
+ else if (hpssi->Init.DataWidth == HAL_PSSI_32BITS)
+ {
+ uint32_t *pbuffer = (uint32_t *)pData;
+
+ while (transfer_size > 0U)
+ {
+ /* Init tickstart for timeout management*/
+ tickstart = HAL_GetTick();
+ /* Wait until Fifo is ready to receive four bytes flag is set */
+ if (PSSI_WaitOnStatusUntilTimeout(hpssi, PSSI_FLAG_RTT4B, RESET, Timeout, tickstart) != HAL_OK)
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_TIMEOUT;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+
+ /* Read data from DR */
+ *pbuffer = *(__IO uint32_t *)(&hpssi->Instance->DR);
+ pbuffer++;
+ transfer_size -= 4U;
+
+ }
+ }
+ else
+ {
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NOT_SUPPORTED;
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+ /* Check Errors Flags */
+
+ if (HAL_PSSI_GET_FLAG(hpssi, PSSI_FLAG_OVR_RIS) != 0U)
+ {
+ HAL_PSSI_CLEAR_FLAG(hpssi, PSSI_FLAG_OVR_RIS);
+ hpssi->ErrorCode = HAL_PSSI_ERROR_OVER_RUN;
+ __HAL_UNLOCK(hpssi);
+ return HAL_ERROR;
+ }
+
+
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_OK;
+ }
+ else
+ {
+ return HAL_BUSY;
+ }
+}
+
+/**
+ * @brief Transmit an amount of data in non-blocking mode with DMA
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @param pData Pointer to data buffer
+ * @param Size Amount of data to be sent (in bytes)
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_Transmit_DMA(PSSI_HandleTypeDef *hpssi, uint32_t *pData, uint32_t Size)
+{
+ HAL_StatusTypeDef dmaxferstatus;
+
+ if (hpssi->State == HAL_PSSI_STATE_READY)
+ {
+
+ /* Process Locked */
+ __HAL_LOCK(hpssi);
+
+ hpssi->State = HAL_PSSI_STATE_BUSY_TX;
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NONE;
+
+ /* Disable the selected PSSI peripheral */
+ HAL_PSSI_DISABLE(hpssi);
+
+ /* Prepare transfer parameters */
+ hpssi->pBuffPtr = pData;
+ hpssi->XferCount = Size;
+
+ if (hpssi->XferCount > PSSI_MAX_NBYTE_SIZE)
+ {
+ hpssi->XferSize = PSSI_MAX_NBYTE_SIZE;
+ }
+ else
+ {
+ hpssi->XferSize = hpssi->XferCount;
+ }
+
+ if (hpssi->XferSize > 0U)
+ {
+ if (hpssi->hdmatx != NULL)
+ {
+
+ /* Configure BusWidth */
+ if (hpssi->hdmatx->Init.PeriphDataAlignment == DMA_PDATAALIGN_BYTE)
+ {
+ MODIFY_REG(hpssi->Instance->CR, PSSI_CR_DMAEN | PSSI_CR_OUTEN | PSSI_CR_CKPOL,
+ PSSI_CR_DMA_ENABLE | PSSI_CR_OUTEN_OUTPUT |
+ ((hpssi->Init.ClockPolarity == HAL_PSSI_RISING_EDGE) ? 0U : PSSI_CR_CKPOL));
+ }
+ else
+ {
+ MODIFY_REG(hpssi->Instance->CR, PSSI_CR_DMAEN | PSSI_CR_OUTEN | PSSI_CR_CKPOL,
+ PSSI_CR_DMA_ENABLE | hpssi->Init.BusWidth | PSSI_CR_OUTEN_OUTPUT |
+ ((hpssi->Init.ClockPolarity == HAL_PSSI_RISING_EDGE) ? 0U : PSSI_CR_CKPOL));
+ }
+
+ /* Set the PSSI DMA transfer complete callback */
+ hpssi->hdmatx->XferCpltCallback = PSSI_DMATransmitCplt;
+
+ /* Set the DMA error callback */
+ hpssi->hdmatx->XferErrorCallback = PSSI_DMAError;
+
+ /* Set the unused DMA callbacks to NULL */
+ hpssi->hdmatx->XferHalfCpltCallback = NULL;
+ hpssi->hdmatx->XferAbortCallback = NULL;
+
+ /* Enable the DMA */
+ dmaxferstatus = HAL_DMA_Start_IT(hpssi->hdmatx, (uint32_t)pData, (uint32_t)&hpssi->Instance->DR,
+ hpssi->XferSize);
+ }
+ else
+ {
+ /* Update PSSI state */
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Update PSSI error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_DMA;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_ERROR;
+ }
+
+ if (dmaxferstatus == HAL_OK)
+ {
+
+
+ /* Update XferCount value */
+ hpssi->XferCount -= hpssi->XferSize;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Note : The PSSI interrupts must be enabled after unlocking current process
+ to avoid the risk of PSSI interrupt handle execution before current
+ process unlock */
+ /* Enable ERR interrupt */
+ HAL_PSSI_ENABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+ /* Enable DMA Request */
+ hpssi->Instance->CR |= PSSI_CR_DMA_ENABLE;
+ /* Enable the selected PSSI peripheral */
+ HAL_PSSI_ENABLE(hpssi);
+ }
+ else
+ {
+ /* Update PSSI state */
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Update PSSI error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_DMA;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_ERROR;
+ }
+ }
+ else
+ {
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Note : The PSSI interrupts must be enabled after unlocking current process
+ to avoid the risk of PSSI interrupt handle execution before current
+ process unlock */
+ /* Enable ERRinterrupt */
+ /* possible to enable all of these */
+
+ HAL_PSSI_ENABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+ }
+
+ return HAL_OK;
+ }
+ else
+ {
+ return HAL_BUSY;
+ }
+}
+
+/**
+ * @brief Receive an amount of data in non-blocking mode with DMA
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @param pData Pointer to data buffer
+ * @param Size Amount of data to be received (in bytes)
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_Receive_DMA(PSSI_HandleTypeDef *hpssi, uint32_t *pData, uint32_t Size)
+{
+
+ HAL_StatusTypeDef dmaxferstatus;
+
+ if (hpssi->State == HAL_PSSI_STATE_READY)
+ {
+
+ /* Disable the selected PSSI peripheral */
+ HAL_PSSI_DISABLE(hpssi);
+ /* Process Locked */
+ __HAL_LOCK(hpssi);
+
+ hpssi->State = HAL_PSSI_STATE_BUSY_RX;
+ hpssi->ErrorCode = HAL_PSSI_ERROR_NONE;
+
+ /* Prepare transfer parameters */
+ hpssi->pBuffPtr = pData;
+ hpssi->XferCount = Size;
+
+ if (hpssi->XferCount > PSSI_MAX_NBYTE_SIZE)
+ {
+ hpssi->XferSize = PSSI_MAX_NBYTE_SIZE;
+ }
+ else
+ {
+ hpssi->XferSize = hpssi->XferCount;
+ }
+
+ if (hpssi->XferSize > 0U)
+ {
+ if (hpssi->hdmarx != NULL)
+ {
+
+ /* Configure BusWidth */
+ if (hpssi->hdmatx->Init.PeriphDataAlignment == DMA_PDATAALIGN_BYTE)
+ {
+ MODIFY_REG(hpssi->Instance->CR, PSSI_CR_DMAEN | PSSI_CR_OUTEN | PSSI_CR_CKPOL, PSSI_CR_DMA_ENABLE |
+ ((hpssi->Init.ClockPolarity == HAL_PSSI_RISING_EDGE) ? PSSI_CR_CKPOL : 0U));
+ }
+ else
+ {
+ MODIFY_REG(hpssi->Instance->CR, PSSI_CR_DMAEN | PSSI_CR_OUTEN | PSSI_CR_CKPOL,
+ PSSI_CR_DMA_ENABLE | hpssi->Init.BusWidth |
+ ((hpssi->Init.ClockPolarity == HAL_PSSI_RISING_EDGE) ? PSSI_CR_CKPOL : 0U));
+ }
+
+ /* Set the PSSI DMA transfer complete callback */
+ hpssi->hdmarx->XferCpltCallback = PSSI_DMAReceiveCplt;
+
+ /* Set the DMA error callback */
+ hpssi->hdmarx->XferErrorCallback = PSSI_DMAError;
+
+ /* Set the unused DMA callbacks to NULL */
+ hpssi->hdmarx->XferHalfCpltCallback = NULL;
+ hpssi->hdmarx->XferAbortCallback = NULL;
+
+ /* Enable the DMA */
+ dmaxferstatus = HAL_DMA_Start_IT(hpssi->hdmarx, (uint32_t)&hpssi->Instance->DR, (uint32_t)pData,
+ hpssi->XferSize);
+ }
+ else
+ {
+ /* Update PSSI state */
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Update PSSI error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_DMA;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_ERROR;
+ }
+
+ if (dmaxferstatus == HAL_OK)
+ {
+ /* Update XferCount value */
+ hpssi->XferCount -= hpssi->XferSize;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Note : The PSSI interrupts must be enabled after unlocking current process
+ to avoid the risk of PSSI interrupt handle execution before current
+ process unlock */
+ /* Enable ERR interrupt */
+ HAL_PSSI_ENABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+ /* Enable DMA Request */
+ hpssi->Instance->CR |= PSSI_CR_DMA_ENABLE;
+ /* Enable the selected PSSI peripheral */
+ HAL_PSSI_ENABLE(hpssi);
+ }
+ else
+ {
+ /* Update PSSI state */
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Update PSSI error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_DMA;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_ERROR;
+ }
+ }
+ else
+ {
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Enable ERR,interrupt */
+ HAL_PSSI_ENABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+ }
+
+ return HAL_OK;
+ }
+ else
+ {
+ return HAL_BUSY;
+ }
+}
+
+
+
+/**
+ * @brief Abort a DMA process communication with Interrupt.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval HAL status
+ */
+HAL_StatusTypeDef HAL_PSSI_Abort_DMA(PSSI_HandleTypeDef *hpssi)
+{
+
+ /* Process Locked */
+ __HAL_LOCK(hpssi);
+
+ /* Disable Interrupts */
+ HAL_PSSI_DISABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+ /* Set State at HAL_PSSI_STATE_ABORT */
+ hpssi->State = HAL_PSSI_STATE_ABORT;
+
+ /* Abort DMA TX transfer if any */
+ if ((hpssi->Instance->CR & PSSI_CR_DMAEN) == PSSI_CR_DMAEN)
+ {
+ if (hpssi->State == HAL_PSSI_STATE_BUSY_TX)
+ {
+
+ hpssi->Instance->CR &= ~PSSI_CR_DMAEN;
+
+ if (hpssi->hdmatx != NULL)
+ {
+ /* Set the PSSI DMA Abort callback :
+ will lead to call HAL_PSSI_ErrorCallback() at end of DMA abort procedure */
+ hpssi->hdmatx->XferAbortCallback = PSSI_DMAAbort;
+
+ /* Abort DMA TX */
+ if (HAL_DMA_Abort_IT(hpssi->hdmatx) != HAL_OK)
+ {
+ /* Call Directly XferAbortCallback function in case of error */
+ hpssi->hdmatx->XferAbortCallback(hpssi->hdmatx);
+ }
+ }
+
+ }
+ /* Abort DMA RX transfer if any */
+ else if (hpssi->State == HAL_PSSI_STATE_BUSY_RX)
+ {
+
+ hpssi->Instance->CR &= ~PSSI_CR_DMAEN;
+
+ if (hpssi->hdmarx != NULL)
+ {
+ /* Set the PSSI DMA Abort callback :
+ will lead to call HAL_PSSI_ErrorCallback() at end of DMA abort procedure */
+ hpssi->hdmarx->XferAbortCallback = PSSI_DMAAbort;
+
+ /* Abort DMA RX */
+ if (HAL_DMA_Abort_IT(hpssi->hdmarx) != HAL_OK)
+ {
+ /* Call Directly hpssi->hdma->XferAbortCallback function in case of error */
+ hpssi->hdmarx->XferAbortCallback(hpssi->hdmarx);
+ }
+ }
+ }
+ else
+ {
+ /* Call the error callback */
+ hpssi->ErrorCallback(hpssi);
+ }
+ }
+
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Note : The PSSI interrupts must be enabled after unlocking current process
+ to avoid the risk of PSSI interrupt handle execution before current
+ process unlock */
+ HAL_PSSI_ENABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+ return HAL_OK;
+
+}
+
+/**
+ * @}
+ */
+
+/** @defgroup PSSI_IRQ_Handler_and_Callbacks IRQ Handler and Callbacks
+ * @{
+ */
+
+/**
+ * @brief This function handles PSSI event interrupt request.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval None
+ */
+void HAL_PSSI_IRQHandler(PSSI_HandleTypeDef *hpssi)
+{
+ /* Overrun/ Underrun Errors */
+ if (HAL_PSSI_GET_FLAG(hpssi, PSSI_FLAG_OVR_MIS) != 0U)
+ {
+ /* Reset handle parameters */
+
+ hpssi->XferCount = 0U;
+
+ /* Disable all interrupts */
+ HAL_PSSI_DISABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+
+ /* Abort DMA TX transfer if any */
+ if ((hpssi->Instance->CR & PSSI_CR_DMAEN) == PSSI_CR_DMAEN)
+ {
+ if (hpssi->State == HAL_PSSI_STATE_BUSY_TX)
+ {
+ /* Set new error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_UNDER_RUN;
+
+ hpssi->Instance->CR &= ~PSSI_CR_DMAEN;
+
+ if (hpssi->hdmatx != NULL)
+ {
+ /* Set the PSSI DMA Abort callback :
+ will lead to call HAL_PSSI_ErrorCallback() at end of DMA abort procedure */
+ hpssi->hdmatx->XferAbortCallback = PSSI_DMAAbort;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Abort DMA TX */
+ if (HAL_DMA_Abort_IT(hpssi->hdmatx) != HAL_OK)
+ {
+ /* Call Directly XferAbortCallback function in case of error */
+ hpssi->hdmatx->XferAbortCallback(hpssi->hdmatx);
+ }
+ }
+
+ }
+ /* Abort DMA RX transfer if any */
+ else if (hpssi->State == HAL_PSSI_STATE_BUSY_RX)
+ {
+ /* Set new error code */
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_OVER_RUN;
+
+ hpssi->Instance->CR &= ~PSSI_CR_DMAEN;
+
+ if (hpssi->hdmarx != NULL)
+ {
+ /* Set the PSSI DMA Abort callback :
+ will lead to call HAL_PSSI_ErrorCallback() at end of DMA abort procedure */
+ hpssi->hdmarx->XferAbortCallback = PSSI_DMAAbort;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Abort DMA RX */
+ if (HAL_DMA_Abort_IT(hpssi->hdmarx) != HAL_OK)
+ {
+ /* Call Directly hpssi->hdma->XferAbortCallback function in case of error */
+ hpssi->hdmarx->XferAbortCallback(hpssi->hdmarx);
+ }
+ }
+ }
+ else
+ {
+ /* Call the corresponding callback to inform upper layer of the error */
+ hpssi->ErrorCallback(hpssi);
+ }
+ }
+
+ /* If state is an abort treatment on going, don't change state */
+ if (hpssi->State == HAL_PSSI_STATE_ABORT)
+ {
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ hpssi->AbortCpltCallback(hpssi);
+
+ }
+ else
+ {
+ /* Set HAL_PSSI_STATE_READY */
+ hpssi->State = HAL_PSSI_STATE_READY;
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ hpssi->ErrorCallback(hpssi);
+
+ }
+
+ }
+}
+
+
+/**
+ * @brief Tx Transfer complete callback.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval None
+ */
+__weak void HAL_PSSI_TxCpltCallback(PSSI_HandleTypeDef *hpssi)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hpssi);
+
+ /* NOTE : This function should not be modified, when the callback is needed,
+ the HAL_PSSI_TxCpltCallback can be implemented in the user file
+ */
+}
+
+/**
+ * @brief Rx Transfer complete callback.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval None
+ */
+__weak void HAL_PSSI_RxCpltCallback(PSSI_HandleTypeDef *hpssi)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hpssi);
+
+ /* NOTE : This function should not be modified, when the callback is needed,
+ the HAL_PSSI_RxCpltCallback can be implemented in the user file
+ */
+}
+
+
+/**
+ * @brief PSSI error callback.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval None
+ */
+__weak void HAL_PSSI_ErrorCallback(PSSI_HandleTypeDef *hpssi)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hpssi);
+
+ /* NOTE : This function should not be modified, when the callback is needed,
+ the HAL_PSSI_ErrorCallback could be implemented in the user file
+ */
+}
+
+/**
+ * @brief PSSI abort callback.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval None
+ */
+__weak void HAL_PSSI_AbortCpltCallback(PSSI_HandleTypeDef *hpssi)
+{
+ /* Prevent unused argument(s) compilation warning */
+ UNUSED(hpssi);
+
+ /* NOTE : This function should not be modified, when the callback is needed,
+ the HAL_PSSI_AbortCpltCallback could be implemented in the user file
+ */
+}
+
+/**
+ * @}
+ */
+
+/** @defgroup PSSI_Exported_Functions_Group3 Peripheral State and Error functions
+ * @brief Peripheral State, Mode and Error functions
+ *
+@verbatim
+ ===============================================================================
+ ##### Peripheral State, Mode and Error functions #####
+ ===============================================================================
+ [..]
+ This subsection permit to get in run-time the status of the peripheral
+ and the data flow.
+
+@endverbatim
+ * @{
+ */
+
+/**
+ * @brief Return the PSSI handle state.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval HAL state
+ */
+HAL_PSSI_StateTypeDef HAL_PSSI_GetState(PSSI_HandleTypeDef *hpssi)
+{
+ /* Return PSSI handle state */
+ return hpssi->State;
+}
+
+
+/**
+ * @brief Return the PSSI error code.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @retval PSSI Error Code
+ */
+uint32_t HAL_PSSI_GetError(PSSI_HandleTypeDef *hpssi)
+{
+ return hpssi->ErrorCode;
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/** @addtogroup PSSI_Private_Functions
+ * @{
+ */
+
+/**
+ * @brief PSSI Errors process.
+ * @param hpssi PSSI handle.
+ * @param ErrorCode Error code to handle.
+ * @retval None
+ */
+static void PSSI_Error(PSSI_HandleTypeDef *hpssi, uint32_t ErrorCode)
+{
+
+ /* Reset handle parameters */
+
+ hpssi->XferCount = 0U;
+
+ /* Set new error code */
+ hpssi->ErrorCode |= ErrorCode;
+
+ /* Disable all interrupts */
+ HAL_PSSI_DISABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+
+ /* Abort DMA TX transfer if any */
+ if ((hpssi->Instance->CR & PSSI_CR_DMAEN) == PSSI_CR_DMAEN)
+ {
+ if (hpssi->State == HAL_PSSI_STATE_BUSY_TX)
+ {
+ hpssi->Instance->CR &= ~PSSI_CR_DMAEN;
+
+ if (hpssi->hdmatx != NULL)
+ {
+ /* Set the PSSI DMA Abort callback :
+ will lead to call HAL_PSSI_ErrorCallback() at end of DMA abort procedure */
+ hpssi->hdmatx->XferAbortCallback = PSSI_DMAAbort;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Abort DMA TX */
+ if (HAL_DMA_Abort_IT(hpssi->hdmatx) != HAL_OK)
+ {
+ /* Call Directly XferAbortCallback function in case of error */
+ hpssi->hdmatx->XferAbortCallback(hpssi->hdmatx);
+ }
+ }
+
+ }
+ /* Abort DMA RX transfer if any */
+ else if (hpssi->State == HAL_PSSI_STATE_BUSY_RX)
+ {
+ hpssi->Instance->CR &= ~PSSI_CR_DMAEN;
+
+ if (hpssi->hdmarx != NULL)
+ {
+ /* Set the PSSI DMA Abort callback :
+ will lead to call HAL_PSSI_ErrorCallback() at end of DMA abort procedure */
+ hpssi->hdmarx->XferAbortCallback = PSSI_DMAAbort;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Abort DMA RX */
+ if (HAL_DMA_Abort_IT(hpssi->hdmarx) != HAL_OK)
+ {
+ /* Call Directly hpssi->hdma->XferAbortCallback function in case of error */
+ hpssi->hdmarx->XferAbortCallback(hpssi->hdmarx);
+ }
+ }
+ }
+ else
+ {
+ /*Nothing to do*/
+ }
+ }
+
+ /* If state is an abort treatment on going, don't change state */
+ if (hpssi->State == HAL_PSSI_STATE_ABORT)
+ {
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+
+ hpssi->AbortCpltCallback(hpssi);
+
+ }
+ else
+ {
+ /* Set HAL_PSSI_STATE_READY */
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ hpssi->ErrorCallback(hpssi);
+
+ }
+}
+
+/**
+ * @brief DMA PSSI slave transmit process complete callback.
+ * @param hdma DMA handle
+ * @retval None
+ */
+void PSSI_DMATransmitCplt(DMA_HandleTypeDef *hdma)
+{
+ /* Derogation MISRAC2012-Rule-11.5 */
+ PSSI_HandleTypeDef *hpssi = (PSSI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent);
+
+ uint32_t tmperror;
+
+
+ /* Disable Interrupts */
+ HAL_PSSI_DISABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+ /* Store current volatile hpssi->ErrorCode, misra rule */
+ tmperror = hpssi->ErrorCode;
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ if ((hpssi->State == HAL_PSSI_STATE_ABORT) || (tmperror != HAL_PSSI_ERROR_NONE))
+ {
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ PSSI_Error(hpssi, hpssi->ErrorCode);
+ }
+ /* hpssi->State == HAL_PSSI_STATE_BUSY_TX */
+ else
+ {
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+
+ hpssi->TxCpltCallback(hpssi);
+
+ }
+
+
+}
+
+/**
+ * @brief DMA PSSI master receive process complete callback.
+ * @param hdma DMA handle
+ * @retval None
+ */
+void PSSI_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
+{
+ /* Derogation MISRAC2012-Rule-11.5 */
+ PSSI_HandleTypeDef *hpssi = (PSSI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent);
+
+ uint32_t tmperror;
+
+
+ /* Disable Interrupts */
+ HAL_PSSI_DISABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+ /* Store current volatile hpssi->ErrorCode, misra rule */
+ tmperror = hpssi->ErrorCode;
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ if ((hpssi->State == HAL_PSSI_STATE_ABORT) || (tmperror != HAL_PSSI_ERROR_NONE))
+ {
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ PSSI_Error(hpssi, hpssi->ErrorCode);
+ }
+ /* hpssi->State == HAL_PSSI_STATE_BUSY_RX */
+ else
+ {
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ hpssi->RxCpltCallback(hpssi);
+
+ }
+
+
+}
+
+/**
+ * @brief DMA PSSI communication abort callback
+ * (To be called at end of DMA Abort procedure).
+ * @param hdma DMA handle.
+ * @retval None
+ */
+void PSSI_DMAAbort(DMA_HandleTypeDef *hdma)
+{
+ /* Derogation MISRAC2012-Rule-11.5 */
+ PSSI_HandleTypeDef *hpssi = (PSSI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent);
+
+ /* Reset AbortCpltCallback */
+ hpssi->hdmatx->XferAbortCallback = NULL;
+ hpssi->hdmarx->XferAbortCallback = NULL;
+
+ /* Check if come from abort from user */
+ if (hpssi->State == HAL_PSSI_STATE_ABORT)
+ {
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+
+ hpssi->AbortCpltCallback(hpssi);
+
+ }
+ else
+ {
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ hpssi->ErrorCallback(hpssi);
+ }
+}
+
+/**
+ * @brief This function handles PSSI Communication Timeout.
+ * @param hpssi Pointer to a PSSI_HandleTypeDef structure that contains
+ * the configuration information for the specified PSSI.
+ * @param Flag Specifies the PSSI flag to check.
+ * @param Status The new Flag status (SET or RESET).
+ * @param Timeout Timeout duration
+ * @param Tickstart Tick start value
+ * @retval HAL status
+ */
+static HAL_StatusTypeDef PSSI_WaitOnStatusUntilTimeout(PSSI_HandleTypeDef *hpssi, uint32_t Flag, FlagStatus Status,
+ uint32_t Timeout, uint32_t Tickstart)
+{
+ while ((HAL_PSSI_GET_STATUS(hpssi, Flag) & Flag) == (uint32_t)Status)
+ {
+ /* Check for the Timeout */
+ if (Timeout != HAL_MAX_DELAY)
+ {
+ if (((HAL_GetTick() - Tickstart) > Timeout) || (Timeout == 0U))
+ {
+ hpssi->ErrorCode |= HAL_PSSI_ERROR_TIMEOUT;
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ return HAL_ERROR;
+ }
+ }
+ }
+ return HAL_OK;
+}
+void PSSI_DMAError(DMA_HandleTypeDef *hdma)
+{
+ /* Derogation MISRAC2012-Rule-11.5 */
+ PSSI_HandleTypeDef *hpssi = (PSSI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent);
+
+ uint32_t tmperror;
+
+
+ /* Disable the selected PSSI peripheral */
+ HAL_PSSI_DISABLE(hpssi);
+
+ /* Disable Interrupts */
+ HAL_PSSI_DISABLE_IT(hpssi, PSSI_FLAG_OVR_RIS);
+
+ /* Store current volatile hpssi->ErrorCode, misra rule */
+ tmperror = hpssi->ErrorCode;
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ if ((hpssi->State == HAL_PSSI_STATE_ABORT) || (tmperror != HAL_PSSI_ERROR_NONE))
+ {
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ PSSI_Error(hpssi, hpssi->ErrorCode);
+ }
+ else
+ {
+ hpssi->State = HAL_PSSI_STATE_READY;
+
+ /* Process Unlocked */
+ __HAL_UNLOCK(hpssi);
+
+ /* Call the corresponding callback to inform upper layer of End of Transfer */
+ hpssi->ErrorCallback(hpssi);
+
+ }
+
+}
+
+
+
+/**
+ * @}
+ */
+#endif /* PSSI */
+#endif /* HAL_PSSI_MODULE_ENABLED */
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
|