dma-uclass.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Direct Memory Access U-Class driver
  4. *
  5. * Copyright (C) 2018 Álvaro Fernández Rojas <noltari@gmail.com>
  6. * Copyright (C) 2015 - 2018 Texas Instruments Incorporated <www.ti.com>
  7. * Written by Mugunthan V N <mugunthanvnm@ti.com>
  8. *
  9. * Author: Mugunthan V N <mugunthanvnm@ti.com>
  10. */
  11. #include <common.h>
  12. #include <cpu_func.h>
  13. #include <dm.h>
  14. #include <log.h>
  15. #include <malloc.h>
  16. #include <asm/cache.h>
  17. #include <dm/read.h>
  18. #include <dma-uclass.h>
  19. #include <dt-structs.h>
  20. #include <errno.h>
  21. #ifdef CONFIG_DMA_CHANNELS
  22. static inline struct dma_ops *dma_dev_ops(struct udevice *dev)
  23. {
  24. return (struct dma_ops *)dev->driver->ops;
  25. }
  26. # if CONFIG_IS_ENABLED(OF_CONTROL)
  27. static int dma_of_xlate_default(struct dma *dma,
  28. struct ofnode_phandle_args *args)
  29. {
  30. debug("%s(dma=%p)\n", __func__, dma);
  31. if (args->args_count > 1) {
  32. pr_err("Invaild args_count: %d\n", args->args_count);
  33. return -EINVAL;
  34. }
  35. if (args->args_count)
  36. dma->id = args->args[0];
  37. else
  38. dma->id = 0;
  39. return 0;
  40. }
  41. int dma_get_by_index(struct udevice *dev, int index, struct dma *dma)
  42. {
  43. int ret;
  44. struct ofnode_phandle_args args;
  45. struct udevice *dev_dma;
  46. const struct dma_ops *ops;
  47. debug("%s(dev=%p, index=%d, dma=%p)\n", __func__, dev, index, dma);
  48. assert(dma);
  49. dma->dev = NULL;
  50. ret = dev_read_phandle_with_args(dev, "dmas", "#dma-cells", 0, index,
  51. &args);
  52. if (ret) {
  53. pr_err("%s: dev_read_phandle_with_args failed: err=%d\n",
  54. __func__, ret);
  55. return ret;
  56. }
  57. ret = uclass_get_device_by_ofnode(UCLASS_DMA, args.node, &dev_dma);
  58. if (ret) {
  59. pr_err("%s: uclass_get_device_by_ofnode failed: err=%d\n",
  60. __func__, ret);
  61. return ret;
  62. }
  63. dma->dev = dev_dma;
  64. ops = dma_dev_ops(dev_dma);
  65. if (ops->of_xlate)
  66. ret = ops->of_xlate(dma, &args);
  67. else
  68. ret = dma_of_xlate_default(dma, &args);
  69. if (ret) {
  70. pr_err("of_xlate() failed: %d\n", ret);
  71. return ret;
  72. }
  73. return dma_request(dev_dma, dma);
  74. }
  75. int dma_get_by_name(struct udevice *dev, const char *name, struct dma *dma)
  76. {
  77. int index;
  78. debug("%s(dev=%p, name=%s, dma=%p)\n", __func__, dev, name, dma);
  79. dma->dev = NULL;
  80. index = dev_read_stringlist_search(dev, "dma-names", name);
  81. if (index < 0) {
  82. pr_err("dev_read_stringlist_search() failed: %d\n", index);
  83. return index;
  84. }
  85. return dma_get_by_index(dev, index, dma);
  86. }
  87. # endif /* OF_CONTROL */
  88. int dma_request(struct udevice *dev, struct dma *dma)
  89. {
  90. struct dma_ops *ops = dma_dev_ops(dev);
  91. debug("%s(dev=%p, dma=%p)\n", __func__, dev, dma);
  92. dma->dev = dev;
  93. if (!ops->request)
  94. return 0;
  95. return ops->request(dma);
  96. }
  97. int dma_free(struct dma *dma)
  98. {
  99. struct dma_ops *ops = dma_dev_ops(dma->dev);
  100. debug("%s(dma=%p)\n", __func__, dma);
  101. if (!ops->rfree)
  102. return 0;
  103. return ops->rfree(dma);
  104. }
  105. int dma_enable(struct dma *dma)
  106. {
  107. struct dma_ops *ops = dma_dev_ops(dma->dev);
  108. debug("%s(dma=%p)\n", __func__, dma);
  109. if (!ops->enable)
  110. return -ENOSYS;
  111. return ops->enable(dma);
  112. }
  113. int dma_disable(struct dma *dma)
  114. {
  115. struct dma_ops *ops = dma_dev_ops(dma->dev);
  116. debug("%s(dma=%p)\n", __func__, dma);
  117. if (!ops->disable)
  118. return -ENOSYS;
  119. return ops->disable(dma);
  120. }
  121. int dma_prepare_rcv_buf(struct dma *dma, void *dst, size_t size)
  122. {
  123. struct dma_ops *ops = dma_dev_ops(dma->dev);
  124. debug("%s(dma=%p)\n", __func__, dma);
  125. if (!ops->prepare_rcv_buf)
  126. return -1;
  127. return ops->prepare_rcv_buf(dma, dst, size);
  128. }
  129. int dma_receive(struct dma *dma, void **dst, void *metadata)
  130. {
  131. struct dma_ops *ops = dma_dev_ops(dma->dev);
  132. debug("%s(dma=%p)\n", __func__, dma);
  133. if (!ops->receive)
  134. return -ENOSYS;
  135. return ops->receive(dma, dst, metadata);
  136. }
  137. int dma_send(struct dma *dma, void *src, size_t len, void *metadata)
  138. {
  139. struct dma_ops *ops = dma_dev_ops(dma->dev);
  140. debug("%s(dma=%p)\n", __func__, dma);
  141. if (!ops->send)
  142. return -ENOSYS;
  143. return ops->send(dma, src, len, metadata);
  144. }
  145. int dma_get_cfg(struct dma *dma, u32 cfg_id, void **cfg_data)
  146. {
  147. struct dma_ops *ops = dma_dev_ops(dma->dev);
  148. debug("%s(dma=%p)\n", __func__, dma);
  149. if (!ops->get_cfg)
  150. return -ENOSYS;
  151. return ops->get_cfg(dma, cfg_id, cfg_data);
  152. }
  153. #endif /* CONFIG_DMA_CHANNELS */
  154. int dma_get_device(u32 transfer_type, struct udevice **devp)
  155. {
  156. struct udevice *dev;
  157. int ret;
  158. for (ret = uclass_first_device(UCLASS_DMA, &dev); dev && !ret;
  159. ret = uclass_next_device(&dev)) {
  160. struct dma_dev_priv *uc_priv;
  161. uc_priv = dev_get_uclass_priv(dev);
  162. if (uc_priv->supported & transfer_type)
  163. break;
  164. }
  165. if (!dev) {
  166. pr_err("No DMA device found that supports %x type\n",
  167. transfer_type);
  168. return -EPROTONOSUPPORT;
  169. }
  170. *devp = dev;
  171. return ret;
  172. }
  173. int dma_memcpy(void *dst, void *src, size_t len)
  174. {
  175. struct udevice *dev;
  176. const struct dma_ops *ops;
  177. int ret;
  178. ret = dma_get_device(DMA_SUPPORTS_MEM_TO_MEM, &dev);
  179. if (ret < 0)
  180. return ret;
  181. ops = device_get_ops(dev);
  182. if (!ops->transfer)
  183. return -ENOSYS;
  184. /* Invalidate the area, so no writeback into the RAM races with DMA */
  185. invalidate_dcache_range((unsigned long)dst, (unsigned long)dst +
  186. roundup(len, ARCH_DMA_MINALIGN));
  187. return ops->transfer(dev, DMA_MEM_TO_MEM, dst, src, len);
  188. }
  189. UCLASS_DRIVER(dma) = {
  190. .id = UCLASS_DMA,
  191. .name = "dma",
  192. .flags = DM_UC_FLAG_SEQ_ALIAS,
  193. .per_device_auto_alloc_size = sizeof(struct dma_dev_priv),
  194. };