drivers/hid/hid-ft260.c

   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  * 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  */
  47 enum {
  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 */
  55 enum {
  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 */
  64 enum {
  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 */
  79 enum {
  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 */
 105 enum {
 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 */
 117 enum {
 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
 130 struct 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
 136 struct 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
 158 struct 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
 167 struct 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
 173 struct 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
 179 struct 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
 186 struct ft260_set_i2c_reset_report {
 187         u8 report;              /* FT260_SYSTEM_SETTINGS */
 188         u8 request;             /* FT260_SET_I2C_RESET */
 189 } __packed;
 190
 191 struct 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
 199 struct 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[FT260_WR_DATA_MAX]; /* data payload */
 205 } __packed;
 206
 207 struct 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
 214 struct 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
 220 static 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 };
 225 MODULE_DEVICE_TABLE(hid, ft260_devices);
 226
 227 struct 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
 239 static 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         if (likely(ret == len))
 253                 memcpy(data, buf, len);
 254         else if (ret >= 0)
 255                 ret = -EIO;
 256         kfree(buf);
 257         return ret;
 258 }
 259
 260 static int ft260_hid_feature_report_set(struct hid_device *hdev, u8 *data,
 261                                         size_t len)
 262 {
 263         u8 *buf;
 264         int ret;
 265
 266         buf = kmemdup(data, len, GFP_KERNEL);
 267         if (!buf)
 268                 return -ENOMEM;
 269
 270         buf[0] = FT260_SYSTEM_SETTINGS;
 271
 272         ret = hid_hw_raw_request(hdev, buf[0], buf, len, HID_FEATURE_REPORT,
 273                                  HID_REQ_SET_REPORT);
 274
 275         kfree(buf);
 276         return ret;
 277 }
 278
 279 static int ft260_i2c_reset(struct hid_device *hdev)
 280 {
 281         struct ft260_set_i2c_reset_report report;
 282         int ret;
 283
 284         report.request = FT260_SET_I2C_RESET;
 285
 286         ret = ft260_hid_feature_report_set(hdev, (u8 *)&report, sizeof(report));
 287         if (ret < 0) {
 288                 hid_err(hdev, "failed to reset I2C controller: %d\n", ret);
 289                 return ret;
 290         }
 291
 292         ft260_dbg("done\n");
 293         return ret;
 294 }
 295
 296 static int ft260_xfer_status(struct ft260_device *dev)
 297 {
 298         struct hid_device *hdev = dev->hdev;
 299         struct ft260_get_i2c_status_report report;
 300         int ret;
 301
 302         ret = ft260_hid_feature_report_get(hdev, FT260_I2C_STATUS,
 303                                            (u8 *)&report, sizeof(report));
 304         if (unlikely(ret < 0)) {
 305                 hid_err(hdev, "failed to retrieve status: %d\n", ret);
 306                 return ret;
 307         }
 308
 309         dev->clock = le16_to_cpu(report.clock);
 310         ft260_dbg("bus_status %#02x, clock %u\n", report.bus_status,
 311                   dev->clock);
 312
 313         if (report.bus_status & FT260_I2C_STATUS_CTRL_BUSY)
 314                 return -EAGAIN;
 315
 316         /*
 317          * The error condition (bit 1) is a status bit reflecting any
 318          * error conditions. When any of the bits 2, 3, or 4 are raised
 319          * to 1, bit 1 is also set to 1.
 320          */
 321         if (report.bus_status & FT260_I2C_STATUS_ERROR) {
 322                 hid_err(hdev, "i2c bus error: %#02x\n", report.bus_status);
 323                 return -EIO;
 324         }
 325
 326         return 0;
 327 }
 328
 329 static int ft260_hid_output_report(struct hid_device *hdev, u8 *data,
 330                                    size_t len)
 331 {
 332         u8 *buf;
 333         int ret;
 334
 335         buf = kmemdup(data, len, GFP_KERNEL);
 336         if (!buf)
 337                 return -ENOMEM;
 338
 339         ret = hid_hw_output_report(hdev, buf, len);
 340
 341         kfree(buf);
 342         return ret;
 343 }
 344
 345 static int ft260_hid_output_report_check_status(struct ft260_device *dev,
 346                                                 u8 *data, int len)
 347 {
 348         int ret, usec, try = 100;
 349         struct hid_device *hdev = dev->hdev;
 350
 351         ret = ft260_hid_output_report(hdev, data, len);
 352         if (ret < 0) {
 353                 hid_err(hdev, "%s: failed to start transfer, ret %d\n",
 354                         __func__, ret);
 355                 ft260_i2c_reset(hdev);
 356                 return ret;
 357         }
 358
 359         /* transfer time = 1 / clock(KHz) * 9 bits * bytes */
 360         usec = len * 9000 / dev->clock;
 361         if (usec > 2000) {
 362                 usec -= 1500;
 363                 usleep_range(usec, usec + 100);
 364                 ft260_dbg("wait %d usec, len %d\n", usec, len);
 365         }
 366
 367         do {
 368                 ret = ft260_xfer_status(dev);
 369                 if (ret != -EAGAIN)
 370                         break;
 371         } while (--try);
 372
 373         if (ret == 0)
 374                 return 0;
 375
 376         ft260_i2c_reset(hdev);
 377         return -EIO;
 378 }
 379
 380 static int ft260_i2c_write(struct ft260_device *dev, u8 addr, u8 *data,
 381                            int data_len, u8 flag)
 382 {
 383         int len, ret, idx = 0;
 384         struct hid_device *hdev = dev->hdev;
 385         struct ft260_i2c_write_request_report *rep =
 386                 (struct ft260_i2c_write_request_report *)dev->write_buf;
 387
 388         do {
 389                 if (data_len <= FT260_WR_DATA_MAX)
 390                         len = data_len;
 391                 else
 392                         len = FT260_WR_DATA_MAX;
 393
 394                 rep->report = FT260_I2C_DATA_REPORT_ID(len);
 395                 rep->address = addr;
 396                 rep->length = len;
 397                 rep->flag = flag;
 398
 399                 memcpy(rep->data, &data[idx], len);
 400
 401                 ft260_dbg("rep %#02x addr %#02x off %d len %d d[0] %#02x\n",
 402                           rep->report, addr, idx, len, data[0]);
 403
 404                 ret = ft260_hid_output_report_check_status(dev, (u8 *)rep,
 405                                                            len + 4);
 406                 if (ret < 0) {
 407                         hid_err(hdev, "%s: failed to start transfer, ret %d\n",
 408                                 __func__, ret);
 409                         return ret;
 410                 }
 411
 412                 data_len -= len;
 413                 idx += len;
 414
 415         } while (data_len > 0);
 416
 417         return 0;
 418 }
 419
 420 static int ft260_smbus_write(struct ft260_device *dev, u8 addr, u8 cmd,
 421                              u8 *data, u8 data_len, u8 flag)
 422 {
 423         int ret = 0;
 424         int len = 4;
 425
 426         struct ft260_i2c_write_request_report *rep =
 427                 (struct ft260_i2c_write_request_report *)dev->write_buf;
 428
 429         if (data_len >= sizeof(rep->data))
 430                 return -EINVAL;
 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
 451 static 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  */
 505 static 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) {
 515                 hid_err(hdev, "%s: unsupported wr len: %d\n", __func__,
 516                         msgs[0].len);
 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
 550 static 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;
 584 i2c_exit:
 585         hid_hw_power(hdev, PM_HINT_NORMAL);
 586         mutex_unlock(&dev->lock);
 587         return ret;
 588 }
 589
 590 static 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
 692 smbus_exit:
 693         hid_hw_power(hdev, PM_HINT_NORMAL);
 694         mutex_unlock(&dev->lock);
 695         return ret;
 696 }
 697
 698 static 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
 705 static 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
 710 static 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
 716 static 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 < 0) {
 725                 hid_err(hdev, "failed to retrieve system status\n");
 726                 return ret;
 727         }
 728         return 0;
 729 }
 730
 731 static int ft260_is_interface_enabled(struct hid_device *hdev)
 732 {
 733         struct ft260_get_system_status_report cfg;
 734         struct usb_interface *usbif = to_usb_interface(hdev->dev.parent);
 735         int interface = usbif->cur_altsetting->desc.bInterfaceNumber;
 736         int ret;
 737
 738         ret = ft260_get_system_config(hdev, &cfg);
 739         if (ret < 0)
 740                 return ret;
 741
 742         ft260_dbg("interface:  0x%02x\n", interface);
 743         ft260_dbg("chip mode:  0x%02x\n", cfg.chip_mode);
 744         ft260_dbg("clock_ctl:  0x%02x\n", cfg.clock_ctl);
 745         ft260_dbg("i2c_enable: 0x%02x\n", cfg.i2c_enable);
 746         ft260_dbg("uart_mode:  0x%02x\n", cfg.uart_mode);
 747
 748         switch (cfg.chip_mode) {
 749         case FT260_MODE_ALL:
 750         case FT260_MODE_BOTH:
 751                 if (interface == 1)
 752                         hid_info(hdev, "uart interface is not supported\n");
 753                 else
 754                         ret = 1;
 755                 break;
 756         case FT260_MODE_UART:
 757                 hid_info(hdev, "uart interface is not supported\n");
 758                 break;
 759         case FT260_MODE_I2C:
 760                 ret = 1;
 761                 break;
 762         }
 763         return ret;
 764 }
 765
 766 static int ft260_byte_show(struct hid_device *hdev, int id, u8 *cfg, int len,
 767                            u8 *field, u8 *buf)
 768 {
 769         int ret;
 770
 771         ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
 772         if (ret < 0)
 773                 return ret;
 774
 775         return scnprintf(buf, PAGE_SIZE, "%d\n", *field);
 776 }
 777
 778 static int ft260_word_show(struct hid_device *hdev, int id, u8 *cfg, int len,
 779                            u16 *field, u8 *buf)
 780 {
 781         int ret;
 782
 783         ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
 784         if (ret < 0)
 785                 return ret;
 786
 787         return scnprintf(buf, PAGE_SIZE, "%d\n", le16_to_cpu(*field));
 788 }
 789
 790 #define FT260_ATTR_SHOW(name, reptype, id, type, func)                         \
 791         static ssize_t name##_show(struct device *kdev,                        \
 792                                    struct device_attribute *attr, char *buf)   \
 793         {                                                                      \
 794                 struct reptype rep;                                            \
 795                 struct hid_device *hdev = to_hid_device(kdev);                 \
 796                 type *field = &rep.name;                                       \
 797                 int len = sizeof(rep);                                         \
 798                                                                                \
 799                 return func(hdev, id, (u8 *)&rep, len, field, buf);            \
 800         }
 801
 802 #define FT260_SSTAT_ATTR_SHOW(name)                                            \
 803                 FT260_ATTR_SHOW(name, ft260_get_system_status_report,          \
 804                                 FT260_SYSTEM_SETTINGS, u8, ft260_byte_show)
 805
 806 #define FT260_I2CST_ATTR_SHOW(name)                                            \
 807                 FT260_ATTR_SHOW(name, ft260_get_i2c_status_report,             \
 808                                 FT260_I2C_STATUS, u16, ft260_word_show)
 809
 810 #define FT260_ATTR_STORE(name, reptype, id, req, type, func)                   \
 811         static ssize_t name##_store(struct device *kdev,                       \
 812                                     struct device_attribute *attr,             \
 813                                     const char *buf, size_t count)             \
 814         {                                                                      \
 815                 struct reptype rep;                                            \
 816                 struct hid_device *hdev = to_hid_device(kdev);                 \
 817                 type name;                                                     \
 818                 int ret;                                                       \
 819                                                                                \
 820                 if (!func(buf, 10, &name)) {                                   \
 821                         rep.name = name;                                       \
 822                         rep.report = id;                                       \
 823                         rep.request = req;                                     \
 824                         ret = ft260_hid_feature_report_set(hdev, (u8 *)&rep,   \
 825                                                            sizeof(rep));       \
 826                         if (!ret)                                              \
 827                                 ret = count;                                   \
 828                 } else {                                                       \
 829                         ret = -EINVAL;                                         \
 830                 }                                                              \
 831                 return ret;                                                    \
 832         }
 833
 834 #define FT260_BYTE_ATTR_STORE(name, reptype, req)                              \
 835                 FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req,    \
 836                                  u8, kstrtou8)
 837
 838 #define FT260_WORD_ATTR_STORE(name, reptype, req)                              \
 839                 FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req,    \
 840                                  u16, kstrtou16)
 841
 842 FT260_SSTAT_ATTR_SHOW(chip_mode);
 843 static DEVICE_ATTR_RO(chip_mode);
 844
 845 FT260_SSTAT_ATTR_SHOW(pwren_status);
 846 static DEVICE_ATTR_RO(pwren_status);
 847
 848 FT260_SSTAT_ATTR_SHOW(suspend_status);
 849 static DEVICE_ATTR_RO(suspend_status);
 850
 851 FT260_SSTAT_ATTR_SHOW(hid_over_i2c_en);
 852 static DEVICE_ATTR_RO(hid_over_i2c_en);
 853
 854 FT260_SSTAT_ATTR_SHOW(power_saving_en);
 855 static DEVICE_ATTR_RO(power_saving_en);
 856
 857 FT260_SSTAT_ATTR_SHOW(i2c_enable);
 858 FT260_BYTE_ATTR_STORE(i2c_enable, ft260_set_i2c_mode_report,
 859                       FT260_SET_I2C_MODE);
 860 static DEVICE_ATTR_RW(i2c_enable);
 861
 862 FT260_SSTAT_ATTR_SHOW(uart_mode);
 863 FT260_BYTE_ATTR_STORE(uart_mode, ft260_set_uart_mode_report,
 864                       FT260_SET_UART_MODE);
 865 static DEVICE_ATTR_RW(uart_mode);
 866
 867 FT260_SSTAT_ATTR_SHOW(clock_ctl);
 868 FT260_BYTE_ATTR_STORE(clock_ctl, ft260_set_system_clock_report,
 869                       FT260_SET_CLOCK);
 870 static DEVICE_ATTR_RW(clock_ctl);
 871
 872 FT260_I2CST_ATTR_SHOW(clock);
 873 FT260_WORD_ATTR_STORE(clock, ft260_set_i2c_speed_report,
 874                       FT260_SET_I2C_CLOCK_SPEED);
 875 static DEVICE_ATTR_RW(clock);
 876
 877 static ssize_t i2c_reset_store(struct device *kdev,
 878                                struct device_attribute *attr, const char *buf,
 879                                size_t count)
 880 {
 881         struct hid_device *hdev = to_hid_device(kdev);
 882         int ret = ft260_i2c_reset(hdev);
 883
 884         if (ret)
 885                 return ret;
 886         return count;
 887 }
 888 static DEVICE_ATTR_WO(i2c_reset);
 889
 890 static const struct attribute_group ft260_attr_group = {
 891         .attrs = (struct attribute *[]) {
 892                   &dev_attr_chip_mode.attr,
 893                   &dev_attr_pwren_status.attr,
 894                   &dev_attr_suspend_status.attr,
 895                   &dev_attr_hid_over_i2c_en.attr,
 896                   &dev_attr_power_saving_en.attr,
 897                   &dev_attr_i2c_enable.attr,
 898                   &dev_attr_uart_mode.attr,
 899                   &dev_attr_clock_ctl.attr,
 900                   &dev_attr_i2c_reset.attr,
 901                   &dev_attr_clock.attr,
 902                   NULL
 903         }
 904 };
 905
 906 static int ft260_probe(struct hid_device *hdev, const struct hid_device_id *id)
 907 {
 908         struct ft260_device *dev;
 909         struct ft260_get_chip_version_report version;
 910         int ret;
 911
 912         if (!hid_is_usb(hdev))
 913                 return -EINVAL;
 914
 915         dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
 916         if (!dev)
 917                 return -ENOMEM;
 918
 919         ret = hid_parse(hdev);
 920         if (ret) {
 921                 hid_err(hdev, "failed to parse HID\n");
 922                 return ret;
 923         }
 924
 925         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
 926         if (ret) {
 927                 hid_err(hdev, "failed to start HID HW\n");
 928                 return ret;
 929         }
 930
 931         ret = hid_hw_open(hdev);
 932         if (ret) {
 933                 hid_err(hdev, "failed to open HID HW\n");
 934                 goto err_hid_stop;
 935         }
 936
 937         ret = ft260_hid_feature_report_get(hdev, FT260_CHIP_VERSION,
 938                                            (u8 *)&version, sizeof(version));
 939         if (ret < 0) {
 940                 hid_err(hdev, "failed to retrieve chip version\n");
 941                 goto err_hid_close;
 942         }
 943
 944         hid_info(hdev, "chip code: %02x%02x %02x%02x\n",
 945                  version.chip_code[0], version.chip_code[1],
 946                  version.chip_code[2], version.chip_code[3]);
 947
 948         ret = ft260_is_interface_enabled(hdev);
 949         if (ret <= 0)
 950                 goto err_hid_close;
 951
 952         hid_set_drvdata(hdev, dev);
 953         dev->hdev = hdev;
 954         dev->adap.owner = THIS_MODULE;
 955         dev->adap.class = I2C_CLASS_HWMON;
 956         dev->adap.algo = &ft260_i2c_algo;
 957         dev->adap.quirks = &ft260_i2c_quirks;
 958         dev->adap.dev.parent = &hdev->dev;
 959         snprintf(dev->adap.name, sizeof(dev->adap.name),
 960                  "FT260 usb-i2c bridge on hidraw%d",
 961                  ((struct hidraw *)hdev->hidraw)->minor);
 962
 963         mutex_init(&dev->lock);
 964         init_completion(&dev->wait);
 965
 966         ret = ft260_xfer_status(dev);
 967         if (ret)
 968                 ft260_i2c_reset(hdev);
 969
 970         i2c_set_adapdata(&dev->adap, dev);
 971         ret = i2c_add_adapter(&dev->adap);
 972         if (ret) {
 973                 hid_err(hdev, "failed to add i2c adapter\n");
 974                 goto err_hid_close;
 975         }
 976
 977         ret = sysfs_create_group(&hdev->dev.kobj, &ft260_attr_group);
 978         if (ret < 0) {
 979                 hid_err(hdev, "failed to create sysfs attrs\n");
 980                 goto err_i2c_free;
 981         }
 982
 983         return 0;
 984
 985 err_i2c_free:
 986         i2c_del_adapter(&dev->adap);
 987 err_hid_close:
 988         hid_hw_close(hdev);
 989 err_hid_stop:
 990         hid_hw_stop(hdev);
 991         return ret;
 992 }
 993
 994 static void ft260_remove(struct hid_device *hdev)
 995 {
 996         struct ft260_device *dev = hid_get_drvdata(hdev);
 997
 998         if (!dev)
 999                 return;
1000
1001         sysfs_remove_group(&hdev->dev.kobj, &ft260_attr_group);
1002         i2c_del_adapter(&dev->adap);
1003
1004         hid_hw_close(hdev);
1005         hid_hw_stop(hdev);
1006 }
1007
1008 static int ft260_raw_event(struct hid_device *hdev, struct hid_report *report,
1009                            u8 *data, int size)
1010 {
1011         struct ft260_device *dev = hid_get_drvdata(hdev);
1012         struct ft260_i2c_input_report *xfer = (void *)data;
1013
1014         if (xfer->report >= FT260_I2C_REPORT_MIN &&
1015             xfer->report <= FT260_I2C_REPORT_MAX) {
1016                 ft260_dbg("i2c resp: rep %#02x len %d\n", xfer->report,
1017                           xfer->length);
1018
1019                 memcpy(&dev->read_buf[dev->read_idx], &xfer->data,
1020                        xfer->length);
1021                 dev->read_idx += xfer->length;
1022
1023                 if (dev->read_idx == dev->read_len)
1024                         complete(&dev->wait);
1025
1026         } else {
1027                 hid_err(hdev, "unknown report: %#02x\n", xfer->report);
1028                 return 0;
1029         }
1030         return 1;
1031 }
1032
1033 static struct hid_driver ft260_driver = {
1034         .name           = "ft260",
1035         .id_table       = ft260_devices,
1036         .probe          = ft260_probe,
1037         .remove         = ft260_remove,
1038         .raw_event      = ft260_raw_event,
1039 };
1040
1041 module_hid_driver(ft260_driver);
1042 MODULE_DESCRIPTION("FTDI FT260 USB HID to I2C host bridge");
1043 MODULE_AUTHOR("Michael Zaidman <michael.zaidman@gmail.com>");
1044 MODULE_LICENSE("GPL v2");