Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid
Pull HID updates from Jiri Kosina:
- open/close tracking improvements from Dmitry Torokhov
- battery support improvements in Wacom driver from Jason Gerecke
- Win8 support fixes from Benjamin Tissories and Hans de Geode
- misc fixes to Intel-ISH driver from Arnd Bergmann
- support for quite a few new devices and small assorted fixes here and
there
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid: (35 commits)
HID: intel-ish-hid: Enable Gemini Lake ish driver
HID: intel-ish-hid: Enable Cannon Lake ish driver
HID: wacom: fix mistake in printk
HID: multitouch: optimize the sticky fingers timer
HID: multitouch: fix rare Win 8 cases when the touch up event gets missing
HID: multitouch: use BIT macro
HID: Add driver for Retrode2 joypad adapter
HID: multitouch: Add support for Google Rose Touchpad
HID: multitouch: Support PTP Stick and Touchpad device
HID: core: don't use negative operands when shift
HID: apple: Use country code to detect ISO keyboards
HID: remove no longer used hid->open field
greybus: hid: remove custom locking from gb_hid_open/close
HID: usbhid: remove custom locking from usbhid_open/close
HID: i2c-hid: remove custom locking from i2c_hid_open/close
HID: serialize hid_hw_open and hid_hw_close
HID: usbhid: do not rely on hid->open when deciding to do IO
HID: hiddev: use hid_hw_power instead of usbhid_get/put_power
HID: hiddev: use hid_hw_open/close instead of usbhid_open/close
HID: asus: Add support for Zen AiO MD-5110 keyboard
...
+797
-426
+15
drivers/hid/Kconfig
+15
drivers/hid/Kconfig
···
388
388
To compile this driver as a module, choose M here: the
389
389
module will be called hid-icade.
390
390
391
+
config HID_ITE
392
+
tristate "ITE devices"
393
+
depends on HID
394
+
default !EXPERT
395
+
---help---
396
+
Support for ITE devices not fully compliant with HID standard.
397
+
391
398
config HID_TWINHAN
392
399
tristate "Twinhan IR remote control"
393
400
depends on HID
···
747
740
---help---
748
741
Support for Primax devices that are not fully compliant with the
749
742
HID standard.
743
+
744
+
config HID_RETRODE
745
+
tristate "Retrode"
746
+
depends on USB_HID
747
+
---help---
748
+
Support for
749
+
750
+
* Retrode 2 cartridge and controller adapter
750
751
751
752
config HID_ROCCAT
752
753
tristate "Roccat device support"
+2
drivers/hid/Makefile
+2
drivers/hid/Makefile
···
50
50
obj-$(CONFIG_HID_HOLTEK) += hid-holtekff.o
51
51
obj-$(CONFIG_HID_HYPERV_MOUSE) += hid-hyperv.o
52
52
obj-$(CONFIG_HID_ICADE) += hid-icade.o
53
+
obj-$(CONFIG_HID_ITE) += hid-ite.o
53
54
obj-$(CONFIG_HID_KENSINGTON) += hid-kensington.o
54
55
obj-$(CONFIG_HID_KEYTOUCH) += hid-keytouch.o
55
56
obj-$(CONFIG_HID_KYE) += hid-kye.o
···
82
81
83
82
obj-$(CONFIG_HID_PLANTRONICS) += hid-plantronics.o
84
83
obj-$(CONFIG_HID_PRIMAX) += hid-primax.o
84
+
obj-$(CONFIG_HID_RETRODE) += hid-retrode.o
85
85
obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o hid-roccat-common.o \
86
86
hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \
87
87
hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \
+27
-32
drivers/hid/hid-apple.c
+27
-32
drivers/hid/hid-apple.c
···
28
28
#define APPLE_IGNORE_MOUSE 0x0002
29
29
#define APPLE_HAS_FN 0x0004
30
30
#define APPLE_HIDDEV 0x0008
31
-
#define APPLE_ISO_KEYBOARD 0x0010
31
+
/* 0x0010 reserved, was: APPLE_ISO_KEYBOARD */
32
32
#define APPLE_MIGHTYMOUSE 0x0020
33
33
#define APPLE_INVERT_HWHEEL 0x0040
34
34
#define APPLE_IGNORE_HIDINPUT 0x0080
35
35
#define APPLE_NUMLOCK_EMULATION 0x0100
36
36
37
37
#define APPLE_FLAG_FKEY 0x01
38
+
39
+
#define HID_COUNTRY_INTERNATIONAL_ISO 13
38
40
39
41
static unsigned int fnmode = 1;
40
42
module_param(fnmode, uint, 0644);
···
249
247
}
250
248
251
249
if (iso_layout) {
252
-
if (asc->quirks & APPLE_ISO_KEYBOARD) {
250
+
if (hid->country == HID_COUNTRY_INTERNATIONAL_ISO) {
253
251
trans = apple_find_translation(apple_iso_keyboard, usage->code);
254
252
if (trans) {
255
253
input_event(input, usage->type, trans->to, value);
···
414
412
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
415
413
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
416
414
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
417
-
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
418
-
APPLE_ISO_KEYBOARD },
415
+
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
419
416
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
420
417
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
421
418
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
422
419
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
423
420
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
424
-
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
425
-
APPLE_ISO_KEYBOARD },
421
+
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
426
422
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
427
423
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
428
424
APPLE_RDESC_JIS },
429
425
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
430
426
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
431
427
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
432
-
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
433
-
APPLE_ISO_KEYBOARD },
428
+
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
434
429
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
435
430
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
436
431
APPLE_RDESC_JIS },
437
432
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI),
438
433
.driver_data = APPLE_HAS_FN },
439
434
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO),
440
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
435
+
.driver_data = APPLE_HAS_FN },
441
436
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS),
442
437
.driver_data = APPLE_HAS_FN },
443
438
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
444
439
.driver_data = APPLE_HAS_FN },
445
440
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
446
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
441
+
.driver_data = APPLE_HAS_FN },
447
442
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
448
443
.driver_data = APPLE_HAS_FN },
449
444
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
450
445
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
451
446
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
452
-
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
453
-
APPLE_ISO_KEYBOARD },
447
+
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
454
448
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
455
449
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
456
450
APPLE_RDESC_JIS },
457
451
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
458
452
.driver_data = APPLE_HAS_FN },
459
453
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
460
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
454
+
.driver_data = APPLE_HAS_FN },
461
455
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS),
462
456
.driver_data = APPLE_HAS_FN },
463
457
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
464
458
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
465
459
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
466
-
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
467
-
APPLE_ISO_KEYBOARD },
460
+
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
468
461
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO),
469
-
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
470
-
APPLE_ISO_KEYBOARD },
462
+
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
471
463
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
472
464
USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
473
465
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
···
475
479
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
476
480
.driver_data = APPLE_HAS_FN },
477
481
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
478
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
482
+
.driver_data = APPLE_HAS_FN },
479
483
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
480
484
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
481
485
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
482
486
.driver_data = APPLE_HAS_FN },
483
487
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
484
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
488
+
.driver_data = APPLE_HAS_FN },
485
489
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
486
490
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
487
491
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI),
488
492
.driver_data = APPLE_HAS_FN },
489
493
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO),
490
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
494
+
.driver_data = APPLE_HAS_FN },
491
495
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS),
492
496
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
493
497
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI),
494
498
.driver_data = APPLE_HAS_FN },
495
499
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO),
496
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
500
+
.driver_data = APPLE_HAS_FN },
497
501
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS),
498
502
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
499
503
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI),
500
504
.driver_data = APPLE_HAS_FN },
501
505
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO),
502
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
506
+
.driver_data = APPLE_HAS_FN },
503
507
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS),
504
508
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
505
509
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI),
506
510
.driver_data = APPLE_HAS_FN },
507
511
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO),
508
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
512
+
.driver_data = APPLE_HAS_FN },
509
513
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS),
510
514
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
511
515
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI),
512
516
.driver_data = APPLE_HAS_FN },
513
517
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO),
514
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
518
+
.driver_data = APPLE_HAS_FN },
515
519
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS),
516
520
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
517
521
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI),
518
522
.driver_data = APPLE_HAS_FN },
519
523
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO),
520
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
524
+
.driver_data = APPLE_HAS_FN },
521
525
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS),
522
526
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
523
527
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI),
524
528
.driver_data = APPLE_HAS_FN },
525
529
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO),
526
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
530
+
.driver_data = APPLE_HAS_FN },
527
531
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
528
532
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
529
533
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI),
530
534
.driver_data = APPLE_HAS_FN },
531
535
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO),
532
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
536
+
.driver_data = APPLE_HAS_FN },
533
537
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS),
534
538
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
535
539
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI),
536
540
.driver_data = APPLE_HAS_FN },
537
541
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO),
538
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
542
+
.driver_data = APPLE_HAS_FN },
539
543
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS),
540
544
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
541
545
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI),
542
546
.driver_data = APPLE_HAS_FN },
543
547
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO),
544
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
548
+
.driver_data = APPLE_HAS_FN },
545
549
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS),
546
550
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
547
551
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI),
548
552
.driver_data = APPLE_HAS_FN },
549
553
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ISO),
550
-
.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
554
+
.driver_data = APPLE_HAS_FN },
551
555
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_JIS),
552
556
.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
553
557
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
554
558
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
555
559
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
556
-
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
557
-
APPLE_ISO_KEYBOARD },
560
+
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
558
561
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS),
559
562
.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
560
563
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
+30
drivers/hid/hid-asus.c
+30
drivers/hid/hid-asus.c
···
422
422
return 1;
423
423
}
424
424
425
+
if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
426
+
set_bit(EV_REP, hi->input->evbit);
427
+
switch (usage->hid & HID_USAGE) {
428
+
case 0xff01: asus_map_key_clear(BTN_1); break;
429
+
case 0xff02: asus_map_key_clear(BTN_2); break;
430
+
case 0xff03: asus_map_key_clear(BTN_3); break;
431
+
case 0xff04: asus_map_key_clear(BTN_4); break;
432
+
case 0xff05: asus_map_key_clear(BTN_5); break;
433
+
case 0xff06: asus_map_key_clear(BTN_6); break;
434
+
case 0xff07: asus_map_key_clear(BTN_7); break;
435
+
case 0xff08: asus_map_key_clear(BTN_8); break;
436
+
case 0xff09: asus_map_key_clear(BTN_9); break;
437
+
case 0xff0a: asus_map_key_clear(BTN_A); break;
438
+
case 0xff0b: asus_map_key_clear(BTN_B); break;
439
+
case 0x00f1: asus_map_key_clear(KEY_WLAN); break;
440
+
case 0x00f2: asus_map_key_clear(KEY_BRIGHTNESSDOWN); break;
441
+
case 0x00f3: asus_map_key_clear(KEY_BRIGHTNESSUP); break;
442
+
case 0x00f4: asus_map_key_clear(KEY_DISPLAY_OFF); break;
443
+
case 0x00f7: asus_map_key_clear(KEY_CAMERA); break;
444
+
case 0x00f8: asus_map_key_clear(KEY_PROG1); break;
445
+
default:
446
+
return 0;
447
+
}
448
+
449
+
return 1;
450
+
}
451
+
425
452
if (drvdata->quirks & QUIRK_NO_CONSUMER_USAGES &&
426
453
(usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
427
454
switch (usage->hid & HID_USAGE) {
···
599
572
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK,
600
573
USB_DEVICE_ID_ASUSTEK_T100_KEYBOARD),
601
574
QUIRK_T100_KEYBOARD | QUIRK_NO_CONSUMER_USAGES },
575
+
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_ASUS_AK1D) },
576
+
{ HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_ASUS_MD_5110) },
577
+
{ HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_ASUS_MD_5112) },
602
578
{ }
603
579
};
604
580
MODULE_DEVICE_TABLE(hid, asus_devices);
-2
drivers/hid/hid-chicony.c
-2
drivers/hid/hid-chicony.c
···
84
84
static const struct hid_device_id ch_devices[] = {
85
85
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
86
86
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
87
-
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) },
88
87
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_ACER_SWITCH12) },
89
-
{ HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_JESS_ZEN_AIO_KBD) },
90
88
{ }
91
89
};
92
90
MODULE_DEVICE_TABLE(hid, ch_devices);
+99
-3
drivers/hid/hid-core.c
+99
-3
drivers/hid/hid-core.c
···
1070
1070
case 16: return ((__s16)value);
1071
1071
case 32: return ((__s32)value);
1072
1072
}
1073
-
return value & (1 << (n - 1)) ? value | (-1 << n) : value;
1073
+
return value & (1 << (n - 1)) ? value | (~0U << n) : value;
1074
1074
}
1075
1075
1076
1076
s32 hid_snto32(__u32 value, unsigned n)
···
1774
1774
}
1775
1775
EXPORT_SYMBOL_GPL(hid_disconnect);
1776
1776
1777
+
/**
1778
+
* hid_hw_start - start underlying HW
1779
+
* @hdev: hid device
1780
+
* @connect_mask: which outputs to connect, see HID_CONNECT_*
1781
+
*
1782
+
* Call this in probe function *after* hid_parse. This will setup HW
1783
+
* buffers and start the device (if not defeirred to device open).
1784
+
* hid_hw_stop must be called if this was successful.
1785
+
*/
1786
+
int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask)
1787
+
{
1788
+
int error;
1789
+
1790
+
error = hdev->ll_driver->start(hdev);
1791
+
if (error)
1792
+
return error;
1793
+
1794
+
if (connect_mask) {
1795
+
error = hid_connect(hdev, connect_mask);
1796
+
if (error) {
1797
+
hdev->ll_driver->stop(hdev);
1798
+
return error;
1799
+
}
1800
+
}
1801
+
1802
+
return 0;
1803
+
}
1804
+
EXPORT_SYMBOL_GPL(hid_hw_start);
1805
+
1806
+
/**
1807
+
* hid_hw_stop - stop underlying HW
1808
+
* @hdev: hid device
1809
+
*
1810
+
* This is usually called from remove function or from probe when something
1811
+
* failed and hid_hw_start was called already.
1812
+
*/
1813
+
void hid_hw_stop(struct hid_device *hdev)
1814
+
{
1815
+
hid_disconnect(hdev);
1816
+
hdev->ll_driver->stop(hdev);
1817
+
}
1818
+
EXPORT_SYMBOL_GPL(hid_hw_stop);
1819
+
1820
+
/**
1821
+
* hid_hw_open - signal underlying HW to start delivering events
1822
+
* @hdev: hid device
1823
+
*
1824
+
* Tell underlying HW to start delivering events from the device.
1825
+
* This function should be called sometime after successful call
1826
+
* to hid_hiw_start().
1827
+
*/
1828
+
int hid_hw_open(struct hid_device *hdev)
1829
+
{
1830
+
int ret;
1831
+
1832
+
ret = mutex_lock_killable(&hdev->ll_open_lock);
1833
+
if (ret)
1834
+
return ret;
1835
+
1836
+
if (!hdev->ll_open_count++) {
1837
+
ret = hdev->ll_driver->open(hdev);
1838
+
if (ret)
1839
+
hdev->ll_open_count--;
1840
+
}
1841
+
1842
+
mutex_unlock(&hdev->ll_open_lock);
1843
+
return ret;
1844
+
}
1845
+
EXPORT_SYMBOL_GPL(hid_hw_open);
1846
+
1847
+
/**
1848
+
* hid_hw_close - signal underlaying HW to stop delivering events
1849
+
*
1850
+
* @hdev: hid device
1851
+
*
1852
+
* This function indicates that we are not interested in the events
1853
+
* from this device anymore. Delivery of events may or may not stop,
1854
+
* depending on the number of users still outstanding.
1855
+
*/
1856
+
void hid_hw_close(struct hid_device *hdev)
1857
+
{
1858
+
mutex_lock(&hdev->ll_open_lock);
1859
+
if (!--hdev->ll_open_count)
1860
+
hdev->ll_driver->close(hdev);
1861
+
mutex_unlock(&hdev->ll_open_lock);
1862
+
}
1863
+
EXPORT_SYMBOL_GPL(hid_hw_close);
1864
+
1777
1865
/*
1778
1866
* A list of devices for which there is a specialized driver on HID bus.
1779
1867
*
···
1980
1892
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD1) },
1981
1893
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD2) },
1982
1894
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T100_KEYBOARD) },
1895
+
{ HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_ASUS_MD_5112) },
1896
+
{ HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_ASUS_MD_5110) },
1983
1897
#endif
1984
1898
#if IS_ENABLED(CONFIG_HID_AUREAL)
1985
1899
{ HID_USB_DEVICE(USB_VENDOR_ID_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },
···
2003
1913
#if IS_ENABLED(CONFIG_HID_CHICONY)
2004
1914
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
2005
1915
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
2006
-
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) },
1916
+
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_ASUS_AK1D) },
2007
1917
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_ACER_SWITCH12) },
2008
-
{ HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_JESS_ZEN_AIO_KBD) },
2009
1918
#endif
2010
1919
#if IS_ENABLED(CONFIG_HID_CMEDIA)
2011
1920
{ HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM6533) },
···
2072
1983
#endif
2073
1984
#if IS_ENABLED(CONFIG_HID_ICADE)
2074
1985
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
1986
+
#endif
1987
+
#if IS_ENABLED(CONFIG_HID_ITE)
1988
+
{ HID_USB_DEVICE(USB_VENDOR_ID_ITE, USB_DEVICE_ID_ITE8595) },
2075
1989
#endif
2076
1990
#if IS_ENABLED(CONFIG_HID_KENSINGTON)
2077
1991
{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
···
2242
2150
#endif
2243
2151
#if IS_ENABLED(CONFIG_HID_PRODIKEYS)
2244
2152
{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
2153
+
#endif
2154
+
#if IS_ENABLED(CONFIG_HID_RETRODE)
2155
+
{ HID_USB_DEVICE(USB_VENDOR_ID_FUTURE_TECHNOLOGY, USB_DEVICE_ID_RETRODE2) },
2245
2156
#endif
2246
2157
#if IS_ENABLED(CONFIG_HID_RMI)
2247
2158
{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
···
3009
2914
spin_lock_init(&hdev->debug_list_lock);
3010
2915
sema_init(&hdev->driver_lock, 1);
3011
2916
sema_init(&hdev->driver_input_lock, 1);
2917
+
mutex_init(&hdev->ll_open_lock);
3012
2918
3013
2919
return hdev;
3014
2920
}
+12
-2
drivers/hid/hid-ids.h
+12
-2
drivers/hid/hid-ids.h
···
75
75
76
76
#define USB_VENDOR_ID_ALPS_JP 0x044E
77
77
#define HID_DEVICE_ID_ALPS_U1_DUAL 0x120B
78
+
#define HID_DEVICE_ID_ALPS_U1_DUAL_PTP 0x121F
79
+
#define HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP 0x1220
78
80
79
81
#define USB_VENDOR_ID_AMI 0x046b
80
82
#define USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE 0xff10
···
254
252
#define USB_DEVICE_ID_CHICONY_WIRELESS 0x0618
255
253
#define USB_DEVICE_ID_CHICONY_PIXART_USB_OPTICAL_MOUSE 0x1053
256
254
#define USB_DEVICE_ID_CHICONY_WIRELESS2 0x1123
257
-
#define USB_DEVICE_ID_CHICONY_AK1D 0x1125
255
+
#define USB_DEVICE_ID_ASUS_AK1D 0x1125
258
256
#define USB_DEVICE_ID_CHICONY_ACER_SWITCH12 0x1421
259
257
260
258
#define USB_VENDOR_ID_CHUNGHWAT 0x2247
···
388
386
#define USB_VENDOR_ID_FUTABA 0x0547
389
387
#define USB_DEVICE_ID_LED_DISPLAY 0x7000
390
388
389
+
#define USB_VENDOR_ID_FUTURE_TECHNOLOGY 0x0403
390
+
#define USB_DEVICE_ID_RETRODE2 0x97c1
391
+
391
392
#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
392
393
#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
393
394
···
432
427
433
428
#define USB_VENDOR_ID_GOODTOUCH 0x1aad
434
429
#define USB_DEVICE_ID_GOODTOUCH_000f 0x000f
430
+
431
+
#define USB_VENDOR_ID_GOOGLE 0x18d1
432
+
#define USB_DEVICE_ID_GOOGLE_TOUCH_ROSE 0x5028
435
433
436
434
#define USB_VENDOR_ID_GOTOP 0x08f2
437
435
#define USB_DEVICE_ID_SUPER_Q2 0x007f
···
573
565
#define USB_DEVICE_ID_ITE_LENOVO_YOGA 0x8386
574
566
#define USB_DEVICE_ID_ITE_LENOVO_YOGA2 0x8350
575
567
#define USB_DEVICE_ID_ITE_LENOVO_YOGA900 0x8396
568
+
#define USB_DEVICE_ID_ITE8595 0x8595
576
569
577
570
#define USB_VENDOR_ID_JABRA 0x0b0e
578
571
#define USB_DEVICE_ID_JABRA_SPEAK_410 0x0412
···
582
573
583
574
#define USB_VENDOR_ID_JESS 0x0c45
584
575
#define USB_DEVICE_ID_JESS_YUREX 0x1010
585
-
#define USB_DEVICE_ID_JESS_ZEN_AIO_KBD 0x5112
576
+
#define USB_DEVICE_ID_ASUS_MD_5112 0x5112
586
577
587
578
#define USB_VENDOR_ID_JESS2 0x0f30
588
579
#define USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD 0x0111
···
1033
1024
1034
1025
#define USB_VENDOR_ID_TURBOX 0x062a
1035
1026
#define USB_DEVICE_ID_TURBOX_KEYBOARD 0x0201
1027
+
#define USB_DEVICE_ID_ASUS_MD_5110 0x5110
1036
1028
#define USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART 0x7100
1037
1029
1038
1030
#define USB_VENDOR_ID_TWINHAN 0x6253
+9
drivers/hid/hid-input.c
+9
drivers/hid/hid-input.c
···
656
656
case HID_GD_START: map_key_clear(BTN_START); break;
657
657
case HID_GD_SELECT: map_key_clear(BTN_SELECT); break;
658
658
659
+
case HID_GD_RFKILL_BTN:
660
+
/* MS wireless radio ctl extension, also check CA */
661
+
if (field->application == HID_GD_WIRELESS_RADIO_CTLS) {
662
+
map_key_clear(KEY_RFKILL);
663
+
/* We need to simulate the btn release */
664
+
field->flags |= HID_MAIN_ITEM_RELATIVE;
665
+
break;
666
+
}
667
+
659
668
default: goto unknown;
660
669
}
661
670
+56
drivers/hid/hid-ite.c
+56
drivers/hid/hid-ite.c
···
1
+
/*
2
+
* HID driver for some ITE "special" devices
3
+
* Copyright (c) 2017 Hans de Goede <hdegoede@redhat.com>
4
+
*
5
+
* This program is free software; you can redistribute it and/or modify
6
+
* it under the terms of the GNU General Public License version 2 as
7
+
* published by the Free Software Foundation.
8
+
*/
9
+
10
+
#include <linux/device.h>
11
+
#include <linux/input.h>
12
+
#include <linux/hid.h>
13
+
#include <linux/module.h>
14
+
15
+
#include "hid-ids.h"
16
+
17
+
static int ite_event(struct hid_device *hdev, struct hid_field *field,
18
+
struct hid_usage *usage, __s32 value)
19
+
{
20
+
struct input_dev *input;
21
+
22
+
if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput)
23
+
return 0;
24
+
25
+
input = field->hidinput->input;
26
+
27
+
/*
28
+
* The ITE8595 always reports 0 as value for the rfkill button. Luckily
29
+
* it is the only button in its report, and it sends a report on
30
+
* release only, so receiving a report means the button was pressed.
31
+
*/
32
+
if (usage->hid == HID_GD_RFKILL_BTN) {
33
+
input_event(input, EV_KEY, KEY_RFKILL, 1);
34
+
input_sync(input);
35
+
input_event(input, EV_KEY, KEY_RFKILL, 0);
36
+
input_sync(input);
37
+
return 1;
38
+
}
39
+
40
+
return 0;
41
+
}
42
+
43
+
static const struct hid_device_id ite_devices[] = {
44
+
{ HID_USB_DEVICE(USB_VENDOR_ID_ITE, USB_DEVICE_ID_ITE8595) },
45
+
{ }
46
+
};
47
+
MODULE_DEVICE_TABLE(hid, ite_devices);
48
+
49
+
static struct hid_driver ite_driver = {
50
+
.name = "itetech",
51
+
.id_table = ite_devices,
52
+
.event = ite_event,
53
+
};
54
+
module_hid_driver(ite_driver);
55
+
56
+
MODULE_LICENSE("GPL");
+143
-41
drivers/hid/hid-multitouch.c
+143
-41
drivers/hid/hid-multitouch.c
···
44
44
#include <linux/slab.h>
45
45
#include <linux/input/mt.h>
46
46
#include <linux/string.h>
47
+
#include <linux/timer.h>
47
48
48
49
49
50
MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
···
55
54
#include "hid-ids.h"
56
55
57
56
/* quirks to control the device */
58
-
#define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0)
59
-
#define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1)
60
-
#define MT_QUIRK_CYPRESS (1 << 2)
61
-
#define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3)
62
-
#define MT_QUIRK_ALWAYS_VALID (1 << 4)
63
-
#define MT_QUIRK_VALID_IS_INRANGE (1 << 5)
64
-
#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 6)
65
-
#define MT_QUIRK_CONFIDENCE (1 << 7)
66
-
#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 8)
67
-
#define MT_QUIRK_NO_AREA (1 << 9)
68
-
#define MT_QUIRK_IGNORE_DUPLICATES (1 << 10)
69
-
#define MT_QUIRK_HOVERING (1 << 11)
70
-
#define MT_QUIRK_CONTACT_CNT_ACCURATE (1 << 12)
71
-
#define MT_QUIRK_FORCE_GET_FEATURE (1 << 13)
72
-
#define MT_QUIRK_FIX_CONST_CONTACT_ID (1 << 14)
73
-
#define MT_QUIRK_TOUCH_SIZE_SCALING (1 << 15)
57
+
#define MT_QUIRK_NOT_SEEN_MEANS_UP BIT(0)
58
+
#define MT_QUIRK_SLOT_IS_CONTACTID BIT(1)
59
+
#define MT_QUIRK_CYPRESS BIT(2)
60
+
#define MT_QUIRK_SLOT_IS_CONTACTNUMBER BIT(3)
61
+
#define MT_QUIRK_ALWAYS_VALID BIT(4)
62
+
#define MT_QUIRK_VALID_IS_INRANGE BIT(5)
63
+
#define MT_QUIRK_VALID_IS_CONFIDENCE BIT(6)
64
+
#define MT_QUIRK_CONFIDENCE BIT(7)
65
+
#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE BIT(8)
66
+
#define MT_QUIRK_NO_AREA BIT(9)
67
+
#define MT_QUIRK_IGNORE_DUPLICATES BIT(10)
68
+
#define MT_QUIRK_HOVERING BIT(11)
69
+
#define MT_QUIRK_CONTACT_CNT_ACCURATE BIT(12)
70
+
#define MT_QUIRK_FORCE_GET_FEATURE BIT(13)
71
+
#define MT_QUIRK_FIX_CONST_CONTACT_ID BIT(14)
72
+
#define MT_QUIRK_TOUCH_SIZE_SCALING BIT(15)
73
+
#define MT_QUIRK_STICKY_FINGERS BIT(16)
74
74
75
75
#define MT_INPUTMODE_TOUCHSCREEN 0x02
76
76
#define MT_INPUTMODE_TOUCHPAD 0x03
77
77
78
78
#define MT_BUTTONTYPE_CLICKPAD 0
79
+
80
+
#define MT_IO_FLAGS_RUNNING 0
81
+
#define MT_IO_FLAGS_ACTIVE_SLOTS 1
82
+
#define MT_IO_FLAGS_PENDING_SLOTS 2
79
83
80
84
struct mt_slot {
81
85
__s32 x, y, cx, cy, p, w, h;
···
110
104
struct mt_device {
111
105
struct mt_slot curdata; /* placeholder of incoming data */
112
106
struct mt_class mtclass; /* our mt device class */
107
+
struct timer_list release_timer; /* to release sticky fingers */
113
108
struct mt_fields *fields; /* temporary placeholder for storing the
114
109
multitouch fields */
110
+
unsigned long mt_io_flags; /* mt flags (MT_IO_FLAGS_*) */
115
111
int cc_index; /* contact count field index in the report */
116
112
int cc_value_index; /* contact count value index in the field */
117
113
unsigned last_slot_field; /* the last field of a slot */
···
156
148
/* reserved 0x0011 */
157
149
#define MT_CLS_WIN_8 0x0012
158
150
#define MT_CLS_EXPORT_ALL_INPUTS 0x0013
151
+
#define MT_CLS_WIN_8_DUAL 0x0014
159
152
160
153
/* vendor specific classes */
161
154
#define MT_CLS_3M 0x0101
···
170
161
#define MT_CLS_GENERALTOUCH_PWT_TENFINGERS 0x0109
171
162
#define MT_CLS_LG 0x010a
172
163
#define MT_CLS_VTL 0x0110
164
+
#define MT_CLS_GOOGLE 0x0111
173
165
174
166
#define MT_DEFAULT_MAXCONTACT 10
175
167
#define MT_MAX_MAXCONTACT 250
···
222
212
.quirks = MT_QUIRK_ALWAYS_VALID |
223
213
MT_QUIRK_IGNORE_DUPLICATES |
224
214
MT_QUIRK_HOVERING |
225
-
MT_QUIRK_CONTACT_CNT_ACCURATE },
215
+
MT_QUIRK_CONTACT_CNT_ACCURATE |
216
+
MT_QUIRK_STICKY_FINGERS },
226
217
{ .name = MT_CLS_EXPORT_ALL_INPUTS,
227
218
.quirks = MT_QUIRK_ALWAYS_VALID |
219
+
MT_QUIRK_CONTACT_CNT_ACCURATE,
220
+
.export_all_inputs = true },
221
+
{ .name = MT_CLS_WIN_8_DUAL,
222
+
.quirks = MT_QUIRK_ALWAYS_VALID |
223
+
MT_QUIRK_IGNORE_DUPLICATES |
224
+
MT_QUIRK_HOVERING |
228
225
MT_QUIRK_CONTACT_CNT_ACCURATE,
229
226
.export_all_inputs = true },
230
227
···
294
277
.quirks = MT_QUIRK_ALWAYS_VALID |
295
278
MT_QUIRK_CONTACT_CNT_ACCURATE |
296
279
MT_QUIRK_FORCE_GET_FEATURE,
280
+
},
281
+
{ .name = MT_CLS_GOOGLE,
282
+
.quirks = MT_QUIRK_ALWAYS_VALID |
283
+
MT_QUIRK_CONTACT_CNT_ACCURATE |
284
+
MT_QUIRK_SLOT_IS_CONTACTID |
285
+
MT_QUIRK_HOVERING
297
286
},
298
287
{ }
299
288
};
···
535
512
mt_store_field(usage, td, hi);
536
513
return 1;
537
514
case HID_DG_CONFIDENCE:
538
-
if (cls->name == MT_CLS_WIN_8 &&
515
+
if ((cls->name == MT_CLS_WIN_8 ||
516
+
cls->name == MT_CLS_WIN_8_DUAL) &&
539
517
field->application == HID_DG_TOUCHPAD)
540
518
cls->quirks |= MT_QUIRK_CONFIDENCE;
541
519
mt_store_field(usage, td, hi);
···
603
579
* MS PTP spec says that external buttons left and right have
604
580
* usages 2 and 3.
605
581
*/
606
-
if (cls->name == MT_CLS_WIN_8 &&
582
+
if ((cls->name == MT_CLS_WIN_8 ||
583
+
cls->name == MT_CLS_WIN_8_DUAL) &&
607
584
field->application == HID_DG_TOUCHPAD &&
608
585
(usage->hid & HID_USAGE) > 1)
609
586
code--;
···
707
682
input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
708
683
input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
709
684
input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
685
+
686
+
set_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
710
687
}
711
688
}
712
689
···
724
697
input_mt_sync_frame(input);
725
698
input_sync(input);
726
699
td->num_received = 0;
700
+
if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags))
701
+
set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
702
+
else
703
+
clear_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
704
+
clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
727
705
}
728
706
729
707
static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
···
820
788
unsigned count;
821
789
int r, n;
822
790
791
+
/* sticky fingers release in progress, abort */
792
+
if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
793
+
return;
794
+
823
795
/*
824
796
* Includes multi-packet support where subsequent
825
797
* packets are sent with zero contactcount.
···
849
813
850
814
if (td->num_received >= td->num_expected)
851
815
mt_sync_frame(td, report->field[0]->hidinput->input);
816
+
817
+
/*
818
+
* Windows 8 specs says 2 things:
819
+
* - once a contact has been reported, it has to be reported in each
820
+
* subsequent report
821
+
* - the report rate when fingers are present has to be at least
822
+
* the refresh rate of the screen, 60 or 120 Hz
823
+
*
824
+
* I interprete this that the specification forces a report rate of
825
+
* at least 60 Hz for a touchscreen to be certified.
826
+
* Which means that if we do not get a report whithin 16 ms, either
827
+
* something wrong happens, either the touchscreen forgets to send
828
+
* a release. Taking a reasonable margin allows to remove issues
829
+
* with USB communication or the load of the machine.
830
+
*
831
+
* Given that Win 8 devices are forced to send a release, this will
832
+
* only affect laggish machines and the ones that have a firmware
833
+
* defect.
834
+
*/
835
+
if (td->mtclass.quirks & MT_QUIRK_STICKY_FINGERS) {
836
+
if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
837
+
mod_timer(&td->release_timer,
838
+
jiffies + msecs_to_jiffies(100));
839
+
else
840
+
del_timer(&td->release_timer);
841
+
}
842
+
843
+
clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
852
844
}
853
845
854
846
static int mt_touch_input_configured(struct hid_device *hdev,
···
1188
1124
}
1189
1125
}
1190
1126
1127
+
static void mt_release_contacts(struct hid_device *hid)
1128
+
{
1129
+
struct hid_input *hidinput;
1130
+
struct mt_device *td = hid_get_drvdata(hid);
1131
+
1132
+
list_for_each_entry(hidinput, &hid->inputs, list) {
1133
+
struct input_dev *input_dev = hidinput->input;
1134
+
struct input_mt *mt = input_dev->mt;
1135
+
int i;
1136
+
1137
+
if (mt) {
1138
+
for (i = 0; i < mt->num_slots; i++) {
1139
+
input_mt_slot(input_dev, i);
1140
+
input_mt_report_slot_state(input_dev,
1141
+
MT_TOOL_FINGER,
1142
+
false);
1143
+
}
1144
+
input_mt_sync_frame(input_dev);
1145
+
input_sync(input_dev);
1146
+
}
1147
+
}
1148
+
1149
+
td->num_received = 0;
1150
+
}
1151
+
1152
+
static void mt_expired_timeout(unsigned long arg)
1153
+
{
1154
+
struct hid_device *hdev = (void *)arg;
1155
+
struct mt_device *td = hid_get_drvdata(hdev);
1156
+
1157
+
/*
1158
+
* An input report came in just before we release the sticky fingers,
1159
+
* it will take care of the sticky fingers.
1160
+
*/
1161
+
if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1162
+
return;
1163
+
if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1164
+
mt_release_contacts(hdev);
1165
+
clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
1166
+
}
1167
+
1191
1168
static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
1192
1169
{
1193
1170
int ret, i;
···
1298
1193
*/
1299
1194
hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
1300
1195
1196
+
setup_timer(&td->release_timer, mt_expired_timeout, (long)hdev);
1197
+
1301
1198
ret = hid_parse(hdev);
1302
1199
if (ret != 0)
1303
1200
return ret;
···
1327
1220
}
1328
1221
1329
1222
#ifdef CONFIG_PM
1330
-
static void mt_release_contacts(struct hid_device *hid)
1331
-
{
1332
-
struct hid_input *hidinput;
1333
-
1334
-
list_for_each_entry(hidinput, &hid->inputs, list) {
1335
-
struct input_dev *input_dev = hidinput->input;
1336
-
struct input_mt *mt = input_dev->mt;
1337
-
int i;
1338
-
1339
-
if (mt) {
1340
-
for (i = 0; i < mt->num_slots; i++) {
1341
-
input_mt_slot(input_dev, i);
1342
-
input_mt_report_slot_state(input_dev,
1343
-
MT_TOOL_FINGER,
1344
-
false);
1345
-
}
1346
-
input_mt_sync_frame(input_dev);
1347
-
input_sync(input_dev);
1348
-
}
1349
-
}
1350
-
}
1351
-
1352
1223
static int mt_reset_resume(struct hid_device *hdev)
1353
1224
{
1354
1225
mt_release_contacts(hdev);
···
1351
1266
{
1352
1267
struct mt_device *td = hid_get_drvdata(hdev);
1353
1268
1269
+
del_timer_sync(&td->release_timer);
1270
+
1354
1271
sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
1355
1272
hid_hw_stop(hdev);
1356
1273
hdev->quirks = td->initial_quirks;
···
1376
1289
{ .driver_data = MT_CLS_3M,
1377
1290
MT_USB_DEVICE(USB_VENDOR_ID_3M,
1378
1291
USB_DEVICE_ID_3M3266) },
1292
+
1293
+
/* Alps devices */
1294
+
{ .driver_data = MT_CLS_WIN_8_DUAL,
1295
+
HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1296
+
USB_VENDOR_ID_ALPS_JP,
1297
+
HID_DEVICE_ID_ALPS_U1_DUAL_PTP) },
1298
+
{ .driver_data = MT_CLS_WIN_8_DUAL,
1299
+
HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1300
+
USB_VENDOR_ID_ALPS_JP,
1301
+
HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP) },
1379
1302
1380
1303
/* Anton devices */
1381
1304
{ .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
···
1665
1568
{ .driver_data = MT_CLS_NSMU,
1666
1569
MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1667
1570
USB_DEVICE_ID_XIROKU_CSR2) },
1571
+
1572
+
/* Google MT devices */
1573
+
{ .driver_data = MT_CLS_GOOGLE,
1574
+
HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_GOOGLE,
1575
+
USB_DEVICE_ID_GOOGLE_TOUCH_ROSE) },
1668
1576
1669
1577
/* Generic MT device */
1670
1578
{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
+100
drivers/hid/hid-retrode.c
+100
drivers/hid/hid-retrode.c
···
1
+
/*
2
+
* HID driver for Retrode 2 controller adapter and plug-in extensions
3
+
*
4
+
* Copyright (c) 2017 Bastien Nocera <hadess@hadess.net>
5
+
*/
6
+
7
+
/*
8
+
* This program is free software; you can redistribute it and/or modify it
9
+
* under the terms of the GNU General Public License as published by the Free
10
+
* Software Foundation; either version 2 of the License, or (at your option)
11
+
* any later version.
12
+
*/
13
+
14
+
#include <linux/input.h>
15
+
#include <linux/slab.h>
16
+
#include <linux/hid.h>
17
+
#include <linux/module.h>
18
+
#include "hid-ids.h"
19
+
20
+
#define CONTROLLER_NAME_BASE "Retrode"
21
+
22
+
static int retrode_input_configured(struct hid_device *hdev,
23
+
struct hid_input *hi)
24
+
{
25
+
struct hid_field *field = hi->report->field[0];
26
+
const char *suffix;
27
+
int number = 0;
28
+
char *name;
29
+
30
+
switch (field->report->id) {
31
+
case 0:
32
+
suffix = "SNES Mouse";
33
+
break;
34
+
case 1:
35
+
case 2:
36
+
suffix = "SNES / N64";
37
+
number = field->report->id;
38
+
break;
39
+
case 3:
40
+
case 4:
41
+
suffix = "Mega Drive";
42
+
number = field->report->id - 2;
43
+
break;
44
+
default:
45
+
hid_err(hdev, "Got unhandled report id %d\n", field->report->id);
46
+
suffix = "Unknown";
47
+
}
48
+
49
+
if (number)
50
+
name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
51
+
"%s %s #%d", CONTROLLER_NAME_BASE,
52
+
suffix, number);
53
+
else
54
+
name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
55
+
"%s %s", CONTROLLER_NAME_BASE, suffix);
56
+
57
+
if (!name)
58
+
return -ENOMEM;
59
+
60
+
hi->input->name = name;
61
+
62
+
return 0;
63
+
}
64
+
65
+
static int retrode_probe(struct hid_device *hdev,
66
+
const struct hid_device_id *id)
67
+
{
68
+
69
+
int ret;
70
+
71
+
/* Has no effect on the mouse device */
72
+
hdev->quirks |= HID_QUIRK_MULTI_INPUT;
73
+
74
+
ret = hid_parse(hdev);
75
+
if (ret)
76
+
return ret;
77
+
78
+
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
79
+
if (ret)
80
+
return ret;
81
+
82
+
return 0;
83
+
}
84
+
85
+
static const struct hid_device_id retrode_devices[] = {
86
+
{ HID_USB_DEVICE(USB_VENDOR_ID_FUTURE_TECHNOLOGY, USB_DEVICE_ID_RETRODE2) },
87
+
{ }
88
+
};
89
+
MODULE_DEVICE_TABLE(hid, retrode_devices);
90
+
91
+
static struct hid_driver retrode_driver = {
92
+
.name = "hid-retrode",
93
+
.id_table = retrode_devices,
94
+
.input_configured = retrode_input_configured,
95
+
.probe = retrode_probe,
96
+
};
97
+
98
+
module_hid_driver(retrode_driver);
99
+
100
+
MODULE_LICENSE("GPL");
+10
-24
drivers/hid/i2c-hid/i2c-hid.c
+10
-24
drivers/hid/i2c-hid/i2c-hid.c
···
40
40
#include <linux/of.h>
41
41
#include <linux/regulator/consumer.h>
42
42
43
-
#include <linux/i2c/i2c-hid.h>
43
+
#include <linux/platform_data/i2c-hid.h>
44
44
45
45
#include "../hid-ids.h"
46
46
···
743
743
struct i2c_hid *ihid = i2c_get_clientdata(client);
744
744
int ret = 0;
745
745
746
-
mutex_lock(&i2c_hid_open_mut);
747
-
if (!hid->open++) {
748
-
ret = pm_runtime_get_sync(&client->dev);
749
-
if (ret < 0) {
750
-
hid->open--;
751
-
goto done;
752
-
}
753
-
set_bit(I2C_HID_STARTED, &ihid->flags);
754
-
}
755
-
done:
756
-
mutex_unlock(&i2c_hid_open_mut);
757
-
return ret < 0 ? ret : 0;
746
+
ret = pm_runtime_get_sync(&client->dev);
747
+
if (ret < 0)
748
+
return ret;
749
+
750
+
set_bit(I2C_HID_STARTED, &ihid->flags);
751
+
return 0;
758
752
}
759
753
760
754
static void i2c_hid_close(struct hid_device *hid)
···
756
762
struct i2c_client *client = hid->driver_data;
757
763
struct i2c_hid *ihid = i2c_get_clientdata(client);
758
764
759
-
/* protecting hid->open to make sure we don't restart
760
-
* data acquistion due to a resumption we no longer
761
-
* care about
762
-
*/
763
-
mutex_lock(&i2c_hid_open_mut);
764
-
if (!--hid->open) {
765
-
clear_bit(I2C_HID_STARTED, &ihid->flags);
765
+
clear_bit(I2C_HID_STARTED, &ihid->flags);
766
766
767
-
/* Save some power */
768
-
pm_runtime_put(&client->dev);
769
-
}
770
-
mutex_unlock(&i2c_hid_open_mut);
767
+
/* Save some power */
768
+
pm_runtime_put(&client->dev);
771
769
}
772
770
773
771
static int i2c_hid_power(struct hid_device *hid, int lvl)
+1
-1
drivers/hid/intel-ish-hid/Kconfig
+1
-1
drivers/hid/intel-ish-hid/Kconfig
+2
drivers/hid/intel-ish-hid/ipc/hw-ish.h
+2
drivers/hid/intel-ish-hid/ipc/hw-ish.h
+4
-11
drivers/hid/intel-ish-hid/ipc/ipc.c
+4
-11
drivers/hid/intel-ish-hid/ipc/ipc.c
···
296
296
/* If sending MNG_SYNC_FW_CLOCK, update clock again */
297
297
if (IPC_HEADER_GET_PROTOCOL(doorbell_val) == IPC_PROTOCOL_MNG &&
298
298
IPC_HEADER_GET_MNG_CMD(doorbell_val) == MNG_SYNC_FW_CLOCK) {
299
-
struct timespec ts_system;
300
-
struct timeval tv_utc;
301
-
uint64_t usec_system, usec_utc;
299
+
uint64_t usec_system, usec_utc;
302
300
struct ipc_time_update_msg time_update;
303
301
struct time_sync_format ts_format;
304
302
305
-
get_monotonic_boottime(&ts_system);
306
-
do_gettimeofday(&tv_utc);
307
-
usec_system = (timespec_to_ns(&ts_system)) / NSEC_PER_USEC;
308
-
usec_utc = (uint64_t)tv_utc.tv_sec * 1000000 +
309
-
((uint32_t)tv_utc.tv_usec);
303
+
usec_system = ktime_to_us(ktime_get_boottime());
304
+
usec_utc = ktime_to_us(ktime_get_real());
310
305
ts_format.ts1_source = HOST_SYSTEM_TIME_USEC;
311
306
ts_format.ts2_source = HOST_UTC_TIME_USEC;
312
307
ts_format.reserved = 0;
···
570
575
static void _ish_sync_fw_clock(struct ishtp_device *dev)
571
576
{
572
577
static unsigned long prev_sync;
573
-
struct timespec ts;
574
578
uint64_t usec;
575
579
576
580
if (prev_sync && jiffies - prev_sync < 20 * HZ)
577
581
return;
578
582
579
583
prev_sync = jiffies;
580
-
get_monotonic_boottime(&ts);
581
-
usec = (timespec_to_ns(&ts)) / NSEC_PER_USEC;
584
+
usec = ktime_to_us(ktime_get_boottime());
582
585
ipc_send_mng_msg(dev, MNG_SYNC_FW_CLOCK, &usec, sizeof(uint64_t));
583
586
}
584
587
+2
drivers/hid/intel-ish-hid/ipc/pci-ish.c
+2
drivers/hid/intel-ish-hid/ipc/pci-ish.c
···
35
35
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, BXT_Bx_DEVICE_ID)},
36
36
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, APL_Ax_DEVICE_ID)},
37
37
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, SPT_Ax_DEVICE_ID)},
38
+
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, CNL_Ax_DEVICE_ID)},
39
+
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, GLK_Ax_DEVICE_ID)},
38
40
{0, }
39
41
};
40
42
MODULE_DEVICE_TABLE(pci, ish_pci_tbl);
+2
-3
drivers/hid/intel-ish-hid/ishtp-hid-client.c
+2
-3
drivers/hid/intel-ish-hid/ishtp-hid-client.c
···
136
136
if (1 + sizeof(struct device_info) * i >=
137
137
payload_len) {
138
138
dev_err(&client_data->cl_device->dev,
139
-
"[hid-ish]: [ENUM_DEVICES]: content size %lu is bigger than payload_len %u\n",
139
+
"[hid-ish]: [ENUM_DEVICES]: content size %zu is bigger than payload_len %zu\n",
140
140
1 + sizeof(struct device_info)
141
-
* i,
142
-
(unsigned int)payload_len);
141
+
* i, payload_len);
143
142
}
144
143
145
144
if (1 + sizeof(struct device_info) * i >=
+21
-28
drivers/hid/intel-ish-hid/ishtp/client.c
+21
-28
drivers/hid/intel-ish-hid/ishtp/client.c
···
803
803
* @ishtp_hdr: Pointer to message header
804
804
*
805
805
* Receive and dispatch ISHTP client messages. This function executes in ISR
806
-
* context
806
+
* or work queue context
807
807
*/
808
808
void recv_ishtp_cl_msg(struct ishtp_device *dev,
809
809
struct ishtp_msg_hdr *ishtp_hdr)
···
813
813
struct ishtp_cl_rb *new_rb;
814
814
unsigned char *buffer = NULL;
815
815
struct ishtp_cl_rb *complete_rb = NULL;
816
-
unsigned long dev_flags;
817
816
unsigned long flags;
818
817
int rb_count;
819
818
···
827
828
goto eoi;
828
829
}
829
830
830
-
spin_lock_irqsave(&dev->read_list_spinlock, dev_flags);
831
+
spin_lock_irqsave(&dev->read_list_spinlock, flags);
831
832
rb_count = -1;
832
833
list_for_each_entry(rb, &dev->read_list.list, list) {
833
834
++rb_count;
···
839
840
840
841
/* If no Rx buffer is allocated, disband the rb */
841
842
if (rb->buffer.size == 0 || rb->buffer.data == NULL) {
842
-
spin_unlock_irqrestore(&dev->read_list_spinlock,
843
-
dev_flags);
843
+
spin_unlock_irqrestore(&dev->read_list_spinlock, flags);
844
844
dev_err(&cl->device->dev,
845
845
"Rx buffer is not allocated.\n");
846
846
list_del(&rb->list);
···
855
857
* back FC, so communication will be stuck anyway)
856
858
*/
857
859
if (rb->buffer.size < ishtp_hdr->length + rb->buf_idx) {
858
-
spin_unlock_irqrestore(&dev->read_list_spinlock,
859
-
dev_flags);
860
+
spin_unlock_irqrestore(&dev->read_list_spinlock, flags);
860
861
dev_err(&cl->device->dev,
861
862
"message overflow. size %d len %d idx %ld\n",
862
863
rb->buffer.size, ishtp_hdr->length,
···
881
884
* the whole msg arrived, send a new FC, and add a new
882
885
* rb buffer for the next coming msg
883
886
*/
884
-
spin_lock_irqsave(&cl->free_list_spinlock, flags);
887
+
spin_lock(&cl->free_list_spinlock);
885
888
886
889
if (!list_empty(&cl->free_rb_list.list)) {
887
890
new_rb = list_entry(cl->free_rb_list.list.next,
888
891
struct ishtp_cl_rb, list);
889
892
list_del_init(&new_rb->list);
890
-
spin_unlock_irqrestore(&cl->free_list_spinlock,
891
-
flags);
893
+
spin_unlock(&cl->free_list_spinlock);
892
894
new_rb->cl = cl;
893
895
new_rb->buf_idx = 0;
894
896
INIT_LIST_HEAD(&new_rb->list);
···
896
900
897
901
ishtp_hbm_cl_flow_control_req(dev, cl);
898
902
} else {
899
-
spin_unlock_irqrestore(&cl->free_list_spinlock,
900
-
flags);
903
+
spin_unlock(&cl->free_list_spinlock);
901
904
}
902
905
}
903
906
/* One more fragment in message (even if this was last) */
···
909
914
break;
910
915
}
911
916
912
-
spin_unlock_irqrestore(&dev->read_list_spinlock, dev_flags);
917
+
spin_unlock_irqrestore(&dev->read_list_spinlock, flags);
913
918
/* If it's nobody's message, just read and discard it */
914
919
if (!buffer) {
915
920
uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE];
···
920
925
}
921
926
922
927
if (complete_rb) {
923
-
getnstimeofday(&cl->ts_rx);
928
+
cl = complete_rb->cl;
929
+
cl->ts_rx = ktime_get();
924
930
++cl->recv_msg_cnt_ipc;
925
931
ishtp_cl_read_complete(complete_rb);
926
932
}
···
936
940
* @hbm: hbm buffer
937
941
*
938
942
* Receive and dispatch ISHTP client messages using DMA. This function executes
939
-
* in ISR context
943
+
* in ISR or work queue context
940
944
*/
941
945
void recv_ishtp_cl_msg_dma(struct ishtp_device *dev, void *msg,
942
946
struct dma_xfer_hbm *hbm)
···
946
950
struct ishtp_cl_rb *new_rb;
947
951
unsigned char *buffer = NULL;
948
952
struct ishtp_cl_rb *complete_rb = NULL;
949
-
unsigned long dev_flags;
950
953
unsigned long flags;
951
954
952
-
spin_lock_irqsave(&dev->read_list_spinlock, dev_flags);
955
+
spin_lock_irqsave(&dev->read_list_spinlock, flags);
956
+
953
957
list_for_each_entry(rb, &dev->read_list.list, list) {
954
958
cl = rb->cl;
955
959
if (!cl || !(cl->host_client_id == hbm->host_client_id &&
···
961
965
* If no Rx buffer is allocated, disband the rb
962
966
*/
963
967
if (rb->buffer.size == 0 || rb->buffer.data == NULL) {
964
-
spin_unlock_irqrestore(&dev->read_list_spinlock,
965
-
dev_flags);
968
+
spin_unlock_irqrestore(&dev->read_list_spinlock, flags);
966
969
dev_err(&cl->device->dev,
967
970
"response buffer is not allocated.\n");
968
971
list_del(&rb->list);
···
977
982
* back FC, so communication will be stuck anyway)
978
983
*/
979
984
if (rb->buffer.size < hbm->msg_length) {
980
-
spin_unlock_irqrestore(&dev->read_list_spinlock,
981
-
dev_flags);
985
+
spin_unlock_irqrestore(&dev->read_list_spinlock, flags);
982
986
dev_err(&cl->device->dev,
983
987
"message overflow. size %d len %d idx %ld\n",
984
988
rb->buffer.size, hbm->msg_length, rb->buf_idx);
···
1001
1007
* the whole msg arrived, send a new FC, and add a new
1002
1008
* rb buffer for the next coming msg
1003
1009
*/
1004
-
spin_lock_irqsave(&cl->free_list_spinlock, flags);
1010
+
spin_lock(&cl->free_list_spinlock);
1005
1011
1006
1012
if (!list_empty(&cl->free_rb_list.list)) {
1007
1013
new_rb = list_entry(cl->free_rb_list.list.next,
1008
1014
struct ishtp_cl_rb, list);
1009
1015
list_del_init(&new_rb->list);
1010
-
spin_unlock_irqrestore(&cl->free_list_spinlock,
1011
-
flags);
1016
+
spin_unlock(&cl->free_list_spinlock);
1012
1017
new_rb->cl = cl;
1013
1018
new_rb->buf_idx = 0;
1014
1019
INIT_LIST_HEAD(&new_rb->list);
···
1016
1023
1017
1024
ishtp_hbm_cl_flow_control_req(dev, cl);
1018
1025
} else {
1019
-
spin_unlock_irqrestore(&cl->free_list_spinlock,
1020
-
flags);
1026
+
spin_unlock(&cl->free_list_spinlock);
1021
1027
}
1022
1028
1023
1029
/* One more fragment in message (this is always last) */
···
1029
1037
break;
1030
1038
}
1031
1039
1032
-
spin_unlock_irqrestore(&dev->read_list_spinlock, dev_flags);
1040
+
spin_unlock_irqrestore(&dev->read_list_spinlock, flags);
1033
1041
/* If it's nobody's message, just read and discard it */
1034
1042
if (!buffer) {
1035
1043
dev_err(dev->devc, "Dropped Rx (DMA) msg - no request\n");
···
1037
1045
}
1038
1046
1039
1047
if (complete_rb) {
1040
-
getnstimeofday(&cl->ts_rx);
1048
+
cl = complete_rb->cl;
1049
+
cl->ts_rx = ktime_get();
1041
1050
++cl->recv_msg_cnt_dma;
1042
1051
ishtp_cl_read_complete(complete_rb);
1043
1052
}
+3
-3
drivers/hid/intel-ish-hid/ishtp/client.h
+3
-3
drivers/hid/intel-ish-hid/ishtp/client.h
···
118
118
unsigned int out_flow_ctrl_cnt;
119
119
120
120
/* Rx msg ... out FC timing */
121
-
struct timespec ts_rx;
122
-
struct timespec ts_out_fc;
123
-
struct timespec ts_max_fc_delay;
121
+
ktime_t ts_rx;
122
+
ktime_t ts_out_fc;
123
+
ktime_t ts_max_fc_delay;
124
124
void *client_data;
125
125
};
126
126
+4
-7
drivers/hid/intel-ish-hid/ishtp/hbm.c
+4
-7
drivers/hid/intel-ish-hid/ishtp/hbm.c
···
321
321
if (!rv) {
322
322
++cl->out_flow_ctrl_creds;
323
323
++cl->out_flow_ctrl_cnt;
324
-
getnstimeofday(&cl->ts_out_fc);
325
-
if (cl->ts_rx.tv_sec && cl->ts_rx.tv_nsec) {
326
-
struct timespec ts_diff;
327
-
328
-
ts_diff = timespec_sub(cl->ts_out_fc, cl->ts_rx);
329
-
if (timespec_compare(&ts_diff, &cl->ts_max_fc_delay)
330
-
> 0)
324
+
cl->ts_out_fc = ktime_get();
325
+
if (cl->ts_rx) {
326
+
ktime_t ts_diff = ktime_sub(cl->ts_out_fc, cl->ts_rx);
327
+
if (ktime_after(ts_diff, cl->ts_max_fc_delay))
331
328
cl->ts_max_fc_delay = ts_diff;
332
329
}
333
330
} else {
+69
-79
drivers/hid/usbhid/hid-core.c
+69
-79
drivers/hid/usbhid/hid-core.c
···
70
70
/*
71
71
* Input submission and I/O error handler.
72
72
*/
73
-
static DEFINE_MUTEX(hid_open_mut);
74
-
75
73
static void hid_io_error(struct hid_device *hid);
76
74
static int hid_submit_out(struct hid_device *hid);
77
75
static int hid_submit_ctrl(struct hid_device *hid);
···
83
85
struct usbhid_device *usbhid = hid->driver_data;
84
86
85
87
spin_lock_irqsave(&usbhid->lock, flags);
86
-
if ((hid->open > 0 || hid->quirks & HID_QUIRK_ALWAYS_POLL) &&
87
-
!test_bit(HID_DISCONNECTED, &usbhid->iofl) &&
88
-
!test_bit(HID_SUSPENDED, &usbhid->iofl) &&
89
-
!test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) {
88
+
if (test_bit(HID_IN_POLLING, &usbhid->iofl) &&
89
+
!test_bit(HID_DISCONNECTED, &usbhid->iofl) &&
90
+
!test_bit(HID_SUSPENDED, &usbhid->iofl) &&
91
+
!test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) {
90
92
rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC);
91
93
if (rc != 0) {
92
94
clear_bit(HID_IN_RUNNING, &usbhid->iofl);
···
270
272
static void hid_irq_in(struct urb *urb)
271
273
{
272
274
struct hid_device *hid = urb->context;
273
-
struct usbhid_device *usbhid = hid->driver_data;
275
+
struct usbhid_device *usbhid = hid->driver_data;
274
276
int status;
275
277
276
278
switch (urb->status) {
277
279
case 0: /* success */
278
280
usbhid->retry_delay = 0;
279
-
if ((hid->quirks & HID_QUIRK_ALWAYS_POLL) && !hid->open)
281
+
if (!test_bit(HID_OPENED, &usbhid->iofl))
280
282
break;
281
283
usbhid_mark_busy(usbhid);
282
284
if (!test_bit(HID_RESUME_RUNNING, &usbhid->iofl)) {
···
675
677
return result;
676
678
}
677
679
678
-
int usbhid_open(struct hid_device *hid)
680
+
static int usbhid_open(struct hid_device *hid)
679
681
{
680
682
struct usbhid_device *usbhid = hid->driver_data;
681
-
int res = 0;
683
+
int res;
682
684
683
-
mutex_lock(&hid_open_mut);
684
-
if (!hid->open++) {
685
-
res = usb_autopm_get_interface(usbhid->intf);
686
-
/* the device must be awake to reliably request remote wakeup */
687
-
if (res < 0) {
688
-
hid->open--;
689
-
res = -EIO;
690
-
goto done;
691
-
}
692
-
usbhid->intf->needs_remote_wakeup = 1;
693
-
set_bit(HID_RESUME_RUNNING, &usbhid->iofl);
694
-
res = hid_start_in(hid);
695
-
if (res) {
696
-
if (res != -ENOSPC) {
697
-
hid_io_error(hid);
698
-
res = 0;
699
-
} else {
700
-
/* no use opening if resources are insufficient */
701
-
hid->open--;
702
-
res = -EBUSY;
703
-
usbhid->intf->needs_remote_wakeup = 0;
704
-
}
705
-
}
706
-
usb_autopm_put_interface(usbhid->intf);
685
+
if (hid->quirks & HID_QUIRK_ALWAYS_POLL)
686
+
return 0;
707
687
708
-
/*
709
-
* In case events are generated while nobody was listening,
710
-
* some are released when the device is re-opened.
711
-
* Wait 50 msec for the queue to empty before allowing events
712
-
* to go through hid.
713
-
*/
714
-
if (res == 0 && !(hid->quirks & HID_QUIRK_ALWAYS_POLL))
715
-
msleep(50);
716
-
clear_bit(HID_RESUME_RUNNING, &usbhid->iofl);
688
+
res = usb_autopm_get_interface(usbhid->intf);
689
+
/* the device must be awake to reliably request remote wakeup */
690
+
if (res < 0)
691
+
return -EIO;
692
+
693
+
usbhid->intf->needs_remote_wakeup = 1;
694
+
695
+
set_bit(HID_RESUME_RUNNING, &usbhid->iofl);
696
+
set_bit(HID_OPENED, &usbhid->iofl);
697
+
set_bit(HID_IN_POLLING, &usbhid->iofl);
698
+
699
+
res = hid_start_in(hid);
700
+
if (res) {
701
+
if (res != -ENOSPC) {
702
+
hid_io_error(hid);
703
+
res = 0;
704
+
} else {
705
+
/* no use opening if resources are insufficient */
706
+
res = -EBUSY;
707
+
clear_bit(HID_OPENED, &usbhid->iofl);
708
+
clear_bit(HID_IN_POLLING, &usbhid->iofl);
709
+
usbhid->intf->needs_remote_wakeup = 0;
710
+
}
717
711
}
718
-
done:
719
-
mutex_unlock(&hid_open_mut);
712
+
713
+
usb_autopm_put_interface(usbhid->intf);
714
+
715
+
/*
716
+
* In case events are generated while nobody was listening,
717
+
* some are released when the device is re-opened.
718
+
* Wait 50 msec for the queue to empty before allowing events
719
+
* to go through hid.
720
+
*/
721
+
if (res == 0)
722
+
msleep(50);
723
+
724
+
clear_bit(HID_RESUME_RUNNING, &usbhid->iofl);
720
725
return res;
721
726
}
722
727
723
-
void usbhid_close(struct hid_device *hid)
728
+
static void usbhid_close(struct hid_device *hid)
724
729
{
725
730
struct usbhid_device *usbhid = hid->driver_data;
726
731
727
-
mutex_lock(&hid_open_mut);
732
+
if (hid->quirks & HID_QUIRK_ALWAYS_POLL)
733
+
return;
728
734
729
-
/* protecting hid->open to make sure we don't restart
730
-
* data acquistion due to a resumption we no longer
731
-
* care about
735
+
/*
736
+
* Make sure we don't restart data acquisition due to
737
+
* a resumption we no longer care about by avoiding racing
738
+
* with hid_start_in().
732
739
*/
733
740
spin_lock_irq(&usbhid->lock);
734
-
if (!--hid->open) {
735
-
spin_unlock_irq(&usbhid->lock);
736
-
hid_cancel_delayed_stuff(usbhid);
737
-
if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL)) {
738
-
usb_kill_urb(usbhid->urbin);
739
-
usbhid->intf->needs_remote_wakeup = 0;
740
-
}
741
-
} else {
742
-
spin_unlock_irq(&usbhid->lock);
743
-
}
744
-
mutex_unlock(&hid_open_mut);
741
+
clear_bit(HID_IN_POLLING, &usbhid->iofl);
742
+
clear_bit(HID_OPENED, &usbhid->iofl);
743
+
spin_unlock_irq(&usbhid->lock);
744
+
745
+
hid_cancel_delayed_stuff(usbhid);
746
+
usb_kill_urb(usbhid->urbin);
747
+
usbhid->intf->needs_remote_wakeup = 0;
745
748
}
746
749
747
750
/*
···
1134
1135
ret = usb_autopm_get_interface(usbhid->intf);
1135
1136
if (ret)
1136
1137
goto fail;
1138
+
set_bit(HID_IN_POLLING, &usbhid->iofl);
1137
1139
usbhid->intf->needs_remote_wakeup = 1;
1138
1140
ret = hid_start_in(hid);
1139
1141
if (ret) {
···
1176
1176
if (WARN_ON(!usbhid))
1177
1177
return;
1178
1178
1179
-
if (hid->quirks & HID_QUIRK_ALWAYS_POLL)
1179
+
if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
1180
+
clear_bit(HID_IN_POLLING, &usbhid->iofl);
1180
1181
usbhid->intf->needs_remote_wakeup = 0;
1182
+
}
1181
1183
1182
1184
clear_bit(HID_STARTED, &usbhid->iofl);
1183
1185
spin_lock_irq(&usbhid->lock); /* Sync with error and led handlers */
···
1205
1203
1206
1204
static int usbhid_power(struct hid_device *hid, int lvl)
1207
1205
{
1206
+
struct usbhid_device *usbhid = hid->driver_data;
1208
1207
int r = 0;
1209
1208
1210
1209
switch (lvl) {
1211
1210
case PM_HINT_FULLON:
1212
-
r = usbhid_get_power(hid);
1211
+
r = usb_autopm_get_interface(usbhid->intf);
1213
1212
break;
1213
+
1214
1214
case PM_HINT_NORMAL:
1215
-
usbhid_put_power(hid);
1215
+
usb_autopm_put_interface(usbhid->intf);
1216
1216
break;
1217
1217
}
1218
+
1218
1219
return r;
1219
1220
}
1220
1221
···
1496
1491
1497
1492
return 0;
1498
1493
}
1499
-
1500
-
int usbhid_get_power(struct hid_device *hid)
1501
-
{
1502
-
struct usbhid_device *usbhid = hid->driver_data;
1503
-
1504
-
return usb_autopm_get_interface(usbhid->intf);
1505
-
}
1506
-
1507
-
void usbhid_put_power(struct hid_device *hid)
1508
-
{
1509
-
struct usbhid_device *usbhid = hid->driver_data;
1510
-
1511
-
usb_autopm_put_interface(usbhid->intf);
1512
-
}
1513
-
1514
1494
1515
1495
#ifdef CONFIG_PM
1516
1496
static int hid_resume_common(struct hid_device *hid, bool driver_suspended)
+12
-12
drivers/hid/usbhid/hiddev.c
+12
-12
drivers/hid/usbhid/hiddev.c
···
237
237
mutex_lock(&list->hiddev->existancelock);
238
238
if (!--list->hiddev->open) {
239
239
if (list->hiddev->exist) {
240
-
usbhid_close(list->hiddev->hid);
241
-
usbhid_put_power(list->hiddev->hid);
240
+
hid_hw_close(list->hiddev->hid);
241
+
hid_hw_power(list->hiddev->hid, PM_HINT_NORMAL);
242
242
} else {
243
243
mutex_unlock(&list->hiddev->existancelock);
244
244
kfree(list->hiddev);
···
282
282
*/
283
283
if (list->hiddev->exist) {
284
284
if (!list->hiddev->open++) {
285
-
res = usbhid_open(hiddev->hid);
286
-
if (res < 0) {
287
-
res = -EIO;
285
+
res = hid_hw_open(hiddev->hid);
286
+
if (res < 0)
288
287
goto bail;
289
-
}
290
288
}
291
289
} else {
292
290
res = -ENODEV;
···
299
301
if (!list->hiddev->open++)
300
302
if (list->hiddev->exist) {
301
303
struct hid_device *hid = hiddev->hid;
302
-
res = usbhid_get_power(hid);
303
-
if (res < 0) {
304
-
res = -EIO;
304
+
res = hid_hw_power(hid, PM_HINT_FULLON);
305
+
if (res < 0)
305
306
goto bail_unlock;
306
-
}
307
-
usbhid_open(hid);
307
+
res = hid_hw_open(hid);
308
+
if (res < 0)
309
+
goto bail_normal_power;
308
310
}
309
311
mutex_unlock(&hiddev->existancelock);
310
312
return 0;
313
+
bail_normal_power:
314
+
hid_hw_power(hid, PM_HINT_NORMAL);
311
315
bail_unlock:
312
316
mutex_unlock(&hiddev->existancelock);
313
317
bail:
···
935
935
936
936
if (hiddev->open) {
937
937
mutex_unlock(&hiddev->existancelock);
938
-
usbhid_close(hiddev->hid);
938
+
hid_hw_close(hiddev->hid);
939
939
wake_up_interruptible(&hiddev->wait);
940
940
} else {
941
941
mutex_unlock(&hiddev->existancelock);
+11
-4
drivers/hid/usbhid/usbhid.h
+11
-4
drivers/hid/usbhid/usbhid.h
···
34
34
#include <linux/input.h>
35
35
36
36
/* API provided by hid-core.c for USB HID drivers */
37
-
void usbhid_close(struct hid_device *hid);
38
-
int usbhid_open(struct hid_device *hid);
39
37
void usbhid_init_reports(struct hid_device *hid);
40
-
int usbhid_get_power(struct hid_device *hid);
41
-
void usbhid_put_power(struct hid_device *hid);
42
38
struct usb_interface *usbhid_find_interface(int minor);
43
39
44
40
/* iofl flags */
···
49
53
#define HID_KEYS_PRESSED 10
50
54
#define HID_NO_BANDWIDTH 11
51
55
#define HID_RESUME_RUNNING 12
56
+
/*
57
+
* The device is opened, meaning there is a client that is interested
58
+
* in data coming from the device.
59
+
*/
60
+
#define HID_OPENED 13
61
+
/*
62
+
* We are polling input endpoint by [re]submitting IN URB, because
63
+
* either HID device is opened or ALWAYS POLL quirk is set for the
64
+
* device.
65
+
*/
66
+
#define HID_IN_POLLING 14
52
67
53
68
/*
54
69
* USB-specific HID struct, to be pointed to
+1
drivers/hid/wacom.h
+1
drivers/hid/wacom.h
+3
-1
drivers/hid/wacom_sys.c
+3
-1
drivers/hid/wacom_sys.c
···
1547
1547
val->intval = battery->battery_capacity;
1548
1548
break;
1549
1549
case POWER_SUPPLY_PROP_STATUS:
1550
-
if (battery->bat_charging)
1550
+
if (battery->bat_status != WACOM_POWER_SUPPLY_STATUS_AUTO)
1551
+
val->intval = battery->bat_status;
1552
+
else if (battery->bat_charging)
1551
1553
val->intval = POWER_SUPPLY_STATUS_CHARGING;
1552
1554
else if (battery->battery_capacity == 100 &&
1553
1555
battery->ps_connected)
+122
-82
drivers/hid/wacom_wac.c
+122
-82
drivers/hid/wacom_wac.c
···
57
57
static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
58
58
59
59
static void __wacom_notify_battery(struct wacom_battery *battery,
60
-
int bat_capacity, bool bat_charging,
61
-
bool bat_connected, bool ps_connected)
60
+
int bat_status, int bat_capacity,
61
+
bool bat_charging, bool bat_connected,
62
+
bool ps_connected)
62
63
{
63
-
bool changed = battery->battery_capacity != bat_capacity ||
64
+
bool changed = battery->bat_status != bat_status ||
65
+
battery->battery_capacity != bat_capacity ||
64
66
battery->bat_charging != bat_charging ||
65
67
battery->bat_connected != bat_connected ||
66
68
battery->ps_connected != ps_connected;
67
69
68
70
if (changed) {
71
+
battery->bat_status = bat_status;
69
72
battery->battery_capacity = bat_capacity;
70
73
battery->bat_charging = bat_charging;
71
74
battery->bat_connected = bat_connected;
···
80
77
}
81
78
82
79
static void wacom_notify_battery(struct wacom_wac *wacom_wac,
83
-
int bat_capacity, bool bat_charging, bool bat_connected,
84
-
bool ps_connected)
80
+
int bat_status, int bat_capacity, bool bat_charging,
81
+
bool bat_connected, bool ps_connected)
85
82
{
86
83
struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
87
84
88
-
__wacom_notify_battery(&wacom->battery, bat_capacity, bat_charging,
89
-
bat_connected, ps_connected);
85
+
__wacom_notify_battery(&wacom->battery, bat_status, bat_capacity,
86
+
bat_charging, bat_connected, ps_connected);
90
87
}
91
88
92
89
static int wacom_penpartner_irq(struct wacom_wac *wacom)
···
451
448
rw = (data[7] >> 2 & 0x07);
452
449
battery_capacity = batcap_gr[rw];
453
450
ps_connected = rw == 7;
454
-
wacom_notify_battery(wacom, battery_capacity, ps_connected,
455
-
1, ps_connected);
451
+
wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
452
+
battery_capacity, ps_connected, 1,
453
+
ps_connected);
456
454
}
457
455
exit:
458
456
return retval;
···
1075
1071
wacom->led.groups[i].select = touch_ring_mode;
1076
1072
}
1077
1073
1078
-
__wacom_notify_battery(&remote->remotes[index].battery, bat_percent,
1074
+
__wacom_notify_battery(&remote->remotes[index].battery,
1075
+
WACOM_POWER_SUPPLY_STATUS_AUTO, bat_percent,
1079
1076
bat_charging, 1, bat_charging);
1080
1077
1081
1078
out:
···
1162
1157
bat_charging = (power_raw & 0x08) ? 1 : 0;
1163
1158
ps_connected = (power_raw & 0x10) ? 1 : 0;
1164
1159
battery_capacity = batcap_i4[power_raw & 0x07];
1165
-
wacom_notify_battery(wacom, battery_capacity, bat_charging,
1160
+
wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
1161
+
battery_capacity, bat_charging,
1166
1162
battery_capacity || bat_charging,
1167
1163
ps_connected);
1168
1164
break;
···
1340
1334
bool chg = data[284] & 0x80;
1341
1335
int battery_status = data[284] & 0x7F;
1342
1336
1343
-
wacom_notify_battery(wacom, battery_status, chg, 1, chg);
1337
+
wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
1338
+
battery_status, chg, 1, chg);
1344
1339
}
1345
1340
1346
1341
static int wacom_intuos_pro2_bt_irq(struct wacom_wac *wacom, size_t len)
···
1703
1696
}
1704
1697
}
1705
1698
1699
+
static void wacom_wac_battery_usage_mapping(struct hid_device *hdev,
1700
+
struct hid_field *field, struct hid_usage *usage)
1701
+
{
1702
+
struct wacom *wacom = hid_get_drvdata(hdev);
1703
+
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1704
+
struct wacom_features *features = &wacom_wac->features;
1705
+
unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
1706
+
1707
+
switch (equivalent_usage) {
1708
+
case HID_DG_BATTERYSTRENGTH:
1709
+
case WACOM_HID_WD_BATTERY_LEVEL:
1710
+
case WACOM_HID_WD_BATTERY_CHARGING:
1711
+
features->quirks |= WACOM_QUIRK_BATTERY;
1712
+
break;
1713
+
}
1714
+
}
1715
+
1716
+
static void wacom_wac_battery_event(struct hid_device *hdev, struct hid_field *field,
1717
+
struct hid_usage *usage, __s32 value)
1718
+
{
1719
+
struct wacom *wacom = hid_get_drvdata(hdev);
1720
+
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1721
+
unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
1722
+
1723
+
switch (equivalent_usage) {
1724
+
case HID_DG_BATTERYSTRENGTH:
1725
+
if (value == 0) {
1726
+
wacom_wac->hid_data.bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
1727
+
}
1728
+
else {
1729
+
value = value * 100 / (field->logical_maximum - field->logical_minimum);
1730
+
wacom_wac->hid_data.battery_capacity = value;
1731
+
wacom_wac->hid_data.bat_connected = 1;
1732
+
wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
1733
+
}
1734
+
break;
1735
+
case WACOM_HID_WD_BATTERY_LEVEL:
1736
+
value = value * 100 / (field->logical_maximum - field->logical_minimum);
1737
+
wacom_wac->hid_data.battery_capacity = value;
1738
+
wacom_wac->hid_data.bat_connected = 1;
1739
+
wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
1740
+
break;
1741
+
case WACOM_HID_WD_BATTERY_CHARGING:
1742
+
wacom_wac->hid_data.bat_charging = value;
1743
+
wacom_wac->hid_data.ps_connected = value;
1744
+
wacom_wac->hid_data.bat_connected = 1;
1745
+
wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
1746
+
break;
1747
+
}
1748
+
}
1749
+
1750
+
static void wacom_wac_battery_pre_report(struct hid_device *hdev,
1751
+
struct hid_report *report)
1752
+
{
1753
+
return;
1754
+
}
1755
+
1756
+
static void wacom_wac_battery_report(struct hid_device *hdev,
1757
+
struct hid_report *report)
1758
+
{
1759
+
struct wacom *wacom = hid_get_drvdata(hdev);
1760
+
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1761
+
struct wacom_features *features = &wacom_wac->features;
1762
+
1763
+
if (features->quirks & WACOM_QUIRK_BATTERY) {
1764
+
int status = wacom_wac->hid_data.bat_status;
1765
+
int capacity = wacom_wac->hid_data.battery_capacity;
1766
+
bool charging = wacom_wac->hid_data.bat_charging;
1767
+
bool connected = wacom_wac->hid_data.bat_connected;
1768
+
bool powered = wacom_wac->hid_data.ps_connected;
1769
+
1770
+
wacom_notify_battery(wacom_wac, status, capacity, charging,
1771
+
connected, powered);
1772
+
}
1773
+
}
1774
+
1706
1775
static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
1707
1776
struct hid_field *field, struct hid_usage *usage)
1708
1777
{
···
1789
1706
unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
1790
1707
1791
1708
switch (equivalent_usage) {
1792
-
case WACOM_HID_WD_BATTERY_LEVEL:
1793
-
case WACOM_HID_WD_BATTERY_CHARGING:
1794
-
features->quirks |= WACOM_QUIRK_BATTERY;
1795
-
break;
1796
1709
case WACOM_HID_WD_ACCELEROMETER_X:
1797
1710
__set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
1798
1711
wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 0);
···
1882
1803
}
1883
1804
}
1884
1805
1885
-
static void wacom_wac_pad_battery_event(struct hid_device *hdev, struct hid_field *field,
1886
-
struct hid_usage *usage, __s32 value)
1887
-
{
1888
-
struct wacom *wacom = hid_get_drvdata(hdev);
1889
-
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1890
-
unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
1891
-
1892
-
switch (equivalent_usage) {
1893
-
case WACOM_HID_WD_BATTERY_LEVEL:
1894
-
wacom_wac->hid_data.battery_capacity = value;
1895
-
wacom_wac->hid_data.bat_connected = 1;
1896
-
break;
1897
-
1898
-
case WACOM_HID_WD_BATTERY_CHARGING:
1899
-
wacom_wac->hid_data.bat_charging = value;
1900
-
wacom_wac->hid_data.ps_connected = value;
1901
-
wacom_wac->hid_data.bat_connected = 1;
1902
-
break;
1903
-
}
1904
-
}
1905
-
1906
1806
static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
1907
1807
struct hid_usage *usage, __s32 value)
1908
1808
{
···
1955
1897
wacom_wac->hid_data.inrange_state = 0;
1956
1898
}
1957
1899
1958
-
static void wacom_wac_pad_battery_report(struct hid_device *hdev,
1959
-
struct hid_report *report)
1960
-
{
1961
-
struct wacom *wacom = hid_get_drvdata(hdev);
1962
-
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1963
-
struct wacom_features *features = &wacom_wac->features;
1964
-
1965
-
if (features->quirks & WACOM_QUIRK_BATTERY) {
1966
-
int capacity = wacom_wac->hid_data.battery_capacity;
1967
-
bool charging = wacom_wac->hid_data.bat_charging;
1968
-
bool connected = wacom_wac->hid_data.bat_connected;
1969
-
bool powered = wacom_wac->hid_data.ps_connected;
1970
-
1971
-
wacom_notify_battery(wacom_wac, capacity, charging,
1972
-
connected, powered);
1973
-
}
1974
-
}
1975
-
1976
1900
static void wacom_wac_pad_report(struct hid_device *hdev,
1977
1901
struct hid_report *report)
1978
1902
{
···
1999
1959
break;
2000
1960
case HID_DG_INRANGE:
2001
1961
wacom_map_usage(input, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
2002
-
break;
2003
-
case HID_DG_BATTERYSTRENGTH:
2004
-
features->quirks |= WACOM_QUIRK_BATTERY;
2005
1962
break;
2006
1963
case HID_DG_INVERT:
2007
1964
wacom_map_usage(input, usage, field, EV_KEY,
···
2072
2035
if (!(features->quirks & WACOM_QUIRK_SENSE))
2073
2036
wacom_wac->hid_data.sense_state = value;
2074
2037
return;
2075
-
case HID_DG_BATTERYSTRENGTH:
2076
-
wacom_wac->hid_data.battery_capacity = value;
2077
-
wacom_wac->hid_data.bat_connected = 1;
2078
-
break;
2079
2038
case HID_DG_INVERT:
2080
2039
wacom_wac->hid_data.invert_state = value;
2081
2040
return;
···
2110
2077
return;
2111
2078
case WACOM_HID_WD_OFFSETLEFT:
2112
2079
if (features->offset_left && value != features->offset_left)
2113
-
hid_warn(hdev, "%s: overriding exising left offset "
2080
+
hid_warn(hdev, "%s: overriding existing left offset "
2114
2081
"%d -> %d\n", __func__, value,
2115
2082
features->offset_left);
2116
2083
features->offset_left = value;
2117
2084
return;
2118
2085
case WACOM_HID_WD_OFFSETRIGHT:
2119
2086
if (features->offset_right && value != features->offset_right)
2120
-
hid_warn(hdev, "%s: overriding exising right offset "
2087
+
hid_warn(hdev, "%s: overriding existing right offset "
2121
2088
"%d -> %d\n", __func__, value,
2122
2089
features->offset_right);
2123
2090
features->offset_right = value;
2124
2091
return;
2125
2092
case WACOM_HID_WD_OFFSETTOP:
2126
2093
if (features->offset_top && value != features->offset_top)
2127
-
hid_warn(hdev, "%s: overriding exising top offset "
2094
+
hid_warn(hdev, "%s: overriding existing top offset "
2128
2095
"%d -> %d\n", __func__, value,
2129
2096
features->offset_top);
2130
2097
features->offset_top = value;
2131
2098
return;
2132
2099
case WACOM_HID_WD_OFFSETBOTTOM:
2133
2100
if (features->offset_bottom && value != features->offset_bottom)
2134
-
hid_warn(hdev, "%s: overriding exising bottom offset "
2101
+
hid_warn(hdev, "%s: overriding existing bottom offset "
2135
2102
"%d -> %d\n", __func__, value,
2136
2103
features->offset_bottom);
2137
2104
features->offset_bottom = value;
···
2428
2395
if (WACOM_DIRECT_DEVICE(field))
2429
2396
features->device_type |= WACOM_DEVICETYPE_DIRECT;
2430
2397
2431
-
if (WACOM_PAD_FIELD(field))
2398
+
/* usage tests must precede field tests */
2399
+
if (WACOM_BATTERY_USAGE(usage))
2400
+
wacom_wac_battery_usage_mapping(hdev, field, usage);
2401
+
else if (WACOM_PAD_FIELD(field))
2432
2402
wacom_wac_pad_usage_mapping(hdev, field, usage);
2433
2403
else if (WACOM_PEN_FIELD(field))
2434
2404
wacom_wac_pen_usage_mapping(hdev, field, usage);
···
2450
2414
if (value > field->logical_maximum || value < field->logical_minimum)
2451
2415
return;
2452
2416
2453
-
if (WACOM_PAD_FIELD(field)) {
2454
-
wacom_wac_pad_battery_event(hdev, field, usage, value);
2455
-
if (wacom->wacom_wac.pad_input)
2456
-
wacom_wac_pad_event(hdev, field, usage, value);
2457
-
} else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
2417
+
/* usage tests must precede field tests */
2418
+
if (WACOM_BATTERY_USAGE(usage))
2419
+
wacom_wac_battery_event(hdev, field, usage, value);
2420
+
else if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
2421
+
wacom_wac_pad_event(hdev, field, usage, value);
2422
+
else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
2458
2423
wacom_wac_pen_event(hdev, field, usage, value);
2459
2424
else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
2460
2425
wacom_wac_finger_event(hdev, field, usage, value);
···
2489
2452
if (wacom_wac->features.type != HID_GENERIC)
2490
2453
return;
2491
2454
2455
+
wacom_wac_battery_pre_report(hdev, report);
2456
+
2492
2457
if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
2493
2458
wacom_wac_pad_pre_report(hdev, report);
2494
2459
else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
···
2510
2471
if (report->type != HID_INPUT_REPORT)
2511
2472
return;
2512
2473
2513
-
if (WACOM_PAD_FIELD(field)) {
2514
-
wacom_wac_pad_battery_report(hdev, report);
2515
-
if (wacom->wacom_wac.pad_input)
2516
-
wacom_wac_pad_report(hdev, report);
2517
-
} else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
2474
+
wacom_wac_battery_report(hdev, report);
2475
+
2476
+
if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
2477
+
wacom_wac_pad_report(hdev, report);
2478
+
else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
2518
2479
wacom_wac_pen_report(hdev, report);
2519
2480
else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
2520
2481
wacom_wac_finger_report(hdev, report);
···
2852
2813
wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
2853
2814
}
2854
2815
2855
-
wacom_notify_battery(wacom, battery, charging, 1, 0);
2816
+
wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
2817
+
battery, charging, 1, 0);
2856
2818
2857
2819
} else if (wacom->pid != 0) {
2858
2820
/* disconnected while previously connected */
2859
2821
wacom->pid = 0;
2860
2822
wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
2861
-
wacom_notify_battery(wacom, 0, 0, 0, 0);
2823
+
wacom_notify_battery(wacom, POWER_SUPPLY_STATUS_UNKNOWN, 0, 0, 0, 0);
2862
2824
}
2863
2825
2864
2826
return 0;
···
2887
2847
int battery = (data[8] & 0x3f) * 100 / 31;
2888
2848
bool charging = !!(data[8] & 0x80);
2889
2849
2890
-
wacom_notify_battery(wacom_wac, battery, charging,
2891
-
battery || charging, 1);
2850
+
wacom_notify_battery(wacom_wac, WACOM_POWER_SUPPLY_STATUS_AUTO,
2851
+
battery, charging, battery || charging, 1);
2892
2852
2893
2853
if (!wacom->battery.battery &&
2894
2854
!(features->quirks & WACOM_QUIRK_BATTERY)) {
···
2900
2860
wacom->battery.battery) {
2901
2861
features->quirks &= ~WACOM_QUIRK_BATTERY;
2902
2862
wacom_schedule_work(wacom_wac, WACOM_WORKER_BATTERY);
2903
-
wacom_notify_battery(wacom_wac, 0, 0, 0, 0);
2863
+
wacom_notify_battery(wacom_wac, POWER_SUPPLY_STATUS_UNKNOWN, 0, 0, 0, 0);
2904
2864
}
2905
2865
return 0;
2906
2866
}
+7
drivers/hid/wacom_wac.h
+7
drivers/hid/wacom_wac.h
···
96
96
#define WACOM_DEVICETYPE_WL_MONITOR 0x0008
97
97
#define WACOM_DEVICETYPE_DIRECT 0x0010
98
98
99
+
#define WACOM_POWER_SUPPLY_STATUS_AUTO -1
100
+
99
101
#define WACOM_HID_UP_WACOMDIGITIZER 0xff0d0000
100
102
#define WACOM_HID_SP_PAD 0x00040000
101
103
#define WACOM_HID_SP_BUTTON 0x00090000
···
152
150
#define WACOM_HID_WT_CONTACTMAX (WACOM_HID_UP_WACOMTOUCH | 0x55)
153
151
#define WACOM_HID_WT_X (WACOM_HID_UP_WACOMTOUCH | 0x130)
154
152
#define WACOM_HID_WT_Y (WACOM_HID_UP_WACOMTOUCH | 0x131)
153
+
154
+
#define WACOM_BATTERY_USAGE(f) (((f)->hid == HID_DG_BATTERYSTRENGTH) || \
155
+
((f)->hid == WACOM_HID_WD_BATTERY_CHARGING) || \
156
+
((f)->hid == WACOM_HID_WD_BATTERY_LEVEL))
155
157
156
158
#define WACOM_PAD_FIELD(f) (((f)->physical == HID_DG_TABLETFUNCTIONKEY) || \
157
159
((f)->physical == WACOM_HID_WD_DIGITIZERFNKEYS) || \
···
303
297
int last_slot_field;
304
298
int num_expected;
305
299
int num_received;
300
+
int bat_status;
306
301
int battery_capacity;
307
302
int bat_charging;
308
303
int bat_connected;
+12
-27
drivers/staging/greybus/hid.c
+12
-27
drivers/staging/greybus/hid.c
···
32
32
char *inbuf;
33
33
};
34
34
35
-
static DEFINE_MUTEX(gb_hid_open_mutex);
36
-
37
35
/* Routines to get controller's information over greybus */
38
36
39
37
/* Operations performed on greybus */
···
344
346
static int gb_hid_open(struct hid_device *hid)
345
347
{
346
348
struct gb_hid *ghid = hid->driver_data;
347
-
int ret = 0;
349
+
int ret;
348
350
349
-
mutex_lock(&gb_hid_open_mutex);
350
-
if (!hid->open++) {
351
-
ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_ON);
352
-
if (ret < 0)
353
-
hid->open--;
354
-
else
355
-
set_bit(GB_HID_STARTED, &ghid->flags);
356
-
}
357
-
mutex_unlock(&gb_hid_open_mutex);
351
+
ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_ON);
352
+
if (ret < 0)
353
+
return ret;
358
354
359
-
return ret;
355
+
set_bit(GB_HID_STARTED, &ghid->flags);
356
+
return 0;
360
357
}
361
358
362
359
static void gb_hid_close(struct hid_device *hid)
···
359
366
struct gb_hid *ghid = hid->driver_data;
360
367
int ret;
361
368
362
-
/*
363
-
* Protecting hid->open to make sure we don't restart data acquistion
364
-
* due to a resumption we no longer care about..
365
-
*/
366
-
mutex_lock(&gb_hid_open_mutex);
367
-
if (!--hid->open) {
368
-
clear_bit(GB_HID_STARTED, &ghid->flags);
369
+
clear_bit(GB_HID_STARTED, &ghid->flags);
369
370
370
-
/* Save some power */
371
-
ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_OFF);
372
-
if (ret)
373
-
dev_err(&ghid->connection->bundle->dev,
374
-
"failed to power off (%d)\n", ret);
375
-
}
376
-
mutex_unlock(&gb_hid_open_mutex);
371
+
/* Save some power */
372
+
ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_OFF);
373
+
if (ret)
374
+
dev_err(&ghid->connection->bundle->dev,
375
+
"failed to power off (%d)\n", ret);
377
376
}
378
377
379
378
static int gb_hid_power(struct hid_device *hid, int lvl)
+18
-64
include/linux/hid.h
+18
-64
include/linux/hid.h
···
34
34
#include <linux/workqueue.h>
35
35
#include <linux/input.h>
36
36
#include <linux/semaphore.h>
37
+
#include <linux/mutex.h>
37
38
#include <linux/power_supply.h>
38
39
#include <uapi/linux/hid.h>
39
40
···
183
182
#define HID_GD_KEYBOARD 0x00010006
184
183
#define HID_GD_KEYPAD 0x00010007
185
184
#define HID_GD_MULTIAXIS 0x00010008
185
+
/*
186
+
* Microsoft Win8 Wireless Radio Controls extensions CA, see:
187
+
* http://www.usb.org/developers/hidpage/HUTRR40RadioHIDUsagesFinal.pdf
188
+
*/
189
+
#define HID_GD_WIRELESS_RADIO_CTLS 0x0001000c
186
190
#define HID_GD_X 0x00010030
187
191
#define HID_GD_Y 0x00010031
188
192
#define HID_GD_Z 0x00010032
···
216
210
#define HID_GD_DOWN 0x00010091
217
211
#define HID_GD_RIGHT 0x00010092
218
212
#define HID_GD_LEFT 0x00010093
213
+
/* Microsoft Win8 Wireless Radio Controls CA usage codes */
214
+
#define HID_GD_RFKILL_BTN 0x000100c6
215
+
#define HID_GD_RFKILL_LED 0x000100c7
216
+
#define HID_GD_RFKILL_SWITCH 0x000100c8
219
217
220
218
#define HID_DC_BATTERYSTRENGTH 0x00060020
221
219
···
530
520
struct semaphore driver_input_lock; /* protects the current driver */
531
521
struct device dev; /* device */
532
522
struct hid_driver *driver;
523
+
533
524
struct hid_ll_driver *ll_driver;
525
+
struct mutex ll_open_lock;
526
+
unsigned int ll_open_count;
534
527
535
528
#ifdef CONFIG_HID_BATTERY_STRENGTH
536
529
/*
···
557
544
void *hiddev; /* The hiddev structure */
558
545
void *hidraw;
559
546
560
-
int open; /* is the device open by anyone? */
561
547
char name[128]; /* Device name */
562
548
char phys[64]; /* Device physical location */
563
549
char uniq[64]; /* Device unique identifier (serial #) */
···
949
937
return hid_open_report(hdev);
950
938
}
951
939
952
-
/**
953
-
* hid_hw_start - start underlaying HW
954
-
*
955
-
* @hdev: hid device
956
-
* @connect_mask: which outputs to connect, see HID_CONNECT_*
957
-
*
958
-
* Call this in probe function *after* hid_parse. This will setup HW buffers
959
-
* and start the device (if not deffered to device open). hid_hw_stop must be
960
-
* called if this was successful.
961
-
*/
962
-
static inline int __must_check hid_hw_start(struct hid_device *hdev,
963
-
unsigned int connect_mask)
964
-
{
965
-
int ret = hdev->ll_driver->start(hdev);
966
-
if (ret || !connect_mask)
967
-
return ret;
968
-
ret = hid_connect(hdev, connect_mask);
969
-
if (ret)
970
-
hdev->ll_driver->stop(hdev);
971
-
return ret;
972
-
}
973
-
974
-
/**
975
-
* hid_hw_stop - stop underlaying HW
976
-
*
977
-
* @hdev: hid device
978
-
*
979
-
* This is usually called from remove function or from probe when something
980
-
* failed and hid_hw_start was called already.
981
-
*/
982
-
static inline void hid_hw_stop(struct hid_device *hdev)
983
-
{
984
-
hid_disconnect(hdev);
985
-
hdev->ll_driver->stop(hdev);
986
-
}
987
-
988
-
/**
989
-
* hid_hw_open - signal underlaying HW to start delivering events
990
-
*
991
-
* @hdev: hid device
992
-
*
993
-
* Tell underlying HW to start delivering events from the device.
994
-
* This function should be called sometime after successful call
995
-
* to hid_hiw_start().
996
-
*/
997
-
static inline int __must_check hid_hw_open(struct hid_device *hdev)
998
-
{
999
-
return hdev->ll_driver->open(hdev);
1000
-
}
1001
-
1002
-
/**
1003
-
* hid_hw_close - signal underlaying HW to stop delivering events
1004
-
*
1005
-
* @hdev: hid device
1006
-
*
1007
-
* This function indicates that we are not interested in the events
1008
-
* from this device anymore. Delivery of events may or may not stop,
1009
-
* depending on the number of users still outstanding.
1010
-
*/
1011
-
static inline void hid_hw_close(struct hid_device *hdev)
1012
-
{
1013
-
hdev->ll_driver->close(hdev);
1014
-
}
940
+
int __must_check hid_hw_start(struct hid_device *hdev,
941
+
unsigned int connect_mask);
942
+
void hid_hw_stop(struct hid_device *hdev);
943
+
int __must_check hid_hw_open(struct hid_device *hdev);
944
+
void hid_hw_close(struct hid_device *hdev);
1015
945
1016
946
/**
1017
947
* hid_hw_power - requests underlying HW to go into given power mode
include/linux/i2c/i2c-hid.h
include/linux/platform_data/i2c-hid.h
include/linux/i2c/i2c-hid.h
include/linux/platform_data/i2c-hid.h