1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * TI K3 R5F (MCU) Remote Processor driver
4 *
5 * Copyright (C) 2017-2019 Texas Instruments Incorporated - http://www.ti.com/
6 * Suman Anna <s-anna@ti.com>
7 */
9 #include <linux/dma-mapping.h>
10 #include <linux/err.h>
11 #include <linux/interrupt.h>
12 #include <linux/kernel.h>
13 #include <linux/mailbox_client.h>
14 #include <linux/module.h>
15 #include <linux/of_device.h>
16 #include <linux/of_address.h>
17 #include <linux/of_reserved_mem.h>
18 #include <linux/platform_device.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/remoteproc.h>
21 #include <linux/omap-mailbox.h>
22 #include <linux/reset.h>
23 #include <linux/soc/ti/ti_sci_protocol.h>
25 #include "omap_remoteproc.h"
26 #include "remoteproc_internal.h"
27 #include "ti_sci_proc.h"
29 /* This address can either be for ATCM or BTCM with the other at address 0x0 */
30 #define K3_R5_TCM_DEV_ADDR 0x41010000
32 /* R5 TI-SCI Processor Configuration Flags */
33 #define PROC_BOOT_CFG_FLAG_R5_DBG_EN 0x00000001
34 #define PROC_BOOT_CFG_FLAG_R5_DBG_NIDEN 0x00000002
35 #define PROC_BOOT_CFG_FLAG_R5_LOCKSTEP 0x00000100
36 #define PROC_BOOT_CFG_FLAG_R5_TEINIT 0x00000200
37 #define PROC_BOOT_CFG_FLAG_R5_NMFI_EN 0x00000400
38 #define PROC_BOOT_CFG_FLAG_R5_TCM_RSTBASE 0x00000800
39 #define PROC_BOOT_CFG_FLAG_R5_BTCM_EN 0x00001000
40 #define PROC_BOOT_CFG_FLAG_R5_ATCM_EN 0x00002000
42 /* R5 TI-SCI Processor Control Flags */
43 #define PROC_BOOT_CTRL_FLAG_R5_CORE_HALT 0x00000001
45 /* R5 TI-SCI Processor Status Flags */
46 #define PROC_BOOT_STATUS_FLAG_R5_WFE 0x00000001
47 #define PROC_BOOT_STATUS_FLAG_R5_WFI 0x00000002
48 #define PROC_BOOT_STATUS_FLAG_R5_CLK_GATED 0x00000004
49 #define PROC_BOOT_STATUS_FLAG_R5_LOCKSTEP_PERMITTED 0x00000100
51 /**
52 * struct k3_r5_mem - internal memory structure
53 * @cpu_addr: MPU virtual address of the memory region
54 * @bus_addr: Bus address used to access the memory region
55 * @dev_addr: Device address from remoteproc view
56 * @size: Size of the memory region
57 */
58 struct k3_r5_mem {
59 void __iomem *cpu_addr;
60 phys_addr_t bus_addr;
61 u32 dev_addr;
62 size_t size;
63 };
65 enum cluster_mode {
66 CLUSTER_MODE_SPLIT = 0,
67 CLUSTER_MODE_LOCKSTEP,
68 };
70 /**
71 * struct k3_r5_cluster - K3 R5F Cluster structure
72 * @dev: cached device pointer
73 * @mode: Mode to configure the Cluster - Split or LockStep
74 * @cores: list of R5 cores within the cluster
75 */
76 struct k3_r5_cluster {
77 struct device *dev;
78 enum cluster_mode mode;
79 struct list_head cores;
80 };
82 /**
83 * struct k3_r5_core - K3 R5 core structure
84 * @dev: cached device pointer
85 * @rproc: rproc handle representing this core
86 * @mem: internal memory regions data
87 * @sram: on-chip SRAM memory regions data
88 * @num_mems: number of internal memory regions
89 * @num_sram: number of on-chip SRAM memory regions
90 * @reset: reset control handle
91 * @tsp: TI-SCI processor control handle
92 * @ti_sci: TI-SCI handle
93 * @ti_sci_id: TI-SCI device identifier
94 * @atcm_enable: flag to control ATCM enablement
95 * @btcm_enable: flag to control BTCM enablement
96 * @loczrama: flag to dictate which TCM is at device address 0x0
97 */
98 struct k3_r5_core {
99 struct list_head elem;
100 struct device *dev;
101 struct rproc *rproc;
102 struct k3_r5_mem *mem;
103 struct k3_r5_mem *sram;
104 int num_mems;
105 int num_sram;
106 struct reset_control *reset;
107 struct ti_sci_proc *tsp;
108 const struct ti_sci_handle *ti_sci;
109 u32 ti_sci_id;
110 u32 atcm_enable;
111 u32 btcm_enable;
112 u32 loczrama;
113 };
115 /**
116 * struct k3_r5_rproc - K3 remote processor state
117 * @dev: cached device pointer
118 * @cluster: cached pointer to parent cluster structure
119 * @mbox: mailbox channel handle
120 * @client: mailbox client to request the mailbox channel
121 * @rproc: rproc handle
122 * @core: cached pointer to r5 core structure being used
123 * @rmem: reserved memory regions data
124 * @num_rmems: number of reserved memory regions
125 */
126 struct k3_r5_rproc {
127 struct device *dev;
128 struct k3_r5_cluster *cluster;
129 struct mbox_chan *mbox;
130 struct mbox_client client;
131 struct rproc *rproc;
132 struct k3_r5_core *core;
133 struct k3_r5_mem *rmem;
134 int num_rmems;
135 };
137 /**
138 * struct k3_r5_rproc_dev_data - device data for the remote processor
139 * @device_name: device name of the remote processor
140 * @fw_name: firmware name to use
141 */
142 struct k3_r5_rproc_dev_data {
143 const char *device_name;
144 const char *fw_name;
145 };
147 /**
148 * k3_r5_rproc_mbox_callback() - inbound mailbox message handler
149 * @client: mailbox client pointer used for requesting the mailbox channel
150 * @data: mailbox payload
151 *
152 * This handler is invoked by the OMAP mailbox driver whenever a mailbox
153 * message is received. Usually, the mailbox payload simply contains
154 * the index of the virtqueue that is kicked by the remote processor,
155 * and we let remoteproc core handle it.
156 *
157 * In addition to virtqueue indices, we also have some out-of-band values
158 * that indicate different events. Those values are deliberately very
159 * large so they don't coincide with virtqueue indices.
160 */
161 static void k3_r5_rproc_mbox_callback(struct mbox_client *client, void *data)
162 {
163 struct k3_r5_rproc *kproc = container_of(client, struct k3_r5_rproc,
164 client);
165 struct device *dev = kproc->rproc->dev.parent;
166 const char *name = kproc->rproc->name;
167 u32 msg = to_omap_mbox_msg(data);
169 dev_dbg(dev, "mbox msg: 0x%x\n", msg);
171 switch (msg) {
172 case RP_MBOX_CRASH:
173 /*
174 * remoteproc detected an exception, but error recovery is not
175 * supported. So, just log this for now
176 */
177 dev_err(dev, "K3 R5F rproc %s crashed\n", name);
178 break;
179 case RP_MBOX_ECHO_REPLY:
180 dev_info(dev, "received echo reply from %s\n", name);
181 break;
182 default:
183 /* silently handle all other valid messages */
184 if (msg >= RP_MBOX_READY && msg < RP_MBOX_END_MSG)
185 return;
186 if (msg > kproc->rproc->max_notifyid) {
187 dev_dbg(dev, "dropping unknown message 0x%x", msg);
188 return;
189 }
190 /* msg contains the index of the triggered vring */
191 if (rproc_vq_interrupt(kproc->rproc, msg) == IRQ_NONE)
192 dev_dbg(dev, "no message was found in vqid %d\n", msg);
193 }
194 }
196 /* kick a virtqueue */
197 static void k3_r5_rproc_kick(struct rproc *rproc, int vqid)
198 {
199 struct k3_r5_rproc *kproc = rproc->priv;
200 struct device *dev = rproc->dev.parent;
201 mbox_msg_t msg = (mbox_msg_t)vqid;
202 int ret;
204 /* send the index of the triggered virtqueue in the mailbox payload */
205 ret = mbox_send_message(kproc->mbox, (void *)msg);
206 if (ret < 0)
207 dev_err(dev, "failed to send mailbox message, status = %d\n",
208 ret);
209 }
211 static int k3_r5_split_reset(struct k3_r5_core *core)
212 {
213 int ret;
215 ret = reset_control_assert(core->reset);
216 if (ret) {
217 dev_err(core->dev, "local-reset assert failed, ret = %d\n",
218 ret);
219 return ret;
220 }
222 ret = core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
223 core->ti_sci_id);
224 if (ret) {
225 dev_err(core->dev, "module-reset assert failed, ret = %d\n",
226 ret);
227 if (reset_control_deassert(core->reset))
228 dev_warn(core->dev, "local-reset deassert back failed\n");
229 }
231 return ret;
232 }
234 static int k3_r5_split_release(struct k3_r5_core *core)
235 {
236 int ret;
238 ret = core->ti_sci->ops.dev_ops.get_device(core->ti_sci,
239 core->ti_sci_id);
240 if (ret) {
241 dev_err(core->dev, "module-reset deassert failed, ret = %d\n",
242 ret);
243 return ret;
244 }
246 ret = reset_control_deassert(core->reset);
247 if (ret) {
248 dev_err(core->dev, "local-reset deassert failed, ret = %d\n",
249 ret);
250 if (core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
251 core->ti_sci_id))
252 dev_warn(core->dev, "module-reset assert back failed\n");
253 }
255 return ret;
256 }
258 static int k3_r5_lockstep_reset(struct k3_r5_cluster *cluster)
259 {
260 struct k3_r5_core *core;
261 int ret;
263 /* assert local reset on all applicable cores */
264 list_for_each_entry(core, &cluster->cores, elem) {
265 ret = reset_control_assert(core->reset);
266 if (ret) {
267 dev_err(core->dev, "local-reset assert failed, ret = %d\n",
268 ret);
269 core = list_prev_entry(core, elem);
270 goto unroll_local_reset;
271 }
272 }
274 /* disable PSC modules on all applicable cores */
275 list_for_each_entry(core, &cluster->cores, elem) {
276 ret = core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
277 core->ti_sci_id);
278 if (ret) {
279 dev_err(core->dev, "module-reset assert failed, ret = %d\n",
280 ret);
281 goto unroll_module_reset;
282 }
283 }
285 return 0;
287 unroll_module_reset:
288 list_for_each_entry_continue_reverse(core, &cluster->cores, elem) {
289 if (core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
290 core->ti_sci_id))
291 dev_warn(core->dev, "module-reset assert back failed\n");
292 }
293 core = list_last_entry(&cluster->cores, struct k3_r5_core, elem);
294 unroll_local_reset:
295 list_for_each_entry_from_reverse(core, &cluster->cores, elem) {
296 if (reset_control_deassert(core->reset))
297 dev_warn(core->dev, "local-reset deassert back failed\n");
298 }
300 return ret;
301 }
303 static int k3_r5_lockstep_release(struct k3_r5_cluster *cluster)
304 {
305 struct k3_r5_core *core;
306 int ret;
308 /* enable PSC modules on all applicable cores */
309 list_for_each_entry_reverse(core, &cluster->cores, elem) {
310 ret = core->ti_sci->ops.dev_ops.get_device(core->ti_sci,
311 core->ti_sci_id);
312 if (ret) {
313 dev_err(core->dev, "module-reset deassert failed, ret = %d\n",
314 ret);
315 core = list_next_entry(core, elem);
316 goto unroll_module_reset;
317 }
318 }
320 /* deassert local reset on all applicable cores */
321 list_for_each_entry_reverse(core, &cluster->cores, elem) {
322 ret = reset_control_deassert(core->reset);
323 if (ret) {
324 dev_err(core->dev, "module-reset deassert failed, ret = %d\n",
325 ret);
326 goto unroll_local_reset;
327 }
328 }
330 return 0;
332 unroll_local_reset:
333 list_for_each_entry_continue(core, &cluster->cores, elem) {
334 if (reset_control_assert(core->reset))
335 dev_warn(core->dev, "local-reset assert back failed\n");
336 }
337 core = list_first_entry(&cluster->cores, struct k3_r5_core, elem);
338 unroll_module_reset:
339 list_for_each_entry_from(core, &cluster->cores, elem) {
340 if (core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
341 core->ti_sci_id))
342 dev_warn(core->dev, "module-reset assert back failed\n");
343 }
345 return ret;
346 }
348 static inline int k3_r5_core_halt(struct k3_r5_core *core)
349 {
350 return ti_sci_proc_set_control(core->tsp,
351 PROC_BOOT_CTRL_FLAG_R5_CORE_HALT, 0);
352 }
354 static inline int k3_r5_core_run(struct k3_r5_core *core)
355 {
356 return ti_sci_proc_set_control(core->tsp,
357 0, PROC_BOOT_CTRL_FLAG_R5_CORE_HALT);
358 }
360 /*
361 * The R5F cores have controls for both a reset and a halt/run. The code
362 * execution from DDR requires the initial boot-strapping code to be run
363 * from the internal TCMs. This function is used to release the resets on
364 * applicable cores to allow loading into the TCMs. The .prepare() ops is
365 * invoked by remoteproc core before any firmware loading, and is followed
366 * by the .start() ops after loading to actually let the R5 cores run.
367 */
368 static int k3_r5_rproc_prepare(struct rproc *rproc)
369 {
370 struct k3_r5_rproc *kproc = rproc->priv;
371 struct k3_r5_cluster *cluster = kproc->cluster;
372 struct k3_r5_core *core = kproc->core;
373 struct device *dev = kproc->dev;
374 int ret;
376 ret = cluster->mode ? k3_r5_lockstep_release(cluster) :
377 k3_r5_split_release(core);
378 if (ret)
379 dev_err(dev, "unable to enable cores for TCM loading, ret = %d\n",
380 ret);
382 /*
383 * Zero out both TCMs unconditionally (access from v8 Arm core is not
384 * affected by ATCM & BTCM enable configuration values) so that ECC
385 * can be effective on all TCM addresses.
386 */
387 dev_dbg(dev, "zeroing out ATCM memory\n");
388 memset(core->mem[0].cpu_addr, 0x00, core->mem[0].size);
390 dev_dbg(dev, "zeroing out BTCM memory\n");
391 memset(core->mem[1].cpu_addr, 0x00, core->mem[1].size);
393 return ret;
394 }
396 /*
397 * This function implements the .unprepare() ops and performs the complimentary
398 * operations to that of the .prepare() ops. The function is used to assert the
399 * resets on all applicable cores for the rproc device (depending on LockStep
400 * or Split mode). This completes the second portion of powering down the R5F
401 * cores. The cores themselves are only halted in the .stop() ops, and the
402 * .unprepare() ops is invoked by the remoteproc core after the remoteproc is
403 * stopped.
404 */
405 static int k3_r5_rproc_unprepare(struct rproc *rproc)
406 {
407 struct k3_r5_rproc *kproc = rproc->priv;
408 struct k3_r5_cluster *cluster = kproc->cluster;
409 struct k3_r5_core *core = kproc->core;
410 struct device *dev = kproc->dev;
411 int ret;
413 ret = cluster->mode ? k3_r5_lockstep_reset(cluster) :
414 k3_r5_split_reset(core);
415 if (ret)
416 dev_err(dev, "unable to disable cores, ret = %d\n", ret);
418 return ret;
419 }
421 /*
422 * The R5F start sequence includes two different operations
423 * 1. Configure the boot vector for R5F core(s)
424 * 2. Unhalt/Run the R5F core(s)
425 *
426 * The sequence is different between LockStep and Split modes. The LockStep
427 * mode requires the boot vector to be configured only for Core0, and then
428 * unhalt both the cores to start the execution - Core1 needs to be unhalted
429 * first followed by Core0. The Split-mode requires that Core0 to be maintained
430 * always in a higher power state that Core1 (implying Core1 needs to be started
431 * always only after Core0 is started).
432 */
433 static int k3_r5_rproc_start(struct rproc *rproc)
434 {
435 struct k3_r5_rproc *kproc = rproc->priv;
436 struct k3_r5_cluster *cluster = kproc->cluster;
437 struct mbox_client *client = &kproc->client;
438 struct device *dev = kproc->dev;
439 struct k3_r5_core *core;
440 u32 boot_addr;
441 int ret;
443 client->dev = dev;
444 client->tx_done = NULL;
445 client->rx_callback = k3_r5_rproc_mbox_callback;
446 client->tx_block = false;
447 client->knows_txdone = false;
449 kproc->mbox = mbox_request_channel(client, 0);
450 if (IS_ERR(kproc->mbox)) {
451 ret = -EBUSY;
452 dev_err(dev, "mbox_request_channel failed: %ld\n",
453 PTR_ERR(kproc->mbox));
454 return ret;
455 }
457 /*
458 * Ping the remote processor, this is only for sanity-sake for now;
459 * there is no functional effect whatsoever.
460 *
461 * Note that the reply will _not_ arrive immediately: this message
462 * will wait in the mailbox fifo until the remote processor is booted.
463 */
464 ret = mbox_send_message(kproc->mbox, (void *)RP_MBOX_ECHO_REQUEST);
465 if (ret < 0) {
466 dev_err(dev, "mbox_send_message failed: %d\n", ret);
467 goto put_mbox;
468 }
470 boot_addr = rproc->bootaddr;
471 /* TODO: add boot_addr sanity checking */
472 dev_err(dev, "booting R5F core using boot addr = 0x%x\n", boot_addr);
474 /* boot vector need not be programmed for Core1 in LockStep mode */
475 core = kproc->core;
476 ret = ti_sci_proc_set_config(core->tsp, boot_addr, 0, 0);
477 if (ret)
478 goto put_mbox;
480 /* unhalt/run all applicable cores */
481 if (cluster->mode) {
482 list_for_each_entry_reverse(core, &cluster->cores, elem) {
483 ret = k3_r5_core_run(core);
484 if (ret)
485 goto unroll_core_run;
486 }
487 } else {
488 ret = k3_r5_core_run(core);
489 if (ret)
490 goto put_mbox;
491 }
493 return 0;
495 unroll_core_run:
496 list_for_each_entry_continue(core, &cluster->cores, elem) {
497 if (k3_r5_core_halt(core))
498 dev_warn(core->dev, "core halt back failed\n");
499 }
500 put_mbox:
501 mbox_free_channel(kproc->mbox);
502 return ret;
503 }
505 /*
506 * The R5F stop function includes the following operations
507 * 1. Halt R5F core(s)
508 *
509 * The sequence is different between LockStep and Split modes, and the order
510 * of cores the operations are performed are also in general reverse to that
511 * of the start function. The LockStep mode requires each operation to be
512 * performed first on Core0 followed by Core1. The Split-mode requires that
513 * Core0 to be maintained always in a higher power state that Core1 (implying
514 * Core1 needs to be stopped first before Core0).
515 *
516 * Note that the R5F halt operation in general is not effective when the R5F
517 * core is running, but is needed to make sure the core won't run after
518 * deasserting the reset the subsequent time. The asserting of reset can
519 * be done here, but is preferred to be done in the .unprepare() ops - this
520 * maintains the symmetric behavior between the .start(), .stop(), .prepare()
521 * and .unprepare() ops, and also balances them well between sysfs 'state'
522 * flow and device bind/unbind or module removal.
523 */
524 static int k3_r5_rproc_stop(struct rproc *rproc)
525 {
526 struct k3_r5_rproc *kproc = rproc->priv;
527 struct k3_r5_cluster *cluster = kproc->cluster;
528 struct k3_r5_core *core = kproc->core;
529 int ret;
531 /* halt all applicable cores */
532 if (cluster->mode) {
533 list_for_each_entry(core, &cluster->cores, elem) {
534 ret = k3_r5_core_halt(core);
535 if (ret) {
536 core = list_prev_entry(core, elem);
537 goto unroll_core_halt;
538 }
539 }
540 } else {
541 ret = k3_r5_core_halt(core);
542 if (ret)
543 goto out;
544 }
546 mbox_free_channel(kproc->mbox);
548 return 0;
550 unroll_core_halt:
551 list_for_each_entry_from_reverse(core, &cluster->cores, elem) {
552 if (k3_r5_core_run(core))
553 dev_warn(core->dev, "core run back failed\n");
554 }
555 out:
556 return ret;
557 }
559 /*
560 * Internal Memory translation helper
561 *
562 * Custom function implementing the rproc .da_to_va ops to provide address
563 * translation (device address to kernel virtual address) for internal RAMs
564 * present in a DSP or IPU device). The translated addresses can be used
565 * either by the remoteproc core for loading, or by any rpmsg bus drivers.
566 */
567 static void *k3_r5_rproc_da_to_va(struct rproc *rproc, u64 da, int len,
568 u32 flags)
569 {
570 struct k3_r5_rproc *kproc = rproc->priv;
571 struct k3_r5_core *core = kproc->core;
572 void __iomem *va = NULL;
573 phys_addr_t bus_addr;
574 u32 dev_addr, offset;
575 size_t size;
576 int i;
578 if (len <= 0)
579 return NULL;
581 /* handle both R5 and SoC views of ATCM and BTCM */
582 for (i = 0; i < core->num_mems; i++) {
583 bus_addr = core->mem[i].bus_addr;
584 dev_addr = core->mem[i].dev_addr;
585 size = core->mem[i].size;
587 /* handle R5-view addresses of TCMs */
588 if (da >= dev_addr && ((da + len) <= (dev_addr + size))) {
589 offset = da - dev_addr;
590 va = core->mem[i].cpu_addr + offset;
591 return (__force void *)va;
592 }
594 /* handle SoC-view addresses of TCMs */
595 if (da >= bus_addr && ((da + len) <= (bus_addr + size))) {
596 offset = da - bus_addr;
597 va = core->mem[i].cpu_addr + offset;
598 return (__force void *)va;
599 }
600 }
602 /* handle any SRAM regions using SoC-view addresses */
603 for (i = 0; i < core->num_sram; i++) {
604 dev_addr = core->sram[i].dev_addr;
605 size = core->sram[i].size;
607 if (da >= dev_addr && ((da + len) <= (dev_addr + size))) {
608 offset = da - dev_addr;
609 va = core->sram[i].cpu_addr + offset;
610 return (__force void *)va;
611 }
612 }
614 /* handle static DDR reserved memory regions */
615 for (i = 0; i < kproc->num_rmems; i++) {
616 dev_addr = kproc->rmem[i].dev_addr;
617 size = kproc->rmem[i].size;
619 if (da >= dev_addr && ((da + len) <= (dev_addr + size))) {
620 offset = da - dev_addr;
621 va = kproc->rmem[i].cpu_addr + offset;
622 return (__force void *)va;
623 }
624 }
626 return NULL;
627 }
629 static const struct rproc_ops k3_r5_rproc_ops = {
630 .prepare = k3_r5_rproc_prepare,
631 .unprepare = k3_r5_rproc_unprepare,
632 .start = k3_r5_rproc_start,
633 .stop = k3_r5_rproc_stop,
634 .kick = k3_r5_rproc_kick,
635 .da_to_va = k3_r5_rproc_da_to_va,
636 };
638 static const char *k3_r5_rproc_get_firmware(struct device *dev)
639 {
640 const struct k3_r5_rproc_dev_data *data =
641 of_device_get_match_data(dev->parent);
643 if (!data) {
644 dev_err(dev, "data is NULL, %s\n", dev_name(dev));
645 return ERR_PTR(-ENODEV);
646 }
648 for (; data && data->device_name; data++) {
649 if (!strcmp(dev_name(dev), data->device_name))
650 return data->fw_name;
651 }
653 return ERR_PTR(-ENODEV);
654 }
656 static int k3_r5_rproc_configure(struct k3_r5_rproc *kproc)
657 {
658 struct k3_r5_cluster *cluster = kproc->cluster;
659 struct device *dev = kproc->dev;
660 struct k3_r5_core *core0, *core, *temp;
661 u32 ctrl = 0, cfg = 0, stat = 0;
662 u32 set_cfg = 0, clr_cfg = 0;
663 u64 boot_vec = 0;
664 bool lockstep_en;
665 int ret;
667 core0 = list_first_entry(&cluster->cores, struct k3_r5_core, elem);
668 core = cluster->mode ? core0 : kproc->core;
670 ret = ti_sci_proc_get_status(core->tsp, &boot_vec, &cfg, &ctrl,
671 &stat);
672 if (ret < 0)
673 return ret;
675 dev_dbg(dev, "boot_vector = 0x%llx, cfg = 0x%x ctrl = 0x%x stat = 0x%x\n",
676 boot_vec, cfg, ctrl, stat);
678 lockstep_en = !!(stat & PROC_BOOT_STATUS_FLAG_R5_LOCKSTEP_PERMITTED);
679 if (!lockstep_en && cluster->mode) {
680 dev_err(cluster->dev, "lockstep mode not permitted, force configuring for split-mode\n");
681 cluster->mode = 0;
682 }
684 /* always enable ARM mode and set boot vector to 0 */
685 boot_vec = 0x0;
686 if (core == core0) {
687 clr_cfg = PROC_BOOT_CFG_FLAG_R5_TEINIT;
688 if (lockstep_en)
689 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_LOCKSTEP;
690 }
692 if (core->atcm_enable)
693 set_cfg |= PROC_BOOT_CFG_FLAG_R5_ATCM_EN;
694 else
695 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_ATCM_EN;
697 if (core->btcm_enable)
698 set_cfg |= PROC_BOOT_CFG_FLAG_R5_BTCM_EN;
699 else
700 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_BTCM_EN;
702 if (core->loczrama)
703 set_cfg |= PROC_BOOT_CFG_FLAG_R5_TCM_RSTBASE;
704 else
705 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_TCM_RSTBASE;
707 if (cluster->mode) {
708 /*
709 * work around system firmware limitations to make sure both
710 * cores are programmed symmetrically in LockStep. LockStep
711 * and TEINIT config is only allowed with Core0.
712 */
713 list_for_each_entry(temp, &cluster->cores, elem) {
714 ret = k3_r5_core_halt(core);
715 if (ret)
716 goto out;
718 if (temp != core) {
719 clr_cfg &= ~PROC_BOOT_CFG_FLAG_R5_LOCKSTEP;
720 clr_cfg &= ~PROC_BOOT_CFG_FLAG_R5_TEINIT;
721 }
722 ret = ti_sci_proc_set_config(temp->tsp, boot_vec,
723 set_cfg, clr_cfg);
724 if (ret)
725 goto out;
726 }
728 set_cfg = PROC_BOOT_CFG_FLAG_R5_LOCKSTEP;
729 clr_cfg = 0;
730 ret = ti_sci_proc_set_config(core->tsp, boot_vec,
731 set_cfg, clr_cfg);
732 } else {
733 ret = k3_r5_core_halt(core);
734 if (ret)
735 goto out;
737 ret = ti_sci_proc_set_config(core->tsp, boot_vec,
738 set_cfg, clr_cfg);
739 }
741 out:
742 return ret;
743 }
745 static int k3_r5_reserved_mem_init(struct k3_r5_rproc *kproc)
746 {
747 struct device *dev = kproc->dev;
748 struct device_node *np = dev->of_node;
749 struct device_node *rmem_np;
750 struct reserved_mem *rmem;
751 int num_rmems;
752 int ret, i;
754 num_rmems = of_property_count_elems_of_size(np, "memory-region",
755 sizeof(phandle));
756 if (num_rmems <= 0) {
757 dev_err(dev, "device does not have reserved memory regions, ret = %d\n",
758 num_rmems);
759 return -EINVAL;
760 }
761 if (num_rmems < 2) {
762 dev_err(dev, "device needs atleast two memory regions to be defined, num = %d\n",
763 num_rmems);
764 return -EINVAL;
765 }
767 /* use reserved memory region 0 for vring DMA allocations */
768 ret = of_reserved_mem_device_init_by_idx(dev, np, 0);
769 if (ret) {
770 dev_err(dev, "device cannot initialize DMA pool, ret = %d\n",
771 ret);
772 return ret;
773 }
775 num_rmems--;
776 kproc->rmem = kcalloc(num_rmems, sizeof(*kproc->rmem), GFP_KERNEL);
777 if (!kproc->rmem) {
778 ret = -ENOMEM;
779 goto release_rmem;
780 }
782 /* use remaining reserved memory regions for static carveouts */
783 for (i = 0; i < num_rmems; i++) {
784 rmem_np = of_parse_phandle(np, "memory-region", i + 1);
785 if (!rmem_np) {
786 ret = -EINVAL;
787 goto unmap_rmem;
788 }
790 rmem = of_reserved_mem_lookup(rmem_np);
791 if (!rmem) {
792 of_node_put(rmem_np);
793 ret = -EINVAL;
794 goto unmap_rmem;
795 }
796 of_node_put(rmem_np);
798 kproc->rmem[i].bus_addr = rmem->base;
799 /* 64-bit address regions currently not supported */
800 kproc->rmem[i].dev_addr = (u32)rmem->base;
801 kproc->rmem[i].size = rmem->size;
802 kproc->rmem[i].cpu_addr = ioremap_wc(rmem->base, rmem->size);
803 if (!kproc->rmem[i].cpu_addr) {
804 dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n",
805 i + 1, &rmem->base, &rmem->size);
806 ret = -ENOMEM;
807 goto unmap_rmem;
808 }
810 dev_dbg(dev, "reserved memory%d: bus addr %pa size 0x%zx va %pK da 0x%x\n",
811 i + 1, &kproc->rmem[i].bus_addr,
812 kproc->rmem[i].size, kproc->rmem[i].cpu_addr,
813 kproc->rmem[i].dev_addr);
814 }
815 kproc->num_rmems = num_rmems;
817 return 0;
819 unmap_rmem:
820 for (i--; i >= 0; i--) {
821 if (kproc->rmem[i].cpu_addr)
822 iounmap(kproc->rmem[i].cpu_addr);
823 }
824 kfree(kproc->rmem);
825 release_rmem:
826 of_reserved_mem_device_release(dev);
827 return ret;
828 }
830 static void k3_r5_reserved_mem_exit(struct k3_r5_rproc *kproc)
831 {
832 int i;
834 for (i = 0; i < kproc->num_rmems; i++)
835 iounmap(kproc->rmem[i].cpu_addr);
836 kfree(kproc->rmem);
838 of_reserved_mem_device_release(kproc->dev);
839 }
841 static int k3_r5_cluster_rproc_init(struct platform_device *pdev)
842 {
843 struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
844 struct device *dev = &pdev->dev;
845 struct k3_r5_rproc *kproc;
846 struct k3_r5_core *core, *core1;
847 struct device *cdev;
848 const char *fw_name;
849 struct rproc *rproc;
850 int ret;
852 core1 = list_last_entry(&cluster->cores, struct k3_r5_core, elem);
853 list_for_each_entry(core, &cluster->cores, elem) {
854 cdev = core->dev;
855 fw_name = k3_r5_rproc_get_firmware(cdev);
856 if (IS_ERR(fw_name)) {
857 ret = PTR_ERR(fw_name);
858 goto out;
859 }
861 rproc = rproc_alloc(cdev, dev_name(cdev), &k3_r5_rproc_ops,
862 fw_name, sizeof(*kproc));
863 if (!rproc) {
864 ret = -ENOMEM;
865 goto out;
866 }
868 /* K3 R5s have a Region Address Translator (RAT) but no MMU */
869 rproc->has_iommu = false;
870 /* error recovery is not supported at present */
871 rproc->recovery_disabled = true;
873 kproc = rproc->priv;
874 kproc->cluster = cluster;
875 kproc->core = core;
876 kproc->dev = cdev;
877 kproc->rproc = rproc;
878 core->rproc = rproc;
880 ret = k3_r5_rproc_configure(kproc);
881 if (ret) {
882 dev_err(dev, "initial configure failed, ret = %d\n",
883 ret);
884 goto err_config;
885 }
887 ret = k3_r5_reserved_mem_init(kproc);
888 if (ret) {
889 dev_err(dev, "reserved memory init failed, ret = %d\n",
890 ret);
891 goto err_config;
892 }
894 ret = rproc_add(rproc);
895 if (ret) {
896 dev_err(dev, "rproc_add failed, ret = %d\n", ret);
897 goto err_add;
898 }
900 /* create only one rproc in lockstep mode */
901 if (cluster->mode)
902 break;
903 }
905 return 0;
907 err_split:
908 rproc_del(rproc);
909 err_add:
910 k3_r5_reserved_mem_exit(kproc);
911 err_config:
912 rproc_free(rproc);
913 core->rproc = NULL;
914 out:
915 /* undo core0 upon any failures on core1 in split-mode */
916 if (!cluster->mode && core == core1) {
917 core = list_prev_entry(core, elem);
918 rproc = core->rproc;
919 kproc = rproc->priv;
920 goto err_split;
921 }
922 return ret;
923 }
925 static int k3_r5_cluster_rproc_exit(struct platform_device *pdev)
926 {
927 struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
928 struct k3_r5_rproc *kproc;
929 struct k3_r5_core *core;
930 struct rproc *rproc;
932 /*
933 * lockstep mode has only one rproc associated with first core, whereas
934 * split-mode has two rprocs associated with each core, and requires
935 * that core1 be powered down first
936 */
937 core = cluster->mode ?
938 list_first_entry(&cluster->cores, struct k3_r5_core, elem) :
939 list_last_entry(&cluster->cores, struct k3_r5_core, elem);
941 list_for_each_entry_from_reverse(core, &cluster->cores, elem) {
942 rproc = core->rproc;
943 kproc = rproc->priv;
945 rproc_del(rproc);
947 k3_r5_reserved_mem_exit(kproc);
949 rproc_free(rproc);
950 core->rproc = NULL;
951 }
953 return 0;
954 }
956 static int k3_r5_core_of_get_internal_memories(struct platform_device *pdev,
957 struct k3_r5_core *core)
958 {
959 static const char * const mem_names[] = {"atcm", "btcm"};
960 struct device *dev = &pdev->dev;
961 struct resource *res;
962 int num_mems;
963 int i, ret;
965 num_mems = ARRAY_SIZE(mem_names);
966 core->mem = devm_kcalloc(dev, num_mems, sizeof(*core->mem), GFP_KERNEL);
967 if (!core->mem)
968 return -ENOMEM;
970 for (i = 0; i < num_mems; i++) {
971 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
972 mem_names[i]);
973 if (!res) {
974 dev_err(dev, "found no memory resource for %s\n",
975 mem_names[i]);
976 ret = -EINVAL;
977 goto fail;
978 }
979 if (!devm_request_mem_region(dev, res->start,
980 resource_size(res),
981 dev_name(dev))) {
982 dev_err(dev, "could not request %s region for resource\n",
983 mem_names[i]);
984 ret = -EBUSY;
985 goto fail;
986 }
988 core->mem[i].cpu_addr = devm_ioremap_wc(dev, res->start,
989 resource_size(res));
990 if (IS_ERR(core->mem[i].cpu_addr)) {
991 dev_err(dev, "failed to map %s memory\n", mem_names[i]);
992 ret = PTR_ERR(core->mem[i].cpu_addr);
993 devm_release_mem_region(dev, res->start,
994 resource_size(res));
995 goto fail;
996 }
997 core->mem[i].bus_addr = res->start;
999 /*
1000 * TODO:
1001 * The R5F cores can place ATCM & BTCM anywhere in its address
1002 * based on the corresponding Region Registers in the System
1003 * Control coprocessor. For now, place ATCM and BTCM at
1004 * addresses 0 and 0x41010000 (same as the bus address on AM65x
1005 * SoCs) based on loczrama setting
1006 */
1007 if (!strcmp(mem_names[i], "atcm")) {
1008 core->mem[i].dev_addr = core->loczrama ?
1009 0 : K3_R5_TCM_DEV_ADDR;
1010 } else {
1011 core->mem[i].dev_addr = core->loczrama ?
1012 K3_R5_TCM_DEV_ADDR : 0;
1013 }
1014 core->mem[i].size = resource_size(res);
1016 dev_dbg(dev, "memory %8s: bus addr %pa size 0x%zx va %p da 0x%x\n",
1017 mem_names[i], &core->mem[i].bus_addr,
1018 core->mem[i].size, core->mem[i].cpu_addr,
1019 core->mem[i].dev_addr);
1020 }
1021 core->num_mems = num_mems;
1023 return 0;
1025 fail:
1026 for (i--; i >= 0; i--) {
1027 devm_release_mem_region(dev, core->mem[i].bus_addr,
1028 core->mem[i].size);
1029 devm_iounmap(dev, core->mem[i].cpu_addr);
1030 }
1031 if (core->mem)
1032 devm_kfree(dev, core->mem);
1033 return ret;
1034 }
1036 static int k3_r5_core_of_get_sram_memories(struct platform_device *pdev,
1037 struct k3_r5_core *core)
1038 {
1039 struct device_node *np = pdev->dev.of_node;
1040 struct device *dev = &pdev->dev;
1041 struct device_node *sram_np;
1042 struct resource res;
1043 int num_sram;
1044 int i, ret;
1046 num_sram = of_property_count_elems_of_size(np, "sram", sizeof(phandle));
1047 if (num_sram <= 0) {
1048 dev_dbg(dev, "device does not use reserved on-chip memories, num_sram = %d\n",
1049 num_sram);
1050 return 0;
1051 }
1053 core->sram = kcalloc(num_sram, sizeof(*core->sram), GFP_KERNEL);
1054 if (!core->sram)
1055 return -ENOMEM;
1057 for (i = 0; i < num_sram; i++) {
1058 sram_np = of_parse_phandle(np, "sram", i);
1059 if (!sram_np) {
1060 ret = -EINVAL;
1061 goto fail;
1062 }
1064 if (!of_device_is_available(sram_np)) {
1065 of_node_put(sram_np);
1066 ret = -EINVAL;
1067 goto fail;
1068 }
1070 ret = of_address_to_resource(sram_np, 0, &res);
1071 of_node_put(sram_np);
1072 if (ret) {
1073 ret = -EINVAL;
1074 goto fail;
1075 }
1076 core->sram[i].bus_addr = res.start;
1077 core->sram[i].dev_addr = res.start;
1078 core->sram[i].size = resource_size(&res);
1079 core->sram[i].cpu_addr = ioremap_wc(res.start,
1080 resource_size(&res));
1081 if (!core->sram[i].cpu_addr) {
1082 dev_err(dev, "failed to parse and map sram%d memory at %pad\n",
1083 i, &res.start);
1084 ret = -ENOMEM;
1085 goto fail;
1086 }
1088 dev_dbg(dev, "memory sram%d: bus addr %pa size 0x%zx va %pK da 0x%x\n",
1089 i, &core->sram[i].bus_addr,
1090 core->sram[i].size, core->sram[i].cpu_addr,
1091 core->sram[i].dev_addr);
1092 }
1093 core->num_sram = num_sram;
1095 return 0;
1097 fail:
1098 for (i--; i >= 0; i--) {
1099 if (core->sram[i].cpu_addr)
1100 iounmap(core->sram[i].cpu_addr);
1101 }
1102 kfree(core->sram);
1104 return ret;
1105 }
1107 static
1108 struct ti_sci_proc *k3_r5_core_of_get_tsp(struct device *dev,
1109 const struct ti_sci_handle *sci)
1110 {
1111 struct ti_sci_proc *tsp;
1112 u32 temp[2];
1113 int ret;
1115 ret = of_property_read_u32_array(dev->of_node, "ti,sci-proc-ids",
1116 temp, 2);
1117 if (ret < 0)
1118 return ERR_PTR(ret);
1120 tsp = kzalloc(sizeof(*tsp), GFP_KERNEL);
1121 if (!tsp)
1122 return ERR_PTR(-ENOMEM);
1124 tsp->dev = dev;
1125 tsp->sci = sci;
1126 tsp->ops = &sci->ops.proc_ops;
1127 tsp->proc_id = temp[0];
1128 tsp->host_id = temp[1];
1130 return tsp;
1131 }
1133 static int k3_r5_core_of_init(struct platform_device *pdev)
1134 {
1135 struct device *dev = &pdev->dev;
1136 struct device_node *np = dev->of_node;
1137 struct k3_r5_core *core;
1138 int ret, ret1, i;
1140 core = devm_kzalloc(dev, sizeof(*core), GFP_KERNEL);
1141 if (!core)
1142 return -ENOMEM;
1144 core->dev = dev;
1145 core->atcm_enable = 0;
1146 core->btcm_enable = 1;
1147 core->loczrama = 1;
1149 ret = of_property_read_u32(np, "atcm-enable", &core->atcm_enable);
1150 if (ret < 0 && ret != -EINVAL) {
1151 dev_err(dev, "invalid format for atcm-enable, ret = %d\n", ret);
1152 goto err_of;
1153 }
1155 ret = of_property_read_u32(np, "btcm-enable", &core->btcm_enable);
1156 if (ret < 0 && ret != -EINVAL) {
1157 dev_err(dev, "invalid format for btcm-enable, ret = %d\n", ret);
1158 goto err_of;
1159 }
1161 ret = of_property_read_u32(np, "loczrama", &core->loczrama);
1162 if (ret < 0 && ret != -EINVAL) {
1163 dev_err(dev, "invalid format for loczrama, ret = %d\n", ret);
1164 goto err_of;
1165 }
1167 core->ti_sci = ti_sci_get_by_phandle(np, "ti,sci");
1168 if (IS_ERR(core->ti_sci)) {
1169 ret = PTR_ERR(core->ti_sci);
1170 if (ret != -EPROBE_DEFER) {
1171 dev_err(dev, "failed to get ti-sci handle, ret = %d\n",
1172 ret);
1173 }
1174 core->ti_sci = NULL;
1175 goto err_of;
1176 }
1178 ret = of_property_read_u32(np, "ti,sci-dev-id", &core->ti_sci_id);
1179 if (ret) {
1180 dev_err(dev, "missing 'ti,sci-dev-id' property\n");
1181 goto err_sci_id;
1182 }
1184 core->reset = reset_control_get_exclusive(dev, NULL);
1185 if (IS_ERR(core->reset)) {
1186 ret = PTR_ERR(core->reset);
1187 if (ret != -EPROBE_DEFER) {
1188 dev_err(dev, "failed to get reset handle, ret = %d\n",
1189 ret);
1190 }
1191 goto err_sci_id;
1192 }
1194 core->tsp = k3_r5_core_of_get_tsp(dev, core->ti_sci);
1195 if (IS_ERR(core->tsp)) {
1196 dev_err(dev, "failed to construct ti-sci proc control, ret = %d\n",
1197 ret);
1198 ret = PTR_ERR(core->tsp);
1199 goto err_sci_proc;
1200 }
1202 ret = ti_sci_proc_request(core->tsp);
1203 if (ret < 0) {
1204 dev_err(dev, "ti_sci_proc_request failed, ret = %d\n", ret);
1205 goto err_proc;
1206 }
1208 ret = k3_r5_core_of_get_internal_memories(pdev, core);
1209 if (ret) {
1210 dev_err(dev, "failed to get internal memories, ret = %d\n",
1211 ret);
1212 goto err_intmem;
1213 }
1215 ret = k3_r5_core_of_get_sram_memories(pdev, core);
1216 if (ret) {
1217 dev_err(dev, "failed to get sram memories, ret = %d\n", ret);
1218 goto err_sram;
1219 }
1221 platform_set_drvdata(pdev, core);
1223 return 0;
1225 err_sram:
1226 for (i = 0; i < core->num_mems; i++) {
1227 devm_release_mem_region(dev, core->mem[i].bus_addr,
1228 core->mem[i].size);
1229 devm_iounmap(dev, core->mem[i].cpu_addr);
1230 }
1231 devm_kfree(dev, core->mem);
1232 err_intmem:
1233 ret1 = ti_sci_proc_release(core->tsp);
1234 if (ret1)
1235 dev_err(dev, "failed to release proc, ret1 = %d\n", ret1);
1236 err_proc:
1237 kfree(core->tsp);
1238 err_sci_proc:
1239 reset_control_put(core->reset);
1240 err_sci_id:
1241 ret1 = ti_sci_put_handle(core->ti_sci);
1242 if (ret1)
1243 dev_err(dev, "failed to put ti_sci handle, ret = %d\n", ret1);
1244 err_of:
1245 devm_kfree(dev, core);
1246 return ret;
1247 }
1249 /*
1250 * free the resources explicitly since driver model is not being used
1251 * for the child R5F devices
1252 */
1253 static int k3_r5_core_of_exit(struct platform_device *pdev)
1254 {
1255 struct k3_r5_core *core = platform_get_drvdata(pdev);
1256 struct device *dev = &pdev->dev;
1257 int i, ret;
1259 for (i = 0; i < core->num_sram; i++)
1260 iounmap(core->sram[i].cpu_addr);
1261 kfree(core->sram);
1263 for (i = 0; i < core->num_mems; i++) {
1264 devm_release_mem_region(dev, core->mem[i].bus_addr,
1265 core->mem[i].size);
1266 devm_iounmap(dev, core->mem[i].cpu_addr);
1267 }
1268 if (core->mem)
1269 devm_kfree(dev, core->mem);
1271 ret = ti_sci_proc_release(core->tsp);
1272 if (ret)
1273 dev_err(dev, "failed to release proc, ret = %d\n", ret);
1275 kfree(core->tsp);
1276 reset_control_put(core->reset);
1278 ret = ti_sci_put_handle(core->ti_sci);
1279 if (ret)
1280 dev_err(dev, "failed to put ti_sci handle, ret = %d\n", ret);
1282 platform_set_drvdata(pdev, NULL);
1283 devm_kfree(dev, core);
1285 return ret;
1286 }
1288 static int k3_r5_cluster_of_init(struct platform_device *pdev)
1289 {
1290 struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
1291 struct device *dev = &pdev->dev;
1292 struct device_node *np = dev->of_node;
1293 struct platform_device *cpdev;
1294 struct device_node *child;
1295 struct k3_r5_core *core, *temp;
1296 int ret;
1298 for_each_available_child_of_node(np, child) {
1299 cpdev = of_find_device_by_node(child);
1300 if (!cpdev) {
1301 ret = -ENODEV;
1302 dev_err(dev, "could not get R5 core platform device\n");
1303 goto fail;
1304 }
1306 ret = k3_r5_core_of_init(cpdev);
1307 if (ret) {
1308 dev_err(dev, "k3_r5_core_of_init failed, ret = %d\n",
1309 ret);
1310 put_device(&cpdev->dev);
1311 goto fail;
1312 }
1314 core = platform_get_drvdata(cpdev);
1315 put_device(&cpdev->dev);
1316 list_add_tail(&core->elem, &cluster->cores);
1317 }
1319 return 0;
1321 fail:
1322 list_for_each_entry_safe_reverse(core, temp, &cluster->cores, elem) {
1323 list_del(&core->elem);
1324 cpdev = to_platform_device(core->dev);
1325 if (k3_r5_core_of_exit(cpdev))
1326 dev_err(dev, "k3_r5_core_of_exit cleanup failed\n");
1327 }
1328 return ret;
1329 }
1331 static int k3_r5_cluster_of_exit(struct platform_device *pdev)
1332 {
1333 struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
1334 struct device *dev = &pdev->dev;
1335 struct platform_device *cpdev;
1336 struct k3_r5_core *core, *temp;
1337 int ret;
1339 list_for_each_entry_safe_reverse(core, temp, &cluster->cores, elem) {
1340 list_del(&core->elem);
1341 cpdev = to_platform_device(core->dev);
1342 ret = k3_r5_core_of_exit(cpdev);
1343 if (ret) {
1344 dev_err(dev, "k3_r5_core_of_exit failed, ret = %d\n",
1345 ret);
1346 break;
1347 }
1348 }
1350 return ret;
1351 }
1353 static int k3_r5_probe(struct platform_device *pdev)
1354 {
1355 struct device *dev = &pdev->dev;
1356 struct device_node *np = dev->of_node;
1357 struct k3_r5_cluster *cluster;
1358 int ret, ret1;
1359 int num_cores;
1361 cluster = devm_kzalloc(dev, sizeof(*cluster), GFP_KERNEL);
1362 if (!cluster)
1363 return -ENOMEM;
1365 cluster->dev = dev;
1366 cluster->mode = CLUSTER_MODE_LOCKSTEP;
1367 INIT_LIST_HEAD(&cluster->cores);
1369 ret = of_property_read_u32(np, "lockstep-mode", &cluster->mode);
1370 if (ret < 0 && ret != -EINVAL) {
1371 dev_err(dev, "invalid format for lockstep-mode, ret = %d\n",
1372 ret);
1373 return ret;
1374 }
1376 num_cores = of_get_available_child_count(np);
1377 if (num_cores != 2) {
1378 dev_err(dev, "MCU cluster requires both R5F cores to be enabled, num_cores = %d\n",
1379 num_cores);
1380 return -ENODEV;
1381 }
1383 platform_set_drvdata(pdev, cluster);
1385 dev_info(dev, "creating child devices for R5F cores\n");
1386 ret = of_platform_populate(np, NULL, NULL, dev);
1387 if (ret) {
1388 dev_err(dev, "of_platform_populate failed, ret = %d\n", ret);
1389 return ret;
1390 }
1392 ret = k3_r5_cluster_of_init(pdev);
1393 if (ret) {
1394 dev_err(dev, "k3_r5_cluster_of_init failed, ret = %d\n", ret);
1395 goto fail_of;
1396 }
1398 ret = k3_r5_cluster_rproc_init(pdev);
1399 if (ret) {
1400 dev_err(dev, "k3_r5_cluster_rproc_init failed, ret = %d\n",
1401 ret);
1402 goto fail_rproc;
1403 }
1405 return 0;
1407 fail_rproc:
1408 ret1 = k3_r5_cluster_of_exit(pdev);
1409 if (ret1)
1410 dev_err(dev, "k3_r5_cluster_of_exit failed, ret = %d\n", ret1);
1411 fail_of:
1412 of_platform_depopulate(dev);
1413 return ret;
1414 }
1416 static int k3_r5_remove(struct platform_device *pdev)
1417 {
1418 struct device *dev = &pdev->dev;
1419 int ret;
1421 ret = k3_r5_cluster_rproc_exit(pdev);
1422 if (ret) {
1423 dev_err(dev, "k3_r5_cluster_rproc_exit failed, ret = %d\n",
1424 ret);
1425 goto fail;
1426 }
1428 ret = k3_r5_cluster_of_exit(pdev);
1429 if (ret) {
1430 dev_err(dev, "k3_r5_cluster_of_exit failed, ret = %d\n", ret);
1431 goto fail;
1432 }
1434 dev_info(dev, "removing child devices for R5F cores\n");
1435 of_platform_depopulate(dev);
1437 fail:
1438 return ret;
1439 }
1441 static const struct k3_r5_rproc_dev_data am65x_r5f_dev_data[] = {
1442 {
1443 .device_name = "41000000.r5f",
1444 .fw_name = "am65x-mcu-r5f0_0-fw",
1445 },
1446 {
1447 .device_name = "41400000.r5f",
1448 .fw_name = "am65x-mcu-r5f0_1-fw",
1449 },
1450 {
1451 /* sentinel */
1452 },
1453 };
1455 static const struct of_device_id k3_r5_of_match[] = {
1456 {
1457 .compatible = "ti,am654-r5fss",
1458 .data = am65x_r5f_dev_data,
1459 },
1460 { /* sentinel */ },
1461 };
1462 MODULE_DEVICE_TABLE(of, k3_r5_of_match);
1464 static struct platform_driver k3_r5_rproc_driver = {
1465 .probe = k3_r5_probe,
1466 .remove = k3_r5_remove,
1467 .driver = {
1468 .name = "k3_r5_rproc",
1469 .of_match_table = k3_r5_of_match,
1470 },
1471 };
1473 module_platform_driver(k3_r5_rproc_driver);
1475 MODULE_LICENSE("GPL v2");
1476 MODULE_DESCRIPTION("TI K3 R5F remote processor driver");
1477 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");