197fb5e8dSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
250e99641SBjorn Andersson /*
350e99641SBjorn Andersson * Copyright (c) 2015, Sony Mobile Communications AB.
450e99641SBjorn Andersson * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
550e99641SBjorn Andersson */
650e99641SBjorn Andersson
750e99641SBjorn Andersson #include <linux/interrupt.h>
850e99641SBjorn Andersson #include <linux/list.h>
950e99641SBjorn Andersson #include <linux/io.h>
1050e99641SBjorn Andersson #include <linux/of.h>
1150e99641SBjorn Andersson #include <linux/irq.h>
1250e99641SBjorn Andersson #include <linux/irqdomain.h>
13e7180264SBjorn Andersson #include <linux/mailbox_client.h>
1450e99641SBjorn Andersson #include <linux/mfd/syscon.h>
1550e99641SBjorn Andersson #include <linux/module.h>
1650e99641SBjorn Andersson #include <linux/platform_device.h>
171a561c52SDeepak Kumar Singh #include <linux/pm_wakeirq.h>
1850e99641SBjorn Andersson #include <linux/regmap.h>
1950e99641SBjorn Andersson #include <linux/soc/qcom/smem.h>
2050e99641SBjorn Andersson #include <linux/soc/qcom/smem_state.h>
2150e99641SBjorn Andersson #include <linux/spinlock.h>
2250e99641SBjorn Andersson
2350e99641SBjorn Andersson /*
2450e99641SBjorn Andersson * The Shared Memory Point to Point (SMP2P) protocol facilitates communication
2550e99641SBjorn Andersson * of a single 32-bit value between two processors. Each value has a single
2650e99641SBjorn Andersson * writer (the local side) and a single reader (the remote side). Values are
2750e99641SBjorn Andersson * uniquely identified in the system by the directed edge (local processor ID
2850e99641SBjorn Andersson * to remote processor ID) and a string identifier.
2950e99641SBjorn Andersson *
3050e99641SBjorn Andersson * Each processor is responsible for creating the outgoing SMEM items and each
3150e99641SBjorn Andersson * item is writable by the local processor and readable by the remote
3250e99641SBjorn Andersson * processor. By using two separate SMEM items that are single-reader and
3350e99641SBjorn Andersson * single-writer, SMP2P does not require any remote locking mechanisms.
3450e99641SBjorn Andersson *
3550e99641SBjorn Andersson * The driver uses the Linux GPIO and interrupt framework to expose a virtual
3650e99641SBjorn Andersson * GPIO for each outbound entry and a virtual interrupt controller for each
3750e99641SBjorn Andersson * inbound entry.
3850e99641SBjorn Andersson */
3950e99641SBjorn Andersson
4050e99641SBjorn Andersson #define SMP2P_MAX_ENTRY 16
4150e99641SBjorn Andersson #define SMP2P_MAX_ENTRY_NAME 16
4250e99641SBjorn Andersson
4350e99641SBjorn Andersson #define SMP2P_FEATURE_SSR_ACK 0x1
4485f75508SChris Lew #define SMP2P_FLAGS_RESTART_DONE_BIT 0
4585f75508SChris Lew #define SMP2P_FLAGS_RESTART_ACK_BIT 1
4650e99641SBjorn Andersson
4750e99641SBjorn Andersson #define SMP2P_MAGIC 0x504d5324
4885f75508SChris Lew #define SMP2P_ALL_FEATURES SMP2P_FEATURE_SSR_ACK
4950e99641SBjorn Andersson
5050e99641SBjorn Andersson /**
5150e99641SBjorn Andersson * struct smp2p_smem_item - in memory communication structure
5250e99641SBjorn Andersson * @magic: magic number
5350e99641SBjorn Andersson * @version: version - must be 1
5450e99641SBjorn Andersson * @features: features flag - currently unused
5550e99641SBjorn Andersson * @local_pid: processor id of sending end
5650e99641SBjorn Andersson * @remote_pid: processor id of receiving end
5750e99641SBjorn Andersson * @total_entries: number of entries - always SMP2P_MAX_ENTRY
5850e99641SBjorn Andersson * @valid_entries: number of allocated entries
5950e99641SBjorn Andersson * @flags:
6050e99641SBjorn Andersson * @entries: individual communication entries
6150e99641SBjorn Andersson * @name: name of the entry
6250e99641SBjorn Andersson * @value: content of the entry
6350e99641SBjorn Andersson */
6450e99641SBjorn Andersson struct smp2p_smem_item {
6550e99641SBjorn Andersson u32 magic;
6650e99641SBjorn Andersson u8 version;
6750e99641SBjorn Andersson unsigned features:24;
6850e99641SBjorn Andersson u16 local_pid;
6950e99641SBjorn Andersson u16 remote_pid;
7050e99641SBjorn Andersson u16 total_entries;
7150e99641SBjorn Andersson u16 valid_entries;
7250e99641SBjorn Andersson u32 flags;
7350e99641SBjorn Andersson
7450e99641SBjorn Andersson struct {
7550e99641SBjorn Andersson u8 name[SMP2P_MAX_ENTRY_NAME];
7650e99641SBjorn Andersson u32 value;
7750e99641SBjorn Andersson } entries[SMP2P_MAX_ENTRY];
7850e99641SBjorn Andersson } __packed;
7950e99641SBjorn Andersson
8050e99641SBjorn Andersson /**
8150e99641SBjorn Andersson * struct smp2p_entry - driver context matching one entry
8250e99641SBjorn Andersson * @node: list entry to keep track of allocated entries
8350e99641SBjorn Andersson * @smp2p: reference to the device driver context
8450e99641SBjorn Andersson * @name: name of the entry, to match against smp2p_smem_item
8550e99641SBjorn Andersson * @value: pointer to smp2p_smem_item entry value
8650e99641SBjorn Andersson * @last_value: last handled value
8750e99641SBjorn Andersson * @domain: irq_domain for inbound entries
8850e99641SBjorn Andersson * @irq_enabled:bitmap to track enabled irq bits
8950e99641SBjorn Andersson * @irq_rising: bitmap to mark irq bits for rising detection
9050e99641SBjorn Andersson * @irq_falling:bitmap to mark irq bits for falling detection
9150e99641SBjorn Andersson * @state: smem state handle
9250e99641SBjorn Andersson * @lock: spinlock to protect read-modify-write of the value
9350e99641SBjorn Andersson */
9450e99641SBjorn Andersson struct smp2p_entry {
9550e99641SBjorn Andersson struct list_head node;
9650e99641SBjorn Andersson struct qcom_smp2p *smp2p;
9750e99641SBjorn Andersson
9850e99641SBjorn Andersson const char *name;
9950e99641SBjorn Andersson u32 *value;
10050e99641SBjorn Andersson u32 last_value;
10150e99641SBjorn Andersson
10250e99641SBjorn Andersson struct irq_domain *domain;
10350e99641SBjorn Andersson DECLARE_BITMAP(irq_enabled, 32);
10450e99641SBjorn Andersson DECLARE_BITMAP(irq_rising, 32);
10550e99641SBjorn Andersson DECLARE_BITMAP(irq_falling, 32);
10650e99641SBjorn Andersson
10750e99641SBjorn Andersson struct qcom_smem_state *state;
10850e99641SBjorn Andersson
10950e99641SBjorn Andersson spinlock_t lock;
11050e99641SBjorn Andersson };
11150e99641SBjorn Andersson
11250e99641SBjorn Andersson #define SMP2P_INBOUND 0
11350e99641SBjorn Andersson #define SMP2P_OUTBOUND 1
11450e99641SBjorn Andersson
11550e99641SBjorn Andersson /**
11650e99641SBjorn Andersson * struct qcom_smp2p - device driver context
11750e99641SBjorn Andersson * @dev: device driver handle
11850e99641SBjorn Andersson * @in: pointer to the inbound smem item
1191f8933c2SLee Jones * @out: pointer to the outbound smem item
12050e99641SBjorn Andersson * @smem_items: ids of the two smem items
12150e99641SBjorn Andersson * @valid_entries: already scanned inbound entries
122d11a34a4SKrzysztof Kozlowski * @ssr_ack_enabled: SMP2P_FEATURE_SSR_ACK feature is supported and was enabled
123d11a34a4SKrzysztof Kozlowski * @ssr_ack: current cached state of the local ack bit
124d11a34a4SKrzysztof Kozlowski * @negotiation_done: whether negotiating finished
12550e99641SBjorn Andersson * @local_pid: processor id of the inbound edge
12650e99641SBjorn Andersson * @remote_pid: processor id of the outbound edge
12750e99641SBjorn Andersson * @ipc_regmap: regmap for the outbound ipc
12850e99641SBjorn Andersson * @ipc_offset: offset within the regmap
12950e99641SBjorn Andersson * @ipc_bit: bit in regmap@offset to kick to signal remote processor
130e7180264SBjorn Andersson * @mbox_client: mailbox client handle
131e7180264SBjorn Andersson * @mbox_chan: apcs ipc mailbox channel handle
13250e99641SBjorn Andersson * @inbound: list of inbound entries
13350e99641SBjorn Andersson * @outbound: list of outbound entries
13450e99641SBjorn Andersson */
13550e99641SBjorn Andersson struct qcom_smp2p {
13650e99641SBjorn Andersson struct device *dev;
13750e99641SBjorn Andersson
13850e99641SBjorn Andersson struct smp2p_smem_item *in;
13950e99641SBjorn Andersson struct smp2p_smem_item *out;
14050e99641SBjorn Andersson
14150e99641SBjorn Andersson unsigned smem_items[SMP2P_OUTBOUND + 1];
14250e99641SBjorn Andersson
14350e99641SBjorn Andersson unsigned valid_entries;
14450e99641SBjorn Andersson
14585f75508SChris Lew bool ssr_ack_enabled;
14685f75508SChris Lew bool ssr_ack;
14785f75508SChris Lew bool negotiation_done;
14885f75508SChris Lew
14950e99641SBjorn Andersson unsigned local_pid;
15050e99641SBjorn Andersson unsigned remote_pid;
15150e99641SBjorn Andersson
15250e99641SBjorn Andersson struct regmap *ipc_regmap;
15350e99641SBjorn Andersson int ipc_offset;
15450e99641SBjorn Andersson int ipc_bit;
15550e99641SBjorn Andersson
156e7180264SBjorn Andersson struct mbox_client mbox_client;
157e7180264SBjorn Andersson struct mbox_chan *mbox_chan;
158e7180264SBjorn Andersson
15950e99641SBjorn Andersson struct list_head inbound;
16050e99641SBjorn Andersson struct list_head outbound;
16150e99641SBjorn Andersson };
16250e99641SBjorn Andersson
qcom_smp2p_kick(struct qcom_smp2p * smp2p)16350e99641SBjorn Andersson static void qcom_smp2p_kick(struct qcom_smp2p *smp2p)
16450e99641SBjorn Andersson {
16550e99641SBjorn Andersson /* Make sure any updated data is written before the kick */
16650e99641SBjorn Andersson wmb();
167e7180264SBjorn Andersson
168e7180264SBjorn Andersson if (smp2p->mbox_chan) {
169e7180264SBjorn Andersson mbox_send_message(smp2p->mbox_chan, NULL);
170e7180264SBjorn Andersson mbox_client_txdone(smp2p->mbox_chan, 0);
171e7180264SBjorn Andersson } else {
17250e99641SBjorn Andersson regmap_write(smp2p->ipc_regmap, smp2p->ipc_offset, BIT(smp2p->ipc_bit));
17350e99641SBjorn Andersson }
174e7180264SBjorn Andersson }
17550e99641SBjorn Andersson
qcom_smp2p_check_ssr(struct qcom_smp2p * smp2p)17685f75508SChris Lew static bool qcom_smp2p_check_ssr(struct qcom_smp2p *smp2p)
17785f75508SChris Lew {
17885f75508SChris Lew struct smp2p_smem_item *in = smp2p->in;
17985f75508SChris Lew bool restart;
18085f75508SChris Lew
18185f75508SChris Lew if (!smp2p->ssr_ack_enabled)
18285f75508SChris Lew return false;
18385f75508SChris Lew
18485f75508SChris Lew restart = in->flags & BIT(SMP2P_FLAGS_RESTART_DONE_BIT);
18585f75508SChris Lew
18685f75508SChris Lew return restart != smp2p->ssr_ack;
18785f75508SChris Lew }
18885f75508SChris Lew
qcom_smp2p_do_ssr_ack(struct qcom_smp2p * smp2p)18985f75508SChris Lew static void qcom_smp2p_do_ssr_ack(struct qcom_smp2p *smp2p)
19085f75508SChris Lew {
19185f75508SChris Lew struct smp2p_smem_item *out = smp2p->out;
19285f75508SChris Lew u32 val;
19385f75508SChris Lew
19485f75508SChris Lew smp2p->ssr_ack = !smp2p->ssr_ack;
19585f75508SChris Lew
19685f75508SChris Lew val = out->flags & ~BIT(SMP2P_FLAGS_RESTART_ACK_BIT);
19785f75508SChris Lew if (smp2p->ssr_ack)
19885f75508SChris Lew val |= BIT(SMP2P_FLAGS_RESTART_ACK_BIT);
19985f75508SChris Lew out->flags = val;
20085f75508SChris Lew
20185f75508SChris Lew qcom_smp2p_kick(smp2p);
20285f75508SChris Lew }
20385f75508SChris Lew
qcom_smp2p_negotiate(struct qcom_smp2p * smp2p)20485f75508SChris Lew static void qcom_smp2p_negotiate(struct qcom_smp2p *smp2p)
20585f75508SChris Lew {
20685f75508SChris Lew struct smp2p_smem_item *out = smp2p->out;
20785f75508SChris Lew struct smp2p_smem_item *in = smp2p->in;
20885f75508SChris Lew
20985f75508SChris Lew if (in->version == out->version) {
21085f75508SChris Lew out->features &= in->features;
21185f75508SChris Lew
21285f75508SChris Lew if (out->features & SMP2P_FEATURE_SSR_ACK)
21385f75508SChris Lew smp2p->ssr_ack_enabled = true;
21485f75508SChris Lew
21585f75508SChris Lew smp2p->negotiation_done = true;
21685f75508SChris Lew }
21785f75508SChris Lew }
21885f75508SChris Lew
qcom_smp2p_notify_in(struct qcom_smp2p * smp2p)21985f75508SChris Lew static void qcom_smp2p_notify_in(struct qcom_smp2p *smp2p)
22050e99641SBjorn Andersson {
22150e99641SBjorn Andersson struct smp2p_smem_item *in;
22250e99641SBjorn Andersson struct smp2p_entry *entry;
22350e99641SBjorn Andersson int irq_pin;
22450e99641SBjorn Andersson u32 status;
22550e99641SBjorn Andersson char buf[SMP2P_MAX_ENTRY_NAME];
22650e99641SBjorn Andersson u32 val;
22750e99641SBjorn Andersson int i;
22850e99641SBjorn Andersson
22950e99641SBjorn Andersson in = smp2p->in;
23050e99641SBjorn Andersson
23150e99641SBjorn Andersson /* Match newly created entries */
23250e99641SBjorn Andersson for (i = smp2p->valid_entries; i < in->valid_entries; i++) {
23350e99641SBjorn Andersson list_for_each_entry(entry, &smp2p->inbound, node) {
234e7306dd7SBjorn Andersson memcpy(buf, in->entries[i].name, sizeof(buf));
23550e99641SBjorn Andersson if (!strcmp(buf, entry->name)) {
23650e99641SBjorn Andersson entry->value = &in->entries[i].value;
23750e99641SBjorn Andersson break;
23850e99641SBjorn Andersson }
23950e99641SBjorn Andersson }
24050e99641SBjorn Andersson }
24150e99641SBjorn Andersson smp2p->valid_entries = i;
24250e99641SBjorn Andersson
24350e99641SBjorn Andersson /* Fire interrupts based on any value changes */
24450e99641SBjorn Andersson list_for_each_entry(entry, &smp2p->inbound, node) {
24550e99641SBjorn Andersson /* Ignore entries not yet allocated by the remote side */
24650e99641SBjorn Andersson if (!entry->value)
24750e99641SBjorn Andersson continue;
24850e99641SBjorn Andersson
24950e99641SBjorn Andersson val = readl(entry->value);
25050e99641SBjorn Andersson
25150e99641SBjorn Andersson status = val ^ entry->last_value;
25250e99641SBjorn Andersson entry->last_value = val;
25350e99641SBjorn Andersson
25450e99641SBjorn Andersson /* No changes of this entry? */
25550e99641SBjorn Andersson if (!status)
25650e99641SBjorn Andersson continue;
25750e99641SBjorn Andersson
25850e99641SBjorn Andersson for_each_set_bit(i, entry->irq_enabled, 32) {
25950e99641SBjorn Andersson if (!(status & BIT(i)))
26050e99641SBjorn Andersson continue;
26150e99641SBjorn Andersson
26250e99641SBjorn Andersson if ((val & BIT(i) && test_bit(i, entry->irq_rising)) ||
26350e99641SBjorn Andersson (!(val & BIT(i)) && test_bit(i, entry->irq_falling))) {
26450e99641SBjorn Andersson irq_pin = irq_find_mapping(entry->domain, i);
26550e99641SBjorn Andersson handle_nested_irq(irq_pin);
26650e99641SBjorn Andersson }
26750e99641SBjorn Andersson }
26850e99641SBjorn Andersson }
26985f75508SChris Lew }
27050e99641SBjorn Andersson
27185f75508SChris Lew /**
27285f75508SChris Lew * qcom_smp2p_intr() - interrupt handler for incoming notifications
27385f75508SChris Lew * @irq: unused
27485f75508SChris Lew * @data: smp2p driver context
27585f75508SChris Lew *
27685f75508SChris Lew * Handle notifications from the remote side to handle newly allocated entries
27785f75508SChris Lew * or any changes to the state bits of existing entries.
27885f75508SChris Lew */
qcom_smp2p_intr(int irq,void * data)27985f75508SChris Lew static irqreturn_t qcom_smp2p_intr(int irq, void *data)
28085f75508SChris Lew {
28185f75508SChris Lew struct smp2p_smem_item *in;
28285f75508SChris Lew struct qcom_smp2p *smp2p = data;
28385f75508SChris Lew unsigned int smem_id = smp2p->smem_items[SMP2P_INBOUND];
28485f75508SChris Lew unsigned int pid = smp2p->remote_pid;
28585f75508SChris Lew bool ack_restart;
28685f75508SChris Lew size_t size;
28785f75508SChris Lew
28885f75508SChris Lew in = smp2p->in;
28985f75508SChris Lew
29085f75508SChris Lew /* Acquire smem item, if not already found */
29185f75508SChris Lew if (!in) {
29285f75508SChris Lew in = qcom_smem_get(pid, smem_id, &size);
29385f75508SChris Lew if (IS_ERR(in)) {
29485f75508SChris Lew dev_err(smp2p->dev,
29585f75508SChris Lew "Unable to acquire remote smp2p item\n");
29685f75508SChris Lew goto out;
29785f75508SChris Lew }
29885f75508SChris Lew
29985f75508SChris Lew smp2p->in = in;
30085f75508SChris Lew }
30185f75508SChris Lew
30285f75508SChris Lew if (!smp2p->negotiation_done)
30385f75508SChris Lew qcom_smp2p_negotiate(smp2p);
30485f75508SChris Lew
30585f75508SChris Lew if (smp2p->negotiation_done) {
30685f75508SChris Lew ack_restart = qcom_smp2p_check_ssr(smp2p);
30785f75508SChris Lew qcom_smp2p_notify_in(smp2p);
30885f75508SChris Lew
30985f75508SChris Lew if (ack_restart)
31085f75508SChris Lew qcom_smp2p_do_ssr_ack(smp2p);
31185f75508SChris Lew }
31285f75508SChris Lew
31385f75508SChris Lew out:
31450e99641SBjorn Andersson return IRQ_HANDLED;
31550e99641SBjorn Andersson }
31650e99641SBjorn Andersson
smp2p_mask_irq(struct irq_data * irqd)31750e99641SBjorn Andersson static void smp2p_mask_irq(struct irq_data *irqd)
31850e99641SBjorn Andersson {
31950e99641SBjorn Andersson struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
32050e99641SBjorn Andersson irq_hw_number_t irq = irqd_to_hwirq(irqd);
32150e99641SBjorn Andersson
32250e99641SBjorn Andersson clear_bit(irq, entry->irq_enabled);
32350e99641SBjorn Andersson }
32450e99641SBjorn Andersson
smp2p_unmask_irq(struct irq_data * irqd)32550e99641SBjorn Andersson static void smp2p_unmask_irq(struct irq_data *irqd)
32650e99641SBjorn Andersson {
32750e99641SBjorn Andersson struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
32850e99641SBjorn Andersson irq_hw_number_t irq = irqd_to_hwirq(irqd);
32950e99641SBjorn Andersson
33050e99641SBjorn Andersson set_bit(irq, entry->irq_enabled);
33150e99641SBjorn Andersson }
33250e99641SBjorn Andersson
smp2p_set_irq_type(struct irq_data * irqd,unsigned int type)33350e99641SBjorn Andersson static int smp2p_set_irq_type(struct irq_data *irqd, unsigned int type)
33450e99641SBjorn Andersson {
33550e99641SBjorn Andersson struct smp2p_entry *entry = irq_data_get_irq_chip_data(irqd);
33650e99641SBjorn Andersson irq_hw_number_t irq = irqd_to_hwirq(irqd);
33750e99641SBjorn Andersson
33850e99641SBjorn Andersson if (!(type & IRQ_TYPE_EDGE_BOTH))
33950e99641SBjorn Andersson return -EINVAL;
34050e99641SBjorn Andersson
34150e99641SBjorn Andersson if (type & IRQ_TYPE_EDGE_RISING)
34250e99641SBjorn Andersson set_bit(irq, entry->irq_rising);
34350e99641SBjorn Andersson else
34450e99641SBjorn Andersson clear_bit(irq, entry->irq_rising);
34550e99641SBjorn Andersson
34650e99641SBjorn Andersson if (type & IRQ_TYPE_EDGE_FALLING)
34750e99641SBjorn Andersson set_bit(irq, entry->irq_falling);
34850e99641SBjorn Andersson else
34950e99641SBjorn Andersson clear_bit(irq, entry->irq_falling);
35050e99641SBjorn Andersson
35150e99641SBjorn Andersson return 0;
35250e99641SBjorn Andersson }
35350e99641SBjorn Andersson
35450e99641SBjorn Andersson static struct irq_chip smp2p_irq_chip = {
35550e99641SBjorn Andersson .name = "smp2p",
35650e99641SBjorn Andersson .irq_mask = smp2p_mask_irq,
35750e99641SBjorn Andersson .irq_unmask = smp2p_unmask_irq,
35850e99641SBjorn Andersson .irq_set_type = smp2p_set_irq_type,
35950e99641SBjorn Andersson };
36050e99641SBjorn Andersson
smp2p_irq_map(struct irq_domain * d,unsigned int irq,irq_hw_number_t hw)36150e99641SBjorn Andersson static int smp2p_irq_map(struct irq_domain *d,
36250e99641SBjorn Andersson unsigned int irq,
36350e99641SBjorn Andersson irq_hw_number_t hw)
36450e99641SBjorn Andersson {
36550e99641SBjorn Andersson struct smp2p_entry *entry = d->host_data;
36650e99641SBjorn Andersson
36750e99641SBjorn Andersson irq_set_chip_and_handler(irq, &smp2p_irq_chip, handle_level_irq);
36850e99641SBjorn Andersson irq_set_chip_data(irq, entry);
36950e99641SBjorn Andersson irq_set_nested_thread(irq, 1);
37050e99641SBjorn Andersson irq_set_noprobe(irq);
37150e99641SBjorn Andersson
37250e99641SBjorn Andersson return 0;
37350e99641SBjorn Andersson }
37450e99641SBjorn Andersson
37550e99641SBjorn Andersson static const struct irq_domain_ops smp2p_irq_ops = {
37650e99641SBjorn Andersson .map = smp2p_irq_map,
37750e99641SBjorn Andersson .xlate = irq_domain_xlate_twocell,
37850e99641SBjorn Andersson };
37950e99641SBjorn Andersson
qcom_smp2p_inbound_entry(struct qcom_smp2p * smp2p,struct smp2p_entry * entry,struct device_node * node)38050e99641SBjorn Andersson static int qcom_smp2p_inbound_entry(struct qcom_smp2p *smp2p,
38150e99641SBjorn Andersson struct smp2p_entry *entry,
38250e99641SBjorn Andersson struct device_node *node)
38350e99641SBjorn Andersson {
38450e99641SBjorn Andersson entry->domain = irq_domain_add_linear(node, 32, &smp2p_irq_ops, entry);
38550e99641SBjorn Andersson if (!entry->domain) {
38650e99641SBjorn Andersson dev_err(smp2p->dev, "failed to add irq_domain\n");
38750e99641SBjorn Andersson return -ENOMEM;
38850e99641SBjorn Andersson }
38950e99641SBjorn Andersson
39050e99641SBjorn Andersson return 0;
39150e99641SBjorn Andersson }
39250e99641SBjorn Andersson
smp2p_update_bits(void * data,u32 mask,u32 value)39350e99641SBjorn Andersson static int smp2p_update_bits(void *data, u32 mask, u32 value)
39450e99641SBjorn Andersson {
39550e99641SBjorn Andersson struct smp2p_entry *entry = data;
396fc3e62e2SEvan Green unsigned long flags;
39750e99641SBjorn Andersson u32 orig;
39850e99641SBjorn Andersson u32 val;
39950e99641SBjorn Andersson
400fc3e62e2SEvan Green spin_lock_irqsave(&entry->lock, flags);
40150e99641SBjorn Andersson val = orig = readl(entry->value);
40250e99641SBjorn Andersson val &= ~mask;
40350e99641SBjorn Andersson val |= value;
40450e99641SBjorn Andersson writel(val, entry->value);
405fc3e62e2SEvan Green spin_unlock_irqrestore(&entry->lock, flags);
40650e99641SBjorn Andersson
40750e99641SBjorn Andersson if (val != orig)
40850e99641SBjorn Andersson qcom_smp2p_kick(entry->smp2p);
40950e99641SBjorn Andersson
41050e99641SBjorn Andersson return 0;
41150e99641SBjorn Andersson }
41250e99641SBjorn Andersson
41350e99641SBjorn Andersson static const struct qcom_smem_state_ops smp2p_state_ops = {
41450e99641SBjorn Andersson .update_bits = smp2p_update_bits,
41550e99641SBjorn Andersson };
41650e99641SBjorn Andersson
qcom_smp2p_outbound_entry(struct qcom_smp2p * smp2p,struct smp2p_entry * entry,struct device_node * node)41750e99641SBjorn Andersson static int qcom_smp2p_outbound_entry(struct qcom_smp2p *smp2p,
41850e99641SBjorn Andersson struct smp2p_entry *entry,
41950e99641SBjorn Andersson struct device_node *node)
42050e99641SBjorn Andersson {
42150e99641SBjorn Andersson struct smp2p_smem_item *out = smp2p->out;
42250e99641SBjorn Andersson char buf[SMP2P_MAX_ENTRY_NAME] = {};
42350e99641SBjorn Andersson
42450e99641SBjorn Andersson /* Allocate an entry from the smem item */
425*3f54a398SWolfram Sang strscpy(buf, entry->name, SMP2P_MAX_ENTRY_NAME);
426e7306dd7SBjorn Andersson memcpy(out->entries[out->valid_entries].name, buf, SMP2P_MAX_ENTRY_NAME);
42750e99641SBjorn Andersson
42850e99641SBjorn Andersson /* Make the logical entry reference the physical value */
42950e99641SBjorn Andersson entry->value = &out->entries[out->valid_entries].value;
43050e99641SBjorn Andersson
43163af8e44SBjorn Andersson out->valid_entries++;
43263af8e44SBjorn Andersson
43350e99641SBjorn Andersson entry->state = qcom_smem_state_register(node, &smp2p_state_ops, entry);
43450e99641SBjorn Andersson if (IS_ERR(entry->state)) {
43550e99641SBjorn Andersson dev_err(smp2p->dev, "failed to register qcom_smem_state\n");
43650e99641SBjorn Andersson return PTR_ERR(entry->state);
43750e99641SBjorn Andersson }
43850e99641SBjorn Andersson
43950e99641SBjorn Andersson return 0;
44050e99641SBjorn Andersson }
44150e99641SBjorn Andersson
qcom_smp2p_alloc_outbound_item(struct qcom_smp2p * smp2p)44250e99641SBjorn Andersson static int qcom_smp2p_alloc_outbound_item(struct qcom_smp2p *smp2p)
44350e99641SBjorn Andersson {
44450e99641SBjorn Andersson struct smp2p_smem_item *out;
44550e99641SBjorn Andersson unsigned smem_id = smp2p->smem_items[SMP2P_OUTBOUND];
44650e99641SBjorn Andersson unsigned pid = smp2p->remote_pid;
44750e99641SBjorn Andersson int ret;
44850e99641SBjorn Andersson
44950e99641SBjorn Andersson ret = qcom_smem_alloc(pid, smem_id, sizeof(*out));
45050e99641SBjorn Andersson if (ret < 0 && ret != -EEXIST) {
45150e99641SBjorn Andersson if (ret != -EPROBE_DEFER)
45250e99641SBjorn Andersson dev_err(smp2p->dev,
45350e99641SBjorn Andersson "unable to allocate local smp2p item\n");
45450e99641SBjorn Andersson return ret;
45550e99641SBjorn Andersson }
45650e99641SBjorn Andersson
45750e99641SBjorn Andersson out = qcom_smem_get(pid, smem_id, NULL);
45850e99641SBjorn Andersson if (IS_ERR(out)) {
45950e99641SBjorn Andersson dev_err(smp2p->dev, "Unable to acquire local smp2p item\n");
46050e99641SBjorn Andersson return PTR_ERR(out);
46150e99641SBjorn Andersson }
46250e99641SBjorn Andersson
46350e99641SBjorn Andersson memset(out, 0, sizeof(*out));
46450e99641SBjorn Andersson out->magic = SMP2P_MAGIC;
46550e99641SBjorn Andersson out->local_pid = smp2p->local_pid;
46650e99641SBjorn Andersson out->remote_pid = smp2p->remote_pid;
46750e99641SBjorn Andersson out->total_entries = SMP2P_MAX_ENTRY;
46850e99641SBjorn Andersson out->valid_entries = 0;
46985f75508SChris Lew out->features = SMP2P_ALL_FEATURES;
47050e99641SBjorn Andersson
47150e99641SBjorn Andersson /*
47250e99641SBjorn Andersson * Make sure the rest of the header is written before we validate the
47350e99641SBjorn Andersson * item by writing a valid version number.
47450e99641SBjorn Andersson */
47550e99641SBjorn Andersson wmb();
47650e99641SBjorn Andersson out->version = 1;
47750e99641SBjorn Andersson
47850e99641SBjorn Andersson qcom_smp2p_kick(smp2p);
47950e99641SBjorn Andersson
48050e99641SBjorn Andersson smp2p->out = out;
48150e99641SBjorn Andersson
48250e99641SBjorn Andersson return 0;
48350e99641SBjorn Andersson }
48450e99641SBjorn Andersson
smp2p_parse_ipc(struct qcom_smp2p * smp2p)48550e99641SBjorn Andersson static int smp2p_parse_ipc(struct qcom_smp2p *smp2p)
48650e99641SBjorn Andersson {
48750e99641SBjorn Andersson struct device_node *syscon;
48850e99641SBjorn Andersson struct device *dev = smp2p->dev;
48950e99641SBjorn Andersson const char *key;
49050e99641SBjorn Andersson int ret;
49150e99641SBjorn Andersson
49250e99641SBjorn Andersson syscon = of_parse_phandle(dev->of_node, "qcom,ipc", 0);
49350e99641SBjorn Andersson if (!syscon) {
49450e99641SBjorn Andersson dev_err(dev, "no qcom,ipc node\n");
49550e99641SBjorn Andersson return -ENODEV;
49650e99641SBjorn Andersson }
49750e99641SBjorn Andersson
49850e99641SBjorn Andersson smp2p->ipc_regmap = syscon_node_to_regmap(syscon);
4998fd3f18eSMiaoqian Lin of_node_put(syscon);
50050e99641SBjorn Andersson if (IS_ERR(smp2p->ipc_regmap))
50150e99641SBjorn Andersson return PTR_ERR(smp2p->ipc_regmap);
50250e99641SBjorn Andersson
50350e99641SBjorn Andersson key = "qcom,ipc";
50450e99641SBjorn Andersson ret = of_property_read_u32_index(dev->of_node, key, 1, &smp2p->ipc_offset);
50550e99641SBjorn Andersson if (ret < 0) {
50650e99641SBjorn Andersson dev_err(dev, "no offset in %s\n", key);
50750e99641SBjorn Andersson return -EINVAL;
50850e99641SBjorn Andersson }
50950e99641SBjorn Andersson
51050e99641SBjorn Andersson ret = of_property_read_u32_index(dev->of_node, key, 2, &smp2p->ipc_bit);
51150e99641SBjorn Andersson if (ret < 0) {
51250e99641SBjorn Andersson dev_err(dev, "no bit in %s\n", key);
51350e99641SBjorn Andersson return -EINVAL;
51450e99641SBjorn Andersson }
51550e99641SBjorn Andersson
51650e99641SBjorn Andersson return 0;
51750e99641SBjorn Andersson }
51850e99641SBjorn Andersson
qcom_smp2p_probe(struct platform_device * pdev)51950e99641SBjorn Andersson static int qcom_smp2p_probe(struct platform_device *pdev)
52050e99641SBjorn Andersson {
52150e99641SBjorn Andersson struct smp2p_entry *entry;
52250e99641SBjorn Andersson struct device_node *node;
52350e99641SBjorn Andersson struct qcom_smp2p *smp2p;
52450e99641SBjorn Andersson const char *key;
52550e99641SBjorn Andersson int irq;
52650e99641SBjorn Andersson int ret;
52750e99641SBjorn Andersson
52850e99641SBjorn Andersson smp2p = devm_kzalloc(&pdev->dev, sizeof(*smp2p), GFP_KERNEL);
52950e99641SBjorn Andersson if (!smp2p)
53050e99641SBjorn Andersson return -ENOMEM;
53150e99641SBjorn Andersson
53250e99641SBjorn Andersson smp2p->dev = &pdev->dev;
53350e99641SBjorn Andersson INIT_LIST_HEAD(&smp2p->inbound);
53450e99641SBjorn Andersson INIT_LIST_HEAD(&smp2p->outbound);
53550e99641SBjorn Andersson
53650e99641SBjorn Andersson platform_set_drvdata(pdev, smp2p);
53750e99641SBjorn Andersson
53850e99641SBjorn Andersson key = "qcom,smem";
53950e99641SBjorn Andersson ret = of_property_read_u32_array(pdev->dev.of_node, key,
54050e99641SBjorn Andersson smp2p->smem_items, 2);
54150e99641SBjorn Andersson if (ret)
54250e99641SBjorn Andersson return ret;
54350e99641SBjorn Andersson
54450e99641SBjorn Andersson key = "qcom,local-pid";
54550e99641SBjorn Andersson ret = of_property_read_u32(pdev->dev.of_node, key, &smp2p->local_pid);
546c01fc227SMarkus Elfring if (ret)
547c01fc227SMarkus Elfring goto report_read_failure;
54850e99641SBjorn Andersson
54950e99641SBjorn Andersson key = "qcom,remote-pid";
55050e99641SBjorn Andersson ret = of_property_read_u32(pdev->dev.of_node, key, &smp2p->remote_pid);
551c01fc227SMarkus Elfring if (ret)
552c01fc227SMarkus Elfring goto report_read_failure;
55350e99641SBjorn Andersson
55450e99641SBjorn Andersson irq = platform_get_irq(pdev, 0);
5551790c971SMarkus Elfring if (irq < 0)
55650e99641SBjorn Andersson return irq;
55750e99641SBjorn Andersson
558e7180264SBjorn Andersson smp2p->mbox_client.dev = &pdev->dev;
559e7180264SBjorn Andersson smp2p->mbox_client.knows_txdone = true;
560e7180264SBjorn Andersson smp2p->mbox_chan = mbox_request_channel(&smp2p->mbox_client, 0);
561e7180264SBjorn Andersson if (IS_ERR(smp2p->mbox_chan)) {
562e7180264SBjorn Andersson if (PTR_ERR(smp2p->mbox_chan) != -ENODEV)
563e7180264SBjorn Andersson return PTR_ERR(smp2p->mbox_chan);
564e7180264SBjorn Andersson
565e7180264SBjorn Andersson smp2p->mbox_chan = NULL;
566e7180264SBjorn Andersson
567e7180264SBjorn Andersson ret = smp2p_parse_ipc(smp2p);
568e7180264SBjorn Andersson if (ret)
569e7180264SBjorn Andersson return ret;
570e7180264SBjorn Andersson }
571e7180264SBjorn Andersson
57250e99641SBjorn Andersson ret = qcom_smp2p_alloc_outbound_item(smp2p);
57350e99641SBjorn Andersson if (ret < 0)
574e7180264SBjorn Andersson goto release_mbox;
57550e99641SBjorn Andersson
57650e99641SBjorn Andersson for_each_available_child_of_node(pdev->dev.of_node, node) {
57750e99641SBjorn Andersson entry = devm_kzalloc(&pdev->dev, sizeof(*entry), GFP_KERNEL);
57850e99641SBjorn Andersson if (!entry) {
57950e99641SBjorn Andersson ret = -ENOMEM;
580e1b391e9SWan Jiabing of_node_put(node);
58150e99641SBjorn Andersson goto unwind_interfaces;
58250e99641SBjorn Andersson }
58350e99641SBjorn Andersson
58450e99641SBjorn Andersson entry->smp2p = smp2p;
58550e99641SBjorn Andersson spin_lock_init(&entry->lock);
58650e99641SBjorn Andersson
58750e99641SBjorn Andersson ret = of_property_read_string(node, "qcom,entry-name", &entry->name);
588e1b391e9SWan Jiabing if (ret < 0) {
589e1b391e9SWan Jiabing of_node_put(node);
59050e99641SBjorn Andersson goto unwind_interfaces;
591e1b391e9SWan Jiabing }
59250e99641SBjorn Andersson
59350e99641SBjorn Andersson if (of_property_read_bool(node, "interrupt-controller")) {
59450e99641SBjorn Andersson ret = qcom_smp2p_inbound_entry(smp2p, entry, node);
595e1b391e9SWan Jiabing if (ret < 0) {
596e1b391e9SWan Jiabing of_node_put(node);
59750e99641SBjorn Andersson goto unwind_interfaces;
598e1b391e9SWan Jiabing }
59950e99641SBjorn Andersson
60050e99641SBjorn Andersson list_add(&entry->node, &smp2p->inbound);
60150e99641SBjorn Andersson } else {
60250e99641SBjorn Andersson ret = qcom_smp2p_outbound_entry(smp2p, entry, node);
603e1b391e9SWan Jiabing if (ret < 0) {
604e1b391e9SWan Jiabing of_node_put(node);
60550e99641SBjorn Andersson goto unwind_interfaces;
606e1b391e9SWan Jiabing }
60750e99641SBjorn Andersson
60850e99641SBjorn Andersson list_add(&entry->node, &smp2p->outbound);
60950e99641SBjorn Andersson }
61050e99641SBjorn Andersson }
61150e99641SBjorn Andersson
61250e99641SBjorn Andersson /* Kick the outgoing edge after allocating entries */
61350e99641SBjorn Andersson qcom_smp2p_kick(smp2p);
61450e99641SBjorn Andersson
61550e99641SBjorn Andersson ret = devm_request_threaded_irq(&pdev->dev, irq,
61650e99641SBjorn Andersson NULL, qcom_smp2p_intr,
61750e99641SBjorn Andersson IRQF_ONESHOT,
61850e99641SBjorn Andersson "smp2p", (void *)smp2p);
61950e99641SBjorn Andersson if (ret) {
62050e99641SBjorn Andersson dev_err(&pdev->dev, "failed to request interrupt\n");
62150e99641SBjorn Andersson goto unwind_interfaces;
62250e99641SBjorn Andersson }
62350e99641SBjorn Andersson
6241a561c52SDeepak Kumar Singh /*
6251a561c52SDeepak Kumar Singh * Treat smp2p interrupt as wakeup source, but keep it disabled
6261a561c52SDeepak Kumar Singh * by default. User space can decide enabling it depending on its
6271a561c52SDeepak Kumar Singh * use cases. For example if remoteproc crashes and device wants
6281a561c52SDeepak Kumar Singh * to handle it immediatedly (e.g. to not miss phone calls) it can
6291a561c52SDeepak Kumar Singh * enable wakeup source from user space, while other devices which
6301a561c52SDeepak Kumar Singh * do not have proper autosleep feature may want to handle it with
6311a561c52SDeepak Kumar Singh * other wakeup events (e.g. Power button) instead waking up immediately.
6321a561c52SDeepak Kumar Singh */
6331a561c52SDeepak Kumar Singh device_set_wakeup_capable(&pdev->dev, true);
6341a561c52SDeepak Kumar Singh
6351a561c52SDeepak Kumar Singh ret = dev_pm_set_wake_irq(&pdev->dev, irq);
6361a561c52SDeepak Kumar Singh if (ret)
6371a561c52SDeepak Kumar Singh goto set_wake_irq_fail;
63850e99641SBjorn Andersson
63950e99641SBjorn Andersson return 0;
64050e99641SBjorn Andersson
6411a561c52SDeepak Kumar Singh set_wake_irq_fail:
6421a561c52SDeepak Kumar Singh dev_pm_clear_wake_irq(&pdev->dev);
6431a561c52SDeepak Kumar Singh
64450e99641SBjorn Andersson unwind_interfaces:
64550e99641SBjorn Andersson list_for_each_entry(entry, &smp2p->inbound, node)
64650e99641SBjorn Andersson irq_domain_remove(entry->domain);
64750e99641SBjorn Andersson
64850e99641SBjorn Andersson list_for_each_entry(entry, &smp2p->outbound, node)
64950e99641SBjorn Andersson qcom_smem_state_unregister(entry->state);
65050e99641SBjorn Andersson
65150e99641SBjorn Andersson smp2p->out->valid_entries = 0;
65250e99641SBjorn Andersson
653e7180264SBjorn Andersson release_mbox:
654e7180264SBjorn Andersson mbox_free_channel(smp2p->mbox_chan);
655e7180264SBjorn Andersson
65650e99641SBjorn Andersson return ret;
657c01fc227SMarkus Elfring
658c01fc227SMarkus Elfring report_read_failure:
659c01fc227SMarkus Elfring dev_err(&pdev->dev, "failed to read %s\n", key);
660c01fc227SMarkus Elfring return -EINVAL;
66150e99641SBjorn Andersson }
66250e99641SBjorn Andersson
qcom_smp2p_remove(struct platform_device * pdev)66350e99641SBjorn Andersson static int qcom_smp2p_remove(struct platform_device *pdev)
66450e99641SBjorn Andersson {
66550e99641SBjorn Andersson struct qcom_smp2p *smp2p = platform_get_drvdata(pdev);
66650e99641SBjorn Andersson struct smp2p_entry *entry;
66750e99641SBjorn Andersson
6681a561c52SDeepak Kumar Singh dev_pm_clear_wake_irq(&pdev->dev);
6691a561c52SDeepak Kumar Singh
67050e99641SBjorn Andersson list_for_each_entry(entry, &smp2p->inbound, node)
67150e99641SBjorn Andersson irq_domain_remove(entry->domain);
67250e99641SBjorn Andersson
67350e99641SBjorn Andersson list_for_each_entry(entry, &smp2p->outbound, node)
67450e99641SBjorn Andersson qcom_smem_state_unregister(entry->state);
67550e99641SBjorn Andersson
676e7180264SBjorn Andersson mbox_free_channel(smp2p->mbox_chan);
677e7180264SBjorn Andersson
67850e99641SBjorn Andersson smp2p->out->valid_entries = 0;
67950e99641SBjorn Andersson
68050e99641SBjorn Andersson return 0;
68150e99641SBjorn Andersson }
68250e99641SBjorn Andersson
68350e99641SBjorn Andersson static const struct of_device_id qcom_smp2p_of_match[] = {
68450e99641SBjorn Andersson { .compatible = "qcom,smp2p" },
68550e99641SBjorn Andersson {}
68650e99641SBjorn Andersson };
68750e99641SBjorn Andersson MODULE_DEVICE_TABLE(of, qcom_smp2p_of_match);
68850e99641SBjorn Andersson
68950e99641SBjorn Andersson static struct platform_driver qcom_smp2p_driver = {
69050e99641SBjorn Andersson .probe = qcom_smp2p_probe,
69150e99641SBjorn Andersson .remove = qcom_smp2p_remove,
69250e99641SBjorn Andersson .driver = {
69350e99641SBjorn Andersson .name = "qcom_smp2p",
69450e99641SBjorn Andersson .of_match_table = qcom_smp2p_of_match,
69550e99641SBjorn Andersson },
69650e99641SBjorn Andersson };
69750e99641SBjorn Andersson module_platform_driver(qcom_smp2p_driver);
69850e99641SBjorn Andersson
69950e99641SBjorn Andersson MODULE_DESCRIPTION("Qualcomm Shared Memory Point to Point driver");
70050e99641SBjorn Andersson MODULE_LICENSE("GPL v2");
701