src/main/drivers/serial_uart_stm32f10x.c

   1 /*
   2  * This file is part of Cleanflight.
   3  *
   4  * Cleanflight is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * Cleanflight is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with Cleanflight.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /*
  19  * Authors:
  20  * Dominic Clifton/Hydra - Various cleanups for Cleanflight
  21  * Bill Nesbitt - Code from AutoQuad
  22  * Hamasaki/Timecop - Initial baseflight code
  23 */
  24
  25 #include <stdbool.h>
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28
  29 #include "platform.h"
  30
  31 #include "system.h"
  32 #include "gpio.h"
  33 #include "nvic.h"
  34
  35 #include "serial.h"
  36 #include "serial_uart.h"
  37 #include "serial_uart_impl.h"
  38
  39 #ifdef USE_USART1
  40 static uartPort_t uartPort1;
  41 #endif
  42
  43 #ifdef USE_USART2
  44 static uartPort_t uartPort2;
  45 #endif
  46
  47 #ifdef USE_USART3
  48 static uartPort_t uartPort3;
  49 #endif
  50
  51 // Using RX DMA disables the use of receive callbacks
  52 #define USE_USART1_RX_DMA
  53
  54 #if defined(CC3D) // FIXME move board specific code to target.h files.
  55 #undef USE_USART1_RX_DMA
  56 #endif
  57
  58 void usartIrqCallback(uartPort_t *s)
  59 {
  60     uint16_t SR = s->USARTx->SR;
  61
  62     if (SR & USART_FLAG_RXNE && !s->rxDMAChannel) {
  63         // If we registered a callback, pass crap there
  64         if (s->port.callback) {
  65             s->port.callback(s->USARTx->DR);
  66         } else {
  67             s->port.rxBuffer[s->port.rxBufferHead++] = s->USARTx->DR;
  68             if (s->port.rxBufferHead >= s->port.rxBufferSize) {
  69                 s->port.rxBufferHead = 0;
  70             }
  71         }
  72     }
  73     if (SR & USART_FLAG_TXE) {
  74         if (s->port.txBufferTail != s->port.txBufferHead) {
  75             s->USARTx->DR = s->port.txBuffer[s->port.txBufferTail++];
  76             if (s->port.txBufferTail >= s->port.txBufferSize) {
  77                 s->port.txBufferTail = 0;
  78             }
  79         } else {
  80             USART_ITConfig(s->USARTx, USART_IT_TXE, DISABLE);
  81         }
  82     }
  83 }
  84
  85 #ifdef USE_USART1
  86 // USART1 - Telemetry (RX/TX by DMA)
  87 uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode)
  88 {
  89     uartPort_t *s;
  90     static volatile uint8_t rx1Buffer[UART1_RX_BUFFER_SIZE];
  91     static volatile uint8_t tx1Buffer[UART1_TX_BUFFER_SIZE];
  92     gpio_config_t gpio;
  93     NVIC_InitTypeDef NVIC_InitStructure;
  94
  95     s = &uartPort1;
  96     s->port.vTable = uartVTable;
  97
  98     s->port.baudRate = baudRate;
  99
 100     s->port.rxBuffer = rx1Buffer;
 101     s->port.txBuffer = tx1Buffer;
 102     s->port.rxBufferSize = UART1_RX_BUFFER_SIZE;
 103     s->port.txBufferSize = UART1_TX_BUFFER_SIZE;
 104
 105     s->USARTx = USART1;
 106
 107
 108 #ifdef USE_USART1_RX_DMA
 109     s->rxDMAChannel = DMA1_Channel5;
 110     s->rxDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->DR;
 111 #endif
 112     s->txDMAChannel = DMA1_Channel4;
 113     s->txDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->DR;
 114
 115     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
 116     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
 117
 118     // USART1_TX    PA9
 119     // USART1_RX    PA10
 120     gpio.speed = Speed_2MHz;
 121     gpio.pin = Pin_9;
 122     gpio.mode = Mode_AF_PP;
 123     if (mode & MODE_TX)
 124         gpioInit(GPIOA, &gpio);
 125     gpio.mode = Mode_AF_OD;
 126     if (mode & MODE_BIDIR)
 127         gpioInit(GPIOA, &gpio);
 128     gpio.pin = Pin_10;
 129     gpio.mode = Mode_IPU;
 130     if (mode & MODE_RX)
 131         gpioInit(GPIOA, &gpio);
 132
 133     // DMA TX Interrupt
 134     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
 135     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART1_TXDMA);
 136     NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART1_TXDMA);
 137     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
 138     NVIC_Init(&NVIC_InitStructure);
 139
 140 #ifndef USE_USART1_RX_DMA
 141     // RX/TX Interrupt
 142     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
 143     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART1);
 144     NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART1);
 145     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
 146     NVIC_Init(&NVIC_InitStructure);
 147 #endif
 148
 149     return s;
 150 }
 151
 152
 153 // USART1 Tx DMA Handler
 154 void DMA1_Channel4_IRQHandler(void)
 155 {
 156     uartPort_t *s = &uartPort1;
 157     DMA_ClearITPendingBit(DMA1_IT_TC4);
 158     DMA_Cmd(s->txDMAChannel, DISABLE);
 159
 160     if (s->port.txBufferHead != s->port.txBufferTail)
 161         uartStartTxDMA(s);
 162     else
 163         s->txDMAEmpty = true;
 164 }
 165
 166 // USART1 Rx/Tx IRQ Handler
 167 void USART1_IRQHandler(void)
 168 {
 169     uartPort_t *s = &uartPort1;
 170     usartIrqCallback(s);
 171 }
 172
 173 #endif
 174
 175 #ifdef USE_USART2
 176 // USART2 - GPS or Spektrum or ?? (RX + TX by IRQ)
 177 uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode)
 178 {
 179     uartPort_t *s;
 180     static volatile uint8_t rx2Buffer[UART2_RX_BUFFER_SIZE];
 181     static volatile uint8_t tx2Buffer[UART2_TX_BUFFER_SIZE];
 182     gpio_config_t gpio;
 183     NVIC_InitTypeDef NVIC_InitStructure;
 184
 185     s = &uartPort2;
 186     s->port.vTable = uartVTable;
 187
 188     s->port.baudRate = baudRate;
 189
 190     s->port.rxBufferSize = UART2_RX_BUFFER_SIZE;
 191     s->port.txBufferSize = UART2_TX_BUFFER_SIZE;
 192     s->port.rxBuffer = rx2Buffer;
 193     s->port.txBuffer = tx2Buffer;
 194
 195     s->USARTx = USART2;
 196
 197     s->txDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->DR;
 198     s->rxDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->DR;
 199
 200     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
 201     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
 202
 203     // USART2_TX    PA2
 204     // USART2_RX    PA3
 205     gpio.speed = Speed_2MHz;
 206     gpio.pin = Pin_2;
 207     gpio.mode = Mode_AF_PP;
 208     if (mode & MODE_TX)
 209         gpioInit(GPIOA, &gpio);
 210     gpio.mode = Mode_AF_OD;
 211     if (mode & MODE_BIDIR)
 212         gpioInit(GPIOA, &gpio);
 213     gpio.pin = Pin_3;
 214     gpio.mode = Mode_IPU;
 215     if (mode & MODE_RX)
 216         gpioInit(GPIOA, &gpio);
 217
 218     // RX/TX Interrupt
 219     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
 220     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART2);
 221     NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART2);
 222     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
 223     NVIC_Init(&NVIC_InitStructure);
 224
 225     return s;
 226 }
 227
 228
 229 // USART2 Rx/Tx IRQ Handler
 230 void USART2_IRQHandler(void)
 231 {
 232     uartPort_t *s = &uartPort2;
 233     usartIrqCallback(s);
 234 }
 235
 236 #endif
 237
 238 #ifdef USE_USART3
 239 // USART3
 240 uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode)
 241 {
 242     uartPort_t *s;
 243     static volatile uint8_t rx3Buffer[UART3_RX_BUFFER_SIZE];
 244     static volatile uint8_t tx3Buffer[UART3_TX_BUFFER_SIZE];
 245     gpio_config_t gpio;
 246     NVIC_InitTypeDef NVIC_InitStructure;
 247
 248     s = &uartPort3;
 249     s->port.vTable = uartVTable;
 250
 251     s->port.baudRate = baudRate;
 252
 253     s->port.rxBuffer = rx3Buffer;
 254     s->port.txBuffer = tx3Buffer;
 255     s->port.rxBufferSize = UART3_RX_BUFFER_SIZE;
 256     s->port.txBufferSize = UART3_TX_BUFFER_SIZE;
 257
 258     s->USARTx = USART3;
 259
 260     s->txDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->DR;
 261     s->rxDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->DR;
 262
 263 #ifdef USART3_APB1_PERIPHERALS
 264     RCC_APB1PeriphClockCmd(USART3_APB1_PERIPHERALS, ENABLE);
 265 #endif
 266 #ifdef USART3_APB2_PERIPHERALS
 267     RCC_APB2PeriphClockCmd(USART3_APB2_PERIPHERALS, ENABLE);
 268 #endif
 269
 270     gpio.speed = Speed_2MHz;
 271     gpio.pin = USART3_TX_PIN;
 272     gpio.mode = Mode_AF_PP;
 273     if (mode & MODE_TX)
 274         gpioInit(USART3_GPIO, &gpio);
 275     gpio.mode = Mode_AF_OD;
 276     if (mode & MODE_BIDIR)
 277         gpioInit(USART3_GPIO, &gpio);
 278     gpio.pin = USART3_RX_PIN;
 279     gpio.mode = Mode_IPU;
 280     if (mode & MODE_RX)
 281         gpioInit(USART3_GPIO, &gpio);
 282
 283     // RX/TX Interrupt
 284     NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
 285     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART3);
 286     NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART3);
 287     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
 288     NVIC_Init(&NVIC_InitStructure);
 289
 290     return s;
 291 }
 292
 293 // USART2 Rx/Tx IRQ Handler
 294 void USART3_IRQHandler(void)
 295 {
 296     uartPort_t *s = &uartPort3;
 297     usartIrqCallback(s);
 298 }
 299 #endif