Commit 13be5432 authored by Robert Tivy's avatar Robert Tivy Committed by Ohad Ben-Cohen
Browse files

remoteproc/davinci: add a remoteproc driver for OMAP-L13x DSP 



Adding a new remoteproc driver for OMAP-L13x DSP

Signed-off-by: default avatarRobert Tivy <rtivy@ti.com>
[removed 'EXPERIMENTAL' and fixed some indentation issues]
Signed-off-by: default avatarOhad Ben-Cohen <ohad@wizery.com>
parent 8b4aec9a

drivers/remoteproc/Kconfig

+23 −0
Original line number Diff line number Diff line
@@ -39,4 +39,27 @@ config STE_MODEM_RPROC 
	  This can be either built-in or a loadable module.

	  If unsure say N.



config DA8XX_REMOTEPROC

	tristate "DA8xx/OMAP-L13x remoteproc support"

	depends on ARCH_DAVINCI_DA8XX

	select CMA

	select REMOTEPROC

	select RPMSG

	help

	  Say y here to support DA8xx/OMAP-L13x remote processors via the

	  remote processor framework.



	  You want to say y here in order to enable AMP

	  use-cases to run on your platform (multimedia codecs are

	  offloaded to remote DSP processors using this framework).



	  This module controls the name of the firmware file that gets

	  loaded on the DSP.  This file must reside in the /lib/firmware

	  directory.  It can be specified via the module parameter

	  da8xx_fw_name=<filename>, and if not specified will default to

	  "rproc-dsp-fw".



	  It's safe to say n here if you're not interested in multimedia

	  offloading.



endmenu

drivers/remoteproc/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -9,3 +9,4 @@ remoteproc-y += remoteproc_virtio.o 
remoteproc-y				+= remoteproc_elf_loader.o

obj-$(CONFIG_OMAP_REMOTEPROC)		+= omap_remoteproc.o

obj-$(CONFIG_STE_MODEM_RPROC)	 	+= ste_modem_rproc.o

obj-$(CONFIG_DA8XX_REMOTEPROC)		+= da8xx_remoteproc.o

drivers/remoteproc/da8xx_remoteproc.c

0 → 100644
+324 −0
Original line number Diff line number Diff line 
/*

 * Remote processor machine-specific module for DA8XX

 *

 * Copyright (C) 2013 Texas Instruments, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * version 2 as published by the Free Software Foundation.

 */



#include <linux/bitops.h>

#include <linux/clk.h>

#include <linux/err.h>

#include <linux/interrupt.h>

#include <linux/io.h>

#include <linux/irq.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/remoteproc.h>



#include <mach/clock.h>   /* for davinci_clk_reset_assert/deassert() */



#include "remoteproc_internal.h"



static char *da8xx_fw_name;

module_param(da8xx_fw_name, charp, S_IRUGO);

MODULE_PARM_DESC(da8xx_fw_name,

		 "\n\t\tName of DSP firmware file in /lib/firmware"

		 " (if not specified defaults to 'rproc-dsp-fw')");



/*

 * OMAP-L138 Technical References:

 * http://www.ti.com/product/omap-l138

 */

#define SYSCFG_CHIPSIG0 BIT(0)

#define SYSCFG_CHIPSIG1 BIT(1)

#define SYSCFG_CHIPSIG2 BIT(2)

#define SYSCFG_CHIPSIG3 BIT(3)

#define SYSCFG_CHIPSIG4 BIT(4)



/**

 * struct da8xx_rproc - da8xx remote processor instance state

 * @rproc: rproc handle

 * @dsp_clk: placeholder for platform's DSP clk

 * @ack_fxn: chip-specific ack function for ack'ing irq

 * @irq_data: ack_fxn function parameter

 * @chipsig: virt ptr to DSP interrupt registers (CHIPSIG & CHIPSIG_CLR)

 * @bootreg: virt ptr to DSP boot address register (HOST1CFG)

 * @irq: irq # used by this instance

 */

struct da8xx_rproc {

