mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_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