drv_spi.c 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123
  1. /*
  2. * Copyright (c) 2006-2024, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2018-11-5 SummerGift first version
  9. * 2018-12-11 greedyhao Porting for stm32f7xx
  10. * 2019-01-03 zylx modify DMA initialization and spixfer function
  11. * 2020-01-15 whj4674672 Porting for stm32h7xx
  12. * 2020-06-18 thread-liu Porting for stm32mp1xx
  13. * 2020-10-14 Dozingfiretruck Porting for stm32wbxx
  14. */
  15. #include <rtthread.h>
  16. #include <rtdevice.h>
  17. #include "board.h"
  18. #ifdef BSP_USING_SPI
  19. #if defined(BSP_USING_SPI1) || defined(BSP_USING_SPI2) || defined(BSP_USING_SPI3) || defined(BSP_USING_SPI4) || defined(BSP_USING_SPI5) || defined(BSP_USING_SPI6)
  20. #include "drv_spi.h"
  21. #include "drv_config.h"
  22. #include <string.h>
  23. //#define DRV_DEBUG
  24. #define LOG_TAG "drv.spi"
  25. #include <drv_log.h>
  26. enum
  27. {
  28. #ifdef BSP_USING_SPI1
  29. SPI1_INDEX,
  30. #endif
  31. #ifdef BSP_USING_SPI2
  32. SPI2_INDEX,
  33. #endif
  34. #ifdef BSP_USING_SPI3
  35. SPI3_INDEX,
  36. #endif
  37. #ifdef BSP_USING_SPI4
  38. SPI4_INDEX,
  39. #endif
  40. #ifdef BSP_USING_SPI5
  41. SPI5_INDEX,
  42. #endif
  43. #ifdef BSP_USING_SPI6
  44. SPI6_INDEX,
  45. #endif
  46. };
  47. static struct stm32_spi_config spi_config[] =
  48. {
  49. #ifdef BSP_USING_SPI1
  50. SPI1_BUS_CONFIG,
  51. #endif
  52. #ifdef BSP_USING_SPI2
  53. SPI2_BUS_CONFIG,
  54. #endif
  55. #ifdef BSP_USING_SPI3
  56. SPI3_BUS_CONFIG,
  57. #endif
  58. #ifdef BSP_USING_SPI4
  59. SPI4_BUS_CONFIG,
  60. #endif
  61. #ifdef BSP_USING_SPI5
  62. SPI5_BUS_CONFIG,
  63. #endif
  64. #ifdef BSP_USING_SPI6
  65. SPI6_BUS_CONFIG,
  66. #endif
  67. };
  68. static struct stm32_spi spi_bus_obj[sizeof(spi_config) / sizeof(spi_config[0])] = {0};
  69. static rt_err_t stm32_spi_init(struct stm32_spi *spi_drv, struct rt_spi_configuration *cfg)
  70. {
  71. RT_ASSERT(spi_drv != RT_NULL);
  72. RT_ASSERT(cfg != RT_NULL);
  73. SPI_HandleTypeDef *spi_handle = &spi_drv->handle;
  74. if (cfg->mode & RT_SPI_SLAVE)
  75. {
  76. spi_handle->Init.Mode = SPI_MODE_SLAVE;
  77. }
  78. else
  79. {
  80. spi_handle->Init.Mode = SPI_MODE_MASTER;
  81. }
  82. if (cfg->mode & RT_SPI_3WIRE)
  83. {
  84. spi_handle->Init.Direction = SPI_DIRECTION_1LINE;
  85. }
  86. else
  87. {
  88. spi_handle->Init.Direction = SPI_DIRECTION_2LINES;
  89. }
  90. if (cfg->data_width == 8)
  91. {
  92. spi_handle->Init.DataSize = SPI_DATASIZE_8BIT;
  93. }
  94. else if (cfg->data_width == 16)
  95. {
  96. spi_handle->Init.DataSize = SPI_DATASIZE_16BIT;
  97. }
  98. else
  99. {
  100. return -RT_EIO;
  101. }
  102. if (cfg->mode & RT_SPI_CPHA)
  103. {
  104. spi_handle->Init.CLKPhase = SPI_PHASE_2EDGE;
  105. }
  106. else
  107. {
  108. spi_handle->Init.CLKPhase = SPI_PHASE_1EDGE;
  109. }
  110. if (cfg->mode & RT_SPI_CPOL)
  111. {
  112. spi_handle->Init.CLKPolarity = SPI_POLARITY_HIGH;
  113. }
  114. else
  115. {
  116. spi_handle->Init.CLKPolarity = SPI_POLARITY_LOW;
  117. }
  118. spi_handle->Init.NSS = SPI_NSS_SOFT;
  119. uint32_t SPI_CLOCK = 0UL;
  120. /* Some series may only have APBPERIPH_BASE, but don't have HAL_RCC_GetPCLK2Freq */
  121. #if defined(APBPERIPH_BASE)
  122. SPI_CLOCK = HAL_RCC_GetPCLK1Freq();
  123. #elif defined(APB1PERIPH_BASE) || defined(APB2PERIPH_BASE)
  124. /* The SPI clock for H7 cannot be configured with a peripheral bus clock, so it needs to be written separately */
  125. #if defined(SOC_SERIES_STM32H7)
  126. /* When the configuration is generated using CUBEMX, the configuration for the SPI clock is placed in the HAL_SPI_Init function.
  127. Therefore, it is necessary to initialize and configure the SPI clock to automatically configure the frequency division */
  128. HAL_SPI_Init(spi_handle);
  129. SPI_CLOCK = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI123);
  130. #else
  131. if ((rt_uint32_t)spi_drv->config->Instance >= APB2PERIPH_BASE)
  132. {
  133. SPI_CLOCK = HAL_RCC_GetPCLK2Freq();
  134. }
  135. else
  136. {
  137. SPI_CLOCK = HAL_RCC_GetPCLK1Freq();
  138. }
  139. #endif /* SOC_SERIES_STM32H7) */
  140. #endif /* APBPERIPH_BASE */
  141. if (cfg->max_hz >= SPI_CLOCK / 2)
  142. {
  143. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  144. }
  145. else if (cfg->max_hz >= SPI_CLOCK / 4)
  146. {
  147. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
  148. }
  149. else if (cfg->max_hz >= SPI_CLOCK / 8)
  150. {
  151. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
  152. }
  153. else if (cfg->max_hz >= SPI_CLOCK / 16)
  154. {
  155. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
  156. }
  157. else if (cfg->max_hz >= SPI_CLOCK / 32)
  158. {
  159. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
  160. }
  161. else if (cfg->max_hz >= SPI_CLOCK / 64)
  162. {
  163. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
  164. }
  165. else if (cfg->max_hz >= SPI_CLOCK / 128)
  166. {
  167. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
  168. }
  169. else
  170. {
  171. /* min prescaler 256 */
  172. spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
  173. }
  174. LOG_D("sys freq: %d, pclk freq: %d, SPI limiting freq: %d, SPI usage freq: %d",
  175. #if defined(SOC_SERIES_STM32MP1)
  176. HAL_RCC_GetSystemCoreClockFreq(),
  177. #else
  178. HAL_RCC_GetSysClockFreq(),
  179. #endif
  180. SPI_CLOCK,
  181. cfg->max_hz,
  182. SPI_CLOCK / (rt_size_t)pow(2,(spi_handle->Init.BaudRatePrescaler >> 28) + 1));
  183. if (cfg->mode & RT_SPI_MSB)
  184. {
  185. spi_handle->Init.FirstBit = SPI_FIRSTBIT_MSB;
  186. }
  187. else
  188. {
  189. spi_handle->Init.FirstBit = SPI_FIRSTBIT_LSB;
  190. }
  191. spi_handle->Init.TIMode = SPI_TIMODE_DISABLE;
  192. spi_handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  193. spi_handle->State = HAL_SPI_STATE_RESET;
  194. #if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32WB)
  195. spi_handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  196. #elif defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32MP1)
  197. spi_handle->Init.Mode = SPI_MODE_MASTER;
  198. spi_handle->Init.NSS = SPI_NSS_SOFT;
  199. spi_handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  200. spi_handle->Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  201. spi_handle->Init.CRCPolynomial = 7;
  202. spi_handle->Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  203. spi_handle->Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  204. spi_handle->Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  205. spi_handle->Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  206. spi_handle->Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  207. spi_handle->Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
  208. spi_handle->Init.IOSwap = SPI_IO_SWAP_DISABLE;
  209. spi_handle->Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  210. #endif
  211. if (HAL_SPI_Init(spi_handle) != HAL_OK)
  212. {
  213. return -RT_EIO;
  214. }
  215. #if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F0) \
  216. || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32WB)
  217. SET_BIT(spi_handle->Instance->CR2, SPI_RXFIFO_THRESHOLD_HF);
  218. #endif
  219. /* DMA configuration */
  220. if (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG)
  221. {
  222. HAL_DMA_Init(&spi_drv->dma.handle_rx);
  223. __HAL_LINKDMA(&spi_drv->handle, hdmarx, spi_drv->dma.handle_rx);
  224. /* NVIC configuration for DMA transfer complete interrupt */
  225. HAL_NVIC_SetPriority(spi_drv->config->dma_rx->dma_irq, 0, 0);
  226. HAL_NVIC_EnableIRQ(spi_drv->config->dma_rx->dma_irq);
  227. }
  228. if (spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG)
  229. {
  230. HAL_DMA_Init(&spi_drv->dma.handle_tx);
  231. __HAL_LINKDMA(&spi_drv->handle, hdmatx, spi_drv->dma.handle_tx);
  232. /* NVIC configuration for DMA transfer complete interrupt */
  233. HAL_NVIC_SetPriority(spi_drv->config->dma_tx->dma_irq, 1, 0);
  234. HAL_NVIC_EnableIRQ(spi_drv->config->dma_tx->dma_irq);
  235. }
  236. if(spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG || spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG)
  237. {
  238. HAL_NVIC_SetPriority(spi_drv->config->irq_type, 2, 0);
  239. HAL_NVIC_EnableIRQ(spi_drv->config->irq_type);
  240. }
  241. LOG_D("%s init done", spi_drv->config->bus_name);
  242. return RT_EOK;
  243. }
  244. static rt_ssize_t spixfer(struct rt_spi_device *device, struct rt_spi_message *message)
  245. {
  246. #define DMA_TRANS_MIN_LEN 10 /* only buffer length >= DMA_TRANS_MIN_LEN will use DMA mode */
  247. HAL_StatusTypeDef state = HAL_OK;
  248. rt_size_t message_length, already_send_length;
  249. rt_uint16_t send_length;
  250. rt_uint8_t *recv_buf;
  251. const rt_uint8_t *send_buf;
  252. RT_ASSERT(device != RT_NULL);
  253. RT_ASSERT(device->bus != RT_NULL);
  254. RT_ASSERT(message != RT_NULL);
  255. struct stm32_spi *spi_drv = rt_container_of(device->bus, struct stm32_spi, spi_bus);
  256. SPI_HandleTypeDef *spi_handle = &spi_drv->handle;
  257. if (message->cs_take && !(device->config.mode & RT_SPI_NO_CS) && (device->cs_pin != PIN_NONE))
  258. {
  259. if (device->config.mode & RT_SPI_CS_HIGH)
  260. {
  261. rt_pin_write(device->cs_pin, PIN_HIGH);
  262. }
  263. else
  264. {
  265. rt_pin_write(device->cs_pin, PIN_LOW);
  266. }
  267. }
  268. LOG_D("%s transfer prepare and start", spi_drv->config->bus_name);
  269. LOG_D("%s sendbuf: %X, recvbuf: %X, length: %d",
  270. spi_drv->config->bus_name,
  271. (uint32_t)message->send_buf,
  272. (uint32_t)message->recv_buf, message->length);
  273. message_length = message->length;
  274. recv_buf = message->recv_buf;
  275. send_buf = message->send_buf;
  276. while (message_length)
  277. {
  278. /* the HAL library use uint16 to save the data length */
  279. if (message_length > 65535)
  280. {
  281. send_length = 65535;
  282. message_length = message_length - 65535;
  283. }
  284. else
  285. {
  286. send_length = message_length;
  287. message_length = 0;
  288. }
  289. /* calculate the start address */
  290. already_send_length = message->length - send_length - message_length;
  291. /* avoid null pointer problems */
  292. if (message->send_buf)
  293. {
  294. send_buf = (rt_uint8_t *)message->send_buf + already_send_length;
  295. }
  296. if (message->recv_buf)
  297. {
  298. recv_buf = (rt_uint8_t *)message->recv_buf + already_send_length;
  299. }
  300. rt_uint32_t* dma_aligned_buffer = RT_NULL;
  301. rt_uint32_t* p_txrx_buffer = RT_NULL;
  302. if ((spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) && (send_length >= DMA_TRANS_MIN_LEN))
  303. {
  304. #if defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32F7)
  305. if (RT_IS_ALIGN((rt_uint32_t)send_buf, 32) && send_buf != RT_NULL) /* aligned with 32 bytes? */
  306. {
  307. p_txrx_buffer = (rt_uint32_t *)send_buf; /* send_buf aligns with 32 bytes, no more operations */
  308. }
  309. else
  310. {
  311. /* send_buf doesn't align with 32 bytes, so creat a cache buffer with 32 bytes aligned */
  312. dma_aligned_buffer = (rt_uint32_t *)rt_malloc_align(send_length, 32);
  313. rt_memcpy(dma_aligned_buffer, send_buf, send_length);
  314. p_txrx_buffer = dma_aligned_buffer;
  315. }
  316. rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, dma_aligned_buffer, send_length);
  317. #else
  318. if (RT_IS_ALIGN((rt_uint32_t)send_buf, 4) && send_buf != RT_NULL) /* aligned with 4 bytes? */
  319. {
  320. p_txrx_buffer = (rt_uint32_t *)send_buf; /* send_buf aligns with 4 bytes, no more operations */
  321. }
  322. else
  323. {
  324. /* send_buf doesn't align with 4 bytes, so creat a cache buffer with 4 bytes aligned */
  325. dma_aligned_buffer = (rt_uint32_t *)rt_malloc(send_length); /* aligned with RT_ALIGN_SIZE (8 bytes by default) */
  326. rt_memcpy(dma_aligned_buffer, send_buf, send_length);
  327. p_txrx_buffer = dma_aligned_buffer;
  328. }
  329. #endif /* SOC_SERIES_STM32H7 || SOC_SERIES_STM32F7 */
  330. }
  331. else if ((spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG) && (send_length >= DMA_TRANS_MIN_LEN))
  332. {
  333. #if defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32F7)
  334. if (RT_IS_ALIGN((rt_uint32_t)recv_buf, 32) && recv_buf != RT_NULL) /* aligned with 32 bytes? */
  335. {
  336. p_txrx_buffer = (rt_uint32_t *)recv_buf; /* recv_buf aligns with 32 bytes, no more operations */
  337. }
  338. else
  339. {
  340. /* recv_buf doesn't align with 32 bytes, so creat a cache buffer with 32 bytes aligned */
  341. dma_aligned_buffer = (rt_uint32_t *)rt_malloc_align(send_length, 32);
  342. rt_memcpy(dma_aligned_buffer, recv_buf, send_length);
  343. p_txrx_buffer = dma_aligned_buffer;
  344. }
  345. rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, dma_aligned_buffer, send_length);
  346. #else
  347. if (RT_IS_ALIGN((rt_uint32_t)recv_buf, 4) && recv_buf != RT_NULL) /* aligned with 4 bytes? */
  348. {
  349. p_txrx_buffer = (rt_uint32_t *)recv_buf; /* recv_buf aligns with 4 bytes, no more operations */
  350. }
  351. else
  352. {
  353. /* recv_buf doesn't align with 4 bytes, so creat a cache buffer with 4 bytes aligned */
  354. dma_aligned_buffer = (rt_uint32_t *)rt_malloc(send_length); /* aligned with RT_ALIGN_SIZE (8 bytes by default) */
  355. rt_memcpy(dma_aligned_buffer, recv_buf, send_length);
  356. p_txrx_buffer = dma_aligned_buffer;
  357. }
  358. #endif /* SOC_SERIES_STM32H7 || SOC_SERIES_STM32F7 */
  359. }
  360. /* start once data exchange in DMA mode */
  361. if (message->send_buf && message->recv_buf)
  362. {
  363. if ((spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) && (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG) && (send_length >= DMA_TRANS_MIN_LEN))
  364. {
  365. state = HAL_SPI_TransmitReceive_DMA(spi_handle, (uint8_t *)p_txrx_buffer, (uint8_t *)p_txrx_buffer, send_length);
  366. }
  367. else if ((spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) && (send_length >= DMA_TRANS_MIN_LEN))
  368. {
  369. /* same as Tx ONLY. It will not receive SPI data any more. */
  370. state = HAL_SPI_Transmit_DMA(spi_handle, (uint8_t *)p_txrx_buffer, send_length);
  371. }
  372. else if ((spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG) && (send_length >= DMA_TRANS_MIN_LEN))
  373. {
  374. state = HAL_ERROR;
  375. LOG_E("It shoule be enabled both BSP_SPIx_TX_USING_DMA and BSP_SPIx_TX_USING_DMA flag, if wants to use SPI DMA Rx singly.");
  376. break;
  377. }
  378. else
  379. {
  380. state = HAL_SPI_TransmitReceive(spi_handle, (uint8_t *)send_buf, (uint8_t *)recv_buf, send_length, 1000);
  381. }
  382. }
  383. else if (message->send_buf)
  384. {
  385. if ((spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) && (send_length >= DMA_TRANS_MIN_LEN))
  386. {
  387. state = HAL_SPI_Transmit_DMA(spi_handle, (uint8_t *)p_txrx_buffer, send_length);
  388. }
  389. else
  390. {
  391. state = HAL_SPI_Transmit(spi_handle, (uint8_t *)send_buf, send_length, 1000);
  392. }
  393. if (message->cs_release && (device->config.mode & RT_SPI_3WIRE))
  394. {
  395. /* release the CS by disable SPI when using 3 wires SPI */
  396. __HAL_SPI_DISABLE(spi_handle);
  397. }
  398. }
  399. else if(message->recv_buf)
  400. {
  401. rt_memset((uint8_t *)recv_buf, 0xff, send_length);
  402. if ((spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG) && (send_length >= DMA_TRANS_MIN_LEN))
  403. {
  404. state = HAL_SPI_Receive_DMA(spi_handle, (uint8_t *)p_txrx_buffer, send_length);
  405. }
  406. else
  407. {
  408. /* clear the old error flag */
  409. __HAL_SPI_CLEAR_OVRFLAG(spi_handle);
  410. state = HAL_SPI_Receive(spi_handle, (uint8_t *)recv_buf, send_length, 1000);
  411. }
  412. }
  413. else
  414. {
  415. state = HAL_ERROR;
  416. LOG_E("message->send_buf and message->recv_buf are both NULL!");
  417. }
  418. if (state != HAL_OK)
  419. {
  420. LOG_E("SPI transfer error: %d", state);
  421. message->length = 0;
  422. spi_handle->State = HAL_SPI_STATE_READY;
  423. break;
  424. }
  425. else
  426. {
  427. LOG_D("%s transfer done", spi_drv->config->bus_name);
  428. }
  429. /* For simplicity reasons, this example is just waiting till the end of the
  430. transfer, but application may perform other tasks while transfer operation
  431. is ongoing. */
  432. if ((spi_drv->spi_dma_flag & (SPI_USING_TX_DMA_FLAG | SPI_USING_RX_DMA_FLAG)) && (send_length >= DMA_TRANS_MIN_LEN))
  433. {
  434. /* blocking the thread,and the other tasks can run */
  435. if (rt_completion_wait(&spi_drv->cpt, 1000) != RT_EOK)
  436. {
  437. state = HAL_ERROR;
  438. LOG_E("wait for DMA interrupt overtime!");
  439. break;
  440. }
  441. }
  442. else
  443. {
  444. while (HAL_SPI_GetState(spi_handle) != HAL_SPI_STATE_READY);
  445. }
  446. if(dma_aligned_buffer != RT_NULL) /* re-aligned, so need to copy the data to recv_buf */
  447. {
  448. if(recv_buf != RT_NULL)
  449. {
  450. #if defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32F7)
  451. rt_hw_cpu_dcache_ops(RT_HW_CACHE_INVALIDATE, p_txrx_buffer, send_length);
  452. #endif /* SOC_SERIES_STM32H7 || SOC_SERIES_STM32F7 */
  453. rt_memcpy(recv_buf, p_txrx_buffer, send_length);
  454. }
  455. #if defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32F7)
  456. rt_free_align(dma_aligned_buffer);
  457. #else
  458. rt_free(dma_aligned_buffer);
  459. #endif /* SOC_SERIES_STM32H7 || SOC_SERIES_STM32F7 */
  460. }
  461. }
  462. if (message->cs_release && !(device->config.mode & RT_SPI_NO_CS) && (device->cs_pin != PIN_NONE))
  463. {
  464. if (device->config.mode & RT_SPI_CS_HIGH)
  465. rt_pin_write(device->cs_pin, PIN_LOW);
  466. else
  467. rt_pin_write(device->cs_pin, PIN_HIGH);
  468. }
  469. if(state != HAL_OK)
  470. {
  471. return -RT_ERROR;
  472. }
  473. return message->length;
  474. }
  475. static rt_err_t spi_configure(struct rt_spi_device *device,
  476. struct rt_spi_configuration *configuration)
  477. {
  478. RT_ASSERT(device != RT_NULL);
  479. RT_ASSERT(configuration != RT_NULL);
  480. struct stm32_spi *spi_drv = rt_container_of(device->bus, struct stm32_spi, spi_bus);
  481. spi_drv->cfg = configuration;
  482. return stm32_spi_init(spi_drv, configuration);
  483. }
  484. static const struct rt_spi_ops stm_spi_ops =
  485. {
  486. .configure = spi_configure,
  487. .xfer = spixfer,
  488. };
  489. static int rt_hw_spi_bus_init(void)
  490. {
  491. rt_err_t result;
  492. for (rt_size_t i = 0; i < sizeof(spi_config) / sizeof(spi_config[0]); i++)
  493. {
  494. spi_bus_obj[i].config = &spi_config[i];
  495. spi_bus_obj[i].spi_bus.parent.user_data = &spi_config[i];
  496. spi_bus_obj[i].handle.Instance = spi_config[i].Instance;
  497. if (spi_bus_obj[i].spi_dma_flag & SPI_USING_RX_DMA_FLAG)
  498. {
  499. /* Configure the DMA handler for Transmission process */
  500. spi_bus_obj[i].dma.handle_rx.Instance = spi_config[i].dma_rx->Instance;
  501. #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)
  502. spi_bus_obj[i].dma.handle_rx.Init.Channel = spi_config[i].dma_rx->channel;
  503. #elif defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32WB) || defined(SOC_SERIES_STM32H7)
  504. spi_bus_obj[i].dma.handle_rx.Init.Request = spi_config[i].dma_rx->request;
  505. #endif
  506. #ifndef SOC_SERIES_STM32U5
  507. spi_bus_obj[i].dma.handle_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
  508. spi_bus_obj[i].dma.handle_rx.Init.PeriphInc = DMA_PINC_DISABLE;
  509. spi_bus_obj[i].dma.handle_rx.Init.MemInc = DMA_MINC_ENABLE;
  510. spi_bus_obj[i].dma.handle_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  511. spi_bus_obj[i].dma.handle_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  512. spi_bus_obj[i].dma.handle_rx.Init.Mode = DMA_NORMAL;
  513. spi_bus_obj[i].dma.handle_rx.Init.Priority = DMA_PRIORITY_HIGH;
  514. #endif
  515. #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7)
  516. spi_bus_obj[i].dma.handle_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  517. spi_bus_obj[i].dma.handle_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
  518. spi_bus_obj[i].dma.handle_rx.Init.MemBurst = DMA_MBURST_INC4;
  519. spi_bus_obj[i].dma.handle_rx.Init.PeriphBurst = DMA_PBURST_INC4;
  520. #endif
  521. {
  522. rt_uint32_t tmpreg = 0x00U;
  523. #if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32F0)
  524. /* enable DMA clock && Delay after an RCC peripheral clock enabling*/
  525. SET_BIT(RCC->AHBENR, spi_config[i].dma_rx->dma_rcc);
  526. tmpreg = READ_BIT(RCC->AHBENR, spi_config[i].dma_rx->dma_rcc);
  527. #elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32WB) || defined(SOC_SERIES_STM32H7)
  528. SET_BIT(RCC->AHB1ENR, spi_config[i].dma_rx->dma_rcc);
  529. /* Delay after an RCC peripheral clock enabling */
  530. tmpreg = READ_BIT(RCC->AHB1ENR, spi_config[i].dma_rx->dma_rcc);
  531. #elif defined(SOC_SERIES_STM32MP1)
  532. __HAL_RCC_DMAMUX_CLK_ENABLE();
  533. SET_BIT(RCC->MP_AHB2ENSETR, spi_config[i].dma_rx->dma_rcc);
  534. tmpreg = READ_BIT(RCC->MP_AHB2ENSETR, spi_config[i].dma_rx->dma_rcc);
  535. #endif
  536. UNUSED(tmpreg); /* To avoid compiler warnings */
  537. }
  538. }
  539. if (spi_bus_obj[i].spi_dma_flag & SPI_USING_TX_DMA_FLAG)
  540. {
  541. /* Configure the DMA handler for Transmission process */
  542. spi_bus_obj[i].dma.handle_tx.Instance = spi_config[i].dma_tx->Instance;
  543. #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)
  544. spi_bus_obj[i].dma.handle_tx.Init.Channel = spi_config[i].dma_tx->channel;
  545. #elif defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32WB) || defined(SOC_SERIES_STM32H7)
  546. spi_bus_obj[i].dma.handle_tx.Init.Request = spi_config[i].dma_tx->request;
  547. #endif
  548. #ifndef SOC_SERIES_STM32U5
  549. spi_bus_obj[i].dma.handle_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
  550. spi_bus_obj[i].dma.handle_tx.Init.PeriphInc = DMA_PINC_DISABLE;
  551. spi_bus_obj[i].dma.handle_tx.Init.MemInc = DMA_MINC_ENABLE;
  552. spi_bus_obj[i].dma.handle_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  553. spi_bus_obj[i].dma.handle_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  554. spi_bus_obj[i].dma.handle_tx.Init.Mode = DMA_NORMAL;
  555. spi_bus_obj[i].dma.handle_tx.Init.Priority = DMA_PRIORITY_LOW;
  556. #endif
  557. #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7)
  558. spi_bus_obj[i].dma.handle_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  559. spi_bus_obj[i].dma.handle_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
  560. spi_bus_obj[i].dma.handle_tx.Init.MemBurst = DMA_MBURST_INC4;
  561. spi_bus_obj[i].dma.handle_tx.Init.PeriphBurst = DMA_PBURST_INC4;
  562. #endif
  563. {
  564. rt_uint32_t tmpreg = 0x00U;
  565. #if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32F0)
  566. /* enable DMA clock && Delay after an RCC peripheral clock enabling*/
  567. SET_BIT(RCC->AHBENR, spi_config[i].dma_tx->dma_rcc);
  568. tmpreg = READ_BIT(RCC->AHBENR, spi_config[i].dma_tx->dma_rcc);
  569. #elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32WB) || defined(SOC_SERIES_STM32H7)
  570. SET_BIT(RCC->AHB1ENR, spi_config[i].dma_tx->dma_rcc);
  571. /* Delay after an RCC peripheral clock enabling */
  572. tmpreg = READ_BIT(RCC->AHB1ENR, spi_config[i].dma_tx->dma_rcc);
  573. #elif defined(SOC_SERIES_STM32MP1)
  574. __HAL_RCC_DMAMUX_CLK_ENABLE();
  575. SET_BIT(RCC->MP_AHB2ENSETR, spi_config[i].dma_tx->dma_rcc);
  576. tmpreg = READ_BIT(RCC->MP_AHB2ENSETR, spi_config[i].dma_tx->dma_rcc);
  577. #endif
  578. UNUSED(tmpreg); /* To avoid compiler warnings */
  579. }
  580. }
  581. /* initialize completion object */
  582. rt_completion_init(&spi_bus_obj[i].cpt);
  583. result = rt_spi_bus_register(&spi_bus_obj[i].spi_bus, spi_config[i].bus_name, &stm_spi_ops);
  584. RT_ASSERT(result == RT_EOK);
  585. LOG_D("%s bus init done", spi_config[i].bus_name);
  586. }
  587. return result;
  588. }
  589. /**
  590. * Attach the spi device to SPI bus, this function must be used after initialization.
  591. */
  592. rt_err_t rt_hw_spi_device_attach(const char *bus_name, const char *device_name, rt_base_t cs_pin)
  593. {
  594. RT_ASSERT(bus_name != RT_NULL);
  595. RT_ASSERT(device_name != RT_NULL);
  596. rt_err_t result;
  597. struct rt_spi_device *spi_device;
  598. /* attach the device to spi bus*/
  599. spi_device = (struct rt_spi_device *)rt_malloc(sizeof(struct rt_spi_device));
  600. RT_ASSERT(spi_device != RT_NULL);
  601. result = rt_spi_bus_attach_device_cspin(spi_device, device_name, bus_name, cs_pin, RT_NULL);
  602. if (result != RT_EOK)
  603. {
  604. LOG_E("%s attach to %s faild, %d\n", device_name, bus_name, result);
  605. }
  606. RT_ASSERT(result == RT_EOK);
  607. LOG_D("%s attach to %s done", device_name, bus_name);
  608. return result;
  609. }
  610. #if defined(BSP_SPI1_TX_USING_DMA) || defined(BSP_SPI1_RX_USING_DMA)
  611. void SPI1_IRQHandler(void)
  612. {
  613. /* enter interrupt */
  614. rt_interrupt_enter();
  615. HAL_SPI_IRQHandler(&spi_bus_obj[SPI1_INDEX].handle);
  616. /* leave interrupt */
  617. rt_interrupt_leave();
  618. }
  619. #endif
  620. #if defined(BSP_USING_SPI1) && defined(BSP_SPI1_RX_USING_DMA)
  621. /**
  622. * @brief This function handles DMA Rx interrupt request.
  623. * @param None
  624. * @retval None
  625. */
  626. void SPI1_DMA_RX_IRQHandler(void)
  627. {
  628. /* enter interrupt */
  629. rt_interrupt_enter();
  630. HAL_DMA_IRQHandler(&spi_bus_obj[SPI1_INDEX].dma.handle_rx);
  631. /* leave interrupt */
  632. rt_interrupt_leave();
  633. }
  634. #endif
  635. #if defined(BSP_USING_SPI1) && defined(BSP_SPI1_TX_USING_DMA)
  636. /**
  637. * @brief This function handles DMA Tx interrupt request.
  638. * @param None
  639. * @retval None
  640. */
  641. void SPI1_DMA_TX_IRQHandler(void)
  642. {
  643. /* enter interrupt */
  644. rt_interrupt_enter();
  645. HAL_DMA_IRQHandler(&spi_bus_obj[SPI1_INDEX].dma.handle_tx);
  646. /* leave interrupt */
  647. rt_interrupt_leave();
  648. }
  649. #endif /* defined(BSP_USING_SPI1) && defined(BSP_SPI_USING_DMA) */
  650. #if defined(BSP_SPI2_TX_USING_DMA) || defined(BSP_SPI2_RX_USING_DMA)
  651. void SPI2_IRQHandler(void)
  652. {
  653. /* enter interrupt */
  654. rt_interrupt_enter();
  655. HAL_SPI_IRQHandler(&spi_bus_obj[SPI2_INDEX].handle);
  656. /* leave interrupt */
  657. rt_interrupt_leave();
  658. }
  659. #endif
  660. #if defined(BSP_USING_SPI2) && defined(BSP_SPI2_RX_USING_DMA)
  661. /**
  662. * @brief This function handles DMA Rx interrupt request.
  663. * @param None
  664. * @retval None
  665. */
  666. void SPI2_DMA_RX_IRQHandler(void)
  667. {
  668. /* enter interrupt */
  669. rt_interrupt_enter();
  670. HAL_DMA_IRQHandler(&spi_bus_obj[SPI2_INDEX].dma.handle_rx);
  671. /* leave interrupt */
  672. rt_interrupt_leave();
  673. }
  674. #endif
  675. #if defined(BSP_USING_SPI2) && defined(BSP_SPI2_TX_USING_DMA)
  676. /**
  677. * @brief This function handles DMA Tx interrupt request.
  678. * @param None
  679. * @retval None
  680. */
  681. void SPI2_DMA_TX_IRQHandler(void)
  682. {
  683. /* enter interrupt */
  684. rt_interrupt_enter();
  685. HAL_DMA_IRQHandler(&spi_bus_obj[SPI2_INDEX].dma.handle_tx);
  686. /* leave interrupt */
  687. rt_interrupt_leave();
  688. }
  689. #endif /* defined(BSP_USING_SPI2) && defined(BSP_SPI_USING_DMA) */
  690. #if defined(BSP_SPI3_TX_USING_DMA) || defined(BSP_SPI3_RX_USING_DMA)
  691. void SPI3_IRQHandler(void)
  692. {
  693. /* enter interrupt */
  694. rt_interrupt_enter();
  695. HAL_SPI_IRQHandler(&spi_bus_obj[SPI3_INDEX].handle);
  696. /* leave interrupt */
  697. rt_interrupt_leave();
  698. }
  699. #endif
  700. #if defined(BSP_USING_SPI3) && defined(BSP_SPI3_RX_USING_DMA)
  701. /**
  702. * @brief This function handles DMA Rx interrupt request.
  703. * @param None
  704. * @retval None
  705. */
  706. void SPI3_DMA_RX_IRQHandler(void)
  707. {
  708. /* enter interrupt */
  709. rt_interrupt_enter();
  710. HAL_DMA_IRQHandler(&spi_bus_obj[SPI3_INDEX].dma.handle_rx);
  711. /* leave interrupt */
  712. rt_interrupt_leave();
  713. }
  714. #endif
  715. #if defined(BSP_USING_SPI3) && defined(BSP_SPI3_TX_USING_DMA)
  716. /**
  717. * @brief This function handles DMA Tx interrupt request.
  718. * @param None
  719. * @retval None
  720. */
  721. void SPI3_DMA_TX_IRQHandler(void)
  722. {
  723. /* enter interrupt */
  724. rt_interrupt_enter();
  725. HAL_DMA_IRQHandler(&spi_bus_obj[SPI3_INDEX].dma.handle_tx);
  726. /* leave interrupt */
  727. rt_interrupt_leave();
  728. }
  729. #endif /* defined(BSP_USING_SPI3) && defined(BSP_SPI_USING_DMA) */
  730. #if defined(BSP_SPI4_TX_USING_DMA) || defined(BSP_SPI4_RX_USING_DMA)
  731. void SPI4_IRQHandler(void)
  732. {
  733. /* enter interrupt */
  734. rt_interrupt_enter();
  735. HAL_SPI_IRQHandler(&spi_bus_obj[SPI4_INDEX].handle);
  736. /* leave interrupt */
  737. rt_interrupt_leave();
  738. }
  739. #endif
  740. #if defined(BSP_USING_SPI4) && defined(BSP_SPI4_RX_USING_DMA)
  741. /**
  742. * @brief This function handles DMA Rx interrupt request.
  743. * @param None
  744. * @retval None
  745. */
  746. void SPI4_DMA_RX_IRQHandler(void)
  747. {
  748. /* enter interrupt */
  749. rt_interrupt_enter();
  750. HAL_DMA_IRQHandler(&spi_bus_obj[SPI4_INDEX].dma.handle_rx);
  751. /* leave interrupt */
  752. rt_interrupt_leave();
  753. }
  754. #endif
  755. #if defined(BSP_USING_SPI4) && defined(BSP_SPI4_TX_USING_DMA)
  756. /**
  757. * @brief This function handles DMA Tx interrupt request.
  758. * @param None
  759. * @retval None
  760. */
  761. void SPI4_DMA_TX_IRQHandler(void)
  762. {
  763. /* enter interrupt */
  764. rt_interrupt_enter();
  765. HAL_DMA_IRQHandler(&spi_bus_obj[SPI4_INDEX].dma.handle_tx);
  766. /* leave interrupt */
  767. rt_interrupt_leave();
  768. }
  769. #endif /* defined(BSP_USING_SPI4) && defined(BSP_SPI_USING_DMA) */
  770. #if defined(BSP_SPI5_TX_USING_DMA) || defined(BSP_SPI5_RX_USING_DMA)
  771. void SPI5_IRQHandler(void)
  772. {
  773. /* enter interrupt */
  774. rt_interrupt_enter();
  775. HAL_SPI_IRQHandler(&spi_bus_obj[SPI5_INDEX].handle);
  776. /* leave interrupt */
  777. rt_interrupt_leave();
  778. }
  779. #endif
  780. #if defined(BSP_USING_SPI5) && defined(BSP_SPI5_RX_USING_DMA)
  781. /**
  782. * @brief This function handles DMA Rx interrupt request.
  783. * @param None
  784. * @retval None
  785. */
  786. void SPI5_DMA_RX_IRQHandler(void)
  787. {
  788. /* enter interrupt */
  789. rt_interrupt_enter();
  790. HAL_DMA_IRQHandler(&spi_bus_obj[SPI5_INDEX].dma.handle_rx);
  791. /* leave interrupt */
  792. rt_interrupt_leave();
  793. }
  794. #endif
  795. #if defined(BSP_USING_SPI5) && defined(BSP_SPI5_TX_USING_DMA)
  796. /**
  797. * @brief This function handles DMA Tx interrupt request.
  798. * @param None
  799. * @retval None
  800. */
  801. void SPI5_DMA_TX_IRQHandler(void)
  802. {
  803. /* enter interrupt */
  804. rt_interrupt_enter();
  805. HAL_DMA_IRQHandler(&spi_bus_obj[SPI5_INDEX].dma.handle_tx);
  806. /* leave interrupt */
  807. rt_interrupt_leave();
  808. }
  809. #endif /* defined(BSP_USING_SPI5) && defined(BSP_SPI_USING_DMA) */
  810. #if defined(BSP_USING_SPI6) && defined(BSP_SPI6_RX_USING_DMA)
  811. /**
  812. * @brief This function handles DMA Rx interrupt request.
  813. * @param None
  814. * @retval None
  815. */
  816. void SPI6_DMA_RX_IRQHandler(void)
  817. {
  818. /* enter interrupt */
  819. rt_interrupt_enter();
  820. HAL_DMA_IRQHandler(&spi_bus_obj[SPI6_INDEX].dma.handle_rx);
  821. /* leave interrupt */
  822. rt_interrupt_leave();
  823. }
  824. #endif
  825. #if defined(BSP_USING_SPI6) && defined(BSP_SPI6_TX_USING_DMA)
  826. /**
  827. * @brief This function handles DMA Tx interrupt request.
  828. * @param None
  829. * @retval None
  830. */
  831. void SPI6_DMA_TX_IRQHandler(void)
  832. {
  833. /* enter interrupt */
  834. rt_interrupt_enter();
  835. HAL_DMA_IRQHandler(&spi_bus_obj[SPI6_INDEX].dma.handle_tx);
  836. /* leave interrupt */
  837. rt_interrupt_leave();
  838. }
  839. #endif /* defined(BSP_USING_SPI6) && defined(BSP_SPI_USING_DMA) */
  840. static void stm32_get_dma_info(void)
  841. {
  842. #ifdef BSP_SPI1_RX_USING_DMA
  843. spi_bus_obj[SPI1_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG;
  844. static struct dma_config spi1_dma_rx = SPI1_RX_DMA_CONFIG;
  845. spi_config[SPI1_INDEX].dma_rx = &spi1_dma_rx;
  846. #endif
  847. #ifdef BSP_SPI1_TX_USING_DMA
  848. spi_bus_obj[SPI1_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG;
  849. static struct dma_config spi1_dma_tx = SPI1_TX_DMA_CONFIG;
  850. spi_config[SPI1_INDEX].dma_tx = &spi1_dma_tx;
  851. #endif
  852. #ifdef BSP_SPI2_RX_USING_DMA
  853. spi_bus_obj[SPI2_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG;
  854. static struct dma_config spi2_dma_rx = SPI2_RX_DMA_CONFIG;
  855. spi_config[SPI2_INDEX].dma_rx = &spi2_dma_rx;
  856. #endif
  857. #ifdef BSP_SPI2_TX_USING_DMA
  858. spi_bus_obj[SPI2_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG;
  859. static struct dma_config spi2_dma_tx = SPI2_TX_DMA_CONFIG;
  860. spi_config[SPI2_INDEX].dma_tx = &spi2_dma_tx;
  861. #endif
  862. #ifdef BSP_SPI3_RX_USING_DMA
  863. spi_bus_obj[SPI3_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG;
  864. static struct dma_config spi3_dma_rx = SPI3_RX_DMA_CONFIG;
  865. spi_config[SPI3_INDEX].dma_rx = &spi3_dma_rx;
  866. #endif
  867. #ifdef BSP_SPI3_TX_USING_DMA
  868. spi_bus_obj[SPI3_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG;
  869. static struct dma_config spi3_dma_tx = SPI3_TX_DMA_CONFIG;
  870. spi_config[SPI3_INDEX].dma_tx = &spi3_dma_tx;
  871. #endif
  872. #ifdef BSP_SPI4_RX_USING_DMA
  873. spi_bus_obj[SPI4_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG;
  874. static struct dma_config spi4_dma_rx = SPI4_RX_DMA_CONFIG;
  875. spi_config[SPI4_INDEX].dma_rx = &spi4_dma_rx;
  876. #endif
  877. #ifdef BSP_SPI4_TX_USING_DMA
  878. spi_bus_obj[SPI4_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG;
  879. static struct dma_config spi4_dma_tx = SPI4_TX_DMA_CONFIG;
  880. spi_config[SPI4_INDEX].dma_tx = &spi4_dma_tx;
  881. #endif
  882. #ifdef BSP_SPI5_RX_USING_DMA
  883. spi_bus_obj[SPI5_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG;
  884. static struct dma_config spi5_dma_rx = SPI5_RX_DMA_CONFIG;
  885. spi_config[SPI5_INDEX].dma_rx = &spi5_dma_rx;
  886. #endif
  887. #ifdef BSP_SPI5_TX_USING_DMA
  888. spi_bus_obj[SPI5_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG;
  889. static struct dma_config spi5_dma_tx = SPI5_TX_DMA_CONFIG;
  890. spi_config[SPI5_INDEX].dma_tx = &spi5_dma_tx;
  891. #endif
  892. #ifdef BSP_SPI6_RX_USING_DMA
  893. spi_bus_obj[SPI6_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG;
  894. static struct dma_config spi6_dma_rx = SPI6_RX_DMA_CONFIG;
  895. spi_config[SPI6_INDEX].dma_rx = &spi6_dma_rx;
  896. #endif
  897. #ifdef BSP_SPI6_TX_USING_DMA
  898. spi_bus_obj[SPI6_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG;
  899. static struct dma_config spi6_dma_tx = SPI6_TX_DMA_CONFIG;
  900. spi_config[SPI6_INDEX].dma_tx = &spi6_dma_tx;
  901. #endif
  902. }
  903. void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)
  904. {
  905. struct stm32_spi *spi_drv = rt_container_of(hspi, struct stm32_spi, handle);
  906. rt_completion_done(&spi_drv->cpt);
  907. }
  908. void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
  909. {
  910. struct stm32_spi *spi_drv = rt_container_of(hspi, struct stm32_spi, handle);
  911. rt_completion_done(&spi_drv->cpt);
  912. }
  913. void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)
  914. {
  915. struct stm32_spi *spi_drv = rt_container_of(hspi, struct stm32_spi, handle);
  916. rt_completion_done(&spi_drv->cpt);
  917. }
  918. #if defined(SOC_SERIES_STM32F0)
  919. void SPI1_DMA_RX_TX_IRQHandler(void)
  920. {
  921. #if defined(BSP_USING_SPI1) && defined(BSP_SPI1_TX_USING_DMA)
  922. SPI1_DMA_TX_IRQHandler();
  923. #endif
  924. #if defined(BSP_USING_SPI1) && defined(BSP_SPI1_RX_USING_DMA)
  925. SPI1_DMA_RX_IRQHandler();
  926. #endif
  927. }
  928. void SPI2_DMA_RX_TX_IRQHandler(void)
  929. {
  930. #if defined(BSP_USING_SPI2) && defined(BSP_SPI2_TX_USING_DMA)
  931. SPI2_DMA_TX_IRQHandler();
  932. #endif
  933. #if defined(BSP_USING_SPI2) && defined(BSP_SPI2_RX_USING_DMA)
  934. SPI2_DMA_RX_IRQHandler();
  935. #endif
  936. }
  937. #elif defined(SOC_SERIES_STM32G0)
  938. #if defined(BSP_SPI1_TX_USING_DMA) || defined(BSP_SPI1_RX_USING_DMA)
  939. void SPI1_DMA_RX_TX_IRQHandler(void)
  940. {
  941. #if defined(BSP_SPI1_TX_USING_DMA)
  942. SPI1_DMA_TX_IRQHandler();
  943. #endif
  944. #if defined(BSP_SPI1_RX_USING_DMA)
  945. SPI1_DMA_RX_IRQHandler();
  946. #endif
  947. }
  948. #endif /* defined(BSP_SPI1_TX_USING_DMA) || defined(BSP_SPI1_RX_USING_DMA) */
  949. #if defined(BSP_SPI2_TX_USING_DMA) || defined(BSP_SPI2_RX_USING_DMA)
  950. void SPI2_DMA_RX_TX_IRQHandler(void)
  951. {
  952. #if defined(BSP_SPI2_TX_USING_DMA)
  953. SPI2_DMA_TX_IRQHandler();
  954. #endif
  955. #if defined(BSP_SPI2_RX_USING_DMA)
  956. SPI2_DMA_RX_IRQHandler();
  957. #endif
  958. }
  959. #endif /* defined(BSP_SPI1_TX_USING_DMA) || defined(BSP_SPI1_RX_USING_DMA) */
  960. #if defined(STM32G0B0xx) || defined(STM32G0B1xx) || defined(STM32G0C1xx)
  961. #if defined(BSP_USING_SPI2) || defined(BSP_USING_SPI3)
  962. void SPI2_3_IRQHandler(void)
  963. {
  964. #if defined(BSP_SPI2_TX_USING_DMA) || defined(BSP_SPI2_RX_USING_DMA)
  965. SPI2_IRQHandler();
  966. #endif
  967. #if defined(BSP_SPI3_TX_USING_DMA) || defined(BSP_SPI3_RX_USING_DMA)
  968. SPI3_IRQHandler();
  969. #endif
  970. }
  971. #endif /* defined(BSP_USING_SPI2) || defined(BSP_USING_SPI3) */
  972. #endif /* defined(STM32G0B0xx) || defined(STM32G0B1xx) || defined(STM32G0C1xx) */
  973. #endif /* defined(SOC_SERIES_STM32F0) */
  974. int rt_hw_spi_init(void)
  975. {
  976. stm32_get_dma_info();
  977. return rt_hw_spi_bus_init();
  978. }
  979. INIT_BOARD_EXPORT(rt_hw_spi_init);
  980. #endif /* BSP_USING_SPI1 || BSP_USING_SPI2 || BSP_USING_SPI3 || BSP_USING_SPI4 || BSP_USING_SPI5 */
  981. #endif /* BSP_USING_SPI */