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 <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 __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) { 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 __devexit 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 = __devexit_p(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