drv_usart.c 46 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448
  1. /*
  2. * Copyright (c) 2006-2018, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2018-10-30 SummerGift first version
  9. */
  10. #include "drv_common.h"
  11. #include "uart_config.h"
  12. #include "board.h"
  13. #ifdef RT_USING_SERIAL
  14. #include <rtdevice.h>
  15. #if (defined(SOC_SERIES_STM32L0) || defined(SOC_SERIES_STM32H7)) && defined(RT_SERIAL_USING_DMA)
  16. #error "The STM32L0 and STM32H7 devices DO NOT support UART DMA feature."
  17. #elif defined(RT_SERIAL_USING_DMA)
  18. #include "dma_config.h"
  19. #endif
  20. //#define DRV_DEBUG
  21. #define DBG_TAG "drv.usart"
  22. #ifdef DRV_DEBUG
  23. #define DBG_LVL DBG_LOG
  24. #else
  25. #define DBG_LVL DBG_INFO
  26. #endif /* DRV_DEBUG */
  27. #include <rtdbg.h>
  28. #if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32L4) \
  29. || defined(SOC_SERIES_STM32L0) || defined(SOC_SERIES_STM32L1) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32G4)
  30. #define DMA_INSTANCE_TYPE DMA_Channel_TypeDef
  31. #elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32H7)
  32. #define DMA_INSTANCE_TYPE DMA_Stream_TypeDef
  33. #endif /* defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32L4) */
  34. #if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F2) \
  35. || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32L0) || defined(SOC_SERIES_STM32L1) \
  36. || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32G4)
  37. #define UART_INSTANCE_CLEAR_FUNCTION __HAL_UART_CLEAR_FLAG
  38. #elif defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32H7)
  39. #define UART_INSTANCE_CLEAR_FUNCTION __HAL_UART_CLEAR_IT
  40. #endif
  41. #ifdef RT_SERIAL_USING_DMA
  42. /* -------------------------- DMA config -------------------------- */
  43. #if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32L0) \
  44. || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32G4)
  45. #define DMA_INSTANCE_TYPE DMA_Channel_TypeDef
  46. #elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)\
  47. || defined(SOC_SERIES_STM32H7)
  48. #define DMA_INSTANCE_TYPE DMA_Stream_TypeDef
  49. #endif /* defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32L4) */
  50. struct dma_config {
  51. DMA_INSTANCE_TYPE *Instance;
  52. rt_uint32_t dma_rcc;
  53. IRQn_Type dma_irq;
  54. #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)
  55. rt_uint32_t channel;
  56. #endif
  57. #if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32G4)
  58. rt_uint32_t request;
  59. #endif
  60. };
  61. #endif
  62. /* stm32 config class */
  63. struct stm32_uart_config
  64. {
  65. const char *name;
  66. USART_TypeDef *Instance;
  67. IRQn_Type irq_type;
  68. #ifdef RT_SERIAL_USING_DMA
  69. struct dma_config *dma_rx;
  70. struct dma_config *dma_tx;
  71. #endif
  72. GPIO_TypeDef *tx_port;
  73. GPIO_TypeDef *rx_port;
  74. rt_uint32_t tx_pin;
  75. rt_uint32_t rx_pin;
  76. };
  77. /* stm32 uart dirver class */
  78. struct stm32_uart
  79. {
  80. UART_HandleTypeDef handle;
  81. struct stm32_uart_config *config;
  82. #ifdef RT_SERIAL_USING_DMA
  83. struct
  84. {
  85. DMA_HandleTypeDef handle;
  86. rt_size_t last_index;
  87. } dma_rx;
  88. struct
  89. {
  90. DMA_HandleTypeDef handle;
  91. } dma_tx;
  92. #endif
  93. rt_uint16_t uart_dma_flag;
  94. struct rt_serial_device serial;
  95. };
  96. #if !defined(BSP_USING_UART1) && !defined(BSP_USING_UART2) && !defined(BSP_USING_UART3) && \
  97. !defined(BSP_USING_UART4) && !defined(BSP_USING_UART5) && !defined(BSP_USING_UART6) && \
  98. !defined(BSP_USING_UART7) && !defined(BSP_USING_UART8) && !defined(BSP_USING_LPUART1)
  99. #error "Please define at least one BSP_USING_UARTx"
  100. /* this driver can be disabled at menuconfig -> RT-Thread Components -> Device Drivers */
  101. #endif
  102. #ifdef RT_SERIAL_USING_DMA
  103. static void stm32_dma_config(struct rt_serial_device *serial, rt_ubase_t flag);
  104. #endif
  105. enum
  106. {
  107. #ifdef BSP_USING_UART1
  108. UART1_INDEX,
  109. #endif
  110. #ifdef BSP_USING_UART2
  111. UART2_INDEX,
  112. #endif
  113. #ifdef BSP_USING_UART3
  114. UART3_INDEX,
  115. #endif
  116. #ifdef BSP_USING_UART4
  117. UART4_INDEX,
  118. #endif
  119. #ifdef BSP_USING_UART5
  120. UART5_INDEX,
  121. #endif
  122. #ifdef BSP_USING_UART6
  123. UART6_INDEX,
  124. #endif
  125. #ifdef BSP_USING_UART7
  126. UART7_INDEX,
  127. #endif
  128. #ifdef BSP_USING_UART8
  129. UART8_INDEX,
  130. #endif
  131. #ifdef BSP_USING_LPUART1
  132. LPUART1_INDEX,
  133. #endif
  134. };
  135. static struct stm32_uart_config uart_config[] =
  136. {
  137. #ifdef BSP_USING_UART1
  138. UART1_CONFIG,
  139. #endif
  140. #ifdef BSP_USING_UART2
  141. UART2_CONFIG,
  142. #endif
  143. #ifdef BSP_USING_UART3
  144. UART3_CONFIG,
  145. #endif
  146. #ifdef BSP_USING_UART4
  147. UART4_CONFIG,
  148. #endif
  149. #ifdef BSP_USING_UART5
  150. UART5_CONFIG,
  151. #endif
  152. #ifdef BSP_USING_UART6
  153. UART6_CONFIG,
  154. #endif
  155. #ifdef BSP_USING_UART7
  156. UART7_CONFIG,
  157. #endif
  158. #ifdef BSP_USING_UART8
  159. UART8_CONFIG,
  160. #endif
  161. #ifdef BSP_USING_LPUART1
  162. LPUART1_CONFIG,
  163. #endif
  164. };
  165. static rt_err_t stm32_uart_clk_enable(struct stm32_uart_config *config)
  166. {
  167. /* uart clock enable */
  168. switch ((uint32_t)config->Instance)
  169. {
  170. #ifdef BSP_USING_UART1
  171. case (uint32_t)USART1:
  172. __HAL_RCC_USART1_CLK_ENABLE();
  173. break;
  174. #endif /* BSP_USING_UART1 */
  175. #ifdef BSP_USING_UART2
  176. case (uint32_t)USART2:
  177. __HAL_RCC_USART2_CLK_ENABLE();
  178. break;
  179. #endif /* BSP_USING_UART2 */
  180. #ifdef BSP_USING_UART3
  181. case (uint32_t)USART3:
  182. __HAL_RCC_USART3_CLK_ENABLE();
  183. break;
  184. #endif /* BSP_USING_UART3 */
  185. #ifdef BSP_USING_UART4
  186. #if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32L0) || \
  187. defined(SOC_SERIES_STM32G0)
  188. case (uint32_t)USART4:
  189. __HAL_RCC_USART4_CLK_ENABLE();
  190. #else
  191. case (uint32_t)UART4:
  192. __HAL_RCC_UART4_CLK_ENABLE();
  193. #endif
  194. break;
  195. #endif /* BSP_USING_UART4 */
  196. #ifdef BSP_USING_UART5
  197. #if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32L0) || \
  198. defined(SOC_SERIES_STM32G0)
  199. case (uint32_t)USART5:
  200. __HAL_RCC_USART5_CLK_ENABLE();
  201. #else
  202. case (uint32_t)UART5:
  203. __HAL_RCC_UART5_CLK_ENABLE();
  204. #endif
  205. break;
  206. #endif /* BSP_USING_UART5 */
  207. #ifdef BSP_USING_UART6
  208. case (uint32_t)USART6:
  209. __HAL_RCC_USART6_CLK_ENABLE();
  210. break;
  211. #endif /* BSP_USING_UART6 */
  212. #ifdef BSP_USING_UART7
  213. #if defined(SOC_SERIES_STM32F0)
  214. case (uint32_t)USART7:
  215. __HAL_RCC_USART7_CLK_ENABLE();
  216. #else
  217. case (uint32_t)UART7:
  218. __HAL_RCC_UART7_CLK_ENABLE();
  219. #endif
  220. break;
  221. #endif /* BSP_USING_UART7 */
  222. #ifdef BSP_USING_UART8
  223. #if defined(SOC_SERIES_STM32F0)
  224. case (uint32_t)USART8:
  225. __HAL_RCC_USART8_CLK_ENABLE();
  226. #else
  227. case (uint32_t)UART8:
  228. __HAL_RCC_UART8_CLK_ENABLE();
  229. #endif
  230. break;
  231. #endif /* BSP_USING_UART8 */
  232. #ifdef BSP_USING_LPUART1
  233. case (uint32_t)LPUART1:
  234. __HAL_RCC_LPUART1_CLK_ENABLE();
  235. break;
  236. #endif /* BSP_USING_LPUART1 */
  237. default:
  238. return -RT_ERROR;
  239. }
  240. return RT_EOK;
  241. }
  242. static rt_err_t stm32_gpio_clk_enable(GPIO_TypeDef *gpiox)
  243. {
  244. /* check the parameters */
  245. RT_ASSERT(IS_GPIO_ALL_INSTANCE(gpiox));
  246. /* gpio ports clock enable */
  247. switch ((uint32_t)gpiox)
  248. {
  249. #if defined(__HAL_RCC_GPIOA_CLK_ENABLE)
  250. case (uint32_t)GPIOA:
  251. __HAL_RCC_GPIOA_CLK_ENABLE();
  252. break;
  253. #endif
  254. #if defined(__HAL_RCC_GPIOB_CLK_ENABLE)
  255. case (uint32_t)GPIOB:
  256. __HAL_RCC_GPIOB_CLK_ENABLE();
  257. break;
  258. #endif
  259. #if defined(__HAL_RCC_GPIOC_CLK_ENABLE)
  260. case (uint32_t)GPIOC:
  261. __HAL_RCC_GPIOC_CLK_ENABLE();
  262. break;
  263. #endif
  264. #if defined(__HAL_RCC_GPIOD_CLK_ENABLE)
  265. case (uint32_t)GPIOD:
  266. __HAL_RCC_GPIOD_CLK_ENABLE();
  267. break;
  268. #endif
  269. #if defined(__HAL_RCC_GPIOE_CLK_ENABLE)
  270. case (uint32_t)GPIOE:
  271. __HAL_RCC_GPIOE_CLK_ENABLE();
  272. break;
  273. #endif
  274. #if defined(__HAL_RCC_GPIOF_CLK_ENABLE)
  275. case (uint32_t)GPIOF:
  276. __HAL_RCC_GPIOF_CLK_ENABLE();
  277. break;
  278. #endif
  279. #if defined(__HAL_RCC_GPIOG_CLK_ENABLE)
  280. case (uint32_t)GPIOG:
  281. __HAL_RCC_GPIOG_CLK_ENABLE();
  282. break;
  283. #endif
  284. #if defined(__HAL_RCC_GPIOH_CLK_ENABLE)
  285. case (uint32_t)GPIOH:
  286. __HAL_RCC_GPIOH_CLK_ENABLE();
  287. break;
  288. #endif
  289. #if defined(__HAL_RCC_GPIOI_CLK_ENABLE)
  290. case (uint32_t)GPIOI:
  291. __HAL_RCC_GPIOI_CLK_ENABLE();
  292. break;
  293. #endif
  294. #if defined(__HAL_RCC_GPIOJ_CLK_ENABLE)
  295. case (uint32_t)GPIOJ:
  296. __HAL_RCC_GPIOJ_CLK_ENABLE();
  297. break;
  298. #endif
  299. #if defined(__HAL_RCC_GPIOK_CLK_ENABLE)
  300. case (uint32_t)GPIOK:
  301. __HAL_RCC_GPIOK_CLK_ENABLE();
  302. break;
  303. #endif
  304. default:
  305. return -RT_ERROR;
  306. }
  307. return RT_EOK;
  308. }
  309. static uint16_t stm32_get_pin(GPIO_TypeDef *pin_port, rt_uint32_t pin_num)
  310. {
  311. return (uint16_t)((16 * (((rt_base_t)pin_port - (rt_base_t)GPIOA_BASE)/(0x0400UL))) + (__rt_ffs(pin_num) - 1));
  312. }
  313. static rt_err_t stm32_gpio_configure(struct stm32_uart_config *config)
  314. {
  315. rt_uint16_t tx_pin_num = 0, rx_pin_num = 0;
  316. int rx_index = 0, tx_index = 0, index = 0;
  317. int uart_num = 0;
  318. rt_bool_t uart_is_remap = 0;
  319. struct gpio_uart_remap {
  320. /* index get by GET_PIN */
  321. rt_uint16_t pin_index;
  322. /* -1: not uart, 1: uart1, 2: uart2 ... */
  323. rt_int8_t normal_uart;
  324. /* -1: not uart, 1: uart1, 2: uart2 ... */
  325. rt_int8_t remap_uart;
  326. };
  327. static const struct gpio_uart_remap uart_remaps[] =
  328. {
  329. /* usart1 configure */
  330. { .pin_index = GET_PIN(A, 9), .normal_uart = 1, .remap_uart = -1 },
  331. { .pin_index = GET_PIN(A, 10), .normal_uart = 1, .remap_uart = -1 },
  332. { .pin_index = GET_PIN(B, 6), .normal_uart = -1, .remap_uart = 1 },
  333. { .pin_index = GET_PIN(B, 7), .normal_uart = -1, .remap_uart = 1 },
  334. /* usart2 configure */
  335. { .pin_index = GET_PIN(A, 2), .normal_uart = 2, .remap_uart = -1 },
  336. { .pin_index = GET_PIN(A, 3), .normal_uart = 2, .remap_uart = -1 },
  337. { .pin_index = GET_PIN(D, 5), .normal_uart = -1, .remap_uart = 2 },
  338. { .pin_index = GET_PIN(D, 6), .normal_uart = -1, .remap_uart = 2 },
  339. /* usart3 configure */
  340. { .pin_index = GET_PIN(B, 10), .normal_uart = 3, .remap_uart = -1 },
  341. { .pin_index = GET_PIN(B, 11), .normal_uart = 3, .remap_uart = -1 },
  342. { .pin_index = GET_PIN(D, 8), .normal_uart = -1, .remap_uart = 3 },
  343. { .pin_index = GET_PIN(D, 9), .normal_uart = -1, .remap_uart = 3 },
  344. { .pin_index = GET_PIN(C, 10), .normal_uart = 4, .remap_uart = 3 },
  345. { .pin_index = GET_PIN(C, 11), .normal_uart = 4, .remap_uart = 3 },
  346. };
  347. /* get tx/rx pin index */
  348. tx_pin_num = stm32_get_pin(config->tx_port, config->tx_pin);
  349. rx_pin_num = stm32_get_pin(config->rx_port, config->rx_pin);
  350. for (index = 0; index < sizeof(uart_remaps) / sizeof(struct gpio_uart_remap); index++)
  351. {
  352. if (uart_remaps[index].pin_index == tx_pin_num)
  353. {
  354. tx_index = index;
  355. }
  356. else if (uart_remaps[index].pin_index == rx_pin_num)
  357. {
  358. rx_index = index;
  359. }
  360. }
  361. /* check tx/rx pin remap information */
  362. RT_ASSERT(uart_remaps[tx_index].normal_uart == uart_remaps[rx_index].normal_uart);
  363. RT_ASSERT(uart_remaps[tx_index].remap_uart == uart_remaps[rx_index].remap_uart);
  364. uart_num = config->name[4] - '0';
  365. uart_is_remap = uart_remaps[tx_index].remap_uart == uart_num ? RT_TRUE : RT_FALSE;
  366. {
  367. GPIO_InitTypeDef GPIO_InitStruct = {0};
  368. /* gpio ports clock enable */
  369. stm32_gpio_clk_enable(config->tx_port);
  370. if (config->tx_port != config->rx_port)
  371. {
  372. stm32_gpio_clk_enable(config->rx_port);
  373. }
  374. /* tx pin initialize */
  375. GPIO_InitStruct.Pin = config->tx_pin;
  376. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  377. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  378. HAL_GPIO_Init(config->tx_port, &GPIO_InitStruct);
  379. /* rx pin initialize */
  380. GPIO_InitStruct.Pin = config->rx_pin;
  381. GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  382. GPIO_InitStruct.Pull = GPIO_NOPULL;
  383. HAL_GPIO_Init(config->rx_port, &GPIO_InitStruct);
  384. /* enable the remapping of usart alternate */
  385. if (uart_is_remap)
  386. {
  387. __HAL_RCC_AFIO_CLK_ENABLE();
  388. switch (uart_num)
  389. {
  390. case 1:
  391. __HAL_AFIO_REMAP_USART1_ENABLE();
  392. break;
  393. case 2:
  394. __HAL_AFIO_REMAP_USART2_ENABLE();
  395. break;
  396. case 3:
  397. if (uart_remaps[tx_index].normal_uart < 0)
  398. __HAL_AFIO_REMAP_USART3_ENABLE();
  399. else
  400. __HAL_AFIO_REMAP_USART3_PARTIAL();
  401. break;
  402. default:
  403. RT_ASSERT(0);
  404. }
  405. }
  406. }
  407. return RT_EOK;
  408. }
  409. static struct stm32_uart uart_obj[sizeof(uart_config) / sizeof(uart_config[0])] = {0};
  410. static rt_err_t stm32_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
  411. {
  412. struct stm32_uart *uart;
  413. RT_ASSERT(serial != RT_NULL);
  414. RT_ASSERT(cfg != RT_NULL);
  415. uart = rt_container_of(serial, struct stm32_uart, serial);
  416. /* uart clock enable */
  417. stm32_uart_clk_enable(uart->config);
  418. /* uart gpio clock enable and gpio pin init */
  419. stm32_gpio_configure(uart->config);
  420. uart->handle.Instance = uart->config->Instance;
  421. uart->handle.Init.BaudRate = cfg->baud_rate;
  422. uart->handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  423. uart->handle.Init.Mode = UART_MODE_TX_RX;
  424. uart->handle.Init.OverSampling = UART_OVERSAMPLING_16;
  425. switch (cfg->data_bits)
  426. {
  427. case DATA_BITS_8:
  428. uart->handle.Init.WordLength = UART_WORDLENGTH_8B;
  429. break;
  430. case DATA_BITS_9:
  431. uart->handle.Init.WordLength = UART_WORDLENGTH_9B;
  432. break;
  433. default:
  434. uart->handle.Init.WordLength = UART_WORDLENGTH_8B;
  435. break;
  436. }
  437. switch (cfg->stop_bits)
  438. {
  439. case STOP_BITS_1:
  440. uart->handle.Init.StopBits = UART_STOPBITS_1;
  441. break;
  442. case STOP_BITS_2:
  443. uart->handle.Init.StopBits = UART_STOPBITS_2;
  444. break;
  445. default:
  446. uart->handle.Init.StopBits = UART_STOPBITS_1;
  447. break;
  448. }
  449. switch (cfg->parity)
  450. {
  451. case PARITY_NONE:
  452. uart->handle.Init.Parity = UART_PARITY_NONE;
  453. break;
  454. case PARITY_ODD:
  455. uart->handle.Init.Parity = UART_PARITY_ODD;
  456. break;
  457. case PARITY_EVEN:
  458. uart->handle.Init.Parity = UART_PARITY_EVEN;
  459. break;
  460. default:
  461. uart->handle.Init.Parity = UART_PARITY_NONE;
  462. break;
  463. }
  464. if (HAL_UART_Init(&uart->handle) != HAL_OK)
  465. {
  466. return -RT_ERROR;
  467. }
  468. return RT_EOK;
  469. }
  470. static rt_err_t stm32_control(struct rt_serial_device *serial, int cmd, void *arg)
  471. {
  472. struct stm32_uart *uart;
  473. #ifdef RT_SERIAL_USING_DMA
  474. rt_ubase_t ctrl_arg = (rt_ubase_t)arg;
  475. #endif
  476. RT_ASSERT(serial != RT_NULL);
  477. uart = rt_container_of(serial, struct stm32_uart, serial);
  478. switch (cmd)
  479. {
  480. /* disable interrupt */
  481. case RT_DEVICE_CTRL_CLR_INT:
  482. /* disable rx irq */
  483. NVIC_DisableIRQ(uart->config->irq_type);
  484. /* disable interrupt */
  485. __HAL_UART_DISABLE_IT(&(uart->handle), UART_IT_RXNE);
  486. #ifdef RT_SERIAL_USING_DMA
  487. /* DMA 接收模式下必须同时停掉 DMA 通道/IDLE 中断:
  488. * 框架 rt_serial_close() 调用本命令后即 rt_free(rx_fifo)(serial.c:753-757),
  489. * 若 DMA 仍指向该缓冲,下一字节到达就会经 dma_isr() 写入/记账到已释放内存
  490. * (堆破坏或 HardFault)。现有 close 路径(RTU 断电/OTA)靠外设 FORCE_RESET
  491. * 兜底,这里补上驱动自身防护,任何 close 路径都安全。 */
  492. if (ctrl_arg == RT_DEVICE_FLAG_DMA_RX)
  493. {
  494. HAL_UART_DMAStop(&(uart->handle));
  495. __HAL_UART_DISABLE_IT(&(uart->handle), UART_IT_IDLE);
  496. if (uart->config->dma_rx != RT_NULL)
  497. {
  498. HAL_NVIC_DisableIRQ(uart->config->dma_rx->dma_irq);
  499. }
  500. }
  501. #endif
  502. break;
  503. /* enable interrupt */
  504. case RT_DEVICE_CTRL_SET_INT:
  505. /* enable rx irq */
  506. NVIC_EnableIRQ(uart->config->irq_type);
  507. /* enable interrupt */
  508. __HAL_UART_ENABLE_IT(&(uart->handle), UART_IT_RXNE);
  509. break;
  510. #ifdef RT_SERIAL_USING_DMA
  511. case RT_DEVICE_CTRL_CONFIG:
  512. stm32_dma_config(serial, ctrl_arg);
  513. break;
  514. #endif
  515. }
  516. return RT_EOK;
  517. }
  518. static int stm32_putc(struct rt_serial_device *serial, char c)
  519. {
  520. struct stm32_uart *uart;
  521. RT_ASSERT(serial != RT_NULL);
  522. uart = rt_container_of(serial, struct stm32_uart, serial);
  523. UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TC);
  524. #if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32F0) \
  525. || defined(SOC_SERIES_STM32L0) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32H7) \
  526. || defined(SOC_SERIES_STM32G4)
  527. uart->handle.Instance->TDR = c;
  528. #else
  529. uart->handle.Instance->DR = c;
  530. #endif
  531. while (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) == RESET);
  532. return 1;
  533. }
  534. static int stm32_getc(struct rt_serial_device *serial)
  535. {
  536. int ch;
  537. struct stm32_uart *uart;
  538. RT_ASSERT(serial != RT_NULL);
  539. uart = rt_container_of(serial, struct stm32_uart, serial);
  540. ch = -1;
  541. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_RXNE) != RESET)
  542. {
  543. #if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32F0) \
  544. || defined(SOC_SERIES_STM32L0) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32H7) \
  545. || defined(SOC_SERIES_STM32G4)
  546. ch = uart->handle.Instance->RDR & 0xff;
  547. #else
  548. ch = uart->handle.Instance->DR & 0xff;
  549. #endif
  550. }
  551. return ch;
  552. }
  553. static rt_size_t stm32_dma_transmit(struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size, int direction)
  554. {
  555. struct stm32_uart *uart;
  556. RT_ASSERT(serial != RT_NULL);
  557. uart = rt_container_of(serial, struct stm32_uart, serial);
  558. if (size == 0)
  559. {
  560. return 0;
  561. }
  562. if (RT_SERIAL_DMA_TX == direction)
  563. {
  564. if (HAL_UART_Transmit_DMA(&uart->handle, buf, size) == HAL_OK)
  565. {
  566. return size;
  567. }
  568. else
  569. {
  570. return 0;
  571. }
  572. }
  573. return 0;
  574. }
  575. static const struct rt_uart_ops stm32_uart_ops =
  576. {
  577. .configure = stm32_configure,
  578. .control = stm32_control,
  579. .putc = stm32_putc,
  580. .getc = stm32_getc,
  581. .dma_transmit = stm32_dma_transmit
  582. };
  583. /* [BZY FIX] 判断 DMA 接收通道是否真的在运行。
  584. * DMA 停用(或 HAL_UART_Receive_DMA 失败、从未武装)时 CNDTR 会读回 0,
  585. * 若仍用它推算"已收多少字节",会得到"整个缓冲区都已收满"的错误结论,
  586. * 进而写坏 rx_fifo 的 put_index / is_full —— 应用侧表现为读出 bufsz 字节全 0,
  587. * 同时掩盖"接收链路已死"这一真实故障。 */
  588. #define STM32_DMA_RX_RUNNING(uart) \
  589. ((((uart)->dma_rx.handle.Instance) != RT_NULL) && \
  590. (((((uart)->dma_rx.handle.Instance)->CCR) & DMA_CCR_EN) != 0U))
  591. /**
  592. * Uart common interrupt process. This need add to uart ISR.
  593. *
  594. * @param serial serial device
  595. */
  596. static void uart_isr(struct rt_serial_device *serial)
  597. {
  598. struct stm32_uart *uart;
  599. #ifdef RT_SERIAL_USING_DMA
  600. rt_size_t recv_total_index, recv_len;
  601. rt_base_t level;
  602. #endif
  603. RT_ASSERT(serial != RT_NULL);
  604. uart = rt_container_of(serial, struct stm32_uart, serial);
  605. /* UART in mode Receiver -------------------------------------------------*/
  606. if ((__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_RXNE) != RESET) &&
  607. (__HAL_UART_GET_IT_SOURCE(&(uart->handle), UART_IT_RXNE) != RESET))
  608. {
  609. rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
  610. }
  611. #ifdef RT_SERIAL_USING_DMA
  612. else if ((uart->uart_dma_flag) && (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_IDLE) != RESET)
  613. && (__HAL_UART_GET_IT_SOURCE(&(uart->handle), UART_IT_IDLE) != RESET))
  614. {
  615. level = rt_hw_interrupt_disable();
  616. /* [BZY FIX] 只有 DMA 通道确实在运行时,CNDTR 才能用来推算已收长度。
  617. * DMA 停用/未成功武装时 CNDTR 读回 0,会被算成"整缓冲区都收到了",
  618. * 进而写坏 rx_fifo 的 put_index/is_full(现象:应用读出 bufsz 字节全 0)。
  619. * 该情形下按"本次无可信新数据"处理,不累加长度。*/
  620. if (STM32_DMA_RX_RUNNING(uart))
  621. {
  622. recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
  623. /* [BZY FIX] 防回绕:两次采样之间若 DMA 已绕过缓冲区顶部(TC 未及更新
  624. * last_index),recv_total_index 会小于 last_index,原式无符号减法下溢
  625. * 得到巨大 recv_len,写坏 rx_fifo 的 put_index。此处不推算增量
  626. * (宁少报不误报,与 dma_isr 的保护口径一致),仅同步索引。 */
  627. if (recv_total_index >= uart->dma_rx.last_index)
  628. {
  629. recv_len = recv_total_index - uart->dma_rx.last_index;
  630. }
  631. else
  632. {
  633. recv_len = 0;
  634. }
  635. uart->dma_rx.last_index = recv_total_index;
  636. }
  637. else
  638. {
  639. recv_len = 0;
  640. }
  641. rt_hw_interrupt_enable(level);
  642. if (recv_len)
  643. {
  644. rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
  645. }
  646. __HAL_UART_CLEAR_IDLEFLAG(&uart->handle);
  647. }
  648. else if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) != RESET)
  649. {
  650. if ((serial->parent.open_flag & RT_DEVICE_FLAG_DMA_TX) != 0)
  651. {
  652. HAL_UART_IRQHandler(&(uart->handle));
  653. }
  654. else
  655. {
  656. UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TC);
  657. }
  658. }
  659. #endif
  660. else
  661. {
  662. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_ORE) != RESET)
  663. {
  664. __HAL_UART_CLEAR_OREFLAG(&uart->handle);
  665. }
  666. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_NE) != RESET)
  667. {
  668. __HAL_UART_CLEAR_NEFLAG(&uart->handle);
  669. }
  670. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_FE) != RESET)
  671. {
  672. __HAL_UART_CLEAR_FEFLAG(&uart->handle);
  673. }
  674. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_PE) != RESET)
  675. {
  676. __HAL_UART_CLEAR_PEFLAG(&uart->handle);
  677. }
  678. #if !defined(SOC_SERIES_STM32L4) && !defined(SOC_SERIES_STM32F7) && !defined(SOC_SERIES_STM32F0) \
  679. && !defined(SOC_SERIES_STM32L0) && !defined(SOC_SERIES_STM32G0) && !defined(SOC_SERIES_STM32H7) \
  680. && !defined(SOC_SERIES_STM32G4)
  681. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_LBD) != RESET)
  682. {
  683. UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_LBD);
  684. }
  685. #endif
  686. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_CTS) != RESET)
  687. {
  688. UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_CTS);
  689. }
  690. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TXE) != RESET)
  691. {
  692. UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TXE);
  693. }
  694. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) != RESET)
  695. {
  696. UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TC);
  697. }
  698. if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_RXNE) != RESET)
  699. {
  700. UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_RXNE);
  701. }
  702. }
  703. }
  704. #ifdef RT_SERIAL_USING_DMA
  705. static void dma_isr(struct rt_serial_device *serial)
  706. {
  707. struct stm32_uart *uart;
  708. rt_size_t recv_total_index, recv_len;
  709. rt_base_t level;
  710. RT_ASSERT(serial != RT_NULL);
  711. uart = rt_container_of(serial, struct stm32_uart, serial);
  712. if ((__HAL_DMA_GET_IT_SOURCE(&(uart->dma_rx.handle), DMA_IT_TC) != RESET) ||
  713. (__HAL_DMA_GET_IT_SOURCE(&(uart->dma_rx.handle), DMA_IT_HT) != RESET))
  714. {
  715. /* [BZY FIX] DMA 未运行时不推算长度,避免 CNDTR=0 被误算成"整缓冲区已收满"。
  716. * 另:last_index == 0 且 recv_total_index == 0 时,原式会得出
  717. * bufsz - 0 = bufsz(虚报整缓冲区),这也是"读出 2048 字节全 0"的直接来源。*/
  718. if (!STM32_DMA_RX_RUNNING(uart))
  719. {
  720. return;
  721. }
  722. level = rt_hw_interrupt_disable();
  723. recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
  724. if (recv_total_index == 0)
  725. {
  726. recv_len = serial->config.bufsz - uart->dma_rx.last_index;
  727. }
  728. else if (recv_total_index >= uart->dma_rx.last_index)
  729. {
  730. recv_len = recv_total_index - uart->dma_rx.last_index;
  731. }
  732. else
  733. {
  734. /* 索引回绕:本次无法可靠推算增量,交由 IDLE 路径处理,宁少报不误报 */
  735. recv_len = 0;
  736. }
  737. if (recv_len > serial->config.bufsz)
  738. {
  739. recv_len = serial->config.bufsz;
  740. }
  741. uart->dma_rx.last_index = recv_total_index;
  742. rt_hw_interrupt_enable(level);
  743. if (recv_len)
  744. {
  745. rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
  746. }
  747. }
  748. }
  749. #endif
  750. #if defined(BSP_USING_UART1)
  751. void USART1_IRQHandler(void)
  752. {
  753. /* enter interrupt */
  754. rt_interrupt_enter();
  755. uart_isr(&(uart_obj[UART1_INDEX].serial));
  756. /* leave interrupt */
  757. rt_interrupt_leave();
  758. }
  759. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART1_RX_USING_DMA)
  760. void UART1_DMA_RX_IRQHandler(void)
  761. {
  762. /* enter interrupt */
  763. rt_interrupt_enter();
  764. HAL_DMA_IRQHandler(&uart_obj[UART1_INDEX].dma_rx.handle);
  765. /* leave interrupt */
  766. rt_interrupt_leave();
  767. }
  768. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART1_RX_USING_DMA) */
  769. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART1_TX_USING_DMA)
  770. void UART1_DMA_TX_IRQHandler(void)
  771. {
  772. /* enter interrupt */
  773. rt_interrupt_enter();
  774. HAL_DMA_IRQHandler(&uart_obj[UART1_INDEX].dma_tx.handle);
  775. /* leave interrupt */
  776. rt_interrupt_leave();
  777. }
  778. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART1_TX_USING_DMA) */
  779. #endif /* BSP_USING_UART1 */
  780. #if defined(BSP_USING_UART2)
  781. void USART2_IRQHandler(void)
  782. {
  783. /* enter interrupt */
  784. rt_interrupt_enter();
  785. uart_isr(&(uart_obj[UART2_INDEX].serial));
  786. /* leave interrupt */
  787. rt_interrupt_leave();
  788. }
  789. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART2_RX_USING_DMA)
  790. void UART2_DMA_RX_IRQHandler(void)
  791. {
  792. /* enter interrupt */
  793. rt_interrupt_enter();
  794. HAL_DMA_IRQHandler(&uart_obj[UART2_INDEX].dma_rx.handle);
  795. /* leave interrupt */
  796. rt_interrupt_leave();
  797. }
  798. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART2_RX_USING_DMA) */
  799. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART2_TX_USING_DMA)
  800. void UART2_DMA_TX_IRQHandler(void)
  801. {
  802. /* enter interrupt */
  803. rt_interrupt_enter();
  804. HAL_DMA_IRQHandler(&uart_obj[UART2_INDEX].dma_tx.handle);
  805. /* leave interrupt */
  806. rt_interrupt_leave();
  807. }
  808. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART2_TX_USING_DMA) */
  809. #endif /* BSP_USING_UART2 */
  810. #if defined(BSP_USING_UART3)
  811. void USART3_IRQHandler(void)
  812. {
  813. /* enter interrupt */
  814. rt_interrupt_enter();
  815. uart_isr(&(uart_obj[UART3_INDEX].serial));
  816. /* leave interrupt */
  817. rt_interrupt_leave();
  818. }
  819. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART3_RX_USING_DMA)
  820. void UART3_DMA_RX_IRQHandler(void)
  821. {
  822. /* enter interrupt */
  823. rt_interrupt_enter();
  824. HAL_DMA_IRQHandler(&uart_obj[UART3_INDEX].dma_rx.handle);
  825. /* leave interrupt */
  826. rt_interrupt_leave();
  827. }
  828. #endif /* defined(BSP_UART_USING_DMA_RX) && defined(BSP_UART3_RX_USING_DMA) */
  829. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART3_TX_USING_DMA)
  830. void UART3_DMA_TX_IRQHandler(void)
  831. {
  832. /* enter interrupt */
  833. rt_interrupt_enter();
  834. HAL_DMA_IRQHandler(&uart_obj[UART3_INDEX].dma_tx.handle);
  835. /* leave interrupt */
  836. rt_interrupt_leave();
  837. }
  838. #endif /* defined(BSP_UART_USING_DMA_TX) && defined(BSP_UART3_TX_USING_DMA) */
  839. #endif /* BSP_USING_UART3*/
  840. #if defined(BSP_USING_UART4)
  841. void UART4_IRQHandler(void)
  842. {
  843. /* enter interrupt */
  844. rt_interrupt_enter();
  845. uart_isr(&(uart_obj[UART4_INDEX].serial));
  846. /* leave interrupt */
  847. rt_interrupt_leave();
  848. }
  849. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART4_RX_USING_DMA)
  850. void UART4_DMA_RX_IRQHandler(void)
  851. {
  852. /* enter interrupt */
  853. rt_interrupt_enter();
  854. HAL_DMA_IRQHandler(&uart_obj[UART4_INDEX].dma_rx.handle);
  855. /* leave interrupt */
  856. rt_interrupt_leave();
  857. }
  858. #endif /* defined(BSP_UART_USING_DMA_RX) && defined(BSP_UART4_RX_USING_DMA) */
  859. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART4_TX_USING_DMA)
  860. void UART4_DMA_TX_IRQHandler(void)
  861. {
  862. /* enter interrupt */
  863. rt_interrupt_enter();
  864. HAL_DMA_IRQHandler(&uart_obj[UART4_INDEX].dma_tx.handle);
  865. /* leave interrupt */
  866. rt_interrupt_leave();
  867. }
  868. #endif /* defined(BSP_UART_USING_DMA_TX) && defined(BSP_UART4_TX_USING_DMA) */
  869. #endif /* BSP_USING_UART4*/
  870. #if defined(BSP_USING_UART5)
  871. void UART5_IRQHandler(void)
  872. {
  873. /* enter interrupt */
  874. rt_interrupt_enter();
  875. uart_isr(&(uart_obj[UART5_INDEX].serial));
  876. /* leave interrupt */
  877. rt_interrupt_leave();
  878. }
  879. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART5_RX_USING_DMA)
  880. void UART5_DMA_RX_IRQHandler(void)
  881. {
  882. /* enter interrupt */
  883. rt_interrupt_enter();
  884. HAL_DMA_IRQHandler(&uart_obj[UART5_INDEX].dma_rx.handle);
  885. /* leave interrupt */
  886. rt_interrupt_leave();
  887. }
  888. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART5_RX_USING_DMA) */
  889. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART5_TX_USING_DMA)
  890. void UART5_DMA_TX_IRQHandler(void)
  891. {
  892. /* enter interrupt */
  893. rt_interrupt_enter();
  894. HAL_DMA_IRQHandler(&uart_obj[UART5_INDEX].dma_tx.handle);
  895. /* leave interrupt */
  896. rt_interrupt_leave();
  897. }
  898. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART5_TX_USING_DMA) */
  899. #endif /* BSP_USING_UART5*/
  900. #if defined(BSP_USING_UART6)
  901. void USART6_IRQHandler(void)
  902. {
  903. /* enter interrupt */
  904. rt_interrupt_enter();
  905. uart_isr(&(uart_obj[UART6_INDEX].serial));
  906. /* leave interrupt */
  907. rt_interrupt_leave();
  908. }
  909. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART6_RX_USING_DMA)
  910. void UART6_DMA_RX_IRQHandler(void)
  911. {
  912. /* enter interrupt */
  913. rt_interrupt_enter();
  914. HAL_DMA_IRQHandler(&uart_obj[UART6_INDEX].dma_rx.handle);
  915. /* leave interrupt */
  916. rt_interrupt_leave();
  917. }
  918. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART6_RX_USING_DMA) */
  919. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART6_TX_USING_DMA)
  920. void UART6_DMA_TX_IRQHandler(void)
  921. {
  922. /* enter interrupt */
  923. rt_interrupt_enter();
  924. HAL_DMA_IRQHandler(&uart_obj[UART6_INDEX].dma_tx.handle);
  925. /* leave interrupt */
  926. rt_interrupt_leave();
  927. }
  928. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART6_TX_USING_DMA) */
  929. #endif /* BSP_USING_UART6*/
  930. #if defined(BSP_USING_UART7)
  931. void UART7_IRQHandler(void)
  932. {
  933. /* enter interrupt */
  934. rt_interrupt_enter();
  935. uart_isr(&(uart_obj[UART7_INDEX].serial));
  936. /* leave interrupt */
  937. rt_interrupt_leave();
  938. }
  939. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART7_RX_USING_DMA)
  940. void UART7_DMA_RX_IRQHandler(void)
  941. {
  942. /* enter interrupt */
  943. rt_interrupt_enter();
  944. HAL_DMA_IRQHandler(&uart_obj[UART7_INDEX].dma_rx.handle);
  945. /* leave interrupt */
  946. rt_interrupt_leave();
  947. }
  948. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART7_RX_USING_DMA) */
  949. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART7_TX_USING_DMA)
  950. void UART7_DMA_TX_IRQHandler(void)
  951. {
  952. /* enter interrupt */
  953. rt_interrupt_enter();
  954. HAL_DMA_IRQHandler(&uart_obj[UART7_INDEX].dma_tx.handle);
  955. /* leave interrupt */
  956. rt_interrupt_leave();
  957. }
  958. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART7_TX_USING_DMA) */
  959. #endif /* BSP_USING_UART7*/
  960. #if defined(BSP_USING_UART8)
  961. void UART8_IRQHandler(void)
  962. {
  963. /* enter interrupt */
  964. rt_interrupt_enter();
  965. uart_isr(&(uart_obj[UART8_INDEX].serial));
  966. /* leave interrupt */
  967. rt_interrupt_leave();
  968. }
  969. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART8_RX_USING_DMA)
  970. void UART8_DMA_RX_IRQHandler(void)
  971. {
  972. /* enter interrupt */
  973. rt_interrupt_enter();
  974. HAL_DMA_IRQHandler(&uart_obj[UART8_INDEX].dma_rx.handle);
  975. /* leave interrupt */
  976. rt_interrupt_leave();
  977. }
  978. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART8_RX_USING_DMA) */
  979. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_UART8_TX_USING_DMA)
  980. void UART8_DMA_TX_IRQHandler(void)
  981. {
  982. /* enter interrupt */
  983. rt_interrupt_enter();
  984. HAL_DMA_IRQHandler(&uart_obj[UART8_INDEX].dma_tx.handle);
  985. /* leave interrupt */
  986. rt_interrupt_leave();
  987. }
  988. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_UART8_TX_USING_DMA) */
  989. #endif /* BSP_USING_UART8*/
  990. #if defined(BSP_USING_LPUART1)
  991. void LPUART1_IRQHandler(void)
  992. {
  993. /* enter interrupt */
  994. rt_interrupt_enter();
  995. uart_isr(&(uart_obj[LPUART1_INDEX].serial));
  996. /* leave interrupt */
  997. rt_interrupt_leave();
  998. }
  999. #if defined(RT_SERIAL_USING_DMA) && defined(BSP_LPUART1_RX_USING_DMA)
  1000. void LPUART1_DMA_RX_IRQHandler(void)
  1001. {
  1002. /* enter interrupt */
  1003. rt_interrupt_enter();
  1004. HAL_DMA_IRQHandler(&uart_obj[LPUART1_INDEX].dma_rx.handle);
  1005. /* leave interrupt */
  1006. rt_interrupt_leave();
  1007. }
  1008. #endif /* defined(RT_SERIAL_USING_DMA) && defined(BSP_LPUART1_RX_USING_DMA) */
  1009. #endif /* BSP_USING_LPUART1*/
  1010. #ifdef RT_SERIAL_USING_DMA
  1011. static void stm32_dma_config(struct rt_serial_device *serial, rt_ubase_t flag)
  1012. {
  1013. struct rt_serial_rx_fifo *rx_fifo;
  1014. DMA_HandleTypeDef *DMA_Handle;
  1015. struct dma_config *dma_config;
  1016. struct stm32_uart *uart;
  1017. RT_ASSERT(serial != RT_NULL);
  1018. uart = rt_container_of(serial, struct stm32_uart, serial);
  1019. if (RT_DEVICE_FLAG_DMA_RX == flag)
  1020. {
  1021. DMA_Handle = &uart->dma_rx.handle;
  1022. dma_config = uart->config->dma_rx;
  1023. }
  1024. else if (RT_DEVICE_FLAG_DMA_TX == flag)
  1025. {
  1026. DMA_Handle = &uart->dma_tx.handle;
  1027. dma_config = uart->config->dma_tx;
  1028. }
  1029. LOG_D("%s dma config start", uart->config->name);
  1030. {
  1031. rt_uint32_t tmpreg = 0x00U;
  1032. #if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0) \
  1033. || defined(SOC_SERIES_STM32L0)
  1034. /* enable DMA clock && Delay after an RCC peripheral clock enabling*/
  1035. SET_BIT(RCC->AHBENR, dma_config->dma_rcc);
  1036. tmpreg = READ_BIT(RCC->AHBENR, dma_config->dma_rcc);
  1037. #elif defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) \
  1038. || defined(SOC_SERIES_STM32G4)
  1039. /* enable DMA clock && Delay after an RCC peripheral clock enabling*/
  1040. SET_BIT(RCC->AHB1ENR, dma_config->dma_rcc);
  1041. tmpreg = READ_BIT(RCC->AHB1ENR, dma_config->dma_rcc);
  1042. #if (defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G4)) && defined(DMAMUX1)
  1043. /* enable DMAMUX clock for L4+ and G4 */
  1044. __HAL_RCC_DMAMUX1_CLK_ENABLE();
  1045. #endif
  1046. #endif
  1047. UNUSED(tmpreg); /* To avoid compiler warnings */
  1048. }
  1049. if (RT_DEVICE_FLAG_DMA_RX == flag)
  1050. {
  1051. __HAL_LINKDMA(&(uart->handle), hdmarx, uart->dma_rx.handle);
  1052. }
  1053. else if (RT_DEVICE_FLAG_DMA_TX == flag)
  1054. {
  1055. __HAL_LINKDMA(&(uart->handle), hdmatx, uart->dma_tx.handle);
  1056. }
  1057. #if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32L0)
  1058. DMA_Handle->Instance = dma_config->Instance;
  1059. #elif defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)
  1060. DMA_Handle->Instance = dma_config->Instance;
  1061. DMA_Handle->Init.Channel = dma_config->channel;
  1062. #elif defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32G4)
  1063. DMA_Handle->Instance = dma_config->Instance;
  1064. DMA_Handle->Init.Request = dma_config->request;
  1065. #endif
  1066. DMA_Handle->Init.PeriphInc = DMA_PINC_DISABLE;
  1067. DMA_Handle->Init.MemInc = DMA_MINC_ENABLE;
  1068. DMA_Handle->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  1069. DMA_Handle->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  1070. if (RT_DEVICE_FLAG_DMA_RX == flag)
  1071. {
  1072. DMA_Handle->Init.Direction = DMA_PERIPH_TO_MEMORY;
  1073. DMA_Handle->Init.Mode = DMA_CIRCULAR;
  1074. }
  1075. else if (RT_DEVICE_FLAG_DMA_TX == flag)
  1076. {
  1077. DMA_Handle->Init.Direction = DMA_MEMORY_TO_PERIPH;
  1078. DMA_Handle->Init.Mode = DMA_NORMAL;
  1079. }
  1080. DMA_Handle->Init.Priority = DMA_PRIORITY_MEDIUM;
  1081. #if defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)
  1082. DMA_Handle->Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  1083. #endif
  1084. if (HAL_DMA_DeInit(DMA_Handle) != HAL_OK)
  1085. {
  1086. RT_ASSERT(0);
  1087. }
  1088. if (HAL_DMA_Init(DMA_Handle) != HAL_OK)
  1089. {
  1090. RT_ASSERT(0);
  1091. }
  1092. /* enable interrupt */
  1093. if (flag == RT_DEVICE_FLAG_DMA_RX)
  1094. {
  1095. rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
  1096. /* [BZY FIX] 重新武装 DMA 前必须把 HAL 的接收状态机复位为 READY。
  1097. * 原因:HAL_UART_Receive_DMA() 开头就是
  1098. * if (huart->RxState == HAL_UART_STATE_READY) {...} else return HAL_BUSY;
  1099. * 而 RxState 只由 HAL 自己的接收完成回调复位;本驱动绕开 HAL 接收路径、
  1100. * 自己处理 IDLE 中断,所以 RxState 会永远停在 BUSY_RX ——
  1101. * 第二次调用(即任何 rt_device_close()+rt_device_open() 之后)直接返回
  1102. * HAL_BUSY,DMA 根本没被武装,接收链路永久失效(且下面的 RT_ASSERT 在
  1103. * 未开 RT_DEBUG 时是空操作,失败完全静默)。
  1104. * 受影响场景:RTU 断电重启、屏幕固件升级、串口环回自检等所有 close/open 路径。*/
  1105. uart->handle.RxState = HAL_UART_STATE_READY;
  1106. /* Start DMA transfer */
  1107. if (HAL_UART_Receive_DMA(&(uart->handle), rx_fifo->buffer, serial->config.bufsz) != HAL_OK)
  1108. {
  1109. /* Transfer error in reception process */
  1110. LOG_E("%s HAL_UART_Receive_DMA failed (rx disabled!)", uart->config->name);
  1111. RT_ASSERT(0);
  1112. }
  1113. /* Reset last_index to 0 after reinitializing DMA.
  1114. * Without this, the stale last_index from before rt_device_close()
  1115. * will cause recv_len underflow on the first IDLE interrupt,
  1116. * corrupting the rx_fifo and producing garbled data.
  1117. */
  1118. uart->dma_rx.last_index = 0;
  1119. CLEAR_BIT(uart->handle.Instance->CR3, USART_CR3_EIE);
  1120. __HAL_UART_ENABLE_IT(&(uart->handle), UART_IT_IDLE);
  1121. }
  1122. /* enable irq */
  1123. HAL_NVIC_SetPriority(dma_config->dma_irq, 0, 0);
  1124. HAL_NVIC_EnableIRQ(dma_config->dma_irq);
  1125. HAL_NVIC_SetPriority(uart->config->irq_type, 1, 0);
  1126. HAL_NVIC_EnableIRQ(uart->config->irq_type);
  1127. LOG_D("%s dma %s instance: %x", uart->config->name, flag == RT_DEVICE_FLAG_DMA_RX ? "RX" : "TX", DMA_Handle->Instance);
  1128. LOG_D("%s dma config done", uart->config->name);
  1129. }
  1130. /**
  1131. * @brief UART error callbacks
  1132. * @param huart: UART handle
  1133. * @note This example shows a simple way to report transfer error, and you can
  1134. * add your own implementation.
  1135. * @retval None
  1136. */
  1137. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
  1138. {
  1139. RT_ASSERT(huart != NULL);
  1140. struct stm32_uart *uart = (struct stm32_uart *)huart;
  1141. LOG_D("%s: %s %d\n", __FUNCTION__, uart->config->name, huart->ErrorCode);
  1142. UNUSED(uart);
  1143. }
  1144. /**
  1145. * @brief Rx Transfer completed callback
  1146. * @param huart: UART handle
  1147. * @note This example shows a simple way to report end of DMA Rx transfer, and
  1148. * you can add your own implementation.
  1149. * @retval None
  1150. */
  1151. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  1152. {
  1153. struct stm32_uart *uart;
  1154. RT_ASSERT(huart != NULL);
  1155. uart = (struct stm32_uart *)huart;
  1156. /* DMA 接收缓冲区回绕(TC)时必须把已收到的数据推入 FIFO:
  1157. * 否则在“数据流没有空闲间隔”的场景下,IDLE 中断不触发,
  1158. * 回绕后的 recv_len 计算会下溢,导致接收数据错乱。 */
  1159. dma_isr(&uart->serial);
  1160. }
  1161. /**
  1162. * @brief Rx Half transfer completed callback
  1163. * @param huart: UART handle
  1164. * @note This example shows a simple way to report end of DMA Rx Half transfer,
  1165. * and you can add your own implementation.
  1166. * @retval None
  1167. */
  1168. void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
  1169. {
  1170. struct stm32_uart *uart;
  1171. RT_ASSERT(huart != NULL);
  1172. uart = (struct stm32_uart *)huart;
  1173. /* 半传输中断同样上报增量,避免长时间无 IDLE 时 FIFO 长时间得不到更新 */
  1174. dma_isr(&uart->serial);
  1175. }
  1176. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
  1177. {
  1178. struct stm32_uart *uart;
  1179. RT_ASSERT(huart != NULL);
  1180. uart = (struct stm32_uart *)huart;
  1181. rt_hw_serial_isr(&uart->serial, RT_SERIAL_EVENT_TX_DMADONE);
  1182. }
  1183. #endif /* RT_SERIAL_USING_DMA */
  1184. static void stm32_uart_get_dma_config(void)
  1185. {
  1186. #ifdef BSP_USING_UART1
  1187. uart_obj[UART1_INDEX].uart_dma_flag = 0;
  1188. #ifdef BSP_UART1_RX_USING_DMA
  1189. uart_obj[UART1_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_RX;
  1190. static struct dma_config uart1_dma_rx = UART1_DMA_RX_CONFIG;
  1191. uart_config[UART1_INDEX].dma_rx = &uart1_dma_rx;
  1192. #endif
  1193. #ifdef BSP_UART1_TX_USING_DMA
  1194. uart_obj[UART1_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_TX;
  1195. static struct dma_config uart1_dma_tx = UART1_DMA_TX_CONFIG;
  1196. uart_config[UART1_INDEX].dma_tx = &uart1_dma_tx;
  1197. #endif
  1198. #endif
  1199. #ifdef BSP_USING_UART2
  1200. uart_obj[UART2_INDEX].uart_dma_flag = 0;
  1201. #ifdef BSP_UART2_RX_USING_DMA
  1202. uart_obj[UART2_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_RX;
  1203. static struct dma_config uart2_dma_rx = UART2_DMA_RX_CONFIG;
  1204. uart_config[UART2_INDEX].dma_rx = &uart2_dma_rx;
  1205. #endif
  1206. #ifdef BSP_UART2_TX_USING_DMA
  1207. uart_obj[UART2_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_TX;
  1208. static struct dma_config uart2_dma_tx = UART2_DMA_TX_CONFIG;
  1209. uart_config[UART2_INDEX].dma_tx = &uart2_dma_tx;
  1210. #endif
  1211. #endif
  1212. #ifdef BSP_USING_UART3
  1213. uart_obj[UART3_INDEX].uart_dma_flag = 0;
  1214. #ifdef BSP_UART3_RX_USING_DMA
  1215. uart_obj[UART3_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_RX;
  1216. static struct dma_config uart3_dma_rx = UART3_DMA_RX_CONFIG;
  1217. uart_config[UART3_INDEX].dma_rx = &uart3_dma_rx;
  1218. #endif
  1219. #ifdef BSP_UART3_TX_USING_DMA
  1220. uart_obj[UART3_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_TX;
  1221. static struct dma_config uart3_dma_tx = UART3_DMA_TX_CONFIG;
  1222. uart_config[UART3_INDEX].dma_tx = &uart3_dma_tx;
  1223. #endif
  1224. #endif
  1225. #ifdef BSP_USING_UART4
  1226. uart_obj[UART4_INDEX].uart_dma_flag = 0;
  1227. #ifdef BSP_UART4_RX_USING_DMA
  1228. uart_obj[UART4_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_RX;
  1229. static struct dma_config uart4_dma_rx = UART4_DMA_RX_CONFIG;
  1230. uart_config[UART4_INDEX].dma_rx = &uart4_dma_rx;
  1231. #endif
  1232. #ifdef BSP_UART4_TX_USING_DMA
  1233. uart_obj[UART4_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_TX;
  1234. static struct dma_config uart4_dma_tx = UART4_DMA_TX_CONFIG;
  1235. uart_config[UART4_INDEX].dma_tx = &uart4_dma_tx;
  1236. #endif
  1237. #endif
  1238. #ifdef BSP_USING_UART5
  1239. uart_obj[UART5_INDEX].uart_dma_flag = 0;
  1240. #ifdef BSP_UART5_RX_USING_DMA
  1241. uart_obj[UART5_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_RX;
  1242. static struct dma_config uart5_dma_rx = UART5_DMA_RX_CONFIG;
  1243. uart_config[UART5_INDEX].dma_rx = &uart5_dma_rx;
  1244. #endif
  1245. #ifdef BSP_UART5_TX_USING_DMA
  1246. uart_obj[UART5_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_TX;
  1247. static struct dma_config uart5_dma_tx = UART5_DMA_TX_CONFIG;
  1248. uart_config[UART5_INDEX].dma_tx = &uart5_dma_tx;
  1249. #endif
  1250. #endif
  1251. #ifdef BSP_USING_UART6
  1252. uart_obj[UART6_INDEX].uart_dma_flag = 0;
  1253. #ifdef BSP_UART6_RX_USING_DMA
  1254. uart_obj[UART6_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_RX;
  1255. static struct dma_config uart6_dma_rx = UART6_DMA_RX_CONFIG;
  1256. uart_config[UART6_INDEX].dma_rx = &uart6_dma_rx;
  1257. #endif
  1258. #ifdef BSP_UART6_TX_USING_DMA
  1259. uart_obj[UART6_INDEX].uart_dma_flag |= RT_DEVICE_FLAG_DMA_TX;
  1260. static struct dma_config uart6_dma_tx = UART6_DMA_TX_CONFIG;
  1261. uart_config[UART6_INDEX].dma_tx = &uart6_dma_tx;
  1262. #endif
  1263. #endif
  1264. }
  1265. int rt_hw_usart_init(void)
  1266. {
  1267. rt_size_t obj_num = sizeof(uart_obj) / sizeof(struct stm32_uart);
  1268. struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
  1269. rt_err_t result = 0;
  1270. stm32_uart_get_dma_config();
  1271. for (int i = 0; i < obj_num; i++)
  1272. {
  1273. uart_obj[i].config = &uart_config[i];
  1274. uart_obj[i].serial.ops = &stm32_uart_ops;
  1275. uart_obj[i].serial.config = config;
  1276. /* register UART device */
  1277. result = rt_hw_serial_register(&uart_obj[i].serial, uart_obj[i].config->name,
  1278. RT_DEVICE_FLAG_RDWR
  1279. | RT_DEVICE_FLAG_INT_RX
  1280. | RT_DEVICE_FLAG_INT_TX
  1281. | uart_obj[i].uart_dma_flag
  1282. , NULL);
  1283. RT_ASSERT(result == RT_EOK);
  1284. }
  1285. return result;
  1286. }
  1287. #endif /* RT_USING_SERIAL */