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