[linux-2.6-block.git] / drivers / remoteproc / wkup_m3_rproc.c

/*
 * TI AMx3 Wakeup M3 Remote Processor driver
 *
 * Copyright (C) 2014-2015 Texas Instruments, Inc.
 *
 * Dave Gerlach <d-gerlach@ti.com>
 * Suman Anna <s-anna@ti.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/remoteproc.h>

#include <linux/platform_data/wkup_m3.h>

#include "remoteproc_internal.h"

#define WKUPM3_MEM_MAX	2

/**
 * struct wkup_m3_mem - WkupM3 internal memory structure
 * @cpu_addr: MPU virtual address of the memory region
 * @bus_addr: Bus address used to access the memory region
 * @dev_addr: Device address from Wakeup M3 view
 * @size: Size of the memory region
 */
struct wkup_m3_mem {
	void __iomem *cpu_addr;
	phys_addr_t bus_addr;
	u32 dev_addr;
	size_t size;
};

/**
 * struct wkup_m3_rproc - WkupM3 remote processor state
 * @rproc: rproc handle
 * @pdev: pointer to platform device
 * @mem: WkupM3 memory information
 */
struct wkup_m3_rproc {
	struct rproc *rproc;
	struct platform_device *pdev;
	struct wkup_m3_mem mem[WKUPM3_MEM_MAX];
};

static int wkup_m3_rproc_start(struct rproc *rproc)
{
	struct wkup_m3_rproc *wkupm3 = rproc->priv;
	struct platform_device *pdev = wkupm3->pdev;
	struct device *dev = &pdev->dev;
	struct wkup_m3_platform_data *pdata = dev_get_platdata(dev);

	if (pdata->deassert_reset(pdev, pdata->reset_name)) {
		dev_err(dev, "Unable to reset wkup_m3!\n");
		return -ENODEV;
	}

	return 0;
}

static int wkup_m3_rproc_stop(struct rproc *rproc)
{
	struct wkup_m3_rproc *wkupm3 = rproc->priv;
	struct platform_device *pdev = wkupm3->pdev;
	struct device *dev = &pdev->dev;
	struct wkup_m3_platform_data *pdata = dev_get_platdata(dev);

	if (pdata->assert_reset(pdev, pdata->reset_name)) {
		dev_err(dev, "Unable to assert reset of wkup_m3!\n");
		return -ENODEV;
	}

	return 0;
}

static void *wkup_m3_rproc_da_to_va(struct rproc *rproc, u64 da, int len)
{
	struct wkup_m3_rproc *wkupm3 = rproc->priv;
	void *va = NULL;
	int i;
	u32 offset;

	if (len <= 0)
		return NULL;

	for (i = 0; i < WKUPM3_MEM_MAX; i++) {
		if (da >= wkupm3->mem[i].dev_addr && da + len <=
		    wkupm3->mem[i].dev_addr +  wkupm3->mem[i].size) {
			offset = da -  wkupm3->mem[i].dev_addr;
			/* __force to make sparse happy with type conversion */
			va = (__force void *)(wkupm3->mem[i].cpu_addr + offset);
			break;
		}
	}

	return va;
}

static struct rproc_ops wkup_m3_rproc_ops = {
	.start		= wkup_m3_rproc_start,
	.stop		= wkup_m3_rproc_stop,
	.da_to_va	= wkup_m3_rproc_da_to_va,
};

static const struct of_device_id wkup_m3_rproc_of_match[] = {
	{ .compatible = "ti,am3352-wkup-m3", },
	{ .compatible = "ti,am4372-wkup-m3", },
	{},
};

static int wkup_m3_rproc_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct wkup_m3_platform_data *pdata = dev->platform_data;
	/* umem always needs to be processed first */
	const char *mem_names[WKUPM3_MEM_MAX] = { "umem", "dmem" };
	struct wkup_m3_rproc *wkupm3;
	const char *fw_name;
	struct rproc *rproc;
	struct resource *res;
	const __be32 *addrp;
	u32 l4_offset = 0;
	u64 size;
	int ret;
	int i;

	if (!(pdata && pdata->deassert_reset && pdata->assert_reset &&
	      pdata->reset_name)) {
		dev_err(dev, "Platform data missing!\n");
		return -ENODEV;
	}

	ret = of_property_read_string(dev->of_node, "ti,pm-firmware",
				      &fw_name);
	if (ret) {
		dev_err(dev, "No firmware filename given\n");
		return -ENODEV;
	}

	pm_runtime_enable(&pdev->dev);
	ret = pm_runtime_get_sync(&pdev->dev);
	if (ret < 0) {
		dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n");
		goto err;
	}

	rproc = rproc_alloc(dev, "wkup_m3", &wkup_m3_rproc_ops,
			    fw_name, sizeof(*wkupm3));
	if (!rproc) {
		ret = -ENOMEM;
		goto err;
	}

	wkupm3 = rproc->priv;
	wkupm3->rproc = rproc;
	wkupm3->pdev = pdev;

	for (i = 0; i < ARRAY_SIZE(mem_names); i++) {
		res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
						   mem_names[i]);
		wkupm3->mem[i].cpu_addr = devm_ioremap_resource(dev, res);
		if (IS_ERR(wkupm3->mem[i].cpu_addr)) {
			dev_err(&pdev->dev, "devm_ioremap_resource failed for resource %d\n",
				i);
			ret = PTR_ERR(wkupm3->mem[i].cpu_addr);
			goto err;
		}
		wkupm3->mem[i].bus_addr = res->start;
		wkupm3->mem[i].size = resource_size(res);
		addrp = of_get_address(dev->of_node, i, &size, NULL);
		/*
		 * The wkupm3 has umem at address 0 in its view, so the device
		 * addresses for each memory region is computed as a relative
		 * offset of the bus address for umem, and therefore needs to be
		 * processed first.
		 */
		if (!strcmp(mem_names[i], "umem"))
			l4_offset = be32_to_cpu(*addrp);
		wkupm3->mem[i].dev_addr = be32_to_cpu(*addrp) - l4_offset;
	}

	dev_set_drvdata(dev, rproc);

	ret = rproc_add(rproc);
	if (ret) {
		dev_err(dev, "rproc_add failed\n");
		goto err_put_rproc;
	}

	return 0;

err_put_rproc:
	rproc_put(rproc);
err:
	pm_runtime_put_noidle(dev);
	pm_runtime_disable(dev);
	return ret;
}

static int wkup_m3_rproc_remove(struct platform_device *pdev)
{
	struct rproc *rproc = platform_get_drvdata(pdev);

	rproc_del(rproc);
	rproc_put(rproc);
	pm_runtime_put_sync(&pdev->dev);
	pm_runtime_disable(&pdev->dev);

	return 0;
}

#ifdef CONFIG_PM
static int wkup_m3_rpm_suspend(struct device *dev)
{
	return -EBUSY;
}

static int wkup_m3_rpm_resume(struct device *dev)
{
	return 0;
}
#endif

static const struct dev_pm_ops wkup_m3_rproc_pm_ops = {
	SET_RUNTIME_PM_OPS(wkup_m3_rpm_suspend, wkup_m3_rpm_resume, NULL)
};

static struct platform_driver wkup_m3_rproc_driver = {
	.probe = wkup_m3_rproc_probe,
	.remove = wkup_m3_rproc_remove,
	.driver = {
		.name = "wkup_m3_rproc",
		.of_match_table = wkup_m3_rproc_of_match,
		.pm = &wkup_m3_rproc_pm_ops,
	},
};

module_platform_driver(wkup_m3_rproc_driver);

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