Series comparison

-[PATCH 0/5] virtio: Implement generic vhost-user-i2c backend
+[PATCH V2 0/6] virtio: Implement generic vhost-user-i2c backend
 ...
 thread by Alex Bennée for his RPMB work:
   https://lore.kernel.org/qemu-devel/20200925125147.26943-1-alex.bennee@linaro.org/
-Testing:
+I2C Testing:
--------
+------------
 I didn't have access to a real hardware where I can play with a I2C
 client device (like RTC, eeprom, etc) to verify the working of the
 backend daemon, so I decided to test it on my x86 box itself with
 hierarchy of two ARM64 guests.
 ...
   Reaches i2c-virtio.c (Linux bus driver in guest2) ->
     transfer over virtio ->
       Reaches the qemu's vhost-i2c device emulation (running over guest1) ->
         Reaches the backend daemon vhost-user-i2c started earlier (in guest1) ->
           ioctl(/dev/i2c-0, I2C_RDWR, ..); (in guest1) ->
-        reaches qemu's hw/rtc/ds1338.c (running over host)
+            reaches qemu's hw/rtc/ds1338.c (running over host)
+SMBUS Testing:
+--------------
+I wasn't required to have such a tedious setup for testing out with
+SMBUS devices. I was able to emulate a SMBUS device on my x86 machine
+using i2c-stub driver.
+$ modprobe i2c-stub chip_addr=0x20
+//Boot the arm64 guest now with i2c-virtio driver and then do:
+$ echo al3320a 0x20 > /sys/class/i2c-adapter/i2c-0/new_device
+$ cat /sys/bus/iio/devices/iio:device0/in_illuminance_raw
+That's it.
 I hope I was able to give a clear picture of my test setup here :)
 Thanks.
-Viresh Kumar (5):
+V1->V2:
 - Add a separate patch (not to be merged) to keep stuff temporarily
   taken from Linux kernel.
 - Support SMBUS devices/busses in the backend daemon.
 - Fix lots of checkpatch warnings/errors.
 - Some other bug fixes, suggestions, etc.
 Viresh Kumar (6):
   !Merge: Update virtio headers from kernel
   hw/virtio: add boilerplate for vhost-user-i2c device
   hw/virtio: add vhost-user-i2c-pci boilerplate
   tools/vhost-user-i2c: Add backend driver
   docs: add a man page for vhost-user-i2c
   MAINTAINERS: Add entry for virtio-i2c
  MAINTAINERS                                 |   9 +
  docs/tools/index.rst                        |   1 +
- docs/tools/vhost-user-i2c.rst               |  75 +++
+ docs/tools/vhost-user-i2c.rst               |  75 ++
  hw/virtio/Kconfig                           |   5 +
  hw/virtio/meson.build                       |   2 +
- hw/virtio/vhost-user-i2c-pci.c              |  79 +++
+ hw/virtio/vhost-user-i2c-pci.c              |  69 ++
- hw/virtio/vhost-user-i2c.c                  | 286 +++++++++
+ hw/virtio/vhost-user-i2c.c                  | 285 +++++++
- include/hw/virtio/vhost-user-i2c.h          |  37 ++
+ include/hw/virtio/vhost-user-i2c.h          |  37 +
  include/standard-headers/linux/virtio_i2c.h |  40 +
  include/standard-headers/linux/virtio_ids.h |   1 +
  tools/meson.build                           |   8 +
  tools/vhost-user-i2c/50-qemu-i2c.json.in    |   5 +
- tools/vhost-user-i2c/main.c                 | 652 ++++++++++++++++++++
+ tools/vhost-user-i2c/main.c                 | 809 ++++++++++++++++++++
  tools/vhost-user-i2c/meson.build            |  10 +
-files changed, 1170 insertions(+)
+files changed, 1356 insertions(+)
  create mode 100644 docs/tools/vhost-user-i2c.rst
  create mode 100644 hw/virtio/vhost-user-i2c-pci.c
  create mode 100644 hw/virtio/vhost-user-i2c.c
  create mode 100644 include/hw/virtio/vhost-user-i2c.h
+ create mode 100644 include/standard-headers/linux/virtio_i2c.h
  create mode 100644 tools/vhost-user-i2c/50-qemu-i2c.json.in
  create mode 100644 tools/vhost-user-i2c/main.c
  create mode 100644 tools/vhost-user-i2c/meson.build
 --
 .25.0.rc1.19.g042ed3e048af

-New patch
+[PATCH V2 1/6] !Merge: Update virtio headers from kernel
+DO NOT MERGE
+Update Linux virtio headers with help of
+  ./scripts/update-linux-headers.sh ~/lsrc/linux.git
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+---
+ include/standard-headers/linux/virtio_i2c.h | 40 +++++++++++++++++++++
+ include/standard-headers/linux/virtio_ids.h |  1 +
+files changed, 41 insertions(+)
+ create mode 100644 include/standard-headers/linux/virtio_i2c.h
+diff --git a/include/standard-headers/linux/virtio_i2c.h b/include/standard-headers/linux/virtio_i2c.h
+new file mode 100644
+index XXXXXXX..XXXXXXX
+--- /dev/null
++++ b/include/standard-headers/linux/virtio_i2c.h
+@@ -XXX,XX +XXX,XX @@
++/* 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 _LINUX_VIRTIO_I2C_H
++#define _LINUX_VIRTIO_I2C_H
++
++#include "standard-headers/linux/types.h"
++
++/* 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_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 {
++    uint16_t addr;
++    uint16_t padding;
++    uint32_t flags;
++};
++
++/**
++ * struct virtio_i2c_in_hdr - the virtio I2C message IN header
++ * @status: the processing result from the backend
++ */
++struct virtio_i2c_in_hdr {
++    uint8_t status;
++};
++
++/* The final status written by the device */
++#define VIRTIO_I2C_MSG_OK    0
++#define VIRTIO_I2C_MSG_ERR    1
++
++#endif /* _LINUX_VIRTIO_I2C_H */
+diff --git a/include/standard-headers/linux/virtio_ids.h b/include/standard-headers/linux/virtio_ids.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/standard-headers/linux/virtio_ids.h
++++ b/include/standard-headers/linux/virtio_ids.h
+@@ -XXX,XX +XXX,XX @@
+ #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_ADAPTER        34 /* virtio i2c adapter */
+ #endif /* _LINUX_VIRTIO_IDS_H */
+--
+.25.0.rc1.19.g042ed3e048af

-[PATCH 1/5] hw/virtio: add boilerplate for vhost-user-i2c device
+[PATCH V2 2/6] hw/virtio: add boilerplate for vhost-user-i2c device
 This creates the QEMU side of the vhost-user-i2c device which connects
 to the remote daemon. It is based of vhost-user-fs code.
 Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
 ---
- hw/virtio/Kconfig                           |   5 +
+ hw/virtio/Kconfig                  |   5 +
- hw/virtio/meson.build                       |   1 +
+ hw/virtio/meson.build              |   1 +
- hw/virtio/vhost-user-i2c.c                  | 286 ++++++++++++++++++++
+ hw/virtio/vhost-user-i2c.c         | 285 +++++++++++++++++++++++++++++
- include/hw/virtio/vhost-user-i2c.h          |  37 +++
+ include/hw/virtio/vhost-user-i2c.h |  37 ++++
- include/standard-headers/linux/virtio_ids.h |   1 +
+files changed, 328 insertions(+)
 files changed, 330 insertions(+)
  create mode 100644 hw/virtio/vhost-user-i2c.c
  create mode 100644 include/hw/virtio/vhost-user-i2c.h
 diff --git a/hw/virtio/Kconfig b/hw/virtio/Kconfig
 index XXXXXXX..XXXXXXX 100644
 ...
 +
 +static void do_vhost_user_cleanup(VirtIODevice *vdev, VHostUserI2C *i2c)
 +{
 +    vhost_user_cleanup(&i2c->vhost_user);
 +    virtio_delete_queue(i2c->req_vq);
-+    g_free(i2c->vhost_dev.vqs);
 +    virtio_cleanup(vdev);
 +    g_free(i2c->vhost_dev.vqs);
 +    i2c->vhost_dev.vqs = NULL;
 +}
 +
 ...
 +
 +    if (!vhost_user_init(&i2c->vhost_user, &i2c->conf.chardev, errp)) {
 +        return;
 +    }
 +
-+    virtio_init(vdev, "vhost-user-i2c", VIRTIO_ID_I2C, 0);
++    virtio_init(vdev, "vhost-user-i2c", VIRTIO_ID_I2C_ADAPTER, 0);
 +
-+    i2c->req_vq = virtio_add_queue(vdev, 3, vu_i2c_handle_output);
++    i2c->req_vq = virtio_add_queue(vdev, 4, vu_i2c_handle_output);
 +    i2c->vhost_dev.nvqs = 1;
 +    i2c->vhost_dev.vqs = g_new0(struct vhost_virtqueue, i2c->vhost_dev.nvqs);
 +    ret = vhost_dev_init(&i2c->vhost_dev, &i2c->vhost_user,
 +                         VHOST_BACKEND_TYPE_USER, 0);
 +    if (ret < 0) {
 ...
 +
 +    /*< public >*/
 +};
 +
 +#endif /* _QEMU_VHOST_USER_I2C_H */
-diff --git a/include/standard-headers/linux/virtio_ids.h b/include/standard-headers/linux/virtio_ids.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/standard-headers/linux/virtio_ids.h
-+++ b/include/standard-headers/linux/virtio_ids.h
-@@ -XXX,XX +XXX,XX @@
- #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            34 /* virtio i2c */
- #endif /* _LINUX_VIRTIO_IDS_H */
 --
 .25.0.rc1.19.g042ed3e048af

-[PATCH 2/5] hw/virtio: add vhost-user-i2c-pci boilerplate
+[PATCH V2 3/6] hw/virtio: add vhost-user-i2c-pci boilerplate
 This allows is to instantiate a vhost-user-i2c device as part of a PCI
 bus. It is mostly boilerplate which looks pretty similar to the
 vhost-user-fs-pci device.
+Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
 Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
 ---
  hw/virtio/meson.build          |  1 +
- hw/virtio/vhost-user-i2c-pci.c | 79 ++++++++++++++++++++++++++++++++++
+ hw/virtio/vhost-user-i2c-pci.c | 69 ++++++++++++++++++++++++++++++++++
-files changed, 80 insertions(+)
+files changed, 70 insertions(+)
  create mode 100644 hw/virtio/vhost-user-i2c-pci.c
 diff --git a/hw/virtio/meson.build b/hw/virtio/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/virtio/meson.build
 ...
 +#define TYPE_VHOST_USER_I2C_PCI "vhost-user-i2c-pci-base"
 +
 +DECLARE_INSTANCE_CHECKER(VHostUserI2CPCI, VHOST_USER_I2C_PCI,
 +                         TYPE_VHOST_USER_I2C_PCI)
 +
-+static Property vhost_user_i2c_pci_properties[] = {
-+    DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
-+                       DEV_NVECTORS_UNSPECIFIED),
-+    DEFINE_PROP_END_OF_LIST(),
-+};
-+
 +static void vhost_user_i2c_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 +{
 +    VHostUserI2CPCI *dev = VHOST_USER_I2C_PCI(vpci_dev);
 +    DeviceState *vdev = DEVICE(&dev->vdev);
 +
-+    if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
++    vpci_dev->nvectors = 1;
 +        vpci_dev->nvectors = 1;
 +    }
 +
 +    qdev_realize(vdev, BUS(&vpci_dev->bus), errp);
 +}
 +
 +static void vhost_user_i2c_pci_class_init(ObjectClass *klass, void *data)
 +{
 +    DeviceClass *dc = DEVICE_CLASS(klass);
 +    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
 +    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 +    k->realize = vhost_user_i2c_pci_realize;
 +    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
-+    device_class_set_props(dc, vhost_user_i2c_pci_properties);
 +    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
 +    pcidev_k->device_id = 0; /* Set by virtio-pci based on virtio id */
 +    pcidev_k->revision = 0x00;
 +    pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
 +}
 ...

-[PATCH 3/5] tools/vhost-user-i2c: Add backend driver
+[PATCH V2 4/6] tools/vhost-user-i2c: Add backend driver
-This adds the vhost-user backend driver to support virtio based I2C
+This adds the vhost-user backend driver to support virtio based I2C and
-devices.
+SMBUS devices.
 vhost-user-i2c --help
 Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
 ---
- hw/virtio/vhost-user-i2c.c               |   2 +-
  tools/meson.build                        |   8 +
  tools/vhost-user-i2c/50-qemu-i2c.json.in |   5 +
- tools/vhost-user-i2c/main.c              | 652 +++++++++++++++++++++++
+ tools/vhost-user-i2c/main.c              | 809 +++++++++++++++++++++++
  tools/vhost-user-i2c/meson.build         |  10 +
-files changed, 676 insertions(+), 1 deletion(-)
+files changed, 832 insertions(+)
  create mode 100644 tools/vhost-user-i2c/50-qemu-i2c.json.in
  create mode 100644 tools/vhost-user-i2c/main.c
  create mode 100644 tools/vhost-user-i2c/meson.build
-diff --git a/hw/virtio/vhost-user-i2c.c b/hw/virtio/vhost-user-i2c.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/virtio/vhost-user-i2c.c
-+++ b/hw/virtio/vhost-user-i2c.c
-@@ -XXX,XX +XXX,XX @@ static void vu_i2c_device_realize(DeviceState *dev, Error **errp)
-     virtio_init(vdev, "vhost-user-i2c", VIRTIO_ID_I2C, 0);
--    i2c->req_vq = virtio_add_queue(vdev, 3, vu_i2c_handle_output);
-+    i2c->req_vq = virtio_add_queue(vdev, 4, vu_i2c_handle_output);
-     i2c->vhost_dev.nvqs = 1;
-     i2c->vhost_dev.vqs = g_new0(struct vhost_virtqueue, i2c->vhost_dev.nvqs);
-     ret = vhost_dev_init(&i2c->vhost_dev, &i2c->vhost_user,
 diff --git a/tools/meson.build b/tools/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/tools/meson.build
 +++ b/tools/meson.build
 @@ -XXX,XX +XXX,XX @@ endif
 ...
 + */
 +
 +#define G_LOG_DOMAIN "vhost-user-i2c"
 +#define G_LOG_USE_STRUCTURED 1
 +
-+#include <glib.h>
++#include <assert.h>
 +#include <endian.h>
 +#include <fcntl.h>
 +#include <gio/gio.h>
 +#include <gio/gunixsocketaddress.h>
++#include <glib.h>
 +#include <glib-unix.h>
 +#include <glib/gstdio.h>
-+#include <stdio.h>
-+#include <stdbool.h>
-+#include <string.h>
 +#include <inttypes.h>
-+#include <fcntl.h>
-+#include <sys/ioctl.h>
-+#include <sys/types.h>
-+#include <sys/stat.h>
-+#include <sys/mman.h>
-+#include <unistd.h>
-+#include <endian.h>
-+#include <assert.h>
 +#include <linux/i2c.h>
 +#include <linux/i2c-dev.h>
-+
++#include <stdbool.h>
 +#include <stdio.h>
 +#include <string.h>
 +#include <sys/ioctl.h>
 +#include <sys/mman.h>
 +#include <sys/stat.h>
 +#include <sys/types.h>
 +#include <unistd.h>
 +
 +#include "qemu/compiler.h"
 +#include "qemu/cutils.h"
++#include "standard-headers/linux/virtio_i2c.h"
 +#include "subprojects/libvhost-user/libvhost-user-glib.h"
 +#include "subprojects/libvhost-user/libvhost-user.h"
 +
-+/* Definitions from virtio-i2c specifications */
 +#define VHOST_USER_I2C_MAX_QUEUES       1
 +
-+/* Status */
-+#define VIRTIO_I2C_MSG_OK               0
-+#define VIRTIO_I2C_MSG_ERR              1
-+
-+/* 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_out_hdr - the virtio I2C message OUT header
-+ * @addr: the controlled device's address
-+ * @padding: used to pad to full dword
-+ * @flags: used for feature extensibility
-+ */
-+struct virtio_i2c_out_hdr {
-+    uint16_t addr;
-+    uint16_t padding;
-+    uint32_t flags;
-+} __attribute__((packed));
-+
-+/**
-+ * struct virtio_i2c_in_hdr - the virtio I2C message IN header
-+ * @status: the processing result from the backend
-+ */
-+struct virtio_i2c_in_hdr {
-+    uint8_t status;
-+} __attribute__((packed));
-+
 +/* vhost-user-i2c definitions */
-+
-+#ifndef container_of
-+#define container_of(ptr, type, member) ({                      \
-+        const typeof(((type *) 0)->member) *__mptr = (ptr);     \
-+        (type *) ((char *) __mptr - offsetof(type, member));})
-+#endif
 +
 +#define MAX_I2C_VDEV                    (1 << 7)
 +#define MAX_I2C_ADAPTER                 16
 +
 +typedef struct {
 +    int32_t fd;
 +    int32_t bus;
++    bool smbus;
 +    bool clients[MAX_I2C_VDEV];
 +} VI2cAdapter;
 +
 +typedef struct {
 +    VugDev dev;
 ...
 +static gboolean print_cap, verbose;
 +static gchar *socket_path, *device_list;
 +static gint socket_fd = -1;
 +
 +static GOptionEntry options[] = {
-+    { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &socket_path, "Location of vhost-user Unix domain socket, incompatible with --fd", "PATH" },
++    { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &socket_path,
-+    { "fd", 'f', 0, G_OPTION_ARG_INT, &socket_fd, "Specify the file-descriptor of the backend, incompatible with --socket-path", "FD" },
++      "Location of vhost-user Unix domain socket, incompatible with --fd",
-+    { "device-list", 'l', 0, G_OPTION_ARG_STRING, &device_list, "List of i2c-dev bus and attached devices", "I2C Devices" },
++      "PATH" },
-+    { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &print_cap, "Output to stdout the backend capabilities in JSON format and exit", NULL},
++    { "fd", 'f', 0, G_OPTION_ARG_INT, &socket_fd,
-+    { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Be more verbose in output", NULL},
++      "Specify file-descriptor of the backend, don't use with --socket-path",
 +      "FD" },
 +    { "device-list", 'l', 0, G_OPTION_ARG_STRING, &device_list,
 +      "List of i2c-dev bus and attached devices", "I2C Devices" },
 +    { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &print_cap,
 +      "Output to stdout the backend capabilities in JSON format and exit",
 +      NULL},
 +    { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
 +      "Be more verbose in output", NULL},
 +    { NULL }
 +};
 +
 +
 +/* I2c helpers */
 ...
 +        }
 +        g_string_append_printf(s, "%x ", bytes[i]);
 +    }
 +}
 +
