[linux-2.6-block.git] / drivers / soc / qcom / smp2p.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2015, Sony Mobile Communications AB.
 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
 */

#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/mailbox_client.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/soc/qcom/smem.h>
#include <linux/soc/qcom/smem_state.h>
#include <linux/spinlock.h>

/*
 * The Shared Memory Point to Point (SMP2P) protocol facilitates communication
 * of a single 32-bit value between two processors.  Each value has a single
 * writer (the local side) and a single reader (the remote side). Values are
 * uniquely identified in the system by the directed edge (local processor ID
 * to remote processor ID) and a string identifier.
 *
 * Each processor is responsible for creating the outgoing SMEM items and each
 * item is writable by the local processor and readable by the remote
 * processor.  By using two separate SMEM items that are single-reader and
 * single-writer, SMP2P does not require any remote locking mechanisms.
 *
 * The driver uses the Linux GPIO and interrupt framework to expose a virtual
 * GPIO for each outbound entry and a virtual interrupt controller for each
 * inbound entry.
 */

#define SMP2P_MAX_ENTRY 16
#define SMP2P_MAX_ENTRY_NAME 16

#define SMP2P_FEATURE_SSR_ACK 0x1

#define SMP2P_MAGIC 0x504d5324

/**
 * struct smp2p_smem_item - in memory communication structure
 * @magic:		magic number
 * @version:		version - must be 1
 * @features:		features flag - currently unused
 * @local_pid:		processor id of sending end
 * @remote_pid:		processor id of receiving end
 * @total_entries:	number of entries - always SMP2P_MAX_ENTRY
 * @valid_entries:	number of allocated entries
 * @flags:
 * @entries:		individual communication entries
 *     @name:		name of the entry
 *     @value:		content of the entry
 */
struct smp2p_smem_item {
	u32 magic;
	u8 version;
	unsigned features:24;
	u16 local_pid;
	u16 remote_pid;
	u16 total_entries;
	u16 valid_entries;
	u32 flags;

	struct {
		u8 name[SMP2P_MAX_ENTRY_NAME];
		u32 value;
	} entries[SMP2P_MAX_ENTRY];
} __packed;

/**
 * struct smp2p_entry - driver context matching one entry
 * @node:	list entry to keep track of allocated entries
 * @smp2p:	reference to the device driver context
 * @name:	name of the entry, to match against smp2p_smem_item
 * @value:	pointer to smp2p_smem_item entry value
 * @last_value:	last handled value
 * @domain:	irq_domain for inbound entries
 * @irq_enabled:bitmap to track enabled irq bits
 * @irq_rising:	bitmap to mark irq bits for rising detection
 * @irq_falling:bitmap to mark irq bits for falling detection
 * @state:	smem state handle
 * @lock:	spinlock to protect read-modify-write of the value
 */
struct smp2p_entry {
	struct list_head node;
	struct qcom_smp2p *smp2p;

	const char *name;
	u32 *value;
	u32 last_value;

	struct irq_domain *domain;
	DECLARE_BITMAP(irq_enabled, 32);
	DECLARE_BITMAP(irq_rising, 32);
	DECLARE_BITMAP(irq_falling, 32);

	struct qcom_smem_state *state;

	spinlock_t lock;
};

#define SMP2P_INBOUND	0
#define SMP2P_OUTBOUND	1

/**
 * struct qcom_smp2p - device driver context
 * @dev:	device driver handle
 * @in:		pointer to the inbound smem item
 * @smem_items:	ids of the two smem items
 * @valid_entries: already scanned inbound entries
 * @local_pid:	processor id of the inbound edge
 * @remote_pid:	processor id of the outbound edge
 * @ipc_regmap:	regmap for the outbound ipc
 * @ipc_offset:	offset within the regmap
 * @ipc_bit:	bit in regmap@offset to kick to signal remote processor
 * @mbox_client: mailbox client handle
 * @mbox_chan:	apcs ipc mailbox channel handle
 * @inbound:	list of inbound entries
 * @outbound:	list of outbound entries
 */
struct qcom_smp2p {
	struct device *dev;

	struct smp2p_smem_item *in;
	struct smp2p_smem_item *out;

	unsigned smem_items[SMP2P_OUTBOUND + 1];

	unsigned valid_entries;

	unsigned local_pid;
	unsigned remote_pid;

	struct regmap *ipc_regmap;
	int ipc_offset;
	int ipc_bit;

	struct mbox_client mbox_client;
	struct mbox_chan *mbox_chan;

	struct list_head inbound;
	struct list_head outbound;
};

static void qcom_smp2p_kick(struct qcom_smp2p *smp2p)
{
	/* Make sure any updated data is written before the kick */
	wmb();

	if (smp2p->mbox_chan) {
		mbox_send_message(smp2p->mbox_chan, NULL);
		mbox_client_txdone(smp2p->mbox_chan, 0);
	} else {
		regmap_write(smp2p->ipc_regmap, smp2p->ipc_offset, BIT(smp2p->ipc_bit));
	}
}

/**
 * qcom_smp2p_intr() - interrupt handler for incoming notifications
 * @irq:	unused
 * @data:	smp2p driver context
 *
 * Handle notifications from the remote side to handle newly allocated entries
 * or any changes to the state bits of existing entries.
 */
