Subversion Repositories AFRtranscoder

/**

  ******************************************************************************

  * @file    stm32f1xx_hal_i2c.c

  * @author  MCD Application Team

  * @brief   I2C HAL module driver.

  *          This file provides firmware functions to manage the following

  *          functionalities of the Inter Integrated Circuit (I2C) peripheral:

  *           + Initialization and de-initialization functions

  *           + IO operation functions

  *           + Peripheral State, Mode and Error functions

  *

  ******************************************************************************

  * @attention

  *

  * Copyright (c) 2016 STMicroelectronics.

  * All rights reserved.

  *

  * This software is licensed under terms that can be found in the LICENSE file

  * in the root directory of this software component.

  * If no LICENSE file comes with this software, it is provided AS-IS.

  *

  ******************************************************************************

  @verbatim

  ==============================================================================

                        ##### How to use this driver #####

  ==============================================================================

  [..]

    The I2C HAL driver can be used as follows:

    (#) Declare a I2C_HandleTypeDef handle structure, for example:

        I2C_HandleTypeDef  hi2c;

    (#)Initialize the I2C low level resources by implementing the HAL_I2C_MspInit() API:

        (##) Enable the I2Cx interface clock

        (##) I2C pins configuration

            (+++) Enable the clock for the I2C GPIOs

            (+++) Configure I2C pins as alternate function open-drain

        (##) NVIC configuration if you need to use interrupt process

            (+++) Configure the I2Cx interrupt priority

            (+++) Enable the NVIC I2C IRQ Channel

        (##) DMA Configuration if you need to use DMA process

            (+++) Declare a DMA_HandleTypeDef handle structure for the transmit or receive channel

            (+++) Enable the DMAx interface clock using

            (+++) Configure the DMA handle parameters

            (+++) Configure the DMA Tx or Rx channel

            (+++) Associate the initialized DMA handle to the hi2c DMA Tx or Rx handle

            (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on

                  the DMA Tx or Rx channel

    (#) Configure the Communication Speed, Duty cycle, Addressing mode, Own Address1,

        Dual Addressing mode, Own Address2, General call and Nostretch mode in the hi2c Init structure.

    (#) Initialize the I2C registers by calling the HAL_I2C_Init(), configures also the low level Hardware

        (GPIO, CLOCK, NVIC...etc) by calling the customized HAL_I2C_MspInit() API.

    (#) To check if target device is ready for communication, use the function HAL_I2C_IsDeviceReady()

    (#) For I2C IO and IO MEM operations, three operation modes are available within this driver :

    *** Polling mode IO operation ***

    =================================

    [..]

      (+) Transmit in master mode an amount of data in blocking mode using HAL_I2C_Master_Transmit()

      (+) Receive in master mode an amount of data in blocking mode using HAL_I2C_Master_Receive()

      (+) Transmit in slave mode an amount of data in blocking mode using HAL_I2C_Slave_Transmit()

      (+) Receive in slave mode an amount of data in blocking mode using HAL_I2C_Slave_Receive()

    *** Polling mode IO MEM operation ***

    =====================================

    [..]

      (+) Write an amount of data in blocking mode to a specific memory address using HAL_I2C_Mem_Write()

      (+) Read an amount of data in blocking mode from a specific memory address using HAL_I2C_Mem_Read()

    *** Interrupt mode IO operation ***

    ===================================

    [..]

      (+) Transmit in master mode an amount of data in non-blocking mode using HAL_I2C_Master_Transmit_IT()

      (+) At transmission end of transfer, HAL_I2C_MasterTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MasterTxCpltCallback()

      (+) Receive in master mode an amount of data in non-blocking mode using HAL_I2C_Master_Receive_IT()

      (+) At reception end of transfer, HAL_I2C_MasterRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MasterRxCpltCallback()

      (+) Transmit in slave mode an amount of data in non-blocking mode using HAL_I2C_Slave_Transmit_IT()

      (+) At transmission end of transfer, HAL_I2C_SlaveTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_SlaveTxCpltCallback()

      (+) Receive in slave mode an amount of data in non-blocking mode using HAL_I2C_Slave_Receive_IT()

      (+) At reception end of transfer, HAL_I2C_SlaveRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_SlaveRxCpltCallback()

      (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can

           add his own code by customization of function pointer HAL_I2C_ErrorCallback()

      (+) Abort a master I2C process communication with Interrupt using HAL_I2C_Master_Abort_IT()

      (+) End of abort process, HAL_I2C_AbortCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_AbortCpltCallback()

    *** Interrupt mode or DMA mode IO sequential operation ***

    ==========================================================

    [..]

      (@) These interfaces allow to manage a sequential transfer with a repeated start condition

          when a direction change during transfer

    [..]

      (+) A specific option field manage the different steps of a sequential transfer

      (+) Option field values are defined through I2C_XferOptions_definition and are listed below:

      (++) I2C_FIRST_AND_LAST_FRAME: No sequential usage, functional is same as associated interfaces in no sequential mode

      (++) I2C_FIRST_FRAME: Sequential usage, this option allow to manage a sequence with start condition, address

                            and data to transfer without a final stop condition

      (++) I2C_FIRST_AND_NEXT_FRAME: Sequential usage (Master only), this option allow to manage a sequence with start condition, address

                            and data to transfer without a final stop condition, an then permit a call the same master sequential interface

                            several times (like HAL_I2C_Master_Seq_Transmit_IT() then HAL_I2C_Master_Seq_Transmit_IT()

                            or HAL_I2C_Master_Seq_Transmit_DMA() then HAL_I2C_Master_Seq_Transmit_DMA())

      (++) I2C_NEXT_FRAME: Sequential usage, this option allow to manage a sequence with a restart condition, address

                            and with new data to transfer if the direction change or manage only the new data to transfer

                            if no direction change and without a final stop condition in both cases

      (++) I2C_LAST_FRAME: Sequential usage, this option allow to manage a sequance with a restart condition, address

                            and with new data to transfer if the direction change or manage only the new data to transfer

                            if no direction change and with a final stop condition in both cases

      (++) I2C_LAST_FRAME_NO_STOP: Sequential usage (Master only), this option allow to manage a restart condition after several call of the same master sequential

                            interface several times (link with option I2C_FIRST_AND_NEXT_FRAME).

                            Usage can, transfer several bytes one by one using HAL_I2C_Master_Seq_Transmit_IT(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME)

                              or HAL_I2C_Master_Seq_Receive_IT(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME)

                              or HAL_I2C_Master_Seq_Transmit_DMA(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME)

                              or HAL_I2C_Master_Seq_Receive_DMA(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME).

                            Then usage of this option I2C_LAST_FRAME_NO_STOP at the last Transmit or Receive sequence permit to call the opposite interface Receive or Transmit

                              without stopping the communication and so generate a restart condition.

      (++) I2C_OTHER_FRAME: Sequential usage (Master only), this option allow to manage a restart condition after each call of the same master sequential

                            interface.

                            Usage can, transfer several bytes one by one with a restart with slave address between each bytes using HAL_I2C_Master_Seq_Transmit_IT(option I2C_FIRST_FRAME then I2C_OTHER_FRAME)

                              or HAL_I2C_Master_Seq_Receive_IT(option I2C_FIRST_FRAME then I2C_OTHER_FRAME)

                              or HAL_I2C_Master_Seq_Transmit_DMA(option I2C_FIRST_FRAME then I2C_OTHER_FRAME)

                              or HAL_I2C_Master_Seq_Receive_DMA(option I2C_FIRST_FRAME then I2C_OTHER_FRAME).

                            Then usage of this option I2C_OTHER_AND_LAST_FRAME at the last frame to help automatic generation of STOP condition.

      (+) Different sequential I2C interfaces are listed below:

      (++) Sequential transmit in master I2C mode an amount of data in non-blocking mode using HAL_I2C_Master_Seq_Transmit_IT()

            or using HAL_I2C_Master_Seq_Transmit_DMA()

      (+++) At transmission end of current frame transfer, HAL_I2C_MasterTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MasterTxCpltCallback()

      (++) Sequential receive in master I2C mode an amount of data in non-blocking mode using HAL_I2C_Master_Seq_Receive_IT()

            or using HAL_I2C_Master_Seq_Receive_DMA()

      (+++) At reception end of current frame transfer, HAL_I2C_MasterRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MasterRxCpltCallback()

      (++) Abort a master IT or DMA I2C process communication with Interrupt using HAL_I2C_Master_Abort_IT()

      (+++) End of abort process, HAL_I2C_AbortCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_AbortCpltCallback()

      (++) Enable/disable the Address listen mode in slave I2C mode using HAL_I2C_EnableListen_IT() HAL_I2C_DisableListen_IT()

      (+++) When address slave I2C match, HAL_I2C_AddrCallback() is executed and user can

           add his own code to check the Address Match Code and the transmission direction request by master (Write/Read).

      (+++) At Listen mode end HAL_I2C_ListenCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_ListenCpltCallback()

      (++) Sequential transmit in slave I2C mode an amount of data in non-blocking mode using HAL_I2C_Slave_Seq_Transmit_IT()

            or using HAL_I2C_Slave_Seq_Transmit_DMA()

      (+++) At transmission end of current frame transfer, HAL_I2C_SlaveTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_SlaveTxCpltCallback()

      (++) Sequential receive in slave I2C mode an amount of data in non-blocking mode using HAL_I2C_Slave_Seq_Receive_IT()

            or using HAL_I2C_Slave_Seq_Receive_DMA()

      (+++) At reception end of current frame transfer, HAL_I2C_SlaveRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_SlaveRxCpltCallback()

      (++) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can

           add his own code by customization of function pointer HAL_I2C_ErrorCallback()

    *** Interrupt mode IO MEM operation ***

    =======================================

    [..]

      (+) Write an amount of data in non-blocking mode with Interrupt to a specific memory address using

          HAL_I2C_Mem_Write_IT()

      (+) At Memory end of write transfer, HAL_I2C_MemTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MemTxCpltCallback()

      (+) Read an amount of data in non-blocking mode with Interrupt from a specific memory address using

          HAL_I2C_Mem_Read_IT()

      (+) At Memory end of read transfer, HAL_I2C_MemRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MemRxCpltCallback()

      (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can

           add his own code by customization of function pointer HAL_I2C_ErrorCallback()

    *** DMA mode IO operation ***

    ==============================

    [..]

      (+) Transmit in master mode an amount of data in non-blocking mode (DMA) using

          HAL_I2C_Master_Transmit_DMA()

      (+) At transmission end of transfer, HAL_I2C_MasterTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MasterTxCpltCallback()

      (+) Receive in master mode an amount of data in non-blocking mode (DMA) using

          HAL_I2C_Master_Receive_DMA()

      (+) At reception end of transfer, HAL_I2C_MasterRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MasterRxCpltCallback()

      (+) Transmit in slave mode an amount of data in non-blocking mode (DMA) using

          HAL_I2C_Slave_Transmit_DMA()

      (+) At transmission end of transfer, HAL_I2C_SlaveTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_SlaveTxCpltCallback()

      (+) Receive in slave mode an amount of data in non-blocking mode (DMA) using

          HAL_I2C_Slave_Receive_DMA()

      (+) At reception end of transfer, HAL_I2C_SlaveRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_SlaveRxCpltCallback()

      (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can

           add his own code by customization of function pointer HAL_I2C_ErrorCallback()

      (+) Abort a master I2C process communication with Interrupt using HAL_I2C_Master_Abort_IT()

      (+) End of abort process, HAL_I2C_AbortCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_AbortCpltCallback()

    *** DMA mode IO MEM operation ***

    =================================

    [..]

      (+) Write an amount of data in non-blocking mode with DMA to a specific memory address using

          HAL_I2C_Mem_Write_DMA()

      (+) At Memory end of write transfer, HAL_I2C_MemTxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MemTxCpltCallback()

      (+) Read an amount of data in non-blocking mode with DMA from a specific memory address using

          HAL_I2C_Mem_Read_DMA()

      (+) At Memory end of read transfer, HAL_I2C_MemRxCpltCallback() is executed and user can

           add his own code by customization of function pointer HAL_I2C_MemRxCpltCallback()

      (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can

           add his own code by customization of function pointer HAL_I2C_ErrorCallback()

     *** I2C HAL driver macros list ***

     ==================================

     [..]

       Below the list of most used macros in I2C HAL driver.

      (+) __HAL_I2C_ENABLE:     Enable the I2C peripheral

      (+) __HAL_I2C_DISABLE:    Disable the I2C peripheral

      (+) __HAL_I2C_GET_FLAG:   Checks whether the specified I2C flag is set or not

      (+) __HAL_I2C_CLEAR_FLAG: Clear the specified I2C pending flag

      (+) __HAL_I2C_ENABLE_IT:  Enable the specified I2C interrupt

      (+) __HAL_I2C_DISABLE_IT: Disable the specified I2C interrupt

     *** Callback registration ***

     =============================================

    [..]

     The compilation flag USE_HAL_I2C_REGISTER_CALLBACKS when set to 1

     allows the user to configure dynamically the driver callbacks.

     Use Functions HAL_I2C_RegisterCallback() or HAL_I2C_RegisterAddrCallback()

     to register an interrupt callback.

    [..]

     Function HAL_I2C_RegisterCallback() allows to register following callbacks:

       (+) MasterTxCpltCallback : callback for Master transmission end of transfer.

       (+) MasterRxCpltCallback : callback for Master reception end of transfer.

       (+) SlaveTxCpltCallback  : callback for Slave transmission end of transfer.

       (+) SlaveRxCpltCallback  : callback for Slave reception end of transfer.

       (+) ListenCpltCallback   : callback for end of listen mode.

       (+) MemTxCpltCallback    : callback for Memory transmission end of transfer.

       (+) MemRxCpltCallback    : callback for Memory reception end of transfer.

       (+) ErrorCallback        : callback for error detection.

       (+) AbortCpltCallback    : callback for abort completion process.

       (+) MspInitCallback      : callback for Msp Init.

       (+) MspDeInitCallback    : callback for Msp DeInit.

     This function takes as parameters the HAL peripheral handle, the Callback ID

     and a pointer to the user callback function.

    [..]

     For specific callback AddrCallback use dedicated register callbacks : HAL_I2C_RegisterAddrCallback().

    [..]

     Use function HAL_I2C_UnRegisterCallback to reset a callback to the default

     weak function.

     HAL_I2C_UnRegisterCallback takes as parameters the HAL peripheral handle,

     and the Callback ID.

     This function allows to reset following callbacks:

       (+) MasterTxCpltCallback : callback for Master transmission end of transfer.

       (+) MasterRxCpltCallback : callback for Master reception end of transfer.

       (+) SlaveTxCpltCallback  : callback for Slave transmission end of transfer.

       (+) SlaveRxCpltCallback  : callback for Slave reception end of transfer.

       (+) ListenCpltCallback   : callback for end of listen mode.

       (+) MemTxCpltCallback    : callback for Memory transmission end of transfer.

       (+) MemRxCpltCallback    : callback for Memory reception end of transfer.

       (+) ErrorCallback        : callback for error detection.

       (+) AbortCpltCallback    : callback for abort completion process.

       (+) MspInitCallback      : callback for Msp Init.

       (+) MspDeInitCallback    : callback for Msp DeInit.

    [..]

     For callback AddrCallback use dedicated register callbacks : HAL_I2C_UnRegisterAddrCallback().

    [..]

     By default, after the HAL_I2C_Init() and when the state is HAL_I2C_STATE_RESET

     all callbacks are set to the corresponding weak functions:

     examples HAL_I2C_MasterTxCpltCallback(), HAL_I2C_MasterRxCpltCallback().

     Exception done for MspInit and MspDeInit functions that are

     reset to the legacy weak functions in the HAL_I2C_Init()/ HAL_I2C_DeInit() only when

     these callbacks are null (not registered beforehand).

     If MspInit or MspDeInit are not null, the HAL_I2C_Init()/ HAL_I2C_DeInit()

     keep and use the user MspInit/MspDeInit callbacks (registered beforehand) whatever the state.

    [..]

     Callbacks can be registered/unregistered in HAL_I2C_STATE_READY state only.

     Exception done MspInit/MspDeInit functions that can be registered/unregistered

     in HAL_I2C_STATE_READY or HAL_I2C_STATE_RESET state,

     thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit.

     Then, the user first registers the MspInit/MspDeInit user callbacks

     using HAL_I2C_RegisterCallback() before calling HAL_I2C_DeInit()

     or HAL_I2C_Init() function.

    [..]

     When the compilation flag USE_HAL_I2C_REGISTER_CALLBACKS is set to 0 or

     not defined, the callback registration feature is not available and all callbacks

     are set to the corresponding weak functions.

     *** I2C Workarounds linked to Silicon Limitation ***

     ====================================================

     [..]

       Below the list of all silicon limitations implemented for HAL on STM32F1xx product.

       (@) See ErrataSheet to know full silicon limitation list of your product.

       (+) Workarounds Implemented inside I2C HAL Driver

          (++) Wrong data read into data register (Polling and Interrupt mode)

          (++) Start cannot be generated after a misplaced Stop

          (++) Some software events must be managed before the current byte is being transferred:

               Workaround: Use DMA in general, except when the Master is receiving a single byte.

               For Interrupt mode, I2C should have the highest priority in the application.

          (++) Mismatch on the "Setup time for a repeated Start condition" timing parameter:

               Workaround: Reduce the frequency down to 88 kHz or use the I2C Fast-mode if

               supported by the slave.

          (++) Data valid time (tVD;DAT) violated without the OVR flag being set:

               Workaround: If the slave device allows it, use the clock stretching mechanism

               by programming NoStretchMode = I2C_NOSTRETCH_DISABLE in HAL_I2C_Init.

     [..]

       (@) You can refer to the I2C HAL driver header file for more useful macros

  @endverbatim

  */