	struct rproc *rproc;

	struct clk *dsp_clk;

	void (*ack_fxn)(struct irq_data *data);

	struct irq_data *irq_data;

	void __iomem *chipsig;

	void __iomem *bootreg;

	int irq;

};



/**

 * handle_event() - inbound virtqueue message workqueue function

 *

 * This function is registered as a kernel thread and is scheduled by the

 * kernel handler.

 */

static irqreturn_t handle_event(int irq, void *p)

{

	struct rproc *rproc = (struct rproc *)p;



	/* Process incoming buffers on all our vrings */

	rproc_vq_interrupt(rproc, 0);

	rproc_vq_interrupt(rproc, 1);



	return IRQ_HANDLED;

}



/**

 * da8xx_rproc_callback() - inbound virtqueue message handler

 *

 * This handler is invoked directly by the kernel whenever the remote

 * core (DSP) has modified the state of a virtqueue.  There is no

 * "payload" message indicating the virtqueue index as is the case with

 * mailbox-based implementations on OMAP4.  As such, this handler "polls"

 * each known virtqueue index for every invocation.

 */

static irqreturn_t da8xx_rproc_callback(int irq, void *p)

{

	struct rproc *rproc = (struct rproc *)p;

	struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv;

	u32 chipsig;



	chipsig = readl(drproc->chipsig);

	if (chipsig & SYSCFG_CHIPSIG0) {

		/* Clear interrupt level source */

		writel(SYSCFG_CHIPSIG0, drproc->chipsig + 4);



		/*

		 * ACK intr to AINTC.

		 *

		 * It has already been ack'ed by the kernel before calling

		 * this function, but since the ARM<->DSP interrupts in the

		 * CHIPSIG register are "level" instead of "pulse" variety,

		 * we need to ack it after taking down the level else we'll

		 * be called again immediately after returning.

		 */

		drproc->ack_fxn(drproc->irq_data);



		return IRQ_WAKE_THREAD;

	}



	return IRQ_HANDLED;

}



static int da8xx_rproc_start(struct rproc *rproc)

{

	struct device *dev = rproc->dev.parent;

	struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv;

	struct clk *dsp_clk = drproc->dsp_clk;



	/* hw requires the start (boot) address be on 1KB boundary */

	if (rproc->bootaddr & 0x3ff) {

		dev_err(dev, "invalid boot address: must be aligned to 1KB\n");



		return -EINVAL;

	}



	writel(rproc->bootaddr, drproc->bootreg);



	clk_enable(dsp_clk);

	davinci_clk_reset_deassert(dsp_clk);



	return 0;

}



static int da8xx_rproc_stop(struct rproc *rproc)

{

	struct da8xx_rproc *drproc = rproc->priv;



	clk_disable(drproc->dsp_clk);



	return 0;

}



/* kick a virtqueue */

static void da8xx_rproc_kick(struct rproc *rproc, int vqid)

{

	struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv;



	/* Interupt remote proc */

	writel(SYSCFG_CHIPSIG2, drproc->chipsig);

}



static struct rproc_ops da8xx_rproc_ops = {

	.start = da8xx_rproc_start,

	.stop = da8xx_rproc_stop,

	.kick = da8xx_rproc_kick,

};



static int reset_assert(struct device *dev)

{

	struct clk *dsp_clk;



	dsp_clk = clk_get(dev, NULL);

	if (IS_ERR(dsp_clk)) {

		dev_err(dev, "clk_get error: %ld\n", PTR_ERR(dsp_clk));

		return PTR_RET(dsp_clk);

	}



	davinci_clk_reset_assert(dsp_clk);

	clk_put(dsp_clk);



	return 0;

}



