drv_usart.c 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2021-08-15 Jonas first version
  9. */
  10. #include <board.h>
  11. #include "drv_usart.h"
  12. #ifdef RT_USING_SERIAL
  13. #if !defined(BSP_USING_UART1) && !defined(BSP_USING_UART2)
  14. #error "Please define at least one BSP_USING_UARTx"
  15. /* this driver can be disabled at menuconfig -> RT-Thread Components -> Device Drivers */
  16. #endif
  17. struct hk32_usart
  18. {
  19. char *name;
  20. USART_TypeDef *usartx;
  21. IRQn_Type irqn;
  22. struct rt_serial_device serial;
  23. };
  24. enum
  25. {
  26. #ifdef BSP_USING_UART1
  27. USART1_INDEX,
  28. #endif
  29. #ifdef BSP_USING_UART2
  30. USART2_INDEX,
  31. #endif
  32. };
  33. static struct hk32_usart usart_config[] =
  34. {
  35. #ifdef BSP_USING_UART1
  36. {
  37. "uart1",
  38. USART1,
  39. USART1_IRQn,
  40. },
  41. #endif
  42. #ifdef BSP_USING_UART2
  43. {
  44. "uart2",
  45. USART2,
  46. USART2_IRQn,
  47. },
  48. #endif
  49. };
  50. static rt_err_t hk32_configure(struct rt_serial_device *serial,
  51. struct serial_configure *cfg)
  52. {
  53. struct hk32_usart *usart_instance = (struct hk32_usart *) serial->parent.user_data;
  54. USART_InitTypeDef USART_InitStructure;
  55. RT_ASSERT(serial != RT_NULL);
  56. RT_ASSERT(cfg != RT_NULL);
  57. RT_ASSERT(usart_instance != RT_NULL);
  58. hk32_msp_usart_init((void *)usart_instance->usartx);
  59. USART_StructInit(&USART_InitStructure);
  60. USART_DeInit(usart_instance->usartx);
  61. USART_InitStructure.USART_BaudRate = cfg->baud_rate;
  62. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  63. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  64. switch (cfg->data_bits)
  65. {
  66. case DATA_BITS_8:
  67. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  68. break;
  69. case DATA_BITS_9:
  70. USART_InitStructure.USART_WordLength = USART_WordLength_9b;
  71. break;
  72. default:
  73. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  74. break;
  75. }
  76. switch (cfg->stop_bits)
  77. {
  78. case STOP_BITS_1:
  79. USART_InitStructure.USART_StopBits = USART_StopBits_1;
  80. break;
  81. case STOP_BITS_2:
  82. USART_InitStructure.USART_StopBits = USART_StopBits_2;
  83. break;
  84. default:
  85. USART_InitStructure.USART_StopBits = USART_StopBits_1;
  86. break;
  87. }
  88. switch (cfg->parity)
  89. {
  90. case PARITY_NONE:
  91. USART_InitStructure.USART_Parity = USART_Parity_No;
  92. break;
  93. case PARITY_ODD:
  94. USART_InitStructure.USART_Parity = USART_Parity_Odd;
  95. break;
  96. case PARITY_EVEN:
  97. USART_InitStructure.USART_Parity = USART_Parity_Even;
  98. break;
  99. default:
  100. USART_InitStructure.USART_Parity = USART_Parity_No;
  101. break;
  102. }
  103. USART_Init(usart_instance->usartx, &USART_InitStructure);
  104. USART_Cmd(usart_instance->usartx, ENABLE);
  105. return RT_EOK;
  106. }
  107. static rt_err_t hk32_control(struct rt_serial_device *serial, int cmd,
  108. void *arg)
  109. {
  110. struct hk32_usart *usart;
  111. NVIC_InitTypeDef NVIC_InitStruct;
  112. RT_ASSERT(serial != RT_NULL);
  113. usart = (struct hk32_usart *) serial->parent.user_data;
  114. RT_ASSERT(usart != RT_NULL);
  115. NVIC_InitStruct.NVIC_IRQChannel = usart->irqn;
  116. NVIC_InitStruct.NVIC_IRQChannelPriority = 2;
  117. switch (cmd)
  118. {
  119. case RT_DEVICE_CTRL_CLR_INT:
  120. NVIC_InitStruct.NVIC_IRQChannelCmd = DISABLE;
  121. NVIC_Init(&NVIC_InitStruct);
  122. USART_ITConfig(usart->usartx, USART_IT_RXNE, DISABLE);
  123. break;
  124. case RT_DEVICE_CTRL_SET_INT:
  125. NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
  126. NVIC_Init(&NVIC_InitStruct);
  127. USART_ITConfig(usart->usartx, USART_IT_RXNE, ENABLE);
  128. break;
  129. }
  130. return RT_EOK;
  131. }
  132. static int hk32_putc(struct rt_serial_device *serial, char ch)
  133. {
  134. struct hk32_usart *usart;
  135. RT_ASSERT(serial != RT_NULL);
  136. usart = (struct hk32_usart *) serial->parent.user_data;
  137. RT_ASSERT(usart != RT_NULL);
  138. USART_SendData(usart->usartx, (uint8_t) ch);
  139. while (USART_GetFlagStatus(usart->usartx, USART_FLAG_TXE) == RESET);
  140. return 1;
  141. }
  142. static int hk32_getc(struct rt_serial_device *serial)
  143. {
  144. int ch;
  145. struct hk32_usart *usart;
  146. RT_ASSERT(serial != RT_NULL);
  147. usart = (struct hk32_usart *) serial->parent.user_data;
  148. RT_ASSERT(usart != RT_NULL);
  149. ch = -1;
  150. if (RESET != USART_GetFlagStatus(usart->usartx, USART_FLAG_RXNE))
  151. {
  152. ch = USART_ReceiveData(usart->usartx) & 0xff;
  153. }
  154. return ch;
  155. }
  156. static const struct rt_uart_ops hk32_usart_ops =
  157. {
  158. hk32_configure,
  159. hk32_control,
  160. hk32_putc,
  161. hk32_getc,
  162. RT_NULL
  163. };
  164. static void usart_isr(struct rt_serial_device *serial)
  165. {
  166. struct hk32_usart *usart_instance;
  167. RT_ASSERT(serial != RT_NULL);
  168. usart_instance = (struct hk32_usart *) serial->parent.user_data;
  169. RT_ASSERT(usart_instance != RT_NULL);
  170. if ((USART_GetITStatus(usart_instance->usartx, USART_IT_RXNE) != RESET) \
  171. && (RESET != USART_GetFlagStatus(usart_instance->usartx, USART_FLAG_RXNE)))
  172. {
  173. rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
  174. USART_ClearITPendingBit(usart_instance->usartx, USART_IT_RXNE);
  175. USART_ClearFlag(usart_instance->usartx, USART_FLAG_RXNE);
  176. }
  177. else
  178. {
  179. if (USART_GetFlagStatus(usart_instance->usartx, USART_FLAG_CTS) != RESET)
  180. {
  181. USART_ClearFlag(usart_instance->usartx, USART_FLAG_CTS);
  182. }
  183. if (USART_GetFlagStatus(usart_instance->usartx, USART_FLAG_TC) != RESET)
  184. {
  185. USART_ClearFlag(usart_instance->usartx, USART_FLAG_TC);
  186. }
  187. }
  188. }
  189. #ifdef BSP_USING_UART1
  190. void USART1_IRQHandler(void)
  191. {
  192. rt_interrupt_enter();
  193. usart_isr(&usart_config[USART1_INDEX].serial);
  194. rt_interrupt_leave();
  195. }
  196. #endif
  197. #ifdef BSP_USING_UART2
  198. void USART2_IRQHandler(void)
  199. {
  200. rt_interrupt_enter();
  201. usart_isr(&usart_config[USART2_INDEX].serial);
  202. rt_interrupt_leave();
  203. }
  204. #endif
  205. int rt_hw_usart_init(void)
  206. {
  207. rt_size_t obj_num;
  208. int index;
  209. obj_num = sizeof(usart_config) / sizeof(struct hk32_usart);
  210. struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
  211. rt_err_t result = 0;
  212. for (index = 0; index < obj_num; index++)
  213. {
  214. usart_config[index].serial.ops = &hk32_usart_ops;
  215. usart_config[index].serial.config = config;
  216. /* register UART device */
  217. result = rt_hw_serial_register(&usart_config[index].serial,
  218. usart_config[index].name,
  219. RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX
  220. | RT_DEVICE_FLAG_INT_TX, &usart_config[index]);
  221. RT_ASSERT(result == RT_EOK);
  222. }
  223. return result;
  224. }
  225. INIT_BOARD_EXPORT(rt_hw_usart_init);
  226. #endif /* BSP_USING_SERIAL */