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