mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_smbus.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
489:119543c9f674 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 376:cb4d9db17537 1 /**
mbed_official 376:cb4d9db17537 2 ******************************************************************************
mbed_official 376:cb4d9db17537 3 * @file stm32l0xx_hal_smbus.c
mbed_official 376:cb4d9db17537 4 * @author MCD Application Team
mbed_official 489:119543c9f674 5 * @version V1.2.0
mbed_official 489:119543c9f674 6 * @date 06-February-2015
mbed_official 376:cb4d9db17537 7 * @brief SMBUS HAL module driver.
mbed_official 376:cb4d9db17537 8 *
mbed_official 376:cb4d9db17537 9 * This file provides firmware functions to manage the following
mbed_official 376:cb4d9db17537 10 * functionalities of the System Management Bus (SMBus) peripheral,
mbed_official 376:cb4d9db17537 11 * based on I2C principales of operation :
mbed_official 376:cb4d9db17537 12 * + Initialization/de-initialization functions
mbed_official 376:cb4d9db17537 13 * + I/O operation functions
mbed_official 376:cb4d9db17537 14 * + Peripheral Control functions
mbed_official 376:cb4d9db17537 15 * + Peripheral State functions
mbed_official 376:cb4d9db17537 16 *
mbed_official 376:cb4d9db17537 17 @verbatim
mbed_official 376:cb4d9db17537 18 ==============================================================================
mbed_official 376:cb4d9db17537 19 ##### How to use this driver #####
mbed_official 376:cb4d9db17537 20 ==============================================================================
mbed_official 376:cb4d9db17537 21 [..]
mbed_official 376:cb4d9db17537 22 The SMBUS HAL driver can be used as follows:
mbed_official 376:cb4d9db17537 23
mbed_official 376:cb4d9db17537 24 (#) Declare a SMBUS_HandleTypeDef handle structure, for example:
mbed_official 376:cb4d9db17537 25 SMBUS_HandleTypeDef hsmbus;
mbed_official 376:cb4d9db17537 26
mbed_official 376:cb4d9db17537 27 (#)Initialize the SMBUS low level resources by implement the HAL_SMBUS_MspInit ()API:
mbed_official 376:cb4d9db17537 28 (##) Enable the SMBUSx interface clock
mbed_official 376:cb4d9db17537 29 (##) SMBUS pins configuration
mbed_official 376:cb4d9db17537 30 (+) Enable the clock for the SMBUS GPIOs
mbed_official 376:cb4d9db17537 31 (+) Configure SMBUS pins as alternate function open-drain
mbed_official 376:cb4d9db17537 32 (##) NVIC configuration if you need to use interrupt process
mbed_official 376:cb4d9db17537 33 (+) Configure the SMBUSx interrupt priority
mbed_official 376:cb4d9db17537 34 (+) Enable the NVIC SMBUS IRQ Channel
mbed_official 376:cb4d9db17537 35
mbed_official 376:cb4d9db17537 36 (#) Configure the Communication Clock Timing, Bus Timeout, Own Address1, Master Adressing Mode,
mbed_official 376:cb4d9db17537 37 Dual Addressing mode, Own Address2, Own Address2 Mask, General call, Nostretch mode,
mbed_official 376:cb4d9db17537 38 Peripheral mode and Packet Error Check mode in the hsmbus Init structure.
mbed_official 376:cb4d9db17537 39
mbed_official 376:cb4d9db17537 40 (#) Initialize the SMBUS registers by calling the HAL_SMBUS_Init() API:
mbed_official 376:cb4d9db17537 41 (+) These API's configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
mbed_official 376:cb4d9db17537 42 by calling the customed HAL_SMBUS_MspInit(&hsmbus) API.
mbed_official 376:cb4d9db17537 43
mbed_official 376:cb4d9db17537 44 (#) To check if target device is ready for communication, use the function HAL_SMBUS_IsDeviceReady()
mbed_official 376:cb4d9db17537 45
mbed_official 376:cb4d9db17537 46 (#) For SMBUS IO operations, only one mode of operations is available within this driver :
mbed_official 376:cb4d9db17537 47
mbed_official 376:cb4d9db17537 48 *** Interrupt mode IO operation ***
mbed_official 376:cb4d9db17537 49 ===================================
mbed_official 376:cb4d9db17537 50 [..]
mbed_official 376:cb4d9db17537 51 (+) Transmit in master/host SMBUS mode an amount of data in non blocking mode using HAL_SMBUS_Master_Transmit_IT()
mbed_official 376:cb4d9db17537 52 (++) At transmission end of transfer HAL_SMBUS_MasterTxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 53 add his own code by customization of function pointer HAL_SMBUS_MasterTxCpltCallback
mbed_official 376:cb4d9db17537 54 (+) Receive in master/host SMBUS mode an amount of data in non blocking mode using HAL_SMBUS_Master_Receive_IT()
mbed_official 376:cb4d9db17537 55 (++) At reception end of transfer HAL_SMBUS_MasterRxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 56 add his own code by customization of function pointer HAL_SMBUS_MasterRxCpltCallback
mbed_official 376:cb4d9db17537 57 (+) Abort a master/host SMBUS process commnunication with Interrupt using HAL_SMBUS_Master_Abort_IT()
mbed_official 376:cb4d9db17537 58 (++) The associated previous transfer callback is called at the end of abort process
mbed_official 376:cb4d9db17537 59 (++) mean HAL_SMBUS_MasterTxCpltCallback in case of previous state was master transmit
mbed_official 376:cb4d9db17537 60 (++) mean HAL_SMBUS_MasterRxCpltCallback in case of previous state was master receive
mbed_official 489:119543c9f674 61 (+) Enable the Address listen mode in slave/device SMBUS mode using HAL_SMBUS_EnableListen_IT()
mbed_official 489:119543c9f674 62 (++) When address slave/device SMBUS match, HAL_SMBUS_AddrCallback is executed and user can
mbed_official 376:cb4d9db17537 63 add his own code to check the Address Match Code and the transmission direction request by master/host (Write/Read).
mbed_official 489:119543c9f674 64 (++) At Listen mode end HAL_SMBUS_ListenCpltCallback is executed and user can
mbed_official 489:119543c9f674 65 add his own code by customization of function pointer HAL_SMBUS_ListenCpltCallback
mbed_official 376:cb4d9db17537 66 (+) Transmit in slave/device SMBUS mode an amount of data in non blocking mode using HAL_SMBUS_Slave_Transmit_IT()
mbed_official 376:cb4d9db17537 67 (++) At transmission end of transfer HAL_SMBUS_SlaveTxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 68 add his own code by customization of function pointer HAL_SMBUS_SlaveTxCpltCallback
mbed_official 376:cb4d9db17537 69 (+) Receive in slave/device SMBUS mode an amount of data in non blocking mode using HAL_SMBUS_Slave_Receive_IT()
mbed_official 376:cb4d9db17537 70 (++) At reception end of transfer HAL_SMBUS_SlaveRxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 71 add his own code by customization of function pointer HAL_SMBUS_SlaveRxCpltCallback
mbed_official 376:cb4d9db17537 72 (+) Enable/Disable the SMBUS alert mode using HAL_SMBUS_EnableAlert_IT() HAL_SMBUS_DisableAlert_IT()
mbed_official 376:cb4d9db17537 73 (++) When SMBUS Alert is generated HAL_SMBUS_ErrorCallback() is executed and user can
mbed_official 376:cb4d9db17537 74 add his own code by customization of function pointer HAL_SMBUS_ErrorCallback
mbed_official 376:cb4d9db17537 75 to check the Alert Error Code using function HAL_SMBUS_GetError()
mbed_official 376:cb4d9db17537 76 (+) Get HAL state machine or error values using HAL_SMBUS_GetState() or HAL_SMBUS_GetError()
mbed_official 376:cb4d9db17537 77 (+) In case of transfer Error, HAL_SMBUS_ErrorCallback() function is executed and user can
mbed_official 376:cb4d9db17537 78 add his own code by customization of function pointer HAL_SMBUS_ErrorCallback
mbed_official 376:cb4d9db17537 79 to check the Error Code using function HAL_SMBUS_GetError()
mbed_official 376:cb4d9db17537 80
mbed_official 376:cb4d9db17537 81 *** SMBUS HAL driver macros list ***
mbed_official 376:cb4d9db17537 82 ==================================
mbed_official 376:cb4d9db17537 83 [..]
mbed_official 376:cb4d9db17537 84 Below the list of most used macros in SMBUS HAL driver.
mbed_official 376:cb4d9db17537 85
mbed_official 376:cb4d9db17537 86 (+) __HAL_SMBUS_ENABLE: Enable the SMBUS peripheral
mbed_official 376:cb4d9db17537 87 (+) __HAL_SMBUS_DISABLE: Disable the SMBUS peripheral
mbed_official 376:cb4d9db17537 88 (+) __HAL_SMBUS_GET_FLAG : Checks whether the specified SMBUS flag is set or not
mbed_official 376:cb4d9db17537 89 (+) __HAL_SMBUS_CLEAR_FLAG : Clears the specified SMBUS pending flag
mbed_official 376:cb4d9db17537 90 (+) __HAL_SMBUS_ENABLE_IT: Enables the specified SMBUS interrupt
mbed_official 376:cb4d9db17537 91 (+) __HAL_SMBUS_DISABLE_IT: Disables the specified SMBUS interrupt
mbed_official 376:cb4d9db17537 92
mbed_official 376:cb4d9db17537 93 [..]
mbed_official 376:cb4d9db17537 94 (@) You can refer to the SMBUS HAL driver header file for more useful macros
mbed_official 376:cb4d9db17537 95
mbed_official 376:cb4d9db17537 96
mbed_official 376:cb4d9db17537 97 @endverbatim
mbed_official 376:cb4d9db17537 98 ******************************************************************************
mbed_official 376:cb4d9db17537 99 * @attention
mbed_official 376:cb4d9db17537 100 *
mbed_official 489:119543c9f674 101 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 376:cb4d9db17537 102 *
mbed_official 376:cb4d9db17537 103 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 376:cb4d9db17537 104 * are permitted provided that the following conditions are met:
mbed_official 376:cb4d9db17537 105 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 376:cb4d9db17537 106 * this list of conditions and the following disclaimer.
mbed_official 376:cb4d9db17537 107 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 376:cb4d9db17537 108 * this list of conditions and the following disclaimer in the documentation
mbed_official 376:cb4d9db17537 109 * and/or other materials provided with the distribution.
mbed_official 376:cb4d9db17537 110 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 376:cb4d9db17537 111 * may be used to endorse or promote products derived from this software
mbed_official 376:cb4d9db17537 112 * without specific prior written permission.
mbed_official 376:cb4d9db17537 113 *
mbed_official 376:cb4d9db17537 114 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 376:cb4d9db17537 115 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 376:cb4d9db17537 116 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 376:cb4d9db17537 117 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 376:cb4d9db17537 118 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 376:cb4d9db17537 119 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 376:cb4d9db17537 120 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 376:cb4d9db17537 121 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 376:cb4d9db17537 122 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 376:cb4d9db17537 123 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 376:cb4d9db17537 124 *
mbed_official 376:cb4d9db17537 125 ******************************************************************************
mbed_official 376:cb4d9db17537 126 */
mbed_official 376:cb4d9db17537 127
mbed_official 376:cb4d9db17537 128 /* Includes ------------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 129 #include "stm32l0xx_hal.h"
mbed_official 376:cb4d9db17537 130
mbed_official 376:cb4d9db17537 131 /** @addtogroup STM32L0xx_HAL_Driver
mbed_official 376:cb4d9db17537 132 * @{
mbed_official 376:cb4d9db17537 133 */
mbed_official 376:cb4d9db17537 134
mbed_official 376:cb4d9db17537 135 /** @defgroup SMBUS
mbed_official 376:cb4d9db17537 136 * @brief SMBUS HAL module driver
mbed_official 376:cb4d9db17537 137 * @{
mbed_official 376:cb4d9db17537 138 */
mbed_official 376:cb4d9db17537 139
mbed_official 376:cb4d9db17537 140 #ifdef HAL_SMBUS_MODULE_ENABLED
mbed_official 376:cb4d9db17537 141
mbed_official 376:cb4d9db17537 142 /* Private typedef -----------------------------------------------------------*/
mbed_official 376:cb4d9db17537 143 /* Private define ------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 144 #define TIMING_CLEAR_MASK ((uint32_t)0xF0FFFFFF) /*<! SMBUS TIMING clear register Mask */
mbed_official 376:cb4d9db17537 145 #define HAL_TIMEOUT_ADDR ((uint32_t)10000) /* 10 s */
mbed_official 376:cb4d9db17537 146 #define HAL_TIMEOUT_BUSY ((uint32_t)25) /* 25 ms */
mbed_official 376:cb4d9db17537 147 #define HAL_TIMEOUT_DIR ((uint32_t)25) /* 25 ms */
mbed_official 376:cb4d9db17537 148 #define HAL_TIMEOUT_RXNE ((uint32_t)25) /* 25 ms */
mbed_official 376:cb4d9db17537 149 #define HAL_TIMEOUT_STOPF ((uint32_t)25) /* 25 ms */
mbed_official 376:cb4d9db17537 150 #define HAL_TIMEOUT_TC ((uint32_t)25) /* 25 ms */
mbed_official 376:cb4d9db17537 151 #define HAL_TIMEOUT_TCR ((uint32_t)25) /* 25 ms */
mbed_official 376:cb4d9db17537 152 #define HAL_TIMEOUT_TXIS ((uint32_t)25) /* 25 ms */
mbed_official 376:cb4d9db17537 153 #define MAX_NBYTE_SIZE 255
mbed_official 376:cb4d9db17537 154
mbed_official 376:cb4d9db17537 155 /* Private macro -------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 156 #define __SMBUS_GET_ISR_REG(__HANDLE__) ((__HANDLE__)->Instance->ISR)
mbed_official 376:cb4d9db17537 157 #define __SMBUS_CHECK_FLAG(__ISR__, __FLAG__) ((((__ISR__) & ((__FLAG__) & SMBUS_FLAG_MASK)) == ((__FLAG__) & SMBUS_FLAG_MASK)))
mbed_official 376:cb4d9db17537 158
mbed_official 376:cb4d9db17537 159 /* Private variables ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 160 /* Private function prototypes -----------------------------------------------*/
mbed_official 376:cb4d9db17537 161 static HAL_StatusTypeDef SMBUS_WaitOnFlagUntilTimeout(SMBUS_HandleTypeDef *hsmbus, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
mbed_official 376:cb4d9db17537 162
mbed_official 376:cb4d9db17537 163 static HAL_StatusTypeDef SMBUS_Enable_IRQ(SMBUS_HandleTypeDef *hsmbus, uint16_t InterruptRequest);
mbed_official 376:cb4d9db17537 164 static HAL_StatusTypeDef SMBUS_Disable_IRQ(SMBUS_HandleTypeDef *hsmbus, uint16_t InterruptRequest);
mbed_official 376:cb4d9db17537 165 static HAL_StatusTypeDef SMBUS_Master_ISR(SMBUS_HandleTypeDef *hsmbus);
mbed_official 376:cb4d9db17537 166 static HAL_StatusTypeDef SMBUS_Slave_ISR(SMBUS_HandleTypeDef *hsmbus);
mbed_official 376:cb4d9db17537 167
mbed_official 376:cb4d9db17537 168 static void SMBUS_TransferConfig(SMBUS_HandleTypeDef *hsmbus, uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request);
mbed_official 376:cb4d9db17537 169
mbed_official 376:cb4d9db17537 170 /* Private functions ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 171
mbed_official 376:cb4d9db17537 172 /** @defgroup SMBUS_Private_Functions
mbed_official 376:cb4d9db17537 173 * @{
mbed_official 376:cb4d9db17537 174 */
mbed_official 376:cb4d9db17537 175
mbed_official 376:cb4d9db17537 176 /** @defgroup SMBUS_Group1 Initialization and de-initialization functions
mbed_official 376:cb4d9db17537 177 * @brief Initialization and Configuration functions
mbed_official 376:cb4d9db17537 178 *
mbed_official 376:cb4d9db17537 179 @verbatim
mbed_official 376:cb4d9db17537 180 ===============================================================================
mbed_official 376:cb4d9db17537 181 ##### Initialization and de-initialization functions #####
mbed_official 376:cb4d9db17537 182 ===============================================================================
mbed_official 376:cb4d9db17537 183 [..] This subsection provides a set of functions allowing to initialize and
mbed_official 376:cb4d9db17537 184 de-initialiaze the SMBUSx peripheral:
mbed_official 376:cb4d9db17537 185
mbed_official 376:cb4d9db17537 186 (+) User must Implement HAL_SMBUS_MspInit() function in which he configures
mbed_official 376:cb4d9db17537 187 all related peripherals resources (CLOCK, GPIO, IT and NVIC ).
mbed_official 376:cb4d9db17537 188
mbed_official 376:cb4d9db17537 189 (+) Call the function HAL_SMBUS_Init() to configure the selected device with
mbed_official 376:cb4d9db17537 190 the selected configuration:
mbed_official 376:cb4d9db17537 191 (++) Clock Timing
mbed_official 376:cb4d9db17537 192 (++) Bus Timeout
mbed_official 376:cb4d9db17537 193 (++) Analog Filer mode
mbed_official 376:cb4d9db17537 194 (++) Own Address 1
mbed_official 376:cb4d9db17537 195 (++) Addressing mode (Master, Slave)
mbed_official 376:cb4d9db17537 196 (++) Dual Addressing mode
mbed_official 376:cb4d9db17537 197 (++) Own Address 2
mbed_official 376:cb4d9db17537 198 (++) Own Address 2 Mask
mbed_official 376:cb4d9db17537 199 (++) General call mode
mbed_official 376:cb4d9db17537 200 (++) Nostretch mode
mbed_official 376:cb4d9db17537 201 (++) Packet Error Check mode
mbed_official 376:cb4d9db17537 202 (++) Peripheral mode
mbed_official 376:cb4d9db17537 203
mbed_official 376:cb4d9db17537 204 (+) Call the function HAL_SMBUS_DeInit() to restore the default configuration
mbed_official 376:cb4d9db17537 205 of the selected SMBUSx periperal.
mbed_official 376:cb4d9db17537 206
mbed_official 376:cb4d9db17537 207 @endverbatim
mbed_official 376:cb4d9db17537 208 * @{
mbed_official 376:cb4d9db17537 209 */
mbed_official 376:cb4d9db17537 210
mbed_official 376:cb4d9db17537 211 /**
mbed_official 376:cb4d9db17537 212 * @brief Initializes the SMBUS according to the specified parameters
mbed_official 376:cb4d9db17537 213 * in the SMBUS_InitTypeDef and create the associated handle.
mbed_official 376:cb4d9db17537 214 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 215 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 216 * @retval HAL status
mbed_official 376:cb4d9db17537 217 */
mbed_official 376:cb4d9db17537 218 HAL_StatusTypeDef HAL_SMBUS_Init(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 219 {
mbed_official 376:cb4d9db17537 220 /* Check the SMBUS handle allocation */
mbed_official 489:119543c9f674 221 if(hsmbus == NULL)
mbed_official 376:cb4d9db17537 222 {
mbed_official 376:cb4d9db17537 223 return HAL_ERROR;
mbed_official 376:cb4d9db17537 224 }
mbed_official 376:cb4d9db17537 225
mbed_official 376:cb4d9db17537 226 /* Check the parameters */
mbed_official 376:cb4d9db17537 227 assert_param(IS_SMBUS_INSTANCE(hsmbus->Instance));
mbed_official 376:cb4d9db17537 228 assert_param(IS_SMBUS_ANALOG_FILTER(hsmbus->Init.AnalogFilter));
mbed_official 376:cb4d9db17537 229 assert_param(IS_SMBUS_OWN_ADDRESS1(hsmbus->Init.OwnAddress1));
mbed_official 376:cb4d9db17537 230 assert_param(IS_SMBUS_ADDRESSING_MODE(hsmbus->Init.AddressingMode));
mbed_official 376:cb4d9db17537 231 assert_param(IS_SMBUS_DUAL_ADDRESS(hsmbus->Init.DualAddressMode));
mbed_official 376:cb4d9db17537 232 assert_param(IS_SMBUS_OWN_ADDRESS2(hsmbus->Init.OwnAddress2));
mbed_official 376:cb4d9db17537 233 assert_param(IS_SMBUS_OWN_ADDRESS2_MASK(hsmbus->Init.OwnAddress2Masks));
mbed_official 376:cb4d9db17537 234 assert_param(IS_SMBUS_GENERAL_CALL(hsmbus->Init.GeneralCallMode));
mbed_official 376:cb4d9db17537 235 assert_param(IS_SMBUS_NO_STRETCH(hsmbus->Init.NoStretchMode));
mbed_official 376:cb4d9db17537 236 assert_param(IS_SMBUS_PEC(hsmbus->Init.PacketErrorCheckMode));
mbed_official 376:cb4d9db17537 237 assert_param(IS_SMBUS_PERIPHERAL_MODE(hsmbus->Init.PeripheralMode));
mbed_official 376:cb4d9db17537 238
mbed_official 376:cb4d9db17537 239 if(hsmbus->State == HAL_SMBUS_STATE_RESET)
mbed_official 376:cb4d9db17537 240 {
mbed_official 376:cb4d9db17537 241 /* Init the low level hardware : GPIO, CLOCK, NVIC */
mbed_official 376:cb4d9db17537 242 HAL_SMBUS_MspInit(hsmbus);
mbed_official 376:cb4d9db17537 243 }
mbed_official 376:cb4d9db17537 244
mbed_official 376:cb4d9db17537 245 hsmbus->State = HAL_SMBUS_STATE_BUSY;
mbed_official 376:cb4d9db17537 246
mbed_official 376:cb4d9db17537 247 /* Disable the selected SMBUS peripheral */
mbed_official 376:cb4d9db17537 248 __HAL_SMBUS_DISABLE(hsmbus);
mbed_official 376:cb4d9db17537 249
mbed_official 376:cb4d9db17537 250 /*---------------------------- SMBUSx TIMINGR Configuration ----------------*/
mbed_official 376:cb4d9db17537 251 /* Configure SMBUSx: Frequency range */
mbed_official 376:cb4d9db17537 252 hsmbus->Instance->TIMINGR = hsmbus->Init.Timing & TIMING_CLEAR_MASK;
mbed_official 376:cb4d9db17537 253
mbed_official 376:cb4d9db17537 254 /*---------------------------- SMBUSx TIMEOUTR Configuration ---------------*/
mbed_official 376:cb4d9db17537 255 /* Configure SMBUSx: Bus Timeout */
mbed_official 376:cb4d9db17537 256 hsmbus->Instance->TIMEOUTR = hsmbus->Init.SMBusTimeout;
mbed_official 376:cb4d9db17537 257
mbed_official 376:cb4d9db17537 258 /*---------------------------- SMBUSx OAR1 Configuration -------------------*/
mbed_official 376:cb4d9db17537 259 /* Configure SMBUSx: Own Address1 and ack own address1 mode */
mbed_official 376:cb4d9db17537 260 hsmbus->Instance->OAR1 &= ~I2C_OAR1_OA1EN;
mbed_official 376:cb4d9db17537 261 if(hsmbus->Init.OwnAddress1 != 0)
mbed_official 376:cb4d9db17537 262 {
mbed_official 376:cb4d9db17537 263 if(hsmbus->Init.AddressingMode == SMBUS_ADDRESSINGMODE_7BIT)
mbed_official 376:cb4d9db17537 264 {
mbed_official 376:cb4d9db17537 265 hsmbus->Instance->OAR1 = (I2C_OAR1_OA1EN | hsmbus->Init.OwnAddress1);
mbed_official 376:cb4d9db17537 266 }
mbed_official 376:cb4d9db17537 267 else /* SMBUS_ADDRESSINGMODE_10BIT */
mbed_official 376:cb4d9db17537 268 {
mbed_official 376:cb4d9db17537 269 hsmbus->Instance->OAR1 = (I2C_OAR1_OA1EN | I2C_OAR1_OA1MODE | hsmbus->Init.OwnAddress1);
mbed_official 376:cb4d9db17537 270 }
mbed_official 376:cb4d9db17537 271 }
mbed_official 376:cb4d9db17537 272
mbed_official 376:cb4d9db17537 273 /*---------------------------- SMBUSx CR2 Configuration --------------------*/
mbed_official 376:cb4d9db17537 274 /* Configure SMBUSx: Addressing Master mode */
mbed_official 376:cb4d9db17537 275 if(hsmbus->Init.AddressingMode == SMBUS_ADDRESSINGMODE_10BIT)
mbed_official 376:cb4d9db17537 276 {
mbed_official 376:cb4d9db17537 277 hsmbus->Instance->CR2 = (I2C_CR2_ADD10);
mbed_official 376:cb4d9db17537 278 }
mbed_official 376:cb4d9db17537 279 /* Enable the AUTOEND by default, and enable NACK (should be disable only during Slave process) */
mbed_official 376:cb4d9db17537 280 /* AUTOEND and NACK bit will be manage during Transfer process */
mbed_official 376:cb4d9db17537 281 hsmbus->Instance->CR2 |= (I2C_CR2_AUTOEND | I2C_CR2_NACK);
mbed_official 376:cb4d9db17537 282
mbed_official 376:cb4d9db17537 283 /*---------------------------- SMBUSx OAR2 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 284 /* Configure SMBUSx: Dual mode and Own Address2 */
mbed_official 376:cb4d9db17537 285 hsmbus->Instance->OAR2 = (hsmbus->Init.DualAddressMode | hsmbus->Init.OwnAddress2 | (hsmbus->Init.OwnAddress2Masks << 8));
mbed_official 376:cb4d9db17537 286
mbed_official 376:cb4d9db17537 287 /*---------------------------- SMBUSx CR1 Configuration ------------------------*/
mbed_official 376:cb4d9db17537 288 /* Configure SMBUSx: Generalcall and NoStretch mode */
mbed_official 376:cb4d9db17537 289 hsmbus->Instance->CR1 = (hsmbus->Init.GeneralCallMode | hsmbus->Init.NoStretchMode | hsmbus->Init.PacketErrorCheckMode | hsmbus->Init.PeripheralMode | hsmbus->Init.AnalogFilter);
mbed_official 376:cb4d9db17537 290
mbed_official 376:cb4d9db17537 291 /* Enable Slave Byte Control only in case of Packet Error Check is enabled and SMBUS Peripheral is set in Slave mode */
mbed_official 489:119543c9f674 292 if( (hsmbus->Init.PacketErrorCheckMode == SMBUS_PEC_ENABLE)
mbed_official 376:cb4d9db17537 293 && ( (hsmbus->Init.PeripheralMode == SMBUS_PERIPHERAL_MODE_SMBUS_SLAVE) || (hsmbus->Init.PeripheralMode == SMBUS_PERIPHERAL_MODE_SMBUS_SLAVE_ARP) ) )
mbed_official 376:cb4d9db17537 294 {
mbed_official 376:cb4d9db17537 295 hsmbus->Instance->CR1 |= I2C_CR1_SBC;
mbed_official 376:cb4d9db17537 296 }
mbed_official 376:cb4d9db17537 297
mbed_official 376:cb4d9db17537 298 /* Enable the selected SMBUS peripheral */
mbed_official 376:cb4d9db17537 299 __HAL_SMBUS_ENABLE(hsmbus);
mbed_official 376:cb4d9db17537 300
mbed_official 376:cb4d9db17537 301 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 302 hsmbus->PreviousState = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 303 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 304
mbed_official 376:cb4d9db17537 305 return HAL_OK;
mbed_official 376:cb4d9db17537 306 }
mbed_official 376:cb4d9db17537 307
mbed_official 376:cb4d9db17537 308 /**
mbed_official 376:cb4d9db17537 309 * @brief DeInitializes the SMBUS peripheral.
mbed_official 376:cb4d9db17537 310 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 311 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 312 * @retval HAL status
mbed_official 376:cb4d9db17537 313 */
mbed_official 376:cb4d9db17537 314 HAL_StatusTypeDef HAL_SMBUS_DeInit(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 315 {
mbed_official 376:cb4d9db17537 316 /* Check the SMBUS handle allocation */
mbed_official 489:119543c9f674 317 if(hsmbus == NULL)
mbed_official 376:cb4d9db17537 318 {
mbed_official 376:cb4d9db17537 319 return HAL_ERROR;
mbed_official 376:cb4d9db17537 320 }
mbed_official 376:cb4d9db17537 321
mbed_official 376:cb4d9db17537 322 /* Check the parameters */
mbed_official 376:cb4d9db17537 323 assert_param(IS_SMBUS_INSTANCE(hsmbus->Instance));
mbed_official 376:cb4d9db17537 324
mbed_official 376:cb4d9db17537 325 hsmbus->State = HAL_SMBUS_STATE_BUSY;
mbed_official 376:cb4d9db17537 326
mbed_official 376:cb4d9db17537 327 /* Disable the SMBUS Peripheral Clock */
mbed_official 376:cb4d9db17537 328 __HAL_SMBUS_DISABLE(hsmbus);
mbed_official 376:cb4d9db17537 329
mbed_official 376:cb4d9db17537 330 /* DeInit the low level hardware: GPIO, CLOCK, NVIC */
mbed_official 376:cb4d9db17537 331 HAL_SMBUS_MspDeInit(hsmbus);
mbed_official 376:cb4d9db17537 332
mbed_official 376:cb4d9db17537 333 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 334 hsmbus->PreviousState = HAL_SMBUS_STATE_RESET;
mbed_official 376:cb4d9db17537 335 hsmbus->State = HAL_SMBUS_STATE_RESET;
mbed_official 376:cb4d9db17537 336
mbed_official 376:cb4d9db17537 337 /* Release Lock */
mbed_official 376:cb4d9db17537 338 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 339
mbed_official 376:cb4d9db17537 340 return HAL_OK;
mbed_official 376:cb4d9db17537 341 }
mbed_official 376:cb4d9db17537 342
mbed_official 376:cb4d9db17537 343 /**
mbed_official 376:cb4d9db17537 344 * @brief SMBUS MSP Init.
mbed_official 376:cb4d9db17537 345 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 346 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 347 * @retval None
mbed_official 376:cb4d9db17537 348 */
mbed_official 376:cb4d9db17537 349 __weak void HAL_SMBUS_MspInit(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 350 {
mbed_official 376:cb4d9db17537 351 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 352 the HAL_SMBUS_MspInit could be implemented in the user file
mbed_official 376:cb4d9db17537 353 */
mbed_official 376:cb4d9db17537 354 }
mbed_official 376:cb4d9db17537 355
mbed_official 376:cb4d9db17537 356 /**
mbed_official 376:cb4d9db17537 357 * @brief SMBUS MSP DeInit
mbed_official 376:cb4d9db17537 358 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 359 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 360 * @retval None
mbed_official 376:cb4d9db17537 361 */
mbed_official 376:cb4d9db17537 362 __weak void HAL_SMBUS_MspDeInit(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 363 {
mbed_official 376:cb4d9db17537 364 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 365 the HAL_SMBUS_MspDeInit could be implemented in the user file
mbed_official 376:cb4d9db17537 366 */
mbed_official 376:cb4d9db17537 367 }
mbed_official 376:cb4d9db17537 368
mbed_official 376:cb4d9db17537 369 /**
mbed_official 376:cb4d9db17537 370 * @}
mbed_official 376:cb4d9db17537 371 */
mbed_official 376:cb4d9db17537 372
mbed_official 376:cb4d9db17537 373 /** @defgroup SMBUS_Group2 IO operation functions
mbed_official 376:cb4d9db17537 374 * @brief Data transfers functions
mbed_official 376:cb4d9db17537 375 *
mbed_official 376:cb4d9db17537 376 @verbatim
mbed_official 376:cb4d9db17537 377 ===============================================================================
mbed_official 376:cb4d9db17537 378 ##### IO operation functions #####
mbed_official 376:cb4d9db17537 379 ===============================================================================
mbed_official 376:cb4d9db17537 380 [..]
mbed_official 376:cb4d9db17537 381 This subsection provides a set of functions allowing to manage the SMBUS data
mbed_official 376:cb4d9db17537 382 transfers.
mbed_official 376:cb4d9db17537 383
mbed_official 376:cb4d9db17537 384 (#) Blocking mode function to check if device is ready for usage is :
mbed_official 376:cb4d9db17537 385 (++) HAL_SMBUS_IsDeviceReady()
mbed_official 376:cb4d9db17537 386
mbed_official 376:cb4d9db17537 387 (#) There is only one mode of transfer:
mbed_official 376:cb4d9db17537 388 (++) No-Blocking mode : The communication is performed using Interrupts.
mbed_official 376:cb4d9db17537 389 These functions return the status of the transfer startup.
mbed_official 376:cb4d9db17537 390 The end of the data processing will be indicated through the
mbed_official 376:cb4d9db17537 391 dedicated SMBUS IRQ when using Interrupt mode.
mbed_official 376:cb4d9db17537 392
mbed_official 376:cb4d9db17537 393 (#) No-Blocking mode functions with Interrupt are :
mbed_official 376:cb4d9db17537 394 (++) HAL_SMBUS_Master_Transmit_IT()
mbed_official 376:cb4d9db17537 395 (++) HAL_SMBUS_Master_Receive_IT()
mbed_official 376:cb4d9db17537 396 (++) HAL_SMBUS_Slave_Transmit_IT()
mbed_official 376:cb4d9db17537 397 (++) HAL_SMBUS_Slave_Receive_IT()
mbed_official 489:119543c9f674 398 (++) HAL_SMBUS_EnableListen_IT()
mbed_official 376:cb4d9db17537 399 (++) HAL_SMBUS_EnableAlert_IT()
mbed_official 376:cb4d9db17537 400 (++) HAL_SMBUS_DisableAlert_IT()
mbed_official 376:cb4d9db17537 401
mbed_official 376:cb4d9db17537 402 (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:
mbed_official 376:cb4d9db17537 403 (++) HAL_SMBUS_MasterTxCpltCallback()
mbed_official 376:cb4d9db17537 404 (++) HAL_SMBUS_MasterRxCpltCallback()
mbed_official 376:cb4d9db17537 405 (++) HAL_SMBUS_SlaveTxCpltCallback()
mbed_official 376:cb4d9db17537 406 (++) HAL_SMBUS_SlaveRxCpltCallback()
mbed_official 489:119543c9f674 407 (++) HAL_SMBUS_AddrCallback()
mbed_official 489:119543c9f674 408 (++) HAL_SMBUS_ListenCpltCallback()
mbed_official 376:cb4d9db17537 409 (++) HAL_SMBUS_ErrorCallback()
mbed_official 376:cb4d9db17537 410
mbed_official 376:cb4d9db17537 411 @endverbatim
mbed_official 376:cb4d9db17537 412 * @{
mbed_official 376:cb4d9db17537 413 */
mbed_official 376:cb4d9db17537 414
mbed_official 376:cb4d9db17537 415 /**
mbed_official 376:cb4d9db17537 416 * @brief Transmit in master/host SMBUS mode an amount of data in no-blocking mode with Interrupt
mbed_official 376:cb4d9db17537 417 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 418 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 419 * @param DevAddress: Target device address
mbed_official 376:cb4d9db17537 420 * @param pData: Pointer to data buffer
mbed_official 376:cb4d9db17537 421 * @param Size: Amount of data to be sent
mbed_official 376:cb4d9db17537 422 * @param XferOptions: Options of Transfer, value of @ref SMBUS_XferOptions_definition
mbed_official 376:cb4d9db17537 423 * @retval HAL status
mbed_official 376:cb4d9db17537 424 */
mbed_official 376:cb4d9db17537 425 HAL_StatusTypeDef HAL_SMBUS_Master_Transmit_IT(SMBUS_HandleTypeDef *hsmbus, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t XferOptions)
mbed_official 376:cb4d9db17537 426 {
mbed_official 376:cb4d9db17537 427 /* Check the parameters */
mbed_official 376:cb4d9db17537 428 assert_param(IS_SMBUS_TRANSFER_OPTIONS_REQUEST(XferOptions));
mbed_official 376:cb4d9db17537 429
mbed_official 376:cb4d9db17537 430 if(hsmbus->State == HAL_SMBUS_STATE_READY)
mbed_official 376:cb4d9db17537 431 {
mbed_official 376:cb4d9db17537 432 /* Process Locked */
mbed_official 376:cb4d9db17537 433 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 434
mbed_official 376:cb4d9db17537 435 hsmbus->State = HAL_SMBUS_STATE_MASTER_BUSY_TX;
mbed_official 376:cb4d9db17537 436 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 437 /* Prepare transfer parameters */
mbed_official 376:cb4d9db17537 438 hsmbus->pBuffPtr = pData;
mbed_official 376:cb4d9db17537 439 hsmbus->XferCount = Size;
mbed_official 376:cb4d9db17537 440 hsmbus->XferOptions = XferOptions;
mbed_official 376:cb4d9db17537 441
mbed_official 376:cb4d9db17537 442 /* In case of Quick command, remove autoend mode */
mbed_official 376:cb4d9db17537 443 /* Manage the stop generation by software */
mbed_official 489:119543c9f674 444 if(hsmbus->pBuffPtr == NULL)
mbed_official 376:cb4d9db17537 445 {
mbed_official 376:cb4d9db17537 446 hsmbus->XferOptions &= ~SMBUS_AUTOEND_MODE;
mbed_official 376:cb4d9db17537 447 }
mbed_official 376:cb4d9db17537 448
mbed_official 376:cb4d9db17537 449 if(Size > MAX_NBYTE_SIZE)
mbed_official 376:cb4d9db17537 450 {
mbed_official 376:cb4d9db17537 451 hsmbus->XferSize = MAX_NBYTE_SIZE;
mbed_official 376:cb4d9db17537 452 }
mbed_official 376:cb4d9db17537 453 else
mbed_official 376:cb4d9db17537 454 {
mbed_official 376:cb4d9db17537 455 hsmbus->XferSize = Size;
mbed_official 376:cb4d9db17537 456 }
mbed_official 376:cb4d9db17537 457
mbed_official 376:cb4d9db17537 458 /* Send Slave Address */
mbed_official 376:cb4d9db17537 459 /* Set NBYTES to write and reload if size > MAX_NBYTE_SIZE and generate RESTART */
mbed_official 376:cb4d9db17537 460 if( (hsmbus->XferSize == MAX_NBYTE_SIZE) && (hsmbus->XferSize < hsmbus->XferCount) )
mbed_official 376:cb4d9db17537 461 {
mbed_official 376:cb4d9db17537 462 SMBUS_TransferConfig(hsmbus,DevAddress,hsmbus->XferSize, SMBUS_RELOAD_MODE, SMBUS_GENERATE_START_WRITE);
mbed_official 376:cb4d9db17537 463 }
mbed_official 376:cb4d9db17537 464 else
mbed_official 376:cb4d9db17537 465 {
mbed_official 376:cb4d9db17537 466 /* If transfer direction not change, do not generate Restart Condition */
mbed_official 376:cb4d9db17537 467 /* Mean Previous state is same as current state */
mbed_official 376:cb4d9db17537 468 if(hsmbus->PreviousState == HAL_SMBUS_STATE_MASTER_BUSY_TX)
mbed_official 376:cb4d9db17537 469 {
mbed_official 376:cb4d9db17537 470 SMBUS_TransferConfig(hsmbus,DevAddress,hsmbus->XferSize, hsmbus->XferOptions, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 471 }
mbed_official 376:cb4d9db17537 472 /* Else transfer direction change, so generate Restart with new transfer direction */
mbed_official 376:cb4d9db17537 473 else
mbed_official 376:cb4d9db17537 474 {
mbed_official 376:cb4d9db17537 475 SMBUS_TransferConfig(hsmbus,DevAddress,hsmbus->XferSize, hsmbus->XferOptions, SMBUS_GENERATE_START_WRITE);
mbed_official 376:cb4d9db17537 476 }
mbed_official 376:cb4d9db17537 477
mbed_official 376:cb4d9db17537 478 /* If PEC mode is enable, size to transmit manage by SW part should be Size-1 byte, corresponding to PEC byte */
mbed_official 376:cb4d9db17537 479 /* PEC byte is automatically sent by HW block, no need to manage it in Transmit process */
mbed_official 489:119543c9f674 480 if(__SMBUS_GET_PEC_MODE(hsmbus) != RESET)
mbed_official 376:cb4d9db17537 481 {
mbed_official 376:cb4d9db17537 482 hsmbus->XferSize--;
mbed_official 376:cb4d9db17537 483 hsmbus->XferCount--;
mbed_official 376:cb4d9db17537 484 }
mbed_official 376:cb4d9db17537 485 }
mbed_official 376:cb4d9db17537 486
mbed_official 376:cb4d9db17537 487 /* Process Unlocked */
mbed_official 376:cb4d9db17537 488 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 489
mbed_official 376:cb4d9db17537 490 /* Note : The SMBUS interrupts must be enabled after unlocking current process
mbed_official 376:cb4d9db17537 491 to avoid the risk of SMBUS interrupt handle execution before current
mbed_official 376:cb4d9db17537 492 process unlock */
mbed_official 376:cb4d9db17537 493 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 494
mbed_official 376:cb4d9db17537 495 return HAL_OK;
mbed_official 376:cb4d9db17537 496 }
mbed_official 376:cb4d9db17537 497 else
mbed_official 376:cb4d9db17537 498 {
mbed_official 376:cb4d9db17537 499 return HAL_BUSY;
mbed_official 376:cb4d9db17537 500 }
mbed_official 376:cb4d9db17537 501 }
mbed_official 376:cb4d9db17537 502
mbed_official 376:cb4d9db17537 503 /**
mbed_official 376:cb4d9db17537 504 * @brief Receive in master/host SMBUS mode an amount of data in no-blocking mode with Interrupt
mbed_official 376:cb4d9db17537 505 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 506 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 507 * @param DevAddress: Target device address
mbed_official 376:cb4d9db17537 508 * @param pData: Pointer to data buffer
mbed_official 376:cb4d9db17537 509 * @param Size: Amount of data to be sent
mbed_official 376:cb4d9db17537 510 * @param XferOptions: Options of Transfer, value of @ref SMBUS_XferOptions_definition
mbed_official 376:cb4d9db17537 511 * @retval HAL status
mbed_official 376:cb4d9db17537 512 */
mbed_official 376:cb4d9db17537 513 HAL_StatusTypeDef HAL_SMBUS_Master_Receive_IT(SMBUS_HandleTypeDef *hsmbus, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t XferOptions)
mbed_official 376:cb4d9db17537 514 {
mbed_official 376:cb4d9db17537 515 /* Check the parameters */
mbed_official 376:cb4d9db17537 516 assert_param(IS_SMBUS_TRANSFER_OPTIONS_REQUEST(XferOptions));
mbed_official 376:cb4d9db17537 517
mbed_official 376:cb4d9db17537 518 if(hsmbus->State == HAL_SMBUS_STATE_READY)
mbed_official 376:cb4d9db17537 519 {
mbed_official 376:cb4d9db17537 520 /* Process Locked */
mbed_official 376:cb4d9db17537 521 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 522
mbed_official 376:cb4d9db17537 523 hsmbus->State = HAL_SMBUS_STATE_MASTER_BUSY_RX;
mbed_official 376:cb4d9db17537 524 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 525
mbed_official 376:cb4d9db17537 526 /* Prepare transfer parameters */
mbed_official 376:cb4d9db17537 527 hsmbus->pBuffPtr = pData;
mbed_official 376:cb4d9db17537 528 hsmbus->XferCount = Size;
mbed_official 376:cb4d9db17537 529 hsmbus->XferOptions = XferOptions;
mbed_official 376:cb4d9db17537 530
mbed_official 376:cb4d9db17537 531 /* In case of Quick command, remove autoend mode */
mbed_official 376:cb4d9db17537 532 /* Manage the stop generation by software */
mbed_official 489:119543c9f674 533 if(hsmbus->pBuffPtr == NULL)
mbed_official 376:cb4d9db17537 534 {
mbed_official 376:cb4d9db17537 535 hsmbus->XferOptions &= ~SMBUS_AUTOEND_MODE;
mbed_official 376:cb4d9db17537 536 }
mbed_official 376:cb4d9db17537 537
mbed_official 376:cb4d9db17537 538 if(Size > MAX_NBYTE_SIZE)
mbed_official 376:cb4d9db17537 539 {
mbed_official 376:cb4d9db17537 540 hsmbus->XferSize = MAX_NBYTE_SIZE;
mbed_official 376:cb4d9db17537 541 }
mbed_official 376:cb4d9db17537 542 else
mbed_official 376:cb4d9db17537 543 {
mbed_official 376:cb4d9db17537 544 hsmbus->XferSize = Size;
mbed_official 376:cb4d9db17537 545 }
mbed_official 376:cb4d9db17537 546
mbed_official 376:cb4d9db17537 547 /* Send Slave Address */
mbed_official 376:cb4d9db17537 548 /* Set NBYTES to write and reload if size > MAX_NBYTE_SIZE and generate RESTART */
mbed_official 376:cb4d9db17537 549 if( (hsmbus->XferSize == MAX_NBYTE_SIZE) && (hsmbus->XferSize < hsmbus->XferCount) )
mbed_official 376:cb4d9db17537 550 {
mbed_official 376:cb4d9db17537 551 SMBUS_TransferConfig(hsmbus,DevAddress,hsmbus->XferSize, SMBUS_RELOAD_MODE, SMBUS_GENERATE_START_READ);
mbed_official 376:cb4d9db17537 552 }
mbed_official 376:cb4d9db17537 553 else
mbed_official 376:cb4d9db17537 554 {
mbed_official 376:cb4d9db17537 555 /* If transfer direction not change, do not generate Restart Condition */
mbed_official 376:cb4d9db17537 556 /* Mean Previous state is same as current state */
mbed_official 376:cb4d9db17537 557 if(hsmbus->PreviousState == HAL_SMBUS_STATE_MASTER_BUSY_RX)
mbed_official 376:cb4d9db17537 558 {
mbed_official 376:cb4d9db17537 559 SMBUS_TransferConfig(hsmbus,DevAddress,hsmbus->XferSize, hsmbus->XferOptions, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 560 }
mbed_official 376:cb4d9db17537 561 /* Else transfer direction change, so generate Restart with new transfer direction */
mbed_official 376:cb4d9db17537 562 else
mbed_official 376:cb4d9db17537 563 {
mbed_official 376:cb4d9db17537 564 SMBUS_TransferConfig(hsmbus,DevAddress,hsmbus->XferSize, hsmbus->XferOptions, SMBUS_GENERATE_START_READ);
mbed_official 376:cb4d9db17537 565 }
mbed_official 376:cb4d9db17537 566 }
mbed_official 376:cb4d9db17537 567
mbed_official 376:cb4d9db17537 568 /* Process Unlocked */
mbed_official 376:cb4d9db17537 569 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 570
mbed_official 376:cb4d9db17537 571 /* Note : The SMBUS interrupts must be enabled after unlocking current process
mbed_official 376:cb4d9db17537 572 to avoid the risk of SMBUS interrupt handle execution before current
mbed_official 376:cb4d9db17537 573 process unlock */
mbed_official 376:cb4d9db17537 574 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_RX);
mbed_official 376:cb4d9db17537 575
mbed_official 376:cb4d9db17537 576 return HAL_OK;
mbed_official 376:cb4d9db17537 577 }
mbed_official 376:cb4d9db17537 578 else
mbed_official 376:cb4d9db17537 579 {
mbed_official 376:cb4d9db17537 580 return HAL_BUSY;
mbed_official 376:cb4d9db17537 581 }
mbed_official 376:cb4d9db17537 582 }
mbed_official 376:cb4d9db17537 583
mbed_official 376:cb4d9db17537 584 /**
mbed_official 376:cb4d9db17537 585 * @brief Abort a master/host SMBUS process commnunication with Interrupt
mbed_official 376:cb4d9db17537 586 * @note : This abort can be called only if state is ready
mbed_official 376:cb4d9db17537 587 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 588 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 589 * @param DevAddress: Target device address
mbed_official 376:cb4d9db17537 590 * @retval HAL status
mbed_official 376:cb4d9db17537 591 */
mbed_official 376:cb4d9db17537 592 HAL_StatusTypeDef HAL_SMBUS_Master_Abort_IT(SMBUS_HandleTypeDef *hsmbus, uint16_t DevAddress)
mbed_official 376:cb4d9db17537 593 {
mbed_official 376:cb4d9db17537 594 if(hsmbus->State == HAL_SMBUS_STATE_READY)
mbed_official 376:cb4d9db17537 595 {
mbed_official 376:cb4d9db17537 596 /* Process Locked */
mbed_official 376:cb4d9db17537 597 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 598
mbed_official 376:cb4d9db17537 599 /* Keep the same state as previous */
mbed_official 376:cb4d9db17537 600 /* to perform as well the call of the corresponding end of transfer callback */
mbed_official 376:cb4d9db17537 601 if(hsmbus->PreviousState == HAL_SMBUS_STATE_MASTER_BUSY_TX)
mbed_official 376:cb4d9db17537 602 {
mbed_official 376:cb4d9db17537 603 hsmbus->State = HAL_SMBUS_STATE_MASTER_BUSY_TX;
mbed_official 376:cb4d9db17537 604 }
mbed_official 376:cb4d9db17537 605 else if(hsmbus->PreviousState == HAL_SMBUS_STATE_MASTER_BUSY_RX)
mbed_official 376:cb4d9db17537 606 {
mbed_official 376:cb4d9db17537 607 hsmbus->State = HAL_SMBUS_STATE_MASTER_BUSY_RX;
mbed_official 376:cb4d9db17537 608 }
mbed_official 376:cb4d9db17537 609 else
mbed_official 376:cb4d9db17537 610 {
mbed_official 376:cb4d9db17537 611 /* Wrong usage of abort function */
mbed_official 376:cb4d9db17537 612 /* This function should be used only in case of abort monitored by master device */
mbed_official 376:cb4d9db17537 613 return HAL_ERROR;
mbed_official 376:cb4d9db17537 614 }
mbed_official 376:cb4d9db17537 615 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 616
mbed_official 376:cb4d9db17537 617 /* Set NBYTES to 1 to generate a dummy read on SMBUS peripheral */
mbed_official 376:cb4d9db17537 618 /* Set AUTOEND mode, this will generate a NACK then STOP condition to abort the current transfer */
mbed_official 376:cb4d9db17537 619 SMBUS_TransferConfig(hsmbus, DevAddress, 1, SMBUS_AUTOEND_MODE, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 620
mbed_official 376:cb4d9db17537 621 /* Process Unlocked */
mbed_official 376:cb4d9db17537 622 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 623
mbed_official 376:cb4d9db17537 624 /* Note : The SMBUS interrupts must be enabled after unlocking current process
mbed_official 376:cb4d9db17537 625 to avoid the risk of SMBUS interrupt handle execution before current
mbed_official 376:cb4d9db17537 626 process unlock */
mbed_official 376:cb4d9db17537 627 if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_TX)
mbed_official 376:cb4d9db17537 628 {
mbed_official 376:cb4d9db17537 629 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 630 }
mbed_official 376:cb4d9db17537 631 else if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_RX)
mbed_official 376:cb4d9db17537 632 {
mbed_official 376:cb4d9db17537 633 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_RX);
mbed_official 376:cb4d9db17537 634 }
mbed_official 376:cb4d9db17537 635
mbed_official 376:cb4d9db17537 636 return HAL_OK;
mbed_official 376:cb4d9db17537 637 }
mbed_official 376:cb4d9db17537 638 else
mbed_official 376:cb4d9db17537 639 {
mbed_official 376:cb4d9db17537 640 return HAL_BUSY;
mbed_official 376:cb4d9db17537 641 }
mbed_official 376:cb4d9db17537 642 }
mbed_official 376:cb4d9db17537 643
mbed_official 376:cb4d9db17537 644 /**
mbed_official 376:cb4d9db17537 645 * @brief Transmit in slave/device SMBUS mode an amount of data in no-blocking mode with Interrupt
mbed_official 376:cb4d9db17537 646 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 647 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 648 * @param pData: Pointer to data buffer
mbed_official 376:cb4d9db17537 649 * @param Size: Amount of data to be sent
mbed_official 376:cb4d9db17537 650 * @param XferOptions: Options of Transfer, value of @ref SMBUS_XferOptions_definition
mbed_official 376:cb4d9db17537 651 * @retval HAL status
mbed_official 376:cb4d9db17537 652 */
mbed_official 376:cb4d9db17537 653 HAL_StatusTypeDef HAL_SMBUS_Slave_Transmit_IT(SMBUS_HandleTypeDef *hsmbus, uint8_t *pData, uint16_t Size, uint32_t XferOptions)
mbed_official 376:cb4d9db17537 654 {
mbed_official 376:cb4d9db17537 655 /* Check the parameters */
mbed_official 376:cb4d9db17537 656 assert_param(IS_SMBUS_TRANSFER_OPTIONS_REQUEST(XferOptions));
mbed_official 376:cb4d9db17537 657
mbed_official 376:cb4d9db17537 658 if(hsmbus->State == HAL_SMBUS_STATE_LISTEN)
mbed_official 376:cb4d9db17537 659 {
mbed_official 489:119543c9f674 660 if((pData == NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 661 {
mbed_official 376:cb4d9db17537 662 return HAL_ERROR;
mbed_official 376:cb4d9db17537 663 }
mbed_official 376:cb4d9db17537 664
mbed_official 376:cb4d9db17537 665 /* Disable Interrupts, to prevent preemption during treatment in case of multicall */
mbed_official 376:cb4d9db17537 666 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_ADDR | SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 667
mbed_official 376:cb4d9db17537 668 /* Process Locked */
mbed_official 376:cb4d9db17537 669 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 670
mbed_official 376:cb4d9db17537 671 hsmbus->State |= HAL_SMBUS_STATE_SLAVE_BUSY_TX;
mbed_official 376:cb4d9db17537 672 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 673
mbed_official 376:cb4d9db17537 674 /* Enable Address Acknowledge */
mbed_official 376:cb4d9db17537 675 hsmbus->Instance->CR2 &= ~I2C_CR2_NACK;
mbed_official 376:cb4d9db17537 676
mbed_official 376:cb4d9db17537 677 /* Prepare transfer parameters */
mbed_official 376:cb4d9db17537 678 hsmbus->pBuffPtr = pData;
mbed_official 376:cb4d9db17537 679 hsmbus->XferSize = Size;
mbed_official 376:cb4d9db17537 680 hsmbus->XferCount = Size;
mbed_official 376:cb4d9db17537 681 hsmbus->XferOptions = XferOptions;
mbed_official 376:cb4d9db17537 682
mbed_official 376:cb4d9db17537 683 /* Set NBYTE to transmit */
mbed_official 376:cb4d9db17537 684 SMBUS_TransferConfig(hsmbus,0,hsmbus->XferSize, hsmbus->XferOptions, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 685
mbed_official 376:cb4d9db17537 686 /* If PEC mode is enable, size to transmit should be Size-1 byte, corresponding to PEC byte */
mbed_official 376:cb4d9db17537 687 /* PEC byte is automatically sent by HW block, no need to manage it in Transmit process */
mbed_official 489:119543c9f674 688 if(__SMBUS_GET_PEC_MODE(hsmbus) != RESET)
mbed_official 376:cb4d9db17537 689 {
mbed_official 376:cb4d9db17537 690 hsmbus->XferSize--;
mbed_official 376:cb4d9db17537 691 hsmbus->XferCount--;
mbed_official 376:cb4d9db17537 692 }
mbed_official 376:cb4d9db17537 693
mbed_official 376:cb4d9db17537 694 /* Clear ADDR flag after prepare the transfer parameters */
mbed_official 376:cb4d9db17537 695 /* This action will generate an acknowledge to the HOST */
mbed_official 376:cb4d9db17537 696 __HAL_SMBUS_CLEAR_FLAG(hsmbus,SMBUS_FLAG_ADDR);
mbed_official 376:cb4d9db17537 697
mbed_official 376:cb4d9db17537 698 /* Process Unlocked */
mbed_official 376:cb4d9db17537 699 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 700
mbed_official 376:cb4d9db17537 701 /* Note : The SMBUS interrupts must be enabled after unlocking current process
mbed_official 376:cb4d9db17537 702 to avoid the risk of SMBUS interrupt handle execution before current
mbed_official 376:cb4d9db17537 703 process unlock */
mbed_official 376:cb4d9db17537 704 /* REnable ADDR interrupt */
mbed_official 376:cb4d9db17537 705 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_TX | SMBUS_IT_ADDR);
mbed_official 376:cb4d9db17537 706
mbed_official 376:cb4d9db17537 707 return HAL_OK;
mbed_official 376:cb4d9db17537 708 }
mbed_official 376:cb4d9db17537 709 else
mbed_official 376:cb4d9db17537 710 {
mbed_official 376:cb4d9db17537 711 return HAL_ERROR;
mbed_official 376:cb4d9db17537 712 }
mbed_official 376:cb4d9db17537 713 }
mbed_official 376:cb4d9db17537 714
mbed_official 376:cb4d9db17537 715 /**
mbed_official 376:cb4d9db17537 716 * @brief Receive in slave/device SMBUS mode an amount of data in no-blocking mode with Interrupt
mbed_official 376:cb4d9db17537 717 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 718 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 719 * @param pData: Pointer to data buffer
mbed_official 376:cb4d9db17537 720 * @param Size: Amount of data to be sent
mbed_official 376:cb4d9db17537 721 * @param XferOptions: Options of Transfer, value of @ref SMBUS_XferOptions_definition
mbed_official 376:cb4d9db17537 722 * @retval HAL status
mbed_official 376:cb4d9db17537 723 */
mbed_official 376:cb4d9db17537 724 HAL_StatusTypeDef HAL_SMBUS_Slave_Receive_IT(SMBUS_HandleTypeDef *hsmbus, uint8_t *pData, uint16_t Size, uint32_t XferOptions)
mbed_official 376:cb4d9db17537 725 {
mbed_official 376:cb4d9db17537 726 /* Check the parameters */
mbed_official 376:cb4d9db17537 727 assert_param(IS_SMBUS_TRANSFER_OPTIONS_REQUEST(XferOptions));
mbed_official 376:cb4d9db17537 728
mbed_official 376:cb4d9db17537 729 if(hsmbus->State == HAL_SMBUS_STATE_LISTEN)
mbed_official 376:cb4d9db17537 730 {
mbed_official 489:119543c9f674 731 if((pData == NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 732 {
mbed_official 376:cb4d9db17537 733 return HAL_ERROR;
mbed_official 376:cb4d9db17537 734 }
mbed_official 376:cb4d9db17537 735
mbed_official 376:cb4d9db17537 736 /* Disable Interrupts, to prevent preemption during treatment in case of multicall */
mbed_official 376:cb4d9db17537 737 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_ADDR | SMBUS_IT_RX);
mbed_official 376:cb4d9db17537 738
mbed_official 376:cb4d9db17537 739 /* Process Locked */
mbed_official 376:cb4d9db17537 740 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 741
mbed_official 376:cb4d9db17537 742 hsmbus->State |= HAL_SMBUS_STATE_SLAVE_BUSY_RX;
mbed_official 376:cb4d9db17537 743 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 744
mbed_official 376:cb4d9db17537 745 /* Enable Address Acknowledge */
mbed_official 376:cb4d9db17537 746 hsmbus->Instance->CR2 &= ~I2C_CR2_NACK;
mbed_official 376:cb4d9db17537 747
mbed_official 376:cb4d9db17537 748 /* Prepare transfer parameters */
mbed_official 376:cb4d9db17537 749 hsmbus->pBuffPtr = pData;
mbed_official 376:cb4d9db17537 750 hsmbus->XferSize = Size;
mbed_official 376:cb4d9db17537 751 hsmbus->XferCount = Size;
mbed_official 376:cb4d9db17537 752 hsmbus->XferOptions = XferOptions;
mbed_official 376:cb4d9db17537 753
mbed_official 376:cb4d9db17537 754 /* Set NBYTE to receive */
mbed_official 376:cb4d9db17537 755 /* If XferSize equal "1", or XferSize equal "2" with PEC requested (mean 1 data byte + 1 PEC byte */
mbed_official 376:cb4d9db17537 756 /* no need to set RELOAD bit mode, a ACK will be automatically generated in that case */
mbed_official 376:cb4d9db17537 757 /* else need to set RELOAD bit mode to generate an automatic ACK at each byte Received */
mbed_official 376:cb4d9db17537 758 /* This RELOAD bit will be reset for last BYTE to be receive in SMBUS_Slave_ISR */
mbed_official 489:119543c9f674 759 if((hsmbus->XferSize == 1) || ((hsmbus->XferSize == 2) && (__SMBUS_GET_PEC_MODE(hsmbus) != RESET)))
mbed_official 376:cb4d9db17537 760 {
mbed_official 376:cb4d9db17537 761 SMBUS_TransferConfig(hsmbus,0,hsmbus->XferSize, hsmbus->XferOptions, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 762 }
mbed_official 376:cb4d9db17537 763 else
mbed_official 376:cb4d9db17537 764 {
mbed_official 376:cb4d9db17537 765 SMBUS_TransferConfig(hsmbus,0,/*hsmbus->XferSize*/1, hsmbus->XferOptions | SMBUS_RELOAD_MODE, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 766 }
mbed_official 376:cb4d9db17537 767
mbed_official 376:cb4d9db17537 768 /* Clear ADDR flag after prepare the transfer parameters */
mbed_official 376:cb4d9db17537 769 /* This action will generate an acknowledge to the HOST */
mbed_official 376:cb4d9db17537 770 __HAL_SMBUS_CLEAR_FLAG(hsmbus,SMBUS_FLAG_ADDR);
mbed_official 376:cb4d9db17537 771
mbed_official 376:cb4d9db17537 772 /* Process Unlocked */
mbed_official 376:cb4d9db17537 773 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 774
mbed_official 376:cb4d9db17537 775 /* Note : The SMBUS interrupts must be enabled after unlocking current process
mbed_official 376:cb4d9db17537 776 to avoid the risk of SMBUS interrupt handle execution before current
mbed_official 376:cb4d9db17537 777 process unlock */
mbed_official 376:cb4d9db17537 778 /* REnable ADDR interrupt */
mbed_official 376:cb4d9db17537 779 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_RX | SMBUS_IT_ADDR);
mbed_official 376:cb4d9db17537 780
mbed_official 376:cb4d9db17537 781 return HAL_OK;
mbed_official 376:cb4d9db17537 782 }
mbed_official 376:cb4d9db17537 783 else
mbed_official 376:cb4d9db17537 784 {
mbed_official 376:cb4d9db17537 785 return HAL_ERROR;
mbed_official 376:cb4d9db17537 786 }
mbed_official 376:cb4d9db17537 787 }
mbed_official 376:cb4d9db17537 788 /**
mbed_official 376:cb4d9db17537 789 * @brief This function enable the Address listen mode in Slave mode
mbed_official 376:cb4d9db17537 790 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 791 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 792 * @retval HAL status
mbed_official 376:cb4d9db17537 793 */
mbed_official 376:cb4d9db17537 794 HAL_StatusTypeDef HAL_SMBUS_EnableListen_IT(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 795 {
mbed_official 376:cb4d9db17537 796 hsmbus->State = HAL_SMBUS_STATE_LISTEN;
mbed_official 376:cb4d9db17537 797
mbed_official 376:cb4d9db17537 798 /* Enable the Address Match interrupt */
mbed_official 376:cb4d9db17537 799 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_ADDR);
mbed_official 376:cb4d9db17537 800
mbed_official 376:cb4d9db17537 801 return HAL_OK;
mbed_official 376:cb4d9db17537 802 }
mbed_official 376:cb4d9db17537 803
mbed_official 376:cb4d9db17537 804 /**
mbed_official 376:cb4d9db17537 805 * @brief This function disable the Address listen mode
mbed_official 376:cb4d9db17537 806 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 807 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 808 * @retval HAL status
mbed_official 376:cb4d9db17537 809 */
mbed_official 376:cb4d9db17537 810 HAL_StatusTypeDef HAL_SMBUS_DisableListen_IT(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 811 {
mbed_official 376:cb4d9db17537 812 /* Disable Address listen mode only if a transfer is not ongoing */
mbed_official 376:cb4d9db17537 813 if(hsmbus->State == HAL_SMBUS_STATE_LISTEN)
mbed_official 376:cb4d9db17537 814 {
mbed_official 376:cb4d9db17537 815 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 816
mbed_official 376:cb4d9db17537 817 /* Disable the Address Match interrupt */
mbed_official 376:cb4d9db17537 818 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_ADDR);
mbed_official 376:cb4d9db17537 819
mbed_official 376:cb4d9db17537 820 return HAL_OK;
mbed_official 376:cb4d9db17537 821 }
mbed_official 376:cb4d9db17537 822 else
mbed_official 376:cb4d9db17537 823 {
mbed_official 376:cb4d9db17537 824 return HAL_BUSY;
mbed_official 376:cb4d9db17537 825 }
mbed_official 376:cb4d9db17537 826 }
mbed_official 376:cb4d9db17537 827
mbed_official 376:cb4d9db17537 828 /**
mbed_official 376:cb4d9db17537 829 * @brief Enable SMBUS alert.
mbed_official 376:cb4d9db17537 830 * @param hsmbus : pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 831 * the configuration information for the specified SMBUSx peripheral.
mbed_official 376:cb4d9db17537 832 * @retval HAL status
mbed_official 376:cb4d9db17537 833 */
mbed_official 376:cb4d9db17537 834 HAL_StatusTypeDef HAL_SMBUS_EnableAlert_IT(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 835 {
mbed_official 376:cb4d9db17537 836 /* Enable SMBus alert */
mbed_official 376:cb4d9db17537 837 hsmbus->Instance->CR1 |= I2C_CR1_ALERTEN;
mbed_official 376:cb4d9db17537 838
mbed_official 376:cb4d9db17537 839 /* Clear ALERT flag */
mbed_official 376:cb4d9db17537 840 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_ALERT);
mbed_official 376:cb4d9db17537 841
mbed_official 376:cb4d9db17537 842 /* Enable Alert Interrupt */
mbed_official 376:cb4d9db17537 843 SMBUS_Enable_IRQ(hsmbus, SMBUS_IT_ALERT);
mbed_official 376:cb4d9db17537 844
mbed_official 376:cb4d9db17537 845 return HAL_OK;
mbed_official 376:cb4d9db17537 846 }
mbed_official 376:cb4d9db17537 847 /**
mbed_official 376:cb4d9db17537 848 * @brief Disable SMBUS alert.
mbed_official 376:cb4d9db17537 849 * @param hsmbus : pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 850 * the configuration information for the specified SMBUSx peripheral.
mbed_official 376:cb4d9db17537 851 * @retval HAL status
mbed_official 376:cb4d9db17537 852 */
mbed_official 376:cb4d9db17537 853 HAL_StatusTypeDef HAL_SMBUS_DisableAlert_IT(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 854 {
mbed_official 376:cb4d9db17537 855 /* Enable SMBus alert */
mbed_official 376:cb4d9db17537 856 hsmbus->Instance->CR1 &= ~I2C_CR1_ALERTEN;
mbed_official 376:cb4d9db17537 857
mbed_official 376:cb4d9db17537 858 /* Disable Alert Interrupt */
mbed_official 376:cb4d9db17537 859 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_ALERT);
mbed_official 376:cb4d9db17537 860
mbed_official 376:cb4d9db17537 861 return HAL_OK;
mbed_official 376:cb4d9db17537 862 }
mbed_official 376:cb4d9db17537 863 /**
mbed_official 376:cb4d9db17537 864 * @brief Checks if target device is ready for communication.
mbed_official 376:cb4d9db17537 865 * @note This function is used with Memory devices
mbed_official 376:cb4d9db17537 866 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 867 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 868 * @param DevAddress: Target device address
mbed_official 376:cb4d9db17537 869 * @param Trials: Number of trials
mbed_official 376:cb4d9db17537 870 * @param Timeout: Timeout duration
mbed_official 376:cb4d9db17537 871 * @retval HAL status
mbed_official 376:cb4d9db17537 872 */
mbed_official 376:cb4d9db17537 873 HAL_StatusTypeDef HAL_SMBUS_IsDeviceReady(SMBUS_HandleTypeDef *hsmbus, uint16_t DevAddress, uint32_t Trials, uint32_t Timeout)
mbed_official 376:cb4d9db17537 874 {
mbed_official 376:cb4d9db17537 875 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 876 __IO uint32_t SMBUS_Trials = 0x00;
mbed_official 376:cb4d9db17537 877
mbed_official 376:cb4d9db17537 878 if(hsmbus->State == HAL_SMBUS_STATE_READY)
mbed_official 376:cb4d9db17537 879 {
mbed_official 376:cb4d9db17537 880 if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_BUSY) != RESET)
mbed_official 376:cb4d9db17537 881 {
mbed_official 376:cb4d9db17537 882 return HAL_BUSY;
mbed_official 376:cb4d9db17537 883 }
mbed_official 376:cb4d9db17537 884
mbed_official 376:cb4d9db17537 885 /* Process Locked */
mbed_official 376:cb4d9db17537 886 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 887
mbed_official 376:cb4d9db17537 888 hsmbus->State = HAL_SMBUS_STATE_BUSY;
mbed_official 376:cb4d9db17537 889 hsmbus->ErrorCode = HAL_SMBUS_ERROR_NONE;
mbed_official 376:cb4d9db17537 890
mbed_official 376:cb4d9db17537 891 do
mbed_official 376:cb4d9db17537 892 {
mbed_official 376:cb4d9db17537 893 /* Generate Start */
mbed_official 489:119543c9f674 894 hsmbus->Instance->CR2 = __SMBUS_GENERATE_START(hsmbus->Init.AddressingMode,DevAddress);
mbed_official 376:cb4d9db17537 895
mbed_official 376:cb4d9db17537 896 /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */
mbed_official 376:cb4d9db17537 897 /* Wait until STOPF flag is set or a NACK flag is set*/
mbed_official 376:cb4d9db17537 898 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 899 while((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_STOPF) == RESET) && (__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_AF) == RESET) && (hsmbus->State != HAL_SMBUS_STATE_TIMEOUT))
mbed_official 376:cb4d9db17537 900 {
mbed_official 376:cb4d9db17537 901 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 902 {
mbed_official 376:cb4d9db17537 903 hsmbus->State = HAL_SMBUS_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 904 }
mbed_official 376:cb4d9db17537 905 }
mbed_official 376:cb4d9db17537 906
mbed_official 376:cb4d9db17537 907 /* Check if the NACKF flag has not been set */
mbed_official 376:cb4d9db17537 908 if (__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_AF) == RESET)
mbed_official 376:cb4d9db17537 909 {
mbed_official 376:cb4d9db17537 910 /* Wait until STOPF flag is reset */
mbed_official 376:cb4d9db17537 911 if(SMBUS_WaitOnFlagUntilTimeout(hsmbus, SMBUS_FLAG_STOPF, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 912 {
mbed_official 376:cb4d9db17537 913 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 914 }
mbed_official 376:cb4d9db17537 915
mbed_official 376:cb4d9db17537 916 /* Clear STOP Flag */
mbed_official 376:cb4d9db17537 917 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_STOPF);
mbed_official 376:cb4d9db17537 918
mbed_official 376:cb4d9db17537 919 /* Device is ready */
mbed_official 376:cb4d9db17537 920 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 921
mbed_official 376:cb4d9db17537 922 /* Process Unlocked */
mbed_official 376:cb4d9db17537 923 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 924
mbed_official 376:cb4d9db17537 925 return HAL_OK;
mbed_official 376:cb4d9db17537 926 }
mbed_official 376:cb4d9db17537 927 else
mbed_official 376:cb4d9db17537 928 {
mbed_official 376:cb4d9db17537 929 /* Wait until STOPF flag is reset */
mbed_official 376:cb4d9db17537 930 if(SMBUS_WaitOnFlagUntilTimeout(hsmbus, SMBUS_FLAG_STOPF, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 931 {
mbed_official 376:cb4d9db17537 932 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 933 }
mbed_official 376:cb4d9db17537 934
mbed_official 376:cb4d9db17537 935 /* Clear NACK Flag */
mbed_official 376:cb4d9db17537 936 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_AF);
mbed_official 376:cb4d9db17537 937
mbed_official 376:cb4d9db17537 938 /* Clear STOP Flag, auto generated with autoend*/
mbed_official 376:cb4d9db17537 939 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_STOPF);
mbed_official 376:cb4d9db17537 940 }
mbed_official 376:cb4d9db17537 941
mbed_official 376:cb4d9db17537 942 /* Check if the maximum allowed numbe of trials has bee reached */
mbed_official 376:cb4d9db17537 943 if (SMBUS_Trials++ == Trials)
mbed_official 376:cb4d9db17537 944 {
mbed_official 376:cb4d9db17537 945 /* Generate Stop */
mbed_official 376:cb4d9db17537 946 hsmbus->Instance->CR2 |= I2C_CR2_STOP;
mbed_official 376:cb4d9db17537 947
mbed_official 376:cb4d9db17537 948 /* Wait until STOPF flag is reset */
mbed_official 376:cb4d9db17537 949 if(SMBUS_WaitOnFlagUntilTimeout(hsmbus, SMBUS_FLAG_STOPF, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 950 {
mbed_official 376:cb4d9db17537 951 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 952 }
mbed_official 376:cb4d9db17537 953
mbed_official 376:cb4d9db17537 954 /* Clear STOP Flag */
mbed_official 376:cb4d9db17537 955 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_STOPF);
mbed_official 376:cb4d9db17537 956 }
mbed_official 376:cb4d9db17537 957 }while(SMBUS_Trials++ < Trials);
mbed_official 376:cb4d9db17537 958
mbed_official 376:cb4d9db17537 959 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 960
mbed_official 376:cb4d9db17537 961 /* Process Unlocked */
mbed_official 376:cb4d9db17537 962 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 963
mbed_official 376:cb4d9db17537 964 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 965 }
mbed_official 376:cb4d9db17537 966 else
mbed_official 376:cb4d9db17537 967 {
mbed_official 376:cb4d9db17537 968 return HAL_BUSY;
mbed_official 376:cb4d9db17537 969 }
mbed_official 376:cb4d9db17537 970 }
mbed_official 376:cb4d9db17537 971
mbed_official 376:cb4d9db17537 972 /**
mbed_official 376:cb4d9db17537 973 * @brief This function handles SMBUS event interrupt request.
mbed_official 376:cb4d9db17537 974 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 975 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 976 * @retval None
mbed_official 376:cb4d9db17537 977 */
mbed_official 376:cb4d9db17537 978 void HAL_SMBUS_EV_IRQHandler(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 979 {
mbed_official 376:cb4d9db17537 980 uint32_t tmpisrvalue = 0;
mbed_official 376:cb4d9db17537 981
mbed_official 376:cb4d9db17537 982 /* Use a local variable to store the current ISR flags */
mbed_official 376:cb4d9db17537 983 /* This action will avoid a wrong treatment due to ISR flags change during interrupt handler */
mbed_official 376:cb4d9db17537 984 tmpisrvalue = __SMBUS_GET_ISR_REG(hsmbus);
mbed_official 376:cb4d9db17537 985
mbed_official 376:cb4d9db17537 986 /* SMBUS in mode Transmitter ---------------------------------------------------*/
mbed_official 376:cb4d9db17537 987 if (((__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_TXIS) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_TCR) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_TC) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_STOPF) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_AF) != RESET)) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, (SMBUS_IT_TCI| SMBUS_IT_STOPI| SMBUS_IT_NACKI | SMBUS_IT_TXI)) != RESET))
mbed_official 376:cb4d9db17537 988 {
mbed_official 376:cb4d9db17537 989 /* Slave mode selected */
mbed_official 376:cb4d9db17537 990 if ((hsmbus->State & HAL_SMBUS_STATE_SLAVE_BUSY_TX) == HAL_SMBUS_STATE_SLAVE_BUSY_TX)
mbed_official 376:cb4d9db17537 991 {
mbed_official 376:cb4d9db17537 992 SMBUS_Slave_ISR(hsmbus);
mbed_official 376:cb4d9db17537 993 }
mbed_official 376:cb4d9db17537 994 /* Master mode selected */
mbed_official 376:cb4d9db17537 995 else if((hsmbus->State & HAL_SMBUS_STATE_MASTER_BUSY_TX) == HAL_SMBUS_STATE_MASTER_BUSY_TX)
mbed_official 376:cb4d9db17537 996 {
mbed_official 376:cb4d9db17537 997 SMBUS_Master_ISR(hsmbus);
mbed_official 376:cb4d9db17537 998 }
mbed_official 376:cb4d9db17537 999 }
mbed_official 376:cb4d9db17537 1000
mbed_official 376:cb4d9db17537 1001 /* SMBUS in mode Receiver ----------------------------------------------------*/
mbed_official 376:cb4d9db17537 1002 if (((__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_RXNE) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_TCR) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_TC) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_STOPF) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_AF) != RESET)) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, (SMBUS_IT_TCI| SMBUS_IT_STOPI| SMBUS_IT_NACKI | SMBUS_IT_RXI)) != RESET))
mbed_official 376:cb4d9db17537 1003 {
mbed_official 376:cb4d9db17537 1004 /* Slave mode selected */
mbed_official 376:cb4d9db17537 1005 if ((hsmbus->State & HAL_SMBUS_STATE_SLAVE_BUSY_RX) == HAL_SMBUS_STATE_SLAVE_BUSY_RX)
mbed_official 376:cb4d9db17537 1006 {
mbed_official 376:cb4d9db17537 1007 SMBUS_Slave_ISR(hsmbus);
mbed_official 376:cb4d9db17537 1008 }
mbed_official 376:cb4d9db17537 1009 /* Master mode selected */
mbed_official 376:cb4d9db17537 1010 else if((hsmbus->State & HAL_SMBUS_STATE_MASTER_BUSY_RX) == HAL_SMBUS_STATE_MASTER_BUSY_RX)
mbed_official 376:cb4d9db17537 1011 {
mbed_official 376:cb4d9db17537 1012 SMBUS_Master_ISR(hsmbus);
mbed_official 376:cb4d9db17537 1013 }
mbed_official 376:cb4d9db17537 1014 }
mbed_official 376:cb4d9db17537 1015
mbed_official 376:cb4d9db17537 1016 /* SMBUS in mode Listener Only --------------------------------------------------*/
mbed_official 376:cb4d9db17537 1017 /* Slave mode selected */
mbed_official 376:cb4d9db17537 1018 if (((__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_ADDR) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_STOPF) != RESET) || (__SMBUS_CHECK_FLAG(tmpisrvalue, SMBUS_FLAG_AF) != RESET))
mbed_official 376:cb4d9db17537 1019 && ((__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_ADDRI) != RESET) || (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_STOPI) != RESET) || (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_NACKI) != RESET)))
mbed_official 376:cb4d9db17537 1020 {
mbed_official 376:cb4d9db17537 1021 if (hsmbus->State == HAL_SMBUS_STATE_LISTEN)
mbed_official 376:cb4d9db17537 1022 {
mbed_official 376:cb4d9db17537 1023 SMBUS_Slave_ISR(hsmbus);
mbed_official 376:cb4d9db17537 1024 }
mbed_official 376:cb4d9db17537 1025 }
mbed_official 376:cb4d9db17537 1026 }
mbed_official 376:cb4d9db17537 1027
mbed_official 376:cb4d9db17537 1028 /**
mbed_official 376:cb4d9db17537 1029 * @brief This function handles SMBUS error interrupt request.
mbed_official 376:cb4d9db17537 1030 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1031 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1032 * @retval None
mbed_official 376:cb4d9db17537 1033 */
mbed_official 376:cb4d9db17537 1034 void HAL_SMBUS_ER_IRQHandler(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1035 {
mbed_official 376:cb4d9db17537 1036 /* SMBUS Bus error interrupt occurred ------------------------------------*/
mbed_official 376:cb4d9db17537 1037 if((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_BERR) != RESET) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_ERRI) != RESET))
mbed_official 376:cb4d9db17537 1038 {
mbed_official 376:cb4d9db17537 1039 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_BERR;
mbed_official 376:cb4d9db17537 1040
mbed_official 376:cb4d9db17537 1041 /* Clear BERR flag */
mbed_official 376:cb4d9db17537 1042 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_BERR);
mbed_official 376:cb4d9db17537 1043 }
mbed_official 376:cb4d9db17537 1044
mbed_official 376:cb4d9db17537 1045 /* SMBUS Over-Run/Under-Run interrupt occurred ----------------------------------------*/
mbed_official 376:cb4d9db17537 1046 if((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_OVR) != RESET) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_ERRI) != RESET))
mbed_official 376:cb4d9db17537 1047 {
mbed_official 376:cb4d9db17537 1048 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_OVR;
mbed_official 376:cb4d9db17537 1049
mbed_official 376:cb4d9db17537 1050 /* Clear OVR flag */
mbed_official 376:cb4d9db17537 1051 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_OVR);
mbed_official 376:cb4d9db17537 1052 }
mbed_official 376:cb4d9db17537 1053
mbed_official 376:cb4d9db17537 1054 /* SMBUS Arbitration Loss error interrupt occurred ------------------------------------*/
mbed_official 376:cb4d9db17537 1055 if((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_ARLO) != RESET) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_ERRI) != RESET))
mbed_official 376:cb4d9db17537 1056 {
mbed_official 376:cb4d9db17537 1057 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_ARLO;
mbed_official 376:cb4d9db17537 1058
mbed_official 376:cb4d9db17537 1059 /* Clear ARLO flag */
mbed_official 376:cb4d9db17537 1060 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_ARLO);
mbed_official 376:cb4d9db17537 1061 }
mbed_official 376:cb4d9db17537 1062
mbed_official 376:cb4d9db17537 1063 /* SMBUS Timeout error interrupt occurred ---------------------------------------------*/
mbed_official 376:cb4d9db17537 1064 if((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_TIMEOUT) != RESET) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_ERRI) != RESET))
mbed_official 376:cb4d9db17537 1065 {
mbed_official 376:cb4d9db17537 1066 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_BUSTIMEOUT;
mbed_official 376:cb4d9db17537 1067
mbed_official 376:cb4d9db17537 1068 /* Clear TIMEOUT flag */
mbed_official 376:cb4d9db17537 1069 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_TIMEOUT);
mbed_official 376:cb4d9db17537 1070 }
mbed_official 376:cb4d9db17537 1071
mbed_official 376:cb4d9db17537 1072 /* SMBUS Alert error interrupt occurred -----------------------------------------------*/
mbed_official 376:cb4d9db17537 1073 if((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_ALERT) != RESET) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_ERRI) != RESET))
mbed_official 376:cb4d9db17537 1074 {
mbed_official 376:cb4d9db17537 1075 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_ALERT;
mbed_official 376:cb4d9db17537 1076
mbed_official 376:cb4d9db17537 1077 /* Clear ALERT flag */
mbed_official 376:cb4d9db17537 1078 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_ALERT);
mbed_official 376:cb4d9db17537 1079 }
mbed_official 376:cb4d9db17537 1080
mbed_official 376:cb4d9db17537 1081 /* SMBUS Packet Error Check error interrupt occurred ----------------------------------*/
mbed_official 376:cb4d9db17537 1082 if((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_PECERR) != RESET) && (__HAL_SMBUS_GET_IT_SOURCE(hsmbus, SMBUS_IT_ERRI) != RESET))
mbed_official 376:cb4d9db17537 1083 {
mbed_official 376:cb4d9db17537 1084 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_PECERR;
mbed_official 376:cb4d9db17537 1085
mbed_official 376:cb4d9db17537 1086 /* Clear PEC error flag */
mbed_official 376:cb4d9db17537 1087 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_PECERR);
mbed_official 376:cb4d9db17537 1088 }
mbed_official 376:cb4d9db17537 1089
mbed_official 376:cb4d9db17537 1090 /* Call the Error Callback in case of Error detected */
mbed_official 376:cb4d9db17537 1091 if((hsmbus->ErrorCode != HAL_SMBUS_ERROR_NONE)&&(hsmbus->ErrorCode != HAL_SMBUS_ERROR_ACKF))
mbed_official 376:cb4d9db17537 1092 {
mbed_official 376:cb4d9db17537 1093 /* Do not Reset the the HAL state in case of ALERT error */
mbed_official 376:cb4d9db17537 1094 if((hsmbus->ErrorCode & HAL_SMBUS_ERROR_ALERT) != HAL_SMBUS_ERROR_ALERT)
mbed_official 376:cb4d9db17537 1095 {
mbed_official 376:cb4d9db17537 1096 /* Reset only HAL_SMBUS_STATE_SLAVE_BUSY_XX and HAL_SMBUS_STATE_MASTER_BUSY_XX */
mbed_official 489:119543c9f674 1097 /* keep HAL_SMBUS_STATE_LISTEN if set */
mbed_official 376:cb4d9db17537 1098 hsmbus->State &= (uint32_t)~((uint32_t)HAL_SMBUS_STATE_MASTER_BUSY_RX | HAL_SMBUS_STATE_MASTER_BUSY_TX | HAL_SMBUS_STATE_SLAVE_BUSY_RX | HAL_SMBUS_STATE_SLAVE_BUSY_TX);
mbed_official 376:cb4d9db17537 1099 }
mbed_official 376:cb4d9db17537 1100
mbed_official 376:cb4d9db17537 1101 /* Call the Error callback to prevent upper layer */
mbed_official 376:cb4d9db17537 1102 HAL_SMBUS_ErrorCallback(hsmbus);
mbed_official 376:cb4d9db17537 1103 }
mbed_official 376:cb4d9db17537 1104 }
mbed_official 376:cb4d9db17537 1105
mbed_official 376:cb4d9db17537 1106 /**
mbed_official 376:cb4d9db17537 1107 * @brief Master Tx Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1108 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1109 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1110 * @retval None
mbed_official 376:cb4d9db17537 1111 */
mbed_official 376:cb4d9db17537 1112 __weak void HAL_SMBUS_MasterTxCpltCallback(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1113 {
mbed_official 376:cb4d9db17537 1114 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1115 the HAL_SMBUS_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1116 */
mbed_official 376:cb4d9db17537 1117 }
mbed_official 376:cb4d9db17537 1118
mbed_official 376:cb4d9db17537 1119 /**
mbed_official 376:cb4d9db17537 1120 * @brief Master Rx Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1121 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1122 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1123 * @retval None
mbed_official 376:cb4d9db17537 1124 */
mbed_official 376:cb4d9db17537 1125 __weak void HAL_SMBUS_MasterRxCpltCallback(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1126 {
mbed_official 376:cb4d9db17537 1127 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1128 the HAL_SMBUS_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1129 */
mbed_official 376:cb4d9db17537 1130 }
mbed_official 376:cb4d9db17537 1131
mbed_official 376:cb4d9db17537 1132 /** @brief Slave Tx Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1133 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1134 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1135 * @retval None
mbed_official 376:cb4d9db17537 1136 */
mbed_official 376:cb4d9db17537 1137 __weak void HAL_SMBUS_SlaveTxCpltCallback(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1138 {
mbed_official 376:cb4d9db17537 1139 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1140 the HAL_SMBUS_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1141 */
mbed_official 376:cb4d9db17537 1142 }
mbed_official 376:cb4d9db17537 1143
mbed_official 376:cb4d9db17537 1144 /**
mbed_official 376:cb4d9db17537 1145 * @brief Slave Rx Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1146 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1147 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1148 * @retval None
mbed_official 376:cb4d9db17537 1149 */
mbed_official 376:cb4d9db17537 1150 __weak void HAL_SMBUS_SlaveRxCpltCallback(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1151 {
mbed_official 376:cb4d9db17537 1152 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1153 the HAL_SMBUS_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1154 */
mbed_official 376:cb4d9db17537 1155 }
mbed_official 376:cb4d9db17537 1156
mbed_official 376:cb4d9db17537 1157 /**
mbed_official 376:cb4d9db17537 1158 * @brief Slave Address Match callbacks.
mbed_official 376:cb4d9db17537 1159 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1160 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1161 * @param TransferDirection: Master request Transfer Direction (Write/Read)
mbed_official 376:cb4d9db17537 1162 * @param AddrMatchCode: Address Match Code
mbed_official 376:cb4d9db17537 1163 * @retval None
mbed_official 376:cb4d9db17537 1164 */
mbed_official 376:cb4d9db17537 1165 __weak void HAL_SMBUS_AddrCallback(SMBUS_HandleTypeDef *hsmbus, uint8_t TransferDirection, uint16_t AddrMatchCode)
mbed_official 376:cb4d9db17537 1166 {
mbed_official 376:cb4d9db17537 1167 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 489:119543c9f674 1168 the HAL_SMBUS_AddrCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1169 */
mbed_official 376:cb4d9db17537 1170 }
mbed_official 376:cb4d9db17537 1171
mbed_official 376:cb4d9db17537 1172 /**
mbed_official 376:cb4d9db17537 1173 * @brief Slave Listen Complete callbacks.
mbed_official 376:cb4d9db17537 1174 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1175 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1176 * @retval None
mbed_official 376:cb4d9db17537 1177 */
mbed_official 376:cb4d9db17537 1178 __weak void HAL_SMBUS_ListenCpltCallback(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1179 {
mbed_official 376:cb4d9db17537 1180 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 489:119543c9f674 1181 the HAL_SMBUS_ListenCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1182 */
mbed_official 376:cb4d9db17537 1183 }
mbed_official 376:cb4d9db17537 1184
mbed_official 376:cb4d9db17537 1185 /**
mbed_official 376:cb4d9db17537 1186 * @brief SMBUS error callbacks.
mbed_official 376:cb4d9db17537 1187 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1188 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1189 * @retval None
mbed_official 376:cb4d9db17537 1190 */
mbed_official 376:cb4d9db17537 1191 __weak void HAL_SMBUS_ErrorCallback(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1192 {
mbed_official 376:cb4d9db17537 1193 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1194 the HAL_SMBUS_ErrorCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1195 */
mbed_official 376:cb4d9db17537 1196 }
mbed_official 376:cb4d9db17537 1197
mbed_official 376:cb4d9db17537 1198 /**
mbed_official 376:cb4d9db17537 1199 * @}
mbed_official 376:cb4d9db17537 1200 */
mbed_official 376:cb4d9db17537 1201
mbed_official 376:cb4d9db17537 1202 /** @defgroup SMBUS_Group3 Peripheral State and Errors functions
mbed_official 376:cb4d9db17537 1203 * @brief Peripheral State and Errors functions
mbed_official 376:cb4d9db17537 1204 *
mbed_official 376:cb4d9db17537 1205 @verbatim
mbed_official 376:cb4d9db17537 1206 ===============================================================================
mbed_official 376:cb4d9db17537 1207 ##### Peripheral State and Errors functions #####
mbed_official 376:cb4d9db17537 1208 ===============================================================================
mbed_official 376:cb4d9db17537 1209 [..]
mbed_official 376:cb4d9db17537 1210 This subsection permit to get in run-time the status of the peripheral
mbed_official 376:cb4d9db17537 1211 and the data flow.
mbed_official 376:cb4d9db17537 1212
mbed_official 376:cb4d9db17537 1213 @endverbatim
mbed_official 376:cb4d9db17537 1214 * @{
mbed_official 376:cb4d9db17537 1215 */
mbed_official 376:cb4d9db17537 1216
mbed_official 376:cb4d9db17537 1217 /**
mbed_official 376:cb4d9db17537 1218 * @brief Returns the SMBUS state.
mbed_official 376:cb4d9db17537 1219 * @param hsmbus : SMBUS handle
mbed_official 376:cb4d9db17537 1220 * @retval HAL state
mbed_official 376:cb4d9db17537 1221 */
mbed_official 489:119543c9f674 1222 uint32_t HAL_SMBUS_GetState(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1223 {
mbed_official 376:cb4d9db17537 1224 return hsmbus->State;
mbed_official 376:cb4d9db17537 1225 }
mbed_official 376:cb4d9db17537 1226
mbed_official 376:cb4d9db17537 1227 /**
mbed_official 376:cb4d9db17537 1228 * @brief Return the SMBUS error code
mbed_official 376:cb4d9db17537 1229 * @param hsmbus : pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1230 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1231 * @retval SMBUS Error Code
mbed_official 376:cb4d9db17537 1232 */
mbed_official 376:cb4d9db17537 1233 uint32_t HAL_SMBUS_GetError(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1234 {
mbed_official 376:cb4d9db17537 1235 return hsmbus->ErrorCode;
mbed_official 376:cb4d9db17537 1236 }
mbed_official 376:cb4d9db17537 1237
mbed_official 376:cb4d9db17537 1238 /**
mbed_official 376:cb4d9db17537 1239 * @}
mbed_official 376:cb4d9db17537 1240 */
mbed_official 376:cb4d9db17537 1241
mbed_official 376:cb4d9db17537 1242 /**
mbed_official 376:cb4d9db17537 1243 * @brief Interrupt Sub-Routine which handle the Interrupt Flags Master Mode
mbed_official 376:cb4d9db17537 1244 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1245 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1246 * @retval HAL status
mbed_official 376:cb4d9db17537 1247 */
mbed_official 376:cb4d9db17537 1248 static HAL_StatusTypeDef SMBUS_Master_ISR(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1249 {
mbed_official 376:cb4d9db17537 1250 uint16_t DevAddress;
mbed_official 376:cb4d9db17537 1251
mbed_official 376:cb4d9db17537 1252 /* Process Locked */
mbed_official 376:cb4d9db17537 1253 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 1254
mbed_official 376:cb4d9db17537 1255 if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_AF) != RESET)
mbed_official 376:cb4d9db17537 1256 {
mbed_official 376:cb4d9db17537 1257 /* Clear NACK Flag */
mbed_official 376:cb4d9db17537 1258 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_AF);
mbed_official 376:cb4d9db17537 1259
mbed_official 376:cb4d9db17537 1260 /* Set corresponding Error Code */
mbed_official 376:cb4d9db17537 1261 /* No need to generate STOP, it is automatically done */
mbed_official 376:cb4d9db17537 1262 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_ACKF;
mbed_official 376:cb4d9db17537 1263
mbed_official 376:cb4d9db17537 1264 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1265 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1266
mbed_official 376:cb4d9db17537 1267 /* Call the Error callback to prevent upper layer */
mbed_official 376:cb4d9db17537 1268 HAL_SMBUS_ErrorCallback(hsmbus);
mbed_official 376:cb4d9db17537 1269 }
mbed_official 376:cb4d9db17537 1270 else if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_STOPF) != RESET)
mbed_official 376:cb4d9db17537 1271 {
mbed_official 376:cb4d9db17537 1272
mbed_official 376:cb4d9db17537 1273 /* Call the corresponding callback to inform upper layer of End of Transfer */
mbed_official 376:cb4d9db17537 1274 if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_TX)
mbed_official 376:cb4d9db17537 1275 {
mbed_official 376:cb4d9db17537 1276 /* Disable Interrupt */
mbed_official 376:cb4d9db17537 1277 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 1278
mbed_official 376:cb4d9db17537 1279 /* Clear STOP Flag */
mbed_official 376:cb4d9db17537 1280 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_STOPF);
mbed_official 376:cb4d9db17537 1281
mbed_official 376:cb4d9db17537 1282 /* Clear Configuration Register 2 */
mbed_official 489:119543c9f674 1283 __SMBUS_RESET_CR2(hsmbus);
mbed_official 376:cb4d9db17537 1284
mbed_official 376:cb4d9db17537 1285
mbed_official 376:cb4d9db17537 1286 /* Flush remaining data in Fifo register in case of error occurs before TXEmpty */
mbed_official 376:cb4d9db17537 1287 /* Disable the selected SMBUS peripheral */
mbed_official 376:cb4d9db17537 1288 __HAL_SMBUS_DISABLE(hsmbus);
mbed_official 376:cb4d9db17537 1289
mbed_official 376:cb4d9db17537 1290 hsmbus->PreviousState = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1291 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1292
mbed_official 376:cb4d9db17537 1293 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1294 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1295
mbed_official 376:cb4d9db17537 1296 /* REenable the selected SMBUS peripheral */
mbed_official 376:cb4d9db17537 1297 __HAL_SMBUS_ENABLE(hsmbus);
mbed_official 376:cb4d9db17537 1298
mbed_official 376:cb4d9db17537 1299 HAL_SMBUS_MasterTxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1300 }
mbed_official 376:cb4d9db17537 1301 else if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_RX)
mbed_official 376:cb4d9db17537 1302 {
mbed_official 376:cb4d9db17537 1303 /* Disable Interrupt */
mbed_official 376:cb4d9db17537 1304 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_RX);
mbed_official 376:cb4d9db17537 1305
mbed_official 376:cb4d9db17537 1306 /* Clear STOP Flag */
mbed_official 376:cb4d9db17537 1307 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_STOPF);
mbed_official 376:cb4d9db17537 1308
mbed_official 376:cb4d9db17537 1309 /* Clear Configuration Register 2 */
mbed_official 489:119543c9f674 1310 __SMBUS_RESET_CR2(hsmbus);
mbed_official 376:cb4d9db17537 1311
mbed_official 376:cb4d9db17537 1312 hsmbus->PreviousState = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1313 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1314
mbed_official 376:cb4d9db17537 1315 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1316 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1317
mbed_official 376:cb4d9db17537 1318 HAL_SMBUS_MasterRxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1319 }
mbed_official 376:cb4d9db17537 1320 }
mbed_official 376:cb4d9db17537 1321 else if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_RXNE) != RESET)
mbed_official 376:cb4d9db17537 1322 {
mbed_official 376:cb4d9db17537 1323 /* Read data from RXDR */
mbed_official 376:cb4d9db17537 1324 (*hsmbus->pBuffPtr++) = hsmbus->Instance->RXDR;
mbed_official 376:cb4d9db17537 1325 hsmbus->XferSize--;
mbed_official 376:cb4d9db17537 1326 hsmbus->XferCount--;
mbed_official 376:cb4d9db17537 1327 }
mbed_official 376:cb4d9db17537 1328 else if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_TXIS) != RESET)
mbed_official 376:cb4d9db17537 1329 {
mbed_official 376:cb4d9db17537 1330 /* Write data to TXDR */
mbed_official 376:cb4d9db17537 1331 hsmbus->Instance->TXDR = (*hsmbus->pBuffPtr++);
mbed_official 376:cb4d9db17537 1332 hsmbus->XferSize--;
mbed_official 376:cb4d9db17537 1333 hsmbus->XferCount--;
mbed_official 376:cb4d9db17537 1334 }
mbed_official 376:cb4d9db17537 1335 else if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_TCR) != RESET)
mbed_official 376:cb4d9db17537 1336 {
mbed_official 376:cb4d9db17537 1337 if((hsmbus->XferSize == 0)&&(hsmbus->XferCount!=0))
mbed_official 376:cb4d9db17537 1338 {
mbed_official 376:cb4d9db17537 1339 DevAddress = (hsmbus->Instance->CR2 & I2C_CR2_SADD);
mbed_official 376:cb4d9db17537 1340
mbed_official 376:cb4d9db17537 1341 if(hsmbus->XferCount > MAX_NBYTE_SIZE)
mbed_official 376:cb4d9db17537 1342 {
mbed_official 376:cb4d9db17537 1343 SMBUS_TransferConfig(hsmbus,DevAddress,MAX_NBYTE_SIZE, SMBUS_RELOAD_MODE, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 1344 hsmbus->XferSize = MAX_NBYTE_SIZE;
mbed_official 376:cb4d9db17537 1345 }
mbed_official 376:cb4d9db17537 1346 else
mbed_official 376:cb4d9db17537 1347 {
mbed_official 376:cb4d9db17537 1348 SMBUS_TransferConfig(hsmbus,DevAddress,hsmbus->XferSize, SMBUS_AUTOEND_MODE, SMBUS_GENERATE_START_WRITE);
mbed_official 376:cb4d9db17537 1349 /* If PEC mode is enable, size to transmit should be Size-1 byte, corresponding to PEC byte */
mbed_official 376:cb4d9db17537 1350 /* PEC byte is automatically sent by HW block, no need to manage it in Transmit process */
mbed_official 489:119543c9f674 1351 if(__SMBUS_GET_PEC_MODE(hsmbus) != RESET)
mbed_official 376:cb4d9db17537 1352 {
mbed_official 376:cb4d9db17537 1353 hsmbus->XferSize--;
mbed_official 376:cb4d9db17537 1354 hsmbus->XferCount--;
mbed_official 376:cb4d9db17537 1355 }
mbed_official 376:cb4d9db17537 1356 hsmbus->XferSize = hsmbus->XferCount;
mbed_official 376:cb4d9db17537 1357 }
mbed_official 376:cb4d9db17537 1358 }
mbed_official 376:cb4d9db17537 1359 else if((hsmbus->XferSize == 0)&&(hsmbus->XferCount==0))
mbed_official 376:cb4d9db17537 1360 {
mbed_official 376:cb4d9db17537 1361 /* Call TxCpltCallback if no stop mode is set */
mbed_official 489:119543c9f674 1362 if(__SMBUS_GET_STOP_MODE(hsmbus) != SMBUS_AUTOEND_MODE)
mbed_official 376:cb4d9db17537 1363 {
mbed_official 376:cb4d9db17537 1364 /* Call the corresponding callback to inform upper layer of End of Transfer */
mbed_official 376:cb4d9db17537 1365 if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_TX)
mbed_official 376:cb4d9db17537 1366 {
mbed_official 376:cb4d9db17537 1367 /* Disable Interrupt */
mbed_official 376:cb4d9db17537 1368 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 1369 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1370 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1371
mbed_official 376:cb4d9db17537 1372 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1373 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1374
mbed_official 376:cb4d9db17537 1375 HAL_SMBUS_MasterTxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1376 }
mbed_official 376:cb4d9db17537 1377 else if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_RX)
mbed_official 376:cb4d9db17537 1378 {
mbed_official 376:cb4d9db17537 1379 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_RX);
mbed_official 376:cb4d9db17537 1380 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1381 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1382
mbed_official 376:cb4d9db17537 1383 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1384 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1385
mbed_official 376:cb4d9db17537 1386 HAL_SMBUS_MasterRxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1387 }
mbed_official 376:cb4d9db17537 1388 }
mbed_official 376:cb4d9db17537 1389 }
mbed_official 376:cb4d9db17537 1390 }
mbed_official 376:cb4d9db17537 1391 else if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_TC) != RESET)
mbed_official 376:cb4d9db17537 1392 {
mbed_official 376:cb4d9db17537 1393 if(hsmbus->XferCount == 0)
mbed_official 376:cb4d9db17537 1394 {
mbed_official 376:cb4d9db17537 1395 /* Specific use case for Quick command */
mbed_official 489:119543c9f674 1396 if(hsmbus->pBuffPtr == NULL)
mbed_official 376:cb4d9db17537 1397 {
mbed_official 376:cb4d9db17537 1398 /* Generate a Stop command */
mbed_official 376:cb4d9db17537 1399 hsmbus->Instance->CR2 |= I2C_CR2_STOP;
mbed_official 376:cb4d9db17537 1400 }
mbed_official 376:cb4d9db17537 1401 /* Call TxCpltCallback if no stop mode is set */
mbed_official 489:119543c9f674 1402 else if(__SMBUS_GET_STOP_MODE(hsmbus) != SMBUS_AUTOEND_MODE)
mbed_official 376:cb4d9db17537 1403 {
mbed_official 376:cb4d9db17537 1404 /* No Generate Stop, to permit restart mode */
mbed_official 376:cb4d9db17537 1405 /* The stop will be done at the end of transfer, when SMBUS_AUTOEND_MODE enable */
mbed_official 376:cb4d9db17537 1406
mbed_official 376:cb4d9db17537 1407 /* Call the corresponding callback to inform upper layer of End of Transfer */
mbed_official 376:cb4d9db17537 1408 if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_TX)
mbed_official 376:cb4d9db17537 1409 {
mbed_official 376:cb4d9db17537 1410 /* Disable Interrupt */
mbed_official 376:cb4d9db17537 1411 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 1412 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1413 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1414
mbed_official 376:cb4d9db17537 1415 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1416 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1417
mbed_official 376:cb4d9db17537 1418 HAL_SMBUS_MasterTxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1419 }
mbed_official 376:cb4d9db17537 1420 else if(hsmbus->State == HAL_SMBUS_STATE_MASTER_BUSY_RX)
mbed_official 376:cb4d9db17537 1421 {
mbed_official 376:cb4d9db17537 1422 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_RX);
mbed_official 376:cb4d9db17537 1423 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1424 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1425
mbed_official 376:cb4d9db17537 1426 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1427 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1428
mbed_official 376:cb4d9db17537 1429 HAL_SMBUS_MasterRxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1430 }
mbed_official 376:cb4d9db17537 1431 }
mbed_official 376:cb4d9db17537 1432 }
mbed_official 376:cb4d9db17537 1433 }
mbed_official 376:cb4d9db17537 1434
mbed_official 376:cb4d9db17537 1435 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1436 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1437
mbed_official 376:cb4d9db17537 1438 return HAL_OK;
mbed_official 376:cb4d9db17537 1439 }
mbed_official 376:cb4d9db17537 1440
mbed_official 376:cb4d9db17537 1441 /**
mbed_official 376:cb4d9db17537 1442 * @brief Interrupt Sub-Routine which handle the Interrupt Flags Slave Mode
mbed_official 376:cb4d9db17537 1443 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1444 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1445 * @retval HAL status
mbed_official 376:cb4d9db17537 1446 */
mbed_official 376:cb4d9db17537 1447 static HAL_StatusTypeDef SMBUS_Slave_ISR(SMBUS_HandleTypeDef *hsmbus)
mbed_official 376:cb4d9db17537 1448 {
mbed_official 376:cb4d9db17537 1449 uint8_t TransferDirection = 0;
mbed_official 376:cb4d9db17537 1450 uint16_t SlaveAddrCode = 0;
mbed_official 376:cb4d9db17537 1451
mbed_official 376:cb4d9db17537 1452 /* Process Locked */
mbed_official 376:cb4d9db17537 1453 __HAL_LOCK(hsmbus);
mbed_official 376:cb4d9db17537 1454
mbed_official 376:cb4d9db17537 1455 if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_AF) != RESET)
mbed_official 376:cb4d9db17537 1456 {
mbed_official 376:cb4d9db17537 1457 /* Check that SMBUS transfer finished */
mbed_official 376:cb4d9db17537 1458 /* if yes, normal usecase, a NACK is sent by the HOST when Transfer is finished */
mbed_official 376:cb4d9db17537 1459 /* Mean XferCount == 0*/
mbed_official 376:cb4d9db17537 1460 /* So clear Flag NACKF only */
mbed_official 376:cb4d9db17537 1461 if(hsmbus->XferCount == 0)
mbed_official 376:cb4d9db17537 1462 {
mbed_official 376:cb4d9db17537 1463 /* Clear NACK Flag */
mbed_official 376:cb4d9db17537 1464 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_AF);
mbed_official 376:cb4d9db17537 1465
mbed_official 376:cb4d9db17537 1466 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1467 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1468 }
mbed_official 376:cb4d9db17537 1469 else
mbed_official 376:cb4d9db17537 1470 {
mbed_official 376:cb4d9db17537 1471 /* if no, error usecase, a Non-Acknowledge of last Data is generated by the HOST*/
mbed_official 376:cb4d9db17537 1472 /* Clear NACK Flag */
mbed_official 376:cb4d9db17537 1473 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_AF);
mbed_official 376:cb4d9db17537 1474
mbed_official 376:cb4d9db17537 1475 /* Set HAL State to "Idle" State, mean to LISTEN state */
mbed_official 376:cb4d9db17537 1476 /* So reset Slave Busy state */
mbed_official 376:cb4d9db17537 1477 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1478 hsmbus->State &= (uint32_t)~((uint32_t)HAL_SMBUS_STATE_SLAVE_BUSY_TX);
mbed_official 376:cb4d9db17537 1479 hsmbus->State &= (uint32_t)~((uint32_t)HAL_SMBUS_STATE_SLAVE_BUSY_RX);
mbed_official 376:cb4d9db17537 1480
mbed_official 376:cb4d9db17537 1481 /* Disable RX/TX Interrupts, keep only ADDR Interrupt */
mbed_official 376:cb4d9db17537 1482 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_RX | SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 1483
mbed_official 376:cb4d9db17537 1484 /* Set ErrorCode corresponding to a Non-Acknowledge */
mbed_official 376:cb4d9db17537 1485 hsmbus->ErrorCode |= HAL_SMBUS_ERROR_ACKF;
mbed_official 376:cb4d9db17537 1486
mbed_official 376:cb4d9db17537 1487 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1488 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1489
mbed_official 376:cb4d9db17537 1490 /* Call the Error callback to prevent upper layer */
mbed_official 376:cb4d9db17537 1491 HAL_SMBUS_ErrorCallback(hsmbus);
mbed_official 376:cb4d9db17537 1492 }
mbed_official 376:cb4d9db17537 1493 }
mbed_official 376:cb4d9db17537 1494 else if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_ADDR) != RESET)
mbed_official 376:cb4d9db17537 1495 {
mbed_official 489:119543c9f674 1496 TransferDirection = __SMBUS_GET_DIR(hsmbus);
mbed_official 489:119543c9f674 1497 SlaveAddrCode = __SMBUS_GET_ADDR_MATCH(hsmbus);
mbed_official 376:cb4d9db17537 1498
mbed_official 376:cb4d9db17537 1499 /* Disable ADDR interrupt to prevent multiple ADDRInterrupt*/
mbed_official 376:cb4d9db17537 1500 /* Other ADDRInterrupt will be treat in next Listen usecase */
mbed_official 376:cb4d9db17537 1501 __HAL_SMBUS_DISABLE_IT(hsmbus, SMBUS_IT_ADDRI);
mbed_official 376:cb4d9db17537 1502
mbed_official 376:cb4d9db17537 1503 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1504 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1505
mbed_official 376:cb4d9db17537 1506 /* Call Slave Addr callback */
mbed_official 376:cb4d9db17537 1507 HAL_SMBUS_AddrCallback(hsmbus, TransferDirection, SlaveAddrCode);
mbed_official 376:cb4d9db17537 1508 }
mbed_official 376:cb4d9db17537 1509 else if((__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_RXNE) != RESET) || (__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_TCR) != RESET))
mbed_official 376:cb4d9db17537 1510 {
mbed_official 376:cb4d9db17537 1511 /* Read data from RXDR */
mbed_official 376:cb4d9db17537 1512 (*hsmbus->pBuffPtr++) = hsmbus->Instance->RXDR;
mbed_official 376:cb4d9db17537 1513 hsmbus->XferSize--;
mbed_official 376:cb4d9db17537 1514 hsmbus->XferCount--;
mbed_official 376:cb4d9db17537 1515
mbed_official 376:cb4d9db17537 1516 if(hsmbus->XferCount == 1)
mbed_official 376:cb4d9db17537 1517 {
mbed_official 376:cb4d9db17537 1518 /* Receive last Byte, can be PEC byte in case of PEC BYTE enabled */
mbed_official 376:cb4d9db17537 1519 /* or only the last Byte of Transfer */
mbed_official 376:cb4d9db17537 1520 /* So reset the RELOAD bit mode */
mbed_official 376:cb4d9db17537 1521 hsmbus->XferOptions &= ~SMBUS_RELOAD_MODE;
mbed_official 376:cb4d9db17537 1522 SMBUS_TransferConfig(hsmbus,0 ,1 , hsmbus->XferOptions, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 1523 }
mbed_official 376:cb4d9db17537 1524 else if(hsmbus->XferCount == 0)
mbed_official 376:cb4d9db17537 1525 {
mbed_official 376:cb4d9db17537 1526 /* Last Byte is received, disable Interrupt */
mbed_official 376:cb4d9db17537 1527 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_RX);
mbed_official 376:cb4d9db17537 1528
mbed_official 489:119543c9f674 1529 /* Remove HAL_SMBUS_STATE_SLAVE_BUSY_RX, keep only HAL_SMBUS_STATE_LISTEN */
mbed_official 376:cb4d9db17537 1530 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1531 hsmbus->State &= (uint32_t)~((uint32_t)HAL_SMBUS_STATE_SLAVE_BUSY_RX);
mbed_official 376:cb4d9db17537 1532
mbed_official 376:cb4d9db17537 1533 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1534 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1535
mbed_official 376:cb4d9db17537 1536 /* Call the Rx complete callback to inform upper layer of the end of receive process */
mbed_official 376:cb4d9db17537 1537 HAL_SMBUS_SlaveRxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1538 }
mbed_official 376:cb4d9db17537 1539 else
mbed_official 376:cb4d9db17537 1540 {
mbed_official 376:cb4d9db17537 1541 /* Set Reload for next Bytes */
mbed_official 376:cb4d9db17537 1542 SMBUS_TransferConfig(hsmbus,0, 1, SMBUS_RELOAD_MODE, SMBUS_NO_STARTSTOP);
mbed_official 376:cb4d9db17537 1543
mbed_official 376:cb4d9db17537 1544 /* Ack last Byte Read */
mbed_official 376:cb4d9db17537 1545 hsmbus->Instance->CR2 &= ~I2C_CR2_NACK;
mbed_official 376:cb4d9db17537 1546 }
mbed_official 376:cb4d9db17537 1547 }
mbed_official 376:cb4d9db17537 1548 else if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_TXIS) != RESET)
mbed_official 376:cb4d9db17537 1549 {
mbed_official 376:cb4d9db17537 1550 /* Write data to TXDR only if XferCount not reach "0" */
mbed_official 376:cb4d9db17537 1551 /* A TXIS flag can be set, during STOP treatment */
mbed_official 376:cb4d9db17537 1552
mbed_official 376:cb4d9db17537 1553 /* Check if all Datas have already been sent */
mbed_official 376:cb4d9db17537 1554 /* If it is the case, this last write in TXDR is not sent, correspond to a dummy TXIS event */
mbed_official 376:cb4d9db17537 1555 if(hsmbus->XferCount > 0)
mbed_official 376:cb4d9db17537 1556 {
mbed_official 376:cb4d9db17537 1557 /* Write data to TXDR */
mbed_official 376:cb4d9db17537 1558 hsmbus->Instance->TXDR = (*hsmbus->pBuffPtr++);
mbed_official 376:cb4d9db17537 1559 hsmbus->XferCount--;
mbed_official 376:cb4d9db17537 1560 hsmbus->XferSize--;
mbed_official 376:cb4d9db17537 1561 }
mbed_official 376:cb4d9db17537 1562
mbed_official 376:cb4d9db17537 1563 if(hsmbus->XferSize == 0)
mbed_official 376:cb4d9db17537 1564 {
mbed_official 376:cb4d9db17537 1565 /* Last Byte is Transmitted */
mbed_official 489:119543c9f674 1566 /* Remove HAL_SMBUS_STATE_SLAVE_BUSY_TX, keep only HAL_SMBUS_STATE_LISTEN */
mbed_official 376:cb4d9db17537 1567 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 1568 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1569 hsmbus->State &= (uint32_t)~((uint32_t)HAL_SMBUS_STATE_SLAVE_BUSY_TX);
mbed_official 376:cb4d9db17537 1570
mbed_official 376:cb4d9db17537 1571 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1572 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1573
mbed_official 376:cb4d9db17537 1574 /* Call the Tx complete callback to inform upper layer of the end of transmit process */
mbed_official 376:cb4d9db17537 1575 HAL_SMBUS_SlaveTxCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1576 }
mbed_official 376:cb4d9db17537 1577 }
mbed_official 376:cb4d9db17537 1578
mbed_official 376:cb4d9db17537 1579 /* Check if STOPF is set */
mbed_official 376:cb4d9db17537 1580 if(__HAL_SMBUS_GET_FLAG(hsmbus, SMBUS_FLAG_STOPF) != RESET)
mbed_official 376:cb4d9db17537 1581 {
mbed_official 376:cb4d9db17537 1582 if((hsmbus->State & HAL_SMBUS_STATE_LISTEN) == HAL_SMBUS_STATE_LISTEN)
mbed_official 376:cb4d9db17537 1583 {
mbed_official 376:cb4d9db17537 1584 /* Disable RX and TX Interrupts */
mbed_official 376:cb4d9db17537 1585 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_RX | SMBUS_IT_TX);
mbed_official 376:cb4d9db17537 1586
mbed_official 376:cb4d9db17537 1587 /* Disable ADDR Interrupt */
mbed_official 376:cb4d9db17537 1588 SMBUS_Disable_IRQ(hsmbus, SMBUS_IT_ADDR);
mbed_official 376:cb4d9db17537 1589
mbed_official 376:cb4d9db17537 1590 /* Disable Address Acknowledge */
mbed_official 376:cb4d9db17537 1591 hsmbus->Instance->CR2 |= I2C_CR2_NACK;
mbed_official 376:cb4d9db17537 1592
mbed_official 376:cb4d9db17537 1593 /* Clear Configuration Register 2 */
mbed_official 489:119543c9f674 1594 __SMBUS_RESET_CR2(hsmbus);
mbed_official 376:cb4d9db17537 1595
mbed_official 376:cb4d9db17537 1596 /* Clear STOP Flag */
mbed_official 376:cb4d9db17537 1597 __HAL_SMBUS_CLEAR_FLAG(hsmbus, SMBUS_FLAG_STOPF);
mbed_official 376:cb4d9db17537 1598
mbed_official 376:cb4d9db17537 1599 /* Clear ADDR flag */
mbed_official 376:cb4d9db17537 1600 __HAL_SMBUS_CLEAR_FLAG(hsmbus,SMBUS_FLAG_ADDR);
mbed_official 376:cb4d9db17537 1601
mbed_official 376:cb4d9db17537 1602 hsmbus->XferOptions = 0;
mbed_official 376:cb4d9db17537 1603 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1604 hsmbus->State = HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1605
mbed_official 376:cb4d9db17537 1606 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1607 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1608
mbed_official 376:cb4d9db17537 1609 /* Call the Slave Complete callback, to prevent upper layer of the end of slave usecase */
mbed_official 376:cb4d9db17537 1610 HAL_SMBUS_ListenCpltCallback(hsmbus);
mbed_official 376:cb4d9db17537 1611 }
mbed_official 376:cb4d9db17537 1612 }
mbed_official 376:cb4d9db17537 1613
mbed_official 376:cb4d9db17537 1614 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1615 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1616
mbed_official 376:cb4d9db17537 1617 return HAL_OK;
mbed_official 376:cb4d9db17537 1618 }
mbed_official 376:cb4d9db17537 1619
mbed_official 376:cb4d9db17537 1620 /**
mbed_official 376:cb4d9db17537 1621 * @brief Manage the enabling of Interrupts
mbed_official 376:cb4d9db17537 1622 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1623 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1624 * @param InterruptRequest : Value of @ref SMBUS_Interrupt_configuration_definition.
mbed_official 376:cb4d9db17537 1625 * @retval HAL status
mbed_official 376:cb4d9db17537 1626 */
mbed_official 376:cb4d9db17537 1627 static HAL_StatusTypeDef SMBUS_Enable_IRQ(SMBUS_HandleTypeDef *hsmbus, uint16_t InterruptRequest)
mbed_official 376:cb4d9db17537 1628 {
mbed_official 376:cb4d9db17537 1629 uint32_t tmpisr = 0;
mbed_official 376:cb4d9db17537 1630
mbed_official 376:cb4d9db17537 1631 if((InterruptRequest & SMBUS_IT_ALERT) == SMBUS_IT_ALERT)
mbed_official 376:cb4d9db17537 1632 {
mbed_official 376:cb4d9db17537 1633 /* Enable ERR interrupt */
mbed_official 376:cb4d9db17537 1634 tmpisr |= SMBUS_IT_ERRI;
mbed_official 376:cb4d9db17537 1635 }
mbed_official 376:cb4d9db17537 1636
mbed_official 376:cb4d9db17537 1637 if((InterruptRequest & SMBUS_IT_ADDR) == SMBUS_IT_ADDR)
mbed_official 376:cb4d9db17537 1638 {
mbed_official 376:cb4d9db17537 1639 /* Enable ADDR, STOP interrupt */
mbed_official 376:cb4d9db17537 1640 tmpisr |= SMBUS_IT_ADDRI | SMBUS_IT_STOPI | SMBUS_IT_NACKI | SMBUS_IT_ERRI;
mbed_official 376:cb4d9db17537 1641 }
mbed_official 376:cb4d9db17537 1642
mbed_official 376:cb4d9db17537 1643 if((InterruptRequest & SMBUS_IT_TX) == SMBUS_IT_TX)
mbed_official 376:cb4d9db17537 1644 {
mbed_official 376:cb4d9db17537 1645 /* Enable ERR, TC, STOP, NACK, RXI interrupt */
mbed_official 376:cb4d9db17537 1646 tmpisr |= SMBUS_IT_ERRI | SMBUS_IT_TCI | SMBUS_IT_STOPI | SMBUS_IT_NACKI | SMBUS_IT_TXI;
mbed_official 376:cb4d9db17537 1647 }
mbed_official 376:cb4d9db17537 1648
mbed_official 376:cb4d9db17537 1649 if((InterruptRequest & SMBUS_IT_RX) == SMBUS_IT_RX)
mbed_official 376:cb4d9db17537 1650 {
mbed_official 376:cb4d9db17537 1651 /* Enable ERR, TC, STOP, NACK, TXI interrupt */
mbed_official 376:cb4d9db17537 1652 tmpisr |= SMBUS_IT_ERRI | SMBUS_IT_TCI | SMBUS_IT_STOPI | SMBUS_IT_NACKI | SMBUS_IT_RXI;
mbed_official 376:cb4d9db17537 1653 }
mbed_official 376:cb4d9db17537 1654
mbed_official 376:cb4d9db17537 1655 /* Enable interrupts only at the end */
mbed_official 376:cb4d9db17537 1656 /* to avoid the risk of SMBUS interrupt handle execution before */
mbed_official 376:cb4d9db17537 1657 /* all interrupts requested done */
mbed_official 376:cb4d9db17537 1658 __HAL_SMBUS_ENABLE_IT(hsmbus, tmpisr);
mbed_official 376:cb4d9db17537 1659
mbed_official 376:cb4d9db17537 1660 return HAL_OK;
mbed_official 376:cb4d9db17537 1661 }
mbed_official 376:cb4d9db17537 1662 /**
mbed_official 376:cb4d9db17537 1663 * @brief Manage the disabling of Interrupts
mbed_official 376:cb4d9db17537 1664 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1665 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1666 * @param InterruptRequest : Value of @ref SMBUS_Interrupt_configuration_definition.
mbed_official 376:cb4d9db17537 1667 * @retval HAL status
mbed_official 376:cb4d9db17537 1668 */
mbed_official 376:cb4d9db17537 1669 static HAL_StatusTypeDef SMBUS_Disable_IRQ(SMBUS_HandleTypeDef *hsmbus, uint16_t InterruptRequest)
mbed_official 376:cb4d9db17537 1670 {
mbed_official 376:cb4d9db17537 1671 uint32_t tmpisr = 0;
mbed_official 376:cb4d9db17537 1672
mbed_official 376:cb4d9db17537 1673 if( ((InterruptRequest & SMBUS_IT_ALERT) == SMBUS_IT_ALERT) && (hsmbus->State == HAL_SMBUS_STATE_READY) )
mbed_official 376:cb4d9db17537 1674 {
mbed_official 376:cb4d9db17537 1675 /* Disable ERR interrupt */
mbed_official 376:cb4d9db17537 1676 tmpisr |= SMBUS_IT_ERRI;
mbed_official 376:cb4d9db17537 1677 }
mbed_official 376:cb4d9db17537 1678
mbed_official 376:cb4d9db17537 1679 if((InterruptRequest & SMBUS_IT_TX) == SMBUS_IT_TX)
mbed_official 376:cb4d9db17537 1680 {
mbed_official 376:cb4d9db17537 1681 /* Disable TC, STOP, NACK, TXI interrupt */
mbed_official 376:cb4d9db17537 1682 tmpisr |= SMBUS_IT_TCI | SMBUS_IT_TXI;
mbed_official 376:cb4d9db17537 1683
mbed_official 489:119543c9f674 1684 if((__SMBUS_GET_ALERT_ENABLE(hsmbus) == RESET)
mbed_official 376:cb4d9db17537 1685 && ((hsmbus->State & HAL_SMBUS_STATE_LISTEN) != HAL_SMBUS_STATE_LISTEN))
mbed_official 376:cb4d9db17537 1686 {
mbed_official 376:cb4d9db17537 1687 /* Disable ERR interrupt */
mbed_official 376:cb4d9db17537 1688 tmpisr |= SMBUS_IT_ERRI;
mbed_official 376:cb4d9db17537 1689 }
mbed_official 376:cb4d9db17537 1690
mbed_official 376:cb4d9db17537 1691 if((hsmbus->State & HAL_SMBUS_STATE_LISTEN) != HAL_SMBUS_STATE_LISTEN)
mbed_official 376:cb4d9db17537 1692 {
mbed_official 376:cb4d9db17537 1693 /* Disable STOPI, NACKI */
mbed_official 376:cb4d9db17537 1694 tmpisr |= SMBUS_IT_STOPI | SMBUS_IT_NACKI;
mbed_official 376:cb4d9db17537 1695 }
mbed_official 376:cb4d9db17537 1696 }
mbed_official 376:cb4d9db17537 1697
mbed_official 376:cb4d9db17537 1698 if((InterruptRequest & SMBUS_IT_RX) == SMBUS_IT_RX)
mbed_official 376:cb4d9db17537 1699 {
mbed_official 376:cb4d9db17537 1700 /* Disable TC, STOP, NACK, RXI interrupt */
mbed_official 376:cb4d9db17537 1701 tmpisr |= SMBUS_IT_TCI | SMBUS_IT_RXI;
mbed_official 376:cb4d9db17537 1702
mbed_official 489:119543c9f674 1703 if((__SMBUS_GET_ALERT_ENABLE(hsmbus) == RESET)
mbed_official 376:cb4d9db17537 1704 && ((hsmbus->State & HAL_SMBUS_STATE_LISTEN) != HAL_SMBUS_STATE_LISTEN))
mbed_official 376:cb4d9db17537 1705 {
mbed_official 376:cb4d9db17537 1706 /* Disable ERR interrupt */
mbed_official 376:cb4d9db17537 1707 tmpisr |= SMBUS_IT_ERRI;
mbed_official 376:cb4d9db17537 1708 }
mbed_official 376:cb4d9db17537 1709
mbed_official 376:cb4d9db17537 1710 if((hsmbus->State & HAL_SMBUS_STATE_LISTEN) != HAL_SMBUS_STATE_LISTEN)
mbed_official 376:cb4d9db17537 1711 {
mbed_official 376:cb4d9db17537 1712 /* Disable STOPI, NACKI */
mbed_official 376:cb4d9db17537 1713 tmpisr |= SMBUS_IT_STOPI | SMBUS_IT_NACKI;
mbed_official 376:cb4d9db17537 1714 }
mbed_official 376:cb4d9db17537 1715 }
mbed_official 376:cb4d9db17537 1716
mbed_official 376:cb4d9db17537 1717 if((InterruptRequest & SMBUS_IT_ADDR) == SMBUS_IT_ADDR)
mbed_official 376:cb4d9db17537 1718 {
mbed_official 376:cb4d9db17537 1719 /* Enable ADDR, STOP interrupt */
mbed_official 376:cb4d9db17537 1720 tmpisr |= SMBUS_IT_ADDRI | SMBUS_IT_STOPI | SMBUS_IT_NACKI;
mbed_official 376:cb4d9db17537 1721
mbed_official 489:119543c9f674 1722 if(__SMBUS_GET_ALERT_ENABLE(hsmbus) == RESET)
mbed_official 376:cb4d9db17537 1723 {
mbed_official 376:cb4d9db17537 1724 /* Disable ERR interrupt */
mbed_official 376:cb4d9db17537 1725 tmpisr |= SMBUS_IT_ERRI;
mbed_official 376:cb4d9db17537 1726 }
mbed_official 376:cb4d9db17537 1727 }
mbed_official 376:cb4d9db17537 1728
mbed_official 376:cb4d9db17537 1729 /* Disable interrupts only at the end */
mbed_official 376:cb4d9db17537 1730 /* to avoid a breaking situation like at "t" time */
mbed_official 376:cb4d9db17537 1731 /* all disable interrupts request are not done */
mbed_official 376:cb4d9db17537 1732 __HAL_SMBUS_DISABLE_IT(hsmbus, tmpisr);
mbed_official 376:cb4d9db17537 1733
mbed_official 376:cb4d9db17537 1734 return HAL_OK;
mbed_official 376:cb4d9db17537 1735 }
mbed_official 376:cb4d9db17537 1736 /**
mbed_official 376:cb4d9db17537 1737 * @brief This function handles SMBUS Communication Timeout.
mbed_official 376:cb4d9db17537 1738 * @param hsmbus : Pointer to a SMBUS_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1739 * the configuration information for the specified SMBUS.
mbed_official 376:cb4d9db17537 1740 * @param Flag: specifies the SMBUS flag to check.
mbed_official 376:cb4d9db17537 1741 * @param Status: The new Flag status (SET or RESET).
mbed_official 376:cb4d9db17537 1742 * @param Timeout: Timeout duration
mbed_official 376:cb4d9db17537 1743 * @retval HAL status
mbed_official 376:cb4d9db17537 1744 */
mbed_official 376:cb4d9db17537 1745 static HAL_StatusTypeDef SMBUS_WaitOnFlagUntilTimeout(SMBUS_HandleTypeDef *hsmbus, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 376:cb4d9db17537 1746 {
mbed_official 376:cb4d9db17537 1747 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 1748 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1749
mbed_official 376:cb4d9db17537 1750 /* Wait until flag is set */
mbed_official 376:cb4d9db17537 1751 if(Status == RESET)
mbed_official 376:cb4d9db17537 1752 {
mbed_official 376:cb4d9db17537 1753 while(__HAL_SMBUS_GET_FLAG(hsmbus, Flag) == RESET)
mbed_official 376:cb4d9db17537 1754 {
mbed_official 376:cb4d9db17537 1755 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1756 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1757 {
mbed_official 376:cb4d9db17537 1758 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1759 {
mbed_official 376:cb4d9db17537 1760 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1761 hsmbus->State= HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1762
mbed_official 376:cb4d9db17537 1763 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1764 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1765
mbed_official 376:cb4d9db17537 1766 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1767 }
mbed_official 376:cb4d9db17537 1768 }
mbed_official 376:cb4d9db17537 1769 }
mbed_official 376:cb4d9db17537 1770 }
mbed_official 376:cb4d9db17537 1771 else
mbed_official 376:cb4d9db17537 1772 {
mbed_official 376:cb4d9db17537 1773 while(__HAL_SMBUS_GET_FLAG(hsmbus, Flag) != RESET)
mbed_official 376:cb4d9db17537 1774 {
mbed_official 376:cb4d9db17537 1775 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1776 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1777 {
mbed_official 376:cb4d9db17537 1778 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1779 {
mbed_official 376:cb4d9db17537 1780 hsmbus->PreviousState = hsmbus->State;
mbed_official 376:cb4d9db17537 1781 hsmbus->State= HAL_SMBUS_STATE_READY;
mbed_official 376:cb4d9db17537 1782
mbed_official 376:cb4d9db17537 1783 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1784 __HAL_UNLOCK(hsmbus);
mbed_official 376:cb4d9db17537 1785
mbed_official 376:cb4d9db17537 1786 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1787 }
mbed_official 376:cb4d9db17537 1788 }
mbed_official 376:cb4d9db17537 1789 }
mbed_official 376:cb4d9db17537 1790 }
mbed_official 376:cb4d9db17537 1791 return HAL_OK;
mbed_official 376:cb4d9db17537 1792 }
mbed_official 376:cb4d9db17537 1793
mbed_official 376:cb4d9db17537 1794 /**
mbed_official 376:cb4d9db17537 1795 * @brief Handles SMBUSx communication when starting transfer or during transfer (TC or TCR flag are set).
mbed_official 376:cb4d9db17537 1796 * @param hsmbus: SMBUS handle.
mbed_official 376:cb4d9db17537 1797 * @param DevAddress: specifies the slave address to be programmed.
mbed_official 376:cb4d9db17537 1798 * @param Size: specifies the number of bytes to be programmed.
mbed_official 376:cb4d9db17537 1799 * This parameter must be a value between 0 and 255.
mbed_official 376:cb4d9db17537 1800 * @param Mode: new state of the SMBUS START condition generation.
mbed_official 376:cb4d9db17537 1801 * This parameter can be one or a combination of the following values:
mbed_official 376:cb4d9db17537 1802 * @arg SMBUS_NO_MODE: No specific mode enabled.
mbed_official 376:cb4d9db17537 1803 * @arg SMBUS_RELOAD_MODE: Enable Reload mode.
mbed_official 376:cb4d9db17537 1804 * @arg SMBUS_AUTOEND_MODE: Enable Automatic end mode.
mbed_official 376:cb4d9db17537 1805 * @arg SMBUS_SOFTEND_MODE: Enable Software end mode and Reload mode.
mbed_official 376:cb4d9db17537 1806 * @param Request: new state of the SMBUS START condition generation.
mbed_official 376:cb4d9db17537 1807 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 1808 * @arg SMBUS_NO_STARTSTOP: Don't Generate stop and start condition.
mbed_official 376:cb4d9db17537 1809 * @arg SMBUS_GENERATE_STOP: Generate stop condition (Size should be set to 0).
mbed_official 376:cb4d9db17537 1810 * @arg SMBUS_GENERATE_START_READ: Generate Restart for read request.
mbed_official 376:cb4d9db17537 1811 * @arg SMBUS_GENERATE_START_WRITE: Generate Restart for write request.
mbed_official 376:cb4d9db17537 1812 * @retval None
mbed_official 376:cb4d9db17537 1813 */
mbed_official 376:cb4d9db17537 1814 static void SMBUS_TransferConfig(SMBUS_HandleTypeDef *hsmbus, uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request)
mbed_official 376:cb4d9db17537 1815 {
mbed_official 376:cb4d9db17537 1816 uint32_t tmpreg = 0;
mbed_official 376:cb4d9db17537 1817
mbed_official 376:cb4d9db17537 1818 /* Check the parameters */
mbed_official 376:cb4d9db17537 1819 assert_param(IS_SMBUS_INSTANCE(hsmbus->Instance));
mbed_official 376:cb4d9db17537 1820 assert_param(IS_SMBUS_TRANSFER_MODE(Mode));
mbed_official 376:cb4d9db17537 1821 assert_param(IS_SMBUS_TRANSFER_REQUEST(Request));
mbed_official 376:cb4d9db17537 1822
mbed_official 376:cb4d9db17537 1823 /* Get the CR2 register value */
mbed_official 376:cb4d9db17537 1824 tmpreg = hsmbus->Instance->CR2;
mbed_official 376:cb4d9db17537 1825
mbed_official 376:cb4d9db17537 1826 /* clear tmpreg specific bits */
mbed_official 376:cb4d9db17537 1827 tmpreg &= (uint32_t)~((uint32_t)(I2C_CR2_SADD | I2C_CR2_NBYTES | I2C_CR2_RELOAD | I2C_CR2_AUTOEND | I2C_CR2_RD_WRN | I2C_CR2_START | I2C_CR2_STOP | I2C_CR2_PECBYTE));
mbed_official 376:cb4d9db17537 1828
mbed_official 376:cb4d9db17537 1829 /* update tmpreg */
mbed_official 376:cb4d9db17537 1830 tmpreg |= (uint32_t)(((uint32_t)DevAddress & I2C_CR2_SADD) | (((uint32_t)Size << 16 ) & I2C_CR2_NBYTES) | \
mbed_official 376:cb4d9db17537 1831 (uint32_t)Mode | (uint32_t)Request);
mbed_official 376:cb4d9db17537 1832
mbed_official 376:cb4d9db17537 1833 /* update CR2 register */
mbed_official 376:cb4d9db17537 1834 hsmbus->Instance->CR2 = tmpreg;
mbed_official 376:cb4d9db17537 1835 }
mbed_official 376:cb4d9db17537 1836
mbed_official 376:cb4d9db17537 1837 /**
mbed_official 376:cb4d9db17537 1838 * @}
mbed_official 376:cb4d9db17537 1839 */
mbed_official 376:cb4d9db17537 1840
mbed_official 376:cb4d9db17537 1841 #endif /* HAL_SMBUS_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1842 /**
mbed_official 376:cb4d9db17537 1843 * @}
mbed_official 376:cb4d9db17537 1844 */
mbed_official 376:cb4d9db17537 1845
mbed_official 376:cb4d9db17537 1846 /**
mbed_official 376:cb4d9db17537 1847 * @}
mbed_official 376:cb4d9db17537 1848 */
mbed_official 376:cb4d9db17537 1849
mbed_official 376:cb4d9db17537 1850 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 489:119543c9f674 1851