marcus chiou / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_spdifrx.c@613:bc40b8d2aec4, 2015-08-20 (annotated)

Committer:
mbed_official
Date:
Thu Aug 20 10:45:13 2015 +0100
Revision:
613:bc40b8d2aec4
Parent:
532:fe11edbda85c 
Synchronized with git revision 92ca8c7b60a283b6bb60eb65b183dac1599f0ade



Full URL: https://github.com/mbedmicro/mbed/commit/92ca8c7b60a283b6bb60eb65b183dac1599f0ade/



Nordic: update application start address in GCC linker script

Who changed what in which revision?

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