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> | |
30 | ||
31 | #include <plat/mailbox.h> | |
2203747c | 32 | #include <linux/platform_data/remoteproc-omap.h> |
34ed5a33 OBC |
33 | |
34 | #include "omap_remoteproc.h" | |
35 | #include "remoteproc_internal.h" | |
36 | ||
37 | /** | |
38 | * struct omap_rproc - omap remote processor state | |
39 | * @mbox: omap mailbox handle | |
40 | * @nb: notifier block that will be invoked on inbound mailbox messages | |
41 | * @rproc: rproc handle | |
42 | */ | |
43 | struct omap_rproc { | |
44 | struct omap_mbox *mbox; | |
45 | struct notifier_block nb; | |
46 | struct rproc *rproc; | |
47 | }; | |
48 | ||
49 | /** | |
50 | * omap_rproc_mbox_callback() - inbound mailbox message handler | |
51 | * @this: notifier block | |
52 | * @index: unused | |
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 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); | |
b5ab5e24 | 69 | struct device *dev = oproc->rproc->dev.parent; |
34ed5a33 OBC |
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 | /* 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 | } | |
87 | ||
88 | return NOTIFY_DONE; | |
89 | } | |
90 | ||
91 | /* kick a virtqueue */ | |
92 | static void omap_rproc_kick(struct rproc *rproc, int vqid) | |
93 | { | |
94 | struct omap_rproc *oproc = rproc->priv; | |
b5ab5e24 | 95 | struct device *dev = rproc->dev.parent; |
34ed5a33 OBC |
96 | int ret; |
97 | ||
98 | /* send the index of the triggered virtqueue in the mailbox payload */ | |
99 | ret = omap_mbox_msg_send(oproc->mbox, vqid); | |
100 | if (ret) | |
b5ab5e24 | 101 | dev_err(dev, "omap_mbox_msg_send failed: %d\n", ret); |
34ed5a33 OBC |
102 | } |
103 | ||
104 | /* | |
105 | * Power up the remote processor. | |
106 | * | |
107 | * This function will be invoked only after the firmware for this rproc | |
108 | * was loaded, parsed successfully, and all of its resource requirements | |
109 | * were met. | |
110 | */ | |
111 | static int omap_rproc_start(struct rproc *rproc) | |
112 | { | |
113 | struct omap_rproc *oproc = rproc->priv; | |
b5ab5e24 OBC |
114 | struct device *dev = rproc->dev.parent; |
115 | struct platform_device *pdev = to_platform_device(dev); | |
34ed5a33 OBC |
116 | struct omap_rproc_pdata *pdata = pdev->dev.platform_data; |
117 | int ret; | |
118 | ||
4980f465 JG |
119 | if (pdata->set_bootaddr) |
120 | pdata->set_bootaddr(rproc->bootaddr); | |
121 | ||
34ed5a33 OBC |
122 | oproc->nb.notifier_call = omap_rproc_mbox_callback; |
123 | ||
124 | /* every omap rproc is assigned a mailbox instance for messaging */ | |
125 | oproc->mbox = omap_mbox_get(pdata->mbox_name, &oproc->nb); | |
126 | if (IS_ERR(oproc->mbox)) { | |
127 | ret = PTR_ERR(oproc->mbox); | |
b5ab5e24 | 128 | dev_err(dev, "omap_mbox_get failed: %d\n", ret); |
34ed5a33 OBC |
129 | return ret; |
130 | } | |
131 | ||
132 | /* | |
133 | * Ping the remote processor. this is only for sanity-sake; | |
134 | * there is no functional effect whatsoever. | |
135 | * | |
136 | * Note that the reply will _not_ arrive immediately: this message | |
137 | * will wait in the mailbox fifo until the remote processor is booted. | |
138 | */ | |
139 | ret = omap_mbox_msg_send(oproc->mbox, RP_MBOX_ECHO_REQUEST); | |
140 | if (ret) { | |
b5ab5e24 | 141 | dev_err(dev, "omap_mbox_get failed: %d\n", ret); |
34ed5a33 OBC |
142 | goto put_mbox; |
143 | } | |
144 | ||
145 | ret = pdata->device_enable(pdev); | |
146 | if (ret) { | |
b5ab5e24 | 147 | dev_err(dev, "omap_device_enable failed: %d\n", ret); |
34ed5a33 OBC |
148 | goto put_mbox; |
149 | } | |
150 | ||
151 | return 0; | |
152 | ||
153 | put_mbox: | |
154 | omap_mbox_put(oproc->mbox, &oproc->nb); | |
155 | return ret; | |
156 | } | |
157 | ||
158 | /* power off the remote processor */ | |
159 | static int omap_rproc_stop(struct rproc *rproc) | |
160 | { | |
b5ab5e24 OBC |
161 | struct device *dev = rproc->dev.parent; |
162 | struct platform_device *pdev = to_platform_device(dev); | |
34ed5a33 OBC |
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 | ||
176 | static struct rproc_ops omap_rproc_ops = { | |
177 | .start = omap_rproc_start, | |
178 | .stop = omap_rproc_stop, | |
179 | .kick = omap_rproc_kick, | |
180 | }; | |
181 | ||
182 | static int __devinit 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) { | |
6b039762 | 191 | dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret); |
34ed5a33 OBC |
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 | ||
160e7c84 | 205 | ret = rproc_add(rproc); |
34ed5a33 OBC |
206 | if (ret) |
207 | goto free_rproc; | |
208 | ||
209 | return 0; | |
210 | ||
211 | free_rproc: | |
160e7c84 | 212 | rproc_put(rproc); |
34ed5a33 OBC |
213 | return ret; |
214 | } | |
215 | ||
216 | static int __devexit omap_rproc_remove(struct platform_device *pdev) | |
217 | { | |
218 | struct rproc *rproc = platform_get_drvdata(pdev); | |
219 | ||
160e7c84 OBC |
220 | rproc_del(rproc); |
221 | rproc_put(rproc); | |
c6b5a276 OBC |
222 | |
223 | return 0; | |
34ed5a33 OBC |
224 | } |
225 | ||
226 | static struct platform_driver omap_rproc_driver = { | |
227 | .probe = omap_rproc_probe, | |
228 | .remove = __devexit_p(omap_rproc_remove), | |
229 | .driver = { | |
230 | .name = "omap-rproc", | |
231 | .owner = THIS_MODULE, | |
232 | }, | |
233 | }; | |
234 | ||
63d667bf | 235 | module_platform_driver(omap_rproc_driver); |
34ed5a33 OBC |
236 | |
237 | MODULE_LICENSE("GPL v2"); | |
238 | MODULE_DESCRIPTION("OMAP Remote Processor control driver"); |