[deliverable/linux.git] / drivers / remoteproc / omap_remoteproc.c

/*
 * OMAP Remote Processor driver
 *
 * Copyright (C) 2011 Texas Instruments, Inc.
 * Copyright (C) 2011 Google, Inc.
 *
 * Ohad Ben-Cohen <ohad@wizery.com>
 * Brian Swetland <swetland@google.com>
 * Fernando Guzman Lugo <fernando.lugo@ti.com>
 * Mark Grosen <mgrosen@ti.com>
 * Suman Anna <s-anna@ti.com>
 * Hari Kanigeri <h-kanigeri2@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/kernel.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/remoteproc.h>
#include <linux/mailbox_client.h>
#include <linux/omap-mailbox.h>

#include <linux/platform_data/remoteproc-omap.h>

#include "omap_remoteproc.h"
#include "remoteproc_internal.h"

/**
 * struct omap_rproc - omap remote processor state
 * @mbox: mailbox channel handle
 * @client: mailbox client to request the mailbox channel
 * @rproc: rproc handle
 */
struct omap_rproc {
	struct mbox_chan *mbox;
	struct mbox_client client;
	struct rproc *rproc;
};

/**
 * omap_rproc_mbox_callback() - inbound mailbox message handler
 * @client: mailbox client pointer used for requesting the mailbox channel
 * @data: mailbox payload
 *
 * This handler is invoked by omap's mailbox driver whenever a mailbox
 * message is received. Usually, the mailbox payload simply contains
 * the index of the virtqueue that is kicked by the remote processor,
 * and we let remoteproc core handle it.
 *
 * In addition to virtqueue indices, we also have some out-of-band values
 * that indicates different events. Those values are deliberately very
 * big so they don't coincide with virtqueue indices.
 */
static void omap_rproc_mbox_callback(struct mbox_client *client, void *data)
{
	struct omap_rproc *oproc = container_of(client, struct omap_rproc,
						client);
	struct device *dev = oproc->rproc->dev.parent;
	const char *name = oproc->rproc->name;
	u32 msg = (u32)data;

	dev_dbg(dev, "mbox msg: 0x%x\n", msg);

	switch (msg) {
	case RP_MBOX_CRASH:
		/* just log this for now. later, we'll also do recovery */
		dev_err(dev, "omap rproc %s crashed\n", name);
		break;
	case RP_MBOX_ECHO_REPLY:
		dev_info(dev, "received echo reply from %s\n", name);
		break;
	default:
		/* msg contains the index of the triggered vring */
		if (rproc_vq_interrupt(oproc->rproc, msg) == IRQ_NONE)
			dev_dbg(dev, "no message was found in vqid %d\n", msg);
	}
}

/* kick a virtqueue */
static void omap_rproc_kick(struct rproc *rproc, int vqid)
{
	struct omap_rproc *oproc = rproc->priv;
	struct device *dev = rproc->dev.parent;
	int ret;

	/* send the index of the triggered virtqueue in the mailbox payload */
	ret = mbox_send_message(oproc->mbox, (void *)vqid);
	if (ret < 0)
		dev_err(dev, "failed to send mailbox message, status = %d\n",
			ret);
}

/*
 * Power up the remote processor.
 *
 * This function will be invoked only after the firmware for this rproc
 * was loaded, parsed successfully, and all of its resource requirements
 * were met.
 */
static int omap_rproc_start(struct rproc *rproc)
{
	struct omap_rproc *oproc = rproc->priv;
	struct device *dev = rproc->dev.parent;
	struct platform_device *pdev = to_platform_device(dev);
	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
	int ret;
	struct mbox_client *client = &oproc->client;

	if (pdata->set_bootaddr)
		pdata->set_bootaddr(rproc->bootaddr);

	client->dev = dev;
	client->tx_done = NULL;
	client->rx_callback = omap_rproc_mbox_callback;
	client->tx_block = false;
	client->knows_txdone = false;

	oproc->mbox = omap_mbox_request_channel(client, pdata->mbox_name);
	if (IS_ERR(oproc->mbox)) {
		ret = -EBUSY;
		dev_err(dev, "mbox_request_channel failed: %ld\n",
			PTR_ERR(oproc->mbox));
		return ret;
	}

	/*
	 * Ping the remote processor. this is only for sanity-sake;
	 * there is no functional effect whatsoever.
	 *
	 * Note that the reply will _not_ arrive immediately: this message
	 * will wait in the mailbox fifo until the remote processor is booted.
	 */
	ret = mbox_send_message(oproc->mbox, (void *)RP_MBOX_ECHO_REQUEST);
	if (ret < 0) {
		dev_err(dev, "mbox_send_message failed: %d\n", ret);
		goto put_mbox;
	}

	ret = pdata->device_enable(pdev);
	if (ret) {
		dev_err(dev, "omap_device_enable failed: %d\n", ret);
		goto put_mbox;
	}

	return 0;

put_mbox:
	mbox_free_channel(oproc->mbox);
	return ret;
}

