mbed-src - mbed library sources

Users » marcusC » Code » mbed-src

marcus chiou / mbed-src

mbed library sources

Fork of mbed-src 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?

User	Revision	Line number	New 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>© 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**/

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	27 Oct 2015
Imports:	0
Forks:	0
Commits:	637
Dependents:	0
Dependencies:	0
Followers:	1

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

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning