ti_k3_dsp_rproc.c 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Texas Instruments' K3 DSP Remoteproc driver
  4. *
  5. * Copyright (C) 2018-2019 Texas Instruments Incorporated - http://www.ti.com/
  6. * Lokesh Vutla <lokeshvutla@ti.com>
  7. *
  8. */
  9. #include <common.h>
  10. #include <dm.h>
  11. #include <remoteproc.h>
  12. #include <errno.h>
  13. #include <clk.h>
  14. #include <reset.h>
  15. #include <asm/io.h>
  16. #include <power-domain.h>
  17. #include <linux/soc/ti/ti_sci_protocol.h>
  18. #include "ti_sci_proc.h"
  19. #define KEYSTONE_RPROC_LOCAL_ADDRESS_MASK (SZ_16M - 1)
  20. /**
  21. * struct k3_dsp_mem - internal memory structure
  22. * @cpu_addr: MPU virtual address of the memory region
  23. * @bus_addr: Bus address used to access the memory region
  24. * @dev_addr: Device address from remoteproc view
  25. * @size: Size of the memory region
  26. */
  27. struct k3_dsp_mem {
  28. void __iomem *cpu_addr;
  29. phys_addr_t bus_addr;
  30. phys_addr_t dev_addr;
  31. size_t size;
  32. };
  33. /**
  34. * struct k3_dsp_privdata - Structure representing Remote processor data.
  35. * @rproc_rst: rproc reset control data
  36. * @tsp: Pointer to TISCI proc contrl handle
  37. * @mem: Array of available memories
  38. * @num_mem: Number of available memories
  39. */
  40. struct k3_dsp_privdata {
  41. struct reset_ctl dsp_rst;
  42. struct ti_sci_proc tsp;
  43. struct k3_dsp_mem *mem;
  44. int num_mems;
  45. };
  46. /**
  47. * k3_dsp_load() - Load up the Remote processor image
  48. * @dev: rproc device pointer
  49. * @addr: Address at which image is available
  50. * @size: size of the image
  51. *
  52. * Return: 0 if all goes good, else appropriate error message.
  53. */
  54. static int k3_dsp_load(struct udevice *dev, ulong addr, ulong size)
  55. {
  56. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  57. u32 boot_vector;
  58. int ret;
  59. dev_dbg(dev, "%s addr = 0x%lx, size = 0x%lx\n", __func__, addr, size);
  60. ret = ti_sci_proc_request(&dsp->tsp);
  61. if (ret)
  62. return ret;
  63. ret = rproc_elf_load_image(dev, addr, size);
  64. if (ret < 0) {
  65. dev_err(dev, "Loading elf failed %d\n", ret);
  66. goto proc_release;
  67. }
  68. boot_vector = rproc_elf_get_boot_addr(dev, addr);
  69. dev_dbg(dev, "%s: Boot vector = 0x%x\n", __func__, boot_vector);
  70. ret = ti_sci_proc_set_config(&dsp->tsp, boot_vector, 0, 0);
  71. proc_release:
  72. ti_sci_proc_release(&dsp->tsp);
  73. return ret;
  74. }
  75. /**
  76. * k3_dsp_start() - Start the remote processor
  77. * @dev: rproc device pointer
  78. *
  79. * Return: 0 if all went ok, else return appropriate error
  80. */
  81. static int k3_dsp_start(struct udevice *dev)
  82. {
  83. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  84. int ret;
  85. dev_dbg(dev, "%s\n", __func__);
  86. ret = ti_sci_proc_request(&dsp->tsp);
  87. if (ret)
  88. return ret;
  89. /*
  90. * Setting the right clock frequency would have taken care by
  91. * assigned-clock-rates during the device probe. So no need to
  92. * set the frequency again here.
  93. */
  94. ret = ti_sci_proc_power_domain_on(&dsp->tsp);
  95. if (ret)
  96. goto proc_release;
  97. ret = reset_deassert(&dsp->dsp_rst);
  98. proc_release:
  99. ti_sci_proc_release(&dsp->tsp);
  100. return ret;
  101. }
  102. static int k3_dsp_stop(struct udevice *dev)
  103. {
  104. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  105. dev_dbg(dev, "%s\n", __func__);
  106. ti_sci_proc_request(&dsp->tsp);
  107. reset_assert(&dsp->dsp_rst);
  108. ti_sci_proc_power_domain_off(&dsp->tsp);
  109. ti_sci_proc_release(&dsp->tsp);
  110. return 0;
  111. }
  112. /**
  113. * k3_dsp_init() - Initialize the remote processor
  114. * @dev: rproc device pointer
  115. *
  116. * Return: 0 if all went ok, else return appropriate error
  117. */
  118. static int k3_dsp_init(struct udevice *dev)
  119. {
  120. dev_dbg(dev, "%s\n", __func__);
  121. return 0;
  122. }
  123. static int k3_dsp_reset(struct udevice *dev)
  124. {
  125. dev_dbg(dev, "%s\n", __func__);
  126. return 0;
  127. }
  128. static void *k3_dsp_da_to_va(struct udevice *dev, ulong da, ulong len)
  129. {
  130. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  131. phys_addr_t bus_addr, dev_addr;
  132. void __iomem *va = NULL;
  133. size_t size;
  134. u32 offset;
  135. int i;
  136. dev_dbg(dev, "%s\n", __func__);
  137. if (len <= 0)
  138. return NULL;
  139. for (i = 0; i < dsp->num_mems; i++) {
  140. bus_addr = dsp->mem[i].bus_addr;
  141. dev_addr = dsp->mem[i].dev_addr;
  142. size = dsp->mem[i].size;
  143. if (da >= dev_addr && ((da + len) <= (dev_addr + size))) {
  144. offset = da - dev_addr;
  145. va = dsp->mem[i].cpu_addr + offset;
  146. return (__force void *)va;
  147. }
  148. if (da >= bus_addr && (da + len) <= (bus_addr + size)) {
  149. offset = da - bus_addr;
  150. va = dsp->mem[i].cpu_addr + offset;
  151. return (__force void *)va;
  152. }
  153. }
  154. /* Assume it is DDR region and return da */
  155. return map_physmem(da, len, MAP_NOCACHE);
  156. }
  157. static const struct dm_rproc_ops k3_dsp_ops = {
  158. .init = k3_dsp_init,
  159. .load = k3_dsp_load,
  160. .start = k3_dsp_start,
  161. .stop = k3_dsp_stop,
  162. .reset = k3_dsp_reset,
  163. .device_to_virt = k3_dsp_da_to_va,
  164. };
  165. static int ti_sci_proc_of_to_priv(struct udevice *dev, struct ti_sci_proc *tsp)
  166. {
  167. u32 ids[2];
  168. int ret;
  169. dev_dbg(dev, "%s\n", __func__);
  170. tsp->sci = ti_sci_get_by_phandle(dev, "ti,sci");
  171. if (IS_ERR(tsp->sci)) {
  172. dev_err(dev, "ti_sci get failed: %ld\n", PTR_ERR(tsp->sci));
  173. return PTR_ERR(tsp->sci);
  174. }
  175. ret = dev_read_u32_array(dev, "ti,sci-proc-ids", ids, 2);
  176. if (ret) {
  177. dev_err(dev, "Proc IDs not populated %d\n", ret);
  178. return ret;
  179. }
  180. tsp->ops = &tsp->sci->ops.proc_ops;
  181. tsp->proc_id = ids[0];
  182. tsp->host_id = ids[1];
  183. tsp->dev_id = dev_read_u32_default(dev, "ti,sci-dev-id",
  184. TI_SCI_RESOURCE_NULL);
  185. if (tsp->dev_id == TI_SCI_RESOURCE_NULL) {
  186. dev_err(dev, "Device ID not populated %d\n", ret);
  187. return -ENODEV;
  188. }
  189. return 0;
  190. }
  191. static int k3_dsp_of_get_memories(struct udevice *dev)
  192. {
  193. static const char * const mem_names[] = {"l2sram", "l1pram", "l1dram"};
  194. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  195. int i;
  196. dev_dbg(dev, "%s\n", __func__);
  197. dsp->num_mems = ARRAY_SIZE(mem_names);
  198. dsp->mem = calloc(dsp->num_mems, sizeof(*dsp->mem));
  199. if (!dsp->mem)
  200. return -ENOMEM;
  201. for (i = 0; i < dsp->num_mems; i++) {
  202. /* C71 cores only have a L1P Cache, there are no L1P SRAMs */
  203. if (device_is_compatible(dev, "ti,j721e-c71-dsp") &&
  204. !strcmp(mem_names[i], "l1pram")) {
  205. dsp->mem[i].bus_addr = FDT_ADDR_T_NONE;
  206. dsp->mem[i].dev_addr = FDT_ADDR_T_NONE;
  207. dsp->mem[i].cpu_addr = NULL;
  208. dsp->mem[i].size = 0;
  209. continue;
  210. }
  211. dsp->mem[i].bus_addr = dev_read_addr_size_name(dev, mem_names[i],
  212. (fdt_addr_t *)&dsp->mem[i].size);
  213. if (dsp->mem[i].bus_addr == FDT_ADDR_T_NONE) {
  214. dev_err(dev, "%s bus address not found\n", mem_names[i]);
  215. return -EINVAL;
  216. }
  217. dsp->mem[i].cpu_addr = map_physmem(dsp->mem[i].bus_addr,
  218. dsp->mem[i].size,
  219. MAP_NOCACHE);
  220. dsp->mem[i].dev_addr = dsp->mem[i].bus_addr &
  221. KEYSTONE_RPROC_LOCAL_ADDRESS_MASK;
  222. dev_dbg(dev, "memory %8s: bus addr %pa size 0x%zx va %p da %pa\n",
  223. mem_names[i], &dsp->mem[i].bus_addr,
  224. dsp->mem[i].size, dsp->mem[i].cpu_addr,
  225. &dsp->mem[i].dev_addr);
  226. }
  227. return 0;
  228. }
  229. /**
  230. * k3_of_to_priv() - generate private data from device tree
  231. * @dev: corresponding k3 dsp processor device
  232. * @dsp: pointer to driver specific private data
  233. *
  234. * Return: 0 if all goes good, else appropriate error message.
  235. */
  236. static int k3_dsp_of_to_priv(struct udevice *dev, struct k3_dsp_privdata *dsp)
  237. {
  238. int ret;
  239. dev_dbg(dev, "%s\n", __func__);
  240. ret = reset_get_by_index(dev, 0, &dsp->dsp_rst);
  241. if (ret) {
  242. dev_err(dev, "reset_get() failed: %d\n", ret);
  243. return ret;
  244. }
  245. ret = ti_sci_proc_of_to_priv(dev, &dsp->tsp);
  246. if (ret)
  247. return ret;
  248. ret = k3_dsp_of_get_memories(dev);
  249. if (ret)
  250. return ret;
  251. return 0;
  252. }
  253. /**
  254. * k3_dsp_probe() - Basic probe
  255. * @dev: corresponding k3 remote processor device
  256. *
  257. * Return: 0 if all goes good, else appropriate error message.
  258. */
  259. static int k3_dsp_probe(struct udevice *dev)
  260. {
  261. struct k3_dsp_privdata *dsp;
  262. int ret;
  263. dev_dbg(dev, "%s\n", __func__);
  264. dsp = dev_get_priv(dev);
  265. ret = k3_dsp_of_to_priv(dev, dsp);
  266. if (ret) {
  267. dev_dbg(dev, "%s: Probe failed with error %d\n", __func__, ret);
  268. return ret;
  269. }
  270. dev_dbg(dev, "Remoteproc successfully probed\n");
  271. return 0;
  272. }
  273. static int k3_dsp_remove(struct udevice *dev)
  274. {
  275. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  276. free(dsp->mem);
  277. return 0;
  278. }
  279. static const struct udevice_id k3_dsp_ids[] = {
  280. { .compatible = "ti,j721e-c66-dsp"},
  281. { .compatible = "ti,j721e-c71-dsp"},
  282. {}
  283. };
  284. U_BOOT_DRIVER(k3_dsp) = {
  285. .name = "k3_dsp",
  286. .of_match = k3_dsp_ids,
  287. .id = UCLASS_REMOTEPROC,
  288. .ops = &k3_dsp_ops,
  289. .probe = k3_dsp_probe,
  290. .remove = k3_dsp_remove,
  291. .priv_auto_alloc_size = sizeof(struct k3_dsp_privdata),
  292. };