1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Driver for the Diolan u2c-12 USB-I2C adapter |
4 | * |
5 | * Copyright (c) 2010-2011 Ericsson AB |
6 | * |
7 | * Derived from: |
8 | * i2c-tiny-usb.c |
9 | * Copyright (C) 2006-2007 Till Harbaum (Till@Harbaum.org) |
10 | */ |
11 | |
12 | #include <linux/kernel.h> |
13 | #include <linux/errno.h> |
14 | #include <linux/module.h> |
15 | #include <linux/types.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/usb.h> |
18 | #include <linux/i2c.h> |
19 | |
20 | #define DRIVER_NAME "i2c-diolan-u2c" |
21 | |
22 | #define USB_VENDOR_ID_DIOLAN 0x0abf |
23 | #define USB_DEVICE_ID_DIOLAN_U2C 0x3370 |
24 | |
25 | |
26 | /* commands via USB, must match command ids in the firmware */ |
27 | #define CMD_I2C_READ 0x01 |
28 | #define CMD_I2C_WRITE 0x02 |
29 | #define CMD_I2C_SCAN 0x03 /* Returns list of detected devices */ |
30 | #define CMD_I2C_RELEASE_SDA 0x04 |
31 | #define CMD_I2C_RELEASE_SCL 0x05 |
32 | #define CMD_I2C_DROP_SDA 0x06 |
33 | #define CMD_I2C_DROP_SCL 0x07 |
34 | #define CMD_I2C_READ_SDA 0x08 |
35 | #define CMD_I2C_READ_SCL 0x09 |
36 | #define CMD_GET_FW_VERSION 0x0a |
37 | #define CMD_GET_SERIAL 0x0b |
38 | #define CMD_I2C_START 0x0c |
39 | #define CMD_I2C_STOP 0x0d |
40 | #define CMD_I2C_REPEATED_START 0x0e |
41 | #define CMD_I2C_PUT_BYTE 0x0f |
42 | #define CMD_I2C_GET_BYTE 0x10 |
43 | #define CMD_I2C_PUT_ACK 0x11 |
44 | #define CMD_I2C_GET_ACK 0x12 |
45 | #define CMD_I2C_PUT_BYTE_ACK 0x13 |
46 | #define CMD_I2C_GET_BYTE_ACK 0x14 |
47 | #define CMD_I2C_SET_SPEED 0x1b |
48 | #define CMD_I2C_GET_SPEED 0x1c |
49 | #define CMD_I2C_SET_CLK_SYNC 0x24 |
50 | #define CMD_I2C_GET_CLK_SYNC 0x25 |
51 | #define CMD_I2C_SET_CLK_SYNC_TO 0x26 |
52 | #define CMD_I2C_GET_CLK_SYNC_TO 0x27 |
53 | |
54 | #define RESP_OK 0x00 |
55 | #define RESP_FAILED 0x01 |
56 | #define RESP_BAD_MEMADDR 0x04 |
57 | #define RESP_DATA_ERR 0x05 |
58 | #define RESP_NOT_IMPLEMENTED 0x06 |
59 | #define RESP_NACK 0x07 |
60 | #define RESP_TIMEOUT 0x09 |
61 | |
62 | #define U2C_I2C_SPEED_FAST 0 /* 400 kHz */ |
63 | #define U2C_I2C_SPEED_STD 1 /* 100 kHz */ |
64 | #define U2C_I2C_SPEED_2KHZ 242 /* 2 kHz, minimum speed */ |
65 | #define U2C_I2C_SPEED(f) ((DIV_ROUND_UP(1000000, (f)) - 10) / 2 + 1) |
66 | |
67 | #define U2C_I2C_FREQ(s) (1000000 / (2 * (s - 1) + 10)) |
68 | |
69 | #define DIOLAN_USB_TIMEOUT 100 /* in ms */ |
70 | #define DIOLAN_SYNC_TIMEOUT 20 /* in ms */ |
71 | |
72 | #define DIOLAN_OUTBUF_LEN 128 |
73 | #define DIOLAN_FLUSH_LEN (DIOLAN_OUTBUF_LEN - 4) |
74 | #define DIOLAN_INBUF_LEN 256 /* Maximum supported receive length */ |
75 | |
76 | /* Structure to hold all of our device specific stuff */ |
77 | struct i2c_diolan_u2c { |
78 | u8 obuffer[DIOLAN_OUTBUF_LEN]; /* output buffer */ |
79 | u8 ibuffer[DIOLAN_INBUF_LEN]; /* input buffer */ |
80 | int ep_in, ep_out; /* Endpoints */ |
81 | struct usb_device *usb_dev; /* the usb device for this device */ |
82 | struct usb_interface *interface;/* the interface for this device */ |
83 | struct i2c_adapter adapter; /* i2c related things */ |
84 | int olen; /* Output buffer length */ |
85 | int ocount; /* Number of enqueued messages */ |
86 | }; |
87 | |
88 | static uint frequency = I2C_MAX_STANDARD_MODE_FREQ; /* I2C clock frequency in Hz */ |
89 | |
90 | module_param(frequency, uint, S_IRUGO | S_IWUSR); |
91 | MODULE_PARM_DESC(frequency, "I2C clock frequency in hertz" ); |
92 | |
93 | /* usb layer */ |
94 | |
95 | /* Send command to device, and get response. */ |
96 | static int diolan_usb_transfer(struct i2c_diolan_u2c *dev) |
97 | { |
98 | int ret = 0; |
99 | int actual; |
100 | int i; |
101 | |
102 | if (!dev->olen || !dev->ocount) |
103 | return -EINVAL; |
104 | |
105 | ret = usb_bulk_msg(usb_dev: dev->usb_dev, |
106 | usb_sndbulkpipe(dev->usb_dev, dev->ep_out), |
107 | data: dev->obuffer, len: dev->olen, actual_length: &actual, |
108 | DIOLAN_USB_TIMEOUT); |
109 | if (!ret) { |
110 | for (i = 0; i < dev->ocount; i++) { |
111 | int tmpret; |
112 | |
113 | tmpret = usb_bulk_msg(usb_dev: dev->usb_dev, |
114 | usb_rcvbulkpipe(dev->usb_dev, |
115 | dev->ep_in), |
116 | data: dev->ibuffer, |
117 | len: sizeof(dev->ibuffer), actual_length: &actual, |
118 | DIOLAN_USB_TIMEOUT); |
119 | /* |
120 | * Stop command processing if a previous command |
121 | * returned an error. |
122 | * Note that we still need to retrieve all messages. |
123 | */ |
124 | if (ret < 0) |
125 | continue; |
126 | ret = tmpret; |
127 | if (ret == 0 && actual > 0) { |
128 | switch (dev->ibuffer[actual - 1]) { |
129 | case RESP_NACK: |
130 | /* |
131 | * Return ENXIO if NACK was received as |
132 | * response to the address phase, |
133 | * EIO otherwise |
134 | */ |
135 | ret = i == 1 ? -ENXIO : -EIO; |
136 | break; |
137 | case RESP_TIMEOUT: |
138 | ret = -ETIMEDOUT; |
139 | break; |
140 | case RESP_OK: |
141 | /* strip off return code */ |
142 | ret = actual - 1; |
143 | break; |
144 | default: |
145 | ret = -EIO; |
146 | break; |
147 | } |
148 | } |
149 | } |
150 | } |
151 | dev->olen = 0; |
152 | dev->ocount = 0; |
153 | return ret; |
154 | } |
155 | |
156 | static int diolan_write_cmd(struct i2c_diolan_u2c *dev, bool flush) |
157 | { |
158 | if (flush || dev->olen >= DIOLAN_FLUSH_LEN) |
159 | return diolan_usb_transfer(dev); |
160 | return 0; |
161 | } |
162 | |
163 | /* Send command (no data) */ |
164 | static int diolan_usb_cmd(struct i2c_diolan_u2c *dev, u8 command, bool flush) |
165 | { |
166 | dev->obuffer[dev->olen++] = command; |
167 | dev->ocount++; |
168 | return diolan_write_cmd(dev, flush); |
169 | } |
170 | |
171 | /* Send command with one byte of data */ |
172 | static int diolan_usb_cmd_data(struct i2c_diolan_u2c *dev, u8 command, u8 data, |
173 | bool flush) |
174 | { |
175 | dev->obuffer[dev->olen++] = command; |
176 | dev->obuffer[dev->olen++] = data; |
177 | dev->ocount++; |
178 | return diolan_write_cmd(dev, flush); |
179 | } |
180 | |
181 | /* Send command with two bytes of data */ |
182 | static int diolan_usb_cmd_data2(struct i2c_diolan_u2c *dev, u8 command, u8 d1, |
183 | u8 d2, bool flush) |
184 | { |
185 | dev->obuffer[dev->olen++] = command; |
186 | dev->obuffer[dev->olen++] = d1; |
187 | dev->obuffer[dev->olen++] = d2; |
188 | dev->ocount++; |
189 | return diolan_write_cmd(dev, flush); |
190 | } |
191 | |
192 | /* |
193 | * Flush input queue. |
194 | * If we don't do this at startup and the controller has queued up |
195 | * messages which were not retrieved, it will stop responding |
196 | * at some point. |
197 | */ |
198 | static void diolan_flush_input(struct i2c_diolan_u2c *dev) |
199 | { |
200 | int i; |
201 | |
202 | for (i = 0; i < 10; i++) { |
203 | int actual = 0; |
204 | int ret; |
205 | |
206 | ret = usb_bulk_msg(usb_dev: dev->usb_dev, |
207 | usb_rcvbulkpipe(dev->usb_dev, dev->ep_in), |
208 | data: dev->ibuffer, len: sizeof(dev->ibuffer), actual_length: &actual, |
209 | DIOLAN_USB_TIMEOUT); |
210 | if (ret < 0 || actual == 0) |
211 | break; |
212 | } |
213 | if (i == 10) |
214 | dev_err(&dev->interface->dev, "Failed to flush input buffer\n" ); |
215 | } |
216 | |
217 | static int diolan_i2c_start(struct i2c_diolan_u2c *dev) |
218 | { |
219 | return diolan_usb_cmd(dev, CMD_I2C_START, flush: false); |
220 | } |
221 | |
222 | static int diolan_i2c_repeated_start(struct i2c_diolan_u2c *dev) |
223 | { |
224 | return diolan_usb_cmd(dev, CMD_I2C_REPEATED_START, flush: false); |
225 | } |
226 | |
227 | static int diolan_i2c_stop(struct i2c_diolan_u2c *dev) |
228 | { |
229 | return diolan_usb_cmd(dev, CMD_I2C_STOP, flush: true); |
230 | } |
231 | |
232 | static int diolan_i2c_get_byte_ack(struct i2c_diolan_u2c *dev, bool ack, |
233 | u8 *byte) |
234 | { |
235 | int ret; |
236 | |
237 | ret = diolan_usb_cmd_data(dev, CMD_I2C_GET_BYTE_ACK, data: ack, flush: true); |
238 | if (ret > 0) |
239 | *byte = dev->ibuffer[0]; |
240 | else if (ret == 0) |
241 | ret = -EIO; |
242 | |
243 | return ret; |
244 | } |
245 | |
246 | static int diolan_i2c_put_byte_ack(struct i2c_diolan_u2c *dev, u8 byte) |
247 | { |
248 | return diolan_usb_cmd_data(dev, CMD_I2C_PUT_BYTE_ACK, data: byte, flush: false); |
249 | } |
250 | |
251 | static int diolan_set_speed(struct i2c_diolan_u2c *dev, u8 speed) |
252 | { |
253 | return diolan_usb_cmd_data(dev, CMD_I2C_SET_SPEED, data: speed, flush: true); |
254 | } |
255 | |
256 | /* Enable or disable clock synchronization (stretching) */ |
257 | static int diolan_set_clock_synch(struct i2c_diolan_u2c *dev, bool enable) |
258 | { |
259 | return diolan_usb_cmd_data(dev, CMD_I2C_SET_CLK_SYNC, data: enable, flush: true); |
260 | } |
261 | |
262 | /* Set clock synchronization timeout in ms */ |
263 | static int diolan_set_clock_synch_timeout(struct i2c_diolan_u2c *dev, int ms) |
264 | { |
265 | int to_val = ms * 10; |
266 | |
267 | return diolan_usb_cmd_data2(dev, CMD_I2C_SET_CLK_SYNC_TO, |
268 | d1: to_val & 0xff, d2: (to_val >> 8) & 0xff, flush: true); |
269 | } |
270 | |
271 | static void diolan_fw_version(struct i2c_diolan_u2c *dev) |
272 | { |
273 | int ret; |
274 | |
275 | ret = diolan_usb_cmd(dev, CMD_GET_FW_VERSION, flush: true); |
276 | if (ret >= 2) |
277 | dev_info(&dev->interface->dev, |
278 | "Diolan U2C firmware version %u.%u\n" , |
279 | (unsigned int)dev->ibuffer[0], |
280 | (unsigned int)dev->ibuffer[1]); |
281 | } |
282 | |
283 | static void diolan_get_serial(struct i2c_diolan_u2c *dev) |
284 | { |
285 | int ret; |
286 | u32 serial; |
287 | |
288 | ret = diolan_usb_cmd(dev, CMD_GET_SERIAL, flush: true); |
289 | if (ret >= 4) { |
290 | serial = le32_to_cpu(*(u32 *)dev->ibuffer); |
291 | dev_info(&dev->interface->dev, |
292 | "Diolan U2C serial number %u\n" , serial); |
293 | } |
294 | } |
295 | |
296 | static int diolan_init(struct i2c_diolan_u2c *dev) |
297 | { |
298 | int speed, ret; |
299 | |
300 | if (frequency >= 2 * I2C_MAX_STANDARD_MODE_FREQ) { |
301 | speed = U2C_I2C_SPEED_FAST; |
302 | frequency = I2C_MAX_FAST_MODE_FREQ; |
303 | } else if (frequency >= I2C_MAX_STANDARD_MODE_FREQ || frequency == 0) { |
304 | speed = U2C_I2C_SPEED_STD; |
305 | frequency = I2C_MAX_STANDARD_MODE_FREQ; |
306 | } else { |
307 | speed = U2C_I2C_SPEED(frequency); |
308 | if (speed > U2C_I2C_SPEED_2KHZ) |
309 | speed = U2C_I2C_SPEED_2KHZ; |
310 | frequency = U2C_I2C_FREQ(speed); |
311 | } |
312 | |
313 | dev_info(&dev->interface->dev, |
314 | "Diolan U2C at USB bus %03d address %03d speed %d Hz\n" , |
315 | dev->usb_dev->bus->busnum, dev->usb_dev->devnum, frequency); |
316 | |
317 | diolan_flush_input(dev); |
318 | diolan_fw_version(dev); |
319 | diolan_get_serial(dev); |
320 | |
321 | /* Set I2C speed */ |
322 | ret = diolan_set_speed(dev, speed); |
323 | if (ret < 0) |
324 | return ret; |
325 | |
326 | /* Configure I2C clock synchronization */ |
327 | ret = diolan_set_clock_synch(dev, enable: speed != U2C_I2C_SPEED_FAST); |
328 | if (ret < 0) |
329 | return ret; |
330 | |
331 | if (speed != U2C_I2C_SPEED_FAST) |
332 | ret = diolan_set_clock_synch_timeout(dev, DIOLAN_SYNC_TIMEOUT); |
333 | |
334 | return ret; |
335 | } |
336 | |
337 | /* i2c layer */ |
338 | |
339 | static int diolan_usb_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, |
340 | int num) |
341 | { |
342 | struct i2c_diolan_u2c *dev = i2c_get_adapdata(adap: adapter); |
343 | struct i2c_msg *pmsg; |
344 | int i, j; |
345 | int ret, sret; |
346 | |
347 | ret = diolan_i2c_start(dev); |
348 | if (ret < 0) |
349 | return ret; |
350 | |
351 | for (i = 0; i < num; i++) { |
352 | pmsg = &msgs[i]; |
353 | if (i) { |
354 | ret = diolan_i2c_repeated_start(dev); |
355 | if (ret < 0) |
356 | goto abort; |
357 | } |
358 | ret = diolan_i2c_put_byte_ack(dev, |
359 | byte: i2c_8bit_addr_from_msg(msg: pmsg)); |
360 | if (ret < 0) |
361 | goto abort; |
362 | if (pmsg->flags & I2C_M_RD) { |
363 | for (j = 0; j < pmsg->len; j++) { |
364 | u8 byte; |
365 | bool ack = j < pmsg->len - 1; |
366 | |
367 | /* |
368 | * Don't send NACK if this is the first byte |
369 | * of a SMBUS_BLOCK message. |
370 | */ |
371 | if (j == 0 && (pmsg->flags & I2C_M_RECV_LEN)) |
372 | ack = true; |
373 | |
374 | ret = diolan_i2c_get_byte_ack(dev, ack, byte: &byte); |
375 | if (ret < 0) |
376 | goto abort; |
377 | /* |
378 | * Adjust count if first received byte is length |
379 | */ |
380 | if (j == 0 && (pmsg->flags & I2C_M_RECV_LEN)) { |
381 | if (byte == 0 |
382 | || byte > I2C_SMBUS_BLOCK_MAX) { |
383 | ret = -EPROTO; |
384 | goto abort; |
385 | } |
386 | pmsg->len += byte; |
387 | } |
388 | pmsg->buf[j] = byte; |
389 | } |
390 | } else { |
391 | for (j = 0; j < pmsg->len; j++) { |
392 | ret = diolan_i2c_put_byte_ack(dev, |
393 | byte: pmsg->buf[j]); |
394 | if (ret < 0) |
395 | goto abort; |
396 | } |
397 | } |
398 | } |
399 | ret = num; |
400 | abort: |
401 | sret = diolan_i2c_stop(dev); |
402 | if (sret < 0 && ret >= 0) |
403 | ret = sret; |
404 | return ret; |
405 | } |
406 | |
407 | /* |
408 | * Return list of supported functionality. |
409 | */ |
410 | static u32 diolan_usb_func(struct i2c_adapter *a) |
411 | { |
412 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | |
413 | I2C_FUNC_SMBUS_READ_BLOCK_DATA | I2C_FUNC_SMBUS_BLOCK_PROC_CALL; |
414 | } |
415 | |
416 | static const struct i2c_algorithm diolan_usb_algorithm = { |
417 | .master_xfer = diolan_usb_xfer, |
418 | .functionality = diolan_usb_func, |
419 | }; |
420 | |
421 | /* device layer */ |
422 | |
423 | static const struct usb_device_id diolan_u2c_table[] = { |
424 | { USB_DEVICE(USB_VENDOR_ID_DIOLAN, USB_DEVICE_ID_DIOLAN_U2C) }, |
425 | { } |
426 | }; |
427 | |
428 | MODULE_DEVICE_TABLE(usb, diolan_u2c_table); |
429 | |
430 | static void diolan_u2c_free(struct i2c_diolan_u2c *dev) |
431 | { |
432 | usb_put_dev(dev: dev->usb_dev); |
433 | kfree(objp: dev); |
434 | } |
435 | |
436 | static int diolan_u2c_probe(struct usb_interface *interface, |
437 | const struct usb_device_id *id) |
438 | { |
439 | struct usb_host_interface *hostif = interface->cur_altsetting; |
440 | struct i2c_diolan_u2c *dev; |
441 | int ret; |
442 | |
443 | if (hostif->desc.bInterfaceNumber != 0 |
444 | || hostif->desc.bNumEndpoints < 2) |
445 | return -ENODEV; |
446 | |
447 | /* allocate memory for our device state and initialize it */ |
448 | dev = kzalloc(size: sizeof(*dev), GFP_KERNEL); |
449 | if (dev == NULL) { |
450 | ret = -ENOMEM; |
451 | goto error; |
452 | } |
453 | dev->ep_out = hostif->endpoint[0].desc.bEndpointAddress; |
454 | dev->ep_in = hostif->endpoint[1].desc.bEndpointAddress; |
455 | |
456 | dev->usb_dev = usb_get_dev(interface_to_usbdev(interface)); |
457 | dev->interface = interface; |
458 | |
459 | /* save our data pointer in this interface device */ |
460 | usb_set_intfdata(intf: interface, data: dev); |
461 | |
462 | /* setup i2c adapter description */ |
463 | dev->adapter.owner = THIS_MODULE; |
464 | dev->adapter.class = I2C_CLASS_HWMON; |
465 | dev->adapter.algo = &diolan_usb_algorithm; |
466 | i2c_set_adapdata(adap: &dev->adapter, data: dev); |
467 | snprintf(buf: dev->adapter.name, size: sizeof(dev->adapter.name), |
468 | DRIVER_NAME " at bus %03d device %03d" , |
469 | dev->usb_dev->bus->busnum, dev->usb_dev->devnum); |
470 | |
471 | dev->adapter.dev.parent = &dev->interface->dev; |
472 | |
473 | /* initialize diolan i2c interface */ |
474 | ret = diolan_init(dev); |
475 | if (ret < 0) { |
476 | dev_err(&interface->dev, "failed to initialize adapter\n" ); |
477 | goto error_free; |
478 | } |
479 | |
480 | /* and finally attach to i2c layer */ |
481 | ret = i2c_add_adapter(adap: &dev->adapter); |
482 | if (ret < 0) |
483 | goto error_free; |
484 | |
485 | dev_dbg(&interface->dev, "connected " DRIVER_NAME "\n" ); |
486 | |
487 | return 0; |
488 | |
489 | error_free: |
490 | usb_set_intfdata(intf: interface, NULL); |
491 | diolan_u2c_free(dev); |
492 | error: |
493 | return ret; |
494 | } |
495 | |
496 | static void diolan_u2c_disconnect(struct usb_interface *interface) |
497 | { |
498 | struct i2c_diolan_u2c *dev = usb_get_intfdata(intf: interface); |
499 | |
500 | i2c_del_adapter(adap: &dev->adapter); |
501 | usb_set_intfdata(intf: interface, NULL); |
502 | diolan_u2c_free(dev); |
503 | |
504 | dev_dbg(&interface->dev, "disconnected\n" ); |
505 | } |
506 | |
507 | static struct usb_driver diolan_u2c_driver = { |
508 | .name = DRIVER_NAME, |
509 | .probe = diolan_u2c_probe, |
510 | .disconnect = diolan_u2c_disconnect, |
511 | .id_table = diolan_u2c_table, |
512 | }; |
513 | |
514 | module_usb_driver(diolan_u2c_driver); |
515 | |
516 | MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>" ); |
517 | MODULE_DESCRIPTION(DRIVER_NAME " driver" ); |
518 | MODULE_LICENSE("GPL" ); |
519 | |