1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * TI AMx3 Wakeup M3 Remote Processor driver 4 * 5 * Copyright (C) 2014-2015 Texas Instruments, Inc. 6 * 7 * Dave Gerlach <d-gerlach@ti.com> 8 * Suman Anna <s-anna@ti.com> 9 */ 10 11 #include <linux/err.h> 12 #include <linux/interrupt.h> 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/of_address.h> 17 #include <linux/platform_device.h> 18 #include <linux/pm_runtime.h> 19 #include <linux/remoteproc.h> 20 #include <linux/reset.h> 21 22 #include <linux/platform_data/wkup_m3.h> 23 24 #include "remoteproc_internal.h" 25 26 #define WKUPM3_MEM_MAX 2 27 28 /** 29 * struct wkup_m3_mem - WkupM3 internal memory structure 30 * @cpu_addr: MPU virtual address of the memory region 31 * @bus_addr: Bus address used to access the memory region 32 * @dev_addr: Device address from Wakeup M3 view 33 * @size: Size of the memory region 34 */ 35 struct wkup_m3_mem { 36 void __iomem *cpu_addr; 37 phys_addr_t bus_addr; 38 u32 dev_addr; 39 size_t size; 40 }; 41 42 /** 43 * struct wkup_m3_rproc - WkupM3 remote processor state 44 * @rproc: rproc handle 45 * @pdev: pointer to platform device 46 * @mem: WkupM3 memory information 47 * @rsts: reset control 48 */ 49 struct wkup_m3_rproc { 50 struct rproc *rproc; 51 struct platform_device *pdev; 52 struct wkup_m3_mem mem[WKUPM3_MEM_MAX]; 53 struct reset_control *rsts; 54 }; 55 56 static int wkup_m3_rproc_start(struct rproc *rproc) 57 { 58 struct wkup_m3_rproc *wkupm3 = rproc->priv; 59 struct platform_device *pdev = wkupm3->pdev; 60 struct device *dev = &pdev->dev; 61 struct wkup_m3_platform_data *pdata = dev_get_platdata(dev); 62 int error = 0; 63 64 error = reset_control_deassert(wkupm3->rsts); 65 66 if (!wkupm3->rsts && pdata->deassert_reset(pdev, pdata->reset_name)) { 67 dev_err(dev, "Unable to reset wkup_m3!\n"); 68 error = -ENODEV; 69 } 70 71 return error; 72 } 73 74 static int wkup_m3_rproc_stop(struct rproc *rproc) 75 { 76 struct wkup_m3_rproc *wkupm3 = rproc->priv; 77 struct platform_device *pdev = wkupm3->pdev; 78 struct device *dev = &pdev->dev; 79 struct wkup_m3_platform_data *pdata = dev_get_platdata(dev); 80 int error = 0; 81 82 error = reset_control_assert(wkupm3->rsts); 83 84 if (!wkupm3->rsts && pdata->assert_reset(pdev, pdata->reset_name)) { 85 dev_err(dev, "Unable to assert reset of wkup_m3!\n"); 86 error = -ENODEV; 87 } 88 89 return error; 90 } 91 92 static void *wkup_m3_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem) 93 { 94 struct wkup_m3_rproc *wkupm3 = rproc->priv; 95 void *va = NULL; 96 int i; 97 u32 offset; 98 99 if (len == 0) 100 return NULL; 101 102 for (i = 0; i < WKUPM3_MEM_MAX; i++) { 103 if (da >= wkupm3->mem[i].dev_addr && da + len <= 104 wkupm3->mem[i].dev_addr + wkupm3->mem[i].size) { 105 offset = da - wkupm3->mem[i].dev_addr; 106 /* __force to make sparse happy with type conversion */ 107 va = (__force void *)(wkupm3->mem[i].cpu_addr + offset); 108 break; 109 } 110 } 111 112 return va; 113 } 114 115 static const struct rproc_ops wkup_m3_rproc_ops = { 116 .start = wkup_m3_rproc_start, 117 .stop = wkup_m3_rproc_stop, 118 .da_to_va = wkup_m3_rproc_da_to_va, 119 }; 120 121 static const struct of_device_id wkup_m3_rproc_of_match[] = { 122 { .compatible = "ti,am3352-wkup-m3", }, 123 { .compatible = "ti,am4372-wkup-m3", }, 124 {}, 125 }; 126 MODULE_DEVICE_TABLE(of, wkup_m3_rproc_of_match); 127 128 static void wkup_m3_rproc_pm_runtime_put(void *data) 129 { 130 struct device *dev = data; 131 132 pm_runtime_put_sync(dev); 133 } 134 135 static int wkup_m3_rproc_probe(struct platform_device *pdev) 136 { 137 struct device *dev = &pdev->dev; 138 struct wkup_m3_platform_data *pdata = dev->platform_data; 139 /* umem always needs to be processed first */ 140 const char *mem_names[WKUPM3_MEM_MAX] = { "umem", "dmem" }; 141 struct wkup_m3_rproc *wkupm3; 142 const char *fw_name; 143 struct rproc *rproc; 144 struct resource *res; 145 const __be32 *addrp; 146 u32 l4_offset = 0; 147 u64 size; 148 int ret; 149 int i; 150 151 ret = of_property_read_string(dev->of_node, "ti,pm-firmware", 152 &fw_name); 153 if (ret) { 154 dev_err(dev, "No firmware filename given\n"); 155 return -ENODEV; 156 } 157 158 ret = devm_pm_runtime_enable(dev); 159 if (ret < 0) 160 return dev_err_probe(dev, ret, "Failed to enable runtime PM\n"); 161 ret = pm_runtime_get_sync(&pdev->dev); 162 if (ret < 0) 163 return dev_err_probe(dev, ret, "pm_runtime_get_sync() failed\n"); 164 ret = devm_add_action_or_reset(dev, wkup_m3_rproc_pm_runtime_put, dev); 165 if (ret) 166 return dev_err_probe(dev, ret, "failed to add disable pm devm action\n"); 167 168 rproc = devm_rproc_alloc(dev, "wkup_m3", &wkup_m3_rproc_ops, 169 fw_name, sizeof(*wkupm3)); 170 if (!rproc) 171 return -ENOMEM; 172 173 rproc->auto_boot = false; 174 rproc->sysfs_read_only = true; 175 176 wkupm3 = rproc->priv; 177 wkupm3->rproc = rproc; 178 wkupm3->pdev = pdev; 179 180 wkupm3->rsts = devm_reset_control_get_optional_shared(dev, "rstctrl"); 181 if (IS_ERR(wkupm3->rsts)) 182 return PTR_ERR(wkupm3->rsts); 183 if (!wkupm3->rsts) { 184 if (!(pdata && pdata->deassert_reset && pdata->assert_reset && 185 pdata->reset_name)) { 186 return dev_err_probe(dev, -ENODEV, "Platform data missing!\n"); 187 } 188 } 189 190 for (i = 0; i < ARRAY_SIZE(mem_names); i++) { 191 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, 192 mem_names[i]); 193 wkupm3->mem[i].cpu_addr = devm_ioremap_resource(dev, res); 194 if (IS_ERR(wkupm3->mem[i].cpu_addr)) 195 return dev_err_probe(dev, PTR_ERR(wkupm3->mem[i].cpu_addr), 196 "devm_ioremap_resource failed for resource %d\n", i); 197 wkupm3->mem[i].bus_addr = res->start; 198 wkupm3->mem[i].size = resource_size(res); 199 addrp = of_get_address(dev->of_node, i, &size, NULL); 200 /* 201 * The wkupm3 has umem at address 0 in its view, so the device 202 * addresses for each memory region is computed as a relative 203 * offset of the bus address for umem, and therefore needs to be 204 * processed first. 205 */ 206 if (!strcmp(mem_names[i], "umem")) 207 l4_offset = be32_to_cpu(*addrp); 208 wkupm3->mem[i].dev_addr = be32_to_cpu(*addrp) - l4_offset; 209 } 210 211 dev_set_drvdata(dev, rproc); 212 213 ret = devm_rproc_add(dev, rproc); 214 if (ret) 215 return dev_err_probe(dev, ret, "rproc_add failed\n"); 216 217 return 0; 218 } 219 220 #ifdef CONFIG_PM 221 static int wkup_m3_rpm_suspend(struct device *dev) 222 { 223 return -EBUSY; 224 } 225 226 static int wkup_m3_rpm_resume(struct device *dev) 227 { 228 return 0; 229 } 230 #endif 231 232 static const struct dev_pm_ops wkup_m3_rproc_pm_ops = { 233 SET_RUNTIME_PM_OPS(wkup_m3_rpm_suspend, wkup_m3_rpm_resume, NULL) 234 }; 235 236 static struct platform_driver wkup_m3_rproc_driver = { 237 .probe = wkup_m3_rproc_probe, 238 .driver = { 239 .name = "wkup_m3_rproc", 240 .of_match_table = wkup_m3_rproc_of_match, 241 .pm = &wkup_m3_rproc_pm_ops, 242 }, 243 }; 244 245 module_platform_driver(wkup_m3_rproc_driver); 246 247 MODULE_LICENSE("GPL v2"); 248 MODULE_DESCRIPTION("TI Wakeup M3 remote processor control driver"); 249 MODULE_AUTHOR("Dave Gerlach <d-gerlach@ti.com>"); 250