/* Includes ------------------------------------------------------------------*/

#include "stm32f1xx_hal.h"

/** @addtogroup STM32F1xx_HAL_Driver

  * @{

  */

/** @defgroup I2C I2C

  * @brief I2C HAL module driver

  * @{

  */

#ifdef HAL_I2C_MODULE_ENABLED

/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/

/** @defgroup I2C_Private_Define I2C Private Define

  * @{

  */

#define I2C_TIMEOUT_FLAG          35U         /*!< Timeout 35 ms             */

#define I2C_TIMEOUT_BUSY_FLAG     25U         /*!< Timeout 25 ms             */

#define I2C_TIMEOUT_STOP_FLAG     5U          /*!< Timeout 5 ms              */

#define I2C_NO_OPTION_FRAME       0xFFFF0000U /*!< XferOptions default value */

/* Private define for @ref PreviousState usage */

#define I2C_STATE_MSK             ((uint32_t)((uint32_t)((uint32_t)HAL_I2C_STATE_BUSY_TX | (uint32_t)HAL_I2C_STATE_BUSY_RX) & (uint32_t)(~((uint32_t)HAL_I2C_STATE_READY)))) /*!< Mask State define, keep only RX and TX bits            */

#define I2C_STATE_NONE            ((uint32_t)(HAL_I2C_MODE_NONE))                                                        /*!< Default Value                                          */