static irqreturn_t qcom_smp2p_intr(int irq, void *data)
{
	struct smp2p_smem_item *in;
	struct smp2p_entry *entry;
	struct qcom_smp2p *smp2p = data;
	unsigned smem_id = smp2p->smem_items[SMP2P_INBOUND];
	unsigned pid = smp2p->remote_pid;
	size_t size;
	int irq_pin;
	u32 status;
	char buf[SMP2P_MAX_ENTRY_NAME];
	u32 val;
	int i;

	in = smp2p->in;

	/* Acquire smem item, if not already found */
	if (!in) {
		in = qcom_smem_get(pid, smem_id, &size);
		if (IS_ERR(in)) {
			dev_err(smp2p->dev,
				"Unable to acquire remote smp2p item\n");
			return IRQ_HANDLED;
		}

		smp2p->in = in;
	}

	/* Match newly created entries */
	for (i = smp2p->valid_entries; i < in->valid_entries; i++) {
		list_for_each_entry(entry, &smp2p->inbound, node) {
			memcpy(buf, in->entries[i].name, sizeof(buf));
			if (!strcmp(buf, entry->name)) {
				entry->value = &in->entries[i].value;
				break;
			}
		}
	}
	smp2p->valid_entries = i;

	/* Fire interrupts based on any value changes */
	list_for_each_entry(entry, &smp2p->inbound, node) {
		/* Ignore entries not yet allocated by the remote side */
		if (!entry->value)
			continue;

		val = readl(entry->value);

		status = val ^ entry->last_value;
		entry->last_value = val;

		/* No changes of this entry? */
		if (!status)
			continue;

		for_each_set_bit(i, entry->irq_enabled, 32) {
			if (!(status & BIT(i)))
				continue;

			if ((val & BIT(i) && test_bit(i, entry->irq_rising)) ||
			    (!(val & BIT(i)) && test_bit(i, entry->irq_falling))) {
				irq_pin = irq_find_mapping(entry->domain, i);
				handle_nested_irq(irq_pin);
			}
		}
	}

	return IRQ_HANDLED;
}

static void smp2p_mask_irq(struct irq_data *irqd)
{
	struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
	irq_hw_number_t irq = irqd_to_hwirq(irqd);

	clear_bit(irq, entry->irq_enabled);
}

static void smp2p_unmask_irq(struct irq_data *irqd)
{
	struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
	irq_hw_number_t irq = irqd_to_hwirq(irqd);

	set_bit(irq, entry->irq_enabled);
}

static int smp2p_set_irq_type(struct irq_data *irqd, unsigned int type)
{
	struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
	irq_hw_number_t irq = irqd_to_hwirq(irqd);

	if (!(type & IRQ_TYPE_EDGE_BOTH))
		return -EINVAL;

	if (type & IRQ_TYPE_EDGE_RISING)
		set_bit(irq, entry->irq_rising);
	else
		clear_bit(irq, entry->irq_rising);

	if (type & IRQ_TYPE_EDGE_FALLING)
		set_bit(irq, entry->irq_falling);
	else
		clear_bit(irq, entry->irq_falling);

	return 0;
}

static struct irq_chip smp2p_irq_chip = {
	.name           = "smp2p",
	.irq_mask       = smp2p_mask_irq,
	.irq_unmask     = smp2p_unmask_irq,
	.irq_set_type	= smp2p_set_irq_type,
};

static int smp2p_irq_map(struct irq_domain *d,
			 unsigned int irq,
			 irq_hw_number_t hw)
{
	struct smp2p_entry *entry = d->host_data;

	irq_set_chip_and_handler(irq, &smp2p_irq_chip, handle_level_irq);
	irq_set_chip_data(irq, entry);
	irq_set_nested_thread(irq, 1);
	irq_set_noprobe(irq);

	return 0;
}

static const struct irq_domain_ops smp2p_irq_ops = {
	.map = smp2p_irq_map,
	.xlate = irq_domain_xlate_twocell,
};

static int qcom_smp2p_inbound_entry(struct qcom_smp2p *smp2p,
				    struct smp2p_entry *entry,
				    struct device_node *node)
{
	entry->domain = irq_domain_add_linear(node, 32, &smp2p_irq_ops, entry);
	if (!entry->domain) {
		dev_err(smp2p->dev, "failed to add irq_domain\n");
		return -ENOMEM;
	}

	return 0;
}

static int smp2p_update_bits(void *data, u32 mask, u32 value)
{
	struct smp2p_entry *entry = data;
	u32 orig;
	u32 val;

	spin_lock(&entry->lock);
	val = orig = readl(entry->value);
	val &= ~mask;
	val |= value;
	writel(val, entry->value);
	spin_unlock(&entry->lock);

	if (val != orig)
		qcom_smp2p_kick(entry->smp2p);

	return 0;
}

static const struct qcom_smem_state_ops smp2p_state_ops = {
	.update_bits = smp2p_update_bits,
};

