mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_fmpi2c.c@613:bc40b8d2aec4, 2015-08-20 (annotated)

Committer:
mbed_official
Date:
Thu Aug 20 10:45:13 2015 +0100
Revision:
613:bc40b8d2aec4
Parent:
532:fe11edbda85c 
Synchronized with git revision 92ca8c7b60a283b6bb60eb65b183dac1599f0ade



Full URL: https://github.com/mbedmicro/mbed/commit/92ca8c7b60a283b6bb60eb65b183dac1599f0ade/



Nordic: update application start address in GCC linker script

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 532:fe11edbda85c 1 /**
mbed_official 532:fe11edbda85c 2 ******************************************************************************
mbed_official 532:fe11edbda85c 3 * @file stm32f4xx_hal_fmpi2c.c
mbed_official 532:fe11edbda85c 4 * @author MCD Application Team
mbed_official 613:bc40b8d2aec4 5 * @version V1.3.2
mbed_official 613:bc40b8d2aec4 6 * @date 26-June-2015
mbed_official 532:fe11edbda85c 7 * @brief FMPI2C HAL module driver.
mbed_official 532:fe11edbda85c 8 *
mbed_official 532:fe11edbda85c 9 * This file provides firmware functions to manage the following
mbed_official 532:fe11edbda85c 10 * functionalities of the Inter Integrated Circuit (FMPI2C) peripheral:
mbed_official 532:fe11edbda85c 11 * + Initialization and de-initialization functions
mbed_official 532:fe11edbda85c 12 * + IO operation functions
mbed_official 532:fe11edbda85c 13 * + Peripheral State functions
mbed_official 532:fe11edbda85c 14 *
mbed_official 532:fe11edbda85c 15 @verbatim
mbed_official 532:fe11edbda85c 16 ==============================================================================
mbed_official 532:fe11edbda85c 17 ##### How to use this driver #####
mbed_official 532:fe11edbda85c 18 ==============================================================================
mbed_official 532:fe11edbda85c 19 [..]
mbed_official 532:fe11edbda85c 20 The FMPI2C HAL driver can be used as follows:
mbed_official 532:fe11edbda85c 21
mbed_official 532:fe11edbda85c 22 (#) Declare a FMPI2C_HandleTypeDef handle structure, for example:
mbed_official 532:fe11edbda85c 23 FMPI2C_HandleTypeDef hfmpi2c;
mbed_official 532:fe11edbda85c 24
mbed_official 532:fe11edbda85c 25 (#)Initialize the FMPI2C low level resources by implement the HAL_FMPI2C_MspInit ()API:
mbed_official 532:fe11edbda85c 26 (##) Enable the FMPI2Cx interface clock
mbed_official 532:fe11edbda85c 27 (##) FMPI2C pins configuration
mbed_official 532:fe11edbda85c 28 (+++) Enable the clock for the FMPI2C GPIOs
mbed_official 532:fe11edbda85c 29 (+++) Configure FMPI2C pins as alternate function open-drain
mbed_official 532:fe11edbda85c 30 (##) NVIC configuration if you need to use interrupt process
mbed_official 532:fe11edbda85c 31 (+++) Configure the FMPI2Cx interrupt priority
mbed_official 532:fe11edbda85c 32 (+++) Enable the NVIC FMPI2C IRQ Channel
mbed_official 532:fe11edbda85c 33 (##) DMA Configuration if you need to use DMA process
mbed_official 532:fe11edbda85c 34 (+++) Declare a DMA_HandleTypeDef handle structure for the transmit or receive stream
mbed_official 532:fe11edbda85c 35 (+++) Enable the DMAx interface clock using
mbed_official 532:fe11edbda85c 36 (+++) Configure the DMA handle parameters
mbed_official 532:fe11edbda85c 37 (+++) Configure the DMA Tx or Rx Stream
mbed_official 532:fe11edbda85c 38 (+++) Associate the initilalized DMA handle to the hfmpi2c DMA Tx or Rx handle
mbed_official 532:fe11edbda85c 39 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx or Rx Stream
mbed_official 532:fe11edbda85c 40
mbed_official 532:fe11edbda85c 41 (#) Configure the Communication Clock Timing, Own Address1, Master Adressing Mode, Dual Addressing mode,
mbed_official 532:fe11edbda85c 42 Own Address2, Own Address2 Mask, General call and Nostretch mode in the hfmpi2c Init structure.
mbed_official 532:fe11edbda85c 43
mbed_official 532:fe11edbda85c 44 (#) Initialize the FMPI2C registers by calling the HAL_FMPI2C_Init() API:
mbed_official 532:fe11edbda85c 45 (+++) These API's configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
mbed_official 532:fe11edbda85c 46 by calling the customed HAL_FMPI2C_MspInit(&hfmpi2c) API.
mbed_official 532:fe11edbda85c 47
mbed_official 532:fe11edbda85c 48 (#) To check if target device is ready for communication, use the function HAL_FMPI2C_IsDeviceReady()
mbed_official 532:fe11edbda85c 49
mbed_official 532:fe11edbda85c 50 (#) For FMPI2C IO and IO MEM operations, three mode of operations are available within this driver :
mbed_official 532:fe11edbda85c 51
mbed_official 532:fe11edbda85c 52 *** Polling mode IO operation ***
mbed_official 532:fe11edbda85c 53 =================================
mbed_official 532:fe11edbda85c 54 [..]
mbed_official 532:fe11edbda85c 55 (+) Transmit in master mode an amount of data in blocking mode using HAL_FMPI2C_Master_Transmit()
mbed_official 532:fe11edbda85c 56 (+) Receive in master mode an amount of data in blocking mode using HAL_FMPI2C_Master_Receive()
mbed_official 532:fe11edbda85c 57 (+) Transmit in slave mode an amount of data in blocking mode using HAL_FMPI2C_Slave_Transmit()
mbed_official 532:fe11edbda85c 58 (+) Receive in slave mode an amount of data in blocking mode using HAL_FMPI2C_Slave_Receive()
mbed_official 532:fe11edbda85c 59
mbed_official 532:fe11edbda85c 60 *** Polling mode IO MEM operation ***
mbed_official 532:fe11edbda85c 61 =====================================
mbed_official 532:fe11edbda85c 62 [..]
mbed_official 532:fe11edbda85c 63 (+) Write an amount of data in blocking mode to a specific memory address using HAL_FMPI2C_Mem_Write()
mbed_official 532:fe11edbda85c 64 (+) Read an amount of data in blocking mode from a specific memory address using HAL_FMPI2C_Mem_Read()
mbed_official 532:fe11edbda85c 65
mbed_official 532:fe11edbda85c 66
mbed_official 532:fe11edbda85c 67 *** Interrupt mode IO operation ***
mbed_official 532:fe11edbda85c 68 ===================================
mbed_official 532:fe11edbda85c 69 [..]
mbed_official 532:fe11edbda85c 70 (+) Transmit in master mode an amount of data in non blocking mode using HAL_FMPI2C_Master_Transmit_IT()
mbed_official 532:fe11edbda85c 71 (+) At transmission end of transfer HAL_FMPI2C_MasterTxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 72 add his own code by customization of function pointer HAL_FMPI2C_MasterTxCpltCallback
mbed_official 532:fe11edbda85c 73 (+) Receive in master mode an amount of data in non blocking mode using HAL_FMPI2C_Master_Receive_IT()
mbed_official 532:fe11edbda85c 74 (+) At reception end of transfer HAL_FMPI2C_MasterRxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 75 add his own code by customization of function pointer HAL_FMPI2C_MasterRxCpltCallback
mbed_official 532:fe11edbda85c 76 (+) Transmit in slave mode an amount of data in non blocking mode using HAL_FMPI2C_Slave_Transmit_IT()
mbed_official 532:fe11edbda85c 77 (+) At transmission end of transfer HAL_FMPI2C_SlaveTxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 78 add his own code by customization of function pointer HAL_FMPI2C_SlaveTxCpltCallback
mbed_official 532:fe11edbda85c 79 (+) Receive in slave mode an amount of data in non blocking mode using HAL_FMPI2C_Slave_Receive_IT()
mbed_official 532:fe11edbda85c 80 (+) At reception end of transfer HAL_FMPI2C_SlaveRxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 81 add his own code by customization of function pointer HAL_FMPI2C_SlaveRxCpltCallback
mbed_official 532:fe11edbda85c 82 (+) In case of transfer Error, HAL_FMPI2C_ErrorCallback() function is executed and user can
mbed_official 532:fe11edbda85c 83 add his own code by customization of function pointer HAL_FMPI2C_ErrorCallback
mbed_official 532:fe11edbda85c 84
mbed_official 532:fe11edbda85c 85 *** Interrupt mode IO MEM operation ***
mbed_official 532:fe11edbda85c 86 =======================================
mbed_official 532:fe11edbda85c 87 [..]
mbed_official 532:fe11edbda85c 88 (+) Write an amount of data in no-blocking mode with Interrupt to a specific memory address using
mbed_official 532:fe11edbda85c 89 HAL_FMPI2C_Mem_Write_IT()
mbed_official 532:fe11edbda85c 90 (+) At MEM end of write transfer HAL_FMPI2C_MemTxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 91 add his own code by customization of function pointer HAL_FMPI2C_MemTxCpltCallback
mbed_official 532:fe11edbda85c 92 (+) Read an amount of data in no-blocking mode with Interrupt from a specific memory address using
mbed_official 532:fe11edbda85c 93 HAL_FMPI2C_Mem_Read_IT()
mbed_official 532:fe11edbda85c 94 (+) At MEM end of read transfer HAL_FMPI2C_MemRxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 95 add his own code by customization of function pointer HAL_FMPI2C_MemRxCpltCallback
mbed_official 532:fe11edbda85c 96 (+) In case of transfer Error, HAL_FMPI2C_ErrorCallback() function is executed and user can
mbed_official 532:fe11edbda85c 97 add his own code by customization of function pointer HAL_FMPI2C_ErrorCallback
mbed_official 532:fe11edbda85c 98
mbed_official 532:fe11edbda85c 99 *** DMA mode IO operation ***
mbed_official 532:fe11edbda85c 100 ==============================
mbed_official 532:fe11edbda85c 101 [..]
mbed_official 532:fe11edbda85c 102 (+) Transmit in master mode an amount of data in non blocking mode (DMA) using
mbed_official 532:fe11edbda85c 103 HAL_FMPI2C_Master_Transmit_DMA()
mbed_official 532:fe11edbda85c 104 (+) At transmission end of transfer HAL_FMPI2C_MasterTxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 105 add his own code by customization of function pointer HAL_FMPI2C_MasterTxCpltCallback
mbed_official 532:fe11edbda85c 106 (+) Receive in master mode an amount of data in non blocking mode (DMA) using
mbed_official 532:fe11edbda85c 107 HAL_FMPI2C_Master_Receive_DMA()
mbed_official 532:fe11edbda85c 108 (+) At reception end of transfer HAL_FMPI2C_MasterRxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 109 add his own code by customization of function pointer HAL_FMPI2C_MasterRxCpltCallback
mbed_official 532:fe11edbda85c 110 (+) Transmit in slave mode an amount of data in non blocking mode (DMA) using
mbed_official 532:fe11edbda85c 111 HAL_FMPI2C_Slave_Transmit_DMA()
mbed_official 532:fe11edbda85c 112 (+) At transmission end of transfer HAL_FMPI2C_SlaveTxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 113 add his own code by customization of function pointer HAL_FMPI2C_SlaveTxCpltCallback
mbed_official 532:fe11edbda85c 114 (+) Receive in slave mode an amount of data in non blocking mode (DMA) using
mbed_official 532:fe11edbda85c 115 HAL_FMPI2C_Slave_Receive_DMA()
mbed_official 532:fe11edbda85c 116 (+) At reception end of transfer HAL_FMPI2C_SlaveRxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 117 add his own code by customization of function pointer HAL_FMPI2C_SlaveRxCpltCallback
mbed_official 532:fe11edbda85c 118 (+) In case of transfer Error, HAL_FMPI2C_ErrorCallback() function is executed and user can
mbed_official 532:fe11edbda85c 119 add his own code by customization of function pointer HAL_FMPI2C_ErrorCallback
mbed_official 532:fe11edbda85c 120
mbed_official 532:fe11edbda85c 121 *** DMA mode IO MEM operation ***
mbed_official 532:fe11edbda85c 122 =================================
mbed_official 532:fe11edbda85c 123 [..]
mbed_official 532:fe11edbda85c 124 (+) Write an amount of data in no-blocking mode with DMA to a specific memory address using
mbed_official 532:fe11edbda85c 125 HAL_FMPI2C_Mem_Write_DMA()
mbed_official 532:fe11edbda85c 126 (+) At MEM end of write transfer HAL_FMPI2C_MemTxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 127 add his own code by customization of function pointer HAL_FMPI2C_MemTxCpltCallback
mbed_official 532:fe11edbda85c 128 (+) Read an amount of data in no-blocking mode with DMA from a specific memory address using
mbed_official 532:fe11edbda85c 129 HAL_FMPI2C_Mem_Read_DMA()
mbed_official 532:fe11edbda85c 130 (+) At MEM end of read transfer HAL_FMPI2C_MemRxCpltCallback is executed and user can
mbed_official 532:fe11edbda85c 131 add his own code by customization of function pointer HAL_FMPI2C_MemRxCpltCallback
mbed_official 532:fe11edbda85c 132 (+) In case of transfer Error, HAL_FMPI2C_ErrorCallback() function is executed and user can
mbed_official 532:fe11edbda85c 133 add his own code by customization of function pointer HAL_FMPI2C_ErrorCallback
mbed_official 532:fe11edbda85c 134
mbed_official 532:fe11edbda85c 135
mbed_official 532:fe11edbda85c 136 *** FMPI2C HAL driver macros list ***
mbed_official 532:fe11edbda85c 137 ==================================
mbed_official 532:fe11edbda85c 138 [..]
mbed_official 532:fe11edbda85c 139 Below the list of most used macros in FMPI2C HAL driver.
mbed_official 532:fe11edbda85c 140
mbed_official 532:fe11edbda85c 141 (+) __HAL_FMPI2C_ENABLE: Enable the FMPI2C peripheral
mbed_official 532:fe11edbda85c 142 (+) __HAL_FMPI2C_DISABLE: Disable the FMPI2C peripheral
mbed_official 532:fe11edbda85c 143 (+) __HAL_FMPI2C_GET_FLAG : Checks whether the specified FMPI2C flag is set or not
mbed_official 532:fe11edbda85c 144 (+) __HAL_FMPI2C_CLEAR_FLAG : Clears the specified FMPI2C pending flag
mbed_official 532:fe11edbda85c 145 (+) __HAL_FMPI2C_ENABLE_IT: Enables the specified FMPI2C interrupt
mbed_official 532:fe11edbda85c 146 (+) __HAL_FMPI2C_DISABLE_IT: Disables the specified FMPI2C interrupt
mbed_official 532:fe11edbda85c 147
mbed_official 532:fe11edbda85c 148 [..]
mbed_official 532:fe11edbda85c 149 (@) You can refer to the FMPI2C HAL driver header file for more useful macros
mbed_official 532:fe11edbda85c 150
mbed_official 532:fe11edbda85c 151 @endverbatim
mbed_official 532:fe11edbda85c 152 ******************************************************************************
mbed_official 532:fe11edbda85c 153 * @attention
mbed_official 532:fe11edbda85c 154 *
mbed_official 532:fe11edbda85c 155 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 532:fe11edbda85c 156 *
mbed_official 532:fe11edbda85c 157 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 532:fe11edbda85c 158 * are permitted provided that the following conditions are met:
mbed_official 532:fe11edbda85c 159 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 532:fe11edbda85c 160 * this list of conditions and the following disclaimer.
mbed_official 532:fe11edbda85c 161 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 532:fe11edbda85c 162 * this list of conditions and the following disclaimer in the documentation
mbed_official 532:fe11edbda85c 163 * and/or other materials provided with the distribution.
mbed_official 532:fe11edbda85c 164 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 532:fe11edbda85c 165 * may be used to endorse or promote products derived from this software
mbed_official 532:fe11edbda85c 166 * without specific prior written permission.
mbed_official 532:fe11edbda85c 167 *
mbed_official 532:fe11edbda85c 168 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 532:fe11edbda85c 169 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 532:fe11edbda85c 170 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 532:fe11edbda85c 171 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 532:fe11edbda85c 172 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 532:fe11edbda85c 173 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 532:fe11edbda85c 174 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 532:fe11edbda85c 175 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 532:fe11edbda85c 176 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 532:fe11edbda85c 177 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 532:fe11edbda85c 178 *
mbed_official 532:fe11edbda85c 179 ******************************************************************************
mbed_official 532:fe11edbda85c 180 */
mbed_official 532:fe11edbda85c 181
mbed_official 532:fe11edbda85c 182 /* Includes ------------------------------------------------------------------*/
mbed_official 532:fe11edbda85c 183 #include "stm32f4xx_hal.h"
mbed_official 532:fe11edbda85c 184
mbed_official 532:fe11edbda85c 185 /** @addtogroup STM32F4xx_HAL_Driver
mbed_official 532:fe11edbda85c 186 * @{
mbed_official 532:fe11edbda85c 187 */
mbed_official 532:fe11edbda85c 188
mbed_official 532:fe11edbda85c 189 /** @defgroup FMPI2C FMPI2C
mbed_official 532:fe11edbda85c 190 * @brief FMPI2C HAL module driver
mbed_official 532:fe11edbda85c 191 * @{
mbed_official 532:fe11edbda85c 192 */
mbed_official 532:fe11edbda85c 193
mbed_official 532:fe11edbda85c 194 #ifdef HAL_FMPI2C_MODULE_ENABLED
mbed_official 532:fe11edbda85c 195
mbed_official 532:fe11edbda85c 196 #if defined(STM32F446xx)
mbed_official 532:fe11edbda85c 197
mbed_official 532:fe11edbda85c 198 /* Private typedef -----------------------------------------------------------*/
mbed_official 532:fe11edbda85c 199 /* Private define ------------------------------------------------------------*/
mbed_official 532:fe11edbda85c 200 /** @addtogroup FMPI2C_Private_Constants
mbed_official 532:fe11edbda85c 201 * @{
mbed_official 532:fe11edbda85c 202 */
mbed_official 532:fe11edbda85c 203 #define TIMING_CLEAR_MASK ((uint32_t)0xF0FFFFFF) /*<! FMPI2C TIMING clear register Mask */
mbed_official 532:fe11edbda85c 204 #define FMPI2C_TIMEOUT_ADDR ((uint32_t)10000) /* 10 s */
mbed_official 532:fe11edbda85c 205 #define FMPI2C_TIMEOUT_BUSY ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 206 #define FMPI2C_TIMEOUT_DIR ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 207 #define FMPI2C_TIMEOUT_RXNE ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 208 #define FMPI2C_TIMEOUT_STOPF ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 209 #define FMPI2C_TIMEOUT_TC ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 210 #define FMPI2C_TIMEOUT_TCR ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 211 #define FMPI2C_TIMEOUT_TXIS ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 212 #define FMPI2C_TIMEOUT_FLAG ((uint32_t)25) /* 25 ms */
mbed_official 532:fe11edbda85c 213 /**
mbed_official 532:fe11edbda85c 214 * @}
mbed_official 532:fe11edbda85c 215 */
mbed_official 532:fe11edbda85c 216
mbed_official 532:fe11edbda85c 217 /* Private macro -------------------------------------------------------------*/
mbed_official 532:fe11edbda85c 218 /* Private variables ---------------------------------------------------------*/
mbed_official 532:fe11edbda85c 219 /* Private function prototypes -----------------------------------------------*/
mbed_official 532:fe11edbda85c 220 /** @addtogroup FMPI2C_Private_Functions
mbed_official 532:fe11edbda85c 221 * @brief FMPI2C private functions
mbed_official 532:fe11edbda85c 222 * @{
mbed_official 532:fe11edbda85c 223 */
mbed_official 532:fe11edbda85c 224 static void FMPI2C_DMAMasterTransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 532:fe11edbda85c 225 static void FMPI2C_DMAMasterReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 532:fe11edbda85c 226 static void FMPI2C_DMASlaveTransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 532:fe11edbda85c 227 static void FMPI2C_DMASlaveReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 532:fe11edbda85c 228 static void FMPI2C_DMAMemTransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 532:fe11edbda85c 229 static void FMPI2C_DMAMemReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 532:fe11edbda85c 230 static void FMPI2C_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 532:fe11edbda85c 231
mbed_official 532:fe11edbda85c 232 static HAL_StatusTypeDef FMPI2C_RequestMemoryWrite(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout);
mbed_official 532:fe11edbda85c 233 static HAL_StatusTypeDef FMPI2C_RequestMemoryRead(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout);
mbed_official 532:fe11edbda85c 234 static HAL_StatusTypeDef FMPI2C_WaitOnFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
mbed_official 532:fe11edbda85c 235 static HAL_StatusTypeDef FMPI2C_WaitOnTXISFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout);
mbed_official 532:fe11edbda85c 236 static HAL_StatusTypeDef FMPI2C_WaitOnRXNEFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout);
mbed_official 532:fe11edbda85c 237 static HAL_StatusTypeDef FMPI2C_WaitOnSTOPFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout);
mbed_official 532:fe11edbda85c 238 static HAL_StatusTypeDef FMPI2C_IsAcknowledgeFailed(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout);
mbed_official 532:fe11edbda85c 239
mbed_official 532:fe11edbda85c 240 static HAL_StatusTypeDef FMPI2C_MasterTransmit_ISR(FMPI2C_HandleTypeDef *hfmpi2c);
mbed_official 532:fe11edbda85c 241 static HAL_StatusTypeDef FMPI2C_MasterReceive_ISR(FMPI2C_HandleTypeDef *hfmpi2c);
mbed_official 532:fe11edbda85c 242
mbed_official 532:fe11edbda85c 243 static HAL_StatusTypeDef FMPI2C_SlaveTransmit_ISR(FMPI2C_HandleTypeDef *hfmpi2c);
mbed_official 532:fe11edbda85c 244 static HAL_StatusTypeDef FMPI2C_SlaveReceive_ISR(FMPI2C_HandleTypeDef *hfmpi2c);
mbed_official 532:fe11edbda85c 245
mbed_official 532:fe11edbda85c 246 static void FMPI2C_TransferConfig(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request);
mbed_official 532:fe11edbda85c 247 /**
mbed_official 532:fe11edbda85c 248 * @}
mbed_official 532:fe11edbda85c 249 */
mbed_official 532:fe11edbda85c 250
mbed_official 532:fe11edbda85c 251 /* Exported functions --------------------------------------------------------*/
mbed_official 532:fe11edbda85c 252 /** @defgroup FMPI2C_Exported_Functions FMPI2C Exported Functions
mbed_official 532:fe11edbda85c 253 * @{
mbed_official 532:fe11edbda85c 254 */
mbed_official 532:fe11edbda85c 255
mbed_official 532:fe11edbda85c 256 /** @defgroup FMPI2C_Exported_Functions_Group1 Initialization/de-initialization functions
mbed_official 532:fe11edbda85c 257 * @brief Initialization and Configuration functions
mbed_official 532:fe11edbda85c 258 *
mbed_official 532:fe11edbda85c 259 @verbatim
mbed_official 532:fe11edbda85c 260 ===============================================================================
mbed_official 532:fe11edbda85c 261 ##### Initialization/de-initialization functions #####
mbed_official 532:fe11edbda85c 262 ===============================================================================
mbed_official 532:fe11edbda85c 263 [..] This subsection provides a set of functions allowing to initialize and
mbed_official 532:fe11edbda85c 264 de-initialiaze the FMPI2Cx peripheral:
mbed_official 532:fe11edbda85c 265
mbed_official 532:fe11edbda85c 266 (+) User must Implement HAL_FMPI2C_MspInit() function in which he configures
mbed_official 532:fe11edbda85c 267 all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC ).
mbed_official 532:fe11edbda85c 268
mbed_official 532:fe11edbda85c 269 (+) Call the function HAL_FMPI2C_Init() to configure the selected device with
mbed_official 532:fe11edbda85c 270 the selected configuration:
mbed_official 532:fe11edbda85c 271 (++) Clock Timing
mbed_official 532:fe11edbda85c 272 (++) Own Address 1
mbed_official 532:fe11edbda85c 273 (++) Addressing mode (Master, Slave)
mbed_official 532:fe11edbda85c 274 (++) Dual Addressing mode
mbed_official 532:fe11edbda85c 275 (++) Own Address 2
mbed_official 532:fe11edbda85c 276 (++) Own Address 2 Mask
mbed_official 532:fe11edbda85c 277 (++) General call mode
mbed_official 532:fe11edbda85c 278 (++) Nostretch mode
mbed_official 532:fe11edbda85c 279
mbed_official 532:fe11edbda85c 280 (+) Call the function HAL_FMPI2C_DeInit() to restore the default configuration
mbed_official 532:fe11edbda85c 281 of the selected FMPI2Cx periperal.
mbed_official 532:fe11edbda85c 282
mbed_official 532:fe11edbda85c 283 @endverbatim
mbed_official 532:fe11edbda85c 284 * @{
mbed_official 532:fe11edbda85c 285 */
mbed_official 532:fe11edbda85c 286
mbed_official 532:fe11edbda85c 287 /**
mbed_official 532:fe11edbda85c 288 * @brief Initializes the FMPI2C according to the specified parameters
mbed_official 532:fe11edbda85c 289 * in the FMPI2C_InitTypeDef and create the associated handle.
mbed_official 532:fe11edbda85c 290 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 291 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 292 * @retval HAL status
mbed_official 532:fe11edbda85c 293 */
mbed_official 532:fe11edbda85c 294 HAL_StatusTypeDef HAL_FMPI2C_Init(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 295 {
mbed_official 532:fe11edbda85c 296 /* Check the FMPI2C handle allocation */
mbed_official 532:fe11edbda85c 297 if(hfmpi2c == NULL)
mbed_official 532:fe11edbda85c 298 {
mbed_official 532:fe11edbda85c 299 return HAL_ERROR;
mbed_official 532:fe11edbda85c 300 }
mbed_official 532:fe11edbda85c 301
mbed_official 532:fe11edbda85c 302 /* Check the parameters */
mbed_official 532:fe11edbda85c 303 assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance));
mbed_official 532:fe11edbda85c 304 assert_param(IS_FMPI2C_OWN_ADDRESS1(hfmpi2c->Init.OwnAddress1));
mbed_official 532:fe11edbda85c 305 assert_param(IS_FMPI2C_ADDRESSING_MODE(hfmpi2c->Init.AddressingMode));
mbed_official 532:fe11edbda85c 306 assert_param(IS_FMPI2C_DUAL_ADDRESS(hfmpi2c->Init.DualAddressMode));
mbed_official 532:fe11edbda85c 307 assert_param(IS_FMPI2C_OWN_ADDRESS2(hfmpi2c->Init.OwnAddress2));
mbed_official 532:fe11edbda85c 308 assert_param(IS_FMPI2C_OWN_ADDRESS2_MASK(hfmpi2c->Init.OwnAddress2Masks));
mbed_official 532:fe11edbda85c 309 assert_param(IS_FMPI2C_GENERAL_CALL(hfmpi2c->Init.GeneralCallMode));
mbed_official 532:fe11edbda85c 310 assert_param(IS_FMPI2C_NO_STRETCH(hfmpi2c->Init.NoStretchMode));
mbed_official 532:fe11edbda85c 311
mbed_official 532:fe11edbda85c 312 if(hfmpi2c->State == HAL_FMPI2C_STATE_RESET)
mbed_official 532:fe11edbda85c 313 {
mbed_official 532:fe11edbda85c 314 /* Allocate lock resource and initialize it */
mbed_official 532:fe11edbda85c 315 hfmpi2c->Lock = HAL_UNLOCKED;
mbed_official 532:fe11edbda85c 316 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
mbed_official 532:fe11edbda85c 317 HAL_FMPI2C_MspInit(hfmpi2c);
mbed_official 532:fe11edbda85c 318 }
mbed_official 532:fe11edbda85c 319
mbed_official 532:fe11edbda85c 320 hfmpi2c->State = HAL_FMPI2C_STATE_BUSY;
mbed_official 532:fe11edbda85c 321
mbed_official 532:fe11edbda85c 322 /* Disable the selected FMPI2C peripheral */
mbed_official 532:fe11edbda85c 323 __HAL_FMPI2C_DISABLE(hfmpi2c);
mbed_official 532:fe11edbda85c 324
mbed_official 532:fe11edbda85c 325 /*---------------------------- FMPI2Cx TIMINGR Configuration ------------------*/
mbed_official 532:fe11edbda85c 326 /* Configure FMPI2Cx: Frequency range */
mbed_official 532:fe11edbda85c 327 hfmpi2c->Instance->TIMINGR = hfmpi2c->Init.Timing & TIMING_CLEAR_MASK;
mbed_official 532:fe11edbda85c 328
mbed_official 532:fe11edbda85c 329 /*---------------------------- FMPI2Cx OAR1 Configuration ---------------------*/
mbed_official 532:fe11edbda85c 330 /* Configure FMPI2Cx: Own Address1 and ack own address1 mode */
mbed_official 532:fe11edbda85c 331 hfmpi2c->Instance->OAR1 &= ~FMPI2C_OAR1_OA1EN;
mbed_official 532:fe11edbda85c 332 if(hfmpi2c->Init.OwnAddress1 != 0)
mbed_official 532:fe11edbda85c 333 {
mbed_official 532:fe11edbda85c 334 if(hfmpi2c->Init.AddressingMode == FMPI2C_ADDRESSINGMODE_7BIT)
mbed_official 532:fe11edbda85c 335 {
mbed_official 532:fe11edbda85c 336 hfmpi2c->Instance->OAR1 = (FMPI2C_OAR1_OA1EN | hfmpi2c->Init.OwnAddress1);
mbed_official 532:fe11edbda85c 337 }
mbed_official 532:fe11edbda85c 338 else /* FMPI2C_ADDRESSINGMODE_10BIT */
mbed_official 532:fe11edbda85c 339 {
mbed_official 532:fe11edbda85c 340 hfmpi2c->Instance->OAR1 = (FMPI2C_OAR1_OA1EN | FMPI2C_OAR1_OA1MODE | hfmpi2c->Init.OwnAddress1);
mbed_official 532:fe11edbda85c 341 }
mbed_official 532:fe11edbda85c 342 }
mbed_official 532:fe11edbda85c 343
mbed_official 532:fe11edbda85c 344 /*---------------------------- FMPI2Cx CR2 Configuration ----------------------*/
mbed_official 532:fe11edbda85c 345 /* Configure FMPI2Cx: Addressing Master mode */
mbed_official 532:fe11edbda85c 346 if(hfmpi2c->Init.AddressingMode == FMPI2C_ADDRESSINGMODE_10BIT)
mbed_official 532:fe11edbda85c 347 {
mbed_official 532:fe11edbda85c 348 hfmpi2c->Instance->CR2 = (FMPI2C_CR2_ADD10);
mbed_official 532:fe11edbda85c 349 }
mbed_official 532:fe11edbda85c 350 /* Enable the AUTOEND by default, and enable NACK (should be disable only during Slave process */
mbed_official 532:fe11edbda85c 351 hfmpi2c->Instance->CR2 |= (FMPI2C_CR2_AUTOEND | FMPI2C_CR2_NACK);
mbed_official 532:fe11edbda85c 352
mbed_official 532:fe11edbda85c 353 /*---------------------------- FMPI2Cx OAR2 Configuration ---------------------*/
mbed_official 532:fe11edbda85c 354 /* Configure FMPI2Cx: Dual mode and Own Address2 */
mbed_official 532:fe11edbda85c 355 hfmpi2c->Instance->OAR2 = (hfmpi2c->Init.DualAddressMode | hfmpi2c->Init.OwnAddress2 | (hfmpi2c->Init.OwnAddress2Masks << 8));
mbed_official 532:fe11edbda85c 356
mbed_official 532:fe11edbda85c 357 /*---------------------------- FMPI2Cx CR1 Configuration ----------------------*/
mbed_official 532:fe11edbda85c 358 /* Configure FMPI2Cx: Generalcall and NoStretch mode */
mbed_official 532:fe11edbda85c 359 hfmpi2c->Instance->CR1 = (hfmpi2c->Init.GeneralCallMode | hfmpi2c->Init.NoStretchMode);
mbed_official 532:fe11edbda85c 360
mbed_official 532:fe11edbda85c 361 /* Enable the selected FMPI2C peripheral */
mbed_official 532:fe11edbda85c 362 __HAL_FMPI2C_ENABLE(hfmpi2c);
mbed_official 532:fe11edbda85c 363
mbed_official 532:fe11edbda85c 364 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 365 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 366
mbed_official 532:fe11edbda85c 367 return HAL_OK;
mbed_official 532:fe11edbda85c 368 }
mbed_official 532:fe11edbda85c 369
mbed_official 532:fe11edbda85c 370 /**
mbed_official 532:fe11edbda85c 371 * @brief DeInitializes the FMPI2C peripheral.
mbed_official 532:fe11edbda85c 372 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 373 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 374 * @retval HAL status
mbed_official 532:fe11edbda85c 375 */
mbed_official 532:fe11edbda85c 376 HAL_StatusTypeDef HAL_FMPI2C_DeInit(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 377 {
mbed_official 532:fe11edbda85c 378 /* Check the FMPI2C handle allocation */
mbed_official 532:fe11edbda85c 379 if(hfmpi2c == NULL)
mbed_official 532:fe11edbda85c 380 {
mbed_official 532:fe11edbda85c 381 return HAL_ERROR;
mbed_official 532:fe11edbda85c 382 }
mbed_official 532:fe11edbda85c 383
mbed_official 532:fe11edbda85c 384 /* Check the parameters */
mbed_official 532:fe11edbda85c 385 assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance));
mbed_official 532:fe11edbda85c 386
mbed_official 532:fe11edbda85c 387 hfmpi2c->State = HAL_FMPI2C_STATE_BUSY;
mbed_official 532:fe11edbda85c 388
mbed_official 532:fe11edbda85c 389 /* Disable the FMPI2C Peripheral Clock */
mbed_official 532:fe11edbda85c 390 __HAL_FMPI2C_DISABLE(hfmpi2c);
mbed_official 532:fe11edbda85c 391
mbed_official 532:fe11edbda85c 392 /* DeInit the low level hardware: GPIO, CLOCK, NVIC */
mbed_official 532:fe11edbda85c 393 HAL_FMPI2C_MspDeInit(hfmpi2c);
mbed_official 532:fe11edbda85c 394
mbed_official 532:fe11edbda85c 395 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 396 hfmpi2c->State = HAL_FMPI2C_STATE_RESET;
mbed_official 532:fe11edbda85c 397
mbed_official 532:fe11edbda85c 398 /* Release Lock */
mbed_official 532:fe11edbda85c 399 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 400
mbed_official 532:fe11edbda85c 401 return HAL_OK;
mbed_official 532:fe11edbda85c 402 }
mbed_official 532:fe11edbda85c 403
mbed_official 532:fe11edbda85c 404 /**
mbed_official 532:fe11edbda85c 405 * @brief FMPI2C MSP Init.
mbed_official 532:fe11edbda85c 406 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 407 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 408 * @retval None
mbed_official 532:fe11edbda85c 409 */
mbed_official 532:fe11edbda85c 410 __weak void HAL_FMPI2C_MspInit(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 411 {
mbed_official 532:fe11edbda85c 412 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 413 the HAL_FMPI2C_MspInit could be implemented in the user file
mbed_official 532:fe11edbda85c 414 */
mbed_official 532:fe11edbda85c 415 }
mbed_official 532:fe11edbda85c 416
mbed_official 532:fe11edbda85c 417 /**
mbed_official 532:fe11edbda85c 418 * @brief FMPI2C MSP DeInit
mbed_official 532:fe11edbda85c 419 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 420 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 421 * @retval None
mbed_official 532:fe11edbda85c 422 */
mbed_official 532:fe11edbda85c 423 __weak void HAL_FMPI2C_MspDeInit(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 424 {
mbed_official 532:fe11edbda85c 425 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 426 the HAL_FMPI2C_MspDeInit could be implemented in the user file
mbed_official 532:fe11edbda85c 427 */
mbed_official 532:fe11edbda85c 428 }
mbed_official 532:fe11edbda85c 429
mbed_official 532:fe11edbda85c 430 /**
mbed_official 532:fe11edbda85c 431 * @}
mbed_official 532:fe11edbda85c 432 */
mbed_official 532:fe11edbda85c 433
mbed_official 532:fe11edbda85c 434 /** @defgroup FMPI2C_Exported_Functions_Group2 I/O operation functions
mbed_official 532:fe11edbda85c 435 * @brief Data transfers functions
mbed_official 532:fe11edbda85c 436 *
mbed_official 532:fe11edbda85c 437 @verbatim
mbed_official 532:fe11edbda85c 438 ===============================================================================
mbed_official 532:fe11edbda85c 439 ##### IO operation functions #####
mbed_official 532:fe11edbda85c 440 ===============================================================================
mbed_official 532:fe11edbda85c 441 [..]
mbed_official 532:fe11edbda85c 442 This subsection provides a set of functions allowing to manage the FMPI2C data
mbed_official 532:fe11edbda85c 443 transfers.
mbed_official 532:fe11edbda85c 444
mbed_official 532:fe11edbda85c 445 (#) There is two mode of transfer:
mbed_official 532:fe11edbda85c 446 (++) Blocking mode : The communication is performed in the polling mode.
mbed_official 532:fe11edbda85c 447 The status of all data processing is returned by the same function
mbed_official 532:fe11edbda85c 448 after finishing transfer.
mbed_official 532:fe11edbda85c 449 (++) No-Blocking mode : The communication is performed using Interrupts
mbed_official 532:fe11edbda85c 450 or DMA. These functions return the status of the transfer startup.
mbed_official 532:fe11edbda85c 451 The end of the data processing will be indicated through the
mbed_official 532:fe11edbda85c 452 dedicated FMPI2C IRQ when using Interrupt mode or the DMA IRQ when
mbed_official 532:fe11edbda85c 453 using DMA mode.
mbed_official 532:fe11edbda85c 454
mbed_official 532:fe11edbda85c 455 (#) Blocking mode functions are :
mbed_official 532:fe11edbda85c 456 (++) HAL_FMPI2C_Master_Transmit()
mbed_official 532:fe11edbda85c 457 (++) HAL_FMPI2C_Master_Receive()
mbed_official 532:fe11edbda85c 458 (++) HAL_FMPI2C_Slave_Transmit()
mbed_official 532:fe11edbda85c 459 (++) HAL_FMPI2C_Slave_Receive()
mbed_official 532:fe11edbda85c 460 (++) HAL_FMPI2C_Mem_Write()
mbed_official 532:fe11edbda85c 461 (++) HAL_FMPI2C_Mem_Read()
mbed_official 532:fe11edbda85c 462 (++) HAL_FMPI2C_IsDeviceReady()
mbed_official 532:fe11edbda85c 463
mbed_official 532:fe11edbda85c 464 (#) No-Blocking mode functions with Interrupt are :
mbed_official 532:fe11edbda85c 465 (++) HAL_FMPI2C_Master_Transmit_IT()
mbed_official 532:fe11edbda85c 466 (++) HAL_FMPI2C_Master_Receive_IT()
mbed_official 532:fe11edbda85c 467 (++) HAL_FMPI2C_Slave_Transmit_IT()
mbed_official 532:fe11edbda85c 468 (++) HAL_FMPI2C_Slave_Receive_IT()
mbed_official 532:fe11edbda85c 469 (++) HAL_FMPI2C_Mem_Write_IT()
mbed_official 532:fe11edbda85c 470 (++) HAL_FMPI2C_Mem_Read_IT()
mbed_official 532:fe11edbda85c 471
mbed_official 532:fe11edbda85c 472 (#) No-Blocking mode functions with DMA are :
mbed_official 532:fe11edbda85c 473 (++) HAL_FMPI2C_Master_Transmit_DMA()
mbed_official 532:fe11edbda85c 474 (++) HAL_FMPI2C_Master_Receive_DMA()
mbed_official 532:fe11edbda85c 475 (++) HAL_FMPI2C_Slave_Transmit_DMA()
mbed_official 532:fe11edbda85c 476 (++) HAL_FMPI2C_Slave_Receive_DMA()
mbed_official 532:fe11edbda85c 477 (++) HAL_FMPI2C_Mem_Write_DMA()
mbed_official 532:fe11edbda85c 478 (++) HAL_FMPI2C_Mem_Read_DMA()
mbed_official 532:fe11edbda85c 479
mbed_official 532:fe11edbda85c 480 (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:
mbed_official 532:fe11edbda85c 481 (++) HAL_FMPI2C_MemTxCpltCallback()
mbed_official 532:fe11edbda85c 482 (++) HAL_FMPI2C_MemRxCpltCallback()
mbed_official 532:fe11edbda85c 483 (++) HAL_FMPI2C_MasterTxCpltCallback()
mbed_official 532:fe11edbda85c 484 (++) HAL_FMPI2C_MasterRxCpltCallback()
mbed_official 532:fe11edbda85c 485 (++) HAL_FMPI2C_SlaveTxCpltCallback()
mbed_official 532:fe11edbda85c 486 (++) HAL_FMPI2C_SlaveRxCpltCallback()
mbed_official 532:fe11edbda85c 487 (++) HAL_FMPI2C_ErrorCallback()
mbed_official 532:fe11edbda85c 488
mbed_official 532:fe11edbda85c 489 @endverbatim
mbed_official 532:fe11edbda85c 490 * @{
mbed_official 532:fe11edbda85c 491 */
mbed_official 532:fe11edbda85c 492
mbed_official 532:fe11edbda85c 493 /**
mbed_official 532:fe11edbda85c 494 * @brief Transmits in master mode an amount of data in blocking mode.
mbed_official 532:fe11edbda85c 495 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 496 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 497 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 498 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 499 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 500 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 501 * @retval HAL status
mbed_official 532:fe11edbda85c 502 */
mbed_official 532:fe11edbda85c 503 HAL_StatusTypeDef HAL_FMPI2C_Master_Transmit(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 532:fe11edbda85c 504 {
mbed_official 532:fe11edbda85c 505 uint32_t sizetmp = 0;
mbed_official 532:fe11edbda85c 506
mbed_official 532:fe11edbda85c 507 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 508 {
mbed_official 532:fe11edbda85c 509 if((pData == NULL ) || (Size == 0))
mbed_official 532:fe11edbda85c 510 {
mbed_official 532:fe11edbda85c 511 return HAL_ERROR;
mbed_official 532:fe11edbda85c 512 }
mbed_official 532:fe11edbda85c 513
mbed_official 532:fe11edbda85c 514 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 515 {
mbed_official 532:fe11edbda85c 516 return HAL_BUSY;
mbed_official 532:fe11edbda85c 517 }
mbed_official 532:fe11edbda85c 518
mbed_official 532:fe11edbda85c 519 /* Process Locked */
mbed_official 532:fe11edbda85c 520 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 521
mbed_official 532:fe11edbda85c 522 hfmpi2c->State = HAL_FMPI2C_STATE_MASTER_BUSY_TX;
mbed_official 532:fe11edbda85c 523 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 524
mbed_official 532:fe11edbda85c 525 /* Send Slave Address */
mbed_official 532:fe11edbda85c 526 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 527 /* Size > 255, need to set RELOAD bit */
mbed_official 532:fe11edbda85c 528 if(Size > 255)
mbed_official 532:fe11edbda85c 529 {
mbed_official 532:fe11edbda85c 530 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 531 sizetmp = 255;
mbed_official 532:fe11edbda85c 532 }
mbed_official 532:fe11edbda85c 533 else
mbed_official 532:fe11edbda85c 534 {
mbed_official 532:fe11edbda85c 535 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 536 sizetmp = Size;
mbed_official 532:fe11edbda85c 537 }
mbed_official 532:fe11edbda85c 538
mbed_official 532:fe11edbda85c 539 do
mbed_official 532:fe11edbda85c 540 {
mbed_official 532:fe11edbda85c 541 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 542 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 543 {
mbed_official 532:fe11edbda85c 544 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 545 {
mbed_official 532:fe11edbda85c 546 return HAL_ERROR;
mbed_official 532:fe11edbda85c 547 }
mbed_official 532:fe11edbda85c 548 else
mbed_official 532:fe11edbda85c 549 {
mbed_official 532:fe11edbda85c 550 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 551 }
mbed_official 532:fe11edbda85c 552 }
mbed_official 532:fe11edbda85c 553 /* Write data to TXDR */
mbed_official 532:fe11edbda85c 554 hfmpi2c->Instance->TXDR = (*pData++);
mbed_official 532:fe11edbda85c 555 sizetmp--;
mbed_official 532:fe11edbda85c 556 Size--;
mbed_official 532:fe11edbda85c 557
mbed_official 532:fe11edbda85c 558 if((sizetmp == 0)&&(Size!=0))
mbed_official 532:fe11edbda85c 559 {
mbed_official 532:fe11edbda85c 560 /* Wait until TXE flag is set */
mbed_official 532:fe11edbda85c 561 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 562 {
mbed_official 532:fe11edbda85c 563 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 564 }
mbed_official 532:fe11edbda85c 565
mbed_official 532:fe11edbda85c 566 if(Size > 255)
mbed_official 532:fe11edbda85c 567 {
mbed_official 532:fe11edbda85c 568 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 569 sizetmp = 255;
mbed_official 532:fe11edbda85c 570 }
mbed_official 532:fe11edbda85c 571 else
mbed_official 532:fe11edbda85c 572 {
mbed_official 532:fe11edbda85c 573 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 574 sizetmp = Size;
mbed_official 532:fe11edbda85c 575 }
mbed_official 532:fe11edbda85c 576 }
mbed_official 532:fe11edbda85c 577
mbed_official 532:fe11edbda85c 578 }while(Size > 0);
mbed_official 532:fe11edbda85c 579
mbed_official 532:fe11edbda85c 580 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 581 /* Wait until STOPF flag is set */
mbed_official 532:fe11edbda85c 582 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 583 {
mbed_official 532:fe11edbda85c 584 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 585 {
mbed_official 532:fe11edbda85c 586 return HAL_ERROR;
mbed_official 532:fe11edbda85c 587 }
mbed_official 532:fe11edbda85c 588 else
mbed_official 532:fe11edbda85c 589 {
mbed_official 532:fe11edbda85c 590 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 591 }
mbed_official 532:fe11edbda85c 592 }
mbed_official 532:fe11edbda85c 593
mbed_official 532:fe11edbda85c 594 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 595 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 596
mbed_official 532:fe11edbda85c 597 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 598 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 599
mbed_official 532:fe11edbda85c 600 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 601
mbed_official 532:fe11edbda85c 602 /* Process Unlocked */
mbed_official 532:fe11edbda85c 603 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 604
mbed_official 532:fe11edbda85c 605 return HAL_OK;
mbed_official 532:fe11edbda85c 606 }
mbed_official 532:fe11edbda85c 607 else
mbed_official 532:fe11edbda85c 608 {
mbed_official 532:fe11edbda85c 609 return HAL_BUSY;
mbed_official 532:fe11edbda85c 610 }
mbed_official 532:fe11edbda85c 611 }
mbed_official 532:fe11edbda85c 612
mbed_official 532:fe11edbda85c 613 /**
mbed_official 532:fe11edbda85c 614 * @brief Receives in master mode an amount of data in blocking mode.
mbed_official 532:fe11edbda85c 615 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 616 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 617 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 618 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 619 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 620 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 621 * @retval HAL status
mbed_official 532:fe11edbda85c 622 */
mbed_official 532:fe11edbda85c 623 HAL_StatusTypeDef HAL_FMPI2C_Master_Receive(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 532:fe11edbda85c 624 {
mbed_official 532:fe11edbda85c 625 uint32_t sizetmp = 0;
mbed_official 532:fe11edbda85c 626
mbed_official 532:fe11edbda85c 627 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 628 {
mbed_official 532:fe11edbda85c 629 if((pData == NULL ) || (Size == 0))
mbed_official 532:fe11edbda85c 630 {
mbed_official 532:fe11edbda85c 631 return HAL_ERROR;
mbed_official 532:fe11edbda85c 632 }
mbed_official 532:fe11edbda85c 633
mbed_official 532:fe11edbda85c 634 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 635 {
mbed_official 532:fe11edbda85c 636 return HAL_BUSY;
mbed_official 532:fe11edbda85c 637 }
mbed_official 532:fe11edbda85c 638
mbed_official 532:fe11edbda85c 639 /* Process Locked */
mbed_official 532:fe11edbda85c 640 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 641
mbed_official 532:fe11edbda85c 642 hfmpi2c->State = HAL_FMPI2C_STATE_MASTER_BUSY_RX;
mbed_official 532:fe11edbda85c 643 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 644
mbed_official 532:fe11edbda85c 645 /* Send Slave Address */
mbed_official 532:fe11edbda85c 646 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 647 /* Size > 255, need to set RELOAD bit */
mbed_official 532:fe11edbda85c 648 if(Size > 255)
mbed_official 532:fe11edbda85c 649 {
mbed_official 532:fe11edbda85c 650 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 651 sizetmp = 255;
mbed_official 532:fe11edbda85c 652 }
mbed_official 532:fe11edbda85c 653 else
mbed_official 532:fe11edbda85c 654 {
mbed_official 532:fe11edbda85c 655 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 656 sizetmp = Size;
mbed_official 532:fe11edbda85c 657 }
mbed_official 532:fe11edbda85c 658
mbed_official 532:fe11edbda85c 659 do
mbed_official 532:fe11edbda85c 660 {
mbed_official 532:fe11edbda85c 661 /* Wait until RXNE flag is set */
mbed_official 532:fe11edbda85c 662 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 663 {
mbed_official 532:fe11edbda85c 664 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 665 }
mbed_official 532:fe11edbda85c 666
mbed_official 532:fe11edbda85c 667 /* Write data to RXDR */
mbed_official 532:fe11edbda85c 668 (*pData++) =hfmpi2c->Instance->RXDR;
mbed_official 532:fe11edbda85c 669 sizetmp--;
mbed_official 532:fe11edbda85c 670 Size--;
mbed_official 532:fe11edbda85c 671
mbed_official 532:fe11edbda85c 672 if((sizetmp == 0)&&(Size!=0))
mbed_official 532:fe11edbda85c 673 {
mbed_official 532:fe11edbda85c 674 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 675 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 676 {
mbed_official 532:fe11edbda85c 677 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 678 }
mbed_official 532:fe11edbda85c 679
mbed_official 532:fe11edbda85c 680 if(Size > 255)
mbed_official 532:fe11edbda85c 681 {
mbed_official 532:fe11edbda85c 682 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 683 sizetmp = 255;
mbed_official 532:fe11edbda85c 684 }
mbed_official 532:fe11edbda85c 685 else
mbed_official 532:fe11edbda85c 686 {
mbed_official 532:fe11edbda85c 687 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 688 sizetmp = Size;
mbed_official 532:fe11edbda85c 689 }
mbed_official 532:fe11edbda85c 690 }
mbed_official 532:fe11edbda85c 691
mbed_official 532:fe11edbda85c 692 }while(Size > 0);
mbed_official 532:fe11edbda85c 693
mbed_official 532:fe11edbda85c 694 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 695 /* Wait until STOPF flag is set */
mbed_official 532:fe11edbda85c 696 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 697 {
mbed_official 532:fe11edbda85c 698 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 699 {
mbed_official 532:fe11edbda85c 700 return HAL_ERROR;
mbed_official 532:fe11edbda85c 701 }
mbed_official 532:fe11edbda85c 702 else
mbed_official 532:fe11edbda85c 703 {
mbed_official 532:fe11edbda85c 704 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 705 }
mbed_official 532:fe11edbda85c 706 }
mbed_official 532:fe11edbda85c 707
mbed_official 532:fe11edbda85c 708 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 709 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 710
mbed_official 532:fe11edbda85c 711 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 712 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 713
mbed_official 532:fe11edbda85c 714 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 715
mbed_official 532:fe11edbda85c 716 /* Process Unlocked */
mbed_official 532:fe11edbda85c 717 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 718
mbed_official 532:fe11edbda85c 719 return HAL_OK;
mbed_official 532:fe11edbda85c 720 }
mbed_official 532:fe11edbda85c 721 else
mbed_official 532:fe11edbda85c 722 {
mbed_official 532:fe11edbda85c 723 return HAL_BUSY;
mbed_official 532:fe11edbda85c 724 }
mbed_official 532:fe11edbda85c 725 }
mbed_official 532:fe11edbda85c 726
mbed_official 532:fe11edbda85c 727 /**
mbed_official 532:fe11edbda85c 728 * @brief Transmits in slave mode an amount of data in blocking mode.
mbed_official 532:fe11edbda85c 729 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 730 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 731 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 732 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 733 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 734 * @retval HAL status
mbed_official 532:fe11edbda85c 735 */
mbed_official 532:fe11edbda85c 736 HAL_StatusTypeDef HAL_FMPI2C_Slave_Transmit(FMPI2C_HandleTypeDef *hfmpi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 532:fe11edbda85c 737 {
mbed_official 532:fe11edbda85c 738 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 739 {
mbed_official 532:fe11edbda85c 740 if((pData == NULL ) || (Size == 0))
mbed_official 532:fe11edbda85c 741 {
mbed_official 532:fe11edbda85c 742 return HAL_ERROR;
mbed_official 532:fe11edbda85c 743 }
mbed_official 532:fe11edbda85c 744
mbed_official 532:fe11edbda85c 745 /* Process Locked */
mbed_official 532:fe11edbda85c 746 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 747
mbed_official 532:fe11edbda85c 748 hfmpi2c->State = HAL_FMPI2C_STATE_SLAVE_BUSY_RX;
mbed_official 532:fe11edbda85c 749 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 750
mbed_official 532:fe11edbda85c 751 /* Enable Address Acknowledge */
mbed_official 532:fe11edbda85c 752 hfmpi2c->Instance->CR2 &= ~FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 753
mbed_official 532:fe11edbda85c 754 /* Wait until ADDR flag is set */
mbed_official 532:fe11edbda85c 755 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 756 {
mbed_official 532:fe11edbda85c 757 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 758 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 759 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 760 }
mbed_official 532:fe11edbda85c 761
mbed_official 532:fe11edbda85c 762 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 763 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 764
mbed_official 532:fe11edbda85c 765 /* If 10bit addressing mode is selected */
mbed_official 532:fe11edbda85c 766 if(hfmpi2c->Init.AddressingMode == FMPI2C_ADDRESSINGMODE_10BIT)
mbed_official 532:fe11edbda85c 767 {
mbed_official 532:fe11edbda85c 768 /* Wait until ADDR flag is set */
mbed_official 532:fe11edbda85c 769 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 770 {
mbed_official 532:fe11edbda85c 771 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 772 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 773 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 774 }
mbed_official 532:fe11edbda85c 775
mbed_official 532:fe11edbda85c 776 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 777 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 778 }
mbed_official 532:fe11edbda85c 779
mbed_official 532:fe11edbda85c 780 /* Wait until DIR flag is set Transmitter mode */
mbed_official 532:fe11edbda85c 781 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_DIR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 782 {
mbed_official 532:fe11edbda85c 783 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 784 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 785 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 786 }
mbed_official 532:fe11edbda85c 787
mbed_official 532:fe11edbda85c 788 do
mbed_official 532:fe11edbda85c 789 {
mbed_official 532:fe11edbda85c 790 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 791 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 792 {
mbed_official 532:fe11edbda85c 793 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 794 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 795
mbed_official 532:fe11edbda85c 796 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 797 {
mbed_official 532:fe11edbda85c 798 return HAL_ERROR;
mbed_official 532:fe11edbda85c 799 }
mbed_official 532:fe11edbda85c 800 else
mbed_official 532:fe11edbda85c 801 {
mbed_official 532:fe11edbda85c 802 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 803 }
mbed_official 532:fe11edbda85c 804 }
mbed_official 532:fe11edbda85c 805
mbed_official 532:fe11edbda85c 806 /* Read data from TXDR */
mbed_official 532:fe11edbda85c 807 hfmpi2c->Instance->TXDR = (*pData++);
mbed_official 532:fe11edbda85c 808 Size--;
mbed_official 532:fe11edbda85c 809 }while(Size > 0);
mbed_official 532:fe11edbda85c 810
mbed_official 532:fe11edbda85c 811 /* Wait until STOP flag is set */
mbed_official 532:fe11edbda85c 812 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 813 {
mbed_official 532:fe11edbda85c 814 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 815 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 816
mbed_official 532:fe11edbda85c 817 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 818 {
mbed_official 532:fe11edbda85c 819 /* Normal use case for Transmitter mode */
mbed_official 532:fe11edbda85c 820 /* A NACK is generated to confirm the end of transfer */
mbed_official 532:fe11edbda85c 821 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 822 }
mbed_official 532:fe11edbda85c 823 else
mbed_official 532:fe11edbda85c 824 {
mbed_official 532:fe11edbda85c 825 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 826 }
mbed_official 532:fe11edbda85c 827 }
mbed_official 532:fe11edbda85c 828
mbed_official 532:fe11edbda85c 829 /* Clear STOP flag */
mbed_official 532:fe11edbda85c 830 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 831
mbed_official 532:fe11edbda85c 832 /* Wait until BUSY flag is reset */
mbed_official 532:fe11edbda85c 833 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_BUSY, SET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 834 {
mbed_official 532:fe11edbda85c 835 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 836 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 837 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 838 }
mbed_official 532:fe11edbda85c 839
mbed_official 532:fe11edbda85c 840 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 841 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 842
mbed_official 532:fe11edbda85c 843 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 844
mbed_official 532:fe11edbda85c 845 /* Process Unlocked */
mbed_official 532:fe11edbda85c 846 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 847
mbed_official 532:fe11edbda85c 848 return HAL_OK;
mbed_official 532:fe11edbda85c 849 }
mbed_official 532:fe11edbda85c 850 else
mbed_official 532:fe11edbda85c 851 {
mbed_official 532:fe11edbda85c 852 return HAL_BUSY;
mbed_official 532:fe11edbda85c 853 }
mbed_official 532:fe11edbda85c 854 }
mbed_official 532:fe11edbda85c 855
mbed_official 532:fe11edbda85c 856 /**
mbed_official 532:fe11edbda85c 857 * @brief Receive in slave mode an amount of data in blocking mode
mbed_official 532:fe11edbda85c 858 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 859 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 860 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 861 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 862 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 863 * @retval HAL status
mbed_official 532:fe11edbda85c 864 */
mbed_official 532:fe11edbda85c 865 HAL_StatusTypeDef HAL_FMPI2C_Slave_Receive(FMPI2C_HandleTypeDef *hfmpi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 532:fe11edbda85c 866 {
mbed_official 532:fe11edbda85c 867 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 868 {
mbed_official 532:fe11edbda85c 869 if((pData == NULL ) || (Size == 0))
mbed_official 532:fe11edbda85c 870 {
mbed_official 532:fe11edbda85c 871 return HAL_ERROR;
mbed_official 532:fe11edbda85c 872 }
mbed_official 532:fe11edbda85c 873
mbed_official 532:fe11edbda85c 874 /* Process Locked */
mbed_official 532:fe11edbda85c 875 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 876
mbed_official 532:fe11edbda85c 877 hfmpi2c->State = HAL_FMPI2C_STATE_SLAVE_BUSY_RX;
mbed_official 532:fe11edbda85c 878 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 879
mbed_official 532:fe11edbda85c 880 /* Enable Address Acknowledge */
mbed_official 532:fe11edbda85c 881 hfmpi2c->Instance->CR2 &= ~FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 882
mbed_official 532:fe11edbda85c 883 /* Wait until ADDR flag is set */
mbed_official 532:fe11edbda85c 884 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 885 {
mbed_official 532:fe11edbda85c 886 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 887 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 888 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 889 }
mbed_official 532:fe11edbda85c 890
mbed_official 532:fe11edbda85c 891 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 892 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 893
mbed_official 532:fe11edbda85c 894 /* Wait until DIR flag is reset Receiver mode */
mbed_official 532:fe11edbda85c 895 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_DIR, SET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 896 {
mbed_official 532:fe11edbda85c 897 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 898 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 899 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 900 }
mbed_official 532:fe11edbda85c 901
mbed_official 532:fe11edbda85c 902 while(Size > 0)
mbed_official 532:fe11edbda85c 903 {
mbed_official 532:fe11edbda85c 904 /* Wait until RXNE flag is set */
mbed_official 532:fe11edbda85c 905 if(FMPI2C_WaitOnRXNEFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 906 {
mbed_official 532:fe11edbda85c 907 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 908 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 909 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_TIMEOUT)
mbed_official 532:fe11edbda85c 910 {
mbed_official 532:fe11edbda85c 911 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 912 }
mbed_official 532:fe11edbda85c 913 else
mbed_official 532:fe11edbda85c 914 {
mbed_official 532:fe11edbda85c 915 return HAL_ERROR;
mbed_official 532:fe11edbda85c 916 }
mbed_official 532:fe11edbda85c 917 }
mbed_official 532:fe11edbda85c 918
mbed_official 532:fe11edbda85c 919 /* Read data from RXDR */
mbed_official 532:fe11edbda85c 920 (*pData++) = hfmpi2c->Instance->RXDR;
mbed_official 532:fe11edbda85c 921 Size--;
mbed_official 532:fe11edbda85c 922 }
mbed_official 532:fe11edbda85c 923
mbed_official 532:fe11edbda85c 924 /* Wait until STOP flag is set */
mbed_official 532:fe11edbda85c 925 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 926 {
mbed_official 532:fe11edbda85c 927 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 928 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 929
mbed_official 532:fe11edbda85c 930 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 931 {
mbed_official 532:fe11edbda85c 932 return HAL_ERROR;
mbed_official 532:fe11edbda85c 933 }
mbed_official 532:fe11edbda85c 934 else
mbed_official 532:fe11edbda85c 935 {
mbed_official 532:fe11edbda85c 936 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 937 }
mbed_official 532:fe11edbda85c 938 }
mbed_official 532:fe11edbda85c 939
mbed_official 532:fe11edbda85c 940 /* Clear STOP flag */
mbed_official 532:fe11edbda85c 941 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 942
mbed_official 532:fe11edbda85c 943 /* Wait until BUSY flag is reset */
mbed_official 532:fe11edbda85c 944 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_BUSY, SET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 945 {
mbed_official 532:fe11edbda85c 946 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 947 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 948 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 949 }
mbed_official 532:fe11edbda85c 950
mbed_official 532:fe11edbda85c 951
mbed_official 532:fe11edbda85c 952 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 953 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 954
mbed_official 532:fe11edbda85c 955 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 956
mbed_official 532:fe11edbda85c 957 /* Process Unlocked */
mbed_official 532:fe11edbda85c 958 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 959
mbed_official 532:fe11edbda85c 960 return HAL_OK;
mbed_official 532:fe11edbda85c 961 }
mbed_official 532:fe11edbda85c 962 else
mbed_official 532:fe11edbda85c 963 {
mbed_official 532:fe11edbda85c 964 return HAL_BUSY;
mbed_official 532:fe11edbda85c 965 }
mbed_official 532:fe11edbda85c 966 }
mbed_official 532:fe11edbda85c 967
mbed_official 532:fe11edbda85c 968 /**
mbed_official 532:fe11edbda85c 969 * @brief Transmit in master mode an amount of data in no-blocking mode with Interrupt
mbed_official 532:fe11edbda85c 970 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 971 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 972 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 973 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 974 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 975 * @retval HAL status
mbed_official 532:fe11edbda85c 976 */
mbed_official 532:fe11edbda85c 977 HAL_StatusTypeDef HAL_FMPI2C_Master_Transmit_IT(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 978 {
mbed_official 532:fe11edbda85c 979 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 980 {
mbed_official 532:fe11edbda85c 981 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 982 {
mbed_official 532:fe11edbda85c 983 return HAL_ERROR;
mbed_official 532:fe11edbda85c 984 }
mbed_official 532:fe11edbda85c 985
mbed_official 532:fe11edbda85c 986 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 987 {
mbed_official 532:fe11edbda85c 988 return HAL_BUSY;
mbed_official 532:fe11edbda85c 989 }
mbed_official 532:fe11edbda85c 990
mbed_official 532:fe11edbda85c 991 /* Process Locked */
mbed_official 532:fe11edbda85c 992 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 993
mbed_official 532:fe11edbda85c 994 hfmpi2c->State = HAL_FMPI2C_STATE_MASTER_BUSY_TX;
mbed_official 532:fe11edbda85c 995 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 996
mbed_official 532:fe11edbda85c 997 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 998 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 999 if(Size > 255)
mbed_official 532:fe11edbda85c 1000 {
mbed_official 532:fe11edbda85c 1001 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 1002 }
mbed_official 532:fe11edbda85c 1003 else
mbed_official 532:fe11edbda85c 1004 {
mbed_official 532:fe11edbda85c 1005 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1006 }
mbed_official 532:fe11edbda85c 1007
mbed_official 532:fe11edbda85c 1008 /* Send Slave Address */
mbed_official 532:fe11edbda85c 1009 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 1010 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 1011 {
mbed_official 532:fe11edbda85c 1012 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 1013 }
mbed_official 532:fe11edbda85c 1014 else
mbed_official 532:fe11edbda85c 1015 {
mbed_official 532:fe11edbda85c 1016 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 1017 }
mbed_official 532:fe11edbda85c 1018
mbed_official 532:fe11edbda85c 1019 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1020 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1021
mbed_official 532:fe11edbda85c 1022 /* Note : The FMPI2C interrupts must be enabled after unlocking current process
mbed_official 532:fe11edbda85c 1023 to avoid the risk of FMPI2C interrupt handle execution before current
mbed_official 532:fe11edbda85c 1024 process unlock */
mbed_official 532:fe11edbda85c 1025
mbed_official 532:fe11edbda85c 1026
mbed_official 532:fe11edbda85c 1027 /* Enable ERR, TC, STOP, NACK, TXI interrupt */
mbed_official 532:fe11edbda85c 1028 /* possible to enable all of these */
mbed_official 532:fe11edbda85c 1029 /* FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_TXI */
mbed_official 532:fe11edbda85c 1030 __HAL_FMPI2C_ENABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_TXI );
mbed_official 532:fe11edbda85c 1031
mbed_official 532:fe11edbda85c 1032 return HAL_OK;
mbed_official 532:fe11edbda85c 1033 }
mbed_official 532:fe11edbda85c 1034 else
mbed_official 532:fe11edbda85c 1035 {
mbed_official 532:fe11edbda85c 1036 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1037 }
mbed_official 532:fe11edbda85c 1038 }
mbed_official 532:fe11edbda85c 1039
mbed_official 532:fe11edbda85c 1040 /**
mbed_official 532:fe11edbda85c 1041 * @brief Receive in master mode an amount of data in no-blocking mode with Interrupt
mbed_official 532:fe11edbda85c 1042 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1043 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1044 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 1045 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1046 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1047 * @retval HAL status
mbed_official 532:fe11edbda85c 1048 */
mbed_official 532:fe11edbda85c 1049 HAL_StatusTypeDef HAL_FMPI2C_Master_Receive_IT(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1050 {
mbed_official 532:fe11edbda85c 1051 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1052 {
mbed_official 532:fe11edbda85c 1053 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1054 {
mbed_official 532:fe11edbda85c 1055 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1056 }
mbed_official 532:fe11edbda85c 1057
mbed_official 532:fe11edbda85c 1058 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 1059 {
mbed_official 532:fe11edbda85c 1060 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1061 }
mbed_official 532:fe11edbda85c 1062
mbed_official 532:fe11edbda85c 1063 /* Process Locked */
mbed_official 532:fe11edbda85c 1064 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1065
mbed_official 532:fe11edbda85c 1066 hfmpi2c->State = HAL_FMPI2C_STATE_MASTER_BUSY_RX;
mbed_official 532:fe11edbda85c 1067 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1068
mbed_official 532:fe11edbda85c 1069 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1070 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1071 if(Size > 255)
mbed_official 532:fe11edbda85c 1072 {
mbed_official 532:fe11edbda85c 1073 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 1074 }
mbed_official 532:fe11edbda85c 1075 else
mbed_official 532:fe11edbda85c 1076 {
mbed_official 532:fe11edbda85c 1077 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1078 }
mbed_official 532:fe11edbda85c 1079
mbed_official 532:fe11edbda85c 1080 /* Send Slave Address */
mbed_official 532:fe11edbda85c 1081 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 1082 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 1083 {
mbed_official 532:fe11edbda85c 1084 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1085 }
mbed_official 532:fe11edbda85c 1086 else
mbed_official 532:fe11edbda85c 1087 {
mbed_official 532:fe11edbda85c 1088 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1089 }
mbed_official 532:fe11edbda85c 1090
mbed_official 532:fe11edbda85c 1091 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1092 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1093
mbed_official 532:fe11edbda85c 1094 /* Note : The FMPI2C interrupts must be enabled after unlocking current process
mbed_official 532:fe11edbda85c 1095 to avoid the risk of FMPI2C interrupt handle execution before current
mbed_official 532:fe11edbda85c 1096 process unlock */
mbed_official 532:fe11edbda85c 1097
mbed_official 532:fe11edbda85c 1098 /* Enable ERR, TC, STOP, NACK, RXI interrupt */
mbed_official 532:fe11edbda85c 1099 /* possible to enable all of these */
mbed_official 532:fe11edbda85c 1100 /* FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_TXI */
mbed_official 532:fe11edbda85c 1101 __HAL_FMPI2C_ENABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI | FMPI2C_IT_STOPI | FMPI2C_IT_NACKI | FMPI2C_IT_RXI );
mbed_official 532:fe11edbda85c 1102
mbed_official 532:fe11edbda85c 1103 return HAL_OK;
mbed_official 532:fe11edbda85c 1104 }
mbed_official 532:fe11edbda85c 1105 else
mbed_official 532:fe11edbda85c 1106 {
mbed_official 532:fe11edbda85c 1107 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1108 }
mbed_official 532:fe11edbda85c 1109 }
mbed_official 532:fe11edbda85c 1110
mbed_official 532:fe11edbda85c 1111 /**
mbed_official 532:fe11edbda85c 1112 * @brief Transmit in slave mode an amount of data in no-blocking mode with Interrupt
mbed_official 532:fe11edbda85c 1113 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1114 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1115 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1116 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1117 * @retval HAL status
mbed_official 532:fe11edbda85c 1118 */
mbed_official 532:fe11edbda85c 1119 HAL_StatusTypeDef HAL_FMPI2C_Slave_Transmit_IT(FMPI2C_HandleTypeDef *hfmpi2c, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1120 {
mbed_official 532:fe11edbda85c 1121 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1122 {
mbed_official 532:fe11edbda85c 1123 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1124 {
mbed_official 532:fe11edbda85c 1125 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1126 }
mbed_official 532:fe11edbda85c 1127
mbed_official 532:fe11edbda85c 1128 /* Process Locked */
mbed_official 532:fe11edbda85c 1129 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1130
mbed_official 532:fe11edbda85c 1131 hfmpi2c->State = HAL_FMPI2C_STATE_SLAVE_BUSY_TX;
mbed_official 532:fe11edbda85c 1132 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1133
mbed_official 532:fe11edbda85c 1134 /* Enable Address Acknowledge */
mbed_official 532:fe11edbda85c 1135 hfmpi2c->Instance->CR2 &= ~FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1136
mbed_official 532:fe11edbda85c 1137 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1138 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1139 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1140
mbed_official 532:fe11edbda85c 1141 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1142 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1143
mbed_official 532:fe11edbda85c 1144 /* Note : The FMPI2C interrupts must be enabled after unlocking current process
mbed_official 532:fe11edbda85c 1145 to avoid the risk of FMPI2C interrupt handle execution before current
mbed_official 532:fe11edbda85c 1146 process unlock */
mbed_official 532:fe11edbda85c 1147
mbed_official 532:fe11edbda85c 1148 /* Enable ERR, TC, STOP, NACK, TXI interrupt */
mbed_official 532:fe11edbda85c 1149 /* possible to enable all of these */
mbed_official 532:fe11edbda85c 1150 /* FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_TXI */
mbed_official 532:fe11edbda85c 1151 __HAL_FMPI2C_ENABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI | FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_TXI );
mbed_official 532:fe11edbda85c 1152
mbed_official 532:fe11edbda85c 1153 return HAL_OK;
mbed_official 532:fe11edbda85c 1154 }
mbed_official 532:fe11edbda85c 1155 else
mbed_official 532:fe11edbda85c 1156 {
mbed_official 532:fe11edbda85c 1157 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1158 }
mbed_official 532:fe11edbda85c 1159 }
mbed_official 532:fe11edbda85c 1160
mbed_official 532:fe11edbda85c 1161 /**
mbed_official 532:fe11edbda85c 1162 * @brief Receive in slave mode an amount of data in no-blocking mode with Interrupt
mbed_official 532:fe11edbda85c 1163 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1164 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1165 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1166 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1167 * @retval HAL status
mbed_official 532:fe11edbda85c 1168 */
mbed_official 532:fe11edbda85c 1169 HAL_StatusTypeDef HAL_FMPI2C_Slave_Receive_IT(FMPI2C_HandleTypeDef *hfmpi2c, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1170 {
mbed_official 532:fe11edbda85c 1171 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1172 {
mbed_official 532:fe11edbda85c 1173 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1174 {
mbed_official 532:fe11edbda85c 1175 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1176 }
mbed_official 532:fe11edbda85c 1177
mbed_official 532:fe11edbda85c 1178 /* Process Locked */
mbed_official 532:fe11edbda85c 1179 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1180
mbed_official 532:fe11edbda85c 1181 hfmpi2c->State = HAL_FMPI2C_STATE_SLAVE_BUSY_RX;
mbed_official 532:fe11edbda85c 1182 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1183
mbed_official 532:fe11edbda85c 1184 /* Enable Address Acknowledge */
mbed_official 532:fe11edbda85c 1185 hfmpi2c->Instance->CR2 &= ~FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1186
mbed_official 532:fe11edbda85c 1187 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1188 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1189 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1190
mbed_official 532:fe11edbda85c 1191 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1192 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1193
mbed_official 532:fe11edbda85c 1194 /* Note : The FMPI2C interrupts must be enabled after unlocking current process
mbed_official 532:fe11edbda85c 1195 to avoid the risk of FMPI2C interrupt handle execution before current
mbed_official 532:fe11edbda85c 1196 process unlock */
mbed_official 532:fe11edbda85c 1197
mbed_official 532:fe11edbda85c 1198 /* Enable ERR, TC, STOP, NACK, RXI interrupt */
mbed_official 532:fe11edbda85c 1199 /* possible to enable all of these */
mbed_official 532:fe11edbda85c 1200 /* FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_TXI */
mbed_official 532:fe11edbda85c 1201 __HAL_FMPI2C_ENABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI | FMPI2C_IT_STOPI | FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI);
mbed_official 532:fe11edbda85c 1202
mbed_official 532:fe11edbda85c 1203 return HAL_OK;
mbed_official 532:fe11edbda85c 1204 }
mbed_official 532:fe11edbda85c 1205 else
mbed_official 532:fe11edbda85c 1206 {
mbed_official 532:fe11edbda85c 1207 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1208 }
mbed_official 532:fe11edbda85c 1209 }
mbed_official 532:fe11edbda85c 1210
mbed_official 532:fe11edbda85c 1211 /**
mbed_official 532:fe11edbda85c 1212 * @brief Transmit in master mode an amount of data in no-blocking mode with DMA
mbed_official 532:fe11edbda85c 1213 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1214 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1215 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 1216 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1217 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1218 * @retval HAL status
mbed_official 532:fe11edbda85c 1219 */
mbed_official 532:fe11edbda85c 1220 HAL_StatusTypeDef HAL_FMPI2C_Master_Transmit_DMA(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1221 {
mbed_official 532:fe11edbda85c 1222 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1223 {
mbed_official 532:fe11edbda85c 1224 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1225 {
mbed_official 532:fe11edbda85c 1226 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1227 }
mbed_official 532:fe11edbda85c 1228
mbed_official 532:fe11edbda85c 1229 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 1230 {
mbed_official 532:fe11edbda85c 1231 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1232 }
mbed_official 532:fe11edbda85c 1233
mbed_official 532:fe11edbda85c 1234 /* Process Locked */
mbed_official 532:fe11edbda85c 1235 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1236
mbed_official 532:fe11edbda85c 1237 hfmpi2c->State = HAL_FMPI2C_STATE_MASTER_BUSY_TX;
mbed_official 532:fe11edbda85c 1238 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1239
mbed_official 532:fe11edbda85c 1240 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1241 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1242 if(Size > 255)
mbed_official 532:fe11edbda85c 1243 {
mbed_official 532:fe11edbda85c 1244 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 1245 }
mbed_official 532:fe11edbda85c 1246 else
mbed_official 532:fe11edbda85c 1247 {
mbed_official 532:fe11edbda85c 1248 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1249 }
mbed_official 532:fe11edbda85c 1250
mbed_official 532:fe11edbda85c 1251 /* Set the FMPI2C DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1252 hfmpi2c->hdmatx->XferCpltCallback = FMPI2C_DMAMasterTransmitCplt;
mbed_official 532:fe11edbda85c 1253
mbed_official 532:fe11edbda85c 1254 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1255 hfmpi2c->hdmatx->XferErrorCallback = FMPI2C_DMAError;
mbed_official 532:fe11edbda85c 1256
mbed_official 532:fe11edbda85c 1257 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 1258 HAL_DMA_Start_IT(hfmpi2c->hdmatx, (uint32_t)pData, (uint32_t)&hfmpi2c->Instance->TXDR, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 1259
mbed_official 532:fe11edbda85c 1260 /* Send Slave Address */
mbed_official 532:fe11edbda85c 1261 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 1262 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 1263 {
mbed_official 532:fe11edbda85c 1264 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 1265 }
mbed_official 532:fe11edbda85c 1266 else
mbed_official 532:fe11edbda85c 1267 {
mbed_official 532:fe11edbda85c 1268 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 1269 }
mbed_official 532:fe11edbda85c 1270
mbed_official 532:fe11edbda85c 1271 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 1272 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_TXIS) != HAL_OK)
mbed_official 532:fe11edbda85c 1273 {
mbed_official 532:fe11edbda85c 1274 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 1275 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1276
mbed_official 532:fe11edbda85c 1277 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1278 {
mbed_official 532:fe11edbda85c 1279 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1280 }
mbed_official 532:fe11edbda85c 1281 else
mbed_official 532:fe11edbda85c 1282 {
mbed_official 532:fe11edbda85c 1283 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1284 }
mbed_official 532:fe11edbda85c 1285 }
mbed_official 532:fe11edbda85c 1286
mbed_official 532:fe11edbda85c 1287
mbed_official 532:fe11edbda85c 1288 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 1289 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 1290
mbed_official 532:fe11edbda85c 1291 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1292 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1293
mbed_official 532:fe11edbda85c 1294 return HAL_OK;
mbed_official 532:fe11edbda85c 1295 }
mbed_official 532:fe11edbda85c 1296 else
mbed_official 532:fe11edbda85c 1297 {
mbed_official 532:fe11edbda85c 1298 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1299 }
mbed_official 532:fe11edbda85c 1300 }
mbed_official 532:fe11edbda85c 1301
mbed_official 532:fe11edbda85c 1302 /**
mbed_official 532:fe11edbda85c 1303 * @brief Receive in master mode an amount of data in no-blocking mode with DMA
mbed_official 532:fe11edbda85c 1304 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1305 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1306 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 1307 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1308 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1309 * @retval HAL status
mbed_official 532:fe11edbda85c 1310 */
mbed_official 532:fe11edbda85c 1311 HAL_StatusTypeDef HAL_FMPI2C_Master_Receive_DMA(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1312 {
mbed_official 532:fe11edbda85c 1313 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1314 {
mbed_official 532:fe11edbda85c 1315 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1316 {
mbed_official 532:fe11edbda85c 1317 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1318 }
mbed_official 532:fe11edbda85c 1319
mbed_official 532:fe11edbda85c 1320 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 1321 {
mbed_official 532:fe11edbda85c 1322 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1323 }
mbed_official 532:fe11edbda85c 1324
mbed_official 532:fe11edbda85c 1325 /* Process Locked */
mbed_official 532:fe11edbda85c 1326 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1327
mbed_official 532:fe11edbda85c 1328 hfmpi2c->State = HAL_FMPI2C_STATE_MASTER_BUSY_RX;
mbed_official 532:fe11edbda85c 1329 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1330
mbed_official 532:fe11edbda85c 1331 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1332 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1333 if(Size > 255)
mbed_official 532:fe11edbda85c 1334 {
mbed_official 532:fe11edbda85c 1335 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 1336 }
mbed_official 532:fe11edbda85c 1337 else
mbed_official 532:fe11edbda85c 1338 {
mbed_official 532:fe11edbda85c 1339 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1340 }
mbed_official 532:fe11edbda85c 1341
mbed_official 532:fe11edbda85c 1342 /* Set the FMPI2C DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1343 hfmpi2c->hdmarx->XferCpltCallback = FMPI2C_DMAMasterReceiveCplt;
mbed_official 532:fe11edbda85c 1344
mbed_official 532:fe11edbda85c 1345 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1346 hfmpi2c->hdmarx->XferErrorCallback = FMPI2C_DMAError;
mbed_official 532:fe11edbda85c 1347
mbed_official 532:fe11edbda85c 1348 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 1349 HAL_DMA_Start_IT(hfmpi2c->hdmarx, (uint32_t)&hfmpi2c->Instance->RXDR, (uint32_t)pData, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 1350
mbed_official 532:fe11edbda85c 1351 /* Send Slave Address */
mbed_official 532:fe11edbda85c 1352 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 1353 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 1354 {
mbed_official 532:fe11edbda85c 1355 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1356 }
mbed_official 532:fe11edbda85c 1357 else
mbed_official 532:fe11edbda85c 1358 {
mbed_official 532:fe11edbda85c 1359 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1360 }
mbed_official 532:fe11edbda85c 1361
mbed_official 532:fe11edbda85c 1362 /* Wait until RXNE flag is set */
mbed_official 532:fe11edbda85c 1363 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_RXNE, RESET, FMPI2C_TIMEOUT_RXNE) != HAL_OK)
mbed_official 532:fe11edbda85c 1364 {
mbed_official 532:fe11edbda85c 1365 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1366 }
mbed_official 532:fe11edbda85c 1367
mbed_official 532:fe11edbda85c 1368
mbed_official 532:fe11edbda85c 1369 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 1370 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 1371
mbed_official 532:fe11edbda85c 1372 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1373 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1374
mbed_official 532:fe11edbda85c 1375 return HAL_OK;
mbed_official 532:fe11edbda85c 1376 }
mbed_official 532:fe11edbda85c 1377 else
mbed_official 532:fe11edbda85c 1378 {
mbed_official 532:fe11edbda85c 1379 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1380 }
mbed_official 532:fe11edbda85c 1381 }
mbed_official 532:fe11edbda85c 1382
mbed_official 532:fe11edbda85c 1383 /**
mbed_official 532:fe11edbda85c 1384 * @brief Transmit in slave mode an amount of data in no-blocking mode with DMA
mbed_official 532:fe11edbda85c 1385 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1386 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1387 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1388 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1389 * @retval HAL status
mbed_official 532:fe11edbda85c 1390 */
mbed_official 532:fe11edbda85c 1391 HAL_StatusTypeDef HAL_FMPI2C_Slave_Transmit_DMA(FMPI2C_HandleTypeDef *hfmpi2c, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1392 {
mbed_official 532:fe11edbda85c 1393 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1394 {
mbed_official 532:fe11edbda85c 1395 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1396 {
mbed_official 532:fe11edbda85c 1397 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1398 }
mbed_official 532:fe11edbda85c 1399 /* Process Locked */
mbed_official 532:fe11edbda85c 1400 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1401
mbed_official 532:fe11edbda85c 1402 hfmpi2c->State = HAL_FMPI2C_STATE_SLAVE_BUSY_TX;
mbed_official 532:fe11edbda85c 1403 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1404
mbed_official 532:fe11edbda85c 1405 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1406 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1407 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1408
mbed_official 532:fe11edbda85c 1409 /* Set the FMPI2C DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1410 hfmpi2c->hdmatx->XferCpltCallback = FMPI2C_DMASlaveTransmitCplt;
mbed_official 532:fe11edbda85c 1411
mbed_official 532:fe11edbda85c 1412 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1413 hfmpi2c->hdmatx->XferErrorCallback = FMPI2C_DMAError;
mbed_official 532:fe11edbda85c 1414
mbed_official 532:fe11edbda85c 1415 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 1416 HAL_DMA_Start_IT(hfmpi2c->hdmatx, (uint32_t)pData, (uint32_t)&hfmpi2c->Instance->TXDR, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 1417
mbed_official 532:fe11edbda85c 1418 /* Enable Address Acknowledge */
mbed_official 532:fe11edbda85c 1419 hfmpi2c->Instance->CR2 &= ~FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1420
mbed_official 532:fe11edbda85c 1421 /* Wait until ADDR flag is set */
mbed_official 532:fe11edbda85c 1422 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_ADDR, RESET, FMPI2C_TIMEOUT_ADDR) != HAL_OK)
mbed_official 532:fe11edbda85c 1423 {
mbed_official 532:fe11edbda85c 1424 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 1425 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1426 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1427 }
mbed_official 532:fe11edbda85c 1428
mbed_official 532:fe11edbda85c 1429 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 1430 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 1431
mbed_official 532:fe11edbda85c 1432 /* If 10bits addressing mode is selected */
mbed_official 532:fe11edbda85c 1433 if(hfmpi2c->Init.AddressingMode == FMPI2C_ADDRESSINGMODE_10BIT)
mbed_official 532:fe11edbda85c 1434 {
mbed_official 532:fe11edbda85c 1435 /* Wait until ADDR flag is set */
mbed_official 532:fe11edbda85c 1436 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_ADDR, RESET, FMPI2C_TIMEOUT_ADDR) != HAL_OK)
mbed_official 532:fe11edbda85c 1437 {
mbed_official 532:fe11edbda85c 1438 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 1439 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1440 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1441 }
mbed_official 532:fe11edbda85c 1442
mbed_official 532:fe11edbda85c 1443 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 1444 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 1445 }
mbed_official 532:fe11edbda85c 1446
mbed_official 532:fe11edbda85c 1447 /* Wait until DIR flag is set Transmitter mode */
mbed_official 532:fe11edbda85c 1448 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_DIR, RESET, FMPI2C_TIMEOUT_BUSY) != HAL_OK)
mbed_official 532:fe11edbda85c 1449 {
mbed_official 532:fe11edbda85c 1450 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 1451 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1452 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1453 }
mbed_official 532:fe11edbda85c 1454
mbed_official 532:fe11edbda85c 1455 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 1456 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 1457
mbed_official 532:fe11edbda85c 1458 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1459 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1460
mbed_official 532:fe11edbda85c 1461 return HAL_OK;
mbed_official 532:fe11edbda85c 1462 }
mbed_official 532:fe11edbda85c 1463 else
mbed_official 532:fe11edbda85c 1464 {
mbed_official 532:fe11edbda85c 1465 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1466 }
mbed_official 532:fe11edbda85c 1467 }
mbed_official 532:fe11edbda85c 1468
mbed_official 532:fe11edbda85c 1469 /**
mbed_official 532:fe11edbda85c 1470 * @brief Receive in slave mode an amount of data in no-blocking mode with DMA
mbed_official 532:fe11edbda85c 1471 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1472 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1473 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1474 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1475 * @retval HAL status
mbed_official 532:fe11edbda85c 1476 */
mbed_official 532:fe11edbda85c 1477 HAL_StatusTypeDef HAL_FMPI2C_Slave_Receive_DMA(FMPI2C_HandleTypeDef *hfmpi2c, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1478 {
mbed_official 532:fe11edbda85c 1479 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1480 {
mbed_official 532:fe11edbda85c 1481 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1482 {
mbed_official 532:fe11edbda85c 1483 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1484 }
mbed_official 532:fe11edbda85c 1485 /* Process Locked */
mbed_official 532:fe11edbda85c 1486 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1487
mbed_official 532:fe11edbda85c 1488 hfmpi2c->State = HAL_FMPI2C_STATE_SLAVE_BUSY_RX;
mbed_official 532:fe11edbda85c 1489 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1490
mbed_official 532:fe11edbda85c 1491 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1492 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1493 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1494
mbed_official 532:fe11edbda85c 1495 /* Set the FMPI2C DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1496 hfmpi2c->hdmarx->XferCpltCallback = FMPI2C_DMASlaveReceiveCplt;
mbed_official 532:fe11edbda85c 1497
mbed_official 532:fe11edbda85c 1498 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1499 hfmpi2c->hdmarx->XferErrorCallback = FMPI2C_DMAError;
mbed_official 532:fe11edbda85c 1500
mbed_official 532:fe11edbda85c 1501 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 1502 HAL_DMA_Start_IT(hfmpi2c->hdmarx, (uint32_t)&hfmpi2c->Instance->RXDR, (uint32_t)pData, Size);
mbed_official 532:fe11edbda85c 1503
mbed_official 532:fe11edbda85c 1504 /* Enable Address Acknowledge */
mbed_official 532:fe11edbda85c 1505 hfmpi2c->Instance->CR2 &= ~FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1506
mbed_official 532:fe11edbda85c 1507 /* Wait until ADDR flag is set */
mbed_official 532:fe11edbda85c 1508 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_ADDR, RESET, FMPI2C_TIMEOUT_ADDR) != HAL_OK)
mbed_official 532:fe11edbda85c 1509 {
mbed_official 532:fe11edbda85c 1510 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 1511 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1512 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1513 }
mbed_official 532:fe11edbda85c 1514
mbed_official 532:fe11edbda85c 1515 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 1516 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 1517
mbed_official 532:fe11edbda85c 1518 /* Wait until DIR flag is set Receiver mode */
mbed_official 532:fe11edbda85c 1519 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_DIR, SET, FMPI2C_TIMEOUT_DIR) != HAL_OK)
mbed_official 532:fe11edbda85c 1520 {
mbed_official 532:fe11edbda85c 1521 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 1522 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 1523 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1524 }
mbed_official 532:fe11edbda85c 1525
mbed_official 532:fe11edbda85c 1526 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 1527 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 1528
mbed_official 532:fe11edbda85c 1529 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1530 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1531
mbed_official 532:fe11edbda85c 1532 return HAL_OK;
mbed_official 532:fe11edbda85c 1533 }
mbed_official 532:fe11edbda85c 1534 else
mbed_official 532:fe11edbda85c 1535 {
mbed_official 532:fe11edbda85c 1536 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1537 }
mbed_official 532:fe11edbda85c 1538 }
mbed_official 532:fe11edbda85c 1539 /**
mbed_official 532:fe11edbda85c 1540 * @brief Write an amount of data in blocking mode to a specific memory address
mbed_official 532:fe11edbda85c 1541 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1542 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1543 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 1544 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 1545 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 1546 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1547 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1548 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 1549 * @retval HAL status
mbed_official 532:fe11edbda85c 1550 */
mbed_official 532:fe11edbda85c 1551 HAL_StatusTypeDef HAL_FMPI2C_Mem_Write(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 532:fe11edbda85c 1552 {
mbed_official 532:fe11edbda85c 1553 uint32_t Sizetmp = 0;
mbed_official 532:fe11edbda85c 1554
mbed_official 532:fe11edbda85c 1555 /* Check the parameters */
mbed_official 532:fe11edbda85c 1556 assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize));
mbed_official 532:fe11edbda85c 1557
mbed_official 532:fe11edbda85c 1558 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1559 {
mbed_official 532:fe11edbda85c 1560 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1561 {
mbed_official 532:fe11edbda85c 1562 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1563 }
mbed_official 532:fe11edbda85c 1564
mbed_official 532:fe11edbda85c 1565 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 1566 {
mbed_official 532:fe11edbda85c 1567 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1568 }
mbed_official 532:fe11edbda85c 1569
mbed_official 532:fe11edbda85c 1570 /* Process Locked */
mbed_official 532:fe11edbda85c 1571 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1572
mbed_official 532:fe11edbda85c 1573 hfmpi2c->State = HAL_FMPI2C_STATE_MEM_BUSY_TX;
mbed_official 532:fe11edbda85c 1574 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1575
mbed_official 532:fe11edbda85c 1576 /* Send Slave Address and Memory Address */
mbed_official 532:fe11edbda85c 1577 if(FMPI2C_RequestMemoryWrite(hfmpi2c, DevAddress, MemAddress, MemAddSize, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 1578 {
mbed_official 532:fe11edbda85c 1579 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1580 {
mbed_official 532:fe11edbda85c 1581 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1582 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1583 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1584 }
mbed_official 532:fe11edbda85c 1585 else
mbed_official 532:fe11edbda85c 1586 {
mbed_official 532:fe11edbda85c 1587 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1588 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1589 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1590 }
mbed_official 532:fe11edbda85c 1591 }
mbed_official 532:fe11edbda85c 1592
mbed_official 532:fe11edbda85c 1593 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 1594 /* Size > 255, need to set RELOAD bit */
mbed_official 532:fe11edbda85c 1595 if(Size > 255)
mbed_official 532:fe11edbda85c 1596 {
mbed_official 532:fe11edbda85c 1597 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1598 Sizetmp = 255;
mbed_official 532:fe11edbda85c 1599 }
mbed_official 532:fe11edbda85c 1600 else
mbed_official 532:fe11edbda85c 1601 {
mbed_official 532:fe11edbda85c 1602 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1603 Sizetmp = Size;
mbed_official 532:fe11edbda85c 1604 }
mbed_official 532:fe11edbda85c 1605
mbed_official 532:fe11edbda85c 1606 do
mbed_official 532:fe11edbda85c 1607 {
mbed_official 532:fe11edbda85c 1608 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 1609 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 1610 {
mbed_official 532:fe11edbda85c 1611 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1612 {
mbed_official 532:fe11edbda85c 1613 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1614 }
mbed_official 532:fe11edbda85c 1615 else
mbed_official 532:fe11edbda85c 1616 {
mbed_official 532:fe11edbda85c 1617 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1618 }
mbed_official 532:fe11edbda85c 1619 }
mbed_official 532:fe11edbda85c 1620
mbed_official 532:fe11edbda85c 1621 /* Write data to DR */
mbed_official 532:fe11edbda85c 1622 hfmpi2c->Instance->TXDR = (*pData++);
mbed_official 532:fe11edbda85c 1623 Sizetmp--;
mbed_official 532:fe11edbda85c 1624 Size--;
mbed_official 532:fe11edbda85c 1625
mbed_official 532:fe11edbda85c 1626 if((Sizetmp == 0)&&(Size!=0))
mbed_official 532:fe11edbda85c 1627 {
mbed_official 532:fe11edbda85c 1628 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 1629 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 1630 {
mbed_official 532:fe11edbda85c 1631 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1632 }
mbed_official 532:fe11edbda85c 1633
mbed_official 532:fe11edbda85c 1634
mbed_official 532:fe11edbda85c 1635 if(Size > 255)
mbed_official 532:fe11edbda85c 1636 {
mbed_official 532:fe11edbda85c 1637 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1638 Sizetmp = 255;
mbed_official 532:fe11edbda85c 1639 }
mbed_official 532:fe11edbda85c 1640 else
mbed_official 532:fe11edbda85c 1641 {
mbed_official 532:fe11edbda85c 1642 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1643 Sizetmp = Size;
mbed_official 532:fe11edbda85c 1644 }
mbed_official 532:fe11edbda85c 1645 }
mbed_official 532:fe11edbda85c 1646
mbed_official 532:fe11edbda85c 1647 }while(Size > 0);
mbed_official 532:fe11edbda85c 1648
mbed_official 532:fe11edbda85c 1649 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 1650 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 1651 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 1652 {
mbed_official 532:fe11edbda85c 1653 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1654 {
mbed_official 532:fe11edbda85c 1655 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1656 }
mbed_official 532:fe11edbda85c 1657 else
mbed_official 532:fe11edbda85c 1658 {
mbed_official 532:fe11edbda85c 1659 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1660 }
mbed_official 532:fe11edbda85c 1661 }
mbed_official 532:fe11edbda85c 1662
mbed_official 532:fe11edbda85c 1663 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 1664 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 1665
mbed_official 532:fe11edbda85c 1666 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 1667 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 1668
mbed_official 532:fe11edbda85c 1669 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 1670
mbed_official 532:fe11edbda85c 1671 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1672 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1673
mbed_official 532:fe11edbda85c 1674 return HAL_OK;
mbed_official 532:fe11edbda85c 1675 }
mbed_official 532:fe11edbda85c 1676 else
mbed_official 532:fe11edbda85c 1677 {
mbed_official 532:fe11edbda85c 1678 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1679 }
mbed_official 532:fe11edbda85c 1680 }
mbed_official 532:fe11edbda85c 1681
mbed_official 532:fe11edbda85c 1682 /**
mbed_official 532:fe11edbda85c 1683 * @brief Read an amount of data in blocking mode from a specific memory address
mbed_official 532:fe11edbda85c 1684 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1685 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1686 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 1687 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 1688 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 1689 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1690 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1691 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 1692 * @retval HAL status
mbed_official 532:fe11edbda85c 1693 */
mbed_official 532:fe11edbda85c 1694 HAL_StatusTypeDef HAL_FMPI2C_Mem_Read(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 532:fe11edbda85c 1695 {
mbed_official 532:fe11edbda85c 1696 uint32_t Sizetmp = 0;
mbed_official 532:fe11edbda85c 1697
mbed_official 532:fe11edbda85c 1698 /* Check the parameters */
mbed_official 532:fe11edbda85c 1699 assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize));
mbed_official 532:fe11edbda85c 1700
mbed_official 532:fe11edbda85c 1701 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1702 {
mbed_official 532:fe11edbda85c 1703 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1704 {
mbed_official 532:fe11edbda85c 1705 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1706 }
mbed_official 532:fe11edbda85c 1707
mbed_official 532:fe11edbda85c 1708 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 1709 {
mbed_official 532:fe11edbda85c 1710 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1711 }
mbed_official 532:fe11edbda85c 1712
mbed_official 532:fe11edbda85c 1713 /* Process Locked */
mbed_official 532:fe11edbda85c 1714 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1715
mbed_official 532:fe11edbda85c 1716 hfmpi2c->State = HAL_FMPI2C_STATE_MEM_BUSY_RX;
mbed_official 532:fe11edbda85c 1717 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1718
mbed_official 532:fe11edbda85c 1719 /* Send Slave Address and Memory Address */
mbed_official 532:fe11edbda85c 1720 if(FMPI2C_RequestMemoryRead(hfmpi2c, DevAddress, MemAddress, MemAddSize, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 1721 {
mbed_official 532:fe11edbda85c 1722 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1723 {
mbed_official 532:fe11edbda85c 1724 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1725 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1726 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1727 }
mbed_official 532:fe11edbda85c 1728 else
mbed_official 532:fe11edbda85c 1729 {
mbed_official 532:fe11edbda85c 1730 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1731 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1732 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1733 }
mbed_official 532:fe11edbda85c 1734 }
mbed_official 532:fe11edbda85c 1735
mbed_official 532:fe11edbda85c 1736 /* Send Slave Address */
mbed_official 532:fe11edbda85c 1737 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 1738 /* Size > 255, need to set RELOAD bit */
mbed_official 532:fe11edbda85c 1739 if(Size > 255)
mbed_official 532:fe11edbda85c 1740 {
mbed_official 532:fe11edbda85c 1741 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1742 Sizetmp = 255;
mbed_official 532:fe11edbda85c 1743 }
mbed_official 532:fe11edbda85c 1744 else
mbed_official 532:fe11edbda85c 1745 {
mbed_official 532:fe11edbda85c 1746 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1747 Sizetmp = Size;
mbed_official 532:fe11edbda85c 1748 }
mbed_official 532:fe11edbda85c 1749
mbed_official 532:fe11edbda85c 1750 do
mbed_official 532:fe11edbda85c 1751 {
mbed_official 532:fe11edbda85c 1752 /* Wait until RXNE flag is set */
mbed_official 532:fe11edbda85c 1753 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 1754 {
mbed_official 532:fe11edbda85c 1755 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1756 }
mbed_official 532:fe11edbda85c 1757
mbed_official 532:fe11edbda85c 1758 /* Read data from RXDR */
mbed_official 532:fe11edbda85c 1759 (*pData++) = hfmpi2c->Instance->RXDR;
mbed_official 532:fe11edbda85c 1760
mbed_official 532:fe11edbda85c 1761 /* Decrement the Size counter */
mbed_official 532:fe11edbda85c 1762 Sizetmp--;
mbed_official 532:fe11edbda85c 1763 Size--;
mbed_official 532:fe11edbda85c 1764
mbed_official 532:fe11edbda85c 1765 if((Sizetmp == 0)&&(Size!=0))
mbed_official 532:fe11edbda85c 1766 {
mbed_official 532:fe11edbda85c 1767 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 1768 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 1769 {
mbed_official 532:fe11edbda85c 1770 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1771 }
mbed_official 532:fe11edbda85c 1772
mbed_official 532:fe11edbda85c 1773 if(Size > 255)
mbed_official 532:fe11edbda85c 1774 {
mbed_official 532:fe11edbda85c 1775 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1776 Sizetmp = 255;
mbed_official 532:fe11edbda85c 1777 }
mbed_official 532:fe11edbda85c 1778 else
mbed_official 532:fe11edbda85c 1779 {
mbed_official 532:fe11edbda85c 1780 FMPI2C_TransferConfig(hfmpi2c,DevAddress,Size, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1781 Sizetmp = Size;
mbed_official 532:fe11edbda85c 1782 }
mbed_official 532:fe11edbda85c 1783 }
mbed_official 532:fe11edbda85c 1784
mbed_official 532:fe11edbda85c 1785 }while(Size > 0);
mbed_official 532:fe11edbda85c 1786
mbed_official 532:fe11edbda85c 1787 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 1788 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 1789 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 1790 {
mbed_official 532:fe11edbda85c 1791 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1792 {
mbed_official 532:fe11edbda85c 1793 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1794 }
mbed_official 532:fe11edbda85c 1795 else
mbed_official 532:fe11edbda85c 1796 {
mbed_official 532:fe11edbda85c 1797 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1798 }
mbed_official 532:fe11edbda85c 1799 }
mbed_official 532:fe11edbda85c 1800
mbed_official 532:fe11edbda85c 1801 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 1802 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 1803
mbed_official 532:fe11edbda85c 1804 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 1805 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 1806
mbed_official 532:fe11edbda85c 1807 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 1808
mbed_official 532:fe11edbda85c 1809 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1810 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1811
mbed_official 532:fe11edbda85c 1812 return HAL_OK;
mbed_official 532:fe11edbda85c 1813 }
mbed_official 532:fe11edbda85c 1814 else
mbed_official 532:fe11edbda85c 1815 {
mbed_official 532:fe11edbda85c 1816 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1817 }
mbed_official 532:fe11edbda85c 1818 }
mbed_official 532:fe11edbda85c 1819 /**
mbed_official 532:fe11edbda85c 1820 * @brief Write an amount of data in no-blocking mode with Interrupt to a specific memory address
mbed_official 532:fe11edbda85c 1821 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1822 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1823 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 1824 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 1825 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 1826 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1827 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1828 * @retval HAL status
mbed_official 532:fe11edbda85c 1829 */
mbed_official 532:fe11edbda85c 1830 HAL_StatusTypeDef HAL_FMPI2C_Mem_Write_IT(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1831 {
mbed_official 532:fe11edbda85c 1832 /* Check the parameters */
mbed_official 532:fe11edbda85c 1833 assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize));
mbed_official 532:fe11edbda85c 1834
mbed_official 532:fe11edbda85c 1835 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1836 {
mbed_official 532:fe11edbda85c 1837 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1838 {
mbed_official 532:fe11edbda85c 1839 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1840 }
mbed_official 532:fe11edbda85c 1841
mbed_official 532:fe11edbda85c 1842 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 1843 {
mbed_official 532:fe11edbda85c 1844 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1845 }
mbed_official 532:fe11edbda85c 1846
mbed_official 532:fe11edbda85c 1847 /* Process Locked */
mbed_official 532:fe11edbda85c 1848 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1849
mbed_official 532:fe11edbda85c 1850 hfmpi2c->State = HAL_FMPI2C_STATE_MEM_BUSY_TX;
mbed_official 532:fe11edbda85c 1851 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 1852
mbed_official 532:fe11edbda85c 1853 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1854 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1855 if(Size > 255)
mbed_official 532:fe11edbda85c 1856 {
mbed_official 532:fe11edbda85c 1857 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 1858 }
mbed_official 532:fe11edbda85c 1859 else
mbed_official 532:fe11edbda85c 1860 {
mbed_official 532:fe11edbda85c 1861 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1862 }
mbed_official 532:fe11edbda85c 1863
mbed_official 532:fe11edbda85c 1864 /* Send Slave Address and Memory Address */
mbed_official 532:fe11edbda85c 1865 if(FMPI2C_RequestMemoryWrite(hfmpi2c, DevAddress, MemAddress, MemAddSize, FMPI2C_TIMEOUT_FLAG) != HAL_OK)
mbed_official 532:fe11edbda85c 1866 {
mbed_official 532:fe11edbda85c 1867 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1868 {
mbed_official 532:fe11edbda85c 1869 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1870 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1871 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1872 }
mbed_official 532:fe11edbda85c 1873 else
mbed_official 532:fe11edbda85c 1874 {
mbed_official 532:fe11edbda85c 1875 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1876 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1877 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1878 }
mbed_official 532:fe11edbda85c 1879 }
mbed_official 532:fe11edbda85c 1880
mbed_official 532:fe11edbda85c 1881 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 1882 /* Size > 255, need to set RELOAD bit */
mbed_official 532:fe11edbda85c 1883 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 1884 {
mbed_official 532:fe11edbda85c 1885 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1886 }
mbed_official 532:fe11edbda85c 1887 else
mbed_official 532:fe11edbda85c 1888 {
mbed_official 532:fe11edbda85c 1889 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 1890 }
mbed_official 532:fe11edbda85c 1891
mbed_official 532:fe11edbda85c 1892 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1893 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1894
mbed_official 532:fe11edbda85c 1895 /* Note : The FMPI2C interrupts must be enabled after unlocking current process
mbed_official 532:fe11edbda85c 1896 to avoid the risk of FMPI2C interrupt handle execution before current
mbed_official 532:fe11edbda85c 1897 process unlock */
mbed_official 532:fe11edbda85c 1898
mbed_official 532:fe11edbda85c 1899 /* Enable ERR, TC, STOP, NACK, TXI interrupt */
mbed_official 532:fe11edbda85c 1900 /* possible to enable all of these */
mbed_official 532:fe11edbda85c 1901 /* FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_TXI */
mbed_official 532:fe11edbda85c 1902 __HAL_FMPI2C_ENABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_TXI );
mbed_official 532:fe11edbda85c 1903
mbed_official 532:fe11edbda85c 1904 return HAL_OK;
mbed_official 532:fe11edbda85c 1905 }
mbed_official 532:fe11edbda85c 1906 else
mbed_official 532:fe11edbda85c 1907 {
mbed_official 532:fe11edbda85c 1908 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1909 }
mbed_official 532:fe11edbda85c 1910 }
mbed_official 532:fe11edbda85c 1911
mbed_official 532:fe11edbda85c 1912 /**
mbed_official 532:fe11edbda85c 1913 * @brief Read an amount of data in no-blocking mode with Interrupt from a specific memory address
mbed_official 532:fe11edbda85c 1914 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1915 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 1916 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 1917 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 1918 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 1919 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 1920 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 1921 * @retval HAL status
mbed_official 532:fe11edbda85c 1922 */
mbed_official 532:fe11edbda85c 1923 HAL_StatusTypeDef HAL_FMPI2C_Mem_Read_IT(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 1924 {
mbed_official 532:fe11edbda85c 1925 /* Check the parameters */
mbed_official 532:fe11edbda85c 1926 assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize));
mbed_official 532:fe11edbda85c 1927
mbed_official 532:fe11edbda85c 1928 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 1929 {
mbed_official 532:fe11edbda85c 1930 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 1931 {
mbed_official 532:fe11edbda85c 1932 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1933 }
mbed_official 532:fe11edbda85c 1934
mbed_official 532:fe11edbda85c 1935 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 1936 {
mbed_official 532:fe11edbda85c 1937 return HAL_BUSY;
mbed_official 532:fe11edbda85c 1938 }
mbed_official 532:fe11edbda85c 1939
mbed_official 532:fe11edbda85c 1940 /* Process Locked */
mbed_official 532:fe11edbda85c 1941 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1942
mbed_official 532:fe11edbda85c 1943 hfmpi2c->State = HAL_FMPI2C_STATE_MEM_BUSY_RX;
mbed_official 532:fe11edbda85c 1944
mbed_official 532:fe11edbda85c 1945 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 1946 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 1947 if(Size > 255)
mbed_official 532:fe11edbda85c 1948 {
mbed_official 532:fe11edbda85c 1949 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 1950 }
mbed_official 532:fe11edbda85c 1951 else
mbed_official 532:fe11edbda85c 1952 {
mbed_official 532:fe11edbda85c 1953 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 1954 }
mbed_official 532:fe11edbda85c 1955
mbed_official 532:fe11edbda85c 1956 /* Send Slave Address and Memory Address */
mbed_official 532:fe11edbda85c 1957 if(FMPI2C_RequestMemoryRead(hfmpi2c, DevAddress, MemAddress, MemAddSize, FMPI2C_TIMEOUT_FLAG) != HAL_OK)
mbed_official 532:fe11edbda85c 1958 {
mbed_official 532:fe11edbda85c 1959 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 1960 {
mbed_official 532:fe11edbda85c 1961 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1962 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1963 return HAL_ERROR;
mbed_official 532:fe11edbda85c 1964 }
mbed_official 532:fe11edbda85c 1965 else
mbed_official 532:fe11edbda85c 1966 {
mbed_official 532:fe11edbda85c 1967 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1968 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1969 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1970 }
mbed_official 532:fe11edbda85c 1971 }
mbed_official 532:fe11edbda85c 1972
mbed_official 532:fe11edbda85c 1973 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 1974 /* Size > 255, need to set RELOAD bit */
mbed_official 532:fe11edbda85c 1975 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 1976 {
mbed_official 532:fe11edbda85c 1977 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1978 }
mbed_official 532:fe11edbda85c 1979 else
mbed_official 532:fe11edbda85c 1980 {
mbed_official 532:fe11edbda85c 1981 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 1982 }
mbed_official 532:fe11edbda85c 1983
mbed_official 532:fe11edbda85c 1984 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1985 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 1986
mbed_official 532:fe11edbda85c 1987 /* Note : The FMPI2C interrupts must be enabled after unlocking current process
mbed_official 532:fe11edbda85c 1988 to avoid the risk of FMPI2C interrupt handle execution before current
mbed_official 532:fe11edbda85c 1989 process unlock */
mbed_official 532:fe11edbda85c 1990
mbed_official 532:fe11edbda85c 1991 /* Enable ERR, TC, STOP, NACK, RXI interrupt */
mbed_official 532:fe11edbda85c 1992 /* possible to enable all of these */
mbed_official 532:fe11edbda85c 1993 /* FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_TXI */
mbed_official 532:fe11edbda85c 1994 __HAL_FMPI2C_ENABLE_IT(hfmpi2c, FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_RXI );
mbed_official 532:fe11edbda85c 1995
mbed_official 532:fe11edbda85c 1996 return HAL_OK;
mbed_official 532:fe11edbda85c 1997 }
mbed_official 532:fe11edbda85c 1998 else
mbed_official 532:fe11edbda85c 1999 {
mbed_official 532:fe11edbda85c 2000 return HAL_BUSY;
mbed_official 532:fe11edbda85c 2001 }
mbed_official 532:fe11edbda85c 2002 }
mbed_official 532:fe11edbda85c 2003 /**
mbed_official 532:fe11edbda85c 2004 * @brief Write an amount of data in no-blocking mode with DMA to a specific memory address
mbed_official 532:fe11edbda85c 2005 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2006 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2007 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 2008 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 2009 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 2010 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 2011 * @param Size: Amount of data to be sent
mbed_official 532:fe11edbda85c 2012 * @retval HAL status
mbed_official 532:fe11edbda85c 2013 */
mbed_official 532:fe11edbda85c 2014 HAL_StatusTypeDef HAL_FMPI2C_Mem_Write_DMA(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 2015 {
mbed_official 532:fe11edbda85c 2016 /* Check the parameters */
mbed_official 532:fe11edbda85c 2017 assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize));
mbed_official 532:fe11edbda85c 2018
mbed_official 532:fe11edbda85c 2019 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 2020 {
mbed_official 532:fe11edbda85c 2021 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 2022 {
mbed_official 532:fe11edbda85c 2023 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2024 }
mbed_official 532:fe11edbda85c 2025
mbed_official 532:fe11edbda85c 2026 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 2027 {
mbed_official 532:fe11edbda85c 2028 return HAL_BUSY;
mbed_official 532:fe11edbda85c 2029 }
mbed_official 532:fe11edbda85c 2030
mbed_official 532:fe11edbda85c 2031 /* Process Locked */
mbed_official 532:fe11edbda85c 2032 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2033
mbed_official 532:fe11edbda85c 2034 hfmpi2c->State = HAL_FMPI2C_STATE_MEM_BUSY_TX;
mbed_official 532:fe11edbda85c 2035 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 2036
mbed_official 532:fe11edbda85c 2037 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 2038 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 2039 if(Size > 255)
mbed_official 532:fe11edbda85c 2040 {
mbed_official 532:fe11edbda85c 2041 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 2042 }
mbed_official 532:fe11edbda85c 2043 else
mbed_official 532:fe11edbda85c 2044 {
mbed_official 532:fe11edbda85c 2045 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 2046 }
mbed_official 532:fe11edbda85c 2047
mbed_official 532:fe11edbda85c 2048 /* Set the FMPI2C DMA transfer complete callback */
mbed_official 532:fe11edbda85c 2049 hfmpi2c->hdmatx->XferCpltCallback = FMPI2C_DMAMemTransmitCplt;
mbed_official 532:fe11edbda85c 2050
mbed_official 532:fe11edbda85c 2051 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 2052 hfmpi2c->hdmatx->XferErrorCallback = FMPI2C_DMAError;
mbed_official 532:fe11edbda85c 2053
mbed_official 532:fe11edbda85c 2054 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 2055 HAL_DMA_Start_IT(hfmpi2c->hdmatx, (uint32_t)pData, (uint32_t)&hfmpi2c->Instance->TXDR, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 2056
mbed_official 532:fe11edbda85c 2057 /* Send Slave Address and Memory Address */
mbed_official 532:fe11edbda85c 2058 if(FMPI2C_RequestMemoryWrite(hfmpi2c, DevAddress, MemAddress, MemAddSize, FMPI2C_TIMEOUT_FLAG) != HAL_OK)
mbed_official 532:fe11edbda85c 2059 {
mbed_official 532:fe11edbda85c 2060 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 2061 {
mbed_official 532:fe11edbda85c 2062 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2063 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2064 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2065 }
mbed_official 532:fe11edbda85c 2066 else
mbed_official 532:fe11edbda85c 2067 {
mbed_official 532:fe11edbda85c 2068 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2069 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2070 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2071 }
mbed_official 532:fe11edbda85c 2072 }
mbed_official 532:fe11edbda85c 2073
mbed_official 532:fe11edbda85c 2074 /* Send Slave Address */
mbed_official 532:fe11edbda85c 2075 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 2076 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 2077 {
mbed_official 532:fe11edbda85c 2078 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 2079 }
mbed_official 532:fe11edbda85c 2080 else
mbed_official 532:fe11edbda85c 2081 {
mbed_official 532:fe11edbda85c 2082 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 2083 }
mbed_official 532:fe11edbda85c 2084
mbed_official 532:fe11edbda85c 2085 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 2086 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_TXIS) != HAL_OK)
mbed_official 532:fe11edbda85c 2087 {
mbed_official 532:fe11edbda85c 2088 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 2089 {
mbed_official 532:fe11edbda85c 2090 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2091 }
mbed_official 532:fe11edbda85c 2092 else
mbed_official 532:fe11edbda85c 2093 {
mbed_official 532:fe11edbda85c 2094 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2095 }
mbed_official 532:fe11edbda85c 2096 }
mbed_official 532:fe11edbda85c 2097
mbed_official 532:fe11edbda85c 2098 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 2099 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 2100
mbed_official 532:fe11edbda85c 2101 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2102 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2103
mbed_official 532:fe11edbda85c 2104 return HAL_OK;
mbed_official 532:fe11edbda85c 2105 }
mbed_official 532:fe11edbda85c 2106 else
mbed_official 532:fe11edbda85c 2107 {
mbed_official 532:fe11edbda85c 2108 return HAL_BUSY;
mbed_official 532:fe11edbda85c 2109 }
mbed_official 532:fe11edbda85c 2110 }
mbed_official 532:fe11edbda85c 2111
mbed_official 532:fe11edbda85c 2112 /**
mbed_official 532:fe11edbda85c 2113 * @brief Reads an amount of data in no-blocking mode with DMA from a specific memory address.
mbed_official 532:fe11edbda85c 2114 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2115 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2116 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 2117 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 2118 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 2119 * @param pData: Pointer to data buffer
mbed_official 532:fe11edbda85c 2120 * @param Size: Amount of data to be read
mbed_official 532:fe11edbda85c 2121 * @retval HAL status
mbed_official 532:fe11edbda85c 2122 */
mbed_official 532:fe11edbda85c 2123 HAL_StatusTypeDef HAL_FMPI2C_Mem_Read_DMA(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)
mbed_official 532:fe11edbda85c 2124 {
mbed_official 532:fe11edbda85c 2125 /* Check the parameters */
mbed_official 532:fe11edbda85c 2126 assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize));
mbed_official 532:fe11edbda85c 2127
mbed_official 532:fe11edbda85c 2128 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 2129 {
mbed_official 532:fe11edbda85c 2130 if((pData == NULL) || (Size == 0))
mbed_official 532:fe11edbda85c 2131 {
mbed_official 532:fe11edbda85c 2132 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2133 }
mbed_official 532:fe11edbda85c 2134
mbed_official 532:fe11edbda85c 2135 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 2136 {
mbed_official 532:fe11edbda85c 2137 return HAL_BUSY;
mbed_official 532:fe11edbda85c 2138 }
mbed_official 532:fe11edbda85c 2139
mbed_official 532:fe11edbda85c 2140 /* Process Locked */
mbed_official 532:fe11edbda85c 2141 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2142
mbed_official 532:fe11edbda85c 2143 hfmpi2c->State = HAL_FMPI2C_STATE_MEM_BUSY_RX;
mbed_official 532:fe11edbda85c 2144
mbed_official 532:fe11edbda85c 2145 hfmpi2c->pBuffPtr = pData;
mbed_official 532:fe11edbda85c 2146 hfmpi2c->XferCount = Size;
mbed_official 532:fe11edbda85c 2147 if(Size > 255)
mbed_official 532:fe11edbda85c 2148 {
mbed_official 532:fe11edbda85c 2149 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 2150 }
mbed_official 532:fe11edbda85c 2151 else
mbed_official 532:fe11edbda85c 2152 {
mbed_official 532:fe11edbda85c 2153 hfmpi2c->XferSize = Size;
mbed_official 532:fe11edbda85c 2154 }
mbed_official 532:fe11edbda85c 2155
mbed_official 532:fe11edbda85c 2156 /* Set the FMPI2C DMA transfer complete callback */
mbed_official 532:fe11edbda85c 2157 hfmpi2c->hdmarx->XferCpltCallback = FMPI2C_DMAMemReceiveCplt;
mbed_official 532:fe11edbda85c 2158
mbed_official 532:fe11edbda85c 2159 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 2160 hfmpi2c->hdmarx->XferErrorCallback = FMPI2C_DMAError;
mbed_official 532:fe11edbda85c 2161
mbed_official 532:fe11edbda85c 2162 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 2163 HAL_DMA_Start_IT(hfmpi2c->hdmarx, (uint32_t)&hfmpi2c->Instance->RXDR, (uint32_t)pData, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 2164
mbed_official 532:fe11edbda85c 2165 /* Send Slave Address and Memory Address */
mbed_official 532:fe11edbda85c 2166 if(FMPI2C_RequestMemoryRead(hfmpi2c, DevAddress, MemAddress, MemAddSize, FMPI2C_TIMEOUT_FLAG) != HAL_OK)
mbed_official 532:fe11edbda85c 2167 {
mbed_official 532:fe11edbda85c 2168 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 2169 {
mbed_official 532:fe11edbda85c 2170 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2171 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2172 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2173 }
mbed_official 532:fe11edbda85c 2174 else
mbed_official 532:fe11edbda85c 2175 {
mbed_official 532:fe11edbda85c 2176 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2177 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2178 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2179 }
mbed_official 532:fe11edbda85c 2180 }
mbed_official 532:fe11edbda85c 2181
mbed_official 532:fe11edbda85c 2182 /* Set NBYTES to write and reload if size > 255 and generate RESTART */
mbed_official 532:fe11edbda85c 2183 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 2184 {
mbed_official 532:fe11edbda85c 2185 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 2186 }
mbed_official 532:fe11edbda85c 2187 else
mbed_official 532:fe11edbda85c 2188 {
mbed_official 532:fe11edbda85c 2189 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_GENERATE_START_READ);
mbed_official 532:fe11edbda85c 2190 }
mbed_official 532:fe11edbda85c 2191
mbed_official 532:fe11edbda85c 2192 /* Wait until RXNE flag is set */
mbed_official 532:fe11edbda85c 2193 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_RXNE, RESET, FMPI2C_TIMEOUT_RXNE) != HAL_OK)
mbed_official 532:fe11edbda85c 2194 {
mbed_official 532:fe11edbda85c 2195 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2196 }
mbed_official 532:fe11edbda85c 2197
mbed_official 532:fe11edbda85c 2198 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 2199 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 2200
mbed_official 532:fe11edbda85c 2201 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2202 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2203
mbed_official 532:fe11edbda85c 2204 return HAL_OK;
mbed_official 532:fe11edbda85c 2205 }
mbed_official 532:fe11edbda85c 2206 else
mbed_official 532:fe11edbda85c 2207 {
mbed_official 532:fe11edbda85c 2208 return HAL_BUSY;
mbed_official 532:fe11edbda85c 2209 }
mbed_official 532:fe11edbda85c 2210 }
mbed_official 532:fe11edbda85c 2211
mbed_official 532:fe11edbda85c 2212 /**
mbed_official 532:fe11edbda85c 2213 * @brief Checks if target device is ready for communication.
mbed_official 532:fe11edbda85c 2214 * @note This function is used with Memory devices
mbed_official 532:fe11edbda85c 2215 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2216 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2217 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 2218 * @param Trials: Number of trials
mbed_official 532:fe11edbda85c 2219 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 2220 * @retval HAL status
mbed_official 532:fe11edbda85c 2221 */
mbed_official 532:fe11edbda85c 2222 HAL_StatusTypeDef HAL_FMPI2C_IsDeviceReady(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint32_t Trials, uint32_t Timeout)
mbed_official 532:fe11edbda85c 2223 {
mbed_official 532:fe11edbda85c 2224 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 2225
mbed_official 532:fe11edbda85c 2226 __IO uint32_t FMPI2C_Trials = 0;
mbed_official 532:fe11edbda85c 2227
mbed_official 532:fe11edbda85c 2228 if(hfmpi2c->State == HAL_FMPI2C_STATE_READY)
mbed_official 532:fe11edbda85c 2229 {
mbed_official 532:fe11edbda85c 2230 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BUSY) == SET)
mbed_official 532:fe11edbda85c 2231 {
mbed_official 532:fe11edbda85c 2232 return HAL_BUSY;
mbed_official 532:fe11edbda85c 2233 }
mbed_official 532:fe11edbda85c 2234
mbed_official 532:fe11edbda85c 2235 /* Process Locked */
mbed_official 532:fe11edbda85c 2236 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2237
mbed_official 532:fe11edbda85c 2238 hfmpi2c->State = HAL_FMPI2C_STATE_BUSY;
mbed_official 532:fe11edbda85c 2239 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 2240
mbed_official 532:fe11edbda85c 2241 do
mbed_official 532:fe11edbda85c 2242 {
mbed_official 532:fe11edbda85c 2243 /* Generate Start */
mbed_official 532:fe11edbda85c 2244 hfmpi2c->Instance->CR2 = __HAL_FMPI2C_GENERATE_START(hfmpi2c->Init.AddressingMode,DevAddress);
mbed_official 532:fe11edbda85c 2245
mbed_official 532:fe11edbda85c 2246 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 2247 /* Wait until STOPF flag is set or a NACK flag is set*/
mbed_official 532:fe11edbda85c 2248 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 2249 while((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == RESET) && (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == RESET) && (hfmpi2c->State != HAL_FMPI2C_STATE_TIMEOUT))
mbed_official 532:fe11edbda85c 2250 {
mbed_official 532:fe11edbda85c 2251 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 2252 {
mbed_official 532:fe11edbda85c 2253 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 2254 {
mbed_official 532:fe11edbda85c 2255 /* Device is ready */
mbed_official 532:fe11edbda85c 2256 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2257 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2258 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2259 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2260 }
mbed_official 532:fe11edbda85c 2261 }
mbed_official 532:fe11edbda85c 2262 }
mbed_official 532:fe11edbda85c 2263
mbed_official 532:fe11edbda85c 2264 /* Check if the NACKF flag has not been set */
mbed_official 532:fe11edbda85c 2265 if (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == RESET)
mbed_official 532:fe11edbda85c 2266 {
mbed_official 532:fe11edbda85c 2267 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 2268 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 2269 {
mbed_official 532:fe11edbda85c 2270 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2271 }
mbed_official 532:fe11edbda85c 2272
mbed_official 532:fe11edbda85c 2273 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 2274 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 2275
mbed_official 532:fe11edbda85c 2276 /* Device is ready */
mbed_official 532:fe11edbda85c 2277 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2278
mbed_official 532:fe11edbda85c 2279 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2280 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2281
mbed_official 532:fe11edbda85c 2282 return HAL_OK;
mbed_official 532:fe11edbda85c 2283 }
mbed_official 532:fe11edbda85c 2284 else
mbed_official 532:fe11edbda85c 2285 {
mbed_official 532:fe11edbda85c 2286 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 2287 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 2288 {
mbed_official 532:fe11edbda85c 2289 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2290 }
mbed_official 532:fe11edbda85c 2291
mbed_official 532:fe11edbda85c 2292 /* Clear NACK Flag */
mbed_official 532:fe11edbda85c 2293 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_AF);
mbed_official 532:fe11edbda85c 2294
mbed_official 532:fe11edbda85c 2295 /* Clear STOP Flag, auto generated with autoend*/
mbed_official 532:fe11edbda85c 2296 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 2297 }
mbed_official 532:fe11edbda85c 2298
mbed_official 532:fe11edbda85c 2299 /* Check if the maximum allowed number of trials has been reached */
mbed_official 532:fe11edbda85c 2300 if (FMPI2C_Trials++ == Trials)
mbed_official 532:fe11edbda85c 2301 {
mbed_official 532:fe11edbda85c 2302 /* Generate Stop */
mbed_official 532:fe11edbda85c 2303 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_STOP;
mbed_official 532:fe11edbda85c 2304
mbed_official 532:fe11edbda85c 2305 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 2306 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 2307 {
mbed_official 532:fe11edbda85c 2308 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2309 }
mbed_official 532:fe11edbda85c 2310
mbed_official 532:fe11edbda85c 2311 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 2312 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 2313 }
mbed_official 532:fe11edbda85c 2314 }while(FMPI2C_Trials < Trials);
mbed_official 532:fe11edbda85c 2315
mbed_official 532:fe11edbda85c 2316 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2317
mbed_official 532:fe11edbda85c 2318 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2319 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2320
mbed_official 532:fe11edbda85c 2321 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2322 }
mbed_official 532:fe11edbda85c 2323 else
mbed_official 532:fe11edbda85c 2324 {
mbed_official 532:fe11edbda85c 2325 return HAL_BUSY;
mbed_official 532:fe11edbda85c 2326 }
mbed_official 532:fe11edbda85c 2327 }
mbed_official 532:fe11edbda85c 2328
mbed_official 532:fe11edbda85c 2329 /**
mbed_official 532:fe11edbda85c 2330 * @brief This function handles FMPI2C event interrupt request.
mbed_official 532:fe11edbda85c 2331 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2332 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2333 * @retval None
mbed_official 532:fe11edbda85c 2334 */
mbed_official 532:fe11edbda85c 2335 void HAL_FMPI2C_EV_IRQHandler(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2336 {
mbed_official 532:fe11edbda85c 2337 /* FMPI2C in mode Transmitter ---------------------------------------------------*/
mbed_official 532:fe11edbda85c 2338 if (((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TXIS) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TCR) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TC) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_ADDR) == SET)) && (__HAL_FMPI2C_GET_IT_SOURCE(hfmpi2c, (FMPI2C_IT_TCI | FMPI2C_IT_STOPI | FMPI2C_IT_NACKI | FMPI2C_IT_TXI | FMPI2C_IT_ADDRI)) == SET))
mbed_official 532:fe11edbda85c 2339 {
mbed_official 532:fe11edbda85c 2340 /* Slave mode selected */
mbed_official 532:fe11edbda85c 2341 if (hfmpi2c->State == HAL_FMPI2C_STATE_SLAVE_BUSY_TX)
mbed_official 532:fe11edbda85c 2342 {
mbed_official 532:fe11edbda85c 2343 FMPI2C_SlaveTransmit_ISR(hfmpi2c);
mbed_official 532:fe11edbda85c 2344 }
mbed_official 532:fe11edbda85c 2345 }
mbed_official 532:fe11edbda85c 2346
mbed_official 532:fe11edbda85c 2347 if (((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TXIS) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TCR) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TC) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == SET)) && (__HAL_FMPI2C_GET_IT_SOURCE(hfmpi2c, (FMPI2C_IT_TCI | FMPI2C_IT_STOPI | FMPI2C_IT_NACKI | FMPI2C_IT_TXI)) == SET))
mbed_official 532:fe11edbda85c 2348 {
mbed_official 532:fe11edbda85c 2349 /* Master mode selected */
mbed_official 532:fe11edbda85c 2350 if ((hfmpi2c->State == HAL_FMPI2C_STATE_MASTER_BUSY_TX) || (hfmpi2c->State == HAL_FMPI2C_STATE_MEM_BUSY_TX))
mbed_official 532:fe11edbda85c 2351 {
mbed_official 532:fe11edbda85c 2352 FMPI2C_MasterTransmit_ISR(hfmpi2c);
mbed_official 532:fe11edbda85c 2353 }
mbed_official 532:fe11edbda85c 2354 }
mbed_official 532:fe11edbda85c 2355
mbed_official 532:fe11edbda85c 2356 /* FMPI2C in mode Receiver ----------------------------------------------------*/
mbed_official 532:fe11edbda85c 2357 if (((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_RXNE) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TCR) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TC) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_ADDR) == SET)) && (__HAL_FMPI2C_GET_IT_SOURCE(hfmpi2c, (FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_RXI | FMPI2C_IT_ADDRI)) == SET))
mbed_official 532:fe11edbda85c 2358 {
mbed_official 532:fe11edbda85c 2359 /* Slave mode selected */
mbed_official 532:fe11edbda85c 2360 if (hfmpi2c->State == HAL_FMPI2C_STATE_SLAVE_BUSY_RX)
mbed_official 532:fe11edbda85c 2361 {
mbed_official 532:fe11edbda85c 2362 FMPI2C_SlaveReceive_ISR(hfmpi2c);
mbed_official 532:fe11edbda85c 2363 }
mbed_official 532:fe11edbda85c 2364 }
mbed_official 532:fe11edbda85c 2365 if (((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_RXNE) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TCR) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TC) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET) || (__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == SET)) && (__HAL_FMPI2C_GET_IT_SOURCE(hfmpi2c, (FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_RXI)) == SET))
mbed_official 532:fe11edbda85c 2366 {
mbed_official 532:fe11edbda85c 2367 /* Master mode selected */
mbed_official 532:fe11edbda85c 2368 if ((hfmpi2c->State == HAL_FMPI2C_STATE_MASTER_BUSY_RX) || (hfmpi2c->State == HAL_FMPI2C_STATE_MEM_BUSY_RX))
mbed_official 532:fe11edbda85c 2369 {
mbed_official 532:fe11edbda85c 2370 FMPI2C_MasterReceive_ISR(hfmpi2c);
mbed_official 532:fe11edbda85c 2371 }
mbed_official 532:fe11edbda85c 2372 }
mbed_official 532:fe11edbda85c 2373 }
mbed_official 532:fe11edbda85c 2374
mbed_official 532:fe11edbda85c 2375 /**
mbed_official 532:fe11edbda85c 2376 * @brief This function handles FMPI2C error interrupt request.
mbed_official 532:fe11edbda85c 2377 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2378 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2379 * @retval None
mbed_official 532:fe11edbda85c 2380 */
mbed_official 532:fe11edbda85c 2381 void HAL_FMPI2C_ER_IRQHandler(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2382 {
mbed_official 532:fe11edbda85c 2383 /* FMPI2C Bus error interrupt occurred ------------------------------------*/
mbed_official 532:fe11edbda85c 2384 if((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_BERR) == SET) && (__HAL_FMPI2C_GET_IT_SOURCE(hfmpi2c, FMPI2C_IT_ERRI) == SET))
mbed_official 532:fe11edbda85c 2385 {
mbed_official 532:fe11edbda85c 2386 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_BERR;
mbed_official 532:fe11edbda85c 2387
mbed_official 532:fe11edbda85c 2388 /* Clear BERR flag */
mbed_official 532:fe11edbda85c 2389 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_BERR);
mbed_official 532:fe11edbda85c 2390 }
mbed_official 532:fe11edbda85c 2391
mbed_official 532:fe11edbda85c 2392 /* FMPI2C Over-Run/Under-Run interrupt occurred ----------------------------------------*/
mbed_official 532:fe11edbda85c 2393 if((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_OVR) == SET) && (__HAL_FMPI2C_GET_IT_SOURCE(hfmpi2c, FMPI2C_IT_ERRI) == SET))
mbed_official 532:fe11edbda85c 2394 {
mbed_official 532:fe11edbda85c 2395 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_OVR;
mbed_official 532:fe11edbda85c 2396
mbed_official 532:fe11edbda85c 2397 /* Clear OVR flag */
mbed_official 532:fe11edbda85c 2398 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_OVR);
mbed_official 532:fe11edbda85c 2399 }
mbed_official 532:fe11edbda85c 2400
mbed_official 532:fe11edbda85c 2401 /* FMPI2C Arbitration Loss error interrupt occurred -------------------------------------*/
mbed_official 532:fe11edbda85c 2402 if((__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_ARLO) == SET) && (__HAL_FMPI2C_GET_IT_SOURCE(hfmpi2c, FMPI2C_IT_ERRI) == SET))
mbed_official 532:fe11edbda85c 2403 {
mbed_official 532:fe11edbda85c 2404 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_ARLO;
mbed_official 532:fe11edbda85c 2405
mbed_official 532:fe11edbda85c 2406 /* Clear ARLO flag */
mbed_official 532:fe11edbda85c 2407 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_ARLO);
mbed_official 532:fe11edbda85c 2408 }
mbed_official 532:fe11edbda85c 2409
mbed_official 532:fe11edbda85c 2410 /* Call the Error Callback in case of Error detected */
mbed_official 532:fe11edbda85c 2411 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 2412 {
mbed_official 532:fe11edbda85c 2413 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2414
mbed_official 532:fe11edbda85c 2415 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2416 }
mbed_official 532:fe11edbda85c 2417 }
mbed_official 532:fe11edbda85c 2418
mbed_official 532:fe11edbda85c 2419 /**
mbed_official 532:fe11edbda85c 2420 * @brief Master Tx Transfer completed callbacks.
mbed_official 532:fe11edbda85c 2421 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2422 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2423 * @retval None
mbed_official 532:fe11edbda85c 2424 */
mbed_official 532:fe11edbda85c 2425 __weak void HAL_FMPI2C_MasterTxCpltCallback(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2426 {
mbed_official 532:fe11edbda85c 2427 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 2428 the HAL_FMPI2C_TxCpltCallback could be implemented in the user file
mbed_official 532:fe11edbda85c 2429 */
mbed_official 532:fe11edbda85c 2430 }
mbed_official 532:fe11edbda85c 2431
mbed_official 532:fe11edbda85c 2432 /**
mbed_official 532:fe11edbda85c 2433 * @brief Master Rx Transfer completed callbacks.
mbed_official 532:fe11edbda85c 2434 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2435 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2436 * @retval None
mbed_official 532:fe11edbda85c 2437 */
mbed_official 532:fe11edbda85c 2438 __weak void HAL_FMPI2C_MasterRxCpltCallback(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2439 {
mbed_official 532:fe11edbda85c 2440 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 2441 the HAL_FMPI2C_TxCpltCallback could be implemented in the user file
mbed_official 532:fe11edbda85c 2442 */
mbed_official 532:fe11edbda85c 2443 }
mbed_official 532:fe11edbda85c 2444
mbed_official 532:fe11edbda85c 2445 /** @brief Slave Tx Transfer completed callbacks.
mbed_official 532:fe11edbda85c 2446 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2447 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2448 * @retval None
mbed_official 532:fe11edbda85c 2449 */
mbed_official 532:fe11edbda85c 2450 __weak void HAL_FMPI2C_SlaveTxCpltCallback(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2451 {
mbed_official 532:fe11edbda85c 2452 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 2453 the HAL_FMPI2C_TxCpltCallback could be implemented in the user file
mbed_official 532:fe11edbda85c 2454 */
mbed_official 532:fe11edbda85c 2455 }
mbed_official 532:fe11edbda85c 2456
mbed_official 532:fe11edbda85c 2457 /**
mbed_official 532:fe11edbda85c 2458 * @brief Slave Rx Transfer completed callbacks.
mbed_official 532:fe11edbda85c 2459 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2460 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2461 * @retval None
mbed_official 532:fe11edbda85c 2462 */
mbed_official 532:fe11edbda85c 2463 __weak void HAL_FMPI2C_SlaveRxCpltCallback(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2464 {
mbed_official 532:fe11edbda85c 2465 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 2466 the HAL_FMPI2C_TxCpltCallback could be implemented in the user file
mbed_official 532:fe11edbda85c 2467 */
mbed_official 532:fe11edbda85c 2468 }
mbed_official 532:fe11edbda85c 2469
mbed_official 532:fe11edbda85c 2470 /**
mbed_official 532:fe11edbda85c 2471 * @brief Memory Tx Transfer completed callbacks.
mbed_official 532:fe11edbda85c 2472 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2473 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2474 * @retval None
mbed_official 532:fe11edbda85c 2475 */
mbed_official 532:fe11edbda85c 2476 __weak void HAL_FMPI2C_MemTxCpltCallback(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2477 {
mbed_official 532:fe11edbda85c 2478 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 2479 the HAL_FMPI2C_TxCpltCallback could be implemented in the user file
mbed_official 532:fe11edbda85c 2480 */
mbed_official 532:fe11edbda85c 2481 }
mbed_official 532:fe11edbda85c 2482
mbed_official 532:fe11edbda85c 2483 /**
mbed_official 532:fe11edbda85c 2484 * @brief Memory Rx Transfer completed callbacks.
mbed_official 532:fe11edbda85c 2485 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2486 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2487 * @retval None
mbed_official 532:fe11edbda85c 2488 */
mbed_official 532:fe11edbda85c 2489 __weak void HAL_FMPI2C_MemRxCpltCallback(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2490 {
mbed_official 532:fe11edbda85c 2491 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 2492 the HAL_FMPI2C_TxCpltCallback could be implemented in the user file
mbed_official 532:fe11edbda85c 2493 */
mbed_official 532:fe11edbda85c 2494 }
mbed_official 532:fe11edbda85c 2495
mbed_official 532:fe11edbda85c 2496 /**
mbed_official 532:fe11edbda85c 2497 * @brief FMPI2C error callbacks.
mbed_official 532:fe11edbda85c 2498 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2499 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2500 * @retval None
mbed_official 532:fe11edbda85c 2501 */
mbed_official 532:fe11edbda85c 2502 __weak void HAL_FMPI2C_ErrorCallback(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2503 {
mbed_official 532:fe11edbda85c 2504 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 532:fe11edbda85c 2505 the HAL_FMPI2C_ErrorCallback could be implemented in the user file
mbed_official 532:fe11edbda85c 2506 */
mbed_official 532:fe11edbda85c 2507 }
mbed_official 532:fe11edbda85c 2508
mbed_official 532:fe11edbda85c 2509 /**
mbed_official 532:fe11edbda85c 2510 * @}
mbed_official 532:fe11edbda85c 2511 */
mbed_official 532:fe11edbda85c 2512
mbed_official 532:fe11edbda85c 2513 /** @defgroup FMPI2C_Exported_Functions_Group3 Peripheral State and Errors functions
mbed_official 532:fe11edbda85c 2514 * @brief Peripheral State and Errors functions
mbed_official 532:fe11edbda85c 2515 *
mbed_official 532:fe11edbda85c 2516 @verbatim
mbed_official 532:fe11edbda85c 2517 ===============================================================================
mbed_official 532:fe11edbda85c 2518 ##### Peripheral State and Errors functions #####
mbed_official 532:fe11edbda85c 2519 ===============================================================================
mbed_official 532:fe11edbda85c 2520 [..]
mbed_official 532:fe11edbda85c 2521 This subsection permit to get in run-time the status of the peripheral
mbed_official 532:fe11edbda85c 2522 and the data flow.
mbed_official 532:fe11edbda85c 2523
mbed_official 532:fe11edbda85c 2524 @endverbatim
mbed_official 532:fe11edbda85c 2525 * @{
mbed_official 532:fe11edbda85c 2526 */
mbed_official 532:fe11edbda85c 2527
mbed_official 532:fe11edbda85c 2528 /**
mbed_official 532:fe11edbda85c 2529 * @brief Returns the FMPI2C state.
mbed_official 532:fe11edbda85c 2530 * @param hfmpi2c : FMPI2C handle
mbed_official 532:fe11edbda85c 2531 * @retval HAL state
mbed_official 532:fe11edbda85c 2532 */
mbed_official 532:fe11edbda85c 2533 HAL_FMPI2C_StateTypeDef HAL_FMPI2C_GetState(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2534 {
mbed_official 532:fe11edbda85c 2535 return hfmpi2c->State;
mbed_official 532:fe11edbda85c 2536 }
mbed_official 532:fe11edbda85c 2537
mbed_official 532:fe11edbda85c 2538 /**
mbed_official 532:fe11edbda85c 2539 * @brief Return the FMPI2C error code
mbed_official 532:fe11edbda85c 2540 * @param hfmpi2c : pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2541 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2542 * @retval FMPI2C Error Code
mbed_official 532:fe11edbda85c 2543 */
mbed_official 532:fe11edbda85c 2544 uint32_t HAL_FMPI2C_GetError(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2545 {
mbed_official 532:fe11edbda85c 2546 return hfmpi2c->ErrorCode;
mbed_official 532:fe11edbda85c 2547 }
mbed_official 532:fe11edbda85c 2548
mbed_official 532:fe11edbda85c 2549 /**
mbed_official 532:fe11edbda85c 2550 * @}
mbed_official 532:fe11edbda85c 2551 */
mbed_official 532:fe11edbda85c 2552
mbed_official 532:fe11edbda85c 2553 /**
mbed_official 532:fe11edbda85c 2554 * @brief Handle Interrupt Flags Master Transmit Mode
mbed_official 532:fe11edbda85c 2555 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2556 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2557 * @retval HAL status
mbed_official 532:fe11edbda85c 2558 */
mbed_official 532:fe11edbda85c 2559 static HAL_StatusTypeDef FMPI2C_MasterTransmit_ISR(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2560 {
mbed_official 532:fe11edbda85c 2561 uint16_t DevAddress;
mbed_official 532:fe11edbda85c 2562
mbed_official 532:fe11edbda85c 2563 /* Process Locked */
mbed_official 532:fe11edbda85c 2564 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2565
mbed_official 532:fe11edbda85c 2566 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TXIS) == SET)
mbed_official 532:fe11edbda85c 2567 {
mbed_official 532:fe11edbda85c 2568 /* Write data to TXDR */
mbed_official 532:fe11edbda85c 2569 hfmpi2c->Instance->TXDR = (*hfmpi2c->pBuffPtr++);
mbed_official 532:fe11edbda85c 2570 hfmpi2c->XferSize--;
mbed_official 532:fe11edbda85c 2571 hfmpi2c->XferCount--;
mbed_official 532:fe11edbda85c 2572 }
mbed_official 532:fe11edbda85c 2573 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TCR) == SET)
mbed_official 532:fe11edbda85c 2574 {
mbed_official 532:fe11edbda85c 2575 if((hfmpi2c->XferSize == 0)&&(hfmpi2c->XferCount!=0))
mbed_official 532:fe11edbda85c 2576 {
mbed_official 532:fe11edbda85c 2577 DevAddress = (hfmpi2c->Instance->CR2 & FMPI2C_CR2_SADD);
mbed_official 532:fe11edbda85c 2578
mbed_official 532:fe11edbda85c 2579 if(hfmpi2c->XferCount > 255)
mbed_official 532:fe11edbda85c 2580 {
mbed_official 532:fe11edbda85c 2581 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 2582 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 2583 }
mbed_official 532:fe11edbda85c 2584 else
mbed_official 532:fe11edbda85c 2585 {
mbed_official 532:fe11edbda85c 2586 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferCount, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 2587 hfmpi2c->XferSize = hfmpi2c->XferCount;
mbed_official 532:fe11edbda85c 2588 }
mbed_official 532:fe11edbda85c 2589 }
mbed_official 532:fe11edbda85c 2590 else
mbed_official 532:fe11edbda85c 2591 {
mbed_official 532:fe11edbda85c 2592 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2593 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2594
mbed_official 532:fe11edbda85c 2595 /* Wrong size Status regarding TCR flag event */
mbed_official 532:fe11edbda85c 2596 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_SIZE;
mbed_official 532:fe11edbda85c 2597 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2598 }
mbed_official 532:fe11edbda85c 2599 }
mbed_official 532:fe11edbda85c 2600 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TC) == SET)
mbed_official 532:fe11edbda85c 2601 {
mbed_official 532:fe11edbda85c 2602 if(hfmpi2c->XferCount == 0)
mbed_official 532:fe11edbda85c 2603 {
mbed_official 532:fe11edbda85c 2604 /* Generate Stop */
mbed_official 532:fe11edbda85c 2605 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_STOP;
mbed_official 532:fe11edbda85c 2606 }
mbed_official 532:fe11edbda85c 2607 else
mbed_official 532:fe11edbda85c 2608 {
mbed_official 532:fe11edbda85c 2609 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2610 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2611
mbed_official 532:fe11edbda85c 2612 /* Wrong size Status regarding TCR flag event */
mbed_official 532:fe11edbda85c 2613 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_SIZE;
mbed_official 532:fe11edbda85c 2614 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2615 }
mbed_official 532:fe11edbda85c 2616 }
mbed_official 532:fe11edbda85c 2617 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET)
mbed_official 532:fe11edbda85c 2618 {
mbed_official 532:fe11edbda85c 2619 /* Disable ERR, TC, STOP, NACK, TXI interrupt */
mbed_official 532:fe11edbda85c 2620 __HAL_FMPI2C_DISABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_TXI );
mbed_official 532:fe11edbda85c 2621
mbed_official 532:fe11edbda85c 2622 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 2623 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 2624
mbed_official 532:fe11edbda85c 2625 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 2626 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 2627
mbed_official 532:fe11edbda85c 2628 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2629
mbed_official 532:fe11edbda85c 2630 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2631 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2632
mbed_official 532:fe11edbda85c 2633 if(hfmpi2c->State == HAL_FMPI2C_STATE_MEM_BUSY_TX)
mbed_official 532:fe11edbda85c 2634 {
mbed_official 532:fe11edbda85c 2635 HAL_FMPI2C_MemTxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2636 }
mbed_official 532:fe11edbda85c 2637 else
mbed_official 532:fe11edbda85c 2638 {
mbed_official 532:fe11edbda85c 2639 HAL_FMPI2C_MasterTxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2640 }
mbed_official 532:fe11edbda85c 2641 }
mbed_official 532:fe11edbda85c 2642 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == SET)
mbed_official 532:fe11edbda85c 2643 {
mbed_official 532:fe11edbda85c 2644 /* Clear NACK Flag */
mbed_official 532:fe11edbda85c 2645 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_AF);
mbed_official 532:fe11edbda85c 2646
mbed_official 532:fe11edbda85c 2647 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2648 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2649
mbed_official 532:fe11edbda85c 2650 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 2651 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2652 }
mbed_official 532:fe11edbda85c 2653
mbed_official 532:fe11edbda85c 2654 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2655 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2656
mbed_official 532:fe11edbda85c 2657 return HAL_OK;
mbed_official 532:fe11edbda85c 2658 }
mbed_official 532:fe11edbda85c 2659
mbed_official 532:fe11edbda85c 2660 /**
mbed_official 532:fe11edbda85c 2661 * @brief Handle Interrupt Flags Master Receive Mode
mbed_official 532:fe11edbda85c 2662 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2663 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2664 * @retval HAL status
mbed_official 532:fe11edbda85c 2665 */
mbed_official 532:fe11edbda85c 2666 static HAL_StatusTypeDef FMPI2C_MasterReceive_ISR(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2667 {
mbed_official 532:fe11edbda85c 2668 uint16_t DevAddress;
mbed_official 532:fe11edbda85c 2669
mbed_official 532:fe11edbda85c 2670 /* Process Locked */
mbed_official 532:fe11edbda85c 2671 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2672
mbed_official 532:fe11edbda85c 2673 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_RXNE) == SET)
mbed_official 532:fe11edbda85c 2674 {
mbed_official 532:fe11edbda85c 2675 /* Read data from RXDR */
mbed_official 532:fe11edbda85c 2676 (*hfmpi2c->pBuffPtr++) = hfmpi2c->Instance->RXDR;
mbed_official 532:fe11edbda85c 2677 hfmpi2c->XferSize--;
mbed_official 532:fe11edbda85c 2678 hfmpi2c->XferCount--;
mbed_official 532:fe11edbda85c 2679 }
mbed_official 532:fe11edbda85c 2680 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TCR) == SET)
mbed_official 532:fe11edbda85c 2681 {
mbed_official 532:fe11edbda85c 2682 if((hfmpi2c->XferSize == 0)&&(hfmpi2c->XferCount!=0))
mbed_official 532:fe11edbda85c 2683 {
mbed_official 532:fe11edbda85c 2684 DevAddress = (hfmpi2c->Instance->CR2 & FMPI2C_CR2_SADD);
mbed_official 532:fe11edbda85c 2685
mbed_official 532:fe11edbda85c 2686 if(hfmpi2c->XferCount > 255)
mbed_official 532:fe11edbda85c 2687 {
mbed_official 532:fe11edbda85c 2688 FMPI2C_TransferConfig(hfmpi2c,DevAddress,255, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 2689 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 2690 }
mbed_official 532:fe11edbda85c 2691 else
mbed_official 532:fe11edbda85c 2692 {
mbed_official 532:fe11edbda85c 2693 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferCount, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 2694 hfmpi2c->XferSize = hfmpi2c->XferCount;
mbed_official 532:fe11edbda85c 2695 }
mbed_official 532:fe11edbda85c 2696 }
mbed_official 532:fe11edbda85c 2697 else
mbed_official 532:fe11edbda85c 2698 {
mbed_official 532:fe11edbda85c 2699 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2700 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2701
mbed_official 532:fe11edbda85c 2702 /* Wrong size Status regarding TCR flag event */
mbed_official 532:fe11edbda85c 2703 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_SIZE;
mbed_official 532:fe11edbda85c 2704 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2705 }
mbed_official 532:fe11edbda85c 2706 }
mbed_official 532:fe11edbda85c 2707 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TC) == SET)
mbed_official 532:fe11edbda85c 2708 {
mbed_official 532:fe11edbda85c 2709 if(hfmpi2c->XferCount == 0)
mbed_official 532:fe11edbda85c 2710 {
mbed_official 532:fe11edbda85c 2711 /* Generate Stop */
mbed_official 532:fe11edbda85c 2712 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_STOP;
mbed_official 532:fe11edbda85c 2713 }
mbed_official 532:fe11edbda85c 2714 else
mbed_official 532:fe11edbda85c 2715 {
mbed_official 532:fe11edbda85c 2716 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2717 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2718
mbed_official 532:fe11edbda85c 2719 /* Wrong size Status regarding TCR flag event */
mbed_official 532:fe11edbda85c 2720 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_SIZE;
mbed_official 532:fe11edbda85c 2721 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2722 }
mbed_official 532:fe11edbda85c 2723 }
mbed_official 532:fe11edbda85c 2724 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET)
mbed_official 532:fe11edbda85c 2725 {
mbed_official 532:fe11edbda85c 2726 /* Disable ERR, TC, STOP, NACK, TXI interrupt */
mbed_official 532:fe11edbda85c 2727 __HAL_FMPI2C_DISABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_RXI );
mbed_official 532:fe11edbda85c 2728
mbed_official 532:fe11edbda85c 2729 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 2730 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 2731
mbed_official 532:fe11edbda85c 2732 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 2733 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 2734
mbed_official 532:fe11edbda85c 2735 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2736
mbed_official 532:fe11edbda85c 2737 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2738 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2739
mbed_official 532:fe11edbda85c 2740 if(hfmpi2c->State == HAL_FMPI2C_STATE_MEM_BUSY_RX)
mbed_official 532:fe11edbda85c 2741 {
mbed_official 532:fe11edbda85c 2742 HAL_FMPI2C_MemRxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2743 }
mbed_official 532:fe11edbda85c 2744 else
mbed_official 532:fe11edbda85c 2745 {
mbed_official 532:fe11edbda85c 2746 HAL_FMPI2C_MasterRxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2747 }
mbed_official 532:fe11edbda85c 2748 }
mbed_official 532:fe11edbda85c 2749 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == SET)
mbed_official 532:fe11edbda85c 2750 {
mbed_official 532:fe11edbda85c 2751 /* Clear NACK Flag */
mbed_official 532:fe11edbda85c 2752 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_AF);
mbed_official 532:fe11edbda85c 2753
mbed_official 532:fe11edbda85c 2754 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2755 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2756
mbed_official 532:fe11edbda85c 2757 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 2758 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2759 }
mbed_official 532:fe11edbda85c 2760
mbed_official 532:fe11edbda85c 2761 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2762 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2763
mbed_official 532:fe11edbda85c 2764 return HAL_OK;
mbed_official 532:fe11edbda85c 2765
mbed_official 532:fe11edbda85c 2766 }
mbed_official 532:fe11edbda85c 2767
mbed_official 532:fe11edbda85c 2768 /**
mbed_official 532:fe11edbda85c 2769 * @brief Handle Interrupt Flags Slave Transmit Mode
mbed_official 532:fe11edbda85c 2770 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2771 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2772 * @retval HAL status
mbed_official 532:fe11edbda85c 2773 */
mbed_official 532:fe11edbda85c 2774 static HAL_StatusTypeDef FMPI2C_SlaveTransmit_ISR(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2775 {
mbed_official 532:fe11edbda85c 2776 /* Process locked */
mbed_official 532:fe11edbda85c 2777 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2778
mbed_official 532:fe11edbda85c 2779 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) != RESET)
mbed_official 532:fe11edbda85c 2780 {
mbed_official 532:fe11edbda85c 2781 /* Check that FMPI2C transfer finished */
mbed_official 532:fe11edbda85c 2782 /* if yes, normal usecase, a NACK is sent by the MASTER when Transfer is finished */
mbed_official 532:fe11edbda85c 2783 /* Mean XferCount == 0*/
mbed_official 532:fe11edbda85c 2784 /* So clear Flag NACKF only */
mbed_official 532:fe11edbda85c 2785 if(hfmpi2c->XferCount == 0)
mbed_official 532:fe11edbda85c 2786 {
mbed_official 532:fe11edbda85c 2787 /* Clear NACK Flag */
mbed_official 532:fe11edbda85c 2788 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_AF);
mbed_official 532:fe11edbda85c 2789
mbed_official 532:fe11edbda85c 2790 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2791 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2792 }
mbed_official 532:fe11edbda85c 2793 else
mbed_official 532:fe11edbda85c 2794 {
mbed_official 532:fe11edbda85c 2795 /* if no, error usecase, a Non-Acknowledge of last Data is generated by the MASTER*/
mbed_official 532:fe11edbda85c 2796 /* Clear NACK Flag */
mbed_official 532:fe11edbda85c 2797 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_AF);
mbed_official 532:fe11edbda85c 2798
mbed_official 532:fe11edbda85c 2799 /* Set ErrorCode corresponding to a Non-Acknowledge */
mbed_official 532:fe11edbda85c 2800 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 2801
mbed_official 532:fe11edbda85c 2802 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2803 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2804
mbed_official 532:fe11edbda85c 2805 /* Call the Error callback to prevent upper layer */
mbed_official 532:fe11edbda85c 2806 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2807 }
mbed_official 532:fe11edbda85c 2808 }
mbed_official 532:fe11edbda85c 2809 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_ADDR) == SET)
mbed_official 532:fe11edbda85c 2810 {
mbed_official 532:fe11edbda85c 2811 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 2812 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 2813 }
mbed_official 532:fe11edbda85c 2814 /* Check first if STOPF is set */
mbed_official 532:fe11edbda85c 2815 /* to prevent a Write Data in TX buffer */
mbed_official 532:fe11edbda85c 2816 /* which is stuck in TXDR until next */
mbed_official 532:fe11edbda85c 2817 /* communication with Master */
mbed_official 532:fe11edbda85c 2818 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET)
mbed_official 532:fe11edbda85c 2819 {
mbed_official 532:fe11edbda85c 2820 /* Disable ERRI, TCI, STOPI, NACKI, ADDRI, RXI, TXI interrupt */
mbed_official 532:fe11edbda85c 2821 __HAL_FMPI2C_DISABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_TXI );
mbed_official 532:fe11edbda85c 2822
mbed_official 532:fe11edbda85c 2823 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 2824 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 2825
mbed_official 532:fe11edbda85c 2826 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 2827 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 2828
mbed_official 532:fe11edbda85c 2829 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2830
mbed_official 532:fe11edbda85c 2831 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2832 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2833
mbed_official 532:fe11edbda85c 2834 HAL_FMPI2C_SlaveTxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2835 }
mbed_official 532:fe11edbda85c 2836 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TXIS) == SET)
mbed_official 532:fe11edbda85c 2837 {
mbed_official 532:fe11edbda85c 2838 /* Write data to TXDR only if XferCount not reach "0" */
mbed_official 532:fe11edbda85c 2839 /* A TXIS flag can be set, during STOP treatment */
mbed_official 532:fe11edbda85c 2840 if(hfmpi2c->XferCount > 0)
mbed_official 532:fe11edbda85c 2841 {
mbed_official 532:fe11edbda85c 2842 /* Write data to TXDR */
mbed_official 532:fe11edbda85c 2843 hfmpi2c->Instance->TXDR = (*hfmpi2c->pBuffPtr++);
mbed_official 532:fe11edbda85c 2844 hfmpi2c->XferCount--;
mbed_official 532:fe11edbda85c 2845 }
mbed_official 532:fe11edbda85c 2846 }
mbed_official 532:fe11edbda85c 2847
mbed_official 532:fe11edbda85c 2848 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2849 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2850
mbed_official 532:fe11edbda85c 2851 return HAL_OK;
mbed_official 532:fe11edbda85c 2852 }
mbed_official 532:fe11edbda85c 2853
mbed_official 532:fe11edbda85c 2854 /**
mbed_official 532:fe11edbda85c 2855 * @brief Handle Interrupt Flags Slave Receive Mode
mbed_official 532:fe11edbda85c 2856 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2857 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2858 * @retval HAL status
mbed_official 532:fe11edbda85c 2859 */
mbed_official 532:fe11edbda85c 2860 static HAL_StatusTypeDef FMPI2C_SlaveReceive_ISR(FMPI2C_HandleTypeDef *hfmpi2c)
mbed_official 532:fe11edbda85c 2861 {
mbed_official 532:fe11edbda85c 2862 /* Process Locked */
mbed_official 532:fe11edbda85c 2863 __HAL_LOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2864
mbed_official 532:fe11edbda85c 2865 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) != RESET)
mbed_official 532:fe11edbda85c 2866 {
mbed_official 532:fe11edbda85c 2867 /* Clear NACK Flag */
mbed_official 532:fe11edbda85c 2868 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_AF);
mbed_official 532:fe11edbda85c 2869
mbed_official 532:fe11edbda85c 2870 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2871 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2872
mbed_official 532:fe11edbda85c 2873 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 2874 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2875 }
mbed_official 532:fe11edbda85c 2876 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_ADDR) == SET)
mbed_official 532:fe11edbda85c 2877 {
mbed_official 532:fe11edbda85c 2878 /* Clear ADDR flag */
mbed_official 532:fe11edbda85c 2879 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_ADDR);
mbed_official 532:fe11edbda85c 2880 }
mbed_official 532:fe11edbda85c 2881 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_RXNE) == SET)
mbed_official 532:fe11edbda85c 2882 {
mbed_official 532:fe11edbda85c 2883 /* Read data from RXDR */
mbed_official 532:fe11edbda85c 2884 (*hfmpi2c->pBuffPtr++) = hfmpi2c->Instance->RXDR;
mbed_official 532:fe11edbda85c 2885 hfmpi2c->XferSize--;
mbed_official 532:fe11edbda85c 2886 hfmpi2c->XferCount--;
mbed_official 532:fe11edbda85c 2887 }
mbed_official 532:fe11edbda85c 2888 else if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET)
mbed_official 532:fe11edbda85c 2889 {
mbed_official 532:fe11edbda85c 2890 /* Disable ERRI, TCI, STOPI, NACKI, ADDRI, RXI, TXI interrupt */
mbed_official 532:fe11edbda85c 2891 __HAL_FMPI2C_DISABLE_IT(hfmpi2c,FMPI2C_IT_ERRI | FMPI2C_IT_TCI| FMPI2C_IT_STOPI| FMPI2C_IT_NACKI | FMPI2C_IT_ADDRI | FMPI2C_IT_RXI | FMPI2C_IT_RXI );
mbed_official 532:fe11edbda85c 2892
mbed_official 532:fe11edbda85c 2893 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 2894 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 2895
mbed_official 532:fe11edbda85c 2896 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 2897 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 2898
mbed_official 532:fe11edbda85c 2899 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 2900
mbed_official 532:fe11edbda85c 2901 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2902 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2903
mbed_official 532:fe11edbda85c 2904 HAL_FMPI2C_SlaveRxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 2905 }
mbed_official 532:fe11edbda85c 2906
mbed_official 532:fe11edbda85c 2907 /* Process Unlocked */
mbed_official 532:fe11edbda85c 2908 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 2909
mbed_official 532:fe11edbda85c 2910 return HAL_OK;
mbed_official 532:fe11edbda85c 2911 }
mbed_official 532:fe11edbda85c 2912
mbed_official 532:fe11edbda85c 2913 /**
mbed_official 532:fe11edbda85c 2914 * @brief Master sends target device address followed by internal memory address for write request.
mbed_official 532:fe11edbda85c 2915 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2916 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2917 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 2918 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 2919 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 2920 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 2921 * @retval HAL status
mbed_official 532:fe11edbda85c 2922 */
mbed_official 532:fe11edbda85c 2923 static HAL_StatusTypeDef FMPI2C_RequestMemoryWrite(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout)
mbed_official 532:fe11edbda85c 2924 {
mbed_official 532:fe11edbda85c 2925 FMPI2C_TransferConfig(hfmpi2c,DevAddress,MemAddSize, FMPI2C_RELOAD_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 2926
mbed_official 532:fe11edbda85c 2927 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 2928 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 2929 {
mbed_official 532:fe11edbda85c 2930 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 2931 {
mbed_official 532:fe11edbda85c 2932 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2933 }
mbed_official 532:fe11edbda85c 2934 else
mbed_official 532:fe11edbda85c 2935 {
mbed_official 532:fe11edbda85c 2936 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2937 }
mbed_official 532:fe11edbda85c 2938 }
mbed_official 532:fe11edbda85c 2939
mbed_official 532:fe11edbda85c 2940 /* If Memory address size is 8Bit */
mbed_official 532:fe11edbda85c 2941 if(MemAddSize == FMPI2C_MEMADD_SIZE_8BIT)
mbed_official 532:fe11edbda85c 2942 {
mbed_official 532:fe11edbda85c 2943 /* Send Memory Address */
mbed_official 532:fe11edbda85c 2944 hfmpi2c->Instance->TXDR = __HAL_FMPI2C_MEM_ADD_LSB(MemAddress);
mbed_official 532:fe11edbda85c 2945 }
mbed_official 532:fe11edbda85c 2946 /* If Memory address size is 16Bit */
mbed_official 532:fe11edbda85c 2947 else
mbed_official 532:fe11edbda85c 2948 {
mbed_official 532:fe11edbda85c 2949 /* Send MSB of Memory Address */
mbed_official 532:fe11edbda85c 2950 hfmpi2c->Instance->TXDR = __HAL_FMPI2C_MEM_ADD_MSB(MemAddress);
mbed_official 532:fe11edbda85c 2951
mbed_official 532:fe11edbda85c 2952 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 2953 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 2954 {
mbed_official 532:fe11edbda85c 2955 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 2956 {
mbed_official 532:fe11edbda85c 2957 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2958 }
mbed_official 532:fe11edbda85c 2959 else
mbed_official 532:fe11edbda85c 2960 {
mbed_official 532:fe11edbda85c 2961 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2962 }
mbed_official 532:fe11edbda85c 2963 }
mbed_official 532:fe11edbda85c 2964
mbed_official 532:fe11edbda85c 2965 /* Send LSB of Memory Address */
mbed_official 532:fe11edbda85c 2966 hfmpi2c->Instance->TXDR = __HAL_FMPI2C_MEM_ADD_LSB(MemAddress);
mbed_official 532:fe11edbda85c 2967 }
mbed_official 532:fe11edbda85c 2968
mbed_official 532:fe11edbda85c 2969 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 2970 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 2971 {
mbed_official 532:fe11edbda85c 2972 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 2973 }
mbed_official 532:fe11edbda85c 2974
mbed_official 532:fe11edbda85c 2975 return HAL_OK;
mbed_official 532:fe11edbda85c 2976 }
mbed_official 532:fe11edbda85c 2977
mbed_official 532:fe11edbda85c 2978 /**
mbed_official 532:fe11edbda85c 2979 * @brief Master sends target device address followed by internal memory address for read request.
mbed_official 532:fe11edbda85c 2980 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 2981 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 2982 * @param DevAddress: Target device address
mbed_official 532:fe11edbda85c 2983 * @param MemAddress: Internal memory address
mbed_official 532:fe11edbda85c 2984 * @param MemAddSize: Size of internal memory address
mbed_official 532:fe11edbda85c 2985 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 2986 * @retval HAL status
mbed_official 532:fe11edbda85c 2987 */
mbed_official 532:fe11edbda85c 2988 static HAL_StatusTypeDef FMPI2C_RequestMemoryRead(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout)
mbed_official 532:fe11edbda85c 2989 {
mbed_official 532:fe11edbda85c 2990 FMPI2C_TransferConfig(hfmpi2c,DevAddress,MemAddSize, FMPI2C_SOFTEND_MODE, FMPI2C_GENERATE_START_WRITE);
mbed_official 532:fe11edbda85c 2991
mbed_official 532:fe11edbda85c 2992 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 2993 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 2994 {
mbed_official 532:fe11edbda85c 2995 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 2996 {
mbed_official 532:fe11edbda85c 2997 return HAL_ERROR;
mbed_official 532:fe11edbda85c 2998 }
mbed_official 532:fe11edbda85c 2999 else
mbed_official 532:fe11edbda85c 3000 {
mbed_official 532:fe11edbda85c 3001 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3002 }
mbed_official 532:fe11edbda85c 3003 }
mbed_official 532:fe11edbda85c 3004
mbed_official 532:fe11edbda85c 3005 /* If Memory address size is 8Bit */
mbed_official 532:fe11edbda85c 3006 if(MemAddSize == FMPI2C_MEMADD_SIZE_8BIT)
mbed_official 532:fe11edbda85c 3007 {
mbed_official 532:fe11edbda85c 3008 /* Send Memory Address */
mbed_official 532:fe11edbda85c 3009 hfmpi2c->Instance->TXDR = __HAL_FMPI2C_MEM_ADD_LSB(MemAddress);
mbed_official 532:fe11edbda85c 3010 }
mbed_official 532:fe11edbda85c 3011 /* If Mememory address size is 16Bit */
mbed_official 532:fe11edbda85c 3012 else
mbed_official 532:fe11edbda85c 3013 {
mbed_official 532:fe11edbda85c 3014 /* Send MSB of Memory Address */
mbed_official 532:fe11edbda85c 3015 hfmpi2c->Instance->TXDR = __HAL_FMPI2C_MEM_ADD_MSB(MemAddress);
mbed_official 532:fe11edbda85c 3016
mbed_official 532:fe11edbda85c 3017 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 3018 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 3019 {
mbed_official 532:fe11edbda85c 3020 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3021 {
mbed_official 532:fe11edbda85c 3022 return HAL_ERROR;
mbed_official 532:fe11edbda85c 3023 }
mbed_official 532:fe11edbda85c 3024 else
mbed_official 532:fe11edbda85c 3025 {
mbed_official 532:fe11edbda85c 3026 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3027 }
mbed_official 532:fe11edbda85c 3028 }
mbed_official 532:fe11edbda85c 3029
mbed_official 532:fe11edbda85c 3030 /* Send LSB of Memory Address */
mbed_official 532:fe11edbda85c 3031 hfmpi2c->Instance->TXDR = __HAL_FMPI2C_MEM_ADD_LSB(MemAddress);
mbed_official 532:fe11edbda85c 3032 }
mbed_official 532:fe11edbda85c 3033
mbed_official 532:fe11edbda85c 3034 /* Wait until TC flag is set */
mbed_official 532:fe11edbda85c 3035 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TC, RESET, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 3036 {
mbed_official 532:fe11edbda85c 3037 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3038 }
mbed_official 532:fe11edbda85c 3039
mbed_official 532:fe11edbda85c 3040 return HAL_OK;
mbed_official 532:fe11edbda85c 3041 }
mbed_official 532:fe11edbda85c 3042
mbed_official 532:fe11edbda85c 3043
mbed_official 532:fe11edbda85c 3044 /**
mbed_official 532:fe11edbda85c 3045 * @brief DMA FMPI2C master transmit process complete callback.
mbed_official 532:fe11edbda85c 3046 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 3047 * @retval None
mbed_official 532:fe11edbda85c 3048 */
mbed_official 532:fe11edbda85c 3049 static void FMPI2C_DMAMasterTransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 3050 {
mbed_official 532:fe11edbda85c 3051 uint16_t DevAddress;
mbed_official 532:fe11edbda85c 3052 FMPI2C_HandleTypeDef* hfmpi2c = (FMPI2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 532:fe11edbda85c 3053
mbed_official 532:fe11edbda85c 3054 /* Check if last DMA request was done with RELOAD */
mbed_official 532:fe11edbda85c 3055 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3056 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3057 {
mbed_official 532:fe11edbda85c 3058 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 3059 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, FMPI2C_TIMEOUT_TCR) != HAL_OK)
mbed_official 532:fe11edbda85c 3060 {
mbed_official 532:fe11edbda85c 3061 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3062 }
mbed_official 532:fe11edbda85c 3063
mbed_official 532:fe11edbda85c 3064 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3065 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 3066
mbed_official 532:fe11edbda85c 3067 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3068 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3069 {
mbed_official 532:fe11edbda85c 3070 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3071 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3072 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3073 {
mbed_official 532:fe11edbda85c 3074 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3075 {
mbed_official 532:fe11edbda85c 3076 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3077 }
mbed_official 532:fe11edbda85c 3078 else
mbed_official 532:fe11edbda85c 3079 {
mbed_official 532:fe11edbda85c 3080 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3081 }
mbed_official 532:fe11edbda85c 3082 }
mbed_official 532:fe11edbda85c 3083
mbed_official 532:fe11edbda85c 3084 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3085 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3086
mbed_official 532:fe11edbda85c 3087 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3088 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3089
mbed_official 532:fe11edbda85c 3090 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3091
mbed_official 532:fe11edbda85c 3092 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3093 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3094 }
mbed_official 532:fe11edbda85c 3095 else
mbed_official 532:fe11edbda85c 3096 {
mbed_official 532:fe11edbda85c 3097 hfmpi2c->pBuffPtr += hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3098 hfmpi2c->XferCount -= hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3099 if(hfmpi2c->XferCount > 255)
mbed_official 532:fe11edbda85c 3100 {
mbed_official 532:fe11edbda85c 3101 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 3102 }
mbed_official 532:fe11edbda85c 3103 else
mbed_official 532:fe11edbda85c 3104 {
mbed_official 532:fe11edbda85c 3105 hfmpi2c->XferSize = hfmpi2c->XferCount;
mbed_official 532:fe11edbda85c 3106 }
mbed_official 532:fe11edbda85c 3107
mbed_official 532:fe11edbda85c 3108 DevAddress = (hfmpi2c->Instance->CR2 & FMPI2C_CR2_SADD);
mbed_official 532:fe11edbda85c 3109
mbed_official 532:fe11edbda85c 3110 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 3111 HAL_DMA_Start_IT(hfmpi2c->hdmatx, (uint32_t)hfmpi2c->pBuffPtr, (uint32_t)&hfmpi2c->Instance->TXDR, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 3112
mbed_official 532:fe11edbda85c 3113 /* Send Slave Address */
mbed_official 532:fe11edbda85c 3114 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3115 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3116 {
mbed_official 532:fe11edbda85c 3117 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3118 }
mbed_official 532:fe11edbda85c 3119 else
mbed_official 532:fe11edbda85c 3120 {
mbed_official 532:fe11edbda85c 3121 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3122 }
mbed_official 532:fe11edbda85c 3123
mbed_official 532:fe11edbda85c 3124 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 3125 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_TXIS) != HAL_OK)
mbed_official 532:fe11edbda85c 3126 {
mbed_official 532:fe11edbda85c 3127 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3128 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3129 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3130 {
mbed_official 532:fe11edbda85c 3131 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3132 {
mbed_official 532:fe11edbda85c 3133 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3134 }
mbed_official 532:fe11edbda85c 3135 else
mbed_official 532:fe11edbda85c 3136 {
mbed_official 532:fe11edbda85c 3137 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3138 }
mbed_official 532:fe11edbda85c 3139 }
mbed_official 532:fe11edbda85c 3140
mbed_official 532:fe11edbda85c 3141 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3142 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3143
mbed_official 532:fe11edbda85c 3144 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3145 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3146
mbed_official 532:fe11edbda85c 3147 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3148
mbed_official 532:fe11edbda85c 3149 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3150 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3151 }
mbed_official 532:fe11edbda85c 3152 else
mbed_official 532:fe11edbda85c 3153 {
mbed_official 532:fe11edbda85c 3154 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 3155 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 3156 }
mbed_official 532:fe11edbda85c 3157 }
mbed_official 532:fe11edbda85c 3158 }
mbed_official 532:fe11edbda85c 3159 else
mbed_official 532:fe11edbda85c 3160 {
mbed_official 532:fe11edbda85c 3161 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3162 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3163 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3164 {
mbed_official 532:fe11edbda85c 3165 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3166 {
mbed_official 532:fe11edbda85c 3167 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3168 }
mbed_official 532:fe11edbda85c 3169 else
mbed_official 532:fe11edbda85c 3170 {
mbed_official 532:fe11edbda85c 3171 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3172 }
mbed_official 532:fe11edbda85c 3173 }
mbed_official 532:fe11edbda85c 3174
mbed_official 532:fe11edbda85c 3175 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3176 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3177
mbed_official 532:fe11edbda85c 3178 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3179 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3180
mbed_official 532:fe11edbda85c 3181 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3182 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 3183
mbed_official 532:fe11edbda85c 3184 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3185
mbed_official 532:fe11edbda85c 3186 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3187
mbed_official 532:fe11edbda85c 3188 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3189 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3190 {
mbed_official 532:fe11edbda85c 3191 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3192 }
mbed_official 532:fe11edbda85c 3193 else
mbed_official 532:fe11edbda85c 3194 {
mbed_official 532:fe11edbda85c 3195 HAL_FMPI2C_MasterTxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3196 }
mbed_official 532:fe11edbda85c 3197 }
mbed_official 532:fe11edbda85c 3198 }
mbed_official 532:fe11edbda85c 3199
mbed_official 532:fe11edbda85c 3200 /**
mbed_official 532:fe11edbda85c 3201 * @brief DMA FMPI2C slave transmit process complete callback.
mbed_official 532:fe11edbda85c 3202 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 3203 * @retval None
mbed_official 532:fe11edbda85c 3204 */
mbed_official 532:fe11edbda85c 3205 static void FMPI2C_DMASlaveTransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 3206 {
mbed_official 532:fe11edbda85c 3207 FMPI2C_HandleTypeDef* hfmpi2c = (FMPI2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 532:fe11edbda85c 3208
mbed_official 532:fe11edbda85c 3209 /* Wait until STOP flag is set */
mbed_official 532:fe11edbda85c 3210 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3211 {
mbed_official 532:fe11edbda85c 3212 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3213 {
mbed_official 532:fe11edbda85c 3214 /* Normal Use case, a AF is generated by master */
mbed_official 532:fe11edbda85c 3215 /* to inform slave the end of transfer */
mbed_official 532:fe11edbda85c 3216 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 3217 }
mbed_official 532:fe11edbda85c 3218 else
mbed_official 532:fe11edbda85c 3219 {
mbed_official 532:fe11edbda85c 3220 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3221 }
mbed_official 532:fe11edbda85c 3222 }
mbed_official 532:fe11edbda85c 3223
mbed_official 532:fe11edbda85c 3224 /* Clear STOP flag */
mbed_official 532:fe11edbda85c 3225 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c,FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3226
mbed_official 532:fe11edbda85c 3227 /* Wait until BUSY flag is reset */
mbed_official 532:fe11edbda85c 3228 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_BUSY, SET, FMPI2C_TIMEOUT_BUSY) != HAL_OK)
mbed_official 532:fe11edbda85c 3229 {
mbed_official 532:fe11edbda85c 3230 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3231 }
mbed_official 532:fe11edbda85c 3232
mbed_official 532:fe11edbda85c 3233 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3234 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 3235
mbed_official 532:fe11edbda85c 3236 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3237
mbed_official 532:fe11edbda85c 3238 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3239
mbed_official 532:fe11edbda85c 3240 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3241 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3242 {
mbed_official 532:fe11edbda85c 3243 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3244 }
mbed_official 532:fe11edbda85c 3245 else
mbed_official 532:fe11edbda85c 3246 {
mbed_official 532:fe11edbda85c 3247 HAL_FMPI2C_SlaveTxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3248 }
mbed_official 532:fe11edbda85c 3249 }
mbed_official 532:fe11edbda85c 3250
mbed_official 532:fe11edbda85c 3251 /**
mbed_official 532:fe11edbda85c 3252 * @brief DMA FMPI2C master receive process complete callback
mbed_official 532:fe11edbda85c 3253 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 3254 * @retval None
mbed_official 532:fe11edbda85c 3255 */
mbed_official 532:fe11edbda85c 3256 static void FMPI2C_DMAMasterReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 3257 {
mbed_official 532:fe11edbda85c 3258 FMPI2C_HandleTypeDef* hfmpi2c = (FMPI2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 532:fe11edbda85c 3259 uint16_t DevAddress;
mbed_official 532:fe11edbda85c 3260
mbed_official 532:fe11edbda85c 3261 /* Check if last DMA request was done with RELOAD */
mbed_official 532:fe11edbda85c 3262 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3263 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3264 {
mbed_official 532:fe11edbda85c 3265 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 3266 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, FMPI2C_TIMEOUT_TCR) != HAL_OK)
mbed_official 532:fe11edbda85c 3267 {
mbed_official 532:fe11edbda85c 3268 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3269 }
mbed_official 532:fe11edbda85c 3270
mbed_official 532:fe11edbda85c 3271 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3272 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 3273
mbed_official 532:fe11edbda85c 3274 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3275 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3276 {
mbed_official 532:fe11edbda85c 3277 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3278 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3279 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3280 {
mbed_official 532:fe11edbda85c 3281 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3282 {
mbed_official 532:fe11edbda85c 3283 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3284 }
mbed_official 532:fe11edbda85c 3285 else
mbed_official 532:fe11edbda85c 3286 {
mbed_official 532:fe11edbda85c 3287 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3288 }
mbed_official 532:fe11edbda85c 3289 }
mbed_official 532:fe11edbda85c 3290
mbed_official 532:fe11edbda85c 3291 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3292 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3293
mbed_official 532:fe11edbda85c 3294 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3295 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3296
mbed_official 532:fe11edbda85c 3297 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3298
mbed_official 532:fe11edbda85c 3299 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3300 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3301 }
mbed_official 532:fe11edbda85c 3302 else
mbed_official 532:fe11edbda85c 3303 {
mbed_official 532:fe11edbda85c 3304 hfmpi2c->pBuffPtr += hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3305 hfmpi2c->XferCount -= hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3306 if(hfmpi2c->XferCount > 255)
mbed_official 532:fe11edbda85c 3307 {
mbed_official 532:fe11edbda85c 3308 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 3309 }
mbed_official 532:fe11edbda85c 3310 else
mbed_official 532:fe11edbda85c 3311 {
mbed_official 532:fe11edbda85c 3312 hfmpi2c->XferSize = hfmpi2c->XferCount;
mbed_official 532:fe11edbda85c 3313 }
mbed_official 532:fe11edbda85c 3314
mbed_official 532:fe11edbda85c 3315 DevAddress = (hfmpi2c->Instance->CR2 & FMPI2C_CR2_SADD);
mbed_official 532:fe11edbda85c 3316
mbed_official 532:fe11edbda85c 3317 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 3318 HAL_DMA_Start_IT(hfmpi2c->hdmarx, (uint32_t)&hfmpi2c->Instance->RXDR, (uint32_t)hfmpi2c->pBuffPtr, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 3319
mbed_official 532:fe11edbda85c 3320 /* Send Slave Address */
mbed_official 532:fe11edbda85c 3321 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3322 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3323 {
mbed_official 532:fe11edbda85c 3324 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3325 }
mbed_official 532:fe11edbda85c 3326 else
mbed_official 532:fe11edbda85c 3327 {
mbed_official 532:fe11edbda85c 3328 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3329 }
mbed_official 532:fe11edbda85c 3330
mbed_official 532:fe11edbda85c 3331 /* Wait until RXNE flag is set */
mbed_official 532:fe11edbda85c 3332 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_RXNE, RESET, FMPI2C_TIMEOUT_RXNE) != HAL_OK)
mbed_official 532:fe11edbda85c 3333 {
mbed_official 532:fe11edbda85c 3334 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3335 }
mbed_official 532:fe11edbda85c 3336
mbed_official 532:fe11edbda85c 3337 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3338 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3339 {
mbed_official 532:fe11edbda85c 3340 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3341 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3342 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3343 {
mbed_official 532:fe11edbda85c 3344 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3345 {
mbed_official 532:fe11edbda85c 3346 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3347 }
mbed_official 532:fe11edbda85c 3348 else
mbed_official 532:fe11edbda85c 3349 {
mbed_official 532:fe11edbda85c 3350 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3351 }
mbed_official 532:fe11edbda85c 3352 }
mbed_official 532:fe11edbda85c 3353
mbed_official 532:fe11edbda85c 3354 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3355 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3356
mbed_official 532:fe11edbda85c 3357 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3358 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3359
mbed_official 532:fe11edbda85c 3360 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3361
mbed_official 532:fe11edbda85c 3362 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3363
mbed_official 532:fe11edbda85c 3364 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3365 }
mbed_official 532:fe11edbda85c 3366 else
mbed_official 532:fe11edbda85c 3367 {
mbed_official 532:fe11edbda85c 3368 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 3369 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 3370 }
mbed_official 532:fe11edbda85c 3371 }
mbed_official 532:fe11edbda85c 3372 }
mbed_official 532:fe11edbda85c 3373 else
mbed_official 532:fe11edbda85c 3374 {
mbed_official 532:fe11edbda85c 3375 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3376 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3377 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3378 {
mbed_official 532:fe11edbda85c 3379 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3380 {
mbed_official 532:fe11edbda85c 3381 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3382 }
mbed_official 532:fe11edbda85c 3383 else
mbed_official 532:fe11edbda85c 3384 {
mbed_official 532:fe11edbda85c 3385 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3386 }
mbed_official 532:fe11edbda85c 3387 }
mbed_official 532:fe11edbda85c 3388
mbed_official 532:fe11edbda85c 3389 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3390 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3391
mbed_official 532:fe11edbda85c 3392 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3393 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3394
mbed_official 532:fe11edbda85c 3395 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3396 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 3397
mbed_official 532:fe11edbda85c 3398 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3399
mbed_official 532:fe11edbda85c 3400 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3401
mbed_official 532:fe11edbda85c 3402 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3403 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3404 {
mbed_official 532:fe11edbda85c 3405 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3406 }
mbed_official 532:fe11edbda85c 3407 else
mbed_official 532:fe11edbda85c 3408 {
mbed_official 532:fe11edbda85c 3409 HAL_FMPI2C_MasterRxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3410 }
mbed_official 532:fe11edbda85c 3411 }
mbed_official 532:fe11edbda85c 3412 }
mbed_official 532:fe11edbda85c 3413
mbed_official 532:fe11edbda85c 3414 /**
mbed_official 532:fe11edbda85c 3415 * @brief DMA FMPI2C slave receive process complete callback.
mbed_official 532:fe11edbda85c 3416 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 3417 * @retval None
mbed_official 532:fe11edbda85c 3418 */
mbed_official 532:fe11edbda85c 3419 static void FMPI2C_DMASlaveReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 3420 {
mbed_official 532:fe11edbda85c 3421 FMPI2C_HandleTypeDef* hfmpi2c = (FMPI2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 532:fe11edbda85c 3422
mbed_official 532:fe11edbda85c 3423 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3424 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3425 {
mbed_official 532:fe11edbda85c 3426 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3427 {
mbed_official 532:fe11edbda85c 3428 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3429 }
mbed_official 532:fe11edbda85c 3430 else
mbed_official 532:fe11edbda85c 3431 {
mbed_official 532:fe11edbda85c 3432 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3433 }
mbed_official 532:fe11edbda85c 3434 }
mbed_official 532:fe11edbda85c 3435
mbed_official 532:fe11edbda85c 3436 /* Clear STOPF flag */
mbed_official 532:fe11edbda85c 3437 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3438
mbed_official 532:fe11edbda85c 3439 /* Wait until BUSY flag is reset */
mbed_official 532:fe11edbda85c 3440 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_BUSY, SET, FMPI2C_TIMEOUT_BUSY) != HAL_OK)
mbed_official 532:fe11edbda85c 3441 {
mbed_official 532:fe11edbda85c 3442 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3443 }
mbed_official 532:fe11edbda85c 3444
mbed_official 532:fe11edbda85c 3445 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3446 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 3447
mbed_official 532:fe11edbda85c 3448 /* Disable Address Acknowledge */
mbed_official 532:fe11edbda85c 3449 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 3450
mbed_official 532:fe11edbda85c 3451 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3452
mbed_official 532:fe11edbda85c 3453 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3454
mbed_official 532:fe11edbda85c 3455 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3456 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3457 {
mbed_official 532:fe11edbda85c 3458 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3459 }
mbed_official 532:fe11edbda85c 3460 else
mbed_official 532:fe11edbda85c 3461 {
mbed_official 532:fe11edbda85c 3462 HAL_FMPI2C_SlaveRxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3463 }
mbed_official 532:fe11edbda85c 3464 }
mbed_official 532:fe11edbda85c 3465
mbed_official 532:fe11edbda85c 3466 /**
mbed_official 532:fe11edbda85c 3467 * @brief DMA FMPI2C Memory Write process complete callback
mbed_official 532:fe11edbda85c 3468 * @param hdma : DMA handle
mbed_official 532:fe11edbda85c 3469 * @retval None
mbed_official 532:fe11edbda85c 3470 */
mbed_official 532:fe11edbda85c 3471 static void FMPI2C_DMAMemTransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 3472 {
mbed_official 532:fe11edbda85c 3473 uint16_t DevAddress;
mbed_official 532:fe11edbda85c 3474 FMPI2C_HandleTypeDef* hfmpi2c = ( FMPI2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 532:fe11edbda85c 3475
mbed_official 532:fe11edbda85c 3476 /* Check if last DMA request was done with RELOAD */
mbed_official 532:fe11edbda85c 3477 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3478 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3479 {
mbed_official 532:fe11edbda85c 3480 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 3481 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, FMPI2C_TIMEOUT_TCR) != HAL_OK)
mbed_official 532:fe11edbda85c 3482 {
mbed_official 532:fe11edbda85c 3483 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3484 }
mbed_official 532:fe11edbda85c 3485
mbed_official 532:fe11edbda85c 3486 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3487 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 3488
mbed_official 532:fe11edbda85c 3489 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3490 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3491 {
mbed_official 532:fe11edbda85c 3492 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3493 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3494 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3495 {
mbed_official 532:fe11edbda85c 3496 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3497 {
mbed_official 532:fe11edbda85c 3498 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3499 }
mbed_official 532:fe11edbda85c 3500 else
mbed_official 532:fe11edbda85c 3501 {
mbed_official 532:fe11edbda85c 3502 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3503 }
mbed_official 532:fe11edbda85c 3504 }
mbed_official 532:fe11edbda85c 3505
mbed_official 532:fe11edbda85c 3506 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3507 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3508
mbed_official 532:fe11edbda85c 3509 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3510 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3511
mbed_official 532:fe11edbda85c 3512 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3513
mbed_official 532:fe11edbda85c 3514 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3515 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3516 }
mbed_official 532:fe11edbda85c 3517 else
mbed_official 532:fe11edbda85c 3518 {
mbed_official 532:fe11edbda85c 3519 hfmpi2c->pBuffPtr += hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3520 hfmpi2c->XferCount -= hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3521 if(hfmpi2c->XferCount > 255)
mbed_official 532:fe11edbda85c 3522 {
mbed_official 532:fe11edbda85c 3523 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 3524 }
mbed_official 532:fe11edbda85c 3525 else
mbed_official 532:fe11edbda85c 3526 {
mbed_official 532:fe11edbda85c 3527 hfmpi2c->XferSize = hfmpi2c->XferCount;
mbed_official 532:fe11edbda85c 3528 }
mbed_official 532:fe11edbda85c 3529
mbed_official 532:fe11edbda85c 3530 DevAddress = (hfmpi2c->Instance->CR2 & FMPI2C_CR2_SADD);
mbed_official 532:fe11edbda85c 3531
mbed_official 532:fe11edbda85c 3532 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 3533 HAL_DMA_Start_IT(hfmpi2c->hdmatx, (uint32_t)hfmpi2c->pBuffPtr, (uint32_t)&hfmpi2c->Instance->TXDR, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 3534
mbed_official 532:fe11edbda85c 3535 /* Send Slave Address */
mbed_official 532:fe11edbda85c 3536 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3537 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3538 {
mbed_official 532:fe11edbda85c 3539 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3540 }
mbed_official 532:fe11edbda85c 3541 else
mbed_official 532:fe11edbda85c 3542 {
mbed_official 532:fe11edbda85c 3543 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3544 }
mbed_official 532:fe11edbda85c 3545
mbed_official 532:fe11edbda85c 3546 /* Wait until TXIS flag is set */
mbed_official 532:fe11edbda85c 3547 if(FMPI2C_WaitOnTXISFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_TXIS) != HAL_OK)
mbed_official 532:fe11edbda85c 3548 {
mbed_official 532:fe11edbda85c 3549 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3550 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3551 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3552 {
mbed_official 532:fe11edbda85c 3553 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3554 {
mbed_official 532:fe11edbda85c 3555 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3556 }
mbed_official 532:fe11edbda85c 3557 else
mbed_official 532:fe11edbda85c 3558 {
mbed_official 532:fe11edbda85c 3559 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3560 }
mbed_official 532:fe11edbda85c 3561 }
mbed_official 532:fe11edbda85c 3562
mbed_official 532:fe11edbda85c 3563 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3564 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3565
mbed_official 532:fe11edbda85c 3566 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3567 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3568
mbed_official 532:fe11edbda85c 3569 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3570
mbed_official 532:fe11edbda85c 3571 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3572 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3573 }
mbed_official 532:fe11edbda85c 3574 else
mbed_official 532:fe11edbda85c 3575 {
mbed_official 532:fe11edbda85c 3576 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 3577 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 3578 }
mbed_official 532:fe11edbda85c 3579 }
mbed_official 532:fe11edbda85c 3580 }
mbed_official 532:fe11edbda85c 3581 else
mbed_official 532:fe11edbda85c 3582 {
mbed_official 532:fe11edbda85c 3583 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3584 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3585 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3586 {
mbed_official 532:fe11edbda85c 3587 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3588 {
mbed_official 532:fe11edbda85c 3589 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3590 }
mbed_official 532:fe11edbda85c 3591 else
mbed_official 532:fe11edbda85c 3592 {
mbed_official 532:fe11edbda85c 3593 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3594 }
mbed_official 532:fe11edbda85c 3595 }
mbed_official 532:fe11edbda85c 3596
mbed_official 532:fe11edbda85c 3597 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3598 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3599
mbed_official 532:fe11edbda85c 3600 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3601 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3602
mbed_official 532:fe11edbda85c 3603 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3604 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_TXDMAEN;
mbed_official 532:fe11edbda85c 3605
mbed_official 532:fe11edbda85c 3606 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3607
mbed_official 532:fe11edbda85c 3608 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3609
mbed_official 532:fe11edbda85c 3610 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3611 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3612 {
mbed_official 532:fe11edbda85c 3613 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3614 }
mbed_official 532:fe11edbda85c 3615 else
mbed_official 532:fe11edbda85c 3616 {
mbed_official 532:fe11edbda85c 3617 HAL_FMPI2C_MemTxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3618 }
mbed_official 532:fe11edbda85c 3619 }
mbed_official 532:fe11edbda85c 3620 }
mbed_official 532:fe11edbda85c 3621
mbed_official 532:fe11edbda85c 3622 /**
mbed_official 532:fe11edbda85c 3623 * @brief DMA FMPI2C Memory Read process complete callback
mbed_official 532:fe11edbda85c 3624 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 3625 * @retval None
mbed_official 532:fe11edbda85c 3626 */
mbed_official 532:fe11edbda85c 3627 static void FMPI2C_DMAMemReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 3628 {
mbed_official 532:fe11edbda85c 3629 FMPI2C_HandleTypeDef* hfmpi2c = ( FMPI2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 532:fe11edbda85c 3630 uint16_t DevAddress;
mbed_official 532:fe11edbda85c 3631
mbed_official 532:fe11edbda85c 3632 /* Check if last DMA request was done with RELOAD */
mbed_official 532:fe11edbda85c 3633 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3634 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3635 {
mbed_official 532:fe11edbda85c 3636 /* Wait until TCR flag is set */
mbed_official 532:fe11edbda85c 3637 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_TCR, RESET, FMPI2C_TIMEOUT_TCR) != HAL_OK)
mbed_official 532:fe11edbda85c 3638 {
mbed_official 532:fe11edbda85c 3639 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3640 }
mbed_official 532:fe11edbda85c 3641
mbed_official 532:fe11edbda85c 3642 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3643 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 3644
mbed_official 532:fe11edbda85c 3645 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3646 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3647 {
mbed_official 532:fe11edbda85c 3648 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3649 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3650 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3651 {
mbed_official 532:fe11edbda85c 3652 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3653 {
mbed_official 532:fe11edbda85c 3654 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3655 }
mbed_official 532:fe11edbda85c 3656 else
mbed_official 532:fe11edbda85c 3657 {
mbed_official 532:fe11edbda85c 3658 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3659 }
mbed_official 532:fe11edbda85c 3660 }
mbed_official 532:fe11edbda85c 3661
mbed_official 532:fe11edbda85c 3662 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3663 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3664
mbed_official 532:fe11edbda85c 3665 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3666 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3667
mbed_official 532:fe11edbda85c 3668 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3669
mbed_official 532:fe11edbda85c 3670 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3671 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3672 }
mbed_official 532:fe11edbda85c 3673 else
mbed_official 532:fe11edbda85c 3674 {
mbed_official 532:fe11edbda85c 3675 hfmpi2c->pBuffPtr += hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3676 hfmpi2c->XferCount -= hfmpi2c->XferSize;
mbed_official 532:fe11edbda85c 3677 if(hfmpi2c->XferCount > 255)
mbed_official 532:fe11edbda85c 3678 {
mbed_official 532:fe11edbda85c 3679 hfmpi2c->XferSize = 255;
mbed_official 532:fe11edbda85c 3680 }
mbed_official 532:fe11edbda85c 3681 else
mbed_official 532:fe11edbda85c 3682 {
mbed_official 532:fe11edbda85c 3683 hfmpi2c->XferSize = hfmpi2c->XferCount;
mbed_official 532:fe11edbda85c 3684 }
mbed_official 532:fe11edbda85c 3685
mbed_official 532:fe11edbda85c 3686 DevAddress = (hfmpi2c->Instance->CR2 & FMPI2C_CR2_SADD);
mbed_official 532:fe11edbda85c 3687
mbed_official 532:fe11edbda85c 3688 /* Enable the DMA channel */
mbed_official 532:fe11edbda85c 3689 HAL_DMA_Start_IT(hfmpi2c->hdmarx, (uint32_t)&hfmpi2c->Instance->RXDR, (uint32_t)hfmpi2c->pBuffPtr, hfmpi2c->XferSize);
mbed_official 532:fe11edbda85c 3690
mbed_official 532:fe11edbda85c 3691 /* Send Slave Address */
mbed_official 532:fe11edbda85c 3692 /* Set NBYTES to write and reload if size > 255 */
mbed_official 532:fe11edbda85c 3693 if( (hfmpi2c->XferSize == 255) && (hfmpi2c->XferSize < hfmpi2c->XferCount) )
mbed_official 532:fe11edbda85c 3694 {
mbed_official 532:fe11edbda85c 3695 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_RELOAD_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3696 }
mbed_official 532:fe11edbda85c 3697 else
mbed_official 532:fe11edbda85c 3698 {
mbed_official 532:fe11edbda85c 3699 FMPI2C_TransferConfig(hfmpi2c,DevAddress,hfmpi2c->XferSize, FMPI2C_AUTOEND_MODE, FMPI2C_NO_STARTSTOP);
mbed_official 532:fe11edbda85c 3700 }
mbed_official 532:fe11edbda85c 3701
mbed_official 532:fe11edbda85c 3702 /* Wait until RXNE flag is set */
mbed_official 532:fe11edbda85c 3703 if(FMPI2C_WaitOnFlagUntilTimeout(hfmpi2c, FMPI2C_FLAG_RXNE, RESET, FMPI2C_TIMEOUT_RXNE) != HAL_OK)
mbed_official 532:fe11edbda85c 3704 {
mbed_official 532:fe11edbda85c 3705 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3706 }
mbed_official 532:fe11edbda85c 3707
mbed_official 532:fe11edbda85c 3708 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3709 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3710 {
mbed_official 532:fe11edbda85c 3711 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3712 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3713 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3714 {
mbed_official 532:fe11edbda85c 3715 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3716 {
mbed_official 532:fe11edbda85c 3717 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3718 }
mbed_official 532:fe11edbda85c 3719 else
mbed_official 532:fe11edbda85c 3720 {
mbed_official 532:fe11edbda85c 3721 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3722 }
mbed_official 532:fe11edbda85c 3723 }
mbed_official 532:fe11edbda85c 3724
mbed_official 532:fe11edbda85c 3725 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3726 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3727
mbed_official 532:fe11edbda85c 3728 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3729 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3730
mbed_official 532:fe11edbda85c 3731 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3732
mbed_official 532:fe11edbda85c 3733 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3734 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3735 }
mbed_official 532:fe11edbda85c 3736 else
mbed_official 532:fe11edbda85c 3737 {
mbed_official 532:fe11edbda85c 3738 /* Enable DMA Request */
mbed_official 532:fe11edbda85c 3739 hfmpi2c->Instance->CR1 |= FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 3740 }
mbed_official 532:fe11edbda85c 3741 }
mbed_official 532:fe11edbda85c 3742 }
mbed_official 532:fe11edbda85c 3743 else
mbed_official 532:fe11edbda85c 3744 {
mbed_official 532:fe11edbda85c 3745 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 532:fe11edbda85c 3746 /* Wait until STOPF flag is reset */
mbed_official 532:fe11edbda85c 3747 if(FMPI2C_WaitOnSTOPFlagUntilTimeout(hfmpi2c, FMPI2C_TIMEOUT_STOPF) != HAL_OK)
mbed_official 532:fe11edbda85c 3748 {
mbed_official 532:fe11edbda85c 3749 if(hfmpi2c->ErrorCode == HAL_FMPI2C_ERROR_AF)
mbed_official 532:fe11edbda85c 3750 {
mbed_official 532:fe11edbda85c 3751 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 3752 }
mbed_official 532:fe11edbda85c 3753 else
mbed_official 532:fe11edbda85c 3754 {
mbed_official 532:fe11edbda85c 3755 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3756 }
mbed_official 532:fe11edbda85c 3757 }
mbed_official 532:fe11edbda85c 3758
mbed_official 532:fe11edbda85c 3759 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3760 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3761
mbed_official 532:fe11edbda85c 3762 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3763 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3764
mbed_official 532:fe11edbda85c 3765 /* Disable DMA Request */
mbed_official 532:fe11edbda85c 3766 hfmpi2c->Instance->CR1 &= ~FMPI2C_CR1_RXDMAEN;
mbed_official 532:fe11edbda85c 3767
mbed_official 532:fe11edbda85c 3768 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3769
mbed_official 532:fe11edbda85c 3770 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3771
mbed_official 532:fe11edbda85c 3772 /* Check if Errors has been detected during transfer */
mbed_official 532:fe11edbda85c 3773 if(hfmpi2c->ErrorCode != HAL_FMPI2C_ERROR_NONE)
mbed_official 532:fe11edbda85c 3774 {
mbed_official 532:fe11edbda85c 3775 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3776 }
mbed_official 532:fe11edbda85c 3777 else
mbed_official 532:fe11edbda85c 3778 {
mbed_official 532:fe11edbda85c 3779 HAL_FMPI2C_MemRxCpltCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3780 }
mbed_official 532:fe11edbda85c 3781 }
mbed_official 532:fe11edbda85c 3782 }
mbed_official 532:fe11edbda85c 3783
mbed_official 532:fe11edbda85c 3784 /**
mbed_official 532:fe11edbda85c 3785 * @brief DMA FMPI2C communication error callback.
mbed_official 532:fe11edbda85c 3786 * @param hdma : DMA handle
mbed_official 532:fe11edbda85c 3787 * @retval None
mbed_official 532:fe11edbda85c 3788 */
mbed_official 532:fe11edbda85c 3789 static void FMPI2C_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 3790 {
mbed_official 532:fe11edbda85c 3791 FMPI2C_HandleTypeDef* hfmpi2c = ( FMPI2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 532:fe11edbda85c 3792
mbed_official 532:fe11edbda85c 3793 /* Disable Acknowledge */
mbed_official 532:fe11edbda85c 3794 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_NACK;
mbed_official 532:fe11edbda85c 3795
mbed_official 532:fe11edbda85c 3796 hfmpi2c->XferCount = 0;
mbed_official 532:fe11edbda85c 3797
mbed_official 532:fe11edbda85c 3798 hfmpi2c->State = HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3799
mbed_official 532:fe11edbda85c 3800 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_DMA;
mbed_official 532:fe11edbda85c 3801
mbed_official 532:fe11edbda85c 3802 HAL_FMPI2C_ErrorCallback(hfmpi2c);
mbed_official 532:fe11edbda85c 3803 }
mbed_official 532:fe11edbda85c 3804
mbed_official 532:fe11edbda85c 3805 /**
mbed_official 532:fe11edbda85c 3806 * @brief This function handles FMPI2C Communication Timeout.
mbed_official 532:fe11edbda85c 3807 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 3808 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 3809 * @param Flag: specifies the FMPI2C flag to check.
mbed_official 532:fe11edbda85c 3810 * @param Status: The new Flag status (SET or RESET).
mbed_official 532:fe11edbda85c 3811 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 3812 * @retval HAL status
mbed_official 532:fe11edbda85c 3813 */
mbed_official 532:fe11edbda85c 3814 static HAL_StatusTypeDef FMPI2C_WaitOnFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 532:fe11edbda85c 3815 {
mbed_official 532:fe11edbda85c 3816 uint32_t tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 3817
mbed_official 532:fe11edbda85c 3818 /* Wait until flag is set */
mbed_official 532:fe11edbda85c 3819 if(Status == RESET)
mbed_official 532:fe11edbda85c 3820 {
mbed_official 532:fe11edbda85c 3821 while(__HAL_FMPI2C_GET_FLAG(hfmpi2c, Flag) == RESET)
mbed_official 532:fe11edbda85c 3822 {
mbed_official 532:fe11edbda85c 3823 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 3824 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 3825 {
mbed_official 532:fe11edbda85c 3826 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 3827 {
mbed_official 532:fe11edbda85c 3828 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3829 /* Process Unlocked */
mbed_official 532:fe11edbda85c 3830 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 3831 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3832 }
mbed_official 532:fe11edbda85c 3833 }
mbed_official 532:fe11edbda85c 3834 }
mbed_official 532:fe11edbda85c 3835 }
mbed_official 532:fe11edbda85c 3836 else
mbed_official 532:fe11edbda85c 3837 {
mbed_official 532:fe11edbda85c 3838 while(__HAL_FMPI2C_GET_FLAG(hfmpi2c, Flag) != RESET)
mbed_official 532:fe11edbda85c 3839 {
mbed_official 532:fe11edbda85c 3840 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 3841 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 3842 {
mbed_official 532:fe11edbda85c 3843 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 3844 {
mbed_official 532:fe11edbda85c 3845 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3846 /* Process Unlocked */
mbed_official 532:fe11edbda85c 3847 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 3848 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3849 }
mbed_official 532:fe11edbda85c 3850 }
mbed_official 532:fe11edbda85c 3851 }
mbed_official 532:fe11edbda85c 3852 }
mbed_official 532:fe11edbda85c 3853 return HAL_OK;
mbed_official 532:fe11edbda85c 3854 }
mbed_official 532:fe11edbda85c 3855
mbed_official 532:fe11edbda85c 3856 /**
mbed_official 532:fe11edbda85c 3857 * @brief This function handles FMPI2C Communication Timeout for specific usage of TXIS flag.
mbed_official 532:fe11edbda85c 3858 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 3859 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 3860 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 3861 * @retval HAL status
mbed_official 532:fe11edbda85c 3862 */
mbed_official 532:fe11edbda85c 3863 static HAL_StatusTypeDef FMPI2C_WaitOnTXISFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout)
mbed_official 532:fe11edbda85c 3864 {
mbed_official 532:fe11edbda85c 3865 uint32_t tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 3866
mbed_official 532:fe11edbda85c 3867 while(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_TXIS) == RESET)
mbed_official 532:fe11edbda85c 3868 {
mbed_official 532:fe11edbda85c 3869 /* Check if a NACK is detected */
mbed_official 532:fe11edbda85c 3870 if(FMPI2C_IsAcknowledgeFailed(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 3871 {
mbed_official 532:fe11edbda85c 3872 return HAL_ERROR;
mbed_official 532:fe11edbda85c 3873 }
mbed_official 532:fe11edbda85c 3874
mbed_official 532:fe11edbda85c 3875 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 3876 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 3877 {
mbed_official 532:fe11edbda85c 3878 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 3879 {
mbed_official 532:fe11edbda85c 3880 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3881 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3882
mbed_official 532:fe11edbda85c 3883 /* Process Unlocked */
mbed_official 532:fe11edbda85c 3884 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 3885
mbed_official 532:fe11edbda85c 3886 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3887 }
mbed_official 532:fe11edbda85c 3888 }
mbed_official 532:fe11edbda85c 3889 }
mbed_official 532:fe11edbda85c 3890 return HAL_OK;
mbed_official 532:fe11edbda85c 3891 }
mbed_official 532:fe11edbda85c 3892
mbed_official 532:fe11edbda85c 3893 /**
mbed_official 532:fe11edbda85c 3894 * @brief This function handles FMPI2C Communication Timeout for specific usage of STOP flag.
mbed_official 532:fe11edbda85c 3895 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 3896 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 3897 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 3898 * @retval HAL status
mbed_official 532:fe11edbda85c 3899 */
mbed_official 532:fe11edbda85c 3900 static HAL_StatusTypeDef FMPI2C_WaitOnSTOPFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout)
mbed_official 532:fe11edbda85c 3901 {
mbed_official 532:fe11edbda85c 3902 uint32_t tickstart = 0x00;
mbed_official 532:fe11edbda85c 3903 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 3904
mbed_official 532:fe11edbda85c 3905 while(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == RESET)
mbed_official 532:fe11edbda85c 3906 {
mbed_official 532:fe11edbda85c 3907 /* Check if a NACK is detected */
mbed_official 532:fe11edbda85c 3908 if(FMPI2C_IsAcknowledgeFailed(hfmpi2c, Timeout) != HAL_OK)
mbed_official 532:fe11edbda85c 3909 {
mbed_official 532:fe11edbda85c 3910 return HAL_ERROR;
mbed_official 532:fe11edbda85c 3911 }
mbed_official 532:fe11edbda85c 3912
mbed_official 532:fe11edbda85c 3913 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 3914 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 3915 {
mbed_official 532:fe11edbda85c 3916 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3917 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3918
mbed_official 532:fe11edbda85c 3919 /* Process Unlocked */
mbed_official 532:fe11edbda85c 3920 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 3921
mbed_official 532:fe11edbda85c 3922 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3923 }
mbed_official 532:fe11edbda85c 3924 }
mbed_official 532:fe11edbda85c 3925 return HAL_OK;
mbed_official 532:fe11edbda85c 3926 }
mbed_official 532:fe11edbda85c 3927
mbed_official 532:fe11edbda85c 3928 /**
mbed_official 532:fe11edbda85c 3929 * @brief This function handles FMPI2C Communication Timeout for specific usage of RXNE flag.
mbed_official 532:fe11edbda85c 3930 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 3931 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 3932 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 3933 * @retval HAL status
mbed_official 532:fe11edbda85c 3934 */
mbed_official 532:fe11edbda85c 3935 static HAL_StatusTypeDef FMPI2C_WaitOnRXNEFlagUntilTimeout(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout)
mbed_official 532:fe11edbda85c 3936 {
mbed_official 532:fe11edbda85c 3937 uint32_t tickstart = 0x00;
mbed_official 532:fe11edbda85c 3938 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 3939
mbed_official 532:fe11edbda85c 3940 while(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_RXNE) == RESET)
mbed_official 532:fe11edbda85c 3941 {
mbed_official 532:fe11edbda85c 3942 /* Check if a STOPF is detected */
mbed_official 532:fe11edbda85c 3943 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == SET)
mbed_official 532:fe11edbda85c 3944 {
mbed_official 532:fe11edbda85c 3945 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 3946 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 3947
mbed_official 532:fe11edbda85c 3948 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 3949 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 3950
mbed_official 532:fe11edbda85c 3951 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_NONE;
mbed_official 532:fe11edbda85c 3952 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3953
mbed_official 532:fe11edbda85c 3954 /* Process Unlocked */
mbed_official 532:fe11edbda85c 3955 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 3956
mbed_official 532:fe11edbda85c 3957 return HAL_ERROR;
mbed_official 532:fe11edbda85c 3958 }
mbed_official 532:fe11edbda85c 3959
mbed_official 532:fe11edbda85c 3960 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 3961 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 3962 {
mbed_official 532:fe11edbda85c 3963 hfmpi2c->ErrorCode |= HAL_FMPI2C_ERROR_TIMEOUT;
mbed_official 532:fe11edbda85c 3964 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 3965
mbed_official 532:fe11edbda85c 3966 /* Process Unlocked */
mbed_official 532:fe11edbda85c 3967 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 3968
mbed_official 532:fe11edbda85c 3969 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 3970 }
mbed_official 532:fe11edbda85c 3971 }
mbed_official 532:fe11edbda85c 3972 return HAL_OK;
mbed_official 532:fe11edbda85c 3973 }
mbed_official 532:fe11edbda85c 3974
mbed_official 532:fe11edbda85c 3975 /**
mbed_official 532:fe11edbda85c 3976 * @brief This function handles Acknowledge failed detection during an FMPI2C Communication.
mbed_official 532:fe11edbda85c 3977 * @param hfmpi2c : Pointer to a FMPI2C_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 3978 * the configuration information for the specified FMPI2C.
mbed_official 532:fe11edbda85c 3979 * @param Timeout: Timeout duration
mbed_official 532:fe11edbda85c 3980 * @retval HAL status
mbed_official 532:fe11edbda85c 3981 */
mbed_official 532:fe11edbda85c 3982 static HAL_StatusTypeDef FMPI2C_IsAcknowledgeFailed(FMPI2C_HandleTypeDef *hfmpi2c, uint32_t Timeout)
mbed_official 532:fe11edbda85c 3983 {
mbed_official 532:fe11edbda85c 3984 uint32_t tickstart = 0x00;
mbed_official 532:fe11edbda85c 3985 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 3986
mbed_official 532:fe11edbda85c 3987 if(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_AF) == SET)
mbed_official 532:fe11edbda85c 3988 {
mbed_official 532:fe11edbda85c 3989 /* Generate stop if necessary only in case of FMPI2C peripheral in MASTER mode */
mbed_official 532:fe11edbda85c 3990 if((hfmpi2c->State == HAL_FMPI2C_STATE_MASTER_BUSY_TX) || (hfmpi2c->State == HAL_FMPI2C_STATE_MEM_BUSY_TX)
mbed_official 532:fe11edbda85c 3991 || (hfmpi2c->State == HAL_FMPI2C_STATE_MEM_BUSY_RX))
mbed_official 532:fe11edbda85c 3992 {
mbed_official 532:fe11edbda85c 3993 /* No need to generate the STOP condition if AUTOEND mode is enabled */
mbed_official 532:fe11edbda85c 3994 /* Generate the STOP condition only in case of SOFTEND mode is enabled */
mbed_official 532:fe11edbda85c 3995 if((hfmpi2c->Instance->CR2 & FMPI2C_AUTOEND_MODE) != FMPI2C_AUTOEND_MODE)
mbed_official 532:fe11edbda85c 3996 {
mbed_official 532:fe11edbda85c 3997 /* Generate Stop */
mbed_official 532:fe11edbda85c 3998 hfmpi2c->Instance->CR2 |= FMPI2C_CR2_STOP;
mbed_official 532:fe11edbda85c 3999 }
mbed_official 532:fe11edbda85c 4000 }
mbed_official 532:fe11edbda85c 4001
mbed_official 532:fe11edbda85c 4002 /* Wait until STOP Flag is reset */
mbed_official 532:fe11edbda85c 4003 /* AutoEnd should be initiate after AF */
mbed_official 532:fe11edbda85c 4004 while(__HAL_FMPI2C_GET_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF) == RESET)
mbed_official 532:fe11edbda85c 4005 {
mbed_official 532:fe11edbda85c 4006 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 4007 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 4008 {
mbed_official 532:fe11edbda85c 4009 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 4010 {
mbed_official 532:fe11edbda85c 4011 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 4012 /* Process Unlocked */
mbed_official 532:fe11edbda85c 4013 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 4014 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 4015 }
mbed_official 532:fe11edbda85c 4016 }
mbed_official 532:fe11edbda85c 4017 }
mbed_official 532:fe11edbda85c 4018
mbed_official 532:fe11edbda85c 4019 /* Clear NACKF Flag */
mbed_official 532:fe11edbda85c 4020 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_AF);
mbed_official 532:fe11edbda85c 4021
mbed_official 532:fe11edbda85c 4022 /* Clear STOP Flag */
mbed_official 532:fe11edbda85c 4023 __HAL_FMPI2C_CLEAR_FLAG(hfmpi2c, FMPI2C_FLAG_STOPF);
mbed_official 532:fe11edbda85c 4024
mbed_official 532:fe11edbda85c 4025 /* Clear Configuration Register 2 */
mbed_official 532:fe11edbda85c 4026 __HAL_FMPI2C_RESET_CR2(hfmpi2c);
mbed_official 532:fe11edbda85c 4027
mbed_official 532:fe11edbda85c 4028 hfmpi2c->ErrorCode = HAL_FMPI2C_ERROR_AF;
mbed_official 532:fe11edbda85c 4029 hfmpi2c->State= HAL_FMPI2C_STATE_READY;
mbed_official 532:fe11edbda85c 4030
mbed_official 532:fe11edbda85c 4031 /* Process Unlocked */
mbed_official 532:fe11edbda85c 4032 __HAL_UNLOCK(hfmpi2c);
mbed_official 532:fe11edbda85c 4033
mbed_official 532:fe11edbda85c 4034 return HAL_ERROR;
mbed_official 532:fe11edbda85c 4035 }
mbed_official 532:fe11edbda85c 4036 return HAL_OK;
mbed_official 532:fe11edbda85c 4037 }
mbed_official 532:fe11edbda85c 4038
mbed_official 532:fe11edbda85c 4039 /**
mbed_official 532:fe11edbda85c 4040 * @brief Handles FMPI2Cx communication when starting transfer or during transfer (TC or TCR flag are set).
mbed_official 532:fe11edbda85c 4041 * @param hfmpi2c: FMPI2C handle.
mbed_official 532:fe11edbda85c 4042 * @param DevAddress: specifies the slave address to be programmed.
mbed_official 532:fe11edbda85c 4043 * @param Size: specifies the number of bytes to be programmed.
mbed_official 532:fe11edbda85c 4044 * This parameter must be a value between 0 and 255.
mbed_official 532:fe11edbda85c 4045 * @param Mode: new state of the FMPI2C START condition generation.
mbed_official 532:fe11edbda85c 4046 * This parameter can be one of the following values:
mbed_official 532:fe11edbda85c 4047 * @arg FMPI2C_RELOAD_MODE: Enable Reload mode .
mbed_official 532:fe11edbda85c 4048 * @arg FMPI2C_AUTOEND_MODE: Enable Automatic end mode.
mbed_official 532:fe11edbda85c 4049 * @arg FMPI2C_SOFTEND_MODE: Enable Software end mode.
mbed_official 532:fe11edbda85c 4050 * @param Request: new state of the FMPI2C START condition generation.
mbed_official 532:fe11edbda85c 4051 * This parameter can be one of the following values:
mbed_official 532:fe11edbda85c 4052 * @arg FMPI2C_NO_STARTSTOP: Don't Generate stop and start condition.
mbed_official 532:fe11edbda85c 4053 * @arg FMPI2C_GENERATE_STOP: Generate stop condition (Size should be set to 0).
mbed_official 532:fe11edbda85c 4054 * @arg FMPI2C_GENERATE_START_READ: Generate Restart for read request.
mbed_official 532:fe11edbda85c 4055 * @arg FMPI2C_GENERATE_START_WRITE: Generate Restart for write request.
mbed_official 532:fe11edbda85c 4056 * @retval None
mbed_official 532:fe11edbda85c 4057 */
mbed_official 532:fe11edbda85c 4058 static void FMPI2C_TransferConfig(FMPI2C_HandleTypeDef *hfmpi2c, uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request)
mbed_official 532:fe11edbda85c 4059 {
mbed_official 532:fe11edbda85c 4060 uint32_t tmpreg = 0;
mbed_official 532:fe11edbda85c 4061
mbed_official 532:fe11edbda85c 4062 /* Check the parameters */
mbed_official 532:fe11edbda85c 4063 assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance));
mbed_official 532:fe11edbda85c 4064 assert_param(IS_TRANSFER_MODE(Mode));
mbed_official 532:fe11edbda85c 4065 assert_param(IS_TRANSFER_REQUEST(Request));
mbed_official 532:fe11edbda85c 4066
mbed_official 532:fe11edbda85c 4067 /* Get the CR2 register value */
mbed_official 532:fe11edbda85c 4068 tmpreg = hfmpi2c->Instance->CR2;
mbed_official 532:fe11edbda85c 4069
mbed_official 532:fe11edbda85c 4070 /* clear tmpreg specific bits */
mbed_official 532:fe11edbda85c 4071 tmpreg &= (uint32_t)~((uint32_t)(FMPI2C_CR2_SADD | FMPI2C_CR2_NBYTES | FMPI2C_CR2_RELOAD | FMPI2C_CR2_AUTOEND | FMPI2C_CR2_RD_WRN | FMPI2C_CR2_START | FMPI2C_CR2_STOP));
mbed_official 532:fe11edbda85c 4072
mbed_official 532:fe11edbda85c 4073 /* update tmpreg */
mbed_official 532:fe11edbda85c 4074 tmpreg |= (uint32_t)(((uint32_t)DevAddress & FMPI2C_CR2_SADD) | (((uint32_t)Size << 16 ) & FMPI2C_CR2_NBYTES) | \
mbed_official 532:fe11edbda85c 4075 (uint32_t)Mode | (uint32_t)Request);
mbed_official 532:fe11edbda85c 4076
mbed_official 532:fe11edbda85c 4077 /* update CR2 register */
mbed_official 532:fe11edbda85c 4078 hfmpi2c->Instance->CR2 = tmpreg;
mbed_official 532:fe11edbda85c 4079 }
mbed_official 532:fe11edbda85c 4080
mbed_official 532:fe11edbda85c 4081 /**
mbed_official 532:fe11edbda85c 4082 * @}
mbed_official 532:fe11edbda85c 4083 */
mbed_official 532:fe11edbda85c 4084
mbed_official 532:fe11edbda85c 4085 /**
mbed_official 532:fe11edbda85c 4086 * @}
mbed_official 532:fe11edbda85c 4087 */
mbed_official 532:fe11edbda85c 4088 #endif /* STM32F446xx */
mbed_official 532:fe11edbda85c 4089 #endif /* HAL_FMPI2C_MODULE_ENABLED */
mbed_official 532:fe11edbda85c 4090 /**
mbed_official 532:fe11edbda85c 4091 * @}
mbed_official 532:fe11edbda85c 4092 */
mbed_official 532:fe11edbda85c 4093
mbed_official 532:fe11edbda85c 4094 /**
mbed_official 532:fe11edbda85c 4095 * @}
mbed_official 532:fe11edbda85c 4096 */
mbed_official 532:fe11edbda85c 4097
mbed_official 532:fe11edbda85c 4098 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/