Linux: PRU interrupt to ARM

Hello Chris,

This is a very rough template. I have not had time to check if anything compiles, etc - so if you have any problems or feedback let me know. I am out the rest of this week, but I will reply next week.

I am trying to show two things here:
1) Using remoteproc in your probe function to initialize the PRU and set up the PRU INTC
2) Registering an IRQ to the system so that your function IRQ handler gets called

pru_rproc_get (in pru_rproc.c) calls function pru_rproc_intc_dt_config, which sets up your PRU's INTC based on device tree arguments.

template bindings documentation:

PRU Template Driver on TI SoCs

The PRU can be programmed to fulfill many functions in coordination with Linux.

Each PRU Template node should define the PRU Application node properties as
detailed in bindings ti,pru-rproc.txt.

Required properties:
--------------------
- compatible           : should be "ti,pru-template".
- interrupt-parent     : phandle to the PRUSS INTC node.
- prus                 : phandle to the PRU node used.
- firmware-name        : PRU Template firmware for the PRU core.
- ti,pru-interrupt-map : PRU interrupt mappings, see ti,pru-rproc.txt for
                         details.


Required properties:
--------------------
- interrupts        : interrupt specifier for PRU signaling the host. The
                      property should match the event defined in
                      ti,pru-interrupt-map property.

Example (AM335x BeagleBone Black board):
---------------------------------------

        pru_template0 {
                compatible = "ti,pru-template";
                interrupt-parent = <&pruss_intc>;
                prus = <&pru0>;
                firmware-name = "pru_template.out";
                ti,pru-interrupt-map = <0 21 2 2 >;
                interrupts = <21>;
        }

Template kernel functions:

#include <linux/of_irq.h>
#include <linux/of_platform.h>
#include <linux/pruss.h>
#include <linux/remoteproc.h>
#include <linux/serial_core.h>
#include <linux/tty_flip.h>

...

struct pru_template {
        struct device *dev;
        struct rproc *pru;
        struct pruss *pruss;
        int pru_id;
        struct pruss_mem_region mem;
        //TODO: add something to keep track of multiple ARM interrupts 
};
...
static irqreturn_t pru_template_handle_irq(int irq, void *pru_template)
{
        // Do something
        return IRQ_HANDLED;
}
...
static int pru_template_init_pruss(struct device_node *np, struct pru_template *pt)
{
        u32 reg;
        int ret = 0;

        pt->pru = pru_rproc_get(np, 0);
        if (IS_ERR(pt->pru)) {
                ret = PTR_ERR(pt->pru);
                if (ret != -EPROBE_DEFER)
                        dev_err(pt->dev, "failed to get pru (%d)\n", ret);
                return ret;
        }

        pt->pruss = pruss_get(pt->pru);
        if (IS_ERR(pt->pruss)) {
                ret = PTR_ERR(pt->pruss);
                dev_err(pt->dev, "failed to get pruss handle (%d)\n", ret);
                goto ptt_pru;
        }

        pt->pru_id = pru_rproc_get_id(pt->pru);
        if (pt->pru_id < 0) {
                dev_err(pt->dev, "failed to get pru id (%d)\n", pt->pru_id);
                ret = -EINVAL;
                goto put_pruss;
        }

        if (pt->pru_id > 1) {
                dev_err(pt->dev, "invalid pru id (%d)\n", pt->pru_id);
                ret = -EINVAL;
                goto put_pruss;
        }

        ret = pruss_request_mem_region(pt->pruss,
                        pt->pru_id ? PRUSS_MEM_DRAM1 : PRUSS_MEM_DRAM0,
                        &pt->mem);
        if (ret) {
                dev_err(pt->dev, "failed to get pruss mem region (%d)\n", ret);
                goto put_pruss;
        }

        /* clear the mem region before firmware runs by rproc_boot() */
        memset_io(pt->mem.va, 0, pt->mem.size);

        ret = rproc_boot(pt->pru);
        if (ret) {
                dev_err(pt->dev, "failed to boot pru (%d)\n", ret);
                goto put_mem;
        }

        // check firmware version, magic number, etc here to ensure correct firmware was loaded

        return ret;

put_rproc:
        rproc_shutdown(pt->pru);
put_mem:
        pruss_release_mem_region(pt->pruss, &pt->mem);
put_pruss:
        pruss_put(pt->pruss);
put_pru:
        pru_rproc_put(pt->pru);

        return ret;
}
...
static int pru_template_probe(struct platform_device *pdev)
{
        struct pru_template *pt;
        struct device *dev = &pdev->dev;
        struct device_node *np = dev->of_node;
        struct device_node *child;
        int id, ret;

        if (!np)
                return -ENODEV; /* we don't support non DT */

        pt = devm_kzalloc(dev, sizeof(*pt), GFP_KERNEL);
        if (!pt)
                return -ENOMEM;

        platform_set_drvdata(pdev, pt);
        pt->dev = dev;

        ret = pru_template_init_pruss(np, pt);
        if (ret < 0)
                return -ENODEV;

        // TODO: add for loop so this code iterates over as many interrupts as are defined in device tree
        ret = of_irq_get(np, 0);
        if (ret < 0) {
                dev_err(pt->dev, "failed to get irq (%d)\n", ret);
                return;
        }
        // TODO: save the IRQ number somewhere

        ret = request_irq(ret, pru_template_handle_irq,
                        IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
                        dev_name(pt->dev), pt);
        if (ret) {
                dev_err(pt->dev, "failed to to request irq (%d)\n", ret);
                return;
        }


        return 0;
}
...
static int pru_template_remove(struct platform_device *pdev)
{
        struct pru_template *pt = platform_get_drvdata(pdev);

        // TODO: free all IRQs you defined earlier
        //for (each IRQ) {
        //        free_irq(IRQ#, pt);
        //}

        rproc_shutdown(pt->pru);
        pruss_release_mem_region(pt->pruss, &pt->mem);
        pruss_put(pt->pruss);
        pru_rproc_put(pt->pru);

        return 0;
}

Hope this is helpful,

Nick