static int qcom_smp2p_outbound_entry(struct qcom_smp2p *smp2p,
				     struct smp2p_entry *entry,
				     struct device_node *node)
{
	struct smp2p_smem_item *out = smp2p->out;
	char buf[SMP2P_MAX_ENTRY_NAME] = {};

	/* Allocate an entry from the smem item */
	strlcpy(buf, entry->name, SMP2P_MAX_ENTRY_NAME);
	memcpy(out->entries[out->valid_entries].name, buf, SMP2P_MAX_ENTRY_NAME);

	/* Make the logical entry reference the physical value */
	entry->value = &out->entries[out->valid_entries].value;

	out->valid_entries++;

	entry->state = qcom_smem_state_register(node, &smp2p_state_ops, entry);
	if (IS_ERR(entry->state)) {
		dev_err(smp2p->dev, "failed to register qcom_smem_state\n");
		return PTR_ERR(entry->state);
	}

	return 0;
}

static int qcom_smp2p_alloc_outbound_item(struct qcom_smp2p *smp2p)
{
	struct smp2p_smem_item *out;
	unsigned smem_id = smp2p->smem_items[SMP2P_OUTBOUND];
	unsigned pid = smp2p->remote_pid;
	int ret;

	ret = qcom_smem_alloc(pid, smem_id, sizeof(*out));
	if (ret < 0 && ret != -EEXIST) {
		if (ret != -EPROBE_DEFER)
			dev_err(smp2p->dev,
				"unable to allocate local smp2p item\n");
		return ret;
	}

	out = qcom_smem_get(pid, smem_id, NULL);
	if (IS_ERR(out)) {
		dev_err(smp2p->dev, "Unable to acquire local smp2p item\n");
		return PTR_ERR(out);
	}

	memset(out, 0, sizeof(*out));
	out->magic = SMP2P_MAGIC;
	out->local_pid = smp2p->local_pid;
	out->remote_pid = smp2p->remote_pid;
	out->total_entries = SMP2P_MAX_ENTRY;
	out->valid_entries = 0;

	/*
	 * Make sure the rest of the header is written before we validate the
	 * item by writing a valid version number.
	 */
	wmb();
	out->version = 1;

	qcom_smp2p_kick(smp2p);

	smp2p->out = out;

	return 0;
}

static int smp2p_parse_ipc(struct qcom_smp2p *smp2p)
{
	struct device_node *syscon;
	struct device *dev = smp2p->dev;
	const char *key;
	int ret;

	syscon = of_parse_phandle(dev->of_node, "qcom,ipc", 0);
	if (!syscon) {
		dev_err(dev, "no qcom,ipc node\n");
		return -ENODEV;
	}

	smp2p->ipc_regmap = syscon_node_to_regmap(syscon);
	if (IS_ERR(smp2p->ipc_regmap))
		return PTR_ERR(smp2p->ipc_regmap);

	key = "qcom,ipc";
	ret = of_property_read_u32_index(dev->of_node, key, 1, &smp2p->ipc_offset);
	if (ret < 0) {
		dev_err(dev, "no offset in %s\n", key);
		return -EINVAL;
	}

	ret = of_property_read_u32_index(dev->of_node, key, 2, &smp2p->ipc_bit);
	if (ret < 0) {
		dev_err(dev, "no bit in %s\n", key);
		return -EINVAL;
	}

	return 0;
}

static int qcom_smp2p_probe(struct platform_device *pdev)
{
	struct smp2p_entry *entry;
	struct device_node *node;
	struct qcom_smp2p *smp2p;
	const char *key;
	int irq;
	int ret;

	smp2p = devm_kzalloc(&pdev->dev, sizeof(*smp2p), GFP_KERNEL);
	if (!smp2p)
		return -ENOMEM;

	smp2p->dev = &pdev->dev;
	INIT_LIST_HEAD(&smp2p->inbound);
	INIT_LIST_HEAD(&smp2p->outbound);

	platform_set_drvdata(pdev, smp2p);

	key = "qcom,smem";
	ret = of_property_read_u32_array(pdev->dev.of_node, key,
					 smp2p->smem_items, 2);
	if (ret)
		return ret;

	key = "qcom,local-pid";
	ret = of_property_read_u32(pdev->dev.of_node, key, &smp2p->local_pid);
	if (ret)
		goto report_read_failure;

	key = "qcom,remote-pid";
	ret = of_property_read_u32(pdev->dev.of_node, key, &smp2p->remote_pid);
	if (ret)
		goto report_read_failure;

	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
		dev_err(&pdev->dev, "unable to acquire smp2p interrupt\n");
		return irq;
	}

	smp2p->mbox_client.dev = &pdev->dev;
	smp2p->mbox_client.knows_txdone = true;
	smp2p->mbox_chan = mbox_request_channel(&smp2p->mbox_client, 0);
	if (IS_ERR(smp2p->mbox_chan)) {
		if (PTR_ERR(smp2p->mbox_chan) != -ENODEV)
			return PTR_ERR(smp2p->mbox_chan);

		smp2p->mbox_chan = NULL;

		ret = smp2p_parse_ipc(smp2p);
		if (ret)
			return ret;
	}

	ret = qcom_smp2p_alloc_outbound_item(smp2p);
	if (ret < 0)
		goto release_mbox;

	for_each_available_child_of_node(pdev->dev.of_node, node) {
		entry = devm_kzalloc(&pdev->dev, sizeof(*entry), GFP_KERNEL);
		if (!entry) {
			ret = -ENOMEM;
			goto unwind_interfaces;
		}

		entry->smp2p = smp2p;
		spin_lock_init(&entry->lock);

		ret = of_property_read_string(node, "qcom,entry-name", &entry->name);
		if (ret < 0)
			goto unwind_interfaces;

		if (of_property_read_bool(node, "interrupt-controller")) {
			ret = qcom_smp2p_inbound_entry(smp2p, entry, node);
			if (ret < 0)
				goto unwind_interfaces;

			list_add(&entry->node, &smp2p->inbound);
		} else  {
			ret = qcom_smp2p_outbound_entry(smp2p, entry, node);
			if (ret < 0)
				goto unwind_interfaces;

			list_add(&entry->node, &smp2p->outbound);
		}
	}

	/* Kick the outgoing edge after allocating entries */
	qcom_smp2p_kick(smp2p);

	ret = devm_request_threaded_irq(&pdev->dev, irq,
					NULL, qcom_smp2p_intr,
					IRQF_ONESHOT,
					"smp2p", (void *)smp2p);
	if (ret) {
		dev_err(&pdev->dev, "failed to request interrupt\n");
		goto unwind_interfaces;
	}


	return 0;

