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 /* 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) 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 */ 54 enum { 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 */ 62 enum { 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 */ 71 enum { 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 */ 86 enum { 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 */ 112 enum { 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 */ 124 enum { 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 137 struct 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 143 struct 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 165 struct 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 174 struct 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 180 struct 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 186 struct 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 193 struct ft260_set_i2c_reset_report { 194 u8 report; /* FT260_SYSTEM_SETTINGS */ 195 u8 request; /* FT260_SET_I2C_RESET */ 196 } __packed; 197 198 struct 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 206 struct 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 */ 211 u8 data[FT260_WR_DATA_MAX]; /* data payload */ 212 } __packed; 213 214 struct 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 221 struct 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 227 static 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 }; 232 MODULE_DEVICE_TABLE(hid, ft260_devices); 233 234 struct 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 246 static 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); 259 if (likely(ret == len)) 260 memcpy(data, buf, len); 261 else if (ret >= 0) 262 ret = -EIO; 263 kfree(buf); 264 return ret; 265 } 266 267 static 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 286 static 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 303 static 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)); 311 if (unlikely(ret < 0)) { 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 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); 330 return -EIO; 331 } 332 333 return 0; 334 } 335 336 static 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 352 static int ft260_hid_output_report_check_status(struct ft260_device *dev, 353 u8 *data, int len) 354 { 355 int ret, usec, try = 100; 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) * 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 374 do { 375 ret = ft260_xfer_status(dev); 376 if (ret != -EAGAIN) 377 break; 378 } while (--try); 379 380 if (ret == 0) 381 return 0; 382 383 ft260_i2c_reset(hdev); 384 return -EIO; 385 } 386 387 static int ft260_i2c_write(struct ft260_device *dev, u8 addr, u8 *data, 388 int len, u8 flag) 389 { 390 int ret, wr_len, idx = 0; 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 395 rep->flag = FT260_FLAG_START; 396 397 do { 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 } 405 406 rep->report = FT260_I2C_DATA_REPORT_ID(wr_len); 407 rep->address = addr; 408 rep->length = wr_len; 409 410 memcpy(rep->data, &data[idx], wr_len); 411 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]); 415 416 ret = ft260_hid_output_report_check_status(dev, (u8 *)rep, 417 wr_len + 4); 418 if (ret < 0) { 419 hid_err(hdev, "%s: failed with %d\n", __func__, ret); 420 return ret; 421 } 422 423 len -= wr_len; 424 idx += wr_len; 425 rep->flag = 0; 426 427 } while (len > 0); 428 429 return 0; 430 } 431 432 static 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 441 if (data_len >= sizeof(rep->data)) 442 return -EINVAL; 443 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 463 static int ft260_i2c_read(struct ft260_device *dev, u8 addr, u8 *data, 464 u16 len, u8 flag) 465 { 466 u16 rd_len; 467 int timeout, ret = 0; 468 struct ft260_i2c_read_request_report rep; 469 struct hid_device *hdev = dev->hdev; 470 471 if ((flag & FT260_FLAG_START_REPEATED) == FT260_FLAG_START_REPEATED) 472 flag = FT260_FLAG_START_REPEATED; 473 else 474 flag = FT260_FLAG_START; 475 do { 476 if (len <= FT260_RD_DATA_MAX) { 477 rd_len = len; 478 flag |= FT260_FLAG_STOP; 479 } else { 480 rd_len = FT260_RD_DATA_MAX; 481 } 482 483 rep.report = FT260_I2C_READ_REQ; 484 rep.length = cpu_to_le16(rd_len); 485 rep.address = addr; 486 rep.flag = flag; 487 488 ft260_dbg("rep %#02x addr %#02x len %d rlen %d flag %#x\n", 489 rep.report, rep.address, len, rd_len, flag); 490 491 reinit_completion(&dev->wait); 492 493 dev->read_idx = 0; 494 dev->read_buf = data; 495 dev->read_len = rd_len; 496 497 ret = ft260_hid_output_report(hdev, (u8 *)&rep, sizeof(rep)); 498 if (ret < 0) { 499 hid_err(hdev, "%s: failed with %d\n", __func__, ret); 500 goto ft260_i2c_read_exit; 501 } 502 503 timeout = msecs_to_jiffies(5000); 504 if (!wait_for_completion_timeout(&dev->wait, timeout)) { 505 ret = -ETIMEDOUT; 506 ft260_i2c_reset(hdev); 507 goto ft260_i2c_read_exit; 508 } 509 510 dev->read_buf = NULL; 511 512 ret = ft260_xfer_status(dev); 513 if (ret < 0) { 514 ret = -EIO; 515 ft260_i2c_reset(hdev); 516 goto ft260_i2c_read_exit; 517 } 518 519 len -= rd_len; 520 data += rd_len; 521 flag = 0; 522 523 } while (len > 0); 524 525 ft260_i2c_read_exit: 526 dev->read_buf = NULL; 527 return ret; 528 } 529 530 /* 531 * A random read operation is implemented as a dummy write operation, followed 532 * by a current address read operation. The dummy write operation is used to 533 * load the target byte address into the current byte address counter, from 534 * which the subsequent current address read operation then reads. 535 */ 536 static int ft260_i2c_write_read(struct ft260_device *dev, struct i2c_msg *msgs) 537 { 538 int ret; 539 int wr_len = msgs[0].len; 540 int rd_len = msgs[1].len; 541 struct hid_device *hdev = dev->hdev; 542 u8 addr = msgs[0].addr; 543 u16 read_off = 0; 544 545 if (wr_len > 2) { 546 hid_err(hdev, "%s: invalid wr_len: %d\n", __func__, wr_len); 547 return -EOPNOTSUPP; 548 } 549 550 if (ft260_debug) { 551 if (wr_len == 2) 552 read_off = be16_to_cpu(*(u16 *)msgs[0].buf); 553 else 554 read_off = *msgs[0].buf; 555 556 pr_info("%s: off %#x rlen %d wlen %d\n", __func__, 557 read_off, rd_len, wr_len); 558 } 559 560 ret = ft260_i2c_write(dev, addr, msgs[0].buf, wr_len, 561 FT260_FLAG_START); 562 if (ret < 0) 563 return ret; 564 565 ret = ft260_i2c_read(dev, addr, msgs[1].buf, rd_len, 566 FT260_FLAG_START_STOP_REPEATED); 567 if (ret < 0) 568 return ret; 569 570 return 0; 571 } 572 573 static int ft260_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, 574 int num) 575 { 576 int ret; 577 struct ft260_device *dev = i2c_get_adapdata(adapter); 578 struct hid_device *hdev = dev->hdev; 579 580 mutex_lock(&dev->lock); 581 582 ret = hid_hw_power(hdev, PM_HINT_FULLON); 583 if (ret < 0) { 584 hid_err(hdev, "failed to enter FULLON power mode: %d\n", ret); 585 mutex_unlock(&dev->lock); 586 return ret; 587 } 588 589 if (num == 1) { 590 if (msgs->flags & I2C_M_RD) 591 ret = ft260_i2c_read(dev, msgs->addr, msgs->buf, 592 msgs->len, FT260_FLAG_START_STOP); 593 else 594 ret = ft260_i2c_write(dev, msgs->addr, msgs->buf, 595 msgs->len, FT260_FLAG_START_STOP); 596 if (ret < 0) 597 goto i2c_exit; 598 599 } else { 600 /* Combined write then read message */ 601 ret = ft260_i2c_write_read(dev, msgs); 602 if (ret < 0) 603 goto i2c_exit; 604 } 605 606 ret = num; 607 i2c_exit: 608 hid_hw_power(hdev, PM_HINT_NORMAL); 609 mutex_unlock(&dev->lock); 610 return ret; 611 } 612 613 static int ft260_smbus_xfer(struct i2c_adapter *adapter, u16 addr, u16 flags, 614 char read_write, u8 cmd, int size, 615 union i2c_smbus_data *data) 616 { 617 int ret; 618 struct ft260_device *dev = i2c_get_adapdata(adapter); 619 struct hid_device *hdev = dev->hdev; 620 621 ft260_dbg("smbus size %d\n", size); 622 623 mutex_lock(&dev->lock); 624 625 ret = hid_hw_power(hdev, PM_HINT_FULLON); 626 if (ret < 0) { 627 hid_err(hdev, "power management error: %d\n", ret); 628 mutex_unlock(&dev->lock); 629 return ret; 630 } 631 632 switch (size) { 633 case I2C_SMBUS_BYTE: 634 if (read_write == I2C_SMBUS_READ) 635 ret = ft260_i2c_read(dev, addr, &data->byte, 1, 636 FT260_FLAG_START_STOP); 637 else 638 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0, 639 FT260_FLAG_START_STOP); 640 break; 641 case I2C_SMBUS_BYTE_DATA: 642 if (read_write == I2C_SMBUS_READ) { 643 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0, 644 FT260_FLAG_START); 645 if (ret) 646 goto smbus_exit; 647 648 ret = ft260_i2c_read(dev, addr, &data->byte, 1, 649 FT260_FLAG_START_STOP_REPEATED); 650 } else { 651 ret = ft260_smbus_write(dev, addr, cmd, &data->byte, 1, 652 FT260_FLAG_START_STOP); 653 } 654 break; 655 case I2C_SMBUS_WORD_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, (u8 *)&data->word, 2, 663 FT260_FLAG_START_STOP_REPEATED); 664 } else { 665 ret = ft260_smbus_write(dev, addr, cmd, 666 (u8 *)&data->word, 2, 667 FT260_FLAG_START_STOP); 668 } 669 break; 670 case I2C_SMBUS_BLOCK_DATA: 671 if (read_write == I2C_SMBUS_READ) { 672 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0, 673 FT260_FLAG_START); 674 if (ret) 675 goto smbus_exit; 676 677 ret = ft260_i2c_read(dev, addr, data->block, 678 data->block[0] + 1, 679 FT260_FLAG_START_STOP_REPEATED); 680 } else { 681 ret = ft260_smbus_write(dev, addr, cmd, data->block, 682 data->block[0] + 1, 683 FT260_FLAG_START_STOP); 684 } 685 break; 686 case I2C_SMBUS_I2C_BLOCK_DATA: 687 if (read_write == I2C_SMBUS_READ) { 688 ret = ft260_smbus_write(dev, addr, cmd, NULL, 0, 689 FT260_FLAG_START); 690 if (ret) 691 goto smbus_exit; 692 693 ret = ft260_i2c_read(dev, addr, data->block + 1, 694 data->block[0], 695 FT260_FLAG_START_STOP_REPEATED); 696 } else { 697 ret = ft260_smbus_write(dev, addr, cmd, data->block + 1, 698 data->block[0], 699 FT260_FLAG_START_STOP); 700 } 701 break; 702 default: 703 hid_err(hdev, "unsupported smbus transaction size %d\n", size); 704 ret = -EOPNOTSUPP; 705 } 706 707 smbus_exit: 708 hid_hw_power(hdev, PM_HINT_NORMAL); 709 mutex_unlock(&dev->lock); 710 return ret; 711 } 712 713 static u32 ft260_functionality(struct i2c_adapter *adap) 714 { 715 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE | 716 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 717 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_I2C_BLOCK; 718 } 719 720 static const struct i2c_adapter_quirks ft260_i2c_quirks = { 721 .flags = I2C_AQ_COMB_WRITE_THEN_READ, 722 .max_comb_1st_msg_len = 2, 723 }; 724 725 static const struct i2c_algorithm ft260_i2c_algo = { 726 .master_xfer = ft260_i2c_xfer, 727 .smbus_xfer = ft260_smbus_xfer, 728 .functionality = ft260_functionality, 729 }; 730 731 static int ft260_get_system_config(struct hid_device *hdev, 732 struct ft260_get_system_status_report *cfg) 733 { 734 int ret; 735 int len = sizeof(struct ft260_get_system_status_report); 736 737 ret = ft260_hid_feature_report_get(hdev, FT260_SYSTEM_SETTINGS, 738 (u8 *)cfg, len); 739 if (ret < 0) { 740 hid_err(hdev, "failed to retrieve system status\n"); 741 return ret; 742 } 743 return 0; 744 } 745 746 static int ft260_is_interface_enabled(struct hid_device *hdev) 747 { 748 struct ft260_get_system_status_report cfg; 749 struct usb_interface *usbif = to_usb_interface(hdev->dev.parent); 750 int interface = usbif->cur_altsetting->desc.bInterfaceNumber; 751 int ret; 752 753 ret = ft260_get_system_config(hdev, &cfg); 754 if (ret < 0) 755 return ret; 756 757 ft260_dbg("interface: 0x%02x\n", interface); 758 ft260_dbg("chip mode: 0x%02x\n", cfg.chip_mode); 759 ft260_dbg("clock_ctl: 0x%02x\n", cfg.clock_ctl); 760 ft260_dbg("i2c_enable: 0x%02x\n", cfg.i2c_enable); 761 ft260_dbg("uart_mode: 0x%02x\n", cfg.uart_mode); 762 763 switch (cfg.chip_mode) { 764 case FT260_MODE_ALL: 765 case FT260_MODE_BOTH: 766 if (interface == 1) 767 hid_info(hdev, "uart interface is not supported\n"); 768 else 769 ret = 1; 770 break; 771 case FT260_MODE_UART: 772 hid_info(hdev, "uart interface is not supported\n"); 773 break; 774 case FT260_MODE_I2C: 775 ret = 1; 776 break; 777 } 778 return ret; 779 } 780 781 static int ft260_byte_show(struct hid_device *hdev, int id, u8 *cfg, int len, 782 u8 *field, u8 *buf) 783 { 784 int ret; 785 786 ret = ft260_hid_feature_report_get(hdev, id, cfg, len); 787 if (ret < 0) 788 return ret; 789 790 return scnprintf(buf, PAGE_SIZE, "%d\n", *field); 791 } 792 793 static int ft260_word_show(struct hid_device *hdev, int id, u8 *cfg, int len, 794 u16 *field, u8 *buf) 795 { 796 int ret; 797 798 ret = ft260_hid_feature_report_get(hdev, id, cfg, len); 799 if (ret < 0) 800 return ret; 801 802 return scnprintf(buf, PAGE_SIZE, "%d\n", le16_to_cpu(*field)); 803 } 804 805 #define FT260_ATTR_SHOW(name, reptype, id, type, func) \ 806 static ssize_t name##_show(struct device *kdev, \ 807 struct device_attribute *attr, char *buf) \ 808 { \ 809 struct reptype rep; \ 810 struct hid_device *hdev = to_hid_device(kdev); \ 811 type *field = &rep.name; \ 812 int len = sizeof(rep); \ 813 \ 814 return func(hdev, id, (u8 *)&rep, len, field, buf); \ 815 } 816 817 #define FT260_SSTAT_ATTR_SHOW(name) \ 818 FT260_ATTR_SHOW(name, ft260_get_system_status_report, \ 819 FT260_SYSTEM_SETTINGS, u8, ft260_byte_show) 820 821 #define FT260_I2CST_ATTR_SHOW(name) \ 822 FT260_ATTR_SHOW(name, ft260_get_i2c_status_report, \ 823 FT260_I2C_STATUS, u16, ft260_word_show) 824 825 #define FT260_ATTR_STORE(name, reptype, id, req, type, func) \ 826 static ssize_t name##_store(struct device *kdev, \ 827 struct device_attribute *attr, \ 828 const char *buf, size_t count) \ 829 { \ 830 struct reptype rep; \ 831 struct hid_device *hdev = to_hid_device(kdev); \ 832 type name; \ 833 int ret; \ 834 \ 835 if (!func(buf, 10, &name)) { \ 836 rep.name = name; \ 837 rep.report = id; \ 838 rep.request = req; \ 839 ret = ft260_hid_feature_report_set(hdev, (u8 *)&rep, \ 840 sizeof(rep)); \ 841 if (!ret) \ 842 ret = count; \ 843 } else { \ 844 ret = -EINVAL; \ 845 } \ 846 return ret; \ 847 } 848 849 #define FT260_BYTE_ATTR_STORE(name, reptype, req) \ 850 FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req, \ 851 u8, kstrtou8) 852 853 #define FT260_WORD_ATTR_STORE(name, reptype, req) \ 854 FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req, \ 855 u16, kstrtou16) 856 857 FT260_SSTAT_ATTR_SHOW(chip_mode); 858 static DEVICE_ATTR_RO(chip_mode); 859 860 FT260_SSTAT_ATTR_SHOW(pwren_status); 861 static DEVICE_ATTR_RO(pwren_status); 862 863 FT260_SSTAT_ATTR_SHOW(suspend_status); 864 static DEVICE_ATTR_RO(suspend_status); 865 866 FT260_SSTAT_ATTR_SHOW(hid_over_i2c_en); 867 static DEVICE_ATTR_RO(hid_over_i2c_en); 868 869 FT260_SSTAT_ATTR_SHOW(power_saving_en); 870 static DEVICE_ATTR_RO(power_saving_en); 871 872 FT260_SSTAT_ATTR_SHOW(i2c_enable); 873 FT260_BYTE_ATTR_STORE(i2c_enable, ft260_set_i2c_mode_report, 874 FT260_SET_I2C_MODE); 875 static DEVICE_ATTR_RW(i2c_enable); 876 877 FT260_SSTAT_ATTR_SHOW(uart_mode); 878 FT260_BYTE_ATTR_STORE(uart_mode, ft260_set_uart_mode_report, 879 FT260_SET_UART_MODE); 880 static DEVICE_ATTR_RW(uart_mode); 881 882 FT260_SSTAT_ATTR_SHOW(clock_ctl); 883 FT260_BYTE_ATTR_STORE(clock_ctl, ft260_set_system_clock_report, 884 FT260_SET_CLOCK); 885 static DEVICE_ATTR_RW(clock_ctl); 886 887 FT260_I2CST_ATTR_SHOW(clock); 888 FT260_WORD_ATTR_STORE(clock, ft260_set_i2c_speed_report, 889 FT260_SET_I2C_CLOCK_SPEED); 890 static DEVICE_ATTR_RW(clock); 891 892 static ssize_t i2c_reset_store(struct device *kdev, 893 struct device_attribute *attr, const char *buf, 894 size_t count) 895 { 896 struct hid_device *hdev = to_hid_device(kdev); 897 int ret = ft260_i2c_reset(hdev); 898 899 if (ret) 900 return ret; 901 return count; 902 } 903 static DEVICE_ATTR_WO(i2c_reset); 904 905 static const struct attribute_group ft260_attr_group = { 906 .attrs = (struct attribute *[]) { 907 &dev_attr_chip_mode.attr, 908 &dev_attr_pwren_status.attr, 909 &dev_attr_suspend_status.attr, 910 &dev_attr_hid_over_i2c_en.attr, 911 &dev_attr_power_saving_en.attr, 912 &dev_attr_i2c_enable.attr, 913 &dev_attr_uart_mode.attr, 914 &dev_attr_clock_ctl.attr, 915 &dev_attr_i2c_reset.attr, 916 &dev_attr_clock.attr, 917 NULL 918 } 919 }; 920 921 static int ft260_probe(struct hid_device *hdev, const struct hid_device_id *id) 922 { 923 struct ft260_device *dev; 924 struct ft260_get_chip_version_report version; 925 int ret; 926 927 if (!hid_is_usb(hdev)) 928 return -EINVAL; 929 930 dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL); 931 if (!dev) 932 return -ENOMEM; 933 934 ret = hid_parse(hdev); 935 if (ret) { 936 hid_err(hdev, "failed to parse HID\n"); 937 return ret; 938 } 939 940 ret = hid_hw_start(hdev, 0); 941 if (ret) { 942 hid_err(hdev, "failed to start HID HW\n"); 943 return ret; 944 } 945 946 ret = hid_hw_open(hdev); 947 if (ret) { 948 hid_err(hdev, "failed to open HID HW\n"); 949 goto err_hid_stop; 950 } 951 952 ret = ft260_hid_feature_report_get(hdev, FT260_CHIP_VERSION, 953 (u8 *)&version, sizeof(version)); 954 if (ret < 0) { 955 hid_err(hdev, "failed to retrieve chip version\n"); 956 goto err_hid_close; 957 } 958 959 hid_info(hdev, "chip code: %02x%02x %02x%02x\n", 960 version.chip_code[0], version.chip_code[1], 961 version.chip_code[2], version.chip_code[3]); 962 963 ret = ft260_is_interface_enabled(hdev); 964 if (ret <= 0) 965 goto err_hid_close; 966 967 hid_info(hdev, "USB HID v%x.%02x Device [%s] on %s\n", 968 hdev->version >> 8, hdev->version & 0xff, hdev->name, 969 hdev->phys); 970 971 hid_set_drvdata(hdev, dev); 972 dev->hdev = hdev; 973 dev->adap.owner = THIS_MODULE; 974 dev->adap.class = I2C_CLASS_HWMON; 975 dev->adap.algo = &ft260_i2c_algo; 976 dev->adap.quirks = &ft260_i2c_quirks; 977 dev->adap.dev.parent = &hdev->dev; 978 snprintf(dev->adap.name, sizeof(dev->adap.name), 979 "FT260 usb-i2c bridge"); 980 981 mutex_init(&dev->lock); 982 init_completion(&dev->wait); 983 984 ret = ft260_xfer_status(dev); 985 if (ret) 986 ft260_i2c_reset(hdev); 987 988 i2c_set_adapdata(&dev->adap, dev); 989 ret = i2c_add_adapter(&dev->adap); 990 if (ret) { 991 hid_err(hdev, "failed to add i2c adapter\n"); 992 goto err_hid_close; 993 } 994 995 ret = sysfs_create_group(&hdev->dev.kobj, &ft260_attr_group); 996 if (ret < 0) { 997 hid_err(hdev, "failed to create sysfs attrs\n"); 998 goto err_i2c_free; 999 } 1000 1001 return 0; 1002 1003 err_i2c_free: 1004 i2c_del_adapter(&dev->adap); 1005 err_hid_close: 1006 hid_hw_close(hdev); 1007 err_hid_stop: 1008 hid_hw_stop(hdev); 1009 return ret; 1010 } 1011 1012 static void ft260_remove(struct hid_device *hdev) 1013 { 1014 struct ft260_device *dev = hid_get_drvdata(hdev); 1015 1016 if (!dev) 1017 return; 1018 1019 sysfs_remove_group(&hdev->dev.kobj, &ft260_attr_group); 1020 i2c_del_adapter(&dev->adap); 1021 1022 hid_hw_close(hdev); 1023 hid_hw_stop(hdev); 1024 } 1025 1026 static int ft260_raw_event(struct hid_device *hdev, struct hid_report *report, 1027 u8 *data, int size) 1028 { 1029 struct ft260_device *dev = hid_get_drvdata(hdev); 1030 struct ft260_i2c_input_report *xfer = (void *)data; 1031 1032 if (xfer->report >= FT260_I2C_REPORT_MIN && 1033 xfer->report <= FT260_I2C_REPORT_MAX) { 1034 ft260_dbg("i2c resp: rep %#02x len %d\n", xfer->report, 1035 xfer->length); 1036 1037 if ((dev->read_buf == NULL) || 1038 (xfer->length > dev->read_len - dev->read_idx)) { 1039 hid_err(hdev, "unexpected report %#02x, length %d\n", 1040 xfer->report, xfer->length); 1041 return -1; 1042 } 1043 1044 memcpy(&dev->read_buf[dev->read_idx], &xfer->data, 1045 xfer->length); 1046 dev->read_idx += xfer->length; 1047 1048 if (dev->read_idx == dev->read_len) 1049 complete(&dev->wait); 1050 1051 } else { 1052 hid_err(hdev, "unhandled report %#02x\n", xfer->report); 1053 } 1054 return 0; 1055 } 1056 1057 static struct hid_driver ft260_driver = { 1058 .name = "ft260", 1059 .id_table = ft260_devices, 1060 .probe = ft260_probe, 1061 .remove = ft260_remove, 1062 .raw_event = ft260_raw_event, 1063 }; 1064 1065 module_hid_driver(ft260_driver); 1066 MODULE_DESCRIPTION("FTDI FT260 USB HID to I2C host bridge"); 1067 MODULE_AUTHOR("Michael Zaidman <michael.zaidman@gmail.com>"); 1068 MODULE_LICENSE("GPL v2"); 1069