Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/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 #include <linux/omap-mailbox.h>
 31 
 32 #include <linux/platform_data/remoteproc-omap.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.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                 /* 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         struct device *dev = rproc->dev.parent;
 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)
101                 dev_err(dev, "omap_mbox_msg_send failed: %d\n", ret);
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;
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         /* 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);
128                 dev_err(dev, "omap_mbox_get failed: %d\n", ret);
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) {
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 
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 {
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 
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 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 
211 free_rproc:
212         rproc_put(rproc);
213         return ret;
214 }
215 
216 static 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 
226 static 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 
235 module_platform_driver(omap_rproc_driver);
236 
237 MODULE_LICENSE("GPL v2");
238 MODULE_DESCRIPTION("OMAP Remote Processor control driver");
239 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us