2 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
4 * Copyright (c) 1999 Andreas Gal
5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7 * Copyright (c) 2008 Jiri Slaby
8 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
11 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the Free
17 * Software Foundation; either version 2 of the License, or (at your option)
22 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
23 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
24 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
26 * There will be no PIN request from the device.
29 #include <linux/device.h>
30 #include <linux/hid.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/leds.h>
34 #include <linux/power_supply.h>
35 #include <linux/spinlock.h>
36 #include <linux/list.h>
37 #include <linux/idr.h>
38 #include <linux/input/mt.h>
39 #include <linux/crc32.h>
40 #include <asm/unaligned.h>
44 #define VAIO_RDESC_CONSTANT BIT(0)
45 #define SIXAXIS_CONTROLLER_USB BIT(1)
46 #define SIXAXIS_CONTROLLER_BT BIT(2)
47 #define BUZZ_CONTROLLER BIT(3)
48 #define PS3REMOTE BIT(4)
49 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
50 #define DUALSHOCK4_CONTROLLER_BT BIT(6)
51 #define DUALSHOCK4_DONGLE BIT(7)
52 #define MOTION_CONTROLLER_USB BIT(8)
53 #define MOTION_CONTROLLER_BT BIT(9)
54 #define NAVIGATION_CONTROLLER_USB BIT(10)
55 #define NAVIGATION_CONTROLLER_BT BIT(11)
56 #define SINO_LITE_CONTROLLER BIT(12)
57 #define FUTUREMAX_DANCE_MAT BIT(13)
59 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
60 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
61 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
62 NAVIGATION_CONTROLLER_BT)
63 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
64 DUALSHOCK4_CONTROLLER_BT | \
66 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
67 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
68 NAVIGATION_CONTROLLER)
69 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
70 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
71 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
73 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
74 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
79 /* PS/3 Motion controller */
80 static u8 motion_rdesc[] = {
81 0x05, 0x01, /* Usage Page (Desktop), */
82 0x09, 0x04, /* Usage (Joystick), */
83 0xA1, 0x01, /* Collection (Application), */
84 0xA1, 0x02, /* Collection (Logical), */
85 0x85, 0x01, /* Report ID (1), */
86 0x75, 0x01, /* Report Size (1), */
87 0x95, 0x15, /* Report Count (21), */
88 0x15, 0x00, /* Logical Minimum (0), */
89 0x25, 0x01, /* Logical Maximum (1), */
90 0x35, 0x00, /* Physical Minimum (0), */
91 0x45, 0x01, /* Physical Maximum (1), */
92 0x05, 0x09, /* Usage Page (Button), */
93 0x19, 0x01, /* Usage Minimum (01h), */
94 0x29, 0x15, /* Usage Maximum (15h), */
95 0x81, 0x02, /* Input (Variable), * Buttons */
96 0x95, 0x0B, /* Report Count (11), */
97 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
98 0x81, 0x03, /* Input (Constant, Variable), * Padding */
99 0x15, 0x00, /* Logical Minimum (0), */
100 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
101 0x05, 0x01, /* Usage Page (Desktop), */
102 0xA1, 0x00, /* Collection (Physical), */
103 0x75, 0x08, /* Report Size (8), */
104 0x95, 0x01, /* Report Count (1), */
105 0x35, 0x00, /* Physical Minimum (0), */
106 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
107 0x09, 0x30, /* Usage (X), */
108 0x81, 0x02, /* Input (Variable), * Trigger */
109 0xC0, /* End Collection, */
110 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
111 0x75, 0x08, /* Report Size (8), */
112 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
113 0x81, 0x02, /* Input (Variable), */
114 0x05, 0x01, /* Usage Page (Desktop), */
115 0x75, 0x10, /* Report Size (16), */
116 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
117 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
118 0x95, 0x03, /* Report Count (3), * 3x Accels */
119 0x09, 0x33, /* Usage (rX), */
120 0x09, 0x34, /* Usage (rY), */
121 0x09, 0x35, /* Usage (rZ), */
122 0x81, 0x02, /* Input (Variable), */
123 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
124 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
125 0x81, 0x02, /* Input (Variable), */
126 0x05, 0x01, /* Usage Page (Desktop), */
127 0x09, 0x01, /* Usage (Pointer), */
128 0x95, 0x03, /* Report Count (3), * 3x Gyros */
129 0x81, 0x02, /* Input (Variable), */
130 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
131 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
132 0x81, 0x02, /* Input (Variable), */
133 0x75, 0x0C, /* Report Size (12), */
134 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
135 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
136 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
137 0x81, 0x02, /* Input (Variable), */
138 0x75, 0x08, /* Report Size (8), */
139 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
140 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
141 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
142 0x81, 0x02, /* Input (Variable), */
143 0x75, 0x08, /* Report Size (8), */
144 0x95, 0x30, /* Report Count (48), */
145 0x09, 0x01, /* Usage (Pointer), */
146 0x91, 0x02, /* Output (Variable), */
147 0x75, 0x08, /* Report Size (8), */
148 0x95, 0x30, /* Report Count (48), */
149 0x09, 0x01, /* Usage (Pointer), */
150 0xB1, 0x02, /* Feature (Variable), */
151 0xC0, /* End Collection, */
152 0xA1, 0x02, /* Collection (Logical), */
153 0x85, 0x02, /* Report ID (2), */
154 0x75, 0x08, /* Report Size (8), */
155 0x95, 0x30, /* Report Count (48), */
156 0x09, 0x01, /* Usage (Pointer), */
157 0xB1, 0x02, /* Feature (Variable), */
158 0xC0, /* End Collection, */
159 0xA1, 0x02, /* Collection (Logical), */
160 0x85, 0xEE, /* Report ID (238), */
161 0x75, 0x08, /* Report Size (8), */
162 0x95, 0x30, /* Report Count (48), */
163 0x09, 0x01, /* Usage (Pointer), */
164 0xB1, 0x02, /* Feature (Variable), */
165 0xC0, /* End Collection, */
166 0xA1, 0x02, /* Collection (Logical), */
167 0x85, 0xEF, /* Report ID (239), */
168 0x75, 0x08, /* Report Size (8), */
169 0x95, 0x30, /* Report Count (48), */
170 0x09, 0x01, /* Usage (Pointer), */
171 0xB1, 0x02, /* Feature (Variable), */
172 0xC0, /* End Collection, */
173 0xC0 /* End Collection */
176 static u8 ps3remote_rdesc[] = {
177 0x05, 0x01, /* GUsagePage Generic Desktop */
178 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
179 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
181 /* Use collection 1 for joypad buttons */
182 0xA1, 0x02, /* MCollection Logical (interrelated data) */
185 * Ignore the 1st byte, maybe it is used for a controller
186 * number but it's not needed for correct operation
188 0x75, 0x08, /* GReportSize 0x08 [8] */
189 0x95, 0x01, /* GReportCount 0x01 [1] */
190 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
193 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
194 * buttons multiple keypresses are allowed
196 0x05, 0x09, /* GUsagePage Button */
197 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
198 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
199 0x14, /* GLogicalMinimum [0] */
200 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
201 0x75, 0x01, /* GReportSize 0x01 [1] */
202 0x95, 0x18, /* GReportCount 0x18 [24] */
203 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
205 0xC0, /* MEndCollection */
207 /* Use collection 2 for remote control buttons */
208 0xA1, 0x02, /* MCollection Logical (interrelated data) */
210 /* 5th byte is used for remote control buttons */
211 0x05, 0x09, /* GUsagePage Button */
212 0x18, /* LUsageMinimum [No button pressed] */
213 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
214 0x14, /* GLogicalMinimum [0] */
215 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
216 0x75, 0x08, /* GReportSize 0x08 [8] */
217 0x95, 0x01, /* GReportCount 0x01 [1] */
221 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
222 * 0xff and 11th is for press indication
224 0x75, 0x08, /* GReportSize 0x08 [8] */
225 0x95, 0x06, /* GReportCount 0x06 [6] */
226 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
228 /* 12th byte is for battery strength */
229 0x05, 0x06, /* GUsagePage Generic Device Controls */
230 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
231 0x14, /* GLogicalMinimum [0] */
232 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
233 0x75, 0x08, /* GReportSize 0x08 [8] */
234 0x95, 0x01, /* GReportCount 0x01 [1] */
235 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
237 0xC0, /* MEndCollection */
239 0xC0 /* MEndCollection [Game Pad] */
242 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
244 [0x02] = BTN_THUMBL, /* L3 */
245 [0x03] = BTN_THUMBR, /* R3 */
251 [0x09] = BTN_TL2, /* L2 */
252 [0x0a] = BTN_TR2, /* R2 */
253 [0x0b] = BTN_TL, /* L1 */
254 [0x0c] = BTN_TR, /* R1 */
255 [0x0d] = KEY_OPTION, /* options/triangle */
256 [0x0e] = KEY_BACK, /* back/circle */
257 [0x0f] = BTN_0, /* cross */
258 [0x10] = KEY_SCREEN, /* view/square */
259 [0x11] = KEY_HOMEPAGE, /* PS button */
262 static const unsigned int ps3remote_keymap_remote_buttons[] = {
273 [0x0e] = KEY_ESC, /* return */
275 [0x16] = KEY_EJECTCD,
276 [0x1a] = KEY_MENU, /* top menu */
278 [0x30] = KEY_PREVIOUS,
281 [0x33] = KEY_REWIND, /* scan back */
282 [0x34] = KEY_FORWARD, /* scan forward */
285 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
286 [0x60] = KEY_FRAMEBACK, /* slow/step back */
287 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
288 [0x63] = KEY_SUBTITLE,
291 [0x70] = KEY_INFO, /* display */
298 static const unsigned int buzz_keymap[] = {
300 * The controller has 4 remote buzzers, each with one LED and 5
303 * We use the mapping chosen by the controller, which is:
306 * -------------------
313 * So, for example, the orange button on the third buzzer is mapped to
314 * BTN_TRIGGER_HAPPY14
316 [1] = BTN_TRIGGER_HAPPY1,
317 [2] = BTN_TRIGGER_HAPPY2,
318 [3] = BTN_TRIGGER_HAPPY3,
319 [4] = BTN_TRIGGER_HAPPY4,
320 [5] = BTN_TRIGGER_HAPPY5,
321 [6] = BTN_TRIGGER_HAPPY6,
322 [7] = BTN_TRIGGER_HAPPY7,
323 [8] = BTN_TRIGGER_HAPPY8,
324 [9] = BTN_TRIGGER_HAPPY9,
325 [10] = BTN_TRIGGER_HAPPY10,
326 [11] = BTN_TRIGGER_HAPPY11,
327 [12] = BTN_TRIGGER_HAPPY12,
328 [13] = BTN_TRIGGER_HAPPY13,
329 [14] = BTN_TRIGGER_HAPPY14,
330 [15] = BTN_TRIGGER_HAPPY15,
331 [16] = BTN_TRIGGER_HAPPY16,
332 [17] = BTN_TRIGGER_HAPPY17,
333 [18] = BTN_TRIGGER_HAPPY18,
334 [19] = BTN_TRIGGER_HAPPY19,
335 [20] = BTN_TRIGGER_HAPPY20,
338 /* The Navigation controller is a partial DS3 and uses the same HID report
339 * and hence the same keymap indices, however not not all axes/buttons
340 * are physically present. We use the same axis and button mapping as
341 * the DS3, which uses the Linux gamepad spec.
343 static const unsigned int navigation_absmap[] = {
346 [0x33] = ABS_Z, /* L2 */
349 /* Buttons not physically available on the device, but still available
350 * in the reports are explicitly set to 0 for documentation purposes.
352 static const unsigned int navigation_keymap[] = {
353 [0x01] = 0, /* Select */
354 [0x02] = BTN_THUMBL, /* L3 */
356 [0x04] = 0, /* Start */
357 [0x05] = BTN_DPAD_UP, /* Up */
358 [0x06] = BTN_DPAD_RIGHT, /* Right */
359 [0x07] = BTN_DPAD_DOWN, /* Down */
360 [0x08] = BTN_DPAD_LEFT, /* Left */
361 [0x09] = BTN_TL2, /* L2 */
363 [0x0b] = BTN_TL, /* L1 */
365 [0x0d] = BTN_NORTH, /* Triangle */
366 [0x0e] = BTN_EAST, /* Circle */
367 [0x0f] = BTN_SOUTH, /* Cross */
368 [0x10] = BTN_WEST, /* Square */
369 [0x11] = BTN_MODE, /* PS */
372 static const unsigned int sixaxis_absmap[] = {
375 [0x32] = ABS_RX, /* right stick X */
376 [0x35] = ABS_RY, /* right stick Y */
379 static const unsigned int sixaxis_keymap[] = {
380 [0x01] = BTN_SELECT, /* Select */
381 [0x02] = BTN_THUMBL, /* L3 */
382 [0x03] = BTN_THUMBR, /* R3 */
383 [0x04] = BTN_START, /* Start */
384 [0x05] = BTN_DPAD_UP, /* Up */
385 [0x06] = BTN_DPAD_RIGHT, /* Right */
386 [0x07] = BTN_DPAD_DOWN, /* Down */
387 [0x08] = BTN_DPAD_LEFT, /* Left */
388 [0x09] = BTN_TL2, /* L2 */
389 [0x0a] = BTN_TR2, /* R2 */
390 [0x0b] = BTN_TL, /* L1 */
391 [0x0c] = BTN_TR, /* R1 */
392 [0x0d] = BTN_NORTH, /* Triangle */
393 [0x0e] = BTN_EAST, /* Circle */
394 [0x0f] = BTN_SOUTH, /* Cross */
395 [0x10] = BTN_WEST, /* Square */
396 [0x11] = BTN_MODE, /* PS */
399 static const unsigned int ds4_absmap[] = {
402 [0x32] = ABS_RX, /* right stick X */
403 [0x33] = ABS_Z, /* L2 */
404 [0x34] = ABS_RZ, /* R2 */
405 [0x35] = ABS_RY, /* right stick Y */
408 static const unsigned int ds4_keymap[] = {
409 [0x1] = BTN_WEST, /* Square */
410 [0x2] = BTN_SOUTH, /* Cross */
411 [0x3] = BTN_EAST, /* Circle */
412 [0x4] = BTN_NORTH, /* Triangle */
413 [0x5] = BTN_TL, /* L1 */
414 [0x6] = BTN_TR, /* R1 */
415 [0x7] = BTN_TL2, /* L2 */
416 [0x8] = BTN_TR2, /* R2 */
417 [0x9] = BTN_SELECT, /* Share */
418 [0xa] = BTN_START, /* Options */
419 [0xb] = BTN_THUMBL, /* L3 */
420 [0xc] = BTN_THUMBR, /* R3 */
421 [0xd] = BTN_MODE, /* PS */
424 static const struct {int x; int y; } ds4_hat_mapping[] = {
425 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
429 static enum power_supply_property sony_battery_props[] = {
430 POWER_SUPPLY_PROP_PRESENT,
431 POWER_SUPPLY_PROP_CAPACITY,
432 POWER_SUPPLY_PROP_SCOPE,
433 POWER_SUPPLY_PROP_STATUS,
437 u8 time_enabled; /* the total time the led is active (0xff means forever) */
438 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
440 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
441 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
444 struct sixaxis_rumble {
446 u8 right_duration; /* Right motor duration (0xff means forever) */
447 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
448 u8 left_duration; /* Left motor duration (0xff means forever) */
449 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
452 struct sixaxis_output_report {
454 struct sixaxis_rumble rumble;
456 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
457 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
458 struct sixaxis_led _reserved; /* LED5, not actually soldered */
461 union sixaxis_output_report_01 {
462 struct sixaxis_output_report data;
466 struct motion_output_report_02 {
473 #define DS4_FEATURE_REPORT_0x02_SIZE 37
474 #define DS4_FEATURE_REPORT_0x05_SIZE 41
475 #define DS4_FEATURE_REPORT_0x81_SIZE 7
476 #define DS4_INPUT_REPORT_0x11_SIZE 78
477 #define DS4_OUTPUT_REPORT_0x05_SIZE 32
478 #define DS4_OUTPUT_REPORT_0x11_SIZE 78
479 #define SIXAXIS_REPORT_0xF2_SIZE 17
480 #define SIXAXIS_REPORT_0xF5_SIZE 8
481 #define MOTION_REPORT_0x02_SIZE 49
483 /* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
486 #define DS4_INPUT_REPORT_AXIS_OFFSET 1
487 #define DS4_INPUT_REPORT_BUTTON_OFFSET 5
488 #define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
489 #define DS4_INPUT_REPORT_GYRO_X_OFFSET 13
490 #define DS4_INPUT_REPORT_BATTERY_OFFSET 30
491 #define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
493 #define SENSOR_SUFFIX " Motion Sensors"
494 #define DS4_TOUCHPAD_SUFFIX " Touchpad"
496 /* Default to 4ms poll interval, which is same as USB (not adjustable). */
497 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
498 #define DS4_BT_MAX_POLL_INTERVAL_MS 62
499 #define DS4_GYRO_RES_PER_DEG_S 1024
500 #define DS4_ACC_RES_PER_G 8192
502 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
503 #define SIXAXIS_ACC_RES_PER_G 113
505 static DEFINE_SPINLOCK(sony_dev_list_lock);
506 static LIST_HEAD(sony_device_list);
507 static DEFINE_IDA(sony_device_id_allocator);
509 /* Used for calibration of DS4 accelerometer and gyro. */
510 struct ds4_calibration_data {
513 /* Calibration requires scaling against a sensitivity value, which is a
514 * float. Store sensitivity as a fraction to limit floating point
515 * calculations until final calibration.
521 enum ds4_dongle_state {
535 struct list_head list_node;
536 struct hid_device *hdev;
537 struct input_dev *touchpad;
538 struct input_dev *sensor_dev;
539 struct led_classdev *leds[MAX_LEDS];
540 unsigned long quirks;
541 struct work_struct hotplug_worker;
542 struct work_struct state_worker;
543 void (*send_output_report)(struct sony_sc *);
544 struct power_supply *battery;
545 struct power_supply_desc battery_desc;
547 u8 *output_report_dmabuf;
549 #ifdef CONFIG_SONY_FF
555 u8 hotplug_worker_initialized;
556 u8 state_worker_initialized;
557 u8 defer_initialization;
561 u8 led_state[MAX_LEDS];
562 u8 led_delay_on[MAX_LEDS];
563 u8 led_delay_off[MAX_LEDS];
566 bool timestamp_initialized;
568 unsigned int timestamp_us;
570 u8 ds4_bt_poll_interval;
571 enum ds4_dongle_state ds4_dongle_state;
572 /* DS4 calibration data */
573 struct ds4_calibration_data ds4_calib_data[6];
576 static void sony_set_leds(struct sony_sc *sc);
578 static inline void sony_schedule_work(struct sony_sc *sc,
579 enum sony_worker which)
584 case SONY_WORKER_STATE:
585 spin_lock_irqsave(&sc->lock, flags);
586 if (!sc->defer_initialization && sc->state_worker_initialized)
587 schedule_work(&sc->state_worker);
588 spin_unlock_irqrestore(&sc->lock, flags);
590 case SONY_WORKER_HOTPLUG:
591 if (sc->hotplug_worker_initialized)
592 schedule_work(&sc->hotplug_worker);
597 static ssize_t ds4_show_poll_interval(struct device *dev,
598 struct device_attribute
601 struct hid_device *hdev = to_hid_device(dev);
602 struct sony_sc *sc = hid_get_drvdata(hdev);
604 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
607 static ssize_t ds4_store_poll_interval(struct device *dev,
608 struct device_attribute *attr,
609 const char *buf, size_t count)
611 struct hid_device *hdev = to_hid_device(dev);
612 struct sony_sc *sc = hid_get_drvdata(hdev);
616 if (kstrtou8(buf, 0, &interval))
619 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
622 spin_lock_irqsave(&sc->lock, flags);
623 sc->ds4_bt_poll_interval = interval;
624 spin_unlock_irqrestore(&sc->lock, flags);
626 sony_schedule_work(sc, SONY_WORKER_STATE);
631 static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
632 ds4_store_poll_interval);
635 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
638 *rsize = sizeof(motion_rdesc);
642 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
645 *rsize = sizeof(ps3remote_rdesc);
646 return ps3remote_rdesc;
649 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
650 struct hid_field *field, struct hid_usage *usage,
651 unsigned long **bit, int *max)
653 unsigned int key = usage->hid & HID_USAGE;
655 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
658 switch (usage->collection_index) {
660 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
663 key = ps3remote_keymap_joypad_buttons[key];
668 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
671 key = ps3remote_keymap_remote_buttons[key];
679 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
683 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
684 struct hid_field *field, struct hid_usage *usage,
685 unsigned long **bit, int *max)
687 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
688 unsigned int key = usage->hid & HID_USAGE;
690 if (key >= ARRAY_SIZE(sixaxis_keymap))
693 key = navigation_keymap[key];
697 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
699 } else if (usage->hid == HID_GD_POINTER) {
700 /* See comment in sixaxis_mapping, basically the L2 (and R2)
701 * triggers are reported through GD Pointer.
702 * In addition we ignore any analog button 'axes' and only
703 * support digital buttons.
705 switch (usage->usage_index) {
707 usage->hid = HID_GD_Z;
713 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
715 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
716 unsigned int abs = usage->hid & HID_USAGE;
718 if (abs >= ARRAY_SIZE(navigation_absmap))
721 abs = navigation_absmap[abs];
723 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
731 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
732 struct hid_field *field, struct hid_usage *usage,
733 unsigned long **bit, int *max)
735 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
736 unsigned int key = usage->hid & HID_USAGE;
738 if (key >= ARRAY_SIZE(sixaxis_keymap))
741 key = sixaxis_keymap[key];
742 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
744 } else if (usage->hid == HID_GD_POINTER) {
745 /* The DS3 provides analog values for most buttons and even
746 * for HAT axes through GD Pointer. L2 and R2 are reported
747 * among these as well instead of as GD Z / RZ. Remap L2
748 * and R2 and ignore other analog 'button axes' as there is
749 * no good way for reporting them.
751 switch (usage->usage_index) {
753 usage->hid = HID_GD_Z;
756 usage->hid = HID_GD_RZ;
762 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
764 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
765 unsigned int abs = usage->hid & HID_USAGE;
767 if (abs >= ARRAY_SIZE(sixaxis_absmap))
770 abs = sixaxis_absmap[abs];
772 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
779 static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
780 struct hid_field *field, struct hid_usage *usage,
781 unsigned long **bit, int *max)
783 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
784 unsigned int key = usage->hid & HID_USAGE;
786 if (key >= ARRAY_SIZE(ds4_keymap))
789 key = ds4_keymap[key];
790 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
792 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
793 unsigned int abs = usage->hid & HID_USAGE;
795 /* Let the HID parser deal with the HAT. */
796 if (usage->hid == HID_GD_HATSWITCH)
799 if (abs >= ARRAY_SIZE(ds4_absmap))
802 abs = ds4_absmap[abs];
803 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
810 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
813 struct sony_sc *sc = hid_get_drvdata(hdev);
815 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
819 * Some Sony RF receivers wrongly declare the mouse pointer as a
820 * a constant non-data variable.
822 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
823 /* usage page: generic desktop controls */
824 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
826 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
827 /* input (usage page for x,y axes): constant, variable, relative */
828 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
829 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
830 /* input: data, variable, relative */
834 if (sc->quirks & MOTION_CONTROLLER)
835 return motion_fixup(hdev, rdesc, rsize);
837 if (sc->quirks & PS3REMOTE)
838 return ps3remote_fixup(hdev, rdesc, rsize);
841 * Some knock-off USB dongles incorrectly report their button count
842 * as 13 instead of 16 causing three non-functional buttons.
844 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
845 /* Report Count (13) */
846 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
847 /* Usage Maximum (13) */
848 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
849 /* Report Count (3) */
850 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
851 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
860 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
862 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
865 u8 cable_state, battery_capacity, battery_charging;
868 * The sixaxis is charging if the battery value is 0xee
869 * and it is fully charged if the value is 0xef.
870 * It does not report the actual level while charging so it
871 * is set to 100% while charging is in progress.
873 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
875 if (rd[offset] >= 0xee) {
876 battery_capacity = 100;
877 battery_charging = !(rd[offset] & 0x01);
880 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
881 battery_capacity = sixaxis_battery_capacity[index];
882 battery_charging = 0;
886 spin_lock_irqsave(&sc->lock, flags);
887 sc->cable_state = cable_state;
888 sc->battery_capacity = battery_capacity;
889 sc->battery_charging = battery_charging;
890 spin_unlock_irqrestore(&sc->lock, flags);
892 if (sc->quirks & SIXAXIS_CONTROLLER) {
895 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
896 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
897 input_report_abs(sc->sensor_dev, ABS_X, val);
899 /* Y and Z are swapped and inversed */
900 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
901 input_report_abs(sc->sensor_dev, ABS_Y, val);
903 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
904 input_report_abs(sc->sensor_dev, ABS_Z, val);
906 input_sync(sc->sensor_dev);
910 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
912 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
913 struct hid_input, list);
914 struct input_dev *input_dev = hidinput->input;
916 int n, m, offset, num_touch_data, max_touch_data;
917 u8 cable_state, battery_capacity, battery_charging;
920 /* When using Bluetooth the header is 2 bytes longer, so skip these. */
921 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
923 /* Second bit of third button byte is for the touchpad button. */
924 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
925 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
928 * The default behavior of the Dualshock 4 is to send reports using
929 * report type 1 when running over Bluetooth. However, when feature
930 * report 2 is requested during the controller initialization it starts
931 * sending input reports in report 17. Since report 17 is undefined
932 * in the default HID descriptor, the HID layer won't generate events.
933 * While it is possible (and this was done before) to fixup the HID
934 * descriptor to add this mapping, it was better to do this manually.
935 * The reason is there were various pieces software both open and closed
936 * source, relying on the descriptors to be the same across various
937 * operating systems. If the descriptors wouldn't match some
938 * applications e.g. games on Wine would not be able to function due
939 * to different descriptors, which such applications are not parsing.
944 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
945 input_report_abs(input_dev, ABS_X, rd[offset]);
946 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
947 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
948 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
950 value = rd[offset+4] & 0xf;
952 value = 8; /* Center 0, 0 */
953 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
954 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
956 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
957 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
958 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
959 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
961 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
962 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
963 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
964 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
965 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
966 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
967 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
968 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
970 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
972 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
973 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
975 input_sync(input_dev);
978 /* Convert timestamp (in 5.33us unit) to timestamp_us */
979 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
980 timestamp = get_unaligned_le16(&rd[offset]);
981 if (!sc->timestamp_initialized) {
982 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
983 sc->timestamp_initialized = true;
987 if (sc->prev_timestamp > timestamp)
988 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
990 delta = timestamp - sc->prev_timestamp;
991 sc->timestamp_us += (delta * 16) / 3;
993 sc->prev_timestamp = timestamp;
994 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
996 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
997 for (n = 0; n < 6; n++) {
998 /* Store data in int for more precision during mult_frac. */
999 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1000 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1002 /* High precision is needed during calibration, but the
1003 * calibrated values are within 32-bit.
1004 * Note: we swap numerator 'x' and 'numer' in mult_frac for
1005 * precision reasons so we don't need 64-bit.
1007 int calib_data = mult_frac(calib->sens_numer,
1008 raw_data - calib->bias,
1011 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1014 input_sync(sc->sensor_dev);
1017 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1018 * and the 5th bit contains the USB cable state.
1020 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1021 cable_state = (rd[offset] >> 4) & 0x01;
1022 battery_capacity = rd[offset] & 0x0F;
1025 * When a USB power source is connected the battery level ranges from
1026 * 0 to 10, and when running on battery power it ranges from 0 to 9.
1027 * A battery level above 10 when plugged in means charge completed.
1029 if (!cable_state || battery_capacity > 10)
1030 battery_charging = 0;
1032 battery_charging = 1;
1036 if (battery_capacity > 10)
1037 battery_capacity = 10;
1039 battery_capacity *= 10;
1041 spin_lock_irqsave(&sc->lock, flags);
1042 sc->cable_state = cable_state;
1043 sc->battery_capacity = battery_capacity;
1044 sc->battery_charging = battery_charging;
1045 spin_unlock_irqrestore(&sc->lock, flags);
1048 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1049 * and 35 on Bluetooth.
1050 * The first byte indicates the number of touch data in the report.
1051 * Trackpad data starts 2 bytes later (e.g. 35 for USB).
1053 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1054 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1055 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1056 num_touch_data = rd[offset];
1061 for (m = 0; m < num_touch_data; m++) {
1062 /* Skip past timestamp */
1066 * The first 7 bits of the first byte is a counter and bit 8 is
1067 * a touch indicator that is 0 when pressed and 1 when not
1069 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1070 * The data for the second touch is in the same format and
1071 * immediately follows the data for the first.
1073 for (n = 0; n < 2; n++) {
1077 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1078 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1080 active = !(rd[offset] >> 7);
1081 input_mt_slot(sc->touchpad, n);
1082 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1085 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1086 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1091 input_mt_sync_frame(sc->touchpad);
1092 input_sync(sc->touchpad);
1096 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1099 struct sony_sc *sc = hid_get_drvdata(hdev);
1102 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1103 * has to be BYTE_SWAPPED before passing up to joystick interface
1105 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1107 * When connected via Bluetooth the Sixaxis occasionally sends
1108 * a report with the second byte 0xff and the rest zeroed.
1110 * This report does not reflect the actual state of the
1111 * controller must be ignored to avoid generating false input
1117 swap(rd[41], rd[42]);
1118 swap(rd[43], rd[44]);
1119 swap(rd[45], rd[46]);
1120 swap(rd[47], rd[48]);
1122 sixaxis_parse_report(sc, rd, size);
1123 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1124 sixaxis_parse_report(sc, rd, size);
1125 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1127 sixaxis_parse_report(sc, rd, size);
1128 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1130 dualshock4_parse_report(sc, rd, size);
1131 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1138 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1139 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1140 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1141 if (crc != report_crc) {
1142 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1147 dualshock4_parse_report(sc, rd, size);
1148 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1150 unsigned long flags;
1151 enum ds4_dongle_state dongle_state;
1154 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1155 * if a DS4 is actually connected (indicated by '0').
1156 * For non-dongle, this bit is always 0 (connected).
1158 bool connected = (rd[31] & 0x04) ? false : true;
1160 spin_lock_irqsave(&sc->lock, flags);
1161 dongle_state = sc->ds4_dongle_state;
1162 spin_unlock_irqrestore(&sc->lock, flags);
1165 * The dongle always sends input reports even when no
1166 * DS4 is attached. When a DS4 is connected, we need to
1167 * obtain calibration data before we can use it.
1168 * The code below tracks dongle state and kicks of
1169 * calibration when needed and only allows us to process
1170 * input if a DS4 is actually connected.
1172 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1173 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1176 spin_lock_irqsave(&sc->lock, flags);
1177 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1178 spin_unlock_irqrestore(&sc->lock, flags);
1180 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1182 /* Don't process the report since we don't have
1183 * calibration data, but let hidraw have it anyway.
1186 } else if ((dongle_state == DONGLE_CONNECTED ||
1187 dongle_state == DONGLE_DISABLED) && !connected) {
1188 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1190 spin_lock_irqsave(&sc->lock, flags);
1191 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1192 spin_unlock_irqrestore(&sc->lock, flags);
1194 /* Return 0, so hidraw can get the report. */
1196 } else if (dongle_state == DONGLE_CALIBRATING ||
1197 dongle_state == DONGLE_DISABLED ||
1198 dongle_state == DONGLE_DISCONNECTED) {
1199 /* Return 0, so hidraw can get the report. */
1203 dualshock4_parse_report(sc, rd, size);
1206 if (sc->defer_initialization) {
1207 sc->defer_initialization = 0;
1208 sony_schedule_work(sc, SONY_WORKER_STATE);
1214 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1215 struct hid_field *field, struct hid_usage *usage,
1216 unsigned long **bit, int *max)
1218 struct sony_sc *sc = hid_get_drvdata(hdev);
1220 if (sc->quirks & BUZZ_CONTROLLER) {
1221 unsigned int key = usage->hid & HID_USAGE;
1223 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1226 switch (usage->collection_index) {
1228 if (key >= ARRAY_SIZE(buzz_keymap))
1231 key = buzz_keymap[key];
1239 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1243 if (sc->quirks & PS3REMOTE)
1244 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1246 if (sc->quirks & NAVIGATION_CONTROLLER)
1247 return navigation_mapping(hdev, hi, field, usage, bit, max);
1249 if (sc->quirks & SIXAXIS_CONTROLLER)
1250 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1252 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1253 return ds4_mapping(hdev, hi, field, usage, bit, max);
1256 /* Let hid-core decide for the others */
1260 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1267 sc->touchpad = input_allocate_device();
1271 input_set_drvdata(sc->touchpad, sc);
1272 sc->touchpad->dev.parent = &sc->hdev->dev;
1273 sc->touchpad->phys = sc->hdev->phys;
1274 sc->touchpad->uniq = sc->hdev->uniq;
1275 sc->touchpad->id.bustype = sc->hdev->bus;
1276 sc->touchpad->id.vendor = sc->hdev->vendor;
1277 sc->touchpad->id.product = sc->hdev->product;
1278 sc->touchpad->id.version = sc->hdev->version;
1280 /* Append a suffix to the controller name as there are various
1281 * DS4 compatible non-Sony devices with different names.
1283 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1284 name = kzalloc(name_sz, GFP_KERNEL);
1289 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1290 sc->touchpad->name = name;
1292 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1296 /* We map the button underneath the touchpad to BTN_LEFT. */
1297 __set_bit(EV_KEY, sc->touchpad->evbit);
1298 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1299 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1301 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1302 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1304 ret = input_register_device(sc->touchpad);
1311 kfree(sc->touchpad->name);
1312 sc->touchpad->name = NULL;
1314 input_free_device(sc->touchpad);
1315 sc->touchpad = NULL;
1320 static void sony_unregister_touchpad(struct sony_sc *sc)
1325 kfree(sc->touchpad->name);
1326 sc->touchpad->name = NULL;
1328 input_unregister_device(sc->touchpad);
1329 sc->touchpad = NULL;
1332 static int sony_register_sensors(struct sony_sc *sc)
1339 sc->sensor_dev = input_allocate_device();
1340 if (!sc->sensor_dev)
1343 input_set_drvdata(sc->sensor_dev, sc);
1344 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1345 sc->sensor_dev->phys = sc->hdev->phys;
1346 sc->sensor_dev->uniq = sc->hdev->uniq;
1347 sc->sensor_dev->id.bustype = sc->hdev->bus;
1348 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1349 sc->sensor_dev->id.product = sc->hdev->product;
1350 sc->sensor_dev->id.version = sc->hdev->version;
1352 /* Append a suffix to the controller name as there are various
1353 * DS4 compatible non-Sony devices with different names.
1355 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1356 name = kzalloc(name_sz, GFP_KERNEL);
1361 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1362 sc->sensor_dev->name = name;
1364 if (sc->quirks & SIXAXIS_CONTROLLER) {
1365 /* For the DS3 we only support the accelerometer, which works
1366 * quite well even without calibration. The device also has
1367 * a 1-axis gyro, but it is very difficult to manage from within
1368 * the driver even to get data, the sensor is inaccurate and
1369 * the behavior is very different between hardware revisions.
1371 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1372 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1373 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1374 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1375 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1376 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1377 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1378 range = DS4_ACC_RES_PER_G*4;
1379 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1380 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1381 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1382 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1383 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1384 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1386 range = DS4_GYRO_RES_PER_DEG_S*2048;
1387 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1388 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1389 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1390 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1391 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1392 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1394 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1395 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1398 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1400 ret = input_register_device(sc->sensor_dev);
1407 kfree(sc->sensor_dev->name);
1408 sc->sensor_dev->name = NULL;
1410 input_free_device(sc->sensor_dev);
1411 sc->sensor_dev = NULL;
1416 static void sony_unregister_sensors(struct sony_sc *sc)
1418 if (!sc->sensor_dev)
1421 kfree(sc->sensor_dev->name);
1422 sc->sensor_dev->name = NULL;
1424 input_unregister_device(sc->sensor_dev);
1425 sc->sensor_dev = NULL;
1430 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1431 * to "operational". Without this, the ps3 controller will not report any
1434 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1436 const int buf_size =
1437 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1441 buf = kmalloc(buf_size, GFP_KERNEL);
1445 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1446 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1448 hid_err(hdev, "can't set operational mode: step 1\n");
1453 * Some compatible controllers like the Speedlink Strike FX and
1454 * Gasia need another query plus an USB interrupt to get operational.
1456 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1457 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1459 hid_err(hdev, "can't set operational mode: step 2\n");
1463 ret = hid_hw_output_report(hdev, buf, 1);
1465 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1475 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1477 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1481 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1485 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1486 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1494 * Request DS4 calibration data for the motion sensors.
1495 * For Bluetooth this also affects the operating mode (see below).
1497 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1501 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1502 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1503 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1504 short gyro_speed_plus, gyro_speed_minus;
1505 short acc_x_plus, acc_x_minus;
1506 short acc_y_plus, acc_y_minus;
1507 short acc_z_plus, acc_z_minus;
1511 /* For Bluetooth we use a different request, which supports CRC.
1512 * Note: in Bluetooth mode feature report 0x02 also changes the state
1513 * of the controller, so that it sends input reports of type 0x11.
1515 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1516 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1520 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1521 DS4_FEATURE_REPORT_0x02_SIZE,
1523 HID_REQ_GET_REPORT);
1532 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1536 for (retries = 0; retries < 3; retries++) {
1537 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1538 DS4_FEATURE_REPORT_0x05_SIZE,
1540 HID_REQ_GET_REPORT);
1545 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1546 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1547 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1548 if (crc != report_crc) {
1549 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1552 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1564 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1565 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1566 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1567 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1568 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1569 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1570 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1571 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1572 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1573 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1576 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1577 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1578 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1579 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1580 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1581 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1583 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1584 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1585 acc_x_plus = get_unaligned_le16(&buf[23]);
1586 acc_x_minus = get_unaligned_le16(&buf[25]);
1587 acc_y_plus = get_unaligned_le16(&buf[27]);
1588 acc_y_minus = get_unaligned_le16(&buf[29]);
1589 acc_z_plus = get_unaligned_le16(&buf[31]);
1590 acc_z_minus = get_unaligned_le16(&buf[33]);
1592 /* Set gyroscope calibration and normalization parameters.
1593 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1595 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1596 sc->ds4_calib_data[0].abs_code = ABS_RX;
1597 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1598 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1599 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1601 sc->ds4_calib_data[1].abs_code = ABS_RY;
1602 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1603 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1604 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1606 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1607 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1608 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1609 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1611 /* Set accelerometer calibration and normalization parameters.
1612 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1614 range_2g = acc_x_plus - acc_x_minus;
1615 sc->ds4_calib_data[3].abs_code = ABS_X;
1616 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1617 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1618 sc->ds4_calib_data[3].sens_denom = range_2g;
1620 range_2g = acc_y_plus - acc_y_minus;
1621 sc->ds4_calib_data[4].abs_code = ABS_Y;
1622 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1623 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1624 sc->ds4_calib_data[4].sens_denom = range_2g;
1626 range_2g = acc_z_plus - acc_z_minus;
1627 sc->ds4_calib_data[5].abs_code = ABS_Z;
1628 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1629 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1630 sc->ds4_calib_data[5].sens_denom = range_2g;
1637 static void dualshock4_calibration_work(struct work_struct *work)
1639 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1640 unsigned long flags;
1641 enum ds4_dongle_state dongle_state;
1644 ret = dualshock4_get_calibration_data(sc);
1646 /* This call is very unlikely to fail for the dongle. When it
1647 * fails we are probably in a very bad state, so mark the
1648 * dongle as disabled. We will re-enable the dongle if a new
1649 * DS4 hotplug is detect from sony_raw_event as any issues
1650 * are likely resolved then (the dongle is quite stupid).
1652 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1653 dongle_state = DONGLE_DISABLED;
1655 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1656 dongle_state = DONGLE_CONNECTED;
1659 spin_lock_irqsave(&sc->lock, flags);
1660 sc->ds4_dongle_state = dongle_state;
1661 spin_unlock_irqrestore(&sc->lock, flags);
1664 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1666 static const u8 sixaxis_leds[10][4] = {
1667 { 0x01, 0x00, 0x00, 0x00 },
1668 { 0x00, 0x01, 0x00, 0x00 },
1669 { 0x00, 0x00, 0x01, 0x00 },
1670 { 0x00, 0x00, 0x00, 0x01 },
1671 { 0x01, 0x00, 0x00, 0x01 },
1672 { 0x00, 0x01, 0x00, 0x01 },
1673 { 0x00, 0x00, 0x01, 0x01 },
1674 { 0x01, 0x00, 0x01, 0x01 },
1675 { 0x00, 0x01, 0x01, 0x01 },
1676 { 0x01, 0x01, 0x01, 0x01 }
1679 int id = sc->device_id;
1681 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1687 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1690 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1692 /* The first 4 color/index entries match what the PS4 assigns */
1693 static const u8 color_code[7][3] = {
1694 /* Blue */ { 0x00, 0x00, 0x40 },
1695 /* Red */ { 0x40, 0x00, 0x00 },
1696 /* Green */ { 0x00, 0x40, 0x00 },
1697 /* Pink */ { 0x20, 0x00, 0x20 },
1698 /* Orange */ { 0x02, 0x01, 0x00 },
1699 /* Teal */ { 0x00, 0x01, 0x01 },
1700 /* White */ { 0x01, 0x01, 0x01 }
1703 int id = sc->device_id;
1705 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1711 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1714 static void buzz_set_leds(struct sony_sc *sc)
1716 struct hid_device *hdev = sc->hdev;
1717 struct list_head *report_list =
1718 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1719 struct hid_report *report = list_entry(report_list->next,
1720 struct hid_report, list);
1721 s32 *value = report->field[0]->value;
1723 BUILD_BUG_ON(MAX_LEDS < 4);
1726 value[1] = sc->led_state[0] ? 0xff : 0x00;
1727 value[2] = sc->led_state[1] ? 0xff : 0x00;
1728 value[3] = sc->led_state[2] ? 0xff : 0x00;
1729 value[4] = sc->led_state[3] ? 0xff : 0x00;
1732 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1735 static void sony_set_leds(struct sony_sc *sc)
1737 if (!(sc->quirks & BUZZ_CONTROLLER))
1738 sony_schedule_work(sc, SONY_WORKER_STATE);
1743 static void sony_led_set_brightness(struct led_classdev *led,
1744 enum led_brightness value)
1746 struct device *dev = led->dev->parent;
1747 struct hid_device *hdev = to_hid_device(dev);
1748 struct sony_sc *drv_data;
1753 drv_data = hid_get_drvdata(hdev);
1755 hid_err(hdev, "No device data\n");
1760 * The Sixaxis on USB will override any LED settings sent to it
1761 * and keep flashing all of the LEDs until the PS button is pressed.
1762 * Updates, even if redundant, must be always be sent to the
1763 * controller to avoid having to toggle the state of an LED just to
1764 * stop the flashing later on.
1766 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1768 for (n = 0; n < drv_data->led_count; n++) {
1769 if (led == drv_data->leds[n] && (force_update ||
1770 (value != drv_data->led_state[n] ||
1771 drv_data->led_delay_on[n] ||
1772 drv_data->led_delay_off[n]))) {
1774 drv_data->led_state[n] = value;
1776 /* Setting the brightness stops the blinking */
1777 drv_data->led_delay_on[n] = 0;
1778 drv_data->led_delay_off[n] = 0;
1780 sony_set_leds(drv_data);
1786 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1788 struct device *dev = led->dev->parent;
1789 struct hid_device *hdev = to_hid_device(dev);
1790 struct sony_sc *drv_data;
1794 drv_data = hid_get_drvdata(hdev);
1796 hid_err(hdev, "No device data\n");
1800 for (n = 0; n < drv_data->led_count; n++) {
1801 if (led == drv_data->leds[n])
1802 return drv_data->led_state[n];
1808 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1809 unsigned long *delay_off)
1811 struct device *dev = led->dev->parent;
1812 struct hid_device *hdev = to_hid_device(dev);
1813 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1818 hid_err(hdev, "No device data\n");
1822 /* Max delay is 255 deciseconds or 2550 milliseconds */
1823 if (*delay_on > 2550)
1825 if (*delay_off > 2550)
1828 /* Blink at 1 Hz if both values are zero */
1829 if (!*delay_on && !*delay_off)
1830 *delay_on = *delay_off = 500;
1832 new_on = *delay_on / 10;
1833 new_off = *delay_off / 10;
1835 for (n = 0; n < drv_data->led_count; n++) {
1836 if (led == drv_data->leds[n])
1840 /* This LED is not registered on this device */
1841 if (n >= drv_data->led_count)
1844 /* Don't schedule work if the values didn't change */
1845 if (new_on != drv_data->led_delay_on[n] ||
1846 new_off != drv_data->led_delay_off[n]) {
1847 drv_data->led_delay_on[n] = new_on;
1848 drv_data->led_delay_off[n] = new_off;
1849 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1855 static void sony_leds_remove(struct sony_sc *sc)
1857 struct led_classdev *led;
1860 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1862 for (n = 0; n < sc->led_count; n++) {
1867 led_classdev_unregister(led);
1874 static int sony_leds_init(struct sony_sc *sc)
1876 struct hid_device *hdev = sc->hdev;
1879 struct led_classdev *led;
1883 const char *name_fmt;
1884 static const char * const ds4_name_str[] = { "red", "green", "blue",
1886 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1887 u8 use_hw_blink[MAX_LEDS] = { 0 };
1889 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1891 if (sc->quirks & BUZZ_CONTROLLER) {
1894 name_len = strlen("::buzz#");
1895 name_fmt = "%s::buzz%d";
1896 /* Validate expected report characteristics. */
1897 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1899 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1900 dualshock4_set_leds_from_id(sc);
1901 sc->led_state[3] = 1;
1903 memset(max_brightness, 255, 3);
1904 use_hw_blink[3] = 1;
1908 } else if (sc->quirks & MOTION_CONTROLLER) {
1910 memset(max_brightness, 255, 3);
1914 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1915 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1917 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1919 memset(use_hw_blink, 1, 4);
1921 name_len = strlen("::sony#");
1922 name_fmt = "%s::sony%d";
1924 sixaxis_set_leds_from_id(sc);
1926 memset(use_hw_blink, 1, 4);
1928 name_len = strlen("::sony#");
1929 name_fmt = "%s::sony%d";
1933 * Clear LEDs as we have no way of reading their initial state. This is
1934 * only relevant if the driver is loaded after somebody actively set the
1939 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1941 for (n = 0; n < sc->led_count; n++) {
1944 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1946 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1948 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1953 name = (void *)(&led[1]);
1955 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1958 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1960 led->brightness = sc->led_state[n];
1961 led->max_brightness = max_brightness[n];
1962 led->flags = LED_CORE_SUSPENDRESUME;
1963 led->brightness_get = sony_led_get_brightness;
1964 led->brightness_set = sony_led_set_brightness;
1966 if (use_hw_blink[n])
1967 led->blink_set = sony_led_blink_set;
1971 ret = led_classdev_register(&hdev->dev, led);
1973 hid_err(hdev, "Failed to register LED %d\n", n);
1983 sony_leds_remove(sc);
1988 static void sixaxis_send_output_report(struct sony_sc *sc)
1990 static const union sixaxis_output_report_01 default_report = {
1993 0x01, 0xff, 0x00, 0xff, 0x00,
1994 0x00, 0x00, 0x00, 0x00, 0x00,
1995 0xff, 0x27, 0x10, 0x00, 0x32,
1996 0xff, 0x27, 0x10, 0x00, 0x32,
1997 0xff, 0x27, 0x10, 0x00, 0x32,
1998 0xff, 0x27, 0x10, 0x00, 0x32,
1999 0x00, 0x00, 0x00, 0x00, 0x00
2002 struct sixaxis_output_report *report =
2003 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2006 /* Initialize the report with default values */
2007 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2009 #ifdef CONFIG_SONY_FF
2010 report->rumble.right_motor_on = sc->right ? 1 : 0;
2011 report->rumble.left_motor_force = sc->left;
2014 report->leds_bitmap |= sc->led_state[0] << 1;
2015 report->leds_bitmap |= sc->led_state[1] << 2;
2016 report->leds_bitmap |= sc->led_state[2] << 3;
2017 report->leds_bitmap |= sc->led_state[3] << 4;
2019 /* Set flag for all leds off, required for 3rd party INTEC controller */
2020 if ((report->leds_bitmap & 0x1E) == 0)
2021 report->leds_bitmap |= 0x20;
2024 * The LEDs in the report are indexed in reverse order to their
2025 * corresponding light on the controller.
2026 * Index 0 = LED 4, index 1 = LED 3, etc...
2028 * In the case of both delay values being zero (blinking disabled) the
2029 * default report values should be used or the controller LED will be
2032 for (n = 0; n < 4; n++) {
2033 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2034 report->led[3 - n].duty_off = sc->led_delay_off[n];
2035 report->led[3 - n].duty_on = sc->led_delay_on[n];
2039 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2040 sizeof(struct sixaxis_output_report),
2041 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2044 static void dualshock4_send_output_report(struct sony_sc *sc)
2046 struct hid_device *hdev = sc->hdev;
2047 u8 *buf = sc->output_report_dmabuf;
2051 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2052 * control the interval at which Dualshock 4 reports data:
2059 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2060 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2062 buf[1] = 0x07; /* blink + LEDs + motor */
2065 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2067 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2068 buf[3] = 0x07; /* blink + LEDs + motor */
2072 #ifdef CONFIG_SONY_FF
2073 buf[offset++] = sc->right;
2074 buf[offset++] = sc->left;
2079 /* LED 3 is the global control */
2080 if (sc->led_state[3]) {
2081 buf[offset++] = sc->led_state[0];
2082 buf[offset++] = sc->led_state[1];
2083 buf[offset++] = sc->led_state[2];
2088 /* If both delay values are zero the DualShock 4 disables blinking. */
2089 buf[offset++] = sc->led_delay_on[3];
2090 buf[offset++] = sc->led_delay_off[3];
2092 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2093 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2095 /* CRC generation */
2099 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2100 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2101 put_unaligned_le32(crc, &buf[74]);
2102 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2106 static void motion_send_output_report(struct sony_sc *sc)
2108 struct hid_device *hdev = sc->hdev;
2109 struct motion_output_report_02 *report =
2110 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2112 memset(report, 0, MOTION_REPORT_0x02_SIZE);
2114 report->type = 0x02; /* set leds */
2115 report->r = sc->led_state[0];
2116 report->g = sc->led_state[1];
2117 report->b = sc->led_state[2];
2119 #ifdef CONFIG_SONY_FF
2120 report->rumble = max(sc->right, sc->left);
2123 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2126 static inline void sony_send_output_report(struct sony_sc *sc)
2128 if (sc->send_output_report)
2129 sc->send_output_report(sc);
2132 static void sony_state_worker(struct work_struct *work)
2134 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2136 sc->send_output_report(sc);
2139 static int sony_allocate_output_report(struct sony_sc *sc)
2141 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2142 (sc->quirks & NAVIGATION_CONTROLLER))
2143 sc->output_report_dmabuf =
2144 kmalloc(sizeof(union sixaxis_output_report_01),
2146 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2147 sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x11_SIZE,
2149 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2150 sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x05_SIZE,
2152 else if (sc->quirks & MOTION_CONTROLLER)
2153 sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
2158 if (!sc->output_report_dmabuf)
2164 #ifdef CONFIG_SONY_FF
2165 static int sony_play_effect(struct input_dev *dev, void *data,
2166 struct ff_effect *effect)
2168 struct hid_device *hid = input_get_drvdata(dev);
2169 struct sony_sc *sc = hid_get_drvdata(hid);
2171 if (effect->type != FF_RUMBLE)
2174 sc->left = effect->u.rumble.strong_magnitude / 256;
2175 sc->right = effect->u.rumble.weak_magnitude / 256;
2177 sony_schedule_work(sc, SONY_WORKER_STATE);
2181 static int sony_init_ff(struct sony_sc *sc)
2183 struct hid_input *hidinput;
2184 struct input_dev *input_dev;
2186 if (list_empty(&sc->hdev->inputs)) {
2187 hid_err(sc->hdev, "no inputs found\n");
2190 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2191 input_dev = hidinput->input;
2193 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2194 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2198 static int sony_init_ff(struct sony_sc *sc)
2205 static int sony_battery_get_property(struct power_supply *psy,
2206 enum power_supply_property psp,
2207 union power_supply_propval *val)
2209 struct sony_sc *sc = power_supply_get_drvdata(psy);
2210 unsigned long flags;
2212 u8 battery_charging, battery_capacity, cable_state;
2214 spin_lock_irqsave(&sc->lock, flags);
2215 battery_charging = sc->battery_charging;
2216 battery_capacity = sc->battery_capacity;
2217 cable_state = sc->cable_state;
2218 spin_unlock_irqrestore(&sc->lock, flags);
2221 case POWER_SUPPLY_PROP_PRESENT:
2224 case POWER_SUPPLY_PROP_SCOPE:
2225 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2227 case POWER_SUPPLY_PROP_CAPACITY:
2228 val->intval = battery_capacity;
2230 case POWER_SUPPLY_PROP_STATUS:
2231 if (battery_charging)
2232 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2234 if (battery_capacity == 100 && cable_state)
2235 val->intval = POWER_SUPPLY_STATUS_FULL;
2237 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2246 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2248 const char *battery_str_fmt = append_dev_id ?
2249 "sony_controller_battery_%pMR_%i" :
2250 "sony_controller_battery_%pMR";
2251 struct power_supply_config psy_cfg = { .drv_data = sc, };
2252 struct hid_device *hdev = sc->hdev;
2256 * Set the default battery level to 100% to avoid low battery warnings
2257 * if the battery is polled before the first device report is received.
2259 sc->battery_capacity = 100;
2261 sc->battery_desc.properties = sony_battery_props;
2262 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2263 sc->battery_desc.get_property = sony_battery_get_property;
2264 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2265 sc->battery_desc.use_for_apm = 0;
2266 sc->battery_desc.name = kasprintf(GFP_KERNEL, battery_str_fmt,
2267 sc->mac_address, sc->device_id);
2268 if (!sc->battery_desc.name)
2271 sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
2273 if (IS_ERR(sc->battery)) {
2274 ret = PTR_ERR(sc->battery);
2275 hid_err(hdev, "Unable to register battery device\n");
2279 power_supply_powers(sc->battery, &hdev->dev);
2283 kfree(sc->battery_desc.name);
2284 sc->battery_desc.name = NULL;
2288 static void sony_battery_remove(struct sony_sc *sc)
2290 if (!sc->battery_desc.name)
2293 power_supply_unregister(sc->battery);
2294 kfree(sc->battery_desc.name);
2295 sc->battery_desc.name = NULL;
2299 * If a controller is plugged in via USB while already connected via Bluetooth
2300 * it will show up as two devices. A global list of connected controllers and
2301 * their MAC addresses is maintained to ensure that a device is only connected
2304 * Some USB-only devices masquerade as Sixaxis controllers and all have the
2305 * same dummy Bluetooth address, so a comparison of the connection type is
2306 * required. Devices are only rejected in the case where two devices have
2307 * matching Bluetooth addresses on different bus types.
2309 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2310 struct sony_sc *sc1)
2312 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2313 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2315 return sc0_not_bt == sc1_not_bt;
2318 static int sony_check_add_dev_list(struct sony_sc *sc)
2320 struct sony_sc *entry;
2321 unsigned long flags;
2324 spin_lock_irqsave(&sony_dev_list_lock, flags);
2326 list_for_each_entry(entry, &sony_device_list, list_node) {
2327 ret = memcmp(sc->mac_address, entry->mac_address,
2328 sizeof(sc->mac_address));
2330 if (sony_compare_connection_type(sc, entry)) {
2335 "controller with MAC address %pMR already connected\n",
2343 list_add(&(sc->list_node), &sony_device_list);
2346 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2350 static void sony_remove_dev_list(struct sony_sc *sc)
2352 unsigned long flags;
2354 if (sc->list_node.next) {
2355 spin_lock_irqsave(&sony_dev_list_lock, flags);
2356 list_del(&(sc->list_node));
2357 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2361 static int sony_get_bt_devaddr(struct sony_sc *sc)
2365 /* HIDP stores the device MAC address as a string in the uniq field. */
2366 ret = strlen(sc->hdev->uniq);
2370 ret = sscanf(sc->hdev->uniq,
2371 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2372 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2373 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2381 static int sony_check_add(struct sony_sc *sc)
2386 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2387 (sc->quirks & MOTION_CONTROLLER_BT) ||
2388 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2389 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2391 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2392 * address from the uniq string where HIDP stores it.
2393 * As uniq cannot be guaranteed to be a MAC address in all cases
2394 * a failure of this function should not prevent the connection.
2396 if (sony_get_bt_devaddr(sc) < 0) {
2397 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2400 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2401 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2406 * The MAC address of a DS4 controller connected via USB can be
2407 * retrieved with feature report 0x81. The address begins at
2410 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2411 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2412 HID_REQ_GET_REPORT);
2414 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2415 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2416 ret = ret < 0 ? ret : -EINVAL;
2420 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2422 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2423 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2424 sc->mac_address[5], sc->mac_address[4],
2425 sc->mac_address[3], sc->mac_address[2],
2426 sc->mac_address[1], sc->mac_address[0]);
2427 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2428 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2429 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2434 * The MAC address of a Sixaxis controller connected via USB can
2435 * be retrieved with feature report 0xf2. The address begins at
2438 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2439 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2440 HID_REQ_GET_REPORT);
2442 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2443 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2444 ret = ret < 0 ? ret : -EINVAL;
2449 * The Sixaxis device MAC in the report is big-endian and must
2452 for (n = 0; n < 6; n++)
2453 sc->mac_address[5-n] = buf[4+n];
2455 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2456 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2457 sc->mac_address[5], sc->mac_address[4],
2458 sc->mac_address[3], sc->mac_address[2],
2459 sc->mac_address[1], sc->mac_address[0]);
2464 ret = sony_check_add_dev_list(sc);
2473 static int sony_set_device_id(struct sony_sc *sc)
2478 * Only DualShock 4 or Sixaxis controllers get an id.
2479 * All others are set to -1.
2481 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2482 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2483 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2489 sc->device_id = ret;
2497 static void sony_release_device_id(struct sony_sc *sc)
2499 if (sc->device_id >= 0) {
2500 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2505 static inline void sony_init_output_report(struct sony_sc *sc,
2506 void (*send_output_report)(struct sony_sc *))
2508 sc->send_output_report = send_output_report;
2510 if (!sc->state_worker_initialized)
2511 INIT_WORK(&sc->state_worker, sony_state_worker);
2513 sc->state_worker_initialized = 1;
2516 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2518 unsigned long flags;
2520 if (sc->hotplug_worker_initialized)
2521 cancel_work_sync(&sc->hotplug_worker);
2522 if (sc->state_worker_initialized) {
2523 spin_lock_irqsave(&sc->lock, flags);
2524 sc->state_worker_initialized = 0;
2525 spin_unlock_irqrestore(&sc->lock, flags);
2526 cancel_work_sync(&sc->state_worker);
2530 static int sony_input_configured(struct hid_device *hdev,
2531 struct hid_input *hidinput)
2533 struct sony_sc *sc = hid_get_drvdata(hdev);
2537 ret = sony_set_device_id(sc);
2539 hid_err(hdev, "failed to allocate the device id\n");
2543 ret = append_dev_id = sony_check_add(sc);
2547 ret = sony_allocate_output_report(sc);
2549 hid_err(hdev, "failed to allocate the output report buffer\n");
2553 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2555 * The Sony Sixaxis does not handle HID Output Reports on the
2556 * Interrupt EP like it could, so we need to force HID Output
2557 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2559 * There is also another issue about HID Output Reports via USB,
2560 * the Sixaxis does not want the report_id as part of the data
2561 * packet, so we have to discard buf[0] when sending the actual
2562 * control message, even for numbered reports, humpf!
2564 * Additionally, the Sixaxis on USB isn't properly initialized
2565 * until the PS logo button is pressed and as such won't retain
2566 * any state set by an output report, so the initial
2567 * configuration report is deferred until the first input
2570 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2571 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2572 sc->defer_initialization = 1;
2574 ret = sixaxis_set_operational_usb(hdev);
2576 hid_err(hdev, "Failed to set controller into operational mode\n");
2580 sony_init_output_report(sc, sixaxis_send_output_report);
2581 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2583 * The Navigation controller wants output reports sent on the ctrl
2584 * endpoint when connected via Bluetooth.
2586 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2588 ret = sixaxis_set_operational_bt(hdev);
2590 hid_err(hdev, "Failed to set controller into operational mode\n");
2594 sony_init_output_report(sc, sixaxis_send_output_report);
2595 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2597 * The Sony Sixaxis does not handle HID Output Reports on the
2598 * Interrupt EP and the device only becomes active when the
2599 * PS button is pressed. See comment for Navigation controller
2600 * above for more details.
2602 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2603 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2604 sc->defer_initialization = 1;
2606 ret = sixaxis_set_operational_usb(hdev);
2608 hid_err(hdev, "Failed to set controller into operational mode\n");
2612 ret = sony_register_sensors(sc);
2615 "Unable to initialize motion sensors: %d\n", ret);
2619 sony_init_output_report(sc, sixaxis_send_output_report);
2620 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2622 * The Sixaxis wants output reports sent on the ctrl endpoint
2623 * when connected via Bluetooth.
2625 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2627 ret = sixaxis_set_operational_bt(hdev);
2629 hid_err(hdev, "Failed to set controller into operational mode\n");
2633 ret = sony_register_sensors(sc);
2636 "Unable to initialize motion sensors: %d\n", ret);
2640 sony_init_output_report(sc, sixaxis_send_output_report);
2641 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2642 ret = dualshock4_get_calibration_data(sc);
2644 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2649 * The Dualshock 4 touchpad supports 2 touches and has a
2650 * resolution of 1920x942 (44.86 dots/mm).
2652 ret = sony_register_touchpad(sc, 2, 1920, 942);
2655 "Unable to initialize multi-touch slots: %d\n",
2660 ret = sony_register_sensors(sc);
2663 "Unable to initialize motion sensors: %d\n", ret);
2667 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2668 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2669 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2672 "can't create sysfs bt_poll_interval attribute err: %d\n",
2676 if (sc->quirks & DUALSHOCK4_DONGLE) {
2677 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2678 sc->hotplug_worker_initialized = 1;
2679 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2682 sony_init_output_report(sc, dualshock4_send_output_report);
2683 } else if (sc->quirks & MOTION_CONTROLLER) {
2684 sony_init_output_report(sc, motion_send_output_report);
2689 if (sc->quirks & SONY_LED_SUPPORT) {
2690 ret = sony_leds_init(sc);
2695 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2696 ret = sony_battery_probe(sc, append_dev_id);
2700 /* Open the device to receive reports with battery info */
2701 ret = hid_hw_open(hdev);
2703 hid_err(hdev, "hw open failed\n");
2708 if (sc->quirks & SONY_FF_SUPPORT) {
2709 ret = sony_init_ff(sc);
2718 /* Piggy back on the default ds4_bt_ poll_interval to determine
2719 * if we need to remove the file as we don't know for sure if we
2720 * executed that logic.
2722 if (sc->ds4_bt_poll_interval)
2723 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2724 if (sc->quirks & SONY_LED_SUPPORT)
2725 sony_leds_remove(sc);
2726 if (sc->quirks & SONY_BATTERY_SUPPORT)
2727 sony_battery_remove(sc);
2729 sony_unregister_touchpad(sc);
2731 sony_unregister_sensors(sc);
2732 sony_cancel_work_sync(sc);
2733 kfree(sc->output_report_dmabuf);
2734 sony_remove_dev_list(sc);
2735 sony_release_device_id(sc);
2739 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2742 unsigned long quirks = id->driver_data;
2744 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2746 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2747 quirks |= FUTUREMAX_DANCE_MAT;
2749 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2751 hid_err(hdev, "can't alloc sony descriptor\n");
2755 spin_lock_init(&sc->lock);
2757 sc->quirks = quirks;
2758 hid_set_drvdata(hdev, sc);
2761 ret = hid_parse(hdev);
2763 hid_err(hdev, "parse failed\n");
2767 if (sc->quirks & VAIO_RDESC_CONSTANT)
2768 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2769 else if (sc->quirks & SIXAXIS_CONTROLLER)
2770 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2772 /* Patch the hw version on DS3/4 compatible devices, so applications can
2773 * distinguish between the default HID mappings and the mappings defined
2774 * by the Linux game controller spec. This is important for the SDL2
2775 * library, which has a game controller database, which uses device ids
2776 * in combination with version as a key.
2778 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
2779 hdev->version |= 0x8000;
2781 ret = hid_hw_start(hdev, connect_mask);
2783 hid_err(hdev, "hw start failed\n");
2787 /* sony_input_configured can fail, but this doesn't result
2788 * in hid_hw_start failures (intended). Check whether
2789 * the HID layer claimed the device else fail.
2790 * We don't know the actual reason for the failure, most
2791 * likely it is due to EEXIST in case of double connection
2792 * of USB and Bluetooth, but could have been due to ENOMEM
2793 * or other reasons as well.
2795 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2796 hid_err(hdev, "failed to claim input\n");
2804 static void sony_remove(struct hid_device *hdev)
2806 struct sony_sc *sc = hid_get_drvdata(hdev);
2810 if (sc->quirks & SONY_LED_SUPPORT)
2811 sony_leds_remove(sc);
2813 if (sc->quirks & SONY_BATTERY_SUPPORT)
2814 sony_battery_remove(sc);
2817 sony_unregister_touchpad(sc);
2820 sony_unregister_sensors(sc);
2822 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2823 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2825 sony_cancel_work_sync(sc);
2827 kfree(sc->output_report_dmabuf);
2829 sony_remove_dev_list(sc);
2831 sony_release_device_id(sc);
2838 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2840 #ifdef CONFIG_SONY_FF
2842 /* On suspend stop any running force-feedback events */
2843 if (SONY_FF_SUPPORT) {
2844 struct sony_sc *sc = hid_get_drvdata(hdev);
2846 sc->left = sc->right = 0;
2847 sony_send_output_report(sc);
2854 static int sony_resume(struct hid_device *hdev)
2856 struct sony_sc *sc = hid_get_drvdata(hdev);
2859 * The Sixaxis and navigation controllers on USB need to be
2860 * reinitialized on resume or they won't behave properly.
2862 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2863 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2864 sixaxis_set_operational_usb(sc->hdev);
2865 sc->defer_initialization = 1;
2873 static const struct hid_device_id sony_devices[] = {
2874 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2875 .driver_data = SIXAXIS_CONTROLLER_USB },
2876 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2877 .driver_data = NAVIGATION_CONTROLLER_USB },
2878 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2879 .driver_data = NAVIGATION_CONTROLLER_BT },
2880 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2881 .driver_data = MOTION_CONTROLLER_USB },
2882 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2883 .driver_data = MOTION_CONTROLLER_BT },
2884 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2885 .driver_data = SIXAXIS_CONTROLLER_BT },
2886 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2887 .driver_data = VAIO_RDESC_CONSTANT },
2888 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2889 .driver_data = VAIO_RDESC_CONSTANT },
2891 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2892 * Logitech joystick from the device descriptor.
2894 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2895 .driver_data = BUZZ_CONTROLLER },
2896 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2897 .driver_data = BUZZ_CONTROLLER },
2898 /* PS3 BD Remote Control */
2899 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2900 .driver_data = PS3REMOTE },
2901 /* Logitech Harmony Adapter for PS3 */
2902 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2903 .driver_data = PS3REMOTE },
2904 /* SMK-Link PS3 BD Remote Control */
2905 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2906 .driver_data = PS3REMOTE },
2907 /* Sony Dualshock 4 controllers for PS4 */
2908 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2909 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2910 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2911 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2912 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2913 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2914 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2915 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2916 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
2917 .driver_data = DUALSHOCK4_DONGLE },
2918 /* Nyko Core Controller for PS3 */
2919 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2920 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2923 MODULE_DEVICE_TABLE(hid, sony_devices);
2925 static struct hid_driver sony_driver = {
2927 .id_table = sony_devices,
2928 .input_mapping = sony_mapping,
2929 .input_configured = sony_input_configured,
2930 .probe = sony_probe,
2931 .remove = sony_remove,
2932 .report_fixup = sony_report_fixup,
2933 .raw_event = sony_raw_event,
2936 .suspend = sony_suspend,
2937 .resume = sony_resume,
2938 .reset_resume = sony_resume,
2942 static int __init sony_init(void)
2944 dbg_hid("Sony:%s\n", __func__);
2946 return hid_register_driver(&sony_driver);
2949 static void __exit sony_exit(void)
2951 dbg_hid("Sony:%s\n", __func__);
2953 hid_unregister_driver(&sony_driver);
2954 ida_destroy(&sony_device_id_allocator);
2956 module_init(sony_init);
2957 module_exit(sony_exit);
2959 MODULE_LICENSE("GPL");