ti_k3_dsp_rproc.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Texas Instruments' K3 DSP Remoteproc driver
  4. *
  5. * Copyright (C) 2018-2020 Texas Instruments Incorporated - http://www.ti.com/
  6. * Lokesh Vutla <lokeshvutla@ti.com>
  7. * Suman Anna <s-anna@ti.com>
  8. */
  9. #include <common.h>
  10. #include <dm.h>
  11. #include <malloc.h>
  12. #include <remoteproc.h>
  13. #include <errno.h>
  14. #include <clk.h>
  15. #include <reset.h>
  16. #include <asm/io.h>
  17. #include <power-domain.h>
  18. #include <dm/device_compat.h>
  19. #include <linux/err.h>
  20. #include <linux/sizes.h>
  21. #include <linux/soc/ti/ti_sci_protocol.h>
  22. #include "ti_sci_proc.h"
  23. #define KEYSTONE_RPROC_LOCAL_ADDRESS_MASK (SZ_16M - 1)
  24. /**
  25. * struct k3_dsp_mem - internal memory structure
  26. * @cpu_addr: MPU virtual address of the memory region
  27. * @bus_addr: Bus address used to access the memory region
  28. * @dev_addr: Device address from remoteproc view
  29. * @size: Size of the memory region
  30. */
  31. struct k3_dsp_mem {
  32. void __iomem *cpu_addr;
  33. phys_addr_t bus_addr;
  34. phys_addr_t dev_addr;
  35. size_t size;
  36. };
  37. /**
  38. * struct k3_dsp_boot_data - internal data structure used for boot
  39. * @boot_align_addr: Boot vector address alignment granularity
  40. * @uses_lreset: Flag to denote the need for local reset management
  41. */
  42. struct k3_dsp_boot_data {
  43. u32 boot_align_addr;
  44. bool uses_lreset;
  45. };
  46. /**
  47. * struct k3_dsp_privdata - Structure representing Remote processor data.
  48. * @rproc_rst: rproc reset control data
  49. * @tsp: Pointer to TISCI proc contrl handle
  50. * @data: Pointer to DSP specific boot data structure
  51. * @mem: Array of available memories
  52. * @num_mem: Number of available memories
  53. */
  54. struct k3_dsp_privdata {
  55. struct reset_ctl dsp_rst;
  56. struct ti_sci_proc tsp;
  57. struct k3_dsp_boot_data *data;
  58. struct k3_dsp_mem *mem;
  59. int num_mems;
  60. };
  61. /*
  62. * The C66x DSP cores have a local reset that affects only the CPU, and a
  63. * generic module reset that powers on the device and allows the DSP internal
  64. * memories to be accessed while the local reset is asserted. This function is
  65. * used to release the global reset on C66x DSPs to allow loading into the DSP
  66. * internal RAMs. This helper function is invoked in k3_dsp_load() before any
  67. * actual firmware loading and is undone only in k3_dsp_stop(). The local reset
  68. * on C71x cores is a no-op and the global reset cannot be released on C71x
  69. * cores until after the firmware images are loaded, so this function does
  70. * nothing for C71x cores.
  71. */
  72. static int k3_dsp_prepare(struct udevice *dev)
  73. {
  74. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  75. struct k3_dsp_boot_data *data = dsp->data;
  76. int ret;
  77. /* local reset is no-op on C71x processors */
  78. if (!data->uses_lreset)
  79. return 0;
  80. ret = ti_sci_proc_power_domain_on(&dsp->tsp);
  81. if (ret)
  82. dev_err(dev, "cannot enable internal RAM loading, ret = %d\n",
  83. ret);
  84. return ret;
  85. }
  86. /*
  87. * This function is the counterpart to k3_dsp_prepare() and is used to assert
  88. * the global reset on C66x DSP cores (no-op for C71x DSP cores). This completes
  89. * the second step of powering down the C66x DSP cores. The cores themselves
  90. * are halted through the local reset in first step. This function is invoked
  91. * in k3_dsp_stop() after the local reset is asserted.
  92. */
  93. static int k3_dsp_unprepare(struct udevice *dev)
  94. {
  95. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  96. struct k3_dsp_boot_data *data = dsp->data;
  97. /* local reset is no-op on C71x processors */
  98. if (!data->uses_lreset)
  99. return 0;
  100. return ti_sci_proc_power_domain_off(&dsp->tsp);
  101. }
  102. /**
  103. * k3_dsp_load() - Load up the Remote processor image
  104. * @dev: rproc device pointer
  105. * @addr: Address at which image is available
  106. * @size: size of the image
  107. *
  108. * Return: 0 if all goes good, else appropriate error message.
  109. */
  110. static int k3_dsp_load(struct udevice *dev, ulong addr, ulong size)
  111. {
  112. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  113. struct k3_dsp_boot_data *data = dsp->data;
  114. u32 boot_vector;
  115. int ret;
  116. dev_dbg(dev, "%s addr = 0x%lx, size = 0x%lx\n", __func__, addr, size);
  117. ret = ti_sci_proc_request(&dsp->tsp);
  118. if (ret)
  119. return ret;
  120. ret = k3_dsp_prepare(dev);
  121. if (ret) {
  122. dev_err(dev, "DSP prepare failed for core %d\n",
  123. dsp->tsp.proc_id);
  124. goto proc_release;
  125. }
  126. ret = rproc_elf_load_image(dev, addr, size);
  127. if (ret < 0) {
  128. dev_err(dev, "Loading elf failed %d\n", ret);
  129. goto unprepare;
  130. }
  131. boot_vector = rproc_elf_get_boot_addr(dev, addr);
  132. if (boot_vector & (data->boot_align_addr - 1)) {
  133. ret = -EINVAL;
  134. dev_err(dev, "Boot vector 0x%x not aligned on 0x%x boundary\n",
  135. boot_vector, data->boot_align_addr);
  136. goto proc_release;
  137. }
  138. dev_dbg(dev, "%s: Boot vector = 0x%x\n", __func__, boot_vector);
  139. ret = ti_sci_proc_set_config(&dsp->tsp, boot_vector, 0, 0);
  140. unprepare:
  141. if (ret)
  142. k3_dsp_unprepare(dev);
  143. proc_release:
  144. ti_sci_proc_release(&dsp->tsp);
  145. return ret;
  146. }
  147. /**
  148. * k3_dsp_start() - Start the remote processor
  149. * @dev: rproc device pointer
  150. *
  151. * Return: 0 if all went ok, else return appropriate error
  152. */
  153. static int k3_dsp_start(struct udevice *dev)
  154. {
  155. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  156. struct k3_dsp_boot_data *data = dsp->data;
  157. int ret;
  158. dev_dbg(dev, "%s\n", __func__);
  159. ret = ti_sci_proc_request(&dsp->tsp);
  160. if (ret)
  161. return ret;
  162. if (!data->uses_lreset) {
  163. ret = ti_sci_proc_power_domain_on(&dsp->tsp);
  164. if (ret)
  165. goto proc_release;
  166. }
  167. ret = reset_deassert(&dsp->dsp_rst);
  168. if (ret) {
  169. if (!data->uses_lreset)
  170. ti_sci_proc_power_domain_off(&dsp->tsp);
  171. }
  172. proc_release:
  173. ti_sci_proc_release(&dsp->tsp);
  174. return ret;
  175. }
  176. static int k3_dsp_stop(struct udevice *dev)
  177. {
  178. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  179. dev_dbg(dev, "%s\n", __func__);
  180. ti_sci_proc_request(&dsp->tsp);
  181. reset_assert(&dsp->dsp_rst);
  182. ti_sci_proc_power_domain_off(&dsp->tsp);
  183. ti_sci_proc_release(&dsp->tsp);
  184. return 0;
  185. }
  186. /**
  187. * k3_dsp_init() - Initialize the remote processor
  188. * @dev: rproc device pointer
  189. *
  190. * Return: 0 if all went ok, else return appropriate error
  191. */
  192. static int k3_dsp_init(struct udevice *dev)
  193. {
  194. dev_dbg(dev, "%s\n", __func__);
  195. return 0;
  196. }
  197. static int k3_dsp_reset(struct udevice *dev)
  198. {
  199. dev_dbg(dev, "%s\n", __func__);
  200. return 0;
  201. }
  202. static void *k3_dsp_da_to_va(struct udevice *dev, ulong da, ulong len)
  203. {
  204. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  205. phys_addr_t bus_addr, dev_addr;
  206. void __iomem *va = NULL;
  207. size_t size;
  208. u32 offset;
  209. int i;
  210. dev_dbg(dev, "%s\n", __func__);
  211. if (len <= 0)
  212. return NULL;
  213. for (i = 0; i < dsp->num_mems; i++) {
  214. bus_addr = dsp->mem[i].bus_addr;
  215. dev_addr = dsp->mem[i].dev_addr;
  216. size = dsp->mem[i].size;
  217. if (da >= dev_addr && ((da + len) <= (dev_addr + size))) {
  218. offset = da - dev_addr;
  219. va = dsp->mem[i].cpu_addr + offset;
  220. return (__force void *)va;
  221. }
  222. if (da >= bus_addr && (da + len) <= (bus_addr + size)) {
  223. offset = da - bus_addr;
  224. va = dsp->mem[i].cpu_addr + offset;
  225. return (__force void *)va;
  226. }
  227. }
  228. /* Assume it is DDR region and return da */
  229. return map_physmem(da, len, MAP_NOCACHE);
  230. }
  231. static const struct dm_rproc_ops k3_dsp_ops = {
  232. .init = k3_dsp_init,
  233. .load = k3_dsp_load,
  234. .start = k3_dsp_start,
  235. .stop = k3_dsp_stop,
  236. .reset = k3_dsp_reset,
  237. .device_to_virt = k3_dsp_da_to_va,
  238. };
  239. static int ti_sci_proc_of_to_priv(struct udevice *dev, struct ti_sci_proc *tsp)
  240. {
  241. u32 ids[2];
  242. int ret;
  243. dev_dbg(dev, "%s\n", __func__);
  244. tsp->sci = ti_sci_get_by_phandle(dev, "ti,sci");
  245. if (IS_ERR(tsp->sci)) {
  246. dev_err(dev, "ti_sci get failed: %ld\n", PTR_ERR(tsp->sci));
  247. return PTR_ERR(tsp->sci);
  248. }
  249. ret = dev_read_u32_array(dev, "ti,sci-proc-ids", ids, 2);
  250. if (ret) {
  251. dev_err(dev, "Proc IDs not populated %d\n", ret);
  252. return ret;
  253. }
  254. tsp->ops = &tsp->sci->ops.proc_ops;
  255. tsp->proc_id = ids[0];
  256. tsp->host_id = ids[1];
  257. tsp->dev_id = dev_read_u32_default(dev, "ti,sci-dev-id",
  258. TI_SCI_RESOURCE_NULL);
  259. if (tsp->dev_id == TI_SCI_RESOURCE_NULL) {
  260. dev_err(dev, "Device ID not populated %d\n", ret);
  261. return -ENODEV;
  262. }
  263. return 0;
  264. }
  265. static int k3_dsp_of_get_memories(struct udevice *dev)
  266. {
  267. static const char * const mem_names[] = {"l2sram", "l1pram", "l1dram"};
  268. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  269. int i;
  270. dev_dbg(dev, "%s\n", __func__);
  271. dsp->num_mems = ARRAY_SIZE(mem_names);
  272. dsp->mem = calloc(dsp->num_mems, sizeof(*dsp->mem));
  273. if (!dsp->mem)
  274. return -ENOMEM;
  275. for (i = 0; i < dsp->num_mems; i++) {
  276. /* C71 cores only have a L1P Cache, there are no L1P SRAMs */
  277. if (device_is_compatible(dev, "ti,j721e-c71-dsp") &&
  278. !strcmp(mem_names[i], "l1pram")) {
  279. dsp->mem[i].bus_addr = FDT_ADDR_T_NONE;
  280. dsp->mem[i].dev_addr = FDT_ADDR_T_NONE;
  281. dsp->mem[i].cpu_addr = NULL;
  282. dsp->mem[i].size = 0;
  283. continue;
  284. }
  285. dsp->mem[i].bus_addr = dev_read_addr_size_name(dev, mem_names[i],
  286. (fdt_addr_t *)&dsp->mem[i].size);
  287. if (dsp->mem[i].bus_addr == FDT_ADDR_T_NONE) {
  288. dev_err(dev, "%s bus address not found\n", mem_names[i]);
  289. return -EINVAL;
  290. }
  291. dsp->mem[i].cpu_addr = map_physmem(dsp->mem[i].bus_addr,
  292. dsp->mem[i].size,
  293. MAP_NOCACHE);
  294. dsp->mem[i].dev_addr = dsp->mem[i].bus_addr &
  295. KEYSTONE_RPROC_LOCAL_ADDRESS_MASK;
  296. dev_dbg(dev, "memory %8s: bus addr %pa size 0x%zx va %p da %pa\n",
  297. mem_names[i], &dsp->mem[i].bus_addr,
  298. dsp->mem[i].size, dsp->mem[i].cpu_addr,
  299. &dsp->mem[i].dev_addr);
  300. }
  301. return 0;
  302. }
  303. /**
  304. * k3_of_to_priv() - generate private data from device tree
  305. * @dev: corresponding k3 dsp processor device
  306. * @dsp: pointer to driver specific private data
  307. *
  308. * Return: 0 if all goes good, else appropriate error message.
  309. */
  310. static int k3_dsp_of_to_priv(struct udevice *dev, struct k3_dsp_privdata *dsp)
  311. {
  312. int ret;
  313. dev_dbg(dev, "%s\n", __func__);
  314. ret = reset_get_by_index(dev, 0, &dsp->dsp_rst);
  315. if (ret) {
  316. dev_err(dev, "reset_get() failed: %d\n", ret);
  317. return ret;
  318. }
  319. ret = ti_sci_proc_of_to_priv(dev, &dsp->tsp);
  320. if (ret)
  321. return ret;
  322. ret = k3_dsp_of_get_memories(dev);
  323. if (ret)
  324. return ret;
  325. dsp->data = (struct k3_dsp_boot_data *)dev_get_driver_data(dev);
  326. return 0;
  327. }
  328. /**
  329. * k3_dsp_probe() - Basic probe
  330. * @dev: corresponding k3 remote processor device
  331. *
  332. * Return: 0 if all goes good, else appropriate error message.
  333. */
  334. static int k3_dsp_probe(struct udevice *dev)
  335. {
  336. struct k3_dsp_privdata *dsp;
  337. int ret;
  338. dev_dbg(dev, "%s\n", __func__);
  339. dsp = dev_get_priv(dev);
  340. ret = k3_dsp_of_to_priv(dev, dsp);
  341. if (ret) {
  342. dev_dbg(dev, "%s: Probe failed with error %d\n", __func__, ret);
  343. return ret;
  344. }
  345. /*
  346. * The DSP local resets are deasserted by default on Power-On-Reset.
  347. * Assert the local resets to ensure the DSPs don't execute bogus code
  348. * in .load() callback when the module reset is released to support
  349. * internal memory loading. This is needed for C66x DSPs, and is a
  350. * no-op on C71x DSPs.
  351. */
  352. reset_assert(&dsp->dsp_rst);
  353. dev_dbg(dev, "Remoteproc successfully probed\n");
  354. return 0;
  355. }
  356. static int k3_dsp_remove(struct udevice *dev)
  357. {
  358. struct k3_dsp_privdata *dsp = dev_get_priv(dev);
  359. free(dsp->mem);
  360. return 0;
  361. }
  362. static const struct k3_dsp_boot_data c66_data = {
  363. .boot_align_addr = SZ_1K,
  364. .uses_lreset = true,
  365. };
  366. static const struct k3_dsp_boot_data c71_data = {
  367. .boot_align_addr = SZ_2M,
  368. .uses_lreset = false,
  369. };
  370. static const struct udevice_id k3_dsp_ids[] = {
  371. { .compatible = "ti,j721e-c66-dsp", .data = (ulong)&c66_data, },
  372. { .compatible = "ti,j721e-c71-dsp", .data = (ulong)&c71_data, },
  373. {}
  374. };
  375. U_BOOT_DRIVER(k3_dsp) = {
  376. .name = "k3_dsp",
  377. .of_match = k3_dsp_ids,
  378. .id = UCLASS_REMOTEPROC,
  379. .ops = &k3_dsp_ops,
  380. .probe = k3_dsp_probe,
  381. .remove = k3_dsp_remove,
  382. .priv_auto_alloc_size = sizeof(struct k3_dsp_privdata),
  383. };