Subversion Repositories ScreenTimer

/**

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

  * @file    stm32f0xx_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 and Errors functions

  *

  @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 Clock Timing, Own Address1, Master Addressing mode, Dual Addressing mode,

        Own Address2, Own Address2 Mask, 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(&hi2c) 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 users can

           add their 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 users can

           add their 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 users can

           add their 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 users can

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

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

           add their 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 users can

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

      (+) Discard a slave I2C process communication using __HAL_I2C_GENERATE_NACK() macro.

           This action will inform Master to generate a Stop condition to discard the communication.

    *** 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 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

                              or HAL_I2C_Master_Seq_Receive_IT

                              or HAL_I2C_Master_Seq_Transmit_DMA

                              or HAL_I2C_Master_Seq_Receive_DMA

                              with 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

                              or HAL_I2C_Master_Seq_Receive_IT

                              or HAL_I2C_Master_Seq_Transmit_DMA

                              or HAL_I2C_Master_Seq_Receive_DMA

                              with 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

            users can add their 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 users can

           add their 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 users can

           add their 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 users can

           add their 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 users can

          add their 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

            users can add their 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 users can

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

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

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

      (++) Discard a slave I2C process communication using __HAL_I2C_GENERATE_NACK() macro.

           This action will inform Master to generate a Stop condition to discard the communication.

    *** 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 users can

           add their 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 users can

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

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

           add their 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 users can

           add their 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 users can

           add their 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 users can

           add their 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 users can

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

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

           add their 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 users can

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

      (+) Discard a slave I2C process communication using __HAL_I2C_GENERATE_NACK() macro.

           This action will inform Master to generate a Stop condition to discard the communication.

    *** 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 users can

           add their 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 users can

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

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

           add their 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_GENERATE_NACK: Generate a Non-Acknowledge I2C peripheral in Slave mode

      (+) __HAL_I2C_GET_FLAG: Check 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.

     [..]

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

  @endverbatim

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

  * @attention

  *

  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.

  * All rights reserved.</center></h2>

  *

  * This software component is licensed by ST under BSD 3-Clause license,

  * the "License"; You may not use this file except in compliance with the

  * License. You may obtain a copy of the License at:

  *                        opensource.org/licenses/BSD-3-Clause

  *

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

  */

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

#include "stm32f0xx_hal.h"

/** @addtogroup STM32F0xx_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 TIMING_CLEAR_MASK   (0xF0FFFFFFU)  /*!< I2C TIMING clear register Mask */

#define I2C_TIMEOUT_ADDR    (10000U)       /*!< 10 s  */

#define I2C_TIMEOUT_BUSY    (25U)          /*!< 25 ms */

#define I2C_TIMEOUT_DIR     (25U)          /*!< 25 ms */

#define I2C_TIMEOUT_RXNE    (25U)          /*!< 25 ms */

#define I2C_TIMEOUT_STOPF   (25U)          /*!< 25 ms */

#define I2C_TIMEOUT_TC      (25U)          /*!< 25 ms */

#define I2C_TIMEOUT_TCR     (25U)          /*!< 25 ms */

#define I2C_TIMEOUT_TXIS    (25U)          /*!< 25 ms */

#define I2C_TIMEOUT_FLAG    (25U)          /*!< 25 ms */

#define MAX_NBYTE_SIZE      255U

#define SLAVE_ADDR_SHIFT     7U

#define SLAVE_ADDR_MSK       0x06U

/* 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  */

#define I2C_STATE_MEM_BUSY_TX     ((uint32_t)(((uint32_t)HAL_I2C_STATE_BUSY_TX & I2C_STATE_MSK) | \

                                              (uint32_t)HAL_I2C_MODE_MEM))

/*!< Memory Busy TX, combinaison of State LSB and Mode enum */

#define I2C_STATE_MEM_BUSY_RX     ((uint32_t)(((uint32_t)HAL_I2C_STATE_BUSY_RX & I2C_STATE_MSK) | \

                                              (uint32_t)HAL_I2C_MODE_MEM))

/*!< Memory Busy RX, combinaison of State LSB and Mode enum */

/* Private define to centralize the enable/disable of Interrupts */

#define I2C_XFER_TX_IT          (uint16_t)(0x0001U)   /*!< Bit field can be combinated with

                                                         @ref I2C_XFER_LISTEN_IT */

#define I2C_XFER_RX_IT          (uint16_t)(0x0002U)   /*!< Bit field can be combinated with

                                                         @ref I2C_XFER_LISTEN_IT */

#define I2C_XFER_LISTEN_IT      (uint16_t)(0x8000U)   /*!< Bit field can be combinated with @ref I2C_XFER_TX_IT

                                                         and @ref I2C_XFER_RX_IT */

#define I2C_XFER_ERROR_IT       (uint16_t)(0x0010U)   /*!< Bit definition to manage addition of global Error

                                                         and NACK treatment */

#define I2C_XFER_CPLT_IT        (uint16_t)(0x0020U)   /*!< Bit definition to manage only STOP evenement */

#define I2C_XFER_RELOAD_IT      (uint16_t)(0x0040U)   /*!< Bit definition to manage only Reload of NBYTE */

/* Private define Sequential Transfer Options default/reset value */

#define I2C_NO_OPTION_FRAME     (0xFFFF0000U)

/**

  * @}

  */

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

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

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

/** @defgroup I2C_Private_Functions I2C Private Functions

  * @{

  */

/* Private functions to handle DMA transfer */

