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