#define I2C_STATE_MASTER_BUSY_TX  ((uint32_t)(((uint32_t)HAL_I2C_STATE_BUSY_TX & I2C_STATE_MSK) | (uint32_t)HAL_I2C_MODE_MASTER))            /*!< Master Busy TX, combinaison of State LSB and Mode enum */

#define I2C_STATE_MASTER_BUSY_RX  ((uint32_t)(((uint32_t)HAL_I2C_STATE_BUSY_RX & I2C_STATE_MSK) | (uint32_t)HAL_I2C_MODE_MASTER))            /*!< Master Busy RX, combinaison of State LSB and Mode enum */

#define I2C_STATE_SLAVE_BUSY_TX   ((uint32_t)(((uint32_t)HAL_I2C_STATE_BUSY_TX & I2C_STATE_MSK) | (uint32_t)HAL_I2C_MODE_SLAVE))             /*!< Slave Busy TX, combinaison of State LSB and Mode enum  */

#define I2C_STATE_SLAVE_BUSY_RX   ((uint32_t)(((uint32_t)HAL_I2C_STATE_BUSY_RX & I2C_STATE_MSK) | (uint32_t)HAL_I2C_MODE_SLAVE))             /*!< Slave Busy RX, combinaison of State LSB and Mode enum  */

