drivers/remoteproc/rcar_rproc.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) IoT.bzh 2021
0004  */
0005
0006 #include <linux/limits.h>
0007 #include <linux/module.h>
0008 #include <linux/of_device.h>
0009 #include <linux/of_reserved_mem.h>
0010 #include <linux/pm_runtime.h>
0011 #include <linux/remoteproc.h>
0012 #include <linux/reset.h>
0013 #include <linux/soc/renesas/rcar-rst.h>
0014
0015 #include "remoteproc_internal.h"
0016
0017 struct rcar_rproc {
0018     struct reset_control *rst;
0019 };
0020
0021 static int rcar_rproc_mem_alloc(struct rproc *rproc,
0022                  struct rproc_mem_entry *mem)
0023 {
0024     struct device *dev = &rproc->dev;
0025     void *va;
0026
0027     dev_dbg(dev, "map memory: %pa+%zx\n", &mem->dma, mem->len);
0028     va = ioremap_wc(mem->dma, mem->len);
0029     if (!va) {
0030         dev_err(dev, "Unable to map memory region: %pa+%zx\n",
0031             &mem->dma, mem->len);
0032         return -ENOMEM;
0033     }
0034
0035     /* Update memory entry va */
0036     mem->va = va;
0037
0038     return 0;
0039 }
0040
0041 static int rcar_rproc_mem_release(struct rproc *rproc,
0042                    struct rproc_mem_entry *mem)
0043 {
0044     dev_dbg(&rproc->dev, "unmap memory: %pa\n", &mem->dma);
0045     iounmap(mem->va);
0046
0047     return 0;
0048 }
0049
0050 static int rcar_rproc_prepare(struct rproc *rproc)
0051 {
0052     struct device *dev = rproc->dev.parent;
0053     struct device_node *np = dev->of_node;
0054     struct of_phandle_iterator it;
0055     struct rproc_mem_entry *mem;
0056     struct reserved_mem *rmem;
0057     u32 da;
0058
0059     /* Register associated reserved memory regions */
0060     of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
0061     while (of_phandle_iterator_next(&it) == 0) {
0062
0063         rmem = of_reserved_mem_lookup(it.node);
0064         if (!rmem) {
0065             dev_err(&rproc->dev,
0066                 "unable to acquire memory-region\n");
0067             return -EINVAL;
0068         }
0069
0070         if (rmem->base > U32_MAX)
0071             return -EINVAL;
0072
0073         /* No need to translate pa to da, R-Car use same map */
0074         da = rmem->base;
0075         mem = rproc_mem_entry_init(dev, NULL,
0076                        rmem->base,
0077                        rmem->size, da,
0078                        rcar_rproc_mem_alloc,
0079                        rcar_rproc_mem_release,
0080                        it.node->name);
0081
0082         if (!mem)
0083             return -ENOMEM;
0084
0085         rproc_add_carveout(rproc, mem);
0086     }
0087
0088     return 0;
0089 }
0090
0091 static int rcar_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
0092 {
0093     int ret;
0094
0095     ret = rproc_elf_load_rsc_table(rproc, fw);
0096     if (ret)
0097         dev_info(&rproc->dev, "No resource table in elf\n");
0098
0099     return 0;
0100 }
0101
0102 static int rcar_rproc_start(struct rproc *rproc)
0103 {
0104     struct rcar_rproc *priv = rproc->priv;
0105     int err;
0106
0107     if (!rproc->bootaddr)
0108         return -EINVAL;
0109
0110     err = rcar_rst_set_rproc_boot_addr(rproc->bootaddr);
0111     if (err) {
0112         dev_err(&rproc->dev, "failed to set rproc boot addr\n");
0113         return err;
0114     }
0115
0116     err = reset_control_deassert(priv->rst);
0117     if (err)
0118         dev_err(&rproc->dev, "failed to deassert reset\n");
0119
0120     return err;
0121 }
0122
0123 static int rcar_rproc_stop(struct rproc *rproc)
0124 {
0125     struct rcar_rproc *priv = rproc->priv;
0126     int err;
0127
0128     err = reset_control_assert(priv->rst);
0129     if (err)
0130         dev_err(&rproc->dev, "failed to assert reset\n");
0131
0132     return err;
0133 }
0134
0135 static struct rproc_ops rcar_rproc_ops = {
0136     .prepare    = rcar_rproc_prepare,
0137     .start      = rcar_rproc_start,
0138     .stop       = rcar_rproc_stop,
0139     .load       = rproc_elf_load_segments,
0140     .parse_fw   = rcar_rproc_parse_fw,
0141     .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
0142     .sanity_check   = rproc_elf_sanity_check,
0143     .get_boot_addr  = rproc_elf_get_boot_addr,
0144
0145 };
0146
0147 static int rcar_rproc_probe(struct platform_device *pdev)
0148 {
0149     struct device *dev = &pdev->dev;
0150     struct device_node *np = dev->of_node;
0151     struct rcar_rproc *priv;
0152     struct rproc *rproc;
0153     int ret;
0154
0155     rproc = devm_rproc_alloc(dev, np->name, &rcar_rproc_ops,
0156                 NULL, sizeof(*priv));
0157     if (!rproc)
0158         return -ENOMEM;
0159
0160     priv = rproc->priv;
0161
0162     priv->rst = devm_reset_control_get_exclusive(dev, NULL);
0163     if (IS_ERR(priv->rst)) {
0164         ret = PTR_ERR(priv->rst);
0165         dev_err_probe(dev, ret, "fail to acquire rproc reset\n");
0166         return ret;
0167     }
0168
0169     pm_runtime_enable(dev);
0170     ret = pm_runtime_resume_and_get(dev);
0171     if (ret) {
0172         dev_err(dev, "failed to power up\n");
0173         return ret;
0174     }
0175
0176     dev_set_drvdata(dev, rproc);
0177
0178     /* Manually start the rproc */
0179     rproc->auto_boot = false;
0180
0181     ret = devm_rproc_add(dev, rproc);
0182     if (ret) {
0183         dev_err(dev, "rproc_add failed\n");
0184         goto pm_disable;
0185     }
0186
0187     return 0;
0188
0189 pm_disable:
0190     pm_runtime_disable(dev);
0191
0192     return ret;
0193 }
0194
0195 static int rcar_rproc_remove(struct platform_device *pdev)
0196 {
0197     struct device *dev = &pdev->dev;
0198
0199     pm_runtime_disable(dev);
0200
0201     return 0;
0202 }
0203
0204 static const struct of_device_id rcar_rproc_of_match[] = {
0205     { .compatible = "renesas,rcar-cr7" },
0206     {},
0207 };
0208
0209 MODULE_DEVICE_TABLE(of, rcar_rproc_of_match);
0210
0211 static struct platform_driver rcar_rproc_driver = {
0212     .probe = rcar_rproc_probe,
0213     .remove = rcar_rproc_remove,
0214     .driver = {
0215         .name = "rcar-rproc",
0216         .of_match_table = rcar_rproc_of_match,
0217     },
0218 };
0219
0220 module_platform_driver(rcar_rproc_driver);
0221
0222 MODULE_LICENSE("GPL v2");
0223 MODULE_DESCRIPTION("Renesas R-Car Gen3 remote processor control driver");
0224 MODULE_AUTHOR("Julien Massot <julien.massot@iot.bzh>");