unwind_interfaces:
	list_for_each_entry(entry, &smp2p->inbound, node)
		irq_domain_remove(entry->domain);

	list_for_each_entry(entry, &smp2p->outbound, node)
		qcom_smem_state_unregister(entry->state);

	smp2p->out->valid_entries = 0;

release_mbox:
	mbox_free_channel(smp2p->mbox_chan);

	return ret;

report_read_failure:
	dev_err(&pdev->dev, "failed to read %s\n", key);
	return -EINVAL;
}

static int qcom_smp2p_remove(struct platform_device *pdev)
{
	struct qcom_smp2p *smp2p = platform_get_drvdata(pdev);
	struct smp2p_entry *entry;

	list_for_each_entry(entry, &smp2p->inbound, node)
		irq_domain_remove(entry->domain);

	list_for_each_entry(entry, &smp2p->outbound, node)
		qcom_smem_state_unregister(entry->state);

	mbox_free_channel(smp2p->mbox_chan);

	smp2p->out->valid_entries = 0;

	return 0;
}

static const struct of_device_id qcom_smp2p_of_match[] = {
	{ .compatible = "qcom,smp2p" },
	{}
};
MODULE_DEVICE_TABLE(of, qcom_smp2p_of_match);

static struct platform_driver qcom_smp2p_driver = {
	.probe = qcom_smp2p_probe,
	.remove = qcom_smp2p_remove,
	.driver  = {
		.name  = "qcom_smp2p",
		.of_match_table = qcom_smp2p_of_match,
	},
};
module_platform_driver(qcom_smp2p_driver);

