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 // 13.5 MHz max SPI frequency
  47 #define RX_MAX_SPI_CLK_HZ 13500000
  48 // 6.5 MHz max SPI frequency during startup
  49 #define RX_STARTUP_MAX_SPI_CLK_HZ 6500000
  50
  51 static extDevice_t rxSpiDevice;
  52 static extDevice_t *dev = &rxSpiDevice;
  53
  54 static IO_t extiPin = IO_NONE;
  55 static extiCallbackRec_t rxSpiExtiCallbackRec;
  56 static bool extiLevel = true;
  57
  58 static volatile bool extiHasOccurred = false;
  59 static volatile timeUs_t lastExtiTimeUs = 0;
  60
  61 static uint32_t spiNormalSpeedMhz = RX_MAX_SPI_CLK_HZ;
  62
  63 void rxSpiDevicePreInit(const rxSpiConfig_t *rxSpiConfig)
  64 {
  65     spiPreinitRegister(rxSpiConfig->csnTag, IOCFG_IPU, 1);
  66 }
  67
  68 void rxSpiExtiHandler(extiCallbackRec_t* callback)
  69 {
  70     UNUSED(callback);
  71
  72     const timeUs_t extiTimeUs = microsISR();
  73
  74     if (IORead(extiPin) == extiLevel) {
  75         lastExtiTimeUs = extiTimeUs;
  76         extiHasOccurred = true;
  77     }
  78 }
  79
  80 void rxSpiSetNormalSpeedMhz(uint32_t mhz)
  81 {
  82     spiNormalSpeedMhz = mhz;
  83 }
  84
  85 void rxSpiNormalSpeed()
  86 {
  87     spiSetClkDivisor(dev, spiCalculateDivider(spiNormalSpeedMhz));
  88 }
  89
  90 void rxSpiStartupSpeed()
  91 {
  92     spiSetClkDivisor(dev, spiCalculateDivider(RX_STARTUP_MAX_SPI_CLK_HZ));
  93 }
  94
  95 bool rxSpiDeviceInit(const rxSpiConfig_t *rxSpiConfig)
  96 {
  97     if (!spiSetBusInstance(dev, rxSpiConfig->spibus)) {
  98         return false;
  99     }
 100
 101     const IO_t rxCsPin = IOGetByTag(rxSpiConfig->csnTag);
 102     IOInit(rxCsPin, OWNER_RX_SPI_CS, 0);
 103     IOConfigGPIO(rxCsPin, SPI_IO_CS_CFG);
 104     dev->busType_u.spi.csnPin = rxCsPin;
 105
 106     // Set the clock phase/polarity
 107     spiSetClkPhasePolarity(dev, true);
 108     rxSpiNormalSpeed();
 109
 110     IOHi(rxCsPin);
 111
 112     extiPin = IOGetByTag(rxSpiConfig->extiIoTag);
 113
 114     if (extiPin) {
 115         IOInit(extiPin, OWNER_RX_SPI_EXTI, 0);
 116     }
 117
 118     return true;
 119 }
 120
 121 void rxSpiExtiInit(ioConfig_t rxSpiExtiPinConfig, extiTrigger_t rxSpiExtiPinTrigger)
 122 {
 123     if (extiPin) {
 124         if (rxSpiExtiPinTrigger == BETAFLIGHT_EXTI_TRIGGER_FALLING) {
 125             extiLevel = false;
 126         }
 127         EXTIHandlerInit(&rxSpiExtiCallbackRec, rxSpiExtiHandler);
 128         EXTIConfig(extiPin, &rxSpiExtiCallbackRec, NVIC_PRIO_MPU_INT_EXTI, rxSpiExtiPinConfig, rxSpiExtiPinTrigger);
 129         EXTIEnable(extiPin, true);
 130     }
 131 }
 132
 133 void rxSpiDmaEnable(bool enable)
 134 {
 135     spiDmaEnable(dev, enable);
 136 }
 137
 138 uint8_t rxSpiTransferByte(uint8_t data)
 139 {
 140     return spiReadWrite(dev, data);
 141 }
 142
 143 void rxSpiWriteByte(uint8_t data)
 144 {
 145     spiWrite(dev, data);
 146 }
 147
 148 void rxSpiWriteCommand(uint8_t command, uint8_t data)
 149 {
 150     spiWriteReg(dev, command, data);
 151 }
 152
 153 void rxSpiWriteCommandMulti(uint8_t command, const uint8_t *data, uint8_t length)
 154 {
 155     spiWriteRegBuf(dev, command, (uint8_t *)data, length);
 156 }
 157
 158 uint8_t rxSpiReadCommand(uint8_t command, uint8_t data)
 159 {
 160     UNUSED(data);
 161     return spiReadReg(dev, command);
 162 }
 163
 164 void rxSpiReadCommandMulti(uint8_t command, uint8_t commandData, uint8_t *retData, uint8_t length)
 165 {
 166     UNUSED(commandData);
 167     spiReadRegBuf(dev, command, retData, length);
 168 }
 169
 170 bool rxSpiExtiConfigured(void)
 171 {
 172     return extiPin != IO_NONE;
 173 }
 174
 175 bool rxSpiGetExtiState(void)
 176 {
 177     return IORead(extiPin);
 178 }
 179
 180 bool rxSpiPollExti(void)
 181 {
 182     return extiHasOccurred;
 183 }
 184
 185 void rxSpiResetExti(void)
 186 {
 187     extiHasOccurred = false;
 188 }
 189
 190 timeUs_t rxSpiGetLastExtiTimeUs(void)
 191 {
 192     return lastExtiTimeUs;
 193 }
 194
 195 bool rxSpiIsBusy(void)
 196 {
 197     return spiIsBusy(dev);
 198 }
 199
 200 void rxSpiTransferCommandMulti(uint8_t *data, uint8_t length)
 201 {
 202     spiReadWriteBuf(dev, data, data, length);
 203 }
 204
 205 #endif