1800 lines
54 KiB
C
1800 lines
54 KiB
C
/**
|
|
******************************************************************************
|
|
* @file stm32l4xx_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) 2019 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 "stm32l4xx_hal.h"
|
|
|
|
/** @addtogroup STM32L4xx_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 De-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_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;
|
|
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @addtogroup 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 */
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/**
|
|
* @}
|
|
*/
|