/**

  * @}

  */

/* Private macro -------------------------------------------------------------*/

/** @addtogroup I2C_Private_Macros

  * @{

  */

/* Macro to get remaining data to transfer on DMA side */

#define I2C_GET_DMA_REMAIN_DATA(__HANDLE__)     __HAL_DMA_GET_COUNTER(__HANDLE__)

/**

  * @}

  */

/* Private variables ---------------------------------------------------------*/

/* Private function prototypes -----------------------------------------------*/

/** @defgroup I2C_Private_Functions I2C Private Functions

  * @{

  */

/* Private functions to handle DMA transfer */

static void I2C_DMAXferCplt(DMA_HandleTypeDef *hdma);

static void I2C_DMAError(DMA_HandleTypeDef *hdma);

static void I2C_DMAAbort(DMA_HandleTypeDef *hdma);

static void I2C_ITError(I2C_HandleTypeDef *hi2c);

static HAL_StatusTypeDef I2C_MasterRequestWrite(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_MasterRequestRead(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_RequestMemoryWrite(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_RequestMemoryRead(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout, uint32_t Tickstart);

/* Private functions to handle flags during polling transfer */

static HAL_StatusTypeDef I2C_WaitOnFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Flag, FlagStatus Status, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_WaitOnMasterAddressFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Flag, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_WaitOnTXEFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_WaitOnBTFFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_WaitOnRXNEFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_WaitOnSTOPFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout, uint32_t Tickstart);

static HAL_StatusTypeDef I2C_WaitOnSTOPRequestThroughIT(I2C_HandleTypeDef *hi2c);

static HAL_StatusTypeDef I2C_IsAcknowledgeFailed(I2C_HandleTypeDef *hi2c);

/* Private functions for I2C transfer IRQ handler */

static void I2C_MasterTransmit_TXE(I2C_HandleTypeDef *hi2c);

static void I2C_MasterTransmit_BTF(I2C_HandleTypeDef *hi2c);

static void I2C_MasterReceive_RXNE(I2C_HandleTypeDef *hi2c);

static void I2C_MasterReceive_BTF(I2C_HandleTypeDef *hi2c);

static void I2C_Master_SB(I2C_HandleTypeDef *hi2c);

static void I2C_Master_ADD10(I2C_HandleTypeDef *hi2c);

static void I2C_Master_ADDR(I2C_HandleTypeDef *hi2c);

static void I2C_SlaveTransmit_TXE(I2C_HandleTypeDef *hi2c);

static void I2C_SlaveTransmit_BTF(I2C_HandleTypeDef *hi2c);

static void I2C_SlaveReceive_RXNE(I2C_HandleTypeDef *hi2c);

static void I2C_SlaveReceive_BTF(I2C_HandleTypeDef *hi2c);

static void I2C_Slave_ADDR(I2C_HandleTypeDef *hi2c, uint32_t IT2Flags);

static void I2C_Slave_STOPF(I2C_HandleTypeDef *hi2c);

static void I2C_Slave_AF(I2C_HandleTypeDef *hi2c);

static void I2C_MemoryTransmit_TXE_BTF(I2C_HandleTypeDef *hi2c);

/* Private function to Convert Specific options */

static void I2C_ConvertOtherXferOptions(I2C_HandleTypeDef *hi2c);

/* Private function to flush DR register */

static void I2C_Flush_DR(I2C_HandleTypeDef *hi2c);

/**

  * @}

  */

/* Exported functions --------------------------------------------------------*/

/** @defgroup I2C_Exported_Functions I2C Exported Functions

  * @{

  */

/** @defgroup I2C_Exported_Functions_Group1 Initialization and de-initialization functions

 *  @brief    Initialization and Configuration functions

 *

@verbatim

 ===============================================================================

              ##### Initialization and de-initialization functions #####

 ===============================================================================

    [..]  This subsection provides a set of functions allowing to initialize and

          deinitialize the I2Cx peripheral:

      (+) User must Implement HAL_I2C_MspInit() function in which he configures

          all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC).

      (+) Call the function HAL_I2C_Init() to configure the selected device with

          the selected configuration:

        (++) Communication Speed

        (++) Duty cycle

        (++) Addressing mode

        (++) Own Address 1

        (++) Dual Addressing mode

        (++) Own Address 2

        (++) General call mode

        (++) Nostretch mode

      (+) Call the function HAL_I2C_DeInit() to restore the default configuration

          of the selected I2Cx peripheral.

@endverbatim

  * @{

  */

/**

  * @brief  Initializes the I2C according to the specified parameters

  *         in the I2C_InitTypeDef and initialize the associated handle.

  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains

  *                the configuration information for the specified I2C.

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_I2C_Init(I2C_HandleTypeDef *hi2c)

{

  uint32_t freqrange;

  uint32_t pclk1;

  /* Check the I2C handle allocation */

  if (hi2c == NULL)

  {

    return HAL_ERROR;

  }

  /* Check the parameters */

  assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance));

  assert_param(IS_I2C_CLOCK_SPEED(hi2c->Init.ClockSpeed));

  assert_param(IS_I2C_DUTY_CYCLE(hi2c->Init.DutyCycle));

  assert_param(IS_I2C_OWN_ADDRESS1(hi2c->Init.OwnAddress1));

  assert_param(IS_I2C_ADDRESSING_MODE(hi2c->Init.AddressingMode));

  assert_param(IS_I2C_DUAL_ADDRESS(hi2c->Init.DualAddressMode));

  assert_param(IS_I2C_OWN_ADDRESS2(hi2c->Init.OwnAddress2));

  assert_param(IS_I2C_GENERAL_CALL(hi2c->Init.GeneralCallMode));

  assert_param(IS_I2C_NO_STRETCH(hi2c->Init.NoStretchMode));

  if (hi2c->State == HAL_I2C_STATE_RESET)

  {

    /* Allocate lock resource and initialize it */

    hi2c->Lock = HAL_UNLOCKED;

#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)

    /* Init the I2C Callback settings */

    hi2c->MasterTxCpltCallback = HAL_I2C_MasterTxCpltCallback; /* Legacy weak MasterTxCpltCallback */

    hi2c->MasterRxCpltCallback = HAL_I2C_MasterRxCpltCallback; /* Legacy weak MasterRxCpltCallback */

    hi2c->SlaveTxCpltCallback  = HAL_I2C_SlaveTxCpltCallback;  /* Legacy weak SlaveTxCpltCallback  */

    hi2c->SlaveRxCpltCallback  = HAL_I2C_SlaveRxCpltCallback;  /* Legacy weak SlaveRxCpltCallback  */

    hi2c->ListenCpltCallback   = HAL_I2C_ListenCpltCallback;   /* Legacy weak ListenCpltCallback   */

    hi2c->MemTxCpltCallback    = HAL_I2C_MemTxCpltCallback;    /* Legacy weak MemTxCpltCallback    */

    hi2c->MemRxCpltCallback    = HAL_I2C_MemRxCpltCallback;    /* Legacy weak MemRxCpltCallback    */

    hi2c->ErrorCallback        = HAL_I2C_ErrorCallback;        /* Legacy weak ErrorCallback        */

    hi2c->AbortCpltCallback    = HAL_I2C_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */

    hi2c->AddrCallback         = HAL_I2C_AddrCallback;         /* Legacy weak AddrCallback         */

    if (hi2c->MspInitCallback == NULL)

    {

      hi2c->MspInitCallback = HAL_I2C_MspInit; /* Legacy weak MspInit  */

    }

    /* Init the low level hardware : GPIO, CLOCK, NVIC */

    hi2c->MspInitCallback(hi2c);

#else

    /* Init the low level hardware : GPIO, CLOCK, NVIC */

    HAL_I2C_MspInit(hi2c);

#endif /* USE_HAL_I2C_REGISTER_CALLBACKS */

  }

  hi2c->State = HAL_I2C_STATE_BUSY;

  /* Disable the selected I2C peripheral */

  __HAL_I2C_DISABLE(hi2c);

  /*Reset I2C*/

  hi2c->Instance->CR1 |= I2C_CR1_SWRST;

  hi2c->Instance->CR1 &= ~I2C_CR1_SWRST;

  /* Get PCLK1 frequency */

  pclk1 = HAL_RCC_GetPCLK1Freq();

  /* Check the minimum allowed PCLK1 frequency */

  if (I2C_MIN_PCLK_FREQ(pclk1, hi2c->Init.ClockSpeed) == 1U)

  {

    return HAL_ERROR;

  }

  /* Calculate frequency range */

  freqrange = I2C_FREQRANGE(pclk1);

  /*---------------------------- I2Cx CR2 Configuration ----------------------*/

  /* Configure I2Cx: Frequency range */

  MODIFY_REG(hi2c->Instance->CR2, I2C_CR2_FREQ, freqrange);

  /*---------------------------- I2Cx TRISE Configuration --------------------*/

  /* Configure I2Cx: Rise Time */

  MODIFY_REG(hi2c->Instance->TRISE, I2C_TRISE_TRISE, I2C_RISE_TIME(freqrange, hi2c->Init.ClockSpeed));

  /*---------------------------- I2Cx CCR Configuration ----------------------*/

  /* Configure I2Cx: Speed */

  MODIFY_REG(hi2c->Instance->CCR, (I2C_CCR_FS | I2C_CCR_DUTY | I2C_CCR_CCR), I2C_SPEED(pclk1, hi2c->Init.ClockSpeed, hi2c->Init.DutyCycle));

  /*---------------------------- I2Cx CR1 Configuration ----------------------*/

  /* Configure I2Cx: Generalcall and NoStretch mode */

  MODIFY_REG(hi2c->Instance->CR1, (I2C_CR1_ENGC | I2C_CR1_NOSTRETCH), (hi2c->Init.GeneralCallMode | hi2c->Init.NoStretchMode));

  /*---------------------------- I2Cx OAR1 Configuration ---------------------*/

  /* Configure I2Cx: Own Address1 and addressing mode */

  MODIFY_REG(hi2c->Instance->OAR1, (I2C_OAR1_ADDMODE | I2C_OAR1_ADD8_9 | I2C_OAR1_ADD1_7 | I2C_OAR1_ADD0), (hi2c->Init.AddressingMode | hi2c->Init.OwnAddress1));

  /*---------------------------- I2Cx OAR2 Configuration ---------------------*/

  /* Configure I2Cx: Dual mode and Own Address2 */

  MODIFY_REG(hi2c->Instance->OAR2, (I2C_OAR2_ENDUAL | I2C_OAR2_ADD2), (hi2c->Init.DualAddressMode | hi2c->Init.OwnAddress2));

  /* Enable the selected I2C peripheral */

  __HAL_I2C_ENABLE(hi2c);

  hi2c->ErrorCode = HAL_I2C_ERROR_NONE;

  hi2c->State = HAL_I2C_STATE_READY;

  hi2c->PreviousState = I2C_STATE_NONE;

  hi2c->Mode = HAL_I2C_MODE_NONE;

  return HAL_OK;

}

