drivers/hid/hid-cp2112.c

   1 /*
   2  * hid-cp2112.c - Silicon Labs HID USB to SMBus master bridge
   3  * Copyright (c) 2013,2014 Uplogix, Inc.
   4  * David Barksdale <dbarksdale@uplogix.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  */
  15
  16 /*
  17  * The Silicon Labs CP2112 chip is a USB HID device which provides an
  18  * SMBus controller for talking to slave devices and 8 GPIO pins. The
  19  * host communicates with the CP2112 via raw HID reports.
  20  *
  21  * Data Sheet:
  22  *   http://www.silabs.com/Support%20Documents/TechnicalDocs/CP2112.pdf
  23  * Programming Interface Specification:
  24  *   http://www.silabs.com/Support%20Documents/TechnicalDocs/AN495.pdf
  25  */
  26
  27 #include <linux/gpio/driver.h>
  28 #include <linux/hid.h>
  29 #include <linux/i2c.h>
  30 #include <linux/module.h>
  31 #include <linux/nls.h>
  32 #include <linux/usb/ch9.h>
  33 #include "hid-ids.h"
  34
  35 #define CP2112_REPORT_MAX_LENGTH                64
  36 #define CP2112_GPIO_CONFIG_LENGTH               5
  37 #define CP2112_GPIO_GET_LENGTH                  2
  38 #define CP2112_GPIO_SET_LENGTH                  3
  39
  40 enum {
  41         CP2112_GPIO_CONFIG              = 0x02,
  42         CP2112_GPIO_GET                 = 0x03,
  43         CP2112_GPIO_SET                 = 0x04,
  44         CP2112_GET_VERSION_INFO         = 0x05,
  45         CP2112_SMBUS_CONFIG             = 0x06,
  46         CP2112_DATA_READ_REQUEST        = 0x10,
  47         CP2112_DATA_WRITE_READ_REQUEST  = 0x11,
  48         CP2112_DATA_READ_FORCE_SEND     = 0x12,
  49         CP2112_DATA_READ_RESPONSE       = 0x13,
  50         CP2112_DATA_WRITE_REQUEST       = 0x14,
  51         CP2112_TRANSFER_STATUS_REQUEST  = 0x15,
  52         CP2112_TRANSFER_STATUS_RESPONSE = 0x16,
  53         CP2112_CANCEL_TRANSFER          = 0x17,
  54         CP2112_LOCK_BYTE                = 0x20,
  55         CP2112_USB_CONFIG               = 0x21,
  56         CP2112_MANUFACTURER_STRING      = 0x22,
  57         CP2112_PRODUCT_STRING           = 0x23,
  58         CP2112_SERIAL_STRING            = 0x24,
  59 };
  60
  61 enum {
  62         STATUS0_IDLE            = 0x00,
  63         STATUS0_BUSY            = 0x01,
  64         STATUS0_COMPLETE        = 0x02,
  65         STATUS0_ERROR           = 0x03,
  66 };
  67
  68 enum {
  69         STATUS1_TIMEOUT_NACK            = 0x00,
  70         STATUS1_TIMEOUT_BUS             = 0x01,
  71         STATUS1_ARBITRATION_LOST        = 0x02,
  72         STATUS1_READ_INCOMPLETE         = 0x03,
  73         STATUS1_WRITE_INCOMPLETE        = 0x04,
  74         STATUS1_SUCCESS                 = 0x05,
  75 };
  76
  77 struct cp2112_smbus_config_report {
  78         u8 report;              /* CP2112_SMBUS_CONFIG */
  79         __be32 clock_speed;     /* Hz */
  80         u8 device_address;      /* Stored in the upper 7 bits */
  81         u8 auto_send_read;      /* 1 = enabled, 0 = disabled */
  82         __be16 write_timeout;   /* ms, 0 = no timeout */
  83         __be16 read_timeout;    /* ms, 0 = no timeout */
  84         u8 scl_low_timeout;     /* 1 = enabled, 0 = disabled */
  85         __be16 retry_time;      /* # of retries, 0 = no limit */
  86 } __packed;
  87
  88 struct cp2112_usb_config_report {
  89         u8 report;      /* CP2112_USB_CONFIG */
  90         __le16 vid;     /* Vendor ID */
  91         __le16 pid;     /* Product ID */
  92         u8 max_power;   /* Power requested in 2mA units */
  93         u8 power_mode;  /* 0x00 = bus powered
  94                            0x01 = self powered & regulator off
  95                            0x02 = self powered & regulator on */
  96         u8 release_major;
  97         u8 release_minor;
  98         u8 mask;        /* What fields to program */
  99 } __packed;
 100
 101 struct cp2112_read_req_report {
 102         u8 report;      /* CP2112_DATA_READ_REQUEST */
 103         u8 slave_address;
 104         __be16 length;
 105 } __packed;
 106
 107 struct cp2112_write_read_req_report {
 108         u8 report;      /* CP2112_DATA_WRITE_READ_REQUEST */
 109         u8 slave_address;
 110         __be16 length;
 111         u8 target_address_length;
 112         u8 target_address[16];
 113 } __packed;
 114
 115 struct cp2112_write_req_report {
 116         u8 report;      /* CP2112_DATA_WRITE_REQUEST */
 117         u8 slave_address;
 118         u8 length;
 119         u8 data[61];
 120 } __packed;
 121
 122 struct cp2112_force_read_report {
 123         u8 report;      /* CP2112_DATA_READ_FORCE_SEND */
 124         __be16 length;
 125 } __packed;
 126
 127 struct cp2112_xfer_status_report {
 128         u8 report;      /* CP2112_TRANSFER_STATUS_RESPONSE */
 129         u8 status0;     /* STATUS0_* */
 130         u8 status1;     /* STATUS1_* */
 131         __be16 retries;
 132         __be16 length;
 133 } __packed;
 134
 135 struct cp2112_string_report {
 136         u8 dummy;               /* force .string to be aligned */
 137         u8 report;              /* CP2112_*_STRING */
 138         u8 length;              /* length in bytes of everyting after .report */
 139         u8 type;                /* USB_DT_STRING */
 140         wchar_t string[30];     /* UTF16_LITTLE_ENDIAN string */
 141 } __packed;
 142
 143 /* Number of times to request transfer status before giving up waiting for a
 144    transfer to complete. This may need to be changed if SMBUS clock, retries,
 145    or read/write/scl_low timeout settings are changed. */
 146 static const int XFER_STATUS_RETRIES = 10;
 147
 148 /* Time in ms to wait for a CP2112_DATA_READ_RESPONSE or
 149    CP2112_TRANSFER_STATUS_RESPONSE. */
 150 static const int RESPONSE_TIMEOUT = 50;
 151
 152 static const struct hid_device_id cp2112_devices[] = {
 153         { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
 154         { }
 155 };
 156 MODULE_DEVICE_TABLE(hid, cp2112_devices);
 157
 158 struct cp2112_device {
 159         struct i2c_adapter adap;
 160         struct hid_device *hdev;
 161         wait_queue_head_t wait;
 162         u8 read_data[61];
 163         u8 read_length;
 164         u8 hwversion;
 165         int xfer_status;
 166         atomic_t read_avail;
 167         atomic_t xfer_avail;
 168         struct gpio_chip gc;
 169         u8 *in_out_buffer;
 170         struct mutex lock;
 171 };
 172
 173 static int gpio_push_pull = 0xFF;
 174 module_param(gpio_push_pull, int, S_IRUGO | S_IWUSR);
 175 MODULE_PARM_DESC(gpio_push_pull, "GPIO push-pull configuration bitmask");
 176
 177 static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 178 {
 179         struct cp2112_device *dev = gpiochip_get_data(chip);
 180         struct hid_device *hdev = dev->hdev;
 181         u8 *buf = dev->in_out_buffer;
 182         int ret;
 183
 184         mutex_lock(&dev->lock);
 185
 186         ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 187                                  CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 188                                  HID_REQ_GET_REPORT);
 189         if (ret != CP2112_GPIO_CONFIG_LENGTH) {
 190                 hid_err(hdev, "error requesting GPIO config: %d\n", ret);
 191                 if (ret >= 0)
 192                         ret = -EIO;
 193                 goto exit;
 194         }
 195
 196         buf[1] &= ~(1 << offset);
 197         buf[2] = gpio_push_pull;
 198
 199         ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 200                                  CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 201                                  HID_REQ_SET_REPORT);
 202         if (ret != CP2112_GPIO_CONFIG_LENGTH) {
 203                 hid_err(hdev, "error setting GPIO config: %d\n", ret);
 204                 if (ret >= 0)
 205                         ret = -EIO;
 206                 goto exit;
 207         }
 208
 209         ret = 0;
 210
 211 exit:
 212         mutex_unlock(&dev->lock);
 213         return ret;
 214 }
 215
 216 static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 217 {
 218         struct cp2112_device *dev = gpiochip_get_data(chip);
 219         struct hid_device *hdev = dev->hdev;
 220         u8 *buf = dev->in_out_buffer;
 221         int ret;
 222
 223         mutex_lock(&dev->lock);
 224
 225         buf[0] = CP2112_GPIO_SET;
 226         buf[1] = value ? 0xff : 0;
 227         buf[2] = 1 << offset;
 228
 229         ret = hid_hw_raw_request(hdev, CP2112_GPIO_SET, buf,
 230                                  CP2112_GPIO_SET_LENGTH, HID_FEATURE_REPORT,
 231                                  HID_REQ_SET_REPORT);
 232         if (ret < 0)
 233                 hid_err(hdev, "error setting GPIO values: %d\n", ret);
 234
 235         mutex_unlock(&dev->lock);
 236 }
 237
 238 static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset)
 239 {
 240         struct cp2112_device *dev = gpiochip_get_data(chip);
 241         struct hid_device *hdev = dev->hdev;
 242         u8 *buf = dev->in_out_buffer;
 243         int ret;
 244
 245         mutex_lock(&dev->lock);
 246
 247         ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf,
 248                                  CP2112_GPIO_GET_LENGTH, HID_FEATURE_REPORT,
 249                                  HID_REQ_GET_REPORT);
 250         if (ret != CP2112_GPIO_GET_LENGTH) {
 251                 hid_err(hdev, "error requesting GPIO values: %d\n", ret);
 252                 ret = ret < 0 ? ret : -EIO;
 253                 goto exit;
 254         }
 255
 256         ret = (buf[1] >> offset) & 1;
 257
 258 exit:
 259         mutex_unlock(&dev->lock);
 260
 261         return ret;
 262 }
 263
 264 static int cp2112_gpio_direction_output(struct gpio_chip *chip,
 265                                         unsigned offset, int value)
 266 {
 267         struct cp2112_device *dev = gpiochip_get_data(chip);
 268         struct hid_device *hdev = dev->hdev;
 269         u8 *buf = dev->in_out_buffer;
 270         int ret;
 271
 272         mutex_lock(&dev->lock);
 273
 274         ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 275                                  CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 276                                  HID_REQ_GET_REPORT);
 277         if (ret != CP2112_GPIO_CONFIG_LENGTH) {
 278                 hid_err(hdev, "error requesting GPIO config: %d\n", ret);
 279                 goto fail;
 280         }
 281
 282         buf[1] |= 1 << offset;
 283         buf[2] = gpio_push_pull;
 284
 285         ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 286                                  CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 287                                  HID_REQ_SET_REPORT);
 288         if (ret < 0) {
 289                 hid_err(hdev, "error setting GPIO config: %d\n", ret);
 290                 goto fail;
 291         }
 292
 293         mutex_unlock(&dev->lock);
 294
 295         /*
 296          * Set gpio value when output direction is already set,
 297          * as specified in AN495, Rev. 0.2, cpt. 4.4
 298          */
 299         cp2112_gpio_set(chip, offset, value);
 300
 301         return 0;
 302
 303 fail:
 304         mutex_unlock(&dev->lock);
 305         return ret < 0 ? ret : -EIO;
 306 }
 307
 308 static int cp2112_hid_get(struct hid_device *hdev, unsigned char report_number,
 309                           u8 *data, size_t count, unsigned char report_type)
 310 {
 311         u8 *buf;
 312         int ret;
 313
 314         buf = kmalloc(count, GFP_KERNEL);
 315         if (!buf)
 316                 return -ENOMEM;
 317
 318         ret = hid_hw_raw_request(hdev, report_number, buf, count,
 319                                        report_type, HID_REQ_GET_REPORT);
 320         memcpy(data, buf, count);
 321         kfree(buf);
 322         return ret;
 323 }
 324
 325 static int cp2112_hid_output(struct hid_device *hdev, u8 *data, size_t count,
 326                              unsigned char report_type)
 327 {
 328         u8 *buf;
 329         int ret;
 330
 331         buf = kmemdup(data, count, GFP_KERNEL);
 332         if (!buf)
 333                 return -ENOMEM;
 334
 335         if (report_type == HID_OUTPUT_REPORT)
 336                 ret = hid_hw_output_report(hdev, buf, count);
 337         else
 338                 ret = hid_hw_raw_request(hdev, buf[0], buf, count, report_type,
 339                                 HID_REQ_SET_REPORT);
 340
 341         kfree(buf);
 342         return ret;
 343 }
 344
 345 static int cp2112_wait(struct cp2112_device *dev, atomic_t *avail)
 346 {
 347         int ret = 0;
 348
 349         /* We have sent either a CP2112_TRANSFER_STATUS_REQUEST or a
 350          * CP2112_DATA_READ_FORCE_SEND and we are waiting for the response to
 351          * come in cp2112_raw_event or timeout. There will only be one of these
 352          * in flight at any one time. The timeout is extremely large and is a
 353          * last resort if the CP2112 has died. If we do timeout we don't expect
 354          * to receive the response which would cause data races, it's not like
 355          * we can do anything about it anyway.
 356          */
 357         ret = wait_event_interruptible_timeout(dev->wait,
 358                 atomic_read(avail), msecs_to_jiffies(RESPONSE_TIMEOUT));
 359         if (-ERESTARTSYS == ret)
 360                 return ret;
 361         if (!ret)
 362                 return -ETIMEDOUT;
 363
 364         atomic_set(avail, 0);
 365         return 0;
 366 }
 367
 368 static int cp2112_xfer_status(struct cp2112_device *dev)
 369 {
 370         struct hid_device *hdev = dev->hdev;
 371         u8 buf[2];
 372         int ret;
 373
 374         buf[0] = CP2112_TRANSFER_STATUS_REQUEST;
 375         buf[1] = 0x01;
 376         atomic_set(&dev->xfer_avail, 0);
 377
 378         ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
 379         if (ret < 0) {
 380                 hid_warn(hdev, "Error requesting status: %d\n", ret);
 381                 return ret;
 382         }
 383
 384         ret = cp2112_wait(dev, &dev->xfer_avail);
 385         if (ret)
 386                 return ret;
 387
 388         return dev->xfer_status;
 389 }
 390
 391 static int cp2112_read(struct cp2112_device *dev, u8 *data, size_t size)
 392 {
 393         struct hid_device *hdev = dev->hdev;
 394         struct cp2112_force_read_report report;
 395         int ret;
 396
 397         if (size > sizeof(dev->read_data))
 398                 size = sizeof(dev->read_data);
 399         report.report = CP2112_DATA_READ_FORCE_SEND;
 400         report.length = cpu_to_be16(size);
 401
 402         atomic_set(&dev->read_avail, 0);
 403
 404         ret = cp2112_hid_output(hdev, &report.report, sizeof(report),
 405                                 HID_OUTPUT_REPORT);
 406         if (ret < 0) {
 407                 hid_warn(hdev, "Error requesting data: %d\n", ret);
 408                 return ret;
 409         }
 410
 411         ret = cp2112_wait(dev, &dev->read_avail);
 412         if (ret)
 413                 return ret;
 414
 415         hid_dbg(hdev, "read %d of %zd bytes requested\n",
 416                 dev->read_length, size);
 417
 418         if (size > dev->read_length)
 419                 size = dev->read_length;
 420
 421         memcpy(data, dev->read_data, size);
 422         return dev->read_length;
 423 }
 424
 425 static int cp2112_read_req(void *buf, u8 slave_address, u16 length)
 426 {
 427         struct cp2112_read_req_report *report = buf;
 428
 429         if (length < 1 || length > 512)
 430                 return -EINVAL;
 431
 432         report->report = CP2112_DATA_READ_REQUEST;
 433         report->slave_address = slave_address << 1;
 434         report->length = cpu_to_be16(length);
 435         return sizeof(*report);
 436 }
 437
 438 static int cp2112_write_read_req(void *buf, u8 slave_address, u16 length,
 439                                  u8 command, u8 *data, u8 data_length)
 440 {
 441         struct cp2112_write_read_req_report *report = buf;
 442
 443         if (length < 1 || length > 512
 444             || data_length > sizeof(report->target_address) - 1)
 445                 return -EINVAL;
 446
 447         report->report = CP2112_DATA_WRITE_READ_REQUEST;
 448         report->slave_address = slave_address << 1;
 449         report->length = cpu_to_be16(length);
 450         report->target_address_length = data_length + 1;
 451         report->target_address[0] = command;
 452         memcpy(&report->target_address[1], data, data_length);
 453         return data_length + 6;
 454 }
 455
 456 static int cp2112_write_req(void *buf, u8 slave_address, u8 command, u8 *data,
 457                             u8 data_length)
 458 {
 459         struct cp2112_write_req_report *report = buf;
 460
 461         if (data_length > sizeof(report->data) - 1)
 462                 return -EINVAL;
 463
 464         report->report = CP2112_DATA_WRITE_REQUEST;
 465         report->slave_address = slave_address << 1;
 466         report->length = data_length + 1;
 467         report->data[0] = command;
 468         memcpy(&report->data[1], data, data_length);
 469         return data_length + 4;
 470 }
 471
 472 static int cp2112_i2c_write_req(void *buf, u8 slave_address, u8 *data,
 473                                 u8 data_length)
 474 {
 475         struct cp2112_write_req_report *report = buf;
 476
 477         if (data_length > sizeof(report->data))
 478                 return -EINVAL;
 479
 480         report->report = CP2112_DATA_WRITE_REQUEST;
 481         report->slave_address = slave_address << 1;
 482         report->length = data_length;
 483         memcpy(report->data, data, data_length);
 484         return data_length + 3;
 485 }
 486
 487 static int cp2112_i2c_write_read_req(void *buf, u8 slave_address,
 488                                      u8 *addr, int addr_length,
 489                                      int read_length)
 490 {
 491         struct cp2112_write_read_req_report *report = buf;
 492
 493         if (read_length < 1 || read_length > 512 ||
 494             addr_length > sizeof(report->target_address))
 495                 return -EINVAL;
 496
 497         report->report = CP2112_DATA_WRITE_READ_REQUEST;
 498         report->slave_address = slave_address << 1;
 499         report->length = cpu_to_be16(read_length);
 500         report->target_address_length = addr_length;
 501         memcpy(report->target_address, addr, addr_length);
 502         return addr_length + 5;
 503 }
 504
 505 static int cp2112_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
 506                            int num)
 507 {
 508         struct cp2112_device *dev = (struct cp2112_device *)adap->algo_data;
 509         struct hid_device *hdev = dev->hdev;
 510         u8 buf[64];
 511         ssize_t count;
 512         ssize_t read_length = 0;
 513         u8 *read_buf = NULL;
 514         unsigned int retries;
 515         int ret;
 516
 517         hid_dbg(hdev, "I2C %d messages\n", num);
 518
 519         if (num == 1) {
 520                 if (msgs->flags & I2C_M_RD) {
 521                         hid_dbg(hdev, "I2C read %#04x len %d\n",
 522                                 msgs->addr, msgs->len);
 523                         read_length = msgs->len;
 524                         read_buf = msgs->buf;
 525                         count = cp2112_read_req(buf, msgs->addr, msgs->len);
 526                 } else {
 527                         hid_dbg(hdev, "I2C write %#04x len %d\n",
 528                                 msgs->addr, msgs->len);
 529                         count = cp2112_i2c_write_req(buf, msgs->addr,
 530                                                      msgs->buf, msgs->len);
 531                 }
 532                 if (count < 0)
 533                         return count;
 534         } else if (dev->hwversion > 1 &&  /* no repeated start in rev 1 */
 535                    num == 2 &&
 536                    msgs[0].addr == msgs[1].addr &&
 537                    !(msgs[0].flags & I2C_M_RD) && (msgs[1].flags & I2C_M_RD)) {
 538                 hid_dbg(hdev, "I2C write-read %#04x wlen %d rlen %d\n",
 539                         msgs[0].addr, msgs[0].len, msgs[1].len);
 540                 read_length = msgs[1].len;
 541                 read_buf = msgs[1].buf;
 542                 count = cp2112_i2c_write_read_req(buf, msgs[0].addr,
 543                                 msgs[0].buf, msgs[0].len, msgs[1].len);
 544                 if (count < 0)
 545                         return count;
 546         } else {
 547                 hid_err(hdev,
 548                         "Multi-message I2C transactions not supported\n");
 549                 return -EOPNOTSUPP;
 550         }
 551
 552         ret = hid_hw_power(hdev, PM_HINT_FULLON);
 553         if (ret < 0) {
 554                 hid_err(hdev, "power management error: %d\n", ret);
 555                 return ret;
 556         }
 557
 558         ret = cp2112_hid_output(hdev, buf, count, HID_OUTPUT_REPORT);
 559         if (ret < 0) {
 560                 hid_warn(hdev, "Error starting transaction: %d\n", ret);
 561                 goto power_normal;
 562         }
 563
 564         for (retries = 0; retries < XFER_STATUS_RETRIES; ++retries) {
 565                 ret = cp2112_xfer_status(dev);
 566                 if (-EBUSY == ret)
 567                         continue;
 568                 if (ret < 0)
 569                         goto power_normal;
 570                 break;
 571         }
 572
 573         if (XFER_STATUS_RETRIES <= retries) {
 574                 hid_warn(hdev, "Transfer timed out, cancelling.\n");
 575                 buf[0] = CP2112_CANCEL_TRANSFER;
 576                 buf[1] = 0x01;
 577
 578                 ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
 579                 if (ret < 0)
 580                         hid_warn(hdev, "Error cancelling transaction: %d\n",
 581                                  ret);
 582
 583                 ret = -ETIMEDOUT;
 584                 goto power_normal;
 585         }
 586
 587         for (count = 0; count < read_length;) {
 588                 ret = cp2112_read(dev, read_buf + count, read_length - count);
 589                 if (ret < 0)
 590                         goto power_normal;
 591                 if (ret == 0) {
 592                         hid_err(hdev, "read returned 0\n");
 593                         ret = -EIO;
 594                         goto power_normal;
 595                 }
 596                 count += ret;
 597                 if (count > read_length) {
 598                         /*
 599                          * The hardware returned too much data.
 600                          * This is mostly harmless because cp2112_read()
 601                          * has a limit check so didn't overrun our
 602                          * buffer.  Nevertheless, we return an error
 603                          * because something is seriously wrong and
 604                          * it shouldn't go unnoticed.
 605                          */
 606                         hid_err(hdev, "long read: %d > %zd\n",
 607                                 ret, read_length - count + ret);
 608                         ret = -EIO;
 609                         goto power_normal;
 610                 }
 611         }
 612
 613         /* return the number of transferred messages */
 614         ret = num;
 615
 616 power_normal:
 617         hid_hw_power(hdev, PM_HINT_NORMAL);
 618         hid_dbg(hdev, "I2C transfer finished: %d\n", ret);
 619         return ret;
 620 }
 621
 622 static int cp2112_xfer(struct i2c_adapter *adap, u16 addr,
 623                        unsigned short flags, char read_write, u8 command,
 624                        int size, union i2c_smbus_data *data)
 625 {
 626         struct cp2112_device *dev = (struct cp2112_device *)adap->algo_data;
 627         struct hid_device *hdev = dev->hdev;
 628         u8 buf[64];
 629         __le16 word;
 630         ssize_t count;
 631         size_t read_length = 0;
 632         unsigned int retries;
 633         int ret;
 634
 635         hid_dbg(hdev, "%s addr 0x%x flags 0x%x cmd 0x%x size %d\n",
 636                 read_write == I2C_SMBUS_WRITE ? "write" : "read",
 637                 addr, flags, command, size);
 638
 639         switch (size) {
 640         case I2C_SMBUS_BYTE:
 641                 read_length = 1;
 642
 643                 if (I2C_SMBUS_READ == read_write)
 644                         count = cp2112_read_req(buf, addr, read_length);
 645                 else
 646                         count = cp2112_write_req(buf, addr, command, NULL,
 647                                                  0);
 648                 break;
 649         case I2C_SMBUS_BYTE_DATA:
 650                 read_length = 1;
 651
 652                 if (I2C_SMBUS_READ == read_write)
 653                         count = cp2112_write_read_req(buf, addr, read_length,
 654                                                       command, NULL, 0);
 655                 else
 656                         count = cp2112_write_req(buf, addr, command,
 657                                                  &data->byte, 1);
 658                 break;
 659         case I2C_SMBUS_WORD_DATA:
 660                 read_length = 2;
 661                 word = cpu_to_le16(data->word);
 662
 663                 if (I2C_SMBUS_READ == read_write)
 664                         count = cp2112_write_read_req(buf, addr, read_length,
 665                                                       command, NULL, 0);
 666                 else
 667                         count = cp2112_write_req(buf, addr, command,
 668                                                  (u8 *)&word, 2);
 669                 break;
 670         case I2C_SMBUS_PROC_CALL:
 671                 size = I2C_SMBUS_WORD_DATA;
 672                 read_write = I2C_SMBUS_READ;
 673                 read_length = 2;
 674                 word = cpu_to_le16(data->word);
 675
 676                 count = cp2112_write_read_req(buf, addr, read_length, command,
 677                                               (u8 *)&word, 2);
 678                 break;
 679         case I2C_SMBUS_I2C_BLOCK_DATA:
 680                 size = I2C_SMBUS_BLOCK_DATA;
 681                 /* fallthrough */
 682         case I2C_SMBUS_BLOCK_DATA:
 683                 if (I2C_SMBUS_READ == read_write) {
 684                         count = cp2112_write_read_req(buf, addr,
 685                                                       I2C_SMBUS_BLOCK_MAX,
 686                                                       command, NULL, 0);
 687                 } else {
 688                         count = cp2112_write_req(buf, addr, command,
 689                                                  data->block,
 690                                                  data->block[0] + 1);
 691                 }
 692                 break;
 693         case I2C_SMBUS_BLOCK_PROC_CALL:
 694                 size = I2C_SMBUS_BLOCK_DATA;
 695                 read_write = I2C_SMBUS_READ;
 696
 697                 count = cp2112_write_read_req(buf, addr, I2C_SMBUS_BLOCK_MAX,
 698                                               command, data->block,
 699                                               data->block[0] + 1);
 700                 break;
 701         default:
 702                 hid_warn(hdev, "Unsupported transaction %d\n", size);
 703                 return -EOPNOTSUPP;
 704         }
 705
 706         if (count < 0)
 707                 return count;
 708
 709         ret = hid_hw_power(hdev, PM_HINT_FULLON);
 710         if (ret < 0) {
 711                 hid_err(hdev, "power management error: %d\n", ret);
 712                 return ret;
 713         }
 714
 715         ret = cp2112_hid_output(hdev, buf, count, HID_OUTPUT_REPORT);
 716         if (ret < 0) {
 717                 hid_warn(hdev, "Error starting transaction: %d\n", ret);
 718                 goto power_normal;
 719         }
 720
 721         for (retries = 0; retries < XFER_STATUS_RETRIES; ++retries) {
 722                 ret = cp2112_xfer_status(dev);
 723                 if (-EBUSY == ret)
 724                         continue;
 725                 if (ret < 0)
 726                         goto power_normal;
 727                 break;
 728         }
 729
 730         if (XFER_STATUS_RETRIES <= retries) {
 731                 hid_warn(hdev, "Transfer timed out, cancelling.\n");
 732                 buf[0] = CP2112_CANCEL_TRANSFER;
 733                 buf[1] = 0x01;
 734
 735                 ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
 736                 if (ret < 0)
 737                         hid_warn(hdev, "Error cancelling transaction: %d\n",
 738                                  ret);
 739
 740                 ret = -ETIMEDOUT;
 741                 goto power_normal;
 742         }
 743
 744         if (I2C_SMBUS_WRITE == read_write) {
 745                 ret = 0;
 746                 goto power_normal;
 747         }
 748
 749         if (I2C_SMBUS_BLOCK_DATA == size)
 750                 read_length = ret;
 751
 752         ret = cp2112_read(dev, buf, read_length);
 753         if (ret < 0)
 754                 goto power_normal;
 755         if (ret != read_length) {
 756                 hid_warn(hdev, "short read: %d < %zd\n", ret, read_length);
 757                 ret = -EIO;
 758                 goto power_normal;
 759         }
 760
 761         switch (size) {
 762         case I2C_SMBUS_BYTE:
 763         case I2C_SMBUS_BYTE_DATA:
 764                 data->byte = buf[0];
 765                 break;
 766         case I2C_SMBUS_WORD_DATA:
 767                 data->word = le16_to_cpup((__le16 *)buf);
 768                 break;
 769         case I2C_SMBUS_BLOCK_DATA:
 770                 if (read_length > I2C_SMBUS_BLOCK_MAX) {
 771                         ret = -EPROTO;
 772                         goto power_normal;
 773                 }
 774
 775                 memcpy(data->block, buf, read_length);
 776                 break;
 777         }
 778
 779         ret = 0;
 780 power_normal:
 781         hid_hw_power(hdev, PM_HINT_NORMAL);
 782         hid_dbg(hdev, "transfer finished: %d\n", ret);
 783         return ret;
 784 }
 785
 786 static u32 cp2112_functionality(struct i2c_adapter *adap)
 787 {
 788         return I2C_FUNC_I2C |
 789                 I2C_FUNC_SMBUS_BYTE |
 790                 I2C_FUNC_SMBUS_BYTE_DATA |
 791                 I2C_FUNC_SMBUS_WORD_DATA |
 792                 I2C_FUNC_SMBUS_BLOCK_DATA |
 793                 I2C_FUNC_SMBUS_I2C_BLOCK |
 794                 I2C_FUNC_SMBUS_PROC_CALL |
 795                 I2C_FUNC_SMBUS_BLOCK_PROC_CALL;
 796 }
 797
 798 static const struct i2c_algorithm smbus_algorithm = {
 799         .master_xfer    = cp2112_i2c_xfer,
 800         .smbus_xfer     = cp2112_xfer,
 801         .functionality  = cp2112_functionality,
 802 };
 803
 804 static int cp2112_get_usb_config(struct hid_device *hdev,
 805                                  struct cp2112_usb_config_report *cfg)
 806 {
 807         int ret;
 808
 809         ret = cp2112_hid_get(hdev, CP2112_USB_CONFIG, (u8 *)cfg, sizeof(*cfg),
 810                              HID_FEATURE_REPORT);
 811         if (ret != sizeof(*cfg)) {
 812                 hid_err(hdev, "error reading usb config: %d\n", ret);
 813                 if (ret < 0)
 814                         return ret;
 815                 return -EIO;
 816         }
 817
 818         return 0;
 819 }
 820
 821 static int cp2112_set_usb_config(struct hid_device *hdev,
 822                                  struct cp2112_usb_config_report *cfg)
 823 {
 824         int ret;
 825
 826         BUG_ON(cfg->report != CP2112_USB_CONFIG);
 827
 828         ret = cp2112_hid_output(hdev, (u8 *)cfg, sizeof(*cfg),
 829                                 HID_FEATURE_REPORT);
 830         if (ret != sizeof(*cfg)) {
 831                 hid_err(hdev, "error writing usb config: %d\n", ret);
 832                 if (ret < 0)
 833                         return ret;
 834                 return -EIO;
 835         }
 836
 837         return 0;
 838 }
 839
 840 static void chmod_sysfs_attrs(struct hid_device *hdev);
 841
 842 #define CP2112_CONFIG_ATTR(name, store, format, ...) \
 843 static ssize_t name##_store(struct device *kdev, \
 844                             struct device_attribute *attr, const char *buf, \
 845                             size_t count) \
 846 { \
 847         struct hid_device *hdev = to_hid_device(kdev); \
 848         struct cp2112_usb_config_report cfg; \
 849         int ret = cp2112_get_usb_config(hdev, &cfg); \
 850         if (ret) \
 851                 return ret; \
 852         store; \
 853         ret = cp2112_set_usb_config(hdev, &cfg); \
 854         if (ret) \
 855                 return ret; \
 856         chmod_sysfs_attrs(hdev); \
 857         return count; \
 858 } \
 859 static ssize_t name##_show(struct device *kdev, \
 860                            struct device_attribute *attr, char *buf) \
 861 { \
 862         struct hid_device *hdev = to_hid_device(kdev); \
 863         struct cp2112_usb_config_report cfg; \
 864         int ret = cp2112_get_usb_config(hdev, &cfg); \
 865         if (ret) \
 866                 return ret; \
 867         return scnprintf(buf, PAGE_SIZE, format, ##__VA_ARGS__); \
 868 } \
 869 static DEVICE_ATTR_RW(name);
 870
 871 CP2112_CONFIG_ATTR(vendor_id, ({
 872         u16 vid;
 873
 874         if (sscanf(buf, "%hi", &vid) != 1)
 875                 return -EINVAL;
 876
 877         cfg.vid = cpu_to_le16(vid);
 878         cfg.mask = 0x01;
 879 }), "0x%04x\n", le16_to_cpu(cfg.vid));
 880
 881 CP2112_CONFIG_ATTR(product_id, ({
 882         u16 pid;
 883
 884         if (sscanf(buf, "%hi", &pid) != 1)
 885                 return -EINVAL;
 886
 887         cfg.pid = cpu_to_le16(pid);
 888         cfg.mask = 0x02;
 889 }), "0x%04x\n", le16_to_cpu(cfg.pid));
 890
 891 CP2112_CONFIG_ATTR(max_power, ({
 892         int mA;
 893
 894         if (sscanf(buf, "%i", &mA) != 1)
 895                 return -EINVAL;
 896
 897         cfg.max_power = (mA + 1) / 2;
 898         cfg.mask = 0x04;
 899 }), "%u mA\n", cfg.max_power * 2);
 900
 901 CP2112_CONFIG_ATTR(power_mode, ({
 902         if (sscanf(buf, "%hhi", &cfg.power_mode) != 1)
 903                 return -EINVAL;
 904
 905         cfg.mask = 0x08;
 906 }), "%u\n", cfg.power_mode);
 907
 908 CP2112_CONFIG_ATTR(release_version, ({
 909         if (sscanf(buf, "%hhi.%hhi", &cfg.release_major, &cfg.release_minor)
 910             != 2)
 911                 return -EINVAL;
 912
 913         cfg.mask = 0x10;
 914 }), "%u.%u\n", cfg.release_major, cfg.release_minor);
 915
 916 #undef CP2112_CONFIG_ATTR
 917
 918 struct cp2112_pstring_attribute {
 919         struct device_attribute attr;
 920         unsigned char report;
 921 };
 922
 923 static ssize_t pstr_store(struct device *kdev,
 924                           struct device_attribute *kattr, const char *buf,
 925                           size_t count)
 926 {
 927         struct hid_device *hdev = to_hid_device(kdev);
 928         struct cp2112_pstring_attribute *attr =
 929                 container_of(kattr, struct cp2112_pstring_attribute, attr);
 930         struct cp2112_string_report report;
 931         int ret;
 932
 933         memset(&report, 0, sizeof(report));
 934
 935         ret = utf8s_to_utf16s(buf, count, UTF16_LITTLE_ENDIAN,
 936                               report.string, ARRAY_SIZE(report.string));
 937         report.report = attr->report;
 938         report.length = ret * sizeof(report.string[0]) + 2;
 939         report.type = USB_DT_STRING;
 940
 941         ret = cp2112_hid_output(hdev, &report.report, report.length + 1,
 942                                 HID_FEATURE_REPORT);
 943         if (ret != report.length + 1) {
 944                 hid_err(hdev, "error writing %s string: %d\n", kattr->attr.name,
 945                         ret);
 946                 if (ret < 0)
 947                         return ret;
 948                 return -EIO;
 949         }
 950
 951         chmod_sysfs_attrs(hdev);
 952         return count;
 953 }
 954
 955 static ssize_t pstr_show(struct device *kdev,
 956                          struct device_attribute *kattr, char *buf)
 957 {
 958         struct hid_device *hdev = to_hid_device(kdev);
 959         struct cp2112_pstring_attribute *attr =
 960                 container_of(kattr, struct cp2112_pstring_attribute, attr);
 961         struct cp2112_string_report report;
 962         u8 length;
 963         int ret;
 964
 965         ret = cp2112_hid_get(hdev, attr->report, &report.report,
 966                              sizeof(report) - 1, HID_FEATURE_REPORT);
 967         if (ret < 3) {
 968                 hid_err(hdev, "error reading %s string: %d\n", kattr->attr.name,
 969                         ret);
 970                 if (ret < 0)
 971                         return ret;
 972                 return -EIO;
 973         }
 974
 975         if (report.length < 2) {
 976                 hid_err(hdev, "invalid %s string length: %d\n",
 977                         kattr->attr.name, report.length);
 978                 return -EIO;
 979         }
 980
 981         length = report.length > ret - 1 ? ret - 1 : report.length;
 982         length = (length - 2) / sizeof(report.string[0]);
 983         ret = utf16s_to_utf8s(report.string, length, UTF16_LITTLE_ENDIAN, buf,
 984                               PAGE_SIZE - 1);
 985         buf[ret++] = '\n';
 986         return ret;
 987 }
 988
 989 #define CP2112_PSTR_ATTR(name, _report) \
 990 static struct cp2112_pstring_attribute dev_attr_##name = { \
 991         .attr = __ATTR(name, (S_IWUSR | S_IRUGO), pstr_show, pstr_store), \
 992         .report = _report, \
 993 };
 994
 995 CP2112_PSTR_ATTR(manufacturer,  CP2112_MANUFACTURER_STRING);
 996 CP2112_PSTR_ATTR(product,       CP2112_PRODUCT_STRING);
 997 CP2112_PSTR_ATTR(serial,        CP2112_SERIAL_STRING);
 998
 999 #undef CP2112_PSTR_ATTR