static int da8xx_rproc_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct da8xx_rproc *drproc;

	struct rproc *rproc;

	struct irq_data *irq_data;

	struct resource *bootreg_res;

	struct resource *chipsig_res;

	struct clk *dsp_clk;

	void __iomem *chipsig;

	void __iomem *bootreg;

	int irq;

	int ret;



	irq = platform_get_irq(pdev, 0);

	if (irq < 0) {

		dev_err(dev, "platform_get_irq(pdev, 0) error: %d\n", irq);

		return irq;

	}



	irq_data = irq_get_irq_data(irq);

	if (!irq_data) {

		dev_err(dev, "irq_get_irq_data(%d): NULL\n", irq);

		return -EINVAL;

	}



	bootreg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!bootreg_res) {

		dev_err(dev,

			"platform_get_resource(IORESOURCE_MEM, 0): NULL\n");

		return -EADDRNOTAVAIL;

	}



	chipsig_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);

	if (!chipsig_res) {

		dev_err(dev,

			"platform_get_resource(IORESOURCE_MEM, 1): NULL\n");

		return -EADDRNOTAVAIL;

	}



	bootreg = devm_ioremap_resource(dev, bootreg_res);

	if (IS_ERR(bootreg))

		return PTR_ERR(bootreg);



	chipsig = devm_ioremap_resource(dev, chipsig_res);

	if (IS_ERR(chipsig))

		return PTR_ERR(chipsig);



	dsp_clk = devm_clk_get(dev, NULL);

	if (IS_ERR(dsp_clk)) {

		dev_err(dev, "clk_get error: %ld\n", PTR_ERR(dsp_clk));



		return PTR_ERR(dsp_clk);

	}



	rproc = rproc_alloc(dev, "dsp", &da8xx_rproc_ops, da8xx_fw_name,

		sizeof(*drproc));

	if (!rproc)

		return -ENOMEM;



	drproc = rproc->priv;

	drproc->rproc = rproc;



	platform_set_drvdata(pdev, rproc);



	/* everything the ISR needs is now setup, so hook it up */

	ret = devm_request_threaded_irq(dev, irq, da8xx_rproc_callback,

					handle_event, 0, "da8xx-remoteproc",

					rproc);

	if (ret) {

		dev_err(dev, "devm_request_threaded_irq error: %d\n", ret);

		goto free_rproc;

	}



	/*

	 * rproc_add() can end up enabling the DSP's clk with the DSP

	 * *not* in reset, but da8xx_rproc_start() needs the DSP to be

	 * held in reset at the time it is called.

	 */

	ret = reset_assert(dev);

	if (ret)

		goto free_rproc;



	drproc->chipsig = chipsig;

	drproc->bootreg = bootreg;

	drproc->ack_fxn = irq_data->chip->irq_ack;

	drproc->irq_data = irq_data;

	drproc->irq = irq;

	drproc->dsp_clk = dsp_clk;



	ret = rproc_add(rproc);

	if (ret) {

		dev_err(dev, "rproc_add failed: %d\n", ret);

		goto free_rproc;

	}



	return 0;



free_rproc:

	rproc_put(rproc);



	return ret;

}



static int da8xx_rproc_remove(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct rproc *rproc = platform_get_drvdata(pdev);

	struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv;



	/*

	 * It's important to place the DSP in reset before going away,

	 * since a subsequent insmod of this module may enable the DSP's

	 * clock before its program/boot-address has been loaded and

	 * before this module's probe has had a chance to reset the DSP.

	 * Without the reset, the DSP can lockup permanently when it

	 * begins executing garbage.

	 */

	reset_assert(dev);



	/*

	 * The devm subsystem might end up releasing things before

	 * freeing the irq, thus allowing an interrupt to sneak in while

	 * the device is being removed.  This should prevent that.

	 */

	disable_irq(drproc->irq);



	devm_clk_put(dev, drproc->dsp_clk);



	rproc_del(rproc);

	rproc_put(rproc);



	return 0;

}



static struct platform_driver da8xx_rproc_driver = {

	.probe = da8xx_rproc_probe,

	.remove = da8xx_rproc_remove,

	.driver = {

		.name = "davinci-rproc",

		.owner = THIS_MODULE,

	},

};



module_platform_driver(da8xx_rproc_driver);



MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("DA8XX Remote Processor control driver");