summaryrefslogtreecommitdiffstats
path: root/drivers/hid/hid-sony.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/hid/hid-sony.c')
-rw-r--r--drivers/hid/hid-sony.c800
1 files changed, 704 insertions, 96 deletions
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
index 2f19b15f47f2..b3e82585309e 100644
--- a/drivers/hid/hid-sony.c
+++ b/drivers/hid/hid-sony.c
@@ -17,7 +17,8 @@
17 * any later version. 17 * any later version.
18 */ 18 */
19 19
20/* NOTE: in order for the Sony PS3 BD Remote Control to be found by 20/*
21 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
21 * a Bluetooth host, the key combination Start+Enter has to be kept pressed 22 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
22 * for about 7 seconds with the Bluetooth Host Controller in discovering mode. 23 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
23 * 24 *
@@ -28,8 +29,11 @@
28#include <linux/hid.h> 29#include <linux/hid.h>
29#include <linux/module.h> 30#include <linux/module.h>
30#include <linux/slab.h> 31#include <linux/slab.h>
31#include <linux/usb.h>
32#include <linux/leds.h> 32#include <linux/leds.h>
33#include <linux/power_supply.h>
34#include <linux/spinlock.h>
35#include <linux/list.h>
36#include <linux/input/mt.h>
33 37
34#include "hid-ids.h" 38#include "hid-ids.h"
35 39
@@ -41,8 +45,13 @@
41#define DUALSHOCK4_CONTROLLER_USB BIT(5) 45#define DUALSHOCK4_CONTROLLER_USB BIT(5)
42#define DUALSHOCK4_CONTROLLER_BT BIT(6) 46#define DUALSHOCK4_CONTROLLER_BT BIT(6)
43 47
44#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER_USB | BUZZ_CONTROLLER | DUALSHOCK4_CONTROLLER_USB) 48#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
45#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER_USB | DUALSHOCK4_CONTROLLER_USB) 49#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
50 DUALSHOCK4_CONTROLLER_BT)
51#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
52 DUALSHOCK4_CONTROLLER)
53#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
54#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
46 55
47#define MAX_LEDS 4 56#define MAX_LEDS 4
48 57
@@ -74,7 +83,8 @@ static const u8 sixaxis_rdesc_fixup2[] = {
74 0xb1, 0x02, 0xc0, 0xc0, 83 0xb1, 0x02, 0xc0, 0xc0,
75}; 84};
76 85
77/* The default descriptor doesn't provide mapping for the accelerometers 86/*
87 * The default descriptor doesn't provide mapping for the accelerometers
78 * or orientation sensors. This fixed descriptor maps the accelerometers 88 * or orientation sensors. This fixed descriptor maps the accelerometers
79 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors 89 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
80 * to usage values 0x43, 0x44 and 0x45. 90 * to usage values 0x43, 0x44 and 0x45.
@@ -333,6 +343,217 @@ static u8 dualshock4_usb_rdesc[] = {
333 0xC0 /* End Collection */ 343 0xC0 /* End Collection */
334}; 344};
335 345
346/*
347 * The default behavior of the Dualshock 4 is to send reports using report
348 * type 1 when running over Bluetooth. However, as soon as it receives a
349 * report of type 17 to set the LEDs or rumble it starts returning it's state
350 * in report 17 instead of 1. Since report 17 is undefined in the default HID
351 * descriptor the button and axis definitions must be moved to report 17 or
352 * the HID layer won't process the received input once a report is sent.
353 */
354static u8 dualshock4_bt_rdesc[] = {
355 0x05, 0x01, /* Usage Page (Desktop), */
356 0x09, 0x05, /* Usage (Gamepad), */
357 0xA1, 0x01, /* Collection (Application), */
358 0x85, 0x01, /* Report ID (1), */
359 0x75, 0x08, /* Report Size (8), */
360 0x95, 0x0A, /* Report Count (9), */
361 0x81, 0x02, /* Input (Variable), */
362 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
363 0x85, 0x02, /* Report ID (2), */
364 0x09, 0x24, /* Usage (24h), */
365 0x95, 0x24, /* Report Count (36), */
366 0xB1, 0x02, /* Feature (Variable), */
367 0x85, 0xA3, /* Report ID (163), */
368 0x09, 0x25, /* Usage (25h), */
369 0x95, 0x30, /* Report Count (48), */
370 0xB1, 0x02, /* Feature (Variable), */
371 0x85, 0x05, /* Report ID (5), */
372 0x09, 0x26, /* Usage (26h), */
373 0x95, 0x28, /* Report Count (40), */
374 0xB1, 0x02, /* Feature (Variable), */
375 0x85, 0x06, /* Report ID (6), */
376 0x09, 0x27, /* Usage (27h), */
377 0x95, 0x34, /* Report Count (52), */
378 0xB1, 0x02, /* Feature (Variable), */
379 0x85, 0x07, /* Report ID (7), */
380 0x09, 0x28, /* Usage (28h), */
381 0x95, 0x30, /* Report Count (48), */
382 0xB1, 0x02, /* Feature (Variable), */
383 0x85, 0x08, /* Report ID (8), */
384 0x09, 0x29, /* Usage (29h), */
385 0x95, 0x2F, /* Report Count (47), */
386 0xB1, 0x02, /* Feature (Variable), */
387 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
388 0x85, 0x03, /* Report ID (3), */
389 0x09, 0x21, /* Usage (21h), */
390 0x95, 0x26, /* Report Count (38), */
391 0xB1, 0x02, /* Feature (Variable), */
392 0x85, 0x04, /* Report ID (4), */
393 0x09, 0x22, /* Usage (22h), */
394 0x95, 0x2E, /* Report Count (46), */
395 0xB1, 0x02, /* Feature (Variable), */
396 0x85, 0xF0, /* Report ID (240), */
397 0x09, 0x47, /* Usage (47h), */
398 0x95, 0x3F, /* Report Count (63), */
399 0xB1, 0x02, /* Feature (Variable), */
400 0x85, 0xF1, /* Report ID (241), */
401 0x09, 0x48, /* Usage (48h), */
402 0x95, 0x3F, /* Report Count (63), */
403 0xB1, 0x02, /* Feature (Variable), */
404 0x85, 0xF2, /* Report ID (242), */
405 0x09, 0x49, /* Usage (49h), */
406 0x95, 0x0F, /* Report Count (15), */
407 0xB1, 0x02, /* Feature (Variable), */
408 0x85, 0x11, /* Report ID (17), */
409 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
410 0x09, 0x20, /* Usage (20h), */
411 0x95, 0x02, /* Report Count (2), */
412 0x81, 0x02, /* Input (Variable), */
413 0x05, 0x01, /* Usage Page (Desktop), */
414 0x09, 0x30, /* Usage (X), */
415 0x09, 0x31, /* Usage (Y), */
416 0x09, 0x32, /* Usage (Z), */
417 0x09, 0x35, /* Usage (Rz), */
418 0x15, 0x00, /* Logical Minimum (0), */
419 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
420 0x75, 0x08, /* Report Size (8), */
421 0x95, 0x04, /* Report Count (4), */
422 0x81, 0x02, /* Input (Variable), */
423 0x09, 0x39, /* Usage (Hat Switch), */
424 0x15, 0x00, /* Logical Minimum (0), */
425 0x25, 0x07, /* Logical Maximum (7), */
426 0x75, 0x04, /* Report Size (4), */
427 0x95, 0x01, /* Report Count (1), */
428 0x81, 0x42, /* Input (Variable, Null State), */
429 0x05, 0x09, /* Usage Page (Button), */
430 0x19, 0x01, /* Usage Minimum (01h), */
431 0x29, 0x0E, /* Usage Maximum (0Eh), */
432 0x15, 0x00, /* Logical Minimum (0), */
433 0x25, 0x01, /* Logical Maximum (1), */
434 0x75, 0x01, /* Report Size (1), */
435 0x95, 0x0E, /* Report Count (14), */
436 0x81, 0x02, /* Input (Variable), */
437 0x75, 0x06, /* Report Size (6), */
438 0x95, 0x01, /* Report Count (1), */
439 0x81, 0x01, /* Input (Constant), */
440 0x05, 0x01, /* Usage Page (Desktop), */
441 0x09, 0x33, /* Usage (Rx), */
442 0x09, 0x34, /* Usage (Ry), */
443 0x15, 0x00, /* Logical Minimum (0), */
444 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
445 0x75, 0x08, /* Report Size (8), */
446 0x95, 0x02, /* Report Count (2), */
447 0x81, 0x02, /* Input (Variable), */
448 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
449 0x09, 0x20, /* Usage (20h), */
450 0x95, 0x03, /* Report Count (3), */
451 0x81, 0x02, /* Input (Variable), */
452 0x05, 0x01, /* Usage Page (Desktop), */
453 0x19, 0x40, /* Usage Minimum (40h), */
454 0x29, 0x42, /* Usage Maximum (42h), */
455 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
456 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
457 0x75, 0x10, /* Report Size (16), */
458 0x95, 0x03, /* Report Count (3), */
459 0x81, 0x02, /* Input (Variable), */
460 0x19, 0x43, /* Usage Minimum (43h), */
461 0x29, 0x45, /* Usage Maximum (45h), */
462 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
463 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
464 0x95, 0x03, /* Report Count (3), */
465 0x81, 0x02, /* Input (Variable), */
466 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
467 0x09, 0x20, /* Usage (20h), */
468 0x15, 0x00, /* Logical Minimum (0), */
469 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
470 0x75, 0x08, /* Report Size (8), */
471 0x95, 0x31, /* Report Count (51), */
472 0x81, 0x02, /* Input (Variable), */
473 0x09, 0x21, /* Usage (21h), */
474 0x75, 0x08, /* Report Size (8), */
475 0x95, 0x4D, /* Report Count (77), */
476 0x91, 0x02, /* Output (Variable), */
477 0x85, 0x12, /* Report ID (18), */
478 0x09, 0x22, /* Usage (22h), */
479 0x95, 0x8D, /* Report Count (141), */
480 0x81, 0x02, /* Input (Variable), */
481 0x09, 0x23, /* Usage (23h), */
482 0x91, 0x02, /* Output (Variable), */
483 0x85, 0x13, /* Report ID (19), */
484 0x09, 0x24, /* Usage (24h), */
485 0x95, 0xCD, /* Report Count (205), */
486 0x81, 0x02, /* Input (Variable), */
487 0x09, 0x25, /* Usage (25h), */
488 0x91, 0x02, /* Output (Variable), */
489 0x85, 0x14, /* Report ID (20), */
490 0x09, 0x26, /* Usage (26h), */
491 0x96, 0x0D, 0x01, /* Report Count (269), */
492 0x81, 0x02, /* Input (Variable), */
493 0x09, 0x27, /* Usage (27h), */
494 0x91, 0x02, /* Output (Variable), */
495 0x85, 0x15, /* Report ID (21), */
496 0x09, 0x28, /* Usage (28h), */
497 0x96, 0x4D, 0x01, /* Report Count (333), */
498 0x81, 0x02, /* Input (Variable), */
499 0x09, 0x29, /* Usage (29h), */
500 0x91, 0x02, /* Output (Variable), */
501 0x85, 0x16, /* Report ID (22), */
502 0x09, 0x2A, /* Usage (2Ah), */
503 0x96, 0x8D, 0x01, /* Report Count (397), */
504 0x81, 0x02, /* Input (Variable), */
505 0x09, 0x2B, /* Usage (2Bh), */
506 0x91, 0x02, /* Output (Variable), */
507 0x85, 0x17, /* Report ID (23), */
508 0x09, 0x2C, /* Usage (2Ch), */
509 0x96, 0xCD, 0x01, /* Report Count (461), */
510 0x81, 0x02, /* Input (Variable), */
511 0x09, 0x2D, /* Usage (2Dh), */
512 0x91, 0x02, /* Output (Variable), */
513 0x85, 0x18, /* Report ID (24), */
514 0x09, 0x2E, /* Usage (2Eh), */
515 0x96, 0x0D, 0x02, /* Report Count (525), */
516 0x81, 0x02, /* Input (Variable), */
517 0x09, 0x2F, /* Usage (2Fh), */
518 0x91, 0x02, /* Output (Variable), */
519 0x85, 0x19, /* Report ID (25), */
520 0x09, 0x30, /* Usage (30h), */
521 0x96, 0x22, 0x02, /* Report Count (546), */
522 0x81, 0x02, /* Input (Variable), */
523 0x09, 0x31, /* Usage (31h), */
524 0x91, 0x02, /* Output (Variable), */
525 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
526 0x85, 0x82, /* Report ID (130), */
527 0x09, 0x22, /* Usage (22h), */
528 0x95, 0x3F, /* Report Count (63), */
529 0xB1, 0x02, /* Feature (Variable), */
530 0x85, 0x83, /* Report ID (131), */
531 0x09, 0x23, /* Usage (23h), */
532 0xB1, 0x02, /* Feature (Variable), */
533 0x85, 0x84, /* Report ID (132), */
534 0x09, 0x24, /* Usage (24h), */
535 0xB1, 0x02, /* Feature (Variable), */
536 0x85, 0x90, /* Report ID (144), */
537 0x09, 0x30, /* Usage (30h), */
538 0xB1, 0x02, /* Feature (Variable), */
539 0x85, 0x91, /* Report ID (145), */
540 0x09, 0x31, /* Usage (31h), */
541 0xB1, 0x02, /* Feature (Variable), */
542 0x85, 0x92, /* Report ID (146), */
543 0x09, 0x32, /* Usage (32h), */
544 0xB1, 0x02, /* Feature (Variable), */
545 0x85, 0x93, /* Report ID (147), */
546 0x09, 0x33, /* Usage (33h), */
547 0xB1, 0x02, /* Feature (Variable), */
548 0x85, 0xA0, /* Report ID (160), */
549 0x09, 0x40, /* Usage (40h), */
550 0xB1, 0x02, /* Feature (Variable), */
551 0x85, 0xA4, /* Report ID (164), */
552 0x09, 0x44, /* Usage (44h), */
553 0xB1, 0x02, /* Feature (Variable), */
554 0xC0 /* End Collection */
555};
556
336static __u8 ps3remote_rdesc[] = { 557static __u8 ps3remote_rdesc[] = {
337 0x05, 0x01, /* GUsagePage Generic Desktop */ 558 0x05, 0x01, /* GUsagePage Generic Desktop */
338 0x09, 0x05, /* LUsage 0x05 [Game Pad] */ 559 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
@@ -450,7 +671,8 @@ static const unsigned int ps3remote_keymap_remote_buttons[] = {
450}; 671};
451 672
452static const unsigned int buzz_keymap[] = { 673static const unsigned int buzz_keymap[] = {
453 /* The controller has 4 remote buzzers, each with one LED and 5 674 /*
675 * The controller has 4 remote buzzers, each with one LED and 5
454 * buttons. 676 * buttons.
455 * 677 *
456 * We use the mapping chosen by the controller, which is: 678 * We use the mapping chosen by the controller, which is:
@@ -488,19 +710,35 @@ static const unsigned int buzz_keymap[] = {
488 [20] = BTN_TRIGGER_HAPPY20, 710 [20] = BTN_TRIGGER_HAPPY20,
489}; 711};
490 712
713static enum power_supply_property sony_battery_props[] = {
714 POWER_SUPPLY_PROP_PRESENT,
715 POWER_SUPPLY_PROP_CAPACITY,
716 POWER_SUPPLY_PROP_SCOPE,
717 POWER_SUPPLY_PROP_STATUS,
718};
719
720static spinlock_t sony_dev_list_lock;
721static LIST_HEAD(sony_device_list);
722
491struct sony_sc { 723struct sony_sc {
724 spinlock_t lock;
725 struct list_head list_node;
492 struct hid_device *hdev; 726 struct hid_device *hdev;
493 struct led_classdev *leds[MAX_LEDS]; 727 struct led_classdev *leds[MAX_LEDS];
494 struct hid_report *output_report;
495 unsigned long quirks; 728 unsigned long quirks;
496 struct work_struct state_worker; 729 struct work_struct state_worker;
730 struct power_supply battery;
497 731
498#ifdef CONFIG_SONY_FF 732#ifdef CONFIG_SONY_FF
499 __u8 left; 733 __u8 left;
500 __u8 right; 734 __u8 right;
501#endif 735#endif
502 736
737 __u8 mac_address[6];
503 __u8 worker_initialized; 738 __u8 worker_initialized;
739 __u8 cable_state;
740 __u8 battery_charging;
741 __u8 battery_capacity;
504 __u8 led_state[MAX_LEDS]; 742 __u8 led_state[MAX_LEDS];
505 __u8 led_count; 743 __u8 led_count;
506}; 744};
@@ -578,6 +816,10 @@ static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
578 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n"); 816 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
579 rdesc = dualshock4_usb_rdesc; 817 rdesc = dualshock4_usb_rdesc;
580 *rsize = sizeof(dualshock4_usb_rdesc); 818 *rsize = sizeof(dualshock4_usb_rdesc);
819 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
820 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
821 rdesc = dualshock4_bt_rdesc;
822 *rsize = sizeof(dualshock4_bt_rdesc);
581 } 823 }
582 824
583 /* The HID descriptor exposed over BT has a trailing zero byte */ 825 /* The HID descriptor exposed over BT has a trailing zero byte */
@@ -601,20 +843,127 @@ static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
601 return rdesc; 843 return rdesc;
602} 844}
603 845
846static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
847{
848 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
849 unsigned long flags;
850 __u8 cable_state, battery_capacity, battery_charging;
851
852 /*
853 * The sixaxis is charging if the battery value is 0xee
854 * and it is fully charged if the value is 0xef.
855 * It does not report the actual level while charging so it
856 * is set to 100% while charging is in progress.
857 */
858 if (rd[30] >= 0xee) {
859 battery_capacity = 100;
860 battery_charging = !(rd[30] & 0x01);
861 } else {
862 __u8 index = rd[30] <= 5 ? rd[30] : 5;
863 battery_capacity = sixaxis_battery_capacity[index];
864 battery_charging = 0;
865 }
866 cable_state = !((rd[31] >> 4) & 0x01);
867
868 spin_lock_irqsave(&sc->lock, flags);
869 sc->cable_state = cable_state;
870 sc->battery_capacity = battery_capacity;
871 sc->battery_charging = battery_charging;
872 spin_unlock_irqrestore(&sc->lock, flags);
873}
874
875static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
876{
877 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
878 struct hid_input, list);
879 struct input_dev *input_dev = hidinput->input;
880 unsigned long flags;
881 int n, offset;
882 __u8 cable_state, battery_capacity, battery_charging;
883
884 /*
885 * Battery and touchpad data starts at byte 30 in the USB report and
886 * 32 in Bluetooth report.
887 */
888 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
889
890 /*
891 * The lower 4 bits of byte 30 contain the battery level
892 * and the 5th bit contains the USB cable state.
893 */
894 cable_state = (rd[offset] >> 4) & 0x01;
895 battery_capacity = rd[offset] & 0x0F;
896
897 /*
898 * When a USB power source is connected the battery level ranges from
899 * 0 to 10, and when running on battery power it ranges from 0 to 9.
900 * A battery level above 10 when plugged in means charge completed.
901 */
902 if (!cable_state || battery_capacity > 10)
903 battery_charging = 0;
904 else
905 battery_charging = 1;
906
907 if (!cable_state)
908 battery_capacity++;
909 if (battery_capacity > 10)
910 battery_capacity = 10;
911
912 battery_capacity *= 10;
913
914 spin_lock_irqsave(&sc->lock, flags);
915 sc->cable_state = cable_state;
916 sc->battery_capacity = battery_capacity;
917 sc->battery_charging = battery_charging;
918 spin_unlock_irqrestore(&sc->lock, flags);
919
920 offset += 5;
921
922 /*
923 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
924 * and 37 on Bluetooth.
925 * The first 7 bits of the first byte is a counter and bit 8 is a touch
926 * indicator that is 0 when pressed and 1 when not pressed.
927 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
928 * The data for the second touch is in the same format and immediatly
929 * follows the data for the first.
930 */
931 for (n = 0; n < 2; n++) {
932 __u16 x, y;
933
934 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
935 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
936
937 input_mt_slot(input_dev, n);
938 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
939 !(rd[offset] >> 7));
940 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
941 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
942
943 offset += 4;
944 }
945}
946
604static int sony_raw_event(struct hid_device *hdev, struct hid_report *report, 947static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
605 __u8 *rd, int size) 948 __u8 *rd, int size)
606{ 949{
607 struct sony_sc *sc = hid_get_drvdata(hdev); 950 struct sony_sc *sc = hid_get_drvdata(hdev);
608 951
609 /* Sixaxis HID report has acclerometers/gyro with MSByte first, this 952 /*
953 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
610 * has to be BYTE_SWAPPED before passing up to joystick interface 954 * has to be BYTE_SWAPPED before passing up to joystick interface
611 */ 955 */
612 if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) && 956 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
613 rd[0] == 0x01 && size == 49) {
614 swap(rd[41], rd[42]); 957 swap(rd[41], rd[42]);
615 swap(rd[43], rd[44]); 958 swap(rd[43], rd[44]);
616 swap(rd[45], rd[46]); 959 swap(rd[45], rd[46]);
617 swap(rd[47], rd[48]); 960 swap(rd[47], rd[48]);
961
962 sixaxis_parse_report(sc, rd, size);
963 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
964 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
965 && rd[0] == 0x11 && size == 78)) {
966 dualshock4_parse_report(sc, rd, size);
618 } 967 }
619 968
620 return 0; 969 return 0;
@@ -657,45 +1006,6 @@ static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
657} 1006}
658 1007
659/* 1008/*
660 * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
661 * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
662 * so we need to override that forcing HID Output Reports on the Control EP.
663 *
664 * There is also another issue about HID Output Reports via USB, the Sixaxis
665 * does not want the report_id as part of the data packet, so we have to
666 * discard buf[0] when sending the actual control message, even for numbered
667 * reports, humpf!
668 */
669static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
670 size_t count, unsigned char report_type)
671{
672 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
673 struct usb_device *dev = interface_to_usbdev(intf);
674 struct usb_host_interface *interface = intf->cur_altsetting;
675 int report_id = buf[0];
676 int ret;
677
678 if (report_type == HID_OUTPUT_REPORT) {
679 /* Don't send the Report ID */
680 buf++;
681 count--;
682 }
683
684 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
685 HID_REQ_SET_REPORT,
686 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
687 ((report_type + 1) << 8) | report_id,
688 interface->desc.bInterfaceNumber, buf, count,
689 USB_CTRL_SET_TIMEOUT);
690
691 /* Count also the Report ID, in case of an Output report. */
692 if (ret > 0 && report_type == HID_OUTPUT_REPORT)
693 ret++;
694
695 return ret;
696}
697
698/*
699 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller 1009 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
700 * to "operational". Without this, the ps3 controller will not report any 1010 * to "operational". Without this, the ps3 controller will not report any
701 * events. 1011 * events.
@@ -708,7 +1018,8 @@ static int sixaxis_set_operational_usb(struct hid_device *hdev)
708 if (!buf) 1018 if (!buf)
709 return -ENOMEM; 1019 return -ENOMEM;
710 1020
711 ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT); 1021 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1022 HID_REQ_GET_REPORT);
712 1023
713 if (ret < 0) 1024 if (ret < 0)
714 hid_err(hdev, "can't set operational mode\n"); 1025 hid_err(hdev, "can't set operational mode\n");
@@ -721,7 +1032,20 @@ static int sixaxis_set_operational_usb(struct hid_device *hdev)
721static int sixaxis_set_operational_bt(struct hid_device *hdev) 1032static int sixaxis_set_operational_bt(struct hid_device *hdev)
722{ 1033{
723 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 }; 1034 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
724 return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); 1035 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
1036 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1037}
1038
1039/*
1040 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1041 * controller so that it sends full input reports of type 0x11.
1042 */
1043static int dualshock4_set_operational_bt(struct hid_device *hdev)
1044{
1045 __u8 buf[37] = { 0 };
1046
1047 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf),
1048 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
725} 1049}
726 1050
727static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds) 1051static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
@@ -751,8 +1075,7 @@ static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
751 1075
752 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) { 1076 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
753 buzz_set_leds(hdev, leds); 1077 buzz_set_leds(hdev, leds);
754 } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) || 1078 } else {
755 (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
756 for (n = 0; n < count; n++) 1079 for (n = 0; n < count; n++)
757 drv_data->led_state[n] = leds[n]; 1080 drv_data->led_state[n] = leds[n];
758 schedule_work(&drv_data->state_worker); 1081 schedule_work(&drv_data->state_worker);
@@ -792,7 +1115,6 @@ static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
792 struct sony_sc *drv_data; 1115 struct sony_sc *drv_data;
793 1116
794 int n; 1117 int n;
795 int on = 0;
796 1118
797 drv_data = hid_get_drvdata(hdev); 1119 drv_data = hid_get_drvdata(hdev);
798 if (!drv_data) { 1120 if (!drv_data) {
@@ -801,13 +1123,11 @@ static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
801 } 1123 }
802 1124
803 for (n = 0; n < drv_data->led_count; n++) { 1125 for (n = 0; n < drv_data->led_count; n++) {
804 if (led == drv_data->leds[n]) { 1126 if (led == drv_data->leds[n])
805 on = !!(drv_data->led_state[n]); 1127 return drv_data->led_state[n];
806 break;
807 }
808 } 1128 }
809 1129
810 return on ? LED_FULL : LED_OFF; 1130 return LED_OFF;
811} 1131}
812 1132
813static void sony_leds_remove(struct hid_device *hdev) 1133static void sony_leds_remove(struct hid_device *hdev)
@@ -857,7 +1177,7 @@ static int sony_leds_init(struct hid_device *hdev)
857 /* Validate expected report characteristics. */ 1177 /* Validate expected report characteristics. */
858 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7)) 1178 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
859 return -ENODEV; 1179 return -ENODEV;
860 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) { 1180 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER) {
861 drv_data->led_count = 3; 1181 drv_data->led_count = 3;
862 max_brightness = 255; 1182 max_brightness = 255;
863 use_colors = 1; 1183 use_colors = 1;
@@ -871,9 +1191,11 @@ static int sony_leds_init(struct hid_device *hdev)
871 name_fmt = "%s::sony%d"; 1191 name_fmt = "%s::sony%d";
872 } 1192 }
873 1193
874 /* Clear LEDs as we have no way of reading their initial state. This is 1194 /*
1195 * Clear LEDs as we have no way of reading their initial state. This is
875 * only relevant if the driver is loaded after somebody actively set the 1196 * only relevant if the driver is loaded after somebody actively set the
876 * LEDs to on */ 1197 * LEDs to on
1198 */
877 sony_set_leds(hdev, initial_values, drv_data->led_count); 1199 sony_set_leds(hdev, initial_values, drv_data->led_count);
878 1200
879 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1; 1201 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
@@ -943,29 +1265,45 @@ static void sixaxis_state_worker(struct work_struct *work)
943 buf[10] |= sc->led_state[2] << 3; 1265 buf[10] |= sc->led_state[2] << 3;
944 buf[10] |= sc->led_state[3] << 4; 1266 buf[10] |= sc->led_state[3] << 4;
945 1267
946 sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf), 1268 hid_hw_raw_request(sc->hdev, 0x01, buf, sizeof(buf), HID_OUTPUT_REPORT,
947 HID_OUTPUT_REPORT); 1269 HID_REQ_SET_REPORT);
948} 1270}
949 1271
950static void dualshock4_state_worker(struct work_struct *work) 1272static void dualshock4_state_worker(struct work_struct *work)
951{ 1273{
952 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker); 1274 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
953 struct hid_device *hdev = sc->hdev; 1275 struct hid_device *hdev = sc->hdev;
954 struct hid_report *report = sc->output_report; 1276 int offset;
955 __s32 *value = report->field[0]->value; 1277
1278 __u8 buf[78] = { 0 };
956 1279
957 value[0] = 0x03; 1280 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1281 buf[0] = 0x05;
1282 buf[1] = 0x03;
1283 offset = 4;
1284 } else {
1285 buf[0] = 0x11;
1286 buf[1] = 0xB0;
1287 buf[3] = 0x0F;
1288 offset = 6;
1289 }
958 1290
959#ifdef CONFIG_SONY_FF 1291#ifdef CONFIG_SONY_FF
960 value[3] = sc->right; 1292 buf[offset++] = sc->right;
961 value[4] = sc->left; 1293 buf[offset++] = sc->left;
1294#else
1295 offset += 2;
962#endif 1296#endif
963 1297
964 value[5] = sc->led_state[0]; 1298 buf[offset++] = sc->led_state[0];
965 value[6] = sc->led_state[1]; 1299 buf[offset++] = sc->led_state[1];
966 value[7] = sc->led_state[2]; 1300 buf[offset++] = sc->led_state[2];
967 1301
968 hid_hw_request(hdev, report, HID_REQ_SET_REPORT); 1302 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1303 hid_hw_output_report(hdev, buf, 32);
1304 else
1305 hid_hw_raw_request(hdev, 0x11, buf, 78,
1306 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
969} 1307}
970 1308
971#ifdef CONFIG_SONY_FF 1309#ifdef CONFIG_SONY_FF
@@ -1000,35 +1338,247 @@ static int sony_init_ff(struct hid_device *hdev)
1000{ 1338{
1001 return 0; 1339 return 0;
1002} 1340}
1341
1003#endif 1342#endif
1004 1343
1005static int sony_set_output_report(struct sony_sc *sc, int req_id, int req_size) 1344static int sony_battery_get_property(struct power_supply *psy,
1345 enum power_supply_property psp,
1346 union power_supply_propval *val)
1347{
1348 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1349 unsigned long flags;
1350 int ret = 0;
1351 u8 battery_charging, battery_capacity, cable_state;
1352
1353 spin_lock_irqsave(&sc->lock, flags);
1354 battery_charging = sc->battery_charging;
1355 battery_capacity = sc->battery_capacity;
1356 cable_state = sc->cable_state;
1357 spin_unlock_irqrestore(&sc->lock, flags);
1358
1359 switch (psp) {
1360 case POWER_SUPPLY_PROP_PRESENT:
1361 val->intval = 1;
1362 break;
1363 case POWER_SUPPLY_PROP_SCOPE:
1364 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1365 break;
1366 case POWER_SUPPLY_PROP_CAPACITY:
1367 val->intval = battery_capacity;
1368 break;
1369 case POWER_SUPPLY_PROP_STATUS:
1370 if (battery_charging)
1371 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1372 else
1373 if (battery_capacity == 100 && cable_state)
1374 val->intval = POWER_SUPPLY_STATUS_FULL;
1375 else
1376 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1377 break;
1378 default:
1379 ret = -EINVAL;
1380 break;
1381 }
1382 return ret;
1383}
1384
1385static int sony_battery_probe(struct sony_sc *sc)
1006{ 1386{
1007 struct list_head *head, *list; 1387 static atomic_t power_id_seq = ATOMIC_INIT(0);
1008 struct hid_report *report; 1388 unsigned long power_id;
1009 struct hid_device *hdev = sc->hdev; 1389 struct hid_device *hdev = sc->hdev;
1390 int ret;
1010 1391
1011 list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list; 1392 /*
1393 * Set the default battery level to 100% to avoid low battery warnings
1394 * if the battery is polled before the first device report is received.
1395 */
1396 sc->battery_capacity = 100;
1397
1398 power_id = (unsigned long)atomic_inc_return(&power_id_seq);
1399
1400 sc->battery.properties = sony_battery_props;
1401 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1402 sc->battery.get_property = sony_battery_get_property;
1403 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1404 sc->battery.use_for_apm = 0;
1405 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%lu",
1406 power_id);
1407 if (!sc->battery.name)
1408 return -ENOMEM;
1012 1409
1013 list_for_each(head, list) { 1410 ret = power_supply_register(&hdev->dev, &sc->battery);
1014 report = list_entry(head, struct hid_report, list); 1411 if (ret) {
1412 hid_err(hdev, "Unable to register battery device\n");
1413 goto err_free;
1414 }
1015 1415
1016 if (report->id == req_id) { 1416 power_supply_powers(&sc->battery, &hdev->dev);
1017 if (report->size < req_size) { 1417 return 0;
1018 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n", 1418
1019 req_id, report->size, req_size); 1419err_free:
1020 return -EINVAL; 1420 kfree(sc->battery.name);
1021 } 1421 sc->battery.name = NULL;
1022 sc->output_report = report; 1422 return ret;
1023 return 0; 1423}
1424
1425static void sony_battery_remove(struct sony_sc *sc)
1426{
1427 if (!sc->battery.name)
1428 return;
1429
1430 power_supply_unregister(&sc->battery);
1431 kfree(sc->battery.name);
1432 sc->battery.name = NULL;
1433}
1434
1435static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1436 int w, int h)
1437{
1438 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1439 struct hid_input, list);
1440 struct input_dev *input_dev = hidinput->input;
1441 int ret;
1442
1443 ret = input_mt_init_slots(input_dev, touch_count, 0);
1444 if (ret < 0) {
1445 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1446 return ret;
1447 }
1448
1449 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1450 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1451
1452 return 0;
1453}
1454
1455/*
1456 * If a controller is plugged in via USB while already connected via Bluetooth
1457 * it will show up as two devices. A global list of connected controllers and
1458 * their MAC addresses is maintained to ensure that a device is only connected
1459 * once.
1460 */
1461static int sony_check_add_dev_list(struct sony_sc *sc)
1462{
1463 struct sony_sc *entry;
1464 unsigned long flags;
1465 int ret;
1466
1467 spin_lock_irqsave(&sony_dev_list_lock, flags);
1468
1469 list_for_each_entry(entry, &sony_device_list, list_node) {
1470 ret = memcmp(sc->mac_address, entry->mac_address,
1471 sizeof(sc->mac_address));
1472 if (!ret) {
1473 ret = -EEXIST;
1474 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1475 sc->mac_address);
1476 goto unlock;
1024 } 1477 }
1025 } 1478 }
1026 1479
1027 hid_err(hdev, "Unable to locate output report 0x%02x\n", req_id); 1480 ret = 0;
1481 list_add(&(sc->list_node), &sony_device_list);
1482
1483unlock:
1484 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1485 return ret;
1486}
1487
1488static void sony_remove_dev_list(struct sony_sc *sc)
1489{
1490 unsigned long flags;
1028 1491
1029 return -EINVAL; 1492 if (sc->list_node.next) {
1493 spin_lock_irqsave(&sony_dev_list_lock, flags);
1494 list_del(&(sc->list_node));
1495 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1496 }
1030} 1497}
1031 1498
1499static int sony_get_bt_devaddr(struct sony_sc *sc)
1500{
1501 int ret;
1502
1503 /* HIDP stores the device MAC address as a string in the uniq field. */
1504 ret = strlen(sc->hdev->uniq);
1505 if (ret != 17)
1506 return -EINVAL;
1507
1508 ret = sscanf(sc->hdev->uniq,
1509 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1510 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1511 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1512
1513 if (ret != 6)
1514 return -EINVAL;
1515
1516 return 0;
1517}
1518
1519static int sony_check_add(struct sony_sc *sc)
1520{
1521 int n, ret;
1522
1523 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1524 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1525 /*
1526 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1527 * address from the uniq string where HIDP stores it.
1528 * As uniq cannot be guaranteed to be a MAC address in all cases
1529 * a failure of this function should not prevent the connection.
1530 */
1531 if (sony_get_bt_devaddr(sc) < 0) {
1532 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1533 return 0;
1534 }
1535 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1536 __u8 buf[7];
1537
1538 /*
1539 * The MAC address of a DS4 controller connected via USB can be
1540 * retrieved with feature report 0x81. The address begins at
1541 * offset 1.
1542 */
1543 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1544 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1545
1546 if (ret != 7) {
1547 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1548 return ret < 0 ? ret : -EINVAL;
1549 }
1550
1551 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1552 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1553 __u8 buf[18];
1554
1555 /*
1556 * The MAC address of a Sixaxis controller connected via USB can
1557 * be retrieved with feature report 0xf2. The address begins at
1558 * offset 4.
1559 */
1560 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1561 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1562
1563 if (ret != 18) {
1564 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1565 return ret < 0 ? ret : -EINVAL;
1566 }
1567
1568 /*
1569 * The Sixaxis device MAC in the report is big-endian and must
1570 * be byte-swapped.
1571 */
1572 for (n = 0; n < 6; n++)
1573 sc->mac_address[5-n] = buf[4+n];
1574 } else {
1575 return 0;
1576 }
1577
1578 return sony_check_add_dev_list(sc);
1579}
1580
1581
1032static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) 1582static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1033{ 1583{
1034 int ret; 1584 int ret;
@@ -1066,17 +1616,38 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1066 } 1616 }
1067 1617
1068 if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 1618 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1069 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report; 1619 /*
1620 * The Sony Sixaxis does not handle HID Output Reports on the
1621 * Interrupt EP like it could, so we need to force HID Output
1622 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1623 *
1624 * There is also another issue about HID Output Reports via USB,
1625 * the Sixaxis does not want the report_id as part of the data
1626 * packet, so we have to discard buf[0] when sending the actual
1627 * control message, even for numbered reports, humpf!
1628 */
1629 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1630 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1070 ret = sixaxis_set_operational_usb(hdev); 1631 ret = sixaxis_set_operational_usb(hdev);
1071
1072 sc->worker_initialized = 1; 1632 sc->worker_initialized = 1;
1073 INIT_WORK(&sc->state_worker, sixaxis_state_worker); 1633 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1074 } 1634 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1075 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1076 ret = sixaxis_set_operational_bt(hdev); 1635 ret = sixaxis_set_operational_bt(hdev);
1077 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) { 1636 sc->worker_initialized = 1;
1078 /* Report 5 (31 bytes) is used to send data to the controller via USB */ 1637 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1079 ret = sony_set_output_report(sc, 0x05, 248); 1638 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1639 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1640 ret = dualshock4_set_operational_bt(hdev);
1641 if (ret < 0) {
1642 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1643 goto err_stop;
1644 }
1645 }
1646 /*
1647 * The Dualshock 4 touchpad supports 2 touches and has a
1648 * resolution of 1920x940.
1649 */
1650 ret = sony_register_touchpad(sc, 2, 1920, 940);
1080 if (ret < 0) 1651 if (ret < 0)
1081 goto err_stop; 1652 goto err_stop;
1082 1653
@@ -1089,6 +1660,10 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1089 if (ret < 0) 1660 if (ret < 0)
1090 goto err_stop; 1661 goto err_stop;
1091 1662
1663 ret = sony_check_add(sc);
1664 if (ret < 0)
1665 goto err_stop;
1666
1092 if (sc->quirks & SONY_LED_SUPPORT) { 1667 if (sc->quirks & SONY_LED_SUPPORT) {
1093 ret = sony_leds_init(hdev); 1668 ret = sony_leds_init(hdev);
1094 if (ret < 0) 1669 if (ret < 0)
@@ -1099,12 +1674,36 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1099 ret = sony_init_ff(hdev); 1674 ret = sony_init_ff(hdev);
1100 if (ret < 0) 1675 if (ret < 0)
1101 goto err_stop; 1676 goto err_stop;
1677 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1678 ret = sony_battery_probe(sc);
1679 if (ret < 0)
1680 goto err_stop;
1681
1682 /* Open the device to receive reports with battery info */
1683 ret = hid_hw_open(hdev);
1684 if (ret < 0) {
1685 hid_err(hdev, "hw open failed\n");
1686 goto err_stop;
1687 }
1688 }
1689
1690 if (sc->quirks & SONY_FF_SUPPORT) {
1691 ret = sony_init_ff(hdev);
1692 if (ret < 0)
1693 goto err_close;
1102 } 1694 }
1103 1695
1104 return 0; 1696 return 0;
1697err_close:
1698 hid_hw_close(hdev);
1105err_stop: 1699err_stop:
1106 if (sc->quirks & SONY_LED_SUPPORT) 1700 if (sc->quirks & SONY_LED_SUPPORT)
1107 sony_leds_remove(hdev); 1701 sony_leds_remove(hdev);
1702 if (sc->quirks & SONY_BATTERY_SUPPORT)
1703 sony_battery_remove(sc);
1704 if (sc->worker_initialized)
1705 cancel_work_sync(&sc->state_worker);
1706 sony_remove_dev_list(sc);
1108 hid_hw_stop(hdev); 1707 hid_hw_stop(hdev);
1109 return ret; 1708 return ret;
1110} 1709}
@@ -1118,6 +1717,15 @@ static void sony_remove(struct hid_device *hdev)
1118 1717
1119 if (sc->worker_initialized) 1718 if (sc->worker_initialized)
1120 cancel_work_sync(&sc->state_worker); 1719 cancel_work_sync(&sc->state_worker);
1720 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1721 hid_hw_close(hdev);
1722 sony_battery_remove(sc);
1723 }
1724
1725 if (sc->worker_initialized)
1726 cancel_work_sync(&sc->state_worker);
1727
1728 sony_remove_dev_list(sc);
1121 1729
1122 hid_hw_stop(hdev); 1730 hid_hw_stop(hdev);
1123} 1731}
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-09 12:05:52 -0500