-+static void vi2c_dump_msg(struct i2c_msg *msg)
++static void vi2c_dump_msg(struct i2c_msg *msgs, size_t count)
 +{
-+    g_autoptr(GString) s = g_string_new("\nI2c request: ");
++    int32_t i;
 +
-+    g_string_append_printf(s, "addr: %x\n", msg->addr);
++    for (i = 0; i < count; i++) {
-+    g_string_append_printf(s, "transfer len: %x\n", msg->len);
++        g_autoptr(GString) s = g_string_new("\nI2c request: ");
 +
-+    g_string_append_printf(s, "%s: ", msg->flags & I2C_M_RD ? "Data read" :
++        g_string_append_printf(s, "addr: %x\n", msgs[i].addr);
-+                                                              "Data Written");
++        g_string_append_printf(s, "transfer len: %x\n", msgs[i].len);
-+    fmt_bytes(s, (uint8_t *)msg->buf, msg->len);
++
-+    g_string_append_printf(s, "\n");
++        g_string_append_printf(s, "%s: ", msgs[i].flags & I2C_M_RD ?
-+
++                               "Data read" : "Data Written");
-+    g_debug("%s: %s", __func__, s->str);
++        fmt_bytes(s, (uint8_t *)msgs[i].buf, msgs[i].len);
 +        g_string_append_printf(s, "\n");
 +
 +        g_debug("%s: %s", __func__, s->str);
 +    }
 +}
 +
 +static int vi2c_map_adapters(VuI2c *i2c)
 +{
 +    VI2cAdapter *adapter;
 ...
 +    /*
 +     * Flatten the map for client address and adapter to the array:
 +     *
 +     * adapter_map[MAX_I2C_VDEV]:
 +     *
-+     * Adapter        | adapter2 | none  | adapter1 | adapter3 | none | none| (val)
++     * Adapter        | adapter2 | none  | adapter1 | adapter3 | none| (val)
-+     *                |----------|-------|----------|----------|------|-----|
++     *                |----------|-------|----------|----------|-----|
-+     * Slave Address  | addr 1   | none  | addr 2   | addr 3   | none | none| (idx)
++     * Slave Address  | addr 1   | none  | addr 2   | addr 3   | none| (idx)
 +     *                |<-----------------------MAX_I2C_VDEV---------------->|
 +     */
 +    for (i = 0; i < i2c->adapter_num; i++) {
 +        adapter = i2c->adapter[i];
 +
 ...
 +    return 0;
 +}
 +
 +static VI2cAdapter *vi2c_find_adapter(VuI2c *i2c, uint16_t addr)
 +{
-+    int32_t idx;
++    if (addr < MAX_I2C_VDEV && (i2c->adapter_map[addr] != 0)) {
-+
++        return i2c->adapter[i2c->adapter_map[addr] - 1];
 +    if (addr < MAX_I2C_VDEV && ((idx = i2c->adapter_map[addr]) != 0)) {
 +        return i2c->adapter[idx - 1];
 +    }
 +
 +    return NULL;
 +}
 +
-+static bool vi2c_client_access_ok(VI2cAdapter *adapter, uint16_t addr)
++static bool vi2c_set_client_addr(VI2cAdapter *adapter, uint16_t addr)
 +{
 +    if (ioctl(adapter->fd, I2C_SLAVE, addr) < 0) {
 +        if (errno == EBUSY) {
 +            g_printerr("client device %x is busy!\n", addr);
 +        } else {
 ...
 +static void vi2c_remove_adapters(VuI2c *i2c)
 +{
 +    VI2cAdapter *adapter;
 +    int32_t i;
 +
-+    for (i = 0; i < i2c->adapter_num; i++) {
++    for (i = 0; i < MAX_I2C_ADAPTER; i++) {
 +        adapter = i2c->adapter[i];
 +        if (!adapter) {
 +            break;
 +        }
 +
 ...
 +static VI2cAdapter *vi2c_create_adapter(int32_t bus, uint16_t client_addr[],
 +                                        int32_t n_client)
 +{
 +    VI2cAdapter *adapter;
 +    char path[20];
++    uint64_t funcs;
 +    int32_t fd, i;
 +
-+    if (bus < 0)
++    if (bus < 0) {
 +        return NULL;
++    }
 +
 +    adapter = g_malloc0(sizeof(*adapter));
 +    if (!adapter) {
 +        g_printerr("failed to alloc adapter");
 +        return NULL;
 ...
 +    }
 +
 +    adapter->fd = fd;
 +    adapter->bus = bus;
 +
++    if (ioctl(fd, I2C_FUNCS, &funcs) < 0) {
++        g_printerr("virtio_i2c: failed to get functionality %s: %d\n", path,
++                   errno);
++        goto close_fd;
++    }
++
++    if (funcs & I2C_FUNC_I2C) {
++        adapter->smbus = false;
++    } else if (funcs & I2C_FUNC_SMBUS_WORD_DATA) {
++        adapter->smbus = true;
++    } else {
++        g_printerr("virtio_i2c: invalid functionality %lx\n", funcs);
++        goto close_fd;
++    }
++
 +    for (i = 0; i < n_client; i++) {
 +        if (client_addr[i]) {
-+            if (!vi2c_client_access_ok(adapter, client_addr[i])) {
++            if (!vi2c_set_client_addr(adapter, client_addr[i])) {
-+                goto fail;
++                goto close_fd;
 +            }
 +
 +            if (adapter->clients[client_addr[i]]) {
-+                g_printerr("client addr 0x%x repeat, not allowed.\n", client_addr[i]);
++                g_printerr("client addr 0x%x repeat, not allowed.\n",
-+                goto fail;
++                           client_addr[i]);
 +                goto close_fd;
 +            }
 +
 +            adapter->clients[client_addr[i]] = true;
 +            if (verbose) {
 +                g_print("Added client 0x%x to bus %u\n", client_addr[i], bus);
 +            }
 +        }
 +    }
++
++    if (verbose) {
++        g_print("Added adapter: bus: %d, func %s\n", bus,
++                adapter->smbus ? "smbus" : "i2c");
++    }
 +    return adapter;
 +
++close_fd:
++    close(fd);
 +fail:
 +    g_free(adapter);
 +    return NULL;
 +}
 +
 ...
 + *
 + * <bus>:<client_addr>[:<client_addr>],
 + * [<bus>:<client_addr>[:<client_addr>]]
 + *
 + * bus (dec): adatper bus number.
-+ *     e.g. 2 for /dev/i2c-2
++ *     e.g. 2 for /dev/i2c-2
 + * client_addr (hex): address for client device
-+ *     e.g. 0x1C or 1C
++ *     e.g. 0x1C or 1C
 + *
 + * Example: --device-list="2:0x1c:0x20,3:0x10:0x2c"
 + *
 + * Note: client address can not repeat.
 + */
-+static int vi2c_parse(VuI2c *i2c)
++static int32_t vi2c_parse(VuI2c *i2c)
 +{
 +    uint16_t client_addr[MAX_I2C_VDEV];
 +    int32_t n_adapter = 0, n_client;
 +    int64_t addr, bus;
 +    const char *cp, *t;
 +
 +    while (device_list) {
 +        /* Read <bus>:<client_addr>[:<client_addr>] entries one by one */
 +        cp = strsep(&device_list, ",");
 +
-+        if (!cp || *cp =='\0') {
++        if (!cp || *cp == '\0') {
 +            break;
 +        }
 +
 +        if (n_adapter == MAX_I2C_ADAPTER) {
-+            g_printerr("too many adapter (%d), only support %d \n", n_adapter,
++            g_printerr("too many adapter (%d), only support %d\n", n_adapter,
 +                       MAX_I2C_ADAPTER);
 +            goto out;
 +        }
 +
 +        if (qemu_strtol(cp, &t, 10, &bus) || bus < 0) {
 ...
 +
 +        cp = t;
 +        n_client = 0;
 +
 +        /* Parse clients <client_addr>[:<client_addr>] entries one by one */
-+        while (cp != NULL && *cp !='\0') {
++        while (cp != NULL && *cp != '\0') {
-+            if (*cp == ':')
++            if (*cp == ':') {
 +                cp++;
++            }
 +
 +            if (n_client == MAX_I2C_VDEV) {
-+                g_printerr("too many devices (%d), only support %d \n",
++                g_printerr("too many devices (%d), only support %d\n",
 +                           n_client, MAX_I2C_VDEV);
 +                goto out;
 +            }
 +
-+            if (qemu_strtol(cp, &t, 16, &addr) || addr < 0 || addr > MAX_I2C_VDEV) {
++            if (qemu_strtol(cp, &t, 16, &addr) ||
 +                addr < 0 || addr > MAX_I2C_VDEV) {
 +                g_printerr("Invalid address %s : %lx\n", cp, addr);
 +                goto out;
 +            }
 +
 +            client_addr[n_client++] = addr;
 +            cp = t;
 +            if (verbose) {
 +                g_print("i2c adapter %ld:0x%lx\n", bus, addr);
 +            }
 +        }
 +
-+        i2c->adapter[n_adapter] = vi2c_create_adapter(bus, client_addr, n_client);
++        i2c->adapter[n_adapter] = vi2c_create_adapter(bus, client_addr,
-+        if (!i2c->adapter[n_adapter])
++                                                      n_client);
 +        if (!i2c->adapter[n_adapter]) {
 +            goto out;
++        }
++
 +        n_adapter++;
 +    }
 +
 +    if (!n_adapter) {
 +        g_printerr("Failed to add any adapters\n");
 ...
 +out:
 +    vi2c_remove_adapters(i2c);
 +    return -1;
 +}
 +
-+static uint8_t vi2c_xfer(VuDev *dev, struct i2c_msg *msg)
++static int32_t i2c_xfer(VI2cAdapter *adapter, struct i2c_msg *msgs,
 +                        size_t count)
 +{
 +    struct i2c_rdwr_ioctl_data data;
 +
 +    data.nmsgs = count;
 +    data.msgs = msgs;
 +
 +    return ioctl(adapter->fd, I2C_RDWR, &data);
 +}
 +
 +/*
 + * Based on Linux's drivers/i2c/i2c-core-smbus.c:i2c_smbus_xfer_emulated(). This
 + * function tries to reverse what Linux does, only support basic modes (up to
 + * word transfer).
 + */
 +static int32_t smbus_xfer(VI2cAdapter *adapter, struct i2c_msg *msgs,
 +                          size_t count)
 +{
 +    union i2c_smbus_data data;
 +    struct i2c_smbus_ioctl_data smbus_data = { .data = &data };
 +    int32_t ret;
 +
 +    smbus_data.command = msgs[0].buf[0];
 +
 +    switch (count) {
 +    case 1:
 +        if (msgs[0].flags & I2C_M_RD) {
 +            if (msgs[0].len > 1) {
 +                g_printerr("Incorrect message length for read operation: %d\n",
 +                           msgs[0].len);
 +                return -1;
 +            }
 +            smbus_data.read_write = I2C_SMBUS_READ;
 +        } else {
 +            smbus_data.read_write = I2C_SMBUS_WRITE;
 +        }
 +
 +        if (!msgs[0].len) {
 +            smbus_data.size = I2C_SMBUS_QUICK;
 +            smbus_data.data = NULL;
 +        } else if (msgs[0].len == 1) {
 +            smbus_data.size = I2C_SMBUS_BYTE;
 +            if (smbus_data.read_write == I2C_SMBUS_WRITE) {
 +                smbus_data.data = NULL;
 +            }
 +        } else if (msgs[0].len == 2) {
 +            smbus_data.size = I2C_SMBUS_BYTE_DATA;
 +            data.byte = msgs[0].buf[1];
 +        } else if (msgs[0].len == 3) {
 +            smbus_data.size = I2C_SMBUS_WORD_DATA;
 +            data.word = msgs[0].buf[1] | (msgs[0].buf[2] << 8);
 +        } else {
 +            g_printerr("Message length not supported for write operation: %d\n",
 +                       msgs[0].len);
 +            return -1;
 +        }
 +
 +        break;
 +    case 2:
 +        if ((msgs[0].flags & I2C_M_RD) || !(msgs[1].flags & I2C_M_RD) ||
 +            (msgs[0].len != 1) || (msgs[1].len > 2)) {
 +            g_printerr("Expecting a valid read smbus transfer: %ld: %d: %d\n",
 +                       count, msgs[0].len, msgs[1].len);
 +            return -1;
 +        }
 +
 +        smbus_data.read_write = I2C_SMBUS_READ;
 +        smbus_data.size = msgs[1].len == 1 ?
 +                          I2C_SMBUS_BYTE_DATA : I2C_SMBUS_WORD_DATA;
 +        break;
 +    default:
 +        g_printerr("Invalid number of messages for smbus xfer: %ld\n", count);
 +        return -1;
 +    }
 +
 +    if (verbose) {
 +        g_print("SMBUS command: %x: %x: %x\n", smbus_data.read_write,
 +                smbus_data.command, smbus_data.size);
 +    }
 +
 +    ret = ioctl(adapter->fd, I2C_SMBUS, &smbus_data);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
 +    if (smbus_data.read_write == I2C_SMBUS_WRITE) {
 +        return 0;
 +    }
 +
 +    switch (smbus_data.size) {
 +    case I2C_SMBUS_BYTE:
 +        msgs[0].buf[0] = data.byte;
 +        break;
 +    case I2C_SMBUS_BYTE_DATA:
 +        msgs[1].buf[0] = data.byte;
 +        break;
 +    case I2C_SMBUS_WORD_DATA:
 +        msgs[1].buf[0] = data.word & 0xff;
 +        msgs[1].buf[1] = data.word >> 8;
 +        break;
 +    }
 +
 +    return 0;
 +}
 +
 +static uint8_t vi2c_xfer(VuDev *dev, struct i2c_msg *msgs, size_t count)
 +{
 +    VuI2c *i2c = container_of(dev, VuI2c, dev.parent);
-+    struct i2c_rdwr_ioctl_data data;
 +    VI2cAdapter *adapter;
-+
++    int8_t ret;
-+    adapter = vi2c_find_adapter(i2c, msg->addr);
++
 +    /* Assume that adapter should be same for all messages sent together */
 +    adapter = vi2c_find_adapter(i2c, msgs[0].addr);
 +    if (!adapter) {
-+        g_printerr("Failed to find adapter for address: %x\n", msg->addr);
++        g_printerr("Failed to find adapter for address: %x\n", msgs[0].addr);
 +        return VIRTIO_I2C_MSG_ERR;
 +    }
 +
-+    data.nmsgs = 1;
++    /* Set client's address */
-+    data.msgs = msg;
++    if (!vi2c_set_client_addr(adapter, msgs[0].addr)) {
 +
 +    if (ioctl(adapter->fd, I2C_RDWR, &data) < 0) {
 +        g_printerr("Failed to transfer data to address %x : %d\n", msg->addr, errno);
 +        return VIRTIO_I2C_MSG_ERR;
 +    }
 +
++    if (adapter->smbus) {
++        ret = smbus_xfer(adapter, msgs, count);
++    } else {
++        ret = i2c_xfer(adapter, msgs, count);
++    }
++
++    if (ret < 0) {
++        g_printerr("Failed to transfer data to address %x : %d\n",
++                   msgs[0].addr, errno);
++        return VIRTIO_I2C_MSG_ERR;
++    }
++
 +    if (verbose) {
-+        vi2c_dump_msg(msg);
++        vi2c_dump_msg(msgs, count);
 +    }
 +
 +    return VIRTIO_I2C_MSG_OK;
 +}
-+
 +
 +/* Virtio helpers */
 +static uint64_t vi2c_get_features(VuDev *dev)
 +{
 +    if (verbose) {
 ...
 +}
 +
 +static void vi2c_handle_ctrl(VuDev *dev, int qidx)
 +{
 +    VuVirtq *vq = vu_get_queue(dev, qidx);
-+    struct i2c_msg msg;
 +    struct virtio_i2c_out_hdr *out_hdr;
-+    struct virtio_i2c_in_hdr *in_hdr;
++    size_t i, count = 0, len, in_hdr_len;
-+    bool fail_next = false;
++    struct i2c_msg *msgs;
-+    size_t len, in_hdr_len;
++    VuVirtqElement *elem;
-+
++    uint8_t status;
-+    for (;;) {
++    struct {
 +        struct virtio_i2c_in_hdr *in_hdr;
 +        VuVirtqElement *elem;
-+
++        size_t size;
 +    } *info;
 +
 +    /* Count number of messages */
 +    do {
 +        elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
 +    } while (elem && ++count);
 +
 +    if (!count) {
 +        if (verbose) {
 +            g_printerr("Virtqueue can't have 0 elements\n");
 +        }
 +        return;
 +    }
 +
 +    /* Rewind everything, now that we have counted the number of messages */
 +    vu_queue_rewind(dev, vq, count);
 +
 +    if (verbose) {
 +        g_print("Received %ld messages in virtqueue\n", count);
 +    }
 +
 +    /* Allocate memory for msgs and info */
 +    msgs = g_malloc0_n(count, sizeof(*msgs) + sizeof(*info));
 +    if (!msgs) {
 +        g_printerr("failed to allocate space for messages\n");
 +        return;
 +    }
 +    info = (void *)(msgs + count);
 +
 +    for (i = 0; i < count; i++) {
 +        elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
 +        if (!elem) {
-+            break;
++            g_printerr("Failed to pop element: %ld : %ld\n", i, count);
-+        }
++            goto out;
 +        }
 +        info[i].elem = elem;
 +        info[i].size = sizeof(*info[i].in_hdr);
 +
 +        g_debug("%s: got queue (in %d, out %d)", __func__, elem->in_num,
 +                elem->out_num);
 +
-+        /* Validate size of out header */
++        /* Validate size of "out" header */
 +        if (elem->out_sg[0].iov_len != sizeof(*out_hdr)) {
 +            g_warning("%s: Invalid out hdr %zu : %zu\n", __func__,
 +                      elem->out_sg[0].iov_len, sizeof(*out_hdr));
-+            continue;
++            goto out;
 +        }
 +
 +        out_hdr = elem->out_sg[0].iov_base;
 +
 +        /* Bit 0 is reserved in virtio spec */
-+        msg.addr = out_hdr->addr >> 1;
++        msgs[i].addr = le16toh(out_hdr->addr) >> 1;
 +
 +        /* Read Operation */
 +        if (elem->out_num == 1 && elem->in_num == 2) {
 +            len = elem->in_sg[0].iov_len;
 +            if (!len) {
 +                g_warning("%s: Read buffer length can't be zero\n", __func__);
-+                continue;
++                goto out;
 +            }
 +
-+            msg.buf = elem->in_sg[0].iov_base;
++            msgs[i].buf = elem->in_sg[0].iov_base;
-+            msg.flags = I2C_M_RD;
++            msgs[i].flags = I2C_M_RD;
-+            msg.len = len;
++            msgs[i].len = len;
 +
-+            in_hdr = elem->in_sg[1].iov_base;
++            info[i].in_hdr = elem->in_sg[1].iov_base;
 +            info[i].size += len;
 +            in_hdr_len = elem->in_sg[1].iov_len;
 +        } else if (elem->out_num == 2 && elem->in_num == 1) {
 +            /* Write Operation */
 +            len = elem->out_sg[1].iov_len;
 +            if (!len) {
 +                g_warning("%s: Write buffer length can't be zero\n", __func__);
-+                continue;
++                goto out;
 +            }
 +
-+            msg.buf = elem->out_sg[1].iov_base;
++            msgs[i].buf = elem->out_sg[1].iov_base;
-+            msg.flags = 0;
++            msgs[i].flags = 0;
-+            msg.len = len;
++            msgs[i].len = len;
 +
-+            in_hdr = elem->in_sg[0].iov_base;
++            info[i].in_hdr = elem->in_sg[0].iov_base;
 +            in_hdr_len = elem->in_sg[0].iov_len;
-+            len = 0;
 +        } else {
 +            g_warning("%s: Transfer type not supported (in %d, out %d)\n",
 +                      __func__, elem->in_num, elem->out_num);
-+            continue;
++            goto out;
 +        }
 +
-+        /* Validate size of in header */
++        /* Validate size of "in" header */
-+        if (in_hdr_len != sizeof(*in_hdr)) {
++        if (in_hdr_len != sizeof(*(info[i].in_hdr))) {
 +            g_warning("%s: Invalid in hdr %zu : %zu\n", __func__, in_hdr_len,
-+                      sizeof(*in_hdr));
++                      sizeof(*(info[i].in_hdr)));
-+            continue;
++            goto out;
 +        }
-+
++    }
-+        in_hdr->status = fail_next ? VIRTIO_I2C_MSG_ERR : vi2c_xfer(dev, &msg);
++
-+        if (in_hdr->status == VIRTIO_I2C_MSG_ERR) {
++    status = vi2c_xfer(dev, msgs, count);
-+            /* We need to fail remaining transfers as well */
++
-+            fail_next = out_hdr->flags & VIRTIO_I2C_FLAGS_FAIL_NEXT;
++    for (i = 0; i < count; i++) {
-+        }
++        info[i].in_hdr->status = status;
-+
++        vu_queue_push(dev, vq, info[i].elem, info[i].size);
 +        vu_queue_push(dev, vq, elem, len + sizeof(*in_hdr));
 +    }
 +
 +    vu_queue_notify(dev, vq);
++
++out:
++    g_free(msgs);
 +}
 +
 +static void
 +vi2c_queue_set_started(VuDev *dev, int qidx, bool started)
 +{
 ...
 +    g_autoptr(GSocket) socket = NULL;
 +    VuI2c i2c = {0};
 +
 +    context = g_option_context_new("vhost-user emulation of I2C device");
 +    g_option_context_add_main_entries(context, options, "vhost-user-i2c");
-+    if (!g_option_context_parse(context, &argc, &argv, &error))
++    if (!g_option_context_parse(context, &argc, &argv, &error)) {
 +    {
 +        g_printerr("option parsing failed: %s\n", error->message);
 +        exit(1);
 +    }
 +
 +    if (print_cap) {
 ...
 +
 +    if (verbose) {
 +        g_log_set_handler(NULL, G_LOG_LEVEL_MASK, g_log_default_handler, NULL);
 +        g_setenv("G_MESSAGES_DEBUG", "all", true);
 +    } else {
-+        g_log_set_handler(NULL,
++        g_log_set_handler(NULL, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL |
-+                          G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR,
++                          G_LOG_LEVEL_ERROR, g_log_default_handler, NULL);
 +                          g_log_default_handler, NULL);
 +    }
 +
 +    /*
 +     * Now create a vhost-user socket that we will receive messages
 +     * on. Once we have our handler set up we can enter the glib main
 +     * loop.
 +     */
 +    if (socket_path) {
 +        g_autoptr(GSocketAddress) addr = g_unix_socket_address_new(socket_path);
-+        g_autoptr(GSocket) bind_socket = g_socket_new(G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM,
++        g_autoptr(GSocket) bind_socket = g_socket_new(G_SOCKET_FAMILY_UNIX,
-+                                                      G_SOCKET_PROTOCOL_DEFAULT, &error);
++                    G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, &error);
 +
 +        if (!g_socket_bind(bind_socket, addr, false, &error)) {
 +            g_printerr("Failed to bind to socket at %s (%s).\n",
 +                       socket_path, error->message);
 +            exit(EXIT_FAILURE);
 ...

-[PATCH 4/5] docs: add a man page for vhost-user-i2c
+[PATCH V2 5/6] docs: add a man page for vhost-user-i2c
 ...
 +-----------
 +
 +This program is a vhost-user backend that emulates a VirtIO I2C bus.
 +This program takes the layout of the i2c bus and its devices on the host
 +OS and then talks to them via the /dev/i2c-X interface when a request
-+comes from the guest OS for an I2C device.
++comes from the guest OS for an I2C or SMBUS device.
 +
 +This program is designed to work with QEMU's ``-device
 +vhost-user-i2c-pci`` but should work with any virtual machine monitor
 +(VMM) that supports vhost-user. See the Examples section below.
 +
 ...

-[PATCH 5/5] MAINTAINERS: Add entry for virtio-i2c
+[PATCH V2 6/6] MAINTAINERS: Add entry for virtio-i2c
 ...
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ F: hw/virtio/virtio-mem-pci.h
+@@ -XXX,XX +XXX,XX @@ F: docs/interop/vhost-user-gpu.rst
- F: hw/virtio/virtio-mem-pci.c
+ F: contrib/vhost-user-gpu
- F: include/hw/virtio/virtio-mem.h
+ F: hw/display/vhost-user-*
-+virtio-i2c
++vhost-user-i2c
 +M: Viresh Kumar <viresh.kumar@linaro.org>
 +S: Supported
 +F: docs/tools/vhost-user-i2c.rst
 +F: hw/virtio/vhost-user-i2c.c
 +F: hw/virtio/vhost-user-i2c-pci.c
 +F: include/hw/virtio/vhost-user-i2c.h
 +F: tools/vhost-user-i2c/*
 +
- nvme
+ Cirrus VGA
- M: Keith Busch <kbusch@kernel.org>
+ M: Gerd Hoffmann <kraxel@redhat.com>
- M: Klaus Jensen <its@irrelevant.dk>
+ S: Odd Fixes
 --
 .25.0.rc1.19.g042ed3e048af

Hello,

This is an initial implementation of a generic vhost-user backend for
the I2C bus. This is based of the virtio specifications (already merged)
for the I2C bus.

The kernel virtio I2C driver is still under review, here is the latest
version (v10):

https://lore.kernel.org/lkml/226a8d5663b7bb6f5d06ede7701eedb18d1bafa1.1616493817.git.jie.deng@intel.com/

The backend is implemented as a vhost-user device because we want to
experiment in making portable backends that can be used with multiple
hypervisors.  We also want to support backends isolated in their own
separate service VMs with limited memory cross-sections with the
principle guest. This is part of a wider initiative by Linaro called
"project Stratos" for which you can find information here:

https://collaborate.linaro.org/display/STR/Stratos+Home

I mentioned this to explain the decision to write the daemon as a fairly
pure glib application that just depends on libvhost-user.

We are not sure where the vhost-user backend should get queued, qemu or
a separate repository. Similar questions were raised by an earlier
thread by Alex Bennée for his RPMB work:

https://lore.kernel.org/qemu-devel/20200925125147.26943-1-alex.bennee@linaro.org/

Testing:
-------

I didn't have access to a real hardware where I can play with a I2C
client device (like RTC, eeprom, etc) to verify the working of the
backend daemon, so I decided to test it on my x86 box itself with
hierarchy of two ARM64 guests.

The first ARM64 guest was passed "-device ds1338,address=0x20" option,
so it could emulate a ds1338 RTC device, which connects to an I2C bus.
Once the guest came up, ds1338 device instance was created within the
guest kernel by doing:

echo ds1338 0x20 > /sys/bus/i2c/devices/i2c-0/new_device

[
  Note that this may end up binding the ds1338 device to its driver,
  which won't let our i2c daemon talk to the device. For that we need to
  manually unbind the device from the driver:

echo 0-0020 > /sys/bus/i2c/devices/0-0020/driver/unbind
]

After this is done, you will get /dev/rtc1. This is the device we wanted
to emulate, which will be accessed by the vhost-user-i2c backend daemon
via the /dev/i2c-0 file present in the guest VM.

At this point we need to start the backend daemon and give it a
socket-path to talk to from qemu (you can pass -v to it to get more
detailed messages):

vhost-user-i2c --socket-path=vi2c.sock --device-list 0:20

[ Here, 0:20 is the bus/device mapping, 0 for /dev/i2c-0 and 20 is
client address of ds1338 that we used while creating the device. ]

Now we need to start the second level ARM64 guest (from within the first
guest) to get the i2c-virtio.c Linux driver up. The second level guest
is passed the following options to connect to the same socket:

-chardev socket,path=vi2c.sock,id=vi2c \
  -device vhost-user-i2c-pci,chardev=vi2c,id=i2c

Once the second level guest boots up, we will see the i2c-virtio bus at
/sys/bus/i2c/devices/i2c-X/. From there we can now make it emulate the
ds1338 device again by doing:

echo ds1338 0x20 > /sys/bus/i2c/devices/i2c-0/new_device

[ This time we want ds1338's driver to be bound to the device, so it
should be enabled in the kernel as well. ]

And we will get /dev/rtc1 device again here in the second level guest.
Now we can play with the rtc device with help of hwclock utility and we
can see the following sequence of transfers happening if we try to
update rtc's time from system time.

hwclock -w -f /dev/rtc1 (in guest2) ->
  Reaches i2c-virtio.c (Linux bus driver in guest2) ->
    transfer over virtio ->
      Reaches the qemu's vhost-i2c device emulation (running over guest1) ->
        Reaches the backend daemon vhost-user-i2c started earlier (in guest1) ->
          ioctl(/dev/i2c-0, I2C_RDWR, ..); (in guest1) ->
	    reaches qemu's hw/rtc/ds1338.c (running over host)

I hope I was able to give a clear picture of my test setup here :)

Thanks.

Viresh Kumar (5):
  hw/virtio: add boilerplate for vhost-user-i2c device
  hw/virtio: add vhost-user-i2c-pci boilerplate
  tools/vhost-user-i2c: Add backend driver
  docs: add a man page for vhost-user-i2c
  MAINTAINERS: Add entry for virtio-i2c

MAINTAINERS                                 |   9 +
 docs/tools/index.rst                        |   1 +
 docs/tools/vhost-user-i2c.rst               |  75 +++
 hw/virtio/Kconfig                           |   5 +
 hw/virtio/meson.build                       |   2 +
 hw/virtio/vhost-user-i2c-pci.c              |  79 +++
 hw/virtio/vhost-user-i2c.c                  | 286 +++++++++
 include/hw/virtio/vhost-user-i2c.h          |  37 ++
 include/standard-headers/linux/virtio_ids.h |   1 +
 tools/meson.build                           |   8 +
 tools/vhost-user-i2c/50-qemu-i2c.json.in    |   5 +
 tools/vhost-user-i2c/main.c                 | 652 ++++++++++++++++++++
 tools/vhost-user-i2c/meson.build            |  10 +
 13 files changed, 1170 insertions(+)
 create mode 100644 docs/tools/vhost-user-i2c.rst
 create mode 100644 hw/virtio/vhost-user-i2c-pci.c
 create mode 100644 hw/virtio/vhost-user-i2c.c
 create mode 100644 include/hw/virtio/vhost-user-i2c.h
 create mode 100644 tools/vhost-user-i2c/50-qemu-i2c.json.in
 create mode 100644 tools/vhost-user-i2c/main.c
 create mode 100644 tools/vhost-user-i2c/meson.build

-- 
2.25.0.rc1.19.g042ed3e048af

This creates the QEMU side of the vhost-user-i2c device which connects
to the remote daemon. It is based of vhost-user-fs code.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 hw/virtio/Kconfig                           |   5 +
 hw/virtio/meson.build                       |   1 +
 hw/virtio/vhost-user-i2c.c                  | 286 ++++++++++++++++++++
 include/hw/virtio/vhost-user-i2c.h          |  37 +++
 include/standard-headers/linux/virtio_ids.h |   1 +
 5 files changed, 330 insertions(+)
 create mode 100644 hw/virtio/vhost-user-i2c.c
 create mode 100644 include/hw/virtio/vhost-user-i2c.h

diff --git a/hw/virtio/Kconfig b/hw/virtio/Kconfig
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/Kconfig
+++ b/hw/virtio/Kconfig
@@ -XXX,XX +XXX,XX @@ config VIRTIO_MEM
     depends on LINUX
     depends on VIRTIO_MEM_SUPPORTED
     select MEM_DEVICE
+
+config VHOST_USER_I2C
+    bool
+    default y
+    depends on VIRTIO && VHOST_USER
diff --git a/hw/virtio/meson.build b/hw/virtio/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/meson.build
+++ b/hw/virtio/meson.build
@@ -XXX,XX +XXX,XX @@ virtio_ss.add(when: 'CONFIG_VHOST_USER_VSOCK', if_true: files('vhost-user-vsock.
 virtio_ss.add(when: 'CONFIG_VIRTIO_RNG', if_true: files('virtio-rng.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_IOMMU', if_true: files('virtio-iommu.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_MEM', if_true: files('virtio-mem.c'))
+virtio_ss.add(when: 'CONFIG_VHOST_USER_I2C', if_true: files('vhost-user-i2c.c'))
 
 virtio_pci_ss = ss.source_set()
 virtio_pci_ss.add(when: 'CONFIG_VHOST_VSOCK', if_true: files('vhost-vsock-pci.c'))
diff --git a/hw/virtio/vhost-user-i2c.c b/hw/virtio/vhost-user-i2c.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/virtio/vhost-user-i2c.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Vhost-user i2c virtio device
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/error.h"
+#include "hw/qdev-properties.h"
+#include "hw/virtio/virtio-bus.h"
+#include "hw/virtio/vhost-user-i2c.h"
+#include "qemu/error-report.h"
+#include "standard-headers/linux/virtio_ids.h"
+
+static void vu_i2c_start(VirtIODevice *vdev)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
+    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
+    int ret;
+    int i;
+
+    if (!k->set_guest_notifiers) {
+        error_report("binding does not support guest notifiers");
+        return;
+    }
+
+    ret = vhost_dev_enable_notifiers(&i2c->vhost_dev, vdev);
+    if (ret < 0) {
+        error_report("Error enabling host notifiers: %d", -ret);
+        return;
+    }
+
+    ret = k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, true);
+    if (ret < 0) {
+        error_report("Error binding guest notifier: %d", -ret);
+        goto err_host_notifiers;
+    }
+
+    i2c->vhost_dev.acked_features = vdev->guest_features;
+    ret = vhost_dev_start(&i2c->vhost_dev, vdev);
+    if (ret < 0) {
+        error_report("Error starting vhost-user-i2c: %d", -ret);
+        goto err_guest_notifiers;
+    }
+
+    /*
+     * guest_notifier_mask/pending not used yet, so just unmask
+     * everything here. virtio-pci will do the right thing by
+     * enabling/disabling irqfd.
+     */
+    for (i = 0; i < i2c->vhost_dev.nvqs; i++) {
+        vhost_virtqueue_mask(&i2c->vhost_dev, vdev, i, false);
+    }
+
+    return;
+
+err_guest_notifiers:
+    k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, false);
+err_host_notifiers:
+    vhost_dev_disable_notifiers(&i2c->vhost_dev, vdev);
+}
+
+static void vu_i2c_stop(VirtIODevice *vdev)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
+    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
+    int ret;
+
+    if (!k->set_guest_notifiers) {
+        return;
+    }
+
+    vhost_dev_stop(&i2c->vhost_dev, vdev);
+
+    ret = k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, false);
+    if (ret < 0) {
+        error_report("vhost guest notifier cleanup failed: %d", ret);
+        return;
+    }
+
+    vhost_dev_disable_notifiers(&i2c->vhost_dev, vdev);
+}
+
+static void vu_i2c_set_status(VirtIODevice *vdev, uint8_t status)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+    bool should_start = status & VIRTIO_CONFIG_S_DRIVER_OK;
+
+    if (!vdev->vm_running) {
+        should_start = false;
+    }
+
+    if (i2c->vhost_dev.started == should_start) {
+        return;
+    }
+
+    if (should_start) {
+        vu_i2c_start(vdev);
+    } else {
+        vu_i2c_stop(vdev);
+    }
+}
+
+static uint64_t vu_i2c_get_features(VirtIODevice *vdev,
+                                    uint64_t requested_features, Error **errp)
+{
+    /* No feature bits used yet */
+    return requested_features;
+}
+
+static void vu_i2c_handle_output(VirtIODevice *vdev, VirtQueue *vq)
+{
+    /*
+     * Not normally called; it's the daemon that handles the queue;
+     * however virtio's cleanup path can call this.
+     */
+}
+
+static void vu_i2c_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    vhost_virtqueue_mask(&i2c->vhost_dev, vdev, idx, mask);
+}
+
+static bool vu_i2c_guest_notifier_pending(VirtIODevice *vdev, int idx)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    return vhost_virtqueue_pending(&i2c->vhost_dev, idx);
+}
+
+static void do_vhost_user_cleanup(VirtIODevice *vdev, VHostUserI2C *i2c)
+{
+    vhost_user_cleanup(&i2c->vhost_user);
+    virtio_delete_queue(i2c->req_vq);
+    g_free(i2c->vhost_dev.vqs);
+    virtio_cleanup(vdev);
+    g_free(i2c->vhost_dev.vqs);
+    i2c->vhost_dev.vqs = NULL;
+}
+
+static int vu_i2c_connect(DeviceState *dev)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    if (i2c->connected) {
+        return 0;
+    }
+    i2c->connected = true;
+
+    /* restore vhost state */
+    if (virtio_device_started(vdev, vdev->status)) {
+        vu_i2c_start(vdev);
+    }
+
+    return 0;
+}
+
+static void vu_i2c_disconnect(DeviceState *dev)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    if (!i2c->connected) {
+        return;
+    }
+    i2c->connected = false;
+
+    if (i2c->vhost_dev.started) {
+        vu_i2c_stop(vdev);
+    }
+}
+
+static void vu_i2c_event(void *opaque, QEMUChrEvent event)
+{
+    DeviceState *dev = opaque;
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    switch (event) {
+    case CHR_EVENT_OPENED:
+        if (vu_i2c_connect(dev) < 0) {
+            qemu_chr_fe_disconnect(&i2c->conf.chardev);
+            return;
+        }
+        break;
+    case CHR_EVENT_CLOSED:
+        vu_i2c_disconnect(dev);
+        break;
+    case CHR_EVENT_BREAK:
+    case CHR_EVENT_MUX_IN:
+    case CHR_EVENT_MUX_OUT:
+        /* Ignore */
+        break;
+    }
+}
+
+static void vu_i2c_device_realize(DeviceState *dev, Error **errp)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(dev);
+    int ret;
+
+    if (!i2c->conf.chardev.chr) {
+        error_setg(errp, "missing chardev");
+        return;
+    }
+
+    if (!vhost_user_init(&i2c->vhost_user, &i2c->conf.chardev, errp)) {
+        return;
+    }
+
+    virtio_init(vdev, "vhost-user-i2c", VIRTIO_ID_I2C, 0);
+
+    i2c->req_vq = virtio_add_queue(vdev, 3, vu_i2c_handle_output);
+    i2c->vhost_dev.nvqs = 1;
+    i2c->vhost_dev.vqs = g_new0(struct vhost_virtqueue, i2c->vhost_dev.nvqs);
+    ret = vhost_dev_init(&i2c->vhost_dev, &i2c->vhost_user,
+                         VHOST_BACKEND_TYPE_USER, 0);
+    if (ret < 0) {
+        error_setg_errno(errp, -ret, "vhost_dev_init() failed");
+        do_vhost_user_cleanup(vdev, i2c);
+    }
+
+    qemu_chr_fe_set_handlers(&i2c->conf.chardev, NULL, NULL, vu_i2c_event, NULL,
+                             dev, NULL, true);
+}
+
+static void vu_i2c_device_unrealize(DeviceState *dev)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(dev);
+
+    /* This will stop vhost backend if appropriate. */
+    vu_i2c_set_status(vdev, 0);
+
+    vhost_dev_cleanup(&i2c->vhost_dev);
+
+    do_vhost_user_cleanup(vdev, i2c);
+}
+
+static const VMStateDescription vu_i2c_vmstate = {
+    .name = "vhost-user-i2c",
+    .unmigratable = 1,
+};
+
+static Property vu_i2c_properties[] = {
+    DEFINE_PROP_CHR("chardev", VHostUserI2C, conf.chardev),
+    DEFINE_PROP_END_OF_LIST(),
+};
+
+static void vu_i2c_class_init(ObjectClass *klass, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
+
+    device_class_set_props(dc, vu_i2c_properties);
+    dc->vmsd = &vu_i2c_vmstate;
+    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
+    vdc->realize = vu_i2c_device_realize;
+    vdc->unrealize = vu_i2c_device_unrealize;
+    vdc->get_features = vu_i2c_get_features;
+    vdc->set_status = vu_i2c_set_status;
+    vdc->guest_notifier_mask = vu_i2c_guest_notifier_mask;
+    vdc->guest_notifier_pending = vu_i2c_guest_notifier_pending;
+}
+
+static const TypeInfo vu_i2c_info = {
+    .name = TYPE_VHOST_USER_I2C,
+    .parent = TYPE_VIRTIO_DEVICE,
+    .instance_size = sizeof(VHostUserI2C),
+    .class_init = vu_i2c_class_init,
+};
+
+static void vu_i2c_register_types(void)
+{
+    type_register_static(&vu_i2c_info);
+}
+
+type_init(vu_i2c_register_types)
diff --git a/include/hw/virtio/vhost-user-i2c.h b/include/hw/virtio/vhost-user-i2c.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/hw/virtio/vhost-user-i2c.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Vhost-user i2c virtio device
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef _QEMU_VHOST_USER_I2C_H
+#define _QEMU_VHOST_USER_I2C_H
+
+#include "hw/virtio/virtio.h"
+#include "hw/virtio/vhost.h"
+#include "hw/virtio/vhost-user.h"
+#include "chardev/char-fe.h"
+
+#define TYPE_VHOST_USER_I2C "vhost-user-i2c-device"
+OBJECT_DECLARE_SIMPLE_TYPE(VHostUserI2C, VHOST_USER_I2C)
+
+typedef struct {
+    CharBackend chardev;
+} VHostUserI2CConf;
+
+struct VHostUserI2C {
+    /*< private >*/
+    VirtIODevice parent;
+    VHostUserI2CConf conf;
+    struct vhost_virtqueue *vhost_vq;
+    struct vhost_dev vhost_dev;
+    VhostUserState vhost_user;
+    VirtQueue *req_vq;
+    bool connected;
+
+    /*< public >*/
+};
+
+#endif /* _QEMU_VHOST_USER_I2C_H */
diff --git a/include/standard-headers/linux/virtio_ids.h b/include/standard-headers/linux/virtio_ids.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/linux/virtio_ids.h
+++ b/include/standard-headers/linux/virtio_ids.h
@@ -XXX,XX +XXX,XX @@
 #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			34 /* virtio i2c */
 
 #endif /* _LINUX_VIRTIO_IDS_H */
-- 
2.25.0.rc1.19.g042ed3e048af

This allows is to instantiate a vhost-user-i2c device as part of a PCI
bus. It is mostly boilerplate which looks pretty similar to the
vhost-user-fs-pci device.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 hw/virtio/meson.build          |  1 +
 hw/virtio/vhost-user-i2c-pci.c | 79 ++++++++++++++++++++++++++++++++++
 2 files changed, 80 insertions(+)
 create mode 100644 hw/virtio/vhost-user-i2c-pci.c

diff --git a/hw/virtio/meson.build b/hw/virtio/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/meson.build
+++ b/hw/virtio/meson.build
@@ -XXX,XX +XXX,XX @@ virtio_ss.add(when: 'CONFIG_VIRTIO_RNG', if_true: files('virtio-rng.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_IOMMU', if_true: files('virtio-iommu.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_MEM', if_true: files('virtio-mem.c'))
 virtio_ss.add(when: 'CONFIG_VHOST_USER_I2C', if_true: files('vhost-user-i2c.c'))
+virtio_ss.add(when: ['CONFIG_VIRTIO_PCI', 'CONFIG_VHOST_USER_I2C'], if_true: files('vhost-user-i2c-pci.c'))
 
 virtio_pci_ss = ss.source_set()
 virtio_pci_ss.add(when: 'CONFIG_VHOST_VSOCK', if_true: files('vhost-vsock-pci.c'))
diff --git a/hw/virtio/vhost-user-i2c-pci.c b/hw/virtio/vhost-user-i2c-pci.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/virtio/vhost-user-i2c-pci.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Vhost-user i2c virtio device PCI glue
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "qemu/osdep.h"
+#include "hw/qdev-properties.h"
+#include "hw/virtio/vhost-user-i2c.h"
+#include "virtio-pci.h"
+
+struct VHostUserI2CPCI {
+    VirtIOPCIProxy parent_obj;
+    VHostUserI2C vdev;
+};
+
+typedef struct VHostUserI2CPCI VHostUserI2CPCI;
+
+#define TYPE_VHOST_USER_I2C_PCI "vhost-user-i2c-pci-base"
+
+DECLARE_INSTANCE_CHECKER(VHostUserI2CPCI, VHOST_USER_I2C_PCI,
+                         TYPE_VHOST_USER_I2C_PCI)
+
+static Property vhost_user_i2c_pci_properties[] = {
+    DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
+                       DEV_NVECTORS_UNSPECIFIED),
+    DEFINE_PROP_END_OF_LIST(),
+};
+
+static void vhost_user_i2c_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
+{
+    VHostUserI2CPCI *dev = VHOST_USER_I2C_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
+        vpci_dev->nvectors = 1;
+    }
+
+    qdev_realize(vdev, BUS(&vpci_dev->bus), errp);
+}
+
+static void vhost_user_i2c_pci_class_init(ObjectClass *klass, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+    k->realize = vhost_user_i2c_pci_realize;
+    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
+    device_class_set_props(dc, vhost_user_i2c_pci_properties);
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = 0; /* Set by virtio-pci based on virtio id */
+    pcidev_k->revision = 0x00;
+    pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
+}
+
+static void vhost_user_i2c_pci_instance_init(Object *obj)
+{
+    VHostUserI2CPCI *dev = VHOST_USER_I2C_PCI(obj);
+
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VHOST_USER_I2C);
+}
+
+static const VirtioPCIDeviceTypeInfo vhost_user_i2c_pci_info = {
+    .base_name = TYPE_VHOST_USER_I2C_PCI,
+    .non_transitional_name = "vhost-user-i2c-pci",
+    .instance_size = sizeof(VHostUserI2CPCI),
+    .instance_init = vhost_user_i2c_pci_instance_init,
+    .class_init = vhost_user_i2c_pci_class_init,
+};
+
+static void vhost_user_i2c_pci_register(void)
+{
+    virtio_pci_types_register(&vhost_user_i2c_pci_info);
+}
+
+type_init(vhost_user_i2c_pci_register);
-- 
2.25.0.rc1.19.g042ed3e048af

This adds the vhost-user backend driver to support virtio based I2C
devices.

vhost-user-i2c --help

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 hw/virtio/vhost-user-i2c.c               |   2 +-
 tools/meson.build                        |   8 +
 tools/vhost-user-i2c/50-qemu-i2c.json.in |   5 +
 tools/vhost-user-i2c/main.c              | 652 +++++++++++++++++++++++
 tools/vhost-user-i2c/meson.build         |  10 +
 5 files changed, 676 insertions(+), 1 deletion(-)
 create mode 100644 tools/vhost-user-i2c/50-qemu-i2c.json.in
 create mode 100644 tools/vhost-user-i2c/main.c
 create mode 100644 tools/vhost-user-i2c/meson.build

diff --git a/hw/virtio/vhost-user-i2c.c b/hw/virtio/vhost-user-i2c.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/vhost-user-i2c.c
+++ b/hw/virtio/vhost-user-i2c.c
@@ -XXX,XX +XXX,XX @@ static void vu_i2c_device_realize(DeviceState *dev, Error **errp)
 
     virtio_init(vdev, "vhost-user-i2c", VIRTIO_ID_I2C, 0);
 
-    i2c->req_vq = virtio_add_queue(vdev, 3, vu_i2c_handle_output);
+    i2c->req_vq = virtio_add_queue(vdev, 4, vu_i2c_handle_output);
     i2c->vhost_dev.nvqs = 1;
     i2c->vhost_dev.vqs = g_new0(struct vhost_virtqueue, i2c->vhost_dev.nvqs);
     ret = vhost_dev_init(&i2c->vhost_dev, &i2c->vhost_user,
diff --git a/tools/meson.build b/tools/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/tools/meson.build
+++ b/tools/meson.build
@@ -XXX,XX +XXX,XX @@ endif
 if have_virtiofsd
   subdir('virtiofsd')
 endif
+
+have_virtioi2c= (have_system and
+    have_tools and
+    'CONFIG_LINUX' in config_host)
+
+if have_virtioi2c
+  subdir('vhost-user-i2c')
+endif
diff --git a/tools/vhost-user-i2c/50-qemu-i2c.json.in b/tools/vhost-user-i2c/50-qemu-i2c.json.in
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tools/vhost-user-i2c/50-qemu-i2c.json.in
@@ -XXX,XX +XXX,XX @@
+{
+  "description": "QEMU vhost-user-i2c",
+  "type": "bridge",
+  "binary": "@libexecdir@/vhost-user-i2c"
+}
diff --git a/tools/vhost-user-i2c/main.c b/tools/vhost-user-i2c/main.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tools/vhost-user-i2c/main.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * VIRTIO I2C Emulation via vhost-user
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#define G_LOG_DOMAIN "vhost-user-i2c"
+#define G_LOG_USE_STRUCTURED 1
+
+#include <glib.h>
+#include <gio/gio.h>
+#include <gio/gunixsocketaddress.h>
+#include <glib-unix.h>
+#include <glib/gstdio.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <inttypes.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <endian.h>
+#include <assert.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+
+#include "qemu/cutils.h"
+#include "subprojects/libvhost-user/libvhost-user-glib.h"
+#include "subprojects/libvhost-user/libvhost-user.h"
+
+/* Definitions from virtio-i2c specifications */
+#define VHOST_USER_I2C_MAX_QUEUES       1
+
+/* Status */
+#define VIRTIO_I2C_MSG_OK               0
+#define VIRTIO_I2C_MSG_ERR              1
+
+/* 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_out_hdr - the virtio I2C message OUT header
+ * @addr: the controlled device's address
+ * @padding: used to pad to full dword
+ * @flags: used for feature extensibility
+ */
+struct virtio_i2c_out_hdr {
+    uint16_t addr;
+    uint16_t padding;
+    uint32_t flags;
+} __attribute__((packed));
+
+/**
+ * struct virtio_i2c_in_hdr - the virtio I2C message IN header
+ * @status: the processing result from the backend
+ */
+struct virtio_i2c_in_hdr {
+    uint8_t status;
+} __attribute__((packed));
+
+/* vhost-user-i2c definitions */
+
+#ifndef container_of
+#define container_of(ptr, type, member) ({                      \
+        const typeof(((type *) 0)->member) *__mptr = (ptr);     \
+        (type *) ((char *) __mptr - offsetof(type, member));})
+#endif
+
+#define MAX_I2C_VDEV                    (1 << 7)
+#define MAX_I2C_ADAPTER                 16
+
+typedef struct {
+    int32_t fd;
+    int32_t bus;
+    bool clients[MAX_I2C_VDEV];
+} VI2cAdapter;
+
+typedef struct {
+    VugDev dev;
+    GMainLoop *loop;
+    VI2cAdapter *adapter[MAX_I2C_ADAPTER];
+    uint16_t adapter_map[MAX_I2C_VDEV];
+    uint32_t adapter_num;
+} VuI2c;
+
+static gboolean print_cap, verbose;
+static gchar *socket_path, *device_list;
+static gint socket_fd = -1;
+
+static GOptionEntry options[] = {
+    { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &socket_path, "Location of vhost-user Unix domain socket, incompatible with --fd", "PATH" },
+    { "fd", 'f', 0, G_OPTION_ARG_INT, &socket_fd, "Specify the file-descriptor of the backend, incompatible with --socket-path", "FD" },
+    { "device-list", 'l', 0, G_OPTION_ARG_STRING, &device_list, "List of i2c-dev bus and attached devices", "I2C Devices" },
+    { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &print_cap, "Output to stdout the backend capabilities in JSON format and exit", NULL},
+    { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Be more verbose in output", NULL},
+    { NULL }
+};
+
+
+/* I2c helpers */
+static void fmt_bytes(GString *s, uint8_t *bytes, int len)
+{
+    int32_t i;
+    for (i = 0; i < len; i++) {
+        if (i && i % 16 == 0) {
+            g_string_append_c(s, '\n');
+        }
+        g_string_append_printf(s, "%x ", bytes[i]);
+    }
+}
+
+static void vi2c_dump_msg(struct i2c_msg *msg)
+{
+    g_autoptr(GString) s = g_string_new("\nI2c request: ");
+
+    g_string_append_printf(s, "addr: %x\n", msg->addr);
+    g_string_append_printf(s, "transfer len: %x\n", msg->len);
+
+    g_string_append_printf(s, "%s: ", msg->flags & I2C_M_RD ? "Data read" :
+                                                              "Data Written");
+    fmt_bytes(s, (uint8_t *)msg->buf, msg->len);
+    g_string_append_printf(s, "\n");
+
+    g_debug("%s: %s", __func__, s->str);
+}
+
+static int vi2c_map_adapters(VuI2c *i2c)
+{
+    VI2cAdapter *adapter;
+    int32_t i, client_addr;
+
+    /*
+     * Flatten the map for client address and adapter to the array:
+     *
+     * adapter_map[MAX_I2C_VDEV]:
+     *
+     * Adapter        | adapter2 | none  | adapter1 | adapter3 | none | none| (val)
+     *                |----------|-------|----------|----------|------|-----|
+     * Slave Address  | addr 1   | none  | addr 2   | addr 3   | none | none| (idx)
+     *                |<-----------------------MAX_I2C_VDEV---------------->|
+     */
+    for (i = 0; i < i2c->adapter_num; i++) {
+        adapter = i2c->adapter[i];
+
+        for (client_addr = 0; client_addr < MAX_I2C_VDEV; client_addr++) {
+            if (adapter->clients[client_addr]) {
+                if (i2c->adapter_map[client_addr]) {
+                    g_printerr("client addr %x repeated, not supported!\n",
+                               client_addr);
+                    return -1;
+                }
+
+                /* The array is initialized to 0, + 1 for index */
+                i2c->adapter_map[client_addr] = i + 1;
+                if (verbose) {
+                    g_print("client: 0x%x -> i2c adapter: %d\n", client_addr,
+                            adapter->bus);
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+static VI2cAdapter *vi2c_find_adapter(VuI2c *i2c, uint16_t addr)
+{
+    int32_t idx;
+
+    if (addr < MAX_I2C_VDEV && ((idx = i2c->adapter_map[addr]) != 0)) {
+        return i2c->adapter[idx - 1];
+    }
+
+    return NULL;
+}
+
+static bool vi2c_client_access_ok(VI2cAdapter *adapter, uint16_t addr)
+{
+    if (ioctl(adapter->fd, I2C_SLAVE, addr) < 0) {
+        if (errno == EBUSY) {
+            g_printerr("client device %x is busy!\n", addr);
+        } else {
+            g_printerr("client device %d does not exist!\n", addr);
+        }
+        return false;
+    }
+    return true;
+}
+
+static void vi2c_remove_adapters(VuI2c *i2c)
+{
+    VI2cAdapter *adapter;
+    int32_t i;
+
+    for (i = 0; i < i2c->adapter_num; i++) {
+        adapter = i2c->adapter[i];
+        if (!adapter) {
+            break;
+        }
+
+        if (adapter->fd > 0) {
+            close(adapter->fd);
+        }
+
+        g_free(adapter);
+        i2c->adapter[i] = NULL;
+    }
+}
+
+static VI2cAdapter *vi2c_create_adapter(int32_t bus, uint16_t client_addr[],
+                                        int32_t n_client)
+{
+    VI2cAdapter *adapter;
+    char path[20];
+    int32_t fd, i;
+
+    if (bus < 0)
+        return NULL;
+
+    adapter = g_malloc0(sizeof(*adapter));
+    if (!adapter) {
+        g_printerr("failed to alloc adapter");
+        return NULL;
+    }
+
+    snprintf(path, sizeof(path), "/dev/i2c-%d", bus);
+    path[sizeof(path) - 1] = '\0';
+
+    fd = open(path, O_RDWR);
+    if (fd < 0) {
+        g_printerr("virtio_i2c: failed to open %s\n", path);
+        goto fail;
+    }
+
+    adapter->fd = fd;
+    adapter->bus = bus;
+
+    for (i = 0; i < n_client; i++) {
+        if (client_addr[i]) {
+            if (!vi2c_client_access_ok(adapter, client_addr[i])) {
+                goto fail;
+            }
+
+            if (adapter->clients[client_addr[i]]) {
+                g_printerr("client addr 0x%x repeat, not allowed.\n", client_addr[i]);
+                goto fail;
+            }
+
+            adapter->clients[client_addr[i]] = true;
+            if (verbose) {
+                g_print("Added client 0x%x to bus %u\n", client_addr[i], bus);
+            }
+        }
+    }
+    return adapter;
+
+fail:
+    g_free(adapter);
+    return NULL;
+}
+
+/*
+ * Virtio I2C device list format.
+ *
+ * <bus>:<client_addr>[:<client_addr>],
+ * [<bus>:<client_addr>[:<client_addr>]]
+ *
+ * bus (dec): adatper bus number.
+ * 	e.g. 2 for /dev/i2c-2
+ * client_addr (hex): address for client device
+ * 	e.g. 0x1C or 1C
+ *
+ * Example: --device-list="2:0x1c:0x20,3:0x10:0x2c"
+ *
+ * Note: client address can not repeat.
+ */
+static int vi2c_parse(VuI2c *i2c)
+{
+    uint16_t client_addr[MAX_I2C_VDEV];
+    int32_t n_adapter = 0, n_client;
+    int64_t addr, bus;
+    const char *cp, *t;
+
+    while (device_list) {
+        /* Read <bus>:<client_addr>[:<client_addr>] entries one by one */
+        cp = strsep(&device_list, ",");
+
+        if (!cp || *cp =='\0') {
+            break;
+        }
+
+        if (n_adapter == MAX_I2C_ADAPTER) {
+            g_printerr("too many adapter (%d), only support %d \n", n_adapter,
+                       MAX_I2C_ADAPTER);
+            goto out;
+        }
+
+        if (qemu_strtol(cp, &t, 10, &bus) || bus < 0) {
+            g_printerr("Invalid bus number %s\n", cp);
+            goto out;
+        }
+
+        cp = t;
+        n_client = 0;
+
+        /* Parse clients <client_addr>[:<client_addr>] entries one by one */
+        while (cp != NULL && *cp !='\0') {
+            if (*cp == ':')
+                cp++;
+
+            if (n_client == MAX_I2C_VDEV) {
+                g_printerr("too many devices (%d), only support %d \n",
+                           n_client, MAX_I2C_VDEV);
+                goto out;
+            }
+
+            if (qemu_strtol(cp, &t, 16, &addr) || addr < 0 || addr > MAX_I2C_VDEV) {
+                g_printerr("Invalid address %s : %lx\n", cp, addr);
+                goto out;
+            }
+
+            client_addr[n_client++] = addr;
+            cp = t;
+            if (verbose) {
+                g_print("i2c adapter %ld:0x%lx\n", bus, addr);
+            }
+        }
+
+        i2c->adapter[n_adapter] = vi2c_create_adapter(bus, client_addr, n_client);
+        if (!i2c->adapter[n_adapter])
+            goto out;
+        n_adapter++;
+    }
+
+    if (!n_adapter) {
+        g_printerr("Failed to add any adapters\n");
+        return -1;
+    }
+
+    i2c->adapter_num = n_adapter;
+
+    if (!vi2c_map_adapters(i2c)) {
+        return 0;
+    }
+
+out:
+    vi2c_remove_adapters(i2c);
+    return -1;
+}
+
+static uint8_t vi2c_xfer(VuDev *dev, struct i2c_msg *msg)
+{
+    VuI2c *i2c = container_of(dev, VuI2c, dev.parent);
+    struct i2c_rdwr_ioctl_data data;
+    VI2cAdapter *adapter;
+
+    adapter = vi2c_find_adapter(i2c, msg->addr);
+    if (!adapter) {
+        g_printerr("Failed to find adapter for address: %x\n", msg->addr);
+        return VIRTIO_I2C_MSG_ERR;
+    }
+
+    data.nmsgs = 1;
+    data.msgs = msg;
+
+    if (ioctl(adapter->fd, I2C_RDWR, &data) < 0) {
+        g_printerr("Failed to transfer data to address %x : %d\n", msg->addr, errno);
+        return VIRTIO_I2C_MSG_ERR;
+    }
+
+    if (verbose) {
+        vi2c_dump_msg(msg);
+    }
+
+    return VIRTIO_I2C_MSG_OK;
+}
+
+
+/* Virtio helpers */
+static uint64_t vi2c_get_features(VuDev *dev)
+{
+    if (verbose) {
+        g_info("%s: replying", __func__);
+    }
+    return 0;
+}
+
+static void vi2c_set_features(VuDev *dev, uint64_t features)
+{
+    if (verbose && features) {
+        g_autoptr(GString) s = g_string_new("Requested un-handled feature");
+        g_string_append_printf(s, " 0x%" PRIx64 "", features);
+        g_info("%s: %s", __func__, s->str);
+    }
+}
+
+static void vi2c_handle_ctrl(VuDev *dev, int qidx)
+{
+    VuVirtq *vq = vu_get_queue(dev, qidx);
+    struct i2c_msg msg;
+    struct virtio_i2c_out_hdr *out_hdr;
+    struct virtio_i2c_in_hdr *in_hdr;
+    bool fail_next = false;
+    size_t len, in_hdr_len;
+
+    for (;;) {
+        VuVirtqElement *elem;
+
+        elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
+        if (!elem) {
+            break;
+        }
+
+        g_debug("%s: got queue (in %d, out %d)", __func__, elem->in_num,
+                elem->out_num);
+
+        /* Validate size of out header */
+        if (elem->out_sg[0].iov_len != sizeof(*out_hdr)) {
+            g_warning("%s: Invalid out hdr %zu : %zu\n", __func__,
+                      elem->out_sg[0].iov_len, sizeof(*out_hdr));
+            continue;
+        }
+
+        out_hdr = elem->out_sg[0].iov_base;
+
+        /* Bit 0 is reserved in virtio spec */
+        msg.addr = out_hdr->addr >> 1;
+
+        /* Read Operation */
+        if (elem->out_num == 1 && elem->in_num == 2) {
+            len = elem->in_sg[0].iov_len;
+            if (!len) {
+                g_warning("%s: Read buffer length can't be zero\n", __func__);
+                continue;
+            }
+
+            msg.buf = elem->in_sg[0].iov_base;
+            msg.flags = I2C_M_RD;
+            msg.len = len;
+
+            in_hdr = elem->in_sg[1].iov_base;
+            in_hdr_len = elem->in_sg[1].iov_len;
+        } else if (elem->out_num == 2 && elem->in_num == 1) {
+            /* Write Operation */
+            len = elem->out_sg[1].iov_len;
+            if (!len) {
+                g_warning("%s: Write buffer length can't be zero\n", __func__);
+                continue;
+            }
+
+            msg.buf = elem->out_sg[1].iov_base;
+            msg.flags = 0;
+            msg.len = len;
+
+            in_hdr = elem->in_sg[0].iov_base;
+            in_hdr_len = elem->in_sg[0].iov_len;
+            len = 0;
+        } else {
+            g_warning("%s: Transfer type not supported (in %d, out %d)\n",
+                      __func__, elem->in_num, elem->out_num);
+            continue;
+        }
+
+        /* Validate size of in header */
+        if (in_hdr_len != sizeof(*in_hdr)) {
+            g_warning("%s: Invalid in hdr %zu : %zu\n", __func__, in_hdr_len,
+                      sizeof(*in_hdr));
+            continue;
+        }
+
+        in_hdr->status = fail_next ? VIRTIO_I2C_MSG_ERR : vi2c_xfer(dev, &msg);
+        if (in_hdr->status == VIRTIO_I2C_MSG_ERR) {
+            /* We need to fail remaining transfers as well */
+            fail_next = out_hdr->flags & VIRTIO_I2C_FLAGS_FAIL_NEXT;
+        }
+
+        vu_queue_push(dev, vq, elem, len + sizeof(*in_hdr));
+    }
+
+    vu_queue_notify(dev, vq);
+}
+
+static void
+vi2c_queue_set_started(VuDev *dev, int qidx, bool started)
+{
+    VuVirtq *vq = vu_get_queue(dev, qidx);
+
+    g_debug("queue started %d:%d\n", qidx, started);
+
+    if (!qidx) {
+        vu_set_queue_handler(dev, vq, started ? vi2c_handle_ctrl : NULL);
+    }
+}
+
+/*
+ * vi2c_process_msg: process messages of vhost-user interface
+ *
+ * Any that are not handled here are processed by the libvhost library
+ * itself.
+ */
+static int vi2c_process_msg(VuDev *dev, VhostUserMsg *msg, int *do_reply)
+{
+    VuI2c *i2c = container_of(dev, VuI2c, dev.parent);
+
+    if (msg->request == VHOST_USER_NONE) {
+        g_main_loop_quit(i2c->loop);
+        return 1;
+    }
+
+    return 0;
+}
+
+static const VuDevIface vuiface = {
+    .set_features = vi2c_set_features,
+    .get_features = vi2c_get_features,
+    .queue_set_started = vi2c_queue_set_started,
+    .process_msg = vi2c_process_msg,
+};
+
+static gboolean hangup(gpointer user_data)
+{
+    GMainLoop *loop = (GMainLoop *) user_data;
+    g_info("%s: caught hangup/quit signal, quitting main loop", __func__);
+    g_main_loop_quit(loop);
+    return true;
+}
+
+static void vi2c_panic(VuDev *dev, const char *msg)
+{
+    g_critical("%s\n", msg);
+    exit(EXIT_FAILURE);
+}
+
+/* Print vhost-user.json backend program capabilities */
+static void print_capabilities(void)
+{
+    printf("{\n");
+    printf("  \"type\": \"i2c\"\n");
+    printf("  \"device-list\"\n");
+    printf("}\n");
+}
+
+static void vi2c_destroy(VuI2c *i2c)
+{
+    vi2c_remove_adapters(i2c);
+    vug_deinit(&i2c->dev);
+    if (socket_path) {
+        unlink(socket_path);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    GError *error = NULL;
+    GOptionContext *context;
+    g_autoptr(GSocket) socket = NULL;
+    VuI2c i2c = {0};
+
+    context = g_option_context_new("vhost-user emulation of I2C device");
+    g_option_context_add_main_entries(context, options, "vhost-user-i2c");
+    if (!g_option_context_parse(context, &argc, &argv, &error))
+    {
+        g_printerr("option parsing failed: %s\n", error->message);
+        exit(1);
+    }
+
+    if (print_cap) {
+        print_capabilities();
+        exit(0);
+    }
+
+    if (!socket_path && socket_fd < 0) {
+        g_printerr("Please specify either --fd or --socket-path\n");
+        exit(EXIT_FAILURE);
+    }
+
+    if (verbose) {
+        g_log_set_handler(NULL, G_LOG_LEVEL_MASK, g_log_default_handler, NULL);
+        g_setenv("G_MESSAGES_DEBUG", "all", true);
+    } else {
+        g_log_set_handler(NULL,
+                          G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR,
+                          g_log_default_handler, NULL);
+    }
+
+    /*
+     * Now create a vhost-user socket that we will receive messages
+     * on. Once we have our handler set up we can enter the glib main
+     * loop.
+     */
+    if (socket_path) {
+        g_autoptr(GSocketAddress) addr = g_unix_socket_address_new(socket_path);
+        g_autoptr(GSocket) bind_socket = g_socket_new(G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM,
+                                                      G_SOCKET_PROTOCOL_DEFAULT, &error);
+
+        if (!g_socket_bind(bind_socket, addr, false, &error)) {
+            g_printerr("Failed to bind to socket at %s (%s).\n",
+                       socket_path, error->message);
+            exit(EXIT_FAILURE);
+        }
+        if (!g_socket_listen(bind_socket, &error)) {
+            g_printerr("Failed to listen on socket %s (%s).\n",
+                       socket_path, error->message);
+        }
+        g_message("awaiting connection to %s", socket_path);
+        socket = g_socket_accept(bind_socket, NULL, &error);
+        if (!socket) {
+            g_printerr("Failed to accept on socket %s (%s).\n",
+                       socket_path, error->message);
+        }
+    } else {
+        socket = g_socket_new_from_fd(socket_fd, &error);
+        if (!socket) {
+            g_printerr("Failed to connect to FD %d (%s).\n",
+                       socket_fd, error->message);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    if (vi2c_parse(&i2c)) {
+        exit(EXIT_FAILURE);
+    }
+
+    /*
+     * Create the main loop first so all the various sources can be
+     * added. As well as catching signals we need to ensure vug_init
+     * can add it's GSource watches.
+     */
+
+    i2c.loop = g_main_loop_new(NULL, FALSE);
+    /* catch exit signals */
+    g_unix_signal_add(SIGHUP, hangup, i2c.loop);
+    g_unix_signal_add(SIGINT, hangup, i2c.loop);
+
+    if (!vug_init(&i2c.dev, VHOST_USER_I2C_MAX_QUEUES, g_socket_get_fd(socket),
+                  vi2c_panic, &vuiface)) {
+        g_printerr("Failed to initialize libvhost-user-glib.\n");
+        exit(EXIT_FAILURE);
+    }
+
+
+    g_message("entering main loop, awaiting messages");
+    g_main_loop_run(i2c.loop);
+    g_message("finished main loop, cleaning up");
+
+    g_main_loop_unref(i2c.loop);
+    vi2c_destroy(&i2c);
+}
diff --git a/tools/vhost-user-i2c/meson.build b/tools/vhost-user-i2c/meson.build
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tools/vhost-user-i2c/meson.build
@@ -XXX,XX +XXX,XX @@
+executable('vhost-user-i2c', files(
+  'main.c'),
+  dependencies: [qemuutil, glib, gio],
+  install: true,
+  install_dir: get_option('libexecdir'))
+
+configure_file(input: '50-qemu-i2c.json.in',
+               output: '50-qemu-i2c.json',
+               configuration: config_host,
+               install_dir: qemu_datadir / 'vhost-user')
-- 
2.25.0.rc1.19.g042ed3e048af

Basic usage and example invocation.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 docs/tools/index.rst          |  1 +
 docs/tools/vhost-user-i2c.rst | 75 +++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 docs/tools/vhost-user-i2c.rst

diff --git a/docs/tools/index.rst b/docs/tools/index.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/tools/index.rst
+++ b/docs/tools/index.rst
@@ -XXX,XX +XXX,XX @@ QEMU Tools Guide
    qemu-trace-stap
    virtfs-proxy-helper
    virtiofsd
+   vhost-user-i2c
diff --git a/docs/tools/vhost-user-i2c.rst b/docs/tools/vhost-user-i2c.rst
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/docs/tools/vhost-user-i2c.rst
@@ -XXX,XX +XXX,XX @@
+QEMU vhost-user-i2c - I2C emulation backend
+===========================================
+
+Synopsis
+--------
+
+**vhost-user-i2c** [*OPTIONS*]
+
+Description
+-----------
+
+This program is a vhost-user backend that emulates a VirtIO I2C bus.
+This program takes the layout of the i2c bus and its devices on the host
+OS and then talks to them via the /dev/i2c-X interface when a request
+comes from the guest OS for an I2C device.
+
+This program is designed to work with QEMU's ``-device
+vhost-user-i2c-pci`` but should work with any virtual machine monitor
+(VMM) that supports vhost-user. See the Examples section below.
+
+Options
+-------
+
+.. program:: vhost-user-i2c
+
+.. option:: -h, --help
+
+  Print help.
+
+.. option:: -v, --verbose
+
+   Increase verbosity of output
+
+.. option:: -s, --socket-path=PATH
+
+  Listen on vhost-user UNIX domain socket at PATH. Incompatible with --fd.
+
+.. option:: -f, --fd=FDNUM
+
+  Accept connections from vhost-user UNIX domain socket file descriptor FDNUM.
+  The file descriptor must already be listening for connections.
+  Incompatible with --socket-path.
+
+.. option:: -l, --device-list=I2C-DEVICES
+
+  I2c device list at the host OS in the format:
+      <bus>:<client_addr>[:<client_addr>],[<bus>:<client_addr>[:<client_addr>]]
+
+      Example: --device-list "2:1c:20,3:10:2c"
+
+  Here,
+      bus (decimal): adatper bus number. e.g. 2 for /dev/i2c-2, 3 for /dev/i2c-3.
+      client_addr (hex): address for client device. e.g. 0x1C, 0x20, 0x10, 0x2C.
+
+Examples
+--------
+
+The daemon should be started first:
+
+::
+
+  host# vhost-user-i2c --socket-path=vi2c.sock --device-list 0:20
+
+The QEMU invocation needs to create a chardev socket the device can
+use to communicate as well as share the guests memory over a memfd.
+
+::
+
+  host# qemu-system \
+      -chardev socket,path=vi2c.sock,id=vi2c \
+      -device vhost-user-i2c-pci,chardev=vi2c,id=i2c \
+      -m 4096 \
+      -object memory-backend-file,id=mem,size=4G,mem-path=/dev/shm,share=on \
+      -numa node,memdev=mem \
+      ...
-- 
2.25.0.rc1.19.g042ed3e048af

Hello,

This is an initial implementation of a generic vhost-user backend for
the I2C bus. This is based of the virtio specifications (already merged)
for the I2C bus.

The kernel virtio I2C driver is still under review, here is the latest
version (v10):

https://lore.kernel.org/lkml/226a8d5663b7bb6f5d06ede7701eedb18d1bafa1.1616493817.git.jie.deng@intel.com/

https://collaborate.linaro.org/display/STR/Stratos+Home

I mentioned this to explain the decision to write the daemon as a fairly
pure glib application that just depends on libvhost-user.

We are not sure where the vhost-user backend should get queued, qemu or
a separate repository. Similar questions were raised by an earlier
thread by Alex Bennée for his RPMB work:

https://lore.kernel.org/qemu-devel/20200925125147.26943-1-alex.bennee@linaro.org/

I2C Testing:
------------

echo ds1338 0x20 > /sys/bus/i2c/devices/i2c-0/new_device

[
  Note that this may end up binding the ds1338 device to its driver,
  which won't let our i2c daemon talk to the device. For that we need to
  manually unbind the device from the driver:

echo 0-0020 > /sys/bus/i2c/devices/0-0020/driver/unbind
]

After this is done, you will get /dev/rtc1. This is the device we wanted
to emulate, which will be accessed by the vhost-user-i2c backend daemon
via the /dev/i2c-0 file present in the guest VM.

At this point we need to start the backend daemon and give it a
socket-path to talk to from qemu (you can pass -v to it to get more
detailed messages):

vhost-user-i2c --socket-path=vi2c.sock --device-list 0:20

[ Here, 0:20 is the bus/device mapping, 0 for /dev/i2c-0 and 20 is
client address of ds1338 that we used while creating the device. ]

-chardev socket,path=vi2c.sock,id=vi2c \
  -device vhost-user-i2c-pci,chardev=vi2c,id=i2c

Once the second level guest boots up, we will see the i2c-virtio bus at
/sys/bus/i2c/devices/i2c-X/. From there we can now make it emulate the
ds1338 device again by doing:

echo ds1338 0x20 > /sys/bus/i2c/devices/i2c-0/new_device

[ This time we want ds1338's driver to be bound to the device, so it
should be enabled in the kernel as well. ]

hwclock -w -f /dev/rtc1 (in guest2) ->
  Reaches i2c-virtio.c (Linux bus driver in guest2) ->
    transfer over virtio ->
      Reaches the qemu's vhost-i2c device emulation (running over guest1) ->
        Reaches the backend daemon vhost-user-i2c started earlier (in guest1) ->
          ioctl(/dev/i2c-0, I2C_RDWR, ..); (in guest1) ->
            reaches qemu's hw/rtc/ds1338.c (running over host)

SMBUS Testing:
--------------

I wasn't required to have such a tedious setup for testing out with
SMBUS devices. I was able to emulate a SMBUS device on my x86 machine
using i2c-stub driver.

$ modprobe i2c-stub chip_addr=0x20
//Boot the arm64 guest now with i2c-virtio driver and then do:
$ echo al3320a 0x20 > /sys/class/i2c-adapter/i2c-0/new_device
$ cat /sys/bus/iio/devices/iio:device0/in_illuminance_raw

That's it.

I hope I was able to give a clear picture of my test setup here :)

Thanks.

V1->V2:
- Add a separate patch (not to be merged) to keep stuff temporarily
  taken from Linux kernel.

- Support SMBUS devices/busses in the backend daemon.

- Fix lots of checkpatch warnings/errors.

- Some other bug fixes, suggestions, etc.

Viresh Kumar (6):
  !Merge: Update virtio headers from kernel
  hw/virtio: add boilerplate for vhost-user-i2c device
  hw/virtio: add vhost-user-i2c-pci boilerplate
  tools/vhost-user-i2c: Add backend driver
  docs: add a man page for vhost-user-i2c
  MAINTAINERS: Add entry for virtio-i2c

MAINTAINERS                                 |   9 +
 docs/tools/index.rst                        |   1 +
 docs/tools/vhost-user-i2c.rst               |  75 ++
 hw/virtio/Kconfig                           |   5 +
 hw/virtio/meson.build                       |   2 +
 hw/virtio/vhost-user-i2c-pci.c              |  69 ++
 hw/virtio/vhost-user-i2c.c                  | 285 +++++++
 include/hw/virtio/vhost-user-i2c.h          |  37 +
 include/standard-headers/linux/virtio_i2c.h |  40 +
 include/standard-headers/linux/virtio_ids.h |   1 +
 tools/meson.build                           |   8 +
 tools/vhost-user-i2c/50-qemu-i2c.json.in    |   5 +
 tools/vhost-user-i2c/main.c                 | 809 ++++++++++++++++++++
 tools/vhost-user-i2c/meson.build            |  10 +
 14 files changed, 1356 insertions(+)
 create mode 100644 docs/tools/vhost-user-i2c.rst
 create mode 100644 hw/virtio/vhost-user-i2c-pci.c
 create mode 100644 hw/virtio/vhost-user-i2c.c
 create mode 100644 include/hw/virtio/vhost-user-i2c.h
 create mode 100644 include/standard-headers/linux/virtio_i2c.h
 create mode 100644 tools/vhost-user-i2c/50-qemu-i2c.json.in
 create mode 100644 tools/vhost-user-i2c/main.c
 create mode 100644 tools/vhost-user-i2c/meson.build

-- 
2.25.0.rc1.19.g042ed3e048af

DO NOT MERGE

Update Linux virtio headers with help of

./scripts/update-linux-headers.sh ~/lsrc/linux.git

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 include/standard-headers/linux/virtio_i2c.h | 40 +++++++++++++++++++++
 include/standard-headers/linux/virtio_ids.h |  1 +
 2 files changed, 41 insertions(+)
 create mode 100644 include/standard-headers/linux/virtio_i2c.h

diff --git a/include/standard-headers/linux/virtio_i2c.h b/include/standard-headers/linux/virtio_i2c.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/standard-headers/linux/virtio_i2c.h
@@ -XXX,XX +XXX,XX @@
+/* 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 _LINUX_VIRTIO_I2C_H
+#define _LINUX_VIRTIO_I2C_H
+
+#include "standard-headers/linux/types.h"
+
+/* 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_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 {
+	uint16_t addr;
+	uint16_t padding;
+	uint32_t flags;
+};
+
+/**
+ * struct virtio_i2c_in_hdr - the virtio I2C message IN header
+ * @status: the processing result from the backend
+ */
+struct virtio_i2c_in_hdr {
+	uint8_t status;
+};
+
+/* The final status written by the device */
+#define VIRTIO_I2C_MSG_OK	0
+#define VIRTIO_I2C_MSG_ERR	1
+
+#endif /* _LINUX_VIRTIO_I2C_H */
diff --git a/include/standard-headers/linux/virtio_ids.h b/include/standard-headers/linux/virtio_ids.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/linux/virtio_ids.h
+++ b/include/standard-headers/linux/virtio_ids.h
@@ -XXX,XX +XXX,XX @@
 #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_ADAPTER		34 /* virtio i2c adapter */
 
 #endif /* _LINUX_VIRTIO_IDS_H */
-- 
2.25.0.rc1.19.g042ed3e048af

This creates the QEMU side of the vhost-user-i2c device which connects
to the remote daemon. It is based of vhost-user-fs code.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 hw/virtio/Kconfig                  |   5 +
 hw/virtio/meson.build              |   1 +
 hw/virtio/vhost-user-i2c.c         | 285 +++++++++++++++++++++++++++++
 include/hw/virtio/vhost-user-i2c.h |  37 ++++
 4 files changed, 328 insertions(+)
 create mode 100644 hw/virtio/vhost-user-i2c.c
 create mode 100644 include/hw/virtio/vhost-user-i2c.h

diff --git a/hw/virtio/Kconfig b/hw/virtio/Kconfig
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/Kconfig
+++ b/hw/virtio/Kconfig
@@ -XXX,XX +XXX,XX @@ config VIRTIO_MEM
     depends on LINUX
     depends on VIRTIO_MEM_SUPPORTED
     select MEM_DEVICE
+
+config VHOST_USER_I2C
+    bool
+    default y
+    depends on VIRTIO && VHOST_USER
diff --git a/hw/virtio/meson.build b/hw/virtio/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/meson.build
+++ b/hw/virtio/meson.build
@@ -XXX,XX +XXX,XX @@ virtio_ss.add(when: 'CONFIG_VHOST_USER_VSOCK', if_true: files('vhost-user-vsock.
 virtio_ss.add(when: 'CONFIG_VIRTIO_RNG', if_true: files('virtio-rng.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_IOMMU', if_true: files('virtio-iommu.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_MEM', if_true: files('virtio-mem.c'))
+virtio_ss.add(when: 'CONFIG_VHOST_USER_I2C', if_true: files('vhost-user-i2c.c'))
 
 virtio_pci_ss = ss.source_set()
 virtio_pci_ss.add(when: 'CONFIG_VHOST_VSOCK', if_true: files('vhost-vsock-pci.c'))
diff --git a/hw/virtio/vhost-user-i2c.c b/hw/virtio/vhost-user-i2c.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/virtio/vhost-user-i2c.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Vhost-user i2c virtio device
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/error.h"
+#include "hw/qdev-properties.h"
+#include "hw/virtio/virtio-bus.h"
+#include "hw/virtio/vhost-user-i2c.h"
+#include "qemu/error-report.h"
+#include "standard-headers/linux/virtio_ids.h"
+
+static void vu_i2c_start(VirtIODevice *vdev)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
+    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
+    int ret;
+    int i;
+
+    if (!k->set_guest_notifiers) {
+        error_report("binding does not support guest notifiers");
+        return;
+    }
+
+    ret = vhost_dev_enable_notifiers(&i2c->vhost_dev, vdev);
+    if (ret < 0) {
+        error_report("Error enabling host notifiers: %d", -ret);
+        return;
+    }
+
+    ret = k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, true);
+    if (ret < 0) {
+        error_report("Error binding guest notifier: %d", -ret);
+        goto err_host_notifiers;
+    }
+
+    i2c->vhost_dev.acked_features = vdev->guest_features;
+    ret = vhost_dev_start(&i2c->vhost_dev, vdev);
+    if (ret < 0) {
+        error_report("Error starting vhost-user-i2c: %d", -ret);
+        goto err_guest_notifiers;
+    }
+
+    /*
+     * guest_notifier_mask/pending not used yet, so just unmask
+     * everything here. virtio-pci will do the right thing by
+     * enabling/disabling irqfd.
+     */
+    for (i = 0; i < i2c->vhost_dev.nvqs; i++) {
+        vhost_virtqueue_mask(&i2c->vhost_dev, vdev, i, false);
+    }
+
+    return;
+
+err_guest_notifiers:
+    k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, false);
+err_host_notifiers:
+    vhost_dev_disable_notifiers(&i2c->vhost_dev, vdev);
+}
+
+static void vu_i2c_stop(VirtIODevice *vdev)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
+    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
+    int ret;
+
+    if (!k->set_guest_notifiers) {
+        return;
+    }
+
+    vhost_dev_stop(&i2c->vhost_dev, vdev);
+
+    ret = k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, false);
+    if (ret < 0) {
+        error_report("vhost guest notifier cleanup failed: %d", ret);
+        return;
+    }
+
+    vhost_dev_disable_notifiers(&i2c->vhost_dev, vdev);
+}
+
+static void vu_i2c_set_status(VirtIODevice *vdev, uint8_t status)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+    bool should_start = status & VIRTIO_CONFIG_S_DRIVER_OK;
+
+    if (!vdev->vm_running) {
+        should_start = false;
+    }
+
+    if (i2c->vhost_dev.started == should_start) {
+        return;
+    }
+
+    if (should_start) {
+        vu_i2c_start(vdev);
+    } else {
+        vu_i2c_stop(vdev);
+    }
+}
+
+static uint64_t vu_i2c_get_features(VirtIODevice *vdev,
+                                    uint64_t requested_features, Error **errp)
+{
+    /* No feature bits used yet */
+    return requested_features;
+}
+
+static void vu_i2c_handle_output(VirtIODevice *vdev, VirtQueue *vq)
+{
+    /*
+     * Not normally called; it's the daemon that handles the queue;
+     * however virtio's cleanup path can call this.
+     */
+}
+
+static void vu_i2c_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    vhost_virtqueue_mask(&i2c->vhost_dev, vdev, idx, mask);
+}
+
+static bool vu_i2c_guest_notifier_pending(VirtIODevice *vdev, int idx)
+{
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    return vhost_virtqueue_pending(&i2c->vhost_dev, idx);
+}
+
+static void do_vhost_user_cleanup(VirtIODevice *vdev, VHostUserI2C *i2c)
+{
+    vhost_user_cleanup(&i2c->vhost_user);
+    virtio_delete_queue(i2c->req_vq);
+    virtio_cleanup(vdev);
+    g_free(i2c->vhost_dev.vqs);
+    i2c->vhost_dev.vqs = NULL;
+}
+
+static int vu_i2c_connect(DeviceState *dev)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    if (i2c->connected) {
+        return 0;
+    }
+    i2c->connected = true;
+
+    /* restore vhost state */
+    if (virtio_device_started(vdev, vdev->status)) {
+        vu_i2c_start(vdev);
+    }
+
+    return 0;
+}
+
+static void vu_i2c_disconnect(DeviceState *dev)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    if (!i2c->connected) {
+        return;
+    }
+    i2c->connected = false;
+
+    if (i2c->vhost_dev.started) {
+        vu_i2c_stop(vdev);
+    }
+}
+
+static void vu_i2c_event(void *opaque, QEMUChrEvent event)
+{
+    DeviceState *dev = opaque;
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
+
+    switch (event) {
+    case CHR_EVENT_OPENED:
+        if (vu_i2c_connect(dev) < 0) {
+            qemu_chr_fe_disconnect(&i2c->conf.chardev);
+            return;
+        }
+        break;
+    case CHR_EVENT_CLOSED:
+        vu_i2c_disconnect(dev);
+        break;
+    case CHR_EVENT_BREAK:
+    case CHR_EVENT_MUX_IN:
+    case CHR_EVENT_MUX_OUT:
+        /* Ignore */
+        break;
+    }
+}
+
+static void vu_i2c_device_realize(DeviceState *dev, Error **errp)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(dev);
+    int ret;
+
+    if (!i2c->conf.chardev.chr) {
+        error_setg(errp, "missing chardev");
+        return;
+    }
+
+    if (!vhost_user_init(&i2c->vhost_user, &i2c->conf.chardev, errp)) {
+        return;
+    }
+
+    virtio_init(vdev, "vhost-user-i2c", VIRTIO_ID_I2C_ADAPTER, 0);
+
+    i2c->req_vq = virtio_add_queue(vdev, 4, vu_i2c_handle_output);
+    i2c->vhost_dev.nvqs = 1;
+    i2c->vhost_dev.vqs = g_new0(struct vhost_virtqueue, i2c->vhost_dev.nvqs);
+    ret = vhost_dev_init(&i2c->vhost_dev, &i2c->vhost_user,
+                         VHOST_BACKEND_TYPE_USER, 0);
+    if (ret < 0) {
+        error_setg_errno(errp, -ret, "vhost_dev_init() failed");
+        do_vhost_user_cleanup(vdev, i2c);
+    }
+
+    qemu_chr_fe_set_handlers(&i2c->conf.chardev, NULL, NULL, vu_i2c_event, NULL,
+                             dev, NULL, true);
+}
+
+static void vu_i2c_device_unrealize(DeviceState *dev)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+    VHostUserI2C *i2c = VHOST_USER_I2C(dev);
+
+    /* This will stop vhost backend if appropriate. */
+    vu_i2c_set_status(vdev, 0);
+
+    vhost_dev_cleanup(&i2c->vhost_dev);
+
+    do_vhost_user_cleanup(vdev, i2c);
+}
+
+static const VMStateDescription vu_i2c_vmstate = {
+    .name = "vhost-user-i2c",
+    .unmigratable = 1,
+};
+
+static Property vu_i2c_properties[] = {
+    DEFINE_PROP_CHR("chardev", VHostUserI2C, conf.chardev),
+    DEFINE_PROP_END_OF_LIST(),
+};
+
+static void vu_i2c_class_init(ObjectClass *klass, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
+
+    device_class_set_props(dc, vu_i2c_properties);
+    dc->vmsd = &vu_i2c_vmstate;
+    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
+    vdc->realize = vu_i2c_device_realize;
+    vdc->unrealize = vu_i2c_device_unrealize;
+    vdc->get_features = vu_i2c_get_features;
+    vdc->set_status = vu_i2c_set_status;
+    vdc->guest_notifier_mask = vu_i2c_guest_notifier_mask;
+    vdc->guest_notifier_pending = vu_i2c_guest_notifier_pending;
+}
+
+static const TypeInfo vu_i2c_info = {
+    .name = TYPE_VHOST_USER_I2C,
+    .parent = TYPE_VIRTIO_DEVICE,
+    .instance_size = sizeof(VHostUserI2C),
+    .class_init = vu_i2c_class_init,
+};
+
+static void vu_i2c_register_types(void)
+{
+    type_register_static(&vu_i2c_info);
+}
+
+type_init(vu_i2c_register_types)
diff --git a/include/hw/virtio/vhost-user-i2c.h b/include/hw/virtio/vhost-user-i2c.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/hw/virtio/vhost-user-i2c.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Vhost-user i2c virtio device
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef _QEMU_VHOST_USER_I2C_H
+#define _QEMU_VHOST_USER_I2C_H
+
+#include "hw/virtio/virtio.h"
+#include "hw/virtio/vhost.h"
+#include "hw/virtio/vhost-user.h"
+#include "chardev/char-fe.h"
+
+#define TYPE_VHOST_USER_I2C "vhost-user-i2c-device"
+OBJECT_DECLARE_SIMPLE_TYPE(VHostUserI2C, VHOST_USER_I2C)
+
+typedef struct {
+    CharBackend chardev;
+} VHostUserI2CConf;
+
+struct VHostUserI2C {
+    /*< private >*/
+    VirtIODevice parent;
+    VHostUserI2CConf conf;
+    struct vhost_virtqueue *vhost_vq;
+    struct vhost_dev vhost_dev;
+    VhostUserState vhost_user;
+    VirtQueue *req_vq;
+    bool connected;
+
+    /*< public >*/
+};
+
+#endif /* _QEMU_VHOST_USER_I2C_H */
-- 
2.25.0.rc1.19.g042ed3e048af

This allows is to instantiate a vhost-user-i2c device as part of a PCI
bus. It is mostly boilerplate which looks pretty similar to the
vhost-user-fs-pci device.

Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 hw/virtio/meson.build          |  1 +
 hw/virtio/vhost-user-i2c-pci.c | 69 ++++++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 hw/virtio/vhost-user-i2c-pci.c

diff --git a/hw/virtio/meson.build b/hw/virtio/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/meson.build
+++ b/hw/virtio/meson.build
@@ -XXX,XX +XXX,XX @@ virtio_ss.add(when: 'CONFIG_VIRTIO_RNG', if_true: files('virtio-rng.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_IOMMU', if_true: files('virtio-iommu.c'))
 virtio_ss.add(when: 'CONFIG_VIRTIO_MEM', if_true: files('virtio-mem.c'))
 virtio_ss.add(when: 'CONFIG_VHOST_USER_I2C', if_true: files('vhost-user-i2c.c'))
+virtio_ss.add(when: ['CONFIG_VIRTIO_PCI', 'CONFIG_VHOST_USER_I2C'], if_true: files('vhost-user-i2c-pci.c'))
 
 virtio_pci_ss = ss.source_set()
 virtio_pci_ss.add(when: 'CONFIG_VHOST_VSOCK', if_true: files('vhost-vsock-pci.c'))
diff --git a/hw/virtio/vhost-user-i2c-pci.c b/hw/virtio/vhost-user-i2c-pci.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/virtio/vhost-user-i2c-pci.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Vhost-user i2c virtio device PCI glue
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "qemu/osdep.h"
+#include "hw/qdev-properties.h"
+#include "hw/virtio/vhost-user-i2c.h"
+#include "virtio-pci.h"
+
+struct VHostUserI2CPCI {
+    VirtIOPCIProxy parent_obj;
+    VHostUserI2C vdev;
+};
+
+typedef struct VHostUserI2CPCI VHostUserI2CPCI;
+
+#define TYPE_VHOST_USER_I2C_PCI "vhost-user-i2c-pci-base"
+
+DECLARE_INSTANCE_CHECKER(VHostUserI2CPCI, VHOST_USER_I2C_PCI,
+                         TYPE_VHOST_USER_I2C_PCI)
+
+static void vhost_user_i2c_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
+{
+    VHostUserI2CPCI *dev = VHOST_USER_I2C_PCI(vpci_dev);
+    DeviceState *vdev = DEVICE(&dev->vdev);
+
+    vpci_dev->nvectors = 1;
+    qdev_realize(vdev, BUS(&vpci_dev->bus), errp);
+}
+
+static void vhost_user_i2c_pci_class_init(ObjectClass *klass, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
+    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
+    k->realize = vhost_user_i2c_pci_realize;
+    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
+    pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+    pcidev_k->device_id = 0; /* Set by virtio-pci based on virtio id */
+    pcidev_k->revision = 0x00;
+    pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
+}
+
+static void vhost_user_i2c_pci_instance_init(Object *obj)
+{
+    VHostUserI2CPCI *dev = VHOST_USER_I2C_PCI(obj);
+
+    virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
+                                TYPE_VHOST_USER_I2C);
+}
+
+static const VirtioPCIDeviceTypeInfo vhost_user_i2c_pci_info = {
+    .base_name = TYPE_VHOST_USER_I2C_PCI,
+    .non_transitional_name = "vhost-user-i2c-pci",
+    .instance_size = sizeof(VHostUserI2CPCI),
+    .instance_init = vhost_user_i2c_pci_instance_init,
+    .class_init = vhost_user_i2c_pci_class_init,
+};
+
+static void vhost_user_i2c_pci_register(void)
+{
+    virtio_pci_types_register(&vhost_user_i2c_pci_info);
+}
+
+type_init(vhost_user_i2c_pci_register);
-- 
2.25.0.rc1.19.g042ed3e048af

This adds the vhost-user backend driver to support virtio based I2C and
SMBUS devices.

vhost-user-i2c --help

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 tools/meson.build                        |   8 +
 tools/vhost-user-i2c/50-qemu-i2c.json.in |   5 +
 tools/vhost-user-i2c/main.c              | 809 +++++++++++++++++++++++
 tools/vhost-user-i2c/meson.build         |  10 +
 4 files changed, 832 insertions(+)
 create mode 100644 tools/vhost-user-i2c/50-qemu-i2c.json.in
 create mode 100644 tools/vhost-user-i2c/main.c
 create mode 100644 tools/vhost-user-i2c/meson.build

diff --git a/tools/meson.build b/tools/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/tools/meson.build
+++ b/tools/meson.build
@@ -XXX,XX +XXX,XX @@ endif
 if have_virtiofsd
   subdir('virtiofsd')
 endif
+
+have_virtioi2c= (have_system and
+    have_tools and
+    'CONFIG_LINUX' in config_host)
+
+if have_virtioi2c
+  subdir('vhost-user-i2c')
+endif
diff --git a/tools/vhost-user-i2c/50-qemu-i2c.json.in b/tools/vhost-user-i2c/50-qemu-i2c.json.in
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tools/vhost-user-i2c/50-qemu-i2c.json.in
@@ -XXX,XX +XXX,XX @@
+{
+  "description": "QEMU vhost-user-i2c",
+  "type": "bridge",
+  "binary": "@libexecdir@/vhost-user-i2c"
+}
diff --git a/tools/vhost-user-i2c/main.c b/tools/vhost-user-i2c/main.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tools/vhost-user-i2c/main.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * VIRTIO I2C Emulation via vhost-user
+ *
+ * Copyright (c) 2021 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#define G_LOG_DOMAIN "vhost-user-i2c"
+#define G_LOG_USE_STRUCTURED 1
+
+#include <assert.h>
+#include <endian.h>
+#include <fcntl.h>
+#include <gio/gio.h>
+#include <gio/gunixsocketaddress.h>
+#include <glib.h>
+#include <glib-unix.h>
+#include <glib/gstdio.h>
+#include <inttypes.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "qemu/compiler.h"
+#include "qemu/cutils.h"
+#include "standard-headers/linux/virtio_i2c.h"
+#include "subprojects/libvhost-user/libvhost-user-glib.h"
+#include "subprojects/libvhost-user/libvhost-user.h"
+
+#define VHOST_USER_I2C_MAX_QUEUES       1
+
+/* vhost-user-i2c definitions */
+
+#define MAX_I2C_VDEV                    (1 << 7)
+#define MAX_I2C_ADAPTER                 16
+
+typedef struct {
+    int32_t fd;
+    int32_t bus;
+    bool smbus;
+    bool clients[MAX_I2C_VDEV];
+} VI2cAdapter;
+
+typedef struct {
+    VugDev dev;
+    GMainLoop *loop;
+    VI2cAdapter *adapter[MAX_I2C_ADAPTER];
+    uint16_t adapter_map[MAX_I2C_VDEV];
+    uint32_t adapter_num;
+} VuI2c;
+
+static gboolean print_cap, verbose;
+static gchar *socket_path, *device_list;
+static gint socket_fd = -1;
+
+static GOptionEntry options[] = {
+    { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &socket_path,
+      "Location of vhost-user Unix domain socket, incompatible with --fd",
+      "PATH" },
+    { "fd", 'f', 0, G_OPTION_ARG_INT, &socket_fd,
+      "Specify file-descriptor of the backend, don't use with --socket-path",
+      "FD" },
+    { "device-list", 'l', 0, G_OPTION_ARG_STRING, &device_list,
+      "List of i2c-dev bus and attached devices", "I2C Devices" },
+    { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &print_cap,
+      "Output to stdout the backend capabilities in JSON format and exit",
+      NULL},
+    { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
+      "Be more verbose in output", NULL},
+    { NULL }
+};
+
+
+/* I2c helpers */
+static void fmt_bytes(GString *s, uint8_t *bytes, int len)
+{
+    int32_t i;
+    for (i = 0; i < len; i++) {
+        if (i && i % 16 == 0) {
+            g_string_append_c(s, '\n');
+        }
+        g_string_append_printf(s, "%x ", bytes[i]);
+    }
+}
+
+static void vi2c_dump_msg(struct i2c_msg *msgs, size_t count)
+{
+    int32_t i;
+
+    for (i = 0; i < count; i++) {
+        g_autoptr(GString) s = g_string_new("\nI2c request: ");
+
+        g_string_append_printf(s, "addr: %x\n", msgs[i].addr);
+        g_string_append_printf(s, "transfer len: %x\n", msgs[i].len);
+
+        g_string_append_printf(s, "%s: ", msgs[i].flags & I2C_M_RD ?
+                               "Data read" : "Data Written");
+        fmt_bytes(s, (uint8_t *)msgs[i].buf, msgs[i].len);
+        g_string_append_printf(s, "\n");
+
+        g_debug("%s: %s", __func__, s->str);
+    }
+}
+
+static int vi2c_map_adapters(VuI2c *i2c)
+{
+    VI2cAdapter *adapter;
+    int32_t i, client_addr;
+
+    /*
+     * Flatten the map for client address and adapter to the array:
+     *
+     * adapter_map[MAX_I2C_VDEV]:
+     *
+     * Adapter        | adapter2 | none  | adapter1 | adapter3 | none| (val)
+     *                |----------|-------|----------|----------|-----|
+     * Slave Address  | addr 1   | none  | addr 2   | addr 3   | none| (idx)
+     *                |<-----------------------MAX_I2C_VDEV---------------->|
+     */
+    for (i = 0; i < i2c->adapter_num; i++) {
+        adapter = i2c->adapter[i];
+
+        for (client_addr = 0; client_addr < MAX_I2C_VDEV; client_addr++) {
+            if (adapter->clients[client_addr]) {
+                if (i2c->adapter_map[client_addr]) {
+                    g_printerr("client addr %x repeated, not supported!\n",
+                               client_addr);
+                    return -1;
+                }
+
+                /* The array is initialized to 0, + 1 for index */
+                i2c->adapter_map[client_addr] = i + 1;
+                if (verbose) {
+                    g_print("client: 0x%x -> i2c adapter: %d\n", client_addr,
+                            adapter->bus);
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+static VI2cAdapter *vi2c_find_adapter(VuI2c *i2c, uint16_t addr)
+{
+    if (addr < MAX_I2C_VDEV && (i2c->adapter_map[addr] != 0)) {
+        return i2c->adapter[i2c->adapter_map[addr] - 1];
+    }
+
+    return NULL;
+}
+
+static bool vi2c_set_client_addr(VI2cAdapter *adapter, uint16_t addr)
+{
+    if (ioctl(adapter->fd, I2C_SLAVE, addr) < 0) {
+        if (errno == EBUSY) {
+            g_printerr("client device %x is busy!\n", addr);
+        } else {
+            g_printerr("client device %d does not exist!\n", addr);
+        }
+        return false;
+    }
+    return true;
+}
+
+static void vi2c_remove_adapters(VuI2c *i2c)
+{
+    VI2cAdapter *adapter;
+    int32_t i;
+
+    for (i = 0; i < MAX_I2C_ADAPTER; i++) {
+        adapter = i2c->adapter[i];
+        if (!adapter) {
+            break;
+        }
+
+        if (adapter->fd > 0) {
+            close(adapter->fd);
+        }
+
+        g_free(adapter);
+        i2c->adapter[i] = NULL;
+    }
+}
+
+static VI2cAdapter *vi2c_create_adapter(int32_t bus, uint16_t client_addr[],
+                                        int32_t n_client)
+{
+    VI2cAdapter *adapter;
+    char path[20];
+    uint64_t funcs;
+    int32_t fd, i;
+
+    if (bus < 0) {
+        return NULL;
+    }
+
+    adapter = g_malloc0(sizeof(*adapter));
+    if (!adapter) {
+        g_printerr("failed to alloc adapter");
+        return NULL;
+    }
+
+    snprintf(path, sizeof(path), "/dev/i2c-%d", bus);
+    path[sizeof(path) - 1] = '\0';
+
+    fd = open(path, O_RDWR);
+    if (fd < 0) {
+        g_printerr("virtio_i2c: failed to open %s\n", path);
+        goto fail;
+    }
+
+    adapter->fd = fd;
+    adapter->bus = bus;
+
+    if (ioctl(fd, I2C_FUNCS, &funcs) < 0) {
+        g_printerr("virtio_i2c: failed to get functionality %s: %d\n", path,
+                   errno);
+        goto close_fd;
+    }
+
+    if (funcs & I2C_FUNC_I2C) {
+        adapter->smbus = false;
+    } else if (funcs & I2C_FUNC_SMBUS_WORD_DATA) {
+        adapter->smbus = true;
+    } else {
+        g_printerr("virtio_i2c: invalid functionality %lx\n", funcs);
+        goto close_fd;
+    }
+
+    for (i = 0; i < n_client; i++) {
+        if (client_addr[i]) {
+            if (!vi2c_set_client_addr(adapter, client_addr[i])) {
+                goto close_fd;
+            }
+
+            if (adapter->clients[client_addr[i]]) {
+                g_printerr("client addr 0x%x repeat, not allowed.\n",
+                           client_addr[i]);
+                goto close_fd;
+            }
+
+            adapter->clients[client_addr[i]] = true;
+            if (verbose) {
+                g_print("Added client 0x%x to bus %u\n", client_addr[i], bus);
+            }
+        }
+    }
+
+    if (verbose) {
+        g_print("Added adapter: bus: %d, func %s\n", bus,
+                adapter->smbus ? "smbus" : "i2c");
+    }
+    return adapter;
+
+close_fd:
+    close(fd);
+fail:
+    g_free(adapter);
+    return NULL;
+}
+
+/*
+ * Virtio I2C device list format.
+ *
+ * <bus>:<client_addr>[:<client_addr>],
+ * [<bus>:<client_addr>[:<client_addr>]]
+ *
+ * bus (dec): adatper bus number.
+ *     e.g. 2 for /dev/i2c-2
+ * client_addr (hex): address for client device
+ *     e.g. 0x1C or 1C
+ *
+ * Example: --device-list="2:0x1c:0x20,3:0x10:0x2c"
+ *
+ * Note: client address can not repeat.
+ */
+static int32_t vi2c_parse(VuI2c *i2c)
+{
+    uint16_t client_addr[MAX_I2C_VDEV];
+    int32_t n_adapter = 0, n_client;
+    int64_t addr, bus;
+    const char *cp, *t;
+
+    while (device_list) {
+        /* Read <bus>:<client_addr>[:<client_addr>] entries one by one */
+        cp = strsep(&device_list, ",");
+
+        if (!cp || *cp == '\0') {
+            break;
+        }
+
+        if (n_adapter == MAX_I2C_ADAPTER) {
+            g_printerr("too many adapter (%d), only support %d\n", n_adapter,
+                       MAX_I2C_ADAPTER);
+            goto out;
+        }
+
+        if (qemu_strtol(cp, &t, 10, &bus) || bus < 0) {
+            g_printerr("Invalid bus number %s\n", cp);
+            goto out;
+        }
+
+        cp = t;
+        n_client = 0;
+
+        /* Parse clients <client_addr>[:<client_addr>] entries one by one */
+        while (cp != NULL && *cp != '\0') {
+            if (*cp == ':') {
+                cp++;
+            }
+
+            if (n_client == MAX_I2C_VDEV) {
+                g_printerr("too many devices (%d), only support %d\n",
+                           n_client, MAX_I2C_VDEV);
+                goto out;
+            }
+
+            if (qemu_strtol(cp, &t, 16, &addr) ||
+                addr < 0 || addr > MAX_I2C_VDEV) {
+                g_printerr("Invalid address %s : %lx\n", cp, addr);
+                goto out;
+            }
+
+            client_addr[n_client++] = addr;
+            cp = t;
+            if (verbose) {
+                g_print("i2c adapter %ld:0x%lx\n", bus, addr);
+            }
+        }
+
+        i2c->adapter[n_adapter] = vi2c_create_adapter(bus, client_addr,
+                                                      n_client);
+        if (!i2c->adapter[n_adapter]) {
+            goto out;
+        }
+
+        n_adapter++;
+    }
+
+    if (!n_adapter) {
+        g_printerr("Failed to add any adapters\n");
+        return -1;
+    }
+
+    i2c->adapter_num = n_adapter;
+
+    if (!vi2c_map_adapters(i2c)) {
+        return 0;
+    }
+
+out:
+    vi2c_remove_adapters(i2c);
+    return -1;
+}
+
+static int32_t i2c_xfer(VI2cAdapter *adapter, struct i2c_msg *msgs,
+                        size_t count)
+{
+    struct i2c_rdwr_ioctl_data data;
+
+    data.nmsgs = count;
+    data.msgs = msgs;
+
+    return ioctl(adapter->fd, I2C_RDWR, &data);
+}
+
+/*
+ * Based on Linux's drivers/i2c/i2c-core-smbus.c:i2c_smbus_xfer_emulated(). This
+ * function tries to reverse what Linux does, only support basic modes (up to
+ * word transfer).
+ */
+static int32_t smbus_xfer(VI2cAdapter *adapter, struct i2c_msg *msgs,
+                          size_t count)
+{
+    union i2c_smbus_data data;
+    struct i2c_smbus_ioctl_data smbus_data = { .data = &data };
+    int32_t ret;
+
+    smbus_data.command = msgs[0].buf[0];
+
+    switch (count) {
+    case 1:
+        if (msgs[0].flags & I2C_M_RD) {
+            if (msgs[0].len > 1) {
+                g_printerr("Incorrect message length for read operation: %d\n",
+                           msgs[0].len);
+                return -1;
+            }
+            smbus_data.read_write = I2C_SMBUS_READ;
+        } else {
+            smbus_data.read_write = I2C_SMBUS_WRITE;
+        }
+
+        if (!msgs[0].len) {
+            smbus_data.size = I2C_SMBUS_QUICK;
+            smbus_data.data = NULL;
+        } else if (msgs[0].len == 1) {
+            smbus_data.size = I2C_SMBUS_BYTE;
+            if (smbus_data.read_write == I2C_SMBUS_WRITE) {
+                smbus_data.data = NULL;
+            }
+        } else if (msgs[0].len == 2) {
+            smbus_data.size = I2C_SMBUS_BYTE_DATA;
+            data.byte = msgs[0].buf[1];
+        } else if (msgs[0].len == 3) {
+            smbus_data.size = I2C_SMBUS_WORD_DATA;
+            data.word = msgs[0].buf[1] | (msgs[0].buf[2] << 8);
+        } else {
+            g_printerr("Message length not supported for write operation: %d\n",
+                       msgs[0].len);
+            return -1;
+        }
+
+        break;
+    case 2:
+        if ((msgs[0].flags & I2C_M_RD) || !(msgs[1].flags & I2C_M_RD) ||
+            (msgs[0].len != 1) || (msgs[1].len > 2)) {
+            g_printerr("Expecting a valid read smbus transfer: %ld: %d: %d\n",
+                       count, msgs[0].len, msgs[1].len);
+            return -1;
+        }
+
+        smbus_data.read_write = I2C_SMBUS_READ;
+        smbus_data.size = msgs[1].len == 1 ?
+                          I2C_SMBUS_BYTE_DATA : I2C_SMBUS_WORD_DATA;
+        break;
+    default:
+        g_printerr("Invalid number of messages for smbus xfer: %ld\n", count);
+        return -1;
+    }
+
+    if (verbose) {
+        g_print("SMBUS command: %x: %x: %x\n", smbus_data.read_write,
+                smbus_data.command, smbus_data.size);
+    }
+
+    ret = ioctl(adapter->fd, I2C_SMBUS, &smbus_data);
+    if (ret < 0) {
+        return ret;
+    }
+
+    if (smbus_data.read_write == I2C_SMBUS_WRITE) {
+        return 0;
+    }
+
+    switch (smbus_data.size) {
+    case I2C_SMBUS_BYTE:
+        msgs[0].buf[0] = data.byte;
+        break;
+    case I2C_SMBUS_BYTE_DATA:
+        msgs[1].buf[0] = data.byte;
+        break;
+    case I2C_SMBUS_WORD_DATA:
+        msgs[1].buf[0] = data.word & 0xff;
+        msgs[1].buf[1] = data.word >> 8;
+        break;
+    }
+
+    return 0;
+}
+
+static uint8_t vi2c_xfer(VuDev *dev, struct i2c_msg *msgs, size_t count)
+{
+    VuI2c *i2c = container_of(dev, VuI2c, dev.parent);
+    VI2cAdapter *adapter;
+    int8_t ret;
+
+    /* Assume that adapter should be same for all messages sent together */
+    adapter = vi2c_find_adapter(i2c, msgs[0].addr);
+    if (!adapter) {
+        g_printerr("Failed to find adapter for address: %x\n", msgs[0].addr);
+        return VIRTIO_I2C_MSG_ERR;
+    }
+
+    /* Set client's address */
+    if (!vi2c_set_client_addr(adapter, msgs[0].addr)) {
+        return VIRTIO_I2C_MSG_ERR;
+    }
+
+    if (adapter->smbus) {
+        ret = smbus_xfer(adapter, msgs, count);
+    } else {
+        ret = i2c_xfer(adapter, msgs, count);
+    }
+
+    if (ret < 0) {
+        g_printerr("Failed to transfer data to address %x : %d\n",
+                   msgs[0].addr, errno);
+        return VIRTIO_I2C_MSG_ERR;
+    }
+
+    if (verbose) {
+        vi2c_dump_msg(msgs, count);
+    }
+
+    return VIRTIO_I2C_MSG_OK;
+}
+
+/* Virtio helpers */
+static uint64_t vi2c_get_features(VuDev *dev)
+{
+    if (verbose) {
+        g_info("%s: replying", __func__);
+    }
+    return 0;
+}
+
+static void vi2c_set_features(VuDev *dev, uint64_t features)
+{
+    if (verbose && features) {
+        g_autoptr(GString) s = g_string_new("Requested un-handled feature");
+        g_string_append_printf(s, " 0x%" PRIx64 "", features);
+        g_info("%s: %s", __func__, s->str);
+    }
+}
+
+static void vi2c_handle_ctrl(VuDev *dev, int qidx)
+{
+    VuVirtq *vq = vu_get_queue(dev, qidx);
+    struct virtio_i2c_out_hdr *out_hdr;
+    size_t i, count = 0, len, in_hdr_len;
+    struct i2c_msg *msgs;
+    VuVirtqElement *elem;
+    uint8_t status;
+    struct {
+        struct virtio_i2c_in_hdr *in_hdr;
+        VuVirtqElement *elem;
+        size_t size;
+    } *info;
+
+    /* Count number of messages */
+    do {
+        elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
+    } while (elem && ++count);
+
+    if (!count) {
+        if (verbose) {
+            g_printerr("Virtqueue can't have 0 elements\n");
+        }
+        return;
+    }
+
+    /* Rewind everything, now that we have counted the number of messages */
+    vu_queue_rewind(dev, vq, count);
+
+    if (verbose) {
+        g_print("Received %ld messages in virtqueue\n", count);
+    }
+
+    /* Allocate memory for msgs and info */
+    msgs = g_malloc0_n(count, sizeof(*msgs) + sizeof(*info));
+    if (!msgs) {
+        g_printerr("failed to allocate space for messages\n");
+        return;
+    }
+    info = (void *)(msgs + count);
+
+    for (i = 0; i < count; i++) {
+        elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
+        if (!elem) {
+            g_printerr("Failed to pop element: %ld : %ld\n", i, count);
+            goto out;
+        }
+        info[i].elem = elem;
+        info[i].size = sizeof(*info[i].in_hdr);
+
+        g_debug("%s: got queue (in %d, out %d)", __func__, elem->in_num,
+                elem->out_num);
+
+        /* Validate size of "out" header */
+        if (elem->out_sg[0].iov_len != sizeof(*out_hdr)) {
+            g_warning("%s: Invalid out hdr %zu : %zu\n", __func__,
+                      elem->out_sg[0].iov_len, sizeof(*out_hdr));
+            goto out;
+        }
+
+        out_hdr = elem->out_sg[0].iov_base;
+
+        /* Bit 0 is reserved in virtio spec */
+        msgs[i].addr = le16toh(out_hdr->addr) >> 1;
+
+        /* Read Operation */
+        if (elem->out_num == 1 && elem->in_num == 2) {
+            len = elem->in_sg[0].iov_len;
+            if (!len) {
+                g_warning("%s: Read buffer length can't be zero\n", __func__);
+                goto out;
+            }
+
+            msgs[i].buf = elem->in_sg[0].iov_base;
+            msgs[i].flags = I2C_M_RD;
+            msgs[i].len = len;
+
+            info[i].in_hdr = elem->in_sg[1].iov_base;
+            info[i].size += len;
+            in_hdr_len = elem->in_sg[1].iov_len;
+        } else if (elem->out_num == 2 && elem->in_num == 1) {
+            /* Write Operation */
+            len = elem->out_sg[1].iov_len;
+            if (!len) {
+                g_warning("%s: Write buffer length can't be zero\n", __func__);
+                goto out;
+            }
+
+            msgs[i].buf = elem->out_sg[1].iov_base;
+            msgs[i].flags = 0;
+            msgs[i].len = len;
+
+            info[i].in_hdr = elem->in_sg[0].iov_base;
+            in_hdr_len = elem->in_sg[0].iov_len;
+        } else {
+            g_warning("%s: Transfer type not supported (in %d, out %d)\n",
+                      __func__, elem->in_num, elem->out_num);
+            goto out;
+        }
+
+        /* Validate size of "in" header */
+        if (in_hdr_len != sizeof(*(info[i].in_hdr))) {
+            g_warning("%s: Invalid in hdr %zu : %zu\n", __func__, in_hdr_len,
+                      sizeof(*(info[i].in_hdr)));
+            goto out;
+        }
+    }
+
+    status = vi2c_xfer(dev, msgs, count);
+
+    for (i = 0; i < count; i++) {
+        info[i].in_hdr->status = status;
+        vu_queue_push(dev, vq, info[i].elem, info[i].size);
+    }
+
+    vu_queue_notify(dev, vq);
+
+out:
+    g_free(msgs);
+}
+
+static void
+vi2c_queue_set_started(VuDev *dev, int qidx, bool started)
+{
+    VuVirtq *vq = vu_get_queue(dev, qidx);
+
+    g_debug("queue started %d:%d\n", qidx, started);
+
+    if (!qidx) {
+        vu_set_queue_handler(dev, vq, started ? vi2c_handle_ctrl : NULL);
+    }
+}
+
+/*
+ * vi2c_process_msg: process messages of vhost-user interface
+ *
+ * Any that are not handled here are processed by the libvhost library
+ * itself.
+ */
+static int vi2c_process_msg(VuDev *dev, VhostUserMsg *msg, int *do_reply)
+{
+    VuI2c *i2c = container_of(dev, VuI2c, dev.parent);
+
+    if (msg->request == VHOST_USER_NONE) {
+        g_main_loop_quit(i2c->loop);
+        return 1;
+    }
+
+    return 0;
+}
+
+static const VuDevIface vuiface = {
+    .set_features = vi2c_set_features,
+    .get_features = vi2c_get_features,
+    .queue_set_started = vi2c_queue_set_started,
+    .process_msg = vi2c_process_msg,
+};
+
+static gboolean hangup(gpointer user_data)
+{
+    GMainLoop *loop = (GMainLoop *) user_data;
+    g_info("%s: caught hangup/quit signal, quitting main loop", __func__);
+    g_main_loop_quit(loop);
+    return true;
+}
+
+static void vi2c_panic(VuDev *dev, const char *msg)
+{
+    g_critical("%s\n", msg);
+    exit(EXIT_FAILURE);
+}
+
+/* Print vhost-user.json backend program capabilities */
+static void print_capabilities(void)
+{
+    printf("{\n");
+    printf("  \"type\": \"i2c\"\n");
+    printf("  \"device-list\"\n");
+    printf("}\n");
+}
+
+static void vi2c_destroy(VuI2c *i2c)
+{
+    vi2c_remove_adapters(i2c);
+    vug_deinit(&i2c->dev);
+    if (socket_path) {
+        unlink(socket_path);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    GError *error = NULL;
+    GOptionContext *context;
+    g_autoptr(GSocket) socket = NULL;
+    VuI2c i2c = {0};
+
+    context = g_option_context_new("vhost-user emulation of I2C device");
+    g_option_context_add_main_entries(context, options, "vhost-user-i2c");
+    if (!g_option_context_parse(context, &argc, &argv, &error)) {
+        g_printerr("option parsing failed: %s\n", error->message);
+        exit(1);
+    }
+
+    if (print_cap) {
+        print_capabilities();
+        exit(0);
+    }
+
+    if (!socket_path && socket_fd < 0) {
+        g_printerr("Please specify either --fd or --socket-path\n");
+        exit(EXIT_FAILURE);
+    }
+
+    if (verbose) {
+        g_log_set_handler(NULL, G_LOG_LEVEL_MASK, g_log_default_handler, NULL);
+        g_setenv("G_MESSAGES_DEBUG", "all", true);
+    } else {
+        g_log_set_handler(NULL, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL |
+                          G_LOG_LEVEL_ERROR, g_log_default_handler, NULL);
+    }
+
+    /*
+     * Now create a vhost-user socket that we will receive messages
+     * on. Once we have our handler set up we can enter the glib main
+     * loop.
+     */
+    if (socket_path) {
+        g_autoptr(GSocketAddress) addr = g_unix_socket_address_new(socket_path);
+        g_autoptr(GSocket) bind_socket = g_socket_new(G_SOCKET_FAMILY_UNIX,
+                    G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, &error);
+
+        if (!g_socket_bind(bind_socket, addr, false, &error)) {
+            g_printerr("Failed to bind to socket at %s (%s).\n",
+                       socket_path, error->message);
+            exit(EXIT_FAILURE);
+        }
+        if (!g_socket_listen(bind_socket, &error)) {
+            g_printerr("Failed to listen on socket %s (%s).\n",
+                       socket_path, error->message);
+        }
+        g_message("awaiting connection to %s", socket_path);
+        socket = g_socket_accept(bind_socket, NULL, &error);
+        if (!socket) {
+            g_printerr("Failed to accept on socket %s (%s).\n",
+                       socket_path, error->message);
+        }
+    } else {
+        socket = g_socket_new_from_fd(socket_fd, &error);
+        if (!socket) {
+            g_printerr("Failed to connect to FD %d (%s).\n",
+                       socket_fd, error->message);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    if (vi2c_parse(&i2c)) {
+        exit(EXIT_FAILURE);
+    }
+
+    /*
+     * Create the main loop first so all the various sources can be
+     * added. As well as catching signals we need to ensure vug_init
+     * can add it's GSource watches.
+     */
+
+    i2c.loop = g_main_loop_new(NULL, FALSE);
+    /* catch exit signals */
+    g_unix_signal_add(SIGHUP, hangup, i2c.loop);
+    g_unix_signal_add(SIGINT, hangup, i2c.loop);
+
+    if (!vug_init(&i2c.dev, VHOST_USER_I2C_MAX_QUEUES, g_socket_get_fd(socket),
+                  vi2c_panic, &vuiface)) {
+        g_printerr("Failed to initialize libvhost-user-glib.\n");
+        exit(EXIT_FAILURE);
+    }
+
+
+    g_message("entering main loop, awaiting messages");
+    g_main_loop_run(i2c.loop);
+    g_message("finished main loop, cleaning up");
+
+    g_main_loop_unref(i2c.loop);
+    vi2c_destroy(&i2c);
+}
diff --git a/tools/vhost-user-i2c/meson.build b/tools/vhost-user-i2c/meson.build
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tools/vhost-user-i2c/meson.build
@@ -XXX,XX +XXX,XX @@
+executable('vhost-user-i2c', files(
+  'main.c'),
+  dependencies: [qemuutil, glib, gio],
+  install: true,
+  install_dir: get_option('libexecdir'))
+
+configure_file(input: '50-qemu-i2c.json.in',
+               output: '50-qemu-i2c.json',
+               configuration: config_host,
+               install_dir: qemu_datadir / 'vhost-user')
-- 
2.25.0.rc1.19.g042ed3e048af

Basic usage and example invocation.

diff --git a/docs/tools/index.rst b/docs/tools/index.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/tools/index.rst
+++ b/docs/tools/index.rst
@@ -XXX,XX +XXX,XX @@ QEMU Tools Guide
    qemu-trace-stap
    virtfs-proxy-helper
    virtiofsd
+   vhost-user-i2c
diff --git a/docs/tools/vhost-user-i2c.rst b/docs/tools/vhost-user-i2c.rst
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/docs/tools/vhost-user-i2c.rst
@@ -XXX,XX +XXX,XX @@
+QEMU vhost-user-i2c - I2C emulation backend
+===========================================
+
+Synopsis
+--------
+
+**vhost-user-i2c** [*OPTIONS*]
+
+Description
+-----------
+
+This program is a vhost-user backend that emulates a VirtIO I2C bus.
+This program takes the layout of the i2c bus and its devices on the host
+OS and then talks to them via the /dev/i2c-X interface when a request
+comes from the guest OS for an I2C or SMBUS device.
+
+This program is designed to work with QEMU's ``-device
+vhost-user-i2c-pci`` but should work with any virtual machine monitor
+(VMM) that supports vhost-user. See the Examples section below.
+
+Options
+-------
+
+.. program:: vhost-user-i2c
+
+.. option:: -h, --help
+
+  Print help.
+
+.. option:: -v, --verbose
+
+   Increase verbosity of output
+
+.. option:: -s, --socket-path=PATH
+
+  Listen on vhost-user UNIX domain socket at PATH. Incompatible with --fd.
+
+.. option:: -f, --fd=FDNUM
+
+  Accept connections from vhost-user UNIX domain socket file descriptor FDNUM.
+  The file descriptor must already be listening for connections.
+  Incompatible with --socket-path.
+
+.. option:: -l, --device-list=I2C-DEVICES
+
+  I2c device list at the host OS in the format:
+      <bus>:<client_addr>[:<client_addr>],[<bus>:<client_addr>[:<client_addr>]]
+
+      Example: --device-list "2:1c:20,3:10:2c"
+
+  Here,
+      bus (decimal): adatper bus number. e.g. 2 for /dev/i2c-2, 3 for /dev/i2c-3.
+      client_addr (hex): address for client device. e.g. 0x1C, 0x20, 0x10, 0x2C.
+
+Examples
+--------
+
+The daemon should be started first:
+
+::
+
+  host# vhost-user-i2c --socket-path=vi2c.sock --device-list 0:20
+
+The QEMU invocation needs to create a chardev socket the device can
+use to communicate as well as share the guests memory over a memfd.
+
+::
+
+  host# qemu-system \
+      -chardev socket,path=vi2c.sock,id=vi2c \
+      -device vhost-user-i2c-pci,chardev=vi2c,id=i2c \
+      -m 4096 \
+      -object memory-backend-file,id=mem,size=4G,mem-path=/dev/shm,share=on \
+      -numa node,memdev=mem \
+      ...
-- 
2.25.0.rc1.19.g042ed3e048af