1
2
3
4
5
6
7
8
9
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
27#define CMD_I2C_READ 0x01
28#define CMD_I2C_WRITE 0x02
29#define CMD_I2C_SCAN 0x03
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
63#define U2C_I2C_SPEED_STD 1
64#define U2C_I2C_SPEED_2KHZ 242
65#define U2C_I2C_SPEED(f) ((DIV_ROUND_UP(1000000, (f)) - 10) / 2 + 1)
66
67#define U2C_I2C_FREQ_FAST 400000
68#define U2C_I2C_FREQ_STD 100000
69#define U2C_I2C_FREQ(s) (1000000 / (2 * (s - 1) + 10))
70
71#define DIOLAN_USB_TIMEOUT 100
72#define DIOLAN_SYNC_TIMEOUT 20
73
74#define DIOLAN_OUTBUF_LEN 128
75#define DIOLAN_FLUSH_LEN (DIOLAN_OUTBUF_LEN - 4)
76#define DIOLAN_INBUF_LEN 256
77
78
79struct i2c_diolan_u2c {
80 u8 obuffer[DIOLAN_OUTBUF_LEN];
81 u8 ibuffer[DIOLAN_INBUF_LEN];
82 int ep_in, ep_out;
83 struct usb_device *usb_dev;
84 struct usb_interface *interface;
85 struct i2c_adapter adapter;
86 int olen;
87 int ocount;
88};
89
90static uint frequency = U2C_I2C_FREQ_STD;
91
92module_param(frequency, uint, S_IRUGO | S_IWUSR);
93MODULE_PARM_DESC(frequency, "I2C clock frequency in hertz");
94
95
96
97
98static int diolan_usb_transfer(struct i2c_diolan_u2c *dev)
99{
100 int ret = 0;
101 int actual;
102 int i;
103
104 if (!dev->olen || !dev->ocount)
105 return -EINVAL;
106
107 ret = usb_bulk_msg(dev->usb_dev,
108 usb_sndbulkpipe(dev->usb_dev, dev->ep_out),
109 dev->obuffer, dev->olen, &actual,
110 DIOLAN_USB_TIMEOUT);
111 if (!ret) {
112 for (i = 0; i < dev->ocount; i++) {
113 int tmpret;
114
115 tmpret = usb_bulk_msg(dev->usb_dev,
116 usb_rcvbulkpipe(dev->usb_dev,
117 dev->ep_in),
118 dev->ibuffer,
119 sizeof(dev->ibuffer), &actual,
120 DIOLAN_USB_TIMEOUT);
121
122
123
124
125
126 if (ret < 0)
127 continue;
128 ret = tmpret;
129 if (ret == 0 && actual > 0) {
130 switch (dev->ibuffer[actual - 1]) {
131 case RESP_NACK:
132
133
134
135
136
137 ret = i == 1 ? -ENXIO : -EIO;
138 break;
139 case RESP_TIMEOUT:
140 ret = -ETIMEDOUT;
141 break;
142 case RESP_OK:
143
144 ret = actual - 1;
145 break;
146 default:
147 ret = -EIO;
148 break;
149 }
150 }
151 }
152 }
153 dev->olen = 0;
154 dev->ocount = 0;
155 return ret;
156}
157
158static int diolan_write_cmd(struct i2c_diolan_u2c *dev, bool flush)
159{
160 if (flush || dev->olen >= DIOLAN_FLUSH_LEN)
161 return diolan_usb_transfer(dev);
162 return 0;
163}
164
165
166static int diolan_usb_cmd(struct i2c_diolan_u2c *dev, u8 command, bool flush)
167{
168 dev->obuffer[dev->olen++] = command;
169 dev->ocount++;
170 return diolan_write_cmd(dev, flush);
171}
172
173
174static int diolan_usb_cmd_data(struct i2c_diolan_u2c *dev, u8 command, u8 data,
175 bool flush)
176{
177 dev->obuffer[dev->olen++] = command;
178 dev->obuffer[dev->olen++] = data;
179 dev->ocount++;
180 return diolan_write_cmd(dev, flush);
181}
182
183
184static int diolan_usb_cmd_data2(struct i2c_diolan_u2c *dev, u8 command, u8 d1,
185 u8 d2, bool flush)
186{
187 dev->obuffer[dev->olen++] = command;
188 dev->obuffer[dev->olen++] = d1;
189 dev->obuffer[dev->olen++] = d2;
190 dev->ocount++;
191 return diolan_write_cmd(dev, flush);
192}
193
194
195
196
197
198
199
200static void diolan_flush_input(struct i2c_diolan_u2c *dev)
201{
202 int i;
203
204 for (i = 0; i < 10; i++) {
205 int actual = 0;
206 int ret;
207
208 ret = usb_bulk_msg(dev->usb_dev,
209 usb_rcvbulkpipe(dev->usb_dev, dev->ep_in),
210 dev->ibuffer, sizeof(dev->ibuffer), &actual,
211 DIOLAN_USB_TIMEOUT);
212 if (ret < 0 || actual == 0)
213 break;
214 }
215 if (i == 10)
216 dev_err(&dev->interface->dev, "Failed to flush input buffer\n");
217}
218
219static int diolan_i2c_start(struct i2c_diolan_u2c *dev)
220{
221 return diolan_usb_cmd(dev, CMD_I2C_START, false);
222}
223
224static int diolan_i2c_repeated_start(struct i2c_diolan_u2c *dev)
225{
226 return diolan_usb_cmd(dev, CMD_I2C_REPEATED_START, false);
227}
228
229static int diolan_i2c_stop(struct i2c_diolan_u2c *dev)
230{
231 return diolan_usb_cmd(dev, CMD_I2C_STOP, true);
232}
233
234static int diolan_i2c_get_byte_ack(struct i2c_diolan_u2c *dev, bool ack,
235 u8 *byte)
236{
237 int ret;
238
239 ret = diolan_usb_cmd_data(dev, CMD_I2C_GET_BYTE_ACK, ack, true);
240 if (ret > 0)
241 *byte = dev->ibuffer[0];
242 else if (ret == 0)
243 ret = -EIO;
244
245 return ret;
246}
247
248static int diolan_i2c_put_byte_ack(struct i2c_diolan_u2c *dev, u8 byte)
249{
250 return diolan_usb_cmd_data(dev, CMD_I2C_PUT_BYTE_ACK, byte, false);
251}
252
253static int diolan_set_speed(struct i2c_diolan_u2c *dev, u8 speed)
254{
255 return diolan_usb_cmd_data(dev, CMD_I2C_SET_SPEED, speed, true);
256}
257
258
259static int diolan_set_clock_synch(struct i2c_diolan_u2c *dev, bool enable)
260{
261 return diolan_usb_cmd_data(dev, CMD_I2C_SET_CLK_SYNC, enable, true);
262}
263
264
265static int diolan_set_clock_synch_timeout(struct i2c_diolan_u2c *dev, int ms)
266{
267 int to_val = ms * 10;
268
269 return diolan_usb_cmd_data2(dev, CMD_I2C_SET_CLK_SYNC_TO,
270 to_val & 0xff, (to_val >> 8) & 0xff, true);
271}
272
273static void diolan_fw_version(struct i2c_diolan_u2c *dev)
274{
275 int ret;
276
277 ret = diolan_usb_cmd(dev, CMD_GET_FW_VERSION, true);
278 if (ret >= 2)
279 dev_info(&dev->interface->dev,
280 "Diolan U2C firmware version %u.%u\n",
281 (unsigned int)dev->ibuffer[0],
282 (unsigned int)dev->ibuffer[1]);
283}
284
285static void diolan_get_serial(struct i2c_diolan_u2c *dev)
286{
287 int ret;
288 u32 serial;
289
290 ret = diolan_usb_cmd(dev, CMD_GET_SERIAL, true);
291 if (ret >= 4) {
292 serial = le32_to_cpu(*(u32 *)dev->ibuffer);
293 dev_info(&dev->interface->dev,
294 "Diolan U2C serial number %u\n", serial);
295 }
296}
297
298static int diolan_init(struct i2c_diolan_u2c *dev)
299{
300 int speed, ret;
301
302 if (frequency >= 200000) {
303 speed = U2C_I2C_SPEED_FAST;
304 frequency = U2C_I2C_FREQ_FAST;
305 } else if (frequency >= 100000 || frequency == 0) {
306 speed = U2C_I2C_SPEED_STD;
307 frequency = U2C_I2C_FREQ_STD;
308 } else {
309 speed = U2C_I2C_SPEED(frequency);
310 if (speed > U2C_I2C_SPEED_2KHZ)
311 speed = U2C_I2C_SPEED_2KHZ;
312 frequency = U2C_I2C_FREQ(speed);
313 }
314
315 dev_info(&dev->interface->dev,
316 "Diolan U2C at USB bus %03d address %03d speed %d Hz\n",
317 dev->usb_dev->bus->busnum, dev->usb_dev->devnum, frequency);
318
319 diolan_flush_input(dev);
320 diolan_fw_version(dev);
321 diolan_get_serial(dev);
322
323
324 ret = diolan_set_speed(dev, speed);
325 if (ret < 0)
326 return ret;
327
328
329 ret = diolan_set_clock_synch(dev, speed != U2C_I2C_SPEED_FAST);
330 if (ret < 0)
331 return ret;
332
333 if (speed != U2C_I2C_SPEED_FAST)
334 ret = diolan_set_clock_synch_timeout(dev, DIOLAN_SYNC_TIMEOUT);
335
336 return ret;
337}
338
339
340
341static int diolan_usb_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
342 int num)
343{
344 struct i2c_diolan_u2c *dev = i2c_get_adapdata(adapter);
345 struct i2c_msg *pmsg;
346 int i, j;
347 int ret, sret;
348
349 ret = diolan_i2c_start(dev);
350 if (ret < 0)
351 return ret;
352
353 for (i = 0; i < num; i++) {
354 pmsg = &msgs[i];
355 if (i) {
356 ret = diolan_i2c_repeated_start(dev);
357 if (ret < 0)
358 goto abort;
359 }
360 ret = diolan_i2c_put_byte_ack(dev,
361 i2c_8bit_addr_from_msg(pmsg));
362 if (ret < 0)
363 goto abort;
364 if (pmsg->flags & I2C_M_RD) {
365 for (j = 0; j < pmsg->len; j++) {
366 u8 byte;
367 bool ack = j < pmsg->len - 1;
368
369
370
371
372
373 if (j == 0 && (pmsg->flags & I2C_M_RECV_LEN))
374 ack = true;
375
376 ret = diolan_i2c_get_byte_ack(dev, ack, &byte);
377 if (ret < 0)
378 goto abort;
379
380
381
382 if (j == 0 && (pmsg->flags & I2C_M_RECV_LEN)) {
383 if (byte == 0
384 || byte > I2C_SMBUS_BLOCK_MAX) {
385 ret = -EPROTO;
386 goto abort;
387 }
388 pmsg->len += byte;
389 }
390 pmsg->buf[j] = byte;
391 }
392 } else {
393 for (j = 0; j < pmsg->len; j++) {
394 ret = diolan_i2c_put_byte_ack(dev,
395 pmsg->buf[j]);
396 if (ret < 0)
397 goto abort;
398 }
399 }
400 }
401 ret = num;
402abort:
403 sret = diolan_i2c_stop(dev);
404 if (sret < 0 && ret >= 0)
405 ret = sret;
406 return ret;
407}
408
409
410
411
412static u32 diolan_usb_func(struct i2c_adapter *a)
413{
414 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
415 I2C_FUNC_SMBUS_READ_BLOCK_DATA | I2C_FUNC_SMBUS_BLOCK_PROC_CALL;
416}
417
418static const struct i2c_algorithm diolan_usb_algorithm = {
419 .master_xfer = diolan_usb_xfer,
420 .functionality = diolan_usb_func,
421};
422
423
424
425static const struct usb_device_id diolan_u2c_table[] = {
426 { USB_DEVICE(USB_VENDOR_ID_DIOLAN, USB_DEVICE_ID_DIOLAN_U2C) },
427 { }
428};
429
430MODULE_DEVICE_TABLE(usb, diolan_u2c_table);
431
432static void diolan_u2c_free(struct i2c_diolan_u2c *dev)
433{
434 usb_put_dev(dev->usb_dev);
435 kfree(dev);
436}
437
438static int diolan_u2c_probe(struct usb_interface *interface,
439 const struct usb_device_id *id)
440{
441 struct usb_host_interface *hostif = interface->cur_altsetting;
442 struct i2c_diolan_u2c *dev;
443 int ret;
444
445 if (hostif->desc.bInterfaceNumber != 0
446 || hostif->desc.bNumEndpoints < 2)
447 return -ENODEV;
448
449
450 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
451 if (dev == NULL) {
452 ret = -ENOMEM;
453 goto error;
454 }
455 dev->ep_out = hostif->endpoint[0].desc.bEndpointAddress;
456 dev->ep_in = hostif->endpoint[1].desc.bEndpointAddress;
457
458 dev->usb_dev = usb_get_dev(interface_to_usbdev(interface));
459 dev->interface = interface;
460
461
462 usb_set_intfdata(interface, dev);
463
464
465 dev->adapter.owner = THIS_MODULE;
466 dev->adapter.class = I2C_CLASS_HWMON;
467 dev->adapter.algo = &diolan_usb_algorithm;
468 i2c_set_adapdata(&dev->adapter, dev);
469 snprintf(dev->adapter.name, sizeof(dev->adapter.name),
470 DRIVER_NAME " at bus %03d device %03d",
471 dev->usb_dev->bus->busnum, dev->usb_dev->devnum);
472
473 dev->adapter.dev.parent = &dev->interface->dev;
474
475
476 ret = diolan_init(dev);
477 if (ret < 0) {
478 dev_err(&interface->dev, "failed to initialize adapter\n");
479 goto error_free;
480 }
481
482
483 ret = i2c_add_adapter(&dev->adapter);
484 if (ret < 0)
485 goto error_free;
486
487 dev_dbg(&interface->dev, "connected " DRIVER_NAME "\n");
488
489 return 0;
490
491error_free:
492 usb_set_intfdata(interface, NULL);
493 diolan_u2c_free(dev);
494error:
495 return ret;
496}
497
498static void diolan_u2c_disconnect(struct usb_interface *interface)
499{
500 struct i2c_diolan_u2c *dev = usb_get_intfdata(interface);
501
502 i2c_del_adapter(&dev->adapter);
503 usb_set_intfdata(interface, NULL);
504 diolan_u2c_free(dev);
505
506 dev_dbg(&interface->dev, "disconnected\n");
507}
508
509static struct usb_driver diolan_u2c_driver = {
510 .name = DRIVER_NAME,
511 .probe = diolan_u2c_probe,
512 .disconnect = diolan_u2c_disconnect,
513 .id_table = diolan_u2c_table,
514};
515
516module_usb_driver(diolan_u2c_driver);
517
518MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
519MODULE_DESCRIPTION(DRIVER_NAME " driver");
520MODULE_LICENSE("GPL");
521