ccdc5f2d01b1063080a588dfbd2d65be5e571b59
[muen/linux.git] / drivers / hid / hid-sony.c
1 /*
2  *  HID driver for Sony / PS2 / PS3 / PS4 BD devices.
3  *
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>
12  */
13
14 /*
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)
18  * any later version.
19  */
20
21 /*
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.
25  *
26  * There will be no PIN request from the device.
27  */
28
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>
41
42 #include "hid-ids.h"
43
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)
58
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 | \
65                                 DUALSHOCK4_DONGLE)
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 |\
72                                 MOTION_CONTROLLER)
73 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
74                         MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
75
76 #define MAX_LEDS 4
77
78
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                      */
174 };
175
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) */
180
181          /* Use collection 1 for joypad buttons */
182          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
183
184           /*
185            * Ignore the 1st byte, maybe it is used for a controller
186            * number but it's not needed for correct operation
187            */
188           0x75, 0x08,        /* GReportSize 0x08 [8] */
189           0x95, 0x01,        /* GReportCount 0x01 [1] */
190           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
191
192           /*
193            * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
194            * buttons multiple keypresses are allowed
195            */
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]) */
204
205           0xC0,              /* MEndCollection */
206
207          /* Use collection 2 for remote control buttons */
208          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
209
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] */
218           0x80,              /* MInput  */
219
220           /*
221            * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
222            * 0xff and 11th is for press indication
223            */
224           0x75, 0x08,        /* GReportSize 0x08 [8] */
225           0x95, 0x06,        /* GReportCount 0x06 [6] */
226           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
227
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]) */
236
237           0xC0,              /* MEndCollection */
238
239          0xC0                /* MEndCollection [Game Pad] */
240 };
241
242 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
243         [0x01] = KEY_SELECT,
244         [0x02] = BTN_THUMBL,            /* L3 */
245         [0x03] = BTN_THUMBR,            /* R3 */
246         [0x04] = BTN_START,
247         [0x05] = KEY_UP,
248         [0x06] = KEY_RIGHT,
249         [0x07] = KEY_DOWN,
250         [0x08] = KEY_LEFT,
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 */
260         [0x14] = KEY_ENTER,
261 };
262 static const unsigned int ps3remote_keymap_remote_buttons[] = {
263         [0x00] = KEY_1,
264         [0x01] = KEY_2,
265         [0x02] = KEY_3,
266         [0x03] = KEY_4,
267         [0x04] = KEY_5,
268         [0x05] = KEY_6,
269         [0x06] = KEY_7,
270         [0x07] = KEY_8,
271         [0x08] = KEY_9,
272         [0x09] = KEY_0,
273         [0x0e] = KEY_ESC,               /* return */
274         [0x0f] = KEY_CLEAR,
275         [0x16] = KEY_EJECTCD,
276         [0x1a] = KEY_MENU,              /* top menu */
277         [0x28] = KEY_TIME,
278         [0x30] = KEY_PREVIOUS,
279         [0x31] = KEY_NEXT,
280         [0x32] = KEY_PLAY,
281         [0x33] = KEY_REWIND,            /* scan back */
282         [0x34] = KEY_FORWARD,           /* scan forward */
283         [0x38] = KEY_STOP,
284         [0x39] = KEY_PAUSE,
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,
289         [0x64] = KEY_AUDIO,
290         [0x65] = KEY_ANGLE,
291         [0x70] = KEY_INFO,              /* display */
292         [0x80] = KEY_BLUE,
293         [0x81] = KEY_RED,
294         [0x82] = KEY_GREEN,
295         [0x83] = KEY_YELLOW,
296 };
297
298 static const unsigned int buzz_keymap[] = {
299         /*
300          * The controller has 4 remote buzzers, each with one LED and 5
301          * buttons.
302          *
303          * We use the mapping chosen by the controller, which is:
304          *
305          * Key          Offset
306          * -------------------
307          * Buzz              1
308          * Blue              5
309          * Orange            4
310          * Green             3
311          * Yellow            2
312          *
313          * So, for example, the orange button on the third buzzer is mapped to
314          * BTN_TRIGGER_HAPPY14
315          */
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,
336 };
337
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.
342  */
343 static const unsigned int navigation_absmap[] = {
344         [0x30] = ABS_X,
345         [0x31] = ABS_Y,
346         [0x33] = ABS_Z, /* L2 */
347 };
348
349 /* Buttons not physically available on the device, but still available
350  * in the reports are explicitly set to 0 for documentation purposes.
351  */
352 static const unsigned int navigation_keymap[] = {
353         [0x01] = 0, /* Select */
354         [0x02] = BTN_THUMBL, /* L3 */
355         [0x03] = 0, /* R3 */
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 */
362         [0x0a] = 0, /* R2 */
363         [0x0b] = BTN_TL, /* L1 */
364         [0x0c] = 0, /* R1 */
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 */
370 };
371
372 static const unsigned int sixaxis_absmap[] = {
373         [0x30] = ABS_X,
374         [0x31] = ABS_Y,
375         [0x32] = ABS_RX, /* right stick X */
376         [0x35] = ABS_RY, /* right stick Y */
377 };
378
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 */
397 };
398
399 static const unsigned int ds4_absmap[] = {
400         [0x30] = ABS_X,
401         [0x31] = ABS_Y,
402         [0x32] = ABS_RX, /* right stick X */
403         [0x33] = ABS_Z, /* L2 */
404         [0x34] = ABS_RZ, /* R2 */
405         [0x35] = ABS_RY, /* right stick Y */
406 };
407
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 */
422 };
423
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},
426         {0, 0}
427 };
428
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,
434 };
435
436 struct sixaxis_led {
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") */
439         u8 enabled;
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%) */
442 } __packed;
443
444 struct sixaxis_rumble {
445         u8 padding;
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 */
450 } __packed;
451
452 struct sixaxis_output_report {
453         u8 report_id;
454         struct sixaxis_rumble rumble;
455         u8 padding[4];
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 */
459 } __packed;
460
461 union sixaxis_output_report_01 {
462         struct sixaxis_output_report data;
463         u8 buf[36];
464 };
465
466 struct motion_output_report_02 {
467         u8 type, zero;
468         u8 r, g, b;
469         u8 zero2;
470         u8 rumble;
471 };
472
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_FEATURE_REPORT_0xA3_SIZE 49
477 #define DS4_INPUT_REPORT_0x11_SIZE 78
478 #define DS4_OUTPUT_REPORT_0x05_SIZE 32
479 #define DS4_OUTPUT_REPORT_0x11_SIZE 78
480 #define SIXAXIS_REPORT_0xF2_SIZE 17
481 #define SIXAXIS_REPORT_0xF5_SIZE 8
482 #define MOTION_REPORT_0x02_SIZE 49
483
484 /* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
485  * additional +2.
486  */
487 #define DS4_INPUT_REPORT_AXIS_OFFSET      1
488 #define DS4_INPUT_REPORT_BUTTON_OFFSET    5
489 #define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
490 #define DS4_INPUT_REPORT_GYRO_X_OFFSET   13
491 #define DS4_INPUT_REPORT_BATTERY_OFFSET  30
492 #define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
493
494 #define SENSOR_SUFFIX " Motion Sensors"
495 #define DS4_TOUCHPAD_SUFFIX " Touchpad"
496
497 /* Default to 4ms poll interval, which is same as USB (not adjustable). */
498 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
499 #define DS4_BT_MAX_POLL_INTERVAL_MS 62
500 #define DS4_GYRO_RES_PER_DEG_S 1024
501 #define DS4_ACC_RES_PER_G      8192
502
503 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
504 #define SIXAXIS_ACC_RES_PER_G 113
505
506 static DEFINE_SPINLOCK(sony_dev_list_lock);
507 static LIST_HEAD(sony_device_list);
508 static DEFINE_IDA(sony_device_id_allocator);
509
510 /* Used for calibration of DS4 accelerometer and gyro. */
511 struct ds4_calibration_data {
512         int abs_code;
513         short bias;
514         /* Calibration requires scaling against a sensitivity value, which is a
515          * float. Store sensitivity as a fraction to limit floating point
516          * calculations until final calibration.
517          */
518         int sens_numer;
519         int sens_denom;
520 };
521
522 enum ds4_dongle_state {
523         DONGLE_DISCONNECTED,
524         DONGLE_CALIBRATING,
525         DONGLE_CONNECTED,
526         DONGLE_DISABLED
527 };
528
529 enum sony_worker {
530         SONY_WORKER_STATE,
531         SONY_WORKER_HOTPLUG
532 };
533
534 struct sony_sc {
535         spinlock_t lock;
536         struct list_head list_node;
537         struct hid_device *hdev;
538         struct input_dev *touchpad;
539         struct input_dev *sensor_dev;
540         struct led_classdev *leds[MAX_LEDS];
541         unsigned long quirks;
542         struct work_struct hotplug_worker;
543         struct work_struct state_worker;
544         void (*send_output_report)(struct sony_sc *);
545         struct power_supply *battery;
546         struct power_supply_desc battery_desc;
547         int device_id;
548         unsigned fw_version;
549         unsigned hw_version;
550         u8 *output_report_dmabuf;
551
552 #ifdef CONFIG_SONY_FF
553         u8 left;
554         u8 right;
555 #endif
556
557         u8 mac_address[6];
558         u8 hotplug_worker_initialized;
559         u8 state_worker_initialized;
560         u8 defer_initialization;
561         u8 cable_state;
562         u8 battery_charging;
563         u8 battery_capacity;
564         u8 led_state[MAX_LEDS];
565         u8 led_delay_on[MAX_LEDS];
566         u8 led_delay_off[MAX_LEDS];
567         u8 led_count;
568
569         bool timestamp_initialized;
570         u16 prev_timestamp;
571         unsigned int timestamp_us;
572
573         u8 ds4_bt_poll_interval;
574         enum ds4_dongle_state ds4_dongle_state;
575         /* DS4 calibration data */
576         struct ds4_calibration_data ds4_calib_data[6];
577 };
578
579 static void sony_set_leds(struct sony_sc *sc);
580
581 static inline void sony_schedule_work(struct sony_sc *sc,
582                                       enum sony_worker which)
583 {
584         switch (which) {
585         case SONY_WORKER_STATE:
586                 if (!sc->defer_initialization)
587                         schedule_work(&sc->state_worker);
588                 break;
589         case SONY_WORKER_HOTPLUG:
590                 if (sc->hotplug_worker_initialized)
591                         schedule_work(&sc->hotplug_worker);
592                 break;
593         }
594 }
595
596 static ssize_t ds4_show_poll_interval(struct device *dev,
597                                 struct device_attribute
598                                 *attr, char *buf)
599 {
600         struct hid_device *hdev = to_hid_device(dev);
601         struct sony_sc *sc = hid_get_drvdata(hdev);
602
603         return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
604 }
605
606 static ssize_t ds4_store_poll_interval(struct device *dev,
607                                 struct device_attribute *attr,
608                                 const char *buf, size_t count)
609 {
610         struct hid_device *hdev = to_hid_device(dev);
611         struct sony_sc *sc = hid_get_drvdata(hdev);
612         unsigned long flags;
613         u8 interval;
614
615         if (kstrtou8(buf, 0, &interval))
616                 return -EINVAL;
617
618         if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
619                 return -EINVAL;
620
621         spin_lock_irqsave(&sc->lock, flags);
622         sc->ds4_bt_poll_interval = interval;
623         spin_unlock_irqrestore(&sc->lock, flags);
624
625         sony_schedule_work(sc, SONY_WORKER_STATE);
626
627         return count;
628 }
629
630 static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
631                 ds4_store_poll_interval);
632
633 static ssize_t sony_show_firmware_version(struct device *dev,
634                                 struct device_attribute
635                                 *attr, char *buf)
636 {
637         struct hid_device *hdev = to_hid_device(dev);
638         struct sony_sc *sc = hid_get_drvdata(hdev);
639
640         return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
641 }
642
643 static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
644
645 static ssize_t sony_show_hardware_version(struct device *dev,
646                                 struct device_attribute
647                                 *attr, char *buf)
648 {
649         struct hid_device *hdev = to_hid_device(dev);
650         struct sony_sc *sc = hid_get_drvdata(hdev);
651
652         return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
653 }
654
655 static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
656
657 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
658                              unsigned int *rsize)
659 {
660         *rsize = sizeof(motion_rdesc);
661         return motion_rdesc;
662 }
663
664 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
665                              unsigned int *rsize)
666 {
667         *rsize = sizeof(ps3remote_rdesc);
668         return ps3remote_rdesc;
669 }
670
671 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
672                              struct hid_field *field, struct hid_usage *usage,
673                              unsigned long **bit, int *max)
674 {
675         unsigned int key = usage->hid & HID_USAGE;
676
677         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
678                 return -1;
679
680         switch (usage->collection_index) {
681         case 1:
682                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
683                         return -1;
684
685                 key = ps3remote_keymap_joypad_buttons[key];
686                 if (!key)
687                         return -1;
688                 break;
689         case 2:
690                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
691                         return -1;
692
693                 key = ps3remote_keymap_remote_buttons[key];
694                 if (!key)
695                         return -1;
696                 break;
697         default:
698                 return -1;
699         }
700
701         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
702         return 1;
703 }
704
705 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
706                           struct hid_field *field, struct hid_usage *usage,
707                           unsigned long **bit, int *max)
708 {
709         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
710                 unsigned int key = usage->hid & HID_USAGE;
711
712                 if (key >= ARRAY_SIZE(sixaxis_keymap))
713                         return -1;
714
715                 key = navigation_keymap[key];
716                 if (!key)
717                         return -1;
718
719                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
720                 return 1;
721         } else if (usage->hid == HID_GD_POINTER) {
722                 /* See comment in sixaxis_mapping, basically the L2 (and R2)
723                  * triggers are reported through GD Pointer.
724                  * In addition we ignore any analog button 'axes' and only
725                  * support digital buttons.
726                  */
727                 switch (usage->usage_index) {
728                 case 8: /* L2 */
729                         usage->hid = HID_GD_Z;
730                         break;
731                 default:
732                         return -1;
733                 }
734
735                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
736                 return 1;
737         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
738                 unsigned int abs = usage->hid & HID_USAGE;
739
740                 if (abs >= ARRAY_SIZE(navigation_absmap))
741                         return -1;
742
743                 abs = navigation_absmap[abs];
744
745                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
746                 return 1;
747         }
748
749         return -1;
750 }
751
752
753 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
754                           struct hid_field *field, struct hid_usage *usage,
755                           unsigned long **bit, int *max)
756 {
757         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
758                 unsigned int key = usage->hid & HID_USAGE;
759
760                 if (key >= ARRAY_SIZE(sixaxis_keymap))
761                         return -1;
762
763                 key = sixaxis_keymap[key];
764                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
765                 return 1;
766         } else if (usage->hid == HID_GD_POINTER) {
767                 /* The DS3 provides analog values for most buttons and even
768                  * for HAT axes through GD Pointer. L2 and R2 are reported
769                  * among these as well instead of as GD Z / RZ. Remap L2
770                  * and R2 and ignore other analog 'button axes' as there is
771                  * no good way for reporting them.
772                  */
773                 switch (usage->usage_index) {
774                 case 8: /* L2 */
775                         usage->hid = HID_GD_Z;
776                         break;
777                 case 9: /* R2 */
778                         usage->hid = HID_GD_RZ;
779                         break;
780                 default:
781                         return -1;
782                 }
783
784                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
785                 return 1;
786         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
787                 unsigned int abs = usage->hid & HID_USAGE;
788
789                 if (abs >= ARRAY_SIZE(sixaxis_absmap))
790                         return -1;
791
792                 abs = sixaxis_absmap[abs];
793
794                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
795                 return 1;
796         }
797
798         return -1;
799 }
800
801 static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
802                        struct hid_field *field, struct hid_usage *usage,
803                        unsigned long **bit, int *max)
804 {
805         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
806                 unsigned int key = usage->hid & HID_USAGE;
807
808                 if (key >= ARRAY_SIZE(ds4_keymap))
809                         return -1;
810
811                 key = ds4_keymap[key];
812                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
813                 return 1;
814         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
815                 unsigned int abs = usage->hid & HID_USAGE;
816
817                 /* Let the HID parser deal with the HAT. */
818                 if (usage->hid == HID_GD_HATSWITCH)
819                         return 0;
820
821                 if (abs >= ARRAY_SIZE(ds4_absmap))
822                         return -1;
823
824                 abs = ds4_absmap[abs];
825                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
826                 return 1;
827         }
828
829         return 0;
830 }
831
832 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
833                 unsigned int *rsize)
834 {
835         struct sony_sc *sc = hid_get_drvdata(hdev);
836
837         if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
838                 return rdesc;
839
840         /*
841          * Some Sony RF receivers wrongly declare the mouse pointer as a
842          * a constant non-data variable.
843          */
844         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
845             /* usage page: generic desktop controls */
846             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
847             /* usage: mouse */
848             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
849             /* input (usage page for x,y axes): constant, variable, relative */
850             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
851                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
852                 /* input: data, variable, relative */
853                 rdesc[55] = 0x06;
854         }
855
856         if (sc->quirks & MOTION_CONTROLLER)
857                 return motion_fixup(hdev, rdesc, rsize);
858
859         if (sc->quirks & PS3REMOTE)
860                 return ps3remote_fixup(hdev, rdesc, rsize);
861
862         return rdesc;
863 }
864
865 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
866 {
867         static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
868         unsigned long flags;
869         int offset;
870         u8 cable_state, battery_capacity, battery_charging;
871
872         /*
873          * The sixaxis is charging if the battery value is 0xee
874          * and it is fully charged if the value is 0xef.
875          * It does not report the actual level while charging so it
876          * is set to 100% while charging is in progress.
877          */
878         offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
879
880         if (rd[offset] >= 0xee) {
881                 battery_capacity = 100;
882                 battery_charging = !(rd[offset] & 0x01);
883                 cable_state = 1;
884         } else {
885                 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
886                 battery_capacity = sixaxis_battery_capacity[index];
887                 battery_charging = 0;
888                 cable_state = 0;
889         }
890
891         spin_lock_irqsave(&sc->lock, flags);
892         sc->cable_state = cable_state;
893         sc->battery_capacity = battery_capacity;
894         sc->battery_charging = battery_charging;
895         spin_unlock_irqrestore(&sc->lock, flags);
896
897         if (sc->quirks & SIXAXIS_CONTROLLER) {
898                 int val;
899
900                 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
901                 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
902                 input_report_abs(sc->sensor_dev, ABS_X, val);
903
904                 /* Y and Z are swapped and inversed */
905                 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
906                 input_report_abs(sc->sensor_dev, ABS_Y, val);
907
908                 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
909                 input_report_abs(sc->sensor_dev, ABS_Z, val);
910
911                 input_sync(sc->sensor_dev);
912         }
913 }
914
915 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
916 {
917         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
918                                                 struct hid_input, list);
919         struct input_dev *input_dev = hidinput->input;
920         unsigned long flags;
921         int n, m, offset, num_touch_data, max_touch_data;
922         u8 cable_state, battery_capacity, battery_charging;
923         u16 timestamp;
924
925         /* When using Bluetooth the header is 2 bytes longer, so skip these. */
926         int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
927
928         /* Second bit of third button byte is for the touchpad button. */
929         offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
930         input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
931
932         /*
933          * The default behavior of the Dualshock 4 is to send reports using
934          * report type 1 when running over Bluetooth. However, when feature
935          * report 2 is requested during the controller initialization it starts
936          * sending input reports in report 17. Since report 17 is undefined
937          * in the default HID descriptor, the HID layer won't generate events.
938          * While it is possible (and this was done before) to fixup the HID
939          * descriptor to add this mapping, it was better to do this manually.
940          * The reason is there were various pieces software both open and closed
941          * source, relying on the descriptors to be the same across various
942          * operating systems. If the descriptors wouldn't match some
943          * applications e.g. games on Wine would not be able to function due
944          * to different descriptors, which such applications are not parsing.
945          */
946         if (rd[0] == 17) {
947                 int value;
948
949                 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
950                 input_report_abs(input_dev, ABS_X, rd[offset]);
951                 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
952                 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
953                 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
954
955                 value = rd[offset+4] & 0xf;
956                 if (value > 7)
957                         value = 8; /* Center 0, 0 */
958                 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
959                 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
960
961                 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
962                 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
963                 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
964                 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
965
966                 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
967                 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
968                 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
969                 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
970                 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
971                 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
972                 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
973                 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
974
975                 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
976
977                 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
978                 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
979
980                 input_sync(input_dev);
981         }
982
983         /* Convert timestamp (in 5.33us unit) to timestamp_us */
984         offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
985         timestamp = get_unaligned_le16(&rd[offset]);
986         if (!sc->timestamp_initialized) {
987                 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
988                 sc->timestamp_initialized = true;
989         } else {
990                 u16 delta;
991
992                 if (sc->prev_timestamp > timestamp)
993                         delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
994                 else
995                         delta = timestamp - sc->prev_timestamp;
996                 sc->timestamp_us += (delta * 16) / 3;
997         }
998         sc->prev_timestamp = timestamp;
999         input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1000
1001         offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
1002         for (n = 0; n < 6; n++) {
1003                 /* Store data in int for more precision during mult_frac. */
1004                 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1005                 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1006
1007                 /* High precision is needed during calibration, but the
1008                  * calibrated values are within 32-bit.
1009                  * Note: we swap numerator 'x' and 'numer' in mult_frac for
1010                  *       precision reasons so we don't need 64-bit.
1011                  */
1012                 int calib_data = mult_frac(calib->sens_numer,
1013                                            raw_data - calib->bias,
1014                                            calib->sens_denom);
1015
1016                 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1017                 offset += 2;
1018         }
1019         input_sync(sc->sensor_dev);
1020
1021         /*
1022          * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1023          * and the 5th bit contains the USB cable state.
1024          */
1025         offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1026         cable_state = (rd[offset] >> 4) & 0x01;
1027         battery_capacity = rd[offset] & 0x0F;
1028
1029         /*
1030          * When a USB power source is connected the battery level ranges from
1031          * 0 to 10, and when running on battery power it ranges from 0 to 9.
1032          * A battery level above 10 when plugged in means charge completed.
1033          */
1034         if (!cable_state || battery_capacity > 10)
1035                 battery_charging = 0;
1036         else
1037                 battery_charging = 1;
1038
1039         if (!cable_state)
1040                 battery_capacity++;
1041         if (battery_capacity > 10)
1042                 battery_capacity = 10;
1043
1044         battery_capacity *= 10;
1045
1046         spin_lock_irqsave(&sc->lock, flags);
1047         sc->cable_state = cable_state;
1048         sc->battery_capacity = battery_capacity;
1049         sc->battery_charging = battery_charging;
1050         spin_unlock_irqrestore(&sc->lock, flags);
1051
1052         /*
1053          * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1054          * and 35 on Bluetooth.
1055          * The first byte indicates the number of touch data in the report.
1056          * Trackpad data starts 2 bytes later (e.g. 35 for USB).
1057          */
1058         offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1059         max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1060         if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1061                 num_touch_data = rd[offset];
1062         else
1063                 num_touch_data = 1;
1064         offset += 1;
1065
1066         for (m = 0; m < num_touch_data; m++) {
1067                 /* Skip past timestamp */
1068                 offset += 1;
1069
1070                 /*
1071                  * The first 7 bits of the first byte is a counter and bit 8 is
1072                  * a touch indicator that is 0 when pressed and 1 when not
1073                  * pressed.
1074                  * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1075                  * The data for the second touch is in the same format and
1076                  * immediately follows the data for the first.
1077                  */
1078                 for (n = 0; n < 2; n++) {
1079                         u16 x, y;
1080                         bool active;
1081
1082                         x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1083                         y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1084
1085                         active = !(rd[offset] >> 7);
1086                         input_mt_slot(sc->touchpad, n);
1087                         input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1088
1089                         if (active) {
1090                                 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1091                                 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1092                         }
1093
1094                         offset += 4;
1095                 }
1096                 input_mt_sync_frame(sc->touchpad);
1097                 input_sync(sc->touchpad);
1098         }
1099 }
1100
1101 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1102                 u8 *rd, int size)
1103 {
1104         struct sony_sc *sc = hid_get_drvdata(hdev);
1105
1106         /*
1107          * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1108          * has to be BYTE_SWAPPED before passing up to joystick interface
1109          */
1110         if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1111                 /*
1112                  * When connected via Bluetooth the Sixaxis occasionally sends
1113                  * a report with the second byte 0xff and the rest zeroed.
1114                  *
1115                  * This report does not reflect the actual state of the
1116                  * controller must be ignored to avoid generating false input
1117                  * events.
1118                  */
1119                 if (rd[1] == 0xff)
1120                         return -EINVAL;
1121
1122                 swap(rd[41], rd[42]);
1123                 swap(rd[43], rd[44]);
1124                 swap(rd[45], rd[46]);
1125                 swap(rd[47], rd[48]);
1126
1127                 sixaxis_parse_report(sc, rd, size);
1128         } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1129                 sixaxis_parse_report(sc, rd, size);
1130         } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1131                         size == 49) {
1132                 sixaxis_parse_report(sc, rd, size);
1133         } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1134                         size == 64) {
1135                 dualshock4_parse_report(sc, rd, size);
1136         } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1137                         size == 78)) {
1138                 /* CRC check */
1139                 u8 bthdr = 0xA1;
1140                 u32 crc;
1141                 u32 report_crc;
1142
1143                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1144                 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1145                 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1146                 if (crc != report_crc) {
1147                         hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1148                                 report_crc, crc);
1149                         return -EILSEQ;
1150                 }
1151
1152                 dualshock4_parse_report(sc, rd, size);
1153         } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1154                         size == 64) {
1155                 unsigned long flags;
1156                 enum ds4_dongle_state dongle_state;
1157
1158                 /*
1159                  * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1160                  * if a DS4 is actually connected (indicated by '0').
1161                  * For non-dongle, this bit is always 0 (connected).
1162                  */
1163                 bool connected = (rd[31] & 0x04) ? false : true;
1164
1165                 spin_lock_irqsave(&sc->lock, flags);
1166                 dongle_state = sc->ds4_dongle_state;
1167                 spin_unlock_irqrestore(&sc->lock, flags);
1168
1169                 /*
1170                  * The dongle always sends input reports even when no
1171                  * DS4 is attached. When a DS4 is connected, we need to
1172                  * obtain calibration data before we can use it.
1173                  * The code below tracks dongle state and kicks of
1174                  * calibration when needed and only allows us to process
1175                  * input if a DS4 is actually connected.
1176                  */
1177                 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1178                         hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1179                         sony_set_leds(sc);
1180
1181                         spin_lock_irqsave(&sc->lock, flags);
1182                         sc->ds4_dongle_state = DONGLE_CALIBRATING;
1183                         spin_unlock_irqrestore(&sc->lock, flags);
1184
1185                         sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1186
1187                         /* Don't process the report since we don't have
1188                          * calibration data, but let hidraw have it anyway.
1189                          */
1190                         return 0;
1191                 } else if ((dongle_state == DONGLE_CONNECTED ||
1192                             dongle_state == DONGLE_DISABLED) && !connected) {
1193                         hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1194
1195                         spin_lock_irqsave(&sc->lock, flags);
1196                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1197                         spin_unlock_irqrestore(&sc->lock, flags);
1198
1199                         /* Return 0, so hidraw can get the report. */
1200                         return 0;
1201                 } else if (dongle_state == DONGLE_CALIBRATING ||
1202                            dongle_state == DONGLE_DISABLED ||
1203                            dongle_state == DONGLE_DISCONNECTED) {
1204                         /* Return 0, so hidraw can get the report. */
1205                         return 0;
1206                 }
1207
1208                 dualshock4_parse_report(sc, rd, size);
1209         }
1210
1211         if (sc->defer_initialization) {
1212                 sc->defer_initialization = 0;
1213                 sony_schedule_work(sc, SONY_WORKER_STATE);
1214         }
1215
1216         return 0;
1217 }
1218
1219 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1220                         struct hid_field *field, struct hid_usage *usage,
1221                         unsigned long **bit, int *max)
1222 {
1223         struct sony_sc *sc = hid_get_drvdata(hdev);
1224
1225         if (sc->quirks & BUZZ_CONTROLLER) {
1226                 unsigned int key = usage->hid & HID_USAGE;
1227
1228                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1229                         return -1;
1230
1231                 switch (usage->collection_index) {
1232                 case 1:
1233                         if (key >= ARRAY_SIZE(buzz_keymap))
1234                                 return -1;
1235
1236                         key = buzz_keymap[key];
1237                         if (!key)
1238                                 return -1;
1239                         break;
1240                 default:
1241                         return -1;
1242                 }
1243
1244                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1245                 return 1;
1246         }
1247
1248         if (sc->quirks & PS3REMOTE)
1249                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1250
1251         if (sc->quirks & NAVIGATION_CONTROLLER)
1252                 return navigation_mapping(hdev, hi, field, usage, bit, max);
1253
1254         if (sc->quirks & SIXAXIS_CONTROLLER)
1255                 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1256
1257         if (sc->quirks & DUALSHOCK4_CONTROLLER)
1258                 return ds4_mapping(hdev, hi, field, usage, bit, max);
1259
1260
1261         /* Let hid-core decide for the others */
1262         return 0;
1263 }
1264
1265 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1266                                         int w, int h)
1267 {
1268         size_t name_sz;
1269         char *name;
1270         int ret;
1271
1272         sc->touchpad = input_allocate_device();
1273         if (!sc->touchpad)
1274                 return -ENOMEM;
1275
1276         input_set_drvdata(sc->touchpad, sc);
1277         sc->touchpad->dev.parent = &sc->hdev->dev;
1278         sc->touchpad->phys = sc->hdev->phys;
1279         sc->touchpad->uniq = sc->hdev->uniq;
1280         sc->touchpad->id.bustype = sc->hdev->bus;
1281         sc->touchpad->id.vendor = sc->hdev->vendor;
1282         sc->touchpad->id.product = sc->hdev->product;
1283         sc->touchpad->id.version = sc->hdev->version;
1284
1285         /* Append a suffix to the controller name as there are various
1286          * DS4 compatible non-Sony devices with different names.
1287          */
1288         name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1289         name = kzalloc(name_sz, GFP_KERNEL);
1290         if (!name) {
1291                 ret = -ENOMEM;
1292                 goto err;
1293         }
1294         snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1295         sc->touchpad->name = name;
1296
1297         ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1298         if (ret < 0)
1299                 goto err;
1300
1301         /* We map the button underneath the touchpad to BTN_LEFT. */
1302         __set_bit(EV_KEY, sc->touchpad->evbit);
1303         __set_bit(BTN_LEFT, sc->touchpad->keybit);
1304         __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1305
1306         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1307         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1308
1309         ret = input_register_device(sc->touchpad);
1310         if (ret < 0)
1311                 goto err;
1312
1313         return 0;
1314
1315 err:
1316         kfree(sc->touchpad->name);
1317         sc->touchpad->name = NULL;
1318
1319         input_free_device(sc->touchpad);
1320         sc->touchpad = NULL;
1321
1322         return ret;
1323 }
1324
1325 static void sony_unregister_touchpad(struct sony_sc *sc)
1326 {
1327         if (!sc->touchpad)
1328                 return;
1329
1330         kfree(sc->touchpad->name);
1331         sc->touchpad->name = NULL;
1332
1333         input_unregister_device(sc->touchpad);
1334         sc->touchpad = NULL;
1335 }
1336
1337 static int sony_register_sensors(struct sony_sc *sc)
1338 {
1339         size_t name_sz;
1340         char *name;
1341         int ret;
1342         int range;
1343
1344         sc->sensor_dev = input_allocate_device();
1345         if (!sc->sensor_dev)
1346                 return -ENOMEM;
1347
1348         input_set_drvdata(sc->sensor_dev, sc);
1349         sc->sensor_dev->dev.parent = &sc->hdev->dev;
1350         sc->sensor_dev->phys = sc->hdev->phys;
1351         sc->sensor_dev->uniq = sc->hdev->uniq;
1352         sc->sensor_dev->id.bustype = sc->hdev->bus;
1353         sc->sensor_dev->id.vendor = sc->hdev->vendor;
1354         sc->sensor_dev->id.product = sc->hdev->product;
1355         sc->sensor_dev->id.version = sc->hdev->version;
1356
1357         /* Append a suffix to the controller name as there are various
1358          * DS4 compatible non-Sony devices with different names.
1359          */
1360         name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1361         name = kzalloc(name_sz, GFP_KERNEL);
1362         if (!name) {
1363                 ret = -ENOMEM;
1364                 goto err;
1365         }
1366         snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1367         sc->sensor_dev->name = name;
1368
1369         if (sc->quirks & SIXAXIS_CONTROLLER) {
1370                 /* For the DS3 we only support the accelerometer, which works
1371                  * quite well even without calibration. The device also has
1372                  * a 1-axis gyro, but it is very difficult to manage from within
1373                  * the driver even to get data, the sensor is inaccurate and
1374                  * the behavior is very different between hardware revisions.
1375                  */
1376                 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1377                 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1378                 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1379                 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1380                 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1381                 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1382         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1383                 range = DS4_ACC_RES_PER_G*4;
1384                 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1385                 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1386                 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1387                 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1388                 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1389                 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1390
1391                 range = DS4_GYRO_RES_PER_DEG_S*2048;
1392                 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1393                 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1394                 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1395                 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1396                 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1397                 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1398
1399                 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1400                 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1401         }
1402
1403         __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1404
1405         ret = input_register_device(sc->sensor_dev);
1406         if (ret < 0)
1407                 goto err;
1408
1409         return 0;
1410
1411 err:
1412         kfree(sc->sensor_dev->name);
1413         sc->sensor_dev->name = NULL;
1414
1415         input_free_device(sc->sensor_dev);
1416         sc->sensor_dev = NULL;
1417
1418         return ret;
1419 }
1420
1421 static void sony_unregister_sensors(struct sony_sc *sc)
1422 {
1423         if (!sc->sensor_dev)
1424                 return;
1425
1426         kfree(sc->sensor_dev->name);
1427         sc->sensor_dev->name = NULL;
1428
1429         input_unregister_device(sc->sensor_dev);
1430         sc->sensor_dev = NULL;
1431 }
1432
1433
1434 /*
1435  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1436  * to "operational".  Without this, the ps3 controller will not report any
1437  * events.
1438  */
1439 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1440 {
1441         const int buf_size =
1442                 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1443         u8 *buf;
1444         int ret;
1445
1446         buf = kmalloc(buf_size, GFP_KERNEL);
1447         if (!buf)
1448                 return -ENOMEM;
1449
1450         ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1451                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1452         if (ret < 0) {
1453                 hid_err(hdev, "can't set operational mode: step 1\n");
1454                 goto out;
1455         }
1456
1457         /*
1458          * Some compatible controllers like the Speedlink Strike FX and
1459          * Gasia need another query plus an USB interrupt to get operational.
1460          */
1461         ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1462                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1463         if (ret < 0) {
1464                 hid_err(hdev, "can't set operational mode: step 2\n");
1465                 goto out;
1466         }
1467
1468         /*
1469          * But the USB interrupt would cause SHANWAN controllers to
1470          * start rumbling non-stop.
1471          */
1472         if (strcmp(hdev->name, "SHANWAN PS3 GamePad")) {
1473                 ret = hid_hw_output_report(hdev, buf, 1);
1474                 if (ret < 0) {
1475                         hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1476                         ret = 0;
1477                 }
1478         }
1479
1480 out:
1481         kfree(buf);
1482
1483         return ret;
1484 }
1485
1486 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1487 {
1488         static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1489         u8 *buf;
1490         int ret;
1491
1492         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1493         if (!buf)
1494                 return -ENOMEM;
1495
1496         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1497                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1498
1499         kfree(buf);
1500
1501         return ret;
1502 }
1503
1504 /*
1505  * Request DS4 calibration data for the motion sensors.
1506  * For Bluetooth this also affects the operating mode (see below).
1507  */
1508 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1509 {
1510         u8 *buf;
1511         int ret;
1512         short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1513         short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1514         short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1515         short gyro_speed_plus, gyro_speed_minus;
1516         short acc_x_plus, acc_x_minus;
1517         short acc_y_plus, acc_y_minus;
1518         short acc_z_plus, acc_z_minus;
1519         int speed_2x;
1520         int range_2g;
1521
1522         /* For Bluetooth we use a different request, which supports CRC.
1523          * Note: in Bluetooth mode feature report 0x02 also changes the state
1524          * of the controller, so that it sends input reports of type 0x11.
1525          */
1526         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1527                 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1528                 if (!buf)
1529                         return -ENOMEM;
1530
1531                 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1532                                          DS4_FEATURE_REPORT_0x02_SIZE,
1533                                          HID_FEATURE_REPORT,
1534                                          HID_REQ_GET_REPORT);
1535                 if (ret < 0)
1536                         goto err_stop;
1537         } else {
1538                 u8 bthdr = 0xA3;
1539                 u32 crc;
1540                 u32 report_crc;
1541                 int retries;
1542
1543                 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1544                 if (!buf)
1545                         return -ENOMEM;
1546
1547                 for (retries = 0; retries < 3; retries++) {
1548                         ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1549                                                  DS4_FEATURE_REPORT_0x05_SIZE,
1550                                                  HID_FEATURE_REPORT,
1551                                                  HID_REQ_GET_REPORT);
1552                         if (ret < 0)
1553                                 goto err_stop;
1554
1555                         /* CRC check */
1556                         crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1557                         crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1558                         report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1559                         if (crc != report_crc) {
1560                                 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1561                                         report_crc, crc);
1562                                 if (retries < 2) {
1563                                         hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1564                                         continue;
1565                                 } else {
1566                                         ret = -EILSEQ;
1567                                         goto err_stop;
1568                                 }
1569                         } else {
1570                                 break;
1571                         }
1572                 }
1573         }
1574
1575         gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
1576         gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
1577         gyro_roll_bias   = get_unaligned_le16(&buf[5]);
1578         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1579                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1580                 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1581                 gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
1582                 gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
1583                 gyro_roll_plus   = get_unaligned_le16(&buf[15]);
1584                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1585         } else {
1586                 /* BT + Dongle */
1587                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1588                 gyro_yaw_plus    = get_unaligned_le16(&buf[9]);
1589                 gyro_roll_plus   = get_unaligned_le16(&buf[11]);
1590                 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1591                 gyro_yaw_minus   = get_unaligned_le16(&buf[15]);
1592                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1593         }
1594         gyro_speed_plus  = get_unaligned_le16(&buf[19]);
1595         gyro_speed_minus = get_unaligned_le16(&buf[21]);
1596         acc_x_plus       = get_unaligned_le16(&buf[23]);
1597         acc_x_minus      = get_unaligned_le16(&buf[25]);
1598         acc_y_plus       = get_unaligned_le16(&buf[27]);
1599         acc_y_minus      = get_unaligned_le16(&buf[29]);
1600         acc_z_plus       = get_unaligned_le16(&buf[31]);
1601         acc_z_minus      = get_unaligned_le16(&buf[33]);
1602
1603         /* Set gyroscope calibration and normalization parameters.
1604          * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1605          */
1606         speed_2x = (gyro_speed_plus + gyro_speed_minus);
1607         sc->ds4_calib_data[0].abs_code = ABS_RX;
1608         sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1609         sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1610         sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1611
1612         sc->ds4_calib_data[1].abs_code = ABS_RY;
1613         sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1614         sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1615         sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1616
1617         sc->ds4_calib_data[2].abs_code = ABS_RZ;
1618         sc->ds4_calib_data[2].bias = gyro_roll_bias;
1619         sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1620         sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1621
1622         /* Set accelerometer calibration and normalization parameters.
1623          * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1624          */
1625         range_2g = acc_x_plus - acc_x_minus;
1626         sc->ds4_calib_data[3].abs_code = ABS_X;
1627         sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1628         sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1629         sc->ds4_calib_data[3].sens_denom = range_2g;
1630
1631         range_2g = acc_y_plus - acc_y_minus;
1632         sc->ds4_calib_data[4].abs_code = ABS_Y;
1633         sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1634         sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1635         sc->ds4_calib_data[4].sens_denom = range_2g;
1636
1637         range_2g = acc_z_plus - acc_z_minus;
1638         sc->ds4_calib_data[5].abs_code = ABS_Z;
1639         sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1640         sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1641         sc->ds4_calib_data[5].sens_denom = range_2g;
1642
1643 err_stop:
1644         kfree(buf);
1645         return ret;
1646 }
1647
1648 static void dualshock4_calibration_work(struct work_struct *work)
1649 {
1650         struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1651         unsigned long flags;
1652         enum ds4_dongle_state dongle_state;
1653         int ret;
1654
1655         ret = dualshock4_get_calibration_data(sc);
1656         if (ret < 0) {
1657                 /* This call is very unlikely to fail for the dongle. When it
1658                  * fails we are probably in a very bad state, so mark the
1659                  * dongle as disabled. We will re-enable the dongle if a new
1660                  * DS4 hotplug is detect from sony_raw_event as any issues
1661                  * are likely resolved then (the dongle is quite stupid).
1662                  */
1663                 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1664                 dongle_state = DONGLE_DISABLED;
1665         } else {
1666                 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1667                 dongle_state = DONGLE_CONNECTED;
1668         }
1669
1670         spin_lock_irqsave(&sc->lock, flags);
1671         sc->ds4_dongle_state = dongle_state;
1672         spin_unlock_irqrestore(&sc->lock, flags);
1673 }
1674
1675 static int dualshock4_get_version_info(struct sony_sc *sc)
1676 {
1677         u8 *buf;
1678         int ret;
1679
1680         buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1681         if (!buf)
1682                 return -ENOMEM;
1683
1684         ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1685                                  DS4_FEATURE_REPORT_0xA3_SIZE,
1686                                  HID_FEATURE_REPORT,
1687                                  HID_REQ_GET_REPORT);
1688         if (ret < 0) {
1689                 kfree(buf);
1690                 return ret;
1691         }
1692
1693         sc->hw_version = get_unaligned_le16(&buf[35]);
1694         sc->fw_version = get_unaligned_le16(&buf[41]);
1695
1696         kfree(buf);
1697         return 0;
1698 }
1699
1700 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1701 {
1702         static const u8 sixaxis_leds[10][4] = {
1703                                 { 0x01, 0x00, 0x00, 0x00 },
1704                                 { 0x00, 0x01, 0x00, 0x00 },
1705                                 { 0x00, 0x00, 0x01, 0x00 },
1706                                 { 0x00, 0x00, 0x00, 0x01 },
1707                                 { 0x01, 0x00, 0x00, 0x01 },
1708                                 { 0x00, 0x01, 0x00, 0x01 },
1709                                 { 0x00, 0x00, 0x01, 0x01 },
1710                                 { 0x01, 0x00, 0x01, 0x01 },
1711                                 { 0x00, 0x01, 0x01, 0x01 },
1712                                 { 0x01, 0x01, 0x01, 0x01 }
1713         };
1714
1715         int id = sc->device_id;
1716
1717         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1718
1719         if (id < 0)
1720                 return;
1721
1722         id %= 10;
1723         memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1724 }
1725
1726 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1727 {
1728         /* The first 4 color/index entries match what the PS4 assigns */
1729         static const u8 color_code[7][3] = {
1730                         /* Blue   */    { 0x00, 0x00, 0x40 },
1731                         /* Red    */    { 0x40, 0x00, 0x00 },
1732                         /* Green  */    { 0x00, 0x40, 0x00 },
1733                         /* Pink   */    { 0x20, 0x00, 0x20 },
1734                         /* Orange */    { 0x02, 0x01, 0x00 },
1735                         /* Teal   */    { 0x00, 0x01, 0x01 },
1736                         /* White  */    { 0x01, 0x01, 0x01 }
1737         };
1738
1739         int id = sc->device_id;
1740
1741         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1742
1743         if (id < 0)
1744                 return;
1745
1746         id %= 7;
1747         memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1748 }
1749
1750 static void buzz_set_leds(struct sony_sc *sc)
1751 {
1752         struct hid_device *hdev = sc->hdev;
1753         struct list_head *report_list =
1754                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1755         struct hid_report *report = list_entry(report_list->next,
1756                 struct hid_report, list);
1757         s32 *value = report->field[0]->value;
1758
1759         BUILD_BUG_ON(MAX_LEDS < 4);
1760
1761         value[0] = 0x00;
1762         value[1] = sc->led_state[0] ? 0xff : 0x00;
1763         value[2] = sc->led_state[1] ? 0xff : 0x00;
1764         value[3] = sc->led_state[2] ? 0xff : 0x00;
1765         value[4] = sc->led_state[3] ? 0xff : 0x00;
1766         value[5] = 0x00;
1767         value[6] = 0x00;
1768         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1769 }
1770
1771 static void sony_set_leds(struct sony_sc *sc)
1772 {
1773         if (!(sc->quirks & BUZZ_CONTROLLER))
1774                 sony_schedule_work(sc, SONY_WORKER_STATE);
1775         else
1776                 buzz_set_leds(sc);
1777 }
1778
1779 static void sony_led_set_brightness(struct led_classdev *led,
1780                                     enum led_brightness value)
1781 {
1782         struct device *dev = led->dev->parent;
1783         struct hid_device *hdev = to_hid_device(dev);
1784         struct sony_sc *drv_data;
1785
1786         int n;
1787         int force_update;
1788
1789         drv_data = hid_get_drvdata(hdev);
1790         if (!drv_data) {
1791                 hid_err(hdev, "No device data\n");
1792                 return;
1793         }
1794
1795         /*
1796          * The Sixaxis on USB will override any LED settings sent to it
1797          * and keep flashing all of the LEDs until the PS button is pressed.
1798          * Updates, even if redundant, must be always be sent to the
1799          * controller to avoid having to toggle the state of an LED just to
1800          * stop the flashing later on.
1801          */
1802         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1803
1804         for (n = 0; n < drv_data->led_count; n++) {
1805                 if (led == drv_data->leds[n] && (force_update ||
1806                         (value != drv_data->led_state[n] ||
1807                         drv_data->led_delay_on[n] ||
1808                         drv_data->led_delay_off[n]))) {
1809
1810                         drv_data->led_state[n] = value;
1811
1812                         /* Setting the brightness stops the blinking */
1813                         drv_data->led_delay_on[n] = 0;
1814                         drv_data->led_delay_off[n] = 0;
1815
1816                         sony_set_leds(drv_data);
1817                         break;
1818                 }
1819         }
1820 }
1821
1822 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1823 {
1824         struct device *dev = led->dev->parent;
1825         struct hid_device *hdev = to_hid_device(dev);
1826         struct sony_sc *drv_data;
1827
1828         int n;
1829
1830         drv_data = hid_get_drvdata(hdev);
1831         if (!drv_data) {
1832                 hid_err(hdev, "No device data\n");
1833                 return LED_OFF;
1834         }
1835
1836         for (n = 0; n < drv_data->led_count; n++) {
1837                 if (led == drv_data->leds[n])
1838                         return drv_data->led_state[n];
1839         }
1840
1841         return LED_OFF;
1842 }
1843
1844 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1845                                 unsigned long *delay_off)
1846 {
1847         struct device *dev = led->dev->parent;
1848         struct hid_device *hdev = to_hid_device(dev);
1849         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1850         int n;
1851         u8 new_on, new_off;
1852
1853         if (!drv_data) {
1854                 hid_err(hdev, "No device data\n");
1855                 return -EINVAL;
1856         }
1857
1858         /* Max delay is 255 deciseconds or 2550 milliseconds */
1859         if (*delay_on > 2550)
1860                 *delay_on = 2550;
1861         if (*delay_off > 2550)
1862                 *delay_off = 2550;
1863
1864         /* Blink at 1 Hz if both values are zero */
1865         if (!*delay_on && !*delay_off)
1866                 *delay_on = *delay_off = 500;
1867
1868         new_on = *delay_on / 10;
1869         new_off = *delay_off / 10;
1870
1871         for (n = 0; n < drv_data->led_count; n++) {
1872                 if (led == drv_data->leds[n])
1873                         break;
1874         }
1875
1876         /* This LED is not registered on this device */
1877         if (n >= drv_data->led_count)
1878                 return -EINVAL;
1879
1880         /* Don't schedule work if the values didn't change */
1881         if (new_on != drv_data->led_delay_on[n] ||
1882                 new_off != drv_data->led_delay_off[n]) {
1883                 drv_data->led_delay_on[n] = new_on;
1884                 drv_data->led_delay_off[n] = new_off;
1885                 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1886         }
1887
1888         return 0;
1889 }
1890
1891 static void sony_leds_remove(struct sony_sc *sc)
1892 {
1893         struct led_classdev *led;
1894         int n;
1895
1896         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1897
1898         for (n = 0; n < sc->led_count; n++) {
1899                 led = sc->leds[n];
1900                 sc->leds[n] = NULL;
1901                 if (!led)
1902                         continue;
1903                 led_classdev_unregister(led);
1904                 kfree(led);
1905         }
1906
1907         sc->led_count = 0;
1908 }
1909
1910 static int sony_leds_init(struct sony_sc *sc)
1911 {
1912         struct hid_device *hdev = sc->hdev;
1913         int n, ret = 0;
1914         int use_ds4_names;
1915         struct led_classdev *led;
1916         size_t name_sz;
1917         char *name;
1918         size_t name_len;
1919         const char *name_fmt;
1920         static const char * const ds4_name_str[] = { "red", "green", "blue",
1921                                                   "global" };
1922         u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1923         u8 use_hw_blink[MAX_LEDS] = { 0 };
1924
1925         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1926
1927         if (sc->quirks & BUZZ_CONTROLLER) {
1928                 sc->led_count = 4;
1929                 use_ds4_names = 0;
1930                 name_len = strlen("::buzz#");
1931                 name_fmt = "%s::buzz%d";
1932                 /* Validate expected report characteristics. */
1933                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1934                         return -ENODEV;
1935         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1936                 dualshock4_set_leds_from_id(sc);
1937                 sc->led_state[3] = 1;
1938                 sc->led_count = 4;
1939                 memset(max_brightness, 255, 3);
1940                 use_hw_blink[3] = 1;
1941                 use_ds4_names = 1;
1942                 name_len = 0;
1943                 name_fmt = "%s:%s";
1944         } else if (sc->quirks & MOTION_CONTROLLER) {
1945                 sc->led_count = 3;
1946                 memset(max_brightness, 255, 3);
1947                 use_ds4_names = 1;
1948                 name_len = 0;
1949                 name_fmt = "%s:%s";
1950         } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1951                 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1952
1953                 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1954                 sc->led_count = 1;
1955                 memset(use_hw_blink, 1, 4);
1956                 use_ds4_names = 0;
1957                 name_len = strlen("::sony#");
1958                 name_fmt = "%s::sony%d";
1959         } else {
1960                 sixaxis_set_leds_from_id(sc);
1961                 sc->led_count = 4;
1962                 memset(use_hw_blink, 1, 4);
1963                 use_ds4_names = 0;
1964                 name_len = strlen("::sony#");
1965                 name_fmt = "%s::sony%d";
1966         }
1967
1968         /*
1969          * Clear LEDs as we have no way of reading their initial state. This is
1970          * only relevant if the driver is loaded after somebody actively set the
1971          * LEDs to on
1972          */
1973         sony_set_leds(sc);
1974
1975         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1976
1977         for (n = 0; n < sc->led_count; n++) {
1978
1979                 if (use_ds4_names)
1980                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1981
1982                 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1983                 if (!led) {
1984                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1985                         ret = -ENOMEM;
1986                         goto error_leds;
1987                 }
1988
1989                 name = (void *)(&led[1]);
1990                 if (use_ds4_names)
1991                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1992                         ds4_name_str[n]);
1993                 else
1994                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1995                 led->name = name;
1996                 led->brightness = sc->led_state[n];
1997                 led->max_brightness = max_brightness[n];
1998                 led->flags = LED_CORE_SUSPENDRESUME;
1999                 led->brightness_get = sony_led_get_brightness;
2000                 led->brightness_set = sony_led_set_brightness;
2001
2002                 if (use_hw_blink[n])
2003                         led->blink_set = sony_led_blink_set;
2004
2005                 sc->leds[n] = led;
2006
2007                 ret = led_classdev_register(&hdev->dev, led);
2008                 if (ret) {
2009                         hid_err(hdev, "Failed to register LED %d\n", n);
2010                         sc->leds[n] = NULL;
2011                         kfree(led);
2012                         goto error_leds;
2013                 }
2014         }
2015
2016         return ret;
2017
2018 error_leds:
2019         sony_leds_remove(sc);
2020
2021         return ret;
2022 }
2023
2024 static void sixaxis_send_output_report(struct sony_sc *sc)
2025 {
2026         static const union sixaxis_output_report_01 default_report = {
2027                 .buf = {
2028                         0x01,
2029                         0x01, 0xff, 0x00, 0xff, 0x00,
2030                         0x00, 0x00, 0x00, 0x00, 0x00,
2031                         0xff, 0x27, 0x10, 0x00, 0x32,
2032                         0xff, 0x27, 0x10, 0x00, 0x32,
2033                         0xff, 0x27, 0x10, 0x00, 0x32,
2034                         0xff, 0x27, 0x10, 0x00, 0x32,
2035                         0x00, 0x00, 0x00, 0x00, 0x00
2036                 }
2037         };
2038         struct sixaxis_output_report *report =
2039                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2040         int n;
2041
2042         /* Initialize the report with default values */
2043         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2044
2045 #ifdef CONFIG_SONY_FF
2046         report->rumble.right_motor_on = sc->right ? 1 : 0;
2047         report->rumble.left_motor_force = sc->left;
2048 #endif
2049
2050         report->leds_bitmap |= sc->led_state[0] << 1;
2051         report->leds_bitmap |= sc->led_state[1] << 2;
2052         report->leds_bitmap |= sc->led_state[2] << 3;
2053         report->leds_bitmap |= sc->led_state[3] << 4;
2054
2055         /* Set flag for all leds off, required for 3rd party INTEC controller */
2056         if ((report->leds_bitmap & 0x1E) == 0)
2057                 report->leds_bitmap |= 0x20;
2058
2059         /*
2060          * The LEDs in the report are indexed in reverse order to their
2061          * corresponding light on the controller.
2062          * Index 0 = LED 4, index 1 = LED 3, etc...
2063          *
2064          * In the case of both delay values being zero (blinking disabled) the
2065          * default report values should be used or the controller LED will be
2066          * always off.
2067          */
2068         for (n = 0; n < 4; n++) {
2069                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2070                         report->led[3 - n].duty_off = sc->led_delay_off[n];
2071                         report->led[3 - n].duty_on = sc->led_delay_on[n];
2072                 }
2073         }
2074
2075         hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2076                         sizeof(struct sixaxis_output_report),
2077                         HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2078 }
2079
2080 static void dualshock4_send_output_report(struct sony_sc *sc)
2081 {
2082         struct hid_device *hdev = sc->hdev;
2083         u8 *buf = sc->output_report_dmabuf;
2084         int offset;
2085
2086         /*
2087          * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2088          * control the interval at which Dualshock 4 reports data:
2089          * 0x00 - 1ms
2090          * 0x01 - 1ms
2091          * 0x02 - 2ms
2092          * 0x3E - 62ms
2093          * 0x3F - disabled
2094          */
2095         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2096                 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2097                 buf[0] = 0x05;
2098                 buf[1] = 0x07; /* blink + LEDs + motor */
2099                 offset = 4;
2100         } else {
2101                 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2102                 buf[0] = 0x11;
2103                 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2104                 buf[3] = 0x07; /* blink + LEDs + motor */
2105                 offset = 6;
2106         }
2107
2108 #ifdef CONFIG_SONY_FF
2109         buf[offset++] = sc->right;
2110         buf[offset++] = sc->left;
2111 #else
2112         offset += 2;
2113 #endif
2114
2115         /* LED 3 is the global control */
2116         if (sc->led_state[3]) {
2117                 buf[offset++] = sc->led_state[0];
2118                 buf[offset++] = sc->led_state[1];
2119                 buf[offset++] = sc->led_state[2];
2120         } else {
2121                 offset += 3;
2122         }
2123
2124         /* If both delay values are zero the DualShock 4 disables blinking. */
2125         buf[offset++] = sc->led_delay_on[3];
2126         buf[offset++] = sc->led_delay_off[3];
2127
2128         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2129                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2130         else {
2131                 /* CRC generation */
2132                 u8 bthdr = 0xA2;
2133                 u32 crc;
2134
2135                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2136                 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2137                 put_unaligned_le32(crc, &buf[74]);
2138                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2139         }
2140 }
2141
2142 static void motion_send_output_report(struct sony_sc *sc)
2143 {
2144         struct hid_device *hdev = sc->hdev;
2145         struct motion_output_report_02 *report =
2146                 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2147
2148         memset(report, 0, MOTION_REPORT_0x02_SIZE);
2149
2150         report->type = 0x02; /* set leds */
2151         report->r = sc->led_state[0];
2152         report->g = sc->led_state[1];
2153         report->b = sc->led_state[2];
2154
2155 #ifdef CONFIG_SONY_FF
2156         report->rumble = max(sc->right, sc->left);
2157 #endif
2158
2159         hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2160 }
2161
2162 static inline void sony_send_output_report(struct sony_sc *sc)
2163 {
2164         if (sc->send_output_report)
2165                 sc->send_output_report(sc);
2166 }
2167
2168 static void sony_state_worker(struct work_struct *work)
2169 {
2170         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2171
2172         sc->send_output_report(sc);
2173 }
2174
2175 static int sony_allocate_output_report(struct sony_sc *sc)
2176 {
2177         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2178                         (sc->quirks & NAVIGATION_CONTROLLER))
2179                 sc->output_report_dmabuf =
2180                         kmalloc(sizeof(union sixaxis_output_report_01),
2181                                 GFP_KERNEL);
2182         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2183                 sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x11_SIZE,
2184                                                 GFP_KERNEL);
2185         else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2186                 sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x05_SIZE,
2187                                                 GFP_KERNEL);
2188         else if (sc->quirks & MOTION_CONTROLLER)
2189                 sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
2190                                                 GFP_KERNEL);
2191         else
2192                 return 0;
2193
2194         if (!sc->output_report_dmabuf)
2195                 return -ENOMEM;
2196
2197         return 0;
2198 }
2199
2200 #ifdef CONFIG_SONY_FF
2201 static int sony_play_effect(struct input_dev *dev, void *data,
2202                             struct ff_effect *effect)
2203 {
2204         struct hid_device *hid = input_get_drvdata(dev);
2205         struct sony_sc *sc = hid_get_drvdata(hid);
2206
2207         if (effect->type != FF_RUMBLE)
2208                 return 0;
2209
2210         sc->left = effect->u.rumble.strong_magnitude / 256;
2211         sc->right = effect->u.rumble.weak_magnitude / 256;
2212
2213         sony_schedule_work(sc, SONY_WORKER_STATE);
2214         return 0;
2215 }
2216
2217 static int sony_init_ff(struct sony_sc *sc)
2218 {
2219         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
2220                                                 struct hid_input, list);
2221         struct input_dev *input_dev = hidinput->input;
2222
2223         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2224         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2225 }
2226
2227 #else
2228 static int sony_init_ff(struct sony_sc *sc)
2229 {
2230         return 0;
2231 }
2232
2233 #endif
2234
2235 static int sony_battery_get_property(struct power_supply *psy,
2236                                      enum power_supply_property psp,
2237                                      union power_supply_propval *val)
2238 {
2239         struct sony_sc *sc = power_supply_get_drvdata(psy);
2240         unsigned long flags;
2241         int ret = 0;
2242         u8 battery_charging, battery_capacity, cable_state;
2243
2244         spin_lock_irqsave(&sc->lock, flags);
2245         battery_charging = sc->battery_charging;
2246         battery_capacity = sc->battery_capacity;
2247         cable_state = sc->cable_state;
2248         spin_unlock_irqrestore(&sc->lock, flags);
2249
2250         switch (psp) {
2251         case POWER_SUPPLY_PROP_PRESENT:
2252                 val->intval = 1;
2253                 break;
2254         case POWER_SUPPLY_PROP_SCOPE:
2255                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2256                 break;
2257         case POWER_SUPPLY_PROP_CAPACITY:
2258                 val->intval = battery_capacity;
2259                 break;
2260         case POWER_SUPPLY_PROP_STATUS:
2261                 if (battery_charging)
2262                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
2263                 else
2264                         if (battery_capacity == 100 && cable_state)
2265                                 val->intval = POWER_SUPPLY_STATUS_FULL;
2266                         else
2267                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2268                 break;
2269         default:
2270                 ret = -EINVAL;
2271                 break;
2272         }
2273         return ret;
2274 }
2275
2276 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2277 {
2278         const char *battery_str_fmt = append_dev_id ?
2279                 "sony_controller_battery_%pMR_%i" :
2280                 "sony_controller_battery_%pMR";
2281         struct power_supply_config psy_cfg = { .drv_data = sc, };
2282         struct hid_device *hdev = sc->hdev;
2283         int ret;
2284
2285         /*
2286          * Set the default battery level to 100% to avoid low battery warnings
2287          * if the battery is polled before the first device report is received.
2288          */
2289         sc->battery_capacity = 100;
2290
2291         sc->battery_desc.properties = sony_battery_props;
2292         sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2293         sc->battery_desc.get_property = sony_battery_get_property;
2294         sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2295         sc->battery_desc.use_for_apm = 0;
2296         sc->battery_desc.name = kasprintf(GFP_KERNEL, battery_str_fmt,
2297                                           sc->mac_address, sc->device_id);
2298         if (!sc->battery_desc.name)
2299                 return -ENOMEM;
2300
2301         sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
2302                                             &psy_cfg);
2303         if (IS_ERR(sc->battery)) {
2304                 ret = PTR_ERR(sc->battery);
2305                 hid_err(hdev, "Unable to register battery device\n");
2306                 goto err_free;
2307         }
2308
2309         power_supply_powers(sc->battery, &hdev->dev);
2310         return 0;
2311
2312 err_free:
2313         kfree(sc->battery_desc.name);
2314         sc->battery_desc.name = NULL;
2315         return ret;
2316 }
2317
2318 static void sony_battery_remove(struct sony_sc *sc)
2319 {
2320         if (!sc->battery_desc.name)
2321                 return;
2322
2323         power_supply_unregister(sc->battery);
2324         kfree(sc->battery_desc.name);
2325         sc->battery_desc.name = NULL;
2326 }
2327
2328 /*
2329  * If a controller is plugged in via USB while already connected via Bluetooth
2330  * it will show up as two devices. A global list of connected controllers and
2331  * their MAC addresses is maintained to ensure that a device is only connected
2332  * once.
2333  *
2334  * Some USB-only devices masquerade as Sixaxis controllers and all have the
2335  * same dummy Bluetooth address, so a comparison of the connection type is
2336  * required.  Devices are only rejected in the case where two devices have
2337  * matching Bluetooth addresses on different bus types.
2338  */
2339 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2340                                                 struct sony_sc *sc1)
2341 {
2342         const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2343         const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2344
2345         return sc0_not_bt == sc1_not_bt;
2346 }
2347
2348 static int sony_check_add_dev_list(struct sony_sc *sc)
2349 {
2350         struct sony_sc *entry;
2351         unsigned long flags;
2352         int ret;
2353
2354         spin_lock_irqsave(&sony_dev_list_lock, flags);
2355
2356         list_for_each_entry(entry, &sony_device_list, list_node) {
2357                 ret = memcmp(sc->mac_address, entry->mac_address,
2358                                 sizeof(sc->mac_address));
2359                 if (!ret) {
2360                         if (sony_compare_connection_type(sc, entry)) {
2361                                 ret = 1;
2362                         } else {
2363                                 ret = -EEXIST;
2364                                 hid_info(sc->hdev,
2365                                 "controller with MAC address %pMR already connected\n",
2366                                 sc->mac_address);
2367                         }
2368                         goto unlock;
2369                 }
2370         }
2371
2372         ret = 0;
2373         list_add(&(sc->list_node), &sony_device_list);
2374
2375 unlock:
2376         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2377         return ret;
2378 }
2379
2380 static void sony_remove_dev_list(struct sony_sc *sc)
2381 {
2382         unsigned long flags;
2383
2384         if (sc->list_node.next) {
2385                 spin_lock_irqsave(&sony_dev_list_lock, flags);
2386                 list_del(&(sc->list_node));
2387                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2388         }
2389 }
2390
2391 static int sony_get_bt_devaddr(struct sony_sc *sc)
2392 {
2393         int ret;
2394
2395         /* HIDP stores the device MAC address as a string in the uniq field. */
2396         ret = strlen(sc->hdev->uniq);
2397         if (ret != 17)
2398                 return -EINVAL;
2399
2400         ret = sscanf(sc->hdev->uniq,
2401                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2402                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2403                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2404
2405         if (ret != 6)
2406                 return -EINVAL;
2407
2408         return 0;
2409 }
2410
2411 static int sony_check_add(struct sony_sc *sc)
2412 {
2413         u8 *buf = NULL;
2414         int n, ret;
2415
2416         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2417             (sc->quirks & MOTION_CONTROLLER_BT) ||
2418             (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2419             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2420                 /*
2421                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2422                  * address from the uniq string where HIDP stores it.
2423                  * As uniq cannot be guaranteed to be a MAC address in all cases
2424                  * a failure of this function should not prevent the connection.
2425                  */
2426                 if (sony_get_bt_devaddr(sc) < 0) {
2427                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2428                         return 0;
2429                 }
2430         } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2431                 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2432                 if (!buf)
2433                         return -ENOMEM;
2434
2435                 /*
2436                  * The MAC address of a DS4 controller connected via USB can be
2437                  * retrieved with feature report 0x81. The address begins at
2438                  * offset 1.
2439                  */
2440                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2441                                 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2442                                 HID_REQ_GET_REPORT);
2443
2444                 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2445                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2446                         ret = ret < 0 ? ret : -EINVAL;
2447                         goto out_free;
2448                 }
2449
2450                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2451
2452                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2453                          "%pMR", sc->mac_address);
2454         } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2455                         (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2456                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2457                 if (!buf)
2458                         return -ENOMEM;
2459
2460                 /*
2461                  * The MAC address of a Sixaxis controller connected via USB can
2462                  * be retrieved with feature report 0xf2. The address begins at
2463                  * offset 4.
2464                  */
2465                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2466                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2467                                 HID_REQ_GET_REPORT);
2468
2469                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2470                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2471                         ret = ret < 0 ? ret : -EINVAL;
2472                         goto out_free;
2473                 }
2474
2475                 /*
2476                  * The Sixaxis device MAC in the report is big-endian and must
2477                  * be byte-swapped.
2478                  */
2479                 for (n = 0; n < 6; n++)
2480                         sc->mac_address[5-n] = buf[4+n];
2481
2482                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2483                          "%pMR", sc->mac_address);
2484         } else {
2485                 return 0;
2486         }
2487
2488         ret = sony_check_add_dev_list(sc);
2489
2490 out_free:
2491
2492         kfree(buf);
2493
2494         return ret;
2495 }
2496
2497 static int sony_set_device_id(struct sony_sc *sc)
2498 {
2499         int ret;
2500
2501         /*
2502          * Only DualShock 4 or Sixaxis controllers get an id.
2503          * All others are set to -1.
2504          */
2505         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2506             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2507                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2508                                         GFP_KERNEL);
2509                 if (ret < 0) {
2510                         sc->device_id = -1;
2511                         return ret;
2512                 }
2513                 sc->device_id = ret;
2514         } else {
2515                 sc->device_id = -1;
2516         }
2517
2518         return 0;
2519 }
2520
2521 static void sony_release_device_id(struct sony_sc *sc)
2522 {
2523         if (sc->device_id >= 0) {
2524                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2525                 sc->device_id = -1;
2526         }
2527 }
2528
2529 static inline void sony_init_output_report(struct sony_sc *sc,
2530                                 void (*send_output_report)(struct sony_sc *))
2531 {
2532         sc->send_output_report = send_output_report;
2533
2534         if (!sc->state_worker_initialized)
2535                 INIT_WORK(&sc->state_worker, sony_state_worker);
2536
2537         sc->state_worker_initialized = 1;
2538 }
2539
2540 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2541 {
2542         if (sc->hotplug_worker_initialized)
2543                 cancel_work_sync(&sc->hotplug_worker);
2544         if (sc->state_worker_initialized)
2545                 cancel_work_sync(&sc->state_worker);
2546 }
2547
2548
2549 static int sony_input_configured(struct hid_device *hdev,
2550                                         struct hid_input *hidinput)
2551 {
2552         struct sony_sc *sc = hid_get_drvdata(hdev);
2553         int append_dev_id;
2554         int ret;
2555
2556         ret = sony_set_device_id(sc);
2557         if (ret < 0) {
2558                 hid_err(hdev, "failed to allocate the device id\n");
2559                 goto err_stop;
2560         }
2561
2562         ret = append_dev_id = sony_check_add(sc);
2563         if (ret < 0)
2564                 goto err_stop;
2565
2566         ret = sony_allocate_output_report(sc);
2567         if (ret < 0) {
2568                 hid_err(hdev, "failed to allocate the output report buffer\n");
2569                 goto err_stop;
2570         }
2571
2572         if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2573                 /*
2574                  * The Sony Sixaxis does not handle HID Output Reports on the
2575                  * Interrupt EP like it could, so we need to force HID Output
2576                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
2577                  *
2578                  * There is also another issue about HID Output Reports via USB,
2579                  * the Sixaxis does not want the report_id as part of the data
2580                  * packet, so we have to discard buf[0] when sending the actual
2581                  * control message, even for numbered reports, humpf!
2582                  *
2583                  * Additionally, the Sixaxis on USB isn't properly initialized
2584                  * until the PS logo button is pressed and as such won't retain
2585                  * any state set by an output report, so the initial
2586                  * configuration report is deferred until the first input
2587                  * report arrives.
2588                  */
2589                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2590                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2591                 sc->defer_initialization = 1;
2592
2593                 ret = sixaxis_set_operational_usb(hdev);
2594                 if (ret < 0) {
2595                         hid_err(hdev, "Failed to set controller into operational mode\n");
2596                         goto err_stop;
2597                 }
2598
2599                 sony_init_output_report(sc, sixaxis_send_output_report);
2600         } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2601                 /*
2602                  * The Navigation controller wants output reports sent on the ctrl
2603                  * endpoint when connected via Bluetooth.
2604                  */
2605                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2606
2607                 ret = sixaxis_set_operational_bt(hdev);
2608                 if (ret < 0) {
2609                         hid_err(hdev, "Failed to set controller into operational mode\n");
2610                         goto err_stop;
2611                 }
2612
2613                 sony_init_output_report(sc, sixaxis_send_output_report);
2614         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2615                 /*
2616                  * The Sony Sixaxis does not handle HID Output Reports on the
2617                  * Interrupt EP and the device only becomes active when the
2618                  * PS button is pressed. See comment for Navigation controller
2619                  * above for more details.
2620                  */
2621                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2622                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2623                 sc->defer_initialization = 1;
2624
2625                 ret = sixaxis_set_operational_usb(hdev);
2626                 if (ret < 0) {
2627                         hid_err(hdev, "Failed to set controller into operational mode\n");
2628                         goto err_stop;
2629                 }
2630
2631                 ret = sony_register_sensors(sc);
2632                 if (ret) {
2633                         hid_err(sc->hdev,
2634                         "Unable to initialize motion sensors: %d\n", ret);
2635                         goto err_stop;
2636                 }
2637
2638                 sony_init_output_report(sc, sixaxis_send_output_report);
2639         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2640                 /*
2641                  * The Sixaxis wants output reports sent on the ctrl endpoint
2642                  * when connected via Bluetooth.
2643                  */
2644                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2645
2646                 ret = sixaxis_set_operational_bt(hdev);
2647                 if (ret < 0) {
2648                         hid_err(hdev, "Failed to set controller into operational mode\n");
2649                         goto err_stop;
2650                 }
2651
2652                 ret = sony_register_sensors(sc);
2653                 if (ret) {
2654                         hid_err(sc->hdev,
2655                         "Unable to initialize motion sensors: %d\n", ret);
2656                         goto err_stop;
2657                 }
2658
2659                 sony_init_output_report(sc, sixaxis_send_output_report);
2660         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2661                 ret = dualshock4_get_calibration_data(sc);
2662                 if (ret < 0) {
2663                         hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2664                         goto err_stop;
2665                 }
2666
2667                 ret = dualshock4_get_version_info(sc);
2668                 if (ret < 0) {
2669                         hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2670                         goto err_stop;
2671                 }
2672
2673                 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2674                 if (ret) {
2675                         /* Make zero for cleanup reasons of sysfs entries. */
2676                         sc->fw_version = 0;
2677                         sc->hw_version = 0;
2678                         hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2679                         goto err_stop;
2680                 }
2681
2682                 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2683                 if (ret) {
2684                         sc->hw_version = 0;
2685                         hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2686                         goto err_stop;
2687                 }
2688
2689                 /*
2690                  * The Dualshock 4 touchpad supports 2 touches and has a
2691                  * resolution of 1920x942 (44.86 dots/mm).
2692                  */
2693                 ret = sony_register_touchpad(sc, 2, 1920, 942);
2694                 if (ret) {
2695                         hid_err(sc->hdev,
2696                         "Unable to initialize multi-touch slots: %d\n",
2697                         ret);
2698                         goto err_stop;
2699                 }
2700
2701                 ret = sony_register_sensors(sc);
2702                 if (ret) {
2703                         hid_err(sc->hdev,
2704                         "Unable to initialize motion sensors: %d\n", ret);
2705                         goto err_stop;
2706                 }
2707
2708                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2709                         sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2710                         ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2711                         if (ret)
2712                                 hid_warn(sc->hdev,
2713                                  "can't create sysfs bt_poll_interval attribute err: %d\n",
2714                                  ret);
2715                 }
2716
2717                 if (sc->quirks & DUALSHOCK4_DONGLE) {
2718                         INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2719                         sc->hotplug_worker_initialized = 1;
2720                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2721                 }
2722
2723                 sony_init_output_report(sc, dualshock4_send_output_report);
2724         } else if (sc->quirks & MOTION_CONTROLLER) {
2725                 sony_init_output_report(sc, motion_send_output_report);
2726         } else {
2727                 ret = 0;
2728         }
2729
2730         if (sc->quirks & SONY_LED_SUPPORT) {
2731                 ret = sony_leds_init(sc);
2732                 if (ret < 0)
2733                         goto err_stop;
2734         }
2735
2736         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2737                 ret = sony_battery_probe(sc, append_dev_id);
2738                 if (ret < 0)
2739                         goto err_stop;
2740
2741                 /* Open the device to receive reports with battery info */
2742                 ret = hid_hw_open(hdev);
2743                 if (ret < 0) {
2744                         hid_err(hdev, "hw open failed\n");
2745                         goto err_stop;
2746                 }
2747         }
2748
2749         if (sc->quirks & SONY_FF_SUPPORT) {
2750                 ret = sony_init_ff(sc);
2751                 if (ret < 0)
2752                         goto err_close;
2753         }
2754
2755         return 0;
2756 err_close:
2757         hid_hw_close(hdev);
2758 err_stop:
2759         /* Piggy back on the default ds4_bt_ poll_interval to determine
2760          * if we need to remove the file as we don't know for sure if we
2761          * executed that logic.
2762          */
2763         if (sc->ds4_bt_poll_interval)
2764                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2765         if (sc->fw_version)
2766                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2767         if (sc->hw_version)
2768                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2769         if (sc->quirks & SONY_LED_SUPPORT)
2770                 sony_leds_remove(sc);
2771         if (sc->quirks & SONY_BATTERY_SUPPORT)
2772                 sony_battery_remove(sc);
2773         if (sc->touchpad)
2774                 sony_unregister_touchpad(sc);
2775         if (sc->sensor_dev)
2776                 sony_unregister_sensors(sc);
2777         sony_cancel_work_sync(sc);
2778         kfree(sc->output_report_dmabuf);
2779         sony_remove_dev_list(sc);
2780         sony_release_device_id(sc);
2781         hid_hw_stop(hdev);
2782         return ret;
2783 }
2784
2785 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2786 {
2787         int ret;
2788         unsigned long quirks = id->driver_data;
2789         struct sony_sc *sc;
2790         unsigned int connect_mask = HID_CONNECT_DEFAULT;
2791
2792         if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2793                 quirks |= FUTUREMAX_DANCE_MAT;
2794
2795         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2796         if (sc == NULL) {
2797                 hid_err(hdev, "can't alloc sony descriptor\n");
2798                 return -ENOMEM;
2799         }
2800
2801         spin_lock_init(&sc->lock);
2802
2803         sc->quirks = quirks;
2804         hid_set_drvdata(hdev, sc);
2805         sc->hdev = hdev;
2806
2807         ret = hid_parse(hdev);
2808         if (ret) {
2809                 hid_err(hdev, "parse failed\n");
2810                 return ret;
2811         }
2812
2813         if (sc->quirks & VAIO_RDESC_CONSTANT)
2814                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2815         else if (sc->quirks & SIXAXIS_CONTROLLER)
2816                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2817
2818         /* Patch the hw version on DS3/4 compatible devices, so applications can
2819          * distinguish between the default HID mappings and the mappings defined
2820          * by the Linux game controller spec. This is important for the SDL2
2821          * library, which has a game controller database, which uses device ids
2822          * in combination with version as a key.
2823          */
2824         if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
2825                 hdev->version |= 0x8000;
2826
2827         ret = hid_hw_start(hdev, connect_mask);
2828         if (ret) {
2829                 hid_err(hdev, "hw start failed\n");
2830                 return ret;
2831         }
2832
2833         /* sony_input_configured can fail, but this doesn't result
2834          * in hid_hw_start failures (intended). Check whether
2835          * the HID layer claimed the device else fail.
2836          * We don't know the actual reason for the failure, most
2837          * likely it is due to EEXIST in case of double connection
2838          * of USB and Bluetooth, but could have been due to ENOMEM
2839          * or other reasons as well.
2840          */
2841         if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2842                 hid_err(hdev, "failed to claim input\n");
2843                 return -ENODEV;
2844         }
2845
2846         return ret;
2847 }
2848
2849 static void sony_remove(struct hid_device *hdev)
2850 {
2851         struct sony_sc *sc = hid_get_drvdata(hdev);
2852
2853         hid_hw_close(hdev);
2854
2855         if (sc->quirks & SONY_LED_SUPPORT)
2856                 sony_leds_remove(sc);
2857
2858         if (sc->quirks & SONY_BATTERY_SUPPORT)
2859                 sony_battery_remove(sc);
2860
2861         if (sc->touchpad)
2862                 sony_unregister_touchpad(sc);
2863
2864         if (sc->sensor_dev)
2865                 sony_unregister_sensors(sc);
2866
2867         if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2868                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2869
2870         if (sc->fw_version)
2871                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2872
2873         if (sc->hw_version)
2874                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2875
2876         sony_cancel_work_sync(sc);
2877
2878         kfree(sc->output_report_dmabuf);
2879
2880         sony_remove_dev_list(sc);
2881
2882         sony_release_device_id(sc);
2883
2884         hid_hw_stop(hdev);
2885 }
2886
2887 #ifdef CONFIG_PM
2888
2889 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2890 {
2891 #ifdef CONFIG_SONY_FF
2892
2893         /* On suspend stop any running force-feedback events */
2894         if (SONY_FF_SUPPORT) {
2895                 struct sony_sc *sc = hid_get_drvdata(hdev);
2896
2897                 sc->left = sc->right = 0;
2898                 sony_send_output_report(sc);
2899         }
2900
2901 #endif
2902         return 0;
2903 }
2904
2905 static int sony_resume(struct hid_device *hdev)
2906 {
2907         struct sony_sc *sc = hid_get_drvdata(hdev);
2908
2909         /*
2910          * The Sixaxis and navigation controllers on USB need to be
2911          * reinitialized on resume or they won't behave properly.
2912          */
2913         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2914                 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2915                 sixaxis_set_operational_usb(sc->hdev);
2916                 sc->defer_initialization = 1;
2917         }
2918
2919         return 0;
2920 }
2921
2922 #endif
2923
2924 static const struct hid_device_id sony_devices[] = {
2925         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2926                 .driver_data = SIXAXIS_CONTROLLER_USB },
2927         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2928                 .driver_data = NAVIGATION_CONTROLLER_USB },
2929         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2930                 .driver_data = NAVIGATION_CONTROLLER_BT },
2931         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2932                 .driver_data = MOTION_CONTROLLER_USB },
2933         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2934                 .driver_data = MOTION_CONTROLLER_BT },
2935         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2936                 .driver_data = SIXAXIS_CONTROLLER_BT },
2937         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2938                 .driver_data = VAIO_RDESC_CONSTANT },
2939         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2940                 .driver_data = VAIO_RDESC_CONSTANT },
2941         /*
2942          * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2943          * Logitech joystick from the device descriptor.
2944          */
2945         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2946                 .driver_data = BUZZ_CONTROLLER },
2947         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2948                 .driver_data = BUZZ_CONTROLLER },
2949         /* PS3 BD Remote Control */
2950         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2951                 .driver_data = PS3REMOTE },
2952         /* Logitech Harmony Adapter for PS3 */
2953         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2954                 .driver_data = PS3REMOTE },
2955         /* SMK-Link PS3 BD Remote Control */
2956         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2957                 .driver_data = PS3REMOTE },
2958         /* Sony Dualshock 4 controllers for PS4 */
2959         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2960                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2961         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2962                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2963         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2964                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2965         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2966                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2967         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
2968                 .driver_data = DUALSHOCK4_DONGLE },
2969         /* Nyko Core Controller for PS3 */
2970         { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2971                 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2972         { }
2973 };
2974 MODULE_DEVICE_TABLE(hid, sony_devices);
2975
2976 static struct hid_driver sony_driver = {
2977         .name             = "sony",
2978         .id_table         = sony_devices,
2979         .input_mapping    = sony_mapping,
2980         .input_configured = sony_input_configured,
2981         .probe            = sony_probe,
2982         .remove           = sony_remove,
2983         .report_fixup     = sony_report_fixup,
2984         .raw_event        = sony_raw_event,
2985
2986 #ifdef CONFIG_PM
2987         .suspend          = sony_suspend,
2988         .resume           = sony_resume,
2989         .reset_resume     = sony_resume,
2990 #endif
2991 };
2992
2993 static int __init sony_init(void)
2994 {
2995         dbg_hid("Sony:%s\n", __func__);
2996
2997         return hid_register_driver(&sony_driver);
2998 }
2999
3000 static void __exit sony_exit(void)
3001 {
3002         dbg_hid("Sony:%s\n", __func__);
3003
3004         hid_unregister_driver(&sony_driver);
3005         ida_destroy(&sony_device_id_allocator);
3006 }
3007 module_init(sony_init);
3008 module_exit(sony_exit);
3009
3010 MODULE_LICENSE("GPL");