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