2 * Remote processor machine-specific module for DA8XX
4 * Copyright (C) 2013 Texas Instruments, Inc.
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.
11 #include <linux/bitops.h>
12 #include <linux/clk.h>
13 #include <linux/err.h>
14 #include <linux/interrupt.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>
22 #include <mach/clock.h> /* for davinci_clk_reset_assert/deassert() */
24 #include "remoteproc_internal.h"
26 static char *da8xx_fw_name
;
27 module_param(da8xx_fw_name
, charp
, S_IRUGO
);
28 MODULE_PARM_DESC(da8xx_fw_name
,
29 "Name of DSP firmware file in /lib/firmware (if not specified defaults to 'rproc-dsp-fw')");
32 * OMAP-L138 Technical References:
33 * http://www.ti.com/product/omap-l138
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)
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
54 void (*ack_fxn
)(struct irq_data
*data
);
55 struct irq_data
*irq_data
;
56 void __iomem
*chipsig
;
57 void __iomem
*bootreg
;
62 * handle_event() - inbound virtqueue message workqueue function
64 * This function is registered as a kernel thread and is scheduled by the
67 static irqreturn_t
handle_event(int irq
, void *p
)
69 struct rproc
*rproc
= (struct rproc
*)p
;
71 /* Process incoming buffers on all our vrings */
72 rproc_vq_interrupt(rproc
, 0);
73 rproc_vq_interrupt(rproc
, 1);
79 * da8xx_rproc_callback() - inbound virtqueue message handler
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.
87 static irqreturn_t
da8xx_rproc_callback(int irq
, void *p
)
89 struct rproc
*rproc
= (struct rproc
*)p
;
90 struct da8xx_rproc
*drproc
= (struct da8xx_rproc
*)rproc
->priv
;
93 chipsig
= readl(drproc
->chipsig
);
94 if (chipsig
& SYSCFG_CHIPSIG0
) {
95 /* Clear interrupt level source */
96 writel(SYSCFG_CHIPSIG0
, drproc
->chipsig
+ 4);
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.
107 drproc
->ack_fxn(drproc
->irq_data
);
109 return IRQ_WAKE_THREAD
;
115 static int da8xx_rproc_start(struct rproc
*rproc
)
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
;
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");
128 writel(rproc
->bootaddr
, drproc
->bootreg
);
131 davinci_clk_reset_deassert(dsp_clk
);
136 static int da8xx_rproc_stop(struct rproc
*rproc
)
138 struct da8xx_rproc
*drproc
= rproc
->priv
;
140 davinci_clk_reset_assert(drproc
->dsp_clk
);
141 clk_disable(drproc
->dsp_clk
);
146 /* kick a virtqueue */
147 static void da8xx_rproc_kick(struct rproc
*rproc
, int vqid
)
149 struct da8xx_rproc
*drproc
= (struct da8xx_rproc
*)rproc
->priv
;
151 /* Interrupt remote proc */
152 writel(SYSCFG_CHIPSIG2
, drproc
->chipsig
);
155 static const struct rproc_ops da8xx_rproc_ops
= {
156 .start
= da8xx_rproc_start
,
157 .stop
= da8xx_rproc_stop
,
158 .kick
= da8xx_rproc_kick
,
161 static int da8xx_rproc_probe(struct platform_device
*pdev
)
163 struct device
*dev
= &pdev
->dev
;
164 struct da8xx_rproc
*drproc
;
166 struct irq_data
*irq_data
;
167 struct resource
*bootreg_res
;
168 struct resource
*chipsig_res
;
170 void __iomem
*chipsig
;
171 void __iomem
*bootreg
;
175 irq
= platform_get_irq(pdev
, 0);
177 dev_err(dev
, "platform_get_irq(pdev, 0) error: %d\n", irq
);
181 irq_data
= irq_get_irq_data(irq
);
183 dev_err(dev
, "irq_get_irq_data(%d): NULL\n", irq
);
187 bootreg_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
188 bootreg
= devm_ioremap_resource(dev
, bootreg_res
);
190 return PTR_ERR(bootreg
);
192 chipsig_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
193 chipsig
= devm_ioremap_resource(dev
, chipsig_res
);
195 return PTR_ERR(chipsig
);
197 dsp_clk
= devm_clk_get(dev
, NULL
);
198 if (IS_ERR(dsp_clk
)) {
199 dev_err(dev
, "clk_get error: %ld\n", PTR_ERR(dsp_clk
));
201 return PTR_ERR(dsp_clk
);
204 rproc
= rproc_alloc(dev
, "dsp", &da8xx_rproc_ops
, da8xx_fw_name
,
209 drproc
= rproc
->priv
;
210 drproc
->rproc
= rproc
;
211 drproc
->dsp_clk
= dsp_clk
;
212 rproc
->has_iommu
= false;
214 platform_set_drvdata(pdev
, rproc
);
216 /* everything the ISR needs is now setup, so hook it up */
217 ret
= devm_request_threaded_irq(dev
, irq
, da8xx_rproc_callback
,
218 handle_event
, 0, "da8xx-remoteproc",
221 dev_err(dev
, "devm_request_threaded_irq error: %d\n", ret
);
226 * rproc_add() can end up enabling the DSP's clk with the DSP
227 * *not* in reset, but da8xx_rproc_start() needs the DSP to be
228 * held in reset at the time it is called.
230 ret
= davinci_clk_reset_assert(drproc
->dsp_clk
);
234 drproc
->chipsig
= chipsig
;
235 drproc
->bootreg
= bootreg
;
236 drproc
->ack_fxn
= irq_data
->chip
->irq_ack
;
237 drproc
->irq_data
= irq_data
;
240 ret
= rproc_add(rproc
);
242 dev_err(dev
, "rproc_add failed: %d\n", ret
);
254 static int da8xx_rproc_remove(struct platform_device
*pdev
)
256 struct rproc
*rproc
= platform_get_drvdata(pdev
);
257 struct da8xx_rproc
*drproc
= (struct da8xx_rproc
*)rproc
->priv
;
260 * The devm subsystem might end up releasing things before
261 * freeing the irq, thus allowing an interrupt to sneak in while
262 * the device is being removed. This should prevent that.
264 disable_irq(drproc
->irq
);
272 static struct platform_driver da8xx_rproc_driver
= {
273 .probe
= da8xx_rproc_probe
,
274 .remove
= da8xx_rproc_remove
,
276 .name
= "davinci-rproc",
280 module_platform_driver(da8xx_rproc_driver
);
282 MODULE_LICENSE("GPL v2");
283 MODULE_DESCRIPTION("DA8XX Remote Processor control driver");