Eric Lewiston / STM32L4xx_HAL_Driver

Hal Drivers for L4

Dependents:   BSP OneHopeOnePrayer FINAL_AUDIO_RECORD AudioDemo

Fork of STM32L4xx_HAL_Driver by Senior Design: Sound Monitor

Src/stm32l4xx_hal_swpmi.c@2:7aef7655b0a8, 2015-11-25 (annotated)

Committer:
EricLew
Date:
Wed Nov 25 17:30:43 2015 +0000
Revision:
2:7aef7655b0a8
Parent:
0:80ee8f3b695e 
commit;

Who changed what in which revision?

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