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