remoteproc/k3-r5: add a remoteproc driver for R5F subsystem
[rpmsg/rpmsg.git] / drivers / remoteproc / ti_k3_r5_remoteproc.c
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  * @num_mems: number of internal memory regions
88  * @reset: reset control handle
89  * @tsp: TI-SCI processor control handle
90  * @ti_sci: TI-SCI handle
91  * @ti_sci_id: TI-SCI device identifier
92  * @atcm_enable: flag to control ATCM enablement
93  * @btcm_enable: flag to control BTCM enablement
94  * @loczrama: flag to dictate which TCM is at device address 0x0
95  */
96 struct k3_r5_core {
97         struct list_head elem;
98         struct device *dev;
99         struct rproc *rproc;
100         struct k3_r5_mem *mem;
101         int num_mems;
102         struct reset_control *reset;
103         struct ti_sci_proc *tsp;
104         const struct ti_sci_handle *ti_sci;
105         u32 ti_sci_id;
106         u32 atcm_enable;
107         u32 btcm_enable;
108         u32 loczrama;
109 };
111 /**
112  * struct k3_r5_rproc - K3 remote processor state
113  * @dev: cached device pointer
114  * @cluster: cached pointer to parent cluster structure
115  * @mbox: mailbox channel handle
116  * @client: mailbox client to request the mailbox channel
117  * @rproc: rproc handle
118  * @core: cached pointer to r5 core structure being used
119  * @rmem: reserved memory regions data
120  * @num_rmems: number of reserved memory regions
121  */
122 struct k3_r5_rproc {
123         struct device *dev;
124         struct k3_r5_cluster *cluster;
125         struct mbox_chan *mbox;
126         struct mbox_client client;
127         struct rproc *rproc;
128         struct k3_r5_core *core;
129         struct k3_r5_mem *rmem;
130         int num_rmems;
131 };
133 /**
134  * struct k3_r5_rproc_dev_data - device data for the remote processor
135  * @device_name: device name of the remote processor
136  * @fw_name: firmware name to use
137  */
138 struct k3_r5_rproc_dev_data {
139         const char *device_name;
140         const char *fw_name;
141 };
143 /**
144  * k3_r5_rproc_mbox_callback() - inbound mailbox message handler
145  * @client: mailbox client pointer used for requesting the mailbox channel
146  * @data: mailbox payload
147  *
148  * This handler is invoked by the OMAP mailbox driver whenever a mailbox
149  * message is received. Usually, the mailbox payload simply contains
150  * the index of the virtqueue that is kicked by the remote processor,
151  * and we let remoteproc core handle it.
152  *
153  * In addition to virtqueue indices, we also have some out-of-band values
154  * that indicate different events. Those values are deliberately very
155  * large so they don't coincide with virtqueue indices.
156  */
157 static void k3_r5_rproc_mbox_callback(struct mbox_client *client, void *data)
159         struct k3_r5_rproc *kproc = container_of(client, struct k3_r5_rproc,
160                                                 client);
161         struct device *dev = kproc->rproc->dev.parent;
162         const char *name = kproc->rproc->name;
163         u32 msg = to_omap_mbox_msg(data);
165         dev_dbg(dev, "mbox msg: 0x%x\n", msg);
167         switch (msg) {
168         case RP_MBOX_CRASH:
169                 /*
170                  * remoteproc detected an exception, but error recovery is not
171                  * supported. So, just log this for now
172                  */
173                 dev_err(dev, "K3 R5F rproc %s crashed\n", name);
174                 break;
175         case RP_MBOX_ECHO_REPLY:
176                 dev_info(dev, "received echo reply from %s\n", name);
177                 break;
178         default:
179                 /* silently handle all other valid messages */
180                 if (msg >= RP_MBOX_READY && msg < RP_MBOX_END_MSG)
181                         return;
182                 if (msg > kproc->rproc->max_notifyid) {
183                         dev_dbg(dev, "dropping unknown message 0x%x", msg);
184                         return;
185                 }
186                 /* msg contains the index of the triggered vring */
187                 if (rproc_vq_interrupt(kproc->rproc, msg) == IRQ_NONE)
188                         dev_dbg(dev, "no message was found in vqid %d\n", msg);
189         }
192 /* kick a virtqueue */
193 static void k3_r5_rproc_kick(struct rproc *rproc, int vqid)
195         struct k3_r5_rproc *kproc = rproc->priv;
196         struct device *dev = rproc->dev.parent;
197         mbox_msg_t msg = (mbox_msg_t)vqid;
198         int ret;
200         /* send the index of the triggered virtqueue in the mailbox payload */
201         ret = mbox_send_message(kproc->mbox, (void *)msg);
202         if (ret < 0)
203                 dev_err(dev, "failed to send mailbox message, status = %d\n",
204                         ret);
207 static int k3_r5_split_reset(struct k3_r5_core *core)
209         int ret;
211         ret = reset_control_assert(core->reset);
212         if (ret) {
213                 dev_err(core->dev, "local-reset assert failed, ret = %d\n",
214                         ret);
215                 return ret;
216         }
218         ret = core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
219                                                    core->ti_sci_id);
220         if (ret) {
221                 dev_err(core->dev, "module-reset assert failed, ret = %d\n",
222                         ret);
223                 if (reset_control_deassert(core->reset))
224                         dev_warn(core->dev, "local-reset deassert back failed\n");
225         }
227         return ret;
230 static int k3_r5_split_release(struct k3_r5_core *core)
232         int ret;
234         ret = core->ti_sci->ops.dev_ops.get_device(core->ti_sci,
235                                                    core->ti_sci_id);
236         if (ret) {
237                 dev_err(core->dev, "module-reset deassert failed, ret = %d\n",
238                         ret);
239                 return ret;
240         }
242         ret = reset_control_deassert(core->reset);
243         if (ret) {
244                 dev_err(core->dev, "local-reset deassert failed, ret = %d\n",
245                         ret);
246                 if (core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
247                                                          core->ti_sci_id))
248                         dev_warn(core->dev, "module-reset assert back failed\n");
249         }
251         return ret;
254 static int k3_r5_lockstep_reset(struct k3_r5_cluster *cluster)
256         struct k3_r5_core *core;
257         int ret;
259         /* assert local reset on all applicable cores */
260         list_for_each_entry(core, &cluster->cores, elem) {
261                 ret = reset_control_assert(core->reset);
262                 if (ret) {
263                         dev_err(core->dev, "local-reset assert failed, ret = %d\n",
264                                 ret);
265                         core = list_prev_entry(core, elem);
266                         goto unroll_local_reset;
267                 }
268         }
270         /* disable PSC modules on all applicable cores */
271         list_for_each_entry(core, &cluster->cores, elem) {
272                 ret = core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
273                                                            core->ti_sci_id);
274                 if (ret) {
275                         dev_err(core->dev, "module-reset assert failed, ret = %d\n",
276                                 ret);
277                         goto unroll_module_reset;
278                 }
279         }
281         return 0;
283 unroll_module_reset:
284         list_for_each_entry_continue_reverse(core, &cluster->cores, elem) {
285                 if (core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
286                                                          core->ti_sci_id))
287                         dev_warn(core->dev, "module-reset assert back failed\n");
288         }
289         core = list_last_entry(&cluster->cores, struct k3_r5_core, elem);
290 unroll_local_reset:
291         list_for_each_entry_from_reverse(core, &cluster->cores, elem) {
292                 if (reset_control_deassert(core->reset))
293                         dev_warn(core->dev, "local-reset deassert back failed\n");
294         }
296         return ret;
299 static int k3_r5_lockstep_release(struct k3_r5_cluster *cluster)
301         struct k3_r5_core *core;
302         int ret;
304         /* enable PSC modules on all applicable cores */
305         list_for_each_entry_reverse(core, &cluster->cores, elem) {
306                 ret = core->ti_sci->ops.dev_ops.get_device(core->ti_sci,
307                                                            core->ti_sci_id);
308                 if (ret) {
309                         dev_err(core->dev, "module-reset deassert failed, ret = %d\n",
310                                 ret);
311                         core = list_next_entry(core, elem);
312                         goto unroll_module_reset;
313                 }
314         }
316         /* deassert local reset on all applicable cores */
317         list_for_each_entry_reverse(core, &cluster->cores, elem) {
318                 ret = reset_control_deassert(core->reset);
319                 if (ret) {
320                         dev_err(core->dev, "module-reset deassert failed, ret = %d\n",
321                                 ret);
322                         goto unroll_local_reset;
323                 }
324         }
326         return 0;
328 unroll_local_reset:
329         list_for_each_entry_continue(core, &cluster->cores, elem) {
330                 if (reset_control_assert(core->reset))
331                         dev_warn(core->dev, "local-reset assert back failed\n");
332         }
333         core = list_first_entry(&cluster->cores, struct k3_r5_core, elem);
334 unroll_module_reset:
335         list_for_each_entry_from(core, &cluster->cores, elem) {
336                 if (core->ti_sci->ops.dev_ops.put_device(core->ti_sci,
337                                                          core->ti_sci_id))
338                         dev_warn(core->dev, "module-reset assert back failed\n");
339         }
341         return ret;
344 static inline int k3_r5_core_halt(struct k3_r5_core *core)
346         return ti_sci_proc_set_control(core->tsp,
347                                        PROC_BOOT_CTRL_FLAG_R5_CORE_HALT, 0);
350 static inline int k3_r5_core_run(struct k3_r5_core *core)
352         return ti_sci_proc_set_control(core->tsp,
353                                        0, PROC_BOOT_CTRL_FLAG_R5_CORE_HALT);
356 /*
357  * The R5F cores have controls for both a reset and a halt/run. The code
358  * execution from DDR requires the initial boot-strapping code to be run
359  * from the internal TCMs. This function is used to release the resets on
360  * applicable cores to allow loading into the TCMs. The .prepare() ops is
361  * invoked by remoteproc core before any firmware loading, and is followed
362  * by the .start() ops after loading to actually let the R5 cores run.
363  */
364 static int k3_r5_rproc_prepare(struct rproc *rproc)
366         struct k3_r5_rproc *kproc = rproc->priv;
367         struct k3_r5_cluster *cluster = kproc->cluster;
368         struct k3_r5_core *core = kproc->core;
369         struct device *dev = kproc->dev;
370         int ret;
372         ret = cluster->mode ? k3_r5_lockstep_release(cluster) :
373                               k3_r5_split_release(core);
374         if (ret)
375                 dev_err(dev, "unable to enable cores for TCM loading, ret = %d\n",
376                         ret);
378         return ret;
381 /*
382  * This function implements the .unprepare() ops and performs the complimentary
383  * operations to that of the .prepare() ops. The function is used to assert the
384  * resets on all applicable cores for the rproc device (depending on LockStep
385  * or Split mode). This completes the second portion of powering down the R5F
386  * cores. The cores themselves are only halted in the .stop() ops, and the
387  * .unprepare() ops is invoked by the remoteproc core after the remoteproc is
388  * stopped.
389  */
390 static int k3_r5_rproc_unprepare(struct rproc *rproc)
392         struct k3_r5_rproc *kproc = rproc->priv;
393         struct k3_r5_cluster *cluster = kproc->cluster;
394         struct k3_r5_core *core = kproc->core;
395         struct device *dev = kproc->dev;
396         int ret;
398         ret = cluster->mode ? k3_r5_lockstep_reset(cluster) :
399                               k3_r5_split_reset(core);
400         if (ret)
401                 dev_err(dev, "unable to disable cores, ret = %d\n", ret);
403         return ret;
406 /*
407  * The R5F start sequence includes two different operations
408  * 1. Configure the boot vector for R5F core(s)
409  * 2. Unhalt/Run the R5F core(s)
410  *
411  * The sequence is different between LockStep and Split modes. The LockStep
412  * mode requires the boot vector to be configured only for Core0, and then
413  * unhalt both the cores to start the execution - Core1 needs to be unhalted
414  * first followed by Core0. The Split-mode requires that Core0 to be maintained
415  * always in a higher power state that Core1 (implying Core1 needs to be started
416  * always only after Core0 is started).
417  */
418 static int k3_r5_rproc_start(struct rproc *rproc)
420         struct k3_r5_rproc *kproc = rproc->priv;
421         struct k3_r5_cluster *cluster = kproc->cluster;
422         struct mbox_client *client = &kproc->client;
423         struct device *dev = kproc->dev;
424         struct k3_r5_core *core;
425         u32 boot_addr;
426         int ret;
428         client->dev = dev;
429         client->tx_done = NULL;
430         client->rx_callback = k3_r5_rproc_mbox_callback;
431         client->tx_block = false;
432         client->knows_txdone = false;
434         kproc->mbox = mbox_request_channel(client, 0);
435         if (IS_ERR(kproc->mbox)) {
436                 ret = -EBUSY;
437                 dev_err(dev, "mbox_request_channel failed: %ld\n",
438                         PTR_ERR(kproc->mbox));
439                 return ret;
440         }
442         /*
443          * Ping the remote processor, this is only for sanity-sake for now;
444          * there is no functional effect whatsoever.
445          *
446          * Note that the reply will _not_ arrive immediately: this message
447          * will wait in the mailbox fifo until the remote processor is booted.
448          */
449         ret = mbox_send_message(kproc->mbox, (void *)RP_MBOX_ECHO_REQUEST);
450         if (ret < 0) {
451                 dev_err(dev, "mbox_send_message failed: %d\n", ret);
452                 goto put_mbox;
453         }
455         boot_addr = rproc->bootaddr;
456         /* TODO: add boot_addr sanity checking */
457         dev_err(dev, "booting R5F core using boot addr = 0x%x\n", boot_addr);
459         /* boot vector need not be programmed for Core1 in LockStep mode */
460         core = kproc->core;
461         ret = ti_sci_proc_set_config(core->tsp, boot_addr, 0, 0);
462         if (ret)
463                 goto put_mbox;
465         /* unhalt/run all applicable cores */
466         if (cluster->mode) {
467                 list_for_each_entry_reverse(core, &cluster->cores, elem) {
468                         ret = k3_r5_core_run(core);
469                         if (ret)
470                                 goto unroll_core_run;
471                 }
472         } else {
473                 ret = k3_r5_core_run(core);
474                 if (ret)
475                         goto put_mbox;
476         }
478         return 0;
480 unroll_core_run:
481         list_for_each_entry_continue(core, &cluster->cores, elem) {
482                 if (k3_r5_core_halt(core))
483                         dev_warn(core->dev, "core halt back failed\n");
484         }
485 put_mbox:
486         mbox_free_channel(kproc->mbox);
487         return ret;
490 /*
491  * The R5F stop function includes the following operations
492  * 1. Halt R5F core(s)
493  *
494  * The sequence is different between LockStep and Split modes, and the order
495  * of cores the operations are performed are also in general reverse to that
496  * of the start function. The LockStep mode requires each operation to be
497  * performed first on Core0 followed by Core1. The Split-mode requires that
498  * Core0 to be maintained always in a higher power state that Core1 (implying
499  * Core1 needs to be stopped first before Core0).
500  *
501  * Note that the R5F halt operation in general is not effective when the R5F
502  * core is running, but is needed to make sure the core won't run after
503  * deasserting the reset the subsequent time. The asserting of reset can
504  * be done here, but is preferred to be done in the .unprepare() ops - this
505  * maintains the symmetric behavior between the .start(), .stop(), .prepare()
506  * and .unprepare() ops, and also balances them well between sysfs 'state'
507  * flow and device bind/unbind or module removal.
508  */
509 static int k3_r5_rproc_stop(struct rproc *rproc)
511         struct k3_r5_rproc *kproc = rproc->priv;
512         struct k3_r5_cluster *cluster = kproc->cluster;
513         struct k3_r5_core *core = kproc->core;
514         int ret;
516         /* halt all applicable cores */
517         if (cluster->mode) {
518                 list_for_each_entry(core, &cluster->cores, elem) {
519                         ret = k3_r5_core_halt(core);
520                         if (ret) {
521                                 core = list_prev_entry(core, elem);
522                                 goto unroll_core_halt;
523                         }
524                 }
525         } else {
526                 ret = k3_r5_core_halt(core);
527                 if (ret)
528                         goto out;
529         }
531         mbox_free_channel(kproc->mbox);
533         return 0;
535 unroll_core_halt:
536         list_for_each_entry_from_reverse(core, &cluster->cores, elem) {
537                 if (k3_r5_core_run(core))
538                         dev_warn(core->dev, "core run back failed\n");
539         }
540 out:
541         return ret;
544 /*
545  * Internal Memory translation helper
546  *
547  * Custom function implementing the rproc .da_to_va ops to provide address
548  * translation (device address to kernel virtual address) for internal RAMs
549  * present in a DSP or IPU device). The translated addresses can be used
550  * either by the remoteproc core for loading, or by any rpmsg bus drivers.
551  */
552 static void *k3_r5_rproc_da_to_va(struct rproc *rproc, u64 da, int len,
553                                   u32 flags)
555         struct k3_r5_rproc *kproc = rproc->priv;
556         struct k3_r5_core *core = kproc->core;
557         void __iomem *va = NULL;
558         phys_addr_t bus_addr;
559         u32 dev_addr, offset;
560         size_t size;
561         int i;
563         if (len <= 0)
564                 return NULL;
566         /* handle R5-view of ATCM addresses first using address 0 */
567         size = core->mem[0].size;
568         if (da >= 0 && ((da + len) <= size)) {
569                 offset = da;
570                 va = core->mem[0].cpu_addr + offset;
571                 return (__force void *)va;
572         }
574         /* handle SoC-view addresses for ATCM and BTCM */
575         for (i = 0; i < core->num_mems; i++) {
576                 bus_addr = core->mem[i].bus_addr;
577                 dev_addr = core->mem[i].dev_addr;
578                 size = core->mem[i].size;
580                 if (da >= bus_addr &&
581                     ((da + len) <= (bus_addr + size))) {
582                         offset = da - bus_addr;
583                         va = core->mem[i].cpu_addr + offset;
584                         return (__force void *)va;
585                 }
586         }
588         /* handle static DDR reserved memory regions */
589         for (i = 0; i < kproc->num_rmems; i++) {
590                 dev_addr = kproc->rmem[i].dev_addr;
591                 size = kproc->rmem[i].size;
593                 if (da >= dev_addr && ((da + len) <= (dev_addr + size))) {
594                         offset = da - dev_addr;
595                         va = kproc->rmem[i].cpu_addr + offset;
596                         return (__force void *)va;
597                 }
598         }
600         return NULL;
603 static const struct rproc_ops k3_r5_rproc_ops = {
604         .prepare        = k3_r5_rproc_prepare,
605         .unprepare      = k3_r5_rproc_unprepare,
606         .start          = k3_r5_rproc_start,
607         .stop           = k3_r5_rproc_stop,
608         .kick           = k3_r5_rproc_kick,
609         .da_to_va       = k3_r5_rproc_da_to_va,
610 };
612 static const char *k3_r5_rproc_get_firmware(struct device *dev)
614         const struct k3_r5_rproc_dev_data *data =
615                                 of_device_get_match_data(dev->parent);
617         if (!data) {
618                 dev_err(dev, "data is NULL, %s\n", dev_name(dev));
619                 return ERR_PTR(-ENODEV);
620         }
622         for (; data && data->device_name; data++) {
623                 if (!strcmp(dev_name(dev), data->device_name))
624                         return data->fw_name;
625         }
627         return ERR_PTR(-ENODEV);
630 static int k3_r5_rproc_configure(struct k3_r5_rproc *kproc)
632         struct k3_r5_cluster *cluster = kproc->cluster;
633         struct device *dev = kproc->dev;
634         struct k3_r5_core *core0, *core, *temp;
635         u32 ctrl = 0, cfg = 0, stat = 0;
636         u32 set_cfg = 0, clr_cfg = 0;
637         u64 boot_vec = 0;
638         int ret;
640         core0 = list_first_entry(&cluster->cores, struct k3_r5_core, elem);
641         core = cluster->mode ? core0 : kproc->core;
643         ret = ti_sci_proc_get_status(core->tsp, &boot_vec, &cfg, &ctrl,
644                                      &stat);
645         if (ret < 0)
646                 return ret;
648         dev_dbg(dev, "boot_vector = 0x%llx, cfg = 0x%x ctrl = 0x%x stat = 0x%x\n",
649                 boot_vec, cfg, ctrl, stat);
651         if (!(stat & PROC_BOOT_STATUS_FLAG_R5_LOCKSTEP_PERMITTED) &&
652             cluster->mode) {
653                 dev_err(cluster->dev, "lockstep mode not permitted, force configuring for split-mode\n");
654                 cluster->mode = 0;
655         }
657         /* always enable ARM mode and set boot vector to 0 */
658         boot_vec = 0x0;
659         if (core == core0) {
660                 clr_cfg = PROC_BOOT_CFG_FLAG_R5_TEINIT;
661                 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_LOCKSTEP;
662         }
664         if (core->atcm_enable)
665                 set_cfg |= PROC_BOOT_CFG_FLAG_R5_ATCM_EN;
666         else
667                 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_ATCM_EN;
669         if (core->btcm_enable)
670                 set_cfg |= PROC_BOOT_CFG_FLAG_R5_BTCM_EN;
671         else
672                 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_BTCM_EN;
674         if (core->loczrama)
675                 set_cfg |= PROC_BOOT_CFG_FLAG_R5_TCM_RSTBASE;
676         else
677                 clr_cfg |= PROC_BOOT_CFG_FLAG_R5_TCM_RSTBASE;
679         if (cluster->mode) {
680                 /*
681                  * work around system firmware limitations to make sure both
682                  * cores are programmed symmetrically in LockStep. LockStep
683                  * and TEINIT config is only allowed with Core0.
684                  */
685                 list_for_each_entry(temp, &cluster->cores, elem) {
686                         ret = k3_r5_core_halt(core);
687                         if (ret)
688                                 goto out;
690                         if (temp != core) {
691                                 clr_cfg &= ~PROC_BOOT_CFG_FLAG_R5_LOCKSTEP;
692                                 clr_cfg &= ~PROC_BOOT_CFG_FLAG_R5_TEINIT;
693                         }
694                         ret = ti_sci_proc_set_config(temp->tsp, boot_vec,
695                                                      set_cfg, clr_cfg);
696                         if (ret)
697                                 goto out;
698                 }
700                 set_cfg = PROC_BOOT_CFG_FLAG_R5_LOCKSTEP;
701                 clr_cfg = 0;
702                 ret = ti_sci_proc_set_config(core->tsp, boot_vec,
703                                              set_cfg, clr_cfg);
704         } else {
705                 ret = k3_r5_core_halt(core);
706                 if (ret)
707                         goto out;
709                 ret = ti_sci_proc_set_config(core->tsp, boot_vec,
710                                              set_cfg, clr_cfg);
711         }
713 out:
714         return ret;
717 static int k3_r5_reserved_mem_init(struct k3_r5_rproc *kproc)
719         struct device *dev = kproc->dev;
720         struct device_node *np = dev->of_node;
721         struct device_node *rmem_np;
722         struct reserved_mem *rmem;
723         int num_rmems;
724         int ret, i;
726         num_rmems = of_property_count_elems_of_size(np, "memory-region",
727                                                     sizeof(phandle));
728         if (num_rmems <= 0) {
729                 dev_err(dev, "device does not have reserved memory regions, ret = %d\n",
730                         num_rmems);
731                 return -EINVAL;
732         }
733         if (num_rmems < 2) {
734                 dev_err(dev, "device needs atleast two memory regions to be defined, num = %d\n",
735                         num_rmems);
736                 return -EINVAL;
737         }
739         /* use reserved memory region 0 for vring DMA allocations */
740         ret = of_reserved_mem_device_init_by_idx(dev, np, 0);
741         if (ret) {
742                 dev_err(dev, "device cannot initialize DMA pool, ret = %d\n",
743                         ret);
744                 return ret;
745         }
747         num_rmems--;
748         kproc->rmem = kcalloc(num_rmems, sizeof(*kproc->rmem), GFP_KERNEL);
749         if (!kproc->rmem) {
750                 ret = -ENOMEM;
751                 goto release_rmem;
752         }
754         /* use remaining reserved memory regions for static carveouts */
755         for (i = 0; i < num_rmems; i++) {
756                 rmem_np = of_parse_phandle(np, "memory-region", i + 1);
757                 if (!rmem_np) {
758                         ret = -EINVAL;
759                         goto unmap_rmem;
760                 }
762                 rmem = of_reserved_mem_lookup(rmem_np);
763                 if (!rmem) {
764                         of_node_put(rmem_np);
765                         ret = -EINVAL;
766                         goto unmap_rmem;
767                 }
768                 of_node_put(rmem_np);
770                 kproc->rmem[i].bus_addr = rmem->base;
771                 /* 64-bit address regions currently not supported */
772                 kproc->rmem[i].dev_addr = (u32)rmem->base;
773                 kproc->rmem[i].size = rmem->size;
774                 kproc->rmem[i].cpu_addr = ioremap_wc(rmem->base, rmem->size);
775                 if (!kproc->rmem[i].cpu_addr) {
776                         dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n",
777                                 i + 1, &rmem->base, &rmem->size);
778                         ret = -ENOMEM;
779                         goto unmap_rmem;
780                 }
782                 dev_dbg(dev, "reserved memory%d: bus addr %pa size 0x%zx va %pK da 0x%x\n",
783                         i + 1, &kproc->rmem[i].bus_addr,
784                         kproc->rmem[i].size, kproc->rmem[i].cpu_addr,
785                         kproc->rmem[i].dev_addr);
786         }
787         kproc->num_rmems = num_rmems;
789         return 0;
791 unmap_rmem:
792         for (i--; i >= 0; i--) {
793                 if (kproc->rmem[i].cpu_addr)
794                         iounmap(kproc->rmem[i].cpu_addr);
795         }
796         kfree(kproc->rmem);
797 release_rmem:
798         of_reserved_mem_device_release(dev);
799         return ret;
802 static void k3_r5_reserved_mem_exit(struct k3_r5_rproc *kproc)
804         int i;
806         for (i = 0; i < kproc->num_rmems; i++)
807                 iounmap(kproc->rmem[i].cpu_addr);
808         kfree(kproc->rmem);
810         of_reserved_mem_device_release(kproc->dev);
813 static int k3_r5_cluster_rproc_init(struct platform_device *pdev)
815         struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
816         struct device *dev = &pdev->dev;
817         struct k3_r5_rproc *kproc;
818         struct k3_r5_core *core, *core1;
819         struct device *cdev;
820         const char *fw_name;
821         struct rproc *rproc;
822         int ret;
824         core1 = list_last_entry(&cluster->cores, struct k3_r5_core, elem);
825         list_for_each_entry(core, &cluster->cores, elem) {
826                 cdev = core->dev;
827                 fw_name = k3_r5_rproc_get_firmware(cdev);
828                 if (IS_ERR(fw_name)) {
829                         ret = PTR_ERR(fw_name);
830                         goto out;
831                 }
833                 rproc = rproc_alloc(cdev, dev_name(cdev), &k3_r5_rproc_ops,
834                                     fw_name, sizeof(*kproc));
835                 if (!rproc) {
836                         ret = -ENOMEM;
837                         goto out;
838                 }
840                 /* K3 R5s have a Region Address Translator (RAT) but no MMU */
841                 rproc->has_iommu = false;
842                 /* error recovery is not supported at present */
843                 rproc->recovery_disabled = true;
845                 kproc = rproc->priv;
846                 kproc->cluster = cluster;
847                 kproc->core = core;
848                 kproc->dev = cdev;
849                 kproc->rproc = rproc;
850                 core->rproc = rproc;
852                 ret = k3_r5_rproc_configure(kproc);
853                 if (ret) {
854                         dev_err(dev, "initial configure failed, ret = %d\n",
855                                 ret);
856                         goto err_config;
857                 }
859                 ret = k3_r5_reserved_mem_init(kproc);
860                 if (ret) {
861                         dev_err(dev, "reserved memory init failed, ret = %d\n",
862                                 ret);
863                         goto err_config;
864                 }
866                 ret = rproc_add(rproc);
867                 if (ret) {
868                         dev_err(dev, "rproc_add failed, ret = %d\n", ret);
869                         goto err_add;
870                 }
872                 /* create only one rproc in lockstep mode */
873                 if (cluster->mode)
874                         break;
875         }
877         return 0;
879 err_split:
880         rproc_del(rproc);
881 err_add:
882         k3_r5_reserved_mem_exit(kproc);
883 err_config:
884         rproc_free(rproc);
885         core->rproc = NULL;
886 out:
887         /* undo core0 upon any failures on core1 in split-mode */
888         if (!cluster->mode && core == core1) {
889                 core = list_prev_entry(core, elem);
890                 rproc = core->rproc;
891                 kproc = rproc->priv;
892                 goto err_split;
893         }
894         return ret;
897 static int k3_r5_cluster_rproc_exit(struct platform_device *pdev)
899         struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
900         struct k3_r5_rproc *kproc;
901         struct k3_r5_core *core;
902         struct rproc *rproc;
904         /*
905          * lockstep mode has only one rproc associated with first core, whereas
906          * split-mode has two rprocs associated with each core, and requires
907          * that core1 be powered down first
908          */
909         core = cluster->mode ?
910                 list_first_entry(&cluster->cores, struct k3_r5_core, elem) :
911                 list_last_entry(&cluster->cores, struct k3_r5_core, elem);
913         list_for_each_entry_from_reverse(core, &cluster->cores, elem) {
914                 rproc = core->rproc;
915                 kproc = rproc->priv;
917                 rproc_del(rproc);
919                 k3_r5_reserved_mem_exit(kproc);
921                 rproc_free(rproc);
922                 core->rproc = NULL;
923         }
925         return 0;
928 static int k3_r5_core_of_get_internal_memories(struct platform_device *pdev,
929                                                struct k3_r5_core *core)
931         static const char * const mem_names[] = {"atcm", "btcm"};
932         struct device *dev = &pdev->dev;
933         struct resource *res;
934         int num_mems;
935         int i, ret;
937         num_mems = ARRAY_SIZE(mem_names);
938         core->mem = devm_kcalloc(dev, num_mems, sizeof(*core->mem), GFP_KERNEL);
939         if (!core->mem)
940                 return -ENOMEM;
942         for (i = 0; i < num_mems; i++) {
943                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
944                                                    mem_names[i]);
945                 core->mem[i].cpu_addr = devm_ioremap_resource(dev, res);
946                 if (IS_ERR(core->mem[i].cpu_addr)) {
947                         dev_err(dev, "failed to parse and map %s memory\n",
948                                 mem_names[i]);
949                         ret = PTR_ERR(core->mem[i].cpu_addr);
950                         goto fail;
951                 }
952                 core->mem[i].bus_addr = res->start;
954                 /*
955                  * TODO:
956                  * The R5F cores can place ATCM & BTCM anywhere in its address
957                  * based on the corresponding Region Registers in the System
958                  * Control coprocessor. For now, place ATCM and BTCM at
959                  * addresses 0 and 0x41010000 (same as the bus address on AM65x
960                  * SoCs) based on loczrama setting
961                  */
962                 if (!strcmp(mem_names[i], "atcm")) {
963                         core->mem[i].dev_addr = core->loczrama ?
964                                                         0 : K3_R5_TCM_DEV_ADDR;
965                 } else {
966                         core->mem[i].dev_addr = core->loczrama ?
967                                                         K3_R5_TCM_DEV_ADDR : 0;
968                 }
969                 core->mem[i].size = resource_size(res);
971                 dev_dbg(dev, "memory %8s: bus addr %pa size 0x%zx va %p da 0x%x\n",
972                         mem_names[i], &core->mem[i].bus_addr,
973                         core->mem[i].size, core->mem[i].cpu_addr,
974                         core->mem[i].dev_addr);
975         }
976         core->num_mems = num_mems;
978         return 0;
980 fail:
981         for (i--; i >= 0; i--) {
982                 devm_release_mem_region(dev, core->mem[i].bus_addr,
983                                         core->mem[i].size);
984                 devm_iounmap(dev, core->mem[i].cpu_addr);
985         }
986         if (core->mem)
987                 devm_kfree(dev, core->mem);
988         return ret;
991 static
992 struct ti_sci_proc *k3_r5_core_of_get_tsp(struct device *dev,
993                                           const struct ti_sci_handle *sci)
995         struct ti_sci_proc *tsp;
996         u32 temp[2];
997         int ret;
999         ret = of_property_read_u32_array(dev->of_node, "ti,sci-proc-ids",
1000                                          temp, 2);
1001         if (ret < 0)
1002                 return ERR_PTR(ret);
1004         tsp = kzalloc(sizeof(*tsp), GFP_KERNEL);
1005         if (!tsp)
1006                 return ERR_PTR(-ENOMEM);
1008         tsp->dev = dev;
1009         tsp->sci = sci;
1010         tsp->ops = &sci->ops.proc_ops;
1011         tsp->proc_id = temp[0];
1012         tsp->host_id = temp[1];
1014         return tsp;
1017 static int k3_r5_core_of_init(struct platform_device *pdev)
1019         struct device *dev = &pdev->dev;
1020         struct device_node *np = dev->of_node;
1021         struct k3_r5_core *core;
1022         int ret, ret1;
1024         core = devm_kzalloc(dev, sizeof(*core), GFP_KERNEL);
1025         if (!core)
1026                 return -ENOMEM;
1028         core->dev = dev;
1029         core->atcm_enable = 0;
1030         core->btcm_enable = 1;
1031         core->loczrama = 1;
1033         ret = of_property_read_u32(np, "atcm-enable", &core->atcm_enable);
1034         if (ret < 0 && ret != -EINVAL) {
1035                 dev_err(dev, "invalid format for atcm-enable, ret = %d\n", ret);
1036                 goto err_of;
1037         }
1039         ret = of_property_read_u32(np, "btcm-enable", &core->btcm_enable);
1040         if (ret < 0 && ret != -EINVAL) {
1041                 dev_err(dev, "invalid format for btcm-enable, ret = %d\n", ret);
1042                 goto err_of;
1043         }
1045         ret = of_property_read_u32(np, "loczrama", &core->loczrama);
1046         if (ret < 0 && ret != -EINVAL) {
1047                 dev_err(dev, "invalid format for loczrama, ret = %d\n", ret);
1048                 goto err_of;
1049         }
1051         core->ti_sci = ti_sci_get_by_phandle(np, "ti,sci");
1052         if (IS_ERR(core->ti_sci)) {
1053                 ret = PTR_ERR(core->ti_sci);
1054                 if (ret != -EPROBE_DEFER) {
1055                         dev_err(dev, "failed to get ti-sci handle, ret = %d\n",
1056                                 ret);
1057                 }
1058                 core->ti_sci = NULL;
1059                 goto err_of;
1060         }
1062         ret = of_property_read_u32(np, "ti,sci-dev-id", &core->ti_sci_id);
1063         if (ret) {
1064                 dev_err(dev, "missing 'ti,sci-dev-id' property\n");
1065                 goto err_sci_id;
1066         }
1068         core->reset = reset_control_get_exclusive(dev, NULL);
1069         if (IS_ERR(core->reset)) {
1070                 ret = PTR_ERR(core->reset);
1071                 if (ret != -EPROBE_DEFER) {
1072                         dev_err(dev, "failed to get reset handle, ret = %d\n",
1073                                 ret);
1074                 }
1075                 goto err_sci_id;
1076         }
1078         core->tsp = k3_r5_core_of_get_tsp(dev, core->ti_sci);
1079         if (IS_ERR(core->tsp)) {
1080                 dev_err(dev, "failed to construct ti-sci proc control, ret = %d\n",
1081                         ret);
1082                 ret = PTR_ERR(core->tsp);
1083                 goto err_sci_proc;
1084         }
1086         ret = ti_sci_proc_request(core->tsp);
1087         if (ret < 0) {
1088                 dev_err(dev, "ti_sci_proc_request failed, ret = %d\n", ret);
1089                 goto err_proc;
1090         }
1092         ret = k3_r5_core_of_get_internal_memories(pdev, core);
1093         if (ret) {
1094                 dev_err(dev, "failed to get internal memories, ret = %d\n",
1095                         ret);
1096                 goto err_intmem;
1097         }
1099         platform_set_drvdata(pdev, core);
1101         return 0;
1103 err_intmem:
1104         ret1 = ti_sci_proc_release(core->tsp);
1105         if (ret1)
1106                 dev_err(dev, "failed to release proc, ret1 = %d\n", ret1);
1107 err_proc:
1108         kfree(core->tsp);
1109 err_sci_proc:
1110         reset_control_put(core->reset);
1111 err_sci_id:
1112         ret1 = ti_sci_put_handle(core->ti_sci);
1113         if (ret1)
1114                 dev_err(dev, "failed to put ti_sci handle, ret = %d\n", ret1);
1115 err_of:
1116         devm_kfree(dev, core);
1117         return ret;
1120 /*
1121  * free the resources explicitly since driver model is not being used
1122  * for the child R5F devices
1123  */
1124 static int k3_r5_core_of_exit(struct platform_device *pdev)
1126         struct k3_r5_core *core = platform_get_drvdata(pdev);
1127         struct device *dev = &pdev->dev;
1128         int i, ret;
1130         for (i = 0; i < core->num_mems; i++) {
1131                 devm_release_mem_region(dev, core->mem[i].bus_addr,
1132                                         core->mem[i].size);
1133                 devm_iounmap(dev, core->mem[i].cpu_addr);
1134         }
1135         if (core->mem)
1136                 devm_kfree(dev, core->mem);
1138         ret = ti_sci_proc_release(core->tsp);
1139         if (ret)
1140                 dev_err(dev, "failed to release proc, ret = %d\n", ret);
1142         kfree(core->tsp);
1143         reset_control_put(core->reset);
1145         ret = ti_sci_put_handle(core->ti_sci);
1146         if (ret)
1147                 dev_err(dev, "failed to put ti_sci handle, ret = %d\n", ret);
1149         platform_set_drvdata(pdev, NULL);
1150         devm_kfree(dev, core);
1152         return ret;
1155 static int k3_r5_cluster_of_init(struct platform_device *pdev)
1157         struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
1158         struct device *dev = &pdev->dev;
1159         struct device_node *np = dev->of_node;
1160         struct platform_device *cpdev;
1161         struct device_node *child;
1162         struct k3_r5_core *core, *temp;
1163         int ret;
1165         for_each_available_child_of_node(np, child) {
1166                 cpdev = of_find_device_by_node(child);
1167                 if (!cpdev) {
1168                         ret = -ENODEV;
1169                         dev_err(dev, "could not get R5 core platform device\n");
1170                         goto fail;
1171                 }
1173                 ret = k3_r5_core_of_init(cpdev);
1174                 if (ret) {
1175                         dev_err(dev, "k3_r5_core_of_init failed, ret = %d\n",
1176                                 ret);
1177                         put_device(&cpdev->dev);
1178                         goto fail;
1179                 }
1181                 core = platform_get_drvdata(cpdev);
1182                 put_device(&cpdev->dev);
1183                 list_add_tail(&core->elem, &cluster->cores);
1184         }
1186         return 0;
1188 fail:
1189         list_for_each_entry_safe_reverse(core, temp, &cluster->cores, elem) {
1190                 list_del(&core->elem);
1191                 cpdev = to_platform_device(core->dev);
1192                 if (k3_r5_core_of_exit(cpdev))
1193                         dev_err(dev, "k3_r5_core_of_exit cleanup failed\n");
1194         }
1195         return ret;
1198 static int k3_r5_cluster_of_exit(struct platform_device *pdev)
1200         struct k3_r5_cluster *cluster = platform_get_drvdata(pdev);
1201         struct device *dev = &pdev->dev;
1202         struct platform_device *cpdev;
1203         struct k3_r5_core *core, *temp;
1204         int ret;
1206         list_for_each_entry_safe_reverse(core, temp, &cluster->cores, elem) {
1207                 list_del(&core->elem);
1208                 cpdev = to_platform_device(core->dev);
1209                 ret = k3_r5_core_of_exit(cpdev);
1210                 if (ret) {
1211                         dev_err(dev, "k3_r5_core_of_exit failed, ret = %d\n",
1212                                 ret);
1213                         break;
1214                 }
1215         }
1217         return ret;
1220 static int k3_r5_probe(struct platform_device *pdev)
1222         struct device *dev = &pdev->dev;
1223         struct device_node *np = dev->of_node;
1224         struct k3_r5_cluster *cluster;
1225         int ret, ret1;
1226         int num_cores;
1228         cluster = devm_kzalloc(dev, sizeof(*cluster), GFP_KERNEL);
1229         if (!cluster)
1230                 return -ENOMEM;
1232         cluster->dev = dev;
1233         cluster->mode = CLUSTER_MODE_LOCKSTEP;
1234         INIT_LIST_HEAD(&cluster->cores);
1236         ret = of_property_read_u32(np, "lockstep-mode", &cluster->mode);
1237         if (ret < 0 && ret != -EINVAL) {
1238                 dev_err(dev, "invalid format for lockstep-mode, ret = %d\n",
1239                         ret);
1240                 return ret;
1241         }
1243         num_cores = of_get_available_child_count(np);
1244         if (num_cores != 2) {
1245                 dev_err(dev, "MCU cluster requires both R5F cores to be enabled, num_cores = %d\n",
1246                         num_cores);
1247                 return -ENODEV;
1248         }
1250         platform_set_drvdata(pdev, cluster);
1252         dev_info(dev, "creating child devices for R5F cores\n");
1253         ret = of_platform_populate(np, NULL, NULL, dev);
1254         if (ret) {
1255                 dev_err(dev, "of_platform_populate failed, ret = %d\n", ret);
1256                 return ret;
1257         }
1259         ret = k3_r5_cluster_of_init(pdev);
1260         if (ret) {
1261                 dev_err(dev, "k3_r5_cluster_of_init failed, ret = %d\n", ret);
1262                 goto fail_of;
1263         }
1265         ret = k3_r5_cluster_rproc_init(pdev);
1266         if (ret) {
1267                 dev_err(dev, "k3_r5_cluster_rproc_init failed, ret = %d\n",
1268                         ret);
1269                 goto fail_rproc;
1270         }
1272         return 0;
1274 fail_rproc:
1275         ret1 = k3_r5_cluster_of_exit(pdev);
1276         if (ret1)
1277                 dev_err(dev, "k3_r5_cluster_of_exit failed, ret = %d\n", ret1);
1278 fail_of:
1279         of_platform_depopulate(dev);
1280         return ret;
1283 static int k3_r5_remove(struct platform_device *pdev)
1285         struct device *dev = &pdev->dev;
1286         int ret;
1288         ret = k3_r5_cluster_rproc_exit(pdev);
1289         if (ret) {
1290                 dev_err(dev, "k3_r5_cluster_rproc_exit failed, ret = %d\n",
1291                         ret);
1292                 goto fail;
1293         }
1295         ret = k3_r5_cluster_of_exit(pdev);
1296         if (ret) {
1297                 dev_err(dev, "k3_r5_cluster_of_exit failed, ret = %d\n", ret);
1298                 goto fail;
1299         }
1301         dev_info(dev, "removing child devices for R5F cores\n");
1302         of_platform_depopulate(dev);
1304 fail:
1305         return ret;
1308 static const struct k3_r5_rproc_dev_data am65x_r5f_dev_data[] = {
1309         {
1310                 .device_name    = "41000000.r5f",
1311                 .fw_name        = "am65x-mcu-r5f0_0-fw",
1312         },
1313         {
1314                 .device_name    = "41400000.r5f",
1315                 .fw_name        = "am65x-mcu-r5f0_1-fw",
1316         },
1317         {
1318                 /* sentinel */
1319         },
1320 };
1322 static const struct of_device_id k3_r5_of_match[] = {
1323         {
1324                 .compatible     = "ti,am654-r5fss",
1325                 .data           = am65x_r5f_dev_data,
1326         },
1327         { /* sentinel */ },
1328 };
1329 MODULE_DEVICE_TABLE(of, k3_r5_of_match);
1331 static struct platform_driver k3_r5_rproc_driver = {
1332         .probe = k3_r5_probe,
1333         .remove = k3_r5_remove,
1334         .driver = {
1335                 .name = "k3_r5_rproc",
1336                 .of_match_table = k3_r5_of_match,
1337         },
1338 };
1340 module_platform_driver(k3_r5_rproc_driver);
1342 MODULE_LICENSE("GPL v2");
1343 MODULE_DESCRIPTION("TI K3 R5F remote processor driver");
1344 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");