remoteproc: fix print format warnings
[linux-3.10.git] / drivers / remoteproc / omap_remoteproc.c
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:
83                 /* msg contains the index of the triggered vring */
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
226 module_platform_driver(omap_rproc_driver);
227
228 MODULE_LICENSE("GPL v2");
229 MODULE_DESCRIPTION("OMAP Remote Processor control driver");