drivers/remoteproc/wkup_m3_rproc.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * TI AMx3 Wakeup M3 Remote Processor driver
0004  *
0005  * Copyright (C) 2014-2015 Texas Instruments, Inc.
0006  *
0007  * Dave Gerlach <d-gerlach@ti.com>
0008  * Suman Anna <s-anna@ti.com>
0009  */
0010
0011 #include <linux/err.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/kernel.h>
0014 #include <linux/module.h>
0015 #include <linux/of_device.h>
0016 #include <linux/of_address.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/pm_runtime.h>
0019 #include <linux/remoteproc.h>
0020 #include <linux/reset.h>
0021
0022 #include <linux/platform_data/wkup_m3.h>
0023
0024 #include "remoteproc_internal.h"
0025
0026 #define WKUPM3_MEM_MAX  2
0027
0028 /**
0029  * struct wkup_m3_mem - WkupM3 internal memory structure
0030  * @cpu_addr: MPU virtual address of the memory region
0031  * @bus_addr: Bus address used to access the memory region
0032  * @dev_addr: Device address from Wakeup M3 view
0033  * @size: Size of the memory region
0034  */
0035 struct wkup_m3_mem {
0036     void __iomem *cpu_addr;
0037     phys_addr_t bus_addr;
0038     u32 dev_addr;
0039     size_t size;
0040 };
0041
0042 /**
0043  * struct wkup_m3_rproc - WkupM3 remote processor state
0044  * @rproc: rproc handle
0045  * @pdev: pointer to platform device
0046  * @mem: WkupM3 memory information
0047  * @rsts: reset control
0048  */
0049 struct wkup_m3_rproc {
0050     struct rproc *rproc;
0051     struct platform_device *pdev;
0052     struct wkup_m3_mem mem[WKUPM3_MEM_MAX];
0053     struct reset_control *rsts;
0054 };
0055
0056 static int wkup_m3_rproc_start(struct rproc *rproc)
0057 {
0058     struct wkup_m3_rproc *wkupm3 = rproc->priv;
0059     struct platform_device *pdev = wkupm3->pdev;
0060     struct device *dev = &pdev->dev;
0061     struct wkup_m3_platform_data *pdata = dev_get_platdata(dev);
0062     int error = 0;
0063
0064     error = reset_control_deassert(wkupm3->rsts);
0065
0066     if (!wkupm3->rsts && pdata->deassert_reset(pdev, pdata->reset_name)) {
0067         dev_err(dev, "Unable to reset wkup_m3!\n");
0068         error = -ENODEV;
0069     }
0070
0071     return error;
0072 }
0073
0074 static int wkup_m3_rproc_stop(struct rproc *rproc)
0075 {
0076     struct wkup_m3_rproc *wkupm3 = rproc->priv;
0077     struct platform_device *pdev = wkupm3->pdev;
0078     struct device *dev = &pdev->dev;
0079     struct wkup_m3_platform_data *pdata = dev_get_platdata(dev);
0080     int error = 0;
0081
0082     error = reset_control_assert(wkupm3->rsts);
0083
0084     if (!wkupm3->rsts && pdata->assert_reset(pdev, pdata->reset_name)) {
0085         dev_err(dev, "Unable to assert reset of wkup_m3!\n");
0086         error = -ENODEV;
0087     }
0088
0089     return error;
0090 }
0091
0092 static void *wkup_m3_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)
0093 {
0094     struct wkup_m3_rproc *wkupm3 = rproc->priv;
0095     void *va = NULL;
0096     int i;
0097     u32 offset;
0098
0099     if (len == 0)
0100         return NULL;
0101
0102     for (i = 0; i < WKUPM3_MEM_MAX; i++) {
0103         if (da >= wkupm3->mem[i].dev_addr && da + len <=
0104             wkupm3->mem[i].dev_addr +  wkupm3->mem[i].size) {
0105             offset = da -  wkupm3->mem[i].dev_addr;
0106             /* __force to make sparse happy with type conversion */
0107             va = (__force void *)(wkupm3->mem[i].cpu_addr + offset);
0108             break;
0109         }
0110     }
0111
0112     return va;
0113 }
0114
0115 static const struct rproc_ops wkup_m3_rproc_ops = {
0116     .start      = wkup_m3_rproc_start,
0117     .stop       = wkup_m3_rproc_stop,
0118     .da_to_va   = wkup_m3_rproc_da_to_va,
0119 };
0120
0121 static const struct of_device_id wkup_m3_rproc_of_match[] = {
0122     { .compatible = "ti,am3352-wkup-m3", },
0123     { .compatible = "ti,am4372-wkup-m3", },
0124     {},
0125 };
0126 MODULE_DEVICE_TABLE(of, wkup_m3_rproc_of_match);
0127
0128 static int wkup_m3_rproc_probe(struct platform_device *pdev)
0129 {
0130     struct device *dev = &pdev->dev;
0131     struct wkup_m3_platform_data *pdata = dev->platform_data;
0132     /* umem always needs to be processed first */
0133     const char *mem_names[WKUPM3_MEM_MAX] = { "umem", "dmem" };
0134     struct wkup_m3_rproc *wkupm3;
0135     const char *fw_name;
0136     struct rproc *rproc;
0137     struct resource *res;
0138     const __be32 *addrp;
0139     u32 l4_offset = 0;
0140     u64 size;
0141     int ret;
0142     int i;
0143
0144     ret = of_property_read_string(dev->of_node, "ti,pm-firmware",
0145                       &fw_name);
0146     if (ret) {
0147         dev_err(dev, "No firmware filename given\n");
0148         return -ENODEV;
0149     }
0150
0151     pm_runtime_enable(&pdev->dev);
0152     ret = pm_runtime_get_sync(&pdev->dev);
0153     if (ret < 0) {
0154         dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n");
0155         goto err;
0156     }
0157
0158     rproc = rproc_alloc(dev, "wkup_m3", &wkup_m3_rproc_ops,
0159                 fw_name, sizeof(*wkupm3));
0160     if (!rproc) {
0161         ret = -ENOMEM;
0162         goto err;
0163     }
0164
0165     rproc->auto_boot = false;
0166     rproc->sysfs_read_only = true;
0167
0168     wkupm3 = rproc->priv;
0169     wkupm3->rproc = rproc;
0170     wkupm3->pdev = pdev;
0171
0172     wkupm3->rsts = devm_reset_control_get_optional_shared(dev, "rstctrl");
0173     if (IS_ERR(wkupm3->rsts))
0174         return PTR_ERR(wkupm3->rsts);
0175     if (!wkupm3->rsts) {
0176         if (!(pdata && pdata->deassert_reset && pdata->assert_reset &&
0177               pdata->reset_name)) {
0178             dev_err(dev, "Platform data missing!\n");
0179             ret = -ENODEV;
0180             goto err_put_rproc;
0181         }
0182     }
0183
0184     for (i = 0; i < ARRAY_SIZE(mem_names); i++) {
0185         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
0186                            mem_names[i]);
0187         wkupm3->mem[i].cpu_addr = devm_ioremap_resource(dev, res);
0188         if (IS_ERR(wkupm3->mem[i].cpu_addr)) {
0189             dev_err(&pdev->dev, "devm_ioremap_resource failed for resource %d\n",
0190                 i);
0191             ret = PTR_ERR(wkupm3->mem[i].cpu_addr);
0192             goto err_put_rproc;
0193         }
0194         wkupm3->mem[i].bus_addr = res->start;
0195         wkupm3->mem[i].size = resource_size(res);
0196         addrp = of_get_address(dev->of_node, i, &size, NULL);
0197         /*
0198          * The wkupm3 has umem at address 0 in its view, so the device
0199          * addresses for each memory region is computed as a relative
0200          * offset of the bus address for umem, and therefore needs to be
0201          * processed first.
0202          */
0203         if (!strcmp(mem_names[i], "umem"))
0204             l4_offset = be32_to_cpu(*addrp);
0205         wkupm3->mem[i].dev_addr = be32_to_cpu(*addrp) - l4_offset;
0206     }
0207
0208     dev_set_drvdata(dev, rproc);
0209
0210     ret = rproc_add(rproc);
0211     if (ret) {
0212         dev_err(dev, "rproc_add failed\n");
0213         goto err_put_rproc;
0214     }
0215
0216     return 0;
0217
0218 err_put_rproc:
0219     rproc_free(rproc);
0220 err:
0221     pm_runtime_put_noidle(dev);
0222     pm_runtime_disable(dev);
0223     return ret;
0224 }
0225
0226 static int wkup_m3_rproc_remove(struct platform_device *pdev)
0227 {
0228     struct rproc *rproc = platform_get_drvdata(pdev);
0229
0230     rproc_del(rproc);
0231     rproc_free(rproc);
0232     pm_runtime_put_sync(&pdev->dev);
0233     pm_runtime_disable(&pdev->dev);
0234
0235     return 0;
0236 }
0237
0238 #ifdef CONFIG_PM
0239 static int wkup_m3_rpm_suspend(struct device *dev)
0240 {
0241     return -EBUSY;
0242 }
0243
0244 static int wkup_m3_rpm_resume(struct device *dev)
0245 {
0246     return 0;
0247 }
0248 #endif
0249
0250 static const struct dev_pm_ops wkup_m3_rproc_pm_ops = {
0251     SET_RUNTIME_PM_OPS(wkup_m3_rpm_suspend, wkup_m3_rpm_resume, NULL)
0252 };
0253
0254 static struct platform_driver wkup_m3_rproc_driver = {
0255     .probe = wkup_m3_rproc_probe,
0256     .remove = wkup_m3_rproc_remove,
0257     .driver = {
0258         .name = "wkup_m3_rproc",
0259         .of_match_table = wkup_m3_rproc_of_match,
0260         .pm = &wkup_m3_rproc_pm_ops,
0261     },
0262 };
0263
0264 module_platform_driver(wkup_m3_rproc_driver);
0265
0266 MODULE_LICENSE("GPL v2");
0267 MODULE_DESCRIPTION("TI Wakeup M3 remote processor control driver");
0268 MODULE_AUTHOR("Dave Gerlach <d-gerlach@ti.com>");