1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
40
41
42
43
44struct omap_rproc {
45 struct mbox_chan *mbox;
46 struct mbox_client client;
47 struct rproc *rproc;
48};
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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
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
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
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
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
105
106
107
108
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
138
139
140
141
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
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
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");
244