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/mailbox_client.h> 31 #include <linux/omap-mailbox.h> 32 33 #include <linux/platform_data/remoteproc-omap.h> 34 35 #include "omap_remoteproc.h" 36 #include "remoteproc_internal.h" 37 38 /** 39 * struct omap_rproc - omap remote processor state 40 * @mbox: mailbox channel handle 41 * @client: mailbox client to request the mailbox channel 42 * @rproc: rproc handle 43 */ 44 struct omap_rproc { 45 struct mbox_chan *mbox; 46 struct mbox_client client; 47 struct rproc *rproc; 48 }; 49 50 /** 51 * omap_rproc_mbox_callback() - inbound mailbox message handler 52 * @client: mailbox client pointer used for requesting the mailbox channel 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 void omap_rproc_mbox_callback(struct mbox_client *client, void *data) 65 { 66 struct omap_rproc *oproc = container_of(client, struct omap_rproc, 67 client); 68 struct device *dev = oproc->rproc->dev.parent; 69 const char *name = oproc->rproc->name; 70 u32 msg = (u32)data; 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 89 /* kick a virtqueue */ 90 static void omap_rproc_kick(struct rproc *rproc, int vqid) 91 { 92 struct omap_rproc *oproc = rproc->priv; 93 struct device *dev = rproc->dev.parent; 94 int ret; 95 96 /* send the index of the triggered virtqueue in the mailbox payload */ 97 ret = mbox_send_message(oproc->mbox, (void *)vqid); 98 if (ret < 0) 99 dev_err(dev, "failed to send mailbox message, status = %d\n", 100 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 device *dev = rproc->dev.parent; 114 struct platform_device *pdev = to_platform_device(dev); 115 struct omap_rproc_pdata *pdata = pdev->dev.platform_data; 116 int ret; 117 struct mbox_client *client = &oproc->client; 118 119 if (pdata->set_bootaddr) 120 pdata->set_bootaddr(rproc->bootaddr); 121 122 client->dev = dev; 123 client->tx_done = NULL; 124 client->rx_callback = omap_rproc_mbox_callback; 125 client->tx_block = false; 126 client->knows_txdone = false; 127 128 oproc->mbox = omap_mbox_request_channel(client, pdata->mbox_name); 129 if (IS_ERR(oproc->mbox)) { 130 ret = -EBUSY; 131 dev_err(dev, "mbox_request_channel failed: %ld\n", 132 PTR_ERR(oproc->mbox)); 133 return ret; 134 } 135 136 /* 137 * Ping the remote processor. this is only for sanity-sake; 138 * there is no functional effect whatsoever. 139 * 140 * Note that the reply will _not_ arrive immediately: this message 141 * will wait in the mailbox fifo until the remote processor is booted. 142 */ 143 ret = mbox_send_message(oproc->mbox, (void *)RP_MBOX_ECHO_REQUEST); 144 if (ret < 0) { 145 dev_err(dev, "mbox_send_message failed: %d\n", ret); 146 goto put_mbox; 147 } 148 149 ret = pdata->device_enable(pdev); 150 if (ret) { 151 dev_err(dev, "omap_device_enable failed: %d\n", ret); 152 goto put_mbox; 153 } 154 155 return 0; 156 157 put_mbox: 158 mbox_free_channel(oproc->mbox); 159 return ret; 160 } 161 162 /* power off the remote processor */ 163 static int omap_rproc_stop(struct rproc *rproc) 164 { 165 struct device *dev = rproc->dev.parent; 166 struct platform_device *pdev = to_platform_device(dev); 167 struct omap_rproc_pdata *pdata = pdev->dev.platform_data; 168 struct omap_rproc *oproc = rproc->priv; 169 int ret; 170 171 ret = pdata->device_shutdown(pdev); 172 if (ret) 173 return ret; 174 175 mbox_free_channel(oproc->mbox); 176 177 return 0; 178 } 179 180 static const struct rproc_ops omap_rproc_ops = { 181 .start = omap_rproc_start, 182 .stop = omap_rproc_stop, 183 .kick = omap_rproc_kick, 184 }; 185 186 static int omap_rproc_probe(struct platform_device *pdev) 187 { 188 struct omap_rproc_pdata *pdata = pdev->dev.platform_data; 189 struct omap_rproc *oproc; 190 struct rproc *rproc; 191 int ret; 192 193 ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); 194 if (ret) { 195 dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret); 196 return ret; 197 } 198 199 rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops, 200 pdata->firmware, sizeof(*oproc)); 201 if (!rproc) 202 return -ENOMEM; 203 204 oproc = rproc->priv; 205 oproc->rproc = rproc; 206 /* All existing OMAP IPU and DSP processors have an MMU */ 207 rproc->has_iommu = true; 208 209 platform_set_drvdata(pdev, rproc); 210 211 ret = rproc_add(rproc); 212 if (ret) 213 goto free_rproc; 214 215 return 0; 216 217 free_rproc: 218 rproc_free(rproc); 219 return ret; 220 } 221 222 static int omap_rproc_remove(struct platform_device *pdev) 223 { 224 struct rproc *rproc = platform_get_drvdata(pdev); 225 226 rproc_del(rproc); 227 rproc_free(rproc); 228 229 return 0; 230 } 231 232 static struct platform_driver omap_rproc_driver = { 233 .probe = omap_rproc_probe, 234 .remove = omap_rproc_remove, 235 .driver = { 236 .name = "omap-rproc", 237 }, 238 }; 239 240 module_platform_driver(omap_rproc_driver); 241 242 MODULE_LICENSE("GPL v2"); 243 MODULE_DESCRIPTION("OMAP Remote Processor control driver"); 244