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
31#include <plat/mailbox.h>
32#include <linux/platform_data/remoteproc-omap.h>
33
34#include "omap_remoteproc.h"
35#include "remoteproc_internal.h"
36
37
38
39
40
41
42
43struct omap_rproc {
44 struct omap_mbox *mbox;
45 struct notifier_block nb;
46 struct rproc *rproc;
47};
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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
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 return NOTIFY_DONE;
89}
90
91
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
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
106
107
108
109
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
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
134
135
136
137
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
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