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