/**

  * @brief  DeInitialize the I2C peripheral.

  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains

  *         the configuration information for the specified I2C.

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_I2C_DeInit(I2C_HandleTypeDef *hi2c)

{

  /* Check the I2C handle allocation */

  if (hi2c == NULL)

  {

    return HAL_ERROR;

  }

  /* Check the parameters */

  assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance));

  hi2c->State = HAL_I2C_STATE_BUSY;

  /* Disable the I2C Peripheral Clock */

  __HAL_I2C_DISABLE(hi2c);

#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)

  if (hi2c->MspDeInitCallback == NULL)

  {

    hi2c->MspDeInitCallback = HAL_I2C_MspDeInit; /* Legacy weak MspDeInit  */

  }

  /* DeInit the low level hardware: GPIO, CLOCK, NVIC */

  hi2c->MspDeInitCallback(hi2c);

#else

  /* DeInit the low level hardware: GPIO, CLOCK, NVIC */

  HAL_I2C_MspDeInit(hi2c);

#endif /* USE_HAL_I2C_REGISTER_CALLBACKS */

  hi2c->ErrorCode     = HAL_I2C_ERROR_NONE;

  hi2c->State         = HAL_I2C_STATE_RESET;

  hi2c->PreviousState = I2C_STATE_NONE;

  hi2c->Mode          = HAL_I2C_MODE_NONE;

  /* Release Lock */

  __HAL_UNLOCK(hi2c);

  return HAL_OK;

}

