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