lib/main/STM32F3/Drivers/STM32F3xx_HAL_Driver/Src/stm32f3xx_hal_i2s.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f3xx_hal_i2s.c
   4   * @author  MCD Application Team
   5   * @brief   I2S HAL module driver.
   6   *          This file provides firmware functions to manage the following
   7   *          functionalities of the Integrated Interchip Sound (I2S) peripheral:
   8   *           + Initialization and de-initialization functions
   9   *           + IO operation functions
  10   *           + Peripheral State and Errors functions
  11   @verbatim
  12  ===============================================================================
  13                   ##### How to use this driver #####
  14  ===============================================================================
  15  [..]
  16     The I2S HAL driver can be used as follows:
  17
  18     (#) Declare a I2S_HandleTypeDef handle structure.
  19     (#) Initialize the I2S low level resources by implement the HAL_I2S_MspInit() API:
  20         (##) Enable the SPIx interface clock.
  21         (##) I2S pins configuration:
  22             (+++) Enable the clock for the I2S GPIOs.
  23             (+++) Configure these I2S pins as alternate function pull-up.
  24         (##) NVIC configuration if you need to use interrupt process (HAL_I2S_Transmit_IT()
  25              and HAL_I2S_Receive_IT() APIs).
  26             (+++) Configure the I2Sx interrupt priority.
  27             (+++) Enable the NVIC I2S IRQ handle.
  28         (##) DMA Configuration if you need to use DMA process (HAL_I2S_Transmit_DMA()
  29              and HAL_I2S_Receive_DMA() APIs:
  30             (+++) Declare a DMA handle structure for the Tx/Rx channel.
  31             (+++) Enable the DMAx interface clock.
  32             (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
  33             (+++) Configure the DMA Tx/Rx Channel.
  34             (+++) Associate the initilalized DMA handle to the I2S DMA Tx/Rx handle.
  35             (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the
  36                 DMA Tx/Rx Channel.
  37
  38    (#) Program the Mode, Standard, Data Format, MCLK Output, Audio frequency and Polarity
  39        using HAL_I2S_Init() function.
  40
  41    -@- The specific I2S interrupts (Transmission complete interrupt,
  42        RXNE interrupt and Error Interrupts) will be managed using the macros
  43        __HAL_I2S_ENABLE_IT() and __HAL_I2S_DISABLE_IT() inside the transmit and receive process.
  44    -@- Make sure that either:
  45        (+@) I2S clock is configured based on SYSCLK or
  46        (+@) External clock source is configured after setting correctly
  47             the define constant EXTERNAL_CLOCK_VALUE in the stm32f3xx_hal_conf.h file.
  48
  49    (#) Three mode of operations are available within this driver :
  50
  51    *** Polling mode IO operation ***
  52    =================================
  53    [..]
  54      (+) Send an amount of data in blocking mode using HAL_I2S_Transmit()
  55      (+) Receive an amount of data in blocking mode using HAL_I2S_Receive()
  56
  57    *** Interrupt mode IO operation ***
  58    ===================================
  59    [..]
  60      (+) Send an amount of data in non blocking mode using HAL_I2S_Transmit_IT()
  61      (+) At transmission end of half transfer HAL_I2S_TxHalfCpltCallback is executed and user can
  62          add his own code by customization of function pointer HAL_I2S_TxHalfCpltCallback
  63      (+) At transmission end of transfer HAL_I2S_TxCpltCallback is executed and user can
  64          add his own code by customization of function pointer HAL_I2S_TxCpltCallback
  65      (+) Receive an amount of data in non blocking mode using HAL_I2S_Receive_IT()
  66      (+) At reception end of half transfer HAL_I2S_RxHalfCpltCallback is executed and user can
  67          add his own code by customization of function pointer HAL_I2S_RxHalfCpltCallback
  68      (+) At reception end of transfer HAL_I2S_RxCpltCallback is executed and user can
  69          add his own code by customization of function pointer HAL_I2S_RxCpltCallback
  70      (+) In case of transfer Error, HAL_I2S_ErrorCallback() function is executed and user can
  71          add his own code by customization of function pointer HAL_I2S_ErrorCallback
  72
  73    *** DMA mode IO operation ***
  74    ==============================
  75    [..]
  76      (+) Send an amount of data in non blocking mode (DMA) using HAL_I2S_Transmit_DMA()
  77      (+) At transmission end of half transfer HAL_I2S_TxHalfCpltCallback is executed and user can
  78          add his own code by customization of function pointer HAL_I2S_TxHalfCpltCallback
  79      (+) At transmission end of transfer HAL_I2S_TxCpltCallback is executed and user can
  80          add his own code by customization of function pointer HAL_I2S_TxCpltCallback
  81      (+) Receive an amount of data in non blocking mode (DMA) using HAL_I2S_Receive_DMA()
  82      (+) At reception end of half transfer HAL_I2S_RxHalfCpltCallback is executed and user can
  83          add his own code by customization of function pointer HAL_I2S_RxHalfCpltCallback
  84      (+) At reception end of transfer HAL_I2S_RxCpltCallback is executed and user can
  85          add his own code by customization of function pointer HAL_I2S_RxCpltCallback
  86      (+) In case of transfer Error, HAL_I2S_ErrorCallback() function is executed and user can
  87          add his own code by customization of function pointer HAL_I2S_ErrorCallback
  88      (+) Pause the DMA Transfer using HAL_I2S_DMAPause()
  89      (+) Resume the DMA Transfer using HAL_I2S_DMAResume()
  90      (+) Stop the DMA Transfer using HAL_I2S_DMAStop()
  91
  92    *** I2S HAL driver macros list ***
  93    =============================================
  94    [..]
  95      Below the list of most used macros in I2S HAL driver.
  96
  97       (+) __HAL_I2S_ENABLE: Enable the specified SPI peripheral (in I2S mode)
  98       (+) __HAL_I2S_DISABLE: Disable the specified SPI peripheral (in I2S mode)
  99       (+) __HAL_I2S_ENABLE_IT : Enable the specified I2S interrupts
 100       (+) __HAL_I2S_DISABLE_IT : Disable the specified I2S interrupts
 101       (+) __HAL_I2S_GET_FLAG: Check whether the specified I2S flag is set or not
 102
 103     [..]
 104       (@) You can refer to the I2S HAL driver header file for more useful macros
 105
 106   @endverbatim
 107   ******************************************************************************
 108   * @attention
 109   *
 110   * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
 111   *
 112   * Redistribution and use in source and binary forms, with or without modification,
 113   * are permitted provided that the following conditions are met:
 114   *   1. Redistributions of source code must retain the above copyright notice,
 115   *      this list of conditions and the following disclaimer.
 116   *   2. Redistributions in binary form must reproduce the above copyright notice,
 117   *      this list of conditions and the following disclaimer in the documentation
 118   *      and/or other materials provided with the distribution.
 119   *   3. Neither the name of STMicroelectronics nor the names of its contributors
 120   *      may be used to endorse or promote products derived from this software
 121   *      without specific prior written permission.
 122   *
 123   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 124   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 125   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 126   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 127   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 128   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 129   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 130   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 131   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 132   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 133   *
 134   ******************************************************************************
 135   */
 136
 137 /* Includes ------------------------------------------------------------------*/
 138 #include "stm32f3xx_hal.h"
 139
 140 #ifdef HAL_I2S_MODULE_ENABLED
 141
 142 #if defined(STM32F302xE) || defined(STM32F303xE) || defined(STM32F398xx) || \
 143     defined(STM32F302xC) || defined(STM32F303xC) || defined(STM32F358xx) || \
 144     defined(STM32F301x8) || defined(STM32F302x8) || defined(STM32F318xx) || \
 145     defined(STM32F373xC) || defined(STM32F378xx)
 146
 147 /** @addtogroup STM32F3xx_HAL_Driver
 148   * @{
 149   */
 150
 151 /** @defgroup I2S I2S
 152   * @brief I2S HAL module driver
 153   * @{
 154   */
 155
 156 /* Private typedef -----------------------------------------------------------*/
 157 /* Private define ------------------------------------------------------------*/
 158 /* Private macro -------------------------------------------------------------*/
 159 /* Private variables ---------------------------------------------------------*/
 160 /* Private function prototypes -----------------------------------------------*/
 161 /** @defgroup I2S_Private_Functions I2S Private Functions
 162   * @{
 163   */
 164 static void               I2S_DMATxCplt(DMA_HandleTypeDef *hdma);
 165 static void               I2S_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
 166 static void               I2S_DMARxCplt(DMA_HandleTypeDef *hdma);
 167 static void               I2S_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
 168 static void               I2S_DMAError(DMA_HandleTypeDef *hdma);
 169 static void               I2S_Transmit_IT(I2S_HandleTypeDef *hi2s);
 170 static void               I2S_Receive_IT(I2S_HandleTypeDef *hi2s);
 171 static HAL_StatusTypeDef  I2S_WaitFlagStateUntilTimeout(I2S_HandleTypeDef *hi2s, uint32_t Flag, uint32_t State, uint32_t Timeout);
 172 /**
 173   * @}
 174   */
 175
 176 /* Exported functions ---------------------------------------------------------*/
 177
 178 /** @defgroup I2S_Exported_Functions I2S Exported Functions
 179   * @{
 180   */
 181
 182 /** @defgroup  I2S_Exported_Functions_Group1 Initialization and de-initialization functions
 183   *  @brief    Initialization and Configuration functions
 184   *
 185 @verbatim
 186  ===============================================================================
 187               ##### Initialization and de-initialization functions #####
 188  ===============================================================================
 189     [..]  This subsection provides a set of functions allowing to initialize and
 190           de-initialiaze the I2Sx peripheral in simplex mode:
 191
 192       (+) User must Implement HAL_I2S_MspInit() function in which he configures
 193           all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC ).
 194
 195       (+) Call the function HAL_I2S_Init() to configure the selected device with
 196           the selected configuration:
 197         (++) Mode
 198         (++) Standard
 199         (++) Data Format
 200         (++) MCLK Output
 201         (++) Audio frequency
 202         (++) Polarity
 203         (++) Full duplex mode
 204
 205       (+) Call the function HAL_I2S_DeInit() to restore the default configuration
 206           of the selected I2Sx periperal.
 207 @endverbatim
 208   * @{
 209   */
 210
 211 /**
 212   * @brief Initializes the I2S according to the specified parameters
 213   *         in the I2S_InitTypeDef and create the associated handle.
 214   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 215   *         the configuration information for I2S module
 216   * @retval HAL status
 217   */
 218 __weak HAL_StatusTypeDef HAL_I2S_Init(I2S_HandleTypeDef *hi2s)
 219 {
 220   /* Prevent unused argument(s) compilation warning */
 221   UNUSED(hi2s);
 222
 223   /* Note : This function is defined into this file for library reference.  */
 224   /*        Function content is located into file stm32f3xx_hal_i2s_ex.c to */
 225   /*        handle the possible I2S interfaces defined in STM32F3xx devices */
 226
 227   /* Return error status as not implemented here */
 228   return HAL_ERROR;
 229 }
 230
 231 /**
 232   * @brief DeInitializes the I2S peripheral
 233   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 234   *         the configuration information for I2S module
 235   * @retval HAL status
 236   */
 237 HAL_StatusTypeDef HAL_I2S_DeInit(I2S_HandleTypeDef *hi2s)
 238 {
 239   /* Check the I2S handle allocation */
 240   if(hi2s == NULL)
 241   {
 242     return HAL_ERROR;
 243   }
 244
 245   /* Check the parameters */
 246   assert_param(IS_I2S_ALL_INSTANCE(hi2s->Instance));
 247
 248   hi2s->State = HAL_I2S_STATE_BUSY;
 249
 250   /* DeInit the low level hardware: GPIO, CLOCK, NVIC... */
 251   HAL_I2S_MspDeInit(hi2s);
 252
 253   hi2s->ErrorCode = HAL_I2S_ERROR_NONE;
 254   hi2s->State = HAL_I2S_STATE_RESET;
 255
 256   /* Release Lock */
 257   __HAL_UNLOCK(hi2s);
 258
 259   return HAL_OK;
 260 }
 261
 262 /**
 263   * @brief I2S MSP Init
 264   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 265   *         the configuration information for I2S module
 266   * @retval None
 267   */
 268  __weak void HAL_I2S_MspInit(I2S_HandleTypeDef *hi2s)
 269 {
 270   /* Prevent unused argument(s) compilation warning */
 271   UNUSED(hi2s);
 272
 273   /* NOTE : This function Should not be modified, when the callback is needed,
 274             the HAL_I2S_MspInit could be implemented in the user file
 275    */
 276 }
 277
 278 /**
 279   * @brief I2S MSP DeInit
 280   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 281   *         the configuration information for I2S module
 282   * @retval None
 283   */
 284  __weak void HAL_I2S_MspDeInit(I2S_HandleTypeDef *hi2s)
 285 {
 286   /* Prevent unused argument(s) compilation warning */
 287   UNUSED(hi2s);
 288
 289   /* NOTE : This function Should not be modified, when the callback is needed,
 290             the HAL_I2S_MspDeInit could be implemented in the user file
 291    */
 292 }
 293
 294 /**
 295   * @}
 296   */
 297
 298 /** @defgroup I2S_Exported_Functions_Group2 IO operation functions
 299   *  @brief Data transfers functions
 300   *
 301 @verbatim
 302  ===============================================================================
 303                       ##### IO operation functions #####
 304  ===============================================================================
 305     [..]
 306     This subsection provides a set of functions allowing to manage the I2S data
 307     transfers.
 308
 309     (#) There are two modes of transfer:
 310        (++) Blocking mode : The communication is performed in the polling mode.
 311             The status of all data processing is returned by the same function
 312             after finishing transfer.
 313        (++) No-Blocking mode : The communication is performed using Interrupts
 314             or DMA. These functions return the status of the transfer startup.
 315             The end of the data processing will be indicated through the
 316             dedicated I2S IRQ when using Interrupt mode or the DMA IRQ when
 317             using DMA mode.
 318
 319     (#) Blocking mode functions are :
 320         (++) HAL_I2S_Transmit()
 321         (++) HAL_I2S_Receive()
 322
 323     (#) No-Blocking mode functions with Interrupt are :
 324         (++) HAL_I2S_Transmit_IT()
 325         (++) HAL_I2S_Receive_IT()
 326
 327     (#) No-Blocking mode functions with DMA are :
 328         (++) HAL_I2S_Transmit_DMA()
 329         (++) HAL_I2S_Receive_DMA()
 330
 331     (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
 332         (++) HAL_I2S_TxCpltCallback()
 333         (++) HAL_I2S_RxCpltCallback()
 334         (++) HAL_I2S_ErrorCallback()
 335
 336 @endverbatim
 337   * @{
 338   */
 339
 340 /**
 341   * @brief Transmit an amount of data in blocking mode
 342   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 343   *         the configuration information for I2S module
 344   * @param pData a 16-bit pointer to data buffer.
 345   * @param Size number of data sample to be sent:
 346   * @note When a 16-bit data frame or a 16-bit data frame extended is selected during the I2S
 347   *       configuration phase, the Size parameter means the number of 16-bit data length
 348   *       in the transaction and when a 24-bit data frame or a 32-bit data frame is selected
 349   *       the Size parameter means the number of 16-bit data length.
 350   * @param  Timeout Timeout duration
 351   * @note The I2S is kept enabled at the end of transaction to avoid the clock de-synchronization
 352   *       between Master and Slave(example: audio streaming).
 353   * @retval HAL status
 354   */
 355 HAL_StatusTypeDef HAL_I2S_Transmit(I2S_HandleTypeDef *hi2s, uint16_t *pData, uint16_t Size, uint32_t Timeout)
 356 {
 357   if((pData == NULL ) || (Size == 0U))
 358   {
 359     return  HAL_ERROR;
 360   }
 361
 362   if(hi2s->State == HAL_I2S_STATE_READY)
 363   {
 364     if(((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_24B)||\
 365        ((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_32B))
 366     {
 367       hi2s->TxXferSize = (Size << 1U);
 368       hi2s->TxXferCount = (Size << 1U);
 369     }
 370     else
 371     {
 372       hi2s->TxXferSize = Size;
 373       hi2s->TxXferCount = Size;
 374     }
 375
 376     /* Process Locked */
 377     __HAL_LOCK(hi2s);
 378
 379     hi2s->ErrorCode = HAL_I2S_ERROR_NONE;
 380     hi2s->State = HAL_I2S_STATE_BUSY_TX;
 381
 382     /* Check if the I2S is already enabled */
 383     if((hi2s->Instance->I2SCFGR &SPI_I2SCFGR_I2SE) != SPI_I2SCFGR_I2SE)
 384     {
 385       /* Enable I2S peripheral */
 386       __HAL_I2S_ENABLE(hi2s);
 387     }
 388
 389     while(hi2s->TxXferCount > 0U)
 390     {
 391       hi2s->Instance->DR = (*pData++);
 392       hi2s->TxXferCount--;
 393       /* Wait until TXE flag is set */
 394       if (I2S_WaitFlagStateUntilTimeout(hi2s, I2S_FLAG_TXE, RESET, Timeout) != HAL_OK)
 395       {
 396         /* Set the error code and execute error callback*/
 397         hi2s->ErrorCode |= HAL_I2S_ERROR_TIMEOUT;
 398         HAL_I2S_ErrorCallback(hi2s);
 399         return HAL_TIMEOUT;
 400       }
 401
 402       /* Check if an underrun occurs */
 403       if(__HAL_I2S_GET_FLAG(hi2s, I2S_FLAG_UDR) == SET)
 404       {
 405         /* Set the I2S State ready */
 406         hi2s->State = HAL_I2S_STATE_READY;
 407
 408         /* Process Unlocked */
 409         __HAL_UNLOCK(hi2s);
 410
 411         /* Set the error code and execute error callback*/
 412         hi2s->ErrorCode |= HAL_I2S_ERROR_UDR;
 413         HAL_I2S_ErrorCallback(hi2s);
 414
 415         return HAL_ERROR;
 416       }
 417     }
 418     hi2s->State = HAL_I2S_STATE_READY;
 419
 420     /* Process Unlocked */
 421     __HAL_UNLOCK(hi2s);
 422
 423     return HAL_OK;
 424   }
 425   else
 426   {
 427     return HAL_BUSY;
 428   }
 429 }
 430
 431 /**
 432   * @brief Receive an amount of data in blocking mode
 433   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 434   *         the configuration information for I2S module
 435   * @param pData a 16-bit pointer to data buffer.
 436   * @param Size number of data sample to be sent:
 437   * @note When a 16-bit data frame or a 16-bit data frame extended is selected during the I2S
 438   *       configuration phase, the Size parameter means the number of 16-bit data length
 439   *       in the transaction and when a 24-bit data frame or a 32-bit data frame is selected
 440   *       the Size parameter means the number of 16-bit data length.
 441   * @param Timeout Timeout duration
 442   * @note The I2S is kept enabled at the end of transaction to avoid the clock de-synchronization
 443   *       between Master and Slave(example: audio streaming).
 444   * @note In I2S Master Receiver mode, just after enabling the peripheral the clock will be generate
 445   *       in continouse way and as the I2S is not disabled at the end of the I2S transaction.
 446   * @retval HAL status
 447   */
 448 HAL_StatusTypeDef HAL_I2S_Receive(I2S_HandleTypeDef *hi2s, uint16_t *pData, uint16_t Size, uint32_t Timeout)
 449 {
 450   if((pData == NULL ) || (Size == 0U))
 451   {
 452     return  HAL_ERROR;
 453   }
 454
 455   if(hi2s->State == HAL_I2S_STATE_READY)
 456   {
 457     if(((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_24B)||\
 458        ((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_32B))
 459     {
 460       hi2s->RxXferSize = (Size << 1U);
 461       hi2s->RxXferCount = (Size << 1U);
 462     }
 463     else
 464     {
 465       hi2s->RxXferSize = Size;
 466       hi2s->RxXferCount = Size;
 467     }
 468     /* Process Locked */
 469     __HAL_LOCK(hi2s);
 470
 471     hi2s->ErrorCode = HAL_I2S_ERROR_NONE;
 472     hi2s->State = HAL_I2S_STATE_BUSY_RX;
 473
 474     /* Check if the I2S is already enabled */
 475     if((hi2s->Instance->I2SCFGR & SPI_I2SCFGR_I2SE) != SPI_I2SCFGR_I2SE)
 476     {
 477       /* Enable I2S peripheral */
 478       __HAL_I2S_ENABLE(hi2s);
 479     }
 480
 481     /* Check if Master Receiver mode is selected */
 482     if((hi2s->Instance->I2SCFGR & SPI_I2SCFGR_I2SCFG) == I2S_MODE_MASTER_RX)
 483     {
 484       /* Clear the Overrun Flag by a read operation on the SPI_DR register followed by a read
 485       access to the SPI_SR register. */
 486       __HAL_I2S_CLEAR_OVRFLAG(hi2s);
 487     }
 488
 489     /* Receive data */
 490     while(hi2s->RxXferCount > 0U)
 491     {
 492       /* Wait until RXNE flag is set */
 493       if (I2S_WaitFlagStateUntilTimeout(hi2s, I2S_FLAG_RXNE, RESET, Timeout) != HAL_OK)
 494       {
 495         /* Set the error code and execute error callback*/
 496         hi2s->ErrorCode |= HAL_I2S_ERROR_TIMEOUT;
 497         HAL_I2S_ErrorCallback(hi2s);
 498         return HAL_TIMEOUT;
 499       }
 500
 501       /* Check if an overrun occurs */
 502       if(__HAL_I2S_GET_FLAG(hi2s, I2S_FLAG_OVR) == SET)
 503       {
 504         /* Set the I2S State ready */
 505         hi2s->State = HAL_I2S_STATE_READY;
 506
 507         /* Process Unlocked */
 508         __HAL_UNLOCK(hi2s);
 509
 510         /* Set the error code and execute error callback*/
 511         hi2s->ErrorCode |= HAL_I2S_ERROR_OVR;
 512         HAL_I2S_ErrorCallback(hi2s);
 513
 514         return HAL_ERROR;
 515       }
 516
 517       (*pData++) = hi2s->Instance->DR;
 518       hi2s->RxXferCount--;
 519     }
 520
 521     hi2s->State = HAL_I2S_STATE_READY;
 522
 523     /* Process Unlocked */
 524     __HAL_UNLOCK(hi2s);
 525
 526     return HAL_OK;
 527   }
 528   else
 529   {
 530     return HAL_BUSY;
 531   }
 532 }
 533
 534 /**
 535   * @brief Transmit an amount of data in non-blocking mode with Interrupt
 536   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 537   *         the configuration information for I2S module
 538   * @param pData a 16-bit pointer to data buffer.
 539   * @param Size number of data sample to be sent:
 540   * @note When a 16-bit data frame or a 16-bit data frame extended is selected during the I2S
 541   *       configuration phase, the Size parameter means the number of 16-bit data length
 542   *       in the transaction and when a 24-bit data frame or a 32-bit data frame is selected
 543   *       the Size parameter means the number of 16-bit data length.
 544   * @note The I2S is kept enabled at the end of transaction to avoid the clock de-synchronization
 545   *       between Master and Slave(example: audio streaming).
 546   * @retval HAL status
 547   */
 548 HAL_StatusTypeDef HAL_I2S_Transmit_IT(I2S_HandleTypeDef *hi2s, uint16_t *pData, uint16_t Size)
 549 {
 550   if(hi2s->State == HAL_I2S_STATE_READY)
 551   {
 552     if((pData == NULL) || (Size == 0U))
 553     {
 554       return  HAL_ERROR;
 555     }
 556
 557     hi2s->pTxBuffPtr = pData;
 558     if(((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_24B)||\
 559       ((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_32B))
 560     {
 561       hi2s->TxXferSize = (Size << 1U);
 562       hi2s->TxXferCount = (Size << 1U);
 563     }
 564     else
 565     {
 566       hi2s->TxXferSize = Size;
 567       hi2s->TxXferCount = Size;
 568     }
 569
 570     /* Process Locked */
 571     __HAL_LOCK(hi2s);
 572
 573     hi2s->ErrorCode = HAL_I2S_ERROR_NONE;
 574     hi2s->State = HAL_I2S_STATE_BUSY_TX;
 575
 576     /* Enable TXE and ERR interrupt */
 577     __HAL_I2S_ENABLE_IT(hi2s, (I2S_IT_TXE | I2S_IT_ERR));
 578
 579     /* Check if the I2S is already enabled */
 580     if((hi2s->Instance->I2SCFGR &SPI_I2SCFGR_I2SE) != SPI_I2SCFGR_I2SE)
 581     {
 582       /* Enable I2S peripheral */
 583       __HAL_I2S_ENABLE(hi2s);
 584     }
 585
 586     /* Process Unlocked */
 587     __HAL_UNLOCK(hi2s);
 588
 589     return HAL_OK;
 590   }
 591   else
 592   {
 593     return HAL_BUSY;
 594   }
 595 }
 596
 597 /**
 598   * @brief Receive an amount of data in non-blocking mode with Interrupt
 599   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 600   *         the configuration information for I2S module
 601   * @param pData a 16-bit pointer to the Receive data buffer.
 602   * @param Size number of data sample to be sent:
 603   * @note When a 16-bit data frame or a 16-bit data frame extended is selected during the I2S
 604   *       configuration phase, the Size parameter means the number of 16-bit data length
 605   *       in the transaction and when a 24-bit data frame or a 32-bit data frame is selected
 606   *       the Size parameter means the number of 16-bit data length.
 607   * @note The I2S is kept enabled at the end of transaction to avoid the clock de-synchronization
 608   *       between Master and Slave(example: audio streaming).
 609   * @note It is recommended to use DMA for the I2S receiver to avoid de-synchronisation
 610   * between Master and Slave otherwise the I2S interrupt should be optimized.
 611   * @retval HAL status
 612   */
 613 HAL_StatusTypeDef HAL_I2S_Receive_IT(I2S_HandleTypeDef *hi2s, uint16_t *pData, uint16_t Size)
 614 {
 615   if(hi2s->State == HAL_I2S_STATE_READY)
 616   {
 617     if((pData == NULL) || (Size == 0U))
 618     {
 619       return  HAL_ERROR;
 620     }
 621
 622     hi2s->pRxBuffPtr = pData;
 623     if(((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_24B)||\
 624       ((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_32B))
 625     {
 626       hi2s->RxXferSize = (Size << 1U);
 627       hi2s->RxXferCount = (Size << 1U);
 628     }
 629     else
 630     {
 631       hi2s->RxXferSize = Size;
 632       hi2s->RxXferCount = Size;
 633     }
 634     /* Process Locked */
 635     __HAL_LOCK(hi2s);
 636
 637     hi2s->ErrorCode = HAL_I2S_ERROR_NONE;
 638     hi2s->State = HAL_I2S_STATE_BUSY_RX;
 639
 640     /* Enable TXE and ERR interrupt */
 641     __HAL_I2S_ENABLE_IT(hi2s, (I2S_IT_RXNE | I2S_IT_ERR));
 642
 643     /* Check if the I2S is already enabled */
 644     if((hi2s->Instance->I2SCFGR &SPI_I2SCFGR_I2SE) != SPI_I2SCFGR_I2SE)
 645     {
 646       /* Enable I2S peripheral */
 647       __HAL_I2S_ENABLE(hi2s);
 648     }
 649
 650     /* Process Unlocked */
 651     __HAL_UNLOCK(hi2s);
 652
 653     return HAL_OK;
 654   }
 655   else
 656   {
 657     return HAL_BUSY;
 658   }
 659 }
 660
 661 /**
 662   * @brief Transmit an amount of data in non-blocking mode with DMA
 663   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 664   *         the configuration information for I2S module
 665   * @param pData a 16-bit pointer to the Transmit data buffer.
 666   * @param Size number of data sample to be sent:
 667   * @note When a 16-bit data frame or a 16-bit data frame extended is selected during the I2S
 668   *       configuration phase, the Size parameter means the number of 16-bit data length
 669   *       in the transaction and when a 24-bit data frame or a 32-bit data frame is selected
 670   *       the Size parameter means the number of 16-bit data length.
 671   * @note The I2S is kept enabled at the end of transaction to avoid the clock de-synchronization
 672   *       between Master and Slave(example: audio streaming).
 673   * @retval HAL status
 674   */
 675 HAL_StatusTypeDef HAL_I2S_Transmit_DMA(I2S_HandleTypeDef *hi2s, uint16_t *pData, uint16_t Size)
 676 {
 677   uint32_t *tmp;
 678
 679   if((pData == NULL) || (Size == 0U))
 680   {
 681     return  HAL_ERROR;
 682   }
 683
 684   if(hi2s->State == HAL_I2S_STATE_READY)
 685   {
 686     hi2s->pTxBuffPtr = pData;
 687     if(((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_24B)||\
 688       ((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_32B))
 689     {
 690       hi2s->TxXferSize = (Size << 1U);
 691       hi2s->TxXferCount = (Size << 1U);
 692     }
 693     else
 694     {
 695       hi2s->TxXferSize = Size;
 696       hi2s->TxXferCount = Size;
 697     }
 698
 699     /* Process Locked */
 700     __HAL_LOCK(hi2s);
 701
 702     hi2s->ErrorCode = HAL_I2S_ERROR_NONE;
 703     hi2s->State = HAL_I2S_STATE_BUSY_TX;
 704
 705     /* Set the I2S Tx DMA Half transfer complete callback */
 706     hi2s->hdmatx->XferHalfCpltCallback = I2S_DMATxHalfCplt;
 707
 708     /* Set the I2S Tx DMA transfer complete callback */
 709     hi2s->hdmatx->XferCpltCallback = I2S_DMATxCplt;
 710
 711     /* Set the DMA error callback */
 712     hi2s->hdmatx->XferErrorCallback = I2S_DMAError;
 713
 714     /* Enable the Tx DMA Channel */
 715     tmp = (uint32_t*)&pData;
 716     HAL_DMA_Start_IT(hi2s->hdmatx, *(uint32_t*)tmp, (uint32_t)&hi2s->Instance->DR, hi2s->TxXferSize);
 717
 718     /* Check if the I2S is already enabled */
 719     if((hi2s->Instance->I2SCFGR &SPI_I2SCFGR_I2SE) != SPI_I2SCFGR_I2SE)
 720     {
 721       /* Enable I2S peripheral */
 722       __HAL_I2S_ENABLE(hi2s);
 723     }
 724
 725     /* Enable Tx DMA Request */
 726     hi2s->Instance->CR2 |= SPI_CR2_TXDMAEN;
 727
 728     /* Process Unlocked */
 729     __HAL_UNLOCK(hi2s);
 730
 731     return HAL_OK;
 732   }
 733   else
 734   {
 735     return HAL_BUSY;
 736   }
 737 }
 738
 739 /**
 740   * @brief Receive an amount of data in non-blocking mode with DMA
 741   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 742   *         the configuration information for I2S module
 743   * @param pData a 16-bit pointer to the Receive data buffer.
 744   * @param Size number of data sample to be sent:
 745   * @note When a 16-bit data frame or a 16-bit data frame extended is selected during the I2S
 746   *       configuration phase, the Size parameter means the number of 16-bit data length
 747   *       in the transaction and when a 24-bit data frame or a 32-bit data frame is selected
 748   *       the Size parameter means the number of 16-bit data length.
 749   * @note The I2S is kept enabled at the end of transaction to avoid the clock de-synchronization
 750   *       between Master and Slave(example: audio streaming).
 751   * @retval HAL status
 752   */
 753 HAL_StatusTypeDef HAL_I2S_Receive_DMA(I2S_HandleTypeDef *hi2s, uint16_t *pData, uint16_t Size)
 754 {
 755   uint32_t *tmp;
 756
 757   if((pData == NULL) || (Size == 0U))
 758   {
 759     return  HAL_ERROR;
 760   }
 761
 762   if(hi2s->State == HAL_I2S_STATE_READY)
 763   {
 764     hi2s->pRxBuffPtr = pData;
 765     if(((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_24B)||\
 766       ((hi2s->Instance->I2SCFGR & (SPI_I2SCFGR_DATLEN | SPI_I2SCFGR_CHLEN)) == I2S_DATAFORMAT_32B))
 767     {
 768       hi2s->RxXferSize = (Size << 1U);
 769       hi2s->RxXferCount = (Size << 1U);
 770     }
 771     else
 772     {
 773       hi2s->RxXferSize = Size;
 774       hi2s->RxXferCount = Size;
 775     }
 776     /* Process Locked */
 777     __HAL_LOCK(hi2s);
 778
 779     hi2s->ErrorCode = HAL_I2S_ERROR_NONE;
 780     hi2s->State = HAL_I2S_STATE_BUSY_RX;
 781
 782     /* Set the I2S Rx DMA Half transfer complete callback */
 783     hi2s->hdmarx->XferHalfCpltCallback = I2S_DMARxHalfCplt;
 784
 785     /* Set the I2S Rx DMA transfer complete callback */
 786     hi2s->hdmarx->XferCpltCallback = I2S_DMARxCplt;
 787
 788     /* Set the DMA error callback */
 789     hi2s->hdmarx->XferErrorCallback = I2S_DMAError;
 790
 791     /* Check if Master Receiver mode is selected */
 792     if((hi2s->Instance->I2SCFGR & SPI_I2SCFGR_I2SCFG) == I2S_MODE_MASTER_RX)
 793     {
 794       /* Clear the Overrun Flag by a read operation to the SPI_DR register followed by a read
 795       access to the SPI_SR register. */
 796       __HAL_I2S_CLEAR_OVRFLAG(hi2s);
 797     }
 798
 799     /* Enable the Rx DMA Channel */
 800     tmp = (uint32_t*)&pData;
 801     HAL_DMA_Start_IT(hi2s->hdmarx, (uint32_t)&hi2s->Instance->DR, *(uint32_t*)tmp, hi2s->RxXferSize);
 802
 803     /* Check if the I2S is already enabled */
 804     if((hi2s->Instance->I2SCFGR &SPI_I2SCFGR_I2SE) != SPI_I2SCFGR_I2SE)
 805     {
 806       /* Enable I2S peripheral */
 807       __HAL_I2S_ENABLE(hi2s);
 808     }
 809
 810     /* Enable Rx DMA Request */
 811     hi2s->Instance->CR2 |= SPI_CR2_RXDMAEN;
 812
 813     /* Process Unlocked */
 814     __HAL_UNLOCK(hi2s);
 815
 816     return HAL_OK;
 817   }
 818   else
 819   {
 820     return HAL_BUSY;
 821   }
 822 }
 823
 824 /**
 825   * @brief Pauses the audio stream playing from the Media.
 826   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 827   *         the configuration information for I2S module
 828   * @retval HAL status
 829   */
 830 __weak HAL_StatusTypeDef HAL_I2S_DMAPause(I2S_HandleTypeDef *hi2s)
 831 {
 832   /* Process Locked */
 833   __HAL_LOCK(hi2s);
 834
 835   if(hi2s->State == HAL_I2S_STATE_BUSY_TX)
 836   {
 837     /* Disable the I2S DMA Tx request */
 838     hi2s->Instance->CR2 &= (uint32_t)(~SPI_CR2_TXDMAEN);
 839   }
 840   else if(hi2s->State == HAL_I2S_STATE_BUSY_RX)
 841   {
 842     /* Disable the I2S DMA Rx request */
 843     hi2s->Instance->CR2 &= (uint32_t)(~SPI_CR2_RXDMAEN);
 844   }
 845
 846   /* Process Unlocked */
 847   __HAL_UNLOCK(hi2s);
 848
 849   return HAL_OK;
 850 }
 851
 852 /**
 853   * @brief Resumes the audio stream playing from the Media.
 854   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 855   *         the configuration information for I2S module
 856   * @retval HAL status
 857   */
 858 __weak HAL_StatusTypeDef HAL_I2S_DMAResume(I2S_HandleTypeDef *hi2s)
 859 {
 860   /* Process Locked */
 861   __HAL_LOCK(hi2s);
 862
 863   if(hi2s->State == HAL_I2S_STATE_BUSY_TX)
 864   {
 865     /* Enable the I2S DMA Tx request */
 866     hi2s->Instance->CR2 |= SPI_CR2_TXDMAEN;
 867   }
 868   else if(hi2s->State == HAL_I2S_STATE_BUSY_RX)
 869   {
 870     /* Enable the I2S DMA Rx request */
 871     hi2s->Instance->CR2 |= SPI_CR2_RXDMAEN;
 872   }
 873
 874   /* If the I2S peripheral is still not enabled, enable it */
 875   if ((hi2s->Instance->I2SCFGR & SPI_I2SCFGR_I2SE) == 0U)
 876   {
 877     /* Enable I2S peripheral */
 878     __HAL_I2S_ENABLE(hi2s);
 879   }
 880
 881   /* Process Unlocked */
 882   __HAL_UNLOCK(hi2s);
 883
 884   return HAL_OK;
 885 }
 886
 887 /**
 888   * @brief Resumes the audio stream playing from the Media.
 889   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 890   *         the configuration information for I2S module
 891   * @retval HAL status
 892   */
 893 __weak HAL_StatusTypeDef HAL_I2S_DMAStop(I2S_HandleTypeDef *hi2s)
 894 {
 895   /* Process Locked */
 896   __HAL_LOCK(hi2s);
 897
 898   /* Disable the I2S Tx/Rx DMA requests */
 899   hi2s->Instance->CR2 &= (uint32_t)(~SPI_CR2_TXDMAEN);
 900   hi2s->Instance->CR2 &= (uint32_t)(~SPI_CR2_RXDMAEN);
 901
 902   /* Abort the I2S DMA tx channel */
 903   if(hi2s->hdmatx != NULL)
 904   {
 905     /* Disable the I2S DMA channel */
 906     __HAL_DMA_DISABLE(hi2s->hdmatx);
 907     HAL_DMA_Abort(hi2s->hdmatx);
 908   }
 909   /* Abort the I2S DMA rx channel */
 910   if(hi2s->hdmarx != NULL)
 911   {
 912     /* Disable the I2S DMA channel */
 913     __HAL_DMA_DISABLE(hi2s->hdmarx);
 914     HAL_DMA_Abort(hi2s->hdmarx);
 915   }
 916
 917   /* Disable I2S peripheral */
 918   __HAL_I2S_DISABLE(hi2s);
 919
 920   hi2s->State = HAL_I2S_STATE_READY;
 921
 922   /* Process Unlocked */
 923   __HAL_UNLOCK(hi2s);
 924
 925   return HAL_OK;
 926 }
 927
 928 /**
 929   * @brief  This function handles I2S interrupt request.
 930   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
 931   *         the configuration information for I2S module
 932   * @retval None
 933   */
 934 void HAL_I2S_IRQHandler(I2S_HandleTypeDef *hi2s)
 935 {
 936   __IO uint32_t i2ssr = hi2s->Instance->SR;
 937
 938   if(hi2s->State == HAL_I2S_STATE_BUSY_RX)
 939   {
 940     /* I2S in mode Receiver ----------------------------------------------------*/
 941     if(((i2ssr & I2S_FLAG_RXNE) == I2S_FLAG_RXNE) && (__HAL_I2S_GET_IT_SOURCE(hi2s, I2S_IT_RXNE) != RESET))
 942     {
 943       I2S_Receive_IT(hi2s);
 944     }
 945
 946     /* I2S Overrun error interrupt occured -------------------------------------*/
 947     if(((i2ssr & I2S_FLAG_OVR) == I2S_FLAG_OVR) && (__HAL_I2S_GET_IT_SOURCE(hi2s, I2S_IT_ERR) != RESET))
 948     {
 949       /* Disable RXNE and ERR interrupt */
 950       __HAL_I2S_DISABLE_IT(hi2s, (I2S_IT_RXNE | I2S_IT_ERR));
 951
 952       /* Set the I2S State ready */
 953       hi2s->State = HAL_I2S_STATE_READY;
 954
 955       /* Set the error code and execute error callback*/
 956       hi2s->ErrorCode |= HAL_I2S_ERROR_OVR;
 957       HAL_I2S_ErrorCallback(hi2s);
 958     }
 959   }
 960   else if(hi2s->State == HAL_I2S_STATE_BUSY_TX)
 961   {
 962     /* I2S in mode Tramitter ---------------------------------------------------*/
 963     if(((i2ssr & I2S_FLAG_TXE) == I2S_FLAG_TXE) && (__HAL_I2S_GET_IT_SOURCE(hi2s, I2S_IT_TXE) != RESET))
 964     {
 965       I2S_Transmit_IT(hi2s);
 966     }
 967
 968     /* I2S Underrun error interrupt occured ------------------------------------*/
 969     if(((i2ssr & I2S_FLAG_UDR) == I2S_FLAG_UDR) && (__HAL_I2S_GET_IT_SOURCE(hi2s, I2S_IT_ERR) != RESET))
 970     {
 971       /* Disable TXE and ERR interrupt */
 972       __HAL_I2S_DISABLE_IT(hi2s, (I2S_IT_TXE | I2S_IT_ERR));
 973
 974       /* Set the I2S State ready */
 975       hi2s->State = HAL_I2S_STATE_READY;
 976
 977       /* Set the error code and execute error callback*/
 978       hi2s->ErrorCode |= HAL_I2S_ERROR_UDR;
 979       HAL_I2S_ErrorCallback(hi2s);
 980     }
 981   }
 982 }
 983
 984 /**
 985   * @}
 986   */
 987
 988 /**
 989   * @}
 990   */
 991
 992
 993
 994 /** @addtogroup I2S_Exported_Functions I2S Exported Functions
 995   * @{
 996   */
 997
 998 /** @addtogroup  I2S_Exported_Functions_Group2 IO operation functions
 999   * @{
1000   */
1001 /**
1002   * @brief Tx Transfer Half completed callbacks
1003   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1004   *         the configuration information for I2S module
1005   * @retval None
1006   */
1007  __weak void HAL_I2S_TxHalfCpltCallback(I2S_HandleTypeDef *hi2s)
1008 {
1009   /* Prevent unused argument(s) compilation warning */
1010   UNUSED(hi2s);
1011
1012   /* NOTE : This function Should not be modified, when the callback is needed,
1013             the HAL_I2S_TxHalfCpltCallback could be implemented in the user file
1014    */
1015 }
1016
1017 /**
1018   * @brief Tx Transfer completed callbacks
1019   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1020   *         the configuration information for I2S module
1021   * @retval None
1022   */
1023  __weak void HAL_I2S_TxCpltCallback(I2S_HandleTypeDef *hi2s)
1024 {
1025   /* Prevent unused argument(s) compilation warning */
1026   UNUSED(hi2s);
1027
1028   /* NOTE : This function Should not be modified, when the callback is needed,
1029             the HAL_I2S_TxCpltCallback could be implemented in the user file
1030    */
1031 }
1032
1033 /**
1034   * @brief Rx Transfer half completed callbacks
1035   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1036   *         the configuration information for I2S module
1037   * @retval None
1038   */
1039 __weak void HAL_I2S_RxHalfCpltCallback(I2S_HandleTypeDef *hi2s)
1040 {
1041   /* Prevent unused argument(s) compilation warning */
1042   UNUSED(hi2s);
1043
1044   /* NOTE : This function Should not be modified, when the callback is needed,
1045             the HAL_I2S_RxCpltCallback could be implemented in the user file
1046    */
1047 }
1048
1049 /**
1050   * @brief Rx Transfer completed callbacks
1051   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1052   *         the configuration information for I2S module
1053   * @retval None
1054   */
1055 __weak void HAL_I2S_RxCpltCallback(I2S_HandleTypeDef *hi2s)
1056 {
1057   /* Prevent unused argument(s) compilation warning */
1058   UNUSED(hi2s);
1059
1060   /* NOTE : This function Should not be modified, when the callback is needed,
1061             the HAL_I2S_RxCpltCallback could be implemented in the user file
1062    */
1063 }
1064
1065 /**
1066   * @brief I2S error callbacks
1067   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1068   *         the configuration information for I2S module
1069   * @retval None
1070   */
1071  __weak void HAL_I2S_ErrorCallback(I2S_HandleTypeDef *hi2s)
1072 {
1073   /* Prevent unused argument(s) compilation warning */
1074   UNUSED(hi2s);
1075
1076   /* NOTE : This function Should not be modified, when the callback is needed,
1077             the HAL_I2S_ErrorCallback could be implemented in the user file
1078    */
1079 }
1080
1081 /**
1082   * @}
1083   */
1084
1085 /** @defgroup I2S_Exported_Functions_Group3 Peripheral State and Errors functions
1086   *  @brief   Peripheral State functions
1087   *
1088 @verbatim
1089  ===============================================================================
1090                       ##### Peripheral State and Errors functions #####
1091  ===============================================================================
1092     [..]
1093     This subsection permits to get in run-time the status of the peripheral
1094     and the data flow.
1095
1096 @endverbatim
1097   * @{
1098   */
1099
1100 /**
1101   * @brief  Return the I2S state
1102   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1103   *         the configuration information for I2S module
1104   * @retval HAL state
1105   */
1106 HAL_I2S_StateTypeDef HAL_I2S_GetState(I2S_HandleTypeDef *hi2s)
1107 {
1108   return hi2s->State;
1109 }
1110
1111 /**
1112   * @brief  Return the I2S error code
1113   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1114   *         the configuration information for I2S module
1115   * @retval I2S Error Code
1116   */
1117 uint32_t HAL_I2S_GetError(I2S_HandleTypeDef *hi2s)
1118 {
1119   return hi2s->ErrorCode;
1120 }
1121 /**
1122   * @}
1123   */
1124
1125 /**
1126   * @}
1127   */
1128
1129 /** @addtogroup I2S_Private_Functions I2S Private Functions
1130   * @{
1131   */
1132 /**
1133   * @brief DMA I2S transmit process complete callback
1134   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
1135   *                the configuration information for the specified DMA module.
1136   * @retval None
1137   */
1138 static void I2S_DMATxCplt(DMA_HandleTypeDef *hdma)
1139 {
1140   I2S_HandleTypeDef* hi2s = ( I2S_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1141
1142   if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
1143   {
1144     /* Disable Tx DMA Request */
1145     hi2s->Instance->CR2 &= (uint32_t)(~SPI_CR2_TXDMAEN);
1146
1147     hi2s->TxXferCount = 0U;
1148     hi2s->State = HAL_I2S_STATE_READY;
1149   }
1150   HAL_I2S_TxCpltCallback(hi2s);
1151 }
1152
1153 /**
1154   * @brief DMA I2S transmit process half complete callback
1155   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
1156   *                the configuration information for the specified DMA module.
1157   * @retval None
1158   */
1159 static void I2S_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
1160 {
1161   I2S_HandleTypeDef* hi2s = (I2S_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
1162
1163   HAL_I2S_TxHalfCpltCallback(hi2s);
1164 }
1165
1166 /**
1167   * @brief DMA I2S receive process complete callback
1168   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
1169   *                the configuration information for the specified DMA module.
1170   * @retval None
1171   */
1172 static void I2S_DMARxCplt(DMA_HandleTypeDef *hdma)
1173 {
1174   I2S_HandleTypeDef* hi2s = ( I2S_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1175
1176   if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
1177   {
1178     /* Disable Rx DMA Request */
1179     hi2s->Instance->CR2 &= (uint32_t)(~SPI_CR2_RXDMAEN);
1180     hi2s->RxXferCount = 0U;
1181     hi2s->State = HAL_I2S_STATE_READY;
1182   }
1183   HAL_I2S_RxCpltCallback(hi2s);
1184 }
1185
1186 /**
1187   * @brief DMA I2S receive process half complete callback
1188   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
1189   *                the configuration information for the specified DMA module.
1190   * @retval None
1191   */
1192 static void I2S_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
1193 {
1194   I2S_HandleTypeDef* hi2s = (I2S_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
1195
1196   HAL_I2S_RxHalfCpltCallback(hi2s);
1197 }
1198
1199 /**
1200   * @brief DMA I2S communication error callback
1201   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
1202   *                the configuration information for the specified DMA module.
1203   * @retval None
1204   */
1205 static void I2S_DMAError(DMA_HandleTypeDef *hdma)
1206 {
1207   I2S_HandleTypeDef* hi2s = ( I2S_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1208
1209   /* Disable Rx and Tx DMA Request */
1210   hi2s->Instance->CR2 &= (uint32_t)(~(SPI_CR2_RXDMAEN | SPI_CR2_TXDMAEN));
1211   hi2s->TxXferCount = 0U;
1212   hi2s->RxXferCount = 0U;
1213
1214   hi2s->State= HAL_I2S_STATE_READY;
1215
1216   /* Set the error code and execute error callback*/
1217   hi2s->ErrorCode |= HAL_I2S_ERROR_DMA;
1218   HAL_I2S_ErrorCallback(hi2s);
1219 }
1220
1221 /**
1222   * @brief Transmit an amount of data in non-blocking mode with Interrupt
1223   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1224   *         the configuration information for I2S module
1225   * @retval None
1226   */
1227 static void I2S_Transmit_IT(I2S_HandleTypeDef *hi2s)
1228 {
1229   /* Transmit data */
1230   hi2s->Instance->DR = (*hi2s->pTxBuffPtr++);
1231   hi2s->TxXferCount--;
1232
1233   if(hi2s->TxXferCount == 0U)
1234   {
1235     /* Disable TXE and ERR interrupt */
1236     __HAL_I2S_DISABLE_IT(hi2s, (I2S_IT_TXE | I2S_IT_ERR));
1237
1238     hi2s->State = HAL_I2S_STATE_READY;
1239     HAL_I2S_TxCpltCallback(hi2s);
1240   }
1241 }
1242
1243 /**
1244   * @brief Receive an amount of data in non-blocking mode with Interrupt
1245   * @param hi2s: I2S handle
1246   * @retval None
1247   */
1248 static void I2S_Receive_IT(I2S_HandleTypeDef *hi2s)
1249 {
1250   /* Receive data */
1251   (*hi2s->pRxBuffPtr++) = hi2s->Instance->DR;
1252   hi2s->RxXferCount--;
1253
1254   if(hi2s->RxXferCount == 0U)
1255   {
1256     /* Disable RXNE and ERR interrupt */
1257     __HAL_I2S_DISABLE_IT(hi2s, (I2S_IT_RXNE | I2S_IT_ERR));
1258
1259     hi2s->State = HAL_I2S_STATE_READY;
1260     HAL_I2S_RxCpltCallback(hi2s);
1261   }
1262 }
1263
1264 /**
1265   * @brief This function handles I2S Communication Timeout.
1266   * @param  hi2s: pointer to a I2S_HandleTypeDef structure that contains
1267   *         the configuration information for I2S module
1268   * @param Flag Flag checked
1269   * @param State Value of the flag expected
1270   * @param Timeout Duration of the timeout
1271   * @retval HAL status
1272   */
1273 static HAL_StatusTypeDef I2S_WaitFlagStateUntilTimeout(I2S_HandleTypeDef *hi2s, uint32_t Flag, uint32_t State, uint32_t Timeout)
1274 {
1275   uint32_t tickstart = HAL_GetTick();
1276
1277   /* Wait until flag is set */
1278   if(State == RESET)
1279   {
1280     while(__HAL_I2S_GET_FLAG(hi2s, Flag) == RESET)
1281     {
1282       if(Timeout != HAL_MAX_DELAY)
1283       {
1284         if((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
1285         {
1286           /* Set the I2S State ready */
1287           hi2s->State= HAL_I2S_STATE_READY;
1288
1289           /* Process Unlocked */
1290           __HAL_UNLOCK(hi2s);
1291
1292           return HAL_TIMEOUT;
1293         }
1294       }
1295     }
1296   }
1297   else
1298   {
1299     while(__HAL_I2S_GET_FLAG(hi2s, Flag) != RESET)
1300     {
1301       if(Timeout != HAL_MAX_DELAY)
1302       {
1303         if((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
1304         {
1305           /* Set the I2S State ready */
1306           hi2s->State= HAL_I2S_STATE_READY;
1307
1308           /* Process Unlocked */
1309           __HAL_UNLOCK(hi2s);
1310
1311           return HAL_TIMEOUT;
1312         }
1313       }
1314     }
1315   }
1316   return HAL_OK;
1317 }
1318
1319 /**
1320   * @}
1321   */
1322
1323 /**
1324   * @}
1325   */
1326
1327 /**
1328   * @}
1329   */
1330 #endif /* STM32F302xE || STM32F303xE || STM32F398xx || */
1331        /* STM32F302xC || STM32F303xC || STM32F358xx || */
1332        /* STM32F301x8 || STM32F302x8 || STM32F318xx || */
1333        /* STM32F373xC || STM32F378xx                   */
1334
1335 #endif /* HAL_I2S_MODULE_ENABLED */
1336
1337 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/