drv_can.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883
  1. /*
  2. * Copyright (c) 2006-2023, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2023-03-30 luobeihai first version
  9. */
  10. #include <board.h>
  11. #ifdef RT_USING_CAN
  12. #if defined(BSP_USING_CAN1) || defined(BSP_USING_CAN2)
  13. #include "drv_can.h"
  14. #define LOG_TAG "drv_can"
  15. #include <drv_log.h>
  16. #ifdef BSP_USING_CAN1
  17. static struct apm32_can drv_can1 =
  18. {
  19. .name = "can1",
  20. .CANx = CAN1,
  21. };
  22. #endif
  23. #ifdef BSP_USING_CAN2
  24. static struct apm32_can drv_can2 =
  25. {
  26. .name = "can2",
  27. .CANx = CAN2,
  28. };
  29. #endif
  30. /* baud calculation example: PCLK1 / ((timeSegment1 + timeSegment2 + 1) * prescaler) = 36 / ((1 + 8 + 3) * 3) = 1MHz */
  31. #if defined (SOC_SERIES_APM32F1) || defined (SOC_SERIES_APM32E1) || defined (SOC_SERIES_APM32S1) /* APB1 36MHz(max) */
  32. static const struct apm32_baud_rate_tab can_baud_rate_tab[] =
  33. {
  34. APM32_CAN_BAUD_DEF(CAN1MBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 3),
  35. APM32_CAN_BAUD_DEF(CAN800kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_5, CAN_TIME_SEGMENT2_3, 5),
  36. APM32_CAN_BAUD_DEF(CAN500kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 6),
  37. APM32_CAN_BAUD_DEF(CAN250kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 12),
  38. APM32_CAN_BAUD_DEF(CAN125kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 24),
  39. APM32_CAN_BAUD_DEF(CAN100kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 30),
  40. APM32_CAN_BAUD_DEF(CAN50kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 60),
  41. APM32_CAN_BAUD_DEF(CAN20kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 150),
  42. APM32_CAN_BAUD_DEF(CAN10kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_3, 300),
  43. };
  44. #elif defined (SOC_SERIES_APM32F4) /* APB1 42MHz(max) */
  45. static const struct apm32_baud_rate_tab can_baud_rate_tab[] =
  46. {
  47. APM32_CAN_BAUD_DEF(CAN1MBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 3),
  48. APM32_CAN_BAUD_DEF(CAN800kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_8, CAN_TIME_SEGMENT2_4, 4),
  49. APM32_CAN_BAUD_DEF(CAN500kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 6),
  50. APM32_CAN_BAUD_DEF(CAN250kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 12),
  51. APM32_CAN_BAUD_DEF(CAN125kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 24),
  52. APM32_CAN_BAUD_DEF(CAN100kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 30),
  53. APM32_CAN_BAUD_DEF(CAN50kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 60),
  54. APM32_CAN_BAUD_DEF(CAN20kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 150),
  55. APM32_CAN_BAUD_DEF(CAN10kBaud, CAN_SJW_1, CAN_TIME_SEGMENT1_9, CAN_TIME_SEGMENT2_4, 300),
  56. };
  57. #endif
  58. static rt_uint32_t get_can_baud_index(rt_uint32_t baud)
  59. {
  60. rt_uint32_t len, index;
  61. len = sizeof(can_baud_rate_tab) / sizeof(can_baud_rate_tab[0]);
  62. for (index = 0; index < len; index++)
  63. {
  64. if (can_baud_rate_tab[index].baud_rate == baud)
  65. return index;
  66. }
  67. return 0; /* default baud is CAN1MBaud */
  68. }
  69. static rt_err_t apm32_can_config(struct rt_can_device *can, struct can_configure *cfg)
  70. {
  71. struct apm32_can *drv_can;
  72. rt_uint32_t baud_index;
  73. RT_ASSERT(can);
  74. RT_ASSERT(cfg);
  75. drv_can = (struct apm32_can *)can->parent.user_data;
  76. RT_ASSERT(drv_can);
  77. /* init can gpio and enable can clock */
  78. extern void apm32_msp_can_init(void *Instance);
  79. apm32_msp_can_init(drv_can->CANx);
  80. CAN_ConfigStructInit(&drv_can->can_init);
  81. drv_can->can_init.autoBusOffManage = ENABLE;
  82. drv_can->can_init.autoWakeUpMode = DISABLE;
  83. drv_can->can_init.nonAutoRetran = DISABLE;
  84. drv_can->can_init.rxFIFOLockMode = DISABLE;
  85. drv_can->can_init.txFIFOPriority = ENABLE;
  86. /* can mode config */
  87. switch (cfg->mode)
  88. {
  89. case RT_CAN_MODE_NORMAL:
  90. drv_can->can_init.mode = CAN_MODE_NORMAL;
  91. break;
  92. case RT_CAN_MODE_LISEN:
  93. drv_can->can_init.mode = CAN_MODE_SILENT;
  94. break;
  95. case RT_CAN_MODE_LOOPBACK:
  96. drv_can->can_init.mode = CAN_MODE_LOOPBACK;
  97. break;
  98. case RT_CAN_MODE_LOOPBACKANLISEN:
  99. drv_can->can_init.mode = CAN_MODE_SILENT_LOOPBACK;
  100. break;
  101. default:
  102. drv_can->can_init.mode = CAN_MODE_NORMAL;
  103. break;
  104. }
  105. /* can baud config */
  106. baud_index = get_can_baud_index(cfg->baud_rate);
  107. drv_can->can_init.syncJumpWidth = can_baud_rate_tab[baud_index].syncJumpWidth;
  108. drv_can->can_init.timeSegment1 = can_baud_rate_tab[baud_index].timeSegment1;
  109. drv_can->can_init.timeSegment2 = can_baud_rate_tab[baud_index].timeSegment2;
  110. drv_can->can_init.prescaler = can_baud_rate_tab[baud_index].prescaler;
  111. /* init can */
  112. if (CAN_Config(drv_can->CANx, &drv_can->can_init) != SUCCESS)
  113. {
  114. LOG_D("Can init error");
  115. return -RT_ERROR;
  116. }
  117. /* default filter config */
  118. #if defined(SOC_SERIES_APM32F4) || defined(APM32F10X_CL)
  119. CAN_ConfigFilter(&drv_can->FilterConfig);
  120. #else
  121. CAN_ConfigFilter(drv_can->CANx, &drv_can->FilterConfig);
  122. #endif
  123. return RT_EOK;
  124. }
  125. static rt_err_t apm32_can_control(struct rt_can_device *can, int cmd, void *arg)
  126. {
  127. rt_uint32_t argval;
  128. struct apm32_can *drv_can;
  129. struct rt_can_filter_config *filter_cfg;
  130. RT_ASSERT(can != RT_NULL);
  131. drv_can = (struct apm32_can *)can->parent.user_data;
  132. RT_ASSERT(drv_can != RT_NULL);
  133. switch (cmd)
  134. {
  135. case RT_DEVICE_CTRL_CLR_INT:
  136. argval = (rt_uint32_t) arg;
  137. if (argval == RT_DEVICE_FLAG_INT_RX)
  138. {
  139. if (CAN1 == drv_can->CANx)
  140. {
  141. NVIC_DisableIRQRequest(CAN1_RX0_IRQn);
  142. NVIC_DisableIRQRequest(CAN1_RX1_IRQn);
  143. }
  144. #ifdef BSP_USING_CAN2
  145. if (CAN2 == drv_can->CANx)
  146. {
  147. NVIC_DisableIRQRequest(CAN2_RX0_IRQn);
  148. NVIC_DisableIRQRequest(CAN2_RX1_IRQn);
  149. }
  150. #endif
  151. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_F0MP);
  152. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_F0FULL);
  153. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_F0OVR);
  154. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_F1MP);
  155. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_F1FULL);
  156. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_F1OVR);
  157. }
  158. else if (argval == RT_DEVICE_FLAG_INT_TX)
  159. {
  160. if (CAN1 == drv_can->CANx)
  161. {
  162. NVIC_DisableIRQRequest(CAN1_TX_IRQn);
  163. }
  164. #ifdef BSP_USING_CAN2
  165. if (CAN2 == drv_can->CANx)
  166. {
  167. NVIC_DisableIRQRequest(CAN2_TX_IRQn);
  168. }
  169. #endif
  170. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_TXME);
  171. }
  172. else if (argval == RT_DEVICE_CAN_INT_ERR)
  173. {
  174. if (CAN1 == drv_can->CANx)
  175. {
  176. NVIC_DisableIRQRequest(CAN1_SCE_IRQn);
  177. }
  178. #ifdef BSP_USING_CAN2
  179. if (CAN2 == drv_can->CANx)
  180. {
  181. NVIC_DisableIRQRequest(CAN2_SCE_IRQn);
  182. }
  183. #endif
  184. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_ERRW);
  185. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_ERRP);
  186. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_BOF);
  187. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_LEC);
  188. CAN_DisableInterrupt(drv_can->CANx, CAN_INT_ERR);
  189. }
  190. break;
  191. case RT_DEVICE_CTRL_SET_INT:
  192. argval = (rt_uint32_t) arg;
  193. if (argval == RT_DEVICE_FLAG_INT_RX)
  194. {
  195. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_F0MP);
  196. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_F0FULL);
  197. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_F0OVR);
  198. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_F1MP);
  199. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_F1FULL);
  200. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_F1OVR);
  201. if (CAN1 == drv_can->CANx)
  202. {
  203. NVIC_EnableIRQRequest(CAN1_RX0_IRQn, 1, 0);
  204. NVIC_EnableIRQRequest(CAN1_RX1_IRQn, 1, 0);
  205. }
  206. #ifdef BSP_USING_CAN2
  207. if (CAN2 == drv_can->CANx)
  208. {
  209. NVIC_EnableIRQRequest(CAN2_RX0_IRQn, 1, 0);
  210. NVIC_EnableIRQRequest(CAN2_RX1_IRQn, 1, 0);
  211. }
  212. #endif
  213. }
  214. else if (argval == RT_DEVICE_FLAG_INT_TX)
  215. {
  216. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_TXME);
  217. if (CAN1 == drv_can->CANx)
  218. {
  219. NVIC_EnableIRQRequest(CAN1_TX_IRQn, 1, 0);
  220. }
  221. #ifdef BSP_USING_CAN2
  222. if (CAN2 == drv_can->CANx)
  223. {
  224. NVIC_EnableIRQRequest(CAN2_TX_IRQn, 1, 0);
  225. }
  226. #endif
  227. }
  228. else if (argval == RT_DEVICE_CAN_INT_ERR)
  229. {
  230. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_ERRW);
  231. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_ERRP);
  232. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_BOF);
  233. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_LEC);
  234. CAN_EnableInterrupt(drv_can->CANx, CAN_INT_ERR);
  235. if (CAN1 == drv_can->CANx)
  236. {
  237. NVIC_EnableIRQRequest(CAN1_SCE_IRQn, 1, 0);
  238. }
  239. #ifdef BSP_USING_CAN2
  240. if (CAN2 == drv_can->CANx)
  241. {
  242. NVIC_EnableIRQRequest(CAN2_SCE_IRQn, 1, 0);
  243. }
  244. #endif
  245. }
  246. break;
  247. case RT_CAN_CMD_SET_FILTER:
  248. {
  249. rt_uint32_t id_h = 0;
  250. rt_uint32_t id_l = 0;
  251. rt_uint32_t mask_h = 0;
  252. rt_uint32_t mask_l = 0;
  253. rt_uint32_t mask_l_tail = 0; //CAN_FxR2 bit [2:0]
  254. if (RT_NULL == arg)
  255. {
  256. /* default filter config */
  257. #if defined(SOC_SERIES_APM32F4) || defined(APM32F10X_CL)
  258. CAN_ConfigFilter(&drv_can->FilterConfig);
  259. #else
  260. CAN_ConfigFilter(drv_can->CANx, &drv_can->FilterConfig);
  261. #endif
  262. }
  263. else
  264. {
  265. filter_cfg = (struct rt_can_filter_config *)arg;
  266. /* get default filter */
  267. for (int i = 0; i < filter_cfg->count; i++)
  268. {
  269. if (filter_cfg->items[i].hdr == -1)
  270. {
  271. /* use default filter bank settings */
  272. if (rt_strcmp(drv_can->name, "can1") == 0)
  273. {
  274. /* can1 banks 0~13 */
  275. drv_can->FilterConfig.filterNumber = i;
  276. }
  277. else if (rt_strcmp(drv_can->name, "can2") == 0)
  278. {
  279. /* can2 banks 14~27 */
  280. drv_can->FilterConfig.filterNumber = i + 14;
  281. }
  282. }
  283. else
  284. {
  285. /* use user-defined filter bank settings */
  286. drv_can->FilterConfig.filterNumber = filter_cfg->items[i].hdr;
  287. }
  288. /**
  289. * ID | CAN_FxR1[31:24] | CAN_FxR1[23:16] | CAN_FxR1[15:8] | CAN_FxR1[7:0] |
  290. * MASK | CAN_FxR2[31:24] | CAN_FxR2[23:16] | CAN_FxR2[15:8] | CAN_FxR2[7:0] |
  291. * STD ID | STID[10:3] | STDID[2:0] |<- 21bit ->|
  292. * EXT ID | EXTID[28:21] | EXTID[20:13] | EXTID[12:5] | EXTID[4:0] IDE RTR 0|
  293. * @note the 32bit STD ID must << 21 to fill CAN_FxR1[31:21] and EXT ID must << 3,
  294. * -> but the id bit of struct rt_can_filter_item is 29,
  295. * -> so STD id << 18 and EXT id Don't need << 3, when get the high 16bit.
  296. * -> FilterIdHigh : (((STDid << 18) or (EXT id)) >> 13) & 0xFFFF,
  297. * -> FilterIdLow: ((STDid << 18) or (EXT id << 3)) & 0xFFFF.
  298. * @note the mask bit of struct rt_can_filter_item is 32,
  299. * -> FilterMaskIdHigh: (((STD mask << 21) or (EXT mask <<3)) >> 16) & 0xFFFF
  300. * -> FilterMaskIdLow: ((STD mask << 21) or (EXT mask <<3)) & 0xFFFF
  301. */
  302. if (filter_cfg->items[i].mode == CAN_FILTER_MODE_IDMASK)
  303. {
  304. /* make sure the CAN_FxR1[2:0](IDE RTR) work */
  305. mask_l_tail = 0x06;
  306. drv_can->FilterConfig.filterMode = CAN_FILTER_MODE_IDMASK;
  307. }
  308. else if (filter_cfg->items[i].mode == CAN_FILTER_MODE_IDLIST)
  309. {
  310. /* same as CAN_FxR1 */
  311. mask_l_tail = (filter_cfg->items[i].ide << 2) | (filter_cfg->items[i].rtr << 1);
  312. drv_can->FilterConfig.filterMode = CAN_FILTER_MODE_IDLIST;
  313. }
  314. if (filter_cfg->items[i].ide == RT_CAN_STDID)
  315. {
  316. id_h = ((filter_cfg->items[i].id << 18) >> 13) & 0xFFFF;
  317. id_l = ((filter_cfg->items[i].id << 18) |
  318. (filter_cfg->items[i].ide << 2) |
  319. (filter_cfg->items[i].rtr << 1)) & 0xFFFF;
  320. mask_h = ((filter_cfg->items[i].mask << 21) >> 16) & 0xFFFF;
  321. mask_l = ((filter_cfg->items[i].mask << 21) | mask_l_tail) & 0xFFFF;
  322. }
  323. else if (filter_cfg->items[i].ide == RT_CAN_EXTID)
  324. {
  325. id_h = (filter_cfg->items[i].id >> 13) & 0xFFFF;
  326. id_l = ((filter_cfg->items[i].id << 3) |
  327. (filter_cfg->items[i].ide << 2) |
  328. (filter_cfg->items[i].rtr << 1)) & 0xFFFF;
  329. mask_h = ((filter_cfg->items[i].mask << 3) >> 16) & 0xFFFF;
  330. mask_l = ((filter_cfg->items[i].mask << 3) | mask_l_tail) & 0xFFFF;
  331. }
  332. drv_can->FilterConfig.filterIdHigh = id_h;
  333. drv_can->FilterConfig.filterIdLow = id_l;
  334. drv_can->FilterConfig.filterMaskIdHigh = mask_h;
  335. drv_can->FilterConfig.filterMaskIdLow = mask_l;
  336. drv_can->FilterConfig.filterFIFO = CAN_FILTER_FIFO_0;
  337. drv_can->FilterConfig.filterScale = CAN_FILTER_SCALE_32BIT;
  338. drv_can->FilterConfig.filterActivation = ENABLE;
  339. /* Filter conf */
  340. #if defined(SOC_SERIES_APM32F4) || defined(APM32F10X_CL)
  341. CAN_ConfigFilter(&drv_can->FilterConfig);
  342. #else
  343. CAN_ConfigFilter(drv_can->CANx, &drv_can->FilterConfig);
  344. #endif
  345. }
  346. }
  347. break;
  348. }
  349. case RT_CAN_CMD_SET_MODE:
  350. argval = (rt_uint32_t) arg;
  351. if (argval != RT_CAN_MODE_NORMAL &&
  352. argval != RT_CAN_MODE_LISEN &&
  353. argval != RT_CAN_MODE_LOOPBACK &&
  354. argval != RT_CAN_MODE_LOOPBACKANLISEN)
  355. {
  356. return -RT_ERROR;
  357. }
  358. if (argval != drv_can->device.config.mode)
  359. {
  360. drv_can->device.config.mode = argval;
  361. return apm32_can_config(&drv_can->device, &drv_can->device.config);
  362. }
  363. break;
  364. case RT_CAN_CMD_SET_BAUD:
  365. argval = (rt_uint32_t) arg;
  366. if (argval != CAN1MBaud &&
  367. argval != CAN800kBaud &&
  368. argval != CAN500kBaud &&
  369. argval != CAN250kBaud &&
  370. argval != CAN125kBaud &&
  371. argval != CAN100kBaud &&
  372. argval != CAN50kBaud &&
  373. argval != CAN20kBaud &&
  374. argval != CAN10kBaud)
  375. {
  376. return -RT_ERROR;
  377. }
  378. if (argval != drv_can->device.config.baud_rate)
  379. {
  380. drv_can->device.config.baud_rate = argval;
  381. return apm32_can_config(&drv_can->device, &drv_can->device.config);
  382. }
  383. break;
  384. case RT_CAN_CMD_SET_PRIV:
  385. argval = (rt_uint32_t) arg;
  386. if (argval != RT_CAN_MODE_PRIV &&
  387. argval != RT_CAN_MODE_NOPRIV)
  388. {
  389. return -RT_ERROR;
  390. }
  391. if (argval != drv_can->device.config.privmode)
  392. {
  393. drv_can->device.config.privmode = argval;
  394. return apm32_can_config(&drv_can->device, &drv_can->device.config);
  395. }
  396. break;
  397. case RT_CAN_CMD_GET_STATUS:
  398. {
  399. rt_uint32_t errtype;
  400. errtype = drv_can->CANx->ERRSTS;
  401. drv_can->device.status.rcverrcnt = errtype >> 24;
  402. drv_can->device.status.snderrcnt = (errtype >> 16 & 0xFF);
  403. drv_can->device.status.lasterrtype = errtype & 0x70;
  404. drv_can->device.status.errcode = errtype & 0x07;
  405. rt_memcpy(arg, &drv_can->device.status, sizeof(drv_can->device.status));
  406. }
  407. break;
  408. }
  409. return RT_EOK;
  410. }
  411. static int can_send_rtmsg(CAN_T *CANx, struct rt_can_msg *pmsg, uint32_t mailbox_index)
  412. {
  413. CAN_TxMessage_T CAN_TxMessage = {0};
  414. CAN_TxMessage_T *TxMessage = &CAN_TxMessage;
  415. if (RT_CAN_STDID == pmsg->ide)
  416. {
  417. TxMessage->typeID = CAN_TYPEID_STD;
  418. TxMessage->stdID = pmsg->id;
  419. }
  420. else
  421. {
  422. TxMessage->typeID = CAN_TYPEID_EXT;
  423. TxMessage->extID = pmsg->id;
  424. }
  425. if (RT_CAN_DTR == pmsg->rtr)
  426. {
  427. TxMessage->remoteTxReq = CAN_RTXR_DATA;
  428. }
  429. else
  430. {
  431. TxMessage->remoteTxReq = CAN_RTXR_REMOTE;
  432. }
  433. /* Set up the Id */
  434. CANx->sTxMailBox[mailbox_index].TXMID &= 0x00000001;
  435. if (TxMessage->typeID == CAN_TYPEID_STD)
  436. {
  437. CANx->sTxMailBox[mailbox_index].TXMID |= (TxMessage->stdID << 21) | (TxMessage->remoteTxReq);
  438. }
  439. else
  440. {
  441. CANx->sTxMailBox[mailbox_index].TXMID |= (TxMessage->extID << 3) | (TxMessage->typeID) | (TxMessage->remoteTxReq);
  442. }
  443. /* Set up the TXDLEN */
  444. TxMessage->dataLengthCode = pmsg->len & 0x0FU;
  445. CANx->sTxMailBox[mailbox_index].TXDLEN &= (uint32_t)0xFFFFFFF0;
  446. CANx->sTxMailBox[mailbox_index].TXDLEN |= TxMessage->dataLengthCode;
  447. /* Set up the data field */
  448. CANx->sTxMailBox[mailbox_index].TXMDH = (((uint32_t)pmsg->data[7] << 24) |
  449. ((uint32_t)pmsg->data[6] << 16) |
  450. ((uint32_t)pmsg->data[5] << 8) |
  451. ((uint32_t)pmsg->data[4]));
  452. CANx->sTxMailBox[mailbox_index].TXMDL = (((uint32_t)pmsg->data[3] << 24) |
  453. ((uint32_t)pmsg->data[2] << 16) |
  454. ((uint32_t)pmsg->data[1] << 8) |
  455. ((uint32_t)pmsg->data[0]));
  456. /* Request transmission */
  457. CANx->sTxMailBox[mailbox_index].TXMID |= 0x00000001;
  458. return RT_EOK;
  459. }
  460. static int apm32_can_sendmsg(struct rt_can_device *can, const void *buf, rt_uint32_t box_num)
  461. {
  462. struct apm32_can *drv_can;
  463. RT_ASSERT(can != RT_NULL);
  464. RT_ASSERT(buf != RT_NULL);
  465. drv_can = (struct apm32_can *)can->parent.user_data;
  466. RT_ASSERT(drv_can != RT_NULL);
  467. /* Select one empty transmit mailbox */
  468. switch (box_num)
  469. {
  470. case CAN_TX_MAILBIX_0:
  471. if ((drv_can->CANx->TXSTS & 0x04000000) != 0x04000000)
  472. {
  473. /* Return function status */
  474. return -RT_ERROR;
  475. }
  476. break;
  477. case CAN_TX_MAILBIX_1:
  478. if ((drv_can->CANx->TXSTS & 0x08000000) != 0x08000000)
  479. {
  480. /* Return function status */
  481. return -RT_ERROR;
  482. }
  483. break;
  484. case CAN_TX_MAILBIX_2:
  485. if ((drv_can->CANx->TXSTS & 0x10000000) != 0x10000000)
  486. {
  487. /* Return function status */
  488. return -RT_ERROR;
  489. }
  490. break;
  491. default:
  492. RT_ASSERT(0);
  493. break;
  494. }
  495. /* Start send msg */
  496. return can_send_rtmsg(drv_can->CANx, ((struct rt_can_msg *)buf), box_num);
  497. }
  498. static int apm32_can_recvmsg(struct rt_can_device *can, void *buf, rt_uint32_t fifo)
  499. {
  500. struct apm32_can *drv_can;
  501. struct rt_can_msg *pmsg;
  502. CAN_RxMessage_T RxMessage = {0};
  503. RT_ASSERT(can);
  504. drv_can = (struct apm32_can *)can->parent.user_data;
  505. pmsg = (struct rt_can_msg *) buf;
  506. CAN_RxMessage(drv_can->CANx, (CAN_RX_FIFO_T)fifo, &RxMessage);
  507. /* get data */
  508. pmsg->data[0] = RxMessage.data[0];
  509. pmsg->data[1] = RxMessage.data[1];
  510. pmsg->data[2] = RxMessage.data[2];
  511. pmsg->data[3] = RxMessage.data[3];
  512. pmsg->data[4] = RxMessage.data[4];
  513. pmsg->data[5] = RxMessage.data[5];
  514. pmsg->data[6] = RxMessage.data[6];
  515. pmsg->data[7] = RxMessage.data[7];
  516. /* get id */
  517. if (CAN_TYPEID_STD == RxMessage.typeID)
  518. {
  519. pmsg->ide = RT_CAN_STDID;
  520. pmsg->id = RxMessage.stdID;
  521. }
  522. else
  523. {
  524. pmsg->ide = RT_CAN_EXTID;
  525. pmsg->id = RxMessage.extID;
  526. }
  527. /* get type */
  528. if (CAN_RTXR_DATA == RxMessage.remoteTxReq)
  529. {
  530. pmsg->rtr = RT_CAN_DTR;
  531. }
  532. else
  533. {
  534. pmsg->rtr = RT_CAN_RTR;
  535. }
  536. /*get rxfifo = CAN_RX_FIFO0/CAN_RX_FIFO1*/
  537. //pmsg->rxfifo = fifo;
  538. /* get len */
  539. pmsg->len = RxMessage.dataLengthCode;
  540. /* get hdr */
  541. if (drv_can->CANx == CAN1)
  542. {
  543. pmsg->hdr = RxMessage.filterMatchIndex;
  544. }
  545. #ifdef CAN2
  546. else if (drv_can->CANx == CAN2)
  547. {
  548. pmsg->hdr = RxMessage.filterMatchIndex;
  549. }
  550. #endif
  551. return RT_EOK;
  552. }
  553. static const struct rt_can_ops _can_ops =
  554. {
  555. apm32_can_config,
  556. apm32_can_control,
  557. apm32_can_sendmsg,
  558. apm32_can_recvmsg,
  559. };
  560. static void _can_rx_isr(struct rt_can_device *can, rt_uint32_t fifo)
  561. {
  562. struct apm32_can *drv_can;
  563. RT_ASSERT(can != RT_NULL);
  564. drv_can = (struct apm32_can *)can->parent.user_data;
  565. RT_ASSERT(drv_can != RT_NULL);
  566. switch (fifo)
  567. {
  568. case CAN_RX_FIFO_0:
  569. /* save to user list */
  570. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_F0MP) && CAN_PendingMessage(drv_can->CANx, CAN_RX_FIFO_0))
  571. {
  572. rt_hw_can_isr(can, RT_CAN_EVENT_RX_IND | fifo << 8);
  573. }
  574. /* Check FULL flag for FIFO0 */
  575. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_F0FULL))
  576. {
  577. /* Clear FIFO0 FULL Flag */
  578. CAN_ClearStatusFlag(drv_can->CANx, CAN_FLAG_F0FULL);
  579. }
  580. /* Check Overrun flag for FIFO0 */
  581. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_F0OVR))
  582. {
  583. /* Clear FIFO0 Overrun Flag */
  584. CAN_ClearStatusFlag(drv_can->CANx, CAN_FLAG_F0OVR);
  585. rt_hw_can_isr(can, RT_CAN_EVENT_RXOF_IND | fifo << 8);
  586. }
  587. break;
  588. case CAN_RX_FIFO_1:
  589. /* save to user list */
  590. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_F1MP) && CAN_PendingMessage(drv_can->CANx, CAN_RX_FIFO_1))
  591. {
  592. rt_hw_can_isr(can, RT_CAN_EVENT_RX_IND | fifo << 8);
  593. }
  594. /* Check FULL flag for FIFO1 */
  595. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_F1FULL))
  596. {
  597. /* Clear FIFO1 FULL Flag */
  598. CAN_ClearStatusFlag(drv_can->CANx, CAN_FLAG_F1FULL);
  599. }
  600. /* Check Overrun flag for FIFO1 */
  601. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_F1OVR))
  602. {
  603. /* Clear FIFO1 Overrun Flag */
  604. CAN_ClearStatusFlag(drv_can->CANx, CAN_FLAG_F1OVR);
  605. rt_hw_can_isr(can, RT_CAN_EVENT_RXOF_IND | fifo << 8);
  606. }
  607. break;
  608. }
  609. }
  610. static void _can_sce_isr(struct rt_can_device *can)
  611. {
  612. struct apm32_can *drv_can;
  613. RT_ASSERT(can != RT_NULL);
  614. drv_can = (struct apm32_can *)can->parent.user_data;
  615. RT_ASSERT(drv_can != RT_NULL);
  616. rt_uint32_t errtype = drv_can->CANx->ERRSTS;
  617. switch ((errtype & 0x70) >> 4)
  618. {
  619. case RT_CAN_BUS_BIT_PAD_ERR:
  620. can->status.bitpaderrcnt++;
  621. break;
  622. case RT_CAN_BUS_FORMAT_ERR:
  623. can->status.formaterrcnt++;
  624. break;
  625. case RT_CAN_BUS_ACK_ERR:/* attention !!! test ack err's unit is transmit unit */
  626. can->status.ackerrcnt++;
  627. if (!READ_BIT(drv_can->CANx->TXSTS, 0x00000002))
  628. {
  629. rt_hw_can_isr(can, RT_CAN_EVENT_TX_FAIL | 0 << 8);
  630. }
  631. else if (!READ_BIT(drv_can->CANx->TXSTS, 0x00000200))
  632. {
  633. rt_hw_can_isr(can, RT_CAN_EVENT_TX_FAIL | 1 << 8);
  634. }
  635. else if (!READ_BIT(drv_can->CANx->TXSTS, 0x00020000))
  636. {
  637. rt_hw_can_isr(can, RT_CAN_EVENT_TX_FAIL | 2 << 8);
  638. }
  639. break;
  640. case RT_CAN_BUS_IMPLICIT_BIT_ERR:
  641. case RT_CAN_BUS_EXPLICIT_BIT_ERR:
  642. can->status.biterrcnt++;
  643. break;
  644. case RT_CAN_BUS_CRC_ERR:
  645. can->status.crcerrcnt++;
  646. break;
  647. }
  648. can->status.lasterrtype = errtype & 0x70;
  649. can->status.rcverrcnt = errtype >> 24;
  650. can->status.snderrcnt = (errtype >> 16 & 0xFF);
  651. can->status.errcode = errtype & 0x07;
  652. /* clear error interrupt flag */
  653. CAN_ClearIntFlag(drv_can->CANx, CAN_INT_ERR);
  654. }
  655. static void _can_tx_isr(struct rt_can_device *can)
  656. {
  657. struct apm32_can *drv_can;
  658. RT_ASSERT(can != RT_NULL);
  659. drv_can = (struct apm32_can *)can->parent.user_data;
  660. RT_ASSERT(drv_can != RT_NULL);
  661. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_REQC0))
  662. {
  663. rt_hw_can_isr(can, RT_CAN_EVENT_TX_DONE | (0x00 << 8));
  664. CAN_ClearStatusFlag(drv_can->CANx, CAN_FLAG_REQC0);
  665. }
  666. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_REQC1))
  667. {
  668. rt_hw_can_isr(can, RT_CAN_EVENT_TX_DONE | (0x01 << 8));
  669. CAN_ClearStatusFlag(drv_can->CANx, CAN_FLAG_REQC1);
  670. }
  671. if (CAN_ReadStatusFlag(drv_can->CANx, CAN_FLAG_REQC2))
  672. {
  673. rt_hw_can_isr(can, RT_CAN_EVENT_TX_DONE | (0x02 << 8));
  674. CAN_ClearStatusFlag(drv_can->CANx, CAN_FLAG_REQC2);
  675. }
  676. }
  677. #ifdef BSP_USING_CAN1
  678. /**
  679. * @brief This function handles CAN1 TX interrupts. transmit fifo0/1/2 is empty can trigger this interrupt
  680. */
  681. void CAN1_TX_IRQHandler(void)
  682. {
  683. rt_interrupt_enter();
  684. _can_tx_isr(&drv_can1.device);
  685. rt_interrupt_leave();
  686. }
  687. /**
  688. * @brief This function handles CAN1 RX0 interrupts.
  689. */
  690. void CAN1_RX0_IRQHandler(void)
  691. {
  692. rt_interrupt_enter();
  693. _can_rx_isr(&drv_can1.device, CAN_RX_FIFO0);
  694. rt_interrupt_leave();
  695. }
  696. /**
  697. * @brief This function handles CAN1 RX1 interrupts.
  698. */
  699. void CAN1_RX1_IRQHandler(void)
  700. {
  701. rt_interrupt_enter();
  702. _can_rx_isr(&drv_can1.device, CAN_RX_FIFO1);
  703. rt_interrupt_leave();
  704. }
  705. /**
  706. * @brief This function handles CAN1 SCE interrupts.
  707. */
  708. void CAN1_SCE_IRQHandler(void)
  709. {
  710. rt_interrupt_enter();
  711. _can_sce_isr(&drv_can1.device);
  712. rt_interrupt_leave();
  713. }
  714. #endif /* BSP_USING_CAN1 */
  715. #ifdef BSP_USING_CAN2
  716. /**
  717. * @brief This function handles CAN2 TX interrupts.
  718. */
  719. void CAN2_TX_IRQHandler(void)
  720. {
  721. rt_interrupt_enter();
  722. _can_tx_isr(&drv_can2.device);
  723. rt_interrupt_leave();
  724. }
  725. /**
  726. * @brief This function handles CAN2 RX0 interrupts.
  727. */
  728. void CAN2_RX0_IRQHandler(void)
  729. {
  730. rt_interrupt_enter();
  731. _can_rx_isr(&drv_can2.device, CAN_RX_FIFO0);
  732. rt_interrupt_leave();
  733. }
  734. /**
  735. * @brief This function handles CAN2 RX1 interrupts.
  736. */
  737. void CAN2_RX1_IRQHandler(void)
  738. {
  739. rt_interrupt_enter();
  740. _can_rx_isr(&drv_can2.device, CAN_RX_FIFO1);
  741. rt_interrupt_leave();
  742. }
  743. /**
  744. * @brief This function handles CAN2 SCE interrupts.
  745. */
  746. void CAN2_SCE_IRQHandler(void)
  747. {
  748. rt_interrupt_enter();
  749. _can_sce_isr(&drv_can2.device);
  750. rt_interrupt_leave();
  751. }
  752. #endif /* BSP_USING_CAN2 */
  753. int rt_hw_can_init(void)
  754. {
  755. struct can_configure config = CANDEFAULTCONFIG;
  756. config.privmode = RT_CAN_MODE_NOPRIV;
  757. config.ticks = 50;
  758. #ifdef RT_CAN_USING_HDR
  759. config.maxhdr = 14;
  760. #if defined(CAN2) && (defined(APM32F10X_CL) || defined(SOC_SERIES_APM32F4))
  761. config.maxhdr = 28;
  762. #endif
  763. #endif
  764. /* config default filter */
  765. CAN_FilterConfig_T filterConf = {0};
  766. filterConf.filterNumber = 0;
  767. filterConf.filterIdHigh = 0x0000;
  768. filterConf.filterIdLow = 0x0000;
  769. filterConf.filterMaskIdHigh = 0x0000;
  770. filterConf.filterMaskIdLow = 0x0000;
  771. filterConf.filterFIFO = CAN_FILTER_FIFO_0;
  772. filterConf.filterMode = CAN_FILTER_MODE_IDMASK;
  773. filterConf.filterScale = CAN_FILTER_SCALE_32BIT;
  774. filterConf.filterActivation = ENABLE;
  775. #ifdef BSP_USING_CAN1
  776. filterConf.filterNumber = 0;
  777. drv_can1.FilterConfig = filterConf;
  778. drv_can1.device.config = config;
  779. /* register CAN1 device */
  780. rt_hw_can_register(&drv_can1.device, drv_can1.name, &_can_ops, &drv_can1);
  781. #endif /* BSP_USING_CAN1 */
  782. #ifdef BSP_USING_CAN2
  783. #if defined(APM32F10X_HD) || defined(APM32E10X_HD) || defined(APM32S10X_MD)
  784. filterConf.filterNumber = 0;
  785. #elif defined(APM32F10X_CL) || defined(SOC_SERIES_APM32F4)
  786. filterConf.filterNumber = 14;
  787. #else
  788. filterConf.filterNumber = 0;
  789. #endif
  790. drv_can2.FilterConfig = filterConf;
  791. drv_can2.device.config = config;
  792. /* register CAN2 device */
  793. rt_hw_can_register(&drv_can2.device, drv_can2.name, &_can_ops, &drv_can2);
  794. #endif /* BSP_USING_CAN2 */
  795. return 0;
  796. }
  797. INIT_BOARD_EXPORT(rt_hw_can_init);
  798. #endif /* defined(BSP_USING_CAN1) || defined(BSP_USING_CAN2) */
  799. #endif /*RT_USING_CAN*/