Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Remote processor machine-specific module for DA8XX |
| 3 | * |
| 4 | * Copyright (C) 2013 Texas Instruments, Inc. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License |
| 8 | * version 2 as published by the Free Software Foundation. |
| 9 | */ |
| 10 | |
| 11 | #include <linux/bitops.h> |
| 12 | #include <linux/clk.h> |
| 13 | #include <linux/err.h> |
| 14 | #include <linux/interrupt.h> |
| 15 | #include <linux/io.h> |
| 16 | #include <linux/irq.h> |
| 17 | #include <linux/kernel.h> |
| 18 | #include <linux/module.h> |
| 19 | #include <linux/platform_device.h> |
| 20 | #include <linux/remoteproc.h> |
| 21 | |
| 22 | #include <mach/clock.h> /* for davinci_clk_reset_assert/deassert() */ |
| 23 | |
| 24 | #include "remoteproc_internal.h" |
| 25 | |
| 26 | static char *da8xx_fw_name; |
| 27 | module_param(da8xx_fw_name, charp, S_IRUGO); |
| 28 | MODULE_PARM_DESC(da8xx_fw_name, |
Suman Anna | e17aee3 | 2015-02-27 17:18:22 -0600 | [diff] [blame] | 29 | "Name of DSP firmware file in /lib/firmware (if not specified defaults to 'rproc-dsp-fw')"); |
Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 30 | |
| 31 | /* |
| 32 | * OMAP-L138 Technical References: |
| 33 | * http://www.ti.com/product/omap-l138 |
| 34 | */ |
| 35 | #define SYSCFG_CHIPSIG0 BIT(0) |
| 36 | #define SYSCFG_CHIPSIG1 BIT(1) |
| 37 | #define SYSCFG_CHIPSIG2 BIT(2) |
| 38 | #define SYSCFG_CHIPSIG3 BIT(3) |
| 39 | #define SYSCFG_CHIPSIG4 BIT(4) |
| 40 | |
| 41 | /** |
| 42 | * struct da8xx_rproc - da8xx remote processor instance state |
| 43 | * @rproc: rproc handle |
| 44 | * @dsp_clk: placeholder for platform's DSP clk |
| 45 | * @ack_fxn: chip-specific ack function for ack'ing irq |
| 46 | * @irq_data: ack_fxn function parameter |
| 47 | * @chipsig: virt ptr to DSP interrupt registers (CHIPSIG & CHIPSIG_CLR) |
| 48 | * @bootreg: virt ptr to DSP boot address register (HOST1CFG) |
| 49 | * @irq: irq # used by this instance |
| 50 | */ |
| 51 | struct da8xx_rproc { |
| 52 | struct rproc *rproc; |
| 53 | struct clk *dsp_clk; |
| 54 | void (*ack_fxn)(struct irq_data *data); |
| 55 | struct irq_data *irq_data; |
| 56 | void __iomem *chipsig; |
| 57 | void __iomem *bootreg; |
| 58 | int irq; |
| 59 | }; |
| 60 | |
| 61 | /** |
| 62 | * handle_event() - inbound virtqueue message workqueue function |
| 63 | * |
| 64 | * This function is registered as a kernel thread and is scheduled by the |
| 65 | * kernel handler. |
| 66 | */ |
| 67 | static irqreturn_t handle_event(int irq, void *p) |
| 68 | { |
| 69 | struct rproc *rproc = (struct rproc *)p; |
| 70 | |
| 71 | /* Process incoming buffers on all our vrings */ |
| 72 | rproc_vq_interrupt(rproc, 0); |
| 73 | rproc_vq_interrupt(rproc, 1); |
| 74 | |
| 75 | return IRQ_HANDLED; |
| 76 | } |
| 77 | |
| 78 | /** |
| 79 | * da8xx_rproc_callback() - inbound virtqueue message handler |
| 80 | * |
| 81 | * This handler is invoked directly by the kernel whenever the remote |
| 82 | * core (DSP) has modified the state of a virtqueue. There is no |
| 83 | * "payload" message indicating the virtqueue index as is the case with |
| 84 | * mailbox-based implementations on OMAP4. As such, this handler "polls" |
| 85 | * each known virtqueue index for every invocation. |
| 86 | */ |
| 87 | static irqreturn_t da8xx_rproc_callback(int irq, void *p) |
| 88 | { |
| 89 | struct rproc *rproc = (struct rproc *)p; |
| 90 | struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv; |
| 91 | u32 chipsig; |
| 92 | |
| 93 | chipsig = readl(drproc->chipsig); |
| 94 | if (chipsig & SYSCFG_CHIPSIG0) { |
| 95 | /* Clear interrupt level source */ |
| 96 | writel(SYSCFG_CHIPSIG0, drproc->chipsig + 4); |
| 97 | |
| 98 | /* |
| 99 | * ACK intr to AINTC. |
| 100 | * |
| 101 | * It has already been ack'ed by the kernel before calling |
| 102 | * this function, but since the ARM<->DSP interrupts in the |
| 103 | * CHIPSIG register are "level" instead of "pulse" variety, |
| 104 | * we need to ack it after taking down the level else we'll |
| 105 | * be called again immediately after returning. |
| 106 | */ |
| 107 | drproc->ack_fxn(drproc->irq_data); |
| 108 | |
| 109 | return IRQ_WAKE_THREAD; |
| 110 | } |
| 111 | |
| 112 | return IRQ_HANDLED; |
| 113 | } |
| 114 | |
| 115 | static int da8xx_rproc_start(struct rproc *rproc) |
| 116 | { |
| 117 | struct device *dev = rproc->dev.parent; |
| 118 | struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv; |
| 119 | struct clk *dsp_clk = drproc->dsp_clk; |
| 120 | |
| 121 | /* hw requires the start (boot) address be on 1KB boundary */ |
| 122 | if (rproc->bootaddr & 0x3ff) { |
| 123 | dev_err(dev, "invalid boot address: must be aligned to 1KB\n"); |
| 124 | |
| 125 | return -EINVAL; |
| 126 | } |
| 127 | |
| 128 | writel(rproc->bootaddr, drproc->bootreg); |
| 129 | |
| 130 | clk_enable(dsp_clk); |
| 131 | davinci_clk_reset_deassert(dsp_clk); |
| 132 | |
| 133 | return 0; |
| 134 | } |
| 135 | |
| 136 | static int da8xx_rproc_stop(struct rproc *rproc) |
| 137 | { |
| 138 | struct da8xx_rproc *drproc = rproc->priv; |
| 139 | |
| 140 | clk_disable(drproc->dsp_clk); |
| 141 | |
| 142 | return 0; |
| 143 | } |
| 144 | |
| 145 | /* kick a virtqueue */ |
| 146 | static void da8xx_rproc_kick(struct rproc *rproc, int vqid) |
| 147 | { |
| 148 | struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv; |
| 149 | |
| 150 | /* Interupt remote proc */ |
| 151 | writel(SYSCFG_CHIPSIG2, drproc->chipsig); |
| 152 | } |
| 153 | |
| 154 | static struct rproc_ops da8xx_rproc_ops = { |
| 155 | .start = da8xx_rproc_start, |
| 156 | .stop = da8xx_rproc_stop, |
| 157 | .kick = da8xx_rproc_kick, |
| 158 | }; |
| 159 | |
| 160 | static int reset_assert(struct device *dev) |
| 161 | { |
| 162 | struct clk *dsp_clk; |
| 163 | |
| 164 | dsp_clk = clk_get(dev, NULL); |
| 165 | if (IS_ERR(dsp_clk)) { |
| 166 | dev_err(dev, "clk_get error: %ld\n", PTR_ERR(dsp_clk)); |
Rusty Russell | 60d676c | 2013-07-15 11:24:08 +0930 | [diff] [blame] | 167 | return PTR_ERR(dsp_clk); |
Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 168 | } |
| 169 | |
| 170 | davinci_clk_reset_assert(dsp_clk); |
| 171 | clk_put(dsp_clk); |
| 172 | |
| 173 | return 0; |
| 174 | } |
| 175 | |
| 176 | static int da8xx_rproc_probe(struct platform_device *pdev) |
| 177 | { |
| 178 | struct device *dev = &pdev->dev; |
| 179 | struct da8xx_rproc *drproc; |
| 180 | struct rproc *rproc; |
| 181 | struct irq_data *irq_data; |
| 182 | struct resource *bootreg_res; |
| 183 | struct resource *chipsig_res; |
| 184 | struct clk *dsp_clk; |
| 185 | void __iomem *chipsig; |
| 186 | void __iomem *bootreg; |
| 187 | int irq; |
| 188 | int ret; |
| 189 | |
| 190 | irq = platform_get_irq(pdev, 0); |
| 191 | if (irq < 0) { |
| 192 | dev_err(dev, "platform_get_irq(pdev, 0) error: %d\n", irq); |
| 193 | return irq; |
| 194 | } |
| 195 | |
| 196 | irq_data = irq_get_irq_data(irq); |
| 197 | if (!irq_data) { |
| 198 | dev_err(dev, "irq_get_irq_data(%d): NULL\n", irq); |
| 199 | return -EINVAL; |
| 200 | } |
| 201 | |
| 202 | bootreg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 203 | bootreg = devm_ioremap_resource(dev, bootreg_res); |
| 204 | if (IS_ERR(bootreg)) |
| 205 | return PTR_ERR(bootreg); |
| 206 | |
Julia Lawall | 0ddc5ec | 2013-08-14 11:11:28 +0200 | [diff] [blame] | 207 | chipsig_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); |
Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 208 | chipsig = devm_ioremap_resource(dev, chipsig_res); |
| 209 | if (IS_ERR(chipsig)) |
| 210 | return PTR_ERR(chipsig); |
| 211 | |
| 212 | dsp_clk = devm_clk_get(dev, NULL); |
| 213 | if (IS_ERR(dsp_clk)) { |
| 214 | dev_err(dev, "clk_get error: %ld\n", PTR_ERR(dsp_clk)); |
| 215 | |
| 216 | return PTR_ERR(dsp_clk); |
| 217 | } |
| 218 | |
| 219 | rproc = rproc_alloc(dev, "dsp", &da8xx_rproc_ops, da8xx_fw_name, |
| 220 | sizeof(*drproc)); |
| 221 | if (!rproc) |
| 222 | return -ENOMEM; |
| 223 | |
| 224 | drproc = rproc->priv; |
| 225 | drproc->rproc = rproc; |
Suman Anna | 315491e5 | 2015-01-09 15:21:58 -0600 | [diff] [blame] | 226 | rproc->has_iommu = false; |
Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 227 | |
| 228 | platform_set_drvdata(pdev, rproc); |
| 229 | |
| 230 | /* everything the ISR needs is now setup, so hook it up */ |
| 231 | ret = devm_request_threaded_irq(dev, irq, da8xx_rproc_callback, |
| 232 | handle_event, 0, "da8xx-remoteproc", |
| 233 | rproc); |
| 234 | if (ret) { |
| 235 | dev_err(dev, "devm_request_threaded_irq error: %d\n", ret); |
| 236 | goto free_rproc; |
| 237 | } |
| 238 | |
| 239 | /* |
| 240 | * rproc_add() can end up enabling the DSP's clk with the DSP |
| 241 | * *not* in reset, but da8xx_rproc_start() needs the DSP to be |
| 242 | * held in reset at the time it is called. |
| 243 | */ |
| 244 | ret = reset_assert(dev); |
| 245 | if (ret) |
| 246 | goto free_rproc; |
| 247 | |
| 248 | drproc->chipsig = chipsig; |
| 249 | drproc->bootreg = bootreg; |
| 250 | drproc->ack_fxn = irq_data->chip->irq_ack; |
| 251 | drproc->irq_data = irq_data; |
| 252 | drproc->irq = irq; |
| 253 | drproc->dsp_clk = dsp_clk; |
| 254 | |
| 255 | ret = rproc_add(rproc); |
| 256 | if (ret) { |
| 257 | dev_err(dev, "rproc_add failed: %d\n", ret); |
| 258 | goto free_rproc; |
| 259 | } |
| 260 | |
| 261 | return 0; |
| 262 | |
| 263 | free_rproc: |
| 264 | rproc_put(rproc); |
| 265 | |
| 266 | return ret; |
| 267 | } |
| 268 | |
| 269 | static int da8xx_rproc_remove(struct platform_device *pdev) |
| 270 | { |
| 271 | struct device *dev = &pdev->dev; |
| 272 | struct rproc *rproc = platform_get_drvdata(pdev); |
| 273 | struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv; |
| 274 | |
| 275 | /* |
| 276 | * It's important to place the DSP in reset before going away, |
| 277 | * since a subsequent insmod of this module may enable the DSP's |
| 278 | * clock before its program/boot-address has been loaded and |
| 279 | * before this module's probe has had a chance to reset the DSP. |
| 280 | * Without the reset, the DSP can lockup permanently when it |
| 281 | * begins executing garbage. |
| 282 | */ |
| 283 | reset_assert(dev); |
| 284 | |
| 285 | /* |
| 286 | * The devm subsystem might end up releasing things before |
| 287 | * freeing the irq, thus allowing an interrupt to sneak in while |
| 288 | * the device is being removed. This should prevent that. |
| 289 | */ |
| 290 | disable_irq(drproc->irq); |
| 291 | |
Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 292 | rproc_del(rproc); |
| 293 | rproc_put(rproc); |
| 294 | |
| 295 | return 0; |
| 296 | } |
| 297 | |
| 298 | static struct platform_driver da8xx_rproc_driver = { |
| 299 | .probe = da8xx_rproc_probe, |
| 300 | .remove = da8xx_rproc_remove, |
| 301 | .driver = { |
| 302 | .name = "davinci-rproc", |
Robert Tivy | 13be543 | 2013-04-09 14:20:21 -0700 | [diff] [blame] | 303 | }, |
| 304 | }; |
| 305 | |
| 306 | module_platform_driver(da8xx_rproc_driver); |
| 307 | |
| 308 | MODULE_LICENSE("GPL v2"); |
| 309 | MODULE_DESCRIPTION("DA8XX Remote Processor control driver"); |