i2c: Add Intel USBIO I2C driver (daf16134) · Commits · git / linux-net

MAINTAINERS

+1 −0

Original line number	Diff line number	Diff line
		@@ -12694,6 +12694,7 @@ M: Hans de Goede <hansg@kernel.org>
		R: Sakari Ailus <sakari.ailus@linux.intel.com>
		S: Maintained
		F: drivers/gpio/gpio-usbio.c
		F: drivers/i2c/busses/i2c-usbio.c
		F: drivers/usb/misc/usbio.c
		F: include/linux/usb/usbio.h

drivers/i2c/busses/Kconfig

+11 −0

Original line number	Diff line number	Diff line
		@@ -1357,6 +1357,17 @@ config I2C_LJCA
		This driver can also be built as a module. If so, the module
		will be called i2c-ljca.

		config I2C_USBIO
		tristate "Intel USBIO I2C Adapter support"
		depends on USB_USBIO
		default USB_USBIO
		help
		Select this option to enable I2C driver for the INTEL
		USBIO driver stack.

		This driver can also be built as a module. If so, the module
		will be called i2c_usbio.

		config I2C_CP2615
		tristate "Silicon Labs CP2615 USB sound card and I2C adapter"
		depends on USB

drivers/i2c/busses/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -135,6 +135,7 @@ obj-$(CONFIG_I2C_GXP) += i2c-gxp.o
		obj-$(CONFIG_I2C_DIOLAN_U2C) += i2c-diolan-u2c.o
		obj-$(CONFIG_I2C_DLN2) += i2c-dln2.o
		obj-$(CONFIG_I2C_LJCA) += i2c-ljca.o
		obj-$(CONFIG_I2C_USBIO) += i2c-usbio.o
		obj-$(CONFIG_I2C_CP2615) += i2c-cp2615.o
		obj-$(CONFIG_I2C_PARPORT) += i2c-parport.o
		obj-$(CONFIG_I2C_PCI1XXXX) += i2c-mchp-pci1xxxx.o

drivers/i2c/busses/i2c-usbio.c

0 → 100644