/**

  * @brief  Initialize the I2C MSP.

  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains

  *         the configuration information for the specified I2C.

  * @retval None

  */

__weak void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c)

{

  /* Prevent unused argument(s) compilation warning */

  UNUSED(hi2c);

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_I2C_MspInit could be implemented in the user file

   */

}

/**

  * @brief  DeInitialize the I2C MSP.

  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains

  *         the configuration information for the specified I2C.

  * @retval None

  */

__weak void HAL_I2C_MspDeInit(I2C_HandleTypeDef *hi2c)

{

  /* Prevent unused argument(s) compilation warning */

  UNUSED(hi2c);

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_I2C_MspDeInit could be implemented in the user file

   */

}

#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)

/**

  * @brief  Register a User I2C Callback

  *         To be used instead of the weak predefined callback

  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains

  *                the configuration information for the specified I2C.

  * @param  CallbackID ID of the callback to be registered

  *         This parameter can be one of the following values:

  *          @arg @ref HAL_I2C_MASTER_TX_COMPLETE_CB_ID Master Tx Transfer completed callback ID

  *          @arg @ref HAL_I2C_MASTER_RX_COMPLETE_CB_ID Master Rx Transfer completed callback ID

  *          @arg @ref HAL_I2C_SLAVE_TX_COMPLETE_CB_ID Slave Tx Transfer completed callback ID

  *          @arg @ref HAL_I2C_SLAVE_RX_COMPLETE_CB_ID Slave Rx Transfer completed callback ID

  *          @arg @ref HAL_I2C_LISTEN_COMPLETE_CB_ID Listen Complete callback ID

  *          @arg @ref HAL_I2C_MEM_TX_COMPLETE_CB_ID Memory Tx Transfer callback ID

  *          @arg @ref HAL_I2C_MEM_RX_COMPLETE_CB_ID Memory Rx Transfer completed callback ID

  *          @arg @ref HAL_I2C_ERROR_CB_ID Error callback ID

  *          @arg @ref HAL_I2C_ABORT_CB_ID Abort callback ID

  *          @arg @ref HAL_I2C_MSPINIT_CB_ID MspInit callback ID

  *          @arg @ref HAL_I2C_MSPDEINIT_CB_ID MspDeInit callback ID

  * @param  pCallback pointer to the Callback function

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_I2C_RegisterCallback(I2C_HandleTypeDef *hi2c, HAL_I2C_CallbackIDTypeDef CallbackID, pI2C_CallbackTypeDef pCallback)

{

  HAL_StatusTypeDef status = HAL_OK;

  if (pCallback == NULL)

  {

    /* Update the error code */

    hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;

    return HAL_ERROR;

  }

  /* Process locked */

  __HAL_LOCK(hi2c);

  if (HAL_I2C_STATE_READY == hi2c->State)

  {

    switch (CallbackID)

    {

      case HAL_I2C_MASTER_TX_COMPLETE_CB_ID :

        hi2c->MasterTxCpltCallback = pCallback;

        break;

      case HAL_I2C_MASTER_RX_COMPLETE_CB_ID :

        hi2c->MasterRxCpltCallback = pCallback;

        break;

      case HAL_I2C_SLAVE_TX_COMPLETE_CB_ID :

        hi2c->SlaveTxCpltCallback = pCallback;

        break;

      case HAL_I2C_SLAVE_RX_COMPLETE_CB_ID :

        hi2c->SlaveRxCpltCallback = pCallback;

        break;

      case HAL_I2C_LISTEN_COMPLETE_CB_ID :

        hi2c->ListenCpltCallback = pCallback;

        break;

      case HAL_I2C_MEM_TX_COMPLETE_CB_ID :

        hi2c->MemTxCpltCallback = pCallback;

        break;

      case HAL_I2C_MEM_RX_COMPLETE_CB_ID :

        hi2c->MemRxCpltCallback = pCallback;

        break;

      case HAL_I2C_ERROR_CB_ID :

        hi2c->ErrorCallback = pCallback;

        break;

      case HAL_I2C_ABORT_CB_ID :

        hi2c->AbortCpltCallback = pCallback;

        break;

      case HAL_I2C_MSPINIT_CB_ID :

        hi2c->MspInitCallback = pCallback;

        break;

      case HAL_I2C_MSPDEINIT_CB_ID :

        hi2c->MspDeInitCallback = pCallback;

        break;

      default :

        /* Update the error code */

        hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else if (HAL_I2C_STATE_RESET == hi2c->State)

  {

    switch (CallbackID)

    {

      case HAL_I2C_MSPINIT_CB_ID :

        hi2c->MspInitCallback = pCallback;

        break;

      case HAL_I2C_MSPDEINIT_CB_ID :

        hi2c->MspDeInitCallback = pCallback;

        break;

      default :

        /* Update the error code */

        hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else

  {

    /* Update the error code */

    hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;

    /* Return error status */

    status =  HAL_ERROR;

  }

  /* Release Lock */

  __HAL_UNLOCK(hi2c);

  return status;

}

/**

  * @brief  Unregister an I2C Callback

  *         I2C callback is redirected to the weak predefined callback

  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains

  *                the configuration information for the specified I2C.

  * @param  CallbackID ID of the callback to be unregistered

  *         This parameter can be one of the following values:

  *         This parameter can be one of the following values:

  *          @arg @ref HAL_I2C_MASTER_TX_COMPLETE_CB_ID Master Tx Transfer completed callback ID

  *          @arg @ref HAL_I2C_MASTER_RX_COMPLETE_CB_ID Master Rx Transfer completed callback ID

  *          @arg @ref HAL_I2C_SLAVE_TX_COMPLETE_CB_ID Slave Tx Transfer completed callback ID

  *          @arg @ref HAL_I2C_SLAVE_RX_COMPLETE_CB_ID Slave Rx Transfer completed callback ID

  *          @arg @ref HAL_I2C_LISTEN_COMPLETE_CB_ID Listen Complete callback ID

  *          @arg @ref HAL_I2C_MEM_TX_COMPLETE_CB_ID Memory Tx Transfer callback ID

  *          @arg @ref HAL_I2C_MEM_RX_COMPLETE_CB_ID Memory Rx Transfer completed callback ID

  *          @arg @ref HAL_I2C_ERROR_CB_ID Error callback ID

  *          @arg @ref HAL_I2C_ABORT_CB_ID Abort callback ID

  *          @arg @ref HAL_I2C_MSPINIT_CB_ID MspInit callback ID

  *          @arg @ref HAL_I2C_MSPDEINIT_CB_ID MspDeInit callback ID

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_I2C_UnRegisterCallback(I2C_HandleTypeDef *hi2c, HAL_I2C_CallbackIDTypeDef CallbackID)

{

  HAL_StatusTypeDef status = HAL_OK;

  /* Process locked */

  __HAL_LOCK(hi2c);

  if (HAL_I2C_STATE_READY == hi2c->State)

  {

    switch (CallbackID)

    {

      case HAL_I2C_MASTER_TX_COMPLETE_CB_ID :

        hi2c->MasterTxCpltCallback = HAL_I2C_MasterTxCpltCallback; /* Legacy weak MasterTxCpltCallback */

        break;

      case HAL_I2C_MASTER_RX_COMPLETE_CB_ID :

        hi2c->MasterRxCpltCallback = HAL_I2C_MasterRxCpltCallback; /* Legacy weak MasterRxCpltCallback */

        break;

      case HAL_I2C_SLAVE_TX_COMPLETE_CB_ID :

        hi2c->SlaveTxCpltCallback = HAL_I2C_SlaveTxCpltCallback;   /* Legacy weak SlaveTxCpltCallback  */

        break;

      case HAL_I2C_SLAVE_RX_COMPLETE_CB_ID :

        hi2c->SlaveRxCpltCallback = HAL_I2C_SlaveRxCpltCallback;   /* Legacy weak SlaveRxCpltCallback  */

        break;

      case HAL_I2C_LISTEN_COMPLETE_CB_ID :

        hi2c->ListenCpltCallback = HAL_I2C_ListenCpltCallback;     /* Legacy weak ListenCpltCallback   */

        break;

      case HAL_I2C_MEM_TX_COMPLETE_CB_ID :

        hi2c->MemTxCpltCallback = HAL_I2C_MemTxCpltCallback;       /* Legacy weak MemTxCpltCallback    */

        break;

      case HAL_I2C_MEM_RX_COMPLETE_CB_ID :

        hi2c->MemRxCpltCallback = HAL_I2C_MemRxCpltCallback;       /* Legacy weak MemRxCpltCallback    */

        break;

      case HAL_I2C_ERROR_CB_ID :

        hi2c->ErrorCallback = HAL_I2C_ErrorCallback;               /* Legacy weak ErrorCallback        */

        break;

      case HAL_I2C_ABORT_CB_ID :

        hi2c->AbortCpltCallback = HAL_I2C_AbortCpltCallback;       /* Legacy weak AbortCpltCallback    */

        break;

      case HAL_I2C_MSPINIT_CB_ID :

        hi2c->MspInitCallback = HAL_I2C_MspInit;                   /* Legacy weak MspInit              */

        break;

      case HAL_I2C_MSPDEINIT_CB_ID :

        hi2c->MspDeInitCallback = HAL_I2C_MspDeInit;               /* Legacy weak MspDeInit            */

        break;

      default :

        /* Update the error code */

        hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else if (HAL_I2C_STATE_RESET == hi2c->State)

  {

    switch (CallbackID)

    {

      case HAL_I2C_MSPINIT_CB_ID :

        hi2c->MspInitCallback = HAL_I2C_MspInit;                   /* Legacy weak MspInit              */

        break;

      case HAL_I2C_MSPDEINIT_CB_ID :

        hi2c->MspDeInitCallback = HAL_I2C_MspDeInit;               /* Legacy weak MspDeInit            */

        break;

      default :

        /* Update the error code */

        hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else

  {

    /* Update the error code */

    hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;

    /* Return error status */

    status =  HAL_ERROR;

  }

  /* Release Lock */

  __HAL_UNLOCK(hi2c);

  return status;

}

/**

  * @brief  Register the Slave Address Match I2C Callback

  *         To be used instead of the weak HAL_I2C_AddrCallback() predefined callback

  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains

  *                the configuration information for the specified I2C.

  * @param  pCallback pointer to the Address Match Callback function

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_I2C_RegisterAddrCallback(I2C_HandleTypeDef *hi2c, pI2C_AddrCallbackTypeDef pCallback)

{

  HAL_StatusTypeDef status = HAL_OK;

  if (pCallback == NULL)

  {

    /* Update the error code */

    hi2c->ErrorCode |= HAL_I2C_ERROR_INVALID_CALLBACK;