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_STM32F7/stm32f7xx_hal_spdifrx.c@573:ad23fe03a082, 2015-06-19 (annotated)

Committer:
mbed_official
Date:
Fri Jun 19 09:15:11 2015 +0100
Revision:
573:ad23fe03a082
Child:
610:813dcc80987e
Synchronized with git revision d47834cd4d729e5b36b4c1ad4650f8b8f6a9ab86



Full URL: https://github.com/mbedmicro/mbed/commit/d47834cd4d729e5b36b4c1ad4650f8b8f6a9ab86/



DISCO_F746NG - Add new target

Who changed what in which revision?

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