git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/include/stm32f7xx_hal_spdifrx.h

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_spdifrx.h\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0RC1\r
   6   * @date    24-March-2015\r
   7   * @brief   Header file of SPDIFRX HAL module.\r
   8   ******************************************************************************\r
   9   * @attention\r
  10   *\r
  11   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  12   *\r
  13   * Redistribution and use in source and binary forms, with or without modification,\r
  14   * are permitted provided that the following conditions are met:\r
  15   *   1. Redistributions of source code must retain the above copyright notice,\r
  16   *      this list of conditions and the following disclaimer.\r
  17   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  18   *      this list of conditions and the following disclaimer in the documentation\r
  19   *      and/or other materials provided with the distribution.\r
  20   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  21   *      may be used to endorse or promote products derived from this software\r
  22   *      without specific prior written permission.\r
  23   *\r
  24   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  25   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  26   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  27   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  29   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  31   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  32   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  33   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  34   *\r
  35   ******************************************************************************\r
  36   */ \r
  37 \r
  38 /* Define to prevent recursive inclusion -------------------------------------*/\r
  39 #ifndef __STM32F7xx_HAL_SPDIFRX_H\r
  40 #define __STM32F7xx_HAL_SPDIFRX_H\r
  41 \r
  42 #ifdef __cplusplus\r
  43  extern "C" {\r
  44 #endif\r
  45 \r
  46 /* Includes ------------------------------------------------------------------*/\r
  47 #include "stm32f7xx_hal_def.h"  \r
  48 \r
  49 /** @addtogroup STM32F7xx_HAL_Driver\r
  50   * @{\r
  51   */\r
  52 \r
  53 /** @addtogroup SPDIFRX\r
  54   * @{\r
  55   */ \r
  56 \r
  57 /* Exported types ------------------------------------------------------------*/ \r
  58 /** @defgroup SPDIFRX_Exported_Types SPDIFRX Exported Types\r
  59   * @{\r
  60   */\r
  61 \r
  62 /** \r
  63   * @brief SPDIFRX Init structure definition  \r
  64   */\r
  65 typedef struct\r
  66 {\r
  67   uint32_t InputSelection;           /*!< Specifies the SPDIF input selection.\r
  68                                           This parameter can be a value of @ref SPDIFRX_Input_Selection */\r
  69 \r
  70   uint32_t Retries;                  /*!< Specifies the Maximum allowed re-tries during synchronization phase.\r
  71                                           This parameter can be a value of @ref SPDIFRX_Max_Retries */\r
  72 \r
  73   uint32_t WaitForActivity;          /*!< Specifies the wait for activity on SPDIF selected input.\r
  74                                           This parameter can be a value of @ref SPDIFRX_Wait_For_Activity. */\r
  75 \r
  76   uint32_t ChannelSelection;         /*!< Specifies whether the control flow will take the channel status from channel A or B.\r
  77                                           This parameter can be a value of @ref SPDIFRX_Channel_Selection */\r
  78 \r
  79   uint32_t DataFormat;               /*!< Specifies the Data samples format (LSB, MSB, ...).\r
  80                                           This parameter can be a value of @ref SPDIFRX_Data_Format */\r
  81                                                \r
  82   uint32_t StereoMode;               /*!< Specifies whether the peripheral is in stereo or mono mode.\r
  83                                           This parameter can be a value of @ref SPDIFRX_Stereo_Mode */\r
  84 \r
  85     uint32_t PreambleTypeMask;          /*!< Specifies whether The preamble type bits are copied or not into the received frame.\r
  86                                                                                    This parameter can be a value of @ref SPDIFRX_PT_Mask */\r
  87 \r
  88     uint32_t ChannelStatusMask;        /*!< Specifies whether the channel status and user bits are copied or not into the received frame.\r
  89                                                                                   This parameter can be a value of @ref SPDIFRX_ChannelStatus_Mask */\r
  90     \r
  91     uint32_t ValidityBitMask;          /*!< Specifies whether the validity bit is copied or not into the received frame.\r
  92                                                                                   This parameter can be a value of @ref SPDIFRX_V_Mask */                                                                                \r
  93                                                                                 \r
  94     uint32_t ParityErrorMask;          /*!< Specifies whether the parity error bit is copied or not into the received frame.\r
  95                                                                                   This parameter can be a value of @ref SPDIFRX_PE_Mask */\r
  96     \r
  97 }SPDIFRX_InitTypeDef;\r
  98 \r
  99 /** \r
 100   * @brief SPDIFRX SetDataFormat structure definition  \r
 101   */\r
 102 typedef struct\r
 103 {\r
 104   uint32_t DataFormat;               /*!< Specifies the Data samples format (LSB, MSB, ...).\r
 105                                           This parameter can be a value of @ref SPDIFRX_Data_Format */\r
 106                                                \r
 107   uint32_t StereoMode;               /*!< Specifies whether the peripheral is in stereo or mono mode.\r
 108                                           This parameter can be a value of @ref SPDIFRX_Stereo_Mode */\r
 109 \r
 110   uint32_t PreambleTypeMask;          /*!< Specifies whether The preamble type bits are copied or not into the received frame.\r
 111                                                                                    This parameter can be a value of @ref SPDIFRX_PT_Mask */\r
 112 \r
 113   uint32_t ChannelStatusMask;        /*!< Specifies whether the channel status and user bits are copied or not into the received frame.\r
 114                                                                                   This parameter can be a value of @ref SPDIFRX_ChannelStatus_Mask */\r
 115     \r
 116   uint32_t ValidityBitMask;          /*!< Specifies whether the validity bit is copied or not into the received frame.\r
 117                                                                                   This parameter can be a value of @ref SPDIFRX_V_Mask */                                                                                \r
 118                                                                                 \r
 119   uint32_t ParityErrorMask;          /*!< Specifies whether the parity error bit is copied or not into the received frame.\r
 120                                                                                   This parameter can be a value of @ref SPDIFRX_PE_Mask */\r
 121     \r
 122 }SPDIFRX_SetDataFormatTypeDef;\r
 123 \r
 124 /** \r
 125   * @brief  HAL State structures definition  \r
 126   */ \r
 127 typedef enum\r
 128 {\r
 129   HAL_SPDIFRX_STATE_RESET      = 0x00,  /*!< SPDIFRX not yet initialized or disabled                */\r
 130   HAL_SPDIFRX_STATE_READY      = 0x01,  /*!< SPDIFRX initialized and ready for use                  */\r
 131   HAL_SPDIFRX_STATE_BUSY       = 0x02,  /*!< SPDIFRX internal process is ongoing                    */ \r
 132   HAL_SPDIFRX_STATE_BUSY_RX    = 0x03,  /*!< SPDIFRX internal Data Flow RX process is ongoing       */  \r
 133   HAL_SPDIFRX_STATE_BUSY_CX    = 0x04,  /*!< SPDIFRX internal Control Flow RX process is ongoing    */    \r
 134   HAL_SPDIFRX_STATE_ERROR      = 0x07   /*!< SPDIFRX error state                                    */      \r
 135 }HAL_SPDIFRX_StateTypeDef;\r
 136 \r
 137 /** \r
 138   * @brief SPDIFRX handle Structure definition  \r
 139   */\r
 140 typedef struct\r
 141 {\r
 142   SPDIFRX_TypeDef            *Instance;    /* SPDIFRX registers base address */\r
 143 \r
 144   SPDIFRX_InitTypeDef        Init;         /* SPDIFRX communication parameters */\r
 145                             \r
 146   uint32_t                   *pRxBuffPtr;  /* Pointer to SPDIFRX Rx transfer buffer */\r
 147     \r
 148     uint32_t                   *pCsBuffPtr;  /* Pointer to SPDIFRX Cx transfer buffer */\r
 149   \r
 150   __IO uint16_t              RxXferSize;   /* SPDIFRX Rx transfer size */\r
 151   \r
 152   __IO uint16_t              RxXferCount;  /* SPDIFRX Rx transfer counter \r
 153                                               (This field is initialized at the \r
 154                                                same value as transfer size at the \r
 155                                                beginning of the transfer and \r
 156                                                decremented when a sample is received. \r
 157                                                NbSamplesReceived = RxBufferSize-RxBufferCount) */\r
 158     \r
 159   __IO uint16_t              CsXferSize;   /* SPDIFRX Rx transfer size */\r
 160   \r
 161   __IO uint16_t              CsXferCount;  /* SPDIFRX Rx transfer counter \r
 162                                               (This field is initialized at the \r
 163                                                same value as transfer size at the \r
 164                                                beginning of the transfer and \r
 165                                                decremented when a sample is received. \r
 166                                                NbSamplesReceived = RxBufferSize-RxBufferCount) */\r
 167                                                                                              \r
 168   DMA_HandleTypeDef          *hdmaCsRx;    /* SPDIFRX EC60958_channel_status and user_information DMA handle parameters */\r
 169 \r
 170   DMA_HandleTypeDef          *hdmaDrRx;    /* SPDIFRX Rx DMA handle parameters */\r
 171   \r
 172   __IO HAL_LockTypeDef       Lock;         /* SPDIFRX locking object */\r
 173   \r
 174   __IO HAL_SPDIFRX_StateTypeDef  State;    /* SPDIFRX communication state */\r
 175 \r
 176   __IO uint32_t  ErrorCode;                /* SPDIFRX Error code                 */\r
 177 \r
 178 }SPDIFRX_HandleTypeDef;\r
 179 /**\r
 180   * @}\r
 181   */\r
 182 \r
 183 /* Exported constants --------------------------------------------------------*/\r
 184 /** @defgroup SPDIFRX_Exported_Constants SPDIFRX Exported Constants\r
 185   * @{\r
 186   */\r
 187 /** @defgroup SPDIFRX_ErrorCode SPDIFRX Error Code\r
 188   * @{\r
 189   */ \r
 190 #define HAL_SPDIFRX_ERROR_NONE      ((uint32_t)0x00000000)  /*!< No error           */\r
 191 #define HAL_SPDIFRX_ERROR_TIMEOUT   ((uint32_t)0x00000001)  /*!< Timeout error      */  \r
 192 #define HAL_SPDIFRX_ERROR_OVR       ((uint32_t)0x00000002)  /*!< OVR error          */\r
 193 #define HAL_SPDIFRX_ERROR_PE        ((uint32_t)0x00000004)  /*!< Parity error       */\r
 194 #define HAL_SPDIFRX_ERROR_DMA       ((uint32_t)0x00000008)  /*!< DMA transfer error */\r
 195 #define HAL_SPDIFRX_ERROR_UNKNOWN   ((uint32_t)0x00000010)  /*!< Unknown Error error */  \r
 196 /**\r
 197   * @}\r
 198   */\r
 199   \r
 200 /** @defgroup SPDIFRX_Input_Selection SPDIFRX Input Selection\r
 201   * @{\r
 202   */\r
 203 #define SPDIFRX_INPUT_IN0               ((uint32_t)0x00000000)\r
 204 #define SPDIFRX_INPUT_IN1               ((uint32_t)0x00010000)  \r
 205 #define SPDIFRX_INPUT_IN2               ((uint32_t)0x00020000)\r
 206 #define SPDIFRX_INPUT_IN3               ((uint32_t)0x00030000)\r
 207 /**\r
 208   * @}\r
 209   */\r
 210 \r
 211 /** @defgroup SPDIFRX_Max_Retries SPDIFRX Maximum Retries\r
 212   * @{\r
 213   */\r
 214 #define SPDIFRX_MAXRETRIES_NONE            ((uint32_t)0x00000000)\r
 215 #define SPDIFRX_MAXRETRIES_3               ((uint32_t)0x00001000)  \r
 216 #define SPDIFRX_MAXRETRIES_15              ((uint32_t)0x00002000)\r
 217 #define SPDIFRX_MAXRETRIES_63              ((uint32_t)0x00003000)\r
 218 /**\r
 219   * @}\r
 220   */\r
 221 \r
 222 /** @defgroup SPDIFRX_Wait_For_Activity SPDIFRX Wait For Activity\r
 223   * @{\r
 224   */\r
 225 #define SPDIFRX_WAITFORACTIVITY_OFF                   ((uint32_t)0x00000000)\r
 226 #define SPDIFRX_WAITFORACTIVITY_ON                    ((uint32_t)SPDIFRX_CR_WFA)\r
 227 /**\r
 228   * @}\r
 229   */\r
 230     \r
 231 /** @defgroup SPDIFRX_PT_Mask SPDIFRX Preamble Type Mask\r
 232 * @{\r
 233 */\r
 234 #define SPDIFRX_PREAMBLETYPEMASK_OFF                   ((uint32_t)0x00000000)\r
 235 #define SPDIFRX_PREAMBLETYPEMASK_ON                    ((uint32_t)SPDIFRX_CR_PTMSK)\r
 236 /**\r
 237   * @}\r
 238   */\r
 239 \r
 240 /** @defgroup SPDIFRX_ChannelStatus_Mask  SPDIFRX Channel Status Mask\r
 241 * @{\r
 242 */\r
 243 #define SPDIFRX_CHANNELSTATUS_OFF                 ((uint32_t)0x00000000)        /* The channel status and user bits are copied into the SPDIF_DR */\r
 244 #define SPDIFRX_CHANNELSTATUS_ON                  ((uint32_t)SPDIFRX_CR_CUMSK)  /* The channel status and user bits are not copied into the SPDIF_DR, zeros are written instead*/\r
 245 /**\r
 246   * @}\r
 247   */\r
 248 \r
 249 /** @defgroup SPDIFRX_V_Mask SPDIFRX Validity Mask\r
 250 * @{\r
 251 */\r
 252 #define SPDIFRX_VALIDITYMASK_OFF                   ((uint32_t)0x00000000)\r
 253 #define SPDIFRX_VALIDITYMASK_ON                    ((uint32_t)SPDIFRX_CR_VMSK)\r
 254 /**\r
 255   * @}\r
 256   */\r
 257 \r
 258 /** @defgroup SPDIFRX_PE_Mask  SPDIFRX Parity Error Mask\r
 259 * @{\r
 260 */\r
 261 #define SPDIFRX_PARITYERRORMASK_OFF                   ((uint32_t)0x00000000)\r
 262 #define SPDIFRX_PARITYERRORMASK_ON                    ((uint32_t)SPDIFRX_CR_PMSK)\r
 263 /**\r
 264   * @}\r
 265   */\r
 266 \r
 267 /** @defgroup SPDIFRX_Channel_Selection  SPDIFRX Channel Selection\r
 268   * @{\r
 269   */\r
 270 #define SPDIFRX_CHANNEL_A      ((uint32_t)0x00000000)\r
 271 #define SPDIFRX_CHANNEL_B      ((uint32_t)SPDIFRX_CR_CHSEL)\r
 272 /**\r
 273   * @}\r
 274   */\r
 275 \r
 276 /** @defgroup SPDIFRX_Data_Format SPDIFRX Data Format\r
 277   * @{\r
 278   */\r
 279 #define SPDIFRX_DATAFORMAT_LSB                   ((uint32_t)0x00000000)\r
 280 #define SPDIFRX_DATAFORMAT_MSB                   ((uint32_t)0x00000010)\r
 281 #define SPDIFRX_DATAFORMAT_32BITS                ((uint32_t)0x00000020)\r
 282 /**\r
 283   * @}\r
 284   */ \r
 285 \r
 286 /** @defgroup SPDIFRX_Stereo_Mode SPDIFRX Stereo Mode\r
 287   * @{\r
 288   */\r
 289 #define SPDIFRX_STEREOMODE_DISABLE           ((uint32_t)0x00000000)\r
 290 #define SPDIFRX_STEREOMODE_ENABLE           ((uint32_t)SPDIFRX_CR_RXSTEO)\r
 291 /**\r
 292   * @}\r
 293   */ \r
 294 \r
 295 /** @defgroup SPDIFRX_State SPDIFRX State\r
 296   * @{\r
 297   */\r
 298 \r
 299 #define SPDIFRX_STATE_IDLE    ((uint32_t)0xFFFFFFFC)\r
 300 #define SPDIFRX_STATE_SYNC    ((uint32_t)0x00000001)\r
 301 #define SPDIFRX_STATE_RCV     ((uint32_t)SPDIFRX_CR_SPDIFEN)\r
 302 /**\r
 303   * @}\r
 304   */\r
 305     \r
 306 /** @defgroup SPDIFRX_Interrupts_Definition SPDIFRX Interrupts Definition\r
 307   * @{\r
 308   */\r
 309 #define SPDIFRX_IT_RXNE                       ((uint32_t)SPDIFRX_IMR_RXNEIE)\r
 310 #define SPDIFRX_IT_CSRNE                      ((uint32_t)SPDIFRX_IMR_CSRNEIE)\r
 311 #define SPDIFRX_IT_PERRIE                     ((uint32_t)SPDIFRX_IMR_PERRIE)\r
 312 #define SPDIFRX_IT_OVRIE                      ((uint32_t)SPDIFRX_IMR_OVRIE)\r
 313 #define SPDIFRX_IT_SBLKIE                     ((uint32_t)SPDIFRX_IMR_SBLKIE)\r
 314 #define SPDIFRX_IT_SYNCDIE                    ((uint32_t)SPDIFRX_IMR_SYNCDIE)\r
 315 #define SPDIFRX_IT_IFEIE                      ((uint32_t)SPDIFRX_IMR_IFEIE )\r
 316 /**\r
 317   * @}\r
 318   */\r
 319     \r
 320 /** @defgroup SPDIFRX_Flags_Definition SPDIFRX Flags Definition\r
 321   * @{\r
 322   */\r
 323 #define SPDIFRX_FLAG_RXNE                   ((uint32_t)SPDIFRX_SR_RXNE)\r
 324 #define SPDIFRX_FLAG_CSRNE                  ((uint32_t)SPDIFRX_SR_CSRNE)\r
 325 #define SPDIFRX_FLAG_PERR                   ((uint32_t)SPDIFRX_SR_PERR)\r
 326 #define SPDIFRX_FLAG_OVR                    ((uint32_t)SPDIFRX_SR_OVR)\r
 327 #define SPDIFRX_FLAG_SBD                    ((uint32_t)SPDIFRX_SR_SBD)\r
 328 #define SPDIFRX_FLAG_SYNCD                  ((uint32_t)SPDIFRX_SR_SYNCD)\r
 329 #define SPDIFRX_FLAG_FERR                   ((uint32_t)SPDIFRX_SR_FERR)\r
 330 #define SPDIFRX_FLAG_SERR                   ((uint32_t)SPDIFRX_SR_SERR)\r
 331 #define SPDIFRX_FLAG_TERR                   ((uint32_t)SPDIFRX_SR_TERR)\r
 332 /**\r
 333   * @}\r
 334   */\r
 335 \r
 336 /**\r
 337   * @}\r
 338   */ \r
 339   \r
 340 /* Exported macros -----------------------------------------------------------*/\r
 341 /** @defgroup SPDIFRX_Exported_macros SPDIFRX Exported Macros\r
 342   * @{\r
 343   */\r
 344 \r
 345 /** @brief  Reset SPDIFRX handle state\r
 346   * @param  __HANDLE__: SPDIFRX handle.\r
 347   * @retval None\r
 348   */\r
 349 #define __HAL_SPDIFRX_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = (uint16_t)SPDIFRX_CR_SPDIFEN)\r
 350 \r
 351 /** @brief  Disable the specified SPDIFRX peripheral (IDLE State).\r
 352   * @param  __HANDLE__: specifies the SPDIFRX Handle. \r
 353   * @retval None\r
 354   */\r
 355 #define __HAL_SPDIFRX_IDLE(__HANDLE__) ((__HANDLE__)->Instance->CR &= SPDIFRX_STATE_IDLE)\r
 356 \r
 357 /** @brief  Enable the specified SPDIFRX peripheral (SYNC State).\r
 358   * @param  __HANDLE__: specifies the SPDIFRX Handle. \r
 359   * @retval None\r
 360   */\r
 361 #define __HAL_SPDIFRX_SYNC(__HANDLE__) ((__HANDLE__)->Instance->CR |= SPDIFRX_STATE_SYNC)\r
 362 \r
 363 \r
 364 /** @brief  Enable the specified SPDIFRX peripheral (RCV State).\r
 365   * @param  __HANDLE__: specifies the SPDIFRX Handle. \r
 366   * @retval None\r
 367   */\r
 368 #define __HAL_SPDIFRX_RCV(__HANDLE__) ((__HANDLE__)->Instance->CR |= SPDIFRX_STATE_RCV)\r
 369 \r
 370 \r
 371 /** @brief  Enable or disable the specified SPDIFRX interrupts.\r
 372   * @param  __HANDLE__: specifies the SPDIFRX Handle.\r
 373   * @param  __INTERRUPT__: specifies the interrupt source to enable or disable.\r
 374   *        This parameter can be one of the following values:\r
 375   *            @arg SPDIFRX_IT_RXNE\r
 376   *            @arg SPDIFRX_IT_CSRNE\r
 377   *            @arg SPDIFRX_IT_PERRIE\r
 378   *            @arg SPDIFRX_IT_OVRIE\r
 379   *            @arg SPDIFRX_IT_SBLKIE\r
 380   *            @arg SPDIFRX_IT_SYNCDIE\r
 381   *            @arg SPDIFRX_IT_IFEIE\r
 382   * @retval None\r
 383   */  \r
 384 #define __HAL_SPDIFRX_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->IMR |= (__INTERRUPT__))\r
 385 #define __HAL_SPDIFRX_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->IMR &= (uint16_t)(~(__INTERRUPT__)))\r
 386  \r
 387 /** @brief  Checks if the specified SPDIFRX interrupt source is enabled or disabled.\r
 388   * @param  __HANDLE__: specifies the SPDIFRX Handle.\r
 389   * @param  __INTERRUPT__: specifies the SPDIFRX interrupt source to check.\r
 390   *          This parameter can be one of the following values:\r
 391   *            @arg SPDIFRX_IT_RXNE\r
 392   *            @arg SPDIFRX_IT_CSRNE\r
 393   *            @arg SPDIFRX_IT_PERRIE\r
 394   *            @arg SPDIFRX_IT_OVRIE\r
 395   *            @arg SPDIFRX_IT_SBLKIE\r
 396   *            @arg SPDIFRX_IT_SYNCDIE\r
 397   *            @arg SPDIFRX_IT_IFEIE\r
 398   * @retval The new state of __IT__ (TRUE or FALSE).\r
 399   */\r
 400 #define __HAL_SPDIFRX_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->IMR & (__INTERRUPT__)) == (__INTERRUPT__)) ? SET : RESET)\r
 401 \r
 402 /** @brief  Checks whether the specified SPDIFRX flag is set or not.\r
 403   * @param  __HANDLE__: specifies the SPDIFRX Handle.\r
 404   * @param  __FLAG__: specifies the flag to check.\r
 405   *        This parameter can be one of the following values:\r
 406   *            @arg SPDIFRX_FLAG_RXNE\r
 407   *            @arg SPDIFRX_FLAG_CSRNE\r
 408   *            @arg SPDIFRX_FLAG_PERR\r
 409   *            @arg SPDIFRX_FLAG_OVR\r
 410   *            @arg SPDIFRX_FLAG_SBD\r
 411   *            @arg SPDIFRX_FLAG_SYNCD \r
 412   *            @arg SPDIFRX_FLAG_FERR \r
 413   *            @arg SPDIFRX_FLAG_SERR \r
 414   *            @arg SPDIFRX_FLAG_TERR \r
 415   * @retval The new state of __FLAG__ (TRUE or FALSE).\r
 416   */\r
 417 #define __HAL_SPDIFRX_GET_FLAG(__HANDLE__, __FLAG__) ((((__HANDLE__)->Instance->SR) & (__FLAG__)) == (__FLAG__))\r
 418 \r
 419 /** @brief  Clears the specified SPDIFRX SR flag, in setting the proper IFCR register bit.\r
 420   * @param  __HANDLE__: specifies the USART Handle.\r
 421   * @param  __IT_CLEAR__: specifies the interrupt clear register flag that needs to be set\r
 422   *                       to clear the corresponding interrupt\r
 423   *          This parameter can be one of the following values:\r
 424   *            @arg SPDIFRX_FLAG_PERR\r
 425   *            @arg SPDIFRX_FLAG_OVR\r
 426   *            @arg SPDIFRX_SR_SBD\r
 427   *            @arg SPDIFRX_SR_SYNCD\r
 428   * @retval None\r
 429   */\r
 430 #define __HAL_SPDIFRX_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->IFCR = (uint32_t)(__IT_CLEAR__)) \r
 431   \r
 432 /**\r
 433   * @}\r
 434   */\r
 435   \r
 436 /* Exported functions --------------------------------------------------------*/\r
 437 /** @addtogroup SPDIFRX_Exported_Functions\r
 438   * @{\r
 439   */\r
 440                                                 \r
 441 /** @addtogroup SPDIFRX_Exported_Functions_Group1\r
 442   * @{\r
 443   */\r
 444 /* Initialization/de-initialization functions  **********************************/\r
 445 HAL_StatusTypeDef HAL_SPDIFRX_Init(SPDIFRX_HandleTypeDef *hspdif);\r
 446 HAL_StatusTypeDef HAL_SPDIFRX_DeInit (SPDIFRX_HandleTypeDef *hspdif);\r
 447 void HAL_SPDIFRX_MspInit(SPDIFRX_HandleTypeDef *hspdif);\r
 448 void HAL_SPDIFRX_MspDeInit(SPDIFRX_HandleTypeDef *hspdif);\r
 449 HAL_StatusTypeDef HAL_SPDIFRX_SetDataFormat(SPDIFRX_HandleTypeDef *hspdif, SPDIFRX_SetDataFormatTypeDef  sDataFormat);\r
 450 /**\r
 451   * @}\r
 452   */\r
 453 \r
 454 /** @addtogroup SPDIFRX_Exported_Functions_Group2\r
 455   * @{\r
 456   */\r
 457 /* I/O operation functions  ***************************************************/\r
 458  /* Blocking mode: Polling */\r
 459 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveDataFlow(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size, uint32_t Timeout);\r
 460 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveControlFlow(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size, uint32_t Timeout);\r
 461 \r
 462  /* Non-Blocking mode: Interrupt */\r
 463 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveControlFlow_IT(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size);\r
 464 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveDataFlow_IT(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size);\r
 465 void HAL_SPDIFRX_IRQHandler(SPDIFRX_HandleTypeDef *hspdif);\r
 466 \r
 467 /* Non-Blocking mode: DMA */\r
 468 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveControlFlow_DMA(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size);\r
 469 HAL_StatusTypeDef HAL_SPDIFRX_ReceiveDataFlow_DMA(SPDIFRX_HandleTypeDef *hspdif, uint32_t *pData, uint16_t Size);\r
 470 \r
 471 HAL_StatusTypeDef HAL_SPDIFRX_DMAStop(SPDIFRX_HandleTypeDef *hspdif);\r
 472 \r
 473 /* Callbacks used in non blocking modes (Interrupt and DMA) *******************/\r
 474 void HAL_SPDIFRX_RxHalfCpltCallback(SPDIFRX_HandleTypeDef *hspdif);\r
 475 void HAL_SPDIFRX_RxCpltCallback(SPDIFRX_HandleTypeDef *hspdif);\r
 476 void HAL_SPDIFRX_ErrorCallback(SPDIFRX_HandleTypeDef *hspdif);\r
 477 void HAL_SPDIFRX_CxHalfCpltCallback(SPDIFRX_HandleTypeDef *hspdif);\r
 478 void HAL_SPDIFRX_CxCpltCallback(SPDIFRX_HandleTypeDef *hspdif);\r
 479 /**\r
 480   * @}\r
 481   */\r
 482 \r
 483 /** @addtogroup SPDIFRX_Exported_Functions_Group3\r
 484   * @{\r
 485   */\r
 486 /* Peripheral Control and State functions  ************************************/\r
 487 HAL_SPDIFRX_StateTypeDef HAL_SPDIFRX_GetState(SPDIFRX_HandleTypeDef *hspdif);\r
 488 uint32_t HAL_SPDIFRX_GetError(SPDIFRX_HandleTypeDef *hspdif);\r
 489 /**\r
 490   * @}\r
 491   */\r
 492 \r
 493 /**\r
 494   * @}\r
 495   */ \r
 496 /* Private types -------------------------------------------------------------*/\r
 497 /* Private variables ---------------------------------------------------------*/\r
 498 /* Private constants ---------------------------------------------------------*/\r
 499 /* Private macros ------------------------------------------------------------*/\r
 500 /** @defgroup SPDIFRX_Private_Macros SPDIFRX Private Macros\r
 501   * @{\r
 502   */\r
 503 #define IS_SPDIFRX_INPUT_SELECT(INPUT)  (((INPUT) == SPDIFRX_INPUT_IN1) || \\r
 504                                          ((INPUT) == SPDIFRX_INPUT_IN2) || \\r
 505                                          ((INPUT) == SPDIFRX_INPUT_IN3)  || \\r
 506                                          ((INPUT) == SPDIFRX_INPUT_IN0))\r
 507 #define IS_SPDIFRX_MAX_RETRIES(RET)   (((RET) == SPDIFRX_MAXRETRIES_NONE) || \\r
 508                                       ((RET) == SPDIFRX_MAXRETRIES_3)  || \\r
 509                                       ((RET) == SPDIFRX_MAXRETRIES_15) || \\r
 510                                       ((RET) == SPDIFRX_MAXRETRIES_63))\r
 511 #define IS_SPDIFRX_WAIT_FOR_ACTIVITY(VAL)    (((VAL) == SPDIFRX_WAITFORACTIVITY_ON) || \\r
 512                                                ((VAL) == SPDIFRX_WAITFORACTIVITY_OFF))\r
 513 #define IS_PREAMBLE_TYPE_MASK(VAL)           (((VAL) == SPDIFRX_PREAMBLETYPEMASK_ON) || \\r
 514                                              ((VAL) == SPDIFRX_PREAMBLETYPEMASK_OFF))\r
 515 #define IS_VALIDITY_MASK(VAL)               (((VAL) == SPDIFRX_VALIDITYMASK_OFF) || \\r
 516                                              ((VAL) == SPDIFRX_VALIDITYMASK_ON))\r
 517 #define IS_PARITY_ERROR_MASK(VAL)            (((VAL) == SPDIFRX_PARITYERRORMASK_OFF) || \\r
 518                                              ((VAL) == SPDIFRX_PARITYERRORMASK_ON))\r
 519 #define IS_SPDIFRX_CHANNEL(CHANNEL)   (((CHANNEL) == SPDIFRX_CHANNEL_A) || \\r
 520                                        ((CHANNEL) == SPDIFRX_CHANNEL_B))\r
 521 #define IS_SPDIFRX_DATA_FORMAT(FORMAT)           (((FORMAT) == SPDIFRX_DATAFORMAT_LSB) || \\r
 522                                                  ((FORMAT) == SPDIFRX_DATAFORMAT_MSB) || \\r
 523                                                  ((FORMAT) == SPDIFRX_DATAFORMAT_32BITS))\r
 524 #define IS_STEREO_MODE(MODE)                 (((MODE) == SPDIFRX_STEREOMODE_DISABLE) || \\r
 525                                              ((MODE) == SPDIFRX_STEREOMODE_ENABLE))\r
 526                                              \r
 527 #define IS_CHANNEL_STATUS_MASK(VAL)          (((VAL) == SPDIFRX_CHANNELSTATUS_ON) || \\r
 528                                               ((VAL) == SPDIFRX_CHANNELSTATUS_OFF))\r
 529 /**                                                                                    \r
 530   * @}\r
 531   */\r
 532 \r
 533 /* Private functions ---------------------------------------------------------*/\r
 534 /** @defgroup SPDIFRX_Private_Functions SPDIFRX Private Functions\r
 535   * @{\r
 536   */\r
 537 /**\r
 538   * @}\r
 539   */\r
 540  \r
 541 /**\r
 542   * @}\r
 543   */\r
 544 \r
 545 /**\r
 546   * @}\r
 547   */\r
 548     \r
 549 #ifdef __cplusplus\r
 550 }\r
 551 #endif\r
 552 \r
 553 \r
 554 #endif /* __STM32F7xx_HAL_SPDIFRX_H */\r
 555 \r
 556 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r