mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_swpmi.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 610:813dcc80987e 1 /**
mbed_official 610:813dcc80987e 2 ******************************************************************************
mbed_official 610:813dcc80987e 3 * @file stm32l4xx_hal_swpmi.c
mbed_official 610:813dcc80987e 4 * @author MCD Application Team
mbed_official 610:813dcc80987e 5 * @version V1.0.0
mbed_official 610:813dcc80987e 6 * @date 26-June-2015
mbed_official 610:813dcc80987e 7 * @brief SWPMI HAL module driver.
mbed_official 610:813dcc80987e 8 * This file provides firmware functions to manage the following
mbed_official 610:813dcc80987e 9 * functionalities of the Single Wire Protocol Master Interface (SWPMI).
mbed_official 610:813dcc80987e 10 * + Initialization and Configuration
mbed_official 610:813dcc80987e 11 * + Data transfers functions
mbed_official 610:813dcc80987e 12 * + DMA transfers management
mbed_official 610:813dcc80987e 13 * + Interrupts and flags management
mbed_official 610:813dcc80987e 14 @verbatim
mbed_official 610:813dcc80987e 15 ===============================================================================
mbed_official 610:813dcc80987e 16 ##### How to use this driver #####
mbed_official 610:813dcc80987e 17 ===============================================================================
mbed_official 610:813dcc80987e 18 [..]
mbed_official 610:813dcc80987e 19 The SWPMI HAL driver can be used as follows:
mbed_official 610:813dcc80987e 20
mbed_official 610:813dcc80987e 21 (#) Declare a SWPMI_HandleTypeDef handle structure (eg. SWPMI_HandleTypeDef hswpmi).
mbed_official 610:813dcc80987e 22
mbed_official 610:813dcc80987e 23 (#) Initialize the SWPMI low level resources by implementing the HAL_SWPMI_MspInit() API:
mbed_official 610:813dcc80987e 24 (##) Enable the SWPMIx interface clock with __HAL_RCC_SWPMIx_CLK_ENABLE().
mbed_official 610:813dcc80987e 25 (##) SWPMI IO configuration:
mbed_official 610:813dcc80987e 26 (+++) Enable the clock for the SWPMI GPIO.
mbed_official 610:813dcc80987e 27 (+++) Configure these SWPMI pins as alternate function pull-up.
mbed_official 610:813dcc80987e 28 (##) NVIC configuration if you need to use interrupt process (HAL_SWPMI_Transmit_IT()
mbed_official 610:813dcc80987e 29 and HAL_SWPMI_Receive_IT() APIs):
mbed_official 610:813dcc80987e 30 (+++) Configure the SWPMIx interrupt priority with HAL_NVIC_SetPriority().
mbed_official 610:813dcc80987e 31 (+++) Enable the NVIC SWPMI IRQ handle with HAL_NVIC_EnableIRQ().
mbed_official 610:813dcc80987e 32
mbed_official 610:813dcc80987e 33 (##) DMA Configuration if you need to use DMA process (HAL_SWPMI_Transmit_DMA()
mbed_official 610:813dcc80987e 34 and HAL_SWPMI_Receive_DMA() APIs):
mbed_official 610:813dcc80987e 35 (+++) Declare a DMA handle structure for the Tx/Rx channels.
mbed_official 610:813dcc80987e 36 (+++) Enable the DMAx interface clock.
mbed_official 610:813dcc80987e 37 (+++) Configure the declared DMA handle structure with the required
mbed_official 610:813dcc80987e 38 Tx/Rx parameters.
mbed_official 610:813dcc80987e 39 (+++) Configure the DMA Tx/Rx channels and requests.
mbed_official 610:813dcc80987e 40 (+++) Associate the initialized DMA handle to the SWPMI DMA Tx/Rx handle.
mbed_official 610:813dcc80987e 41 (+++) Configure the priority and enable the NVIC for the transfer complete
mbed_official 610:813dcc80987e 42 interrupt on the DMA Tx/Rx channels.
mbed_official 610:813dcc80987e 43
mbed_official 610:813dcc80987e 44 (#) Program the Bite Rate, Tx Buffering mode, Rx Buffering mode in the Init structure.
mbed_official 610:813dcc80987e 45
mbed_official 610:813dcc80987e 46 (#) Enable the SWPMI peripheral by calling the HAL_SWPMI_Init() function.
mbed_official 610:813dcc80987e 47
mbed_official 610:813dcc80987e 48 @endverbatim
mbed_official 610:813dcc80987e 49 ******************************************************************************
mbed_official 610:813dcc80987e 50 * @attention
mbed_official 610:813dcc80987e 51 *
mbed_official 610:813dcc80987e 52 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 610:813dcc80987e 53 *
mbed_official 610:813dcc80987e 54 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 610:813dcc80987e 55 * are permitted provided that the following conditions are met:
mbed_official 610:813dcc80987e 56 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 610:813dcc80987e 57 * this list of conditions and the following disclaimer.
mbed_official 610:813dcc80987e 58 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 610:813dcc80987e 59 * this list of conditions and the following disclaimer in the documentation
mbed_official 610:813dcc80987e 60 * and/or other materials provided with the distribution.
mbed_official 610:813dcc80987e 61 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 610:813dcc80987e 62 * may be used to endorse or promote products derived from this software
mbed_official 610:813dcc80987e 63 * without specific prior written permission.
mbed_official 610:813dcc80987e 64 *
mbed_official 610:813dcc80987e 65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 610:813dcc80987e 66 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 610:813dcc80987e 67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 610:813dcc80987e 68 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 610:813dcc80987e 69 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 610:813dcc80987e 70 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 610:813dcc80987e 71 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 610:813dcc80987e 72 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 610:813dcc80987e 73 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 610:813dcc80987e 74 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 610:813dcc80987e 75 *
mbed_official 610:813dcc80987e 76 ******************************************************************************
mbed_official 610:813dcc80987e 77 */
mbed_official 610:813dcc80987e 78
mbed_official 610:813dcc80987e 79 /* Includes ------------------------------------------------------------------*/
mbed_official 610:813dcc80987e 80 #include "stm32l4xx_hal.h"
mbed_official 610:813dcc80987e 81
mbed_official 610:813dcc80987e 82 /** @addtogroup STM32L4xx_HAL_Driver
mbed_official 610:813dcc80987e 83 * @{
mbed_official 610:813dcc80987e 84 */
mbed_official 610:813dcc80987e 85
mbed_official 610:813dcc80987e 86 /** @defgroup SWPMI SWPMI
mbed_official 610:813dcc80987e 87 * @brief HAL SWPMI module driver
mbed_official 610:813dcc80987e 88 * @{
mbed_official 610:813dcc80987e 89 */
mbed_official 610:813dcc80987e 90 #ifdef HAL_SWPMI_MODULE_ENABLED
mbed_official 610:813dcc80987e 91
mbed_official 610:813dcc80987e 92 /* Private typedef -----------------------------------------------------------*/
mbed_official 610:813dcc80987e 93 /* Private define ------------------------------------------------------------*/
mbed_official 610:813dcc80987e 94 /* Private constants ---------------------------------------------------------*/
mbed_official 610:813dcc80987e 95 /** @addtogroup SWPMI_Private_Constants SWPMI Private Constants
mbed_official 610:813dcc80987e 96 * @{
mbed_official 610:813dcc80987e 97 */
mbed_official 610:813dcc80987e 98 #define SWPMI_TIMEOUT_VALUE ((uint32_t) 22000)
mbed_official 610:813dcc80987e 99
mbed_official 610:813dcc80987e 100 /**
mbed_official 610:813dcc80987e 101 * @}
mbed_official 610:813dcc80987e 102 */
mbed_official 610:813dcc80987e 103
mbed_official 610:813dcc80987e 104 /* Private macros ------------------------------------------------------------*/
mbed_official 610:813dcc80987e 105 /* Private variables ---------------------------------------------------------*/
mbed_official 610:813dcc80987e 106 /* Private function prototypes -----------------------------------------------*/
mbed_official 610:813dcc80987e 107 static void SWPMI_DMATransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 108 static void SWPMI_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 109 static void SWPMI_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 110 static void SWPMI_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 111 static void SWPMI_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 112 static HAL_StatusTypeDef SWPMI_Transmit_IT(SWPMI_HandleTypeDef *hswpmi);
mbed_official 610:813dcc80987e 113 static HAL_StatusTypeDef SWPMI_EndTransmit_IT(SWPMI_HandleTypeDef *hswpmi);
mbed_official 610:813dcc80987e 114 static HAL_StatusTypeDef SWPMI_Receive_IT(SWPMI_HandleTypeDef *hswpmi);
mbed_official 610:813dcc80987e 115 static HAL_StatusTypeDef SWPMI_EndReceive_IT(SWPMI_HandleTypeDef *hswpmi);
mbed_official 610:813dcc80987e 116 static HAL_StatusTypeDef SWPMI_EndTransmitReceive_IT(SWPMI_HandleTypeDef *hswpmi);
mbed_official 610:813dcc80987e 117 static HAL_StatusTypeDef SWPMI_WaitOnFlagSetUntilTimeout(SWPMI_HandleTypeDef *hswpmi, uint32_t Flag, uint32_t Timeout);
mbed_official 610:813dcc80987e 118
mbed_official 610:813dcc80987e 119 /* Exported functions --------------------------------------------------------*/
mbed_official 610:813dcc80987e 120
mbed_official 610:813dcc80987e 121 /** @defgroup SWPMI_Exported_Functions SWPMI Exported Functions
mbed_official 610:813dcc80987e 122 * @{
mbed_official 610:813dcc80987e 123 */
mbed_official 610:813dcc80987e 124
mbed_official 610:813dcc80987e 125 /** @defgroup SWPMI_Exported_Group1 Initialization/de-initialization methods
mbed_official 610:813dcc80987e 126 * @brief Initialization and Configuration functions
mbed_official 610:813dcc80987e 127 *
mbed_official 610:813dcc80987e 128 @verbatim
mbed_official 610:813dcc80987e 129 ===============================================================================
mbed_official 610:813dcc80987e 130 ##### Initialization and Configuration functions #####
mbed_official 610:813dcc80987e 131 ===============================================================================
mbed_official 610:813dcc80987e 132 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 133 (+) Initialize and configure the SWPMI peripheral.
mbed_official 610:813dcc80987e 134 (+) De-initialize the SWPMI peripheral.
mbed_official 610:813dcc80987e 135
mbed_official 610:813dcc80987e 136 @endverbatim
mbed_official 610:813dcc80987e 137 * @{
mbed_official 610:813dcc80987e 138 */
mbed_official 610:813dcc80987e 139
mbed_official 610:813dcc80987e 140 /**
mbed_official 610:813dcc80987e 141 * @brief Initialize the SWPMI peripheral according to the specified parameters in the SWPMI_InitTypeDef.
mbed_official 610:813dcc80987e 142 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 143 * @retval HAL status
mbed_official 610:813dcc80987e 144 */
mbed_official 610:813dcc80987e 145 HAL_StatusTypeDef HAL_SWPMI_Init(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 146 {
mbed_official 610:813dcc80987e 147 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 148
mbed_official 610:813dcc80987e 149 /* Check the SWPMI handle allocation */
mbed_official 610:813dcc80987e 150 if(hswpmi == NULL)
mbed_official 610:813dcc80987e 151 {
mbed_official 610:813dcc80987e 152 status = HAL_ERROR;
mbed_official 610:813dcc80987e 153 }
mbed_official 610:813dcc80987e 154 else
mbed_official 610:813dcc80987e 155 {
mbed_official 610:813dcc80987e 156 /* Check the parameters */
mbed_official 610:813dcc80987e 157 assert_param(IS_SWPMI_VOLTAGE_CLASS(hswpmi->Init.VoltageClass));
mbed_official 610:813dcc80987e 158 assert_param(IS_SWPMI_BITRATE_VALUE(hswpmi->Init.BitRate));
mbed_official 610:813dcc80987e 159 assert_param(IS_SWPMI_TX_BUFFERING_MODE(hswpmi->Init.TxBufferingMode));
mbed_official 610:813dcc80987e 160 assert_param(IS_SWPMI_RX_BUFFERING_MODE(hswpmi->Init.RxBufferingMode));
mbed_official 610:813dcc80987e 161
mbed_official 610:813dcc80987e 162 if(hswpmi->State == HAL_SWPMI_STATE_RESET)
mbed_official 610:813dcc80987e 163 {
mbed_official 610:813dcc80987e 164 /* Allocate lock resource and initialize it */
mbed_official 610:813dcc80987e 165 hswpmi->Lock = HAL_UNLOCKED;
mbed_official 610:813dcc80987e 166
mbed_official 610:813dcc80987e 167 /* Init the low level hardware : GPIO, CLOCK, CORTEX */
mbed_official 610:813dcc80987e 168 HAL_SWPMI_MspInit(hswpmi);
mbed_official 610:813dcc80987e 169 }
mbed_official 610:813dcc80987e 170
mbed_official 610:813dcc80987e 171 hswpmi->State = HAL_SWPMI_STATE_BUSY;
mbed_official 610:813dcc80987e 172
mbed_official 610:813dcc80987e 173 /* Disable SWPMI interface */
mbed_official 610:813dcc80987e 174 CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 175
mbed_official 610:813dcc80987e 176 /* Clear all SWPMI interface flags */
mbed_official 610:813dcc80987e 177 WRITE_REG(hswpmi->Instance->ICR, 0x019F);
mbed_official 610:813dcc80987e 178
mbed_official 610:813dcc80987e 179 /* Apply Voltage class selection */
mbed_official 610:813dcc80987e 180 MODIFY_REG(hswpmi->Instance->OR, SWPMI_OR_CLASS, hswpmi->Init.VoltageClass);
mbed_official 610:813dcc80987e 181
mbed_official 610:813dcc80987e 182 /* Configure the BRR register (Bitrate) */
mbed_official 610:813dcc80987e 183 WRITE_REG(hswpmi->Instance->BRR, hswpmi->Init.BitRate);
mbed_official 610:813dcc80987e 184
mbed_official 610:813dcc80987e 185 /* Apply SWPMI CR configuration */
mbed_official 610:813dcc80987e 186 MODIFY_REG(hswpmi->Instance->CR, \
mbed_official 610:813dcc80987e 187 SWPMI_CR_RXDMA | SWPMI_CR_TXDMA | SWPMI_CR_RXMODE | SWPMI_CR_TXMODE, \
mbed_official 610:813dcc80987e 188 hswpmi->Init.TxBufferingMode | hswpmi->Init.RxBufferingMode);
mbed_official 610:813dcc80987e 189
mbed_official 610:813dcc80987e 190 hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
mbed_official 610:813dcc80987e 191 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 192
mbed_official 610:813dcc80987e 193 /* Enable SWPMI peripheral if not */
mbed_official 610:813dcc80987e 194 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 195 }
mbed_official 610:813dcc80987e 196
mbed_official 610:813dcc80987e 197 return status;
mbed_official 610:813dcc80987e 198 }
mbed_official 610:813dcc80987e 199
mbed_official 610:813dcc80987e 200 /**
mbed_official 610:813dcc80987e 201 * @brief De-initialize the SWPMI peripheral.
mbed_official 610:813dcc80987e 202 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 203 * @retval HAL status
mbed_official 610:813dcc80987e 204 */
mbed_official 610:813dcc80987e 205 HAL_StatusTypeDef HAL_SWPMI_DeInit(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 206 {
mbed_official 610:813dcc80987e 207 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 208
mbed_official 610:813dcc80987e 209 /* Check the SWPMI handle allocation */
mbed_official 610:813dcc80987e 210 if(hswpmi == NULL)
mbed_official 610:813dcc80987e 211 {
mbed_official 610:813dcc80987e 212 status = HAL_ERROR;
mbed_official 610:813dcc80987e 213 }
mbed_official 610:813dcc80987e 214 else
mbed_official 610:813dcc80987e 215 {
mbed_official 610:813dcc80987e 216 /* Check the parameters */
mbed_official 610:813dcc80987e 217 assert_param(IS_SWPMI_INSTANCE(hswpmi->Instance));
mbed_official 610:813dcc80987e 218
mbed_official 610:813dcc80987e 219 hswpmi->State = HAL_SWPMI_STATE_BUSY;
mbed_official 610:813dcc80987e 220
mbed_official 610:813dcc80987e 221 /* Disable SWPMI interface */
mbed_official 610:813dcc80987e 222 CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 223
mbed_official 610:813dcc80987e 224 /* DeInit the low level hardware */
mbed_official 610:813dcc80987e 225 HAL_SWPMI_MspDeInit(hswpmi);
mbed_official 610:813dcc80987e 226
mbed_official 610:813dcc80987e 227 hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
mbed_official 610:813dcc80987e 228
mbed_official 610:813dcc80987e 229 hswpmi->State = HAL_SWPMI_STATE_RESET;
mbed_official 610:813dcc80987e 230
mbed_official 610:813dcc80987e 231 /* Release Lock */
mbed_official 610:813dcc80987e 232 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 233 }
mbed_official 610:813dcc80987e 234
mbed_official 610:813dcc80987e 235 return status;
mbed_official 610:813dcc80987e 236 }
mbed_official 610:813dcc80987e 237
mbed_official 610:813dcc80987e 238 /**
mbed_official 610:813dcc80987e 239 * @brief Initialize the SWPMI MSP.
mbed_official 610:813dcc80987e 240 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 241 * @retval None
mbed_official 610:813dcc80987e 242 */
mbed_official 610:813dcc80987e 243 __weak void HAL_SWPMI_MspInit(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 244 {
mbed_official 610:813dcc80987e 245 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 246 the HAL_SWPMI_MspInit can be implemented in the user file
mbed_official 610:813dcc80987e 247 */
mbed_official 610:813dcc80987e 248 }
mbed_official 610:813dcc80987e 249
mbed_official 610:813dcc80987e 250 /**
mbed_official 610:813dcc80987e 251 * @brief DeInitialize the SWPMI MSP.
mbed_official 610:813dcc80987e 252 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 253 * @retval None
mbed_official 610:813dcc80987e 254 */
mbed_official 610:813dcc80987e 255 __weak void HAL_SWPMI_MspDeInit(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 256 {
mbed_official 610:813dcc80987e 257 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 258 the HAL_SWPMI_MspDeInit can be implemented in the user file
mbed_official 610:813dcc80987e 259 */
mbed_official 610:813dcc80987e 260 }
mbed_official 610:813dcc80987e 261
mbed_official 610:813dcc80987e 262 /**
mbed_official 610:813dcc80987e 263 * @}
mbed_official 610:813dcc80987e 264 */
mbed_official 610:813dcc80987e 265
mbed_official 610:813dcc80987e 266 /** @defgroup SWPMI_Exported_Group2 IO operation methods
mbed_official 610:813dcc80987e 267 * @brief SWPMI Transmit/Receive functions
mbed_official 610:813dcc80987e 268 *
mbed_official 610:813dcc80987e 269 @verbatim
mbed_official 610:813dcc80987e 270 ===============================================================================
mbed_official 610:813dcc80987e 271 ##### IO operation methods #####
mbed_official 610:813dcc80987e 272 ===============================================================================
mbed_official 610:813dcc80987e 273 [..]
mbed_official 610:813dcc80987e 274 This subsection provides a set of functions allowing to manage the SWPMI
mbed_official 610:813dcc80987e 275 data transfers.
mbed_official 610:813dcc80987e 276
mbed_official 610:813dcc80987e 277 (#) There are two modes of transfer:
mbed_official 610:813dcc80987e 278 (++) Blocking mode: The communication is performed in polling mode.
mbed_official 610:813dcc80987e 279 The HAL status of all data processing is returned by the same function
mbed_official 610:813dcc80987e 280 after finishing transfer.
mbed_official 610:813dcc80987e 281 (++) Non-Blocking mode: The communication is performed using Interrupts
mbed_official 610:813dcc80987e 282 or DMA. The end of the data processing will be indicated through the
mbed_official 610:813dcc80987e 283 dedicated SWPMI Interrupt handler (HAL_SWPMI_IRQHandler()) when using Interrupt mode or
mbed_official 610:813dcc80987e 284 the selected DMA channel interrupt handler when using DMA mode.
mbed_official 610:813dcc80987e 285 The HAL_SWPMI_TxCpltCallback(), HAL_SWPMI_RxCpltCallback() user callbacks
mbed_official 610:813dcc80987e 286 will be executed respectively at the end of the transmit or receive process.
mbed_official 610:813dcc80987e 287 The HAL_SWPMI_ErrorCallback() user callback will be executed when a communication error is detected.
mbed_official 610:813dcc80987e 288
mbed_official 610:813dcc80987e 289 (#) Blocking mode API's are:
mbed_official 610:813dcc80987e 290 (++) HAL_SWPMI_Transmit()
mbed_official 610:813dcc80987e 291 (++) HAL_SWPMI_Receive()
mbed_official 610:813dcc80987e 292
mbed_official 610:813dcc80987e 293 (#) Non-Blocking mode API's with Interrupt are:
mbed_official 610:813dcc80987e 294 (++) HAL_SWPMI_Transmit_IT()
mbed_official 610:813dcc80987e 295 (++) HAL_SWPMI_Receive_IT()
mbed_official 610:813dcc80987e 296 (++) HAL_SWPMI_IRQHandler()
mbed_official 610:813dcc80987e 297
mbed_official 610:813dcc80987e 298 (#) Non-Blocking mode API's with DMA are:
mbed_official 610:813dcc80987e 299 (++) HAL_SWPMI_Transmit_DMA()
mbed_official 610:813dcc80987e 300 (++) HAL_SWPMI_Receive_DMA()
mbed_official 610:813dcc80987e 301 (++) HAL_SWPMI_DMAPause()
mbed_official 610:813dcc80987e 302 (++) HAL_SWPMI_DMAResume()
mbed_official 610:813dcc80987e 303 (++) HAL_SWPMI_DMAStop()
mbed_official 610:813dcc80987e 304
mbed_official 610:813dcc80987e 305 (#) A set of Transfer Complete Callbacks are provided in Non-Blocking mode:
mbed_official 610:813dcc80987e 306 (++) HAL_SWPMI_TxHalfCpltCallback()
mbed_official 610:813dcc80987e 307 (++) HAL_SWPMI_TxCpltCallback()
mbed_official 610:813dcc80987e 308 (++) HAL_SWPMI_RxHalfCpltCallback()
mbed_official 610:813dcc80987e 309 (++) HAL_SWPMI_RxCpltCallback()
mbed_official 610:813dcc80987e 310 (++) HAL_SWPMI_ErrorCallback()
mbed_official 610:813dcc80987e 311
mbed_official 610:813dcc80987e 312 (#) The capability to launch the above IO operations in loopback mode for
mbed_official 610:813dcc80987e 313 user application verification:
mbed_official 610:813dcc80987e 314 (++) HAL_SWPMI_EnableLoopback()
mbed_official 610:813dcc80987e 315 (++) HAL_SWPMI_DisableLoopback()
mbed_official 610:813dcc80987e 316
mbed_official 610:813dcc80987e 317 @endverbatim
mbed_official 610:813dcc80987e 318 * @{
mbed_official 610:813dcc80987e 319 */
mbed_official 610:813dcc80987e 320
mbed_official 610:813dcc80987e 321 /**
mbed_official 610:813dcc80987e 322 * @brief Transmit an amount of data in blocking mode.
mbed_official 610:813dcc80987e 323 * @param hswpmi: pointer to a SWPMI_HandleTypeDef structure that contains
mbed_official 610:813dcc80987e 324 * the configuration information for SWPMI module.
mbed_official 610:813dcc80987e 325 * @param pData: Pointer to data buffer
mbed_official 610:813dcc80987e 326 * @param Size: Amount of data to be sent
mbed_official 610:813dcc80987e 327 * @param Timeout: Timeout duration
mbed_official 610:813dcc80987e 328 * @retval HAL status
mbed_official 610:813dcc80987e 329 */
mbed_official 610:813dcc80987e 330 HAL_StatusTypeDef HAL_SWPMI_Transmit(SWPMI_HandleTypeDef *hswpmi, uint32_t* pData, uint16_t Size, uint32_t Timeout)
mbed_official 610:813dcc80987e 331 {
mbed_official 610:813dcc80987e 332 uint32_t tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 333 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 334
mbed_official 610:813dcc80987e 335 if((pData == NULL ) || (Size == 0))
mbed_official 610:813dcc80987e 336 {
mbed_official 610:813dcc80987e 337 status = HAL_ERROR;
mbed_official 610:813dcc80987e 338 }
mbed_official 610:813dcc80987e 339 else
mbed_official 610:813dcc80987e 340 {
mbed_official 610:813dcc80987e 341 /* Process Locked */
mbed_official 610:813dcc80987e 342 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 343
mbed_official 610:813dcc80987e 344 if((hswpmi->State == HAL_SWPMI_STATE_READY) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_RX))
mbed_official 610:813dcc80987e 345 {
mbed_official 610:813dcc80987e 346 /* Check if a non-blocking receive process is ongoing or not */
mbed_official 610:813dcc80987e 347 if(hswpmi->State == HAL_SWPMI_STATE_READY)
mbed_official 610:813dcc80987e 348 {
mbed_official 610:813dcc80987e 349 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
mbed_official 610:813dcc80987e 350
mbed_official 610:813dcc80987e 351 /* Disable any transmitter interrupts */
mbed_official 610:813dcc80987e 352 __HAL_SWPMI_DISABLE_IT(hswpmi, SWPMI_IT_TCIE | SWPMI_IT_TIE | SWPMI_IT_TXUNRIE | SWPMI_IT_TXBEIE);
mbed_official 610:813dcc80987e 353
mbed_official 610:813dcc80987e 354 /* Disable any transmitter flags */
mbed_official 610:813dcc80987e 355 __HAL_SWPMI_CLEAR_FLAG(hswpmi, SWPMI_FLAG_TXBEF | SWPMI_FLAG_TXUNRF | SWPMI_FLAG_TCF);
mbed_official 610:813dcc80987e 356
mbed_official 610:813dcc80987e 357 /* Enable SWPMI peripheral if not */
mbed_official 610:813dcc80987e 358 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 359 }
mbed_official 610:813dcc80987e 360 else
mbed_official 610:813dcc80987e 361 {
mbed_official 610:813dcc80987e 362 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
mbed_official 610:813dcc80987e 363 }
mbed_official 610:813dcc80987e 364
mbed_official 610:813dcc80987e 365 do
mbed_official 610:813dcc80987e 366 {
mbed_official 610:813dcc80987e 367 /* Wait the TXE to write data */
mbed_official 610:813dcc80987e 368 if(HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_TXE))
mbed_official 610:813dcc80987e 369 {
mbed_official 610:813dcc80987e 370 hswpmi->Instance->TDR = (*pData++);
mbed_official 610:813dcc80987e 371 Size--;
mbed_official 610:813dcc80987e 372 }
mbed_official 610:813dcc80987e 373 else
mbed_official 610:813dcc80987e 374 {
mbed_official 610:813dcc80987e 375 /* Check for the Timeout */
mbed_official 610:813dcc80987e 376 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 377 {
mbed_official 610:813dcc80987e 378 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
mbed_official 610:813dcc80987e 379 {
mbed_official 610:813dcc80987e 380 status = HAL_TIMEOUT;
mbed_official 610:813dcc80987e 381 break;
mbed_official 610:813dcc80987e 382 }
mbed_official 610:813dcc80987e 383 }
mbed_official 610:813dcc80987e 384 }
mbed_official 610:813dcc80987e 385 } while(Size != 0);
mbed_official 610:813dcc80987e 386
mbed_official 610:813dcc80987e 387 /* Wait on TXBEF flag to be able to start a second transfer */
mbed_official 610:813dcc80987e 388 if(SWPMI_WaitOnFlagSetUntilTimeout(hswpmi, SWPMI_FLAG_TXBEF, Timeout) != HAL_OK)
mbed_official 610:813dcc80987e 389 {
mbed_official 610:813dcc80987e 390 status = HAL_TIMEOUT;
mbed_official 610:813dcc80987e 391 }
mbed_official 610:813dcc80987e 392
mbed_official 610:813dcc80987e 393 if(status == HAL_OK)
mbed_official 610:813dcc80987e 394 {
mbed_official 610:813dcc80987e 395 /* Check if a non-blocking receive Process is ongoing or not */
mbed_official 610:813dcc80987e 396 if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
mbed_official 610:813dcc80987e 397 {
mbed_official 610:813dcc80987e 398 hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
mbed_official 610:813dcc80987e 399 }
mbed_official 610:813dcc80987e 400 else
mbed_official 610:813dcc80987e 401 {
mbed_official 610:813dcc80987e 402 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 403 }
mbed_official 610:813dcc80987e 404 }
mbed_official 610:813dcc80987e 405 }
mbed_official 610:813dcc80987e 406 else
mbed_official 610:813dcc80987e 407 {
mbed_official 610:813dcc80987e 408 status = HAL_BUSY;
mbed_official 610:813dcc80987e 409 }
mbed_official 610:813dcc80987e 410 }
mbed_official 610:813dcc80987e 411
mbed_official 610:813dcc80987e 412 if((status != HAL_OK) && (status != HAL_BUSY))
mbed_official 610:813dcc80987e 413 {
mbed_official 610:813dcc80987e 414 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 415 }
mbed_official 610:813dcc80987e 416 /* Process Unlocked */
mbed_official 610:813dcc80987e 417 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 418
mbed_official 610:813dcc80987e 419 return status;
mbed_official 610:813dcc80987e 420 }
mbed_official 610:813dcc80987e 421
mbed_official 610:813dcc80987e 422 /**
mbed_official 610:813dcc80987e 423 * @brief Receive an amount of data in blocking mode.
mbed_official 610:813dcc80987e 424 * @param hswpmi: pointer to a SWPMI_HandleTypeDef structure that contains
mbed_official 610:813dcc80987e 425 * the configuration information for SWPMI module.
mbed_official 610:813dcc80987e 426 * @param pData: Pointer to data buffer
mbed_official 610:813dcc80987e 427 * @param Size: Amount of data to be received
mbed_official 610:813dcc80987e 428 * @param Timeout: Timeout duration
mbed_official 610:813dcc80987e 429 * @retval HAL status
mbed_official 610:813dcc80987e 430 */
mbed_official 610:813dcc80987e 431 HAL_StatusTypeDef HAL_SWPMI_Receive(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 610:813dcc80987e 432 {
mbed_official 610:813dcc80987e 433 uint32_t tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 434 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 435
mbed_official 610:813dcc80987e 436 if((pData == NULL ) || (Size == 0))
mbed_official 610:813dcc80987e 437 {
mbed_official 610:813dcc80987e 438 status = HAL_ERROR;
mbed_official 610:813dcc80987e 439 }
mbed_official 610:813dcc80987e 440 else
mbed_official 610:813dcc80987e 441 {
mbed_official 610:813dcc80987e 442 /* Process Locked */
mbed_official 610:813dcc80987e 443 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 444
mbed_official 610:813dcc80987e 445 if((hswpmi->State == HAL_SWPMI_STATE_READY) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX))
mbed_official 610:813dcc80987e 446 {
mbed_official 610:813dcc80987e 447 /* Check if a non-blocking transmit process is ongoing or not */
mbed_official 610:813dcc80987e 448 if(hswpmi->State == HAL_SWPMI_STATE_READY)
mbed_official 610:813dcc80987e 449 {
mbed_official 610:813dcc80987e 450 hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
mbed_official 610:813dcc80987e 451
mbed_official 610:813dcc80987e 452 /* Disable any receiver interrupts */
mbed_official 610:813dcc80987e 453 CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_SRIE | SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);
mbed_official 610:813dcc80987e 454
mbed_official 610:813dcc80987e 455 /* Enable SWPMI peripheral if not */
mbed_official 610:813dcc80987e 456 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 457 }
mbed_official 610:813dcc80987e 458 else
mbed_official 610:813dcc80987e 459 {
mbed_official 610:813dcc80987e 460 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
mbed_official 610:813dcc80987e 461 }
mbed_official 610:813dcc80987e 462
mbed_official 610:813dcc80987e 463 do
mbed_official 610:813dcc80987e 464 {
mbed_official 610:813dcc80987e 465 /* Wait the RXNE to read data */
mbed_official 610:813dcc80987e 466 if(HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_RXNE))
mbed_official 610:813dcc80987e 467 {
mbed_official 610:813dcc80987e 468 (*pData++) = hswpmi->Instance->RDR;
mbed_official 610:813dcc80987e 469 Size--;
mbed_official 610:813dcc80987e 470 }
mbed_official 610:813dcc80987e 471 else
mbed_official 610:813dcc80987e 472 {
mbed_official 610:813dcc80987e 473 /* Check for the Timeout */
mbed_official 610:813dcc80987e 474 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 475 {
mbed_official 610:813dcc80987e 476 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
mbed_official 610:813dcc80987e 477 {
mbed_official 610:813dcc80987e 478 status = HAL_TIMEOUT;
mbed_official 610:813dcc80987e 479 break;
mbed_official 610:813dcc80987e 480 }
mbed_official 610:813dcc80987e 481 }
mbed_official 610:813dcc80987e 482 }
mbed_official 610:813dcc80987e 483 } while(Size != 0);
mbed_official 610:813dcc80987e 484
mbed_official 610:813dcc80987e 485 if(status == HAL_OK)
mbed_official 610:813dcc80987e 486 {
mbed_official 610:813dcc80987e 487 if(HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_RXBFF))
mbed_official 610:813dcc80987e 488 {
mbed_official 610:813dcc80987e 489 /* Clear RXBFF at end of reception */
mbed_official 610:813dcc80987e 490 WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBFF);
mbed_official 610:813dcc80987e 491 }
mbed_official 610:813dcc80987e 492
mbed_official 610:813dcc80987e 493 /* Check if a non-blocking transmit Process is ongoing or not */
mbed_official 610:813dcc80987e 494 if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
mbed_official 610:813dcc80987e 495 {
mbed_official 610:813dcc80987e 496 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
mbed_official 610:813dcc80987e 497 }
mbed_official 610:813dcc80987e 498 else
mbed_official 610:813dcc80987e 499 {
mbed_official 610:813dcc80987e 500 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 501 }
mbed_official 610:813dcc80987e 502 }
mbed_official 610:813dcc80987e 503 }
mbed_official 610:813dcc80987e 504 else
mbed_official 610:813dcc80987e 505 {
mbed_official 610:813dcc80987e 506 status = HAL_BUSY;
mbed_official 610:813dcc80987e 507 }
mbed_official 610:813dcc80987e 508 }
mbed_official 610:813dcc80987e 509
mbed_official 610:813dcc80987e 510 if((status != HAL_OK) && (status != HAL_BUSY))
mbed_official 610:813dcc80987e 511 {
mbed_official 610:813dcc80987e 512 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 513 }
mbed_official 610:813dcc80987e 514 /* Process Unlocked */
mbed_official 610:813dcc80987e 515 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 516
mbed_official 610:813dcc80987e 517 return status;
mbed_official 610:813dcc80987e 518 }
mbed_official 610:813dcc80987e 519
mbed_official 610:813dcc80987e 520 /**
mbed_official 610:813dcc80987e 521 * @brief Transmit an amount of data in non-blocking mode with interrupt.
mbed_official 610:813dcc80987e 522 * @param hswpmi: pointer to a SWPMI_HandleTypeDef structure that contains
mbed_official 610:813dcc80987e 523 * the configuration information for SWPMI module.
mbed_official 610:813dcc80987e 524 * @param pData: Pointer to data buffer
mbed_official 610:813dcc80987e 525 * @param Size: Amount of data to be sent
mbed_official 610:813dcc80987e 526 * @retval HAL status
mbed_official 610:813dcc80987e 527 */
mbed_official 610:813dcc80987e 528 HAL_StatusTypeDef HAL_SWPMI_Transmit_IT(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
mbed_official 610:813dcc80987e 529 {
mbed_official 610:813dcc80987e 530 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 531
mbed_official 610:813dcc80987e 532 if((pData == NULL ) || (Size == 0))
mbed_official 610:813dcc80987e 533 {
mbed_official 610:813dcc80987e 534 status = HAL_ERROR;
mbed_official 610:813dcc80987e 535 }
mbed_official 610:813dcc80987e 536 else
mbed_official 610:813dcc80987e 537 {
mbed_official 610:813dcc80987e 538 /* Process Locked */
mbed_official 610:813dcc80987e 539 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 540
mbed_official 610:813dcc80987e 541 if((hswpmi->State == HAL_SWPMI_STATE_READY) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_RX))
mbed_official 610:813dcc80987e 542 {
mbed_official 610:813dcc80987e 543 /* Update handle */
mbed_official 610:813dcc80987e 544 hswpmi->pTxBuffPtr = pData;
mbed_official 610:813dcc80987e 545 hswpmi->TxXferSize = Size;
mbed_official 610:813dcc80987e 546 hswpmi->TxXferCount = Size;
mbed_official 610:813dcc80987e 547 hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
mbed_official 610:813dcc80987e 548
mbed_official 610:813dcc80987e 549 /* Check if a receive process is ongoing or not */
mbed_official 610:813dcc80987e 550 if(hswpmi->State == HAL_SWPMI_STATE_READY)
mbed_official 610:813dcc80987e 551 {
mbed_official 610:813dcc80987e 552 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
mbed_official 610:813dcc80987e 553
mbed_official 610:813dcc80987e 554 /* Enable SWPMI peripheral if not */
mbed_official 610:813dcc80987e 555 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 556 }
mbed_official 610:813dcc80987e 557 else
mbed_official 610:813dcc80987e 558 {
mbed_official 610:813dcc80987e 559 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
mbed_official 610:813dcc80987e 560 }
mbed_official 610:813dcc80987e 561
mbed_official 610:813dcc80987e 562 /* Enable the SWPMI transmit underrun error */
mbed_official 610:813dcc80987e 563 __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TXUNRIE);
mbed_official 610:813dcc80987e 564
mbed_official 610:813dcc80987e 565 /* Process Unlocked */
mbed_official 610:813dcc80987e 566 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 567
mbed_official 610:813dcc80987e 568 /* Enable the SWPMI interrupts: */
mbed_official 610:813dcc80987e 569 /* - Transmit data register empty */
mbed_official 610:813dcc80987e 570 /* - Transmit buffer empty */
mbed_official 610:813dcc80987e 571 /* - Transmit/Reception completion */
mbed_official 610:813dcc80987e 572 __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TIE | SWPMI_IT_TXBEIE | SWPMI_IT_TCIE);
mbed_official 610:813dcc80987e 573 }
mbed_official 610:813dcc80987e 574 else
mbed_official 610:813dcc80987e 575 {
mbed_official 610:813dcc80987e 576 status = HAL_BUSY;
mbed_official 610:813dcc80987e 577
mbed_official 610:813dcc80987e 578 /* Process Unlocked */
mbed_official 610:813dcc80987e 579 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 580 }
mbed_official 610:813dcc80987e 581 }
mbed_official 610:813dcc80987e 582
mbed_official 610:813dcc80987e 583 return status;
mbed_official 610:813dcc80987e 584 }
mbed_official 610:813dcc80987e 585
mbed_official 610:813dcc80987e 586 /**
mbed_official 610:813dcc80987e 587 * @brief Receive an amount of data in non-blocking mode with interrupt.
mbed_official 610:813dcc80987e 588 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 589 * @param pData: pointer to data buffer
mbed_official 610:813dcc80987e 590 * @param Size: amount of data to be received
mbed_official 610:813dcc80987e 591 * @retval HAL status
mbed_official 610:813dcc80987e 592 */
mbed_official 610:813dcc80987e 593 HAL_StatusTypeDef HAL_SWPMI_Receive_IT(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
mbed_official 610:813dcc80987e 594 {
mbed_official 610:813dcc80987e 595 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 596
mbed_official 610:813dcc80987e 597 if((pData == NULL ) || (Size == 0))
mbed_official 610:813dcc80987e 598 {
mbed_official 610:813dcc80987e 599 status = HAL_ERROR;
mbed_official 610:813dcc80987e 600 }
mbed_official 610:813dcc80987e 601 else
mbed_official 610:813dcc80987e 602 {
mbed_official 610:813dcc80987e 603 /* Process Locked */
mbed_official 610:813dcc80987e 604 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 605
mbed_official 610:813dcc80987e 606 if((hswpmi->State == HAL_SWPMI_STATE_READY) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX))
mbed_official 610:813dcc80987e 607 {
mbed_official 610:813dcc80987e 608 /* Update handle */
mbed_official 610:813dcc80987e 609 hswpmi->pRxBuffPtr = pData;
mbed_official 610:813dcc80987e 610 hswpmi->RxXferSize = Size;
mbed_official 610:813dcc80987e 611 hswpmi->RxXferCount = Size;
mbed_official 610:813dcc80987e 612 hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
mbed_official 610:813dcc80987e 613
mbed_official 610:813dcc80987e 614 /* Check if a transmit process is ongoing or not */
mbed_official 610:813dcc80987e 615 if(hswpmi->State == HAL_SWPMI_STATE_READY)
mbed_official 610:813dcc80987e 616 {
mbed_official 610:813dcc80987e 617 hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
mbed_official 610:813dcc80987e 618
mbed_official 610:813dcc80987e 619 /* Enable SWPMI peripheral if not */
mbed_official 610:813dcc80987e 620 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 621 }
mbed_official 610:813dcc80987e 622 else
mbed_official 610:813dcc80987e 623 {
mbed_official 610:813dcc80987e 624 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
mbed_official 610:813dcc80987e 625 }
mbed_official 610:813dcc80987e 626
mbed_official 610:813dcc80987e 627 /* Process Unlocked */
mbed_official 610:813dcc80987e 628 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 629
mbed_official 610:813dcc80987e 630 /* Enable the SWPMI slave resume */
mbed_official 610:813dcc80987e 631 /* Enable the SWPMI Data Register not empty Interrupt, receive CRC Error, receive overrun and RxBuf Interrupt */
mbed_official 610:813dcc80987e 632 /* Enable the SWPMI Transmit/Reception completion */
mbed_official 610:813dcc80987e 633 __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);
mbed_official 610:813dcc80987e 634 }
mbed_official 610:813dcc80987e 635 else
mbed_official 610:813dcc80987e 636 {
mbed_official 610:813dcc80987e 637 status = HAL_BUSY;
mbed_official 610:813dcc80987e 638
mbed_official 610:813dcc80987e 639 /* Process Unlocked */
mbed_official 610:813dcc80987e 640 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 641 }
mbed_official 610:813dcc80987e 642 }
mbed_official 610:813dcc80987e 643
mbed_official 610:813dcc80987e 644 return status;
mbed_official 610:813dcc80987e 645 }
mbed_official 610:813dcc80987e 646
mbed_official 610:813dcc80987e 647 /**
mbed_official 610:813dcc80987e 648 * @brief Transmit an amount of data in non-blocking mode with DMA interrupt.
mbed_official 610:813dcc80987e 649 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 650 * @param pData: pointer to data buffer
mbed_official 610:813dcc80987e 651 * @param Size: amount of data to be sent
mbed_official 610:813dcc80987e 652 * @retval HAL status
mbed_official 610:813dcc80987e 653 */
mbed_official 610:813dcc80987e 654 HAL_StatusTypeDef HAL_SWPMI_Transmit_DMA(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
mbed_official 610:813dcc80987e 655 {
mbed_official 610:813dcc80987e 656 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 657
mbed_official 610:813dcc80987e 658 if((pData == NULL ) || (Size == 0))
mbed_official 610:813dcc80987e 659 {
mbed_official 610:813dcc80987e 660 status = HAL_ERROR;
mbed_official 610:813dcc80987e 661 }
mbed_official 610:813dcc80987e 662 else
mbed_official 610:813dcc80987e 663 {
mbed_official 610:813dcc80987e 664 /* Process Locked */
mbed_official 610:813dcc80987e 665 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 666
mbed_official 610:813dcc80987e 667 if((hswpmi->State == HAL_SWPMI_STATE_READY) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_RX))
mbed_official 610:813dcc80987e 668 {
mbed_official 610:813dcc80987e 669 /* Update handle */
mbed_official 610:813dcc80987e 670 hswpmi->pTxBuffPtr = pData;
mbed_official 610:813dcc80987e 671 hswpmi->TxXferSize = Size;
mbed_official 610:813dcc80987e 672 hswpmi->TxXferCount = Size;
mbed_official 610:813dcc80987e 673 hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
mbed_official 610:813dcc80987e 674
mbed_official 610:813dcc80987e 675 /* Check if a receive process is ongoing or not */
mbed_official 610:813dcc80987e 676 if(hswpmi->State == HAL_SWPMI_STATE_READY)
mbed_official 610:813dcc80987e 677 {
mbed_official 610:813dcc80987e 678 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
mbed_official 610:813dcc80987e 679
mbed_official 610:813dcc80987e 680 /* Enable SWPMI peripheral if not */
mbed_official 610:813dcc80987e 681 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 682 }
mbed_official 610:813dcc80987e 683 else
mbed_official 610:813dcc80987e 684 {
mbed_official 610:813dcc80987e 685 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
mbed_official 610:813dcc80987e 686 }
mbed_official 610:813dcc80987e 687
mbed_official 610:813dcc80987e 688 /* Set the SWPMI DMA transfer complete callback */
mbed_official 610:813dcc80987e 689 hswpmi->hdmatx->XferCpltCallback = SWPMI_DMATransmitCplt;
mbed_official 610:813dcc80987e 690
mbed_official 610:813dcc80987e 691 /* Set the SWPMI DMA Half transfer complete callback */
mbed_official 610:813dcc80987e 692 hswpmi->hdmatx->XferHalfCpltCallback = SWPMI_DMATxHalfCplt;
mbed_official 610:813dcc80987e 693
mbed_official 610:813dcc80987e 694 /* Set the DMA error callback */
mbed_official 610:813dcc80987e 695 hswpmi->hdmatx->XferErrorCallback = SWPMI_DMAError;
mbed_official 610:813dcc80987e 696
mbed_official 610:813dcc80987e 697 /* Enable the SWPMI transmit DMA Stream */
mbed_official 610:813dcc80987e 698 HAL_DMA_Start_IT(hswpmi->hdmatx, (uint32_t)hswpmi->pTxBuffPtr, (uint32_t)&hswpmi->Instance->TDR, Size);
mbed_official 610:813dcc80987e 699
mbed_official 610:813dcc80987e 700 /* Process Unlocked */
mbed_official 610:813dcc80987e 701 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 702
mbed_official 610:813dcc80987e 703 /* Enable the DMA transfer for transmit request by setting the TXDMA bit
mbed_official 610:813dcc80987e 704 in the SWPMI CR register */
mbed_official 610:813dcc80987e 705 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_TXDMA);
mbed_official 610:813dcc80987e 706 }
mbed_official 610:813dcc80987e 707 else
mbed_official 610:813dcc80987e 708 {
mbed_official 610:813dcc80987e 709 status = HAL_BUSY;
mbed_official 610:813dcc80987e 710
mbed_official 610:813dcc80987e 711 /* Process Unlocked */
mbed_official 610:813dcc80987e 712 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 713 }
mbed_official 610:813dcc80987e 714 }
mbed_official 610:813dcc80987e 715
mbed_official 610:813dcc80987e 716 return status;
mbed_official 610:813dcc80987e 717 }
mbed_official 610:813dcc80987e 718
mbed_official 610:813dcc80987e 719 /**
mbed_official 610:813dcc80987e 720 * @brief Receive an amount of data in non-blocking mode with DMA interrupt.
mbed_official 610:813dcc80987e 721 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 722 * @param pData: pointer to data buffer
mbed_official 610:813dcc80987e 723 * @param Size: amount of data to be received
mbed_official 610:813dcc80987e 724 * @retval HAL status
mbed_official 610:813dcc80987e 725 */
mbed_official 610:813dcc80987e 726 HAL_StatusTypeDef HAL_SWPMI_Receive_DMA(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
mbed_official 610:813dcc80987e 727 {
mbed_official 610:813dcc80987e 728 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 729
mbed_official 610:813dcc80987e 730 if((pData == NULL ) || (Size == 0))
mbed_official 610:813dcc80987e 731 {
mbed_official 610:813dcc80987e 732 status = HAL_ERROR;
mbed_official 610:813dcc80987e 733 }
mbed_official 610:813dcc80987e 734 else
mbed_official 610:813dcc80987e 735 {
mbed_official 610:813dcc80987e 736 /* Process Locked */
mbed_official 610:813dcc80987e 737 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 738
mbed_official 610:813dcc80987e 739 if((hswpmi->State == HAL_SWPMI_STATE_READY) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX))
mbed_official 610:813dcc80987e 740 {
mbed_official 610:813dcc80987e 741 /* Update handle */
mbed_official 610:813dcc80987e 742 hswpmi->pRxBuffPtr = pData;
mbed_official 610:813dcc80987e 743 hswpmi->RxXferSize = Size;
mbed_official 610:813dcc80987e 744 hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
mbed_official 610:813dcc80987e 745
mbed_official 610:813dcc80987e 746 /* Check if a transmit process is ongoing or not */
mbed_official 610:813dcc80987e 747 if(hswpmi->State == HAL_SWPMI_STATE_READY)
mbed_official 610:813dcc80987e 748 {
mbed_official 610:813dcc80987e 749 hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
mbed_official 610:813dcc80987e 750
mbed_official 610:813dcc80987e 751 /* Enable SWPMI peripheral if not */
mbed_official 610:813dcc80987e 752 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 753 }
mbed_official 610:813dcc80987e 754 else
mbed_official 610:813dcc80987e 755 {
mbed_official 610:813dcc80987e 756 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
mbed_official 610:813dcc80987e 757 }
mbed_official 610:813dcc80987e 758
mbed_official 610:813dcc80987e 759 /* Set the SWPMI DMA transfer complete callback */
mbed_official 610:813dcc80987e 760 hswpmi->hdmarx->XferCpltCallback = SWPMI_DMAReceiveCplt;
mbed_official 610:813dcc80987e 761
mbed_official 610:813dcc80987e 762 /* Set the SWPMI DMA Half transfer complete callback */
mbed_official 610:813dcc80987e 763 hswpmi->hdmarx->XferHalfCpltCallback = SWPMI_DMARxHalfCplt;
mbed_official 610:813dcc80987e 764
mbed_official 610:813dcc80987e 765 /* Set the DMA error callback */
mbed_official 610:813dcc80987e 766 hswpmi->hdmarx->XferErrorCallback = SWPMI_DMAError;
mbed_official 610:813dcc80987e 767
mbed_official 610:813dcc80987e 768 /* Enable the DMA request */
mbed_official 610:813dcc80987e 769 HAL_DMA_Start_IT(hswpmi->hdmarx, (uint32_t)&hswpmi->Instance->RDR, (uint32_t)hswpmi->pRxBuffPtr, Size);
mbed_official 610:813dcc80987e 770
mbed_official 610:813dcc80987e 771 /* Process Unlocked */
mbed_official 610:813dcc80987e 772 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 773
mbed_official 610:813dcc80987e 774 /* Enable the DMA transfer for the receiver request by setting the RXDMA bit
mbed_official 610:813dcc80987e 775 in the SWPMI CR register */
mbed_official 610:813dcc80987e 776 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_RXDMA);
mbed_official 610:813dcc80987e 777 }
mbed_official 610:813dcc80987e 778 else
mbed_official 610:813dcc80987e 779 {
mbed_official 610:813dcc80987e 780 status = HAL_BUSY;
mbed_official 610:813dcc80987e 781
mbed_official 610:813dcc80987e 782 /* Process Unlocked */
mbed_official 610:813dcc80987e 783 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 784 }
mbed_official 610:813dcc80987e 785 }
mbed_official 610:813dcc80987e 786
mbed_official 610:813dcc80987e 787 return status;
mbed_official 610:813dcc80987e 788 }
mbed_official 610:813dcc80987e 789
mbed_official 610:813dcc80987e 790 /**
mbed_official 610:813dcc80987e 791 * @brief Stop all DMA transfers.
mbed_official 610:813dcc80987e 792 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 793 * @retval HAL_OK
mbed_official 610:813dcc80987e 794 */
mbed_official 610:813dcc80987e 795 HAL_StatusTypeDef HAL_SWPMI_DMAStop(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 796 {
mbed_official 610:813dcc80987e 797 /* Process Locked */
mbed_official 610:813dcc80987e 798 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 799
mbed_official 610:813dcc80987e 800 /* Disable the SWPMI Tx/Rx DMA requests */
mbed_official 610:813dcc80987e 801 CLEAR_BIT(hswpmi->Instance->CR, (SWPMI_CR_TXDMA | SWPMI_CR_RXDMA));
mbed_official 610:813dcc80987e 802
mbed_official 610:813dcc80987e 803 /* Abort the SWPMI DMA tx channel */
mbed_official 610:813dcc80987e 804 if(hswpmi->hdmatx != NULL)
mbed_official 610:813dcc80987e 805 {
mbed_official 610:813dcc80987e 806 HAL_DMA_Abort(hswpmi->hdmatx);
mbed_official 610:813dcc80987e 807 }
mbed_official 610:813dcc80987e 808 /* Abort the SWPMI DMA rx channel */
mbed_official 610:813dcc80987e 809 if(hswpmi->hdmarx != NULL)
mbed_official 610:813dcc80987e 810 {
mbed_official 610:813dcc80987e 811 HAL_DMA_Abort(hswpmi->hdmarx);
mbed_official 610:813dcc80987e 812 }
mbed_official 610:813dcc80987e 813
mbed_official 610:813dcc80987e 814 /* Disable SWPMI interface */
mbed_official 610:813dcc80987e 815 CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
mbed_official 610:813dcc80987e 816
mbed_official 610:813dcc80987e 817 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 818
mbed_official 610:813dcc80987e 819 /* Process Unlocked */
mbed_official 610:813dcc80987e 820 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 821
mbed_official 610:813dcc80987e 822 return HAL_OK;
mbed_official 610:813dcc80987e 823 }
mbed_official 610:813dcc80987e 824
mbed_official 610:813dcc80987e 825
mbed_official 610:813dcc80987e 826 /**
mbed_official 610:813dcc80987e 827 * @brief Enable the Loopback mode.
mbed_official 610:813dcc80987e 828 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 829 * @note Loopback mode is to be used only for test purposes
mbed_official 610:813dcc80987e 830 * @retval HAL_OK / HAL_BUSY
mbed_official 610:813dcc80987e 831 */
mbed_official 610:813dcc80987e 832 HAL_StatusTypeDef HAL_SWPMI_EnableLoopback(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 833 {
mbed_official 610:813dcc80987e 834 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 835
mbed_official 610:813dcc80987e 836 /* Process Locked */
mbed_official 610:813dcc80987e 837 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 838
mbed_official 610:813dcc80987e 839 /* Check SWPMI not enabled */
mbed_official 610:813dcc80987e 840 if(READ_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT) != RESET)
mbed_official 610:813dcc80987e 841 {
mbed_official 610:813dcc80987e 842 status = HAL_BUSY;
mbed_official 610:813dcc80987e 843 }
mbed_official 610:813dcc80987e 844 else
mbed_official 610:813dcc80987e 845 {
mbed_official 610:813dcc80987e 846 /* Set Loopback */
mbed_official 610:813dcc80987e 847 SET_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);
mbed_official 610:813dcc80987e 848 }
mbed_official 610:813dcc80987e 849
mbed_official 610:813dcc80987e 850 /* Process Unlocked */
mbed_official 610:813dcc80987e 851 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 852
mbed_official 610:813dcc80987e 853 return status;
mbed_official 610:813dcc80987e 854 }
mbed_official 610:813dcc80987e 855
mbed_official 610:813dcc80987e 856 /**
mbed_official 610:813dcc80987e 857 * @brief Disable the Loopback mode.
mbed_official 610:813dcc80987e 858 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 859 * @note Loopback mode is to be used only for test purposes
mbed_official 610:813dcc80987e 860 * @retval HAL_OK / HAL_BUSY
mbed_official 610:813dcc80987e 861 */
mbed_official 610:813dcc80987e 862 HAL_StatusTypeDef HAL_SWPMI_DisableLoopback(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 863 {
mbed_official 610:813dcc80987e 864 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 865
mbed_official 610:813dcc80987e 866 /* Process Locked */
mbed_official 610:813dcc80987e 867 __HAL_LOCK(hswpmi);
mbed_official 610:813dcc80987e 868
mbed_official 610:813dcc80987e 869 /* Check SWPMI not enabled */
mbed_official 610:813dcc80987e 870 if(READ_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT) != RESET)
mbed_official 610:813dcc80987e 871 {
mbed_official 610:813dcc80987e 872 status = HAL_BUSY;
mbed_official 610:813dcc80987e 873 }
mbed_official 610:813dcc80987e 874 else
mbed_official 610:813dcc80987e 875 {
mbed_official 610:813dcc80987e 876 /* Reset Loopback */
mbed_official 610:813dcc80987e 877 CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);
mbed_official 610:813dcc80987e 878 }
mbed_official 610:813dcc80987e 879
mbed_official 610:813dcc80987e 880 /* Process Unlocked */
mbed_official 610:813dcc80987e 881 __HAL_UNLOCK(hswpmi);
mbed_official 610:813dcc80987e 882
mbed_official 610:813dcc80987e 883 return status;
mbed_official 610:813dcc80987e 884 }
mbed_official 610:813dcc80987e 885
mbed_official 610:813dcc80987e 886 /**
mbed_official 610:813dcc80987e 887 * @}
mbed_official 610:813dcc80987e 888 */
mbed_official 610:813dcc80987e 889
mbed_official 610:813dcc80987e 890 /** @defgroup SWPMI_Exported_Group3 SWPMI IRQ handler and callbacks
mbed_official 610:813dcc80987e 891 * @brief SWPMI IRQ handler.
mbed_official 610:813dcc80987e 892 *
mbed_official 610:813dcc80987e 893 @verbatim
mbed_official 610:813dcc80987e 894 ==============================================================================
mbed_official 610:813dcc80987e 895 ##### SWPMI IRQ handler and callbacks #####
mbed_official 610:813dcc80987e 896 ==============================================================================
mbed_official 610:813dcc80987e 897 [..] This section provides SWPMI IRQ handler and callback functions called within
mbed_official 610:813dcc80987e 898 the IRQ handler.
mbed_official 610:813dcc80987e 899
mbed_official 610:813dcc80987e 900 @endverbatim
mbed_official 610:813dcc80987e 901 * @{
mbed_official 610:813dcc80987e 902 */
mbed_official 610:813dcc80987e 903
mbed_official 610:813dcc80987e 904 /**
mbed_official 610:813dcc80987e 905 * @brief Handle SWPMI interrupt request.
mbed_official 610:813dcc80987e 906 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 907 * @retval None
mbed_official 610:813dcc80987e 908 */
mbed_official 610:813dcc80987e 909 void HAL_SWPMI_IRQHandler(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 910 {
mbed_official 610:813dcc80987e 911 uint32_t regisr = READ_REG(hswpmi->Instance->ISR);
mbed_official 610:813dcc80987e 912 uint32_t regier = READ_REG(hswpmi->Instance->IER);
mbed_official 610:813dcc80987e 913
mbed_official 610:813dcc80987e 914 /* SWPMI CRC error interrupt occurred --------------------------------------*/
mbed_official 610:813dcc80987e 915 if(((regisr & SWPMI_FLAG_RXBERF) != RESET) && ((regier & SWPMI_IT_RXBERIE) != RESET))
mbed_official 610:813dcc80987e 916 {
mbed_official 610:813dcc80987e 917 /* Disable Receive CRC interrupt */
mbed_official 610:813dcc80987e 918 CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RXBERIE | SWPMI_IT_RXBFIE);
mbed_official 610:813dcc80987e 919 /* Clear Receive CRC and Receive buffer full flag */
mbed_official 610:813dcc80987e 920 WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBERF | SWPMI_FLAG_RXBFF);
mbed_official 610:813dcc80987e 921
mbed_official 610:813dcc80987e 922 hswpmi->ErrorCode |= HAL_SWPMI_ERROR_CRC;
mbed_official 610:813dcc80987e 923 }
mbed_official 610:813dcc80987e 924
mbed_official 610:813dcc80987e 925 /* SWPMI Over-Run interrupt occurred -----------------------------------------*/
mbed_official 610:813dcc80987e 926 if(((regisr & SWPMI_FLAG_RXOVRF) != RESET) && ((regier & SWPMI_IT_RXOVRIE) != RESET))
mbed_official 610:813dcc80987e 927 {
mbed_official 610:813dcc80987e 928 /* Disable Receive overrun interrupt */
mbed_official 610:813dcc80987e 929 CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RXOVRIE);
mbed_official 610:813dcc80987e 930 /* Clear Receive overrun flag */
mbed_official 610:813dcc80987e 931 WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXOVRF);
mbed_official 610:813dcc80987e 932
mbed_official 610:813dcc80987e 933 hswpmi->ErrorCode |= HAL_SWPMI_ERROR_OVR;
mbed_official 610:813dcc80987e 934 }
mbed_official 610:813dcc80987e 935
mbed_official 610:813dcc80987e 936 /* SWPMI Under-Run interrupt occurred -----------------------------------------*/
mbed_official 610:813dcc80987e 937 if(((regisr & SWPMI_FLAG_TXUNRF) != RESET) && ((regier & SWPMI_IT_TXUNRIE) != RESET))
mbed_official 610:813dcc80987e 938 {
mbed_official 610:813dcc80987e 939 /* Disable Transmit under run interrupt */
mbed_official 610:813dcc80987e 940 CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_TXUNRIE);
mbed_official 610:813dcc80987e 941 /* Clear Transmit under run flag */
mbed_official 610:813dcc80987e 942 WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_TXUNRF);
mbed_official 610:813dcc80987e 943
mbed_official 610:813dcc80987e 944 hswpmi->ErrorCode |= HAL_SWPMI_ERROR_UDR;
mbed_official 610:813dcc80987e 945 }
mbed_official 610:813dcc80987e 946
mbed_official 610:813dcc80987e 947 /* Call SWPMI Error Call back function if need be --------------------------*/
mbed_official 610:813dcc80987e 948 if(hswpmi->ErrorCode != HAL_SWPMI_ERROR_NONE)
mbed_official 610:813dcc80987e 949 {
mbed_official 610:813dcc80987e 950 /* Set the SWPMI state ready to be able to start again the process */
mbed_official 610:813dcc80987e 951 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 952
mbed_official 610:813dcc80987e 953 HAL_SWPMI_ErrorCallback(hswpmi);
mbed_official 610:813dcc80987e 954 }
mbed_official 610:813dcc80987e 955
mbed_official 610:813dcc80987e 956 /* SWPMI in mode Receiver ---------------------------------------------------*/
mbed_official 610:813dcc80987e 957 if(((regisr & SWPMI_FLAG_RXNE) != RESET) && ((regier & SWPMI_IT_RIE) != RESET))
mbed_official 610:813dcc80987e 958 {
mbed_official 610:813dcc80987e 959 SWPMI_Receive_IT(hswpmi);
mbed_official 610:813dcc80987e 960 }
mbed_official 610:813dcc80987e 961
mbed_official 610:813dcc80987e 962 /* SWPMI in mode Transmitter ------------------------------------------------*/
mbed_official 610:813dcc80987e 963 if(((regisr & SWPMI_FLAG_TXE) != RESET) && ((regier & SWPMI_IT_TIE) != RESET))
mbed_official 610:813dcc80987e 964 {
mbed_official 610:813dcc80987e 965 SWPMI_Transmit_IT(hswpmi);
mbed_official 610:813dcc80987e 966 }
mbed_official 610:813dcc80987e 967
mbed_official 610:813dcc80987e 968 /* SWPMI in mode Transmitter (Transmit buffer empty) ------------------------*/
mbed_official 610:813dcc80987e 969 if(((regisr & SWPMI_FLAG_TXBEF) != RESET) && ((regier & SWPMI_IT_TXBEIE) != RESET))
mbed_official 610:813dcc80987e 970 {
mbed_official 610:813dcc80987e 971 SWPMI_EndTransmit_IT(hswpmi);
mbed_official 610:813dcc80987e 972 }
mbed_official 610:813dcc80987e 973
mbed_official 610:813dcc80987e 974 /* SWPMI in mode Receiver (Receive buffer full) -----------------------------*/
mbed_official 610:813dcc80987e 975 if(((regisr & SWPMI_FLAG_RXBFF) != RESET) && ((regier & SWPMI_IT_RXBFIE) != RESET))
mbed_official 610:813dcc80987e 976 {
mbed_official 610:813dcc80987e 977 SWPMI_EndReceive_IT(hswpmi);
mbed_official 610:813dcc80987e 978 }
mbed_official 610:813dcc80987e 979
mbed_official 610:813dcc80987e 980 /* Both Transmission and reception complete ---------------------------------*/
mbed_official 610:813dcc80987e 981 if(((regisr & SWPMI_FLAG_TCF) != RESET) && ((regier & SWPMI_IT_TCIE) != RESET))
mbed_official 610:813dcc80987e 982 {
mbed_official 610:813dcc80987e 983 SWPMI_EndTransmitReceive_IT(hswpmi);
mbed_official 610:813dcc80987e 984 }
mbed_official 610:813dcc80987e 985 }
mbed_official 610:813dcc80987e 986
mbed_official 610:813dcc80987e 987 /**
mbed_official 610:813dcc80987e 988 * @brief Tx Transfer completed callback.
mbed_official 610:813dcc80987e 989 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 990 * @retval None
mbed_official 610:813dcc80987e 991 */
mbed_official 610:813dcc80987e 992 __weak void HAL_SWPMI_TxCpltCallback(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 993 {
mbed_official 610:813dcc80987e 994 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 995 the HAL_SWPMI_TxCpltCallback is to be implemented in the user file
mbed_official 610:813dcc80987e 996 */
mbed_official 610:813dcc80987e 997 }
mbed_official 610:813dcc80987e 998
mbed_official 610:813dcc80987e 999 /**
mbed_official 610:813dcc80987e 1000 * @brief Tx Half Transfer completed callback.
mbed_official 610:813dcc80987e 1001 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1002 * @retval None
mbed_official 610:813dcc80987e 1003 */
mbed_official 610:813dcc80987e 1004 __weak void HAL_SWPMI_TxHalfCpltCallback(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1005 {
mbed_official 610:813dcc80987e 1006 /* NOTE: This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 1007 the HAL_SWPMI_TxHalfCpltCallback is to be implemented in the user file
mbed_official 610:813dcc80987e 1008 */
mbed_official 610:813dcc80987e 1009 }
mbed_official 610:813dcc80987e 1010
mbed_official 610:813dcc80987e 1011 /**
mbed_official 610:813dcc80987e 1012 * @brief Rx Transfer completed callback.
mbed_official 610:813dcc80987e 1013 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1014 * @retval None
mbed_official 610:813dcc80987e 1015 */
mbed_official 610:813dcc80987e 1016 __weak void HAL_SWPMI_RxCpltCallback(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1017 {
mbed_official 610:813dcc80987e 1018 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 1019 the HAL_SWPMI_RxCpltCallback is to be implemented in the user file
mbed_official 610:813dcc80987e 1020 */
mbed_official 610:813dcc80987e 1021 }
mbed_official 610:813dcc80987e 1022
mbed_official 610:813dcc80987e 1023 /**
mbed_official 610:813dcc80987e 1024 * @brief Rx Half Transfer completed callback.
mbed_official 610:813dcc80987e 1025 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1026 * @retval None
mbed_official 610:813dcc80987e 1027 */
mbed_official 610:813dcc80987e 1028 __weak void HAL_SWPMI_RxHalfCpltCallback(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1029 {
mbed_official 610:813dcc80987e 1030 /* NOTE: This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 1031 the HAL_SWPMI_RxHalfCpltCallback is to be implemented in the user file
mbed_official 610:813dcc80987e 1032 */
mbed_official 610:813dcc80987e 1033 }
mbed_official 610:813dcc80987e 1034
mbed_official 610:813dcc80987e 1035 /**
mbed_official 610:813dcc80987e 1036 * @brief SWPMI error callback.
mbed_official 610:813dcc80987e 1037 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1038 * @retval None
mbed_official 610:813dcc80987e 1039 */
mbed_official 610:813dcc80987e 1040 __weak void HAL_SWPMI_ErrorCallback(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1041 {
mbed_official 610:813dcc80987e 1042 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 1043 the HAL_SWPMI_ErrorCallback is to be implemented in the user file
mbed_official 610:813dcc80987e 1044 */
mbed_official 610:813dcc80987e 1045 }
mbed_official 610:813dcc80987e 1046
mbed_official 610:813dcc80987e 1047 /**
mbed_official 610:813dcc80987e 1048 * @}
mbed_official 610:813dcc80987e 1049 */
mbed_official 610:813dcc80987e 1050
mbed_official 610:813dcc80987e 1051 /** @defgroup SWPMI_Exported_Group4 Peripheral Control methods
mbed_official 610:813dcc80987e 1052 * @brief SWPMI control functions
mbed_official 610:813dcc80987e 1053 *
mbed_official 610:813dcc80987e 1054 @verbatim
mbed_official 610:813dcc80987e 1055 ===============================================================================
mbed_official 610:813dcc80987e 1056 ##### Peripheral Control methods #####
mbed_official 610:813dcc80987e 1057 ===============================================================================
mbed_official 610:813dcc80987e 1058 [..]
mbed_official 610:813dcc80987e 1059 This subsection provides a set of functions allowing to control the SWPMI.
mbed_official 610:813dcc80987e 1060 (+) HAL_SWPMI_GetState() API is helpful to check in run-time the state of the SWPMI peripheral
mbed_official 610:813dcc80987e 1061 (+) HAL_SWPMI_GetError() API is helpful to check in run-time the error state of the SWPMI peripheral
mbed_official 610:813dcc80987e 1062 @endverbatim
mbed_official 610:813dcc80987e 1063 * @{
mbed_official 610:813dcc80987e 1064 */
mbed_official 610:813dcc80987e 1065
mbed_official 610:813dcc80987e 1066 /**
mbed_official 610:813dcc80987e 1067 * @brief Return the SWPMI handle state.
mbed_official 610:813dcc80987e 1068 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1069 * @retval HAL state
mbed_official 610:813dcc80987e 1070 */
mbed_official 610:813dcc80987e 1071 HAL_SWPMI_StateTypeDef HAL_SWPMI_GetState(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1072 {
mbed_official 610:813dcc80987e 1073 /* Return SWPMI handle state */
mbed_official 610:813dcc80987e 1074 return hswpmi->State;
mbed_official 610:813dcc80987e 1075 }
mbed_official 610:813dcc80987e 1076
mbed_official 610:813dcc80987e 1077 /**
mbed_official 610:813dcc80987e 1078 * @brief Return the SWPMI error code.
mbed_official 610:813dcc80987e 1079 * @param hswpmi : pointer to a SWPMI_HandleTypeDef structure that contains
mbed_official 610:813dcc80987e 1080 * the configuration information for the specified SWPMI.
mbed_official 610:813dcc80987e 1081 * @retval SWPMI Error Code
mbed_official 610:813dcc80987e 1082 */
mbed_official 610:813dcc80987e 1083 uint32_t HAL_SWPMI_GetError(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1084 {
mbed_official 610:813dcc80987e 1085 return hswpmi->ErrorCode;
mbed_official 610:813dcc80987e 1086 }
mbed_official 610:813dcc80987e 1087
mbed_official 610:813dcc80987e 1088 /**
mbed_official 610:813dcc80987e 1089 * @}
mbed_official 610:813dcc80987e 1090 */
mbed_official 610:813dcc80987e 1091
mbed_official 610:813dcc80987e 1092 /* Private functions ---------------------------------------------------------*/
mbed_official 610:813dcc80987e 1093
mbed_official 610:813dcc80987e 1094 /** @defgroup SWPMI_Private_Functions SWPMI Private Functions
mbed_official 610:813dcc80987e 1095 * @{
mbed_official 610:813dcc80987e 1096 */
mbed_official 610:813dcc80987e 1097
mbed_official 610:813dcc80987e 1098 /**
mbed_official 610:813dcc80987e 1099 * @brief Transmit an amount of data in interrupt mode.
mbed_official 610:813dcc80987e 1100 * @note Function called under interruption only, once interruptions have been enabled by HAL_SWPMI_Transmit_IT()
mbed_official 610:813dcc80987e 1101 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1102 * @retval HAL status
mbed_official 610:813dcc80987e 1103 */
mbed_official 610:813dcc80987e 1104 static HAL_StatusTypeDef SWPMI_Transmit_IT(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1105 {
mbed_official 610:813dcc80987e 1106 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1107
mbed_official 610:813dcc80987e 1108 if ((hswpmi->State == HAL_SWPMI_STATE_BUSY_TX) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX))
mbed_official 610:813dcc80987e 1109 {
mbed_official 610:813dcc80987e 1110 if(hswpmi->TxXferCount == 0)
mbed_official 610:813dcc80987e 1111 {
mbed_official 610:813dcc80987e 1112 /* Disable the SWPMI TXE and Underrun Interrupts */
mbed_official 610:813dcc80987e 1113 CLEAR_BIT(hswpmi->Instance->IER, (SWPMI_IT_TIE | SWPMI_IT_TXUNRIE));
mbed_official 610:813dcc80987e 1114 }
mbed_official 610:813dcc80987e 1115 else
mbed_official 610:813dcc80987e 1116 {
mbed_official 610:813dcc80987e 1117 hswpmi->Instance->TDR = (uint32_t)(*hswpmi->pTxBuffPtr++);
mbed_official 610:813dcc80987e 1118 hswpmi->TxXferCount--;
mbed_official 610:813dcc80987e 1119 }
mbed_official 610:813dcc80987e 1120 }
mbed_official 610:813dcc80987e 1121 else
mbed_official 610:813dcc80987e 1122 {
mbed_official 610:813dcc80987e 1123 status = HAL_BUSY;
mbed_official 610:813dcc80987e 1124 }
mbed_official 610:813dcc80987e 1125
mbed_official 610:813dcc80987e 1126 return status;
mbed_official 610:813dcc80987e 1127 }
mbed_official 610:813dcc80987e 1128
mbed_official 610:813dcc80987e 1129 /**
mbed_official 610:813dcc80987e 1130 * @brief Wraps up transmission in non-blocking mode.
mbed_official 610:813dcc80987e 1131 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1132 * @retval HAL status
mbed_official 610:813dcc80987e 1133 * @retval HAL status
mbed_official 610:813dcc80987e 1134 */
mbed_official 610:813dcc80987e 1135 static HAL_StatusTypeDef SWPMI_EndTransmit_IT(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1136 {
mbed_official 610:813dcc80987e 1137 /* Clear the SWPMI Transmit buffer empty Flag */
mbed_official 610:813dcc80987e 1138 WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_TXBEF);
mbed_official 610:813dcc80987e 1139 /* Disable the all SWPMI Transmit Interrupts */
mbed_official 610:813dcc80987e 1140 CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_TIE | SWPMI_IT_TXUNRIE | SWPMI_IT_TXBEIE);
mbed_official 610:813dcc80987e 1141
mbed_official 610:813dcc80987e 1142 /* Check if a receive Process is ongoing or not */
mbed_official 610:813dcc80987e 1143 if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
mbed_official 610:813dcc80987e 1144 {
mbed_official 610:813dcc80987e 1145 hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
mbed_official 610:813dcc80987e 1146 }
mbed_official 610:813dcc80987e 1147 else
mbed_official 610:813dcc80987e 1148 {
mbed_official 610:813dcc80987e 1149 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 1150 }
mbed_official 610:813dcc80987e 1151
mbed_official 610:813dcc80987e 1152 HAL_SWPMI_TxCpltCallback(hswpmi);
mbed_official 610:813dcc80987e 1153
mbed_official 610:813dcc80987e 1154 return HAL_OK;
mbed_official 610:813dcc80987e 1155 }
mbed_official 610:813dcc80987e 1156
mbed_official 610:813dcc80987e 1157 /**
mbed_official 610:813dcc80987e 1158 * @brief Receive an amount of data in interrupt mode.
mbed_official 610:813dcc80987e 1159 * @note Function called under interruption only, once interruptions have been enabled by HAL_SWPMI_Receive_IT()
mbed_official 610:813dcc80987e 1160 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1161 * @retval HAL status
mbed_official 610:813dcc80987e 1162 */
mbed_official 610:813dcc80987e 1163 static HAL_StatusTypeDef SWPMI_Receive_IT(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1164 {
mbed_official 610:813dcc80987e 1165 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1166
mbed_official 610:813dcc80987e 1167 if((hswpmi->State == HAL_SWPMI_STATE_BUSY_RX) || (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX))
mbed_official 610:813dcc80987e 1168 {
mbed_official 610:813dcc80987e 1169 *hswpmi->pRxBuffPtr++ = (uint32_t)(hswpmi->Instance->RDR);
mbed_official 610:813dcc80987e 1170
mbed_official 610:813dcc80987e 1171 if(--hswpmi->RxXferCount == 0)
mbed_official 610:813dcc80987e 1172 {
mbed_official 610:813dcc80987e 1173 /* Wait for RXBFF flag to update state */
mbed_official 610:813dcc80987e 1174 HAL_SWPMI_RxCpltCallback(hswpmi);
mbed_official 610:813dcc80987e 1175 }
mbed_official 610:813dcc80987e 1176 }
mbed_official 610:813dcc80987e 1177 else
mbed_official 610:813dcc80987e 1178 {
mbed_official 610:813dcc80987e 1179 status = HAL_BUSY;
mbed_official 610:813dcc80987e 1180 }
mbed_official 610:813dcc80987e 1181
mbed_official 610:813dcc80987e 1182 return status;
mbed_official 610:813dcc80987e 1183 }
mbed_official 610:813dcc80987e 1184
mbed_official 610:813dcc80987e 1185 /**
mbed_official 610:813dcc80987e 1186 * @brief Wraps up reception in non-blocking mode.
mbed_official 610:813dcc80987e 1187 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1188 * @retval HAL status
mbed_official 610:813dcc80987e 1189 * @retval HAL status
mbed_official 610:813dcc80987e 1190 */
mbed_official 610:813dcc80987e 1191 static HAL_StatusTypeDef SWPMI_EndReceive_IT(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1192 {
mbed_official 610:813dcc80987e 1193 /* Clear the SWPMI Receive buffer full Flag */
mbed_official 610:813dcc80987e 1194 WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBFF);
mbed_official 610:813dcc80987e 1195 /* Disable the all SWPMI Receive Interrupts */
mbed_official 610:813dcc80987e 1196 CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);
mbed_official 610:813dcc80987e 1197
mbed_official 610:813dcc80987e 1198 /* Check if a transmit Process is ongoing or not */
mbed_official 610:813dcc80987e 1199 if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
mbed_official 610:813dcc80987e 1200 {
mbed_official 610:813dcc80987e 1201 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
mbed_official 610:813dcc80987e 1202 }
mbed_official 610:813dcc80987e 1203 else
mbed_official 610:813dcc80987e 1204 {
mbed_official 610:813dcc80987e 1205 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 1206 }
mbed_official 610:813dcc80987e 1207
mbed_official 610:813dcc80987e 1208 return HAL_OK;
mbed_official 610:813dcc80987e 1209 }
mbed_official 610:813dcc80987e 1210
mbed_official 610:813dcc80987e 1211 /**
mbed_official 610:813dcc80987e 1212 * @brief Wraps up transmission and reception in non-blocking mode.
mbed_official 610:813dcc80987e 1213 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1214 * @retval HAL status
mbed_official 610:813dcc80987e 1215 * @retval HAL status
mbed_official 610:813dcc80987e 1216 */
mbed_official 610:813dcc80987e 1217 static HAL_StatusTypeDef SWPMI_EndTransmitReceive_IT(SWPMI_HandleTypeDef *hswpmi)
mbed_official 610:813dcc80987e 1218 {
mbed_official 610:813dcc80987e 1219 /* Clear the SWPMI Transmission Complete Flag */
mbed_official 610:813dcc80987e 1220 WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_TCF);
mbed_official 610:813dcc80987e 1221 /* Disable the SWPMI Transmission Complete Interrupt */
mbed_official 610:813dcc80987e 1222 CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_TCIE);
mbed_official 610:813dcc80987e 1223
mbed_official 610:813dcc80987e 1224 /* Check if a receive Process is ongoing or not */
mbed_official 610:813dcc80987e 1225 if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
mbed_official 610:813dcc80987e 1226 {
mbed_official 610:813dcc80987e 1227 hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
mbed_official 610:813dcc80987e 1228 }
mbed_official 610:813dcc80987e 1229 else if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX)
mbed_official 610:813dcc80987e 1230 {
mbed_official 610:813dcc80987e 1231 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 1232 }
mbed_official 610:813dcc80987e 1233
mbed_official 610:813dcc80987e 1234 return HAL_OK;
mbed_official 610:813dcc80987e 1235 }
mbed_official 610:813dcc80987e 1236
mbed_official 610:813dcc80987e 1237 /**
mbed_official 610:813dcc80987e 1238 * @brief DMA SWPMI transmit process complete callback.
mbed_official 610:813dcc80987e 1239 * @param hdma: DMA handle
mbed_official 610:813dcc80987e 1240 * @retval None
mbed_official 610:813dcc80987e 1241 */
mbed_official 610:813dcc80987e 1242 static void SWPMI_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 1243 {
mbed_official 610:813dcc80987e 1244 SWPMI_HandleTypeDef* hswpmi = ( SWPMI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 610:813dcc80987e 1245
mbed_official 610:813dcc80987e 1246 /* DMA Normal mode*/
mbed_official 610:813dcc80987e 1247 if((hdma->Instance->CCR & DMA_CCR_CIRC) != SET)
mbed_official 610:813dcc80987e 1248 {
mbed_official 610:813dcc80987e 1249 hswpmi->TxXferCount = 0;
mbed_official 610:813dcc80987e 1250
mbed_official 610:813dcc80987e 1251 /* Disable the DMA transfer for transmit request by setting the TXDMA bit
mbed_official 610:813dcc80987e 1252 in the SWPMI CR register */
mbed_official 610:813dcc80987e 1253 CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_TXDMA);
mbed_official 610:813dcc80987e 1254
mbed_official 610:813dcc80987e 1255 /* Wait the TXBEF */
mbed_official 610:813dcc80987e 1256 if(SWPMI_WaitOnFlagSetUntilTimeout(hswpmi, SWPMI_FLAG_TXBEF, SWPMI_TIMEOUT_VALUE) != HAL_OK)
mbed_official 610:813dcc80987e 1257 {
mbed_official 610:813dcc80987e 1258 /* Timeout occurred */
mbed_official 610:813dcc80987e 1259 HAL_SWPMI_ErrorCallback(hswpmi);
mbed_official 610:813dcc80987e 1260 }
mbed_official 610:813dcc80987e 1261 else
mbed_official 610:813dcc80987e 1262 {
mbed_official 610:813dcc80987e 1263 /* No Timeout */
mbed_official 610:813dcc80987e 1264 /* Check if a receive process is ongoing or not */
mbed_official 610:813dcc80987e 1265 if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
mbed_official 610:813dcc80987e 1266 {
mbed_official 610:813dcc80987e 1267 hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
mbed_official 610:813dcc80987e 1268 }
mbed_official 610:813dcc80987e 1269 else
mbed_official 610:813dcc80987e 1270 {
mbed_official 610:813dcc80987e 1271 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 1272 }
mbed_official 610:813dcc80987e 1273
mbed_official 610:813dcc80987e 1274 HAL_SWPMI_TxCpltCallback(hswpmi);
mbed_official 610:813dcc80987e 1275 }
mbed_official 610:813dcc80987e 1276 }
mbed_official 610:813dcc80987e 1277 /* DMA Circular mode */
mbed_official 610:813dcc80987e 1278 else
mbed_official 610:813dcc80987e 1279 {
mbed_official 610:813dcc80987e 1280 HAL_SWPMI_TxCpltCallback(hswpmi);
mbed_official 610:813dcc80987e 1281 }
mbed_official 610:813dcc80987e 1282 }
mbed_official 610:813dcc80987e 1283
mbed_official 610:813dcc80987e 1284 /**
mbed_official 610:813dcc80987e 1285 * @brief DMA SWPMI transmit process half complete callback.
mbed_official 610:813dcc80987e 1286 * @param hdma : DMA handle
mbed_official 610:813dcc80987e 1287 * @retval None
mbed_official 610:813dcc80987e 1288 */
mbed_official 610:813dcc80987e 1289 static void SWPMI_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 1290 {
mbed_official 610:813dcc80987e 1291 SWPMI_HandleTypeDef* hswpmi = (SWPMI_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 610:813dcc80987e 1292
mbed_official 610:813dcc80987e 1293 HAL_SWPMI_TxHalfCpltCallback(hswpmi);
mbed_official 610:813dcc80987e 1294 }
mbed_official 610:813dcc80987e 1295
mbed_official 610:813dcc80987e 1296
mbed_official 610:813dcc80987e 1297 /**
mbed_official 610:813dcc80987e 1298 * @brief DMA SWPMI receive process complete callback.
mbed_official 610:813dcc80987e 1299 * @param hdma: DMA handle
mbed_official 610:813dcc80987e 1300 * @retval None
mbed_official 610:813dcc80987e 1301 */
mbed_official 610:813dcc80987e 1302 static void SWPMI_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 1303 {
mbed_official 610:813dcc80987e 1304 SWPMI_HandleTypeDef* hswpmi = ( SWPMI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 610:813dcc80987e 1305
mbed_official 610:813dcc80987e 1306 /* DMA Normal mode*/
mbed_official 610:813dcc80987e 1307 if((hdma->Instance->CCR & DMA_CCR_CIRC) == RESET)
mbed_official 610:813dcc80987e 1308 {
mbed_official 610:813dcc80987e 1309 hswpmi->RxXferCount = 0;
mbed_official 610:813dcc80987e 1310
mbed_official 610:813dcc80987e 1311 /* Disable the DMA transfer for the receiver request by setting the RXDMA bit
mbed_official 610:813dcc80987e 1312 in the SWPMI CR register */
mbed_official 610:813dcc80987e 1313 CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_RXDMA);
mbed_official 610:813dcc80987e 1314
mbed_official 610:813dcc80987e 1315 /* Check if a transmit Process is ongoing or not */
mbed_official 610:813dcc80987e 1316 if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
mbed_official 610:813dcc80987e 1317 {
mbed_official 610:813dcc80987e 1318 hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
mbed_official 610:813dcc80987e 1319 }
mbed_official 610:813dcc80987e 1320 else
mbed_official 610:813dcc80987e 1321 {
mbed_official 610:813dcc80987e 1322 hswpmi->State = HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 1323 }
mbed_official 610:813dcc80987e 1324 }
mbed_official 610:813dcc80987e 1325 HAL_SWPMI_RxCpltCallback(hswpmi);
mbed_official 610:813dcc80987e 1326 }
mbed_official 610:813dcc80987e 1327
mbed_official 610:813dcc80987e 1328 /**
mbed_official 610:813dcc80987e 1329 * @brief DMA SWPMI receive process half complete callback.
mbed_official 610:813dcc80987e 1330 * @param hdma : DMA handle
mbed_official 610:813dcc80987e 1331 * @retval None
mbed_official 610:813dcc80987e 1332 */
mbed_official 610:813dcc80987e 1333 static void SWPMI_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 1334 {
mbed_official 610:813dcc80987e 1335 SWPMI_HandleTypeDef* hswpmi = (SWPMI_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 610:813dcc80987e 1336
mbed_official 610:813dcc80987e 1337 HAL_SWPMI_RxHalfCpltCallback(hswpmi);
mbed_official 610:813dcc80987e 1338 }
mbed_official 610:813dcc80987e 1339
mbed_official 610:813dcc80987e 1340 /**
mbed_official 610:813dcc80987e 1341 * @brief DMA SWPMI communication error callback.
mbed_official 610:813dcc80987e 1342 * @param hdma: DMA handle
mbed_official 610:813dcc80987e 1343 * @retval None
mbed_official 610:813dcc80987e 1344 */
mbed_official 610:813dcc80987e 1345 static void SWPMI_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 1346 {
mbed_official 610:813dcc80987e 1347 SWPMI_HandleTypeDef* hswpmi = ( SWPMI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 610:813dcc80987e 1348
mbed_official 610:813dcc80987e 1349 /* Update handle */
mbed_official 610:813dcc80987e 1350 hswpmi->RxXferCount = 0;
mbed_official 610:813dcc80987e 1351 hswpmi->TxXferCount = 0;
mbed_official 610:813dcc80987e 1352 hswpmi->State= HAL_SWPMI_STATE_READY;
mbed_official 610:813dcc80987e 1353 hswpmi->ErrorCode |= HAL_SWPMI_ERROR_DMA;
mbed_official 610:813dcc80987e 1354
mbed_official 610:813dcc80987e 1355 HAL_SWPMI_ErrorCallback(hswpmi);
mbed_official 610:813dcc80987e 1356 }
mbed_official 610:813dcc80987e 1357
mbed_official 610:813dcc80987e 1358 /**
mbed_official 610:813dcc80987e 1359 * @brief Handle SWPMI Communication Timeout.
mbed_official 610:813dcc80987e 1360 * @param hswpmi: SWPMI handle
mbed_official 610:813dcc80987e 1361 * @param Flag: specifies the SWPMI flag to check.
mbed_official 610:813dcc80987e 1362 * @param Timeout: Timeout duration
mbed_official 610:813dcc80987e 1363 * @retval HAL status
mbed_official 610:813dcc80987e 1364 */
mbed_official 610:813dcc80987e 1365 static HAL_StatusTypeDef SWPMI_WaitOnFlagSetUntilTimeout(SWPMI_HandleTypeDef *hswpmi, uint32_t Flag, uint32_t Timeout)
mbed_official 610:813dcc80987e 1366 {
mbed_official 610:813dcc80987e 1367 uint32_t tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 1368 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1369
mbed_official 610:813dcc80987e 1370 /* Wait until flag is set */
mbed_official 610:813dcc80987e 1371 while(!(HAL_IS_BIT_SET(hswpmi->Instance->ISR, Flag)))
mbed_official 610:813dcc80987e 1372 {
mbed_official 610:813dcc80987e 1373 /* Check for the Timeout */
mbed_official 610:813dcc80987e 1374 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 1375 {
mbed_official 610:813dcc80987e 1376 if((HAL_GetTick() - tickstart ) > Timeout)
mbed_official 610:813dcc80987e 1377 {
mbed_official 610:813dcc80987e 1378 hswpmi->State = HAL_SWPMI_STATE_TIMEOUT;
mbed_official 610:813dcc80987e 1379
mbed_official 610:813dcc80987e 1380 status = HAL_TIMEOUT;
mbed_official 610:813dcc80987e 1381 break;
mbed_official 610:813dcc80987e 1382 }
mbed_official 610:813dcc80987e 1383 }
mbed_official 610:813dcc80987e 1384 }
mbed_official 610:813dcc80987e 1385
mbed_official 610:813dcc80987e 1386 return status;
mbed_official 610:813dcc80987e 1387 }
mbed_official 610:813dcc80987e 1388
mbed_official 610:813dcc80987e 1389 /**
mbed_official 610:813dcc80987e 1390 * @}
mbed_official 610:813dcc80987e 1391 */
mbed_official 610:813dcc80987e 1392
mbed_official 610:813dcc80987e 1393 /**
mbed_official 610:813dcc80987e 1394 * @}
mbed_official 610:813dcc80987e 1395 */
mbed_official 610:813dcc80987e 1396
mbed_official 610:813dcc80987e 1397 #endif /* HAL_SWPMI_MODULE_ENABLED */
mbed_official 610:813dcc80987e 1398 /**
mbed_official 610:813dcc80987e 1399 * @}
mbed_official 610:813dcc80987e 1400 */
mbed_official 610:813dcc80987e 1401
mbed_official 610:813dcc80987e 1402 /**
mbed_official 610:813dcc80987e 1403 * @}
mbed_official 610:813dcc80987e 1404 */
mbed_official 610:813dcc80987e 1405
mbed_official 610:813dcc80987e 1406 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/