src/main/drivers/bus_spi.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 #ifdef USE_SPI
  28
  29 #include "drivers/bus.h"
  30 #include "drivers/bus_spi.h"
  31 #include "drivers/bus_spi_impl.h"
  32 #include "drivers/exti.h"
  33 #include "drivers/io.h"
  34 #include "drivers/rcc.h"
  35
  36 spiDevice_t spiDevice[SPIDEV_COUNT];
  37
  38 SPIDevice spiDeviceByInstance(SPI_TypeDef *instance)
  39 {
  40 #ifdef USE_SPI_DEVICE_1
  41     if (instance == SPI1)
  42         return SPIDEV_1;
  43 #endif
  44
  45 #ifdef USE_SPI_DEVICE_2
  46     if (instance == SPI2)
  47         return SPIDEV_2;
  48 #endif
  49
  50 #ifdef USE_SPI_DEVICE_3
  51     if (instance == SPI3)
  52         return SPIDEV_3;
  53 #endif
  54
  55 #ifdef USE_SPI_DEVICE_4
  56     if (instance == SPI4)
  57         return SPIDEV_4;
  58 #endif
  59
  60     return SPIINVALID;
  61 }
  62
  63 SPI_TypeDef *spiInstanceByDevice(SPIDevice device)
  64 {
  65     if (device == SPIINVALID || device >= SPIDEV_COUNT) {
  66         return NULL;
  67     }
  68
  69     return spiDevice[device].dev;
  70 }
  71
  72 bool spiInit(SPIDevice device, bool leadingEdge)
  73 {
  74     switch (device) {
  75     case SPIINVALID:
  76         return false;
  77
  78     case SPIDEV_1:
  79 #ifdef USE_SPI_DEVICE_1
  80         spiInitDevice(device, leadingEdge);
  81         return true;
  82 #else
  83         break;
  84 #endif
  85
  86     case SPIDEV_2:
  87 #ifdef USE_SPI_DEVICE_2
  88         spiInitDevice(device, leadingEdge);
  89         return true;
  90 #else
  91         break;
  92 #endif
  93
  94     case SPIDEV_3:
  95 #if defined(USE_SPI_DEVICE_3) && !defined(STM32F1)
  96         spiInitDevice(device, leadingEdge);
  97         return true;
  98 #else
  99         break;
 100 #endif
 101
 102     case SPIDEV_4:
 103 #if defined(USE_SPI_DEVICE_4)
 104         spiInitDevice(device, leadingEdge);
 105         return true;
 106 #else
 107         break;
 108 #endif
 109
 110     case SPIDEV_5:
 111 #if defined(USE_SPI_DEVICE_5)
 112         spiInitDevice(device, leadingEdge);
 113         return true;
 114 #else
 115         break;
 116 #endif
 117
 118     case SPIDEV_6:
 119 #if defined(USE_SPI_DEVICE_6)
 120         spiInitDevice(device, leadingEdge);
 121         return true;
 122 #else
 123         break;
 124 #endif
 125     }
 126     return false;
 127 }
 128
 129 uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance)
 130 {
 131     SPIDevice device = spiDeviceByInstance(instance);
 132     if (device == SPIINVALID) {
 133         return -1;
 134     }
 135     spiDevice[device].errorCount++;
 136     return spiDevice[device].errorCount;
 137 }
 138
 139 bool spiBusTransfer(const busDevice_t *bus, const uint8_t *txData, uint8_t *rxData, int length)
 140 {
 141     IOLo(bus->busdev_u.spi.csnPin);
 142     spiTransfer(bus->busdev_u.spi.instance, txData, rxData, length);
 143     IOHi(bus->busdev_u.spi.csnPin);
 144     return true;
 145 }
 146
 147 uint16_t spiGetErrorCounter(SPI_TypeDef *instance)
 148 {
 149     SPIDevice device = spiDeviceByInstance(instance);
 150     if (device == SPIINVALID) {
 151         return 0;
 152     }
 153     return spiDevice[device].errorCount;
 154 }
 155
 156 void spiResetErrorCounter(SPI_TypeDef *instance)
 157 {
 158     SPIDevice device = spiDeviceByInstance(instance);
 159     if (device != SPIINVALID) {
 160         spiDevice[device].errorCount = 0;
 161     }
 162 }
 163
 164 bool spiBusIsBusBusy(const busDevice_t *bus)
 165 {
 166     return spiIsBusBusy(bus->busdev_u.spi.instance);
 167 }
 168
 169 uint8_t spiBusTransferByte(const busDevice_t *bus, uint8_t data)
 170 {
 171     return spiTransferByte(bus->busdev_u.spi.instance, data);
 172 }
 173
 174 void spiBusWriteByte(const busDevice_t *bus, uint8_t data)
 175 {
 176     IOLo(bus->busdev_u.spi.csnPin);
 177     spiBusTransferByte(bus, data);
 178     IOHi(bus->busdev_u.spi.csnPin);
 179 }
 180
 181 bool spiBusRawTransfer(const busDevice_t *bus, const uint8_t *txData, uint8_t *rxData, int len)
 182 {
 183     return spiTransfer(bus->busdev_u.spi.instance, txData, rxData, len);
 184 }
 185
 186 bool spiBusWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
 187 {
 188     IOLo(bus->busdev_u.spi.csnPin);
 189     spiTransferByte(bus->busdev_u.spi.instance, reg);
 190     spiTransferByte(bus->busdev_u.spi.instance, data);
 191     IOHi(bus->busdev_u.spi.csnPin);
 192
 193     return true;
 194 }
 195
 196 bool spiBusRawReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length)
 197 {
 198     IOLo(bus->busdev_u.spi.csnPin);
 199     spiTransferByte(bus->busdev_u.spi.instance, reg);
 200     spiTransfer(bus->busdev_u.spi.instance, NULL, data, length);
 201     IOHi(bus->busdev_u.spi.csnPin);
 202
 203     return true;
 204 }
 205
 206 bool spiBusReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length)
 207 {
 208     return spiBusRawReadRegisterBuffer(bus, reg | 0x80, data, length);
 209 }
 210
 211 void spiBusWriteRegisterBuffer(const busDevice_t *bus, uint8_t reg, const uint8_t *data, uint8_t length)
 212 {
 213     IOLo(bus->busdev_u.spi.csnPin);
 214     spiTransferByte(bus->busdev_u.spi.instance, reg);
 215     spiTransfer(bus->busdev_u.spi.instance, data, NULL, length);
 216     IOHi(bus->busdev_u.spi.csnPin);
 217 }
 218
 219 uint8_t spiBusRawReadRegister(const busDevice_t *bus, uint8_t reg)
 220 {
 221     uint8_t data;
 222     IOLo(bus->busdev_u.spi.csnPin);
 223     spiTransferByte(bus->busdev_u.spi.instance, reg);
 224     spiTransfer(bus->busdev_u.spi.instance, NULL, &data, 1);
 225     IOHi(bus->busdev_u.spi.csnPin);
 226
 227     return data;
 228 }
 229
 230 uint8_t spiBusReadRegister(const busDevice_t *bus, uint8_t reg)
 231 {
 232     return spiBusRawReadRegister(bus, reg | 0x80);
 233 }
 234
 235 void spiBusSetInstance(busDevice_t *bus, SPI_TypeDef *instance)
 236 {
 237     bus->bustype = BUSTYPE_SPI;
 238     bus->busdev_u.spi.instance = instance;
 239 }
 240
 241 void spiBusSetDivisor(busDevice_t *bus, uint16_t divisor)
 242 {
 243     spiSetDivisor(bus->busdev_u.spi.instance, divisor);
 244     // bus->busdev_u.spi.modeCache = bus->busdev_u.spi.instance->CR1;
 245 }
 246
 247 #ifdef USE_SPI_TRANSACTION
 248 // Separate set of spiBusTransactionXXX to keep fast path for acc/gyros.
 249
 250 void spiBusTransactionBegin(const busDevice_t *bus)
 251 {
 252     spiBusTransactionSetup(bus);
 253     IOLo(bus->busdev_u.spi.csnPin);
 254 }
 255
 256 void spiBusTransactionEnd(const busDevice_t *bus)
 257 {
 258     IOHi(bus->busdev_u.spi.csnPin);
 259 }
 260
 261 bool spiBusTransactionTransfer(const busDevice_t *bus, const uint8_t *txData, uint8_t *rxData, int length)
 262 {
 263     spiBusTransactionSetup(bus);
 264     return spiBusTransfer(bus, txData, rxData, length);
 265 }
 266
 267 bool spiBusTransactionWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
 268 {
 269     spiBusTransactionSetup(bus);
 270     return spiBusWriteRegister(bus, reg, data);
 271 }
 272
 273 uint8_t spiBusTransactionReadRegister(const busDevice_t *bus, uint8_t reg)
 274 {
 275     spiBusTransactionSetup(bus);
 276     return spiBusReadRegister(bus, reg);
 277 }
 278
 279 bool spiBusTransactionReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length)
 280 {
 281     spiBusTransactionSetup(bus);
 282     return spiBusReadRegisterBuffer(bus, reg, data, length);
 283 }
 284 #endif // USE_SPI_TRANSACTION
 285 #endif