projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'gpio-updates-for-v5.13-v2' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-block.git] / drivers / hid / hid-ft260.c
CommitLineData
6a82582d
MZ		 1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * hid-ft260.c - FTDI FT260 USB HID to I2C host bridge
4 *
5 * Copyright (c) 2021, Michael Zaidman <michaelz@xsightlabs.com>
6 *
7 * Data Sheet:
8 * https://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT260.pdf
9 */
10
11#include "hid-ids.h"
12#include <linux/hidraw.h>
13#include <linux/i2c.h>
14#include <linux/module.h>
15#include <linux/usb.h>
16
17#ifdef DEBUG
18static int ft260_debug = 1;
19#else
20static int ft260_debug;
21#endif
22module_param_named(debug, ft260_debug, int, 0600);
23MODULE_PARM_DESC(debug, "Toggle FT260 debugging messages");
24
25#define ft260_dbg(format, arg...) \
26 do { \
27 if (ft260_debug) \
28 pr_info("%s: " format, __func__, ##arg); \
29 } while (0)
30
31#define FT260_REPORT_MAX_LENGTH (64)
32#define FT260_I2C_DATA_REPORT_ID(len) (FT260_I2C_REPORT_MIN + (len - 1) / 4)
33/*
34 * The input report format assigns 62 bytes for the data payload, but ft260
35 * returns 60 and 2 in two separate transactions. To minimize transfer time
36 * in reading chunks mode, set the maximum read payload length to 60 bytes.
37 */
38#define FT260_RD_DATA_MAX (60)
39#define FT260_WR_DATA_MAX (60)
40
41/*
42 * Device interface configuration.
43 * The FT260 has 2 interfaces that are controlled by DCNF0 and DCNF1 pins.
44 * First implementes USB HID to I2C bridge function and
45 * second - USB HID to UART bridge function.
46 */
47enum {
48 FT260_MODE_ALL = 0x00,
49 FT260_MODE_I2C = 0x01,
50 FT260_MODE_UART = 0x02,
51 FT260_MODE_BOTH = 0x03,
52};
53
54/* Control pipe */
55enum {
56 FT260_GET_RQST_TYPE = 0xA1,
57 FT260_GET_REPORT = 0x01,
58 FT260_SET_RQST_TYPE = 0x21,
59 FT260_SET_REPORT = 0x09,
60 FT260_FEATURE = 0x03,
61};
62
63/* Report IDs / Feature In */
64enum {
65 FT260_CHIP_VERSION = 0xA0,
66 FT260_SYSTEM_SETTINGS = 0xA1,
67 FT260_I2C_STATUS = 0xC0,
68 FT260_I2C_READ_REQ = 0xC2,
69 FT260_I2C_REPORT_MIN = 0xD0,
70 FT260_I2C_REPORT_MAX = 0xDE,
71 FT260_GPIO = 0xB0,
72 FT260_UART_INTERRUPT_STATUS = 0xB1,
73 FT260_UART_STATUS = 0xE0,
74 FT260_UART_RI_DCD_STATUS = 0xE1,
75 FT260_UART_REPORT = 0xF0,
76};
77
78/* Feature Out */
79enum {
80 FT260_SET_CLOCK = 0x01,
81 FT260_SET_I2C_MODE = 0x02,
82 FT260_SET_UART_MODE = 0x03,
83 FT260_ENABLE_INTERRUPT = 0x05,
84 FT260_SELECT_GPIO2_FUNC = 0x06,
85 FT260_ENABLE_UART_DCD_RI = 0x07,
86 FT260_SELECT_GPIOA_FUNC = 0x08,
87 FT260_SELECT_GPIOG_FUNC = 0x09,
88 FT260_SET_INTERRUPT_TRIGGER = 0x0A,
89 FT260_SET_SUSPEND_OUT_POLAR = 0x0B,
90 FT260_ENABLE_UART_RI_WAKEUP = 0x0C,
91 FT260_SET_UART_RI_WAKEUP_CFG = 0x0D,
92 FT260_SET_I2C_RESET = 0x20,
93 FT260_SET_I2C_CLOCK_SPEED = 0x22,
94 FT260_SET_UART_RESET = 0x40,
95 FT260_SET_UART_CONFIG = 0x41,
96 FT260_SET_UART_BAUD_RATE = 0x42,
97 FT260_SET_UART_DATA_BIT = 0x43,
98 FT260_SET_UART_PARITY = 0x44,
99 FT260_SET_UART_STOP_BIT = 0x45,
100 FT260_SET_UART_BREAKING = 0x46,
101 FT260_SET_UART_XON_XOFF = 0x49,
102};
103
104/* Response codes in I2C status report */
105enum {
106 FT260_I2C_STATUS_SUCCESS = 0x00,
107 FT260_I2C_STATUS_CTRL_BUSY = 0x01,
108 FT260_I2C_STATUS_ERROR = 0x02,
109 FT260_I2C_STATUS_ADDR_NO_ACK = 0x04,
110 FT260_I2C_STATUS_DATA_NO_ACK = 0x08,
111 FT260_I2C_STATUS_ARBITR_LOST = 0x10,
112 FT260_I2C_STATUS_CTRL_IDLE = 0x20,
113 FT260_I2C_STATUS_BUS_BUSY = 0x40,
114};
115
116/* I2C Conditions flags */
117enum {
118 FT260_FLAG_NONE = 0x00,
119 FT260_FLAG_START = 0x02,
120 FT260_FLAG_START_REPEATED = 0x03,
121 FT260_FLAG_STOP = 0x04,
122 FT260_FLAG_START_STOP = 0x06,
123 FT260_FLAG_START_STOP_REPEATED = 0x07,
124};
125
126#define FT260_SET_REQUEST_VALUE(report_id) ((FT260_FEATURE << 8) | report_id)
127
128/* Feature In reports */
129
130struct ft260_get_chip_version_report {
131 u8 report; /* FT260_CHIP_VERSION */
132 u8 chip_code[4]; /* FTDI chip identification code */
133 u8 reserved[8];
134} __packed;
135
136struct ft260_get_system_status_report {
137 u8 report; /* FT260_SYSTEM_SETTINGS */
138 u8 chip_mode; /* DCNF0 and DCNF1 status, bits 0-1 */
139 u8 clock_ctl; /* 0 - 12MHz, 1 - 24MHz, 2 - 48MHz */
140 u8 suspend_status; /* 0 - not suspended, 1 - suspended */
141 u8 pwren_status; /* 0 - FT260 is not ready, 1 - ready */
142 u8 i2c_enable; /* 0 - disabled, 1 - enabled */
143 u8 uart_mode; /* 0 - OFF; 1 - RTS_CTS, 2 - DTR_DSR, */
144 /* 3 - XON_XOFF, 4 - No flow control */
145 u8 hid_over_i2c_en; /* 0 - disabled, 1 - enabled */
146 u8 gpio2_function; /* 0 - GPIO, 1 - SUSPOUT, */
147 /* 2 - PWREN, 4 - TX_LED */
148 u8 gpioA_function; /* 0 - GPIO, 3 - TX_ACTIVE, 4 - TX_LED */
149 u8 gpioG_function; /* 0 - GPIO, 2 - PWREN, */
150 /* 5 - RX_LED, 6 - BCD_DET */
151 u8 suspend_out_pol; /* 0 - active-high, 1 - active-low */
152 u8 enable_wakeup_int; /* 0 - disabled, 1 - enabled */
153 u8 intr_cond; /* Interrupt trigger conditions */
154 u8 power_saving_en; /* 0 - disabled, 1 - enabled */
155 u8 reserved[10];
156} __packed;
157
158struct ft260_get_i2c_status_report {
159 u8 report; /* FT260_I2C_STATUS */
160 u8 bus_status; /* I2C bus status */
161 __le16 clock; /* I2C bus clock in range 60-3400 KHz */
162 u8 reserved;
163} __packed;
164
165/* Feature Out reports */
166
167struct ft260_set_system_clock_report {
168 u8 report; /* FT260_SYSTEM_SETTINGS */
169 u8 request; /* FT260_SET_CLOCK */
170 u8 clock_ctl; /* 0 - 12MHz, 1 - 24MHz, 2 - 48MHz */
171} __packed;
172
173struct ft260_set_i2c_mode_report {
174 u8 report; /* FT260_SYSTEM_SETTINGS */
175 u8 request; /* FT260_SET_I2C_MODE */
176 u8 i2c_enable; /* 0 - disabled, 1 - enabled */
177} __packed;
178
179struct ft260_set_uart_mode_report {
180 u8 report; /* FT260_SYSTEM_SETTINGS */
181 u8 request; /* FT260_SET_UART_MODE */
182 u8 uart_mode; /* 0 - OFF; 1 - RTS_CTS, 2 - DTR_DSR, */
183 /* 3 - XON_XOFF, 4 - No flow control */
184} __packed;
185
186struct ft260_set_i2c_reset_report {
187 u8 report; /* FT260_SYSTEM_SETTINGS */
188 u8 request; /* FT260_SET_I2C_RESET */
189} __packed;
190
191struct ft260_set_i2c_speed_report {
192 u8 report; /* FT260_SYSTEM_SETTINGS */
193 u8 request; /* FT260_SET_I2C_CLOCK_SPEED */
194 __le16 clock; /* I2C bus clock in range 60-3400 KHz */
195} __packed;
196
197/* Data transfer reports */
198
199struct ft260_i2c_write_request_report {
200 u8 report; /* FT260_I2C_REPORT */
201 u8 address; /* 7-bit I2C address */
202 u8 flag; /* I2C transaction condition */
203 u8 length; /* data payload length */
204 u8 data[60]; /* data payload */
205} __packed;
206
207struct ft260_i2c_read_request_report {
208 u8 report; /* FT260_I2C_READ_REQ */
209 u8 address; /* 7-bit I2C address */
210 u8 flag; /* I2C transaction condition */
211 __le16 length; /* data payload length */
212} __packed;
213
214struct ft260_i2c_input_report {
215 u8 report; /* FT260_I2C_REPORT */
216 u8 length; /* data payload length */
217 u8 data[2]; /* data payload */
218} __packed;
219
220static const struct hid_device_id ft260_devices[] = {
221 { HID_USB_DEVICE(USB_VENDOR_ID_FUTURE_TECHNOLOGY,
222 USB_DEVICE_ID_FT260) },
223 { /* END OF LIST */ }
224};
225MODULE_DEVICE_TABLE(hid, ft260_devices);
226
227struct ft260_device {
228 struct i2c_adapter adap;
229 struct hid_device *hdev;
230 struct completion wait;
231 struct mutex lock;
232 u8 write_buf[FT260_REPORT_MAX_LENGTH];
233 u8 *read_buf;
234 u16 read_idx;
235 u16 read_len;
236 u16 clock;
237};
238
239static int ft260_hid_feature_report_get(struct hid_device *hdev,
240 unsigned char report_id, u8 *data,
241 size_t len)
242{
243 u8 *buf;
244 int ret;
245
246 buf = kmalloc(len, GFP_KERNEL);
247 if (!buf)
248 return -ENOMEM;
249
250 ret = hid_hw_raw_request(hdev, report_id, buf, len, HID_FEATURE_REPORT,
251 HID_REQ_GET_REPORT);
252 memcpy(data, buf, len);
253 kfree(buf);
254 return ret;
255}
256
257static int ft260_hid_feature_report_set(struct hid_device *hdev, u8 *data,
258 size_t len)
259{
260 u8 *buf;
261 int ret;
262
263 buf = kmemdup(data, len, GFP_KERNEL);
264 if (!buf)
265 return -ENOMEM;
266
267 buf[0] = FT260_SYSTEM_SETTINGS;
268
269 ret = hid_hw_raw_request(hdev, buf[0], buf, len, HID_FEATURE_REPORT,
270 HID_REQ_SET_REPORT);
271
272 kfree(buf);
273 return ret;
274}
275
276static int ft260_i2c_reset(struct hid_device *hdev)
277{
278 struct ft260_set_i2c_reset_report report;
279 int ret;
280
281 report.request = FT260_SET_I2C_RESET;
282
283 ret = ft260_hid_feature_report_set(hdev, (u8 *)&report, sizeof(report));
284 if (ret < 0) {
285 hid_err(hdev, "failed to reset I2C controller: %d\n", ret);
286 return ret;
287 }
288
289 ft260_dbg("done\n");
290 return ret;
291}
292
293static int ft260_xfer_status(struct ft260_device *dev)
294{
295 struct hid_device *hdev = dev->hdev;
296 struct ft260_get_i2c_status_report report;
297 int ret;
298
299 ret = ft260_hid_feature_report_get(hdev, FT260_I2C_STATUS,
300 (u8 *)&report, sizeof(report));
301 if (ret < 0) {
302 hid_err(hdev, "failed to retrieve status: %d\n", ret);
303 return ret;
304 }
305
306 dev->clock = le16_to_cpu(report.clock);
307 ft260_dbg("bus_status %#02x, clock %u\n", report.bus_status,
308 dev->clock);
309
310 if (report.bus_status & FT260_I2C_STATUS_CTRL_BUSY)
311 return -EAGAIN;
312
313 if (report.bus_status & FT260_I2C_STATUS_BUS_BUSY)
314 return -EBUSY;
315
316 if (report.bus_status & FT260_I2C_STATUS_ERROR)
317 return -EIO;
318
319 ret = -EIO;
320
321 if (report.bus_status & FT260_I2C_STATUS_ADDR_NO_ACK)
322 ft260_dbg("unacknowledged address\n");
323
324 if (report.bus_status & FT260_I2C_STATUS_DATA_NO_ACK)
325 ft260_dbg("unacknowledged data\n");
326
327 if (report.bus_status & FT260_I2C_STATUS_ARBITR_LOST)
328 ft260_dbg("arbitration loss\n");
329
330 if (report.bus_status & FT260_I2C_STATUS_CTRL_IDLE)
331 ret = 0;
332
333 return ret;
334}
335
336static int ft260_hid_output_report(struct hid_device *hdev, u8 *data,
337 size_t len)
338{
339 u8 *buf;
340 int ret;
341
342 buf = kmemdup(data, len, GFP_KERNEL);
343 if (!buf)
344 return -ENOMEM;
345
346 ret = hid_hw_output_report(hdev, buf, len);
347
348 kfree(buf);
349 return ret;
350}
351
352static int ft260_hid_output_report_check_status(struct ft260_device *dev,
353 u8 *data, int len)
354{
355 int ret, usec, try = 3;
356 struct hid_device *hdev = dev->hdev;
357
358 ret = ft260_hid_output_report(hdev, data, len);
359 if (ret < 0) {
360 hid_err(hdev, "%s: failed to start transfer, ret %d\n",
361 __func__, ret);
362 ft260_i2c_reset(hdev);
363 return ret;
364 }
365
366 /* transfer time = 1 / clock(KHz) * 10 bits * bytes */
367 usec = 10000 / dev->clock * len;
368 usleep_range(usec, usec + 100);
369 ft260_dbg("wait %d usec, len %d\n", usec, len);
370 do {
371 ret = ft260_xfer_status(dev);
372 if (ret != -EAGAIN)
373 break;
374 } while (--try);
375
376 if (ret == 0 || ret == -EBUSY)
377 return 0;
378
379 ft260_i2c_reset(hdev);
380 return -EIO;
381}
382
383static int ft260_i2c_write(struct ft260_device *dev, u8 addr, u8 *data,
384 int data_len, u8 flag)
385{
386 int len, ret, idx = 0;
387 struct hid_device *hdev = dev->hdev;
388 struct ft260_i2c_write_request_report *rep =
389 (struct ft260_i2c_write_request_report *)dev->write_buf;
390
391 do {
392 if (data_len <= FT260_WR_DATA_MAX)
393 len = data_len;
394 else
395 len = FT260_WR_DATA_MAX;
396
397 rep->report = FT260_I2C_DATA_REPORT_ID(len);
398 rep->address = addr;
399 rep->length = len;
400 rep->flag = flag;
401
402 memcpy(rep->data, &data[idx], len);
403
404 ft260_dbg("rep %#02x addr %#02x off %d len %d d[0] %#02x\n",
405 rep->report, addr, idx, len, data[0]);
406
407 ret = ft260_hid_output_report_check_status(dev, (u8 *)rep,
408 len + 4);
409 if (ret < 0) {
410 hid_err(hdev, "%s: failed to start transfer, ret %d\n",
411 __func__, ret);
412 return ret;
413 }
414
415 data_len -= len;
416 idx += len;
417
418 } while (data_len > 0);
419
420 return 0;
421}
422
423static int ft260_smbus_write(struct ft260_device *dev, u8 addr, u8 cmd,
424 u8 *data, u8 data_len, u8 flag)
425{
426 int ret = 0;
427 int len = 4;
428
429 struct ft260_i2c_write_request_report *rep =
430 (struct ft260_i2c_write_request_report *)dev->write_buf;
431
432 rep->address = addr;
433 rep->data[0] = cmd;
434 rep->length = data_len + 1;
435 rep->flag = flag;
436 len += rep->length;
437
438 rep->report = FT260_I2C_DATA_REPORT_ID(len);
439
440 if (data_len > 0)
441 memcpy(&rep->data[1], data, data_len);
442
443 ft260_dbg("rep %#02x addr %#02x cmd %#02x datlen %d replen %d\n",
444 rep->report, addr, cmd, rep->length, len);
445
446 ret = ft260_hid_output_report_check_status(dev, (u8 *)rep, len);
447
448 return ret;
449}
450
451static int ft260_i2c_read(struct ft260_device *dev, u8 addr, u8 *data,
452 u16 len, u8 flag)
453{
454 struct ft260_i2c_read_request_report rep;
455 struct hid_device *hdev = dev->hdev;
456 int timeout;
457 int ret;
458
459 if (len > FT260_RD_DATA_MAX) {
460 hid_err(hdev, "%s: unsupported rd len: %d\n", __func__, len);
461 return -EINVAL;
462 }
463
464 dev->read_idx = 0;
465 dev->read_buf = data;
466 dev->read_len = len;
467
468 rep.report = FT260_I2C_READ_REQ;
469 rep.length = cpu_to_le16(len);
470 rep.address = addr;
471 rep.flag = flag;
472
473 ft260_dbg("rep %#02x addr %#02x len %d\n", rep.report, rep.address,
474 rep.length);
475
476 reinit_completion(&dev->wait);
477
478 ret = ft260_hid_output_report(hdev, (u8 *)&rep, sizeof(rep));
479 if (ret < 0) {
480 hid_err(hdev, "%s: failed to start transaction, ret %d\n",
481 __func__, ret);
482 return ret;
483 }
484
485 timeout = msecs_to_jiffies(5000);
486 if (!wait_for_completion_timeout(&dev->wait, timeout)) {
487 ft260_i2c_reset(hdev);
488 return -ETIMEDOUT;
489 }
490
491 ret = ft260_xfer_status(dev);
492 if (ret == 0)
493 return 0;
494
495 ft260_i2c_reset(hdev);
496 return -EIO;
497}
498
499/*
500 * A random read operation is implemented as a dummy write operation, followed
501 * by a current address read operation. The dummy write operation is used to
502 * load the target byte address into the current byte address counter, from
503 * which the subsequent current address read operation then reads.
504 */
505static int ft260_i2c_write_read(struct ft260_device *dev, struct i2c_msg *msgs)
506{
507 int len, ret;
508 u16 left_len = msgs[1].len;
509 u8 *read_buf = msgs[1].buf;
510 u8 addr = msgs[0].addr;
511 u16 read_off = 0;
512 struct hid_device *hdev = dev->hdev;
513
514 if (msgs[0].len > 2) {
2076b7bd
DC		 515 hid_err(hdev, "%s: unsupported wr len: %d\n", __func__,
516 msgs[0].len);
6a82582d
MZ		 517 return -EOPNOTSUPP;
518 }
519
520 memcpy(&read_off, msgs[0].buf, msgs[0].len);
521
522 do {
523 if (left_len <= FT260_RD_DATA_MAX)
524 len = left_len;
525 else
526 len = FT260_RD_DATA_MAX;
527
528 ft260_dbg("read_off %#x left_len %d len %d\n", read_off,
529 left_len, len);
530
531 ret = ft260_i2c_write(dev, addr, (u8 *)&read_off, msgs[0].len,
532 FT260_FLAG_START);
533 if (ret < 0)
534 return ret;
535
536 ret = ft260_i2c_read(dev, addr, read_buf, len,
537 FT260_FLAG_START_STOP);
538 if (ret < 0)
539 return ret;
540
541 left_len -= len;
542 read_buf += len;
543 read_off += len;
544
545 } while (left_len > 0);
546
547 return 0;
548}
549
550static int ft260_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
551 int num)
552{
553 int ret;
554 struct ft260_device *dev = i2c_get_adapdata(adapter);
555 struct hid_device *hdev = dev->hdev;
556
557 mutex_lock(&dev->lock);
558
559 ret = hid_hw_power(hdev, PM_HINT_FULLON);
560 if (ret < 0) {
561 hid_err(hdev, "failed to enter FULLON power mode: %d\n", ret);
562 mutex_unlock(&dev->lock);
563 return ret;
564 }
565
566 if (num == 1) {
567 if (msgs->flags & I2C_M_RD)
568 ret = ft260_i2c_read(dev, msgs->addr, msgs->buf,
569 msgs->len, FT260_FLAG_START_STOP);
570 else
571 ret = ft260_i2c_write(dev, msgs->addr, msgs->buf,
572 msgs->len, FT260_FLAG_START_STOP);
573 if (ret < 0)
574 goto i2c_exit;
575
576 } else {
577 /* Combined write then read message */
578 ret = ft260_i2c_write_read(dev, msgs);
579 if (ret < 0)
580 goto i2c_exit;
581 }
582
583 ret = num;
584i2c_exit:
585 hid_hw_power(hdev, PM_HINT_NORMAL);
586 mutex_unlock(&dev->lock);
587 return ret;
588}
589
590static int ft260_smbus_xfer(struct i2c_adapter *adapter, u16 addr, u16 flags,
591 char read_write, u8 cmd, int size,
592 union i2c_smbus_data *data)
593{
594 int ret;
595 struct ft260_device *dev = i2c_get_adapdata(adapter);
596 struct hid_device *hdev = dev->hdev;
597
598 ft260_dbg("smbus size %d\n", size);
599
600 mutex_lock(&dev->lock);
601
602 ret = hid_hw_power(hdev, PM_HINT_FULLON);
603 if (ret < 0) {
604 hid_err(hdev, "power management error: %d\n", ret);
605 mutex_unlock(&dev->lock);
606 return ret;
607 }
608
609 switch (size) {
610 case I2C_SMBUS_QUICK:
611 if (read_write == I2C_SMBUS_READ)
612 ret = ft260_i2c_read(dev, addr, &data->byte, 0,
613 FT260_FLAG_START_STOP);
614 else
615 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
616 FT260_FLAG_START_STOP);
617 break;
618 case I2C_SMBUS_BYTE:
619 if (read_write == I2C_SMBUS_READ)
620 ret = ft260_i2c_read(dev, addr, &data->byte, 1,
621 FT260_FLAG_START_STOP);
622 else
623 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
624 FT260_FLAG_START_STOP);
625 break;
626 case I2C_SMBUS_BYTE_DATA:
627 if (read_write == I2C_SMBUS_READ) {
628 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
629 FT260_FLAG_START);
630 if (ret)
631 goto smbus_exit;
632
633 ret = ft260_i2c_read(dev, addr, &data->byte, 1,
634 FT260_FLAG_START_STOP_REPEATED);
635 } else {
636 ret = ft260_smbus_write(dev, addr, cmd, &data->byte, 1,
637 FT260_FLAG_START_STOP);
638 }
639 break;
640 case I2C_SMBUS_WORD_DATA:
641 if (read_write == I2C_SMBUS_READ) {
642 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
643 FT260_FLAG_START);
644 if (ret)
645 goto smbus_exit;
646
647 ret = ft260_i2c_read(dev, addr, (u8 *)&data->word, 2,
648 FT260_FLAG_START_STOP_REPEATED);
649 } else {
650 ret = ft260_smbus_write(dev, addr, cmd,
651 (u8 *)&data->word, 2,
652 FT260_FLAG_START_STOP);
653 }
654 break;
655 case I2C_SMBUS_BLOCK_DATA:
656 if (read_write == I2C_SMBUS_READ) {
657 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
658 FT260_FLAG_START);
659 if (ret)
660 goto smbus_exit;
661
662 ret = ft260_i2c_read(dev, addr, data->block,
663 data->block[0] + 1,
664 FT260_FLAG_START_STOP_REPEATED);
665 } else {
666 ret = ft260_smbus_write(dev, addr, cmd, data->block,
667 data->block[0] + 1,
668 FT260_FLAG_START_STOP);
669 }
670 break;
671 case I2C_SMBUS_I2C_BLOCK_DATA:
672 if (read_write == I2C_SMBUS_READ) {
673 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
674 FT260_FLAG_START);
675 if (ret)
676 goto smbus_exit;
677
678 ret = ft260_i2c_read(dev, addr, data->block + 1,
679 data->block[0],
680 FT260_FLAG_START_STOP_REPEATED);
681 } else {
682 ret = ft260_smbus_write(dev, addr, cmd, data->block + 1,
683 data->block[0],
684 FT260_FLAG_START_STOP);
685 }
686 break;
687 default:
688 hid_err(hdev, "unsupported smbus transaction size %d\n", size);
689 ret = -EOPNOTSUPP;
690 }
691
692smbus_exit:
693 hid_hw_power(hdev, PM_HINT_NORMAL);
694 mutex_unlock(&dev->lock);
695 return ret;
696}
697
698static u32 ft260_functionality(struct i2c_adapter *adap)
699{
700 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_QUICK |
701 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
702 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_I2C_BLOCK;
703}
704
705static const struct i2c_adapter_quirks ft260_i2c_quirks = {
706 .flags = I2C_AQ_COMB_WRITE_THEN_READ,
707 .max_comb_1st_msg_len = 2,
708};
709
710static const struct i2c_algorithm ft260_i2c_algo = {
711 .master_xfer = ft260_i2c_xfer,
712 .smbus_xfer = ft260_smbus_xfer,
713 .functionality = ft260_functionality,
714};
715
716static int ft260_get_system_config(struct hid_device *hdev,
717 struct ft260_get_system_status_report *cfg)
718{
719 int ret;
720 int len = sizeof(struct ft260_get_system_status_report);
721
722 ret = ft260_hid_feature_report_get(hdev, FT260_SYSTEM_SETTINGS,
723 (u8 *)cfg, len);
724 if (ret != len) {
725 hid_err(hdev, "failed to retrieve system status\n");
726 if (ret >= 0)
727 return -EIO;
728 }
729 return 0;
730}
731
732static int ft260_is_interface_enabled(struct hid_device *hdev)
733{
734 struct ft260_get_system_status_report cfg;
735 struct usb_interface *usbif = to_usb_interface(hdev->dev.parent);
736 int interface = usbif->cur_altsetting->desc.bInterfaceNumber;
737 int ret;
738
739 ret = ft260_get_system_config(hdev, &cfg);
740 if (ret)
741 return ret;
742
743 ft260_dbg("interface: 0x%02x\n", interface);
744 ft260_dbg("chip mode: 0x%02x\n", cfg.chip_mode);
745 ft260_dbg("clock_ctl: 0x%02x\n", cfg.clock_ctl);
746 ft260_dbg("i2c_enable: 0x%02x\n", cfg.i2c_enable);
747 ft260_dbg("uart_mode: 0x%02x\n", cfg.uart_mode);
748
749 switch (cfg.chip_mode) {
750 case FT260_MODE_ALL:
751 case FT260_MODE_BOTH:
752 if (interface == 1) {
753 hid_info(hdev, "uart interface is not supported\n");
754 return 0;
755 }
756 ret = 1;
757 break;
758 case FT260_MODE_UART:
759 if (interface == 0) {
760 hid_info(hdev, "uart is unsupported on interface 0\n");
761 ret = 0;
762 }
763 break;
764 case FT260_MODE_I2C:
765 if (interface == 1) {
766 hid_info(hdev, "i2c is unsupported on interface 1\n");
767 ret = 0;
768 }
769 break;
770 }
771 return ret;
772}
773
774static int ft260_byte_show(struct hid_device *hdev, int id, u8 *cfg, int len,
775 u8 *field, u8 *buf)
776{
777 int ret;
778
779 ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
780 if (ret != len && ret >= 0)
781 return -EIO;
782
783 return scnprintf(buf, PAGE_SIZE, "%hi\n", *field);
784}
785
786static int ft260_word_show(struct hid_device *hdev, int id, u8 *cfg, int len,
787 u16 *field, u8 *buf)
788{
789 int ret;
790
791 ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
792 if (ret != len && ret >= 0)
793 return -EIO;
794
795 return scnprintf(buf, PAGE_SIZE, "%hi\n", le16_to_cpu(*field));
796}
797
798#define FT260_ATTR_SHOW(name, reptype, id, type, func) \
799 static ssize_t name##_show(struct device *kdev, \
800 struct device_attribute *attr, char *buf) \
801 { \
802 struct reptype rep; \
803 struct hid_device *hdev = to_hid_device(kdev); \
804 type *field = &rep.name; \
805 int len = sizeof(rep); \
806 \
807 return func(hdev, id, (u8 *)&rep, len, field, buf); \
808 }
809
810#define FT260_SSTAT_ATTR_SHOW(name) \
811 FT260_ATTR_SHOW(name, ft260_get_system_status_report, \
812 FT260_SYSTEM_SETTINGS, u8, ft260_byte_show)
813
814#define FT260_I2CST_ATTR_SHOW(name) \
815 FT260_ATTR_SHOW(name, ft260_get_i2c_status_report, \
816 FT260_I2C_STATUS, u16, ft260_word_show)
817
818#define FT260_ATTR_STORE(name, reptype, id, req, type, func) \
819 static ssize_t name##_store(struct device *kdev, \
820 struct device_attribute *attr, \
821 const char *buf, size_t count) \
822 { \
823 struct reptype rep; \
824 struct hid_device *hdev = to_hid_device(kdev); \
825 type name; \
826 int ret; \
827 \
828 if (!func(buf, 10, &name)) { \
829 rep.name = name; \
830 rep.report = id; \
831 rep.request = req; \
832 ret = ft260_hid_feature_report_set(hdev, (u8 *)&rep, \
833 sizeof(rep)); \
834 if (!ret) \
835 ret = count; \
836 } else { \
837 ret = -EINVAL; \
838 } \
839 return ret; \
840 }
841
842#define FT260_BYTE_ATTR_STORE(name, reptype, req) \
843 FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req, \
844 u8, kstrtou8)
845
846#define FT260_WORD_ATTR_STORE(name, reptype, req) \
847 FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req, \
848 u16, kstrtou16)
849
850FT260_SSTAT_ATTR_SHOW(chip_mode);
851static DEVICE_ATTR_RO(chip_mode);
852
853FT260_SSTAT_ATTR_SHOW(pwren_status);
854static DEVICE_ATTR_RO(pwren_status);
855
856FT260_SSTAT_ATTR_SHOW(suspend_status);
857static DEVICE_ATTR_RO(suspend_status);
858
859FT260_SSTAT_ATTR_SHOW(hid_over_i2c_en);
860static DEVICE_ATTR_RO(hid_over_i2c_en);
861
862FT260_SSTAT_ATTR_SHOW(power_saving_en);
863static DEVICE_ATTR_RO(power_saving_en);
864
865FT260_SSTAT_ATTR_SHOW(i2c_enable);
866FT260_BYTE_ATTR_STORE(i2c_enable, ft260_set_i2c_mode_report,
867 FT260_SET_I2C_MODE);
868static DEVICE_ATTR_RW(i2c_enable);
869
870FT260_SSTAT_ATTR_SHOW(uart_mode);
871FT260_BYTE_ATTR_STORE(uart_mode, ft260_set_uart_mode_report,
872 FT260_SET_UART_MODE);
873static DEVICE_ATTR_RW(uart_mode);
874
875FT260_SSTAT_ATTR_SHOW(clock_ctl);
876FT260_BYTE_ATTR_STORE(clock_ctl, ft260_set_system_clock_report,
877 FT260_SET_CLOCK);
878static DEVICE_ATTR_RW(clock_ctl);
879
880FT260_I2CST_ATTR_SHOW(clock);
881FT260_WORD_ATTR_STORE(clock, ft260_set_i2c_speed_report,
882 FT260_SET_I2C_CLOCK_SPEED);
883static DEVICE_ATTR_RW(clock);
884
885static ssize_t i2c_reset_store(struct device *kdev,
886 struct device_attribute *attr, const char *buf,
887 size_t count)
888{
889 struct hid_device *hdev = to_hid_device(kdev);
890 int ret = ft260_i2c_reset(hdev);
891
892 if (ret)
893 return ret;
894 return count;
895}
896static DEVICE_ATTR_WO(i2c_reset);
897
898static const struct attribute_group ft260_attr_group = {
899 .attrs = (struct attribute *[]) {
900 &dev_attr_chip_mode.attr,
901 &dev_attr_pwren_status.attr,
902 &dev_attr_suspend_status.attr,
903 &dev_attr_hid_over_i2c_en.attr,
904 &dev_attr_power_saving_en.attr,
905 &dev_attr_i2c_enable.attr,
906 &dev_attr_uart_mode.attr,
907 &dev_attr_clock_ctl.attr,
908 &dev_attr_i2c_reset.attr,
909 &dev_attr_clock.attr,
910 NULL
911 }
912};
913
914static int ft260_probe(struct hid_device *hdev, const struct hid_device_id *id)
915{
916 struct ft260_device *dev;
917 struct ft260_get_chip_version_report version;
918 int ret;
919
920 dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
921 if (!dev)
922 return -ENOMEM;
923
924 ret = hid_parse(hdev);
925 if (ret) {
926 hid_err(hdev, "failed to parse HID\n");
927 return ret;
928 }
929
930 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
931 if (ret) {
932 hid_err(hdev, "failed to start HID HW\n");
933 return ret;
934 }
935
936 ret = hid_hw_open(hdev);
937 if (ret) {
938 hid_err(hdev, "failed to open HID HW\n");
939 goto err_hid_stop;
940 }
941
942 ret = ft260_hid_feature_report_get(hdev, FT260_CHIP_VERSION,
943 (u8 *)&version, sizeof(version));
944 if (ret != sizeof(version)) {
945 hid_err(hdev, "failed to retrieve chip version\n");
946 if (ret >= 0)
947 ret = -EIO;
948 goto err_hid_close;
949 }
950
951 hid_info(hdev, "chip code: %02x%02x %02x%02x\n",
952 version.chip_code[0], version.chip_code[1],
953 version.chip_code[2], version.chip_code[3]);
954
955 ret = ft260_is_interface_enabled(hdev);
956 if (ret <= 0)
957 goto err_hid_close;
958
959 hid_set_drvdata(hdev, dev);
960 dev->hdev = hdev;
961 dev->adap.owner = THIS_MODULE;
962 dev->adap.class = I2C_CLASS_HWMON;
963 dev->adap.algo = &ft260_i2c_algo;
964 dev->adap.quirks = &ft260_i2c_quirks;
965 dev->adap.dev.parent = &hdev->dev;
966 snprintf(dev->adap.name, sizeof(dev->adap.name),
967 "FT260 usb-i2c bridge on hidraw%d",
968 ((struct hidraw *)hdev->hidraw)->minor);
969
970 mutex_init(&dev->lock);
971 init_completion(&dev->wait);
972
973 ret = i2c_add_adapter(&dev->adap);
974 if (ret) {
975 hid_err(hdev, "failed to add i2c adapter\n");
976 goto err_hid_close;
977 }
978
979 i2c_set_adapdata(&dev->adap, dev);
980
981 ret = sysfs_create_group(&hdev->dev.kobj, &ft260_attr_group);
982 if (ret < 0) {
983 hid_err(hdev, "failed to create sysfs attrs\n");
984 goto err_i2c_free;
985 }
986
987 ret = ft260_xfer_status(dev);
988 if (ret)
989 ft260_i2c_reset(hdev);
990
991 return 0;
992
993err_i2c_free:
994 i2c_del_adapter(&dev->adap);
995err_hid_close:
996 hid_hw_close(hdev);
997err_hid_stop:
998 hid_hw_stop(hdev);
999 return ret;
1000}
1001
1002static void ft260_remove(struct hid_device *hdev)
1003{
1004 int ret;
1005 struct ft260_device *dev = hid_get_drvdata(hdev);
1006
1007 ret = ft260_is_interface_enabled(hdev);
1008 if (ret <= 0)
1009 return;
1010
1011 sysfs_remove_group(&hdev->dev.kobj, &ft260_attr_group);
1012 i2c_del_adapter(&dev->adap);
1013
1014 hid_hw_close(hdev);
1015 hid_hw_stop(hdev);
1016}
1017
1018static int ft260_raw_event(struct hid_device *hdev, struct hid_report *report,
1019 u8 *data, int size)
1020{
1021 struct ft260_device *dev = hid_get_drvdata(hdev);
1022 struct ft260_i2c_input_report *xfer = (void *)data;
1023
1024 if (xfer->report >= FT260_I2C_REPORT_MIN &&
1025 xfer->report <= FT260_I2C_REPORT_MAX) {
1026 ft260_dbg("i2c resp: rep %#02x len %d\n", xfer->report,
1027 xfer->length);
1028
1029 memcpy(&dev->read_buf[dev->read_idx], &xfer->data,
1030 xfer->length);
1031 dev->read_idx += xfer->length;
1032
1033 if (dev->read_idx == dev->read_len)
1034 complete(&dev->wait);
1035
1036 } else {
1037 hid_err(hdev, "unknown report: %#02x\n", xfer->report);
1038 return 0;
1039 }
1040 return 1;
1041}
1042
1043static struct hid_driver ft260_driver = {
1044 .name = "ft260",
1045 .id_table = ft260_devices,
1046 .probe = ft260_probe,
1047 .remove = ft260_remove,
1048 .raw_event = ft260_raw_event,
1049};
1050
1051module_hid_driver(ft260_driver);
1052MODULE_DESCRIPTION("FTDI FT260 USB HID to I2C host bridge");
1053MODULE_AUTHOR("Michael Zaidman <michael.zaidman@gmail.com>");
1054MODULE_LICENSE("GPL v2");
Linux 6.x block layer and io_uring tree(s)