1 // SPDX-License-Identifier: GPL-2.0-only
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>
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.
14 * https://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
19 #include <linux/bitops.h>
20 #include <linux/gpio/driver.h>
21 #include <linux/hid.h>
22 #include <linux/hidraw.h>
23 #include <linux/i2c.h>
24 #include <linux/module.h>
25 #include <linux/nls.h>
26 #include <linux/string_choices.h>
27 #include <linux/usb/ch9.h>
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 #define CP2112_GPIO_MAX_GPIO 8
35 #define CP2112_GPIO_ALL_GPIO_MASK GENMASK(7, 0)
38 CP2112_GPIO_CONFIG
= 0x02,
39 CP2112_GPIO_GET
= 0x03,
40 CP2112_GPIO_SET
= 0x04,
41 CP2112_GET_VERSION_INFO
= 0x05,
42 CP2112_SMBUS_CONFIG
= 0x06,
43 CP2112_DATA_READ_REQUEST
= 0x10,
44 CP2112_DATA_WRITE_READ_REQUEST
= 0x11,
45 CP2112_DATA_READ_FORCE_SEND
= 0x12,
46 CP2112_DATA_READ_RESPONSE
= 0x13,
47 CP2112_DATA_WRITE_REQUEST
= 0x14,
48 CP2112_TRANSFER_STATUS_REQUEST
= 0x15,
49 CP2112_TRANSFER_STATUS_RESPONSE
= 0x16,
50 CP2112_CANCEL_TRANSFER
= 0x17,
51 CP2112_LOCK_BYTE
= 0x20,
52 CP2112_USB_CONFIG
= 0x21,
53 CP2112_MANUFACTURER_STRING
= 0x22,
54 CP2112_PRODUCT_STRING
= 0x23,
55 CP2112_SERIAL_STRING
= 0x24,
61 STATUS0_COMPLETE
= 0x02,
66 STATUS1_TIMEOUT_NACK
= 0x00,
67 STATUS1_TIMEOUT_BUS
= 0x01,
68 STATUS1_ARBITRATION_LOST
= 0x02,
69 STATUS1_READ_INCOMPLETE
= 0x03,
70 STATUS1_WRITE_INCOMPLETE
= 0x04,
71 STATUS1_SUCCESS
= 0x05,
74 struct cp2112_smbus_config_report
{
75 u8 report
; /* CP2112_SMBUS_CONFIG */
76 __be32 clock_speed
; /* Hz */
77 u8 device_address
; /* Stored in the upper 7 bits */
78 u8 auto_send_read
; /* 1 = enabled, 0 = disabled */
79 __be16 write_timeout
; /* ms, 0 = no timeout */
80 __be16 read_timeout
; /* ms, 0 = no timeout */
81 u8 scl_low_timeout
; /* 1 = enabled, 0 = disabled */
82 __be16 retry_time
; /* # of retries, 0 = no limit */
85 struct cp2112_usb_config_report
{
86 u8 report
; /* CP2112_USB_CONFIG */
87 __le16 vid
; /* Vendor ID */
88 __le16 pid
; /* Product ID */
89 u8 max_power
; /* Power requested in 2mA units */
90 u8 power_mode
; /* 0x00 = bus powered
91 0x01 = self powered & regulator off
92 0x02 = self powered & regulator on */
95 u8 mask
; /* What fields to program */
98 struct cp2112_read_req_report
{
99 u8 report
; /* CP2112_DATA_READ_REQUEST */
104 struct cp2112_write_read_req_report
{
105 u8 report
; /* CP2112_DATA_WRITE_READ_REQUEST */
108 u8 target_address_length
;
109 u8 target_address
[16];
112 struct cp2112_write_req_report
{
113 u8 report
; /* CP2112_DATA_WRITE_REQUEST */
119 struct cp2112_force_read_report
{
120 u8 report
; /* CP2112_DATA_READ_FORCE_SEND */
124 struct cp2112_xfer_status_report
{
125 u8 report
; /* CP2112_TRANSFER_STATUS_RESPONSE */
126 u8 status0
; /* STATUS0_* */
127 u8 status1
; /* STATUS1_* */
132 struct cp2112_string_report
{
133 u8 dummy
; /* force .string to be aligned */
134 struct_group_attr(contents
, __packed
,
135 u8 report
; /* CP2112_*_STRING */
136 u8 length
; /* length in bytes of everything after .report */
137 u8 type
; /* USB_DT_STRING */
138 wchar_t string
[30]; /* UTF16_LITTLE_ENDIAN string */
142 /* Number of times to request transfer status before giving up waiting for a
143 transfer to complete. This may need to be changed if SMBUS clock, retries,
144 or read/write/scl_low timeout settings are changed. */
145 static const int XFER_STATUS_RETRIES
= 10;
147 /* Time in ms to wait for a CP2112_DATA_READ_RESPONSE or
148 CP2112_TRANSFER_STATUS_RESPONSE. */
149 static const int RESPONSE_TIMEOUT
= 50;
151 static const struct hid_device_id cp2112_devices
[] = {
152 { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL
, USB_DEVICE_ID_CYGNAL_CP2112
) },
155 MODULE_DEVICE_TABLE(hid
, cp2112_devices
);
157 struct cp2112_device
{
158 struct i2c_adapter adap
;
159 struct hid_device
*hdev
;
160 wait_queue_head_t wait
;
172 struct delayed_work gpio_poll_worker
;
173 unsigned long irq_mask
;
177 static int gpio_push_pull
= CP2112_GPIO_ALL_GPIO_MASK
;
178 module_param(gpio_push_pull
, int, 0644);
179 MODULE_PARM_DESC(gpio_push_pull
, "GPIO push-pull configuration bitmask");
181 static int cp2112_gpio_direction_input(struct gpio_chip
*chip
, unsigned offset
)
183 struct cp2112_device
*dev
= gpiochip_get_data(chip
);
184 struct hid_device
*hdev
= dev
->hdev
;
185 u8
*buf
= dev
->in_out_buffer
;
188 mutex_lock(&dev
->lock
);
190 ret
= hid_hw_raw_request(hdev
, CP2112_GPIO_CONFIG
, buf
,
191 CP2112_GPIO_CONFIG_LENGTH
, HID_FEATURE_REPORT
,
193 if (ret
!= CP2112_GPIO_CONFIG_LENGTH
) {
194 hid_err(hdev
, "error requesting GPIO config: %d\n", ret
);
200 buf
[1] &= ~BIT(offset
);
201 buf
[2] = gpio_push_pull
;
203 ret
= hid_hw_raw_request(hdev
, CP2112_GPIO_CONFIG
, buf
,
204 CP2112_GPIO_CONFIG_LENGTH
, HID_FEATURE_REPORT
,
206 if (ret
!= CP2112_GPIO_CONFIG_LENGTH
) {
207 hid_err(hdev
, "error setting GPIO config: %d\n", ret
);
216 mutex_unlock(&dev
->lock
);
220 static void cp2112_gpio_set(struct gpio_chip
*chip
, unsigned offset
, int value
)
222 struct cp2112_device
*dev
= gpiochip_get_data(chip
);
223 struct hid_device
*hdev
= dev
->hdev
;
224 u8
*buf
= dev
->in_out_buffer
;
227 mutex_lock(&dev
->lock
);
229 buf
[0] = CP2112_GPIO_SET
;
230 buf
[1] = value
? CP2112_GPIO_ALL_GPIO_MASK
: 0;
231 buf
[2] = BIT(offset
);
233 ret
= hid_hw_raw_request(hdev
, CP2112_GPIO_SET
, buf
,
234 CP2112_GPIO_SET_LENGTH
, HID_FEATURE_REPORT
,
237 hid_err(hdev
, "error setting GPIO values: %d\n", ret
);
239 mutex_unlock(&dev
->lock
);
242 static int cp2112_gpio_get_all(struct gpio_chip
*chip
)
244 struct cp2112_device
*dev
= gpiochip_get_data(chip
);
245 struct hid_device
*hdev
= dev
->hdev
;
246 u8
*buf
= dev
->in_out_buffer
;
249 mutex_lock(&dev
->lock
);
251 ret
= hid_hw_raw_request(hdev
, CP2112_GPIO_GET
, buf
,
252 CP2112_GPIO_GET_LENGTH
, HID_FEATURE_REPORT
,
254 if (ret
!= CP2112_GPIO_GET_LENGTH
) {
255 hid_err(hdev
, "error requesting GPIO values: %d\n", ret
);
256 ret
= ret
< 0 ? ret
: -EIO
;
263 mutex_unlock(&dev
->lock
);
268 static int cp2112_gpio_get(struct gpio_chip
*chip
, unsigned int offset
)
272 ret
= cp2112_gpio_get_all(chip
);
276 return (ret
>> offset
) & 1;
279 static int cp2112_gpio_direction_output(struct gpio_chip
*chip
,
280 unsigned offset
, int value
)
282 struct cp2112_device
*dev
= gpiochip_get_data(chip
);
283 struct hid_device
*hdev
= dev
->hdev
;
284 u8
*buf
= dev
->in_out_buffer
;
287 mutex_lock(&dev
->lock
);
289 ret
= hid_hw_raw_request(hdev
, CP2112_GPIO_CONFIG
, buf
,
290 CP2112_GPIO_CONFIG_LENGTH
, HID_FEATURE_REPORT
,
292 if (ret
!= CP2112_GPIO_CONFIG_LENGTH
) {
293 hid_err(hdev
, "error requesting GPIO config: %d\n", ret
);
297 buf
[1] |= 1 << offset
;
298 buf
[2] = gpio_push_pull
;
300 ret
= hid_hw_raw_request(hdev
, CP2112_GPIO_CONFIG
, buf
,
301 CP2112_GPIO_CONFIG_LENGTH
, HID_FEATURE_REPORT
,
304 hid_err(hdev
, "error setting GPIO config: %d\n", ret
);
308 mutex_unlock(&dev
->lock
);
311 * Set gpio value when output direction is already set,
312 * as specified in AN495, Rev. 0.2, cpt. 4.4
314 cp2112_gpio_set(chip
, offset
, value
);
319 mutex_unlock(&dev
->lock
);
320 return ret
< 0 ? ret
: -EIO
;
323 static int cp2112_hid_get(struct hid_device
*hdev
, unsigned char report_number
,
324 u8
*data
, size_t count
, unsigned char report_type
)
329 buf
= kmalloc(count
, GFP_KERNEL
);
333 ret
= hid_hw_raw_request(hdev
, report_number
, buf
, count
,
334 report_type
, HID_REQ_GET_REPORT
);
335 memcpy(data
, buf
, count
);
340 static int cp2112_hid_output(struct hid_device
*hdev
, u8
*data
, size_t count
,
341 unsigned char report_type
)
346 buf
= kmemdup(data
, count
, GFP_KERNEL
);
350 if (report_type
== HID_OUTPUT_REPORT
)
351 ret
= hid_hw_output_report(hdev
, buf
, count
);
353 ret
= hid_hw_raw_request(hdev
, buf
[0], buf
, count
, report_type
,
360 static int cp2112_wait(struct cp2112_device
*dev
, atomic_t
*avail
)
364 /* We have sent either a CP2112_TRANSFER_STATUS_REQUEST or a
365 * CP2112_DATA_READ_FORCE_SEND and we are waiting for the response to
366 * come in cp2112_raw_event or timeout. There will only be one of these
367 * in flight at any one time. The timeout is extremely large and is a
368 * last resort if the CP2112 has died. If we do timeout we don't expect
369 * to receive the response which would cause data races, it's not like
370 * we can do anything about it anyway.
372 ret
= wait_event_interruptible_timeout(dev
->wait
,
373 atomic_read(avail
), msecs_to_jiffies(RESPONSE_TIMEOUT
));
374 if (-ERESTARTSYS
== ret
)
379 atomic_set(avail
, 0);
383 static int cp2112_xfer_status(struct cp2112_device
*dev
)
385 struct hid_device
*hdev
= dev
->hdev
;
389 buf
[0] = CP2112_TRANSFER_STATUS_REQUEST
;
391 atomic_set(&dev
->xfer_avail
, 0);
393 ret
= cp2112_hid_output(hdev
, buf
, 2, HID_OUTPUT_REPORT
);
395 hid_warn(hdev
, "Error requesting status: %d\n", ret
);
399 ret
= cp2112_wait(dev
, &dev
->xfer_avail
);
403 return dev
->xfer_status
;
406 static int cp2112_read(struct cp2112_device
*dev
, u8
*data
, size_t size
)
408 struct hid_device
*hdev
= dev
->hdev
;
409 struct cp2112_force_read_report report
;
412 if (size
> sizeof(dev
->read_data
))
413 size
= sizeof(dev
->read_data
);
414 report
.report
= CP2112_DATA_READ_FORCE_SEND
;
415 report
.length
= cpu_to_be16(size
);
417 atomic_set(&dev
->read_avail
, 0);
419 ret
= cp2112_hid_output(hdev
, &report
.report
, sizeof(report
),
422 hid_warn(hdev
, "Error requesting data: %d\n", ret
);
426 ret
= cp2112_wait(dev
, &dev
->read_avail
);
430 hid_dbg(hdev
, "read %d of %zd bytes requested\n",
431 dev
->read_length
, size
);
433 if (size
> dev
->read_length
)
434 size
= dev
->read_length
;
436 memcpy(data
, dev
->read_data
, size
);
437 return dev
->read_length
;
440 static int cp2112_read_req(void *buf
, u8 slave_address
, u16 length
)
442 struct cp2112_read_req_report
*report
= buf
;
444 if (length
< 1 || length
> 512)
447 report
->report
= CP2112_DATA_READ_REQUEST
;
448 report
->slave_address
= slave_address
<< 1;
449 report
->length
= cpu_to_be16(length
);
450 return sizeof(*report
);
453 static int cp2112_write_read_req(void *buf
, u8 slave_address
, u16 length
,
454 u8 command
, u8
*data
, u8 data_length
)
456 struct cp2112_write_read_req_report
*report
= buf
;
458 if (length
< 1 || length
> 512
459 || data_length
> sizeof(report
->target_address
) - 1)
462 report
->report
= CP2112_DATA_WRITE_READ_REQUEST
;
463 report
->slave_address
= slave_address
<< 1;
464 report
->length
= cpu_to_be16(length
);
465 report
->target_address_length
= data_length
+ 1;
466 report
->target_address
[0] = command
;
467 memcpy(&report
->target_address
[1], data
, data_length
);
468 return data_length
+ 6;
471 static int cp2112_write_req(void *buf
, u8 slave_address
, u8 command
, u8
*data
,
474 struct cp2112_write_req_report
*report
= buf
;
476 if (data_length
> sizeof(report
->data
) - 1)
479 report
->report
= CP2112_DATA_WRITE_REQUEST
;
480 report
->slave_address
= slave_address
<< 1;
481 report
->length
= data_length
+ 1;
482 report
->data
[0] = command
;
483 memcpy(&report
->data
[1], data
, data_length
);
484 return data_length
+ 4;
487 static int cp2112_i2c_write_req(void *buf
, u8 slave_address
, u8
*data
,
490 struct cp2112_write_req_report
*report
= buf
;
492 if (data_length
> sizeof(report
->data
))
495 report
->report
= CP2112_DATA_WRITE_REQUEST
;
496 report
->slave_address
= slave_address
<< 1;
497 report
->length
= data_length
;
498 memcpy(report
->data
, data
, data_length
);
499 return data_length
+ 3;
502 static int cp2112_i2c_write_read_req(void *buf
, u8 slave_address
,
503 u8
*addr
, int addr_length
,
506 struct cp2112_write_read_req_report
*report
= buf
;
508 if (read_length
< 1 || read_length
> 512 ||
509 addr_length
> sizeof(report
->target_address
))
512 report
->report
= CP2112_DATA_WRITE_READ_REQUEST
;
513 report
->slave_address
= slave_address
<< 1;
514 report
->length
= cpu_to_be16(read_length
);
515 report
->target_address_length
= addr_length
;
516 memcpy(report
->target_address
, addr
, addr_length
);
517 return addr_length
+ 5;
520 static int cp2112_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
,
523 struct cp2112_device
*dev
= (struct cp2112_device
*)adap
->algo_data
;
524 struct hid_device
*hdev
= dev
->hdev
;
527 ssize_t read_length
= 0;
529 unsigned int retries
;
532 hid_dbg(hdev
, "I2C %d messages\n", num
);
535 hid_dbg(hdev
, "I2C %s %#04x len %d\n",
536 str_read_write(msgs
->flags
& I2C_M_RD
), msgs
->addr
, msgs
->len
);
537 if (msgs
->flags
& I2C_M_RD
) {
538 read_length
= msgs
->len
;
539 read_buf
= msgs
->buf
;
540 count
= cp2112_read_req(buf
, msgs
->addr
, msgs
->len
);
542 count
= cp2112_i2c_write_req(buf
, msgs
->addr
,
543 msgs
->buf
, msgs
->len
);
547 } else if (dev
->hwversion
> 1 && /* no repeated start in rev 1 */
549 msgs
[0].addr
== msgs
[1].addr
&&
550 !(msgs
[0].flags
& I2C_M_RD
) && (msgs
[1].flags
& I2C_M_RD
)) {
551 hid_dbg(hdev
, "I2C write-read %#04x wlen %d rlen %d\n",
552 msgs
[0].addr
, msgs
[0].len
, msgs
[1].len
);
553 read_length
= msgs
[1].len
;
554 read_buf
= msgs
[1].buf
;
555 count
= cp2112_i2c_write_read_req(buf
, msgs
[0].addr
,
556 msgs
[0].buf
, msgs
[0].len
, msgs
[1].len
);
561 "Multi-message I2C transactions not supported\n");
565 ret
= hid_hw_power(hdev
, PM_HINT_FULLON
);
567 hid_err(hdev
, "power management error: %d\n", ret
);
571 ret
= cp2112_hid_output(hdev
, buf
, count
, HID_OUTPUT_REPORT
);
573 hid_warn(hdev
, "Error starting transaction: %d\n", ret
);
577 for (retries
= 0; retries
< XFER_STATUS_RETRIES
; ++retries
) {
578 ret
= cp2112_xfer_status(dev
);
586 if (XFER_STATUS_RETRIES
<= retries
) {
587 hid_warn(hdev
, "Transfer timed out, cancelling.\n");
588 buf
[0] = CP2112_CANCEL_TRANSFER
;
591 ret
= cp2112_hid_output(hdev
, buf
, 2, HID_OUTPUT_REPORT
);
593 hid_warn(hdev
, "Error cancelling transaction: %d\n",
600 for (count
= 0; count
< read_length
;) {
601 ret
= cp2112_read(dev
, read_buf
+ count
, read_length
- count
);
605 hid_err(hdev
, "read returned 0\n");
610 if (count
> read_length
) {
612 * The hardware returned too much data.
613 * This is mostly harmless because cp2112_read()
614 * has a limit check so didn't overrun our
615 * buffer. Nevertheless, we return an error
616 * because something is seriously wrong and
617 * it shouldn't go unnoticed.
619 hid_err(hdev
, "long read: %d > %zd\n",
620 ret
, read_length
- count
+ ret
);
626 /* return the number of transferred messages */
630 hid_hw_power(hdev
, PM_HINT_NORMAL
);
631 hid_dbg(hdev
, "I2C transfer finished: %d\n", ret
);
635 static int cp2112_xfer(struct i2c_adapter
*adap
, u16 addr
,
636 unsigned short flags
, char read_write
, u8 command
,
637 int size
, union i2c_smbus_data
*data
)
639 struct cp2112_device
*dev
= (struct cp2112_device
*)adap
->algo_data
;
640 struct hid_device
*hdev
= dev
->hdev
;
644 size_t read_length
= 0;
645 unsigned int retries
;
648 hid_dbg(hdev
, "%s addr 0x%x flags 0x%x cmd 0x%x size %d\n",
649 str_write_read(read_write
== I2C_SMBUS_WRITE
),
650 addr
, flags
, command
, size
);
656 if (I2C_SMBUS_READ
== read_write
)
657 count
= cp2112_read_req(buf
, addr
, read_length
);
659 count
= cp2112_write_req(buf
, addr
, command
, NULL
,
662 case I2C_SMBUS_BYTE_DATA
:
665 if (I2C_SMBUS_READ
== read_write
)
666 count
= cp2112_write_read_req(buf
, addr
, read_length
,
669 count
= cp2112_write_req(buf
, addr
, command
,
672 case I2C_SMBUS_WORD_DATA
:
674 word
= cpu_to_le16(data
->word
);
676 if (I2C_SMBUS_READ
== read_write
)
677 count
= cp2112_write_read_req(buf
, addr
, read_length
,
680 count
= cp2112_write_req(buf
, addr
, command
,
683 case I2C_SMBUS_PROC_CALL
:
684 size
= I2C_SMBUS_WORD_DATA
;
685 read_write
= I2C_SMBUS_READ
;
687 word
= cpu_to_le16(data
->word
);
689 count
= cp2112_write_read_req(buf
, addr
, read_length
, command
,
692 case I2C_SMBUS_I2C_BLOCK_DATA
:
693 if (read_write
== I2C_SMBUS_READ
) {
694 read_length
= data
->block
[0];
695 count
= cp2112_write_read_req(buf
, addr
, read_length
,
698 count
= cp2112_write_req(buf
, addr
, command
,
703 case I2C_SMBUS_BLOCK_DATA
:
704 if (I2C_SMBUS_READ
== read_write
) {
705 count
= cp2112_write_read_req(buf
, addr
,
709 count
= cp2112_write_req(buf
, addr
, command
,
714 case I2C_SMBUS_BLOCK_PROC_CALL
:
715 size
= I2C_SMBUS_BLOCK_DATA
;
716 read_write
= I2C_SMBUS_READ
;
718 count
= cp2112_write_read_req(buf
, addr
, I2C_SMBUS_BLOCK_MAX
,
719 command
, data
->block
,
723 hid_warn(hdev
, "Unsupported transaction %d\n", size
);
730 ret
= hid_hw_power(hdev
, PM_HINT_FULLON
);
732 hid_err(hdev
, "power management error: %d\n", ret
);
736 ret
= cp2112_hid_output(hdev
, buf
, count
, HID_OUTPUT_REPORT
);
738 hid_warn(hdev
, "Error starting transaction: %d\n", ret
);
742 for (retries
= 0; retries
< XFER_STATUS_RETRIES
; ++retries
) {
743 ret
= cp2112_xfer_status(dev
);
751 if (XFER_STATUS_RETRIES
<= retries
) {
752 hid_warn(hdev
, "Transfer timed out, cancelling.\n");
753 buf
[0] = CP2112_CANCEL_TRANSFER
;
756 ret
= cp2112_hid_output(hdev
, buf
, 2, HID_OUTPUT_REPORT
);
758 hid_warn(hdev
, "Error cancelling transaction: %d\n",
765 if (I2C_SMBUS_WRITE
== read_write
) {
770 if (I2C_SMBUS_BLOCK_DATA
== size
)
773 ret
= cp2112_read(dev
, buf
, read_length
);
776 if (ret
!= read_length
) {
777 hid_warn(hdev
, "short read: %d < %zd\n", ret
, read_length
);
784 case I2C_SMBUS_BYTE_DATA
:
787 case I2C_SMBUS_WORD_DATA
:
788 data
->word
= le16_to_cpup((__le16
*)buf
);
790 case I2C_SMBUS_I2C_BLOCK_DATA
:
791 if (read_length
> I2C_SMBUS_BLOCK_MAX
) {
796 memcpy(data
->block
+ 1, buf
, read_length
);
798 case I2C_SMBUS_BLOCK_DATA
:
799 if (read_length
> I2C_SMBUS_BLOCK_MAX
) {
804 memcpy(data
->block
, buf
, read_length
);
810 hid_hw_power(hdev
, PM_HINT_NORMAL
);
811 hid_dbg(hdev
, "transfer finished: %d\n", ret
);
815 static u32
cp2112_functionality(struct i2c_adapter
*adap
)
817 return I2C_FUNC_I2C
|
818 I2C_FUNC_SMBUS_BYTE
|
819 I2C_FUNC_SMBUS_BYTE_DATA
|
820 I2C_FUNC_SMBUS_WORD_DATA
|
821 I2C_FUNC_SMBUS_BLOCK_DATA
|
822 I2C_FUNC_SMBUS_I2C_BLOCK
|
823 I2C_FUNC_SMBUS_PROC_CALL
|
824 I2C_FUNC_SMBUS_BLOCK_PROC_CALL
;
827 static const struct i2c_algorithm smbus_algorithm
= {
828 .master_xfer
= cp2112_i2c_xfer
,
829 .smbus_xfer
= cp2112_xfer
,
830 .functionality
= cp2112_functionality
,
833 static int cp2112_get_usb_config(struct hid_device
*hdev
,
834 struct cp2112_usb_config_report
*cfg
)
838 ret
= cp2112_hid_get(hdev
, CP2112_USB_CONFIG
, (u8
*)cfg
, sizeof(*cfg
),
840 if (ret
!= sizeof(*cfg
)) {
841 hid_err(hdev
, "error reading usb config: %d\n", ret
);
850 static int cp2112_set_usb_config(struct hid_device
*hdev
,
851 struct cp2112_usb_config_report
*cfg
)
855 BUG_ON(cfg
->report
!= CP2112_USB_CONFIG
);
857 ret
= cp2112_hid_output(hdev
, (u8
*)cfg
, sizeof(*cfg
),
859 if (ret
!= sizeof(*cfg
)) {
860 hid_err(hdev
, "error writing usb config: %d\n", ret
);
869 static void chmod_sysfs_attrs(struct hid_device
*hdev
);
871 #define CP2112_CONFIG_ATTR(name, store, format, ...) \
872 static ssize_t name##_store(struct device *kdev, \
873 struct device_attribute *attr, const char *buf, \
876 struct hid_device *hdev = to_hid_device(kdev); \
877 struct cp2112_usb_config_report cfg; \
878 int ret = cp2112_get_usb_config(hdev, &cfg); \
882 ret = cp2112_set_usb_config(hdev, &cfg); \
885 chmod_sysfs_attrs(hdev); \
888 static ssize_t name##_show(struct device *kdev, \
889 struct device_attribute *attr, char *buf) \
891 struct hid_device *hdev = to_hid_device(kdev); \
892 struct cp2112_usb_config_report cfg; \
893 int ret = cp2112_get_usb_config(hdev, &cfg); \
896 return sysfs_emit(buf, format, ##__VA_ARGS__); \
898 static DEVICE_ATTR_RW(name);
900 CP2112_CONFIG_ATTR(vendor_id
, ({
903 if (sscanf(buf
, "%hi", &vid
) != 1)
906 cfg
.vid
= cpu_to_le16(vid
);
908 }), "0x%04x\n", le16_to_cpu(cfg
.vid
));
910 CP2112_CONFIG_ATTR(product_id
, ({
913 if (sscanf(buf
, "%hi", &pid
) != 1)
916 cfg
.pid
= cpu_to_le16(pid
);
918 }), "0x%04x\n", le16_to_cpu(cfg
.pid
));
920 CP2112_CONFIG_ATTR(max_power
, ({
923 if (sscanf(buf
, "%i", &mA
) != 1)
926 cfg
.max_power
= (mA
+ 1) / 2;
928 }), "%u mA\n", cfg
.max_power
* 2);
930 CP2112_CONFIG_ATTR(power_mode
, ({
931 if (sscanf(buf
, "%hhi", &cfg
.power_mode
) != 1)
935 }), "%u\n", cfg
.power_mode
);
937 CP2112_CONFIG_ATTR(release_version
, ({
938 if (sscanf(buf
, "%hhi.%hhi", &cfg
.release_major
, &cfg
.release_minor
)
943 }), "%u.%u\n", cfg
.release_major
, cfg
.release_minor
);
945 #undef CP2112_CONFIG_ATTR
947 static ssize_t
pstr_store(struct device
*kdev
, struct device_attribute
*kattr
,
948 const char *buf
, size_t count
, int number
)
950 struct hid_device
*hdev
= to_hid_device(kdev
);
951 struct cp2112_string_report report
;
954 memset(&report
, 0, sizeof(report
));
956 ret
= utf8s_to_utf16s(buf
, count
, UTF16_LITTLE_ENDIAN
,
957 report
.string
, ARRAY_SIZE(report
.string
));
958 report
.report
= number
;
959 report
.length
= ret
* sizeof(report
.string
[0]) + 2;
960 report
.type
= USB_DT_STRING
;
962 ret
= cp2112_hid_output(hdev
, &report
.report
, report
.length
+ 1,
964 if (ret
!= report
.length
+ 1) {
965 hid_err(hdev
, "error writing %s string: %d\n", kattr
->attr
.name
,
972 chmod_sysfs_attrs(hdev
);
976 static ssize_t
pstr_show(struct device
*kdev
, struct device_attribute
*kattr
,
977 char *buf
, int number
)
979 struct hid_device
*hdev
= to_hid_device(kdev
);
980 struct cp2112_string_report report
;
984 ret
= cp2112_hid_get(hdev
, number
, (u8
*)&report
.contents
,
985 sizeof(report
.contents
), HID_FEATURE_REPORT
);
987 hid_err(hdev
, "error reading %s string: %d\n", kattr
->attr
.name
,
994 if (report
.length
< 2) {
995 hid_err(hdev
, "invalid %s string length: %d\n",
996 kattr
->attr
.name
, report
.length
);
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
,
1008 #define CP2112_PSTR_ATTR(name, _report) \
1009 static ssize_t name##_store(struct device *kdev, struct device_attribute *kattr, \
1010 const char *buf, size_t count) \
1012 return pstr_store(kdev, kattr, buf, count, _report); \
1014 static ssize_t name##_show(struct device *kdev, struct device_attribute *kattr, char *buf) \
1016 return pstr_show(kdev, kattr, buf, _report); \
1018 static DEVICE_ATTR_RW(name);
1020 CP2112_PSTR_ATTR(manufacturer
, CP2112_MANUFACTURER_STRING
);
1021 CP2112_PSTR_ATTR(product
, CP2112_PRODUCT_STRING
);
1022 CP2112_PSTR_ATTR(serial
, CP2112_SERIAL_STRING
);
1024 #undef CP2112_PSTR_ATTR
1026 static const struct attribute_group cp2112_attr_group
= {
1027 .attrs
= (struct attribute
*[]){
1028 &dev_attr_vendor_id
.attr
,
1029 &dev_attr_product_id
.attr
,
1030 &dev_attr_max_power
.attr
,
1031 &dev_attr_power_mode
.attr
,
1032 &dev_attr_release_version
.attr
,
1033 &dev_attr_manufacturer
.attr
,
1034 &dev_attr_product
.attr
,
1035 &dev_attr_serial
.attr
,
1040 /* Chmoding our sysfs attributes is simply a way to expose which fields in the
1041 * PROM have already been programmed. We do not depend on this preventing
1042 * writing to these attributes since the CP2112 will simply ignore writes to
1043 * already-programmed fields. This is why there is no sense in fixing this
1046 static void chmod_sysfs_attrs(struct hid_device
*hdev
)
1048 struct attribute
**attr
;
1052 ret
= cp2112_hid_get(hdev
, CP2112_LOCK_BYTE
, buf
, sizeof(buf
),
1053 HID_FEATURE_REPORT
);
1054 if (ret
!= sizeof(buf
)) {
1055 hid_err(hdev
, "error reading lock byte: %d\n", ret
);
1059 for (attr
= cp2112_attr_group
.attrs
; *attr
; ++attr
) {
1060 umode_t mode
= (buf
[1] & 1) ? 0644 : 0444;
1061 ret
= sysfs_chmod_file(&hdev
->dev
.kobj
, *attr
, mode
);
1063 hid_err(hdev
, "error chmoding sysfs file %s\n",
1069 static void cp2112_gpio_irq_ack(struct irq_data
*d
)
1073 static void cp2112_gpio_irq_mask(struct irq_data
*d
)
1075 struct gpio_chip
*gc
= irq_data_get_irq_chip_data(d
);
1076 struct cp2112_device
*dev
= gpiochip_get_data(gc
);
1077 irq_hw_number_t hwirq
= irqd_to_hwirq(d
);
1079 __clear_bit(hwirq
, &dev
->irq_mask
);
1080 gpiochip_disable_irq(gc
, hwirq
);
1083 static void cp2112_gpio_irq_unmask(struct irq_data
*d
)
1085 struct gpio_chip
*gc
= irq_data_get_irq_chip_data(d
);
1086 struct cp2112_device
*dev
= gpiochip_get_data(gc
);
1087 irq_hw_number_t hwirq
= irqd_to_hwirq(d
);
1089 gpiochip_enable_irq(gc
, hwirq
);
1090 __set_bit(hwirq
, &dev
->irq_mask
);
1093 static void cp2112_gpio_poll_callback(struct work_struct
*work
)
1095 struct cp2112_device
*dev
= container_of(work
, struct cp2112_device
,
1096 gpio_poll_worker
.work
);
1101 ret
= cp2112_gpio_get_all(&dev
->gc
);
1102 if (ret
== -ENODEV
) /* the hardware has been disconnected */
1108 for_each_set_bit(virq
, &dev
->irq_mask
, CP2112_GPIO_MAX_GPIO
) {
1109 irq
= irq_find_mapping(dev
->gc
.irq
.domain
, virq
);
1113 irq_type
= irq_get_trigger_type(irq
);
1117 if (gpio_mask
& BIT(virq
)) {
1120 if (irq_type
& IRQ_TYPE_LEVEL_HIGH
)
1121 handle_nested_irq(irq
);
1123 if ((irq_type
& IRQ_TYPE_EDGE_RISING
) &&
1124 !(dev
->gpio_prev_state
& BIT(virq
)))
1125 handle_nested_irq(irq
);
1129 if (irq_type
& IRQ_TYPE_LEVEL_LOW
)
1130 handle_nested_irq(irq
);
1132 if ((irq_type
& IRQ_TYPE_EDGE_FALLING
) &&
1133 (dev
->gpio_prev_state
& BIT(virq
)))
1134 handle_nested_irq(irq
);
1138 dev
->gpio_prev_state
= gpio_mask
;
1142 schedule_delayed_work(&dev
->gpio_poll_worker
, 10);
1146 static unsigned int cp2112_gpio_irq_startup(struct irq_data
*d
)
1148 struct gpio_chip
*gc
= irq_data_get_irq_chip_data(d
);
1149 struct cp2112_device
*dev
= gpiochip_get_data(gc
);
1151 if (!dev
->gpio_poll
) {
1152 dev
->gpio_poll
= true;
1153 schedule_delayed_work(&dev
->gpio_poll_worker
, 0);
1156 cp2112_gpio_irq_unmask(d
);
1160 static void cp2112_gpio_irq_shutdown(struct irq_data
*d
)
1162 struct gpio_chip
*gc
= irq_data_get_irq_chip_data(d
);
1163 struct cp2112_device
*dev
= gpiochip_get_data(gc
);
1165 cp2112_gpio_irq_mask(d
);
1167 if (!dev
->irq_mask
) {
1168 dev
->gpio_poll
= false;
1169 cancel_delayed_work_sync(&dev
->gpio_poll_worker
);
1173 static int cp2112_gpio_irq_type(struct irq_data
*d
, unsigned int type
)
1178 static const struct irq_chip cp2112_gpio_irqchip
= {
1179 .name
= "cp2112-gpio",
1180 .irq_startup
= cp2112_gpio_irq_startup
,
1181 .irq_shutdown
= cp2112_gpio_irq_shutdown
,
1182 .irq_ack
= cp2112_gpio_irq_ack
,
1183 .irq_mask
= cp2112_gpio_irq_mask
,
1184 .irq_unmask
= cp2112_gpio_irq_unmask
,
1185 .irq_set_type
= cp2112_gpio_irq_type
,
1186 .flags
= IRQCHIP_MASK_ON_SUSPEND
| IRQCHIP_IMMUTABLE
,
1187 GPIOCHIP_IRQ_RESOURCE_HELPERS
,
1190 static int cp2112_probe(struct hid_device
*hdev
, const struct hid_device_id
*id
)
1192 struct cp2112_device
*dev
;
1194 struct cp2112_smbus_config_report config
;
1195 struct gpio_irq_chip
*girq
;
1198 dev
= devm_kzalloc(&hdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
1202 dev
->in_out_buffer
= devm_kzalloc(&hdev
->dev
, CP2112_REPORT_MAX_LENGTH
,
1204 if (!dev
->in_out_buffer
)
1207 mutex_init(&dev
->lock
);
1209 ret
= hid_parse(hdev
);
1211 hid_err(hdev
, "parse failed\n");
1215 ret
= hid_hw_start(hdev
, HID_CONNECT_HIDRAW
);
1217 hid_err(hdev
, "hw start failed\n");
1221 ret
= hid_hw_open(hdev
);
1223 hid_err(hdev
, "hw open failed\n");
1227 ret
= hid_hw_power(hdev
, PM_HINT_FULLON
);
1229 hid_err(hdev
, "power management error: %d\n", ret
);
1233 ret
= cp2112_hid_get(hdev
, CP2112_GET_VERSION_INFO
, buf
, sizeof(buf
),
1234 HID_FEATURE_REPORT
);
1235 if (ret
!= sizeof(buf
)) {
1236 hid_err(hdev
, "error requesting version\n");
1239 goto err_power_normal
;
1242 hid_info(hdev
, "Part Number: 0x%02X Device Version: 0x%02X\n",
1245 ret
= cp2112_hid_get(hdev
, CP2112_SMBUS_CONFIG
, (u8
*)&config
,
1246 sizeof(config
), HID_FEATURE_REPORT
);
1247 if (ret
!= sizeof(config
)) {
1248 hid_err(hdev
, "error requesting SMBus config\n");
1251 goto err_power_normal
;
1254 config
.retry_time
= cpu_to_be16(1);
1256 ret
= cp2112_hid_output(hdev
, (u8
*)&config
, sizeof(config
),
1257 HID_FEATURE_REPORT
);
1258 if (ret
!= sizeof(config
)) {
1259 hid_err(hdev
, "error setting SMBus config\n");
1262 goto err_power_normal
;
1265 hid_set_drvdata(hdev
, (void *)dev
);
1267 dev
->adap
.owner
= THIS_MODULE
;
1268 dev
->adap
.class = I2C_CLASS_HWMON
;
1269 dev
->adap
.algo
= &smbus_algorithm
;
1270 dev
->adap
.algo_data
= dev
;
1271 dev
->adap
.dev
.parent
= &hdev
->dev
;
1272 snprintf(dev
->adap
.name
, sizeof(dev
->adap
.name
),
1273 "CP2112 SMBus Bridge on hidraw%d",
1274 ((struct hidraw
*)hdev
->hidraw
)->minor
);
1275 dev
->hwversion
= buf
[2];
1276 init_waitqueue_head(&dev
->wait
);
1278 hid_device_io_start(hdev
);
1279 ret
= i2c_add_adapter(&dev
->adap
);
1280 hid_device_io_stop(hdev
);
1283 hid_err(hdev
, "error registering i2c adapter\n");
1284 goto err_power_normal
;
1287 hid_dbg(hdev
, "adapter registered\n");
1289 dev
->gc
.label
= "cp2112_gpio";
1290 dev
->gc
.direction_input
= cp2112_gpio_direction_input
;
1291 dev
->gc
.direction_output
= cp2112_gpio_direction_output
;
1292 dev
->gc
.set
= cp2112_gpio_set
;
1293 dev
->gc
.get
= cp2112_gpio_get
;
1295 dev
->gc
.ngpio
= CP2112_GPIO_MAX_GPIO
;
1296 dev
->gc
.can_sleep
= 1;
1297 dev
->gc
.parent
= &hdev
->dev
;
1299 girq
= &dev
->gc
.irq
;
1300 gpio_irq_chip_set_chip(girq
, &cp2112_gpio_irqchip
);
1301 /* The event comes from the outside so no parent handler */
1302 girq
->parent_handler
= NULL
;
1303 girq
->num_parents
= 0;
1304 girq
->parents
= NULL
;
1305 girq
->default_type
= IRQ_TYPE_NONE
;
1306 girq
->handler
= handle_simple_irq
;
1307 girq
->threaded
= true;
1309 INIT_DELAYED_WORK(&dev
->gpio_poll_worker
, cp2112_gpio_poll_callback
);
1311 ret
= gpiochip_add_data(&dev
->gc
, dev
);
1313 hid_err(hdev
, "error registering gpio chip\n");
1317 ret
= sysfs_create_group(&hdev
->dev
.kobj
, &cp2112_attr_group
);
1319 hid_err(hdev
, "error creating sysfs attrs\n");
1320 goto err_gpiochip_remove
;
1323 chmod_sysfs_attrs(hdev
);
1324 hid_hw_power(hdev
, PM_HINT_NORMAL
);
1328 err_gpiochip_remove
:
1329 gpiochip_remove(&dev
->gc
);
1331 i2c_del_adapter(&dev
->adap
);
1333 hid_hw_power(hdev
, PM_HINT_NORMAL
);
1341 static void cp2112_remove(struct hid_device
*hdev
)
1343 struct cp2112_device
*dev
= hid_get_drvdata(hdev
);
1345 sysfs_remove_group(&hdev
->dev
.kobj
, &cp2112_attr_group
);
1346 i2c_del_adapter(&dev
->adap
);
1348 if (dev
->gpio_poll
) {
1349 dev
->gpio_poll
= false;
1350 cancel_delayed_work_sync(&dev
->gpio_poll_worker
);
1353 gpiochip_remove(&dev
->gc
);
1354 /* i2c_del_adapter has finished removing all i2c devices from our
1355 * adapter. Well behaved devices should no longer call our cp2112_xfer
1356 * and should have waited for any pending calls to finish. It has also
1357 * waited for device_unregister(&adap->dev) to complete. Therefore we
1358 * can safely free our struct cp2112_device.
1364 static int cp2112_raw_event(struct hid_device
*hdev
, struct hid_report
*report
,
1367 struct cp2112_device
*dev
= hid_get_drvdata(hdev
);
1368 struct cp2112_xfer_status_report
*xfer
= (void *)data
;
1371 case CP2112_TRANSFER_STATUS_RESPONSE
:
1372 hid_dbg(hdev
, "xfer status: %02x %02x %04x %04x\n",
1373 xfer
->status0
, xfer
->status1
,
1374 be16_to_cpu(xfer
->retries
), be16_to_cpu(xfer
->length
));
1376 switch (xfer
->status0
) {
1378 dev
->xfer_status
= -EAGAIN
;
1381 dev
->xfer_status
= -EBUSY
;
1383 case STATUS0_COMPLETE
:
1384 dev
->xfer_status
= be16_to_cpu(xfer
->length
);
1387 switch (xfer
->status1
) {
1388 case STATUS1_TIMEOUT_NACK
:
1389 case STATUS1_TIMEOUT_BUS
:
1390 dev
->xfer_status
= -ETIMEDOUT
;
1393 dev
->xfer_status
= -EIO
;
1398 dev
->xfer_status
= -EINVAL
;
1402 atomic_set(&dev
->xfer_avail
, 1);
1404 case CP2112_DATA_READ_RESPONSE
:
1405 hid_dbg(hdev
, "read response: %02x %02x\n", data
[1], data
[2]);
1407 dev
->read_length
= data
[2];
1408 if (dev
->read_length
> sizeof(dev
->read_data
))
1409 dev
->read_length
= sizeof(dev
->read_data
);
1411 memcpy(dev
->read_data
, &data
[3], dev
->read_length
);
1412 atomic_set(&dev
->read_avail
, 1);
1415 hid_err(hdev
, "unknown report\n");
1420 wake_up_interruptible(&dev
->wait
);
1424 static struct hid_driver cp2112_driver
= {
1426 .id_table
= cp2112_devices
,
1427 .probe
= cp2112_probe
,
1428 .remove
= cp2112_remove
,
1429 .raw_event
= cp2112_raw_event
,
1432 module_hid_driver(cp2112_driver
);
1433 MODULE_DESCRIPTION("Silicon Labs HID USB to SMBus master bridge");
1434 MODULE_AUTHOR("David Barksdale <dbarksdale@uplogix.com>");
1435 MODULE_LICENSE("GPL");