drivers/remoteproc/ti_k3_dsp_remoteproc.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * TI K3 DSP Remote Processor(s) driver
0004  *
0005  * Copyright (C) 2018-2022 Texas Instruments Incorporated - https://www.ti.com/
0006  *  Suman Anna <s-anna@ti.com>
0007  */
0008
0009 #include <linux/io.h>
0010 #include <linux/mailbox_client.h>
0011 #include <linux/module.h>
0012 #include <linux/of_device.h>
0013 #include <linux/of_reserved_mem.h>
0014 #include <linux/omap-mailbox.h>
0015 #include <linux/platform_device.h>
0016 #include <linux/remoteproc.h>
0017 #include <linux/reset.h>
0018 #include <linux/slab.h>
0019
0020 #include "omap_remoteproc.h"
0021 #include "remoteproc_internal.h"
0022 #include "ti_sci_proc.h"
0023
0024 #define KEYSTONE_RPROC_LOCAL_ADDRESS_MASK   (SZ_16M - 1)
0025
0026 /**
0027  * struct k3_dsp_mem - internal memory structure
0028  * @cpu_addr: MPU virtual address of the memory region
0029  * @bus_addr: Bus address used to access the memory region
0030  * @dev_addr: Device address of the memory region from DSP view
0031  * @size: Size of the memory region
0032  */
0033 struct k3_dsp_mem {
0034     void __iomem *cpu_addr;
0035     phys_addr_t bus_addr;
0036     u32 dev_addr;
0037     size_t size;
0038 };
0039
0040 /**
0041  * struct k3_dsp_mem_data - memory definitions for a DSP
0042  * @name: name for this memory entry
0043  * @dev_addr: device address for the memory entry
0044  */
0045 struct k3_dsp_mem_data {
0046     const char *name;
0047     const u32 dev_addr;
0048 };
0049
0050 /**
0051  * struct k3_dsp_dev_data - device data structure for a DSP
0052  * @mems: pointer to memory definitions for a DSP
0053  * @num_mems: number of memory regions in @mems
0054  * @boot_align_addr: boot vector address alignment granularity
0055  * @uses_lreset: flag to denote the need for local reset management
0056  */
0057 struct k3_dsp_dev_data {
0058     const struct k3_dsp_mem_data *mems;
0059     u32 num_mems;
0060     u32 boot_align_addr;
0061     bool uses_lreset;
0062 };
0063
0064 /**
0065  * struct k3_dsp_rproc - k3 DSP remote processor driver structure
0066  * @dev: cached device pointer
0067  * @rproc: remoteproc device handle
0068  * @mem: internal memory regions data
0069  * @num_mems: number of internal memory regions
0070  * @rmem: reserved memory regions data
0071  * @num_rmems: number of reserved memory regions
0072  * @reset: reset control handle
0073  * @data: pointer to DSP-specific device data
0074  * @tsp: TI-SCI processor control handle
0075  * @ti_sci: TI-SCI handle
0076  * @ti_sci_id: TI-SCI device identifier
0077  * @mbox: mailbox channel handle
0078  * @client: mailbox client to request the mailbox channel
0079  */
0080 struct k3_dsp_rproc {
0081     struct device *dev;
0082     struct rproc *rproc;
0083     struct k3_dsp_mem *mem;
0084     int num_mems;
0085     struct k3_dsp_mem *rmem;
0086     int num_rmems;
0087     struct reset_control *reset;
0088     const struct k3_dsp_dev_data *data;
0089     struct ti_sci_proc *tsp;
0090     const struct ti_sci_handle *ti_sci;
0091     u32 ti_sci_id;
0092     struct mbox_chan *mbox;
0093     struct mbox_client client;
0094 };
0095
0096 /**
0097  * k3_dsp_rproc_mbox_callback() - inbound mailbox message handler
0098  * @client: mailbox client pointer used for requesting the mailbox channel
0099  * @data: mailbox payload
0100  *
0101  * This handler is invoked by the OMAP mailbox driver whenever a mailbox
0102  * message is received. Usually, the mailbox payload simply contains
0103  * the index of the virtqueue that is kicked by the remote processor,
0104  * and we let remoteproc core handle it.
0105  *
0106  * In addition to virtqueue indices, we also have some out-of-band values
0107  * that indicate different events. Those values are deliberately very
0108  * large so they don't coincide with virtqueue indices.
0109  */
0110 static void k3_dsp_rproc_mbox_callback(struct mbox_client *client, void *data)
0111 {
0112     struct k3_dsp_rproc *kproc = container_of(client, struct k3_dsp_rproc,
0113                           client);
0114     struct device *dev = kproc->rproc->dev.parent;
0115     const char *name = kproc->rproc->name;
0116     u32 msg = omap_mbox_message(data);
0117
0118     dev_dbg(dev, "mbox msg: 0x%x\n", msg);
0119
0120     switch (msg) {
0121     case RP_MBOX_CRASH:
0122         /*
0123          * remoteproc detected an exception, but error recovery is not
0124          * supported. So, just log this for now
0125          */
0126         dev_err(dev, "K3 DSP rproc %s crashed\n", name);
0127         break;
0128     case RP_MBOX_ECHO_REPLY:
0129         dev_info(dev, "received echo reply from %s\n", name);
0130         break;
0131     default:
0132         /* silently handle all other valid messages */
0133         if (msg >= RP_MBOX_READY && msg < RP_MBOX_END_MSG)
0134             return;
0135         if (msg > kproc->rproc->max_notifyid) {
0136             dev_dbg(dev, "dropping unknown message 0x%x", msg);
0137             return;
0138         }
0139         /* msg contains the index of the triggered vring */
0140         if (rproc_vq_interrupt(kproc->rproc, msg) == IRQ_NONE)
0141             dev_dbg(dev, "no message was found in vqid %d\n", msg);
0142     }
0143 }
0144
0145 /*
0146  * Kick the remote processor to notify about pending unprocessed messages.
0147  * The vqid usage is not used and is inconsequential, as the kick is performed
0148  * through a simulated GPIO (a bit in an IPC interrupt-triggering register),
0149  * the remote processor is expected to process both its Tx and Rx virtqueues.
0150  */
0151 static void k3_dsp_rproc_kick(struct rproc *rproc, int vqid)
0152 {
0153     struct k3_dsp_rproc *kproc = rproc->priv;
0154     struct device *dev = rproc->dev.parent;
0155     mbox_msg_t msg = (mbox_msg_t)vqid;
0156     int ret;
0157
0158     /* send the index of the triggered virtqueue in the mailbox payload */
0159     ret = mbox_send_message(kproc->mbox, (void *)msg);
0160     if (ret < 0)
0161         dev_err(dev, "failed to send mailbox message, status = %d\n",
0162             ret);
0163 }
0164
0165 /* Put the DSP processor into reset */
0166 static int k3_dsp_rproc_reset(struct k3_dsp_rproc *kproc)
0167 {
0168     struct device *dev = kproc->dev;
0169     int ret;
0170
0171     ret = reset_control_assert(kproc->reset);
0172     if (ret) {
0173         dev_err(dev, "local-reset assert failed, ret = %d\n", ret);
0174         return ret;
0175     }
0176
0177     if (kproc->data->uses_lreset)
0178         return ret;
0179
0180     ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
0181                             kproc->ti_sci_id);
0182     if (ret) {
0183         dev_err(dev, "module-reset assert failed, ret = %d\n", ret);
0184         if (reset_control_deassert(kproc->reset))
0185             dev_warn(dev, "local-reset deassert back failed\n");
0186     }
0187
0188     return ret;
0189 }
0190
0191 /* Release the DSP processor from reset */
0192 static int k3_dsp_rproc_release(struct k3_dsp_rproc *kproc)
0193 {
0194     struct device *dev = kproc->dev;
0195     int ret;
0196
0197     if (kproc->data->uses_lreset)
0198         goto lreset;
0199
0200     ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci,
0201                             kproc->ti_sci_id);
0202     if (ret) {
0203         dev_err(dev, "module-reset deassert failed, ret = %d\n", ret);
0204         return ret;
0205     }
0206
0207 lreset:
0208     ret = reset_control_deassert(kproc->reset);
0209     if (ret) {
0210         dev_err(dev, "local-reset deassert failed, ret = %d\n", ret);
0211         if (kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
0212                               kproc->ti_sci_id))
0213             dev_warn(dev, "module-reset assert back failed\n");
0214     }
0215
0216     return ret;
0217 }
0218
0219 static int k3_dsp_rproc_request_mbox(struct rproc *rproc)
0220 {
0221     struct k3_dsp_rproc *kproc = rproc->priv;
0222     struct mbox_client *client = &kproc->client;
0223     struct device *dev = kproc->dev;
0224     int ret;
0225
0226     client->dev = dev;
0227     client->tx_done = NULL;
0228     client->rx_callback = k3_dsp_rproc_mbox_callback;
0229     client->tx_block = false;
0230     client->knows_txdone = false;
0231
0232     kproc->mbox = mbox_request_channel(client, 0);
0233     if (IS_ERR(kproc->mbox)) {
0234         ret = -EBUSY;
0235         dev_err(dev, "mbox_request_channel failed: %ld\n",
0236             PTR_ERR(kproc->mbox));
0237         return ret;
0238     }
0239
0240     /*
0241      * Ping the remote processor, this is only for sanity-sake for now;
0242      * there is no functional effect whatsoever.
0243      *
0244      * Note that the reply will _not_ arrive immediately: this message
0245      * will wait in the mailbox fifo until the remote processor is booted.
0246      */
0247     ret = mbox_send_message(kproc->mbox, (void *)RP_MBOX_ECHO_REQUEST);
0248     if (ret < 0) {
0249         dev_err(dev, "mbox_send_message failed: %d\n", ret);
0250         mbox_free_channel(kproc->mbox);
0251         return ret;
0252     }
0253
0254     return 0;
0255 }
0256 /*
0257  * The C66x DSP cores have a local reset that affects only the CPU, and a
0258  * generic module reset that powers on the device and allows the DSP internal
0259  * memories to be accessed while the local reset is asserted. This function is
0260  * used to release the global reset on C66x DSPs to allow loading into the DSP
0261  * internal RAMs. The .prepare() ops is invoked by remoteproc core before any
0262  * firmware loading, and is followed by the .start() ops after loading to
0263  * actually let the C66x DSP cores run. This callback is invoked only in
0264  * remoteproc mode.
0265  */
0266 static int k3_dsp_rproc_prepare(struct rproc *rproc)
0267 {
0268     struct k3_dsp_rproc *kproc = rproc->priv;
0269     struct device *dev = kproc->dev;
0270     int ret;
0271
0272     ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci,
0273                             kproc->ti_sci_id);
0274     if (ret)
0275         dev_err(dev, "module-reset deassert failed, cannot enable internal RAM loading, ret = %d\n",
0276             ret);
0277
0278     return ret;
0279 }
0280
0281 /*
0282  * This function implements the .unprepare() ops and performs the complimentary
0283  * operations to that of the .prepare() ops. The function is used to assert the
0284  * global reset on applicable C66x cores. This completes the second portion of
0285  * powering down the C66x DSP cores. The cores themselves are only halted in the
0286  * .stop() callback through the local reset, and the .unprepare() ops is invoked
0287  * by the remoteproc core after the remoteproc is stopped to balance the global
0288  * reset. This callback is invoked only in remoteproc mode.
0289  */
0290 static int k3_dsp_rproc_unprepare(struct rproc *rproc)
0291 {
0292     struct k3_dsp_rproc *kproc = rproc->priv;
0293     struct device *dev = kproc->dev;
0294     int ret;
0295
0296     ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
0297                             kproc->ti_sci_id);
0298     if (ret)
0299         dev_err(dev, "module-reset assert failed, ret = %d\n", ret);
0300
0301     return ret;
0302 }
0303
0304 /*
0305  * Power up the DSP remote processor.
0306  *
0307  * This function will be invoked only after the firmware for this rproc
0308  * was loaded, parsed successfully, and all of its resource requirements
0309  * were met. This callback is invoked only in remoteproc mode.
0310  */
0311 static int k3_dsp_rproc_start(struct rproc *rproc)
0312 {
0313     struct k3_dsp_rproc *kproc = rproc->priv;
0314     struct device *dev = kproc->dev;
0315     u32 boot_addr;
0316     int ret;
0317
0318     ret = k3_dsp_rproc_request_mbox(rproc);
0319     if (ret)
0320         return ret;
0321
0322     boot_addr = rproc->bootaddr;
0323     if (boot_addr & (kproc->data->boot_align_addr - 1)) {
0324         dev_err(dev, "invalid boot address 0x%x, must be aligned on a 0x%x boundary\n",
0325             boot_addr, kproc->data->boot_align_addr);
0326         ret = -EINVAL;
0327         goto put_mbox;
0328     }
0329
0330     dev_err(dev, "booting DSP core using boot addr = 0x%x\n", boot_addr);
0331     ret = ti_sci_proc_set_config(kproc->tsp, boot_addr, 0, 0);
0332     if (ret)
0333         goto put_mbox;
0334
0335     ret = k3_dsp_rproc_release(kproc);
0336     if (ret)
0337         goto put_mbox;
0338
0339     return 0;
0340
0341 put_mbox:
0342     mbox_free_channel(kproc->mbox);
0343     return ret;
0344 }
0345
0346 /*
0347  * Stop the DSP remote processor.
0348  *
0349  * This function puts the DSP processor into reset, and finishes processing
0350  * of any pending messages. This callback is invoked only in remoteproc mode.
0351  */
0352 static int k3_dsp_rproc_stop(struct rproc *rproc)
0353 {
0354     struct k3_dsp_rproc *kproc = rproc->priv;
0355
0356     mbox_free_channel(kproc->mbox);
0357
0358     k3_dsp_rproc_reset(kproc);
0359
0360     return 0;
0361 }
0362
0363 /*
0364  * Attach to a running DSP remote processor (IPC-only mode)
0365  *
0366  * This rproc attach callback only needs to request the mailbox, the remote
0367  * processor is already booted, so there is no need to issue any TI-SCI
0368  * commands to boot the DSP core. This callback is invoked only in IPC-only
0369  * mode.
0370  */
0371 static int k3_dsp_rproc_attach(struct rproc *rproc)
0372 {
0373     struct k3_dsp_rproc *kproc = rproc->priv;
0374     struct device *dev = kproc->dev;
0375     int ret;
0376
0377     ret = k3_dsp_rproc_request_mbox(rproc);
0378     if (ret)
0379         return ret;
0380
0381     dev_info(dev, "DSP initialized in IPC-only mode\n");
0382     return 0;
0383 }
0384
0385 /*
0386  * Detach from a running DSP remote processor (IPC-only mode)
0387  *
0388  * This rproc detach callback performs the opposite operation to attach callback
0389  * and only needs to release the mailbox, the DSP core is not stopped and will
0390  * be left to continue to run its booted firmware. This callback is invoked only
0391  * in IPC-only mode.
0392  */
0393 static int k3_dsp_rproc_detach(struct rproc *rproc)
0394 {
0395     struct k3_dsp_rproc *kproc = rproc->priv;
0396     struct device *dev = kproc->dev;
0397
0398     mbox_free_channel(kproc->mbox);
0399     dev_info(dev, "DSP deinitialized in IPC-only mode\n");
0400     return 0;
0401 }
0402
0403 /*
0404  * This function implements the .get_loaded_rsc_table() callback and is used
0405  * to provide the resource table for a booted DSP in IPC-only mode. The K3 DSP
0406  * firmwares follow a design-by-contract approach and are expected to have the
0407  * resource table at the base of the DDR region reserved for firmware usage.
0408  * This provides flexibility for the remote processor to be booted by different
0409  * bootloaders that may or may not have the ability to publish the resource table
0410  * address and size through a DT property. This callback is invoked only in
0411  * IPC-only mode.
0412  */
0413 static struct resource_table *k3_dsp_get_loaded_rsc_table(struct rproc *rproc,
0414                               size_t *rsc_table_sz)
0415 {
0416     struct k3_dsp_rproc *kproc = rproc->priv;
0417     struct device *dev = kproc->dev;
0418
0419     if (!kproc->rmem[0].cpu_addr) {
0420         dev_err(dev, "memory-region #1 does not exist, loaded rsc table can't be found");
0421         return ERR_PTR(-ENOMEM);
0422     }
0423
0424     /*
0425      * NOTE: The resource table size is currently hard-coded to a maximum
0426      * of 256 bytes. The most common resource table usage for K3 firmwares
0427      * is to only have the vdev resource entry and an optional trace entry.
0428      * The exact size could be computed based on resource table address, but
0429      * the hard-coded value suffices to support the IPC-only mode.
0430      */
0431     *rsc_table_sz = 256;
0432     return (struct resource_table *)kproc->rmem[0].cpu_addr;
0433 }
0434
0435 /*
0436  * Custom function to translate a DSP device address (internal RAMs only) to a
0437  * kernel virtual address.  The DSPs can access their RAMs at either an internal
0438  * address visible only from a DSP, or at the SoC-level bus address. Both these
0439  * addresses need to be looked through for translation. The translated addresses
0440  * can be used either by the remoteproc core for loading (when using kernel
0441  * remoteproc loader), or by any rpmsg bus drivers.
0442  */
0443 static void *k3_dsp_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)
0444 {
0445     struct k3_dsp_rproc *kproc = rproc->priv;
0446     void __iomem *va = NULL;
0447     phys_addr_t bus_addr;
0448     u32 dev_addr, offset;
0449     size_t size;
0450     int i;
0451
0452     if (len == 0)
0453         return NULL;
0454
0455     for (i = 0; i < kproc->num_mems; i++) {
0456         bus_addr = kproc->mem[i].bus_addr;
0457         dev_addr = kproc->mem[i].dev_addr;
0458         size = kproc->mem[i].size;
0459
0460         if (da < KEYSTONE_RPROC_LOCAL_ADDRESS_MASK) {
0461             /* handle DSP-view addresses */
0462             if (da >= dev_addr &&
0463                 ((da + len) <= (dev_addr + size))) {
0464                 offset = da - dev_addr;
0465                 va = kproc->mem[i].cpu_addr + offset;
0466                 return (__force void *)va;
0467             }
0468         } else {
0469             /* handle SoC-view addresses */
0470             if (da >= bus_addr &&
0471                 (da + len) <= (bus_addr + size)) {
0472                 offset = da - bus_addr;
0473                 va = kproc->mem[i].cpu_addr + offset;
0474                 return (__force void *)va;
0475             }
0476         }
0477     }
0478
0479     /* handle static DDR reserved memory regions */
0480     for (i = 0; i < kproc->num_rmems; i++) {
0481         dev_addr = kproc->rmem[i].dev_addr;
0482         size = kproc->rmem[i].size;
0483
0484         if (da >= dev_addr && ((da + len) <= (dev_addr + size))) {
0485             offset = da - dev_addr;
0486             va = kproc->rmem[i].cpu_addr + offset;
0487             return (__force void *)va;
0488         }
0489     }
0490
0491     return NULL;
0492 }
0493
0494 static const struct rproc_ops k3_dsp_rproc_ops = {
0495     .start      = k3_dsp_rproc_start,
0496     .stop       = k3_dsp_rproc_stop,
0497     .kick       = k3_dsp_rproc_kick,
0498     .da_to_va   = k3_dsp_rproc_da_to_va,
0499 };
0500
0501 static int k3_dsp_rproc_of_get_memories(struct platform_device *pdev,
0502                     struct k3_dsp_rproc *kproc)
0503 {
0504     const struct k3_dsp_dev_data *data = kproc->data;
0505     struct device *dev = &pdev->dev;
0506     struct resource *res;
0507     int num_mems = 0;
0508     int i;
0509
0510     num_mems = kproc->data->num_mems;
0511     kproc->mem = devm_kcalloc(kproc->dev, num_mems,
0512                   sizeof(*kproc->mem), GFP_KERNEL);
0513     if (!kproc->mem)
0514         return -ENOMEM;
0515
0516     for (i = 0; i < num_mems; i++) {
0517         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
0518                            data->mems[i].name);
0519         if (!res) {
0520             dev_err(dev, "found no memory resource for %s\n",
0521                 data->mems[i].name);
0522             return -EINVAL;
0523         }
0524         if (!devm_request_mem_region(dev, res->start,
0525                          resource_size(res),
0526                          dev_name(dev))) {
0527             dev_err(dev, "could not request %s region for resource\n",
0528                 data->mems[i].name);
0529             return -EBUSY;
0530         }
0531
0532         kproc->mem[i].cpu_addr = devm_ioremap_wc(dev, res->start,
0533                              resource_size(res));
0534         if (!kproc->mem[i].cpu_addr) {
0535             dev_err(dev, "failed to map %s memory\n",
0536                 data->mems[i].name);
0537             return -ENOMEM;
0538         }
0539         kproc->mem[i].bus_addr = res->start;
0540         kproc->mem[i].dev_addr = data->mems[i].dev_addr;
0541         kproc->mem[i].size = resource_size(res);
0542
0543         dev_dbg(dev, "memory %8s: bus addr %pa size 0x%zx va %pK da 0x%x\n",
0544             data->mems[i].name, &kproc->mem[i].bus_addr,
0545             kproc->mem[i].size, kproc->mem[i].cpu_addr,
0546             kproc->mem[i].dev_addr);
0547     }
0548     kproc->num_mems = num_mems;
0549
0550     return 0;
0551 }
0552
0553 static int k3_dsp_reserved_mem_init(struct k3_dsp_rproc *kproc)
0554 {
0555     struct device *dev = kproc->dev;
0556     struct device_node *np = dev->of_node;
0557     struct device_node *rmem_np;
0558     struct reserved_mem *rmem;
0559     int num_rmems;
0560     int ret, i;
0561
0562     num_rmems = of_property_count_elems_of_size(np, "memory-region",
0563                             sizeof(phandle));
0564     if (num_rmems <= 0) {
0565         dev_err(dev, "device does not reserved memory regions, ret = %d\n",
0566             num_rmems);
0567         return -EINVAL;
0568     }
0569     if (num_rmems < 2) {
0570         dev_err(dev, "device needs at least two memory regions to be defined, num = %d\n",
0571             num_rmems);
0572         return -EINVAL;
0573     }
0574
0575     /* use reserved memory region 0 for vring DMA allocations */
0576     ret = of_reserved_mem_device_init_by_idx(dev, np, 0);
0577     if (ret) {
0578         dev_err(dev, "device cannot initialize DMA pool, ret = %d\n",
0579             ret);
0580         return ret;
0581     }
0582
0583     num_rmems--;
0584     kproc->rmem = kcalloc(num_rmems, sizeof(*kproc->rmem), GFP_KERNEL);
0585     if (!kproc->rmem) {
0586         ret = -ENOMEM;
0587         goto release_rmem;
0588     }
0589
0590     /* use remaining reserved memory regions for static carveouts */
0591     for (i = 0; i < num_rmems; i++) {
0592         rmem_np = of_parse_phandle(np, "memory-region", i + 1);
0593         if (!rmem_np) {
0594             ret = -EINVAL;
0595             goto unmap_rmem;
0596         }
0597
0598         rmem = of_reserved_mem_lookup(rmem_np);
0599         if (!rmem) {
0600             of_node_put(rmem_np);
0601             ret = -EINVAL;
0602             goto unmap_rmem;
0603         }
0604         of_node_put(rmem_np);
0605
0606         kproc->rmem[i].bus_addr = rmem->base;
0607         /* 64-bit address regions currently not supported */
0608         kproc->rmem[i].dev_addr = (u32)rmem->base;
0609         kproc->rmem[i].size = rmem->size;
0610         kproc->rmem[i].cpu_addr = ioremap_wc(rmem->base, rmem->size);
0611         if (!kproc->rmem[i].cpu_addr) {
0612             dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n",
0613                 i + 1, &rmem->base, &rmem->size);
0614             ret = -ENOMEM;
0615             goto unmap_rmem;
0616         }
0617
0618         dev_dbg(dev, "reserved memory%d: bus addr %pa size 0x%zx va %pK da 0x%x\n",
0619             i + 1, &kproc->rmem[i].bus_addr,
0620             kproc->rmem[i].size, kproc->rmem[i].cpu_addr,
0621             kproc->rmem[i].dev_addr);
0622     }
0623     kproc->num_rmems = num_rmems;
0624
0625     return 0;
0626
0627 unmap_rmem:
0628     for (i--; i >= 0; i--)
0629         iounmap(kproc->rmem[i].cpu_addr);
0630     kfree(kproc->rmem);
0631 release_rmem:
0632     of_reserved_mem_device_release(kproc->dev);
0633     return ret;
0634 }
0635
0636 static void k3_dsp_reserved_mem_exit(struct k3_dsp_rproc *kproc)
0637 {
0638     int i;
0639
0640     for (i = 0; i < kproc->num_rmems; i++)
0641         iounmap(kproc->rmem[i].cpu_addr);
0642     kfree(kproc->rmem);
0643
0644     of_reserved_mem_device_release(kproc->dev);
0645 }
0646
0647 static
0648 struct ti_sci_proc *k3_dsp_rproc_of_get_tsp(struct device *dev,
0649                         const struct ti_sci_handle *sci)
0650 {
0651     struct ti_sci_proc *tsp;
0652     u32 temp[2];
0653     int ret;
0654
0655     ret = of_property_read_u32_array(dev->of_node, "ti,sci-proc-ids",
0656                      temp, 2);
0657     if (ret < 0)
0658         return ERR_PTR(ret);
0659
0660     tsp = kzalloc(sizeof(*tsp), GFP_KERNEL);
0661     if (!tsp)
0662         return ERR_PTR(-ENOMEM);
0663
0664     tsp->dev = dev;
0665     tsp->sci = sci;
0666     tsp->ops = &sci->ops.proc_ops;
0667     tsp->proc_id = temp[0];
0668     tsp->host_id = temp[1];
0669
0670     return tsp;
0671 }
0672
0673 static int k3_dsp_rproc_probe(struct platform_device *pdev)
0674 {
0675     struct device *dev = &pdev->dev;
0676     struct device_node *np = dev->of_node;
0677     const struct k3_dsp_dev_data *data;
0678     struct k3_dsp_rproc *kproc;
0679     struct rproc *rproc;
0680     const char *fw_name;
0681     bool p_state = false;
0682     int ret = 0;
0683     int ret1;
0684
0685     data = of_device_get_match_data(dev);
0686     if (!data)
0687         return -ENODEV;
0688
0689     ret = rproc_of_parse_firmware(dev, 0, &fw_name);
0690     if (ret) {
0691         dev_err(dev, "failed to parse firmware-name property, ret = %d\n",
0692             ret);
0693         return ret;
0694     }
0695
0696     rproc = rproc_alloc(dev, dev_name(dev), &k3_dsp_rproc_ops, fw_name,
0697                 sizeof(*kproc));
0698     if (!rproc)
0699         return -ENOMEM;
0700
0701     rproc->has_iommu = false;
0702     rproc->recovery_disabled = true;
0703     if (data->uses_lreset) {
0704         rproc->ops->prepare = k3_dsp_rproc_prepare;
0705         rproc->ops->unprepare = k3_dsp_rproc_unprepare;
0706     }
0707     kproc = rproc->priv;
0708     kproc->rproc = rproc;
0709     kproc->dev = dev;
0710     kproc->data = data;
0711
0712     kproc->ti_sci = ti_sci_get_by_phandle(np, "ti,sci");
0713     if (IS_ERR(kproc->ti_sci)) {
0714         ret = PTR_ERR(kproc->ti_sci);
0715         if (ret != -EPROBE_DEFER) {
0716             dev_err(dev, "failed to get ti-sci handle, ret = %d\n",
0717                 ret);
0718         }
0719         kproc->ti_sci = NULL;
0720         goto free_rproc;
0721     }
0722
0723     ret = of_property_read_u32(np, "ti,sci-dev-id", &kproc->ti_sci_id);
0724     if (ret) {
0725         dev_err(dev, "missing 'ti,sci-dev-id' property\n");
0726         goto put_sci;
0727     }
0728
0729     kproc->reset = devm_reset_control_get_exclusive(dev, NULL);
0730     if (IS_ERR(kproc->reset)) {
0731         ret = PTR_ERR(kproc->reset);
0732         dev_err(dev, "failed to get reset, status = %d\n", ret);
0733         goto put_sci;
0734     }
0735
0736     kproc->tsp = k3_dsp_rproc_of_get_tsp(dev, kproc->ti_sci);
0737     if (IS_ERR(kproc->tsp)) {
0738         dev_err(dev, "failed to construct ti-sci proc control, ret = %d\n",
0739             ret);
0740         ret = PTR_ERR(kproc->tsp);
0741         goto put_sci;
0742     }
0743
0744     ret = ti_sci_proc_request(kproc->tsp);
0745     if (ret < 0) {
0746         dev_err(dev, "ti_sci_proc_request failed, ret = %d\n", ret);
0747         goto free_tsp;
0748     }
0749
0750     ret = k3_dsp_rproc_of_get_memories(pdev, kproc);
0751     if (ret)
0752         goto release_tsp;
0753
0754     ret = k3_dsp_reserved_mem_init(kproc);
0755     if (ret) {
0756         dev_err(dev, "reserved memory init failed, ret = %d\n", ret);
0757         goto release_tsp;
0758     }
0759
0760     ret = kproc->ti_sci->ops.dev_ops.is_on(kproc->ti_sci, kproc->ti_sci_id,
0761                            NULL, &p_state);
0762     if (ret) {
0763         dev_err(dev, "failed to get initial state, mode cannot be determined, ret = %d\n",
0764             ret);
0765         goto release_mem;
0766     }
0767
0768     /* configure J721E devices for either remoteproc or IPC-only mode */
0769     if (p_state) {
0770         dev_info(dev, "configured DSP for IPC-only mode\n");
0771         rproc->state = RPROC_DETACHED;
0772         /* override rproc ops with only required IPC-only mode ops */
0773         rproc->ops->prepare = NULL;
0774         rproc->ops->unprepare = NULL;
0775         rproc->ops->start = NULL;
0776         rproc->ops->stop = NULL;
0777         rproc->ops->attach = k3_dsp_rproc_attach;
0778         rproc->ops->detach = k3_dsp_rproc_detach;
0779         rproc->ops->get_loaded_rsc_table = k3_dsp_get_loaded_rsc_table;
0780     } else {
0781         dev_info(dev, "configured DSP for remoteproc mode\n");
0782         /*
0783          * ensure the DSP local reset is asserted to ensure the DSP
0784          * doesn't execute bogus code in .prepare() when the module
0785          * reset is released.
0786          */
0787         if (data->uses_lreset) {
0788             ret = reset_control_status(kproc->reset);
0789             if (ret < 0) {
0790                 dev_err(dev, "failed to get reset status, status = %d\n",
0791                     ret);
0792                 goto release_mem;
0793             } else if (ret == 0) {
0794                 dev_warn(dev, "local reset is deasserted for device\n");
0795                 k3_dsp_rproc_reset(kproc);
0796             }
0797         }
0798     }
0799
0800     ret = rproc_add(rproc);
0801     if (ret) {
0802         dev_err(dev, "failed to add register device with remoteproc core, status = %d\n",
0803             ret);
0804         goto release_mem;
0805     }
0806
0807     platform_set_drvdata(pdev, kproc);
0808
0809     return 0;
0810
0811 release_mem:
0812     k3_dsp_reserved_mem_exit(kproc);
0813 release_tsp:
0814     ret1 = ti_sci_proc_release(kproc->tsp);
0815     if (ret1)
0816         dev_err(dev, "failed to release proc, ret = %d\n", ret1);
0817 free_tsp:
0818     kfree(kproc->tsp);
0819 put_sci:
0820     ret1 = ti_sci_put_handle(kproc->ti_sci);
0821     if (ret1)
0822         dev_err(dev, "failed to put ti_sci handle, ret = %d\n", ret1);
0823 free_rproc:
0824     rproc_free(rproc);
0825     return ret;
0826 }
0827
0828 static int k3_dsp_rproc_remove(struct platform_device *pdev)
0829 {
0830     struct k3_dsp_rproc *kproc = platform_get_drvdata(pdev);
0831     struct rproc *rproc = kproc->rproc;
0832     struct device *dev = &pdev->dev;
0833     int ret;
0834
0835     if (rproc->state == RPROC_ATTACHED) {
0836         ret = rproc_detach(rproc);
0837         if (ret) {
0838             dev_err(dev, "failed to detach proc, ret = %d\n", ret);
0839             return ret;
0840         }
0841     }
0842
0843     rproc_del(kproc->rproc);
0844
0845     ret = ti_sci_proc_release(kproc->tsp);
0846     if (ret)
0847         dev_err(dev, "failed to release proc, ret = %d\n", ret);
0848
0849     kfree(kproc->tsp);
0850
0851     ret = ti_sci_put_handle(kproc->ti_sci);
0852     if (ret)
0853         dev_err(dev, "failed to put ti_sci handle, ret = %d\n", ret);
0854
0855     k3_dsp_reserved_mem_exit(kproc);
0856     rproc_free(kproc->rproc);
0857
0858     return 0;
0859 }
0860
0861 static const struct k3_dsp_mem_data c66_mems[] = {
0862     { .name = "l2sram", .dev_addr = 0x800000 },
0863     { .name = "l1pram", .dev_addr = 0xe00000 },
0864     { .name = "l1dram", .dev_addr = 0xf00000 },
0865 };
0866
0867 /* C71x cores only have a L1P Cache, there are no L1P SRAMs */
0868 static const struct k3_dsp_mem_data c71_mems[] = {
0869     { .name = "l2sram", .dev_addr = 0x800000 },
0870     { .name = "l1dram", .dev_addr = 0xe00000 },
0871 };
0872
0873 static const struct k3_dsp_dev_data c66_data = {
0874     .mems = c66_mems,
0875     .num_mems = ARRAY_SIZE(c66_mems),
0876     .boot_align_addr = SZ_1K,
0877     .uses_lreset = true,
0878 };
0879
0880 static const struct k3_dsp_dev_data c71_data = {
0881     .mems = c71_mems,
0882     .num_mems = ARRAY_SIZE(c71_mems),
0883     .boot_align_addr = SZ_2M,
0884     .uses_lreset = false,
0885 };
0886
0887 static const struct of_device_id k3_dsp_of_match[] = {
0888     { .compatible = "ti,j721e-c66-dsp", .data = &c66_data, },
0889     { .compatible = "ti,j721e-c71-dsp", .data = &c71_data, },
0890     { .compatible = "ti,j721s2-c71-dsp", .data = &c71_data, },
0891     { /* sentinel */ },
0892 };
0893 MODULE_DEVICE_TABLE(of, k3_dsp_of_match);
0894
0895 static struct platform_driver k3_dsp_rproc_driver = {
0896     .probe  = k3_dsp_rproc_probe,
0897     .remove = k3_dsp_rproc_remove,
0898     .driver = {
0899         .name = "k3-dsp-rproc",
0900         .of_match_table = k3_dsp_of_match,
0901     },
0902 };
0903
0904 module_platform_driver(k3_dsp_rproc_driver);
0905
0906 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");
0907 MODULE_LICENSE("GPL v2");
0908 MODULE_DESCRIPTION("TI K3 DSP Remoteproc driver");