remoteproc: pru: Add support for PRU specific interrupt configuration

 */

#include <linux/bitops.h>

#include <linux/irqdomain.h>

#include <linux/module.h>

#include <linux/of_device.h>

#include <linux/of_irq.h>

#include <linux/pruss_driver.h>

#include <linux/remoteproc.h>

#include "remoteproc_internal.h"

#include "remoteproc_elf_helpers.h"

#include "pru_rproc.h"

/* PRU_ICSS_PRU_CTRL registers */

#define PRU_CTRL_CTRL		0x0000

#define PRU_SDRAM_DA	0x2000	/* Secondary Data RAM */

#define PRU_SHRDRAM_DA	0x10000 /* Shared Data RAM */

#define MAX_PRU_SYS_EVENTS 160

/**

 * enum pru_iomem - PRU core memory/register range identifiers

 *

 * @rproc: remoteproc pointer for this PRU core

 * @mem_regions: data for each of the PRU memory regions

 * @fw_name: name of firmware image used during loading

 * @mapped_irq: virtual interrupt numbers of created fw specific mapping

 * @pru_interrupt_map: pointer to interrupt mapping description (firmware)

 * @pru_interrupt_map_sz: pru_interrupt_map size

 * @evt_count: number of mapped events

 */

struct pru_rproc {

	int id;

	struct rproc *rproc;

	struct pruss_mem_region mem_regions[PRU_IOMEM_MAX];

	const char *fw_name;

	unsigned int *mapped_irq;

	struct pru_irq_rsc *pru_interrupt_map;

	size_t pru_interrupt_map_sz;

	u8 evt_count;

};

static inline u32 pru_control_read_reg(struct pru_rproc *pru, unsigned int reg)

	writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg);

}

static void pru_dispose_irq_mapping(struct pru_rproc *pru)

{

	while (pru->evt_count--) {

		if (pru->mapped_irq[pru->evt_count] > 0)

			irq_dispose_mapping(pru->mapped_irq[pru->evt_count]);

	}

	kfree(pru->mapped_irq);

}

/*

 * Parse the custom PRU interrupt map resource and configure the INTC

 * appropriately.

 */

static int pru_handle_intrmap(struct rproc *rproc)

{

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

	struct pru_rproc *pru = rproc->priv;

	struct pru_irq_rsc *rsc = pru->pru_interrupt_map;

	struct irq_fwspec fwspec;

	struct device_node *irq_parent;

	int i, ret = 0;

	/* not having pru_interrupt_map is not an error */

	if (!rsc)

		return 0;

	/* currently supporting only type 0 */

	if (rsc->type != 0) {

		dev_err(dev, "unsupported rsc type: %d\n", rsc->type);

		return -EINVAL;

	}

	if (rsc->num_evts > MAX_PRU_SYS_EVENTS)

		return -EINVAL;

	if (sizeof(*rsc) + rsc->num_evts * sizeof(struct pruss_int_map) !=

	    pru->pru_interrupt_map_sz)

		return -EINVAL;

	pru->evt_count = rsc->num_evts;

	pru->mapped_irq = kcalloc(pru->evt_count, sizeof(unsigned int),

				  GFP_KERNEL);

	if (!pru->mapped_irq)

		return -ENOMEM;

	/*

	 * parse and fill in system event to interrupt channel and

	 * channel-to-host mapping

	 */

	irq_parent = of_irq_find_parent(pru->dev->of_node);

	if (!irq_parent) {

		kfree(pru->mapped_irq);

		return -ENODEV;

	}

	fwspec.fwnode = of_node_to_fwnode(irq_parent);

	fwspec.param_count = 3;

	for (i = 0; i < pru->evt_count; i++) {

		fwspec.param[0] = rsc->pru_intc_map[i].event;

		fwspec.param[1] = rsc->pru_intc_map[i].chnl;

		fwspec.param[2] = rsc->pru_intc_map[i].host;

		dev_dbg(dev, "mapping%d: event %d, chnl %d, host %d\n",

			i, fwspec.param[0], fwspec.param[1], fwspec.param[2]);

		pru->mapped_irq[i] = irq_create_fwspec_mapping(&fwspec);

		if (!pru->mapped_irq[i]) {

			dev_err(dev, "failed to get virq\n");

			ret = pru->mapped_irq[i];

			goto map_fail;

		}

	}

	return ret;

map_fail:

	pru_dispose_irq_mapping(pru);

	return ret;

}

static int pru_rproc_start(struct rproc *rproc)

