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