/* power off the remote processor */
static int omap_rproc_stop(struct rproc *rproc)
{
	struct device *dev = rproc->dev.parent;
	struct platform_device *pdev = to_platform_device(dev);
	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
	struct omap_rproc *oproc = rproc->priv;
	int ret;

	ret = pdata->device_shutdown(pdev);
	if (ret)
		return ret;

	mbox_free_channel(oproc->mbox);

	return 0;
}

static struct rproc_ops omap_rproc_ops = {
	.start		= omap_rproc_start,
	.stop		= omap_rproc_stop,
	.kick		= omap_rproc_kick,
};

static int omap_rproc_probe(struct platform_device *pdev)
{
	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
	struct omap_rproc *oproc;
	struct rproc *rproc;
	int ret;

	ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
	if (ret) {
		dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret);
		return ret;
	}

	rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops,
			    pdata->firmware, sizeof(*oproc));
	if (!rproc)
		return -ENOMEM;

	oproc = rproc->priv;
	oproc->rproc = rproc;
	/* All existing OMAP IPU and DSP processors have an MMU */
	rproc->has_iommu = true;

	platform_set_drvdata(pdev, rproc);

	ret = rproc_add(rproc);
	if (ret)
		goto free_rproc;

	return 0;

free_rproc:
	rproc_put(rproc);
	return ret;
}

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

	rproc_del(rproc);
	rproc_put(rproc);

	return 0;
}

static struct platform_driver omap_rproc_driver = {
	.probe = omap_rproc_probe,
	.remove = omap_rproc_remove,
	.driver = {
		.name = "omap-rproc",
	},
};

module_platform_driver(omap_rproc_driver);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("OMAP Remote Processor control driver");
Commit	Line	Data
34ed5a33 OBC	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>
8841a66a	30	#include <linux/mailbox_client.h>
c869c75c	31	#include <linux/omap-mailbox.h>
34ed5a33	32
2203747c	33	#include <linux/platform_data/remoteproc-omap.h>
34ed5a33 OBC	34
	35	#include "omap_remoteproc.h"
	36	#include "remoteproc_internal.h"
	37
	38	/**
	39	* struct omap_rproc - omap remote processor state
8841a66a SA	40	* @mbox: mailbox channel handle
8841a66a SA	41	* @client: mailbox client to request the mailbox channel
34ed5a33 OBC	42	* @rproc: rproc handle
	43	*/
	44	struct omap_rproc {
8841a66a SA	45	struct mbox_chan *mbox;
8841a66a SA	46	struct mbox_client client;
34ed5a33 OBC	47	struct rproc *rproc;
	48	};
	49
	50	/**
	51	* omap_rproc_mbox_callback() - inbound mailbox message handler
8841a66a	52	* @client: mailbox client pointer used for requesting the mailbox channel
34ed5a33 OBC	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	*/
8841a66a	64	static void omap_rproc_mbox_callback(struct mbox_client client, void data)
34ed5a33	65	{
8841a66a SA	66	struct omap_rproc *oproc = container_of(client, struct omap_rproc,
8841a66a SA	67	client);
b5ab5e24	68	struct device *dev = oproc->rproc->dev.parent;
34ed5a33	69	const char *name = oproc->rproc->name;
8841a66a	70	u32 msg = (u32)data;
34ed5a33 OBC	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:
55f34080	83	/* msg contains the index of the triggered vring */
34ed5a33 OBC	84	if (rproc_vq_interrupt(oproc->rproc, msg) == IRQ_NONE)
	85	dev_dbg(dev, "no message was found in vqid %d\n", msg);
	86	}
