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  */
44 struct 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  */
64 static 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 */
90 static 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  */
110 static 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 
157 put_mbox:
158 	mbox_free_channel(oproc->mbox);
159 	return ret;
160 }
161 
162 /* power off the remote processor */
163 static 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 
180 static const struct rproc_ops omap_rproc_ops = {
181 	.start		= omap_rproc_start,
182 	.stop		= omap_rproc_stop,
183 	.kick		= omap_rproc_kick,
184 };
185 
186 static 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 
217 free_rproc:
218 	rproc_free(rproc);
219 	return ret;
220 }
221 
222 static 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 
232 static 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 
240 module_platform_driver(omap_rproc_driver);
241 
242 MODULE_LICENSE("GPL v2");
243 MODULE_DESCRIPTION("OMAP Remote Processor control driver");
244