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/mailbox_client.h>
 31#include <linux/omap-mailbox.h>
 32
 33#include <linux/platform_data/remoteproc-omap.h>
 34
 35#include "omap_remoteproc.h"
 36#include "remoteproc_internal.h"
 37
 38/**
 39 * struct omap_rproc - omap remote processor state
 40 * @mbox: mailbox channel handle
 41 * @client: mailbox client to request the mailbox channel
 42 * @rproc: rproc handle
 43 */
 44struct omap_rproc {
 45	struct mbox_chan *mbox;
 46	struct mbox_client client;
 47	struct rproc *rproc;
 48};
 49
 50/**
 51 * omap_rproc_mbox_callback() - inbound mailbox message handler
 52 * @client: mailbox client pointer used for requesting the mailbox channel
 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 void omap_rproc_mbox_callback(struct mbox_client *client, void *data)
 65{
 66	struct omap_rproc *oproc = container_of(client, struct omap_rproc,
 67						client);
 68	struct device *dev = oproc->rproc->dev.parent;
 69	const char *name = oproc->rproc->name;
 70	u32 msg = (u32)data;
 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
 89/* kick a virtqueue */
 90static void omap_rproc_kick(struct rproc *rproc, int vqid)
 91{
 92	struct omap_rproc *oproc = rproc->priv;
 93	struct device *dev = rproc->dev.parent;
 94	int ret;
 95
 96	/* send the index of the triggered virtqueue in the mailbox payload */
 97	ret = mbox_send_message(oproc->mbox, (void *)vqid);
 98	if (ret < 0)
 99		dev_err(dev, "failed to send mailbox message, status = %d\n",
100			ret);
101}
102
103/*
104 * Power up the remote processor.
105 *
106 * This function will be invoked only after the firmware for this rproc
107 * was loaded, parsed successfully, and all of its resource requirements
108 * were met.
109 */
110static int omap_rproc_start(struct rproc *rproc)
111{
112	struct omap_rproc *oproc = rproc->priv;
113	struct device *dev = rproc->dev.parent;
114	struct platform_device *pdev = to_platform_device(dev);
115	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
116	int ret;
117	struct mbox_client *client = &oproc->client;
118
119	if (pdata->set_bootaddr)
120		pdata->set_bootaddr(rproc->bootaddr);
121
122	client->dev = dev;
123	client->tx_done = NULL;
124	client->rx_callback = omap_rproc_mbox_callback;
125	client->tx_block = false;
126	client->knows_txdone = false;
127
128	oproc->mbox = omap_mbox_request_channel(client, pdata->mbox_name);
129	if (IS_ERR(oproc->mbox)) {
130		ret = -EBUSY;
131		dev_err(dev, "mbox_request_channel failed: %ld\n",
132			PTR_ERR(oproc->mbox));
133		return ret;
134	}
135
136	/*
137	 * Ping the remote processor. this is only for sanity-sake;
138	 * there is no functional effect whatsoever.
139	 *
140	 * Note that the reply will _not_ arrive immediately: this message
141	 * will wait in the mailbox fifo until the remote processor is booted.
142	 */
143	ret = mbox_send_message(oproc->mbox, (void *)RP_MBOX_ECHO_REQUEST);
144	if (ret < 0) {
145		dev_err(dev, "mbox_send_message failed: %d\n", ret);
146		goto put_mbox;
147	}
148
149	ret = pdata->device_enable(pdev);
150	if (ret) {
151		dev_err(dev, "omap_device_enable failed: %d\n", ret);
152		goto put_mbox;
153	}
154
155	return 0;
156
157put_mbox:
158	mbox_free_channel(oproc->mbox);
159	return ret;
160}
161
162/* power off the remote processor */
163static int omap_rproc_stop(struct rproc *rproc)
164{
165	struct device *dev = rproc->dev.parent;
166	struct platform_device *pdev = to_platform_device(dev);
167	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
168	struct omap_rproc *oproc = rproc->priv;
169	int ret;
170
171	ret = pdata->device_shutdown(pdev);
172	if (ret)
173		return ret;
174
175	mbox_free_channel(oproc->mbox);
176
177	return 0;
178}
179
180static struct rproc_ops omap_rproc_ops = {
181	.start		= omap_rproc_start,
182	.stop		= omap_rproc_stop,
183	.kick		= omap_rproc_kick,
184};
185
186static int omap_rproc_probe(struct platform_device *pdev)
187{
188	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
189	struct omap_rproc *oproc;
190	struct rproc *rproc;
191	int ret;
192
193	ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
194	if (ret) {
195		dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret);
196		return ret;
197	}
198
199	rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops,
200			    pdata->firmware, sizeof(*oproc));
201	if (!rproc)
202		return -ENOMEM;
203
204	oproc = rproc->priv;
205	oproc->rproc = rproc;
206	/* All existing OMAP IPU and DSP processors have an MMU */
207	rproc->has_iommu = true;
208
209	platform_set_drvdata(pdev, rproc);
210
211	ret = rproc_add(rproc);
212	if (ret)
213		goto free_rproc;
214
215	return 0;
216
217free_rproc:
218	rproc_free(rproc);
219	return ret;
220}
221
222static int omap_rproc_remove(struct platform_device *pdev)
223{
224	struct rproc *rproc = platform_get_drvdata(pdev);
225
226	rproc_del(rproc);
227	rproc_free(rproc);
228
229	return 0;
230}
231
232static struct platform_driver omap_rproc_driver = {
233	.probe = omap_rproc_probe,
234	.remove = omap_rproc_remove,
235	.driver = {
236		.name = "omap-rproc",
237	},
238};
239
240module_platform_driver(omap_rproc_driver);
241
242MODULE_LICENSE("GPL v2");
243MODULE_DESCRIPTION("OMAP Remote Processor control driver");