Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
16struct 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
26static 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
36static 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
43static 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
55static 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
83static 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
126static 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
176static 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
199out_release:
200 usbio_release(i2c->adev);
201
202 return ret;
203}
204
205static u32 usbio_i2c_func(struct i2c_adapter *adap)
206{
207 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
208}
209
210static 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
216static 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
222static const struct i2c_algorithm usbio_i2c_algo = {
223 .master_xfer = usbio_i2c_xfer,
224 .functionality = usbio_i2c_func,
225};
226
227static 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
297static 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
304static const struct auxiliary_device_id usbio_i2c_id_table[] = {
305 { "usbio.usbio-i2c" },
306 { }
307};
308MODULE_DEVICE_TABLE(auxiliary, usbio_i2c_id_table);
309
310static 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};
316module_auxiliary_driver(usbio_i2c_driver);
317
318MODULE_DESCRIPTION("Intel USBIO I2C driver");
319MODULE_AUTHOR("Israel Cepeda <israel.a.cepeda.lopez@intel.com>");
320MODULE_AUTHOR("Hans de Goede <hansg@kernel.org>");
321MODULE_LICENSE("GPL");
322MODULE_IMPORT_NS("USBIO");