usart.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393
  1. /*
  2. * File : usart.c
  3. * This file is part of RT-Thread RTOS
  4. * COPYRIGHT (C) 2009, RT-Thread Development Team
  5. *
  6. * The license and distribution terms for this file may be
  7. * found in the file LICENSE in this distribution or at
  8. * http://www.rt-thread.org/license/LICENSE
  9. *
  10. * Change Logs:
  11. * Date Author Notes
  12. * 2009-01-05 Bernard the first version
  13. * 2010-03-29 Bernard remove interrupt Tx and DMA Rx mode
  14. * 2012-02-08 aozima update for F4.
  15. * 2012-07-28 aozima update for ART board.
  16. */
  17. #include "stm32f4xx.h"
  18. #include "usart.h"
  19. #include "board.h"
  20. #include <rtdevice.h>
  21. /* UART GPIO define. */
  22. #define UART1_GPIO_TX GPIO_Pin_6
  23. #define UART1_TX_PIN_SOURCE GPIO_PinSource6
  24. #define UART1_GPIO_RX GPIO_Pin_7
  25. #define UART1_RX_PIN_SOURCE GPIO_PinSource7
  26. #define UART1_GPIO GPIOB
  27. #define UART1_GPIO_RCC RCC_AHB1Periph_GPIOB
  28. #define RCC_APBPeriph_UART1 RCC_APB2Periph_USART1
  29. #define UART1_TX_DMA DMA1_Channel4
  30. #define UART1_RX_DMA DMA1_Channel5
  31. #define UART2_GPIO_TX GPIO_Pin_2
  32. #define UART2_TX_PIN_SOURCE GPIO_PinSource2
  33. #define UART2_GPIO_RX GPIO_Pin_3
  34. #define UART2_RX_PIN_SOURCE GPIO_PinSource3
  35. #define UART2_GPIO GPIOA
  36. #define UART2_GPIO_RCC RCC_AHB1Periph_GPIOA
  37. #define RCC_APBPeriph_UART2 RCC_APB1Periph_USART2
  38. #define UART2_TX_DMA DMA1_Channel4
  39. #define UART2_RX_DMA DMA1_Channel5
  40. #define UART3_GPIO_TX GPIO_Pin_8
  41. #define UART3_TX_PIN_SOURCE GPIO_PinSource8
  42. #define UART3_GPIO_RX GPIO_Pin_9
  43. #define UART3_RX_PIN_SOURCE GPIO_PinSource9
  44. #define UART3_GPIO GPIOD
  45. #define UART3_GPIO_RCC RCC_AHB1Periph_GPIOD
  46. #define RCC_APBPeriph_UART3 RCC_APB1Periph_USART3
  47. #define UART3_TX_DMA DMA1_Stream1
  48. #define UART3_RX_DMA DMA1_Stream3
  49. /* STM32 uart driver */
  50. struct stm32_uart
  51. {
  52. USART_TypeDef *uart_device;
  53. IRQn_Type irq;
  54. };
  55. static rt_err_t stm32_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
  56. {
  57. struct stm32_uart *uart;
  58. USART_InitTypeDef USART_InitStructure;
  59. RT_ASSERT(serial != RT_NULL);
  60. RT_ASSERT(cfg != RT_NULL);
  61. uart = (struct stm32_uart *)serial->parent.user_data;
  62. if (cfg->baud_rate == BAUD_RATE_9600)
  63. USART_InitStructure.USART_BaudRate = 9600;
  64. else if (cfg->baud_rate == BAUD_RATE_115200)
  65. USART_InitStructure.USART_BaudRate = 115200;
  66. if (cfg->data_bits == DATA_BITS_8)
  67. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  68. if (cfg->stop_bits == STOP_BITS_1)
  69. USART_InitStructure.USART_StopBits = USART_StopBits_1;
  70. else if (cfg->stop_bits == STOP_BITS_2)
  71. USART_InitStructure.USART_StopBits = USART_StopBits_2;
  72. USART_InitStructure.USART_Parity = USART_Parity_No;
  73. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  74. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  75. USART_Init(uart->uart_device, &USART_InitStructure);
  76. /* Enable USART */
  77. USART_Cmd(uart->uart_device, ENABLE);
  78. return RT_EOK;
  79. }
  80. static rt_err_t stm32_control(struct rt_serial_device *serial, int cmd, void *arg)
  81. {
  82. struct stm32_uart *uart;
  83. RT_ASSERT(serial != RT_NULL);
  84. uart = (struct stm32_uart *)serial->parent.user_data;
  85. switch (cmd)
  86. {
  87. case RT_DEVICE_CTRL_CLR_INT:
  88. /* disable rx irq */
  89. UART_DISABLE_IRQ(uart->irq);
  90. /* disable interrupt */
  91. USART_ITConfig(uart->uart_device, USART_IT_RXNE, DISABLE);
  92. break;
  93. case RT_DEVICE_CTRL_SET_INT:
  94. /* enable rx irq */
  95. UART_ENABLE_IRQ(uart->irq);
  96. /* enable interrupt */
  97. USART_ITConfig(uart->uart_device, USART_IT_RXNE, ENABLE);
  98. break;
  99. }
  100. return RT_EOK;
  101. }
  102. static int stm32_putc(struct rt_serial_device *serial, char c)
  103. {
  104. struct stm32_uart *uart;
  105. RT_ASSERT(serial != RT_NULL);
  106. uart = (struct stm32_uart *)serial->parent.user_data;
  107. while (!(uart->uart_device->SR & USART_FLAG_TXE));
  108. uart->uart_device->DR = c;
  109. return 1;
  110. }
  111. static int stm32_getc(struct rt_serial_device *serial)
  112. {
  113. int ch;
  114. struct stm32_uart *uart;
  115. RT_ASSERT(serial != RT_NULL);
  116. uart = (struct stm32_uart *)serial->parent.user_data;
  117. ch = -1;
  118. if (uart->uart_device->SR & USART_FLAG_RXNE)
  119. {
  120. ch = uart->uart_device->DR & 0xff;
  121. }
  122. return ch;
  123. }
  124. static const struct rt_uart_ops stm32_uart_ops =
  125. {
  126. stm32_configure,
  127. stm32_control,
  128. stm32_putc,
  129. stm32_getc,
  130. };
  131. #if defined(RT_USING_UART1)
  132. /* UART1 device driver structure */
  133. struct stm32_uart uart1 =
  134. {
  135. USART1,
  136. USART1_IRQn,
  137. };
  138. struct rt_serial_device serial1;
  139. void USART1_IRQHandler(void)
  140. {
  141. struct stm32_uart *uart;
  142. uart = &uart1;
  143. /* enter interrupt */
  144. rt_interrupt_enter();
  145. if (USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET)
  146. {
  147. rt_hw_serial_isr(&serial1, RT_SERIAL_EVENT_RX_IND);
  148. /* clear interrupt */
  149. USART_ClearITPendingBit(uart->uart_device, USART_IT_RXNE);
  150. }
  151. if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET)
  152. {
  153. /* clear interrupt */
  154. USART_ClearITPendingBit(uart->uart_device, USART_IT_TC);
  155. }
  156. /* leave interrupt */
  157. rt_interrupt_leave();
  158. }
  159. #endif /* RT_USING_UART1 */
  160. #if defined(RT_USING_UART2)
  161. /* UART2 device driver structure */
  162. struct stm32_uart uart2 =
  163. {
  164. USART2,
  165. USART2_IRQn,
  166. };
  167. struct rt_serial_device serial2;
  168. void USART2_IRQHandler(void)
  169. {
  170. struct stm32_uart *uart;
  171. uart = &uart2;
  172. /* enter interrupt */
  173. rt_interrupt_enter();
  174. if (USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET)
  175. {
  176. rt_hw_serial_isr(&serial2, RT_SERIAL_EVENT_RX_IND);
  177. /* clear interrupt */
  178. USART_ClearITPendingBit(uart->uart_device, USART_IT_RXNE);
  179. }
  180. if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET)
  181. {
  182. /* clear interrupt */
  183. USART_ClearITPendingBit(uart->uart_device, USART_IT_TC);
  184. }
  185. /* leave interrupt */
  186. rt_interrupt_leave();
  187. }
  188. #endif /* RT_USING_UART2 */
  189. #if defined(RT_USING_UART3)
  190. /* UART3 device driver structure */
  191. struct stm32_uart uart3 =
  192. {
  193. USART3,
  194. USART3_IRQn,
  195. };
  196. struct rt_serial_device serial3;
  197. void USART3_IRQHandler(void)
  198. {
  199. struct stm32_uart *uart;
  200. uart = &uart3;
  201. /* enter interrupt */
  202. rt_interrupt_enter();
  203. if (USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET)
  204. {
  205. rt_hw_serial_isr(&serial3, RT_SERIAL_EVENT_RX_IND);
  206. /* clear interrupt */
  207. USART_ClearITPendingBit(uart->uart_device, USART_IT_RXNE);
  208. }
  209. if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET)
  210. {
  211. /* clear interrupt */
  212. USART_ClearITPendingBit(uart->uart_device, USART_IT_TC);
  213. }
  214. /* leave interrupt */
  215. rt_interrupt_leave();
  216. }
  217. #endif /* RT_USING_UART3 */
  218. static void RCC_Configuration(void)
  219. {
  220. #ifdef RT_USING_UART1
  221. /* Enable UART1 GPIO clocks */
  222. RCC_AHB1PeriphClockCmd(UART1_GPIO_RCC, ENABLE);
  223. /* Enable UART1 clock */
  224. RCC_APB2PeriphClockCmd(RCC_APBPeriph_UART1, ENABLE);
  225. #endif /* RT_USING_UART1 */
  226. #ifdef RT_USING_UART2
  227. /* Enable UART2 GPIO clocks */
  228. RCC_AHB1PeriphClockCmd(UART2_GPIO_RCC, ENABLE);
  229. /* Enable UART2 clock */
  230. RCC_APB1PeriphClockCmd(RCC_APBPeriph_UART2, ENABLE);
  231. #endif /* RT_USING_UART1 */
  232. #ifdef RT_USING_UART3
  233. /* Enable UART3 GPIO clocks */
  234. RCC_AHB1PeriphClockCmd(UART3_GPIO_RCC, ENABLE);
  235. /* Enable UART3 clock */
  236. RCC_APB1PeriphClockCmd(RCC_APBPeriph_UART3, ENABLE);
  237. #endif /* RT_USING_UART3 */
  238. }
  239. static void GPIO_Configuration(void)
  240. {
  241. GPIO_InitTypeDef GPIO_InitStructure;
  242. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  243. GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  244. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  245. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  246. #ifdef RT_USING_UART1
  247. /* Configure USART1 Rx/tx PIN */
  248. GPIO_InitStructure.GPIO_Pin = UART1_GPIO_RX | UART1_GPIO_TX;
  249. GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
  250. /* Connect alternate function */
  251. GPIO_PinAFConfig(UART1_GPIO, UART1_TX_PIN_SOURCE, GPIO_AF_USART1);
  252. GPIO_PinAFConfig(UART1_GPIO, UART1_RX_PIN_SOURCE, GPIO_AF_USART1);
  253. #endif /* RT_USING_UART1 */
  254. #ifdef RT_USING_UART2
  255. /* Configure USART2 Rx/tx PIN */
  256. GPIO_InitStructure.GPIO_Pin = UART2_GPIO_RX | UART2_GPIO_TX;
  257. GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
  258. /* Connect alternate function */
  259. GPIO_PinAFConfig(UART2_GPIO, UART2_TX_PIN_SOURCE, GPIO_AF_USART2);
  260. GPIO_PinAFConfig(UART2_GPIO, UART2_RX_PIN_SOURCE, GPIO_AF_USART2);
  261. #endif /* RT_USING_UART2 */
  262. #ifdef RT_USING_UART3
  263. /* Configure USART3 Rx/tx PIN */
  264. GPIO_InitStructure.GPIO_Pin = UART3_GPIO_TX | UART3_GPIO_RX;
  265. GPIO_Init(UART3_GPIO, &GPIO_InitStructure);
  266. /* Connect alternate function */
  267. GPIO_PinAFConfig(UART3_GPIO, UART3_TX_PIN_SOURCE, GPIO_AF_USART3);
  268. GPIO_PinAFConfig(UART3_GPIO, UART3_RX_PIN_SOURCE, GPIO_AF_USART3);
  269. #endif /* RT_USING_UART3 */
  270. }
  271. static void NVIC_Configuration(struct stm32_uart *uart)
  272. {
  273. NVIC_InitTypeDef NVIC_InitStructure;
  274. /* Enable the USART1 Interrupt */
  275. NVIC_InitStructure.NVIC_IRQChannel = uart->irq;
  276. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
  277. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  278. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  279. NVIC_Init(&NVIC_InitStructure);
  280. }
  281. int stm32_hw_usart_init(void)
  282. {
  283. struct stm32_uart *uart;
  284. struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
  285. RCC_Configuration();
  286. GPIO_Configuration();
  287. #ifdef RT_USING_UART1
  288. uart = &uart1;
  289. serial1.ops = &stm32_uart_ops;
  290. serial1.config = config;
  291. NVIC_Configuration(&uart1);
  292. /* register UART1 device */
  293. rt_hw_serial_register(&serial1,
  294. "uart1",
  295. RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
  296. uart);
  297. #endif /* RT_USING_UART1 */
  298. #ifdef RT_USING_UART2
  299. uart = &uart2;
  300. serial2.ops = &stm32_uart_ops;
  301. serial2.config = config;
  302. NVIC_Configuration(&uart2);
  303. /* register UART1 device */
  304. rt_hw_serial_register(&serial2,
  305. "uart2",
  306. RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
  307. uart);
  308. #endif /* RT_USING_UART2 */
  309. #ifdef RT_USING_UART3
  310. uart = &uart3;
  311. serial3.ops = &stm32_uart_ops;
  312. serial3.config = config;
  313. NVIC_Configuration(&uart3);
  314. /* register UART3 device */
  315. rt_hw_serial_register(&serial3,
  316. "uart3",
  317. RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
  318. uart);
  319. #endif /* RT_USING_UART3 */
  320. return 0;
  321. }
  322. INIT_BOARD_EXPORT(stm32_hw_usart_init);