1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * TI K3 DSP Remote Processor(s) driver |
4 | * |
5 | * Copyright (C) 2018-2022 Texas Instruments Incorporated - https://www.ti.com/ |
6 | * Suman Anna <s-anna@ti.com> |
7 | */ |
8 | |
9 | #include <linux/io.h> |
10 | #include <linux/mailbox_client.h> |
11 | #include <linux/module.h> |
12 | #include <linux/of.h> |
13 | #include <linux/of_reserved_mem.h> |
14 | #include <linux/omap-mailbox.h> |
15 | #include <linux/platform_device.h> |
16 | #include <linux/remoteproc.h> |
17 | #include <linux/reset.h> |
18 | #include <linux/slab.h> |
19 | |
20 | #include "omap_remoteproc.h" |
21 | #include "remoteproc_internal.h" |
22 | #include "ti_sci_proc.h" |
23 | |
24 | #define KEYSTONE_RPROC_LOCAL_ADDRESS_MASK (SZ_16M - 1) |
25 | |
26 | /** |
27 | * struct k3_dsp_mem - internal memory structure |
28 | * @cpu_addr: MPU virtual address of the memory region |
29 | * @bus_addr: Bus address used to access the memory region |
30 | * @dev_addr: Device address of the memory region from DSP view |
31 | * @size: Size of the memory region |
32 | */ |
33 | struct k3_dsp_mem { |
34 | void __iomem *cpu_addr; |
35 | phys_addr_t bus_addr; |
36 | u32 dev_addr; |
37 | size_t size; |
38 | }; |
39 | |
40 | /** |
41 | * struct k3_dsp_mem_data - memory definitions for a DSP |
42 | * @name: name for this memory entry |
43 | * @dev_addr: device address for the memory entry |
44 | */ |
45 | struct k3_dsp_mem_data { |
46 | const char *name; |
47 | const u32 dev_addr; |
48 | }; |
49 | |
50 | /** |
51 | * struct k3_dsp_dev_data - device data structure for a DSP |
52 | * @mems: pointer to memory definitions for a DSP |
53 | * @num_mems: number of memory regions in @mems |
54 | * @boot_align_addr: boot vector address alignment granularity |
55 | * @uses_lreset: flag to denote the need for local reset management |
56 | */ |
57 | struct k3_dsp_dev_data { |
58 | const struct k3_dsp_mem_data *mems; |
59 | u32 num_mems; |
60 | u32 boot_align_addr; |
61 | bool uses_lreset; |
62 | }; |
63 | |
64 | /** |
65 | * struct k3_dsp_rproc - k3 DSP remote processor driver structure |
66 | * @dev: cached device pointer |
67 | * @rproc: remoteproc device handle |
68 | * @mem: internal memory regions data |
69 | * @num_mems: number of internal memory regions |
70 | * @rmem: reserved memory regions data |
71 | * @num_rmems: number of reserved memory regions |
72 | * @reset: reset control handle |
73 | * @data: pointer to DSP-specific device data |
74 | * @tsp: TI-SCI processor control handle |
75 | * @ti_sci: TI-SCI handle |
76 | * @ti_sci_id: TI-SCI device identifier |
77 | * @mbox: mailbox channel handle |
78 | * @client: mailbox client to request the mailbox channel |
79 | */ |
80 | struct k3_dsp_rproc { |
81 | struct device *dev; |
82 | struct rproc *rproc; |
83 | struct k3_dsp_mem *mem; |
84 | int num_mems; |
85 | struct k3_dsp_mem *rmem; |
86 | int num_rmems; |
87 | struct reset_control *reset; |
88 | const struct k3_dsp_dev_data *data; |
89 | struct ti_sci_proc *tsp; |
90 | const struct ti_sci_handle *ti_sci; |
91 | u32 ti_sci_id; |
92 | struct mbox_chan *mbox; |
93 | struct mbox_client client; |
94 | }; |
95 | |
96 | /** |
97 | * k3_dsp_rproc_mbox_callback() - inbound mailbox message handler |
98 | * @client: mailbox client pointer used for requesting the mailbox channel |
99 | * @data: mailbox payload |
100 | * |
101 | * This handler is invoked by the OMAP mailbox driver whenever a mailbox |
102 | * message is received. Usually, the mailbox payload simply contains |
103 | * the index of the virtqueue that is kicked by the remote processor, |
104 | * and we let remoteproc core handle it. |
105 | * |
106 | * In addition to virtqueue indices, we also have some out-of-band values |
107 | * that indicate different events. Those values are deliberately very |
108 | * large so they don't coincide with virtqueue indices. |
109 | */ |
110 | static void k3_dsp_rproc_mbox_callback(struct mbox_client *client, void *data) |
111 | { |
112 | struct k3_dsp_rproc *kproc = container_of(client, struct k3_dsp_rproc, |
113 | client); |
114 | struct device *dev = kproc->rproc->dev.parent; |
115 | const char *name = kproc->rproc->name; |
116 | u32 msg = omap_mbox_message(data); |
117 | |
118 | dev_dbg(dev, "mbox msg: 0x%x\n" , msg); |
119 | |
120 | switch (msg) { |
121 | case RP_MBOX_CRASH: |
122 | /* |
123 | * remoteproc detected an exception, but error recovery is not |
124 | * supported. So, just log this for now |
125 | */ |
126 | dev_err(dev, "K3 DSP rproc %s crashed\n" , name); |
127 | break; |
128 | case RP_MBOX_ECHO_REPLY: |
129 | dev_info(dev, "received echo reply from %s\n" , name); |
130 | break; |
131 | default: |
132 | /* silently handle all other valid messages */ |
133 | if (msg >= RP_MBOX_READY && msg < RP_MBOX_END_MSG) |
134 | return; |
135 | if (msg > kproc->rproc->max_notifyid) { |
136 | dev_dbg(dev, "dropping unknown message 0x%x" , msg); |
137 | return; |
138 | } |
139 | /* msg contains the index of the triggered vring */ |
140 | if (rproc_vq_interrupt(rproc: kproc->rproc, vq_id: msg) == IRQ_NONE) |
141 | dev_dbg(dev, "no message was found in vqid %d\n" , msg); |
142 | } |
143 | } |
144 | |
145 | /* |
146 | * Kick the remote processor to notify about pending unprocessed messages. |
147 | * The vqid usage is not used and is inconsequential, as the kick is performed |
148 | * through a simulated GPIO (a bit in an IPC interrupt-triggering register), |
149 | * the remote processor is expected to process both its Tx and Rx virtqueues. |
150 | */ |
151 | static void k3_dsp_rproc_kick(struct rproc *rproc, int vqid) |
152 | { |
153 | struct k3_dsp_rproc *kproc = rproc->priv; |
154 | struct device *dev = rproc->dev.parent; |
155 | mbox_msg_t msg = (mbox_msg_t)vqid; |
156 | int ret; |
157 | |
158 | /* send the index of the triggered virtqueue in the mailbox payload */ |
159 | ret = mbox_send_message(chan: kproc->mbox, mssg: (void *)msg); |
160 | if (ret < 0) |
161 | dev_err(dev, "failed to send mailbox message (%pe)\n" , |
162 | ERR_PTR(ret)); |
163 | } |
164 | |
165 | /* Put the DSP processor into reset */ |
166 | static int k3_dsp_rproc_reset(struct k3_dsp_rproc *kproc) |
167 | { |
168 | struct device *dev = kproc->dev; |
169 | int ret; |
170 | |
171 | ret = reset_control_assert(rstc: kproc->reset); |
172 | if (ret) { |
173 | dev_err(dev, "local-reset assert failed (%pe)\n" , ERR_PTR(ret)); |
174 | return ret; |
175 | } |
176 | |
177 | if (kproc->data->uses_lreset) |
178 | return ret; |
179 | |
180 | ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci, |
181 | kproc->ti_sci_id); |
182 | if (ret) { |
183 | dev_err(dev, "module-reset assert failed (%pe)\n" , ERR_PTR(ret)); |
184 | if (reset_control_deassert(rstc: kproc->reset)) |
185 | dev_warn(dev, "local-reset deassert back failed\n" ); |
186 | } |
187 | |
188 | return ret; |
189 | } |
190 | |
191 | /* Release the DSP processor from reset */ |
192 | static int k3_dsp_rproc_release(struct k3_dsp_rproc *kproc) |
193 | { |
194 | struct device *dev = kproc->dev; |
195 | int ret; |
196 | |
197 | if (kproc->data->uses_lreset) |
198 | goto lreset; |
199 | |
200 | ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci, |
201 | kproc->ti_sci_id); |
202 | if (ret) { |
203 | dev_err(dev, "module-reset deassert failed (%pe)\n" , ERR_PTR(ret)); |
204 | return ret; |
205 | } |
206 | |
207 | lreset: |
208 | ret = reset_control_deassert(rstc: kproc->reset); |
209 | if (ret) { |
210 | dev_err(dev, "local-reset deassert failed, (%pe)\n" , ERR_PTR(ret)); |
211 | if (kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci, |
212 | kproc->ti_sci_id)) |
213 | dev_warn(dev, "module-reset assert back failed\n" ); |
214 | } |
215 | |
216 | return ret; |
217 | } |
218 | |
219 | static int k3_dsp_rproc_request_mbox(struct rproc *rproc) |
220 | { |
221 | struct k3_dsp_rproc *kproc = rproc->priv; |
222 | struct mbox_client *client = &kproc->client; |
223 | struct device *dev = kproc->dev; |
224 | int ret; |
225 | |
226 | client->dev = dev; |
227 | client->tx_done = NULL; |
228 | client->rx_callback = k3_dsp_rproc_mbox_callback; |
229 | client->tx_block = false; |
230 | client->knows_txdone = false; |
231 | |
232 | kproc->mbox = mbox_request_channel(cl: client, index: 0); |
233 | if (IS_ERR(ptr: kproc->mbox)) { |
234 | ret = -EBUSY; |
235 | dev_err(dev, "mbox_request_channel failed: %ld\n" , |
236 | PTR_ERR(kproc->mbox)); |
237 | return ret; |
238 | } |
239 | |
240 | /* |
241 | * Ping the remote processor, this is only for sanity-sake for now; |
242 | * there is no functional effect whatsoever. |
243 | * |
244 | * Note that the reply will _not_ arrive immediately: this message |
245 | * will wait in the mailbox fifo until the remote processor is booted. |
246 | */ |
247 | ret = mbox_send_message(chan: kproc->mbox, mssg: (void *)RP_MBOX_ECHO_REQUEST); |
248 | if (ret < 0) { |
249 | dev_err(dev, "mbox_send_message failed (%pe)\n" , ERR_PTR(ret)); |
250 | mbox_free_channel(chan: kproc->mbox); |
251 | return ret; |
252 | } |
253 | |
254 | return 0; |
255 | } |
256 | /* |
257 | * The C66x DSP cores have a local reset that affects only the CPU, and a |
258 | * generic module reset that powers on the device and allows the DSP internal |
259 | * memories to be accessed while the local reset is asserted. This function is |
260 | * used to release the global reset on C66x DSPs to allow loading into the DSP |
261 | * internal RAMs. The .prepare() ops is invoked by remoteproc core before any |
262 | * firmware loading, and is followed by the .start() ops after loading to |
263 | * actually let the C66x DSP cores run. This callback is invoked only in |
264 | * remoteproc mode. |
265 | */ |
266 | static int k3_dsp_rproc_prepare(struct rproc *rproc) |
267 | { |
268 | struct k3_dsp_rproc *kproc = rproc->priv; |
269 | struct device *dev = kproc->dev; |
270 | int ret; |
271 | |
272 | ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci, |
273 | kproc->ti_sci_id); |
274 | if (ret) |
275 | dev_err(dev, "module-reset deassert failed, cannot enable internal RAM loading (%pe)\n" , |
276 | ERR_PTR(ret)); |
277 | |
278 | return ret; |
279 | } |
280 | |
281 | /* |
282 | * This function implements the .unprepare() ops and performs the complimentary |
283 | * operations to that of the .prepare() ops. The function is used to assert the |
284 | * global reset on applicable C66x cores. This completes the second portion of |
285 | * powering down the C66x DSP cores. The cores themselves are only halted in the |
286 | * .stop() callback through the local reset, and the .unprepare() ops is invoked |
287 | * by the remoteproc core after the remoteproc is stopped to balance the global |
288 | * reset. This callback is invoked only in remoteproc mode. |
289 | */ |
290 | static int k3_dsp_rproc_unprepare(struct rproc *rproc) |
291 | { |
292 | struct k3_dsp_rproc *kproc = rproc->priv; |
293 | struct device *dev = kproc->dev; |
294 | int ret; |
295 | |
296 | ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci, |
297 | kproc->ti_sci_id); |
298 | if (ret) |
299 | dev_err(dev, "module-reset assert failed (%pe)\n" , ERR_PTR(ret)); |
300 | |
301 | return ret; |
302 | } |
303 | |
304 | /* |
305 | * Power up the DSP remote processor. |
306 | * |
307 | * This function will be invoked only after the firmware for this rproc |
308 | * was loaded, parsed successfully, and all of its resource requirements |
309 | * were met. This callback is invoked only in remoteproc mode. |
310 | */ |
311 | static int k3_dsp_rproc_start(struct rproc *rproc) |
312 | { |
313 | struct k3_dsp_rproc *kproc = rproc->priv; |
314 | struct device *dev = kproc->dev; |
315 | u32 boot_addr; |
316 | int ret; |
317 | |
318 | ret = k3_dsp_rproc_request_mbox(rproc); |
319 | if (ret) |
320 | return ret; |
321 | |
322 | boot_addr = rproc->bootaddr; |
323 | if (boot_addr & (kproc->data->boot_align_addr - 1)) { |
324 | dev_err(dev, "invalid boot address 0x%x, must be aligned on a 0x%x boundary\n" , |
325 | boot_addr, kproc->data->boot_align_addr); |
326 | ret = -EINVAL; |
327 | goto put_mbox; |
328 | } |
329 | |
330 | dev_err(dev, "booting DSP core using boot addr = 0x%x\n" , boot_addr); |
331 | ret = ti_sci_proc_set_config(tsp: kproc->tsp, boot_vector: boot_addr, cfg_set: 0, cfg_clr: 0); |
332 | if (ret) |
333 | goto put_mbox; |
334 | |
335 | ret = k3_dsp_rproc_release(kproc); |
336 | if (ret) |
337 | goto put_mbox; |
338 | |
339 | return 0; |
340 | |
341 | put_mbox: |
342 | mbox_free_channel(chan: kproc->mbox); |
343 | return ret; |
344 | } |
345 | |
346 | /* |
347 | * Stop the DSP remote processor. |
348 | * |
349 | * This function puts the DSP processor into reset, and finishes processing |
350 | * of any pending messages. This callback is invoked only in remoteproc mode. |
351 | */ |
352 | static int k3_dsp_rproc_stop(struct rproc *rproc) |
353 | { |
354 | struct k3_dsp_rproc *kproc = rproc->priv; |
355 | |
356 | mbox_free_channel(chan: kproc->mbox); |
357 | |
358 | k3_dsp_rproc_reset(kproc); |
359 | |
360 | return 0; |
361 | } |
362 | |
363 | /* |
364 | * Attach to a running DSP remote processor (IPC-only mode) |
365 | * |
366 | * This rproc attach callback only needs to request the mailbox, the remote |
367 | * processor is already booted, so there is no need to issue any TI-SCI |
368 | * commands to boot the DSP core. This callback is invoked only in IPC-only |
369 | * mode. |
370 | */ |
371 | static int k3_dsp_rproc_attach(struct rproc *rproc) |
372 | { |
373 | struct k3_dsp_rproc *kproc = rproc->priv; |
374 | struct device *dev = kproc->dev; |
375 | int ret; |
376 | |
377 | ret = k3_dsp_rproc_request_mbox(rproc); |
378 | if (ret) |
379 | return ret; |
380 | |
381 | dev_info(dev, "DSP initialized in IPC-only mode\n" ); |
382 | return 0; |
383 | } |
384 | |
385 | /* |
386 | * Detach from a running DSP remote processor (IPC-only mode) |
387 | * |
388 | * This rproc detach callback performs the opposite operation to attach callback |
389 | * and only needs to release the mailbox, the DSP core is not stopped and will |
390 | * be left to continue to run its booted firmware. This callback is invoked only |
391 | * in IPC-only mode. |
392 | */ |
393 | static int k3_dsp_rproc_detach(struct rproc *rproc) |
394 | { |
395 | struct k3_dsp_rproc *kproc = rproc->priv; |
396 | struct device *dev = kproc->dev; |
397 | |
398 | mbox_free_channel(chan: kproc->mbox); |
399 | dev_info(dev, "DSP deinitialized in IPC-only mode\n" ); |
400 | return 0; |
401 | } |
402 | |
403 | /* |
404 | * This function implements the .get_loaded_rsc_table() callback and is used |
405 | * to provide the resource table for a booted DSP in IPC-only mode. The K3 DSP |
406 | * firmwares follow a design-by-contract approach and are expected to have the |
407 | * resource table at the base of the DDR region reserved for firmware usage. |
408 | * This provides flexibility for the remote processor to be booted by different |
409 | * bootloaders that may or may not have the ability to publish the resource table |
410 | * address and size through a DT property. This callback is invoked only in |
411 | * IPC-only mode. |
412 | */ |
413 | static struct resource_table *k3_dsp_get_loaded_rsc_table(struct rproc *rproc, |
414 | size_t *rsc_table_sz) |
415 | { |
416 | struct k3_dsp_rproc *kproc = rproc->priv; |
417 | struct device *dev = kproc->dev; |
418 | |
419 | if (!kproc->rmem[0].cpu_addr) { |
420 | dev_err(dev, "memory-region #1 does not exist, loaded rsc table can't be found" ); |
421 | return ERR_PTR(error: -ENOMEM); |
422 | } |
423 | |
424 | /* |
425 | * NOTE: The resource table size is currently hard-coded to a maximum |
426 | * of 256 bytes. The most common resource table usage for K3 firmwares |
427 | * is to only have the vdev resource entry and an optional trace entry. |
428 | * The exact size could be computed based on resource table address, but |
429 | * the hard-coded value suffices to support the IPC-only mode. |
430 | */ |
431 | *rsc_table_sz = 256; |
432 | return (struct resource_table *)kproc->rmem[0].cpu_addr; |
433 | } |
434 | |
435 | /* |
436 | * Custom function to translate a DSP device address (internal RAMs only) to a |
437 | * kernel virtual address. The DSPs can access their RAMs at either an internal |
438 | * address visible only from a DSP, or at the SoC-level bus address. Both these |
439 | * addresses need to be looked through for translation. The translated addresses |
440 | * can be used either by the remoteproc core for loading (when using kernel |
441 | * remoteproc loader), or by any rpmsg bus drivers. |
442 | */ |
443 | static void *k3_dsp_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem) |
444 | { |
445 | struct k3_dsp_rproc *kproc = rproc->priv; |
446 | void __iomem *va = NULL; |
447 | phys_addr_t bus_addr; |
448 | u32 dev_addr, offset; |
449 | size_t size; |
450 | int i; |
451 | |
452 | if (len == 0) |
453 | return NULL; |
454 | |
455 | for (i = 0; i < kproc->num_mems; i++) { |
456 | bus_addr = kproc->mem[i].bus_addr; |
457 | dev_addr = kproc->mem[i].dev_addr; |
458 | size = kproc->mem[i].size; |
459 | |
460 | if (da < KEYSTONE_RPROC_LOCAL_ADDRESS_MASK) { |
461 | /* handle DSP-view addresses */ |
462 | if (da >= dev_addr && |
463 | ((da + len) <= (dev_addr + size))) { |
464 | offset = da - dev_addr; |
465 | va = kproc->mem[i].cpu_addr + offset; |
466 | return (__force void *)va; |
467 | } |
468 | } else { |
469 | /* handle SoC-view addresses */ |
470 | if (da >= bus_addr && |
471 | (da + len) <= (bus_addr + size)) { |
472 | offset = da - bus_addr; |
473 | va = kproc->mem[i].cpu_addr + offset; |
474 | return (__force void *)va; |
475 | } |
476 | } |
477 | } |
478 | |
479 | /* handle static DDR reserved memory regions */ |
480 | for (i = 0; i < kproc->num_rmems; i++) { |
481 | dev_addr = kproc->rmem[i].dev_addr; |
482 | size = kproc->rmem[i].size; |
483 | |
484 | if (da >= dev_addr && ((da + len) <= (dev_addr + size))) { |
485 | offset = da - dev_addr; |
486 | va = kproc->rmem[i].cpu_addr + offset; |
487 | return (__force void *)va; |
488 | } |
489 | } |
490 | |
491 | return NULL; |
492 | } |
493 | |
494 | static const struct rproc_ops k3_dsp_rproc_ops = { |
495 | .start = k3_dsp_rproc_start, |
496 | .stop = k3_dsp_rproc_stop, |
497 | .kick = k3_dsp_rproc_kick, |
498 | .da_to_va = k3_dsp_rproc_da_to_va, |
499 | }; |
500 | |
501 | static int k3_dsp_rproc_of_get_memories(struct platform_device *pdev, |
502 | struct k3_dsp_rproc *kproc) |
503 | { |
504 | const struct k3_dsp_dev_data *data = kproc->data; |
505 | struct device *dev = &pdev->dev; |
506 | struct resource *res; |
507 | int num_mems = 0; |
508 | int i; |
509 | |
510 | num_mems = kproc->data->num_mems; |
511 | kproc->mem = devm_kcalloc(dev: kproc->dev, n: num_mems, |
512 | size: sizeof(*kproc->mem), GFP_KERNEL); |
513 | if (!kproc->mem) |
514 | return -ENOMEM; |
515 | |
516 | for (i = 0; i < num_mems; i++) { |
517 | res = platform_get_resource_byname(pdev, IORESOURCE_MEM, |
518 | data->mems[i].name); |
519 | if (!res) { |
520 | dev_err(dev, "found no memory resource for %s\n" , |
521 | data->mems[i].name); |
522 | return -EINVAL; |
523 | } |
524 | if (!devm_request_mem_region(dev, res->start, |
525 | resource_size(res), |
526 | dev_name(dev))) { |
527 | dev_err(dev, "could not request %s region for resource\n" , |
528 | data->mems[i].name); |
529 | return -EBUSY; |
530 | } |
531 | |
532 | kproc->mem[i].cpu_addr = devm_ioremap_wc(dev, offset: res->start, |
533 | size: resource_size(res)); |
534 | if (!kproc->mem[i].cpu_addr) { |
535 | dev_err(dev, "failed to map %s memory\n" , |
536 | data->mems[i].name); |
537 | return -ENOMEM; |
538 | } |
539 | kproc->mem[i].bus_addr = res->start; |
540 | kproc->mem[i].dev_addr = data->mems[i].dev_addr; |
541 | kproc->mem[i].size = resource_size(res); |
542 | |
543 | dev_dbg(dev, "memory %8s: bus addr %pa size 0x%zx va %pK da 0x%x\n" , |
544 | data->mems[i].name, &kproc->mem[i].bus_addr, |
545 | kproc->mem[i].size, kproc->mem[i].cpu_addr, |
546 | kproc->mem[i].dev_addr); |
547 | } |
548 | kproc->num_mems = num_mems; |
549 | |
550 | return 0; |
551 | } |
552 | |
553 | static void k3_dsp_mem_release(void *data) |
554 | { |
555 | struct device *dev = data; |
556 | |
557 | of_reserved_mem_device_release(dev); |
558 | } |
559 | |
560 | static int k3_dsp_reserved_mem_init(struct k3_dsp_rproc *kproc) |
561 | { |
562 | struct device *dev = kproc->dev; |
563 | struct device_node *np = dev->of_node; |
564 | struct device_node *rmem_np; |
565 | struct reserved_mem *rmem; |
566 | int num_rmems; |
567 | int ret, i; |
568 | |
569 | num_rmems = of_property_count_elems_of_size(np, propname: "memory-region" , |
570 | elem_size: sizeof(phandle)); |
571 | if (num_rmems < 0) { |
572 | dev_err(dev, "device does not reserved memory regions (%pe)\n" , |
573 | ERR_PTR(num_rmems)); |
574 | return -EINVAL; |
575 | } |
576 | if (num_rmems < 2) { |
577 | dev_err(dev, "device needs at least two memory regions to be defined, num = %d\n" , |
578 | num_rmems); |
579 | return -EINVAL; |
580 | } |
581 | |
582 | /* use reserved memory region 0 for vring DMA allocations */ |
583 | ret = of_reserved_mem_device_init_by_idx(dev, np, idx: 0); |
584 | if (ret) { |
585 | dev_err(dev, "device cannot initialize DMA pool (%pe)\n" , |
586 | ERR_PTR(ret)); |
587 | return ret; |
588 | } |
589 | ret = devm_add_action_or_reset(dev, k3_dsp_mem_release, dev); |
590 | if (ret) |
591 | return ret; |
592 | |
593 | num_rmems--; |
594 | kproc->rmem = devm_kcalloc(dev, n: num_rmems, size: sizeof(*kproc->rmem), GFP_KERNEL); |
595 | if (!kproc->rmem) |
596 | return -ENOMEM; |
597 | |
598 | /* use remaining reserved memory regions for static carveouts */ |
599 | for (i = 0; i < num_rmems; i++) { |
600 | rmem_np = of_parse_phandle(np, phandle_name: "memory-region" , index: i + 1); |
601 | if (!rmem_np) |
602 | return -EINVAL; |
603 | |
604 | rmem = of_reserved_mem_lookup(np: rmem_np); |
605 | if (!rmem) { |
606 | of_node_put(node: rmem_np); |
607 | return -EINVAL; |
608 | } |
609 | of_node_put(node: rmem_np); |
610 | |
611 | kproc->rmem[i].bus_addr = rmem->base; |
612 | /* 64-bit address regions currently not supported */ |
613 | kproc->rmem[i].dev_addr = (u32)rmem->base; |
614 | kproc->rmem[i].size = rmem->size; |
615 | kproc->rmem[i].cpu_addr = devm_ioremap_wc(dev, offset: rmem->base, size: rmem->size); |
616 | if (!kproc->rmem[i].cpu_addr) { |
617 | dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n" , |
618 | i + 1, &rmem->base, &rmem->size); |
619 | return -ENOMEM; |
620 | } |
621 | |
622 | dev_dbg(dev, "reserved memory%d: bus addr %pa size 0x%zx va %pK da 0x%x\n" , |
623 | i + 1, &kproc->rmem[i].bus_addr, |
624 | kproc->rmem[i].size, kproc->rmem[i].cpu_addr, |
625 | kproc->rmem[i].dev_addr); |
626 | } |
627 | kproc->num_rmems = num_rmems; |
628 | |
629 | return 0; |
630 | } |
631 | |
632 | static void k3_dsp_release_tsp(void *data) |
633 | { |
634 | struct ti_sci_proc *tsp = data; |
635 | |
636 | ti_sci_proc_release(tsp); |
637 | } |
638 | |
639 | static |
640 | struct ti_sci_proc *k3_dsp_rproc_of_get_tsp(struct device *dev, |
641 | const struct ti_sci_handle *sci) |
642 | { |
643 | struct ti_sci_proc *tsp; |
644 | u32 temp[2]; |
645 | int ret; |
646 | |
647 | ret = of_property_read_u32_array(np: dev->of_node, propname: "ti,sci-proc-ids" , |
648 | out_values: temp, sz: 2); |
649 | if (ret < 0) |
650 | return ERR_PTR(error: ret); |
651 | |
652 | tsp = devm_kzalloc(dev, size: sizeof(*tsp), GFP_KERNEL); |
653 | if (!tsp) |
654 | return ERR_PTR(error: -ENOMEM); |
655 | |
656 | tsp->dev = dev; |
657 | tsp->sci = sci; |
658 | tsp->ops = &sci->ops.proc_ops; |
659 | tsp->proc_id = temp[0]; |
660 | tsp->host_id = temp[1]; |
661 | |
662 | return tsp; |
663 | } |
664 | |
665 | static int k3_dsp_rproc_probe(struct platform_device *pdev) |
666 | { |
667 | struct device *dev = &pdev->dev; |
668 | struct device_node *np = dev->of_node; |
669 | const struct k3_dsp_dev_data *data; |
670 | struct k3_dsp_rproc *kproc; |
671 | struct rproc *rproc; |
672 | const char *fw_name; |
673 | bool p_state = false; |
674 | int ret = 0; |
675 | |
676 | data = of_device_get_match_data(dev); |
677 | if (!data) |
678 | return -ENODEV; |
679 | |
680 | ret = rproc_of_parse_firmware(dev, index: 0, fw_name: &fw_name); |
681 | if (ret) |
682 | return dev_err_probe(dev, err: ret, fmt: "failed to parse firmware-name property\n" ); |
683 | |
684 | rproc = devm_rproc_alloc(dev, name: dev_name(dev), ops: &k3_dsp_rproc_ops, |
685 | firmware: fw_name, len: sizeof(*kproc)); |
686 | if (!rproc) |
687 | return -ENOMEM; |
688 | |
689 | rproc->has_iommu = false; |
690 | rproc->recovery_disabled = true; |
691 | if (data->uses_lreset) { |
692 | rproc->ops->prepare = k3_dsp_rproc_prepare; |
693 | rproc->ops->unprepare = k3_dsp_rproc_unprepare; |
694 | } |
695 | kproc = rproc->priv; |
696 | kproc->rproc = rproc; |
697 | kproc->dev = dev; |
698 | kproc->data = data; |
699 | |
700 | kproc->ti_sci = devm_ti_sci_get_by_phandle(dev, property: "ti,sci" ); |
701 | if (IS_ERR(ptr: kproc->ti_sci)) |
702 | return dev_err_probe(dev, err: PTR_ERR(ptr: kproc->ti_sci), |
703 | fmt: "failed to get ti-sci handle\n" ); |
704 | |
705 | ret = of_property_read_u32(np, propname: "ti,sci-dev-id" , out_value: &kproc->ti_sci_id); |
706 | if (ret) |
707 | return dev_err_probe(dev, err: ret, fmt: "missing 'ti,sci-dev-id' property\n" ); |
708 | |
709 | kproc->reset = devm_reset_control_get_exclusive(dev, NULL); |
710 | if (IS_ERR(ptr: kproc->reset)) |
711 | return dev_err_probe(dev, err: PTR_ERR(ptr: kproc->reset), |
712 | fmt: "failed to get reset\n" ); |
713 | |
714 | kproc->tsp = k3_dsp_rproc_of_get_tsp(dev, sci: kproc->ti_sci); |
715 | if (IS_ERR(ptr: kproc->tsp)) |
716 | return dev_err_probe(dev, err: PTR_ERR(ptr: kproc->tsp), |
717 | fmt: "failed to construct ti-sci proc control\n" ); |
718 | |
719 | ret = ti_sci_proc_request(tsp: kproc->tsp); |
720 | if (ret < 0) { |
721 | dev_err_probe(dev, err: ret, fmt: "ti_sci_proc_request failed\n" ); |
722 | return ret; |
723 | } |
724 | ret = devm_add_action_or_reset(dev, k3_dsp_release_tsp, kproc->tsp); |
725 | if (ret) |
726 | return ret; |
727 | |
728 | ret = k3_dsp_rproc_of_get_memories(pdev, kproc); |
729 | if (ret) |
730 | return ret; |
731 | |
732 | ret = k3_dsp_reserved_mem_init(kproc); |
733 | if (ret) |
734 | return dev_err_probe(dev, err: ret, fmt: "reserved memory init failed\n" ); |
735 | |
736 | ret = kproc->ti_sci->ops.dev_ops.is_on(kproc->ti_sci, kproc->ti_sci_id, |
737 | NULL, &p_state); |
738 | if (ret) |
739 | return dev_err_probe(dev, err: ret, fmt: "failed to get initial state, mode cannot be determined\n" ); |
740 | |
741 | /* configure J721E devices for either remoteproc or IPC-only mode */ |
742 | if (p_state) { |
743 | dev_info(dev, "configured DSP for IPC-only mode\n" ); |
744 | rproc->state = RPROC_DETACHED; |
745 | /* override rproc ops with only required IPC-only mode ops */ |
746 | rproc->ops->prepare = NULL; |
747 | rproc->ops->unprepare = NULL; |
748 | rproc->ops->start = NULL; |
749 | rproc->ops->stop = NULL; |
750 | rproc->ops->attach = k3_dsp_rproc_attach; |
751 | rproc->ops->detach = k3_dsp_rproc_detach; |
752 | rproc->ops->get_loaded_rsc_table = k3_dsp_get_loaded_rsc_table; |
753 | } else { |
754 | dev_info(dev, "configured DSP for remoteproc mode\n" ); |
755 | /* |
756 | * ensure the DSP local reset is asserted to ensure the DSP |
757 | * doesn't execute bogus code in .prepare() when the module |
758 | * reset is released. |
759 | */ |
760 | if (data->uses_lreset) { |
761 | ret = reset_control_status(rstc: kproc->reset); |
762 | if (ret < 0) { |
763 | return dev_err_probe(dev, err: ret, fmt: "failed to get reset status\n" ); |
764 | } else if (ret == 0) { |
765 | dev_warn(dev, "local reset is deasserted for device\n" ); |
766 | k3_dsp_rproc_reset(kproc); |
767 | } |
768 | } |
769 | } |
770 | |
771 | ret = devm_rproc_add(dev, rproc); |
772 | if (ret) |
773 | return dev_err_probe(dev, err: ret, fmt: "failed to add register device with remoteproc core\n" ); |
774 | |
775 | platform_set_drvdata(pdev, data: kproc); |
776 | |
777 | return 0; |
778 | } |
779 | |
780 | static void k3_dsp_rproc_remove(struct platform_device *pdev) |
781 | { |
782 | struct k3_dsp_rproc *kproc = platform_get_drvdata(pdev); |
783 | struct rproc *rproc = kproc->rproc; |
784 | struct device *dev = &pdev->dev; |
785 | int ret; |
786 | |
787 | if (rproc->state == RPROC_ATTACHED) { |
788 | ret = rproc_detach(rproc); |
789 | if (ret) |
790 | dev_err(dev, "failed to detach proc (%pe)\n" , ERR_PTR(ret)); |
791 | } |
792 | } |
793 | |
794 | static const struct k3_dsp_mem_data c66_mems[] = { |
795 | { .name = "l2sram" , .dev_addr = 0x800000 }, |
796 | { .name = "l1pram" , .dev_addr = 0xe00000 }, |
797 | { .name = "l1dram" , .dev_addr = 0xf00000 }, |
798 | }; |
799 | |
800 | /* C71x cores only have a L1P Cache, there are no L1P SRAMs */ |
801 | static const struct k3_dsp_mem_data c71_mems[] = { |
802 | { .name = "l2sram" , .dev_addr = 0x800000 }, |
803 | { .name = "l1dram" , .dev_addr = 0xe00000 }, |
804 | }; |
805 | |
806 | static const struct k3_dsp_mem_data c7xv_mems[] = { |
807 | { .name = "l2sram" , .dev_addr = 0x800000 }, |
808 | }; |
809 | |
810 | static const struct k3_dsp_dev_data c66_data = { |
811 | .mems = c66_mems, |
812 | .num_mems = ARRAY_SIZE(c66_mems), |
813 | .boot_align_addr = SZ_1K, |
814 | .uses_lreset = true, |
815 | }; |
816 | |
817 | static const struct k3_dsp_dev_data c71_data = { |
818 | .mems = c71_mems, |
819 | .num_mems = ARRAY_SIZE(c71_mems), |
820 | .boot_align_addr = SZ_2M, |
821 | .uses_lreset = false, |
822 | }; |
823 | |
824 | static const struct k3_dsp_dev_data c7xv_data = { |
825 | .mems = c7xv_mems, |
826 | .num_mems = ARRAY_SIZE(c7xv_mems), |
827 | .boot_align_addr = SZ_2M, |
828 | .uses_lreset = false, |
829 | }; |
830 | |
831 | static const struct of_device_id k3_dsp_of_match[] = { |
832 | { .compatible = "ti,j721e-c66-dsp" , .data = &c66_data, }, |
833 | { .compatible = "ti,j721e-c71-dsp" , .data = &c71_data, }, |
834 | { .compatible = "ti,j721s2-c71-dsp" , .data = &c71_data, }, |
835 | { .compatible = "ti,am62a-c7xv-dsp" , .data = &c7xv_data, }, |
836 | { /* sentinel */ }, |
837 | }; |
838 | MODULE_DEVICE_TABLE(of, k3_dsp_of_match); |
839 | |
840 | static struct platform_driver k3_dsp_rproc_driver = { |
841 | .probe = k3_dsp_rproc_probe, |
842 | .remove_new = k3_dsp_rproc_remove, |
843 | .driver = { |
844 | .name = "k3-dsp-rproc" , |
845 | .of_match_table = k3_dsp_of_match, |
846 | }, |
847 | }; |
848 | |
849 | module_platform_driver(k3_dsp_rproc_driver); |
850 | |
851 | MODULE_AUTHOR("Suman Anna <s-anna@ti.com>" ); |
852 | MODULE_LICENSE("GPL v2" ); |
853 | MODULE_DESCRIPTION("TI K3 DSP Remoteproc driver" ); |
854 | |