src/main/drivers/bus_i2c_hal.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "platform.h"
  26
  27 #if defined(USE_I2C) && !defined(SOFT_I2C)
  28
  29 #include "drivers/io.h"
  30 #include "drivers/io_impl.h"
  31 #include "drivers/nvic.h"
  32 #include "drivers/time.h"
  33 #include "drivers/rcc.h"
  34
  35 #include "drivers/bus_i2c.h"
  36 #include "drivers/bus_i2c_impl.h"
  37
  38 #ifdef USE_I2C_DEVICE_1
  39 void I2C1_ER_IRQHandler(void)
  40 {
  41     HAL_I2C_ER_IRQHandler(&i2cDevice[I2CDEV_1].handle);
  42 }
  43
  44 void I2C1_EV_IRQHandler(void)
  45 {
  46     HAL_I2C_EV_IRQHandler(&i2cDevice[I2CDEV_1].handle);
  47 }
  48 #endif
  49
  50 #ifdef USE_I2C_DEVICE_2
  51 void I2C2_ER_IRQHandler(void)
  52 {
  53     HAL_I2C_ER_IRQHandler(&i2cDevice[I2CDEV_2].handle);
  54 }
  55
  56 void I2C2_EV_IRQHandler(void)
  57 {
  58     HAL_I2C_EV_IRQHandler(&i2cDevice[I2CDEV_2].handle);
  59 }
  60 #endif
  61
  62 #ifdef USE_I2C_DEVICE_3
  63 void I2C3_ER_IRQHandler(void)
  64 {
  65     HAL_I2C_ER_IRQHandler(&i2cDevice[I2CDEV_3].handle);
  66 }
  67
  68 void I2C3_EV_IRQHandler(void)
  69 {
  70     HAL_I2C_EV_IRQHandler(&i2cDevice[I2CDEV_3].handle);
  71 }
  72 #endif
  73
  74 #ifdef USE_I2C_DEVICE_4
  75 void I2C4_ER_IRQHandler(void)
  76 {
  77     HAL_I2C_ER_IRQHandler(&i2cDevice[I2CDEV_4].handle);
  78 }
  79
  80 void I2C4_EV_IRQHandler(void)
  81 {
  82     HAL_I2C_EV_IRQHandler(&i2cDevice[I2CDEV_4].handle);
  83 }
  84 #endif
  85
  86 static volatile uint16_t i2cErrorCount = 0;
  87
  88 static bool i2cHandleHardwareFailure(I2CDevice device)
  89 {
  90     (void)device;
  91     i2cErrorCount++;
  92     // reinit peripheral + clock out garbage
  93     //i2cInit(device);
  94     return false;
  95 }
  96
  97 uint16_t i2cGetErrorCounter(void)
  98 {
  99     return i2cErrorCount;
 100 }
 101
 102 // Blocking write
 103 bool i2cWrite(I2CDevice device, uint8_t addr_, uint8_t reg_, uint8_t data)
 104 {
 105     if (device == I2CINVALID || device >= I2CDEV_COUNT) {
 106         return false;
 107     }
 108
 109     I2C_HandleTypeDef *pHandle = &i2cDevice[device].handle;
 110
 111     if (!pHandle->Instance) {
 112         return false;
 113     }
 114
 115     HAL_StatusTypeDef status;
 116
 117     if (reg_ == 0xFF)
 118         status = HAL_I2C_Master_Transmit(pHandle ,addr_ << 1, &data, 1, I2C_TIMEOUT_SYS_TICKS);
 119     else
 120         status = HAL_I2C_Mem_Write(pHandle ,addr_ << 1, reg_, I2C_MEMADD_SIZE_8BIT, &data, 1, I2C_TIMEOUT_SYS_TICKS);
 121
 122     if (status != HAL_OK)
 123         return i2cHandleHardwareFailure(device);
 124
 125     return true;
 126 }
 127
 128 // Non-blocking write
 129 bool i2cWriteBuffer(I2CDevice device, uint8_t addr_, uint8_t reg_, uint8_t len_, uint8_t *data)
 130 {
 131     if (device == I2CINVALID || device >= I2CDEV_COUNT) {
 132         return false;
 133     }
 134
 135     I2C_HandleTypeDef *pHandle = &i2cDevice[device].handle;
 136
 137     if (!pHandle->Instance) {
 138         return false;
 139     }
 140
 141     HAL_StatusTypeDef status;
 142
 143     status = HAL_I2C_Mem_Write_IT(pHandle ,addr_ << 1, reg_, I2C_MEMADD_SIZE_8BIT,data, len_);
 144
 145     if (status == HAL_BUSY) {
 146         return false;
 147     }
 148
 149     if (status != HAL_OK)
 150     {
 151         return i2cHandleHardwareFailure(device);
 152     }
 153
 154     return true;
 155 }
 156
 157 // Blocking read
 158 bool i2cRead(I2CDevice device, uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf)
 159 {
 160     if (device == I2CINVALID || device >= I2CDEV_COUNT) {
 161         return false;
 162     }
 163
 164     I2C_HandleTypeDef *pHandle = &i2cDevice[device].handle;
 165
 166     if (!pHandle->Instance) {
 167         return false;
 168     }
 169
 170     HAL_StatusTypeDef status;
 171
 172     if (reg_ == 0xFF)
 173         status = HAL_I2C_Master_Receive(pHandle ,addr_ << 1, buf, len, I2C_TIMEOUT_SYS_TICKS);
 174     else
 175         status = HAL_I2C_Mem_Read(pHandle, addr_ << 1, reg_, I2C_MEMADD_SIZE_8BIT,buf, len, I2C_TIMEOUT_SYS_TICKS);
 176
 177     if (status != HAL_OK) {
 178         return i2cHandleHardwareFailure(device);
 179     }
 180
 181     return true;
 182 }
 183
 184 // Non-blocking read
 185 bool i2cReadBuffer(I2CDevice device, uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf)
 186 {
 187     if (device == I2CINVALID || device >= I2CDEV_COUNT) {
 188         return false;
 189     }
 190
 191     I2C_HandleTypeDef *pHandle = &i2cDevice[device].handle;
 192
 193     if (!pHandle->Instance) {
 194         return false;
 195     }
 196
 197     HAL_StatusTypeDef status;
 198
 199     status = HAL_I2C_Mem_Read_IT(pHandle, addr_ << 1, reg_, I2C_MEMADD_SIZE_8BIT,buf, len);
 200
 201     if (status == HAL_BUSY) {
 202         return false;
 203     }
 204
 205     if (status != HAL_OK) {
 206         return i2cHandleHardwareFailure(device);
 207     }
 208
 209     return true;
 210 }
 211
 212 bool i2cBusy(I2CDevice device, bool *error)
 213 {
 214     I2C_HandleTypeDef *pHandle = &i2cDevice[device].handle;
 215
 216     if (error) {
 217         *error = pHandle->ErrorCode;
 218     }
 219
 220     if (pHandle->State == HAL_I2C_STATE_READY)
 221     {
 222         if (__HAL_I2C_GET_FLAG(pHandle, I2C_FLAG_BUSY) == SET)
 223         {
 224             return true;
 225         }
 226
 227         return false;
 228     }
 229
 230     return true;
 231 }
 232
 233 #endif