Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b9f2c2a8 authored by Yimin Peng's avatar Yimin Peng
Browse files

spmi: pmic_arb: add interrupt support to virtio spmi



Add another virtio queue to receive irq notification from
spmi backend. The virtio spmi controller is also a hierarchy
irqchip to handle pmic client interrupts.

Change-Id: I98f44492982340286b68a97537189c3b57c9cd5b
Signed-off-by: default avatarYimin Peng <yiminp@codeaurora.org>
parent e7bdcbc2
Loading
Loading
Loading
Loading
+207 −343
Original line number Diff line number Diff line
/*
 * Copyright (c) 2019, The Linux Foundation. All rights reserved.
 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
@@ -18,6 +18,7 @@
#include <linux/irqchip/chained_irq.h>
#include <linux/irqdomain.h>
#include <linux/irq.h>
#include <linux/of_irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
@@ -33,8 +34,6 @@
/* Mapping Table */
#define PMIC_ARB_MAX_PPID		BIT(12) /* PPID is 12bit */
#define PMIC_ARB_APID_VALID		BIT(15)
#define PMIC_ARB_CHAN_IS_IRQ_OWNER(reg)	((reg) & BIT(24))
#define INVALID_EE				0xFF

/* Command Opcodes */
enum pmic_arb_cmd_op_code {
@@ -79,18 +78,20 @@ struct pmic_arb_ver_ops;

struct apid_data {
	u16		ppid;
	u8		write_ee;
	u8		irq_ee;
	struct irq_desc *desc;
};

struct virtio_spmi {
	struct virtio_device	*vdev;
	struct virtqueue		*vq;
	spinlock_t              lock;
	struct virtio_spmi_config config;
	struct virtqueue		*txq;
	struct virtqueue		*rxq;
	spinlock_t              txlock;
	spinlock_t              rxlock;
	struct spmi_pmic_arb    *pa;
	struct virtio_spmi_config config;
	struct virtio_spmi_msg txmsg;
	struct virtio_spmi_msg rxmsgs[4];
};
static struct virtio_spmi *g_vspmi;

/**
 * spmi_pmic_arb - SPMI PMIC Arbiter object
@@ -111,6 +112,7 @@ struct spmi_pmic_arb {
	u16			max_apid;
	struct irq_domain	*domain;
	struct spmi_controller	*spmic;
	struct virtio_spmi	*vs;
	const struct pmic_arb_ver_ops *ver_ops;
	u16			*ppid_to_apid;
	struct apid_data	apid_data[PMIC_ARB_MAX_PERIPHS];
@@ -130,76 +132,90 @@ struct pmic_arb_ver_ops {
};

static int
vspmi_pmic_arb_xfer(struct spmi_pmic_arb *pa, struct virtio_spmi_msg *req)
vspmi_pmic_arb_xfer(struct spmi_pmic_arb *pa)
{
	struct scatterlist sg[1];
	struct virtio_spmi *vs = pa->vs;
	struct virtio_spmi_msg *msg = &vs->txmsg;
	struct virtio_spmi_msg *rsp;
	unsigned int vqlen;
	int rc = 0;

	struct scatterlist sg[1];
	unsigned int len;
	unsigned long flags;
	int rc = 0;

	sg_init_one(sg, req, virtio32_to_cpu(g_vspmi->vdev, req->len));
	sg_init_one(sg, msg, sizeof(*msg));

	spin_lock_irqsave(&g_vspmi->lock, flags);
	rc = virtqueue_add_outbuf(g_vspmi->vq, sg, 1, req, GFP_ATOMIC);
	spin_lock_irqsave(&vs->txlock, flags);
	rc = virtqueue_add_outbuf(vs->txq, sg, 1, msg, GFP_ATOMIC);
	if (rc) {
		dev_err(&g_vspmi->vdev->dev, "fail to add output buffer\n");
		dev_err(&vs->vdev->dev, "fail to add output buffer\n");
		goto out;
	}

	virtqueue_kick(g_vspmi->vq);
	virtqueue_kick(vs->txq);

	do {
		rsp = virtqueue_get_buf(g_vspmi->vq, &vqlen);
		rsp = virtqueue_get_buf(vs->txq, &len);
	} while (!rsp);
	rc = virtio32_to_cpu(g_vspmi->vdev, rsp->res);
	rc = virtio32_to_cpu(vs->vdev, rsp->res);

out:
	spin_unlock_irqrestore(&g_vspmi->lock, flags);
	spin_unlock_irqrestore(&vs->txlock, flags);
	return rc;
}

static struct virtio_spmi_msg *vspmi_init_msg(u32 len, u32 type, u32 u)
static struct virtio_spmi_msg *vspmi_fill_txmsg(struct spmi_pmic_arb *pa,
		u32 type, u32 cmd, u16 ppid, u32 regval)
{
	struct virtio_spmi_msg *req = NULL;
	struct virtio_spmi *vs = pa->vs;
	struct virtio_spmi_msg *msg = &vs->txmsg;

	memset(msg, 0x0, sizeof(*msg));

	req = kzalloc(len, GFP_ATOMIC);
	if (req) {
		req->len = cpu_to_virtio32(g_vspmi->vdev, len);
		req->type = cpu_to_virtio32(g_vspmi->vdev, type);
		req->u.cnt = req->u.cmd = cpu_to_virtio32(g_vspmi->vdev, u);
	if (type > VIO_SPMI_BUS_CMDMAX) {
		msg->payload.irqd.ppid =
			cpu_to_virtio16(vs->vdev, ppid);
		msg->payload.irqd.regval =
			cpu_to_virtio32(vs->vdev, regval);
	} else {
		dev_err(&g_vspmi->vdev->dev, "no atomic mem\n");
		msg->payload.cmdd.cmd =
			cpu_to_virtio32(vs->vdev, cmd);
	}
	msg->type = cpu_to_virtio32(vs->vdev, type);

	dev_dbg(&g_vspmi->vdev->dev, "len:%u type:%u u:%x\n", len, type, u);
	return req;
	return msg;
}

static void
vspmi_fill_one(struct virtio_spmi_msg *req, u32 ppid, u32 val)
static void vspmi_queue_rxmsg(struct virtio_spmi *vspmi,
		struct virtio_spmi_msg *msg)
{
	u32 idx = virtio32_to_cpu(g_vspmi->vdev, req->u.cnt);
	u32 type = virtio32_to_cpu(g_vspmi->vdev, req->type);
	struct scatterlist sg[1];

	req->payload[idx].irqd.ppid =
		cpu_to_virtio32(g_vspmi->vdev, ppid);
	if ((type == VIO_IRQ_CLEAR) || (type == VIO_ACC_ENABLE_WR))
		req->payload[idx].irqd.val =
			cpu_to_virtio32(g_vspmi->vdev, val);
	memset(msg, 0x0, sizeof(*msg));
	sg_init_one(sg, msg, sizeof(*msg));
	virtqueue_add_inbuf(vspmi->rxq, sg, 1, msg, GFP_ATOMIC);
}

	dev_dbg(&g_vspmi->vdev->dev, "spmi: cnt:%u ppid:%u val:%u\n", idx,
		virtio32_to_cpu(g_vspmi->vdev, req->payload[idx].irqd.ppid),
		virtio32_to_cpu(g_vspmi->vdev, req->payload[idx].irqd.val));
static void vspmi_fill_rxmsgs(struct virtio_spmi *vs)
{
	unsigned long flags;
	int i, size;

	req->u.cnt = cpu_to_virtio32(g_vspmi->vdev, (idx + 1));
	spin_lock_irqsave(&vs->rxlock, flags);
	size = virtqueue_get_vring_size(vs->rxq);
	if (size > ARRAY_SIZE(vs->rxmsgs))
		size = ARRAY_SIZE(vs->rxmsgs);
	for (i = 0; i < size; i++)
		vspmi_queue_rxmsg(vs, &vs->rxmsgs[i]);
	virtqueue_kick(vs->rxq);
	spin_unlock_irqrestore(&vs->rxlock, flags);
}

static int pmic_arb_read_cmd(struct spmi_controller *ctrl, u8 opc, u8 sid,
			     u16 addr, u8 *buf, size_t len)
{
	struct spmi_pmic_arb *pa = spmi_controller_get_drvdata(ctrl);
	struct virtio_spmi_msg *req;
	struct virtio_spmi *vs = pa->vs;
	struct virtio_spmi_msg *msg;
	u8 bc = len - 1;
	u32 data, cmd;
	int rc;
@@ -223,26 +239,22 @@ static int pmic_arb_read_cmd(struct spmi_controller *ctrl, u8 opc, u8 sid,

	cmd = pa->ver_ops->fmt_cmd(opc, sid, addr, bc);

	req = vspmi_init_msg(MSG_SZ(1), VIO_SPMI_BUS_READ, cmd);
	if (!req)
		return -ENOMEM;

	rc = vspmi_pmic_arb_xfer(pa, req);
	msg = vspmi_fill_txmsg(pa, VIO_SPMI_BUS_READ, cmd, 0, 0);
	rc = vspmi_pmic_arb_xfer(pa);
	if (rc)
		goto out;

	data = virtio32_to_cpu(g_vspmi->vdev,
			req->payload[0].cmdd.data[0]);
	data = virtio32_to_cpu(vs->vdev,
			msg->payload.cmdd.data[0]);
	memcpy(buf, &data, (bc & 3) + 1);

	if (bc > 3) {
		data = virtio32_to_cpu(g_vspmi->vdev,
				req->payload[0].cmdd.data[1]);
		data = virtio32_to_cpu(vs->vdev,
				msg->payload.cmdd.data[1]);
		memcpy((buf + 4), &data, ((bc - 4) & 3) + 1);
	}

out:
	kfree(req);
	return rc;
}

@@ -250,7 +262,8 @@ static int pmic_arb_write_cmd(struct spmi_controller *ctrl, u8 opc,
			    u8 sid, u16 addr, const u8 *buf, size_t len)
{
	struct spmi_pmic_arb *pa = spmi_controller_get_drvdata(ctrl);
	struct virtio_spmi_msg *req;
	struct virtio_spmi *vs = pa->vs;
	struct virtio_spmi_msg *msg;
	u8 bc = len - 1;
	u32 data, cmd;
	int rc;
@@ -275,22 +288,18 @@ static int pmic_arb_write_cmd(struct spmi_controller *ctrl, u8 opc,
		return -EINVAL;

	cmd = pa->ver_ops->fmt_cmd(opc, sid, addr, bc);

	req = vspmi_init_msg(MSG_SZ(1), VIO_SPMI_BUS_WRITE, cmd);
	if (!req)
		return -ENOMEM;
	msg = vspmi_fill_txmsg(pa, VIO_SPMI_BUS_WRITE, cmd, 0, 0);

	memcpy(&data, buf, (bc & 3) + 1);
	req->payload[0].cmdd.data[0] = cpu_to_virtio32(g_vspmi->vdev, data);
	msg->payload.cmdd.data[0] = cpu_to_virtio32(vs->vdev, data);
	if (bc > 3) {
		memcpy(&data, (buf + 4), ((bc - 4) & 3) + 1);
		req->payload[0].cmdd.data[1] =
			cpu_to_virtio32(g_vspmi->vdev, data);
		msg->payload.cmdd.data[1] =
			cpu_to_virtio32(vs->vdev, data);
	}

	rc = vspmi_pmic_arb_xfer(pa, req);
	rc = vspmi_pmic_arb_xfer(pa);

	kfree(req);
	return rc;
}

@@ -337,130 +346,37 @@ static void qpnpint_spmi_read(struct irq_data *d, u8 reg, void *buf, size_t len)
				"failed irqchip transaction on %x\n", d->irq);
}

static void cleanup_irq(struct spmi_pmic_arb *pa, u16 apid, int id)
{
	u16 ppid = pa->apid_data[apid].ppid;
	u8 sid = ppid >> 8;
	u8 per = ppid & 0xFF;
	u8 irq_mask = BIT(id);

	struct virtio_spmi_msg *req;

	req = vspmi_init_msg(MSG_SZ(1), VIO_IRQ_CLEAR, 0);
	if (req) {
		dev_err_ratelimited(&pa->spmic->dev,
			"%s apid=%d sid=0x%x per=0x%x irq=%d\n",
			__func__, apid, sid, per, id);

		vspmi_fill_one(req, ppid, irq_mask);
		vspmi_pmic_arb_xfer(pa, req);
		kfree(req);
	}
}

static void periph_interrupt(struct spmi_pmic_arb *pa, u16 apid)
{
	unsigned int irq;
	u32 status, id;
	u32 id = 0;
	u8 sid = (pa->apid_data[apid].ppid >> 8) & 0xF;
	u8 per = pa->apid_data[apid].ppid & 0xFF;

	struct virtio_spmi_msg *req;

	req = vspmi_init_msg(MSG_SZ(1), VIO_IRQ_STATUS, 0);
	if (!req)
		return;

	vspmi_fill_one(req, pa->apid_data[apid].ppid, 0);
	if (vspmi_pmic_arb_xfer(pa, req)) {
		kfree(req);
		return;
	}

	status = virtio32_to_cpu(g_vspmi->vdev,
			req->payload[0].irqd.val);
	kfree(req);

	while (status) {
		id = ffs(status) - 1;
		status &= ~BIT(id);
	irq = irq_find_mapping(pa->domain,
					spec_to_hwirq(sid, per, id, apid));
		if (irq == 0) {
			cleanup_irq(pa, apid, id);
			continue;
		}
	generic_handle_irq(irq);
}
}

static void pmic_arb_chained_irq(struct irq_desc *desc)
static void pmic_arb_chained_irq(struct virtio_spmi *vs,
		struct virtio_spmi_msg *msg)
{
	struct spmi_pmic_arb *pa = irq_desc_get_handler_data(desc);
	struct irq_chip *chip = irq_desc_get_chip(desc);

	u32 enable;
	int i;
	u16 ppid;
	struct spmi_pmic_arb *pa = vs->pa;
	struct apid_data *apidd = pa->apid_data;

	struct virtio_spmi_msg *req;
	u32 *irq_status;
	u16 ppid = virtio16_to_cpu(vs->vdev, msg->payload.irqd.ppid);
	u16 apid = pa->ver_ops->ppid_to_apid(pa, ppid);

	irq_status = kzalloc((pa->max_apid + 1) * sizeof(u32), GFP_ATOMIC);
	if (!irq_status)
		return;
	struct irq_desc *desc = apidd[apid].desc;
	struct irq_chip *chip = irq_desc_get_chip(desc);

	chained_irq_enter(chip, desc);

	/* get all irq_status */
	req = vspmi_init_msg(MSG_SZ(pa->max_apid + 1), VIO_IRQ_STATUS, 0);
	if (req) {
		for (i = pa->min_apid; i <= pa->max_apid; i++) {
			ppid = pa->apid_data[i].ppid;
			vspmi_fill_one(req, ppid, 0);
		}
	} else
		goto out;

