spi_core.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504
  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. * 2012-01-08 bernard first version.
  9. * 2012-02-03 bernard add const attribute to the ops.
  10. * 2012-05-15 dzzxzz fixed the return value in attach_device.
  11. * 2012-05-18 bernard Changed SPI message to message list.
  12. * Added take/release SPI device/bus interface.
  13. * 2012-09-28 aozima fixed rt_spi_release_bus assert error.
  14. */
  15. #include <drivers/spi.h>
  16. extern rt_err_t rt_spi_bus_device_init(struct rt_spi_bus *bus, const char *name);
  17. extern rt_err_t rt_spidev_device_init(struct rt_spi_device *dev, const char *name);
  18. rt_err_t rt_spi_bus_register(struct rt_spi_bus *bus,
  19. const char *name,
  20. const struct rt_spi_ops *ops)
  21. {
  22. rt_err_t result;
  23. result = rt_spi_bus_device_init(bus, name);
  24. if (result != RT_EOK)
  25. return result;
  26. /* initialize mutex lock */
  27. rt_mutex_init(&(bus->lock), name, RT_IPC_FLAG_PRIO);
  28. /* set ops */
  29. bus->ops = ops;
  30. /* initialize owner */
  31. bus->owner = RT_NULL;
  32. /* set bus mode */
  33. bus->mode = RT_SPI_BUS_MODE_SPI;
  34. return RT_EOK;
  35. }
  36. rt_err_t rt_spi_bus_attach_device_cspin(struct rt_spi_device *device,
  37. const char *name,
  38. const char *bus_name,
  39. rt_base_t cs_pin,
  40. void *user_data)
  41. {
  42. rt_err_t result;
  43. rt_device_t bus;
  44. /* get physical spi bus */
  45. bus = rt_device_find(bus_name);
  46. if (bus != RT_NULL && bus->type == RT_Device_Class_SPIBUS)
  47. {
  48. device->bus = (struct rt_spi_bus *)bus;
  49. /* initialize spidev device */
  50. result = rt_spidev_device_init(device, name);
  51. if (result != RT_EOK)
  52. return result;
  53. if(cs_pin != PIN_NONE)
  54. {
  55. rt_pin_mode(cs_pin, PIN_MODE_OUTPUT);
  56. }
  57. rt_memset(&device->config, 0, sizeof(device->config));
  58. device->parent.user_data = user_data;
  59. device->cs_pin = cs_pin;
  60. return RT_EOK;
  61. }
  62. /* not found the host bus */
  63. return -RT_ERROR;
  64. }
  65. rt_err_t rt_spi_bus_attach_device(struct rt_spi_device *device,
  66. const char *name,
  67. const char *bus_name,
  68. void *user_data)
  69. {
  70. return rt_spi_bus_attach_device_cspin(device, name, bus_name, PIN_NONE, user_data);
  71. }
  72. rt_err_t rt_spi_configure(struct rt_spi_device *device,
  73. struct rt_spi_configuration *cfg)
  74. {
  75. rt_err_t result;
  76. RT_ASSERT(device != RT_NULL);
  77. /* set configuration */
  78. device->config.data_width = cfg->data_width;
  79. device->config.mode = cfg->mode & RT_SPI_MODE_MASK ;
  80. device->config.max_hz = cfg->max_hz ;
  81. if (device->cs_pin != PIN_NONE)
  82. {
  83. if (device->config.mode & RT_SPI_CS_HIGH)
  84. rt_pin_write(device->cs_pin, PIN_LOW);
  85. else
  86. rt_pin_write(device->cs_pin, PIN_HIGH);
  87. }
  88. if (device->bus != RT_NULL)
  89. {
  90. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  91. if (result == RT_EOK)
  92. {
  93. if (device->bus->owner == device)
  94. {
  95. device->bus->ops->configure(device, &device->config);
  96. }
  97. /* release lock */
  98. rt_mutex_release(&(device->bus->lock));
  99. }
  100. }
  101. return RT_EOK;
  102. }
  103. rt_err_t rt_spi_send_then_send(struct rt_spi_device *device,
  104. const void *send_buf1,
  105. rt_size_t send_length1,
  106. const void *send_buf2,
  107. rt_size_t send_length2)
  108. {
  109. rt_err_t result;
  110. struct rt_spi_message message;
  111. RT_ASSERT(device != RT_NULL);
  112. RT_ASSERT(device->bus != RT_NULL);
  113. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  114. if (result == RT_EOK)
  115. {
  116. if (device->bus->owner != device)
  117. {
  118. /* not the same owner as current, re-configure SPI bus */
  119. result = device->bus->ops->configure(device, &device->config);
  120. if (result == RT_EOK)
  121. {
  122. /* set SPI bus owner */
  123. device->bus->owner = device;
  124. }
  125. else
  126. {
  127. /* configure SPI bus failed */
  128. result = -RT_EIO;
  129. goto __exit;
  130. }
  131. }
  132. /* send data1 */
  133. message.send_buf = send_buf1;
  134. message.recv_buf = RT_NULL;
  135. message.length = send_length1;
  136. message.cs_take = 1;
  137. message.cs_release = 0;
  138. message.next = RT_NULL;
  139. result = device->bus->ops->xfer(device, &message);
  140. if (result == 0)
  141. {
  142. result = -RT_EIO;
  143. goto __exit;
  144. }
  145. /* send data2 */
  146. message.send_buf = send_buf2;
  147. message.recv_buf = RT_NULL;
  148. message.length = send_length2;
  149. message.cs_take = 0;
  150. message.cs_release = 1;
  151. message.next = RT_NULL;
  152. result = device->bus->ops->xfer(device, &message);
  153. if (result == 0)
  154. {
  155. result = -RT_EIO;
  156. goto __exit;
  157. }
  158. result = RT_EOK;
  159. }
  160. else
  161. {
  162. return -RT_EIO;
  163. }
  164. __exit:
  165. rt_mutex_release(&(device->bus->lock));
  166. return result;
  167. }
  168. rt_err_t rt_spi_send_then_recv(struct rt_spi_device *device,
  169. const void *send_buf,
  170. rt_size_t send_length,
  171. void *recv_buf,
  172. rt_size_t recv_length)
  173. {
  174. rt_err_t result;
  175. struct rt_spi_message message;
  176. RT_ASSERT(device != RT_NULL);
  177. RT_ASSERT(device->bus != RT_NULL);
  178. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  179. if (result == RT_EOK)
  180. {
  181. if (device->bus->owner != device)
  182. {
  183. /* not the same owner as current, re-configure SPI bus */
  184. result = device->bus->ops->configure(device, &device->config);
  185. if (result == RT_EOK)
  186. {
  187. /* set SPI bus owner */
  188. device->bus->owner = device;
  189. }
  190. else
  191. {
  192. /* configure SPI bus failed */
  193. result = -RT_EIO;
  194. goto __exit;
  195. }
  196. }
  197. /* send data */
  198. message.send_buf = send_buf;
  199. message.recv_buf = RT_NULL;
  200. message.length = send_length;
  201. message.cs_take = 1;
  202. message.cs_release = 0;
  203. message.next = RT_NULL;
  204. result = device->bus->ops->xfer(device, &message);
  205. if (result == 0)
  206. {
  207. result = -RT_EIO;
  208. goto __exit;
  209. }
  210. /* recv data */
  211. message.send_buf = RT_NULL;
  212. message.recv_buf = recv_buf;
  213. message.length = recv_length;
  214. message.cs_take = 0;
  215. message.cs_release = 1;
  216. message.next = RT_NULL;
  217. result = device->bus->ops->xfer(device, &message);
  218. if (result == 0)
  219. {
  220. result = -RT_EIO;
  221. goto __exit;
  222. }
  223. result = RT_EOK;
  224. }
  225. else
  226. {
  227. return -RT_EIO;
  228. }
  229. __exit:
  230. rt_mutex_release(&(device->bus->lock));
  231. return result;
  232. }
  233. rt_size_t rt_spi_transfer(struct rt_spi_device *device,
  234. const void *send_buf,
  235. void *recv_buf,
  236. rt_size_t length)
  237. {
  238. rt_err_t result;
  239. struct rt_spi_message message;
  240. RT_ASSERT(device != RT_NULL);
  241. RT_ASSERT(device->bus != RT_NULL);
  242. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  243. if (result == RT_EOK)
  244. {
  245. if (device->bus->owner != device)
  246. {
  247. /* not the same owner as current, re-configure SPI bus */
  248. result = device->bus->ops->configure(device, &device->config);
  249. if (result == RT_EOK)
  250. {
  251. /* set SPI bus owner */
  252. device->bus->owner = device;
  253. }
  254. else
  255. {
  256. /* configure SPI bus failed */
  257. rt_set_errno(-RT_EIO);
  258. result = 0;
  259. goto __exit;
  260. }
  261. }
  262. /* initial message */
  263. message.send_buf = send_buf;
  264. message.recv_buf = recv_buf;
  265. message.length = length;
  266. message.cs_take = 1;
  267. message.cs_release = 1;
  268. message.next = RT_NULL;
  269. /* transfer message */
  270. result = device->bus->ops->xfer(device, &message);
  271. if (result == 0)
  272. {
  273. rt_set_errno(-RT_EIO);
  274. goto __exit;
  275. }
  276. }
  277. else
  278. {
  279. rt_set_errno(-RT_EIO);
  280. return 0;
  281. }
  282. __exit:
  283. rt_mutex_release(&(device->bus->lock));
  284. return result;
  285. }
  286. rt_uint16_t rt_spi_sendrecv16(struct rt_spi_device *device,
  287. rt_uint16_t data)
  288. {
  289. rt_uint16_t value = 0;
  290. rt_uint16_t tmp;
  291. if (device->config.mode & RT_SPI_MSB)
  292. {
  293. tmp = ((data & 0xff00) >> 8) | ((data & 0x00ff) << 8);
  294. data = tmp;
  295. }
  296. rt_spi_send_then_recv(device, &data, 2, &value, 2);
  297. if (device->config.mode & RT_SPI_MSB)
  298. {
  299. tmp = ((value & 0xff00) >> 8) | ((value & 0x00ff) << 8);
  300. value = tmp;
  301. }
  302. return value;
  303. }
  304. struct rt_spi_message *rt_spi_transfer_message(struct rt_spi_device *device,
  305. struct rt_spi_message *message)
  306. {
  307. rt_err_t result;
  308. struct rt_spi_message *index;
  309. RT_ASSERT(device != RT_NULL);
  310. /* get first message */
  311. index = message;
  312. if (index == RT_NULL)
  313. return index;
  314. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  315. if (result != RT_EOK)
  316. {
  317. rt_set_errno(-RT_EBUSY);
  318. return index;
  319. }
  320. /* reset errno */
  321. rt_set_errno(RT_EOK);
  322. /* configure SPI bus */
  323. if (device->bus->owner != device)
  324. {
  325. /* not the same owner as current, re-configure SPI bus */
  326. result = device->bus->ops->configure(device, &device->config);
  327. if (result == RT_EOK)
  328. {
  329. /* set SPI bus owner */
  330. device->bus->owner = device;
  331. }
  332. else
  333. {
  334. /* configure SPI bus failed */
  335. rt_set_errno(-RT_EIO);
  336. goto __exit;
  337. }
  338. }
  339. /* transmit each SPI message */
  340. while (index != RT_NULL)
  341. {
  342. /* transmit SPI message */
  343. result = device->bus->ops->xfer(device, index);
  344. if (result == 0)
  345. {
  346. rt_set_errno(-RT_EIO);
  347. break;
  348. }
  349. index = index->next;
  350. }
  351. __exit:
  352. /* release bus lock */
  353. rt_mutex_release(&(device->bus->lock));
  354. return index;
  355. }
  356. rt_err_t rt_spi_take_bus(struct rt_spi_device *device)
  357. {
  358. rt_err_t result = RT_EOK;
  359. RT_ASSERT(device != RT_NULL);
  360. RT_ASSERT(device->bus != RT_NULL);
  361. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  362. if (result != RT_EOK)
  363. {
  364. rt_set_errno(-RT_EBUSY);
  365. return -RT_EBUSY;
  366. }
  367. /* reset errno */
  368. rt_set_errno(RT_EOK);
  369. /* configure SPI bus */
  370. if (device->bus->owner != device)
  371. {
  372. /* not the same owner as current, re-configure SPI bus */
  373. result = device->bus->ops->configure(device, &device->config);
  374. if (result == RT_EOK)
  375. {
  376. /* set SPI bus owner */
  377. device->bus->owner = device;
  378. }
  379. else
  380. {
  381. /* configure SPI bus failed */
  382. rt_set_errno(-RT_EIO);
  383. /* release lock */
  384. rt_mutex_release(&(device->bus->lock));
  385. return -RT_EIO;
  386. }
  387. }
  388. return result;
  389. }
  390. rt_err_t rt_spi_release_bus(struct rt_spi_device *device)
  391. {
  392. RT_ASSERT(device != RT_NULL);
  393. RT_ASSERT(device->bus != RT_NULL);
  394. RT_ASSERT(device->bus->owner == device);
  395. /* release lock */
  396. rt_mutex_release(&(device->bus->lock));
  397. return RT_EOK;
  398. }
  399. rt_err_t rt_spi_take(struct rt_spi_device *device)
  400. {
  401. rt_err_t result;
  402. struct rt_spi_message message;
  403. RT_ASSERT(device != RT_NULL);
  404. RT_ASSERT(device->bus != RT_NULL);
  405. rt_memset(&message, 0, sizeof(message));
  406. message.cs_take = 1;
  407. result = device->bus->ops->xfer(device, &message);
  408. return result;
  409. }
  410. rt_err_t rt_spi_release(struct rt_spi_device *device)
  411. {
  412. rt_err_t result;
  413. struct rt_spi_message message;
  414. RT_ASSERT(device != RT_NULL);
  415. RT_ASSERT(device->bus != RT_NULL);
  416. rt_memset(&message, 0, sizeof(message));
  417. message.cs_release = 1;
  418. result = device->bus->ops->xfer(device, &message);
  419. return result;
  420. }