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.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 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 int xfer_status; 160 atomic_t read_avail; 161 atomic_t xfer_avail; 162 struct gpio_chip gc; 163 }; 164 165 static int gpio_push_pull = 0xFF; 166 module_param(gpio_push_pull, int, S_IRUGO | S_IWUSR); 167 MODULE_PARM_DESC(gpio_push_pull, "GPIO push-pull configuration bitmask"); 168 169 static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset) 170 { 171 struct cp2112_device *dev = container_of(chip, struct cp2112_device, 172 gc); 173 struct hid_device *hdev = dev->hdev; 174 u8 buf[5]; 175 int ret; 176 177 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, 178 sizeof(buf), HID_FEATURE_REPORT, 179 HID_REQ_GET_REPORT); 180 if (ret != sizeof(buf)) { 181 hid_err(hdev, "error requesting GPIO config: %d\n", ret); 182 return ret; 183 } 184 185 buf[1] &= ~(1 << offset); 186 buf[2] = gpio_push_pull; 187 188 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, sizeof(buf), 189 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 190 if (ret < 0) { 191 hid_err(hdev, "error setting GPIO config: %d\n", ret); 192 return ret; 193 } 194 195 return 0; 196 } 197 198 static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value) 199 { 200 struct cp2112_device *dev = container_of(chip, struct cp2112_device, 201 gc); 202 struct hid_device *hdev = dev->hdev; 203 u8 buf[3]; 204 int ret; 205 206 buf[0] = CP2112_GPIO_SET; 207 buf[1] = value ? 0xff : 0; 208 buf[2] = 1 << offset; 209 210 ret = hid_hw_raw_request(hdev, CP2112_GPIO_SET, buf, sizeof(buf), 211 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 212 if (ret < 0) 213 hid_err(hdev, "error setting GPIO values: %d\n", ret); 214 } 215 216 static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset) 217 { 218 struct cp2112_device *dev = container_of(chip, struct cp2112_device, 219 gc); 220 struct hid_device *hdev = dev->hdev; 221 u8 buf[2]; 222 int ret; 223 224 ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf, sizeof(buf), 225 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 226 if (ret != sizeof(buf)) { 227 hid_err(hdev, "error requesting GPIO values: %d\n", ret); 228 return ret; 229 } 230 231 return (buf[1] >> offset) & 1; 232 } 233 234 static int cp2112_gpio_direction_output(struct gpio_chip *chip, 235 unsigned offset, int value) 236 { 237 struct cp2112_device *dev = container_of(chip, struct cp2112_device, 238 gc); 239 struct hid_device *hdev = dev->hdev; 240 u8 buf[5]; 241 int ret; 242 243 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, 244 sizeof(buf), HID_FEATURE_REPORT, 245 HID_REQ_GET_REPORT); 246 if (ret != sizeof(buf)) { 247 hid_err(hdev, "error requesting GPIO config: %d\n", ret); 248 return ret; 249 } 250 251 buf[1] |= 1 << offset; 252 buf[2] = gpio_push_pull; 253 254 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, sizeof(buf), 255 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 256 if (ret < 0) { 257 hid_err(hdev, "error setting GPIO config: %d\n", ret); 258 return ret; 259 } 260 261 /* 262 * Set gpio value when output direction is already set, 263 * as specified in AN495, Rev. 0.2, cpt. 4.4 264 */ 265 cp2112_gpio_set(chip, offset, value); 266 267 return 0; 268 } 269 270 static int cp2112_hid_get(struct hid_device *hdev, unsigned char report_number, 271 u8 *data, size_t count, unsigned char report_type) 272 { 273 u8 *buf; 274 int ret; 275 276 buf = kmalloc(count, GFP_KERNEL); 277 if (!buf) 278 return -ENOMEM; 279 280 ret = hid_hw_raw_request(hdev, report_number, buf, count, 281 report_type, HID_REQ_GET_REPORT); 282 memcpy(data, buf, count); 283 kfree(buf); 284 return ret; 285 } 286 287 static int cp2112_hid_output(struct hid_device *hdev, u8 *data, size_t count, 288 unsigned char report_type) 289 { 290 u8 *buf; 291 int ret; 292 293 buf = kmemdup(data, count, GFP_KERNEL); 294 if (!buf) 295 return -ENOMEM; 296 297 if (report_type == HID_OUTPUT_REPORT) 298 ret = hid_hw_output_report(hdev, buf, count); 299 else 300 ret = hid_hw_raw_request(hdev, buf[0], buf, count, report_type, 301 HID_REQ_SET_REPORT); 302 303 kfree(buf); 304 return ret; 305 } 306 307 static int cp2112_wait(struct cp2112_device *dev, atomic_t *avail) 308 { 309 int ret = 0; 310 311 /* We have sent either a CP2112_TRANSFER_STATUS_REQUEST or a 312 * CP2112_DATA_READ_FORCE_SEND and we are waiting for the response to 313 * come in cp2112_raw_event or timeout. There will only be one of these 314 * in flight at any one time. The timeout is extremely large and is a 315 * last resort if the CP2112 has died. If we do timeout we don't expect 316 * to receive the response which would cause data races, it's not like 317 * we can do anything about it anyway. 318 */ 319 ret = wait_event_interruptible_timeout(dev->wait, 320 atomic_read(avail), msecs_to_jiffies(RESPONSE_TIMEOUT)); 321 if (-ERESTARTSYS == ret) 322 return ret; 323 if (!ret) 324 return -ETIMEDOUT; 325 326 atomic_set(avail, 0); 327 return 0; 328 } 329 330 static int cp2112_xfer_status(struct cp2112_device *dev) 331 { 332 struct hid_device *hdev = dev->hdev; 333 u8 buf[2]; 334 int ret; 335 336 buf[0] = CP2112_TRANSFER_STATUS_REQUEST; 337 buf[1] = 0x01; 338 atomic_set(&dev->xfer_avail, 0); 339 340 ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT); 341 if (ret < 0) { 342 hid_warn(hdev, "Error requesting status: %d\n", ret); 343 return ret; 344 } 345 346 ret = cp2112_wait(dev, &dev->xfer_avail); 347 if (ret) 348 return ret; 349 350 return dev->xfer_status; 351 } 352 353 static int cp2112_read(struct cp2112_device *dev, u8 *data, size_t size) 354 { 355 struct hid_device *hdev = dev->hdev; 356 struct cp2112_force_read_report report; 357 int ret; 358 359 if (size > sizeof(dev->read_data)) 360 size = sizeof(dev->read_data); 361 report.report = CP2112_DATA_READ_FORCE_SEND; 362 report.length = cpu_to_be16(size); 363 364 atomic_set(&dev->read_avail, 0); 365 366 ret = cp2112_hid_output(hdev, &report.report, sizeof(report), 367 HID_OUTPUT_REPORT); 368 if (ret < 0) { 369 hid_warn(hdev, "Error requesting data: %d\n", ret); 370 return ret; 371 } 372 373 ret = cp2112_wait(dev, &dev->read_avail); 374 if (ret) 375 return ret; 376 377 hid_dbg(hdev, "read %d of %zd bytes requested\n", 378 dev->read_length, size); 379 380 if (size > dev->read_length) 381 size = dev->read_length; 382 383 memcpy(data, dev->read_data, size); 384 return dev->read_length; 385 } 386 387 static int cp2112_read_req(void *buf, u8 slave_address, u16 length) 388 { 389 struct cp2112_read_req_report *report = buf; 390 391 if (length < 1 || length > 512) 392 return -EINVAL; 393 394 report->report = CP2112_DATA_READ_REQUEST; 395 report->slave_address = slave_address << 1; 396 report->length = cpu_to_be16(length); 397 return sizeof(*report); 398 } 399 400 static int cp2112_write_read_req(void *buf, u8 slave_address, u16 length, 401 u8 command, u8 *data, u8 data_length) 402 { 403 struct cp2112_write_read_req_report *report = buf; 404 405 if (length < 1 || length > 512 406 || data_length > sizeof(report->target_address) - 1) 407 return -EINVAL; 408 409 report->report = CP2112_DATA_WRITE_READ_REQUEST; 410 report->slave_address = slave_address << 1; 411 report->length = cpu_to_be16(length); 412 report->target_address_length = data_length + 1; 413 report->target_address[0] = command; 414 memcpy(&report->target_address[1], data, data_length); 415 return data_length + 6; 416 } 417 418 static int cp2112_write_req(void *buf, u8 slave_address, u8 command, u8 *data, 419 u8 data_length) 420 { 421 struct cp2112_write_req_report *report = buf; 422 423 if (data_length > sizeof(report->data) - 1) 424 return -EINVAL; 425 426 report->report = CP2112_DATA_WRITE_REQUEST; 427 report->slave_address = slave_address << 1; 428 report->length = data_length + 1; 429 report->data[0] = command; 430 memcpy(&report->data[1], data, data_length); 431 return data_length + 4; 432 } 433 434 static int cp2112_i2c_write_req(void *buf, u8 slave_address, u8 *data, 435 u8 data_length) 436 { 437 struct cp2112_write_req_report *report = buf; 438 439 if (data_length > sizeof(report->data)) 440 return -EINVAL; 441 442 report->report = CP2112_DATA_WRITE_REQUEST; 443 report->slave_address = slave_address << 1; 444 report->length = data_length; 445 memcpy(report->data, data, data_length); 446 return data_length + 3; 447 } 448 449 static int cp2112_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, 450 int num) 451 { 452 struct cp2112_device *dev = (struct cp2112_device *)adap->algo_data; 453 struct hid_device *hdev = dev->hdev; 454 u8 buf[64]; 455 ssize_t count; 456 unsigned int retries; 457 int ret; 458 459 hid_dbg(hdev, "I2C %d messages\n", num); 460 461 if (num != 1) { 462 hid_err(hdev, 463 "Multi-message I2C transactions not supported\n"); 464 return -EOPNOTSUPP; 465 } 466 467 if (msgs->flags & I2C_M_RD) 468 count = cp2112_read_req(buf, msgs->addr, msgs->len); 469 else 470 count = cp2112_i2c_write_req(buf, msgs->addr, msgs->buf, 471 msgs->len); 472 473 if (count < 0) 474 return count; 475 476 ret = hid_hw_power(hdev, PM_HINT_FULLON); 477 if (ret < 0) { 478 hid_err(hdev, "power management error: %d\n", ret); 479 return ret; 480 } 481 482 ret = cp2112_hid_output(hdev, buf, count, HID_OUTPUT_REPORT); 483 if (ret < 0) { 484 hid_warn(hdev, "Error starting transaction: %d\n", ret); 485 goto power_normal; 486 } 487 488 for (retries = 0; retries < XFER_STATUS_RETRIES; ++retries) { 489 ret = cp2112_xfer_status(dev); 490 if (-EBUSY == ret) 491 continue; 492 if (ret < 0) 493 goto power_normal; 494 break; 495 } 496 497 if (XFER_STATUS_RETRIES <= retries) { 498 hid_warn(hdev, "Transfer timed out, cancelling.\n"); 499 buf[0] = CP2112_CANCEL_TRANSFER; 500 buf[1] = 0x01; 501 502 ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT); 503 if (ret < 0) 504 hid_warn(hdev, "Error cancelling transaction: %d\n", 505 ret); 506 507 ret = -ETIMEDOUT; 508 goto power_normal; 509 } 510 511 if (!(msgs->flags & I2C_M_RD)) 512 goto finish; 513 514 ret = cp2112_read(dev, msgs->buf, msgs->len); 515 if (ret < 0) 516 goto power_normal; 517 if (ret != msgs->len) { 518 hid_warn(hdev, "short read: %d < %d\n", ret, msgs->len); 519 ret = -EIO; 520 goto power_normal; 521 } 522 523 finish: 524 /* return the number of transferred messages */ 525 ret = 1; 526 527 power_normal: 528 hid_hw_power(hdev, PM_HINT_NORMAL); 529 hid_dbg(hdev, "I2C transfer finished: %d\n", ret); 530 return ret; 531 } 532 533 static int cp2112_xfer(struct i2c_adapter *adap, u16 addr, 534 unsigned short flags, char read_write, u8 command, 535 int size, union i2c_smbus_data *data) 536 { 537 struct cp2112_device *dev = (struct cp2112_device *)adap->algo_data; 538 struct hid_device *hdev = dev->hdev; 539 u8 buf[64]; 540 __be16 word; 541 ssize_t count; 542 size_t read_length = 0; 543 unsigned int retries; 544 int ret; 545 546 hid_dbg(hdev, "%s addr 0x%x flags 0x%x cmd 0x%x size %d\n", 547 read_write == I2C_SMBUS_WRITE ? "write" : "read", 548 addr, flags, command, size); 549 550 switch (size) { 551 case I2C_SMBUS_BYTE: 552 read_length = 1; 553 554 if (I2C_SMBUS_READ == read_write) 555 count = cp2112_read_req(buf, addr, read_length); 556 else 557 count = cp2112_write_req(buf, addr, data->byte, NULL, 558 0); 559 break; 560 case I2C_SMBUS_BYTE_DATA: 561 read_length = 1; 562 563 if (I2C_SMBUS_READ == read_write) 564 count = cp2112_write_read_req(buf, addr, read_length, 565 command, NULL, 0); 566 else 567 count = cp2112_write_req(buf, addr, command, 568 &data->byte, 1); 569 break; 570 case I2C_SMBUS_WORD_DATA: 571 read_length = 2; 572 word = cpu_to_be16(data->word); 573 574 if (I2C_SMBUS_READ == read_write) 575 count = cp2112_write_read_req(buf, addr, read_length, 576 command, NULL, 0); 577 else 578 count = cp2112_write_req(buf, addr, command, 579 (u8 *)&word, 2); 580 break; 581 case I2C_SMBUS_PROC_CALL: 582 size = I2C_SMBUS_WORD_DATA; 583 read_write = I2C_SMBUS_READ; 584 read_length = 2; 585 word = cpu_to_be16(data->word); 586 587 count = cp2112_write_read_req(buf, addr, read_length, command, 588 (u8 *)&word, 2); 589 break; 590 case I2C_SMBUS_I2C_BLOCK_DATA: 591 size = I2C_SMBUS_BLOCK_DATA; 592 /* fallthrough */ 593 case I2C_SMBUS_BLOCK_DATA: 594 if (I2C_SMBUS_READ == read_write) { 595 count = cp2112_write_read_req(buf, addr, 596 I2C_SMBUS_BLOCK_MAX, 597 command, NULL, 0); 598 } else { 599 count = cp2112_write_req(buf, addr, command, 600 data->block, 601 data->block[0] + 1); 602 } 603 break; 604 case I2C_SMBUS_BLOCK_PROC_CALL: 605 size = I2C_SMBUS_BLOCK_DATA; 606 read_write = I2C_SMBUS_READ; 607 608 count = cp2112_write_read_req(buf, addr, I2C_SMBUS_BLOCK_MAX, 609 command, data->block, 610 data->block[0] + 1); 611 break; 612 default: 613 hid_warn(hdev, "Unsupported transaction %d\n", size); 614 return -EOPNOTSUPP; 615 } 616 617 if (count < 0) 618 return count; 619 620 ret = hid_hw_power(hdev, PM_HINT_FULLON); 621 if (ret < 0) { 622 hid_err(hdev, "power management error: %d\n", ret); 623 return ret; 624 } 625 626 ret = cp2112_hid_output(hdev, buf, count, HID_OUTPUT_REPORT); 627 if (ret < 0) { 628 hid_warn(hdev, "Error starting transaction: %d\n", ret); 629 goto power_normal; 630 } 631 632 for (retries = 0; retries < XFER_STATUS_RETRIES; ++retries) { 633 ret = cp2112_xfer_status(dev); 634 if (-EBUSY == ret) 635 continue; 636 if (ret < 0) 637 goto power_normal; 638 break; 639 } 640 641 if (XFER_STATUS_RETRIES <= retries) { 642 hid_warn(hdev, "Transfer timed out, cancelling.\n"); 643 buf[0] = CP2112_CANCEL_TRANSFER; 644 buf[1] = 0x01; 645 646 ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT); 647 if (ret < 0) 648 hid_warn(hdev, "Error cancelling transaction: %d\n", 649 ret); 650 651 ret = -ETIMEDOUT; 652 goto power_normal; 653 } 654 655 if (I2C_SMBUS_WRITE == read_write) { 656 ret = 0; 657 goto power_normal; 658 } 659 660 if (I2C_SMBUS_BLOCK_DATA == size) 661 read_length = ret; 662 663 ret = cp2112_read(dev, buf, read_length); 664 if (ret < 0) 665 goto power_normal; 666 if (ret != read_length) { 667 hid_warn(hdev, "short read: %d < %zd\n", ret, read_length); 668 ret = -EIO; 669 goto power_normal; 670 } 671 672 switch (size) { 673 case I2C_SMBUS_BYTE: 674 case I2C_SMBUS_BYTE_DATA: 675 data->byte = buf[0]; 676 break; 677 case I2C_SMBUS_WORD_DATA: 678 data->word = be16_to_cpup((__be16 *)buf); 679 break; 680 case I2C_SMBUS_BLOCK_DATA: 681 if (read_length > I2C_SMBUS_BLOCK_MAX) { 682 ret = -EPROTO; 683 goto power_normal; 684 } 685 686 memcpy(data->block, buf, read_length); 687 break; 688 } 689 690 ret = 0; 691 power_normal: 692 hid_hw_power(hdev, PM_HINT_NORMAL); 693 hid_dbg(hdev, "transfer finished: %d\n", ret); 694 return ret; 695 } 696 697 static u32 cp2112_functionality(struct i2c_adapter *adap) 698 { 699 return I2C_FUNC_I2C | 700 I2C_FUNC_SMBUS_BYTE | 701 I2C_FUNC_SMBUS_BYTE_DATA | 702 I2C_FUNC_SMBUS_WORD_DATA | 703 I2C_FUNC_SMBUS_BLOCK_DATA | 704 I2C_FUNC_SMBUS_I2C_BLOCK | 705 I2C_FUNC_SMBUS_PROC_CALL | 706 I2C_FUNC_SMBUS_BLOCK_PROC_CALL; 707 } 708 709 static const struct i2c_algorithm smbus_algorithm = { 710 .master_xfer = cp2112_i2c_xfer, 711 .smbus_xfer = cp2112_xfer, 712 .functionality = cp2112_functionality, 713 }; 714 715 static int cp2112_get_usb_config(struct hid_device *hdev, 716 struct cp2112_usb_config_report *cfg) 717 { 718 int ret; 719 720 ret = cp2112_hid_get(hdev, CP2112_USB_CONFIG, (u8 *)cfg, sizeof(*cfg), 721 HID_FEATURE_REPORT); 722 if (ret != sizeof(*cfg)) { 723 hid_err(hdev, "error reading usb config: %d\n", ret); 724 if (ret < 0) 725 return ret; 726 return -EIO; 727 } 728 729 return 0; 730 } 731 732 static int cp2112_set_usb_config(struct hid_device *hdev, 733 struct cp2112_usb_config_report *cfg) 734 { 735 int ret; 736 737 BUG_ON(cfg->report != CP2112_USB_CONFIG); 738 739 ret = cp2112_hid_output(hdev, (u8 *)cfg, sizeof(*cfg), 740 HID_FEATURE_REPORT); 741 if (ret != sizeof(*cfg)) { 742 hid_err(hdev, "error writing usb config: %d\n", ret); 743 if (ret < 0) 744 return ret; 745 return -EIO; 746 } 747 748 return 0; 749 } 750 751 static void chmod_sysfs_attrs(struct hid_device *hdev); 752 753 #define CP2112_CONFIG_ATTR(name, store, format, ...) \ 754 static ssize_t name##_store(struct device *kdev, \ 755 struct device_attribute *attr, const char *buf, \ 756 size_t count) \ 757 { \ 758 struct hid_device *hdev = container_of(kdev, struct hid_device, dev); \ 759 struct cp2112_usb_config_report cfg; \ 760 int ret = cp2112_get_usb_config(hdev, &cfg); \ 761 if (ret) \ 762 return ret; \ 763 store; \ 764 ret = cp2112_set_usb_config(hdev, &cfg); \ 765 if (ret) \ 766 return ret; \ 767 chmod_sysfs_attrs(hdev); \ 768 return count; \ 769 } \ 770 static ssize_t name##_show(struct device *kdev, \ 771 struct device_attribute *attr, char *buf) \ 772 { \ 773 struct hid_device *hdev = container_of(kdev, struct hid_device, dev); \ 774 struct cp2112_usb_config_report cfg; \ 775 int ret = cp2112_get_usb_config(hdev, &cfg); \ 776 if (ret) \ 777 return ret; \ 778 return scnprintf(buf, PAGE_SIZE, format, ##__VA_ARGS__); \ 779 } \ 780 static DEVICE_ATTR_RW(name); 781 782 CP2112_CONFIG_ATTR(vendor_id, ({ 783 u16 vid; 784 785 if (sscanf(buf, "%hi", &vid) != 1) 786 return -EINVAL; 787 788 cfg.vid = cpu_to_le16(vid); 789 cfg.mask = 0x01; 790 }), "0x%04x\n", le16_to_cpu(cfg.vid)); 791 792 CP2112_CONFIG_ATTR(product_id, ({ 793 u16 pid; 794 795 if (sscanf(buf, "%hi", &pid) != 1) 796 return -EINVAL; 797 798 cfg.pid = cpu_to_le16(pid); 799 cfg.mask = 0x02; 800 }), "0x%04x\n", le16_to_cpu(cfg.pid)); 801 802 CP2112_CONFIG_ATTR(max_power, ({ 803 int mA; 804 805 if (sscanf(buf, "%i", &mA) != 1) 806 return -EINVAL; 807 808 cfg.max_power = (mA + 1) / 2; 809 cfg.mask = 0x04; 810 }), "%u mA\n", cfg.max_power * 2); 811 812 CP2112_CONFIG_ATTR(power_mode, ({ 813 if (sscanf(buf, "%hhi", &cfg.power_mode) != 1) 814 return -EINVAL; 815 816 cfg.mask = 0x08; 817 }), "%u\n", cfg.power_mode); 818 819 CP2112_CONFIG_ATTR(release_version, ({ 820 if (sscanf(buf, "%hhi.%hhi", &cfg.release_major, &cfg.release_minor) 821 != 2) 822 return -EINVAL; 823 824 cfg.mask = 0x10; 825 }), "%u.%u\n", cfg.release_major, cfg.release_minor); 826 827 #undef CP2112_CONFIG_ATTR 828 829 struct cp2112_pstring_attribute { 830 struct device_attribute attr; 831 unsigned char report; 832 }; 833 834 static ssize_t pstr_store(struct device *kdev, 835 struct device_attribute *kattr, const char *buf, 836 size_t count) 837 { 838 struct hid_device *hdev = container_of(kdev, struct hid_device, dev); 839 struct cp2112_pstring_attribute *attr = 840 container_of(kattr, struct cp2112_pstring_attribute, attr); 841 struct cp2112_string_report report; 842 int ret; 843 844 memset(&report, 0, sizeof(report)); 845 846 ret = utf8s_to_utf16s(buf, count, UTF16_LITTLE_ENDIAN, 847 report.string, ARRAY_SIZE(report.string)); 848 report.report = attr->report; 849 report.length = ret * sizeof(report.string[0]) + 2; 850 report.type = USB_DT_STRING; 851 852 ret = cp2112_hid_output(hdev, &report.report, report.length + 1, 853 HID_FEATURE_REPORT); 854 if (ret != report.length + 1) { 855 hid_err(hdev, "error writing %s string: %d\n", kattr->attr.name, 856 ret); 857 if (ret < 0) 858 return ret; 859 return -EIO; 860 } 861 862 chmod_sysfs_attrs(hdev); 863 return count; 864 } 865 866 static ssize_t pstr_show(struct device *kdev, 867 struct device_attribute *kattr, char *buf) 868 { 869 struct hid_device *hdev = container_of(kdev, struct hid_device, dev); 870 struct cp2112_pstring_attribute *attr = 871 container_of(kattr, struct cp2112_pstring_attribute, attr); 872 struct cp2112_string_report report; 873 u8 length; 874 int ret; 875 876 ret = cp2112_hid_get(hdev, attr->report, &report.report, 877 sizeof(report) - 1, HID_FEATURE_REPORT); 878 if (ret < 3) { 879 hid_err(hdev, "error reading %s string: %d\n", kattr->attr.name, 880 ret); 881 if (ret < 0) 882 return ret; 883 return -EIO; 884 } 885 886 if (report.length < 2) { 887 hid_err(hdev, "invalid %s string length: %d\n", 888 kattr->attr.name, report.length); 889 return -EIO; 890 } 891 892 length = report.length > ret - 1 ? ret - 1 : report.length; 893 length = (length - 2) / sizeof(report.string[0]); 894 ret = utf16s_to_utf8s(report.string, length, UTF16_LITTLE_ENDIAN, buf, 895 PAGE_SIZE - 1); 896 buf[ret++] = '\n'; 897 return ret; 898 } 899 900 #define CP2112_PSTR_ATTR(name, _report) \ 901 static struct cp2112_pstring_attribute dev_attr_##name = { \ 902 .attr = __ATTR(name, (S_IWUSR | S_IRUGO), pstr_show, pstr_store), \ 903 .report = _report, \ 904 }; 905 906 CP2112_PSTR_ATTR(manufacturer, CP2112_MANUFACTURER_STRING); 907 CP2112_PSTR_ATTR(product, CP2112_PRODUCT_STRING); 908 CP2112_PSTR_ATTR(serial, CP2112_SERIAL_STRING); 909 910 #undef CP2112_PSTR_ATTR 911 912 static const struct attribute_group cp2112_attr_group = { 913 .attrs = (struct attribute *[]){ 914 &dev_attr_vendor_id.attr, 915 &dev_attr_product_id.attr, 916 &dev_attr_max_power.attr, 917 &dev_attr_power_mode.attr, 918 &dev_attr_release_version.attr, 919 &dev_attr_manufacturer.attr.attr, 920 &dev_attr_product.attr.attr, 921 &dev_attr_serial.attr.attr, 922 NULL 923 } 924 }; 925 926 /* Chmoding our sysfs attributes is simply a way to expose which fields in the 927 * PROM have already been programmed. We do not depend on this preventing 928 * writing to these attributes since the CP2112 will simply ignore writes to 929 * already-programmed fields. This is why there is no sense in fixing this 930 * racy behaviour. 931 */ 932 static void chmod_sysfs_attrs(struct hid_device *hdev) 933 { 934 struct attribute **attr; 935 u8 buf[2]; 936 int ret; 937 938 ret = cp2112_hid_get(hdev, CP2112_LOCK_BYTE, buf, sizeof(buf), 939 HID_FEATURE_REPORT); 940 if (ret != sizeof(buf)) { 941 hid_err(hdev, "error reading lock byte: %d\n", ret); 942 return; 943 } 944 945 for (attr = cp2112_attr_group.attrs; *attr; ++attr) { 946 umode_t mode = (buf[1] & 1) ? S_IWUSR | S_IRUGO : S_IRUGO; 947 ret = sysfs_chmod_file(&hdev->dev.kobj, *attr, mode); 948 if (ret < 0) 949 hid_err(hdev, "error chmoding sysfs file %s\n", 950 (*attr)->name); 951 buf[1] >>= 1; 952 } 953 } 954 955 static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id) 956 { 957 struct cp2112_device *dev; 958 u8 buf[3]; 959 struct cp2112_smbus_config_report config; 960 int ret; 961 962 ret = hid_parse(hdev); 963 if (ret) { 964 hid_err(hdev, "parse failed\n"); 965 return ret; 966 } 967 968 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); 969 if (ret) { 970 hid_err(hdev, "hw start failed\n"); 971 return ret; 972 } 973 974 ret = hid_hw_open(hdev); 975 if (ret) { 976 hid_err(hdev, "hw open failed\n"); 977 goto err_hid_stop; 978 } 979 980 ret = hid_hw_power(hdev, PM_HINT_FULLON); 981 if (ret < 0) { 982 hid_err(hdev, "power management error: %d\n", ret); 983 goto err_hid_close; 984 } 985 986 ret = cp2112_hid_get(hdev, CP2112_GET_VERSION_INFO, buf, sizeof(buf), 987 HID_FEATURE_REPORT); 988 if (ret != sizeof(buf)) { 989 hid_err(hdev, "error requesting version\n"); 990 if (ret >= 0) 991 ret = -EIO; 992 goto err_power_normal; 993 } 994 995 hid_info(hdev, "Part Number: 0x%02X Device Version: 0x%02X\n", 996 buf[1], buf[2]); 997 998 ret = cp2112_hid_get(hdev, CP2112_SMBUS_CONFIG, (u8 *)&config, 999 sizeof(config), HID_FEATURE_REPORT); 1000 if (ret != sizeof(config)) { 1001 hid_err(hdev, "error requesting SMBus config\n"); 1002 if (ret >= 0) 1003 ret = -EIO; 1004 goto err_power_normal; 1005 } 1006 1007 config.retry_time = cpu_to_be16(1); 1008 1009 ret = cp2112_hid_output(hdev, (u8 *)&config, sizeof(config), 1010 HID_FEATURE_REPORT); 1011 if (ret != sizeof(config)) { 1012 hid_err(hdev, "error setting SMBus config\n"); 1013 if (ret >= 0) 1014 ret = -EIO; 1015 goto err_power_normal; 1016 } 1017 1018 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1019 if (!dev) { 1020 ret = -ENOMEM; 1021 goto err_power_normal; 1022 } 1023 1024 hid_set_drvdata(hdev, (void *)dev); 1025 dev->hdev = hdev; 1026 dev->adap.owner = THIS_MODULE; 1027 dev->adap.class = I2C_CLASS_HWMON; 1028 dev->adap.algo = &smbus_algorithm; 1029 dev->adap.algo_data = dev; 1030 dev->adap.dev.parent = &hdev->dev; 1031 snprintf(dev->adap.name, sizeof(dev->adap.name), 1032 "CP2112 SMBus Bridge on hiddev%d", hdev->minor); 1033 init_waitqueue_head(&dev->wait); 1034 1035 hid_device_io_start(hdev); 1036 ret = i2c_add_adapter(&dev->adap); 1037 hid_device_io_stop(hdev); 1038 1039 if (ret) { 1040 hid_err(hdev, "error registering i2c adapter\n"); 1041 goto err_free_dev; 1042 } 1043 1044 hid_dbg(hdev, "adapter registered\n"); 1045 1046 dev->gc.label = "cp2112_gpio"; 1047 dev->gc.direction_input = cp2112_gpio_direction_input; 1048 dev->gc.direction_output = cp2112_gpio_direction_output; 1049 dev->gc.set = cp2112_gpio_set; 1050 dev->gc.get = cp2112_gpio_get; 1051 dev->gc.base = -1; 1052 dev->gc.ngpio = 8; 1053 dev->gc.can_sleep = 1; 1054 dev->gc.dev = &hdev->dev; 1055 1056 ret = gpiochip_add(&dev->gc); 1057 if (ret < 0) { 1058 hid_err(hdev, "error registering gpio chip\n"); 1059 goto err_free_i2c; 1060 } 1061 1062 ret = sysfs_create_group(&hdev->dev.kobj, &cp2112_attr_group); 1063 if (ret < 0) { 1064 hid_err(hdev, "error creating sysfs attrs\n"); 1065 goto err_gpiochip_remove; 1066 } 1067 1068 chmod_sysfs_attrs(hdev); 1069 hid_hw_power(hdev, PM_HINT_NORMAL); 1070 1071 return ret; 1072 1073 err_gpiochip_remove: 1074 gpiochip_remove(&dev->gc); 1075 err_free_i2c: 1076 i2c_del_adapter(&dev->adap); 1077 err_free_dev: 1078 kfree(dev); 1079 err_power_normal: 1080 hid_hw_power(hdev, PM_HINT_NORMAL); 1081 err_hid_close: 1082 hid_hw_close(hdev); 1083 err_hid_stop: 1084 hid_hw_stop(hdev); 1085 return ret; 1086 } 1087 1088 static void cp2112_remove(struct hid_device *hdev) 1089 { 1090 struct cp2112_device *dev = hid_get_drvdata(hdev); 1091 1092 sysfs_remove_group(&hdev->dev.kobj, &cp2112_attr_group); 1093 gpiochip_remove(&dev->gc); 1094 i2c_del_adapter(&dev->adap); 1095 /* i2c_del_adapter has finished removing all i2c devices from our 1096 * adapter. Well behaved devices should no longer call our cp2112_xfer 1097 * and should have waited for any pending calls to finish. It has also 1098 * waited for device_unregister(&adap->dev) to complete. Therefore we 1099 * can safely free our struct cp2112_device. 1100 */ 1101 hid_hw_close(hdev); 1102 hid_hw_stop(hdev); 1103 kfree(dev); 1104 } 1105 1106 static int cp2112_raw_event(struct hid_device *hdev, struct hid_report *report, 1107 u8 *data, int size) 1108 { 1109 struct cp2112_device *dev = hid_get_drvdata(hdev); 1110 struct cp2112_xfer_status_report *xfer = (void *)data; 1111 1112 switch (data[0]) { 1113 case CP2112_TRANSFER_STATUS_RESPONSE: 1114 hid_dbg(hdev, "xfer status: %02x %02x %04x %04x\n", 1115 xfer->status0, xfer->status1, 1116 be16_to_cpu(xfer->retries), be16_to_cpu(xfer->length)); 1117 1118 switch (xfer->status0) { 1119 case STATUS0_IDLE: 1120 dev->xfer_status = -EAGAIN; 1121 break; 1122 case STATUS0_BUSY: 1123 dev->xfer_status = -EBUSY; 1124 break; 1125 case STATUS0_COMPLETE: 1126 dev->xfer_status = be16_to_cpu(xfer->length); 1127 break; 1128 case STATUS0_ERROR: 1129 switch (xfer->status1) { 1130 case STATUS1_TIMEOUT_NACK: 1131 case STATUS1_TIMEOUT_BUS: 1132 dev->xfer_status = -ETIMEDOUT; 1133 break; 1134 default: 1135 dev->xfer_status = -EIO; 1136 break; 1137 } 1138 break; 1139 default: 1140 dev->xfer_status = -EINVAL; 1141 break; 1142 } 1143 1144 atomic_set(&dev->xfer_avail, 1); 1145 break; 1146 case CP2112_DATA_READ_RESPONSE: 1147 hid_dbg(hdev, "read response: %02x %02x\n", data[1], data[2]); 1148 1149 dev->read_length = data[2]; 1150 if (dev->read_length > sizeof(dev->read_data)) 1151 dev->read_length = sizeof(dev->read_data); 1152 1153 memcpy(dev->read_data, &data[3], dev->read_length); 1154 atomic_set(&dev->read_avail, 1); 1155 break; 1156 default: 1157 hid_err(hdev, "unknown report\n"); 1158 1159 return 0; 1160 } 1161 1162 wake_up_interruptible(&dev->wait); 1163 return 1; 1164 } 1165 1166 static struct hid_driver cp2112_driver = { 1167 .name = "cp2112", 1168 .id_table = cp2112_devices, 1169 .probe = cp2112_probe, 1170 .remove = cp2112_remove, 1171 .raw_event = cp2112_raw_event, 1172 }; 1173 1174 module_hid_driver(cp2112_driver); 1175 MODULE_DESCRIPTION("Silicon Labs HID USB to SMBus master bridge"); 1176 MODULE_AUTHOR("David Barksdale <dbarksdale@uplogix.com>"); 1177 MODULE_LICENSE("GPL"); 1178 1179