	if (vspmi_pmic_arb_xfer(pa, req)) {
		kfree(req);
		goto out;
	}

	for (i = pa->min_apid; i <= pa->max_apid; i++)
		irq_status[i] = virtio32_to_cpu(g_vspmi->vdev,
				req->payload[i].irqd.val);
	kfree(req);

	/* ACC_STATUS is empty but IRQ fired check IRQ_STATUS */
	for (i = pa->min_apid; i <= pa->max_apid; i++) {
		ppid = pa->apid_data[i].ppid;

		if (irq_status[i]) {
			req = vspmi_init_msg(MSG_SZ(1), VIO_ACC_ENABLE_RD, 0);
			if (!req)
				goto out;

			vspmi_fill_one(req, ppid, 0);
			if (vspmi_pmic_arb_xfer(pa, req))
				goto out;

			enable = virtio32_to_cpu(g_vspmi->vdev,
					req->payload[0].irqd.val);
			kfree(req);

			if (enable & SPMI_PIC_ACC_ENABLE_BIT) {
	dev_dbg(&pa->spmic->dev,
					"Dispatching IRQ for apid=%d status=%x\n",
					i, irq_status[i]);
				periph_interrupt(pa, i);
			}
		}
	}
			"Dispatching IRQ for apid=%x ppid=%x\n",
			apid, ppid);
	periph_interrupt(pa, apid);

