On 2021/3/5 1:47 下午, Jie Deng wrote:
On 2021/3/4 17:15, Jason Wang wrote:On 2021/3/4 9:59 上午, Jie Deng wrote:Add an I2C bus driver for virtio para-virtualization. The controller can be emulated by the backend driver in any device model software by following the virtio protocol. The device specification can be found onhttps://lists.oasis-open.org/archives/virtio-comment/202101/msg00008.html.By following the specification, people may implement different backend drivers to emulate different controllers according to their needs. Co-developed-by: Conghui Chen <conghui.chen@xxxxxxxxx> Signed-off-by: Conghui Chen <conghui.chen@xxxxxxxxx> Signed-off-by: Jie Deng <jie.deng@xxxxxxxxx> --- drivers/i2c/busses/Kconfig | 11 ++ drivers/i2c/busses/Makefile | 3 +drivers/i2c/busses/i2c-virtio.c | 289 ++++++++++++++++++++++++++++++++++++++++include/uapi/linux/virtio_i2c.h | 42 ++++++ include/uapi/linux/virtio_ids.h | 1 + 5 files changed, 346 insertions(+) create mode 100644 drivers/i2c/busses/i2c-virtio.c create mode 100644 include/uapi/linux/virtio_i2c.h diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig index 05ebf75..0860395 100644 --- a/drivers/i2c/busses/Kconfig +++ b/drivers/i2c/busses/Kconfig @@ -21,6 +21,17 @@ config I2C_ALI1535 This driver can also be built as a module. If so, the module will be called i2c-ali1535. +config I2C_VIRTIO + tristate "Virtio I2C Adapter" + depends on VIRTIOPlease use select here. There's no prompt for VIRTIO.OK.+ help+ If you say yes to this option, support will be included for the virtio + I2C adapter driver. The hardware can be emulated by any device model+ software according to the virtio protocol. + + This driver can also be built as a module. If so, the module + will be called i2c-virtio. + config I2C_ALI1563 tristate "ALI 1563" depends on PCI diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile index 615f35e..b88da08 100644 --- a/drivers/i2c/busses/Makefile +++ b/drivers/i2c/busses/Makefile @@ -6,6 +6,9 @@ # ACPI drivers obj-$(CONFIG_I2C_SCMI) += i2c-scmi.o +# VIRTIO I2C host controller driver +obj-$(CONFIG_I2C_VIRTIO) += i2c-virtio.o + # PC SMBus host controller drivers obj-$(CONFIG_I2C_ALI1535) += i2c-ali1535.o obj-$(CONFIG_I2C_ALI1563) += i2c-ali1563.odiff --git a/drivers/i2c/busses/i2c-virtio.c b/drivers/i2c/busses/i2c-virtio.cnew file mode 100644 index 0000000..98c0fcc --- /dev/null +++ b/drivers/i2c/busses/i2c-virtio.c @@ -0,0 +1,289 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Virtio I2C Bus Driver + * + * The Virtio I2C Specification:+ * https://raw.githubusercontent.com/oasis-tcs/virtio-spec/master/virtio-i2c.tex+ * + * Copyright (c) 2021 Intel Corporation. All rights reserved. + */ + +#include <linux/acpi.h> +#include <linux/completion.h> +#include <linux/err.h> +#include <linux/i2c.h> +#include <linux/io.h> +#include <linux/jiffies.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/wait.h> + +#include <linux/virtio.h> +#include <linux/virtio_i2c.h> + +/** + * struct virtio_i2c - virtio I2C data + * @vdev: virtio device for this controller + * @completion: completion of virtio I2C message + * @adap: I2C adapter for this controller + * @i2c_lock: lock for virtqueue processing + * @vq: the virtio virtqueue for communication + */ +struct virtio_i2c { + struct virtio_device *vdev; + struct completion completion; + struct i2c_adapter adap; + struct mutex i2c_lock; + struct virtqueue *vq; +}; + +/** + * struct virtio_i2c_req - the virtio I2C request structure + * @out_hdr: the OUT header of the virtio I2C message+ * @buf: the buffer into which data is read, or from which it's written+ * @in_hdr: the IN header of the virtio I2C message + */ +struct virtio_i2c_req { + struct virtio_i2c_out_hdr out_hdr; + u8 *buf; + struct virtio_i2c_in_hdr in_hdr; +}; + +static void virtio_i2c_msg_done(struct virtqueue *vq) +{ + struct virtio_i2c *vi = vq->vdev->priv; + + complete(&vi->completion); +} + +static int virtio_i2c_send_reqs(struct virtqueue *vq, + struct virtio_i2c_req *reqs, + struct i2c_msg *msgs, int nr) +{ + struct scatterlist *sgs[3], out_hdr, msg_buf, in_hdr; + int i, outcnt, incnt, err = 0; + u8 *buf; + + for (i = 0; i < nr; i++) { + if (!msgs[i].len) + break; ++ /* Only 7-bit mode supported for this moment. For the address format,+ * Please check the Virtio I2C Specification. + */ + reqs[i].out_hdr.addr = cpu_to_le16(msgs[i].addr << 1); + + if (i != nr - 1) + reqs[i].out_hdr.flags |= VIRTIO_I2C_FLAGS_FAIL_NEXT; + + outcnt = incnt = 0;+ sg_init_one(&out_hdr, &reqs[i].out_hdr, sizeof(reqs[i].out_hdr));+ sgs[outcnt++] = &out_hdr; + + buf = kzalloc(msgs[i].len, GFP_KERNEL); + if (!buf) + break; + + reqs[i].buf = buf; + sg_init_one(&msg_buf, reqs[i].buf, msgs[i].len); + + if (msgs[i].flags & I2C_M_RD) { + sgs[outcnt + incnt++] = &msg_buf; + } else { + memcpy(reqs[i].buf, msgs[i].buf, msgs[i].len); + sgs[outcnt++] = &msg_buf; + } + + sg_init_one(&in_hdr, &reqs[i].in_hdr, sizeof(reqs[i].in_hdr)); + sgs[outcnt + incnt++] = &in_hdr; ++ err = virtqueue_add_sgs(vq, sgs, outcnt, incnt, &reqs[i], GFP_KERNEL);+ if (err < 0) { + pr_err("failed to add msg[%d] to virtqueue.\n", i); + kfree(reqs[i].buf); + reqs[i].buf = NULL; + break; + } + } + + return i; +} + +static int virtio_i2c_complete_reqs(struct virtqueue *vq, + struct virtio_i2c_req *reqs, + struct i2c_msg *msgs, int nr) +{ + struct virtio_i2c_req *req; + unsigned int len; + int i; + + for (i = 0; i < nr; i++) { + req = (struct virtio_i2c_req *)virtqueue_get_buf(vq, &len);The case is unnecessary.Right. Will remove the conversion.+ if (!(req && req == &reqs[i])) {+ pr_err("msg[%d]: addr=0x%x virtqueue error.\n", i, msgs[i].addr);+ break; + }It's better to be more specific here, e.g we can say we saw out of order completion here.OK.You are right. Need to detach all the used buffers from the vq before queuing new buffers.+ + if (req->in_hdr.status != VIRTIO_I2C_MSG_OK) {+ pr_err("msg[%d]: addr=0x%x backend error.\n", i, msgs[i].addr);+ break;Don't we need to clean used ring by keeping calling virtqueue_get_buf() here?+ } + + if (msgs[i].flags & I2C_M_RD) + memcpy(msgs[i].buf, req->buf, msgs[i].len);Sorry if I had asked this before but any rason not to use msg[i].buf directly?Will try to use msg[i].buf.This is an expected behavior. If timeout happens, we don't need to care about the requests whether really completed by "HW" or not. Just return error and let the i2c core to decide whether to resend.+ + kfree(req->buf); + req->buf = NULL; + } + + return i; +} ++static int virtio_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)+{ + struct virtio_i2c *vi = i2c_get_adapdata(adap); + struct virtqueue *vq = vi->vq; + struct virtio_i2c_req *reqs; + unsigned long time_left; + int ret, nr; + + reqs = kcalloc(num, sizeof(*reqs), GFP_KERNEL); + if (!reqs) + return -ENOMEM; + + mutex_lock(&vi->i2c_lock); + + ret = virtio_i2c_send_reqs(vq, reqs, msgs, num); + if (ret == 0) + goto err_unlock_free; + + nr = ret; + + virtqueue_kick(vq); ++ time_left = wait_for_completion_timeout(&vi->completion, adap->timeout);+ if (!time_left) { + dev_err(&adap->dev, "virtio i2c backend timeout.\n"); + ret = -ETIMEDOUT; + goto err_unlock_free;So if the request is finished after the timerout, all the following request will fail, is this expected?
So you need at least reinit the completion at least?
The device can raise interrupt when some requests are still not completed though this is not a good operation.+ } + + ret = virtio_i2c_complete_reqs(vq, reqs, msgs, nr);So consider driver queue N requests, can device raise interrupt if it completes the first request? If yes, the code break, if not it need to be clarified in the spec.
Then you need forbid this in the spec.
In this case, the remaining requests in the vq will be ignored and the i2c_algorithm. master_xfer will return 1 foryour example. And let the i2c core to decide whether to resend.This flag is introduced by Stefan. Please check following link for the details https://lists.oasis-open.org/archives/virtio-comment/202012/msg00075.html.Acaultly I remember there's no VIRTIO_I2C_FLAGS_FAIL_NEXT in previous versions, and after reading the spec I still don't get the motivation for that (it may complicates both driver and device actually).
> We just need to make sure that once the driver adds some requests to the > virtqueue,> it should complete them (either success or fail) before adding new requests.
> I think this > is a behavior of physical I2C adapter drivers and we can follow.Is this a driver requirement or device? If it's the driver, the code have already did something like this. E.g you wait for the completion of the request and forbid new request via i2c_lock.
Thanks
If interrupt is raised after timeout, those requests in the vq will be ignored.+ + reinit_completion(&vi->completion);So if a request it timeout but interrupt is raised here, everything is broken.ThanksNo need to care about them being handled or not. Just let the i2c core to decide whether need to resend or not.+ +err_unlock_free: + mutex_unlock(&vi->i2c_lock); + kfree(reqs); + return ret; +} + +static void virtio_i2c_del_vqs(struct virtio_device *vdev) +{ + vdev->config->reset(vdev); + vdev->config->del_vqs(vdev); +} + +static int virtio_i2c_setup_vqs(struct virtio_i2c *vi) +{ + struct virtio_device *vdev = vi->vdev; + + vi->vq = virtio_find_single_vq(vdev, virtio_i2c_msg_done, "msg"); + return PTR_ERR_OR_ZERO(vi->vq); +} + +static u32 virtio_i2c_func(struct i2c_adapter *adap) +{ + return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; +} + +static struct i2c_algorithm virtio_algorithm = { + .master_xfer = virtio_i2c_xfer, + .functionality = virtio_i2c_func, +}; + +static struct i2c_adapter virtio_adapter = { + .owner = THIS_MODULE, + .name = "Virtio I2C Adapter", + .class = I2C_CLASS_DEPRECATED, + .algo = &virtio_algorithm, +}; + +static int virtio_i2c_probe(struct virtio_device *vdev) +{ + struct device *pdev = vdev->dev.parent; + struct virtio_i2c *vi; + int ret; + + vi = devm_kzalloc(&vdev->dev, sizeof(*vi), GFP_KERNEL); + if (!vi) + return -ENOMEM; + + vdev->priv = vi; + vi->vdev = vdev; + + mutex_init(&vi->i2c_lock); + init_completion(&vi->completion); + + ret = virtio_i2c_setup_vqs(vi); + if (ret) + return ret; + + vi->adap = virtio_adapter; + i2c_set_adapdata(&vi->adap, vi); + vi->adap.dev.parent = &vdev->dev;+ /* Setup ACPI node for controlled devices which will be probed through ACPI */+ ACPI_COMPANION_SET(&vi->adap.dev, ACPI_COMPANION(pdev)); + vi->adap.timeout = HZ / 10; + + ret = i2c_add_adapter(&vi->adap); + if (ret) { + virtio_i2c_del_vqs(vdev); + dev_err(&vdev->dev, "failed to add virtio-i2c adapter.\n"); + } + + return ret; +} + +static void virtio_i2c_remove(struct virtio_device *vdev) +{ + struct virtio_i2c *vi = vdev->priv; + + i2c_del_adapter(&vi->adap); + virtio_i2c_del_vqs(vdev); +} + +static struct virtio_device_id id_table[] = { + { VIRTIO_ID_I2C_ADPTER, VIRTIO_DEV_ANY_ID }, + {} +}; +MODULE_DEVICE_TABLE(virtio, id_table); ++static int __maybe_unused virtio_i2c_freeze(struct virtio_device *vdev)+{ + virtio_i2c_del_vqs(vdev); + return 0; +} ++static int __maybe_unused virtio_i2c_restore(struct virtio_device *vdev)+{ + return virtio_i2c_setup_vqs(vdev->priv); +} + +static struct virtio_driver virtio_i2c_driver = { + .id_table = id_table, + .probe = virtio_i2c_probe, + .remove = virtio_i2c_remove, + .driver = { + .name = "i2c_virtio", + }, +#ifdef CONFIG_PM_SLEEP + .freeze = virtio_i2c_freeze, + .restore = virtio_i2c_restore, +#endif +}; +module_virtio_driver(virtio_i2c_driver); + +MODULE_DESCRIPTION("Virtio i2c bus driver"); +MODULE_LICENSE("GPL");diff --git a/include/uapi/linux/virtio_i2c.h b/include/uapi/linux/virtio_i2c.hnew file mode 100644 index 0000000..00f4508 --- /dev/null +++ b/include/uapi/linux/virtio_i2c.h @@ -0,0 +1,42 @@+/* SPDX-License-Identifier: GPL-2.0-or-later WITH Linux-syscall-note */+/* + * Definitions for virtio I2C Adpter + * + * Copyright (c) 2021 Intel Corporation. All rights reserved. + */ + +#ifndef _UAPI_LINUX_VIRTIO_I2C_H +#define _UAPI_LINUX_VIRTIO_I2C_H + +#include <linux/types.h> +#include <linux/virtio_ids.h> +#include <linux/virtio_config.h> + +/** + * struct virtio_i2c_out_hdr - the virtio I2C message OUT header + * @addr: the controlled device address + * @padding: used to pad to full dword + * @flags: used for feature extensibility + */ +struct virtio_i2c_out_hdr { + __le16 addr; + __le16 padding; + __le32 flags; +}; ++/* The bit 0 of the @virtio_i2c_out_hdr.@flags, used to group the requests */+#define VIRTIO_I2C_FLAGS_FAIL_NEXT 0x00000001 + +/** + * struct virtio_i2c_in_hdr - the virtio I2C message IN header + * @status: the processing result from the backend + */ +struct virtio_i2c_in_hdr { + u8 status; +}; + +/* The final status written by the device */ +#define VIRTIO_I2C_MSG_OK 0 +#define VIRTIO_I2C_MSG_ERR 1 + +#endif /* _UAPI_LINUX_VIRTIO_I2C_H */diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.hindex bc1c062..6ae32db 100644 --- a/include/uapi/linux/virtio_ids.h +++ b/include/uapi/linux/virtio_ids.h @@ -54,5 +54,6 @@ #define VIRTIO_ID_FS 26 /* virtio filesystem */ #define VIRTIO_ID_PMEM 27 /* virtio pmem */ #define VIRTIO_ID_MAC80211_HWSIM 29 /* virtio mac80211-hwsim */ +#define VIRTIO_ID_I2C_ADPTER 34 /* virtio i2c adpter */ #endif /* _LINUX_VIRTIO_IDS_H */
