long dao / mbed-src

Mbed for VNG board

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_smbus.c@387:643a59b3dbac, 2014-11-05 (annotated)

Committer:
mbed_official
Date:
Wed Nov 05 14:30:08 2014 +0000
Revision:
387:643a59b3dbac
Parent:
382:ee426a420dbb 
Synchronized with git revision cfeccf154f8f92c3ea9c0c881c577c154537aecc



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



Exporters: STM32L053R8 - IAR exporter

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 376:cb4d9db17537 5 * @version V1.1.0
mbed_official 376:cb4d9db17537 6 * @date 18-June-2014
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 376:cb4d9db17537 61 (+) Enable the Address listen mode in slave/device SMBUS mode using HAL_SMBUS_Slave_Listen_IT()
mbed_official 376:cb4d9db17537 62 (++) When address slave/device SMBUS match, HAL_SMBUS_SlaveAddrCallback 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 376:cb4d9db17537 64 (++) At Listen mode end HAL_SMBUS_SlaveListenCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 65 add his own code by customization of function pointer HAL_SMBUS_SlaveListenCpltCallback
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 376:cb4d9db17537 101 * <h2><center>&copy; COPYRIGHT(c) 2014 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 387:643a59b3dbac 221 if(hsmbus == HAL_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 376:cb4d9db17537 292 if( (hsmbus->Init.PacketErrorCheckMode == SMBUS_PEC_ENABLED)
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 387:643a59b3dbac 317 if(hsmbus == HAL_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 376:cb4d9db17537 398 (++) HAL_SMBUS_Slave_Listen_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 376:cb4d9db17537 407 (++) HAL_SMBUS_SlaveAddrCallback()
mbed_official 376:cb4d9db17537 408 (++) HAL_SMBUS_SlaveListenCpltCallback()
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 387:643a59b3dbac 444 if(hsmbus->pBuffPtr == HAL_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 376:cb4d9db17537 480 if(__HAL_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 387:643a59b3dbac 533 if(hsmbus->pBuffPtr == HAL_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 387:643a59b3dbac 660 if((pData == HAL_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 376:cb4d9db17537 688 if(__HAL_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 387:643a59b3dbac 731 if((pData == HAL_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 376:cb4d9db17537 759 if((hsmbus->XferSize == 1) || ((hsmbus->XferSize == 2) && (__HAL_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 376:cb4d9db17537 894 hsmbus->Instance->CR2 = __HAL_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 376:cb4d9db17537 1097 /* keep HAL_SMBUS_STATE_SLAVE_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 376:cb4d9db17537 1168 the HAL_SMBUS_SlaveAddrCallback 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 376:cb4d9db17537 1181 the HAL_SMBUS_SlaveListenCpltCallback 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 376:cb4d9db17537 1222 HAL_SMBUS_StateTypeDef 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 376:cb4d9db17537 1283 __HAL_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 376:cb4d9db17537 1310 __HAL_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 376:cb4d9db17537 1351 if(__HAL_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 376:cb4d9db17537 1362 if(__HAL_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 387:643a59b3dbac 1396 if(hsmbus->pBuffPtr == HAL_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 376:cb4d9db17537 1402 else if(__HAL_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 376:cb4d9db17537 1496 TransferDirection = __HAL_SMBUS_GET_DIR(hsmbus);
mbed_official 376:cb4d9db17537 1497 SlaveAddrCode = __HAL_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 376:cb4d9db17537 1529 /* Remove HAL_SMBUS_STATE_SLAVE_BUSY_RX, keep only HAL_SMBUS_STATE_SLAVE_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 376:cb4d9db17537 1566 /* Remove HAL_SMBUS_STATE_SLAVE_BUSY_TX, keep only HAL_SMBUS_STATE_SLAVE_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 376:cb4d9db17537 1594 __HAL_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 376:cb4d9db17537 1684 if((__HAL_SMBUS_GET_ALERT_ENABLED(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 376:cb4d9db17537 1703 if((__HAL_SMBUS_GET_ALERT_ENABLED(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 376:cb4d9db17537 1722 if(__HAL_SMBUS_GET_ALERT_ENABLED(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****/