1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17#include <linux/device.h>
18#include <linux/input.h>
19#include <linux/usb.h>
20#include <linux/hid.h>
21#include <linux/module.h>
22#include <linux/slab.h>
23#include <linux/sched.h>
24#include <linux/kfifo.h>
25#include <linux/input/mt.h>
26#include <linux/workqueue.h>
27#include <linux/atomic.h>
28#include <linux/fixp-arith.h>
29#include <asm/unaligned.h>
30#include "usbhid/usbhid.h"
31#include "hid-ids.h"
32
33MODULE_LICENSE("GPL");
34MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
35MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
36
37static bool disable_raw_mode;
38module_param(disable_raw_mode, bool, 0644);
39MODULE_PARM_DESC(disable_raw_mode,
40 "Disable Raw mode reporting for touchpads and keep firmware gestures.");
41
42static bool disable_tap_to_click;
43module_param(disable_tap_to_click, bool, 0644);
44MODULE_PARM_DESC(disable_tap_to_click,
45 "Disable Tap-To-Click mode reporting for touchpads (only on the K400 currently).");
46
47#define REPORT_ID_HIDPP_SHORT 0x10
48#define REPORT_ID_HIDPP_LONG 0x11
49#define REPORT_ID_HIDPP_VERY_LONG 0x12
50
51#define HIDPP_REPORT_SHORT_LENGTH 7
52#define HIDPP_REPORT_LONG_LENGTH 20
53#define HIDPP_REPORT_VERY_LONG_LENGTH 64
54
55#define HIDPP_QUIRK_CLASS_WTP BIT(0)
56#define HIDPP_QUIRK_CLASS_M560 BIT(1)
57#define HIDPP_QUIRK_CLASS_K400 BIT(2)
58#define HIDPP_QUIRK_CLASS_G920 BIT(3)
59#define HIDPP_QUIRK_CLASS_K750 BIT(4)
60
61
62
63#define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS BIT(22)
64#define HIDPP_QUIRK_NO_HIDINPUT BIT(23)
65#define HIDPP_QUIRK_FORCE_OUTPUT_REPORTS BIT(24)
66#define HIDPP_QUIRK_UNIFYING BIT(25)
67
68#define HIDPP_QUIRK_DELAYED_INIT HIDPP_QUIRK_NO_HIDINPUT
69
70#define HIDPP_CAPABILITY_HIDPP10_BATTERY BIT(0)
71#define HIDPP_CAPABILITY_HIDPP20_BATTERY BIT(1)
72#define HIDPP_CAPABILITY_BATTERY_MILEAGE BIT(2)
73#define HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS BIT(3)
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97struct fap {
98 u8 feature_index;
99 u8 funcindex_clientid;
100 u8 params[HIDPP_REPORT_VERY_LONG_LENGTH - 4U];
101};
102
103struct rap {
104 u8 sub_id;
105 u8 reg_address;
106 u8 params[HIDPP_REPORT_VERY_LONG_LENGTH - 4U];
107};
108
109struct hidpp_report {
110 u8 report_id;
111 u8 device_index;
112 union {
113 struct fap fap;
114 struct rap rap;
115 u8 rawbytes[sizeof(struct fap)];
116 };
117} __packed;
118
119struct hidpp_battery {
120 u8 feature_index;
121 u8 solar_feature_index;
122 struct power_supply_desc desc;
123 struct power_supply *ps;
124 char name[64];
125 int status;
126 int capacity;
127 int level;
128 bool online;
129};
130
131struct hidpp_device {
132 struct hid_device *hid_dev;
133 struct mutex send_mutex;
134 void *send_receive_buf;
135 char *name;
136 wait_queue_head_t wait;
137 bool answer_available;
138 u8 protocol_major;
139 u8 protocol_minor;
140
141 void *private_data;
142
143 struct work_struct work;
144 struct kfifo delayed_work_fifo;
145 atomic_t connected;
146 struct input_dev *delayed_input;
147
148 unsigned long quirks;
149 unsigned long capabilities;
150
151 struct hidpp_battery battery;
152};
153
154
155#define HIDPP_ERROR 0x8f
156#define HIDPP_ERROR_SUCCESS 0x00
157#define HIDPP_ERROR_INVALID_SUBID 0x01
158#define HIDPP_ERROR_INVALID_ADRESS 0x02
159#define HIDPP_ERROR_INVALID_VALUE 0x03
160#define HIDPP_ERROR_CONNECT_FAIL 0x04
161#define HIDPP_ERROR_TOO_MANY_DEVICES 0x05
162#define HIDPP_ERROR_ALREADY_EXISTS 0x06
163#define HIDPP_ERROR_BUSY 0x07
164#define HIDPP_ERROR_UNKNOWN_DEVICE 0x08
165#define HIDPP_ERROR_RESOURCE_ERROR 0x09
166#define HIDPP_ERROR_REQUEST_UNAVAILABLE 0x0a
167#define HIDPP_ERROR_INVALID_PARAM_VALUE 0x0b
168#define HIDPP_ERROR_WRONG_PIN_CODE 0x0c
169
170#define HIDPP20_ERROR 0xff
171
172static void hidpp_connect_event(struct hidpp_device *hidpp_dev);
173
174static int __hidpp_send_report(struct hid_device *hdev,
175 struct hidpp_report *hidpp_report)
176{
177 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
178 int fields_count, ret;
179
180 hidpp = hid_get_drvdata(hdev);
181
182 switch (hidpp_report->report_id) {
183 case REPORT_ID_HIDPP_SHORT:
184 fields_count = HIDPP_REPORT_SHORT_LENGTH;
185 break;
186 case REPORT_ID_HIDPP_LONG:
187 fields_count = HIDPP_REPORT_LONG_LENGTH;
188 break;
189 case REPORT_ID_HIDPP_VERY_LONG:
190 fields_count = HIDPP_REPORT_VERY_LONG_LENGTH;
191 break;
192 default:
193 return -ENODEV;
194 }
195
196
197
198
199
200 hidpp_report->device_index = 0xff;
201
202 if (hidpp->quirks & HIDPP_QUIRK_FORCE_OUTPUT_REPORTS) {
203 ret = hid_hw_output_report(hdev, (u8 *)hidpp_report, fields_count);
204 } else {
205 ret = hid_hw_raw_request(hdev, hidpp_report->report_id,
206 (u8 *)hidpp_report, fields_count, HID_OUTPUT_REPORT,
207 HID_REQ_SET_REPORT);
208 }
209
210 return ret == fields_count ? 0 : -1;
211}
212
213
214
215
216
217
218
219
220
221static int hidpp_send_message_sync(struct hidpp_device *hidpp,
222 struct hidpp_report *message,
223 struct hidpp_report *response)
224{
225 int ret;
226
227 mutex_lock(&hidpp->send_mutex);
228
229 hidpp->send_receive_buf = response;
230 hidpp->answer_available = false;
231
232
233
234
235
236 *response = *message;
237
238 ret = __hidpp_send_report(hidpp->hid_dev, message);
239
240 if (ret) {
241 dbg_hid("__hidpp_send_report returned err: %d\n", ret);
242 memset(response, 0, sizeof(struct hidpp_report));
243 goto exit;
244 }
245
246 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
247 5*HZ)) {
248 dbg_hid("%s:timeout waiting for response\n", __func__);
249 memset(response, 0, sizeof(struct hidpp_report));
250 ret = -ETIMEDOUT;
251 }
252
253 if (response->report_id == REPORT_ID_HIDPP_SHORT &&
254 response->rap.sub_id == HIDPP_ERROR) {
255 ret = response->rap.params[1];
256 dbg_hid("%s:got hidpp error %02X\n", __func__, ret);
257 goto exit;
258 }
259
260 if ((response->report_id == REPORT_ID_HIDPP_LONG ||
261 response->report_id == REPORT_ID_HIDPP_VERY_LONG) &&
262 response->fap.feature_index == HIDPP20_ERROR) {
263 ret = response->fap.params[1];
264 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret);
265 goto exit;
266 }
267
268exit:
269 mutex_unlock(&hidpp->send_mutex);
270 return ret;
271
272}
273
274static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
275 u8 feat_index, u8 funcindex_clientid, u8 *params, int param_count,
276 struct hidpp_report *response)
277{
278 struct hidpp_report *message;
279 int ret;
280
281 if (param_count > sizeof(message->fap.params))
282 return -EINVAL;
283
284 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
285 if (!message)
286 return -ENOMEM;
287
288 if (param_count > (HIDPP_REPORT_LONG_LENGTH - 4))
289 message->report_id = REPORT_ID_HIDPP_VERY_LONG;
290 else
291 message->report_id = REPORT_ID_HIDPP_LONG;
292 message->fap.feature_index = feat_index;
293 message->fap.funcindex_clientid = funcindex_clientid;
294 memcpy(&message->fap.params, params, param_count);
295
296 ret = hidpp_send_message_sync(hidpp, message, response);
297 kfree(message);
298 return ret;
299}
300
301static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev,
302 u8 report_id, u8 sub_id, u8 reg_address, u8 *params, int param_count,
303 struct hidpp_report *response)
304{
305 struct hidpp_report *message;
306 int ret, max_count;
307
308 switch (report_id) {
309 case REPORT_ID_HIDPP_SHORT:
310 max_count = HIDPP_REPORT_SHORT_LENGTH - 4;
311 break;
312 case REPORT_ID_HIDPP_LONG:
313 max_count = HIDPP_REPORT_LONG_LENGTH - 4;
314 break;
315 case REPORT_ID_HIDPP_VERY_LONG:
316 max_count = HIDPP_REPORT_VERY_LONG_LENGTH - 4;
317 break;
318 default:
319 return -EINVAL;
320 }
321
322 if (param_count > max_count)
323 return -EINVAL;
324
325 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
326 if (!message)
327 return -ENOMEM;
328 message->report_id = report_id;
329 message->rap.sub_id = sub_id;
330 message->rap.reg_address = reg_address;
331 memcpy(&message->rap.params, params, param_count);
332
333 ret = hidpp_send_message_sync(hidpp_dev, message, response);
334 kfree(message);
335 return ret;
336}
337
338static void delayed_work_cb(struct work_struct *work)
339{
340 struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
341 work);
342 hidpp_connect_event(hidpp);
343}
344
345static inline bool hidpp_match_answer(struct hidpp_report *question,
346 struct hidpp_report *answer)
347{
348 return (answer->fap.feature_index == question->fap.feature_index) &&
349 (answer->fap.funcindex_clientid == question->fap.funcindex_clientid);
350}
351
352static inline bool hidpp_match_error(struct hidpp_report *question,
353 struct hidpp_report *answer)
354{
355 return ((answer->rap.sub_id == HIDPP_ERROR) ||
356 (answer->fap.feature_index == HIDPP20_ERROR)) &&
357 (answer->fap.funcindex_clientid == question->fap.feature_index) &&
358 (answer->fap.params[0] == question->fap.funcindex_clientid);
359}
360
361static inline bool hidpp_report_is_connect_event(struct hidpp_report *report)
362{
363 return (report->report_id == REPORT_ID_HIDPP_SHORT) &&
364 (report->rap.sub_id == 0x41);
365}
366
367
368
369
370static void hidpp_prefix_name(char **name, int name_length)
371{
372#define PREFIX_LENGTH 9
373
374 int new_length;
375 char *new_name;
376
377 if (name_length > PREFIX_LENGTH &&
378 strncmp(*name, "Logitech ", PREFIX_LENGTH) == 0)
379
380 return;
381
382 new_length = PREFIX_LENGTH + name_length;
383 new_name = kzalloc(new_length, GFP_KERNEL);
384 if (!new_name)
385 return;
386
387 snprintf(new_name, new_length, "Logitech %s", *name);
388
389 kfree(*name);
390
391 *name = new_name;
392}
393
394
395
396
397
398#define HIDPP_SET_REGISTER 0x80
399#define HIDPP_GET_REGISTER 0x81
400#define HIDPP_SET_LONG_REGISTER 0x82
401#define HIDPP_GET_LONG_REGISTER 0x83
402
403#define HIDPP_REG_GENERAL 0x00
404
405static int hidpp10_enable_battery_reporting(struct hidpp_device *hidpp_dev)
406{
407 struct hidpp_report response;
408 int ret;
409 u8 params[3] = { 0 };
410
411 ret = hidpp_send_rap_command_sync(hidpp_dev,
412 REPORT_ID_HIDPP_SHORT,
413 HIDPP_GET_REGISTER,
414 HIDPP_REG_GENERAL,
415 NULL, 0, &response);
416 if (ret)
417 return ret;
418
419 memcpy(params, response.rap.params, 3);
420
421
422 params[0] |= BIT(4);
423
424 return hidpp_send_rap_command_sync(hidpp_dev,
425 REPORT_ID_HIDPP_SHORT,
426 HIDPP_SET_REGISTER,
427 HIDPP_REG_GENERAL,
428 params, 3, &response);
429}
430
431#define HIDPP_REG_BATTERY_STATUS 0x07
432
433static int hidpp10_battery_status_map_level(u8 param)
434{
435 int level;
436
437 switch (param) {
438 case 1 ... 2:
439 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
440 break;
441 case 3 ... 4:
442 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
443 break;
444 case 5 ... 6:
445 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
446 break;
447 case 7:
448 level = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
449 break;
450 default:
451 level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
452 }
453
454 return level;
455}
456
457static int hidpp10_battery_status_map_status(u8 param)
458{
459 int status;
460
461 switch (param) {
462 case 0x00:
463
464 status = POWER_SUPPLY_STATUS_DISCHARGING;
465 break;
466 case 0x21:
467 case 0x24:
468 case 0x25:
469 status = POWER_SUPPLY_STATUS_CHARGING;
470 break;
471 case 0x26:
472 case 0x22:
473 status = POWER_SUPPLY_STATUS_FULL;
474 break;
475 case 0x20:
476 status = POWER_SUPPLY_STATUS_UNKNOWN;
477 break;
478
479
480
481
482
483 default:
484 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
485 break;
486 }
487
488 return status;
489}
490
491static int hidpp10_query_battery_status(struct hidpp_device *hidpp)
492{
493 struct hidpp_report response;
494 int ret, status;
495
496 ret = hidpp_send_rap_command_sync(hidpp,
497 REPORT_ID_HIDPP_SHORT,
498 HIDPP_GET_REGISTER,
499 HIDPP_REG_BATTERY_STATUS,
500 NULL, 0, &response);
501 if (ret)
502 return ret;
503
504 hidpp->battery.level =
505 hidpp10_battery_status_map_level(response.rap.params[0]);
506 status = hidpp10_battery_status_map_status(response.rap.params[1]);
507 hidpp->battery.status = status;
508
509 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
510 status == POWER_SUPPLY_STATUS_FULL;
511
512 return 0;
513}
514
515#define HIDPP_REG_BATTERY_MILEAGE 0x0D
516
517static int hidpp10_battery_mileage_map_status(u8 param)
518{
519 int status;
520
521 switch (param >> 6) {
522 case 0x00:
523
524 status = POWER_SUPPLY_STATUS_DISCHARGING;
525 break;
526 case 0x01:
527 status = POWER_SUPPLY_STATUS_CHARGING;
528 break;
529 case 0x02:
530 status = POWER_SUPPLY_STATUS_FULL;
531 break;
532
533
534
535 default:
536 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
537 break;
538 }
539
540 return status;
541}
542
543static int hidpp10_query_battery_mileage(struct hidpp_device *hidpp)
544{
545 struct hidpp_report response;
546 int ret, status;
547
548 ret = hidpp_send_rap_command_sync(hidpp,
549 REPORT_ID_HIDPP_SHORT,
550 HIDPP_GET_REGISTER,
551 HIDPP_REG_BATTERY_MILEAGE,
552 NULL, 0, &response);
553 if (ret)
554 return ret;
555
556 hidpp->battery.capacity = response.rap.params[0];
557 status = hidpp10_battery_mileage_map_status(response.rap.params[2]);
558 hidpp->battery.status = status;
559
560 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
561 status == POWER_SUPPLY_STATUS_FULL;
562
563 return 0;
564}
565
566static int hidpp10_battery_event(struct hidpp_device *hidpp, u8 *data, int size)
567{
568 struct hidpp_report *report = (struct hidpp_report *)data;
569 int status, capacity, level;
570 bool changed;
571
572 if (report->report_id != REPORT_ID_HIDPP_SHORT)
573 return 0;
574
575 switch (report->rap.sub_id) {
576 case HIDPP_REG_BATTERY_STATUS:
577 capacity = hidpp->battery.capacity;
578 level = hidpp10_battery_status_map_level(report->rawbytes[1]);
579 status = hidpp10_battery_status_map_status(report->rawbytes[2]);
580 break;
581 case HIDPP_REG_BATTERY_MILEAGE:
582 capacity = report->rap.params[0];
583 level = hidpp->battery.level;
584 status = hidpp10_battery_mileage_map_status(report->rawbytes[3]);
585 break;
586 default:
587 return 0;
588 }
589
590 changed = capacity != hidpp->battery.capacity ||
591 level != hidpp->battery.level ||
592 status != hidpp->battery.status;
593
594
595 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
596 status == POWER_SUPPLY_STATUS_FULL;
597
598 if (changed) {
599 hidpp->battery.level = level;
600 hidpp->battery.status = status;
601 if (hidpp->battery.ps)
602 power_supply_changed(hidpp->battery.ps);
603 }
604
605 return 0;
606}
607
608#define HIDPP_REG_PAIRING_INFORMATION 0xB5
609#define HIDPP_EXTENDED_PAIRING 0x30
610#define HIDPP_DEVICE_NAME 0x40
611
612static char *hidpp_unifying_get_name(struct hidpp_device *hidpp_dev)
613{
614 struct hidpp_report response;
615 int ret;
616 u8 params[1] = { HIDPP_DEVICE_NAME };
617 char *name;
618 int len;
619
620 ret = hidpp_send_rap_command_sync(hidpp_dev,
621 REPORT_ID_HIDPP_SHORT,
622 HIDPP_GET_LONG_REGISTER,
623 HIDPP_REG_PAIRING_INFORMATION,
624 params, 1, &response);
625 if (ret)
626 return NULL;
627
628 len = response.rap.params[1];
629
630 if (2 + len > sizeof(response.rap.params))
631 return NULL;
632
633 name = kzalloc(len + 1, GFP_KERNEL);
634 if (!name)
635 return NULL;
636
637 memcpy(name, &response.rap.params[2], len);
638
639
640 hidpp_prefix_name(&name, len + 1);
641
642 return name;
643}
644
645static int hidpp_unifying_get_serial(struct hidpp_device *hidpp, u32 *serial)
646{
647 struct hidpp_report response;
648 int ret;
649 u8 params[1] = { HIDPP_EXTENDED_PAIRING };
650
651 ret = hidpp_send_rap_command_sync(hidpp,
652 REPORT_ID_HIDPP_SHORT,
653 HIDPP_GET_LONG_REGISTER,
654 HIDPP_REG_PAIRING_INFORMATION,
655 params, 1, &response);
656 if (ret)
657 return ret;
658
659
660
661
662
663 *serial = *((u32 *)&response.rap.params[1]);
664 return 0;
665}
666
667static int hidpp_unifying_init(struct hidpp_device *hidpp)
668{
669 struct hid_device *hdev = hidpp->hid_dev;
670 const char *name;
671 u32 serial;
672 int ret;
673
674 ret = hidpp_unifying_get_serial(hidpp, &serial);
675 if (ret)
676 return ret;
677
678 snprintf(hdev->uniq, sizeof(hdev->uniq), "%04x-%4phD",
679 hdev->product, &serial);
680 dbg_hid("HID++ Unifying: Got serial: %s\n", hdev->uniq);
681
682 name = hidpp_unifying_get_name(hidpp);
683 if (!name)
684 return -EIO;
685
686 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
687 dbg_hid("HID++ Unifying: Got name: %s\n", name);
688
689 kfree(name);
690 return 0;
691}
692
693
694
695
696
697#define HIDPP_PAGE_ROOT 0x0000
698#define HIDPP_PAGE_ROOT_IDX 0x00
699
700#define CMD_ROOT_GET_FEATURE 0x01
701#define CMD_ROOT_GET_PROTOCOL_VERSION 0x11
702
703static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
704 u8 *feature_index, u8 *feature_type)
705{
706 struct hidpp_report response;
707 int ret;
708 u8 params[2] = { feature >> 8, feature & 0x00FF };
709
710 ret = hidpp_send_fap_command_sync(hidpp,
711 HIDPP_PAGE_ROOT_IDX,
712 CMD_ROOT_GET_FEATURE,
713 params, 2, &response);
714 if (ret)
715 return ret;
716
717 if (response.fap.params[0] == 0)
718 return -ENOENT;
719
720 *feature_index = response.fap.params[0];
721 *feature_type = response.fap.params[1];
722
723 return ret;
724}
725
726static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
727{
728 struct hidpp_report response;
729 int ret;
730
731 ret = hidpp_send_fap_command_sync(hidpp,
732 HIDPP_PAGE_ROOT_IDX,
733 CMD_ROOT_GET_PROTOCOL_VERSION,
734 NULL, 0, &response);
735
736 if (ret == HIDPP_ERROR_INVALID_SUBID) {
737 hidpp->protocol_major = 1;
738 hidpp->protocol_minor = 0;
739 return 0;
740 }
741
742
743 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
744 return -EIO;
745
746 if (ret > 0) {
747 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
748 __func__, ret);
749 return -EPROTO;
750 }
751 if (ret)
752 return ret;
753
754 hidpp->protocol_major = response.fap.params[0];
755 hidpp->protocol_minor = response.fap.params[1];
756
757 return ret;
758}
759
760static bool hidpp_is_connected(struct hidpp_device *hidpp)
761{
762 int ret;
763
764 ret = hidpp_root_get_protocol_version(hidpp);
765 if (!ret)
766 hid_dbg(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
767 hidpp->protocol_major, hidpp->protocol_minor);
768 return ret == 0;
769}
770
771
772
773
774
775#define HIDPP_PAGE_GET_DEVICE_NAME_TYPE 0x0005
776
777#define CMD_GET_DEVICE_NAME_TYPE_GET_COUNT 0x01
778#define CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME 0x11
779#define CMD_GET_DEVICE_NAME_TYPE_GET_TYPE 0x21
780
781static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
782 u8 feature_index, u8 *nameLength)
783{
784 struct hidpp_report response;
785 int ret;
786
787 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
788 CMD_GET_DEVICE_NAME_TYPE_GET_COUNT, NULL, 0, &response);
789
790 if (ret > 0) {
791 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
792 __func__, ret);
793 return -EPROTO;
794 }
795 if (ret)
796 return ret;
797
798 *nameLength = response.fap.params[0];
799
800 return ret;
801}
802
803static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
804 u8 feature_index, u8 char_index, char *device_name, int len_buf)
805{
806 struct hidpp_report response;
807 int ret, i;
808 int count;
809
810 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
811 CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME, &char_index, 1,
812 &response);
813
814 if (ret > 0) {
815 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
816 __func__, ret);
817 return -EPROTO;
818 }
819 if (ret)
820 return ret;
821
822 switch (response.report_id) {
823 case REPORT_ID_HIDPP_VERY_LONG:
824 count = HIDPP_REPORT_VERY_LONG_LENGTH - 4;
825 break;
826 case REPORT_ID_HIDPP_LONG:
827 count = HIDPP_REPORT_LONG_LENGTH - 4;
828 break;
829 case REPORT_ID_HIDPP_SHORT:
830 count = HIDPP_REPORT_SHORT_LENGTH - 4;
831 break;
832 default:
833 return -EPROTO;
834 }
835
836 if (len_buf < count)
837 count = len_buf;
838
839 for (i = 0; i < count; i++)
840 device_name[i] = response.fap.params[i];
841
842 return count;
843}
844
845static char *hidpp_get_device_name(struct hidpp_device *hidpp)
846{
847 u8 feature_type;
848 u8 feature_index;
849 u8 __name_length;
850 char *name;
851 unsigned index = 0;
852 int ret;
853
854 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
855 &feature_index, &feature_type);
856 if (ret)
857 return NULL;
858
859 ret = hidpp_devicenametype_get_count(hidpp, feature_index,
860 &__name_length);
861 if (ret)
862 return NULL;
863
864 name = kzalloc(__name_length + 1, GFP_KERNEL);
865 if (!name)
866 return NULL;
867
868 while (index < __name_length) {
869 ret = hidpp_devicenametype_get_device_name(hidpp,
870 feature_index, index, name + index,
871 __name_length - index);
872 if (ret <= 0) {
873 kfree(name);
874 return NULL;
875 }
876 index += ret;
877 }
878
879
880 hidpp_prefix_name(&name, __name_length + 1);
881
882 return name;
883}
884
885
886
887
888
889#define HIDPP_PAGE_BATTERY_LEVEL_STATUS 0x1000
890
891#define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS 0x00
892#define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY 0x10
893
894#define EVENT_BATTERY_LEVEL_STATUS_BROADCAST 0x00
895
896#define FLAG_BATTERY_LEVEL_DISABLE_OSD BIT(0)
897#define FLAG_BATTERY_LEVEL_MILEAGE BIT(1)
898#define FLAG_BATTERY_LEVEL_RECHARGEABLE BIT(2)
899
900static int hidpp_map_battery_level(int capacity)
901{
902 if (capacity < 11)
903 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
904 else if (capacity < 31)
905 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
906 else if (capacity < 81)
907 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
908 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
909}
910
911static int hidpp20_batterylevel_map_status_capacity(u8 data[3], int *capacity,
912 int *next_capacity,
913 int *level)
914{
915 int status;
916
917 *capacity = data[0];
918 *next_capacity = data[1];
919 *level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
920
921
922
923
924 switch (data[2]) {
925 case 0:
926 status = POWER_SUPPLY_STATUS_DISCHARGING;
927 *level = hidpp_map_battery_level(*capacity);
928 break;
929 case 1:
930 status = POWER_SUPPLY_STATUS_CHARGING;
931 break;
932 case 2:
933 status = POWER_SUPPLY_STATUS_CHARGING;
934 break;
935 case 3:
936 status = POWER_SUPPLY_STATUS_FULL;
937 *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
938 *capacity = 100;
939 break;
940 case 4:
941 status = POWER_SUPPLY_STATUS_CHARGING;
942 break;
943
944
945
946 default:
947 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
948 break;
949 }
950
951 return status;
952}
953
954static int hidpp20_batterylevel_get_battery_capacity(struct hidpp_device *hidpp,
955 u8 feature_index,
956 int *status,
957 int *capacity,
958 int *next_capacity,
959 int *level)
960{
961 struct hidpp_report response;
962 int ret;
963 u8 *params = (u8 *)response.fap.params;
964
965 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
966 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS,
967 NULL, 0, &response);
968 if (ret > 0) {
969 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
970 __func__, ret);
971 return -EPROTO;
972 }
973 if (ret)
974 return ret;
975
976 *status = hidpp20_batterylevel_map_status_capacity(params, capacity,
977 next_capacity,
978 level);
979
980 return 0;
981}
982
983static int hidpp20_batterylevel_get_battery_info(struct hidpp_device *hidpp,
984 u8 feature_index)
985{
986 struct hidpp_report response;
987 int ret;
988 u8 *params = (u8 *)response.fap.params;
989 unsigned int level_count, flags;
990
991 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
992 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY,
993 NULL, 0, &response);
994 if (ret > 0) {
995 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
996 __func__, ret);
997 return -EPROTO;
998 }
999 if (ret)
1000 return ret;
1001
1002 level_count = params[0];
1003 flags = params[1];
1004
1005 if (level_count < 10 || !(flags & FLAG_BATTERY_LEVEL_MILEAGE))
1006 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1007 else
1008 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1009
1010 return 0;
1011}
1012
1013static int hidpp20_query_battery_info(struct hidpp_device *hidpp)
1014{
1015 u8 feature_type;
1016 int ret;
1017 int status, capacity, next_capacity, level;
1018
1019 if (hidpp->battery.feature_index == 0xff) {
1020 ret = hidpp_root_get_feature(hidpp,
1021 HIDPP_PAGE_BATTERY_LEVEL_STATUS,
1022 &hidpp->battery.feature_index,
1023 &feature_type);
1024 if (ret)
1025 return ret;
1026 }
1027
1028 ret = hidpp20_batterylevel_get_battery_capacity(hidpp,
1029 hidpp->battery.feature_index,
1030 &status, &capacity,
1031 &next_capacity, &level);
1032 if (ret)
1033 return ret;
1034
1035 ret = hidpp20_batterylevel_get_battery_info(hidpp,
1036 hidpp->battery.feature_index);
1037 if (ret)
1038 return ret;
1039
1040 hidpp->battery.status = status;
1041 hidpp->battery.capacity = capacity;
1042 hidpp->battery.level = level;
1043
1044 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1045 status == POWER_SUPPLY_STATUS_FULL;
1046
1047 return 0;
1048}
1049
1050static int hidpp20_battery_event(struct hidpp_device *hidpp,
1051 u8 *data, int size)
1052{
1053 struct hidpp_report *report = (struct hidpp_report *)data;
1054 int status, capacity, next_capacity, level;
1055 bool changed;
1056
1057 if (report->fap.feature_index != hidpp->battery.feature_index ||
1058 report->fap.funcindex_clientid != EVENT_BATTERY_LEVEL_STATUS_BROADCAST)
1059 return 0;
1060
1061 status = hidpp20_batterylevel_map_status_capacity(report->fap.params,
1062 &capacity,
1063 &next_capacity,
1064 &level);
1065
1066
1067 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1068 status == POWER_SUPPLY_STATUS_FULL;
1069
1070 changed = capacity != hidpp->battery.capacity ||
1071 level != hidpp->battery.level ||
1072 status != hidpp->battery.status;
1073
1074 if (changed) {
1075 hidpp->battery.level = level;
1076 hidpp->battery.capacity = capacity;
1077 hidpp->battery.status = status;
1078 if (hidpp->battery.ps)
1079 power_supply_changed(hidpp->battery.ps);
1080 }
1081
1082 return 0;
1083}
1084
1085static enum power_supply_property hidpp_battery_props[] = {
1086 POWER_SUPPLY_PROP_ONLINE,
1087 POWER_SUPPLY_PROP_STATUS,
1088 POWER_SUPPLY_PROP_SCOPE,
1089 POWER_SUPPLY_PROP_MODEL_NAME,
1090 POWER_SUPPLY_PROP_MANUFACTURER,
1091 POWER_SUPPLY_PROP_SERIAL_NUMBER,
1092 0,
1093 0,
1094};
1095
1096static int hidpp_battery_get_property(struct power_supply *psy,
1097 enum power_supply_property psp,
1098 union power_supply_propval *val)
1099{
1100 struct hidpp_device *hidpp = power_supply_get_drvdata(psy);
1101 int ret = 0;
1102
1103 switch(psp) {
1104 case POWER_SUPPLY_PROP_STATUS:
1105 val->intval = hidpp->battery.status;
1106 break;
1107 case POWER_SUPPLY_PROP_CAPACITY:
1108 val->intval = hidpp->battery.capacity;
1109 break;
1110 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
1111 val->intval = hidpp->battery.level;
1112 break;
1113 case POWER_SUPPLY_PROP_SCOPE:
1114 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1115 break;
1116 case POWER_SUPPLY_PROP_ONLINE:
1117 val->intval = hidpp->battery.online;
1118 break;
1119 case POWER_SUPPLY_PROP_MODEL_NAME:
1120 if (!strncmp(hidpp->name, "Logitech ", 9))
1121 val->strval = hidpp->name + 9;
1122 else
1123 val->strval = hidpp->name;
1124 break;
1125 case POWER_SUPPLY_PROP_MANUFACTURER:
1126 val->strval = "Logitech";
1127 break;
1128 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
1129 val->strval = hidpp->hid_dev->uniq;
1130 break;
1131 default:
1132 ret = -EINVAL;
1133 break;
1134 }
1135
1136 return ret;
1137}
1138
1139
1140
1141
1142
1143#define HIDPP_PAGE_SOLAR_KEYBOARD 0x4301
1144
1145#define CMD_SOLAR_SET_LIGHT_MEASURE 0x00
1146
1147#define EVENT_SOLAR_BATTERY_BROADCAST 0x00
1148#define EVENT_SOLAR_BATTERY_LIGHT_MEASURE 0x10
1149#define EVENT_SOLAR_CHECK_LIGHT_BUTTON 0x20
1150
1151static int hidpp_solar_request_battery_event(struct hidpp_device *hidpp)
1152{
1153 struct hidpp_report response;
1154 u8 params[2] = { 1, 1 };
1155 u8 feature_type;
1156 int ret;
1157
1158 if (hidpp->battery.feature_index == 0xff) {
1159 ret = hidpp_root_get_feature(hidpp,
1160 HIDPP_PAGE_SOLAR_KEYBOARD,
1161 &hidpp->battery.solar_feature_index,
1162 &feature_type);
1163 if (ret)
1164 return ret;
1165 }
1166
1167 ret = hidpp_send_fap_command_sync(hidpp,
1168 hidpp->battery.solar_feature_index,
1169 CMD_SOLAR_SET_LIGHT_MEASURE,
1170 params, 2, &response);
1171 if (ret > 0) {
1172 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1173 __func__, ret);
1174 return -EPROTO;
1175 }
1176 if (ret)
1177 return ret;
1178
1179 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1180
1181 return 0;
1182}
1183
1184static int hidpp_solar_battery_event(struct hidpp_device *hidpp,
1185 u8 *data, int size)
1186{
1187 struct hidpp_report *report = (struct hidpp_report *)data;
1188 int capacity, lux, status;
1189 u8 function;
1190
1191 function = report->fap.funcindex_clientid;
1192
1193
1194 if (report->fap.feature_index != hidpp->battery.solar_feature_index ||
1195 !(function == EVENT_SOLAR_BATTERY_BROADCAST ||
1196 function == EVENT_SOLAR_BATTERY_LIGHT_MEASURE ||
1197 function == EVENT_SOLAR_CHECK_LIGHT_BUTTON))
1198 return 0;
1199
1200 capacity = report->fap.params[0];
1201
1202 switch (function) {
1203 case EVENT_SOLAR_BATTERY_LIGHT_MEASURE:
1204 lux = (report->fap.params[1] << 8) | report->fap.params[2];
1205 if (lux > 200)
1206 status = POWER_SUPPLY_STATUS_CHARGING;
1207 else
1208 status = POWER_SUPPLY_STATUS_DISCHARGING;
1209 break;
1210 case EVENT_SOLAR_CHECK_LIGHT_BUTTON:
1211 default:
1212 if (capacity < hidpp->battery.capacity)
1213 status = POWER_SUPPLY_STATUS_DISCHARGING;
1214 else
1215 status = POWER_SUPPLY_STATUS_CHARGING;
1216
1217 }
1218
1219 if (capacity == 100)
1220 status = POWER_SUPPLY_STATUS_FULL;
1221
1222 hidpp->battery.online = true;
1223 if (capacity != hidpp->battery.capacity ||
1224 status != hidpp->battery.status) {
1225 hidpp->battery.capacity = capacity;
1226 hidpp->battery.status = status;
1227 if (hidpp->battery.ps)
1228 power_supply_changed(hidpp->battery.ps);
1229 }
1230
1231 return 0;
1232}
1233
1234
1235
1236
1237
1238#define HIDPP_PAGE_TOUCHPAD_FW_ITEMS 0x6010
1239
1240#define CMD_TOUCHPAD_FW_ITEMS_SET 0x10
1241
1242struct hidpp_touchpad_fw_items {
1243 uint8_t presence;
1244 uint8_t desired_state;
1245 uint8_t state;
1246 uint8_t persistent;
1247};
1248
1249
1250
1251
1252
1253static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
1254 u8 feature_index,
1255 struct hidpp_touchpad_fw_items *items)
1256{
1257 struct hidpp_report response;
1258 int ret;
1259 u8 *params = (u8 *)response.fap.params;
1260
1261 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1262 CMD_TOUCHPAD_FW_ITEMS_SET, &items->state, 1, &response);
1263
1264 if (ret > 0) {
1265 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1266 __func__, ret);
1267 return -EPROTO;
1268 }
1269 if (ret)
1270 return ret;
1271
1272 items->presence = params[0];
1273 items->desired_state = params[1];
1274 items->state = params[2];
1275 items->persistent = params[3];
1276
1277 return 0;
1278}
1279
1280
1281
1282
1283
1284#define HIDPP_PAGE_TOUCHPAD_RAW_XY 0x6100
1285
1286#define CMD_TOUCHPAD_GET_RAW_INFO 0x01
1287#define CMD_TOUCHPAD_SET_RAW_REPORT_STATE 0x21
1288
1289#define EVENT_TOUCHPAD_RAW_XY 0x00
1290
1291#define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT 0x01
1292#define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT 0x03
1293
1294struct hidpp_touchpad_raw_info {
1295 u16 x_size;
1296 u16 y_size;
1297 u8 z_range;
1298 u8 area_range;
1299 u8 timestamp_unit;
1300 u8 maxcontacts;
1301 u8 origin;
1302 u16 res;
1303};
1304
1305struct hidpp_touchpad_raw_xy_finger {
1306 u8 contact_type;
1307 u8 contact_status;
1308 u16 x;
1309 u16 y;
1310 u8 z;
1311 u8 area;
1312 u8 finger_id;
1313};
1314
1315struct hidpp_touchpad_raw_xy {
1316 u16 timestamp;
1317 struct hidpp_touchpad_raw_xy_finger fingers[2];
1318 u8 spurious_flag;
1319 u8 end_of_frame;
1320 u8 finger_count;
1321 u8 button;
1322};
1323
1324static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
1325 u8 feature_index, struct hidpp_touchpad_raw_info *raw_info)
1326{
1327 struct hidpp_report response;
1328 int ret;
1329 u8 *params = (u8 *)response.fap.params;
1330
1331 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1332 CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response);
1333
1334 if (ret > 0) {
1335 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1336 __func__, ret);
1337 return -EPROTO;
1338 }
1339 if (ret)
1340 return ret;
1341
1342 raw_info->x_size = get_unaligned_be16(¶ms[0]);
1343 raw_info->y_size = get_unaligned_be16(¶ms[2]);
1344 raw_info->z_range = params[4];
1345 raw_info->area_range = params[5];
1346 raw_info->maxcontacts = params[7];
1347 raw_info->origin = params[8];
1348
1349 raw_info->res = get_unaligned_be16(¶ms[13]) * 2 / 51;
1350
1351 return ret;
1352}
1353
1354static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev,
1355 u8 feature_index, bool send_raw_reports,
1356 bool sensor_enhanced_settings)
1357{
1358 struct hidpp_report response;
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369 u8 params = send_raw_reports | (sensor_enhanced_settings << 2);
1370
1371 return hidpp_send_fap_command_sync(hidpp_dev, feature_index,
1372 CMD_TOUCHPAD_SET_RAW_REPORT_STATE, ¶ms, 1, &response);
1373}
1374
1375static void hidpp_touchpad_touch_event(u8 *data,
1376 struct hidpp_touchpad_raw_xy_finger *finger)
1377{
1378 u8 x_m = data[0] << 2;
1379 u8 y_m = data[2] << 2;
1380
1381 finger->x = x_m << 6 | data[1];
1382 finger->y = y_m << 6 | data[3];
1383
1384 finger->contact_type = data[0] >> 6;
1385 finger->contact_status = data[2] >> 6;
1386
1387 finger->z = data[4];
1388 finger->area = data[5];
1389 finger->finger_id = data[6] >> 4;
1390}
1391
1392static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev,
1393 u8 *data, struct hidpp_touchpad_raw_xy *raw_xy)
1394{
1395 memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy));
1396 raw_xy->end_of_frame = data[8] & 0x01;
1397 raw_xy->spurious_flag = (data[8] >> 1) & 0x01;
1398 raw_xy->finger_count = data[15] & 0x0f;
1399 raw_xy->button = (data[8] >> 2) & 0x01;
1400
1401 if (raw_xy->finger_count) {
1402 hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]);
1403 hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]);
1404 }
1405}
1406
1407
1408
1409
1410
1411#define HIDPP_FF_GET_INFO 0x01
1412#define HIDPP_FF_RESET_ALL 0x11
1413#define HIDPP_FF_DOWNLOAD_EFFECT 0x21
1414#define HIDPP_FF_SET_EFFECT_STATE 0x31
1415#define HIDPP_FF_DESTROY_EFFECT 0x41
1416#define HIDPP_FF_GET_APERTURE 0x51
1417#define HIDPP_FF_SET_APERTURE 0x61
1418#define HIDPP_FF_GET_GLOBAL_GAINS 0x71
1419#define HIDPP_FF_SET_GLOBAL_GAINS 0x81
1420
1421#define HIDPP_FF_EFFECT_STATE_GET 0x00
1422#define HIDPP_FF_EFFECT_STATE_STOP 0x01
1423#define HIDPP_FF_EFFECT_STATE_PLAY 0x02
1424#define HIDPP_FF_EFFECT_STATE_PAUSE 0x03
1425
1426#define HIDPP_FF_EFFECT_CONSTANT 0x00
1427#define HIDPP_FF_EFFECT_PERIODIC_SINE 0x01
1428#define HIDPP_FF_EFFECT_PERIODIC_SQUARE 0x02
1429#define HIDPP_FF_EFFECT_PERIODIC_TRIANGLE 0x03
1430#define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP 0x04
1431#define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN 0x05
1432#define HIDPP_FF_EFFECT_SPRING 0x06
1433#define HIDPP_FF_EFFECT_DAMPER 0x07
1434#define HIDPP_FF_EFFECT_FRICTION 0x08
1435#define HIDPP_FF_EFFECT_INERTIA 0x09
1436#define HIDPP_FF_EFFECT_RAMP 0x0A
1437
1438#define HIDPP_FF_EFFECT_AUTOSTART 0x80
1439
1440#define HIDPP_FF_EFFECTID_NONE -1
1441#define HIDPP_FF_EFFECTID_AUTOCENTER -2
1442
1443#define HIDPP_FF_MAX_PARAMS 20
1444#define HIDPP_FF_RESERVED_SLOTS 1
1445
1446struct hidpp_ff_private_data {
1447 struct hidpp_device *hidpp;
1448 u8 feature_index;
1449 u8 version;
1450 u16 gain;
1451 s16 range;
1452 u8 slot_autocenter;
1453 u8 num_effects;
1454 int *effect_ids;
1455 struct workqueue_struct *wq;
1456 atomic_t workqueue_size;
1457};
1458
1459struct hidpp_ff_work_data {
1460 struct work_struct work;
1461 struct hidpp_ff_private_data *data;
1462 int effect_id;
1463 u8 command;
1464 u8 params[HIDPP_FF_MAX_PARAMS];
1465 u8 size;
1466};
1467
1468static const signed short hiddpp_ff_effects[] = {
1469 FF_CONSTANT,
1470 FF_PERIODIC,
1471 FF_SINE,
1472 FF_SQUARE,
1473 FF_SAW_UP,
1474 FF_SAW_DOWN,
1475 FF_TRIANGLE,
1476 FF_SPRING,
1477 FF_DAMPER,
1478 FF_AUTOCENTER,
1479 FF_GAIN,
1480 -1
1481};
1482
1483static const signed short hiddpp_ff_effects_v2[] = {
1484 FF_RAMP,
1485 FF_FRICTION,
1486 FF_INERTIA,
1487 -1
1488};
1489
1490static const u8 HIDPP_FF_CONDITION_CMDS[] = {
1491 HIDPP_FF_EFFECT_SPRING,
1492 HIDPP_FF_EFFECT_FRICTION,
1493 HIDPP_FF_EFFECT_DAMPER,
1494 HIDPP_FF_EFFECT_INERTIA
1495};
1496
1497static const char *HIDPP_FF_CONDITION_NAMES[] = {
1498 "spring",
1499 "friction",
1500 "damper",
1501 "inertia"
1502};
1503
1504
1505static u8 hidpp_ff_find_effect(struct hidpp_ff_private_data *data, int effect_id)
1506{
1507 int i;
1508
1509 for (i = 0; i < data->num_effects; i++)
1510 if (data->effect_ids[i] == effect_id)
1511 return i+1;
1512
1513 return 0;
1514}
1515
1516static void hidpp_ff_work_handler(struct work_struct *w)
1517{
1518 struct hidpp_ff_work_data *wd = container_of(w, struct hidpp_ff_work_data, work);
1519 struct hidpp_ff_private_data *data = wd->data;
1520 struct hidpp_report response;
1521 u8 slot;
1522 int ret;
1523
1524
1525 switch (wd->effect_id) {
1526 case HIDPP_FF_EFFECTID_AUTOCENTER:
1527 wd->params[0] = data->slot_autocenter;
1528 break;
1529 case HIDPP_FF_EFFECTID_NONE:
1530
1531 break;
1532 default:
1533
1534 wd->params[0] = hidpp_ff_find_effect(data, wd->effect_id);
1535 break;
1536 }
1537
1538
1539 ret = hidpp_send_fap_command_sync(data->hidpp, data->feature_index,
1540 wd->command, wd->params, wd->size, &response);
1541
1542 if (ret) {
1543 hid_err(data->hidpp->hid_dev, "Failed to send command to device!\n");
1544 goto out;
1545 }
1546
1547
1548 switch (wd->command) {
1549 case HIDPP_FF_DOWNLOAD_EFFECT:
1550 slot = response.fap.params[0];
1551 if (slot > 0 && slot <= data->num_effects) {
1552 if (wd->effect_id >= 0)
1553
1554 data->effect_ids[slot-1] = wd->effect_id;
1555 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
1556
1557 data->slot_autocenter = slot;
1558 }
1559 break;
1560 case HIDPP_FF_DESTROY_EFFECT:
1561 if (wd->effect_id >= 0)
1562
1563 data->effect_ids[wd->params[0]-1] = -1;
1564 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
1565
1566 data->slot_autocenter = 0;
1567 break;
1568 case HIDPP_FF_SET_GLOBAL_GAINS:
1569 data->gain = (wd->params[0] << 8) + wd->params[1];
1570 break;
1571 case HIDPP_FF_SET_APERTURE:
1572 data->range = (wd->params[0] << 8) + wd->params[1];
1573 break;
1574 default:
1575
1576 break;
1577 }
1578
1579out:
1580 atomic_dec(&data->workqueue_size);
1581 kfree(wd);
1582}
1583
1584static int hidpp_ff_queue_work(struct hidpp_ff_private_data *data, int effect_id, u8 command, u8 *params, u8 size)
1585{
1586 struct hidpp_ff_work_data *wd = kzalloc(sizeof(*wd), GFP_KERNEL);
1587 int s;
1588
1589 if (!wd)
1590 return -ENOMEM;
1591
1592 INIT_WORK(&wd->work, hidpp_ff_work_handler);
1593
1594 wd->data = data;
1595 wd->effect_id = effect_id;
1596 wd->command = command;
1597 wd->size = size;
1598 memcpy(wd->params, params, size);
1599
1600 atomic_inc(&data->workqueue_size);
1601 queue_work(data->wq, &wd->work);
1602
1603
1604 s = atomic_read(&data->workqueue_size);
1605 if (s >= 20 && s % 20 == 0)
1606 hid_warn(data->hidpp->hid_dev, "Force feedback command queue contains %d commands, causing substantial delays!", s);
1607
1608 return 0;
1609}
1610
1611static int hidpp_ff_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
1612{
1613 struct hidpp_ff_private_data *data = dev->ff->private;
1614 u8 params[20];
1615 u8 size;
1616 int force;
1617
1618
1619 params[2] = effect->replay.length >> 8;
1620 params[3] = effect->replay.length & 255;
1621 params[4] = effect->replay.delay >> 8;
1622 params[5] = effect->replay.delay & 255;
1623
1624 switch (effect->type) {
1625 case FF_CONSTANT:
1626 force = (effect->u.constant.level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
1627 params[1] = HIDPP_FF_EFFECT_CONSTANT;
1628 params[6] = force >> 8;
1629 params[7] = force & 255;
1630 params[8] = effect->u.constant.envelope.attack_level >> 7;
1631 params[9] = effect->u.constant.envelope.attack_length >> 8;
1632 params[10] = effect->u.constant.envelope.attack_length & 255;
1633 params[11] = effect->u.constant.envelope.fade_level >> 7;
1634 params[12] = effect->u.constant.envelope.fade_length >> 8;
1635 params[13] = effect->u.constant.envelope.fade_length & 255;
1636 size = 14;
1637 dbg_hid("Uploading constant force level=%d in dir %d = %d\n",
1638 effect->u.constant.level,
1639 effect->direction, force);
1640 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
1641 effect->u.constant.envelope.attack_level,
1642 effect->u.constant.envelope.attack_length,
1643 effect->u.constant.envelope.fade_level,
1644 effect->u.constant.envelope.fade_length);
1645 break;
1646 case FF_PERIODIC:
1647 {
1648 switch (effect->u.periodic.waveform) {
1649 case FF_SINE:
1650 params[1] = HIDPP_FF_EFFECT_PERIODIC_SINE;
1651 break;
1652 case FF_SQUARE:
1653 params[1] = HIDPP_FF_EFFECT_PERIODIC_SQUARE;
1654 break;
1655 case FF_SAW_UP:
1656 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP;
1657 break;
1658 case FF_SAW_DOWN:
1659 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN;
1660 break;
1661 case FF_TRIANGLE:
1662 params[1] = HIDPP_FF_EFFECT_PERIODIC_TRIANGLE;
1663 break;
1664 default:
1665 hid_err(data->hidpp->hid_dev, "Unexpected periodic waveform type %i!\n", effect->u.periodic.waveform);
1666 return -EINVAL;
1667 }
1668 force = (effect->u.periodic.magnitude * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
1669 params[6] = effect->u.periodic.magnitude >> 8;
1670 params[7] = effect->u.periodic.magnitude & 255;
1671 params[8] = effect->u.periodic.offset >> 8;
1672 params[9] = effect->u.periodic.offset & 255;
1673 params[10] = effect->u.periodic.period >> 8;
1674 params[11] = effect->u.periodic.period & 255;
1675 params[12] = effect->u.periodic.phase >> 8;
1676 params[13] = effect->u.periodic.phase & 255;
1677 params[14] = effect->u.periodic.envelope.attack_level >> 7;
1678 params[15] = effect->u.periodic.envelope.attack_length >> 8;
1679 params[16] = effect->u.periodic.envelope.attack_length & 255;
1680 params[17] = effect->u.periodic.envelope.fade_level >> 7;
1681 params[18] = effect->u.periodic.envelope.fade_length >> 8;
1682 params[19] = effect->u.periodic.envelope.fade_length & 255;
1683 size = 20;
1684 dbg_hid("Uploading periodic force mag=%d/dir=%d, offset=%d, period=%d ms, phase=%d\n",
1685 effect->u.periodic.magnitude, effect->direction,
1686 effect->u.periodic.offset,
1687 effect->u.periodic.period,
1688 effect->u.periodic.phase);
1689 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
1690 effect->u.periodic.envelope.attack_level,
1691 effect->u.periodic.envelope.attack_length,
1692 effect->u.periodic.envelope.fade_level,
1693 effect->u.periodic.envelope.fade_length);
1694 break;
1695 }
1696 case FF_RAMP:
1697 params[1] = HIDPP_FF_EFFECT_RAMP;
1698 force = (effect->u.ramp.start_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
1699 params[6] = force >> 8;
1700 params[7] = force & 255;
1701 force = (effect->u.ramp.end_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
1702 params[8] = force >> 8;
1703 params[9] = force & 255;
1704 params[10] = effect->u.ramp.envelope.attack_level >> 7;
1705 params[11] = effect->u.ramp.envelope.attack_length >> 8;
1706 params[12] = effect->u.ramp.envelope.attack_length & 255;
1707 params[13] = effect->u.ramp.envelope.fade_level >> 7;
1708 params[14] = effect->u.ramp.envelope.fade_length >> 8;
1709 params[15] = effect->u.ramp.envelope.fade_length & 255;
1710 size = 16;
1711 dbg_hid("Uploading ramp force level=%d -> %d in dir %d = %d\n",
1712 effect->u.ramp.start_level,
1713 effect->u.ramp.end_level,
1714 effect->direction, force);
1715 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
1716 effect->u.ramp.envelope.attack_level,
1717 effect->u.ramp.envelope.attack_length,
1718 effect->u.ramp.envelope.fade_level,
1719 effect->u.ramp.envelope.fade_length);
1720 break;
1721 case FF_FRICTION:
1722 case FF_INERTIA:
1723 case FF_SPRING:
1724 case FF_DAMPER:
1725 params[1] = HIDPP_FF_CONDITION_CMDS[effect->type - FF_SPRING];
1726 params[6] = effect->u.condition[0].left_saturation >> 9;
1727 params[7] = (effect->u.condition[0].left_saturation >> 1) & 255;
1728 params[8] = effect->u.condition[0].left_coeff >> 8;
1729 params[9] = effect->u.condition[0].left_coeff & 255;
1730 params[10] = effect->u.condition[0].deadband >> 9;
1731 params[11] = (effect->u.condition[0].deadband >> 1) & 255;
1732 params[12] = effect->u.condition[0].center >> 8;
1733 params[13] = effect->u.condition[0].center & 255;
1734 params[14] = effect->u.condition[0].right_coeff >> 8;
1735 params[15] = effect->u.condition[0].right_coeff & 255;
1736 params[16] = effect->u.condition[0].right_saturation >> 9;
1737 params[17] = (effect->u.condition[0].right_saturation >> 1) & 255;
1738 size = 18;
1739 dbg_hid("Uploading %s force left coeff=%d, left sat=%d, right coeff=%d, right sat=%d\n",
1740 HIDPP_FF_CONDITION_NAMES[effect->type - FF_SPRING],
1741 effect->u.condition[0].left_coeff,
1742 effect->u.condition[0].left_saturation,
1743 effect->u.condition[0].right_coeff,
1744 effect->u.condition[0].right_saturation);
1745 dbg_hid(" deadband=%d, center=%d\n",
1746 effect->u.condition[0].deadband,
1747 effect->u.condition[0].center);
1748 break;
1749 default:
1750 hid_err(data->hidpp->hid_dev, "Unexpected force type %i!\n", effect->type);
1751 return -EINVAL;
1752 }
1753
1754 return hidpp_ff_queue_work(data, effect->id, HIDPP_FF_DOWNLOAD_EFFECT, params, size);
1755}
1756
1757static int hidpp_ff_playback(struct input_dev *dev, int effect_id, int value)
1758{
1759 struct hidpp_ff_private_data *data = dev->ff->private;
1760 u8 params[2];
1761
1762 params[1] = value ? HIDPP_FF_EFFECT_STATE_PLAY : HIDPP_FF_EFFECT_STATE_STOP;
1763
1764 dbg_hid("St%sing playback of effect %d.\n", value?"art":"opp", effect_id);
1765
1766 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_SET_EFFECT_STATE, params, ARRAY_SIZE(params));
1767}
1768
1769static int hidpp_ff_erase_effect(struct input_dev *dev, int effect_id)
1770{
1771 struct hidpp_ff_private_data *data = dev->ff->private;
1772 u8 slot = 0;
1773
1774 dbg_hid("Erasing effect %d.\n", effect_id);
1775
1776 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_DESTROY_EFFECT, &slot, 1);
1777}
1778
1779static void hidpp_ff_set_autocenter(struct input_dev *dev, u16 magnitude)
1780{
1781 struct hidpp_ff_private_data *data = dev->ff->private;
1782 u8 params[18];
1783
1784 dbg_hid("Setting autocenter to %d.\n", magnitude);
1785
1786
1787 params[1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART;
1788
1789 params[2] = params[3] = params[4] = params[5] = 0;
1790
1791 params[8] = params[14] = magnitude >> 11;
1792 params[9] = params[15] = (magnitude >> 3) & 255;
1793 params[6] = params[16] = magnitude >> 9;
1794 params[7] = params[17] = (magnitude >> 1) & 255;
1795
1796 params[10] = params[11] = params[12] = params[13] = 0;
1797
1798 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_AUTOCENTER, HIDPP_FF_DOWNLOAD_EFFECT, params, ARRAY_SIZE(params));
1799}
1800
1801static void hidpp_ff_set_gain(struct input_dev *dev, u16 gain)
1802{
1803 struct hidpp_ff_private_data *data = dev->ff->private;
1804 u8 params[4];
1805
1806 dbg_hid("Setting gain to %d.\n", gain);
1807
1808 params[0] = gain >> 8;
1809 params[1] = gain & 255;
1810 params[2] = 0;
1811 params[3] = 0;
1812
1813 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_NONE, HIDPP_FF_SET_GLOBAL_GAINS, params, ARRAY_SIZE(params));
1814}
1815
1816static ssize_t hidpp_ff_range_show(struct device *dev, struct device_attribute *attr, char *buf)
1817{
1818 struct hid_device *hid = to_hid_device(dev);
1819 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
1820 struct input_dev *idev = hidinput->input;
1821 struct hidpp_ff_private_data *data = idev->ff->private;
1822
1823 return scnprintf(buf, PAGE_SIZE, "%u\n", data->range);
1824}
1825
1826static ssize_t hidpp_ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1827{
1828 struct hid_device *hid = to_hid_device(dev);
1829 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
1830 struct input_dev *idev = hidinput->input;
1831 struct hidpp_ff_private_data *data = idev->ff->private;
1832 u8 params[2];
1833 int range = simple_strtoul(buf, NULL, 10);
1834
1835 range = clamp(range, 180, 900);
1836
1837 params[0] = range >> 8;
1838 params[1] = range & 0x00FF;
1839
1840 hidpp_ff_queue_work(data, -1, HIDPP_FF_SET_APERTURE, params, ARRAY_SIZE(params));
1841
1842 return count;
1843}
1844
1845static DEVICE_ATTR(range, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, hidpp_ff_range_show, hidpp_ff_range_store);
1846
1847static void hidpp_ff_destroy(struct ff_device *ff)
1848{
1849 struct hidpp_ff_private_data *data = ff->private;
1850
1851 kfree(data->effect_ids);
1852}
1853
1854static int hidpp_ff_init(struct hidpp_device *hidpp, u8 feature_index)
1855{
1856 struct hid_device *hid = hidpp->hid_dev;
1857 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
1858 struct input_dev *dev = hidinput->input;
1859 const struct usb_device_descriptor *udesc = &(hid_to_usb_dev(hid)->descriptor);
1860 const u16 bcdDevice = le16_to_cpu(udesc->bcdDevice);
1861 struct ff_device *ff;
1862 struct hidpp_report response;
1863 struct hidpp_ff_private_data *data;
1864 int error, j, num_slots;
1865 u8 version;
1866
1867 if (!dev) {
1868 hid_err(hid, "Struct input_dev not set!\n");
1869 return -EINVAL;
1870 }
1871
1872
1873 version = bcdDevice & 255;
1874
1875
1876 for (j = 0; hiddpp_ff_effects[j] >= 0; j++)
1877 set_bit(hiddpp_ff_effects[j], dev->ffbit);
1878 if (version > 1)
1879 for (j = 0; hiddpp_ff_effects_v2[j] >= 0; j++)
1880 set_bit(hiddpp_ff_effects_v2[j], dev->ffbit);
1881
1882
1883 error = hidpp_send_fap_command_sync(hidpp, feature_index,
1884 HIDPP_FF_GET_INFO, NULL, 0, &response);
1885 if (error) {
1886 if (error < 0)
1887 return error;
1888 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1889 __func__, error);
1890 return -EPROTO;
1891 }
1892
1893 num_slots = response.fap.params[0] - HIDPP_FF_RESERVED_SLOTS;
1894
1895 error = input_ff_create(dev, num_slots);
1896
1897 if (error) {
1898 hid_err(dev, "Failed to create FF device!\n");
1899 return error;
1900 }
1901
1902 data = kzalloc(sizeof(*data), GFP_KERNEL);
1903 if (!data)
1904 return -ENOMEM;
1905 data->effect_ids = kcalloc(num_slots, sizeof(int), GFP_KERNEL);
1906 if (!data->effect_ids) {
1907 kfree(data);
1908 return -ENOMEM;
1909 }
1910 data->hidpp = hidpp;
1911 data->feature_index = feature_index;
1912 data->version = version;
1913 data->slot_autocenter = 0;
1914 data->num_effects = num_slots;
1915 for (j = 0; j < num_slots; j++)
1916 data->effect_ids[j] = -1;
1917
1918 ff = dev->ff;
1919 ff->private = data;
1920
1921 ff->upload = hidpp_ff_upload_effect;
1922 ff->erase = hidpp_ff_erase_effect;
1923 ff->playback = hidpp_ff_playback;
1924 ff->set_gain = hidpp_ff_set_gain;
1925 ff->set_autocenter = hidpp_ff_set_autocenter;
1926 ff->destroy = hidpp_ff_destroy;
1927
1928
1929
1930 error = hidpp_send_fap_command_sync(hidpp, feature_index,
1931 HIDPP_FF_RESET_ALL, NULL, 0, &response);
1932
1933
1934 error = hidpp_send_fap_command_sync(hidpp, feature_index,
1935 HIDPP_FF_GET_APERTURE, NULL, 0, &response);
1936 if (error)
1937 hid_warn(hidpp->hid_dev, "Failed to read range from device!\n");
1938 data->range = error ? 900 : get_unaligned_be16(&response.fap.params[0]);
1939
1940
1941 error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
1942 if (error)
1943 hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
1944
1945
1946 error = hidpp_send_fap_command_sync(hidpp, feature_index,
1947 HIDPP_FF_GET_GLOBAL_GAINS, NULL, 0, &response);
1948 if (error)
1949 hid_warn(hidpp->hid_dev, "Failed to read gain values from device!\n");
1950 data->gain = error ? 0xffff : get_unaligned_be16(&response.fap.params[0]);
1951
1952
1953
1954 data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
1955 atomic_set(&data->workqueue_size, 0);
1956
1957
1958 hidpp_ff_set_autocenter(dev, 0);
1959
1960 hid_info(hid, "Force feedback support loaded (firmware release %d).\n",
1961 version);
1962
1963 return 0;
1964}
1965
1966static int hidpp_ff_deinit(struct hid_device *hid)
1967{
1968 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
1969 struct input_dev *dev = hidinput->input;
1970 struct hidpp_ff_private_data *data;
1971
1972 if (!dev) {
1973 hid_err(hid, "Struct input_dev not found!\n");
1974 return -EINVAL;
1975 }
1976
1977 hid_info(hid, "Unloading HID++ force feedback.\n");
1978 data = dev->ff->private;
1979 if (!data) {
1980 hid_err(hid, "Private data not found!\n");
1981 return -EINVAL;
1982 }
1983
1984 destroy_workqueue(data->wq);
1985 device_remove_file(&hid->dev, &dev_attr_range);
1986
1987 return 0;
1988}
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001#define WTP_MANUAL_RESOLUTION 39
2002
2003struct wtp_data {
2004 struct input_dev *input;
2005 u16 x_size, y_size;
2006 u8 finger_count;
2007 u8 mt_feature_index;
2008 u8 button_feature_index;
2009 u8 maxcontacts;
2010 bool flip_y;
2011 unsigned int resolution;
2012};
2013
2014static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2015 struct hid_field *field, struct hid_usage *usage,
2016 unsigned long **bit, int *max)
2017{
2018 return -1;
2019}
2020
2021static void wtp_populate_input(struct hidpp_device *hidpp,
2022 struct input_dev *input_dev, bool origin_is_hid_core)
2023{
2024 struct wtp_data *wd = hidpp->private_data;
2025
2026 __set_bit(EV_ABS, input_dev->evbit);
2027 __set_bit(EV_KEY, input_dev->evbit);
2028 __clear_bit(EV_REL, input_dev->evbit);
2029 __clear_bit(EV_LED, input_dev->evbit);
2030
2031 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0);
2032 input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution);
2033 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0);
2034 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution);
2035
2036
2037 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0);
2038
2039 input_set_capability(input_dev, EV_KEY, BTN_LEFT);
2040
2041 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
2042 input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
2043 else
2044 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
2045
2046 input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
2047 INPUT_MT_DROP_UNUSED);
2048
2049 wd->input = input_dev;
2050}
2051
2052static void wtp_touch_event(struct wtp_data *wd,
2053 struct hidpp_touchpad_raw_xy_finger *touch_report)
2054{
2055 int slot;
2056
2057 if (!touch_report->finger_id || touch_report->contact_type)
2058
2059 return;
2060
2061 slot = input_mt_get_slot_by_key(wd->input, touch_report->finger_id);
2062
2063 input_mt_slot(wd->input, slot);
2064 input_mt_report_slot_state(wd->input, MT_TOOL_FINGER,
2065 touch_report->contact_status);
2066 if (touch_report->contact_status) {
2067 input_event(wd->input, EV_ABS, ABS_MT_POSITION_X,
2068 touch_report->x);
2069 input_event(wd->input, EV_ABS, ABS_MT_POSITION_Y,
2070 wd->flip_y ? wd->y_size - touch_report->y :
2071 touch_report->y);
2072 input_event(wd->input, EV_ABS, ABS_MT_PRESSURE,
2073 touch_report->area);
2074 }
2075}
2076
2077static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
2078 struct hidpp_touchpad_raw_xy *raw)
2079{
2080 struct wtp_data *wd = hidpp->private_data;
2081 int i;
2082
2083 for (i = 0; i < 2; i++)
2084 wtp_touch_event(wd, &(raw->fingers[i]));
2085
2086 if (raw->end_of_frame &&
2087 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
2088 input_event(wd->input, EV_KEY, BTN_LEFT, raw->button);
2089
2090 if (raw->end_of_frame || raw->finger_count <= 2) {
2091 input_mt_sync_frame(wd->input);
2092 input_sync(wd->input);
2093 }
2094}
2095
2096static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
2097{
2098 struct wtp_data *wd = hidpp->private_data;
2099 u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) +
2100 (data[7] >> 4) * (data[7] >> 4)) / 2;
2101 u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) +
2102 (data[13] >> 4) * (data[13] >> 4)) / 2;
2103 struct hidpp_touchpad_raw_xy raw = {
2104 .timestamp = data[1],
2105 .fingers = {
2106 {
2107 .contact_type = 0,
2108 .contact_status = !!data[7],
2109 .x = get_unaligned_le16(&data[3]),
2110 .y = get_unaligned_le16(&data[5]),
2111 .z = c1_area,
2112 .area = c1_area,
2113 .finger_id = data[2],
2114 }, {
2115 .contact_type = 0,
2116 .contact_status = !!data[13],
2117 .x = get_unaligned_le16(&data[9]),
2118 .y = get_unaligned_le16(&data[11]),
2119 .z = c2_area,
2120 .area = c2_area,
2121 .finger_id = data[8],
2122 }
2123 },
2124 .finger_count = wd->maxcontacts,
2125 .spurious_flag = 0,
2126 .end_of_frame = (data[0] >> 7) == 0,
2127 .button = data[0] & 0x01,
2128 };
2129
2130 wtp_send_raw_xy_event(hidpp, &raw);
2131
2132 return 1;
2133}
2134
2135static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
2136{
2137 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2138 struct wtp_data *wd = hidpp->private_data;
2139 struct hidpp_report *report = (struct hidpp_report *)data;
2140 struct hidpp_touchpad_raw_xy raw;
2141
2142 if (!wd || !wd->input)
2143 return 1;
2144
2145 switch (data[0]) {
2146 case 0x02:
2147 if (size < 2) {
2148 hid_err(hdev, "Received HID report of bad size (%d)",
2149 size);
2150 return 1;
2151 }
2152 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
2153 input_event(wd->input, EV_KEY, BTN_LEFT,
2154 !!(data[1] & 0x01));
2155 input_event(wd->input, EV_KEY, BTN_RIGHT,
2156 !!(data[1] & 0x02));
2157 input_sync(wd->input);
2158 return 0;
2159 } else {
2160 if (size < 21)
2161 return 1;
2162 return wtp_mouse_raw_xy_event(hidpp, &data[7]);
2163 }
2164 case REPORT_ID_HIDPP_LONG:
2165
2166 if ((report->fap.feature_index != wd->mt_feature_index) ||
2167 (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))
2168 return 1;
2169 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
2170
2171 wtp_send_raw_xy_event(hidpp, &raw);
2172 return 0;
2173 }
2174
2175 return 0;
2176}
2177
2178static int wtp_get_config(struct hidpp_device *hidpp)
2179{
2180 struct wtp_data *wd = hidpp->private_data;
2181 struct hidpp_touchpad_raw_info raw_info = {0};
2182 u8 feature_type;
2183 int ret;
2184
2185 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
2186 &wd->mt_feature_index, &feature_type);
2187 if (ret)
2188
2189 return ret;
2190
2191 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
2192 &raw_info);
2193 if (ret)
2194 return ret;
2195
2196 wd->x_size = raw_info.x_size;
2197 wd->y_size = raw_info.y_size;
2198 wd->maxcontacts = raw_info.maxcontacts;
2199 wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT;
2200 wd->resolution = raw_info.res;
2201 if (!wd->resolution)
2202 wd->resolution = WTP_MANUAL_RESOLUTION;
2203
2204 return 0;
2205}
2206
2207static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id)
2208{
2209 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2210 struct wtp_data *wd;
2211
2212 wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data),
2213 GFP_KERNEL);
2214 if (!wd)
2215 return -ENOMEM;
2216
2217 hidpp->private_data = wd;
2218
2219 return 0;
2220};
2221
2222static int wtp_connect(struct hid_device *hdev, bool connected)
2223{
2224 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2225 struct wtp_data *wd = hidpp->private_data;
2226 int ret;
2227
2228 if (!wd->x_size) {
2229 ret = wtp_get_config(hidpp);
2230 if (ret) {
2231 hid_err(hdev, "Can not get wtp config: %d\n", ret);
2232 return ret;
2233 }
2234 }
2235
2236 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
2237 true, true);
2238}
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
2274
2275struct m560_private_data {
2276 struct input_dev *input;
2277};
2278
2279
2280#define M560_MOUSE_BTN_LEFT 0x01
2281#define M560_MOUSE_BTN_RIGHT 0x02
2282#define M560_MOUSE_BTN_WHEEL_LEFT 0x08
2283#define M560_MOUSE_BTN_WHEEL_RIGHT 0x10
2284
2285#define M560_SUB_ID 0x0a
2286#define M560_BUTTON_MODE_REGISTER 0x35
2287
2288static int m560_send_config_command(struct hid_device *hdev, bool connected)
2289{
2290 struct hidpp_report response;
2291 struct hidpp_device *hidpp_dev;
2292
2293 hidpp_dev = hid_get_drvdata(hdev);
2294
2295 return hidpp_send_rap_command_sync(
2296 hidpp_dev,
2297 REPORT_ID_HIDPP_SHORT,
2298 M560_SUB_ID,
2299 M560_BUTTON_MODE_REGISTER,
2300 (u8 *)m560_config_parameter,
2301 sizeof(m560_config_parameter),
2302 &response
2303 );
2304}
2305
2306static int m560_allocate(struct hid_device *hdev)
2307{
2308 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2309 struct m560_private_data *d;
2310
2311 d = devm_kzalloc(&hdev->dev, sizeof(struct m560_private_data),
2312 GFP_KERNEL);
2313 if (!d)
2314 return -ENOMEM;
2315
2316 hidpp->private_data = d;
2317
2318 return 0;
2319};
2320
2321static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
2322{
2323 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2324 struct m560_private_data *mydata = hidpp->private_data;
2325
2326
2327 if (!mydata || !mydata->input) {
2328 hid_err(hdev, "error in parameter\n");
2329 return -EINVAL;
2330 }
2331
2332 if (size < 7) {
2333 hid_err(hdev, "error in report\n");
2334 return 0;
2335 }
2336
2337 if (data[0] == REPORT_ID_HIDPP_LONG &&
2338 data[2] == M560_SUB_ID && data[6] == 0x00) {
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352 switch (data[5]) {
2353 case 0xaf:
2354 input_report_key(mydata->input, BTN_MIDDLE, 1);
2355 break;
2356 case 0xb0:
2357 input_report_key(mydata->input, BTN_FORWARD, 1);
2358 break;
2359 case 0xae:
2360 input_report_key(mydata->input, BTN_BACK, 1);
2361 break;
2362 case 0x00:
2363 input_report_key(mydata->input, BTN_BACK, 0);
2364 input_report_key(mydata->input, BTN_FORWARD, 0);
2365 input_report_key(mydata->input, BTN_MIDDLE, 0);
2366 break;
2367 default:
2368 hid_err(hdev, "error in report\n");
2369 return 0;
2370 }
2371 input_sync(mydata->input);
2372
2373 } else if (data[0] == 0x02) {
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383 int v;
2384
2385 input_report_key(mydata->input, BTN_LEFT,
2386 !!(data[1] & M560_MOUSE_BTN_LEFT));
2387 input_report_key(mydata->input, BTN_RIGHT,
2388 !!(data[1] & M560_MOUSE_BTN_RIGHT));
2389
2390 if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT)
2391 input_report_rel(mydata->input, REL_HWHEEL, -1);
2392 else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT)
2393 input_report_rel(mydata->input, REL_HWHEEL, 1);
2394
2395 v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
2396 input_report_rel(mydata->input, REL_X, v);
2397
2398 v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
2399 input_report_rel(mydata->input, REL_Y, v);
2400
2401 v = hid_snto32(data[6], 8);
2402 input_report_rel(mydata->input, REL_WHEEL, v);
2403
2404 input_sync(mydata->input);
2405 }
2406
2407 return 1;
2408}
2409
2410static void m560_populate_input(struct hidpp_device *hidpp,
2411 struct input_dev *input_dev, bool origin_is_hid_core)
2412{
2413 struct m560_private_data *mydata = hidpp->private_data;
2414
2415 mydata->input = input_dev;
2416
2417 __set_bit(EV_KEY, mydata->input->evbit);
2418 __set_bit(BTN_MIDDLE, mydata->input->keybit);
2419 __set_bit(BTN_RIGHT, mydata->input->keybit);
2420 __set_bit(BTN_LEFT, mydata->input->keybit);
2421 __set_bit(BTN_BACK, mydata->input->keybit);
2422 __set_bit(BTN_FORWARD, mydata->input->keybit);
2423
2424 __set_bit(EV_REL, mydata->input->evbit);
2425 __set_bit(REL_X, mydata->input->relbit);
2426 __set_bit(REL_Y, mydata->input->relbit);
2427 __set_bit(REL_WHEEL, mydata->input->relbit);
2428 __set_bit(REL_HWHEEL, mydata->input->relbit);
2429}
2430
2431static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2432 struct hid_field *field, struct hid_usage *usage,
2433 unsigned long **bit, int *max)
2434{
2435 return -1;
2436}
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452struct k400_private_data {
2453 u8 feature_index;
2454};
2455
2456static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
2457{
2458 struct k400_private_data *k400 = hidpp->private_data;
2459 struct hidpp_touchpad_fw_items items = {};
2460 int ret;
2461 u8 feature_type;
2462
2463 if (!k400->feature_index) {
2464 ret = hidpp_root_get_feature(hidpp,
2465 HIDPP_PAGE_TOUCHPAD_FW_ITEMS,
2466 &k400->feature_index, &feature_type);
2467 if (ret)
2468
2469 return ret;
2470 }
2471
2472 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
2473 if (ret)
2474 return ret;
2475
2476 return 0;
2477}
2478
2479static int k400_allocate(struct hid_device *hdev)
2480{
2481 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2482 struct k400_private_data *k400;
2483
2484 k400 = devm_kzalloc(&hdev->dev, sizeof(struct k400_private_data),
2485 GFP_KERNEL);
2486 if (!k400)
2487 return -ENOMEM;
2488
2489 hidpp->private_data = k400;
2490
2491 return 0;
2492};
2493
2494static int k400_connect(struct hid_device *hdev, bool connected)
2495{
2496 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2497
2498 if (!disable_tap_to_click)
2499 return 0;
2500
2501 return k400_disable_tap_to_click(hidpp);
2502}
2503
2504
2505
2506
2507
2508#define HIDPP_PAGE_G920_FORCE_FEEDBACK 0x8123
2509
2510static int g920_get_config(struct hidpp_device *hidpp)
2511{
2512 u8 feature_type;
2513 u8 feature_index;
2514 int ret;
2515
2516
2517 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
2518 &feature_index, &feature_type);
2519 if (ret)
2520 return ret;
2521
2522 ret = hidpp_ff_init(hidpp, feature_index);
2523 if (ret)
2524 hid_warn(hidpp->hid_dev, "Unable to initialize force feedback support, errno %d\n",
2525 ret);
2526
2527 return 0;
2528}
2529
2530
2531
2532
2533
2534static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2535 struct hid_field *field, struct hid_usage *usage,
2536 unsigned long **bit, int *max)
2537{
2538 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2539
2540 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
2541 return wtp_input_mapping(hdev, hi, field, usage, bit, max);
2542 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
2543 field->application != HID_GD_MOUSE)
2544 return m560_input_mapping(hdev, hi, field, usage, bit, max);
2545
2546 return 0;
2547}
2548
2549static int hidpp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
2550 struct hid_field *field, struct hid_usage *usage,
2551 unsigned long **bit, int *max)
2552{
2553 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2554
2555
2556 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
2557 if (usage->type == EV_ABS && (usage->code == ABS_X ||
2558 usage->code == ABS_Y || usage->code == ABS_Z ||
2559 usage->code == ABS_RZ)) {
2560 field->application = HID_GD_MULTIAXIS;
2561 }
2562 }
2563
2564 return 0;
2565}
2566
2567
2568static void hidpp_populate_input(struct hidpp_device *hidpp,
2569 struct input_dev *input, bool origin_is_hid_core)
2570{
2571 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
2572 wtp_populate_input(hidpp, input, origin_is_hid_core);
2573 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
2574 m560_populate_input(hidpp, input, origin_is_hid_core);
2575}
2576
2577static int hidpp_input_configured(struct hid_device *hdev,
2578 struct hid_input *hidinput)
2579{
2580 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2581 struct input_dev *input = hidinput->input;
2582
2583 hidpp_populate_input(hidpp, input, true);
2584
2585 return 0;
2586}
2587
2588static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
2589 int size)
2590{
2591 struct hidpp_report *question = hidpp->send_receive_buf;
2592 struct hidpp_report *answer = hidpp->send_receive_buf;
2593 struct hidpp_report *report = (struct hidpp_report *)data;
2594 int ret;
2595
2596
2597
2598
2599
2600 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
2601
2602
2603
2604
2605 if (hidpp_match_answer(question, report) ||
2606 hidpp_match_error(question, report)) {
2607 *answer = *report;
2608 hidpp->answer_available = true;
2609 wake_up(&hidpp->wait);
2610
2611
2612
2613
2614
2615
2616 return 1;
2617 }
2618 }
2619
2620 if (unlikely(hidpp_report_is_connect_event(report))) {
2621 atomic_set(&hidpp->connected,
2622 !(report->rap.params[0] & (1 << 6)));
2623 if (schedule_work(&hidpp->work) == 0)
2624 dbg_hid("%s: connect event already queued\n", __func__);
2625 return 1;
2626 }
2627
2628 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
2629 ret = hidpp20_battery_event(hidpp, data, size);
2630 if (ret != 0)
2631 return ret;
2632 ret = hidpp_solar_battery_event(hidpp, data, size);
2633 if (ret != 0)
2634 return ret;
2635 }
2636
2637 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
2638 ret = hidpp10_battery_event(hidpp, data, size);
2639 if (ret != 0)
2640 return ret;
2641 }
2642
2643 return 0;
2644}
2645
2646static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
2647 u8 *data, int size)
2648{
2649 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2650 int ret = 0;
2651
2652
2653 switch (data[0]) {
2654 case REPORT_ID_HIDPP_VERY_LONG:
2655 if (size != HIDPP_REPORT_VERY_LONG_LENGTH) {
2656 hid_err(hdev, "received hid++ report of bad size (%d)",
2657 size);
2658 return 1;
2659 }
2660 ret = hidpp_raw_hidpp_event(hidpp, data, size);
2661 break;
2662 case REPORT_ID_HIDPP_LONG:
2663 if (size != HIDPP_REPORT_LONG_LENGTH) {
2664 hid_err(hdev, "received hid++ report of bad size (%d)",
2665 size);
2666 return 1;
2667 }
2668 ret = hidpp_raw_hidpp_event(hidpp, data, size);
2669 break;
2670 case REPORT_ID_HIDPP_SHORT:
2671 if (size != HIDPP_REPORT_SHORT_LENGTH) {
2672 hid_err(hdev, "received hid++ report of bad size (%d)",
2673 size);
2674 return 1;
2675 }
2676 ret = hidpp_raw_hidpp_event(hidpp, data, size);
2677 break;
2678 }
2679
2680
2681
2682 if (ret != 0)
2683 return ret;
2684
2685 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
2686 return wtp_raw_event(hdev, data, size);
2687 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
2688 return m560_raw_event(hdev, data, size);
2689
2690 return 0;
2691}
2692
2693static int hidpp_initialize_battery(struct hidpp_device *hidpp)
2694{
2695 static atomic_t battery_no = ATOMIC_INIT(0);
2696 struct power_supply_config cfg = { .drv_data = hidpp };
2697 struct power_supply_desc *desc = &hidpp->battery.desc;
2698 enum power_supply_property *battery_props;
2699 struct hidpp_battery *battery;
2700 unsigned int num_battery_props;
2701 unsigned long n;
2702 int ret;
2703
2704 if (hidpp->battery.ps)
2705 return 0;
2706
2707 hidpp->battery.feature_index = 0xff;
2708 hidpp->battery.solar_feature_index = 0xff;
2709
2710 if (hidpp->protocol_major >= 2) {
2711 if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
2712 ret = hidpp_solar_request_battery_event(hidpp);
2713 else
2714 ret = hidpp20_query_battery_info(hidpp);
2715
2716 if (ret)
2717 return ret;
2718 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_BATTERY;
2719 } else {
2720 ret = hidpp10_query_battery_status(hidpp);
2721 if (ret) {
2722 ret = hidpp10_query_battery_mileage(hidpp);
2723 if (ret)
2724 return -ENOENT;
2725 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
2726 } else {
2727 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
2728 }
2729 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_BATTERY;
2730 }
2731
2732 battery_props = devm_kmemdup(&hidpp->hid_dev->dev,
2733 hidpp_battery_props,
2734 sizeof(hidpp_battery_props),
2735 GFP_KERNEL);
2736 if (!battery_props)
2737 return -ENOMEM;
2738
2739 num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 2;
2740
2741 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
2742 battery_props[num_battery_props++] =
2743 POWER_SUPPLY_PROP_CAPACITY;
2744
2745 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
2746 battery_props[num_battery_props++] =
2747 POWER_SUPPLY_PROP_CAPACITY_LEVEL;
2748
2749 battery = &hidpp->battery;
2750
2751 n = atomic_inc_return(&battery_no) - 1;
2752 desc->properties = battery_props;
2753 desc->num_properties = num_battery_props;
2754 desc->get_property = hidpp_battery_get_property;
2755 sprintf(battery->name, "hidpp_battery_%ld", n);
2756 desc->name = battery->name;
2757 desc->type = POWER_SUPPLY_TYPE_BATTERY;
2758 desc->use_for_apm = 0;
2759
2760 battery->ps = devm_power_supply_register(&hidpp->hid_dev->dev,
2761 &battery->desc,
2762 &cfg);
2763 if (IS_ERR(battery->ps))
2764 return PTR_ERR(battery->ps);
2765
2766 power_supply_powers(battery->ps, &hidpp->hid_dev->dev);
2767
2768 return ret;
2769}
2770
2771static void hidpp_overwrite_name(struct hid_device *hdev)
2772{
2773 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2774 char *name;
2775
2776 if (hidpp->protocol_major < 2)
2777 return;
2778
2779 name = hidpp_get_device_name(hidpp);
2780
2781 if (!name) {
2782 hid_err(hdev, "unable to retrieve the name of the device");
2783 } else {
2784 dbg_hid("HID++: Got name: %s\n", name);
2785 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
2786 }
2787
2788 kfree(name);
2789}
2790
2791static int hidpp_input_open(struct input_dev *dev)
2792{
2793 struct hid_device *hid = input_get_drvdata(dev);
2794
2795 return hid_hw_open(hid);
2796}
2797
2798static void hidpp_input_close(struct input_dev *dev)
2799{
2800 struct hid_device *hid = input_get_drvdata(dev);
2801
2802 hid_hw_close(hid);
2803}
2804
2805static struct input_dev *hidpp_allocate_input(struct hid_device *hdev)
2806{
2807 struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev);
2808 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2809
2810 if (!input_dev)
2811 return NULL;
2812
2813 input_set_drvdata(input_dev, hdev);
2814 input_dev->open = hidpp_input_open;
2815 input_dev->close = hidpp_input_close;
2816
2817 input_dev->name = hidpp->name;
2818 input_dev->phys = hdev->phys;
2819 input_dev->uniq = hdev->uniq;
2820 input_dev->id.bustype = hdev->bus;
2821 input_dev->id.vendor = hdev->vendor;
2822 input_dev->id.product = hdev->product;
2823 input_dev->id.version = hdev->version;
2824 input_dev->dev.parent = &hdev->dev;
2825
2826 return input_dev;
2827}
2828
2829static void hidpp_connect_event(struct hidpp_device *hidpp)
2830{
2831 struct hid_device *hdev = hidpp->hid_dev;
2832 int ret = 0;
2833 bool connected = atomic_read(&hidpp->connected);
2834 struct input_dev *input;
2835 char *name, *devm_name;
2836
2837 if (!connected) {
2838 if (hidpp->battery.ps) {
2839 hidpp->battery.online = false;
2840 hidpp->battery.status = POWER_SUPPLY_STATUS_UNKNOWN;
2841 hidpp->battery.level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
2842 power_supply_changed(hidpp->battery.ps);
2843 }
2844 return;
2845 }
2846
2847 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
2848 ret = wtp_connect(hdev, connected);
2849 if (ret)
2850 return;
2851 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
2852 ret = m560_send_config_command(hdev, connected);
2853 if (ret)
2854 return;
2855 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
2856 ret = k400_connect(hdev, connected);
2857 if (ret)
2858 return;
2859 }
2860
2861
2862
2863 if (!hidpp->protocol_major) {
2864 ret = !hidpp_is_connected(hidpp);
2865 if (ret) {
2866 hid_err(hdev, "Can not get the protocol version.\n");
2867 return;
2868 }
2869 hid_info(hdev, "HID++ %u.%u device connected.\n",
2870 hidpp->protocol_major, hidpp->protocol_minor);
2871 }
2872
2873 if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
2874 name = hidpp_get_device_name(hidpp);
2875 if (!name) {
2876 hid_err(hdev,
2877 "unable to retrieve the name of the device");
2878 return;
2879 }
2880
2881 devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s", name);
2882 kfree(name);
2883 if (!devm_name)
2884 return;
2885
2886 hidpp->name = devm_name;
2887 }
2888
2889 hidpp_initialize_battery(hidpp);
2890
2891
2892 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
2893 hidpp10_enable_battery_reporting(hidpp);
2894 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
2895 hidpp10_query_battery_mileage(hidpp);
2896 else
2897 hidpp10_query_battery_status(hidpp);
2898 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
2899 hidpp20_query_battery_info(hidpp);
2900 }
2901 if (hidpp->battery.ps)
2902 power_supply_changed(hidpp->battery.ps);
2903
2904 if (!(hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT) || hidpp->delayed_input)
2905
2906 return;
2907
2908 input = hidpp_allocate_input(hdev);
2909 if (!input) {
2910 hid_err(hdev, "cannot allocate new input device: %d\n", ret);
2911 return;
2912 }
2913
2914 hidpp_populate_input(hidpp, input, false);
2915
2916 ret = input_register_device(input);
2917 if (ret)
2918 input_free_device(input);
2919
2920 hidpp->delayed_input = input;
2921}
2922
2923static DEVICE_ATTR(builtin_power_supply, 0000, NULL, NULL);
2924
2925static struct attribute *sysfs_attrs[] = {
2926 &dev_attr_builtin_power_supply.attr,
2927 NULL
2928};
2929
2930static const struct attribute_group ps_attribute_group = {
2931 .attrs = sysfs_attrs
2932};
2933
2934static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
2935{
2936 struct hidpp_device *hidpp;
2937 int ret;
2938 bool connected;
2939 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2940
2941 hidpp = devm_kzalloc(&hdev->dev, sizeof(struct hidpp_device),
2942 GFP_KERNEL);
2943 if (!hidpp)
2944 return -ENOMEM;
2945
2946 hidpp->hid_dev = hdev;
2947 hidpp->name = hdev->name;
2948 hid_set_drvdata(hdev, hidpp);
2949
2950 hidpp->quirks = id->driver_data;
2951
2952 if (id->group == HID_GROUP_LOGITECH_DJ_DEVICE)
2953 hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
2954
2955 if (disable_raw_mode) {
2956 hidpp->quirks &= ~HIDPP_QUIRK_CLASS_WTP;
2957 hidpp->quirks &= ~HIDPP_QUIRK_NO_HIDINPUT;
2958 }
2959
2960 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
2961 ret = wtp_allocate(hdev, id);
2962 if (ret)
2963 goto allocate_fail;
2964 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
2965 ret = m560_allocate(hdev);
2966 if (ret)
2967 goto allocate_fail;
2968 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
2969 ret = k400_allocate(hdev);
2970 if (ret)
2971 goto allocate_fail;
2972 }
2973
2974 INIT_WORK(&hidpp->work, delayed_work_cb);
2975 mutex_init(&hidpp->send_mutex);
2976 init_waitqueue_head(&hidpp->wait);
2977
2978
2979 ret = sysfs_create_group(&hdev->dev.kobj, &ps_attribute_group);
2980 if (ret)
2981 hid_warn(hdev, "Cannot allocate sysfs group for %s\n",
2982 hdev->name);
2983
2984 ret = hid_parse(hdev);
2985 if (ret) {
2986 hid_err(hdev, "%s:parse failed\n", __func__);
2987 goto hid_parse_fail;
2988 }
2989
2990 if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
2991 connect_mask &= ~HID_CONNECT_HIDINPUT;
2992
2993 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
2994 ret = hid_hw_start(hdev, connect_mask);
2995 if (ret) {
2996 hid_err(hdev, "hw start failed\n");
2997 goto hid_hw_start_fail;
2998 }
2999 ret = hid_hw_open(hdev);
3000 if (ret < 0) {
3001 dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
3002 __func__, ret);
3003 hid_hw_stop(hdev);
3004 goto hid_hw_start_fail;
3005 }
3006 }
3007
3008
3009
3010 hid_device_io_start(hdev);
3011
3012 if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
3013 hidpp_unifying_init(hidpp);
3014
3015 connected = hidpp_is_connected(hidpp);
3016 atomic_set(&hidpp->connected, connected);
3017 if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
3018 if (!connected) {
3019 ret = -ENODEV;
3020 hid_err(hdev, "Device not connected");
3021 goto hid_hw_open_failed;
3022 }
3023
3024 hid_info(hdev, "HID++ %u.%u device connected.\n",
3025 hidpp->protocol_major, hidpp->protocol_minor);
3026
3027 hidpp_overwrite_name(hdev);
3028 }
3029
3030 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
3031 ret = wtp_get_config(hidpp);
3032 if (ret)
3033 goto hid_hw_open_failed;
3034 } else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
3035 ret = g920_get_config(hidpp);
3036 if (ret)
3037 goto hid_hw_open_failed;
3038 }
3039
3040
3041 hid_device_io_stop(hdev);
3042
3043 if (!(hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
3044 ret = hid_hw_start(hdev, connect_mask);
3045 if (ret) {
3046 hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
3047 goto hid_hw_start_fail;
3048 }
3049 }
3050
3051
3052 hid_device_io_start(hdev);
3053
3054 hidpp_connect_event(hidpp);
3055
3056 return ret;
3057
3058hid_hw_open_failed:
3059 hid_device_io_stop(hdev);
3060 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3061 hid_hw_close(hdev);
3062 hid_hw_stop(hdev);
3063 }
3064hid_hw_start_fail:
3065hid_parse_fail:
3066 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
3067 cancel_work_sync(&hidpp->work);
3068 mutex_destroy(&hidpp->send_mutex);
3069allocate_fail:
3070 hid_set_drvdata(hdev, NULL);
3071 return ret;
3072}
3073
3074static void hidpp_remove(struct hid_device *hdev)
3075{
3076 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3077
3078 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
3079
3080 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3081 hidpp_ff_deinit(hdev);
3082 hid_hw_close(hdev);
3083 }
3084 hid_hw_stop(hdev);
3085 cancel_work_sync(&hidpp->work);
3086 mutex_destroy(&hidpp->send_mutex);
3087}
3088
3089static const struct hid_device_id hidpp_devices[] = {
3090 {
3091 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3092 USB_VENDOR_ID_LOGITECH, 0x4011),
3093 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT |
3094 HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
3095 {
3096 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3097 USB_VENDOR_ID_LOGITECH, 0x4101),
3098 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
3099 {
3100 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
3101 USB_DEVICE_ID_LOGITECH_T651),
3102 .driver_data = HIDPP_QUIRK_CLASS_WTP },
3103 {
3104 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3105 USB_VENDOR_ID_LOGITECH, 0x402d),
3106 .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_CLASS_M560 },
3107 {
3108 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3109 USB_VENDOR_ID_LOGITECH, 0x4024),
3110 .driver_data = HIDPP_QUIRK_CLASS_K400 },
3111 {
3112 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3113 USB_VENDOR_ID_LOGITECH, 0x4002),
3114 .driver_data = HIDPP_QUIRK_CLASS_K750 },
3115
3116 { HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3117 USB_VENDOR_ID_LOGITECH, HID_ANY_ID)},
3118
3119 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
3120 .driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS},
3121 {}
3122};
3123
3124MODULE_DEVICE_TABLE(hid, hidpp_devices);
3125
3126static struct hid_driver hidpp_driver = {
3127 .name = "logitech-hidpp-device",
3128 .id_table = hidpp_devices,
3129 .probe = hidpp_probe,
3130 .remove = hidpp_remove,
3131 .raw_event = hidpp_raw_event,
3132 .input_configured = hidpp_input_configured,
3133 .input_mapping = hidpp_input_mapping,
3134 .input_mapped = hidpp_input_mapped,
3135};
3136
3137module_hid_driver(hidpp_driver);
3138