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