MODULE_DESCRIPTION("Qualcomm Shared Memory Point to Point driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
97fb5e8d	1	// SPDX-License-Identifier: GPL-2.0-only
50e99641 BA	2	/*
	3	* Copyright (c) 2015, Sony Mobile Communications AB.
	4	* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
50e99641 BA	5	*/
	6
	7	#include <linux/interrupt.h>
	8	#include <linux/list.h>
	9	#include <linux/io.h>
	10	#include <linux/of.h>
	11	#include <linux/irq.h>
	12	#include <linux/irqdomain.h>
e7180264	13	#include <linux/mailbox_client.h>
50e99641 BA	14	#include <linux/mfd/syscon.h>
	15	#include <linux/module.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/regmap.h>
	18	#include <linux/soc/qcom/smem.h>
	19	#include <linux/soc/qcom/smem_state.h>
	20	#include <linux/spinlock.h>
	21
	22	/*
	23	* The Shared Memory Point to Point (SMP2P) protocol facilitates communication
	24	* of a single 32-bit value between two processors. Each value has a single
	25	* writer (the local side) and a single reader (the remote side). Values are
	26	* uniquely identified in the system by the directed edge (local processor ID
	27	* to remote processor ID) and a string identifier.
	28	*
	29	* Each processor is responsible for creating the outgoing SMEM items and each
	30	* item is writable by the local processor and readable by the remote
	31	* processor. By using two separate SMEM items that are single-reader and
	32	* single-writer, SMP2P does not require any remote locking mechanisms.
	33	*
	34	* The driver uses the Linux GPIO and interrupt framework to expose a virtual
	35	* GPIO for each outbound entry and a virtual interrupt controller for each
	36	* inbound entry.
	37	*/
	38
	39	#define SMP2P_MAX_ENTRY 16
	40	#define SMP2P_MAX_ENTRY_NAME 16
	41
	42	#define SMP2P_FEATURE_SSR_ACK 0x1
	43
	44	#define SMP2P_MAGIC 0x504d5324
	45
	46	/**
	47	* struct smp2p_smem_item - in memory communication structure
	48	* @magic: magic number
	49	* @version: version - must be 1
	50	* @features: features flag - currently unused
	51	* @local_pid: processor id of sending end
	52	* @remote_pid: processor id of receiving end
	53	* @total_entries: number of entries - always SMP2P_MAX_ENTRY
	54	* @valid_entries: number of allocated entries
	55	* @flags:
	56	* @entries: individual communication entries
	57	* @name: name of the entry
	58	* @value: content of the entry
	59	*/
	60	struct smp2p_smem_item {
	61	u32 magic;
	62	u8 version;
	63	unsigned features:24;
	64	u16 local_pid;
	65	u16 remote_pid;
	66	u16 total_entries;
	67	u16 valid_entries;
	68	u32 flags;
	69
	70	struct {
	71	u8 name[SMP2P_MAX_ENTRY_NAME];
	72	u32 value;
	73	} entries[SMP2P_MAX_ENTRY];
	74	} __packed;
	75
	76	/**
	77	* struct smp2p_entry - driver context matching one entry
78	* @node: list entry to keep track of allocated entries
79	* @smp2p: reference to the device driver context
80	* @name: name of the entry, to match against smp2p_smem_item
81	* @value: pointer to smp2p_smem_item entry value
82	* @last_value: last handled value
83	* @domain: irq_domain for inbound entries
84	* @irq_enabled:bitmap to track enabled irq bits
85	* @irq_rising: bitmap to mark irq bits for rising detection
86	* @irq_falling:bitmap to mark irq bits for falling detection
87	* @state: smem state handle
88	* @lock: spinlock to protect read-modify-write of the value
89	*/
90	struct smp2p_entry {
91	struct list_head node;
92	struct qcom_smp2p *smp2p;
93
94	const char *name;
95	u32 *value;
96	u32 last_value;
97
98	struct irq_domain *domain;
99	DECLARE_BITMAP(irq_enabled, 32);
100	DECLARE_BITMAP(irq_rising, 32);
101	DECLARE_BITMAP(irq_falling, 32);
102
103	struct qcom_smem_state *state;
104
105	spinlock_t lock;
106	};
107
108	#define SMP2P_INBOUND 0
109	#define SMP2P_OUTBOUND 1
110
111	/**
112	* struct qcom_smp2p - device driver context
113	* @dev: device driver handle
114	* @in: pointer to the inbound smem item
115	* @smem_items: ids of the two smem items
116	* @valid_entries: already scanned inbound entries
117	* @local_pid: processor id of the inbound edge
118	* @remote_pid: processor id of the outbound edge
119	* @ipc_regmap: regmap for the outbound ipc
120	* @ipc_offset: offset within the regmap
121	* @ipc_bit: bit in regmap@offset to kick to signal remote processor
e7180264 BA	122	* @mbox_client: mailbox client handle
e7180264 BA	123	* @mbox_chan: apcs ipc mailbox channel handle
50e99641 BA	124	* @inbound: list of inbound entries
	125	* @outbound: list of outbound entries
	126	*/
	127	struct qcom_smp2p {
	128	struct device *dev;
	129
	130	struct smp2p_smem_item *in;
	131	struct smp2p_smem_item *out;
	132
	133	unsigned smem_items[SMP2P_OUTBOUND + 1];
	134
	135	unsigned valid_entries;
	136
	137	unsigned local_pid;
	138	unsigned remote_pid;
	139
	140	struct regmap *ipc_regmap;
	141	int ipc_offset;
	142	int ipc_bit;
	143
e7180264 BA	144	struct mbox_client mbox_client;
	145	struct mbox_chan *mbox_chan;
	146
50e99641 BA	147	struct list_head inbound;
	148	struct list_head outbound;
	149	};
	150
	151	static void qcom_smp2p_kick(struct qcom_smp2p *smp2p)
	152	{
	153	/* Make sure any updated data is written before the kick */
	154	wmb();
e7180264 BA	155
	156	if (smp2p->mbox_chan) {
	157	mbox_send_message(smp2p->mbox_chan, NULL);
	158	mbox_client_txdone(smp2p->mbox_chan, 0);
	159	} else {
	160	regmap_write(smp2p->ipc_regmap, smp2p->ipc_offset, BIT(smp2p->ipc_bit));
	161	}
50e99641 BA	162	}
	163
	164	/**
	165	* qcom_smp2p_intr() - interrupt handler for incoming notifications
	166	* @irq: unused
	167	* @data: smp2p driver context
	168	*
	169	* Handle notifications from the remote side to handle newly allocated entries
	170	* or any changes to the state bits of existing entries.
	171	*/
	172	static irqreturn_t qcom_smp2p_intr(int irq, void *data)
	173	{
	174	struct smp2p_smem_item *in;
	175	struct smp2p_entry *entry;
	176	struct qcom_smp2p *smp2p = data;
	177	unsigned smem_id = smp2p->smem_items[SMP2P_INBOUND];
	178	unsigned pid = smp2p->remote_pid;
	179	size_t size;
	180	int irq_pin;
	181	u32 status;
	182	char buf[SMP2P_MAX_ENTRY_NAME];
	183	u32 val;
	184	int i;
	185
	186	in = smp2p->in;
	187
	188	/* Acquire smem item, if not already found */
	189	if (!in) {
	190	in = qcom_smem_get(pid, smem_id, &size);
	191	if (IS_ERR(in)) {
	192	dev_err(smp2p->dev,
	193	"Unable to acquire remote smp2p item\n");
	194	return IRQ_HANDLED;
	195	}
	196
	197	smp2p->in = in;
	198	}
	199
	200	/* Match newly created entries */
	201	for (i = smp2p->valid_entries; i < in->valid_entries; i++) {
	202	list_for_each_entry(entry, &smp2p->inbound, node) {
e7306dd7	203	memcpy(buf, in->entries[i].name, sizeof(buf));
50e99641 BA	204	if (!strcmp(buf, entry->name)) {
	205	entry->value = &in->entries[i].value;
	206	break;
	207	}
	208	}
	209	}
	210	smp2p->valid_entries = i;
	211
	212	/* Fire interrupts based on any value changes */
	213	list_for_each_entry(entry, &smp2p->inbound, node) {
	214	/* Ignore entries not yet allocated by the remote side */
	215	if (!entry->value)
	216	continue;
	217
	218	val = readl(entry->value);
	219
	220	status = val ^ entry->last_value;
	221	entry->last_value = val;
	222
	223	/* No changes of this entry? */
	224	if (!status)
	225	continue;
	226
	227	for_each_set_bit(i, entry->irq_enabled, 32) {
	228	if (!(status & BIT(i)))
	229	continue;
	230
	231	if ((val & BIT(i) && test_bit(i, entry->irq_rising)) \|\|
	232	(!(val & BIT(i)) && test_bit(i, entry->irq_falling))) {
	233	irq_pin = irq_find_mapping(entry->domain, i);
	234	handle_nested_irq(irq_pin);
	235	}
	236	}
	237	}
	238
	239	return IRQ_HANDLED;
	240	}
	241
	242	static void smp2p_mask_irq(struct irq_data *irqd)
	243	{
	244	struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
	245	irq_hw_number_t irq = irqd_to_hwirq(irqd);
	246
	247	clear_bit(irq, entry->irq_enabled);
	248	}
	249
	250	static void smp2p_unmask_irq(struct irq_data *irqd)
	251	{
	252	struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
	253	irq_hw_number_t irq = irqd_to_hwirq(irqd);
	254
	255	set_bit(irq, entry->irq_enabled);
	256	}
	257
	258	static int smp2p_set_irq_type(struct irq_data *irqd, unsigned int type)
	259	{
	260	struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
	261	irq_hw_number_t irq = irqd_to_hwirq(irqd);
	262
	263	if (!(type & IRQ_TYPE_EDGE_BOTH))
	264	return -EINVAL;
	265
	266	if (type & IRQ_TYPE_EDGE_RISING)
	267	set_bit(irq, entry->irq_rising);
268	else
269	clear_bit(irq, entry->irq_rising);
270
271	if (type & IRQ_TYPE_EDGE_FALLING)
272	set_bit(irq, entry->irq_falling);
273	else
274	clear_bit(irq, entry->irq_falling);
275
276	return 0;
277	}
278
279	static struct irq_chip smp2p_irq_chip = {
280	.name = "smp2p",
281	.irq_mask = smp2p_mask_irq,
282	.irq_unmask = smp2p_unmask_irq,
283	.irq_set_type = smp2p_set_irq_type,
284	};
285
286	static int smp2p_irq_map(struct irq_domain *d,
287	unsigned int irq,
288	irq_hw_number_t hw)
289	{
290	struct smp2p_entry *entry = d->host_data;
291
292	irq_set_chip_and_handler(irq, &smp2p_irq_chip, handle_level_irq);
293	irq_set_chip_data(irq, entry);
294	irq_set_nested_thread(irq, 1);
295	irq_set_noprobe(irq);
296
297	return 0;
298	}
299
300	static const struct irq_domain_ops smp2p_irq_ops = {
301	.map = smp2p_irq_map,
302	.xlate = irq_domain_xlate_twocell,
303	};
304
305	static int qcom_smp2p_inbound_entry(struct qcom_smp2p *smp2p,
306	struct smp2p_entry *entry,
307	struct device_node *node)
308	{
309	entry->domain = irq_domain_add_linear(node, 32, &smp2p_irq_ops, entry);
310	if (!entry->domain) {
311	dev_err(smp2p->dev, "failed to add irq_domain\n");
312	return -ENOMEM;
313	}
314
315	return 0;
316	}
317
318	static int smp2p_update_bits(void *data, u32 mask, u32 value)
319	{
320	struct smp2p_entry *entry = data;
321	u32 orig;
322	u32 val;
323
324	spin_lock(&entry->lock);
325	val = orig = readl(entry->value);
326	val &= ~mask;
327	val \|= value;
328	writel(val, entry->value);
329	spin_unlock(&entry->lock);
330
331	if (val != orig)
332	qcom_smp2p_kick(entry->smp2p);
333
334	return 0;
335	}
336
337	static const struct qcom_smem_state_ops smp2p_state_ops = {
338	.update_bits = smp2p_update_bits,
339	};
340
341	static int qcom_smp2p_outbound_entry(struct qcom_smp2p *smp2p,
342	struct smp2p_entry *entry,
343	struct device_node *node)
344	{
345	struct smp2p_smem_item *out = smp2p->out;
346	char buf[SMP2P_MAX_ENTRY_NAME] = {};
347
348	/* Allocate an entry from the smem item */
349	strlcpy(buf, entry->name, SMP2P_MAX_ENTRY_NAME);
e7306dd7	350	memcpy(out->entries[out->valid_entries].name, buf, SMP2P_MAX_ENTRY_NAME);
50e99641 BA	351
	352	/* Make the logical entry reference the physical value */
	353	entry->value = &out->entries[out->valid_entries].value;
	354
63af8e44 BA	355	out->valid_entries++;
63af8e44 BA	356
50e99641 BA	357	entry->state = qcom_smem_state_register(node, &smp2p_state_ops, entry);
	358	if (IS_ERR(entry->state)) {
	359	dev_err(smp2p->dev, "failed to register qcom_smem_state\n");
	360	return PTR_ERR(entry->state);
	361	}
	362
	363	return 0;
	364	}
	365
	366	static int qcom_smp2p_alloc_outbound_item(struct qcom_smp2p *smp2p)
	367	{
	368	struct smp2p_smem_item *out;
	369	unsigned smem_id = smp2p->smem_items[SMP2P_OUTBOUND];
	370	unsigned pid = smp2p->remote_pid;
	371	int ret;
	372
	373	ret = qcom_smem_alloc(pid, smem_id, sizeof(*out));
	374	if (ret < 0 && ret != -EEXIST) {
	375	if (ret != -EPROBE_DEFER)
	376	dev_err(smp2p->dev,
	377	"unable to allocate local smp2p item\n");
	378	return ret;
	379	}
	380
	381	out = qcom_smem_get(pid, smem_id, NULL);
	382	if (IS_ERR(out)) {
	383	dev_err(smp2p->dev, "Unable to acquire local smp2p item\n");
	384	return PTR_ERR(out);
	385	}
	386
	387	memset(out, 0, sizeof(*out));
	388	out->magic = SMP2P_MAGIC;
	389	out->local_pid = smp2p->local_pid;
	390	out->remote_pid = smp2p->remote_pid;
	391	out->total_entries = SMP2P_MAX_ENTRY;
	392	out->valid_entries = 0;
	393
	394	/*
	395	* Make sure the rest of the header is written before we validate the
	396	* item by writing a valid version number.
	397	*/
	398	wmb();
	399	out->version = 1;
	400
	401	qcom_smp2p_kick(smp2p);
	402
	403	smp2p->out = out;
	404
	405	return 0;
	406	}
	407
	408	static int smp2p_parse_ipc(struct qcom_smp2p *smp2p)
	409	{
	410	struct device_node *syscon;
	411	struct device *dev = smp2p->dev;
	412	const char *key;
	413	int ret;
	414
	415	syscon = of_parse_phandle(dev->of_node, "qcom,ipc", 0);
	416	if (!syscon) {
	417	dev_err(dev, "no qcom,ipc node\n");
	418	return -ENODEV;
	419	}
	420
421	smp2p->ipc_regmap = syscon_node_to_regmap(syscon);
422	if (IS_ERR(smp2p->ipc_regmap))
423	return PTR_ERR(smp2p->ipc_regmap);
424
425	key = "qcom,ipc";
426	ret = of_property_read_u32_index(dev->of_node, key, 1, &smp2p->ipc_offset);
427	if (ret < 0) {
428	dev_err(dev, "no offset in %s\n", key);
429	return -EINVAL;
430	}
431
432	ret = of_property_read_u32_index(dev->of_node, key, 2, &smp2p->ipc_bit);
433	if (ret < 0) {
434	dev_err(dev, "no bit in %s\n", key);
435	return -EINVAL;
436	}
437
438	return 0;
439	}
440
441	static int qcom_smp2p_probe(struct platform_device *pdev)
442	{
443	struct smp2p_entry *entry;
444	struct device_node *node;
445	struct qcom_smp2p *smp2p;
446	const char *key;
447	int irq;
448	int ret;
449
450	smp2p = devm_kzalloc(&pdev->dev, sizeof(*smp2p), GFP_KERNEL);
451	if (!smp2p)
452	return -ENOMEM;
453
454	smp2p->dev = &pdev->dev;
455	INIT_LIST_HEAD(&smp2p->inbound);
456	INIT_LIST_HEAD(&smp2p->outbound);
457
458	platform_set_drvdata(pdev, smp2p);
459
50e99641 BA	460	key = "qcom,smem";
	461	ret = of_property_read_u32_array(pdev->dev.of_node, key,
	462	smp2p->smem_items, 2);
	463	if (ret)
	464	return ret;
	465
	466	key = "qcom,local-pid";
	467	ret = of_property_read_u32(pdev->dev.of_node, key, &smp2p->local_pid);
c01fc227 ME	468	if (ret)
c01fc227 ME	469	goto report_read_failure;
50e99641 BA	470
	471	key = "qcom,remote-pid";
	472	ret = of_property_read_u32(pdev->dev.of_node, key, &smp2p->remote_pid);
c01fc227 ME	473	if (ret)
c01fc227 ME	474	goto report_read_failure;
50e99641 BA	475
	476	irq = platform_get_irq(pdev, 0);
	477	if (irq < 0) {
	478	dev_err(&pdev->dev, "unable to acquire smp2p interrupt\n");
	479	return irq;
	480	}
	481
e7180264 BA	482	smp2p->mbox_client.dev = &pdev->dev;
	483	smp2p->mbox_client.knows_txdone = true;
	484	smp2p->mbox_chan = mbox_request_channel(&smp2p->mbox_client, 0);
	485	if (IS_ERR(smp2p->mbox_chan)) {
	486	if (PTR_ERR(smp2p->mbox_chan) != -ENODEV)
	487	return PTR_ERR(smp2p->mbox_chan);
	488
	489	smp2p->mbox_chan = NULL;
	490
	491	ret = smp2p_parse_ipc(smp2p);
	492	if (ret)
	493	return ret;
	494	}
	495
50e99641 BA	496	ret = qcom_smp2p_alloc_outbound_item(smp2p);
50e99641 BA	497	if (ret < 0)
e7180264	498	goto release_mbox;
50e99641 BA	499
	500	for_each_available_child_of_node(pdev->dev.of_node, node) {
	501	entry = devm_kzalloc(&pdev->dev, sizeof(*entry), GFP_KERNEL);
	502	if (!entry) {
	503	ret = -ENOMEM;
	504	goto unwind_interfaces;
	505	}
	506
	507	entry->smp2p = smp2p;
	508	spin_lock_init(&entry->lock);
	509
	510	ret = of_property_read_string(node, "qcom,entry-name", &entry->name);
	511	if (ret < 0)
	512	goto unwind_interfaces;
	513
	514	if (of_property_read_bool(node, "interrupt-controller")) {
	515	ret = qcom_smp2p_inbound_entry(smp2p, entry, node);
	516	if (ret < 0)
	517	goto unwind_interfaces;
	518
	519	list_add(&entry->node, &smp2p->inbound);
	520	} else {
	521	ret = qcom_smp2p_outbound_entry(smp2p, entry, node);
	522	if (ret < 0)
	523	goto unwind_interfaces;
	524
	525	list_add(&entry->node, &smp2p->outbound);
	526	}
	527	}
	528
	529	/* Kick the outgoing edge after allocating entries */
	530	qcom_smp2p_kick(smp2p);
	531
	532	ret = devm_request_threaded_irq(&pdev->dev, irq,
	533	NULL, qcom_smp2p_intr,
	534	IRQF_ONESHOT,
	535	"smp2p", (void *)smp2p);
	536	if (ret) {
	537	dev_err(&pdev->dev, "failed to request interrupt\n");
	538	goto unwind_interfaces;
	539	}
	540
	541
	542	return 0;
	543
	544	unwind_interfaces:
	545	list_for_each_entry(entry, &smp2p->inbound, node)
	546	irq_domain_remove(entry->domain);
	547
	548	list_for_each_entry(entry, &smp2p->outbound, node)
	549	qcom_smem_state_unregister(entry->state);
	550
	551	smp2p->out->valid_entries = 0;
	552
e7180264 BA	553	release_mbox:
	554	mbox_free_channel(smp2p->mbox_chan);
	555
50e99641	556	return ret;
c01fc227 ME	557
	558	report_read_failure:
	559	dev_err(&pdev->dev, "failed to read %s\n", key);
	560	return -EINVAL;
50e99641 BA	561	}
	562
	563	static int qcom_smp2p_remove(struct platform_device *pdev)
	564	{
	565	struct qcom_smp2p *smp2p = platform_get_drvdata(pdev);
	566	struct smp2p_entry *entry;
	567
	568	list_for_each_entry(entry, &smp2p->inbound, node)
	569	irq_domain_remove(entry->domain);
	570
	571	list_for_each_entry(entry, &smp2p->outbound, node)
	572	qcom_smem_state_unregister(entry->state);
	573
e7180264 BA	574	mbox_free_channel(smp2p->mbox_chan);
e7180264 BA	575
50e99641 BA	576	smp2p->out->valid_entries = 0;
	577
	578	return 0;
	579	}
	580
	581	static const struct of_device_id qcom_smp2p_of_match[] = {
	582	{ .compatible = "qcom,smp2p" },
	583	{}
	584	};
	585	MODULE_DEVICE_TABLE(of, qcom_smp2p_of_match);
	586
	587	static struct platform_driver qcom_smp2p_driver = {
	588	.probe = qcom_smp2p_probe,
	589	.remove = qcom_smp2p_remove,
	590	.driver = {
	591	.name = "qcom_smp2p",
	592	.of_match_table = qcom_smp2p_of_match,
	593	},
	594	};
	595	module_platform_driver(qcom_smp2p_driver);
	596
	597	MODULE_DESCRIPTION("Qualcomm Shared Memory Point to Point driver");
	598	MODULE_LICENSE("GPL v2");