Joris Aerts / mbed-src

mbed library sources

Dependents:   Marvino mbot

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_spdifrx.c@637:ed69428d4850, 2015-12-22 (annotated)

Committer:
jaerts
Date:
Tue Dec 22 13:22:16 2015 +0000
Revision:
637:ed69428d4850
Parent:
610:813dcc80987e 
Add very shady LPC1768 CAN Filter implementation

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 573:ad23fe03a082 1 /**
mbed_official 573:ad23fe03a082 2 ******************************************************************************
mbed_official 573:ad23fe03a082 3 * @file stm32f7xx_hal_spdifrx.c
mbed_official 573:ad23fe03a082 4 * @author MCD Application Team
mbed_official 610:813dcc80987e 5 * @version V1.0.1
mbed_official 610:813dcc80987e 6 * @date 25-June-2015
mbed_official 573:ad23fe03a082 7 * @brief This file provides firmware functions to manage the following
mbed_official 573:ad23fe03a082 8 * functionalities of the SPDIFRX audio interface:
mbed_official 573:ad23fe03a082 9 * + Initialization and Configuration
mbed_official 573:ad23fe03a082 10 * + Data transfers functions
mbed_official 573:ad23fe03a082 11 * + DMA transfers management
mbed_official 573:ad23fe03a082 12 * + Interrupts and flags management
mbed_official 573:ad23fe03a082 13 @verbatim
mbed_official 573:ad23fe03a082 14 ===============================================================================
mbed_official 573:ad23fe03a082 15 ##### How to use this driver #####
mbed_official 573:ad23fe03a082 16 ===============================================================================
mbed_official 573:ad23fe03a082 17 [..]
mbed_official 573:ad23fe03a082 18 The SPDIFRX HAL driver can be used as follow:
mbed_official 573:ad23fe03a082 19
mbed_official 573:ad23fe03a082 20 (#) Declare SPDIFRX_HandleTypeDef handle structure.
mbed_official 573:ad23fe03a082 21 (#) Initialize the SPDIFRX low level resources by implement the HAL_SPDIFRX_MspInit() API:
mbed_official 573:ad23fe03a082 22 (##) Enable the SPDIFRX interface clock.
mbed_official 573:ad23fe03a082 23 (##) SPDIFRX pins configuration:
mbed_official 573:ad23fe03a082 24 (+++) Enable the clock for the SPDIFRX GPIOs.
mbed_official 573:ad23fe03a082 25 (+++) Configure these SPDIFRX pins as alternate function pull-up.
mbed_official 573:ad23fe03a082 26 (##) NVIC configuration if you need to use interrupt process (HAL_SPDIFRX_ReceiveControlFlow_IT() and HAL_SPDIFRX_ReceiveDataFlow_IT() API's).
mbed_official 573:ad23fe03a082 27 (+++) Configure the SPDIFRX interrupt priority.
mbed_official 573:ad23fe03a082 28 (+++) Enable the NVIC SPDIFRX IRQ handle.
mbed_official 573:ad23fe03a082 29 (##) DMA Configuration if you need to use DMA process (HAL_SPDIFRX_ReceiveDataFlow_DMA() and HAL_SPDIFRX_ReceiveControlFlow_DMA() API's).
mbed_official 573:ad23fe03a082 30 (+++) Declare a DMA handle structure for the reception of the Data Flow channel.
mbed_official 610:813dcc80987e 31 (+++) Declare a DMA handle structure for the reception of the Control Flow channel.
mbed_official 573:ad23fe03a082 32 (+++) Enable the DMAx interface clock.
mbed_official 573:ad23fe03a082 33 (+++) Configure the declared DMA handle structure CtrlRx/DataRx with the required parameters.
mbed_official 573:ad23fe03a082 34 (+++) Configure the DMA Channel.
mbed_official 573:ad23fe03a082 35 (+++) Associate the initialized DMA handle to the SPDIFRX DMA CtrlRx/DataRx handle.
mbed_official 573:ad23fe03a082 36 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the
mbed_official 573:ad23fe03a082 37 DMA CtrlRx/DataRx channel.
mbed_official 573:ad23fe03a082 38
mbed_official 573:ad23fe03a082 39 (#) Program the input selection, re-tries number, wait for activity, channel status selection, data format, stereo mode and masking of user bits
mbed_official 573:ad23fe03a082 40 using HAL_SPDIFRX_Init() function.
mbed_official 573:ad23fe03a082 41
mbed_official 573:ad23fe03a082 42 -@- The specific SPDIFRX interrupts (RXNE/CSRNE and Error Interrupts) will be managed using the macros
mbed_official 573:ad23fe03a082 43 __SPDIFRX_ENABLE_IT() and __SPDIFRX_DISABLE_IT() inside the receive process.
mbed_official 573:ad23fe03a082 44 -@- Make sure that ck_spdif clock is configured.
mbed_official 573:ad23fe03a082 45
mbed_official 573:ad23fe03a082 46 (#) Three operation modes are available within this driver :
mbed_official 573:ad23fe03a082 47
mbed_official 573:ad23fe03a082 48 *** Polling mode for reception operation (for debug purpose) ***
mbed_official 573:ad23fe03a082 49 ================================================================
mbed_official 573:ad23fe03a082 50 [..]
mbed_official 573:ad23fe03a082 51 (+) Receive data flow in blocking mode using HAL_SPDIFRX_ReceiveDataFlow()
mbed_official 573:ad23fe03a082 52 (+) Receive control flow of data in blocking mode using HAL_SPDIFRX_ReceiveControlFlow()
mbed_official 573:ad23fe03a082 53
mbed_official 573:ad23fe03a082 54 *** Interrupt mode for reception operation ***
mbed_official 573:ad23fe03a082 55 =========================================
mbed_official 573:ad23fe03a082 56 [..]
mbed_official 573:ad23fe03a082 57 (+) Receive an amount of data (Data Flow) in non blocking mode using HAL_SPDIFRX_ReceiveDataFlow_IT()
mbed_official 573:ad23fe03a082 58 (+) Receive an amount of data (Control Flow) in non blocking mode using HAL_SPDIFRX_ReceiveControlFlow_IT()
mbed_official 573:ad23fe03a082 59 (+) At reception end of half transfer HAL_SPDIFRX_RxHalfCpltCallback is executed and user can
mbed_official 573:ad23fe03a082 60 add his own code by customization of function pointer HAL_SPDIFRX_RxHalfCpltCallback
mbed_official 573:ad23fe03a082 61 (+) At reception end of transfer HAL_SPDIFRX_RxCpltCallback is executed and user can
mbed_official 573:ad23fe03a082 62 add his own code by customization of function pointer HAL_SPDIFRX_RxCpltCallback
mbed_official 573:ad23fe03a082 63 (+) In case of transfer Error, HAL_SPDIFRX_ErrorCallback() function is executed and user can
mbed_official 573:ad23fe03a082 64 add his own code by customization of function pointer HAL_SPDIFRX_ErrorCallback
mbed_official 573:ad23fe03a082 65
mbed_official 573:ad23fe03a082 66 *** DMA mode for reception operation ***
mbed_official 573:ad23fe03a082 67 ========================================
mbed_official 573:ad23fe03a082 68 [..]
mbed_official 573:ad23fe03a082 69 (+) Receive an amount of data (Data Flow) in non blocking mode (DMA) using HAL_SPDIFRX_ReceiveDataFlow_DMA()
mbed_official 573:ad23fe03a082 70 (+) Receive an amount of data (Control Flow) in non blocking mode (DMA) using HAL_SPDIFRX_ReceiveControlFlow_DMA()
mbed_official 573:ad23fe03a082 71 (+) At reception end of half transfer HAL_SPDIFRX_RxHalfCpltCallback is executed and user can
mbed_official 573:ad23fe03a082 72 add his own code by customization of function pointer HAL_SPDIFRX_RxHalfCpltCallback
mbed_official 573:ad23fe03a082 73 (+) At reception end of transfer HAL_SPDIFRX_RxCpltCallback is executed and user can
mbed_official 573:ad23fe03a082 74 add his own code by customization of function pointer HAL_SPDIFRX_RxCpltCallback
mbed_official 573:ad23fe03a082 75 (+) In case of transfer Error, HAL_SPDIFRX_ErrorCallback() function is executed and user can
mbed_official 573:ad23fe03a082 76 add his own code by customization of function pointer HAL_SPDIFRX_ErrorCallback
mbed_official 573:ad23fe03a082 77 (+) Stop the DMA Transfer using HAL_SPDIFRX_DMAStop()
mbed_official 573:ad23fe03a082 78
mbed_official 573:ad23fe03a082 79 *** SPDIFRX HAL driver macros list ***
mbed_official 573:ad23fe03a082 80 =============================================
mbed_official 573:ad23fe03a082 81 [..]
mbed_official 573:ad23fe03a082 82 Below the list of most used macros in USART HAL driver.
mbed_official 573:ad23fe03a082 83 (+) __HAL_SPDIFRX_IDLE: Disable the specified SPDIFRX peripheral (IDEL State)
mbed_official 573:ad23fe03a082 84 (+) __HAL_SPDIFRX_SYNC: Enable the synchronization state of the specified SPDIFRX peripheral (SYNC State)
mbed_official 573:ad23fe03a082 85 (+) __HAL_SPDIFRX_RCV: Enable the receive state of the specified SPDIFRX peripheral (RCV State)
mbed_official 573:ad23fe03a082 86 (+) __HAL_SPDIFRX_ENABLE_IT : Enable the specified SPDIFRX interrupts
mbed_official 573:ad23fe03a082 87 (+) __HAL_SPDIFRX_DISABLE_IT : Disable the specified SPDIFRX interrupts
mbed_official 573:ad23fe03a082 88 (+) __HAL_SPDIFRX_GET_FLAG: Check whether the specified SPDIFRX flag is set or not.
mbed_official 573:ad23fe03a082 89
mbed_official 573:ad23fe03a082 90 [..]
mbed_official 573:ad23fe03a082 91 (@) You can refer to the SPDIFRX HAL driver header file for more useful macros
mbed_official 573:ad23fe03a082 92
mbed_official 573:ad23fe03a082 93 @endverbatim
mbed_official 573:ad23fe03a082 94 ******************************************************************************
mbed_official 573:ad23fe03a082 95 * @attention
mbed_official 573:ad23fe03a082 96 *
mbed_official 573:ad23fe03a082 97 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 573:ad23fe03a082 98 *
mbed_official 573:ad23fe03a082 99 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 573:ad23fe03a082 100 * are permitted provided that the following conditions are met:
mbed_official 573:ad23fe03a082 101 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 573:ad23fe03a082 102 * this list of conditions and the following disclaimer.
mbed_official 573:ad23fe03a082 103 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 573:ad23fe03a082 104 * this list of conditions and the following disclaimer in the documentation
mbed_official 573:ad23fe03a082 105 * and/or other materials provided with the distribution.
mbed_official 573:ad23fe03a082 106 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 573:ad23fe03a082 107 * may be used to endorse or promote products derived from this software
mbed_official 573:ad23fe03a082 108 * without specific prior written permission.
mbed_official 573:ad23fe03a082 109 *
mbed_official 573:ad23fe03a082 110 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 573:ad23fe03a082 111 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 573:ad23fe03a082 112 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 573:ad23fe03a082 113 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 573:ad23fe03a082 114 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 573:ad23fe03a082 115 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 573:ad23fe03a082 116 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 573:ad23fe03a082 117 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 573:ad23fe03a082 118 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 573:ad23fe03a082 119 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 573:ad23fe03a082 120 *
mbed_official 573:ad23fe03a082 121 ******************************************************************************
mbed_official 573:ad23fe03a082 122 */
mbed_official 573:ad23fe03a082 123
mbed_official 573:ad23fe03a082 124 /* Includes ------------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 125 #include "stm32f7xx_hal.h"
mbed_official 573:ad23fe03a082 126
mbed_official 573:ad23fe03a082 127 /** @addtogroup STM32F7xx_HAL_Driver
mbed_official 573:ad23fe03a082 128 * @{
mbed_official 573:ad23fe03a082 129 */
mbed_official 573:ad23fe03a082 130 /** @defgroup SPDIFRX SPDIFRX
mbed_official 573:ad23fe03a082 131 * @brief SPDIFRX HAL module driver
mbed_official 573:ad23fe03a082 132 * @{
mbed_official 573:ad23fe03a082 133 */
mbed_official 573:ad23fe03a082 134
mbed_official 573:ad23fe03a082 135 #ifdef HAL_SPDIFRX_MODULE_ENABLED
mbed_official 573:ad23fe03a082 136
mbed_official 573:ad23fe03a082 137 /* Private typedef -----------------------------------------------------------*/
mbed_official 573:ad23fe03a082 138 /* Private define ------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 139 #define SPDIFRX_TIMEOUT_VALUE 0xFFFF
mbed_official 573:ad23fe03a082 140
mbed_official 573:ad23fe03a082 141 /* Private macro -------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 142 /* Private variables ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 143 /* Private function prototypes -----------------------------------------------*/
mbed_official 573:ad23fe03a082 144 /** @addtogroup SPDIFRX_Private_Functions
mbed_official 573:ad23fe03a082 145 * @{
mbed_official 573:ad23fe03a082 146 */
mbed_official 573:ad23fe03a082 147 static void SPDIFRX_DMARxCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 148 static void SPDIFRX_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 149 static void SPDIFRX_DMACxCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 150 static void SPDIFRX_DMACxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 151 static void SPDIFRX_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 152 static void SPDIFRX_ReceiveControlFlow_IT(SPDIFRX_HandleTypeDef *hspdif);
mbed_official 573:ad23fe03a082 153 static void SPDIFRX_ReceiveDataFlow_IT(SPDIFRX_HandleTypeDef *hspdif);
mbed_official 573:ad23fe03a082 154 static HAL_StatusTypeDef SPDIFRX_WaitOnFlagUntilTimeout(SPDIFRX_HandleTypeDef *hspdif, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
mbed_official 573:ad23fe03a082 155 /**
mbed_official 573:ad23fe03a082 156 * @}
mbed_official 573:ad23fe03a082 157 */
mbed_official 573:ad23fe03a082 158 /* Exported functions ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 159
mbed_official 573:ad23fe03a082 160 /** @defgroup SPDIFRX_Exported_Functions SPDIFRX Exported Functions
mbed_official 573:ad23fe03a082 161 * @{
mbed_official 573:ad23fe03a082 162 */
mbed_official 573:ad23fe03a082 163
mbed_official 573:ad23fe03a082 164 /** @defgroup SPDIFRX_Exported_Functions_Group1 Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 165 * @brief Initialization and Configuration functions
mbed_official 573:ad23fe03a082 166 *
mbed_official 573:ad23fe03a082 167 @verbatim
mbed_official 573:ad23fe03a082 168 ===============================================================================
mbed_official 573:ad23fe03a082 169 ##### Initialization and de-initialization functions #####
mbed_official 573:ad23fe03a082 170 ===============================================================================
mbed_official 573:ad23fe03a082 171 [..] This subsection provides a set of functions allowing to initialize and
mbed_official 573:ad23fe03a082 172 de-initialize the SPDIFRX peripheral:
mbed_official 573:ad23fe03a082 173
mbed_official 573:ad23fe03a082 174 (+) User must Implement HAL_SPDIFRX_MspInit() function in which he configures
mbed_official 573:ad23fe03a082 175 all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC ).
mbed_official 573:ad23fe03a082 176
mbed_official 573:ad23fe03a082 177 (+) Call the function HAL_SPDIFRX_Init() to configure the SPDIFRX peripheral with
mbed_official 573:ad23fe03a082 178 the selected configuration:
mbed_official 573:ad23fe03a082 179 (++) Input Selection (IN0, IN1,...)
mbed_official 573:ad23fe03a082 180 (++) Maximum allowed re-tries during synchronization phase
mbed_official 573:ad23fe03a082 181 (++) Wait for activity on SPDIF selected input
mbed_official 573:ad23fe03a082 182 (++) Channel status selection (from channel A or B)
mbed_official 573:ad23fe03a082 183 (++) Data format (LSB, MSB, ...)
mbed_official 573:ad23fe03a082 184 (++) Stereo mode
mbed_official 573:ad23fe03a082 185 (++) User bits masking (PT,C,U,V,...)
mbed_official 573:ad23fe03a082 186
mbed_official 573:ad23fe03a082 187 (+) Call the function HAL_SPDIFRX_DeInit() to restore the default configuration
mbed_official 573:ad23fe03a082 188 of the selected SPDIFRXx peripheral.
mbed_official 573:ad23fe03a082 189 @endverbatim
mbed_official 573:ad23fe03a082 190 * @{
mbed_official 573:ad23fe03a082 191 */
mbed_official 573:ad23fe03a082 192
mbed_official 573:ad23fe03a082 193 /**
mbed_official 573:ad23fe03a082 194 * @brief Initializes the SPDIFRX according to the specified parameters
mbed_official 573:ad23fe03a082 195 * in the SPDIFRX_InitTypeDef and create the associated handle.
mbed_official 573:ad23fe03a082 196 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 197 * @retval HAL status
mbed_official 573:ad23fe03a082 198 */
mbed_official 573:ad23fe03a082 199 HAL_StatusTypeDef HAL_SPDIFRX_Init(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 200 {
mbed_official 573:ad23fe03a082 201 uint32_t tmpreg = 0;
mbed_official 573:ad23fe03a082 202
mbed_official 573:ad23fe03a082 203 /* Check the SPDIFRX handle allocation */
mbed_official 573:ad23fe03a082 204 if(hspdif == NULL)
mbed_official 573:ad23fe03a082 205 {
mbed_official 573:ad23fe03a082 206 return HAL_ERROR;
mbed_official 573:ad23fe03a082 207 }
mbed_official 573:ad23fe03a082 208
mbed_official 573:ad23fe03a082 209 /* Check the SPDIFRX parameters */
mbed_official 573:ad23fe03a082 210 assert_param(IS_STEREO_MODE(hspdif->Init.StereoMode));
mbed_official 573:ad23fe03a082 211 assert_param(IS_SPDIFRX_INPUT_SELECT(hspdif->Init.InputSelection));
mbed_official 573:ad23fe03a082 212 assert_param(IS_SPDIFRX_MAX_RETRIES(hspdif->Init.Retries));
mbed_official 573:ad23fe03a082 213 assert_param(IS_SPDIFRX_WAIT_FOR_ACTIVITY(hspdif->Init.WaitForActivity));
mbed_official 573:ad23fe03a082 214 assert_param(IS_SPDIFRX_CHANNEL(hspdif->Init.ChannelSelection));
mbed_official 573:ad23fe03a082 215 assert_param(IS_SPDIFRX_DATA_FORMAT(hspdif->Init.DataFormat));
mbed_official 573:ad23fe03a082 216 assert_param(IS_PREAMBLE_TYPE_MASK(hspdif->Init.PreambleTypeMask));
mbed_official 573:ad23fe03a082 217 assert_param(IS_CHANNEL_STATUS_MASK(hspdif->Init.ChannelStatusMask));
mbed_official 573:ad23fe03a082 218 assert_param(IS_VALIDITY_MASK(hspdif->Init.ValidityBitMask));
mbed_official 573:ad23fe03a082 219 assert_param(IS_PARITY_ERROR_MASK(hspdif->Init.ParityErrorMask));
mbed_official 573:ad23fe03a082 220
mbed_official 573:ad23fe03a082 221 if(hspdif->State == HAL_SPDIFRX_STATE_RESET)
mbed_official 573:ad23fe03a082 222 {
mbed_official 573:ad23fe03a082 223 /* Allocate lock resource and initialize it */
mbed_official 573:ad23fe03a082 224 hspdif->Lock = HAL_UNLOCKED;
mbed_official 573:ad23fe03a082 225 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
mbed_official 573:ad23fe03a082 226 HAL_SPDIFRX_MspInit(hspdif);
mbed_official 573:ad23fe03a082 227 }
mbed_official 573:ad23fe03a082 228
mbed_official 573:ad23fe03a082 229 /* SPDIFRX peripheral state is BUSY*/
mbed_official 573:ad23fe03a082 230 hspdif->State = HAL_SPDIFRX_STATE_BUSY;
mbed_official 573:ad23fe03a082 231
mbed_official 573:ad23fe03a082 232 /* Disable SPDIFRX interface (IDLE State) */
mbed_official 573:ad23fe03a082 233 __HAL_SPDIFRX_IDLE(hspdif);
mbed_official 573:ad23fe03a082 234
mbed_official 573:ad23fe03a082 235 /* Reset the old SPDIFRX CR configuration */
mbed_official 573:ad23fe03a082 236 tmpreg = hspdif->Instance->CR;
mbed_official 573:ad23fe03a082 237
mbed_official 573:ad23fe03a082 238 tmpreg &= ~((uint16_t) SPDIFRX_CR_RXSTEO | SPDIFRX_CR_DRFMT | SPDIFRX_CR_PMSK |
mbed_official 573:ad23fe03a082 239 SPDIFRX_CR_VMSK | SPDIFRX_CR_CUMSK | SPDIFRX_CR_PTMSK |
mbed_official 573:ad23fe03a082 240 SPDIFRX_CR_CHSEL | SPDIFRX_CR_NBTR | SPDIFRX_CR_WFA |
mbed_official 573:ad23fe03a082 241 SPDIFRX_CR_INSEL);
mbed_official 573:ad23fe03a082 242
mbed_official 573:ad23fe03a082 243 /* Sets the new configuration of the SPDIFRX peripheral */
mbed_official 573:ad23fe03a082 244 tmpreg |= ((uint16_t) hspdif->Init.StereoMode |
mbed_official 573:ad23fe03a082 245 hspdif->Init.InputSelection |
mbed_official 573:ad23fe03a082 246 hspdif->Init.Retries |
mbed_official 573:ad23fe03a082 247 hspdif->Init.WaitForActivity |
mbed_official 573:ad23fe03a082 248 hspdif->Init.ChannelSelection |
mbed_official 573:ad23fe03a082 249 hspdif->Init.DataFormat |
mbed_official 573:ad23fe03a082 250 hspdif->Init.PreambleTypeMask |
mbed_official 573:ad23fe03a082 251 hspdif->Init.ChannelStatusMask |
mbed_official 573:ad23fe03a082 252 hspdif->Init.ValidityBitMask |
mbed_official 573:ad23fe03a082 253 hspdif->Init.ParityErrorMask);
mbed_official 573:ad23fe03a082 254
mbed_official 573:ad23fe03a082 255 hspdif->Instance->CR = tmpreg;
mbed_official 573:ad23fe03a082 256
mbed_official 573:ad23fe03a082 257 hspdif->ErrorCode = HAL_SPDIFRX_ERROR_NONE;
mbed_official 573:ad23fe03a082 258
mbed_official 573:ad23fe03a082 259 /* SPDIFRX peripheral state is READY*/
mbed_official 573:ad23fe03a082 260 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 261
mbed_official 573:ad23fe03a082 262 return HAL_OK;
mbed_official 573:ad23fe03a082 263 }
mbed_official 573:ad23fe03a082 264
mbed_official 573:ad23fe03a082 265 /**
mbed_official 573:ad23fe03a082 266 * @brief DeInitializes the SPDIFRX peripheral
mbed_official 573:ad23fe03a082 267 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 268 * @retval HAL status
mbed_official 573:ad23fe03a082 269 */
mbed_official 573:ad23fe03a082 270 HAL_StatusTypeDef HAL_SPDIFRX_DeInit(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 271 {
mbed_official 573:ad23fe03a082 272 /* Check the SPDIFRX handle allocation */
mbed_official 573:ad23fe03a082 273 if(hspdif == NULL)
mbed_official 573:ad23fe03a082 274 {
mbed_official 573:ad23fe03a082 275 return HAL_ERROR;
mbed_official 573:ad23fe03a082 276 }
mbed_official 573:ad23fe03a082 277
mbed_official 573:ad23fe03a082 278 /* Check the parameters */
mbed_official 573:ad23fe03a082 279 assert_param(IS_SPDIFRX_ALL_INSTANCE(hspdif->Instance));
mbed_official 573:ad23fe03a082 280
mbed_official 573:ad23fe03a082 281 hspdif->State = HAL_SPDIFRX_STATE_BUSY;
mbed_official 573:ad23fe03a082 282
mbed_official 573:ad23fe03a082 283 /* Disable SPDIFRX interface (IDLE state) */
mbed_official 573:ad23fe03a082 284 __HAL_SPDIFRX_IDLE(hspdif);
mbed_official 573:ad23fe03a082 285
mbed_official 573:ad23fe03a082 286 /* DeInit the low level hardware: GPIO, CLOCK, NVIC... */
mbed_official 573:ad23fe03a082 287 HAL_SPDIFRX_MspDeInit(hspdif);
mbed_official 573:ad23fe03a082 288
mbed_official 573:ad23fe03a082 289 hspdif->ErrorCode = HAL_SPDIFRX_ERROR_NONE;
mbed_official 573:ad23fe03a082 290
mbed_official 573:ad23fe03a082 291 /* SPDIFRX peripheral state is RESET*/
mbed_official 573:ad23fe03a082 292 hspdif->State = HAL_SPDIFRX_STATE_RESET;
mbed_official 573:ad23fe03a082 293
mbed_official 573:ad23fe03a082 294 /* Release Lock */
mbed_official 573:ad23fe03a082 295 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 296
mbed_official 573:ad23fe03a082 297 return HAL_OK;
mbed_official 573:ad23fe03a082 298 }
mbed_official 573:ad23fe03a082 299
mbed_official 573:ad23fe03a082 300 /**
mbed_official 573:ad23fe03a082 301 * @brief SPDIFRX MSP Init
mbed_official 573:ad23fe03a082 302 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 303 * @retval None
mbed_official 573:ad23fe03a082 304 */
mbed_official 573:ad23fe03a082 305 __weak void HAL_SPDIFRX_MspInit(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 306 {
mbed_official 573:ad23fe03a082 307 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 308 the HAL_SPDIFRX_MspInit could be implemented in the user file
mbed_official 573:ad23fe03a082 309 */
mbed_official 573:ad23fe03a082 310 }
mbed_official 573:ad23fe03a082 311
mbed_official 573:ad23fe03a082 312 /**
mbed_official 573:ad23fe03a082 313 * @brief SPDIFRX MSP DeInit
mbed_official 573:ad23fe03a082 314 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 315 * @retval None
mbed_official 573:ad23fe03a082 316 */
mbed_official 573:ad23fe03a082 317 __weak void HAL_SPDIFRX_MspDeInit(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 318 {
mbed_official 573:ad23fe03a082 319 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 320 the HAL_SPDIFRX_MspDeInit could be implemented in the user file
mbed_official 573:ad23fe03a082 321 */
mbed_official 573:ad23fe03a082 322 }
mbed_official 573:ad23fe03a082 323
mbed_official 573:ad23fe03a082 324 /**
mbed_official 573:ad23fe03a082 325 * @brief Sets the SPDIFRX dtat format according to the specified parameters
mbed_official 573:ad23fe03a082 326 * in the SPDIFRX_InitTypeDef.
mbed_official 573:ad23fe03a082 327 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 328 * @param sDataFormat: SPDIFRX data format
mbed_official 573:ad23fe03a082 329 * @retval HAL status
mbed_official 573:ad23fe03a082 330 */
mbed_official 573:ad23fe03a082 331 HAL_StatusTypeDef HAL_SPDIFRX_SetDataFormat(SPDIFRX_HandleTypeDef *hspdif, SPDIFRX_SetDataFormatTypeDef sDataFormat)
mbed_official 573:ad23fe03a082 332 {
mbed_official 573:ad23fe03a082 333 uint32_t tmpreg = 0;
mbed_official 573:ad23fe03a082 334
mbed_official 573:ad23fe03a082 335 /* Check the SPDIFRX handle allocation */
mbed_official 573:ad23fe03a082 336 if(hspdif == NULL)
mbed_official 573:ad23fe03a082 337 {
mbed_official 573:ad23fe03a082 338 return HAL_ERROR;
mbed_official 573:ad23fe03a082 339 }
mbed_official 573:ad23fe03a082 340
mbed_official 573:ad23fe03a082 341 /* Check the SPDIFRX parameters */
mbed_official 573:ad23fe03a082 342 assert_param(IS_STEREO_MODE(sDataFormat.StereoMode));
mbed_official 573:ad23fe03a082 343 assert_param(IS_SPDIFRX_DATA_FORMAT(sDataFormat.DataFormat));
mbed_official 573:ad23fe03a082 344 assert_param(IS_PREAMBLE_TYPE_MASK(sDataFormat.PreambleTypeMask));
mbed_official 573:ad23fe03a082 345 assert_param(IS_CHANNEL_STATUS_MASK(sDataFormat.ChannelStatusMask));
mbed_official 573:ad23fe03a082 346 assert_param(IS_VALIDITY_MASK(sDataFormat.ValidityBitMask));
mbed_official 573:ad23fe03a082 347 assert_param(IS_PARITY_ERROR_MASK(sDataFormat.ParityErrorMask));
mbed_official 573:ad23fe03a082 348
mbed_official 573:ad23fe03a082 349 /* Reset the old SPDIFRX CR configuration */
mbed_official 573:ad23fe03a082 350 tmpreg = hspdif->Instance->CR;
mbed_official 573:ad23fe03a082 351
mbed_official 573:ad23fe03a082 352 if(((tmpreg & SPDIFRX_STATE_RCV) == SPDIFRX_STATE_RCV) &&
mbed_official 573:ad23fe03a082 353 (((tmpreg & SPDIFRX_CR_DRFMT) != sDataFormat.DataFormat) ||
mbed_official 573:ad23fe03a082 354 ((tmpreg & SPDIFRX_CR_RXSTEO) != sDataFormat.StereoMode)))
mbed_official 573:ad23fe03a082 355 {
mbed_official 573:ad23fe03a082 356 return HAL_ERROR;
mbed_official 573:ad23fe03a082 357 }
mbed_official 573:ad23fe03a082 358
mbed_official 573:ad23fe03a082 359 tmpreg &= ~((uint16_t) SPDIFRX_CR_RXSTEO | SPDIFRX_CR_DRFMT | SPDIFRX_CR_PMSK |
mbed_official 573:ad23fe03a082 360 SPDIFRX_CR_VMSK | SPDIFRX_CR_CUMSK | SPDIFRX_CR_PTMSK);
mbed_official 573:ad23fe03a082 361
mbed_official 573:ad23fe03a082 362 /* Sets the new configuration of the SPDIFRX peripheral */
mbed_official 573:ad23fe03a082 363 tmpreg |= ((uint16_t) sDataFormat.StereoMode |
mbed_official 573:ad23fe03a082 364 sDataFormat.DataFormat |
mbed_official 573:ad23fe03a082 365 sDataFormat.PreambleTypeMask |
mbed_official 573:ad23fe03a082 366 sDataFormat.ChannelStatusMask |
mbed_official 573:ad23fe03a082 367 sDataFormat.ValidityBitMask |
mbed_official 573:ad23fe03a082 368 sDataFormat.ParityErrorMask);
mbed_official 573:ad23fe03a082 369
mbed_official 573:ad23fe03a082 370 hspdif->Instance->CR = tmpreg;
mbed_official 573:ad23fe03a082 371
mbed_official 573:ad23fe03a082 372 return HAL_OK;
mbed_official 573:ad23fe03a082 373 }
mbed_official 573:ad23fe03a082 374
mbed_official 573:ad23fe03a082 375 /**
mbed_official 573:ad23fe03a082 376 * @}
mbed_official 573:ad23fe03a082 377 */
mbed_official 573:ad23fe03a082 378
mbed_official 573:ad23fe03a082 379 /** @defgroup SPDIFRX_Exported_Functions_Group2 IO operation functions
mbed_official 573:ad23fe03a082 380 * @brief Data transfers functions
mbed_official 573:ad23fe03a082 381 *
mbed_official 573:ad23fe03a082 382 @verbatim
mbed_official 573:ad23fe03a082 383 ===============================================================================
mbed_official 573:ad23fe03a082 384 ##### IO operation functions #####
mbed_official 573:ad23fe03a082 385 ===============================================================================
mbed_official 573:ad23fe03a082 386 [..]
mbed_official 573:ad23fe03a082 387 This subsection provides a set of functions allowing to manage the SPDIFRX data
mbed_official 573:ad23fe03a082 388 transfers.
mbed_official 573:ad23fe03a082 389
mbed_official 573:ad23fe03a082 390 (#) There is two mode of transfer:
mbed_official 573:ad23fe03a082 391 (++) Blocking mode : The communication is performed in the polling mode.
mbed_official 573:ad23fe03a082 392 The status of all data processing is returned by the same function
mbed_official 573:ad23fe03a082 393 after finishing transfer.
mbed_official 573:ad23fe03a082 394 (++) No-Blocking mode : The communication is performed using Interrupts
mbed_official 573:ad23fe03a082 395 or DMA. These functions return the status of the transfer start-up.
mbed_official 573:ad23fe03a082 396 The end of the data processing will be indicated through the
mbed_official 573:ad23fe03a082 397 dedicated SPDIFRX IRQ when using Interrupt mode or the DMA IRQ when
mbed_official 573:ad23fe03a082 398 using DMA mode.
mbed_official 573:ad23fe03a082 399
mbed_official 573:ad23fe03a082 400 (#) Blocking mode functions are :
mbed_official 573:ad23fe03a082 401 (++) HAL_SPDIFRX_ReceiveDataFlow()
mbed_official 573:ad23fe03a082 402 (++) HAL_SPDIFRX_ReceiveControlFlow()
mbed_official 573:ad23fe03a082 403 (+@) Do not use blocking mode to receive both control and data flow at the same time.
mbed_official 573:ad23fe03a082 404
mbed_official 573:ad23fe03a082 405 (#) No-Blocking mode functions with Interrupt are :
mbed_official 573:ad23fe03a082 406 (++) HAL_SPDIFRX_ReceiveControlFlow_IT()
mbed_official 573:ad23fe03a082 407 (++) HAL_SPDIFRX_ReceiveDataFlow_IT()
mbed_official 573:ad23fe03a082 408
mbed_official 573:ad23fe03a082 409 (#) No-Blocking mode functions with DMA are :
mbed_official 573:ad23fe03a082 410 (++) HAL_SPDIFRX_ReceiveControlFlow_DMA()
mbed_official 573:ad23fe03a082 411 (++) HAL_SPDIFRX_ReceiveDataFlow_DMA()
mbed_official 573:ad23fe03a082 412
mbed_official 573:ad23fe03a082 413 (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:
mbed_official 573:ad23fe03a082 414 (++) HAL_SPDIFRX_RxCpltCallback()
mbed_official 573:ad23fe03a082 415 (++) HAL_SPDIFRX_ErrorCallback()
mbed_official 573:ad23fe03a082 416
mbed_official 573:ad23fe03a082 417 @endverbatim
mbed_official 573:ad23fe03a082 418 * @{
mbed_official 573:ad23fe03a082 419 */
mbed_official 573:ad23fe03a082 420
mbed_official 573:ad23fe03a082 421
mbed_official 573:ad23fe03a082 422 /**
mbed_official 573:ad23fe03a082 423 * @brief Receives an amount of data (Data Flow) in blocking mode.
mbed_official 573:ad23fe03a082 424 * @param hspdif: pointer to SPDIFRX_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 425 * the configuration information for SPDIFRX module.
mbed_official 573:ad23fe03a082 426 * @param pData: Pointer to data buffer
mbed_official 573:ad23fe03a082 427 * @param Size: Amount of data to be received
mbed_official 573:ad23fe03a082 428 * @param Timeout: Timeout duration
mbed_official 573:ad23fe03a082 429 * @retval HAL status
mbed_official 573:ad23fe03a082 430 */
mbed_official 573:ad23fe03a082 431 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveDataFlow(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 573:ad23fe03a082 432 {
mbed_official 573:ad23fe03a082 433
mbed_official 573:ad23fe03a082 434 if((pData == NULL ) || (Size == 0))
mbed_official 573:ad23fe03a082 435 {
mbed_official 573:ad23fe03a082 436 return HAL_ERROR;
mbed_official 573:ad23fe03a082 437 }
mbed_official 573:ad23fe03a082 438
mbed_official 573:ad23fe03a082 439 if(hspdif->State == HAL_SPDIFRX_STATE_READY)
mbed_official 573:ad23fe03a082 440 {
mbed_official 573:ad23fe03a082 441 /* Process Locked */
mbed_official 573:ad23fe03a082 442 __HAL_LOCK(hspdif);
mbed_official 573:ad23fe03a082 443
mbed_official 573:ad23fe03a082 444 hspdif->State = HAL_SPDIFRX_STATE_BUSY;
mbed_official 573:ad23fe03a082 445
mbed_official 573:ad23fe03a082 446 /* Start synchronisation */
mbed_official 573:ad23fe03a082 447 __HAL_SPDIFRX_SYNC(hspdif);
mbed_official 573:ad23fe03a082 448
mbed_official 573:ad23fe03a082 449 /* Wait until SYNCD flag is set */
mbed_official 573:ad23fe03a082 450 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_SYNCD, RESET, Timeout) != HAL_OK)
mbed_official 573:ad23fe03a082 451 {
mbed_official 573:ad23fe03a082 452 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 453 }
mbed_official 573:ad23fe03a082 454
mbed_official 573:ad23fe03a082 455 /* Start reception */
mbed_official 573:ad23fe03a082 456 __HAL_SPDIFRX_RCV(hspdif);
mbed_official 573:ad23fe03a082 457
mbed_official 573:ad23fe03a082 458 /* Receive data flow */
mbed_official 573:ad23fe03a082 459 while(Size > 0)
mbed_official 573:ad23fe03a082 460 {
mbed_official 573:ad23fe03a082 461 /* Wait until RXNE flag is set */
mbed_official 573:ad23fe03a082 462 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official 573:ad23fe03a082 463 {
mbed_official 573:ad23fe03a082 464 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 465 }
mbed_official 573:ad23fe03a082 466
mbed_official 573:ad23fe03a082 467 (*pData++) = hspdif->Instance->DR;
mbed_official 573:ad23fe03a082 468 Size--;
mbed_official 573:ad23fe03a082 469 }
mbed_official 573:ad23fe03a082 470
mbed_official 573:ad23fe03a082 471 /* SPDIFRX ready */
mbed_official 573:ad23fe03a082 472 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 473
mbed_official 573:ad23fe03a082 474 /* Process Unlocked */
mbed_official 573:ad23fe03a082 475 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 476
mbed_official 573:ad23fe03a082 477 return HAL_OK;
mbed_official 573:ad23fe03a082 478 }
mbed_official 573:ad23fe03a082 479 else
mbed_official 573:ad23fe03a082 480 {
mbed_official 573:ad23fe03a082 481 return HAL_BUSY;
mbed_official 573:ad23fe03a082 482 }
mbed_official 573:ad23fe03a082 483 }
mbed_official 573:ad23fe03a082 484
mbed_official 573:ad23fe03a082 485 /**
mbed_official 573:ad23fe03a082 486 * @brief Receives an amount of data (Control Flow) in blocking mode.
mbed_official 573:ad23fe03a082 487 * @param hspdif: pointer to a SPDIFRX_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 488 * the configuration information for SPDIFRX module.
mbed_official 573:ad23fe03a082 489 * @param pData: Pointer to data buffer
mbed_official 573:ad23fe03a082 490 * @param Size: Amount of data to be received
mbed_official 573:ad23fe03a082 491 * @param Timeout: Timeout duration
mbed_official 573:ad23fe03a082 492 * @retval HAL status
mbed_official 573:ad23fe03a082 493 */
mbed_official 573:ad23fe03a082 494 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveControlFlow(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 573:ad23fe03a082 495 {
mbed_official 573:ad23fe03a082 496
mbed_official 573:ad23fe03a082 497 if((pData == NULL ) || (Size == 0))
mbed_official 573:ad23fe03a082 498 {
mbed_official 573:ad23fe03a082 499 return HAL_ERROR;
mbed_official 573:ad23fe03a082 500 }
mbed_official 573:ad23fe03a082 501
mbed_official 573:ad23fe03a082 502 if(hspdif->State == HAL_SPDIFRX_STATE_READY)
mbed_official 573:ad23fe03a082 503 {
mbed_official 573:ad23fe03a082 504 /* Process Locked */
mbed_official 573:ad23fe03a082 505 __HAL_LOCK(hspdif);
mbed_official 573:ad23fe03a082 506
mbed_official 573:ad23fe03a082 507 hspdif->State = HAL_SPDIFRX_STATE_BUSY;
mbed_official 573:ad23fe03a082 508
mbed_official 573:ad23fe03a082 509 /* Start synchronization */
mbed_official 573:ad23fe03a082 510 __HAL_SPDIFRX_SYNC(hspdif);
mbed_official 573:ad23fe03a082 511
mbed_official 573:ad23fe03a082 512 /* Wait until SYNCD flag is set */
mbed_official 573:ad23fe03a082 513 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_SYNCD, RESET, Timeout) != HAL_OK)
mbed_official 573:ad23fe03a082 514 {
mbed_official 573:ad23fe03a082 515 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 516 }
mbed_official 573:ad23fe03a082 517
mbed_official 573:ad23fe03a082 518 /* Start reception */
mbed_official 573:ad23fe03a082 519 __HAL_SPDIFRX_RCV(hspdif);
mbed_official 573:ad23fe03a082 520
mbed_official 573:ad23fe03a082 521 /* Receive control flow */
mbed_official 573:ad23fe03a082 522 while(Size > 0)
mbed_official 573:ad23fe03a082 523 {
mbed_official 573:ad23fe03a082 524 /* Wait until CSRNE flag is set */
mbed_official 573:ad23fe03a082 525 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_CSRNE, RESET, Timeout) != HAL_OK)
mbed_official 573:ad23fe03a082 526 {
mbed_official 573:ad23fe03a082 527 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 528 }
mbed_official 573:ad23fe03a082 529
mbed_official 573:ad23fe03a082 530 (*pData++) = hspdif->Instance->CSR;
mbed_official 573:ad23fe03a082 531 Size--;
mbed_official 573:ad23fe03a082 532 }
mbed_official 573:ad23fe03a082 533
mbed_official 573:ad23fe03a082 534 /* SPDIFRX ready */
mbed_official 573:ad23fe03a082 535 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 536
mbed_official 573:ad23fe03a082 537 /* Process Unlocked */
mbed_official 573:ad23fe03a082 538 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 539
mbed_official 573:ad23fe03a082 540 return HAL_OK;
mbed_official 573:ad23fe03a082 541 }
mbed_official 573:ad23fe03a082 542 else
mbed_official 573:ad23fe03a082 543 {
mbed_official 573:ad23fe03a082 544 return HAL_BUSY;
mbed_official 573:ad23fe03a082 545 }
mbed_official 573:ad23fe03a082 546 }
mbed_official 573:ad23fe03a082 547 /**
mbed_official 573:ad23fe03a082 548 * @brief Receive an amount of data (Data Flow) in non-blocking mode with Interrupt
mbed_official 573:ad23fe03a082 549 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 550 * @param pData: a 32-bit pointer to the Receive data buffer.
mbed_official 573:ad23fe03a082 551 * @param Size: number of data sample to be received .
mbed_official 573:ad23fe03a082 552 * @retval HAL status
mbed_official 573:ad23fe03a082 553 */
mbed_official 573:ad23fe03a082 554 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveDataFlow_IT(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size)
mbed_official 573:ad23fe03a082 555 {
mbed_official 573:ad23fe03a082 556 if((hspdif->State == HAL_SPDIFRX_STATE_READY) || (hspdif->State == HAL_SPDIFRX_STATE_BUSY_CX))
mbed_official 573:ad23fe03a082 557 {
mbed_official 573:ad23fe03a082 558 if((pData == NULL) || (Size == 0))
mbed_official 573:ad23fe03a082 559 {
mbed_official 573:ad23fe03a082 560 return HAL_ERROR;
mbed_official 573:ad23fe03a082 561 }
mbed_official 573:ad23fe03a082 562
mbed_official 573:ad23fe03a082 563 /* Process Locked */
mbed_official 573:ad23fe03a082 564 __HAL_LOCK(hspdif);
mbed_official 573:ad23fe03a082 565
mbed_official 573:ad23fe03a082 566 hspdif->pRxBuffPtr = pData;
mbed_official 573:ad23fe03a082 567 hspdif->RxXferSize = Size;
mbed_official 573:ad23fe03a082 568 hspdif->RxXferCount = Size;
mbed_official 573:ad23fe03a082 569
mbed_official 573:ad23fe03a082 570 hspdif->ErrorCode = HAL_SPDIFRX_ERROR_NONE;
mbed_official 573:ad23fe03a082 571
mbed_official 573:ad23fe03a082 572 /* Check if a receive process is ongoing or not */
mbed_official 573:ad23fe03a082 573 hspdif->State = HAL_SPDIFRX_STATE_BUSY_RX;
mbed_official 573:ad23fe03a082 574
mbed_official 573:ad23fe03a082 575
mbed_official 573:ad23fe03a082 576 /* Enable the SPDIFRX PE Error Interrupt */
mbed_official 573:ad23fe03a082 577 __HAL_SPDIFRX_ENABLE_IT(hspdif, SPDIFRX_IT_PERRIE);
mbed_official 573:ad23fe03a082 578
mbed_official 573:ad23fe03a082 579 /* Enable the SPDIFRX OVR Error Interrupt */
mbed_official 573:ad23fe03a082 580 __HAL_SPDIFRX_ENABLE_IT(hspdif, SPDIFRX_IT_OVRIE);
mbed_official 573:ad23fe03a082 581
mbed_official 573:ad23fe03a082 582 /* Process Unlocked */
mbed_official 573:ad23fe03a082 583 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 584
mbed_official 573:ad23fe03a082 585 /* Enable the SPDIFRX RXNE interrupt */
mbed_official 573:ad23fe03a082 586 __HAL_SPDIFRX_ENABLE_IT(hspdif, SPDIFRX_IT_RXNE);
mbed_official 573:ad23fe03a082 587
mbed_official 573:ad23fe03a082 588 if (((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != SPDIFRX_STATE_SYNC) || ((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != 0x00))
mbed_official 573:ad23fe03a082 589 {
mbed_official 573:ad23fe03a082 590 /* Start synchronization */
mbed_official 573:ad23fe03a082 591 __HAL_SPDIFRX_SYNC(hspdif);
mbed_official 573:ad23fe03a082 592
mbed_official 573:ad23fe03a082 593 /* Wait until SYNCD flag is set */
mbed_official 573:ad23fe03a082 594 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_SYNCD, RESET, SPDIFRX_TIMEOUT_VALUE) != HAL_OK)
mbed_official 573:ad23fe03a082 595 {
mbed_official 573:ad23fe03a082 596 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 597 }
mbed_official 573:ad23fe03a082 598
mbed_official 573:ad23fe03a082 599 /* Start reception */
mbed_official 573:ad23fe03a082 600 __HAL_SPDIFRX_RCV(hspdif);
mbed_official 573:ad23fe03a082 601 }
mbed_official 573:ad23fe03a082 602
mbed_official 573:ad23fe03a082 603 return HAL_OK;
mbed_official 573:ad23fe03a082 604 }
mbed_official 573:ad23fe03a082 605 else
mbed_official 573:ad23fe03a082 606 {
mbed_official 573:ad23fe03a082 607 return HAL_BUSY;
mbed_official 573:ad23fe03a082 608 }
mbed_official 573:ad23fe03a082 609 }
mbed_official 573:ad23fe03a082 610
mbed_official 573:ad23fe03a082 611 /**
mbed_official 573:ad23fe03a082 612 * @brief Receive an amount of data (Control Flow) with Interrupt
mbed_official 573:ad23fe03a082 613 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 614 * @param pData: a 32-bit pointer to the Receive data buffer.
mbed_official 573:ad23fe03a082 615 * @param Size: number of data sample (Control Flow) to be received :
mbed_official 573:ad23fe03a082 616 * @retval HAL status
mbed_official 573:ad23fe03a082 617 */
mbed_official 573:ad23fe03a082 618 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveControlFlow_IT(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size)
mbed_official 573:ad23fe03a082 619 {
mbed_official 573:ad23fe03a082 620 if((hspdif->State == HAL_SPDIFRX_STATE_READY) || (hspdif->State == HAL_SPDIFRX_STATE_BUSY_RX))
mbed_official 573:ad23fe03a082 621 {
mbed_official 573:ad23fe03a082 622 if((pData == NULL ) || (Size == 0))
mbed_official 573:ad23fe03a082 623 {
mbed_official 573:ad23fe03a082 624 return HAL_ERROR;
mbed_official 573:ad23fe03a082 625 }
mbed_official 573:ad23fe03a082 626
mbed_official 573:ad23fe03a082 627 /* Process Locked */
mbed_official 573:ad23fe03a082 628 __HAL_LOCK(hspdif);
mbed_official 573:ad23fe03a082 629
mbed_official 573:ad23fe03a082 630 hspdif->pCsBuffPtr = pData;
mbed_official 573:ad23fe03a082 631 hspdif->CsXferSize = Size;
mbed_official 573:ad23fe03a082 632 hspdif->CsXferCount = Size;
mbed_official 573:ad23fe03a082 633
mbed_official 573:ad23fe03a082 634 hspdif->ErrorCode = HAL_SPDIFRX_ERROR_NONE;
mbed_official 573:ad23fe03a082 635
mbed_official 573:ad23fe03a082 636 /* Check if a receive process is ongoing or not */
mbed_official 573:ad23fe03a082 637 hspdif->State = HAL_SPDIFRX_STATE_BUSY_CX;
mbed_official 573:ad23fe03a082 638
mbed_official 573:ad23fe03a082 639
mbed_official 573:ad23fe03a082 640 /* Enable the SPDIFRX PE Error Interrupt */
mbed_official 573:ad23fe03a082 641 __HAL_SPDIFRX_ENABLE_IT(hspdif, SPDIFRX_IT_PERRIE);
mbed_official 573:ad23fe03a082 642
mbed_official 573:ad23fe03a082 643 /* Enable the SPDIFRX OVR Error Interrupt */
mbed_official 573:ad23fe03a082 644 __HAL_SPDIFRX_ENABLE_IT(hspdif, SPDIFRX_IT_OVRIE);
mbed_official 573:ad23fe03a082 645
mbed_official 573:ad23fe03a082 646 /* Process Unlocked */
mbed_official 573:ad23fe03a082 647 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 648
mbed_official 573:ad23fe03a082 649 /* Enable the SPDIFRX CSRNE interrupt */
mbed_official 573:ad23fe03a082 650 __HAL_SPDIFRX_ENABLE_IT(hspdif, SPDIFRX_IT_CSRNE);
mbed_official 573:ad23fe03a082 651
mbed_official 573:ad23fe03a082 652 if (((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != SPDIFRX_STATE_SYNC) || ((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != 0x00))
mbed_official 573:ad23fe03a082 653 {
mbed_official 573:ad23fe03a082 654 /* Start synchronization */
mbed_official 573:ad23fe03a082 655 __HAL_SPDIFRX_SYNC(hspdif);
mbed_official 573:ad23fe03a082 656
mbed_official 573:ad23fe03a082 657 /* Wait until SYNCD flag is set */
mbed_official 573:ad23fe03a082 658 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_SYNCD, RESET, SPDIFRX_TIMEOUT_VALUE) != HAL_OK)
mbed_official 573:ad23fe03a082 659 {
mbed_official 573:ad23fe03a082 660 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 661 }
mbed_official 573:ad23fe03a082 662
mbed_official 573:ad23fe03a082 663 /* Start reception */
mbed_official 573:ad23fe03a082 664 __HAL_SPDIFRX_RCV(hspdif);
mbed_official 573:ad23fe03a082 665 }
mbed_official 573:ad23fe03a082 666
mbed_official 573:ad23fe03a082 667 return HAL_OK;
mbed_official 573:ad23fe03a082 668 }
mbed_official 573:ad23fe03a082 669 else
mbed_official 573:ad23fe03a082 670 {
mbed_official 573:ad23fe03a082 671 return HAL_BUSY;
mbed_official 573:ad23fe03a082 672 }
mbed_official 573:ad23fe03a082 673 }
mbed_official 573:ad23fe03a082 674
mbed_official 573:ad23fe03a082 675 /**
mbed_official 573:ad23fe03a082 676 * @brief Receive an amount of data (Data Flow) mode with DMA
mbed_official 573:ad23fe03a082 677 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 678 * @param pData: a 32-bit pointer to the Receive data buffer.
mbed_official 573:ad23fe03a082 679 * @param Size: number of data sample to be received :
mbed_official 573:ad23fe03a082 680 * @retval HAL status
mbed_official 573:ad23fe03a082 681 */
mbed_official 573:ad23fe03a082 682 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveDataFlow_DMA(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size)
mbed_official 573:ad23fe03a082 683 {
mbed_official 573:ad23fe03a082 684
mbed_official 573:ad23fe03a082 685 if((pData == NULL) || (Size == 0))
mbed_official 573:ad23fe03a082 686 {
mbed_official 573:ad23fe03a082 687 return HAL_ERROR;
mbed_official 573:ad23fe03a082 688 }
mbed_official 573:ad23fe03a082 689
mbed_official 573:ad23fe03a082 690 if((hspdif->State == HAL_SPDIFRX_STATE_READY) || (hspdif->State == HAL_SPDIFRX_STATE_BUSY_CX))
mbed_official 573:ad23fe03a082 691 {
mbed_official 573:ad23fe03a082 692 hspdif->pRxBuffPtr = pData;
mbed_official 573:ad23fe03a082 693 hspdif->RxXferSize = Size;
mbed_official 573:ad23fe03a082 694 hspdif->RxXferCount = Size;
mbed_official 573:ad23fe03a082 695
mbed_official 573:ad23fe03a082 696 /* Process Locked */
mbed_official 573:ad23fe03a082 697 __HAL_LOCK(hspdif);
mbed_official 573:ad23fe03a082 698
mbed_official 573:ad23fe03a082 699 hspdif->ErrorCode = HAL_SPDIFRX_ERROR_NONE;
mbed_official 573:ad23fe03a082 700 hspdif->State = HAL_SPDIFRX_STATE_BUSY_RX;
mbed_official 573:ad23fe03a082 701
mbed_official 573:ad23fe03a082 702 /* Set the SPDIFRX Rx DMA Half transfer complete callback */
mbed_official 573:ad23fe03a082 703 hspdif->hdmaDrRx->XferHalfCpltCallback = SPDIFRX_DMARxHalfCplt;
mbed_official 573:ad23fe03a082 704
mbed_official 573:ad23fe03a082 705 /* Set the SPDIFRX Rx DMA transfer complete callback */
mbed_official 573:ad23fe03a082 706 hspdif->hdmaDrRx->XferCpltCallback = SPDIFRX_DMARxCplt;
mbed_official 573:ad23fe03a082 707
mbed_official 573:ad23fe03a082 708 /* Set the DMA error callback */
mbed_official 573:ad23fe03a082 709 hspdif->hdmaDrRx->XferErrorCallback = SPDIFRX_DMAError;
mbed_official 573:ad23fe03a082 710
mbed_official 573:ad23fe03a082 711 /* Enable the DMA request */
mbed_official 573:ad23fe03a082 712 HAL_DMA_Start_IT(hspdif->hdmaDrRx, (uint32_t)&hspdif->Instance->DR, (uint32_t)hspdif->pRxBuffPtr, Size);
mbed_official 573:ad23fe03a082 713
mbed_official 573:ad23fe03a082 714 /* Enable RXDMAEN bit in SPDIFRX CR register for data flow reception*/
mbed_official 573:ad23fe03a082 715 hspdif->Instance->CR |= SPDIFRX_CR_RXDMAEN;
mbed_official 573:ad23fe03a082 716
mbed_official 573:ad23fe03a082 717 if (((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != SPDIFRX_STATE_SYNC) || ((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != 0x00))
mbed_official 573:ad23fe03a082 718 {
mbed_official 573:ad23fe03a082 719 /* Start synchronization */
mbed_official 573:ad23fe03a082 720 __HAL_SPDIFRX_SYNC(hspdif);
mbed_official 573:ad23fe03a082 721
mbed_official 573:ad23fe03a082 722 /* Wait until SYNCD flag is set */
mbed_official 573:ad23fe03a082 723 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_SYNCD, RESET, SPDIFRX_TIMEOUT_VALUE) != HAL_OK)
mbed_official 573:ad23fe03a082 724 {
mbed_official 573:ad23fe03a082 725 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 726 }
mbed_official 573:ad23fe03a082 727
mbed_official 573:ad23fe03a082 728 /* Start reception */
mbed_official 573:ad23fe03a082 729 __HAL_SPDIFRX_RCV(hspdif);
mbed_official 573:ad23fe03a082 730 }
mbed_official 573:ad23fe03a082 731
mbed_official 573:ad23fe03a082 732 /* Process Unlocked */
mbed_official 573:ad23fe03a082 733 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 734
mbed_official 573:ad23fe03a082 735 return HAL_OK;
mbed_official 573:ad23fe03a082 736 }
mbed_official 573:ad23fe03a082 737 else
mbed_official 573:ad23fe03a082 738 {
mbed_official 573:ad23fe03a082 739 return HAL_BUSY;
mbed_official 573:ad23fe03a082 740 }
mbed_official 573:ad23fe03a082 741 }
mbed_official 573:ad23fe03a082 742
mbed_official 573:ad23fe03a082 743 /**
mbed_official 573:ad23fe03a082 744 * @brief Receive an amount of data (Control Flow) with DMA
mbed_official 573:ad23fe03a082 745 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 746 * @param pData: a 32-bit pointer to the Receive data buffer.
mbed_official 573:ad23fe03a082 747 * @param Size: number of data (Control Flow) sample to be received :
mbed_official 573:ad23fe03a082 748 * @retval HAL status
mbed_official 573:ad23fe03a082 749 */
mbed_official 573:ad23fe03a082 750 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveControlFlow_DMA(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size)
mbed_official 573:ad23fe03a082 751 {
mbed_official 573:ad23fe03a082 752
mbed_official 573:ad23fe03a082 753 if((pData == NULL) || (Size == 0))
mbed_official 573:ad23fe03a082 754 {
mbed_official 573:ad23fe03a082 755 return HAL_ERROR;
mbed_official 573:ad23fe03a082 756 }
mbed_official 573:ad23fe03a082 757
mbed_official 573:ad23fe03a082 758 if((hspdif->State == HAL_SPDIFRX_STATE_READY) || (hspdif->State == HAL_SPDIFRX_STATE_BUSY_RX))
mbed_official 573:ad23fe03a082 759 {
mbed_official 573:ad23fe03a082 760 hspdif->pCsBuffPtr = pData;
mbed_official 573:ad23fe03a082 761 hspdif->CsXferSize = Size;
mbed_official 573:ad23fe03a082 762 hspdif->CsXferCount = Size;
mbed_official 573:ad23fe03a082 763
mbed_official 573:ad23fe03a082 764 /* Process Locked */
mbed_official 573:ad23fe03a082 765 __HAL_LOCK(hspdif);
mbed_official 573:ad23fe03a082 766
mbed_official 573:ad23fe03a082 767 hspdif->ErrorCode = HAL_SPDIFRX_ERROR_NONE;
mbed_official 573:ad23fe03a082 768 hspdif->State = HAL_SPDIFRX_STATE_BUSY_CX;
mbed_official 573:ad23fe03a082 769
mbed_official 573:ad23fe03a082 770 /* Set the SPDIFRX Rx DMA Half transfer complete callback */
mbed_official 573:ad23fe03a082 771 hspdif->hdmaCsRx->XferHalfCpltCallback = SPDIFRX_DMACxHalfCplt;
mbed_official 573:ad23fe03a082 772
mbed_official 573:ad23fe03a082 773 /* Set the SPDIFRX Rx DMA transfer complete callback */
mbed_official 573:ad23fe03a082 774 hspdif->hdmaCsRx->XferCpltCallback = SPDIFRX_DMACxCplt;
mbed_official 573:ad23fe03a082 775
mbed_official 573:ad23fe03a082 776 /* Set the DMA error callback */
mbed_official 573:ad23fe03a082 777 hspdif->hdmaCsRx->XferErrorCallback = SPDIFRX_DMAError;
mbed_official 573:ad23fe03a082 778
mbed_official 573:ad23fe03a082 779 /* Enable the DMA request */
mbed_official 573:ad23fe03a082 780 HAL_DMA_Start_IT(hspdif->hdmaCsRx, (uint32_t)&hspdif->Instance->CSR, (uint32_t)hspdif->pCsBuffPtr, Size);
mbed_official 573:ad23fe03a082 781
mbed_official 573:ad23fe03a082 782 /* Enable CBDMAEN bit in SPDIFRX CR register for control flow reception*/
mbed_official 573:ad23fe03a082 783 hspdif->Instance->CR |= SPDIFRX_CR_CBDMAEN;
mbed_official 573:ad23fe03a082 784
mbed_official 573:ad23fe03a082 785 if (((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != SPDIFRX_STATE_SYNC) || ((SPDIFRX->CR & SPDIFRX_CR_SPDIFEN) != 0x00))
mbed_official 573:ad23fe03a082 786 {
mbed_official 573:ad23fe03a082 787 /* Start synchronization */
mbed_official 573:ad23fe03a082 788 __HAL_SPDIFRX_SYNC(hspdif);
mbed_official 573:ad23fe03a082 789
mbed_official 573:ad23fe03a082 790 /* Wait until SYNCD flag is set */
mbed_official 573:ad23fe03a082 791 if(SPDIFRX_WaitOnFlagUntilTimeout(hspdif, SPDIFRX_FLAG_SYNCD, RESET, SPDIFRX_TIMEOUT_VALUE) != HAL_OK)
mbed_official 573:ad23fe03a082 792 {
mbed_official 573:ad23fe03a082 793 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 794 }
mbed_official 573:ad23fe03a082 795
mbed_official 573:ad23fe03a082 796 /* Start reception */
mbed_official 573:ad23fe03a082 797 __HAL_SPDIFRX_RCV(hspdif);
mbed_official 573:ad23fe03a082 798 }
mbed_official 573:ad23fe03a082 799
mbed_official 573:ad23fe03a082 800 /* Process Unlocked */
mbed_official 573:ad23fe03a082 801 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 802
mbed_official 573:ad23fe03a082 803 return HAL_OK;
mbed_official 573:ad23fe03a082 804 }
mbed_official 573:ad23fe03a082 805 else
mbed_official 573:ad23fe03a082 806 {
mbed_official 573:ad23fe03a082 807 return HAL_BUSY;
mbed_official 573:ad23fe03a082 808 }
mbed_official 573:ad23fe03a082 809 }
mbed_official 573:ad23fe03a082 810
mbed_official 573:ad23fe03a082 811 /**
mbed_official 573:ad23fe03a082 812 * @brief stop the audio stream receive from the Media.
mbed_official 573:ad23fe03a082 813 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 814 * @retval None
mbed_official 573:ad23fe03a082 815 */
mbed_official 573:ad23fe03a082 816 HAL_StatusTypeDef HAL_SPDIFRX_DMAStop(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 817 {
mbed_official 573:ad23fe03a082 818 /* Process Locked */
mbed_official 573:ad23fe03a082 819 __HAL_LOCK(hspdif);
mbed_official 573:ad23fe03a082 820
mbed_official 573:ad23fe03a082 821 /* Disable the SPDIFRX DMA requests */
mbed_official 573:ad23fe03a082 822 hspdif->Instance->CR &= (uint16_t)(~SPDIFRX_CR_RXDMAEN);
mbed_official 573:ad23fe03a082 823 hspdif->Instance->CR &= (uint16_t)(~SPDIFRX_CR_CBDMAEN);
mbed_official 573:ad23fe03a082 824
mbed_official 573:ad23fe03a082 825 /* Disable the SPDIFRX DMA channel */
mbed_official 573:ad23fe03a082 826 __HAL_DMA_DISABLE(hspdif->hdmaDrRx);
mbed_official 573:ad23fe03a082 827 __HAL_DMA_DISABLE(hspdif->hdmaCsRx);
mbed_official 573:ad23fe03a082 828
mbed_official 573:ad23fe03a082 829 /* Disable SPDIFRX peripheral */
mbed_official 573:ad23fe03a082 830 __HAL_SPDIFRX_IDLE(hspdif);
mbed_official 573:ad23fe03a082 831
mbed_official 573:ad23fe03a082 832 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 833
mbed_official 573:ad23fe03a082 834 /* Process Unlocked */
mbed_official 573:ad23fe03a082 835 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 836
mbed_official 573:ad23fe03a082 837 return HAL_OK;
mbed_official 573:ad23fe03a082 838 }
mbed_official 573:ad23fe03a082 839
mbed_official 573:ad23fe03a082 840 /**
mbed_official 573:ad23fe03a082 841 * @brief This function handles SPDIFRX interrupt request.
mbed_official 573:ad23fe03a082 842 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 843 * @retval HAL status
mbed_official 573:ad23fe03a082 844 */
mbed_official 573:ad23fe03a082 845 void HAL_SPDIFRX_IRQHandler(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 846 {
mbed_official 573:ad23fe03a082 847 /* SPDIFRX in mode Data Flow Reception ------------------------------------------------*/
mbed_official 573:ad23fe03a082 848 if((__HAL_SPDIFRX_GET_FLAG(hspdif, SPDIFRX_FLAG_RXNE) != RESET) && (__HAL_SPDIFRX_GET_IT_SOURCE(hspdif, SPDIFRX_IT_RXNE) != RESET))
mbed_official 573:ad23fe03a082 849 {
mbed_official 573:ad23fe03a082 850 __HAL_SPDIFRX_CLEAR_IT(hspdif, SPDIFRX_IT_RXNE);
mbed_official 573:ad23fe03a082 851 SPDIFRX_ReceiveDataFlow_IT(hspdif);
mbed_official 573:ad23fe03a082 852 }
mbed_official 573:ad23fe03a082 853
mbed_official 573:ad23fe03a082 854 /* SPDIFRX in mode Control Flow Reception ------------------------------------------------*/
mbed_official 573:ad23fe03a082 855 if((__HAL_SPDIFRX_GET_FLAG(hspdif, SPDIFRX_FLAG_CSRNE) != RESET) && (__HAL_SPDIFRX_GET_IT_SOURCE(hspdif, SPDIFRX_IT_CSRNE) != RESET))
mbed_official 573:ad23fe03a082 856 {
mbed_official 573:ad23fe03a082 857 __HAL_SPDIFRX_CLEAR_IT(hspdif, SPDIFRX_IT_CSRNE);
mbed_official 573:ad23fe03a082 858 SPDIFRX_ReceiveControlFlow_IT(hspdif);
mbed_official 573:ad23fe03a082 859 }
mbed_official 573:ad23fe03a082 860
mbed_official 573:ad23fe03a082 861 /* SPDIFRX Overrun error interrupt occurred ---------------------------------*/
mbed_official 573:ad23fe03a082 862 if((__HAL_SPDIFRX_GET_FLAG(hspdif, SPDIFRX_FLAG_OVR) != RESET) && (__HAL_SPDIFRX_GET_IT_SOURCE(hspdif, SPDIFRX_IT_OVRIE) != RESET))
mbed_official 573:ad23fe03a082 863 {
mbed_official 573:ad23fe03a082 864 __HAL_SPDIFRX_CLEAR_IT(hspdif, SPDIFRX_FLAG_OVR);
mbed_official 573:ad23fe03a082 865
mbed_official 573:ad23fe03a082 866 /* Change the SPDIFRX error code */
mbed_official 573:ad23fe03a082 867 hspdif->ErrorCode |= HAL_SPDIFRX_ERROR_OVR;
mbed_official 573:ad23fe03a082 868
mbed_official 573:ad23fe03a082 869 /* the transfer is not stopped */
mbed_official 573:ad23fe03a082 870 HAL_SPDIFRX_ErrorCallback(hspdif);
mbed_official 573:ad23fe03a082 871 }
mbed_official 573:ad23fe03a082 872
mbed_official 573:ad23fe03a082 873 /* SPDIFRX Parity error interrupt occurred ---------------------------------*/
mbed_official 573:ad23fe03a082 874 if((__HAL_SPDIFRX_GET_FLAG(hspdif, SPDIFRX_FLAG_PERR) != RESET) && (__HAL_SPDIFRX_GET_IT_SOURCE(hspdif, SPDIFRX_IT_PERRIE) != RESET))
mbed_official 573:ad23fe03a082 875 {
mbed_official 573:ad23fe03a082 876 __HAL_SPDIFRX_CLEAR_IT(hspdif, SPDIFRX_FLAG_PERR);
mbed_official 573:ad23fe03a082 877
mbed_official 573:ad23fe03a082 878 /* Change the SPDIFRX error code */
mbed_official 573:ad23fe03a082 879 hspdif->ErrorCode |= HAL_SPDIFRX_ERROR_PE;
mbed_official 573:ad23fe03a082 880
mbed_official 573:ad23fe03a082 881 /* the transfer is not stopped */
mbed_official 573:ad23fe03a082 882 HAL_SPDIFRX_ErrorCallback(hspdif);
mbed_official 573:ad23fe03a082 883 }
mbed_official 573:ad23fe03a082 884
mbed_official 573:ad23fe03a082 885 }
mbed_official 573:ad23fe03a082 886
mbed_official 573:ad23fe03a082 887 /**
mbed_official 573:ad23fe03a082 888 * @brief Rx Transfer (Data flow) half completed callbacks
mbed_official 573:ad23fe03a082 889 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 890 * @retval None
mbed_official 573:ad23fe03a082 891 */
mbed_official 573:ad23fe03a082 892 __weak void HAL_SPDIFRX_RxHalfCpltCallback(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 893 {
mbed_official 573:ad23fe03a082 894 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 895 the HAL_SPDIFRX_RxCpltCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 896 */
mbed_official 573:ad23fe03a082 897 }
mbed_official 573:ad23fe03a082 898
mbed_official 573:ad23fe03a082 899 /**
mbed_official 573:ad23fe03a082 900 * @brief Rx Transfer (Data flow) completed callbacks
mbed_official 573:ad23fe03a082 901 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 902 * @retval None
mbed_official 573:ad23fe03a082 903 */
mbed_official 573:ad23fe03a082 904 __weak void HAL_SPDIFRX_RxCpltCallback(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 905 {
mbed_official 573:ad23fe03a082 906 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 907 the HAL_SPDIFRX_RxCpltCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 908 */
mbed_official 573:ad23fe03a082 909 }
mbed_official 573:ad23fe03a082 910
mbed_official 573:ad23fe03a082 911 /**
mbed_official 573:ad23fe03a082 912 * @brief Rx (Control flow) Transfer half completed callbacks
mbed_official 573:ad23fe03a082 913 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 914 * @retval None
mbed_official 573:ad23fe03a082 915 */
mbed_official 573:ad23fe03a082 916 __weak void HAL_SPDIFRX_CxHalfCpltCallback(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 917 {
mbed_official 573:ad23fe03a082 918 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 919 the HAL_SPDIFRX_RxCpltCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 920 */
mbed_official 573:ad23fe03a082 921 }
mbed_official 573:ad23fe03a082 922
mbed_official 573:ad23fe03a082 923 /**
mbed_official 573:ad23fe03a082 924 * @brief Rx Transfer (Control flow) completed callbacks
mbed_official 573:ad23fe03a082 925 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 926 * @retval None
mbed_official 573:ad23fe03a082 927 */
mbed_official 573:ad23fe03a082 928 __weak void HAL_SPDIFRX_CxCpltCallback(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 929 {
mbed_official 573:ad23fe03a082 930 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 931 the HAL_SPDIFRX_RxCpltCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 932 */
mbed_official 573:ad23fe03a082 933 }
mbed_official 573:ad23fe03a082 934
mbed_official 573:ad23fe03a082 935 /**
mbed_official 573:ad23fe03a082 936 * @brief SPDIFRX error callbacks
mbed_official 573:ad23fe03a082 937 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 938 * @retval None
mbed_official 573:ad23fe03a082 939 */
mbed_official 573:ad23fe03a082 940 __weak void HAL_SPDIFRX_ErrorCallback(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 941 {
mbed_official 573:ad23fe03a082 942 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 943 the HAL_SPDIFRX_ErrorCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 944 */
mbed_official 573:ad23fe03a082 945 }
mbed_official 573:ad23fe03a082 946
mbed_official 573:ad23fe03a082 947 /**
mbed_official 573:ad23fe03a082 948 * @}
mbed_official 573:ad23fe03a082 949 */
mbed_official 573:ad23fe03a082 950
mbed_official 573:ad23fe03a082 951 /** @defgroup SPDIFRX_Exported_Functions_Group3 Peripheral State and Errors functions
mbed_official 573:ad23fe03a082 952 * @brief Peripheral State functions
mbed_official 573:ad23fe03a082 953 *
mbed_official 573:ad23fe03a082 954 @verbatim
mbed_official 573:ad23fe03a082 955 ===============================================================================
mbed_official 573:ad23fe03a082 956 ##### Peripheral State and Errors functions #####
mbed_official 573:ad23fe03a082 957 ===============================================================================
mbed_official 573:ad23fe03a082 958 [..]
mbed_official 573:ad23fe03a082 959 This subsection permit to get in run-time the status of the peripheral
mbed_official 573:ad23fe03a082 960 and the data flow.
mbed_official 573:ad23fe03a082 961
mbed_official 573:ad23fe03a082 962 @endverbatim
mbed_official 573:ad23fe03a082 963 * @{
mbed_official 573:ad23fe03a082 964 */
mbed_official 573:ad23fe03a082 965
mbed_official 573:ad23fe03a082 966 /**
mbed_official 573:ad23fe03a082 967 * @brief Return the SPDIFRX state
mbed_official 573:ad23fe03a082 968 * @param hspdif : SPDIFRX handle
mbed_official 573:ad23fe03a082 969 * @retval HAL state
mbed_official 573:ad23fe03a082 970 */
mbed_official 573:ad23fe03a082 971 HAL_SPDIFRX_StateTypeDef HAL_SPDIFRX_GetState(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 972 {
mbed_official 573:ad23fe03a082 973 return hspdif->State;
mbed_official 573:ad23fe03a082 974 }
mbed_official 573:ad23fe03a082 975
mbed_official 573:ad23fe03a082 976 /**
mbed_official 573:ad23fe03a082 977 * @brief Return the SPDIFRX error code
mbed_official 573:ad23fe03a082 978 * @param hspdif : SPDIFRX handle
mbed_official 573:ad23fe03a082 979 * @retval SPDIFRX Error Code
mbed_official 573:ad23fe03a082 980 */
mbed_official 573:ad23fe03a082 981 uint32_t HAL_SPDIFRX_GetError(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 982 {
mbed_official 573:ad23fe03a082 983 return hspdif->ErrorCode;
mbed_official 573:ad23fe03a082 984 }
mbed_official 573:ad23fe03a082 985
mbed_official 573:ad23fe03a082 986 /**
mbed_official 573:ad23fe03a082 987 * @}
mbed_official 573:ad23fe03a082 988 */
mbed_official 573:ad23fe03a082 989
mbed_official 573:ad23fe03a082 990 /**
mbed_official 573:ad23fe03a082 991 * @brief DMA SPDIFRX receive process (Data flow) complete callback
mbed_official 573:ad23fe03a082 992 * @param hdma : DMA handle
mbed_official 573:ad23fe03a082 993 * @retval None
mbed_official 573:ad23fe03a082 994 */
mbed_official 573:ad23fe03a082 995 static void SPDIFRX_DMARxCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 996 {
mbed_official 573:ad23fe03a082 997 SPDIFRX_HandleTypeDef* hspdif = ( SPDIFRX_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 998
mbed_official 573:ad23fe03a082 999 /* Disable Rx DMA Request */
mbed_official 573:ad23fe03a082 1000 hspdif->Instance->CR &= (uint16_t)(~SPDIFRX_CR_RXDMAEN);
mbed_official 573:ad23fe03a082 1001 hspdif->RxXferCount = 0;
mbed_official 573:ad23fe03a082 1002
mbed_official 573:ad23fe03a082 1003 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 1004 HAL_SPDIFRX_RxCpltCallback(hspdif);
mbed_official 573:ad23fe03a082 1005 }
mbed_official 573:ad23fe03a082 1006
mbed_official 573:ad23fe03a082 1007 /**
mbed_official 573:ad23fe03a082 1008 * @brief DMA SPDIFRX receive process (Data flow) half complete callback
mbed_official 573:ad23fe03a082 1009 * @param hdma : DMA handle
mbed_official 573:ad23fe03a082 1010 * @retval None
mbed_official 573:ad23fe03a082 1011 */
mbed_official 573:ad23fe03a082 1012 static void SPDIFRX_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1013 {
mbed_official 573:ad23fe03a082 1014 SPDIFRX_HandleTypeDef* hspdif = (SPDIFRX_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 573:ad23fe03a082 1015
mbed_official 573:ad23fe03a082 1016 HAL_SPDIFRX_RxHalfCpltCallback(hspdif);
mbed_official 573:ad23fe03a082 1017 }
mbed_official 573:ad23fe03a082 1018
mbed_official 573:ad23fe03a082 1019
mbed_official 573:ad23fe03a082 1020 /**
mbed_official 573:ad23fe03a082 1021 * @brief DMA SPDIFRX receive process (Control flow) complete callback
mbed_official 573:ad23fe03a082 1022 * @param hdma : DMA handle
mbed_official 573:ad23fe03a082 1023 * @retval None
mbed_official 573:ad23fe03a082 1024 */
mbed_official 573:ad23fe03a082 1025 static void SPDIFRX_DMACxCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1026 {
mbed_official 573:ad23fe03a082 1027 SPDIFRX_HandleTypeDef* hspdif = ( SPDIFRX_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1028
mbed_official 573:ad23fe03a082 1029 /* Disable Cb DMA Request */
mbed_official 573:ad23fe03a082 1030 hspdif->Instance->CR &= (uint16_t)(~SPDIFRX_CR_CBDMAEN);
mbed_official 573:ad23fe03a082 1031 hspdif->CsXferCount = 0;
mbed_official 573:ad23fe03a082 1032
mbed_official 573:ad23fe03a082 1033 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 1034 HAL_SPDIFRX_CxCpltCallback(hspdif);
mbed_official 573:ad23fe03a082 1035 }
mbed_official 573:ad23fe03a082 1036
mbed_official 573:ad23fe03a082 1037 /**
mbed_official 573:ad23fe03a082 1038 * @brief DMA SPDIFRX receive process (Control flow) half complete callback
mbed_official 573:ad23fe03a082 1039 * @param hdma : DMA handle
mbed_official 573:ad23fe03a082 1040 * @retval None
mbed_official 573:ad23fe03a082 1041 */
mbed_official 573:ad23fe03a082 1042 static void SPDIFRX_DMACxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1043 {
mbed_official 573:ad23fe03a082 1044 SPDIFRX_HandleTypeDef* hspdif = (SPDIFRX_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 573:ad23fe03a082 1045
mbed_official 573:ad23fe03a082 1046 HAL_SPDIFRX_CxHalfCpltCallback(hspdif);
mbed_official 573:ad23fe03a082 1047 }
mbed_official 573:ad23fe03a082 1048
mbed_official 573:ad23fe03a082 1049 /**
mbed_official 573:ad23fe03a082 1050 * @brief DMA SPDIFRX communication error callback
mbed_official 573:ad23fe03a082 1051 * @param hdma : DMA handle
mbed_official 573:ad23fe03a082 1052 * @retval None
mbed_official 573:ad23fe03a082 1053 */
mbed_official 573:ad23fe03a082 1054 static void SPDIFRX_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1055 {
mbed_official 573:ad23fe03a082 1056 SPDIFRX_HandleTypeDef* hspdif = ( SPDIFRX_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1057
mbed_official 573:ad23fe03a082 1058 /* Disable Rx and Cb DMA Request */
mbed_official 573:ad23fe03a082 1059 hspdif->Instance->CR &= (uint16_t)(~(SPDIFRX_CR_RXDMAEN | SPDIFRX_CR_CBDMAEN));
mbed_official 573:ad23fe03a082 1060 hspdif->RxXferCount = 0;
mbed_official 573:ad23fe03a082 1061
mbed_official 573:ad23fe03a082 1062 hspdif->State= HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 1063
mbed_official 573:ad23fe03a082 1064 /* Set the error code and execute error callback*/
mbed_official 573:ad23fe03a082 1065 hspdif->ErrorCode |= HAL_SPDIFRX_ERROR_DMA;
mbed_official 573:ad23fe03a082 1066 HAL_SPDIFRX_ErrorCallback(hspdif);
mbed_official 573:ad23fe03a082 1067 }
mbed_official 573:ad23fe03a082 1068
mbed_official 573:ad23fe03a082 1069
mbed_official 573:ad23fe03a082 1070 /**
mbed_official 573:ad23fe03a082 1071 * @brief Receive an amount of data (Data Flow) with Interrupt
mbed_official 573:ad23fe03a082 1072 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 1073 * @retval None
mbed_official 573:ad23fe03a082 1074 */
mbed_official 573:ad23fe03a082 1075 static void SPDIFRX_ReceiveDataFlow_IT(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 1076 {
mbed_official 573:ad23fe03a082 1077 /* Receive data */
mbed_official 573:ad23fe03a082 1078 (*hspdif->pRxBuffPtr++) = hspdif->Instance->DR;
mbed_official 573:ad23fe03a082 1079 hspdif->RxXferCount--;
mbed_official 573:ad23fe03a082 1080
mbed_official 573:ad23fe03a082 1081 if(hspdif->RxXferCount == 0)
mbed_official 573:ad23fe03a082 1082 {
mbed_official 573:ad23fe03a082 1083 /* Disable RXNE/PE and OVR interrupts */
mbed_official 573:ad23fe03a082 1084 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_OVRIE | SPDIFRX_IT_PERRIE | SPDIFRX_IT_RXNE);
mbed_official 573:ad23fe03a082 1085
mbed_official 573:ad23fe03a082 1086 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 1087
mbed_official 573:ad23fe03a082 1088 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1089 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 1090
mbed_official 573:ad23fe03a082 1091 HAL_SPDIFRX_RxCpltCallback(hspdif);
mbed_official 573:ad23fe03a082 1092 }
mbed_official 573:ad23fe03a082 1093 }
mbed_official 573:ad23fe03a082 1094
mbed_official 573:ad23fe03a082 1095 /**
mbed_official 573:ad23fe03a082 1096 * @brief Receive an amount of data (Control Flow) with Interrupt
mbed_official 573:ad23fe03a082 1097 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 1098 * @retval None
mbed_official 573:ad23fe03a082 1099 */
mbed_official 573:ad23fe03a082 1100 static void SPDIFRX_ReceiveControlFlow_IT(SPDIFRX_HandleTypeDef *hspdif)
mbed_official 573:ad23fe03a082 1101 {
mbed_official 573:ad23fe03a082 1102 /* Receive data */
mbed_official 573:ad23fe03a082 1103 (*hspdif->pCsBuffPtr++) = hspdif->Instance->CSR;
mbed_official 573:ad23fe03a082 1104 hspdif->CsXferCount--;
mbed_official 573:ad23fe03a082 1105
mbed_official 573:ad23fe03a082 1106 if(hspdif->CsXferCount == 0)
mbed_official 573:ad23fe03a082 1107 {
mbed_official 573:ad23fe03a082 1108 /* Disable CSRNE interrupt */
mbed_official 573:ad23fe03a082 1109 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_CSRNE);
mbed_official 573:ad23fe03a082 1110
mbed_official 573:ad23fe03a082 1111 hspdif->State = HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 1112
mbed_official 573:ad23fe03a082 1113 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1114 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 1115
mbed_official 573:ad23fe03a082 1116 HAL_SPDIFRX_CxCpltCallback(hspdif);
mbed_official 573:ad23fe03a082 1117 }
mbed_official 573:ad23fe03a082 1118 }
mbed_official 573:ad23fe03a082 1119
mbed_official 573:ad23fe03a082 1120 /**
mbed_official 573:ad23fe03a082 1121 * @brief This function handles SPDIFRX Communication Timeout.
mbed_official 573:ad23fe03a082 1122 * @param hspdif: SPDIFRX handle
mbed_official 573:ad23fe03a082 1123 * @param Flag: Flag checked
mbed_official 573:ad23fe03a082 1124 * @param Status: Value of the flag expected
mbed_official 573:ad23fe03a082 1125 * @param Timeout: Duration of the timeout
mbed_official 573:ad23fe03a082 1126 * @retval HAL status
mbed_official 573:ad23fe03a082 1127 */
mbed_official 573:ad23fe03a082 1128 static HAL_StatusTypeDef SPDIFRX_WaitOnFlagUntilTimeout(SPDIFRX_HandleTypeDef *hspdif, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 573:ad23fe03a082 1129 {
mbed_official 573:ad23fe03a082 1130 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1131
mbed_official 573:ad23fe03a082 1132 /* Get tick */
mbed_official 573:ad23fe03a082 1133 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1134
mbed_official 573:ad23fe03a082 1135 /* Wait until flag is set */
mbed_official 573:ad23fe03a082 1136 if(Status == RESET)
mbed_official 573:ad23fe03a082 1137 {
mbed_official 573:ad23fe03a082 1138 while(__HAL_SPDIFRX_GET_FLAG(hspdif, Flag) == RESET)
mbed_official 573:ad23fe03a082 1139 {
mbed_official 573:ad23fe03a082 1140 /* Check for the Timeout */
mbed_official 573:ad23fe03a082 1141 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 1142 {
mbed_official 573:ad23fe03a082 1143 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 573:ad23fe03a082 1144 {
mbed_official 573:ad23fe03a082 1145 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 573:ad23fe03a082 1146 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_RXNE);
mbed_official 573:ad23fe03a082 1147 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_CSRNE);
mbed_official 573:ad23fe03a082 1148 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_PERRIE);
mbed_official 573:ad23fe03a082 1149 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_OVRIE);
mbed_official 573:ad23fe03a082 1150 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_SBLKIE);
mbed_official 573:ad23fe03a082 1151 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_SYNCDIE);
mbed_official 573:ad23fe03a082 1152 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_IFEIE);
mbed_official 573:ad23fe03a082 1153
mbed_official 573:ad23fe03a082 1154 hspdif->State= HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 1155
mbed_official 573:ad23fe03a082 1156 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1157 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 1158
mbed_official 573:ad23fe03a082 1159 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1160 }
mbed_official 573:ad23fe03a082 1161 }
mbed_official 573:ad23fe03a082 1162 }
mbed_official 573:ad23fe03a082 1163 }
mbed_official 573:ad23fe03a082 1164 else
mbed_official 573:ad23fe03a082 1165 {
mbed_official 573:ad23fe03a082 1166 while(__HAL_SPDIFRX_GET_FLAG(hspdif, Flag) != RESET)
mbed_official 573:ad23fe03a082 1167 {
mbed_official 573:ad23fe03a082 1168 /* Check for the Timeout */
mbed_official 573:ad23fe03a082 1169 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 1170 {
mbed_official 573:ad23fe03a082 1171 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 573:ad23fe03a082 1172 {
mbed_official 573:ad23fe03a082 1173 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 573:ad23fe03a082 1174 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_RXNE);
mbed_official 573:ad23fe03a082 1175 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_CSRNE);
mbed_official 573:ad23fe03a082 1176 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_PERRIE);
mbed_official 573:ad23fe03a082 1177 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_OVRIE);
mbed_official 573:ad23fe03a082 1178 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_SBLKIE);
mbed_official 573:ad23fe03a082 1179 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_SYNCDIE);
mbed_official 573:ad23fe03a082 1180 __HAL_SPDIFRX_DISABLE_IT(hspdif, SPDIFRX_IT_IFEIE);
mbed_official 573:ad23fe03a082 1181
mbed_official 573:ad23fe03a082 1182 hspdif->State= HAL_SPDIFRX_STATE_READY;
mbed_official 573:ad23fe03a082 1183
mbed_official 573:ad23fe03a082 1184 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1185 __HAL_UNLOCK(hspdif);
mbed_official 573:ad23fe03a082 1186
mbed_official 573:ad23fe03a082 1187 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1188 }
mbed_official 573:ad23fe03a082 1189 }
mbed_official 573:ad23fe03a082 1190 }
mbed_official 573:ad23fe03a082 1191 }
mbed_official 573:ad23fe03a082 1192 return HAL_OK;
mbed_official 573:ad23fe03a082 1193 }
mbed_official 573:ad23fe03a082 1194
mbed_official 573:ad23fe03a082 1195 /**
mbed_official 573:ad23fe03a082 1196 * @}
mbed_official 573:ad23fe03a082 1197 */
mbed_official 573:ad23fe03a082 1198
mbed_official 573:ad23fe03a082 1199 #endif /* HAL_SPDIFRX_MODULE_ENABLED */
mbed_official 573:ad23fe03a082 1200 /**
mbed_official 573:ad23fe03a082 1201 * @}
mbed_official 573:ad23fe03a082 1202 */
mbed_official 573:ad23fe03a082 1203
mbed_official 573:ad23fe03a082 1204 /**
mbed_official 573:ad23fe03a082 1205 * @}
mbed_official 573:ad23fe03a082 1206 */
mbed_official 573:ad23fe03a082 1207
mbed_official 573:ad23fe03a082 1208 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/