1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2025 Intel Corporation. 4 * Copyright (c) 2025 Red Hat, Inc. 5 */ 6 7 #include <linux/auxiliary_bus.h> 8 #include <linux/dev_printk.h> 9 #include <linux/device.h> 10 #include <linux/i2c.h> 11 #include <linux/types.h> 12 #include <linux/usb/usbio.h> 13 14 #define I2C_RW_OVERHEAD (sizeof(struct usbio_bulk_packet) + sizeof(struct usbio_i2c_rw)) 15 16 struct usbio_i2c { 17 struct i2c_adapter adap; 18 struct auxiliary_device *adev; 19 struct usbio_i2c_rw *rwbuf; 20 unsigned long quirks; 21 u32 speed; 22 u16 txbuf_len; 23 u16 rxbuf_len; 24 }; 25 26 static const struct acpi_device_id usbio_i2c_acpi_hids[] = { 27 { "INTC1008" }, /* MTL */ 28 { "INTC10B3" }, /* ARL */ 29 { "INTC10B6" }, /* LNL */ 30 { "INTC10D2" }, /* MTL-CVF */ 31 { "INTC10E3" }, /* PTL */ 32 { "INTC1118" }, /* NVL */ 33 { } 34 }; 35 36 static const u32 usbio_i2c_speeds[] = { 37 I2C_MAX_STANDARD_MODE_FREQ, 38 I2C_MAX_FAST_MODE_FREQ, 39 I2C_MAX_FAST_MODE_PLUS_FREQ, 40 I2C_MAX_HIGH_SPEED_MODE_FREQ 41 }; 42 43 static void usbio_i2c_uninit(struct i2c_adapter *adap, struct i2c_msg *msg) 44 { 45 struct usbio_i2c *i2c = i2c_get_adapdata(adap); 46 struct usbio_i2c_uninit ubuf; 47 48 ubuf.busid = i2c->adev->id; 49 ubuf.config = cpu_to_le16(msg->addr); 50 51 usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_UNINIT, true, 52 &ubuf, sizeof(ubuf), NULL, 0); 53 } 54 55 static int usbio_i2c_init(struct i2c_adapter *adap, struct i2c_msg *msg) 56 { 57 struct usbio_i2c *i2c = i2c_get_adapdata(adap); 58 struct usbio_i2c_init ibuf; 59 void *reply_buf; 60 u16 reply_len; 61 int ret; 62 63 ibuf.busid = i2c->adev->id; 64 ibuf.config = cpu_to_le16(msg->addr); 65 ibuf.speed = cpu_to_le32(i2c->speed); 66 67 if (i2c->quirks & USBIO_QUIRK_I2C_NO_INIT_ACK) { 68 reply_buf = NULL; 69 reply_len = 0; 70 } else { 71 reply_buf = &ibuf; 72 reply_len = sizeof(ibuf); 73 } 74 75 ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_INIT, true, 76 &ibuf, sizeof(ibuf), reply_buf, reply_len); 77 if (ret != sizeof(ibuf)) 78 return (ret < 0) ? ret : -EIO; 79 80 return 0; 81 } 82 83 static int usbio_i2c_read(struct i2c_adapter *adap, struct i2c_msg *msg) 84 { 85 struct usbio_i2c *i2c = i2c_get_adapdata(adap); 86 u16 rxchunk = i2c->rxbuf_len - I2C_RW_OVERHEAD; 87 struct usbio_i2c_rw *rbuf = i2c->rwbuf; 88 int ret; 89 90 rbuf->busid = i2c->adev->id; 91 rbuf->config = cpu_to_le16(msg->addr); 92 rbuf->size = cpu_to_le16(msg->len); 93 94 if (msg->len > rxchunk) { 95 /* Need to split the input buffer */ 96 u16 len = 0; 97 98 do { 99 if (msg->len - len < rxchunk) 100 rxchunk = msg->len - len; 101 102 ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, 103 USBIO_I2CCMD_READ, true, 104 rbuf, len == 0 ? sizeof(*rbuf) : 0, 105 rbuf, sizeof(*rbuf) + rxchunk); 106 if (ret < 0) 107 return ret; 108 109 memcpy(&msg->buf[len], rbuf->data, rxchunk); 110 len += rxchunk; 111 } while (msg->len > len); 112 113 return 0; 114 } 115 116 ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_READ, true, 117 rbuf, sizeof(*rbuf), rbuf, sizeof(*rbuf) + msg->len); 118 if (ret != sizeof(*rbuf) + msg->len) 119 return (ret < 0) ? ret : -EIO; 120 121 memcpy(msg->buf, rbuf->data, msg->len); 122 123 return 0; 124 } 125 126 static int usbio_i2c_write(struct i2c_adapter *adap, struct i2c_msg *msg) 127 { 128 struct usbio_i2c *i2c = i2c_get_adapdata(adap); 129 u16 txchunk = i2c->txbuf_len - I2C_RW_OVERHEAD; 130 struct usbio_i2c_rw *wbuf = i2c->rwbuf; 131 int ret; 132 133 if (msg->len > txchunk) { 134 /* Need to split the output buffer */ 135 u16 len = 0; 136 137 do { 138 wbuf->busid = i2c->adev->id; 139 wbuf->config = cpu_to_le16(msg->addr); 140 141 if (i2c->quirks & USBIO_QUIRK_I2C_USE_CHUNK_LEN) 142 wbuf->size = cpu_to_le16(txchunk); 143 else 144 wbuf->size = cpu_to_le16(msg->len); 145 146 memcpy(wbuf->data, &msg->buf[len], txchunk); 147 len += txchunk; 148 149 ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, 150 USBIO_I2CCMD_WRITE, msg->len == len, 151 wbuf, sizeof(*wbuf) + txchunk, 152 wbuf, sizeof(*wbuf)); 153 if (ret < 0) 154 return ret; 155 156 if (msg->len - len < txchunk) 157 txchunk = msg->len - len; 158 } while (msg->len > len); 159 160 return 0; 161 } 162 163 wbuf->busid = i2c->adev->id; 164 wbuf->config = cpu_to_le16(msg->addr); 165 wbuf->size = cpu_to_le16(msg->len); 166 memcpy(wbuf->data, msg->buf, msg->len); 167 168 ret = usbio_bulk_msg(i2c->adev, USBIO_PKTTYPE_I2C, USBIO_I2CCMD_WRITE, true, 169 wbuf, sizeof(*wbuf) + msg->len, wbuf, sizeof(*wbuf)); 170 if (ret != sizeof(*wbuf) || le16_to_cpu(wbuf->size) != msg->len) 171 return (ret < 0) ? ret : -EIO; 172 173 return 0; 174 } 175 176 static int usbio_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) 177 { 178 struct usbio_i2c *i2c = i2c_get_adapdata(adap); 179 int ret; 180 181 usbio_acquire(i2c->adev); 182 183 ret = usbio_i2c_init(adap, msgs); 184 if (ret) 185 goto out_release; 186 187 for (int i = 0; i < num; ret = ++i) { 188 if (msgs[i].flags & I2C_M_RD) 189 ret = usbio_i2c_read(adap, &msgs[i]); 190 else 191 ret = usbio_i2c_write(adap, &msgs[i]); 192 193 if (ret) 194 break; 195 } 196 197 usbio_i2c_uninit(adap, msgs); 198 199 out_release: 200 usbio_release(i2c->adev); 201 202 return ret; 203 } 204 205 static u32 usbio_i2c_func(struct i2c_adapter *adap) 206 { 207 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 208 } 209 210 static const struct i2c_adapter_quirks usbio_i2c_quirks = { 211 .flags = I2C_AQ_NO_ZERO_LEN | I2C_AQ_NO_REP_START, 212 .max_read_len = SZ_4K, 213 .max_write_len = SZ_4K, 214 }; 215 216 static const struct i2c_adapter_quirks usbio_i2c_quirks_max_rw_len52 = { 217 .flags = I2C_AQ_NO_ZERO_LEN | I2C_AQ_NO_REP_START, 218 .max_read_len = 52, 219 .max_write_len = 52, 220 }; 221 222 static const struct i2c_algorithm usbio_i2c_algo = { 223 .master_xfer = usbio_i2c_xfer, 224 .functionality = usbio_i2c_func, 225 }; 226 227 static int usbio_i2c_probe(struct auxiliary_device *adev, 228 const struct auxiliary_device_id *adev_id) 229 { 230 struct usbio_i2c_bus_desc *i2c_desc; 231 struct device *dev = &adev->dev; 232 struct usbio_i2c *i2c; 233 u32 max_speed; 234 int ret; 235 236 i2c_desc = dev_get_platdata(dev); 237 if (!i2c_desc) 238 return -EINVAL; 239 240 i2c = devm_kzalloc(dev, sizeof(*i2c), GFP_KERNEL); 241 if (!i2c) 242 return -ENOMEM; 243 244 i2c->adev = adev; 245 246 usbio_acpi_bind(i2c->adev, usbio_i2c_acpi_hids); 247 usbio_get_txrxbuf_len(i2c->adev, &i2c->txbuf_len, &i2c->rxbuf_len); 248 249 i2c->rwbuf = devm_kzalloc(dev, max(i2c->txbuf_len, i2c->rxbuf_len), GFP_KERNEL); 250 if (!i2c->rwbuf) 251 return -ENOMEM; 252 253 i2c->quirks = usbio_get_quirks(i2c->adev); 254 255 max_speed = usbio_i2c_speeds[i2c_desc->caps & USBIO_I2C_BUS_MODE_CAP_MASK]; 256 if (max_speed < I2C_MAX_FAST_MODE_FREQ && 257 (i2c->quirks & USBIO_QUIRK_I2C_ALLOW_400KHZ)) 258 max_speed = I2C_MAX_FAST_MODE_FREQ; 259 260 i2c->speed = i2c_acpi_find_bus_speed(dev); 261 if (!i2c->speed) 262 i2c->speed = I2C_MAX_STANDARD_MODE_FREQ; 263 else if (i2c->speed > max_speed) { 264 dev_warn(dev, "Invalid speed %u adjusting to bus max %u\n", 265 i2c->speed, max_speed); 266 i2c->speed = max_speed; 267 } 268 269 i2c->adap.owner = THIS_MODULE; 270 i2c->adap.class = I2C_CLASS_HWMON; 271 i2c->adap.dev.parent = dev; 272 i2c->adap.algo = &usbio_i2c_algo; 273 274 if (i2c->quirks & USBIO_QUIRK_I2C_MAX_RW_LEN_52) 275 i2c->adap.quirks = &usbio_i2c_quirks_max_rw_len52; 276 else 277 i2c->adap.quirks = &usbio_i2c_quirks; 278 279 snprintf(i2c->adap.name, sizeof(i2c->adap.name), "%s.%d", 280 USBIO_I2C_CLIENT, i2c->adev->id); 281 282 device_set_node(&i2c->adap.dev, dev_fwnode(&adev->dev)); 283 284 auxiliary_set_drvdata(adev, i2c); 285 i2c_set_adapdata(&i2c->adap, i2c); 286 287 ret = i2c_add_adapter(&i2c->adap); 288 if (ret) 289 return ret; 290 291 if (has_acpi_companion(&i2c->adap.dev)) 292 acpi_dev_clear_dependencies(ACPI_COMPANION(&i2c->adap.dev)); 293 294 return 0; 295 } 296 297 static void usbio_i2c_remove(struct auxiliary_device *adev) 298 { 299 struct usbio_i2c *i2c = auxiliary_get_drvdata(adev); 300 301 i2c_del_adapter(&i2c->adap); 302 } 303 304 static const struct auxiliary_device_id usbio_i2c_id_table[] = { 305 { "usbio.usbio-i2c" }, 306 { } 307 }; 308 MODULE_DEVICE_TABLE(auxiliary, usbio_i2c_id_table); 309 310 static struct auxiliary_driver usbio_i2c_driver = { 311 .name = USBIO_I2C_CLIENT, 312 .probe = usbio_i2c_probe, 313 .remove = usbio_i2c_remove, 314 .id_table = usbio_i2c_id_table 315 }; 316 module_auxiliary_driver(usbio_i2c_driver); 317 318 MODULE_DESCRIPTION("Intel USBIO I2C driver"); 319 MODULE_AUTHOR("Israel Cepeda <israel.a.cepeda.lopez@intel.com>"); 320 MODULE_AUTHOR("Hans de Goede <hansg@kernel.org>"); 321 MODULE_LICENSE("GPL"); 322 MODULE_IMPORT_NS("USBIO"); 323