1000
1001 static const struct attribute_group cp2112_attr_group = {
1002         .attrs = (struct attribute *[]){
1003                 &dev_attr_vendor_id.attr,
1004                 &dev_attr_product_id.attr,
1005                 &dev_attr_max_power.attr,
1006                 &dev_attr_power_mode.attr,
1007                 &dev_attr_release_version.attr,
1008                 &dev_attr_manufacturer.attr.attr,
1009                 &dev_attr_product.attr.attr,
1010                 &dev_attr_serial.attr.attr,
1011                 NULL
1012         }
1013 };
1014
1015 /* Chmoding our sysfs attributes is simply a way to expose which fields in the
1016  * PROM have already been programmed. We do not depend on this preventing
1017  * writing to these attributes since the CP2112 will simply ignore writes to
1018  * already-programmed fields. This is why there is no sense in fixing this
1019  * racy behaviour.
1020  */
1021 static void chmod_sysfs_attrs(struct hid_device *hdev)
1022 {
1023         struct attribute **attr;
1024         u8 buf[2];
1025         int ret;
1026
1027         ret = cp2112_hid_get(hdev, CP2112_LOCK_BYTE, buf, sizeof(buf),
1028                              HID_FEATURE_REPORT);
1029         if (ret != sizeof(buf)) {
1030                 hid_err(hdev, "error reading lock byte: %d\n", ret);
1031                 return;
1032         }
1033
1034         for (attr = cp2112_attr_group.attrs; *attr; ++attr) {
1035                 umode_t mode = (buf[1] & 1) ? S_IWUSR | S_IRUGO : S_IRUGO;
1036                 ret = sysfs_chmod_file(&hdev->dev.kobj, *attr, mode);
1037                 if (ret < 0)
1038                         hid_err(hdev, "error chmoding sysfs file %s\n",
1039                                 (*attr)->name);
1040                 buf[1] >>= 1;
1041         }
1042 }
1043
1044 static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
1045 {
1046         struct cp2112_device *dev;
1047         u8 buf[3];
1048         struct cp2112_smbus_config_report config;
1049         int ret;
1050
1051         dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
1052         if (!dev)
1053                 return -ENOMEM;
1054
1055         dev->in_out_buffer = devm_kzalloc(&hdev->dev, CP2112_REPORT_MAX_LENGTH,
1056                                           GFP_KERNEL);
1057         if (!dev->in_out_buffer)
1058                 return -ENOMEM;
1059
1060         mutex_init(&dev->lock);
1061
1062         ret = hid_parse(hdev);
1063         if (ret) {
1064                 hid_err(hdev, "parse failed\n");
1065                 return ret;
1066         }
1067
1068         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1069         if (ret) {
1070                 hid_err(hdev, "hw start failed\n");
1071                 return ret;
1072         }
1073
1074         ret = hid_hw_open(hdev);
1075         if (ret) {
1076                 hid_err(hdev, "hw open failed\n");
1077                 goto err_hid_stop;
1078         }
1079
1080         ret = hid_hw_power(hdev, PM_HINT_FULLON);
1081         if (ret < 0) {
1082                 hid_err(hdev, "power management error: %d\n", ret);
1083                 goto err_hid_close;
1084         }
1085
1086         ret = cp2112_hid_get(hdev, CP2112_GET_VERSION_INFO, buf, sizeof(buf),
1087                              HID_FEATURE_REPORT);
1088         if (ret != sizeof(buf)) {
1089                 hid_err(hdev, "error requesting version\n");
1090                 if (ret >= 0)
1091                         ret = -EIO;
1092                 goto err_power_normal;
1093         }
1094
1095         hid_info(hdev, "Part Number: 0x%02X Device Version: 0x%02X\n",
1096                  buf[1], buf[2]);
1097
1098         ret = cp2112_hid_get(hdev, CP2112_SMBUS_CONFIG, (u8 *)&config,
1099                              sizeof(config), HID_FEATURE_REPORT);
1100         if (ret != sizeof(config)) {
1101                 hid_err(hdev, "error requesting SMBus config\n");
1102                 if (ret >= 0)
1103                         ret = -EIO;
1104                 goto err_power_normal;
1105         }
1106
1107         config.retry_time = cpu_to_be16(1);
1108
1109         ret = cp2112_hid_output(hdev, (u8 *)&config, sizeof(config),
1110                                 HID_FEATURE_REPORT);
1111         if (ret != sizeof(config)) {
1112                 hid_err(hdev, "error setting SMBus config\n");
1113                 if (ret >= 0)
1114                         ret = -EIO;
1115                 goto err_power_normal;
1116         }
1117
1118         hid_set_drvdata(hdev, (void *)dev);
1119         dev->hdev               = hdev;
1120         dev->adap.owner         = THIS_MODULE;
1121         dev->adap.class         = I2C_CLASS_HWMON;
1122         dev->adap.algo          = &smbus_algorithm;
1123         dev->adap.algo_data     = dev;
1124         dev->adap.dev.parent    = &hdev->dev;
1125         snprintf(dev->adap.name, sizeof(dev->adap.name),
1126                  "CP2112 SMBus Bridge on hiddev%d", hdev->minor);
1127         dev->hwversion = buf[2];
1128         init_waitqueue_head(&dev->wait);
1129
1130         hid_device_io_start(hdev);
1131         ret = i2c_add_adapter(&dev->adap);
1132         hid_device_io_stop(hdev);
1133
1134         if (ret) {
1135                 hid_err(hdev, "error registering i2c adapter\n");
1136                 goto err_power_normal;
1137         }
1138
1139         hid_dbg(hdev, "adapter registered\n");
1140
1141         dev->gc.label                   = "cp2112_gpio";
1142         dev->gc.direction_input         = cp2112_gpio_direction_input;
1143         dev->gc.direction_output        = cp2112_gpio_direction_output;
1144         dev->gc.set                     = cp2112_gpio_set;
1145         dev->gc.get                     = cp2112_gpio_get;
1146         dev->gc.base                    = -1;
1147         dev->gc.ngpio                   = 8;
1148         dev->gc.can_sleep               = 1;
1149         dev->gc.parent                  = &hdev->dev;
1150
1151         ret = gpiochip_add_data(&dev->gc, dev);
1152         if (ret < 0) {
1153                 hid_err(hdev, "error registering gpio chip\n");
1154                 goto err_free_i2c;
1155         }
1156
1157         ret = sysfs_create_group(&hdev->dev.kobj, &cp2112_attr_group);
1158         if (ret < 0) {
1159                 hid_err(hdev, "error creating sysfs attrs\n");
1160                 goto err_gpiochip_remove;
1161         }
1162
1163         chmod_sysfs_attrs(hdev);
1164         hid_hw_power(hdev, PM_HINT_NORMAL);
1165
1166         return ret;
1167
1168 err_gpiochip_remove:
1169         gpiochip_remove(&dev->gc);
1170 err_free_i2c:
1171         i2c_del_adapter(&dev->adap);
1172 err_power_normal:
1173         hid_hw_power(hdev, PM_HINT_NORMAL);
1174 err_hid_close:
1175         hid_hw_close(hdev);
1176 err_hid_stop:
1177         hid_hw_stop(hdev);
1178         return ret;
1179 }
1180
1181 static void cp2112_remove(struct hid_device *hdev)
1182 {
1183         struct cp2112_device *dev = hid_get_drvdata(hdev);
1184
1185         sysfs_remove_group(&hdev->dev.kobj, &cp2112_attr_group);
1186         gpiochip_remove(&dev->gc);
1187         i2c_del_adapter(&dev->adap);
1188         /* i2c_del_adapter has finished removing all i2c devices from our
1189          * adapter. Well behaved devices should no longer call our cp2112_xfer
1190          * and should have waited for any pending calls to finish. It has also
1191          * waited for device_unregister(&adap->dev) to complete. Therefore we
1192          * can safely free our struct cp2112_device.
1193          */
1194         hid_hw_close(hdev);
1195         hid_hw_stop(hdev);
1196 }
1197
1198 static int cp2112_raw_event(struct hid_device *hdev, struct hid_report *report,
1199                             u8 *data, int size)
1200 {
1201         struct cp2112_device *dev = hid_get_drvdata(hdev);
1202         struct cp2112_xfer_status_report *xfer = (void *)data;
1203
1204         switch (data[0]) {
1205         case CP2112_TRANSFER_STATUS_RESPONSE:
1206                 hid_dbg(hdev, "xfer status: %02x %02x %04x %04x\n",
1207                         xfer->status0, xfer->status1,
1208                         be16_to_cpu(xfer->retries), be16_to_cpu(xfer->length));
1209
1210                 switch (xfer->status0) {
1211                 case STATUS0_IDLE:
1212                         dev->xfer_status = -EAGAIN;
1213                         break;
1214                 case STATUS0_BUSY:
1215                         dev->xfer_status = -EBUSY;
1216                         break;
1217                 case STATUS0_COMPLETE:
1218                         dev->xfer_status = be16_to_cpu(xfer->length);
1219                         break;
1220                 case STATUS0_ERROR:
1221                         switch (xfer->status1) {
1222                         case STATUS1_TIMEOUT_NACK:
1223                         case STATUS1_TIMEOUT_BUS:
1224                                 dev->xfer_status = -ETIMEDOUT;
1225                                 break;
1226                         default:
1227                                 dev->xfer_status = -EIO;
1228                                 break;
1229                         }
1230                         break;
1231                 default:
1232                         dev->xfer_status = -EINVAL;
1233                         break;
1234                 }
1235
1236                 atomic_set(&dev->xfer_avail, 1);
1237                 break;
1238         case CP2112_DATA_READ_RESPONSE:
1239                 hid_dbg(hdev, "read response: %02x %02x\n", data[1], data[2]);
1240
1241                 dev->read_length = data[2];
1242                 if (dev->read_length > sizeof(dev->read_data))
1243                         dev->read_length = sizeof(dev->read_data);
1244
1245                 memcpy(dev->read_data, &data[3], dev->read_length);
1246                 atomic_set(&dev->read_avail, 1);
1247                 break;
1248         default:
1249                 hid_err(hdev, "unknown report\n");
1250
1251                 return 0;
1252         }
1253
1254         wake_up_interruptible(&dev->wait);
1255         return 1;
1256 }
1257
1258 static struct hid_driver cp2112_driver = {
1259         .name           = "cp2112",
1260         .id_table       = cp2112_devices,
1261         .probe          = cp2112_probe,
1262         .remove         = cp2112_remove,
1263         .raw_event      = cp2112_raw_event,
1264 };
1265
1266 module_hid_driver(cp2112_driver);
1267 MODULE_DESCRIPTION("Silicon Labs HID USB to SMBus master bridge");
1268 MODULE_AUTHOR("David Barksdale <dbarksdale@uplogix.com>");
1269 MODULE_LICENSE("GPL");
1270