34ed5a33 OBC	87	}
	88
	89	/* kick a virtqueue */
	90	static void omap_rproc_kick(struct rproc *rproc, int vqid)
	91	{
	92	struct omap_rproc *oproc = rproc->priv;
b5ab5e24	93	struct device *dev = rproc->dev.parent;
34ed5a33 OBC	94	int ret;
	95
	96	/* send the index of the triggered virtqueue in the mailbox payload */
8841a66a SA	97	ret = mbox_send_message(oproc->mbox, (void *)vqid);
8841a66a SA	98	if (ret < 0)
14096c13 AS	99	dev_err(dev, "failed to send mailbox message, status = %d\n",
14096c13 AS	100	ret);
34ed5a33 OBC	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	*/
	110	static int omap_rproc_start(struct rproc *rproc)
	111	{
	112	struct omap_rproc *oproc = rproc->priv;
b5ab5e24 OBC	113	struct device *dev = rproc->dev.parent;
b5ab5e24 OBC	114	struct platform_device *pdev = to_platform_device(dev);
34ed5a33 OBC	115	struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
34ed5a33 OBC	116	int ret;
8841a66a	117	struct mbox_client *client = &oproc->client;
34ed5a33	118
4980f465 JG	119	if (pdata->set_bootaddr)
	120	pdata->set_bootaddr(rproc->bootaddr);
	121
8841a66a SA	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;
34ed5a33	127
8841a66a	128	oproc->mbox = omap_mbox_request_channel(client, pdata->mbox_name);
34ed5a33	129	if (IS_ERR(oproc->mbox)) {
8841a66a SA	130	ret = -EBUSY;
	131	dev_err(dev, "mbox_request_channel failed: %ld\n",
	132	PTR_ERR(oproc->mbox));
34ed5a33 OBC	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	*/
8841a66a SA	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);
34ed5a33 OBC	146	goto put_mbox;
	147	}
	148
	149	ret = pdata->device_enable(pdev);
	150	if (ret) {
b5ab5e24	151	dev_err(dev, "omap_device_enable failed: %d\n", ret);
34ed5a33 OBC	152	goto put_mbox;
	153	}
	154
	155	return 0;
	156
	157	put_mbox:
8841a66a	158	mbox_free_channel(oproc->mbox);
34ed5a33 OBC	159	return ret;
	160	}
	161
	162	/* power off the remote processor */
	163	static int omap_rproc_stop(struct rproc *rproc)
	164	{
b5ab5e24 OBC	165	struct device *dev = rproc->dev.parent;
b5ab5e24 OBC	166	struct platform_device *pdev = to_platform_device(dev);
34ed5a33 OBC	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
8841a66a	175	mbox_free_channel(oproc->mbox);
34ed5a33 OBC	176
	177	return 0;
	178	}
	179
	180	static struct rproc_ops omap_rproc_ops = {
	181	.start = omap_rproc_start,
	182	.stop = omap_rproc_stop,
	183	.kick = omap_rproc_kick,
	184	};
	185
0fe763c5	186	static int omap_rproc_probe(struct platform_device *pdev)
34ed5a33 OBC	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) {
6b039762	195	dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret);
34ed5a33 OBC	196	return ret;
	197	}
	198
	199	rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops,
334765f4	200	pdata->firmware, sizeof(*oproc));
34ed5a33 OBC	201	if (!rproc)
	202	return -ENOMEM;
	203
	204	oproc = rproc->priv;
	205	oproc->rproc = rproc;
315491e5 SA	206	/* All existing OMAP IPU and DSP processors have an MMU */
315491e5 SA	207	rproc->has_iommu = true;
34ed5a33 OBC	208
	209	platform_set_drvdata(pdev, rproc);
	210
160e7c84	211	ret = rproc_add(rproc);
34ed5a33 OBC	212	if (ret)
	213	goto free_rproc;
	214
	215	return 0;
	216
	217	free_rproc:
160e7c84	218	rproc_put(rproc);
34ed5a33 OBC	219	return ret;
	220	}
	221
0fe763c5	222	static int omap_rproc_remove(struct platform_device *pdev)
34ed5a33 OBC	223	{
	224	struct rproc *rproc = platform_get_drvdata(pdev);
	225
160e7c84 OBC	226	rproc_del(rproc);
160e7c84 OBC	227	rproc_put(rproc);
c6b5a276 OBC	228
c6b5a276 OBC	229	return 0;
34ed5a33 OBC	230	}
	231
	232	static struct platform_driver omap_rproc_driver = {
	233	.probe = omap_rproc_probe,
0fe763c5	234	.remove = omap_rproc_remove,
34ed5a33 OBC	235	.driver = {
34ed5a33 OBC	236	.name = "omap-rproc",
34ed5a33 OBC	237	},
	238	};
	239
63d667bf	240	module_platform_driver(omap_rproc_driver);
34ed5a33 OBC	241
	242	MODULE_LICENSE("GPL v2");
	243	MODULE_DESCRIPTION("OMAP Remote Processor control driver");