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> | |
32 | #include <plat/remoteproc.h> | |
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 | ||
119 | oproc->nb.notifier_call = omap_rproc_mbox_callback; | |
120 | ||
121 | /* every omap rproc is assigned a mailbox instance for messaging */ | |
122 | oproc->mbox = omap_mbox_get(pdata->mbox_name, &oproc->nb); | |
123 | if (IS_ERR(oproc->mbox)) { | |
124 | ret = PTR_ERR(oproc->mbox); | |
b5ab5e24 | 125 | dev_err(dev, "omap_mbox_get failed: %d\n", ret); |
34ed5a33 OBC |
126 | return ret; |
127 | } | |
128 | ||
129 | /* | |
130 | * Ping the remote processor. this is only for sanity-sake; | |
131 | * there is no functional effect whatsoever. | |
132 | * | |
133 | * Note that the reply will _not_ arrive immediately: this message | |
134 | * will wait in the mailbox fifo until the remote processor is booted. | |
135 | */ | |
136 | ret = omap_mbox_msg_send(oproc->mbox, RP_MBOX_ECHO_REQUEST); | |
137 | if (ret) { | |
b5ab5e24 | 138 | dev_err(dev, "omap_mbox_get failed: %d\n", ret); |
34ed5a33 OBC |
139 | goto put_mbox; |
140 | } | |
141 | ||
142 | ret = pdata->device_enable(pdev); | |
143 | if (ret) { | |
b5ab5e24 | 144 | dev_err(dev, "omap_device_enable failed: %d\n", ret); |
34ed5a33 OBC |
145 | goto put_mbox; |
146 | } | |
147 | ||
148 | return 0; | |
149 | ||
150 | put_mbox: | |
151 | omap_mbox_put(oproc->mbox, &oproc->nb); | |
152 | return ret; | |
153 | } | |
154 | ||
155 | /* power off the remote processor */ | |
156 | static int omap_rproc_stop(struct rproc *rproc) | |
157 | { | |
b5ab5e24 OBC |
158 | struct device *dev = rproc->dev.parent; |
159 | struct platform_device *pdev = to_platform_device(dev); | |
34ed5a33 OBC |
160 | struct omap_rproc_pdata *pdata = pdev->dev.platform_data; |
161 | struct omap_rproc *oproc = rproc->priv; | |
162 | int ret; | |
163 | ||
164 | ret = pdata->device_shutdown(pdev); | |
165 | if (ret) | |
166 | return ret; | |
167 | ||
168 | omap_mbox_put(oproc->mbox, &oproc->nb); | |
169 | ||
170 | return 0; | |
171 | } | |
172 | ||
173 | static struct rproc_ops omap_rproc_ops = { | |
174 | .start = omap_rproc_start, | |
175 | .stop = omap_rproc_stop, | |
176 | .kick = omap_rproc_kick, | |
177 | }; | |
178 | ||
179 | static int __devinit omap_rproc_probe(struct platform_device *pdev) | |
180 | { | |
181 | struct omap_rproc_pdata *pdata = pdev->dev.platform_data; | |
182 | struct omap_rproc *oproc; | |
183 | struct rproc *rproc; | |
184 | int ret; | |
185 | ||
186 | ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); | |
187 | if (ret) { | |
188 | dev_err(pdev->dev.parent, "dma_set_coherent_mask: %d\n", ret); | |
189 | return ret; | |
190 | } | |
191 | ||
192 | rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops, | |
193 | pdata->firmware, sizeof(*oproc)); | |
194 | if (!rproc) | |
195 | return -ENOMEM; | |
196 | ||
197 | oproc = rproc->priv; | |
198 | oproc->rproc = rproc; | |
199 | ||
200 | platform_set_drvdata(pdev, rproc); | |
201 | ||
202 | ret = rproc_register(rproc); | |
203 | if (ret) | |
204 | goto free_rproc; | |
205 | ||
206 | return 0; | |
207 | ||
208 | free_rproc: | |
209 | rproc_free(rproc); | |
210 | return ret; | |
211 | } | |
212 | ||
213 | static int __devexit omap_rproc_remove(struct platform_device *pdev) | |
214 | { | |
215 | struct rproc *rproc = platform_get_drvdata(pdev); | |
216 | ||
217 | return rproc_unregister(rproc); | |
218 | } | |
219 | ||
220 | static struct platform_driver omap_rproc_driver = { | |
221 | .probe = omap_rproc_probe, | |
222 | .remove = __devexit_p(omap_rproc_remove), | |
223 | .driver = { | |
224 | .name = "omap-rproc", | |
225 | .owner = THIS_MODULE, | |
226 | }, | |
227 | }; | |
228 | ||
63d667bf | 229 | module_platform_driver(omap_rproc_driver); |
34ed5a33 OBC |
230 | |
231 | MODULE_LICENSE("GPL v2"); | |
232 | MODULE_DESCRIPTION("OMAP Remote Processor control driver"); |