+320 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Copyright (c) 2025 Intel Corporation.
		* Copyright (c) 2025 Red Hat, Inc.
		*/

		#include <linux/auxiliary_bus.h>
		#include <linux/dev_printk.h>
		#include <linux/device.h>
		#include <linux/i2c.h>
		#include <linux/types.h>
		#include <linux/usb/usbio.h>

		#define I2C_RW_OVERHEAD (sizeof(struct usbio_bulk_packet) + sizeof(struct usbio_i2c_rw))

		struct usbio_i2c {
		struct i2c_adapter adap;
		struct auxiliary_device *adev;
		struct usbio_i2c_rw *rwbuf;
		unsigned long quirks;
		u32 speed;
		u16 txbuf_len;
		u16 rxbuf_len;
		};

		static const struct acpi_device_id usbio_i2c_acpi_hids[] = {
		{ "INTC1008" }, /* MTL */
		{ "INTC10B3" }, /* ARL */
		{ "INTC10B6" }, /* LNL */
		{ "INTC10E3" }, /* PTL */
		{ }
		};

		static const u32 usbio_i2c_speeds[] = {
		I2C_MAX_STANDARD_MODE_FREQ,
		I2C_MAX_FAST_MODE_FREQ,
		I2C_MAX_FAST_MODE_PLUS_FREQ,
		I2C_MAX_HIGH_SPEED_MODE_FREQ
		};

		static void usbio_i2c_uninit(struct i2c_adapter adap, struct i2c_msg msg)
		{
		struct usbio_i2c *i2c = i2c_get_adapdata(adap);
		struct usbio_i2c_uninit ubuf;

		ubuf.busid = i2c->adev->id;
		ubuf.config = cpu_to_le16(msg->addr);

		usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_UNINIT, true,
		&ubuf, sizeof(ubuf), NULL, 0);
		}

		static int usbio_i2c_init(struct i2c_adapter adap, struct i2c_msg msg)
		{
		struct usbio_i2c *i2c = i2c_get_adapdata(adap);
		struct usbio_i2c_init ibuf;
		void *reply_buf;
		u16 reply_len;
		int ret;

		ibuf.busid = i2c->adev->id;
		ibuf.config = cpu_to_le16(msg->addr);
		ibuf.speed = cpu_to_le32(i2c->speed);

		if (i2c->quirks & USBIO_QUIRK_I2C_NO_INIT_ACK) {
		reply_buf = NULL;
		reply_len = 0;
		} else {
		reply_buf = &ibuf;
		reply_len = sizeof(ibuf);
		}

		ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_INIT, true,
		&ibuf, sizeof(ibuf), reply_buf, reply_len);
		if (ret != sizeof(ibuf))
		return (ret < 0) ? ret : -EIO;

		return 0;
		}

		static int usbio_i2c_read(struct i2c_adapter adap, struct i2c_msg msg)
		{
		struct usbio_i2c *i2c = i2c_get_adapdata(adap);
		u16 rxchunk = i2c->rxbuf_len - I2C_RW_OVERHEAD;
		struct usbio_i2c_rw *rbuf = i2c->rwbuf;
		int ret;

		rbuf->busid = i2c->adev->id;
		rbuf->config = cpu_to_le16(msg->addr);
		rbuf->size = cpu_to_le16(msg->len);

		if (msg->len > rxchunk) {
		/* Need to split the input buffer */
		u16 len = 0;

		do {
		if (msg->len - len < rxchunk)
		rxchunk = msg->len - len;

		ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C,
		USBIO_I2CCMD_READ, true,
		rbuf, len == 0 ? sizeof(*rbuf) : 0,
		rbuf, sizeof(*rbuf) + rxchunk);
		if (ret < 0)
		return ret;

		memcpy(&msg->buf[len], rbuf->data, rxchunk);
		len += rxchunk;
		} while (msg->len > len);

		return 0;
		}

		ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_READ, true,
		rbuf, sizeof(rbuf), rbuf, sizeof(rbuf) + msg->len);
		if (ret != sizeof(*rbuf) + msg->len)
		return (ret < 0) ? ret : -EIO;

		memcpy(msg->buf, rbuf->data, msg->len);

		return 0;
		}

		static int usbio_i2c_write(struct i2c_adapter adap, struct i2c_msg msg)
		{
		struct usbio_i2c *i2c = i2c_get_adapdata(adap);
		u16 txchunk = i2c->txbuf_len - I2C_RW_OVERHEAD;
		struct usbio_i2c_rw *wbuf = i2c->rwbuf;
		int ret;

		if (msg->len > txchunk) {
		/* Need to split the output buffer */
		u16 len = 0;

		do {
		wbuf->busid = i2c->adev->id;
		wbuf->config = cpu_to_le16(msg->addr);

		if (i2c->quirks & USBIO_QUIRK_I2C_USE_CHUNK_LEN)
		wbuf->size = cpu_to_le16(txchunk);
		else
		wbuf->size = cpu_to_le16(msg->len);

		memcpy(wbuf->data, &msg->buf[len], txchunk);
		len += txchunk;

		ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C,
		USBIO_I2CCMD_WRITE, msg->len == len,
		wbuf, sizeof(*wbuf) + txchunk,
		wbuf, sizeof(*wbuf));
		if (ret < 0)
		return ret;

		if (msg->len - len < txchunk)
		txchunk = msg->len - len;
		} while (msg->len > len);

		return 0;
		}

		wbuf->busid = i2c->adev->id;
		wbuf->config = cpu_to_le16(msg->addr);
		wbuf->size = cpu_to_le16(msg->len);
		memcpy(wbuf->data, msg->buf, msg->len);

		ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_WRITE, true,
		wbuf, sizeof(wbuf) + msg->len, wbuf, sizeof(wbuf));
		if (ret != sizeof(*wbuf) \|\| le16_to_cpu(wbuf->size) != msg->len)
		return (ret < 0) ? ret : -EIO;

		return 0;
		}

		static int usbio_i2c_xfer(struct i2c_adapter adap, struct i2c_msg msgs, int num)
		{
		struct usbio_i2c *i2c = i2c_get_adapdata(adap);
		int ret;

		usbio_acquire(i2c->adev);

		ret = usbio_i2c_init(adap, msgs);
		if (ret)
		goto out_release;

		for (int i = 0; i < num; ret = ++i) {
		if (msgs[i].flags & I2C_M_RD)
		ret = usbio_i2c_read(adap, &msgs[i]);
		else
		ret = usbio_i2c_write(adap, &msgs[i]);

		if (ret)
		break;
		}

		usbio_i2c_uninit(adap, msgs);

		out_release:
		usbio_release(i2c->adev);

		return ret;
		}

		static u32 usbio_i2c_func(struct i2c_adapter *adap)
		{
		return I2C_FUNC_I2C \| I2C_FUNC_SMBUS_EMUL;
		}

		static const struct i2c_adapter_quirks usbio_i2c_quirks = {
		.flags = I2C_AQ_NO_ZERO_LEN \| I2C_AQ_NO_REP_START,
		.max_read_len = SZ_4K,
		.max_write_len = SZ_4K,
		};

		static const struct i2c_adapter_quirks usbio_i2c_quirks_max_rw_len52 = {
		.flags = I2C_AQ_NO_ZERO_LEN \| I2C_AQ_NO_REP_START,
		.max_read_len = 52,
		.max_write_len = 52,
		};

		static const struct i2c_algorithm usbio_i2c_algo = {
		.master_xfer = usbio_i2c_xfer,
		.functionality = usbio_i2c_func,
		};

		static int usbio_i2c_probe(struct auxiliary_device *adev,
		const struct auxiliary_device_id *adev_id)
		{
		struct usbio_i2c_bus_desc *i2c_desc;
		struct device *dev = &adev->dev;
		struct usbio_i2c *i2c;
		u32 max_speed;
		int ret;

		i2c_desc = dev_get_platdata(dev);
		if (!i2c_desc)
		return -EINVAL;

		i2c = devm_kzalloc(dev, sizeof(*i2c), GFP_KERNEL);
		if (!i2c)
		return -ENOMEM;

		i2c->adev = adev;

		usbio_acpi_bind(i2c->adev, usbio_i2c_acpi_hids);
		usbio_get_txrxbuf_len(i2c->adev, &i2c->txbuf_len, &i2c->rxbuf_len);

		i2c->rwbuf = devm_kzalloc(dev, max(i2c->txbuf_len, i2c->rxbuf_len), GFP_KERNEL);
		if (!i2c->rwbuf)
		return -ENOMEM;

		i2c->quirks = usbio_get_quirks(i2c->adev);

		max_speed = usbio_i2c_speeds[i2c_desc->caps & USBIO_I2C_BUS_MODE_CAP_MASK];
		if (max_speed < I2C_MAX_FAST_MODE_FREQ &&
		(i2c->quirks & USBIO_QUIRK_I2C_ALLOW_400KHZ))
		max_speed = I2C_MAX_FAST_MODE_FREQ;

		i2c->speed = i2c_acpi_find_bus_speed(dev);
		if (!i2c->speed)
		i2c->speed = I2C_MAX_STANDARD_MODE_FREQ;
		else if (i2c->speed > max_speed) {
		dev_warn(dev, "Invalid speed %u adjusting to bus max %u\n",
		i2c->speed, max_speed);
		i2c->speed = max_speed;
		}

		i2c->adap.owner = THIS_MODULE;
		i2c->adap.class = I2C_CLASS_HWMON;
		i2c->adap.dev.parent = dev;
		i2c->adap.algo = &usbio_i2c_algo;

		if (i2c->quirks & USBIO_QUIRK_I2C_MAX_RW_LEN_52)
		i2c->adap.quirks = &usbio_i2c_quirks_max_rw_len52;
		else
		i2c->adap.quirks = &usbio_i2c_quirks;

		snprintf(i2c->adap.name, sizeof(i2c->adap.name), "%s.%d",
		USBIO_I2C_CLIENT, i2c->adev->id);

		device_set_node(&i2c->adap.dev, dev_fwnode(&adev->dev));

		auxiliary_set_drvdata(adev, i2c);
		i2c_set_adapdata(&i2c->adap, i2c);

		ret = i2c_add_adapter(&i2c->adap);
		if (ret)
		return ret;

		if (has_acpi_companion(&i2c->adap.dev))
		acpi_dev_clear_dependencies(ACPI_COMPANION(&i2c->adap.dev));

		return 0;
		}

		static void usbio_i2c_remove(struct auxiliary_device *adev)
		{
		struct usbio_i2c *i2c = auxiliary_get_drvdata(adev);

		i2c_del_adapter(&i2c->adap);
		}

		static const struct auxiliary_device_id usbio_i2c_id_table[] = {
		{ "usbio.usbio-i2c" },
		{ }
		};
		MODULE_DEVICE_TABLE(auxiliary, usbio_i2c_id_table);

		static struct auxiliary_driver usbio_i2c_driver = {
		.name = USBIO_I2C_CLIENT,
		.probe = usbio_i2c_probe,
		.remove = usbio_i2c_remove,
		.id_table = usbio_i2c_id_table
		};
		module_auxiliary_driver(usbio_i2c_driver);

		MODULE_DESCRIPTION("Intel USBIO I2C driver");
		MODULE_AUTHOR("Israel Cepeda <israel.a.cepeda.lopez@intel.com>");
		MODULE_AUTHOR("Hans de Goede <hansg@kernel.org>");
		MODULE_LICENSE("GPL");
		MODULE_IMPORT_NS("USBIO");