static void I2C_DMAMasterTransmitCplt(DMA_HandleTypeDef *hdma);

static void I2C_DMAMasterReceiveCplt(DMA_HandleTypeDef *hdma);

static void I2C_DMASlaveTransmitCplt(DMA_HandleTypeDef *hdma);

static void I2C_DMASlaveReceiveCplt(DMA_HandleTypeDef *hdma);

static void I2C_DMAError(DMA_HandleTypeDef *hdma);

static void I2C_DMAAbort(DMA_HandleTypeDef *hdma);

/* Private functions to handle IT transfer */

static void I2C_ITAddrCplt(I2C_HandleTypeDef *hi2c, uint32_t ITFlags);

static void I2C_ITMasterSeqCplt(I2C_HandleTypeDef *hi2c);

static void I2C_ITSlaveSeqCplt(I2C_HandleTypeDef *hi2c);

static void I2C_ITMasterCplt(I2C_HandleTypeDef *hi2c, uint32_t ITFlags);

static void I2C_ITSlaveCplt(I2C_HandleTypeDef *hi2c, uint32_t ITFlags);

static void I2C_ITListenCplt(I2C_HandleTypeDef *hi2c, uint32_t ITFlags);

static void I2C_ITError(I2C_HandleTypeDef *hi2c, uint32_t ErrorCode);

/* Private functions to handle IT transfer */

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 for I2C transfer IRQ handler */

static HAL_StatusTypeDef I2C_Master_ISR_IT(struct __I2C_HandleTypeDef *hi2c, uint32_t ITFlags,

                                           uint32_t ITSources);

static HAL_StatusTypeDef I2C_Slave_ISR_IT(struct __I2C_HandleTypeDef *hi2c, uint32_t ITFlags,

                                          uint32_t ITSources);

static HAL_StatusTypeDef I2C_Master_ISR_DMA(struct __I2C_HandleTypeDef *hi2c, uint32_t ITFlags,

                                            uint32_t ITSources);

static HAL_StatusTypeDef I2C_Slave_ISR_DMA(struct __I2C_HandleTypeDef *hi2c, uint32_t ITFlags,

                                           uint32_t ITSources);

/* 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_WaitOnTXISFlagUntilTimeout(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_IsAcknowledgeFailed(I2C_HandleTypeDef *hi2c, uint32_t Timeout,

                                                 uint32_t Tickstart);

/* Private functions to centralize the enable/disable of Interrupts */

static void I2C_Enable_IRQ(I2C_HandleTypeDef *hi2c, uint16_t InterruptRequest);

static void I2C_Disable_IRQ(I2C_HandleTypeDef *hi2c, uint16_t InterruptRequest);

/* Private function to treat different error callback */

static void I2C_TreatErrorCallback(I2C_HandleTypeDef *hi2c);

/* Private function to flush TXDR register */

static void I2C_Flush_TXDR(I2C_HandleTypeDef *hi2c);

/* Private function to handle  start, restart or stop a transfer */

static void I2C_TransferConfig(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t Size, uint32_t Mode,

                               uint32_t Request);

/* Private function to Convert Specific options */

static void I2C_ConvertOtherXferOptions(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:

        (++) Clock Timing

        (++) Own Address 1

        (++) Addressing mode (Master, Slave)

        (++) Dual Addressing mode

        (++) Own Address 2

        (++) Own Address 2 Mask

        (++) 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)

{

  /* 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_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_OWN_ADDRESS2_MASK(hi2c->Init.OwnAddress2Masks));

  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, CORTEX...etc */

    hi2c->MspInitCallback(hi2c);

#else

    /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */

    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);

  /*---------------------------- I2Cx TIMINGR Configuration ------------------*/

  /* Configure I2Cx: Frequency range */

  hi2c->Instance->TIMINGR = hi2c->Init.Timing & TIMING_CLEAR_MASK;

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

  /* Disable Own Address1 before set the Own Address1 configuration */

  hi2c->Instance->OAR1 &= ~I2C_OAR1_OA1EN;

  /* Configure I2Cx: Own Address1 and ack own address1 mode */

  if (hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_7BIT)

  {

    hi2c->Instance->OAR1 = (I2C_OAR1_OA1EN | hi2c->Init.OwnAddress1);

  }

  else /* I2C_ADDRESSINGMODE_10BIT */

  {

    hi2c->Instance->OAR1 = (I2C_OAR1_OA1EN | I2C_OAR1_OA1MODE | hi2c->Init.OwnAddress1);

  }

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

  /* Configure I2Cx: Addressing Master mode */

  if (hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)

  {

    hi2c->Instance->CR2 = (I2C_CR2_ADD10);

  }

  /* Enable the AUTOEND by default, and enable NACK (should be disable only during Slave process */

  hi2c->Instance->CR2 |= (I2C_CR2_AUTOEND | I2C_CR2_NACK);

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

  /* Disable Own Address2 before set the Own Address2 configuration */

  hi2c->Instance->OAR2 &= ~I2C_DUALADDRESS_ENABLE;

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

  hi2c->Instance->OAR2 = (hi2c->Init.DualAddressMode | hi2c->Init.OwnAddress2 | \

                          (hi2c->Init.OwnAddress2Masks << 8));

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

  /* Configure I2Cx: Generalcall and NoStretch mode */

  hi2c->Instance->CR1 = (hi2c->Init.GeneralCallMode | hi2c->Init.NoStretchMode);

  /* 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 :