1/*
2 * OMAP Remote Processor driver
3 *
4 * Copyright (C) 2011 Texas Instruments, Inc.
5 * Copyright (C) 2011 Google, Inc.
6 *
7 * Ohad Ben-Cohen <ohad@wizery.com>
8 * Brian Swetland <swetland@google.com>
9 * Fernando Guzman Lugo <fernando.lugo@ti.com>
10 * Mark Grosen <mgrosen@ti.com>
11 * Suman Anna <s-anna@ti.com>
12 * Hari Kanigeri <h-kanigeri2@ti.com>
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * version 2 as published by the Free Software Foundation.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 * GNU General Public License for more details.
22 */
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <linux/err.h>
27#include <linux/platform_device.h>
28#include <linux/dma-mapping.h>
29#include <linux/remoteproc.h>
30#include <linux/omap-mailbox.h>
31
32#include <linux/platform_data/remoteproc-omap.h>
33
34#include "omap_remoteproc.h"
35#include "remoteproc_internal.h"
36
37/**
38 * struct omap_rproc - omap remote processor state
39 * @mbox: omap mailbox handle
40 * @nb: notifier block that will be invoked on inbound mailbox messages
41 * @rproc: rproc handle
42 */
43struct omap_rproc {
44	struct omap_mbox *mbox;
45	struct notifier_block nb;
46	struct rproc *rproc;
47};
48
49/**
50 * omap_rproc_mbox_callback() - inbound mailbox message handler
51 * @this: notifier block
52 * @index: unused
53 * @data: mailbox payload
54 *
55 * This handler is invoked by omap's mailbox driver whenever a mailbox
56 * message is received. Usually, the mailbox payload simply contains
57 * the index of the virtqueue that is kicked by the remote processor,
58 * and we let remoteproc core handle it.
59 *
60 * In addition to virtqueue indices, we also have some out-of-band values
61 * that indicates different events. Those values are deliberately very
62 * big so they don't coincide with virtqueue indices.
63 */
64static int omap_rproc_mbox_callback(struct notifier_block *this,
65					unsigned long index, void *data)
66{
67	mbox_msg_t msg = (mbox_msg_t) data;
68	struct omap_rproc *oproc = container_of(this, struct omap_rproc, nb);
69	struct device *dev = oproc->rproc->dev.parent;
70	const char *name = oproc->rproc->name;
71
72	dev_dbg(dev, "mbox msg: 0x%x\n", msg);
73
74	switch (msg) {
75	case RP_MBOX_CRASH:
76		/* just log this for now. later, we'll also do recovery */
77		dev_err(dev, "omap rproc %s crashed\n", name);
78		break;
79	case RP_MBOX_ECHO_REPLY:
80		dev_info(dev, "received echo reply from %s\n", name);
81		break;
82	default:
83		/* msg contains the index of the triggered vring */
84		if (rproc_vq_interrupt(oproc->rproc, msg) == IRQ_NONE)
85			dev_dbg(dev, "no message was found in vqid %d\n", msg);
86	}
87
88	return NOTIFY_DONE;
89}
90
91/* kick a virtqueue */
92static void omap_rproc_kick(struct rproc *rproc, int vqid)
93{
94	struct omap_rproc *oproc = rproc->priv;
95	struct device *dev = rproc->dev.parent;
96	int ret;
97
98	/* send the index of the triggered virtqueue in the mailbox payload */
99	ret = omap_mbox_msg_send(oproc->mbox, vqid);
100	if (ret)
101		dev_err(dev, "omap_mbox_msg_send failed: %d\n", ret);
102}
103
104/*
105 * Power up the remote processor.
106 *
107 * This function will be invoked only after the firmware for this rproc
108 * was loaded, parsed successfully, and all of its resource requirements
109 * were met.
110 */
111static int omap_rproc_start(struct rproc *rproc)
112{
113	struct omap_rproc *oproc = rproc->priv;
114	struct device *dev = rproc->dev.parent;
115	struct platform_device *pdev = to_platform_device(dev);
116	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
117	int ret;
118
119	if (pdata->set_bootaddr)
120		pdata->set_bootaddr(rproc->bootaddr);
121
122	oproc->nb.notifier_call = omap_rproc_mbox_callback;
123
124	/* every omap rproc is assigned a mailbox instance for messaging */
125	oproc->mbox = omap_mbox_get(pdata->mbox_name, &oproc->nb);
126	if (IS_ERR(oproc->mbox)) {
127		ret = PTR_ERR(oproc->mbox);
128		dev_err(dev, "omap_mbox_get failed: %d\n", ret);
129		return ret;
130	}
131
132	/*
133	 * Ping the remote processor. this is only for sanity-sake;
134	 * there is no functional effect whatsoever.
135	 *
136	 * Note that the reply will _not_ arrive immediately: this message
137	 * will wait in the mailbox fifo until the remote processor is booted.
138	 */
139	ret = omap_mbox_msg_send(oproc->mbox, RP_MBOX_ECHO_REQUEST);
140	if (ret) {
141		dev_err(dev, "omap_mbox_get failed: %d\n", ret);
142		goto put_mbox;
143	}
144
145	ret = pdata->device_enable(pdev);
146	if (ret) {
147		dev_err(dev, "omap_device_enable failed: %d\n", ret);
148		goto put_mbox;
149	}
150
151	return 0;
152
153put_mbox:
154	omap_mbox_put(oproc->mbox, &oproc->nb);
155	return ret;
156}
157
158/* power off the remote processor */
159static int omap_rproc_stop(struct rproc *rproc)
160{
161	struct device *dev = rproc->dev.parent;
162	struct platform_device *pdev = to_platform_device(dev);
163	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
164	struct omap_rproc *oproc = rproc->priv;
165	int ret;
166
167	ret = pdata->device_shutdown(pdev);
168	if (ret)
169		return ret;
170
171	omap_mbox_put(oproc->mbox, &oproc->nb);
172
173	return 0;
174}
175
176static struct rproc_ops omap_rproc_ops = {
177	.start		= omap_rproc_start,
178	.stop		= omap_rproc_stop,
179	.kick		= omap_rproc_kick,
180};
181
182static int omap_rproc_probe(struct platform_device *pdev)
183{
184	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
185	struct omap_rproc *oproc;
186	struct rproc *rproc;
187	int ret;
188
189	ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
190	if (ret) {
191		dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret);
192		return ret;
193	}
194
195	rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops,
196				pdata->firmware, sizeof(*oproc));
197	if (!rproc)
198		return -ENOMEM;
199
200	oproc = rproc->priv;
201	oproc->rproc = rproc;
202
203	platform_set_drvdata(pdev, rproc);
204
205	ret = rproc_add(rproc);
206	if (ret)
207		goto free_rproc;
208
209	return 0;
210
211free_rproc:
212	rproc_put(rproc);
213	return ret;
214}
215
216static int omap_rproc_remove(struct platform_device *pdev)
217{
218	struct rproc *rproc = platform_get_drvdata(pdev);
219
220	rproc_del(rproc);
221	rproc_put(rproc);
222
223	return 0;
224}
225
226static struct platform_driver omap_rproc_driver = {
227	.probe = omap_rproc_probe,
228	.remove = omap_rproc_remove,
229	.driver = {
230		.name = "omap-rproc",
231		.owner = THIS_MODULE,
232	},
233};
234
235module_platform_driver(omap_rproc_driver);
236
237MODULE_LICENSE("GPL v2");
238MODULE_DESCRIPTION("OMAP Remote Processor control driver");
239