out:
	chained_irq_exit(chip, desc);
	kfree(irq_status);
}

static void qpnpint_irq_ack(struct irq_data *d)
@@ -471,15 +387,8 @@ static void qpnpint_irq_ack(struct irq_data *d)
	u16 ppid = pa->apid_data[apid].ppid;
	u8 data;

	struct virtio_spmi_msg *req;

	req = vspmi_init_msg(MSG_SZ(1), VIO_IRQ_CLEAR, 0);
	if (req) {
		vspmi_fill_one(req, ppid, BIT(irq));
		vspmi_pmic_arb_xfer(pa, req);
		kfree(req);
	} else
		return;
	vspmi_fill_txmsg(pa, VIO_IRQ_CLEAR, 0, ppid, BIT(irq));
	vspmi_pmic_arb_xfer(pa);

	data = BIT(irq);
	qpnpint_spmi_write(d, QPNPINT_REG_LATCHED_CLR, &data, 1);
@@ -499,17 +408,14 @@ static void qpnpint_irq_unmask(struct irq_data *d)
	u8 irq = hwirq_to_irq(d->hwirq);
	u16 apid = hwirq_to_apid(d->hwirq);
	u16 ppid = pa->apid_data[apid].ppid;
	struct apid_data *apidd = pa->apid_data;
	u8 buf[2];

	struct virtio_spmi_msg *req;
	apidd[apid].desc = irq_data_to_desc(d);

	req = vspmi_init_msg(MSG_SZ(1), VIO_ACC_ENABLE_WR, 0);
	if (req) {
		vspmi_fill_one(req, ppid, SPMI_PIC_ACC_ENABLE_BIT);
		vspmi_pmic_arb_xfer(pa, req);
		kfree(req);
	} else
		return;
	vspmi_fill_txmsg(pa, VIO_ACC_ENABLE_WR, 0,
			ppid, SPMI_PIC_ACC_ENABLE_BIT);
	vspmi_pmic_arb_xfer(pa);

	qpnpint_spmi_read(d, QPNPINT_REG_EN_SET, &buf[0], 1);
	if (!(buf[0] & BIT(irq))) {
@@ -592,19 +498,6 @@ static int qpnpint_get_irqchip_state(struct irq_data *d,

static int qpnpint_irq_request_resources(struct irq_data *d)
{
	struct spmi_pmic_arb *pa = irq_data_get_irq_chip_data(d);
	u16 periph = hwirq_to_per(d->hwirq);
	u16 apid = hwirq_to_apid(d->hwirq);
	u16 sid = hwirq_to_sid(d->hwirq);
	u16 irq = hwirq_to_irq(d->hwirq);

	if (pa->apid_data[apid].irq_ee != pa->ee) {
		dev_err(&pa->spmic->dev, "failed to xlate sid = %#x, periph = %#x, irq = %u: ee=%u but owner=%u\n",
			sid, periph, irq, pa->ee,
			pa->apid_data[apid].irq_ee);
		return -ENODEV;
	}

	return 0;
}

@@ -642,7 +535,8 @@ static int qpnpint_irq_domain_dt_translate(struct irq_domain *d,
	u16 apid, ppid;
	int rc;

	dev_dbg(&pa->spmic->dev, "intspec[0] 0x%1x intspec[1] 0x%02x intspec[2] 0x%02x\n",
	dev_dbg(&pa->spmic->dev,
			"intspec[0] 0x%1x intspec[1] 0x%02x intspec[2] 0x%02x\n",
			intspec[0], intspec[1], intspec[2]);

	if (irq_domain_get_of_node(d) != controller)
@@ -655,7 +549,8 @@ static int qpnpint_irq_domain_dt_translate(struct irq_domain *d,
	ppid = intspec[0] << 8 | intspec[1];
	rc = pa->ver_ops->ppid_to_apid(pa, ppid);
	if (rc < 0) {
		dev_err(&pa->spmic->dev, "failed to xlate sid = %#x, periph = %#x, irq = %u rc = %d\n",
		dev_err(&pa->spmic->dev,
				"failed to xlate sid = %#x, periph = %#x, irq = %u rc = %d\n",
				intspec[0], intspec[1], intspec[2], rc);
		return rc;
	}
@@ -691,31 +586,30 @@ static int qpnpint_irq_domain_map(struct irq_domain *d,

static int pmic_arb_read_apid_map_v5(struct spmi_pmic_arb *pa)
{
	struct virtio_spmi *vs = pa->vs;
	struct apid_data *apidd = pa->apid_data;
	u16 apid, ppid;
	u16 i;

	for (i = 0; i < VM_MAX_PERIPHS; i++) {
		ppid = g_vspmi->config.ppid_allowed[i];
		ppid = vs->config.ppid_allowed[i];
		if (!ppid)
			break;

		apid = i;
		pa->ppid_to_apid[ppid] = apid | PMIC_ARB_APID_VALID;
		pa->apid_data[apid].ppid = ppid;
		pa->apid_data[apid].irq_ee = 0;
		pa->apid_data[apid].write_ee = 0;
		pa->apid_data[apid].desc = NULL;
	}

	/* Dump the mapping table for debug purposes. */
	dev_dbg(&pa->spmic->dev, "PPID APID Write-EE IRQ-EE\n");
	dev_dbg(&pa->spmic->dev, "PPID APID IRQ-DESC\n");
	for (ppid = 0; ppid < PMIC_ARB_MAX_PPID; ppid++) {
		apid = pa->ppid_to_apid[ppid];
		if (apid & PMIC_ARB_APID_VALID) {
			apid &= ~PMIC_ARB_APID_VALID;
			apidd = &pa->apid_data[apid];
			dev_dbg(&pa->spmic->dev, "%#03X %3u %2u %2u\n",
			      ppid, apid, apidd->write_ee, apidd->irq_ee);
			dev_dbg(&pa->spmic->dev, "%#03X %3u %llx\n",
			      ppid, apid, apidd[apid].desc);
		}
	}

@@ -747,40 +641,85 @@ static const struct irq_domain_ops pmic_arb_irq_domain_ops = {
	.activate	= qpnpint_irq_domain_activate,
};

static int spmi_pmic_arb_probe(struct platform_device *pdev)
static void viospmi_rx_isr(struct virtqueue *vq)
{
	struct virtio_spmi *vs = vq->vdev->priv;
	struct virtio_spmi_msg *msg;
	unsigned long flags;
	unsigned int len;

	spin_lock_irqsave(&vs->rxlock, flags);
	while ((msg = virtqueue_get_buf(vs->rxq, &len)) != NULL) {
		spin_unlock_irqrestore(&vs->rxlock, flags);
		pmic_arb_chained_irq(vs, msg);
		spin_lock_irqsave(&vs->rxlock, flags);
		vspmi_queue_rxmsg(vs, msg);
	}

	virtqueue_kick(vs->rxq);
	spin_unlock_irqrestore(&vs->rxlock, flags);
}

static int virtio_spmi_init_vqs(struct virtio_spmi *vspmi)
{
	struct virtqueue *vqs[2];
	vq_callback_t *cbs[] = { NULL, viospmi_rx_isr };
	static const char * const names[] = { "vs.tx", "vs.rx" };
	int rc;

	rc = virtio_find_vqs(vspmi->vdev, 2, vqs, cbs, names, NULL);
	if (rc)
		return rc;

	vspmi->txq = vqs[0];
	vspmi->rxq = vqs[1];

	return 0;
}

static void virtio_spmi_del_vqs(struct virtio_spmi *vspmi)
{
	vspmi->vdev->config->del_vqs(vspmi->vdev);
}

static int virtio_spmi_probe(struct virtio_device *vdev)
{
	struct virtio_spmi *vs;
	int i;
	int ret = 0;
	u32 val;

	struct spmi_pmic_arb *pa;
	struct spmi_controller *ctrl;
	int err;
	u32 ee;

	if (!g_vspmi)
		return -EINVAL;
	if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
		return -ENODEV;

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

	vdev->priv = vs;
	vs->vdev = vdev;
	spin_lock_init(&vs->txlock);
	spin_lock_init(&vs->rxlock);

	ret = virtio_spmi_init_vqs(vs);
	if (ret)
		goto err_init_vq;

	ctrl = spmi_controller_alloc(&pdev->dev, sizeof(*pa));
	ctrl = spmi_controller_alloc(&vdev->dev, sizeof(*pa));
	if (!ctrl)
		return -ENOMEM;

	pa = spmi_controller_get_drvdata(ctrl);
	pa = vs->pa = spmi_controller_get_drvdata(ctrl);
	pa->spmic = ctrl;
	g_vspmi->pa = pa;
	pa->vs = vs;

	pa->ver_ops = &pmic_arb_v5;
	dev_info(&ctrl->dev, "Virtio PMIC arbiter\n");

	pa->irq = platform_get_irq_byname(pdev, "periph_irq");
	if (pa->irq < 0) {
		err = pa->irq;
		goto err_put_ctrl;
	}

	err = of_property_read_u32(pdev->dev.of_node, "qcom,ee", &ee);
	if (err) {
		dev_err(&pdev->dev, "EE unspecified.\n");
		goto err_put_ctrl;
	}
	pa->ee = ee;

	pa->ppid_to_apid = devm_kcalloc(&ctrl->dev, PMIC_ARB_MAX_PPID,
					      sizeof(*pa->ppid_to_apid),
					      GFP_KERNEL);
@@ -795,28 +734,48 @@ static int spmi_pmic_arb_probe(struct platform_device *pdev)
	pa->max_apid = 0;
	pa->min_apid = PMIC_ARB_MAX_PERIPHS - 1;

	platform_set_drvdata(pdev, ctrl);

	ctrl->read_cmd = pmic_arb_read_cmd;
	ctrl->write_cmd = pmic_arb_write_cmd;
	ctrl->dev.of_node = (vdev->dev.parent)->of_node;

	pa->irq = of_irq_get_byname(ctrl->dev.of_node, "periph_irq");
	if (pa->irq < 0) {
		err = pa->irq;
		goto err_put_ctrl;
	}

	virtio_device_ready(vdev);
	vspmi_fill_rxmsgs(vs);

	memset(&vs->config, 0x0, sizeof(vs->config));

	for (i = 0; i < VM_MAX_PERIPHS; i += 2) {
		val = virtio_cread32(vdev,
			offsetof(struct virtio_spmi_config, ppid_allowed[i]));
		vs->config.ppid_allowed[i] = val & PMIC_ARB_PPID_MASK;
		vs->config.ppid_allowed[i + 1] =
					(val >> 16) & PMIC_ARB_PPID_MASK;
		if ((!vs->config.ppid_allowed[i]) ||
				!(vs->config.ppid_allowed[i + 1]))
			break;
	}

	err = pmic_arb_read_apid_map_v5(pa);
	if (err) {
		dev_err(&pdev->dev, "could not read APID->PPID mapping table, rc= %d\n",
		dev_err(&vdev->dev, "could not read APID->PPID mapping table, rc= %d\n",
			err);
		goto err_put_ctrl;
	}

	dev_dbg(&pdev->dev, "adding irq domain\n");
	pa->domain = irq_domain_add_tree(pdev->dev.of_node,
	dev_dbg(&vdev->dev, "adding irq domain\n");
	pa->domain = irq_domain_add_tree(ctrl->dev.of_node,
					 &pmic_arb_irq_domain_ops, pa);
	if (!pa->domain) {
		dev_err(&pdev->dev, "unable to create irq_domain\n");
		dev_err(&vdev->dev, "unable to create irq_domain\n");
		err = -ENOMEM;
		goto err_put_ctrl;
	}

	irq_set_chained_handler_and_data(pa->irq, pmic_arb_chained_irq, pa);
	err = spmi_controller_add(ctrl);
	if (err)
		goto err_domain_remove;
@@ -824,119 +783,24 @@ static int spmi_pmic_arb_probe(struct platform_device *pdev)
	return 0;

err_domain_remove:
	irq_set_chained_handler_and_data(pa->irq, NULL, NULL);
	irq_domain_remove(pa->domain);
err_put_ctrl:
	spmi_controller_put(ctrl);
	return err;
}

static int spmi_pmic_arb_remove(struct platform_device *pdev)
{
	struct spmi_controller *ctrl = platform_get_drvdata(pdev);
	struct spmi_pmic_arb *pa = spmi_controller_get_drvdata(ctrl);

	spmi_controller_remove(ctrl);
	irq_set_chained_handler_and_data(pa->irq, NULL, NULL);
	irq_domain_remove(pa->domain);
	spmi_controller_put(ctrl);
	return 0;
}

static const struct of_device_id spmi_pmic_arb_match_table[] = {
	{ .compatible = "qcom,viospmi-pmic-arb", },
	{},
};
MODULE_DEVICE_TABLE(of, spmi_pmic_arb_match_table);

static struct platform_driver spmi_pmic_arb_driver = {
	.probe		= spmi_pmic_arb_probe,
	.remove		= spmi_pmic_arb_remove,
	.driver		= {
		.name	= "viospmi_pmic_arb",
		.of_match_table = spmi_pmic_arb_match_table,
		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
	},
};

static void virtio_spmi_isr(struct virtqueue *vq) { }

static int virtio_spmi_init_vqs(struct virtio_spmi *vspmi)
{
	struct virtqueue *vqs[1];
	vq_callback_t *cbs[] = { virtio_spmi_isr };
	static const char * const names[] = { "virtio_spmi_isr" };
	int rc;

	rc = virtio_find_vqs(vspmi->vdev, 1, vqs, cbs, names, NULL);
	if (rc)
		return rc;

	vspmi->vq = vqs[0];

	return 0;
}

static void virtio_spmi_del_vqs(struct virtio_spmi *vspmi)
{
	vspmi->vdev->config->del_vqs(vspmi->vdev);
}

static int virtio_spmi_probe(struct virtio_device *vdev)
{
	struct virtio_spmi *vspmi;
	int i;
	int ret = 0;
	u32 val;

	if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
		return -ENODEV;

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

	vdev->priv = vspmi;
	vspmi->vdev = vdev;
	spin_lock_init(&vspmi->lock);

	ret = virtio_spmi_init_vqs(vspmi);
	if (ret)
		goto err_init_vq;

	virtio_device_ready(vdev);

	memset(&vspmi->config, 0x0, sizeof(vspmi->config));

	for (i = 0; i < VM_MAX_PERIPHS; i += 2) {
		val = virtio_cread32(vdev,
			offsetof(struct virtio_spmi_config, ppid_allowed[i]));
		vspmi->config.ppid_allowed[i] = val & PMIC_ARB_PPID_MASK;
		vspmi->config.ppid_allowed[i + 1] =
					(val >> 16) & PMIC_ARB_PPID_MASK;
		if ((!vspmi->config.ppid_allowed[i]) ||
				!(vspmi->config.ppid_allowed[i + 1]))
			break;
	}

	g_vspmi = vspmi;

	return platform_driver_register(&spmi_pmic_arb_driver);

err_init_vq:
	virtio_spmi_del_vqs(vspmi);
	devm_kfree(&vdev->dev, vspmi);
	virtio_spmi_del_vqs(vs);
	devm_kfree(&vdev->dev, vs);
	return ret;
}

static void virtio_spmi_remove(struct virtio_device *vdev)
{
	struct virtio_spmi *vspmi = vdev->priv;
	struct virtio_spmi *vs = vdev->priv;

	vdev->config->reset(vdev);
	vdev->config->del_vqs(vdev);
	devm_kfree(&vdev->dev, vspmi);
	g_vspmi = NULL;
	devm_kfree(&vdev->dev, vs);
}

static unsigned int features[] = {
@@ -968,7 +832,7 @@ static void __exit virtio_spmi_exit(void)
	unregister_virtio_driver(&virtio_spmi_driver);
}

subsys_initcall(virtio_spmi_init);
arch_initcall(virtio_spmi_init);
module_exit(virtio_spmi_exit);

MODULE_DEVICE_TABLE(virtio, id_table);
+6 −15
Original line number Diff line number Diff line
/* Copyright (c) 2019, The Linux Foundation. All rights reserved.
/* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
@@ -29,12 +29,13 @@ struct virtio_spmi_config {
} __packed;

struct payload_cmd {
	__virtio32 cmd;
	__virtio32 data[2];
};

struct payload_irq {
	__virtio32 ppid;
	__virtio32 val;
	__virtio16 ppid;
	__virtio32 regval;
};

union payload_data {
@@ -44,19 +45,15 @@ union payload_data {

struct virtio_spmi_msg {
	__virtio32 type;
	__virtio32 len;
	__virtio32 res;
	union {
		__virtio32 cmd;
		__virtio32 cnt;
	} u;
	union payload_data payload[];
	union payload_data payload;
};

/* Virtio SPMI message type */
enum vio_spmi_msg_type {
	VIO_SPMI_BUS_WRITE = 0,
	VIO_SPMI_BUS_READ = 1,
	VIO_SPMI_BUS_CMDMAX  = 1,
	VIO_ACC_ENABLE_WR = 2,
	VIO_ACC_ENABLE_RD = 3,
	VIO_IRQ_CLEAR = 4,
@@ -68,10 +65,4 @@ enum vio_spmi_msg_res {
	VIO_SPMI_DONE = 0,
	VIO_SPMI_ERR = 1,
};

/* payload fix size and one payload_data size */
#define MSG_FIX_SZ (sizeof(struct virtio_spmi_msg))
#define PER_PLD_SZ (sizeof(union payload_data))
#define MSG_SZ(x)  (MSG_FIX_SZ + ((PER_PLD_SZ) * (x)))

#endif /* _LINUX_VIRTIO_SPMI_H */