src/main/drivers/rx/rx_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 // This file is copied with modifications from project Deviation,
  22 // see http://deviationtx.com
  23
  24 #include <stdbool.h>
  25 #include <stdint.h>
  26 #include <stdlib.h>
  27
  28 #include "platform.h"
  29
  30 #ifdef USE_RX_SPI
  31
  32 #include "build/build_config.h"
  33
  34 #include "drivers/bus_spi.h"
  35 #include "drivers/io.h"
  36 #include "drivers/io_impl.h"
  37 #include "drivers/nvic.h"
  38 #include "drivers/rcc.h"
  39 #include "drivers/system.h"
  40 #include "drivers/time.h"
  41
  42 #include "pg/rx_spi.h"
  43
  44 #include "rx_spi.h"
  45
  46 #ifdef USE_RX_EXPRESSLRS
  47 #include "rx/rx_spi.h"
  48 #include "rx/expresslrs.h"
  49 #endif
  50
  51 // 13.5 MHz max SPI frequency
  52 #define RX_MAX_SPI_CLK_HZ 13500000
  53 // 6.5 MHz max SPI frequency during startup
  54 #define RX_STARTUP_MAX_SPI_CLK_HZ 6500000
  55
  56 static extDevice_t rxSpiDevice;
  57 static extDevice_t *dev = &rxSpiDevice;
  58
  59 static IO_t extiPin = IO_NONE;
  60 static bool extiLevel = true;
  61 static extiCallbackRec_t rxSpiExtiCallbackRec;
  62
  63 static volatile bool extiHasOccurred = false;
  64 static volatile timeUs_t lastExtiTimeUs = 0;
  65
  66 static uint32_t spiNormalSpeedMhz = RX_MAX_SPI_CLK_HZ;
  67
  68 extDevice_t *rxSpiGetDevice(void)
  69 {
  70     return dev;
  71 }
  72
  73 void rxSpiDevicePreInit(const rxSpiConfig_t *rxSpiConfig)
  74 {
  75     spiPreinitRegister(rxSpiConfig->csnTag, IOCFG_IPU, 1);
  76 }
  77
  78 void rxSpiExtiHandler(extiCallbackRec_t* callback)
  79 {
  80     UNUSED(callback);
  81
  82     lastExtiTimeUs = microsISR();
  83     extiHasOccurred = true;
  84
  85 #ifdef USE_RX_EXPRESSLRS
  86     expressLrsISR(true);
  87 #endif
  88 }
  89
  90 void rxSpiSetNormalSpeedMhz(uint32_t mhz)
  91 {
  92     spiNormalSpeedMhz = mhz;
  93 }
  94
  95 void rxSpiNormalSpeed(void)
  96 {
  97     spiSetClkDivisor(dev, spiCalculateDivider(spiNormalSpeedMhz));
  98 }
  99
 100 void rxSpiStartupSpeed(void)
 101 {
 102     spiSetClkDivisor(dev, spiCalculateDivider(RX_STARTUP_MAX_SPI_CLK_HZ));
 103 }
 104
 105 bool rxSpiDeviceInit(const rxSpiConfig_t *rxSpiConfig)
 106 {
 107     if (!spiSetBusInstance(dev, rxSpiConfig->spibus)) {
 108         return false;
 109     }
 110
 111     const IO_t rxCsPin = IOGetByTag(rxSpiConfig->csnTag);
 112     IOInit(rxCsPin, OWNER_RX_SPI_CS, 0);
 113     IOConfigGPIO(rxCsPin, SPI_IO_CS_CFG);
 114     dev->busType_u.spi.csnPin = rxCsPin;
 115
 116     // Set the clock phase/polarity
 117     spiSetClkPhasePolarity(dev, true);
 118     rxSpiNormalSpeed();
 119
 120     IOHi(rxCsPin);
 121
 122     extiPin = IOGetByTag(rxSpiConfig->extiIoTag);
 123
 124     if (extiPin) {
 125         IOInit(extiPin, OWNER_RX_SPI_EXTI, 0);
 126     }
 127
 128     return true;
 129 }
 130
 131 void rxSpiExtiInit(ioConfig_t rxSpiExtiPinConfig, extiTrigger_t rxSpiExtiPinTrigger)
 132 {
 133     if (extiPin) {
 134         // Use interrupts on the EXTI pin
 135         if (rxSpiExtiPinTrigger == BETAFLIGHT_EXTI_TRIGGER_FALLING) {
 136             extiLevel = false;
 137         }
 138
 139         EXTIHandlerInit(&rxSpiExtiCallbackRec, rxSpiExtiHandler);
 140         EXTIConfig(extiPin, &rxSpiExtiCallbackRec, NVIC_PRIO_RX_INT_EXTI, rxSpiExtiPinConfig, rxSpiExtiPinTrigger);
 141         EXTIEnable(extiPin);
 142
 143         // Check that we've not missed the rising edge on the interrupt line
 144         if (rxSpiGetExtiState()) {
 145             rxSpiExtiHandler(NULL);
 146         }
 147     }
 148 }
 149
 150 void rxSpiDmaEnable(bool enable)
 151 {
 152     spiDmaEnable(dev, enable);
 153 }
 154
 155 uint8_t rxSpiTransferByte(uint8_t data)
 156 {
 157     return spiReadWrite(dev, data);
 158 }
 159
 160 void rxSpiWriteByte(uint8_t data)
 161 {
 162     spiWrite(dev, data);
 163 }
 164
 165 void rxSpiWriteCommand(uint8_t command, uint8_t data)
 166 {
 167     spiWriteReg(dev, command, data);
 168 }
 169
 170 void rxSpiWriteCommandMulti(uint8_t command, const uint8_t *data, uint8_t length)
 171 {
 172     spiWriteRegBuf(dev, command, (uint8_t *)data, length);
 173 }
 174
 175 uint8_t rxSpiReadCommand(uint8_t command, uint8_t data)
 176 {
 177     UNUSED(data);
 178     return spiReadReg(dev, command);
 179 }
 180
 181 void rxSpiReadCommandMulti(uint8_t command, uint8_t commandData, uint8_t *retData, uint8_t length)
 182 {
 183     UNUSED(commandData);
 184     spiReadRegBuf(dev, command, retData, length);
 185 }
 186
 187 bool rxSpiExtiConfigured(void)
 188 {
 189     return extiPin != IO_NONE;
 190 }
 191
 192 bool rxSpiGetExtiState(void)
 193 {
 194     return IORead(extiPin);
 195 }
 196
 197 bool rxSpiPollExti(void)
 198 {
 199     return extiHasOccurred;
 200 }
 201
 202 void rxSpiResetExti(void)
 203 {
 204     extiHasOccurred = false;
 205 }
 206
 207 timeUs_t rxSpiGetLastExtiTimeUs(void)
 208 {
 209     return lastExtiTimeUs;
 210 }
 211
 212 bool rxSpiIsBusy(void)
 213 {
 214     return spiIsBusy(dev);
 215 }
 216
 217 void rxSpiTransferCommandMulti(uint8_t *data, uint8_t length)
 218 {
 219     spiReadWriteBuf(dev, data, data, length);
 220 }
 221
 222 #endif