Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * hid-ft260.c - FTDI FT260 USB HID to I2C host bridge
0004  *
0005  * Copyright (c) 2021, Michael Zaidman <michaelz@xsightlabs.com>
0006  *
0007  * Data Sheet:
0008  *   https://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT260.pdf
0009  */
0010 
0011 #include "hid-ids.h"
0012 #include <linux/hidraw.h>
0013 #include <linux/i2c.h>
0014 #include <linux/module.h>
0015 #include <linux/usb.h>
0016 
0017 #ifdef DEBUG
0018 static int ft260_debug = 1;
0019 #else
0020 static int ft260_debug;
0021 #endif
0022 module_param_named(debug, ft260_debug, int, 0600);
0023 MODULE_PARM_DESC(debug, "Toggle FT260 debugging messages");
0024 
0025 #define ft260_dbg(format, arg...)                     \
0026     do {                                  \
0027         if (ft260_debug)                      \
0028             pr_info("%s: " format, __func__, ##arg);      \
0029     } while (0)
0030 
0031 #define FT260_REPORT_MAX_LENGTH (64)
0032 #define FT260_I2C_DATA_REPORT_ID(len) (FT260_I2C_REPORT_MIN + (len - 1) / 4)
0033 /*
0034  * The input report format assigns 62 bytes for the data payload, but ft260
0035  * returns 60 and 2 in two separate transactions. To minimize transfer time
0036  * in reading chunks mode, set the maximum read payload length to 60 bytes.
0037  */
0038 #define FT260_RD_DATA_MAX (60)
0039 #define FT260_WR_DATA_MAX (60)
0040 
0041 /*
0042  * Device interface configuration.
0043  * The FT260 has 2 interfaces that are controlled by DCNF0 and DCNF1 pins.
0044  * First implementes USB HID to I2C bridge function and
0045  * second - USB HID to UART bridge function.
0046  */
0047 enum {
0048     FT260_MODE_ALL          = 0x00,
0049     FT260_MODE_I2C          = 0x01,
0050     FT260_MODE_UART         = 0x02,
0051     FT260_MODE_BOTH         = 0x03,
0052 };
0053 
0054 /* Control pipe */
0055 enum {
0056     FT260_GET_RQST_TYPE     = 0xA1,
0057     FT260_GET_REPORT        = 0x01,
0058     FT260_SET_RQST_TYPE     = 0x21,
0059     FT260_SET_REPORT        = 0x09,
0060     FT260_FEATURE           = 0x03,
0061 };
0062 
0063 /* Report IDs / Feature In */
0064 enum {
0065     FT260_CHIP_VERSION      = 0xA0,
0066     FT260_SYSTEM_SETTINGS       = 0xA1,
0067     FT260_I2C_STATUS        = 0xC0,
0068     FT260_I2C_READ_REQ      = 0xC2,
0069     FT260_I2C_REPORT_MIN        = 0xD0,
0070     FT260_I2C_REPORT_MAX        = 0xDE,
0071     FT260_GPIO          = 0xB0,
0072     FT260_UART_INTERRUPT_STATUS = 0xB1,
0073     FT260_UART_STATUS       = 0xE0,
0074     FT260_UART_RI_DCD_STATUS    = 0xE1,
0075     FT260_UART_REPORT       = 0xF0,
0076 };
0077 
0078 /* Feature Out */
0079 enum {
0080     FT260_SET_CLOCK         = 0x01,
0081     FT260_SET_I2C_MODE      = 0x02,
0082     FT260_SET_UART_MODE     = 0x03,
0083     FT260_ENABLE_INTERRUPT      = 0x05,
0084     FT260_SELECT_GPIO2_FUNC     = 0x06,
0085     FT260_ENABLE_UART_DCD_RI    = 0x07,
0086     FT260_SELECT_GPIOA_FUNC     = 0x08,
0087     FT260_SELECT_GPIOG_FUNC     = 0x09,
0088     FT260_SET_INTERRUPT_TRIGGER = 0x0A,
0089     FT260_SET_SUSPEND_OUT_POLAR = 0x0B,
0090     FT260_ENABLE_UART_RI_WAKEUP = 0x0C,
0091     FT260_SET_UART_RI_WAKEUP_CFG    = 0x0D,
0092     FT260_SET_I2C_RESET     = 0x20,
0093     FT260_SET_I2C_CLOCK_SPEED   = 0x22,
0094     FT260_SET_UART_RESET        = 0x40,
0095     FT260_SET_UART_CONFIG       = 0x41,
0096     FT260_SET_UART_BAUD_RATE    = 0x42,
0097     FT260_SET_UART_DATA_BIT     = 0x43,
0098     FT260_SET_UART_PARITY       = 0x44,
0099     FT260_SET_UART_STOP_BIT     = 0x45,
0100     FT260_SET_UART_BREAKING     = 0x46,
0101     FT260_SET_UART_XON_XOFF     = 0x49,
0102 };
0103 
0104 /* Response codes in I2C status report */
0105 enum {
0106     FT260_I2C_STATUS_SUCCESS    = 0x00,
0107     FT260_I2C_STATUS_CTRL_BUSY  = 0x01,
0108     FT260_I2C_STATUS_ERROR      = 0x02,
0109     FT260_I2C_STATUS_ADDR_NO_ACK    = 0x04,
0110     FT260_I2C_STATUS_DATA_NO_ACK    = 0x08,
0111     FT260_I2C_STATUS_ARBITR_LOST    = 0x10,
0112     FT260_I2C_STATUS_CTRL_IDLE  = 0x20,
0113     FT260_I2C_STATUS_BUS_BUSY   = 0x40,
0114 };
0115 
0116 /* I2C Conditions flags */
0117 enum {
0118     FT260_FLAG_NONE         = 0x00,
0119     FT260_FLAG_START        = 0x02,
0120     FT260_FLAG_START_REPEATED   = 0x03,
0121     FT260_FLAG_STOP         = 0x04,
0122     FT260_FLAG_START_STOP       = 0x06,
0123     FT260_FLAG_START_STOP_REPEATED  = 0x07,
0124 };
0125 
0126 #define FT260_SET_REQUEST_VALUE(report_id) ((FT260_FEATURE << 8) | report_id)
0127 
0128 /* Feature In reports */
0129 
0130 struct ft260_get_chip_version_report {
0131     u8 report;      /* FT260_CHIP_VERSION */
0132     u8 chip_code[4];    /* FTDI chip identification code */
0133     u8 reserved[8];
0134 } __packed;
0135 
0136 struct ft260_get_system_status_report {
0137     u8 report;      /* FT260_SYSTEM_SETTINGS */
0138     u8 chip_mode;       /* DCNF0 and DCNF1 status, bits 0-1 */
0139     u8 clock_ctl;       /* 0 - 12MHz, 1 - 24MHz, 2 - 48MHz */
0140     u8 suspend_status;  /* 0 - not suspended, 1 - suspended */
0141     u8 pwren_status;    /* 0 - FT260 is not ready, 1 - ready */
0142     u8 i2c_enable;      /* 0 - disabled, 1 - enabled */
0143     u8 uart_mode;       /* 0 - OFF; 1 - RTS_CTS, 2 - DTR_DSR, */
0144                 /* 3 - XON_XOFF, 4 - No flow control */
0145     u8 hid_over_i2c_en; /* 0 - disabled, 1 - enabled */
0146     u8 gpio2_function;  /* 0 - GPIO,  1 - SUSPOUT, */
0147                 /* 2 - PWREN, 4 - TX_LED */
0148     u8 gpioA_function;  /* 0 - GPIO, 3 - TX_ACTIVE, 4 - TX_LED */
0149     u8 gpioG_function;  /* 0 - GPIO, 2 - PWREN, */
0150                 /* 5 - RX_LED, 6 - BCD_DET */
0151     u8 suspend_out_pol; /* 0 - active-high, 1 - active-low */
0152     u8 enable_wakeup_int;   /* 0 - disabled, 1 - enabled */
0153     u8 intr_cond;       /* Interrupt trigger conditions */
0154     u8 power_saving_en; /* 0 - disabled, 1 - enabled */
0155     u8 reserved[10];
0156 } __packed;
0157 
0158 struct ft260_get_i2c_status_report {
0159     u8 report;      /* FT260_I2C_STATUS */
0160     u8 bus_status;      /* I2C bus status */
0161     __le16 clock;       /* I2C bus clock in range 60-3400 KHz */
0162     u8 reserved;
0163 } __packed;
0164 
0165 /* Feature Out reports */
0166 
0167 struct ft260_set_system_clock_report {
0168     u8 report;      /* FT260_SYSTEM_SETTINGS */
0169     u8 request;     /* FT260_SET_CLOCK */
0170     u8 clock_ctl;       /* 0 - 12MHz, 1 - 24MHz, 2 - 48MHz */
0171 } __packed;
0172 
0173 struct ft260_set_i2c_mode_report {
0174     u8 report;      /* FT260_SYSTEM_SETTINGS */
0175     u8 request;     /* FT260_SET_I2C_MODE */
0176     u8 i2c_enable;      /* 0 - disabled, 1 - enabled */
0177 } __packed;
0178 
0179 struct ft260_set_uart_mode_report {
0180     u8 report;      /* FT260_SYSTEM_SETTINGS */
0181     u8 request;     /* FT260_SET_UART_MODE */
0182     u8 uart_mode;       /* 0 - OFF; 1 - RTS_CTS, 2 - DTR_DSR, */
0183                 /* 3 - XON_XOFF, 4 - No flow control */
0184 } __packed;
0185 
0186 struct ft260_set_i2c_reset_report {
0187     u8 report;      /* FT260_SYSTEM_SETTINGS */
0188     u8 request;     /* FT260_SET_I2C_RESET */
0189 } __packed;
0190 
0191 struct ft260_set_i2c_speed_report {
0192     u8 report;      /* FT260_SYSTEM_SETTINGS */
0193     u8 request;     /* FT260_SET_I2C_CLOCK_SPEED */
0194     __le16 clock;       /* I2C bus clock in range 60-3400 KHz */
0195 } __packed;
0196 
0197 /* Data transfer reports */
0198 
0199 struct ft260_i2c_write_request_report {
0200     u8 report;      /* FT260_I2C_REPORT */
0201     u8 address;     /* 7-bit I2C address */
0202     u8 flag;        /* I2C transaction condition */
0203     u8 length;      /* data payload length */
0204     u8 data[FT260_WR_DATA_MAX]; /* data payload */
0205 } __packed;
0206 
0207 struct ft260_i2c_read_request_report {
0208     u8 report;      /* FT260_I2C_READ_REQ */
0209     u8 address;     /* 7-bit I2C address */
0210     u8 flag;        /* I2C transaction condition */
0211     __le16 length;      /* data payload length */
0212 } __packed;
0213 
0214 struct ft260_i2c_input_report {
0215     u8 report;      /* FT260_I2C_REPORT */
0216     u8 length;      /* data payload length */
0217     u8 data[2];     /* data payload */
0218 } __packed;
0219 
0220 static const struct hid_device_id ft260_devices[] = {
0221     { HID_USB_DEVICE(USB_VENDOR_ID_FUTURE_TECHNOLOGY,
0222              USB_DEVICE_ID_FT260) },
0223     { /* END OF LIST */ }
0224 };
0225 MODULE_DEVICE_TABLE(hid, ft260_devices);
0226 
0227 struct ft260_device {
0228     struct i2c_adapter adap;
0229     struct hid_device *hdev;
0230     struct completion wait;
0231     struct mutex lock;
0232     u8 write_buf[FT260_REPORT_MAX_LENGTH];
0233     u8 *read_buf;
0234     u16 read_idx;
0235     u16 read_len;
0236     u16 clock;
0237 };
0238 
0239 static int ft260_hid_feature_report_get(struct hid_device *hdev,
0240                     unsigned char report_id, u8 *data,
0241                     size_t len)
0242 {
0243     u8 *buf;
0244     int ret;
0245 
0246     buf = kmalloc(len, GFP_KERNEL);
0247     if (!buf)
0248         return -ENOMEM;
0249 
0250     ret = hid_hw_raw_request(hdev, report_id, buf, len, HID_FEATURE_REPORT,
0251                  HID_REQ_GET_REPORT);
0252     if (likely(ret == len))
0253         memcpy(data, buf, len);
0254     else if (ret >= 0)
0255         ret = -EIO;
0256     kfree(buf);
0257     return ret;
0258 }
0259 
0260 static int ft260_hid_feature_report_set(struct hid_device *hdev, u8 *data,
0261                     size_t len)
0262 {
0263     u8 *buf;
0264     int ret;
0265 
0266     buf = kmemdup(data, len, GFP_KERNEL);
0267     if (!buf)
0268         return -ENOMEM;
0269 
0270     buf[0] = FT260_SYSTEM_SETTINGS;
0271 
0272     ret = hid_hw_raw_request(hdev, buf[0], buf, len, HID_FEATURE_REPORT,
0273                  HID_REQ_SET_REPORT);
0274 
0275     kfree(buf);
0276     return ret;
0277 }
0278 
0279 static int ft260_i2c_reset(struct hid_device *hdev)
0280 {
0281     struct ft260_set_i2c_reset_report report;
0282     int ret;
0283 
0284     report.request = FT260_SET_I2C_RESET;
0285 
0286     ret = ft260_hid_feature_report_set(hdev, (u8 *)&report, sizeof(report));
0287     if (ret < 0) {
0288         hid_err(hdev, "failed to reset I2C controller: %d\n", ret);
0289         return ret;
0290     }
0291 
0292     ft260_dbg("done\n");
0293     return ret;
0294 }
0295 
0296 static int ft260_xfer_status(struct ft260_device *dev)
0297 {
0298     struct hid_device *hdev = dev->hdev;
0299     struct ft260_get_i2c_status_report report;
0300     int ret;
0301 
0302     ret = ft260_hid_feature_report_get(hdev, FT260_I2C_STATUS,
0303                        (u8 *)&report, sizeof(report));
0304     if (unlikely(ret < 0)) {
0305         hid_err(hdev, "failed to retrieve status: %d\n", ret);
0306         return ret;
0307     }
0308 
0309     dev->clock = le16_to_cpu(report.clock);
0310     ft260_dbg("bus_status %#02x, clock %u\n", report.bus_status,
0311           dev->clock);
0312 
0313     if (report.bus_status & FT260_I2C_STATUS_CTRL_BUSY)
0314         return -EAGAIN;
0315 
0316     if (report.bus_status & FT260_I2C_STATUS_BUS_BUSY)
0317         return -EBUSY;
0318 
0319     if (report.bus_status & FT260_I2C_STATUS_ERROR)
0320         return -EIO;
0321 
0322     ret = -EIO;
0323 
0324     if (report.bus_status & FT260_I2C_STATUS_ADDR_NO_ACK)
0325         ft260_dbg("unacknowledged address\n");
0326 
0327     if (report.bus_status & FT260_I2C_STATUS_DATA_NO_ACK)
0328         ft260_dbg("unacknowledged data\n");
0329 
0330     if (report.bus_status & FT260_I2C_STATUS_ARBITR_LOST)
0331         ft260_dbg("arbitration loss\n");
0332 
0333     if (report.bus_status & FT260_I2C_STATUS_CTRL_IDLE)
0334         ret = 0;
0335 
0336     return ret;
0337 }
0338 
0339 static int ft260_hid_output_report(struct hid_device *hdev, u8 *data,
0340                    size_t len)
0341 {
0342     u8 *buf;
0343     int ret;
0344 
0345     buf = kmemdup(data, len, GFP_KERNEL);
0346     if (!buf)
0347         return -ENOMEM;
0348 
0349     ret = hid_hw_output_report(hdev, buf, len);
0350 
0351     kfree(buf);
0352     return ret;
0353 }
0354 
0355 static int ft260_hid_output_report_check_status(struct ft260_device *dev,
0356                         u8 *data, int len)
0357 {
0358     int ret, usec, try = 3;
0359     struct hid_device *hdev = dev->hdev;
0360 
0361     ret = ft260_hid_output_report(hdev, data, len);
0362     if (ret < 0) {
0363         hid_err(hdev, "%s: failed to start transfer, ret %d\n",
0364             __func__, ret);
0365         ft260_i2c_reset(hdev);
0366         return ret;
0367     }
0368 
0369     /* transfer time = 1 / clock(KHz) * 10 bits * bytes */
0370     usec = 10000 / dev->clock * len;
0371     usleep_range(usec, usec + 100);
0372     ft260_dbg("wait %d usec, len %d\n", usec, len);
0373     do {
0374         ret = ft260_xfer_status(dev);
0375         if (ret != -EAGAIN)
0376             break;
0377     } while (--try);
0378 
0379     if (ret == 0 || ret == -EBUSY)
0380         return 0;
0381 
0382     ft260_i2c_reset(hdev);
0383     return -EIO;
0384 }
0385 
0386 static int ft260_i2c_write(struct ft260_device *dev, u8 addr, u8 *data,
0387                int data_len, u8 flag)
0388 {
0389     int len, ret, idx = 0;
0390     struct hid_device *hdev = dev->hdev;
0391     struct ft260_i2c_write_request_report *rep =
0392         (struct ft260_i2c_write_request_report *)dev->write_buf;
0393 
0394     do {
0395         if (data_len <= FT260_WR_DATA_MAX)
0396             len = data_len;
0397         else
0398             len = FT260_WR_DATA_MAX;
0399 
0400         rep->report = FT260_I2C_DATA_REPORT_ID(len);
0401         rep->address = addr;
0402         rep->length = len;
0403         rep->flag = flag;
0404 
0405         memcpy(rep->data, &data[idx], len);
0406 
0407         ft260_dbg("rep %#02x addr %#02x off %d len %d d[0] %#02x\n",
0408               rep->report, addr, idx, len, data[0]);
0409 
0410         ret = ft260_hid_output_report_check_status(dev, (u8 *)rep,
0411                                len + 4);
0412         if (ret < 0) {
0413             hid_err(hdev, "%s: failed to start transfer, ret %d\n",
0414                 __func__, ret);
0415             return ret;
0416         }
0417 
0418         data_len -= len;
0419         idx += len;
0420 
0421     } while (data_len > 0);
0422 
0423     return 0;
0424 }
0425 
0426 static int ft260_smbus_write(struct ft260_device *dev, u8 addr, u8 cmd,
0427                  u8 *data, u8 data_len, u8 flag)
0428 {
0429     int ret = 0;
0430     int len = 4;
0431 
0432     struct ft260_i2c_write_request_report *rep =
0433         (struct ft260_i2c_write_request_report *)dev->write_buf;
0434 
0435     if (data_len >= sizeof(rep->data))
0436         return -EINVAL;
0437 
0438     rep->address = addr;
0439     rep->data[0] = cmd;
0440     rep->length = data_len + 1;
0441     rep->flag = flag;
0442     len += rep->length;
0443 
0444     rep->report = FT260_I2C_DATA_REPORT_ID(len);
0445 
0446     if (data_len > 0)
0447         memcpy(&rep->data[1], data, data_len);
0448 
0449     ft260_dbg("rep %#02x addr %#02x cmd %#02x datlen %d replen %d\n",
0450           rep->report, addr, cmd, rep->length, len);
0451 
0452     ret = ft260_hid_output_report_check_status(dev, (u8 *)rep, len);
0453 
0454     return ret;
0455 }
0456 
0457 static int ft260_i2c_read(struct ft260_device *dev, u8 addr, u8 *data,
0458               u16 len, u8 flag)
0459 {
0460     struct ft260_i2c_read_request_report rep;
0461     struct hid_device *hdev = dev->hdev;
0462     int timeout;
0463     int ret;
0464 
0465     if (len > FT260_RD_DATA_MAX) {
0466         hid_err(hdev, "%s: unsupported rd len: %d\n", __func__, len);
0467         return -EINVAL;
0468     }
0469 
0470     dev->read_idx = 0;
0471     dev->read_buf = data;
0472     dev->read_len = len;
0473 
0474     rep.report = FT260_I2C_READ_REQ;
0475     rep.length = cpu_to_le16(len);
0476     rep.address = addr;
0477     rep.flag = flag;
0478 
0479     ft260_dbg("rep %#02x addr %#02x len %d\n", rep.report, rep.address,
0480           rep.length);
0481 
0482     reinit_completion(&dev->wait);
0483 
0484     ret = ft260_hid_output_report(hdev, (u8 *)&rep, sizeof(rep));
0485     if (ret < 0) {
0486         hid_err(hdev, "%s: failed to start transaction, ret %d\n",
0487             __func__, ret);
0488         return ret;
0489     }
0490 
0491     timeout = msecs_to_jiffies(5000);
0492     if (!wait_for_completion_timeout(&dev->wait, timeout)) {
0493         ft260_i2c_reset(hdev);
0494         return -ETIMEDOUT;
0495     }
0496 
0497     ret = ft260_xfer_status(dev);
0498     if (ret == 0)
0499         return 0;
0500 
0501     ft260_i2c_reset(hdev);
0502     return -EIO;
0503 }
0504 
0505 /*
0506  * A random read operation is implemented as a dummy write operation, followed
0507  * by a current address read operation. The dummy write operation is used to
0508  * load the target byte address into the current byte address counter, from
0509  * which the subsequent current address read operation then reads.
0510  */
0511 static int ft260_i2c_write_read(struct ft260_device *dev, struct i2c_msg *msgs)
0512 {
0513     int len, ret;
0514     u16 left_len = msgs[1].len;
0515     u8 *read_buf = msgs[1].buf;
0516     u8 addr = msgs[0].addr;
0517     u16 read_off = 0;
0518     struct hid_device *hdev = dev->hdev;
0519 
0520     if (msgs[0].len > 2) {
0521         hid_err(hdev, "%s: unsupported wr len: %d\n", __func__,
0522             msgs[0].len);
0523         return -EOPNOTSUPP;
0524     }
0525 
0526     memcpy(&read_off, msgs[0].buf, msgs[0].len);
0527 
0528     do {
0529         if (left_len <= FT260_RD_DATA_MAX)
0530             len = left_len;
0531         else
0532             len = FT260_RD_DATA_MAX;
0533 
0534         ft260_dbg("read_off %#x left_len %d len %d\n", read_off,
0535               left_len, len);
0536 
0537         ret = ft260_i2c_write(dev, addr, (u8 *)&read_off, msgs[0].len,
0538                       FT260_FLAG_START);
0539         if (ret < 0)
0540             return ret;
0541 
0542         ret = ft260_i2c_read(dev, addr, read_buf, len,
0543                      FT260_FLAG_START_STOP);
0544         if (ret < 0)
0545             return ret;
0546 
0547         left_len -= len;
0548         read_buf += len;
0549         read_off += len;
0550 
0551     } while (left_len > 0);
0552 
0553     return 0;
0554 }
0555 
0556 static int ft260_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
0557               int num)
0558 {
0559     int ret;
0560     struct ft260_device *dev = i2c_get_adapdata(adapter);
0561     struct hid_device *hdev = dev->hdev;
0562 
0563     mutex_lock(&dev->lock);
0564 
0565     ret = hid_hw_power(hdev, PM_HINT_FULLON);
0566     if (ret < 0) {
0567         hid_err(hdev, "failed to enter FULLON power mode: %d\n", ret);
0568         mutex_unlock(&dev->lock);
0569         return ret;
0570     }
0571 
0572     if (num == 1) {
0573         if (msgs->flags & I2C_M_RD)
0574             ret = ft260_i2c_read(dev, msgs->addr, msgs->buf,
0575                          msgs->len, FT260_FLAG_START_STOP);
0576         else
0577             ret = ft260_i2c_write(dev, msgs->addr, msgs->buf,
0578                           msgs->len, FT260_FLAG_START_STOP);
0579         if (ret < 0)
0580             goto i2c_exit;
0581 
0582     } else {
0583         /* Combined write then read message */
0584         ret = ft260_i2c_write_read(dev, msgs);
0585         if (ret < 0)
0586             goto i2c_exit;
0587     }
0588 
0589     ret = num;
0590 i2c_exit:
0591     hid_hw_power(hdev, PM_HINT_NORMAL);
0592     mutex_unlock(&dev->lock);
0593     return ret;
0594 }
0595 
0596 static int ft260_smbus_xfer(struct i2c_adapter *adapter, u16 addr, u16 flags,
0597                 char read_write, u8 cmd, int size,
0598                 union i2c_smbus_data *data)
0599 {
0600     int ret;
0601     struct ft260_device *dev = i2c_get_adapdata(adapter);
0602     struct hid_device *hdev = dev->hdev;
0603 
0604     ft260_dbg("smbus size %d\n", size);
0605 
0606     mutex_lock(&dev->lock);
0607 
0608     ret = hid_hw_power(hdev, PM_HINT_FULLON);
0609     if (ret < 0) {
0610         hid_err(hdev, "power management error: %d\n", ret);
0611         mutex_unlock(&dev->lock);
0612         return ret;
0613     }
0614 
0615     switch (size) {
0616     case I2C_SMBUS_QUICK:
0617         if (read_write == I2C_SMBUS_READ)
0618             ret = ft260_i2c_read(dev, addr, &data->byte, 0,
0619                          FT260_FLAG_START_STOP);
0620         else
0621             ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
0622                         FT260_FLAG_START_STOP);
0623         break;
0624     case I2C_SMBUS_BYTE:
0625         if (read_write == I2C_SMBUS_READ)
0626             ret = ft260_i2c_read(dev, addr, &data->byte, 1,
0627                          FT260_FLAG_START_STOP);
0628         else
0629             ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
0630                         FT260_FLAG_START_STOP);
0631         break;
0632     case I2C_SMBUS_BYTE_DATA:
0633         if (read_write == I2C_SMBUS_READ) {
0634             ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
0635                         FT260_FLAG_START);
0636             if (ret)
0637                 goto smbus_exit;
0638 
0639             ret = ft260_i2c_read(dev, addr, &data->byte, 1,
0640                          FT260_FLAG_START_STOP_REPEATED);
0641         } else {
0642             ret = ft260_smbus_write(dev, addr, cmd, &data->byte, 1,
0643                         FT260_FLAG_START_STOP);
0644         }
0645         break;
0646     case I2C_SMBUS_WORD_DATA:
0647         if (read_write == I2C_SMBUS_READ) {
0648             ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
0649                         FT260_FLAG_START);
0650             if (ret)
0651                 goto smbus_exit;
0652 
0653             ret = ft260_i2c_read(dev, addr, (u8 *)&data->word, 2,
0654                          FT260_FLAG_START_STOP_REPEATED);
0655         } else {
0656             ret = ft260_smbus_write(dev, addr, cmd,
0657                         (u8 *)&data->word, 2,
0658                         FT260_FLAG_START_STOP);
0659         }
0660         break;
0661     case I2C_SMBUS_BLOCK_DATA:
0662         if (read_write == I2C_SMBUS_READ) {
0663             ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
0664                         FT260_FLAG_START);
0665             if (ret)
0666                 goto smbus_exit;
0667 
0668             ret = ft260_i2c_read(dev, addr, data->block,
0669                          data->block[0] + 1,
0670                          FT260_FLAG_START_STOP_REPEATED);
0671         } else {
0672             ret = ft260_smbus_write(dev, addr, cmd, data->block,
0673                         data->block[0] + 1,
0674                         FT260_FLAG_START_STOP);
0675         }
0676         break;
0677     case I2C_SMBUS_I2C_BLOCK_DATA:
0678         if (read_write == I2C_SMBUS_READ) {
0679             ret = ft260_smbus_write(dev, addr, cmd, NULL, 0,
0680                         FT260_FLAG_START);
0681             if (ret)
0682                 goto smbus_exit;
0683 
0684             ret = ft260_i2c_read(dev, addr, data->block + 1,
0685                          data->block[0],
0686                          FT260_FLAG_START_STOP_REPEATED);
0687         } else {
0688             ret = ft260_smbus_write(dev, addr, cmd, data->block + 1,
0689                         data->block[0],
0690                         FT260_FLAG_START_STOP);
0691         }
0692         break;
0693     default:
0694         hid_err(hdev, "unsupported smbus transaction size %d\n", size);
0695         ret = -EOPNOTSUPP;
0696     }
0697 
0698 smbus_exit:
0699     hid_hw_power(hdev, PM_HINT_NORMAL);
0700     mutex_unlock(&dev->lock);
0701     return ret;
0702 }
0703 
0704 static u32 ft260_functionality(struct i2c_adapter *adap)
0705 {
0706     return I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_QUICK |
0707            I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
0708            I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_I2C_BLOCK;
0709 }
0710 
0711 static const struct i2c_adapter_quirks ft260_i2c_quirks = {
0712     .flags = I2C_AQ_COMB_WRITE_THEN_READ,
0713     .max_comb_1st_msg_len = 2,
0714 };
0715 
0716 static const struct i2c_algorithm ft260_i2c_algo = {
0717     .master_xfer = ft260_i2c_xfer,
0718     .smbus_xfer = ft260_smbus_xfer,
0719     .functionality = ft260_functionality,
0720 };
0721 
0722 static int ft260_get_system_config(struct hid_device *hdev,
0723                    struct ft260_get_system_status_report *cfg)
0724 {
0725     int ret;
0726     int len = sizeof(struct ft260_get_system_status_report);
0727 
0728     ret = ft260_hid_feature_report_get(hdev, FT260_SYSTEM_SETTINGS,
0729                        (u8 *)cfg, len);
0730     if (ret < 0) {
0731         hid_err(hdev, "failed to retrieve system status\n");
0732         return ret;
0733     }
0734     return 0;
0735 }
0736 
0737 static int ft260_is_interface_enabled(struct hid_device *hdev)
0738 {
0739     struct ft260_get_system_status_report cfg;
0740     struct usb_interface *usbif = to_usb_interface(hdev->dev.parent);
0741     int interface = usbif->cur_altsetting->desc.bInterfaceNumber;
0742     int ret;
0743 
0744     ret = ft260_get_system_config(hdev, &cfg);
0745     if (ret < 0)
0746         return ret;
0747 
0748     ft260_dbg("interface:  0x%02x\n", interface);
0749     ft260_dbg("chip mode:  0x%02x\n", cfg.chip_mode);
0750     ft260_dbg("clock_ctl:  0x%02x\n", cfg.clock_ctl);
0751     ft260_dbg("i2c_enable: 0x%02x\n", cfg.i2c_enable);
0752     ft260_dbg("uart_mode:  0x%02x\n", cfg.uart_mode);
0753 
0754     switch (cfg.chip_mode) {
0755     case FT260_MODE_ALL:
0756     case FT260_MODE_BOTH:
0757         if (interface == 1)
0758             hid_info(hdev, "uart interface is not supported\n");
0759         else
0760             ret = 1;
0761         break;
0762     case FT260_MODE_UART:
0763         hid_info(hdev, "uart interface is not supported\n");
0764         break;
0765     case FT260_MODE_I2C:
0766         ret = 1;
0767         break;
0768     }
0769     return ret;
0770 }
0771 
0772 static int ft260_byte_show(struct hid_device *hdev, int id, u8 *cfg, int len,
0773                u8 *field, u8 *buf)
0774 {
0775     int ret;
0776 
0777     ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
0778     if (ret < 0)
0779         return ret;
0780 
0781     return scnprintf(buf, PAGE_SIZE, "%d\n", *field);
0782 }
0783 
0784 static int ft260_word_show(struct hid_device *hdev, int id, u8 *cfg, int len,
0785                u16 *field, u8 *buf)
0786 {
0787     int ret;
0788 
0789     ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
0790     if (ret < 0)
0791         return ret;
0792 
0793     return scnprintf(buf, PAGE_SIZE, "%d\n", le16_to_cpu(*field));
0794 }
0795 
0796 #define FT260_ATTR_SHOW(name, reptype, id, type, func)                 \
0797     static ssize_t name##_show(struct device *kdev,                \
0798                    struct device_attribute *attr, char *buf)   \
0799     {                                      \
0800         struct reptype rep;                        \
0801         struct hid_device *hdev = to_hid_device(kdev);             \
0802         type *field = &rep.name;                       \
0803         int len = sizeof(rep);                         \
0804                                            \
0805         return func(hdev, id, (u8 *)&rep, len, field, buf);        \
0806     }
0807 
0808 #define FT260_SSTAT_ATTR_SHOW(name)                        \
0809         FT260_ATTR_SHOW(name, ft260_get_system_status_report,          \
0810                 FT260_SYSTEM_SETTINGS, u8, ft260_byte_show)
0811 
0812 #define FT260_I2CST_ATTR_SHOW(name)                        \
0813         FT260_ATTR_SHOW(name, ft260_get_i2c_status_report,         \
0814                 FT260_I2C_STATUS, u16, ft260_word_show)
0815 
0816 #define FT260_ATTR_STORE(name, reptype, id, req, type, func)               \
0817     static ssize_t name##_store(struct device *kdev,               \
0818                     struct device_attribute *attr,         \
0819                     const char *buf, size_t count)         \
0820     {                                      \
0821         struct reptype rep;                        \
0822         struct hid_device *hdev = to_hid_device(kdev);             \
0823         type name;                             \
0824         int ret;                               \
0825                                            \
0826         if (!func(buf, 10, &name)) {                       \
0827             rep.name = name;                       \
0828             rep.report = id;                       \
0829             rep.request = req;                     \
0830             ret = ft260_hid_feature_report_set(hdev, (u8 *)&rep,   \
0831                                sizeof(rep));       \
0832             if (!ret)                          \
0833                 ret = count;                       \
0834         } else {                               \
0835             ret = -EINVAL;                         \
0836         }                                  \
0837         return ret;                            \
0838     }
0839 
0840 #define FT260_BYTE_ATTR_STORE(name, reptype, req)                  \
0841         FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req,    \
0842                  u8, kstrtou8)
0843 
0844 #define FT260_WORD_ATTR_STORE(name, reptype, req)                  \
0845         FT260_ATTR_STORE(name, reptype, FT260_SYSTEM_SETTINGS, req,    \
0846                  u16, kstrtou16)
0847 
0848 FT260_SSTAT_ATTR_SHOW(chip_mode);
0849 static DEVICE_ATTR_RO(chip_mode);
0850 
0851 FT260_SSTAT_ATTR_SHOW(pwren_status);
0852 static DEVICE_ATTR_RO(pwren_status);
0853 
0854 FT260_SSTAT_ATTR_SHOW(suspend_status);
0855 static DEVICE_ATTR_RO(suspend_status);
0856 
0857 FT260_SSTAT_ATTR_SHOW(hid_over_i2c_en);
0858 static DEVICE_ATTR_RO(hid_over_i2c_en);
0859 
0860 FT260_SSTAT_ATTR_SHOW(power_saving_en);
0861 static DEVICE_ATTR_RO(power_saving_en);
0862 
0863 FT260_SSTAT_ATTR_SHOW(i2c_enable);
0864 FT260_BYTE_ATTR_STORE(i2c_enable, ft260_set_i2c_mode_report,
0865               FT260_SET_I2C_MODE);
0866 static DEVICE_ATTR_RW(i2c_enable);
0867 
0868 FT260_SSTAT_ATTR_SHOW(uart_mode);
0869 FT260_BYTE_ATTR_STORE(uart_mode, ft260_set_uart_mode_report,
0870               FT260_SET_UART_MODE);
0871 static DEVICE_ATTR_RW(uart_mode);
0872 
0873 FT260_SSTAT_ATTR_SHOW(clock_ctl);
0874 FT260_BYTE_ATTR_STORE(clock_ctl, ft260_set_system_clock_report,
0875               FT260_SET_CLOCK);
0876 static DEVICE_ATTR_RW(clock_ctl);
0877 
0878 FT260_I2CST_ATTR_SHOW(clock);
0879 FT260_WORD_ATTR_STORE(clock, ft260_set_i2c_speed_report,
0880               FT260_SET_I2C_CLOCK_SPEED);
0881 static DEVICE_ATTR_RW(clock);
0882 
0883 static ssize_t i2c_reset_store(struct device *kdev,
0884                    struct device_attribute *attr, const char *buf,
0885                    size_t count)
0886 {
0887     struct hid_device *hdev = to_hid_device(kdev);
0888     int ret = ft260_i2c_reset(hdev);
0889 
0890     if (ret)
0891         return ret;
0892     return count;
0893 }
0894 static DEVICE_ATTR_WO(i2c_reset);
0895 
0896 static const struct attribute_group ft260_attr_group = {
0897     .attrs = (struct attribute *[]) {
0898           &dev_attr_chip_mode.attr,
0899           &dev_attr_pwren_status.attr,
0900           &dev_attr_suspend_status.attr,
0901           &dev_attr_hid_over_i2c_en.attr,
0902           &dev_attr_power_saving_en.attr,
0903           &dev_attr_i2c_enable.attr,
0904           &dev_attr_uart_mode.attr,
0905           &dev_attr_clock_ctl.attr,
0906           &dev_attr_i2c_reset.attr,
0907           &dev_attr_clock.attr,
0908           NULL
0909     }
0910 };
0911 
0912 static int ft260_probe(struct hid_device *hdev, const struct hid_device_id *id)
0913 {
0914     struct ft260_device *dev;
0915     struct ft260_get_chip_version_report version;
0916     int ret;
0917 
0918     if (!hid_is_usb(hdev))
0919         return -EINVAL;
0920 
0921     dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
0922     if (!dev)
0923         return -ENOMEM;
0924 
0925     ret = hid_parse(hdev);
0926     if (ret) {
0927         hid_err(hdev, "failed to parse HID\n");
0928         return ret;
0929     }
0930 
0931     ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
0932     if (ret) {
0933         hid_err(hdev, "failed to start HID HW\n");
0934         return ret;
0935     }
0936 
0937     ret = hid_hw_open(hdev);
0938     if (ret) {
0939         hid_err(hdev, "failed to open HID HW\n");
0940         goto err_hid_stop;
0941     }
0942 
0943     ret = ft260_hid_feature_report_get(hdev, FT260_CHIP_VERSION,
0944                        (u8 *)&version, sizeof(version));
0945     if (ret < 0) {
0946         hid_err(hdev, "failed to retrieve chip version\n");
0947         goto err_hid_close;
0948     }
0949 
0950     hid_info(hdev, "chip code: %02x%02x %02x%02x\n",
0951          version.chip_code[0], version.chip_code[1],
0952          version.chip_code[2], version.chip_code[3]);
0953 
0954     ret = ft260_is_interface_enabled(hdev);
0955     if (ret <= 0)
0956         goto err_hid_close;
0957 
0958     hid_set_drvdata(hdev, dev);
0959     dev->hdev = hdev;
0960     dev->adap.owner = THIS_MODULE;
0961     dev->adap.class = I2C_CLASS_HWMON;
0962     dev->adap.algo = &ft260_i2c_algo;
0963     dev->adap.quirks = &ft260_i2c_quirks;
0964     dev->adap.dev.parent = &hdev->dev;
0965     snprintf(dev->adap.name, sizeof(dev->adap.name),
0966          "FT260 usb-i2c bridge on hidraw%d",
0967          ((struct hidraw *)hdev->hidraw)->minor);
0968 
0969     mutex_init(&dev->lock);
0970     init_completion(&dev->wait);
0971 
0972     ret = ft260_xfer_status(dev);
0973     if (ret)
0974         ft260_i2c_reset(hdev);
0975 
0976     i2c_set_adapdata(&dev->adap, dev);
0977     ret = i2c_add_adapter(&dev->adap);
0978     if (ret) {
0979         hid_err(hdev, "failed to add i2c adapter\n");
0980         goto err_hid_close;
0981     }
0982 
0983     ret = sysfs_create_group(&hdev->dev.kobj, &ft260_attr_group);
0984     if (ret < 0) {
0985         hid_err(hdev, "failed to create sysfs attrs\n");
0986         goto err_i2c_free;
0987     }
0988 
0989     return 0;
0990 
0991 err_i2c_free:
0992     i2c_del_adapter(&dev->adap);
0993 err_hid_close:
0994     hid_hw_close(hdev);
0995 err_hid_stop:
0996     hid_hw_stop(hdev);
0997     return ret;
0998 }
0999 
1000 static void ft260_remove(struct hid_device *hdev)
1001 {
1002     struct ft260_device *dev = hid_get_drvdata(hdev);
1003 
1004     if (!dev)
1005         return;
1006 
1007     sysfs_remove_group(&hdev->dev.kobj, &ft260_attr_group);
1008     i2c_del_adapter(&dev->adap);
1009 
1010     hid_hw_close(hdev);
1011     hid_hw_stop(hdev);
1012 }
1013 
1014 static int ft260_raw_event(struct hid_device *hdev, struct hid_report *report,
1015                u8 *data, int size)
1016 {
1017     struct ft260_device *dev = hid_get_drvdata(hdev);
1018     struct ft260_i2c_input_report *xfer = (void *)data;
1019 
1020     if (xfer->report >= FT260_I2C_REPORT_MIN &&
1021         xfer->report <= FT260_I2C_REPORT_MAX) {
1022         ft260_dbg("i2c resp: rep %#02x len %d\n", xfer->report,
1023               xfer->length);
1024 
1025         memcpy(&dev->read_buf[dev->read_idx], &xfer->data,
1026                xfer->length);
1027         dev->read_idx += xfer->length;
1028 
1029         if (dev->read_idx == dev->read_len)
1030             complete(&dev->wait);
1031 
1032     } else {
1033         hid_err(hdev, "unknown report: %#02x\n", xfer->report);
1034         return 0;
1035     }
1036     return 1;
1037 }
1038 
1039 static struct hid_driver ft260_driver = {
1040     .name       = "ft260",
1041     .id_table   = ft260_devices,
1042     .probe      = ft260_probe,
1043     .remove     = ft260_remove,
1044     .raw_event  = ft260_raw_event,
1045 };
1046 
1047 module_hid_driver(ft260_driver);
1048 MODULE_DESCRIPTION("FTDI FT260 USB HID to I2C host bridge");
1049 MODULE_AUTHOR("Michael Zaidman <michael.zaidman@gmail.com>");
1050 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!