spi_core.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270
  1. #include <drivers/spi.h>
  2. extern rt_err_t rt_spi_bus_device_init(struct rt_spi_bus* bus, const char* name);
  3. extern rt_err_t rt_spidev_device_init(struct rt_spi_device* dev, const char* name);
  4. rt_err_t rt_spi_bus_register(struct rt_spi_bus* bus, const char* name, const struct rt_spi_ops* ops)
  5. {
  6. rt_err_t result;
  7. result = rt_spi_bus_device_init(bus, name);
  8. if (result != RT_EOK)
  9. return result;
  10. /* initialize mutex lock */
  11. rt_mutex_init(&(bus->lock), name, RT_IPC_FLAG_FIFO);
  12. /* set ops */
  13. bus->ops = ops;
  14. /* initialize owner */
  15. bus->owner = RT_NULL;
  16. return RT_EOK;
  17. }
  18. rt_err_t rt_spi_bus_attach_device(struct rt_spi_device* device, const char* name, const char* bus_name, void* user_data)
  19. {
  20. rt_err_t result;
  21. rt_device_t bus;
  22. /* get physical spi bus */
  23. bus = rt_device_find(bus_name);
  24. if (bus != RT_NULL && bus->type == RT_Device_Class_SPIBUS)
  25. {
  26. device->bus = (struct rt_spi_bus*)bus;
  27. /* initialize spidev device */
  28. result = rt_spidev_device_init(device, name);
  29. if (result != RT_EOK)
  30. return result;
  31. rt_memset(&device->config, 0, sizeof(device->config));
  32. device->parent.user_data = user_data;
  33. return RT_EOK;
  34. }
  35. /* not found the host bus */
  36. return -RT_ERROR;
  37. }
  38. rt_err_t rt_spi_configure(struct rt_spi_device* device, struct rt_spi_configuration* cfg)
  39. {
  40. rt_err_t result;
  41. RT_ASSERT(device != RT_NULL);
  42. /* set configuration */
  43. device->config.data_width = cfg->data_width;
  44. device->config.mode = cfg->mode & RT_SPI_MODE_MASK ;
  45. device->config.max_hz = cfg->max_hz ;
  46. if (device->bus != RT_NULL)
  47. {
  48. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  49. if (result == RT_EOK)
  50. {
  51. if (device->bus->owner == device)
  52. {
  53. device->bus->ops->configure(device, &device->config);
  54. }
  55. /* release lock */
  56. rt_mutex_release(&(device->bus->lock));
  57. }
  58. }
  59. return RT_EOK;
  60. }
  61. rt_err_t rt_spi_send_then_send(struct rt_spi_device* device, const void *send_buf1, rt_size_t send_length1,
  62. const void* send_buf2, rt_size_t send_length2)
  63. {
  64. rt_err_t result;
  65. struct rt_spi_message message;
  66. RT_ASSERT(device != RT_NULL);
  67. RT_ASSERT(device->bus != RT_NULL);
  68. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  69. if (result == RT_EOK)
  70. {
  71. if (device->bus->owner != device)
  72. {
  73. /* not the same owner as current, re-configure SPI bus */
  74. result = device->bus->ops->configure(device, &device->config);
  75. if (result == RT_EOK)
  76. {
  77. /* set SPI bus owner */
  78. device->bus->owner = device;
  79. }
  80. else
  81. {
  82. /* configure SPI bus failed */
  83. result = -RT_EIO;
  84. goto __exit;
  85. }
  86. }
  87. /* send data1 */
  88. message.send_buf = send_buf1;
  89. message.recv_buf = RT_NULL;
  90. message.length = send_length1;
  91. message.cs_take = 1;
  92. message.cs_release = 0;
  93. result = device->bus->ops->xfer(device, &message);
  94. if (result == 0)
  95. {
  96. result = -RT_EIO;
  97. goto __exit;
  98. }
  99. /* send data2 */
  100. message.send_buf = send_buf2;
  101. message.recv_buf = RT_NULL;
  102. message.length = send_length2;
  103. message.cs_take = 0;
  104. message.cs_release = 1;
  105. result = device->bus->ops->xfer(device, &message);
  106. if (result == 0)
  107. {
  108. result = -RT_EIO;
  109. goto __exit;
  110. }
  111. result = RT_EOK;
  112. }
  113. else
  114. {
  115. return -RT_EIO;
  116. }
  117. __exit:
  118. rt_mutex_release(&(device->bus->lock));
  119. return result;
  120. }
  121. rt_err_t rt_spi_send_then_recv(struct rt_spi_device* device, const void *send_buf, rt_size_t send_length,
  122. void* recv_buf, rt_size_t recv_length)
  123. {
  124. rt_err_t result;
  125. struct rt_spi_message message;
  126. RT_ASSERT(device != RT_NULL);
  127. RT_ASSERT(device->bus != RT_NULL);
  128. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  129. if (result == RT_EOK)
  130. {
  131. if (device->bus->owner != device)
  132. {
  133. /* not the same owner as current, re-configure SPI bus */
  134. result = device->bus->ops->configure(device, &device->config);
  135. if (result == RT_EOK)
  136. {
  137. /* set SPI bus owner */
  138. device->bus->owner = device;
  139. }
  140. else
  141. {
  142. /* configure SPI bus failed */
  143. result = -RT_EIO;
  144. goto __exit;
  145. }
  146. }
  147. /* send data */
  148. message.send_buf = send_buf;
  149. message.recv_buf = RT_NULL;
  150. message.length = send_length;
  151. message.cs_take = 1;
  152. message.cs_release = 0;
  153. result = device->bus->ops->xfer(device, &message);
  154. if (result == 0)
  155. {
  156. result = -RT_EIO;
  157. goto __exit;
  158. }
  159. /* recv data */
  160. message.send_buf = RT_NULL;
  161. message.recv_buf = recv_buf;
  162. message.length = recv_length;
  163. message.cs_take = 0;
  164. message.cs_release = 1;
  165. result = device->bus->ops->xfer(device, &message);
  166. if (result == 0)
  167. {
  168. result = -RT_EIO;
  169. goto __exit;
  170. }
  171. result = RT_EOK;
  172. }
  173. else
  174. {
  175. return -RT_EIO;
  176. }
  177. __exit:
  178. rt_mutex_release(&(device->bus->lock));
  179. return result;
  180. }
  181. rt_size_t rt_spi_transfer(struct rt_spi_device* device, const void *send_buf,
  182. void* recv_buf, rt_size_t length)
  183. {
  184. rt_err_t result;
  185. struct rt_spi_message message;
  186. RT_ASSERT(device != RT_NULL);
  187. RT_ASSERT(device->bus != RT_NULL);
  188. result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
  189. if (result == RT_EOK)
  190. {
  191. if (device->bus->owner != device)
  192. {
  193. /* not the same owner as current, re-configure SPI bus */
  194. result = device->bus->ops->configure(device, &device->config);
  195. if (result == RT_EOK)
  196. {
  197. /* set SPI bus owner */
  198. device->bus->owner = device;
  199. }
  200. else
  201. {
  202. /* configure SPI bus failed */
  203. rt_set_errno(-RT_EIO);
  204. result = 0;
  205. goto __exit;
  206. }
  207. }
  208. /* initial message */
  209. message.send_buf = send_buf;
  210. message.recv_buf = recv_buf;
  211. message.length = length;
  212. message.cs_take = message.cs_release = 1;
  213. /* transfer message */
  214. result = device->bus->ops->xfer(device, &message);
  215. if (result == 0)
  216. {
  217. rt_set_errno(-RT_EIO);
  218. goto __exit;
  219. }
  220. }
  221. else
  222. {
  223. rt_set_errno(-RT_EIO);
  224. return 0;
  225. }
  226. __exit:
  227. rt_mutex_release(&(device->bus->lock));
  228. return result;
  229. }