{

	struct device *dev = &rproc->dev;

	struct pru_rproc *pru = rproc->priv;

	u32 val;

	int ret;

	dev_dbg(dev, "starting PRU%d: entry-point = 0x%llx\n",

		pru->id, (rproc->bootaddr >> 2));

	ret = pru_handle_intrmap(rproc);

	/*

	 * reset references to pru interrupt map - they will stop being valid

	 * after rproc_start returns

	 */

	pru->pru_interrupt_map = NULL;

	pru->pru_interrupt_map_sz = 0;

	if (ret)

		return ret;

	val = CTRL_CTRL_EN | ((rproc->bootaddr >> 2) << 16);

	pru_control_write_reg(pru, PRU_CTRL_CTRL, val);

	val &= ~CTRL_CTRL_EN;

	pru_control_write_reg(pru, PRU_CTRL_CTRL, val);

	/* dispose irq mapping - new firmware can provide new mapping */

	if (pru->mapped_irq)

		pru_dispose_irq_mapping(pru);

	return 0;

}

	return ret;

}

static const void *

pru_rproc_find_interrupt_map(struct device *dev, const struct firmware *fw)

{

	struct elf32_shdr *shdr, *name_table_shdr;

	const char *name_table;

	const u8 *elf_data = fw->data;

	struct elf32_hdr *ehdr = (struct elf32_hdr *)elf_data;

	u16 shnum = ehdr->e_shnum;

	u16 shstrndx = ehdr->e_shstrndx;

	int i;

	/* first, get the section header */

	shdr = (struct elf32_shdr *)(elf_data + ehdr->e_shoff);

	/* compute name table section header entry in shdr array */

	name_table_shdr = shdr + shstrndx;

	/* finally, compute the name table section address in elf */

	name_table = elf_data + name_table_shdr->sh_offset;

	for (i = 0; i < shnum; i++, shdr++) {

		u32 size = shdr->sh_size;

		u32 offset = shdr->sh_offset;

		u32 name = shdr->sh_name;

		if (strcmp(name_table + name, ".pru_irq_map"))

			continue;

		/* make sure we have the entire irq map */

		if (offset + size > fw->size || offset + size < size) {

			dev_err(dev, ".pru_irq_map section truncated\n");

			return ERR_PTR(-EINVAL);

		}

		/* make sure irq map has at least the header */

		if (sizeof(struct pru_irq_rsc) > size) {

			dev_err(dev, "header-less .pru_irq_map section\n");

			return ERR_PTR(-EINVAL);

		}

		return shdr;

	}

	dev_dbg(dev, "no .pru_irq_map section found for this fw\n");

	return NULL;

}

/*

 * Use a custom parse_fw callback function for dealing with PRU firmware

 * specific sections.

 *

 * The firmware blob can contain optional ELF sections: .resource_table section

 * and .pru_irq_map one. The second one contains the PRUSS interrupt mapping

 * description, which needs to be setup before powering on the PRU core. To

 * avoid RAM wastage this ELF section is not mapped to any ELF segment (by the

 * firmware linker) and therefore is not loaded to PRU memory.

 */

static int pru_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)

{

	struct device *dev = &rproc->dev;

	struct pru_rproc *pru = rproc->priv;

	const u8 *elf_data = fw->data;

	const void *shdr;

	u8 class = fw_elf_get_class(fw);

	u64 sh_offset;

	int ret;

	/* load optional rsc table */

	else if (ret)

		return ret;

	/* find .pru_interrupt_map section, not having it is not an error */

	shdr = pru_rproc_find_interrupt_map(dev, fw);

	if (IS_ERR(shdr))

		return PTR_ERR(shdr);

	if (!shdr)

		return 0;

	/* preserve pointer to PRU interrupt map together with it size */

	sh_offset = elf_shdr_get_sh_offset(class, shdr);

	pru->pru_interrupt_map = (struct pru_irq_rsc *)(elf_data + sh_offset);

	pru->pru_interrupt_map_sz = elf_shdr_get_sh_size(class, shdr);

	return 0;

}

/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */

/*

 * PRUSS Remote Processor specific types

 *

 * Copyright (C) 2014-2020 Texas Instruments Incorporated - https://www.ti.com/

 *	Suman Anna <s-anna@ti.com>

 */

#ifndef _PRU_RPROC_H_

#define _PRU_RPROC_H_

/**

 * struct pruss_int_map - PRU system events _to_ channel and host mapping

 * @event: number of the system event

 * @chnl: channel number assigned to a given @event

 * @host: host number assigned to a given @chnl

 *

 * PRU system events are mapped to channels, and these channels are mapped

 * to host interrupts. Events can be mapped to channels in a one-to-one or

 * many-to-one ratio (multiple events per channel), and channels can be

 * mapped to host interrupts in a one-to-one or many-to-one ratio (multiple

 * channels per interrupt).

 */

struct pruss_int_map {

	u8 event;

	u8 chnl;

	u8 host;

};

/**

 * struct pru_irq_rsc - PRU firmware section header for IRQ data

 * @type: resource type

 * @num_evts: number of described events

 * @pru_intc_map: PRU interrupt routing description

 *

 * The PRU firmware blob can contain optional .pru_irq_map ELF section, which

 * provides the PRUSS interrupt mapping description. The pru_irq_rsc struct

 * describes resource entry format.

 */

struct pru_irq_rsc {

	u8 type;

	u8 num_evts;

	struct pruss_int_map pru_intc_map[];

} __packed;

#endif	/* _PRU_RPROC_H_ */