xref: /openbmc/linux/drivers/hid/hid-sony.c (revision f4356947)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  HID driver for Sony / PS2 / PS3 / PS4 BD devices.
4  *
5  *  Copyright (c) 1999 Andreas Gal
6  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
7  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
8  *  Copyright (c) 2008 Jiri Slaby
9  *  Copyright (c) 2012 David Dillow <dave@thedillows.org>
10  *  Copyright (c) 2006-2013 Jiri Kosina
11  *  Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
12  *  Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
13  *  Copyright (c) 2018 Todd Kelner
14  *  Copyright (c) 2020-2021 Pascal Giard <pascal.giard@etsmtl.ca>
15  *  Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
16  *  Copyright (c) 2021 Daniel Nguyen <daniel.nguyen.1@ens.etsmtl.ca>
17  */
18 
19 /*
20  */
21 
22 /*
23  * NOTE: in order for the Sony PS3 BD Remote Control to be found by
24  * a Bluetooth host, the key combination Start+Enter has to be kept pressed
25  * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
26  *
27  * There will be no PIN request from the device.
28  */
29 
30 #include <linux/device.h>
31 #include <linux/hid.h>
32 #include <linux/module.h>
33 #include <linux/slab.h>
34 #include <linux/leds.h>
35 #include <linux/power_supply.h>
36 #include <linux/spinlock.h>
37 #include <linux/list.h>
38 #include <linux/idr.h>
39 #include <linux/input/mt.h>
40 #include <linux/crc32.h>
41 #include <linux/usb.h>
42 #include <linux/timer.h>
43 #include <asm/unaligned.h>
44 
45 #include "hid-ids.h"
46 
47 #define VAIO_RDESC_CONSTANT       BIT(0)
48 #define SIXAXIS_CONTROLLER_USB    BIT(1)
49 #define SIXAXIS_CONTROLLER_BT     BIT(2)
50 #define BUZZ_CONTROLLER           BIT(3)
51 #define PS3REMOTE                 BIT(4)
52 #define MOTION_CONTROLLER_USB     BIT(5)
53 #define MOTION_CONTROLLER_BT      BIT(6)
54 #define NAVIGATION_CONTROLLER_USB BIT(7)
55 #define NAVIGATION_CONTROLLER_BT  BIT(8)
56 #define SINO_LITE_CONTROLLER      BIT(9)
57 #define FUTUREMAX_DANCE_MAT       BIT(10)
58 #define NSG_MR5U_REMOTE_BT        BIT(11)
59 #define NSG_MR7U_REMOTE_BT        BIT(12)
60 #define SHANWAN_GAMEPAD           BIT(13)
61 #define GH_GUITAR_CONTROLLER      BIT(14)
62 #define GHL_GUITAR_PS3WIIU        BIT(15)
63 #define GHL_GUITAR_PS4            BIT(16)
64 
65 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
66 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
67 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
68 				NAVIGATION_CONTROLLER_BT)
69 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
70 				MOTION_CONTROLLER | NAVIGATION_CONTROLLER)
71 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
72 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER)
73 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
74 #define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
75 
76 #define MAX_LEDS 4
77 #define NSG_MRXU_MAX_X 1667
78 #define NSG_MRXU_MAX_Y 1868
79 
80 /* The PS3/Wii U dongles require a poke every 10 seconds, but the PS4
81  * requires one every 8 seconds. Using 8 seconds for all for simplicity.
82  */
83 #define GHL_GUITAR_POKE_INTERVAL 8 /* In seconds */
84 #define GUITAR_TILT_USAGE 44
85 
86 /* Magic data taken from GHLtarUtility:
87  * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
88  * Note: The Wii U and PS3 dongles happen to share the same!
89  */
90 static const char ghl_ps3wiiu_magic_data[] = {
91 	0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
92 };
93 
94 /* Magic data for the PS4 dongles sniffed with a USB protocol
95  * analyzer.
96  */
97 static const char ghl_ps4_magic_data[] = {
98 	0x30, 0x02, 0x08, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00
99 };
100 
101 /* PS/3 Motion controller */
102 static u8 motion_rdesc[] = {
103 	0x05, 0x01,         /*  Usage Page (Desktop),               */
104 	0x09, 0x04,         /*  Usage (Joystick),                   */
105 	0xA1, 0x01,         /*  Collection (Application),           */
106 	0xA1, 0x02,         /*      Collection (Logical),           */
107 	0x85, 0x01,         /*          Report ID (1),              */
108 	0x75, 0x01,         /*          Report Size (1),            */
109 	0x95, 0x15,         /*          Report Count (21),          */
110 	0x15, 0x00,         /*          Logical Minimum (0),        */
111 	0x25, 0x01,         /*          Logical Maximum (1),        */
112 	0x35, 0x00,         /*          Physical Minimum (0),       */
113 	0x45, 0x01,         /*          Physical Maximum (1),       */
114 	0x05, 0x09,         /*          Usage Page (Button),        */
115 	0x19, 0x01,         /*          Usage Minimum (01h),        */
116 	0x29, 0x15,         /*          Usage Maximum (15h),        */
117 	0x81, 0x02,         /*          Input (Variable),           * Buttons */
118 	0x95, 0x0B,         /*          Report Count (11),          */
119 	0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
120 	0x81, 0x03,         /*          Input (Constant, Variable), * Padding */
121 	0x15, 0x00,         /*          Logical Minimum (0),        */
122 	0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
123 	0x05, 0x01,         /*          Usage Page (Desktop),       */
124 	0xA1, 0x00,         /*          Collection (Physical),      */
125 	0x75, 0x08,         /*              Report Size (8),        */
126 	0x95, 0x01,         /*              Report Count (1),       */
127 	0x35, 0x00,         /*              Physical Minimum (0),   */
128 	0x46, 0xFF, 0x00,   /*              Physical Maximum (255), */
129 	0x09, 0x30,         /*              Usage (X),              */
130 	0x81, 0x02,         /*              Input (Variable),       * Trigger */
131 	0xC0,               /*          End Collection,             */
132 	0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
133 	0x75, 0x08,         /*          Report Size (8),            */
134 	0x95, 0x07,         /*          Report Count (7),           * skip 7 bytes */
135 	0x81, 0x02,         /*          Input (Variable),           */
136 	0x05, 0x01,         /*          Usage Page (Desktop),       */
137 	0x75, 0x10,         /*          Report Size (16),           */
138 	0x46, 0xFF, 0xFF,   /*          Physical Maximum (65535),   */
139 	0x27, 0xFF, 0xFF, 0x00, 0x00, /*      Logical Maximum (65535),    */
140 	0x95, 0x03,         /*          Report Count (3),           * 3x Accels */
141 	0x09, 0x33,         /*              Usage (rX),             */
142 	0x09, 0x34,         /*              Usage (rY),             */
143 	0x09, 0x35,         /*              Usage (rZ),             */
144 	0x81, 0x02,         /*          Input (Variable),           */
145 	0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
146 	0x95, 0x03,         /*          Report Count (3),           * Skip Accels 2nd frame */
147 	0x81, 0x02,         /*          Input (Variable),           */
148 	0x05, 0x01,         /*          Usage Page (Desktop),       */
149 	0x09, 0x01,         /*          Usage (Pointer),            */
150 	0x95, 0x03,         /*          Report Count (3),           * 3x Gyros */
151 	0x81, 0x02,         /*          Input (Variable),           */
152 	0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
153 	0x95, 0x03,         /*          Report Count (3),           * Skip Gyros 2nd frame */
154 	0x81, 0x02,         /*          Input (Variable),           */
155 	0x75, 0x0C,         /*          Report Size (12),           */
156 	0x46, 0xFF, 0x0F,   /*          Physical Maximum (4095),    */
157 	0x26, 0xFF, 0x0F,   /*          Logical Maximum (4095),     */
158 	0x95, 0x04,         /*          Report Count (4),           * Skip Temp and Magnetometers */
159 	0x81, 0x02,         /*          Input (Variable),           */
160 	0x75, 0x08,         /*          Report Size (8),            */
161 	0x46, 0xFF, 0x00,   /*          Physical Maximum (255),     */
162 	0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
163 	0x95, 0x06,         /*          Report Count (6),           * Skip Timestamp and Extension Bytes */
164 	0x81, 0x02,         /*          Input (Variable),           */
165 	0x75, 0x08,         /*          Report Size (8),            */
166 	0x95, 0x30,         /*          Report Count (48),          */
167 	0x09, 0x01,         /*          Usage (Pointer),            */
168 	0x91, 0x02,         /*          Output (Variable),          */
169 	0x75, 0x08,         /*          Report Size (8),            */
170 	0x95, 0x30,         /*          Report Count (48),          */
171 	0x09, 0x01,         /*          Usage (Pointer),            */
172 	0xB1, 0x02,         /*          Feature (Variable),         */
173 	0xC0,               /*      End Collection,                 */
174 	0xA1, 0x02,         /*      Collection (Logical),           */
175 	0x85, 0x02,         /*          Report ID (2),              */
176 	0x75, 0x08,         /*          Report Size (8),            */
177 	0x95, 0x30,         /*          Report Count (48),          */
178 	0x09, 0x01,         /*          Usage (Pointer),            */
179 	0xB1, 0x02,         /*          Feature (Variable),         */
180 	0xC0,               /*      End Collection,                 */
181 	0xA1, 0x02,         /*      Collection (Logical),           */
182 	0x85, 0xEE,         /*          Report ID (238),            */
183 	0x75, 0x08,         /*          Report Size (8),            */
184 	0x95, 0x30,         /*          Report Count (48),          */
185 	0x09, 0x01,         /*          Usage (Pointer),            */
186 	0xB1, 0x02,         /*          Feature (Variable),         */
187 	0xC0,               /*      End Collection,                 */
188 	0xA1, 0x02,         /*      Collection (Logical),           */
189 	0x85, 0xEF,         /*          Report ID (239),            */
190 	0x75, 0x08,         /*          Report Size (8),            */
191 	0x95, 0x30,         /*          Report Count (48),          */
192 	0x09, 0x01,         /*          Usage (Pointer),            */
193 	0xB1, 0x02,         /*          Feature (Variable),         */
194 	0xC0,               /*      End Collection,                 */
195 	0xC0                /*  End Collection                      */
196 };
197 
198 static u8 ps3remote_rdesc[] = {
199 	0x05, 0x01,          /* GUsagePage Generic Desktop */
200 	0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
201 	0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
202 
203 	 /* Use collection 1 for joypad buttons */
204 	 0xA1, 0x02,         /* MCollection Logical (interrelated data) */
205 
206 	  /*
207 	   * Ignore the 1st byte, maybe it is used for a controller
208 	   * number but it's not needed for correct operation
209 	   */
210 	  0x75, 0x08,        /* GReportSize 0x08 [8] */
211 	  0x95, 0x01,        /* GReportCount 0x01 [1] */
212 	  0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
213 
214 	  /*
215 	   * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
216 	   * buttons multiple keypresses are allowed
217 	   */
218 	  0x05, 0x09,        /* GUsagePage Button */
219 	  0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
220 	  0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
221 	  0x14,              /* GLogicalMinimum [0] */
222 	  0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
223 	  0x75, 0x01,        /* GReportSize 0x01 [1] */
224 	  0x95, 0x18,        /* GReportCount 0x18 [24] */
225 	  0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
226 
227 	  0xC0,              /* MEndCollection */
228 
229 	 /* Use collection 2 for remote control buttons */
230 	 0xA1, 0x02,         /* MCollection Logical (interrelated data) */
231 
232 	  /* 5th byte is used for remote control buttons */
233 	  0x05, 0x09,        /* GUsagePage Button */
234 	  0x18,              /* LUsageMinimum [No button pressed] */
235 	  0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
236 	  0x14,              /* GLogicalMinimum [0] */
237 	  0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
238 	  0x75, 0x08,        /* GReportSize 0x08 [8] */
239 	  0x95, 0x01,        /* GReportCount 0x01 [1] */
240 	  0x80,              /* MInput  */
241 
242 	  /*
243 	   * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
244 	   * 0xff and 11th is for press indication
245 	   */
246 	  0x75, 0x08,        /* GReportSize 0x08 [8] */
247 	  0x95, 0x06,        /* GReportCount 0x06 [6] */
248 	  0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
249 
250 	  /* 12th byte is for battery strength */
251 	  0x05, 0x06,        /* GUsagePage Generic Device Controls */
252 	  0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
253 	  0x14,              /* GLogicalMinimum [0] */
254 	  0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
255 	  0x75, 0x08,        /* GReportSize 0x08 [8] */
256 	  0x95, 0x01,        /* GReportCount 0x01 [1] */
257 	  0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
258 
259 	  0xC0,              /* MEndCollection */
260 
261 	 0xC0                /* MEndCollection [Game Pad] */
262 };
263 
264 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
265 	[0x01] = KEY_SELECT,
266 	[0x02] = BTN_THUMBL,		/* L3 */
267 	[0x03] = BTN_THUMBR,		/* R3 */
268 	[0x04] = BTN_START,
269 	[0x05] = KEY_UP,
270 	[0x06] = KEY_RIGHT,
271 	[0x07] = KEY_DOWN,
272 	[0x08] = KEY_LEFT,
273 	[0x09] = BTN_TL2,		/* L2 */
274 	[0x0a] = BTN_TR2,		/* R2 */
275 	[0x0b] = BTN_TL,		/* L1 */
276 	[0x0c] = BTN_TR,		/* R1 */
277 	[0x0d] = KEY_OPTION,		/* options/triangle */
278 	[0x0e] = KEY_BACK,		/* back/circle */
279 	[0x0f] = BTN_0,			/* cross */
280 	[0x10] = KEY_SCREEN,		/* view/square */
281 	[0x11] = KEY_HOMEPAGE,		/* PS button */
282 	[0x14] = KEY_ENTER,
283 };
284 static const unsigned int ps3remote_keymap_remote_buttons[] = {
285 	[0x00] = KEY_1,
286 	[0x01] = KEY_2,
287 	[0x02] = KEY_3,
288 	[0x03] = KEY_4,
289 	[0x04] = KEY_5,
290 	[0x05] = KEY_6,
291 	[0x06] = KEY_7,
292 	[0x07] = KEY_8,
293 	[0x08] = KEY_9,
294 	[0x09] = KEY_0,
295 	[0x0e] = KEY_ESC,		/* return */
296 	[0x0f] = KEY_CLEAR,
297 	[0x16] = KEY_EJECTCD,
298 	[0x1a] = KEY_MENU,		/* top menu */
299 	[0x28] = KEY_TIME,
300 	[0x30] = KEY_PREVIOUS,
301 	[0x31] = KEY_NEXT,
302 	[0x32] = KEY_PLAY,
303 	[0x33] = KEY_REWIND,		/* scan back */
304 	[0x34] = KEY_FORWARD,		/* scan forward */
305 	[0x38] = KEY_STOP,
306 	[0x39] = KEY_PAUSE,
307 	[0x40] = KEY_CONTEXT_MENU,	/* pop up/menu */
308 	[0x60] = KEY_FRAMEBACK,		/* slow/step back */
309 	[0x61] = KEY_FRAMEFORWARD,	/* slow/step forward */
310 	[0x63] = KEY_SUBTITLE,
311 	[0x64] = KEY_AUDIO,
312 	[0x65] = KEY_ANGLE,
313 	[0x70] = KEY_INFO,		/* display */
314 	[0x80] = KEY_BLUE,
315 	[0x81] = KEY_RED,
316 	[0x82] = KEY_GREEN,
317 	[0x83] = KEY_YELLOW,
318 };
319 
320 static const unsigned int buzz_keymap[] = {
321 	/*
322 	 * The controller has 4 remote buzzers, each with one LED and 5
323 	 * buttons.
324 	 *
325 	 * We use the mapping chosen by the controller, which is:
326 	 *
327 	 * Key          Offset
328 	 * -------------------
329 	 * Buzz              1
330 	 * Blue              5
331 	 * Orange            4
332 	 * Green             3
333 	 * Yellow            2
334 	 *
335 	 * So, for example, the orange button on the third buzzer is mapped to
336 	 * BTN_TRIGGER_HAPPY14
337 	 */
338 	 [1] = BTN_TRIGGER_HAPPY1,
339 	 [2] = BTN_TRIGGER_HAPPY2,
340 	 [3] = BTN_TRIGGER_HAPPY3,
341 	 [4] = BTN_TRIGGER_HAPPY4,
342 	 [5] = BTN_TRIGGER_HAPPY5,
343 	 [6] = BTN_TRIGGER_HAPPY6,
344 	 [7] = BTN_TRIGGER_HAPPY7,
345 	 [8] = BTN_TRIGGER_HAPPY8,
346 	 [9] = BTN_TRIGGER_HAPPY9,
347 	[10] = BTN_TRIGGER_HAPPY10,
348 	[11] = BTN_TRIGGER_HAPPY11,
349 	[12] = BTN_TRIGGER_HAPPY12,
350 	[13] = BTN_TRIGGER_HAPPY13,
351 	[14] = BTN_TRIGGER_HAPPY14,
352 	[15] = BTN_TRIGGER_HAPPY15,
353 	[16] = BTN_TRIGGER_HAPPY16,
354 	[17] = BTN_TRIGGER_HAPPY17,
355 	[18] = BTN_TRIGGER_HAPPY18,
356 	[19] = BTN_TRIGGER_HAPPY19,
357 	[20] = BTN_TRIGGER_HAPPY20,
358 };
359 
360 /* The Navigation controller is a partial DS3 and uses the same HID report
361  * and hence the same keymap indices, however not all axes/buttons
362  * are physically present. We use the same axis and button mapping as
363  * the DS3, which uses the Linux gamepad spec.
364  */
365 static const unsigned int navigation_absmap[] = {
366 	[0x30] = ABS_X,
367 	[0x31] = ABS_Y,
368 	[0x33] = ABS_Z, /* L2 */
369 };
370 
371 /* Buttons not physically available on the device, but still available
372  * in the reports are explicitly set to 0 for documentation purposes.
373  */
374 static const unsigned int navigation_keymap[] = {
375 	[0x01] = 0, /* Select */
376 	[0x02] = BTN_THUMBL, /* L3 */
377 	[0x03] = 0, /* R3 */
378 	[0x04] = 0, /* Start */
379 	[0x05] = BTN_DPAD_UP, /* Up */
380 	[0x06] = BTN_DPAD_RIGHT, /* Right */
381 	[0x07] = BTN_DPAD_DOWN, /* Down */
382 	[0x08] = BTN_DPAD_LEFT, /* Left */
383 	[0x09] = BTN_TL2, /* L2 */
384 	[0x0a] = 0, /* R2 */
385 	[0x0b] = BTN_TL, /* L1 */
386 	[0x0c] = 0, /* R1 */
387 	[0x0d] = BTN_NORTH, /* Triangle */
388 	[0x0e] = BTN_EAST, /* Circle */
389 	[0x0f] = BTN_SOUTH, /* Cross */
390 	[0x10] = BTN_WEST, /* Square */
391 	[0x11] = BTN_MODE, /* PS */
392 };
393 
394 static const unsigned int sixaxis_absmap[] = {
395 	[0x30] = ABS_X,
396 	[0x31] = ABS_Y,
397 	[0x32] = ABS_RX, /* right stick X */
398 	[0x35] = ABS_RY, /* right stick Y */
399 };
400 
401 static const unsigned int sixaxis_keymap[] = {
402 	[0x01] = BTN_SELECT, /* Select */
403 	[0x02] = BTN_THUMBL, /* L3 */
404 	[0x03] = BTN_THUMBR, /* R3 */
405 	[0x04] = BTN_START, /* Start */
406 	[0x05] = BTN_DPAD_UP, /* Up */
407 	[0x06] = BTN_DPAD_RIGHT, /* Right */
408 	[0x07] = BTN_DPAD_DOWN, /* Down */
409 	[0x08] = BTN_DPAD_LEFT, /* Left */
410 	[0x09] = BTN_TL2, /* L2 */
411 	[0x0a] = BTN_TR2, /* R2 */
412 	[0x0b] = BTN_TL, /* L1 */
413 	[0x0c] = BTN_TR, /* R1 */
414 	[0x0d] = BTN_NORTH, /* Triangle */
415 	[0x0e] = BTN_EAST, /* Circle */
416 	[0x0f] = BTN_SOUTH, /* Cross */
417 	[0x10] = BTN_WEST, /* Square */
418 	[0x11] = BTN_MODE, /* PS */
419 };
420 
421 static enum power_supply_property sony_battery_props[] = {
422 	POWER_SUPPLY_PROP_PRESENT,
423 	POWER_SUPPLY_PROP_CAPACITY,
424 	POWER_SUPPLY_PROP_SCOPE,
425 	POWER_SUPPLY_PROP_STATUS,
426 };
427 
428 struct sixaxis_led {
429 	u8 time_enabled; /* the total time the led is active (0xff means forever) */
430 	u8 duty_length;  /* how long a cycle is in deciseconds (0 means "really fast") */
431 	u8 enabled;
432 	u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
433 	u8 duty_on;  /* % of duty_length the led is on (0xff mean 100%) */
434 } __packed;
435 
436 struct sixaxis_rumble {
437 	u8 padding;
438 	u8 right_duration; /* Right motor duration (0xff means forever) */
439 	u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
440 	u8 left_duration;    /* Left motor duration (0xff means forever) */
441 	u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
442 } __packed;
443 
444 struct sixaxis_output_report {
445 	u8 report_id;
446 	struct sixaxis_rumble rumble;
447 	u8 padding[4];
448 	u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
449 	struct sixaxis_led led[4];    /* LEDx at (4 - x) */
450 	struct sixaxis_led _reserved; /* LED5, not actually soldered */
451 } __packed;
452 
453 union sixaxis_output_report_01 {
454 	struct sixaxis_output_report data;
455 	u8 buf[36];
456 };
457 
458 struct motion_output_report_02 {
459 	u8 type, zero;
460 	u8 r, g, b;
461 	u8 zero2;
462 	u8 rumble;
463 };
464 
465 #define SIXAXIS_REPORT_0xF2_SIZE 17
466 #define SIXAXIS_REPORT_0xF5_SIZE 8
467 #define MOTION_REPORT_0x02_SIZE 49
468 
469 #define SENSOR_SUFFIX " Motion Sensors"
470 #define TOUCHPAD_SUFFIX " Touchpad"
471 
472 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
473 #define SIXAXIS_ACC_RES_PER_G 113
474 
475 static DEFINE_SPINLOCK(sony_dev_list_lock);
476 static LIST_HEAD(sony_device_list);
477 static DEFINE_IDA(sony_device_id_allocator);
478 
479 enum sony_worker {
480 	SONY_WORKER_STATE
481 };
482 
483 struct sony_sc {
484 	spinlock_t lock;
485 	struct list_head list_node;
486 	struct hid_device *hdev;
487 	struct input_dev *touchpad;
488 	struct input_dev *sensor_dev;
489 	struct led_classdev *leds[MAX_LEDS];
490 	unsigned long quirks;
491 	struct work_struct state_worker;
492 	void (*send_output_report)(struct sony_sc *);
493 	struct power_supply *battery;
494 	struct power_supply_desc battery_desc;
495 	int device_id;
496 	u8 *output_report_dmabuf;
497 
498 #ifdef CONFIG_SONY_FF
499 	u8 left;
500 	u8 right;
501 #endif
502 
503 	u8 mac_address[6];
504 	u8 state_worker_initialized;
505 	u8 defer_initialization;
506 	u8 battery_capacity;
507 	int battery_status;
508 	u8 led_state[MAX_LEDS];
509 	u8 led_delay_on[MAX_LEDS];
510 	u8 led_delay_off[MAX_LEDS];
511 	u8 led_count;
512 
513 	/* GH Live */
514 	struct urb *ghl_urb;
515 	struct timer_list ghl_poke_timer;
516 };
517 
518 static void sony_set_leds(struct sony_sc *sc);
519 
520 static inline void sony_schedule_work(struct sony_sc *sc,
521 				      enum sony_worker which)
522 {
523 	unsigned long flags;
524 
525 	switch (which) {
526 	case SONY_WORKER_STATE:
527 		spin_lock_irqsave(&sc->lock, flags);
528 		if (!sc->defer_initialization && sc->state_worker_initialized)
529 			schedule_work(&sc->state_worker);
530 		spin_unlock_irqrestore(&sc->lock, flags);
531 		break;
532 	}
533 }
534 
535 static void ghl_magic_poke_cb(struct urb *urb)
536 {
537 	struct sony_sc *sc = urb->context;
538 
539 	if (urb->status < 0)
540 		hid_err(sc->hdev, "URB transfer failed : %d", urb->status);
541 
542 	mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
543 }
544 
545 static void ghl_magic_poke(struct timer_list *t)
546 {
547 	int ret;
548 	struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
549 
550 	ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC);
551 	if (ret < 0)
552 		hid_err(sc->hdev, "usb_submit_urb failed: %d", ret);
553 }
554 
555 static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev,
556 					   const char ghl_magic_data[], u16 poke_size)
557 {
558 	struct usb_ctrlrequest *cr;
559 	u8 *databuf;
560 	unsigned int pipe;
561 	u16 ghl_magic_value = (((HID_OUTPUT_REPORT + 1) << 8) | ghl_magic_data[0]);
562 
563 	pipe = usb_sndctrlpipe(usbdev, 0);
564 
565 	cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
566 	if (cr == NULL)
567 		return -ENOMEM;
568 
569 	databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
570 	if (databuf == NULL)
571 		return -ENOMEM;
572 
573 	cr->bRequestType =
574 		USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
575 	cr->bRequest = USB_REQ_SET_CONFIGURATION;
576 	cr->wValue = cpu_to_le16(ghl_magic_value);
577 	cr->wIndex = 0;
578 	cr->wLength = cpu_to_le16(poke_size);
579 	memcpy(databuf, ghl_magic_data, poke_size);
580 	usb_fill_control_urb(
581 		sc->ghl_urb, usbdev, pipe,
582 		(unsigned char *) cr, databuf, poke_size,
583 		ghl_magic_poke_cb, sc);
584 	return 0;
585 }
586 
587 static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
588 			  struct hid_field *field, struct hid_usage *usage,
589 			  unsigned long **bit, int *max)
590 {
591 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
592 		unsigned int abs = usage->hid & HID_USAGE;
593 
594 		if (abs == GUITAR_TILT_USAGE) {
595 			hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
596 			return 1;
597 		}
598 	}
599 	return 0;
600 }
601 
602 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
603 			     unsigned int *rsize)
604 {
605 	*rsize = sizeof(motion_rdesc);
606 	return motion_rdesc;
607 }
608 
609 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
610 			     unsigned int *rsize)
611 {
612 	*rsize = sizeof(ps3remote_rdesc);
613 	return ps3remote_rdesc;
614 }
615 
616 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
617 			     struct hid_field *field, struct hid_usage *usage,
618 			     unsigned long **bit, int *max)
619 {
620 	unsigned int key = usage->hid & HID_USAGE;
621 
622 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
623 		return -1;
624 
625 	switch (usage->collection_index) {
626 	case 1:
627 		if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
628 			return -1;
629 
630 		key = ps3remote_keymap_joypad_buttons[key];
631 		if (!key)
632 			return -1;
633 		break;
634 	case 2:
635 		if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
636 			return -1;
637 
638 		key = ps3remote_keymap_remote_buttons[key];
639 		if (!key)
640 			return -1;
641 		break;
642 	default:
643 		return -1;
644 	}
645 
646 	hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
647 	return 1;
648 }
649 
650 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
651 			  struct hid_field *field, struct hid_usage *usage,
652 			  unsigned long **bit, int *max)
653 {
654 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
655 		unsigned int key = usage->hid & HID_USAGE;
656 
657 		if (key >= ARRAY_SIZE(sixaxis_keymap))
658 			return -1;
659 
660 		key = navigation_keymap[key];
661 		if (!key)
662 			return -1;
663 
664 		hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
665 		return 1;
666 	} else if (usage->hid == HID_GD_POINTER) {
667 		/* See comment in sixaxis_mapping, basically the L2 (and R2)
668 		 * triggers are reported through GD Pointer.
669 		 * In addition we ignore any analog button 'axes' and only
670 		 * support digital buttons.
671 		 */
672 		switch (usage->usage_index) {
673 		case 8: /* L2 */
674 			usage->hid = HID_GD_Z;
675 			break;
676 		default:
677 			return -1;
678 		}
679 
680 		hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
681 		return 1;
682 	} else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
683 		unsigned int abs = usage->hid & HID_USAGE;
684 
685 		if (abs >= ARRAY_SIZE(navigation_absmap))
686 			return -1;
687 
688 		abs = navigation_absmap[abs];
689 
690 		hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
691 		return 1;
692 	}
693 
694 	return -1;
695 }
696 
697 
698 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
699 			  struct hid_field *field, struct hid_usage *usage,
700 			  unsigned long **bit, int *max)
701 {
702 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
703 		unsigned int key = usage->hid & HID_USAGE;
704 
705 		if (key >= ARRAY_SIZE(sixaxis_keymap))
706 			return -1;
707 
708 		key = sixaxis_keymap[key];
709 		hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
710 		return 1;
711 	} else if (usage->hid == HID_GD_POINTER) {
712 		/* The DS3 provides analog values for most buttons and even
713 		 * for HAT axes through GD Pointer. L2 and R2 are reported
714 		 * among these as well instead of as GD Z / RZ. Remap L2
715 		 * and R2 and ignore other analog 'button axes' as there is
716 		 * no good way for reporting them.
717 		 */
718 		switch (usage->usage_index) {
719 		case 8: /* L2 */
720 			usage->hid = HID_GD_Z;
721 			break;
722 		case 9: /* R2 */
723 			usage->hid = HID_GD_RZ;
724 			break;
725 		default:
726 			return -1;
727 		}
728 
729 		hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
730 		return 1;
731 	} else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
732 		unsigned int abs = usage->hid & HID_USAGE;
733 
734 		if (abs >= ARRAY_SIZE(sixaxis_absmap))
735 			return -1;
736 
737 		abs = sixaxis_absmap[abs];
738 
739 		hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
740 		return 1;
741 	}
742 
743 	return -1;
744 }
745 
746 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
747 		unsigned int *rsize)
748 {
749 	struct sony_sc *sc = hid_get_drvdata(hdev);
750 
751 	if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
752 		return rdesc;
753 
754 	/*
755 	 * Some Sony RF receivers wrongly declare the mouse pointer as a
756 	 * a constant non-data variable.
757 	 */
758 	if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
759 	    /* usage page: generic desktop controls */
760 	    /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
761 	    /* usage: mouse */
762 	    rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
763 	    /* input (usage page for x,y axes): constant, variable, relative */
764 	    rdesc[54] == 0x81 && rdesc[55] == 0x07) {
765 		hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
766 		/* input: data, variable, relative */
767 		rdesc[55] = 0x06;
768 	}
769 
770 	if (sc->quirks & MOTION_CONTROLLER)
771 		return motion_fixup(hdev, rdesc, rsize);
772 
773 	if (sc->quirks & PS3REMOTE)
774 		return ps3remote_fixup(hdev, rdesc, rsize);
775 
776 	/*
777 	 * Some knock-off USB dongles incorrectly report their button count
778 	 * as 13 instead of 16 causing three non-functional buttons.
779 	 */
780 	if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
781 		/* Report Count (13) */
782 		rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
783 		/* Usage Maximum (13) */
784 		rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
785 		/* Report Count (3) */
786 		rdesc[43] == 0x95 && rdesc[44] == 0x03) {
787 		hid_info(hdev, "Fixing up USB dongle report descriptor\n");
788 		rdesc[24] = 0x10;
789 		rdesc[38] = 0x10;
790 		rdesc[44] = 0x00;
791 	}
792 
793 	return rdesc;
794 }
795 
796 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
797 {
798 	static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
799 	unsigned long flags;
800 	int offset;
801 	u8 battery_capacity;
802 	int battery_status;
803 
804 	/*
805 	 * The sixaxis is charging if the battery value is 0xee
806 	 * and it is fully charged if the value is 0xef.
807 	 * It does not report the actual level while charging so it
808 	 * is set to 100% while charging is in progress.
809 	 */
810 	offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
811 
812 	if (rd[offset] >= 0xee) {
813 		battery_capacity = 100;
814 		battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
815 	} else {
816 		u8 index = rd[offset] <= 5 ? rd[offset] : 5;
817 		battery_capacity = sixaxis_battery_capacity[index];
818 		battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
819 	}
820 
821 	spin_lock_irqsave(&sc->lock, flags);
822 	sc->battery_capacity = battery_capacity;
823 	sc->battery_status = battery_status;
824 	spin_unlock_irqrestore(&sc->lock, flags);
825 
826 	if (sc->quirks & SIXAXIS_CONTROLLER) {
827 		int val;
828 
829 		offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
830 		val = ((rd[offset+1] << 8) | rd[offset]) - 511;
831 		input_report_abs(sc->sensor_dev, ABS_X, val);
832 
833 		/* Y and Z are swapped and inversed */
834 		val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
835 		input_report_abs(sc->sensor_dev, ABS_Y, val);
836 
837 		val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
838 		input_report_abs(sc->sensor_dev, ABS_Z, val);
839 
840 		input_sync(sc->sensor_dev);
841 	}
842 }
843 
844 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
845 {
846 	int n, offset, relx, rely;
847 	u8 active;
848 
849 	/*
850 	 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
851 	 *   the touch-related data starts at offset 2.
852 	 * For the first byte, bit 0 is set when touchpad button is pressed.
853 	 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
854 	 * This drag key is mapped to BTN_LEFT.  It is operational only when a
855 	 *   touch point is active.
856 	 * Bit 4 is set when only the first touch point is active.
857 	 * Bit 6 is set when only the second touch point is active.
858 	 * Bits 5 and 7 are set when both touch points are active.
859 	 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
860 	 * The following byte, offset 5, has the touch width and length.
861 	 *   Bits 0-4=X (width), bits 5-7=Y (length).
862 	 * A signed relative X coordinate is at offset 6.
863 	 * The bytes at offset 7-9 are the second touch X/Y coordinates.
864 	 * Offset 10 has the second touch width and length.
865 	 * Offset 11 has the relative Y coordinate.
866 	 */
867 	offset = 1;
868 
869 	input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
870 	active = (rd[offset] >> 4);
871 	relx = (s8) rd[offset+5];
872 	rely = ((s8) rd[offset+10]) * -1;
873 
874 	offset++;
875 
876 	for (n = 0; n < 2; n++) {
877 		u16 x, y;
878 		u8 contactx, contacty;
879 
880 		x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
881 		y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
882 
883 		input_mt_slot(sc->touchpad, n);
884 		input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
885 
886 		if (active & 0x03) {
887 			contactx = rd[offset+3] & 0x0F;
888 			contacty = rd[offset+3] >> 4;
889 			input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
890 				max(contactx, contacty));
891 			input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
892 				min(contactx, contacty));
893 			input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
894 				(bool) (contactx > contacty));
895 			input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
896 			input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
897 				NSG_MRXU_MAX_Y - y);
898 			/*
899 			 * The relative coordinates belong to the first touch
900 			 * point, when present, or to the second touch point
901 			 * when the first is not active.
902 			 */
903 			if ((n == 0) || ((n == 1) && (active & 0x01))) {
904 				input_report_rel(sc->touchpad, REL_X, relx);
905 				input_report_rel(sc->touchpad, REL_Y, rely);
906 			}
907 		}
908 
909 		offset += 5;
910 		active >>= 2;
911 	}
912 
913 	input_mt_sync_frame(sc->touchpad);
914 
915 	input_sync(sc->touchpad);
916 }
917 
918 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
919 		u8 *rd, int size)
920 {
921 	struct sony_sc *sc = hid_get_drvdata(hdev);
922 
923 	/*
924 	 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
925 	 * has to be BYTE_SWAPPED before passing up to joystick interface
926 	 */
927 	if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
928 		/*
929 		 * When connected via Bluetooth the Sixaxis occasionally sends
930 		 * a report with the second byte 0xff and the rest zeroed.
931 		 *
932 		 * This report does not reflect the actual state of the
933 		 * controller must be ignored to avoid generating false input
934 		 * events.
935 		 */
936 		if (rd[1] == 0xff)
937 			return -EINVAL;
938 
939 		swap(rd[41], rd[42]);
940 		swap(rd[43], rd[44]);
941 		swap(rd[45], rd[46]);
942 		swap(rd[47], rd[48]);
943 
944 		sixaxis_parse_report(sc, rd, size);
945 	} else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
946 		sixaxis_parse_report(sc, rd, size);
947 	} else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
948 			size == 49) {
949 		sixaxis_parse_report(sc, rd, size);
950 	} else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
951 		nsg_mrxu_parse_report(sc, rd, size);
952 		return 1;
953 	}
954 
955 	if (sc->defer_initialization) {
956 		sc->defer_initialization = 0;
957 		sony_schedule_work(sc, SONY_WORKER_STATE);
958 	}
959 
960 	return 0;
961 }
962 
963 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
964 			struct hid_field *field, struct hid_usage *usage,
965 			unsigned long **bit, int *max)
966 {
967 	struct sony_sc *sc = hid_get_drvdata(hdev);
968 
969 	if (sc->quirks & BUZZ_CONTROLLER) {
970 		unsigned int key = usage->hid & HID_USAGE;
971 
972 		if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
973 			return -1;
974 
975 		switch (usage->collection_index) {
976 		case 1:
977 			if (key >= ARRAY_SIZE(buzz_keymap))
978 				return -1;
979 
980 			key = buzz_keymap[key];
981 			if (!key)
982 				return -1;
983 			break;
984 		default:
985 			return -1;
986 		}
987 
988 		hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
989 		return 1;
990 	}
991 
992 	if (sc->quirks & PS3REMOTE)
993 		return ps3remote_mapping(hdev, hi, field, usage, bit, max);
994 
995 	if (sc->quirks & NAVIGATION_CONTROLLER)
996 		return navigation_mapping(hdev, hi, field, usage, bit, max);
997 
998 	if (sc->quirks & SIXAXIS_CONTROLLER)
999 		return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1000 
1001 	if (sc->quirks & GH_GUITAR_CONTROLLER)
1002 		return guitar_mapping(hdev, hi, field, usage, bit, max);
1003 
1004 	/* Let hid-core decide for the others */
1005 	return 0;
1006 }
1007 
1008 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1009 		int w, int h, int touch_major, int touch_minor, int orientation)
1010 {
1011 	size_t name_sz;
1012 	char *name;
1013 	int ret;
1014 
1015 	sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1016 	if (!sc->touchpad)
1017 		return -ENOMEM;
1018 
1019 	input_set_drvdata(sc->touchpad, sc);
1020 	sc->touchpad->dev.parent = &sc->hdev->dev;
1021 	sc->touchpad->phys = sc->hdev->phys;
1022 	sc->touchpad->uniq = sc->hdev->uniq;
1023 	sc->touchpad->id.bustype = sc->hdev->bus;
1024 	sc->touchpad->id.vendor = sc->hdev->vendor;
1025 	sc->touchpad->id.product = sc->hdev->product;
1026 	sc->touchpad->id.version = sc->hdev->version;
1027 
1028 	/* This suffix was originally apended when hid-sony also
1029 	 * supported DS4 devices. The DS4 was implemented using multiple
1030 	 * evdev nodes and hence had the need to separete them out using
1031 	 * a suffix. Other devices which were added later like Sony TV remotes
1032 	 * inhirited this suffix.
1033 	 */
1034 	name_sz = strlen(sc->hdev->name) + sizeof(TOUCHPAD_SUFFIX);
1035 	name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1036 	if (!name)
1037 		return -ENOMEM;
1038 	snprintf(name, name_sz, "%s" TOUCHPAD_SUFFIX, sc->hdev->name);
1039 	sc->touchpad->name = name;
1040 
1041 	/* We map the button underneath the touchpad to BTN_LEFT. */
1042 	__set_bit(EV_KEY, sc->touchpad->evbit);
1043 	__set_bit(BTN_LEFT, sc->touchpad->keybit);
1044 	__set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1045 
1046 	input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1047 	input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1048 
1049 	if (touch_major > 0) {
1050 		input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1051 			0, touch_major, 0, 0);
1052 		if (touch_minor > 0)
1053 			input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1054 				0, touch_minor, 0, 0);
1055 		if (orientation > 0)
1056 			input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1057 				0, orientation, 0, 0);
1058 	}
1059 
1060 	if (sc->quirks & NSG_MRXU_REMOTE) {
1061 		__set_bit(EV_REL, sc->touchpad->evbit);
1062 	}
1063 
1064 	ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1065 	if (ret < 0)
1066 		return ret;
1067 
1068 	ret = input_register_device(sc->touchpad);
1069 	if (ret < 0)
1070 		return ret;
1071 
1072 	return 0;
1073 }
1074 
1075 static int sony_register_sensors(struct sony_sc *sc)
1076 {
1077 	size_t name_sz;
1078 	char *name;
1079 	int ret;
1080 
1081 	sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1082 	if (!sc->sensor_dev)
1083 		return -ENOMEM;
1084 
1085 	input_set_drvdata(sc->sensor_dev, sc);
1086 	sc->sensor_dev->dev.parent = &sc->hdev->dev;
1087 	sc->sensor_dev->phys = sc->hdev->phys;
1088 	sc->sensor_dev->uniq = sc->hdev->uniq;
1089 	sc->sensor_dev->id.bustype = sc->hdev->bus;
1090 	sc->sensor_dev->id.vendor = sc->hdev->vendor;
1091 	sc->sensor_dev->id.product = sc->hdev->product;
1092 	sc->sensor_dev->id.version = sc->hdev->version;
1093 
1094 	/* Append a suffix to the controller name as there are various
1095 	 * DS4 compatible non-Sony devices with different names.
1096 	 */
1097 	name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1098 	name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1099 	if (!name)
1100 		return -ENOMEM;
1101 	snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1102 	sc->sensor_dev->name = name;
1103 
1104 	if (sc->quirks & SIXAXIS_CONTROLLER) {
1105 		/* For the DS3 we only support the accelerometer, which works
1106 		 * quite well even without calibration. The device also has
1107 		 * a 1-axis gyro, but it is very difficult to manage from within
1108 		 * the driver even to get data, the sensor is inaccurate and
1109 		 * the behavior is very different between hardware revisions.
1110 		 */
1111 		input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1112 		input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1113 		input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1114 		input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1115 		input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1116 		input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1117 	}
1118 
1119 	__set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1120 
1121 	ret = input_register_device(sc->sensor_dev);
1122 	if (ret < 0)
1123 		return ret;
1124 
1125 	return 0;
1126 }
1127 
1128 /*
1129  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1130  * to "operational".  Without this, the ps3 controller will not report any
1131  * events.
1132  */
1133 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1134 {
1135 	struct sony_sc *sc = hid_get_drvdata(hdev);
1136 	const int buf_size =
1137 		max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1138 	u8 *buf;
1139 	int ret;
1140 
1141 	buf = kmalloc(buf_size, GFP_KERNEL);
1142 	if (!buf)
1143 		return -ENOMEM;
1144 
1145 	ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1146 				 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1147 	if (ret < 0) {
1148 		hid_err(hdev, "can't set operational mode: step 1\n");
1149 		goto out;
1150 	}
1151 
1152 	/*
1153 	 * Some compatible controllers like the Speedlink Strike FX and
1154 	 * Gasia need another query plus an USB interrupt to get operational.
1155 	 */
1156 	ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1157 				 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1158 	if (ret < 0) {
1159 		hid_err(hdev, "can't set operational mode: step 2\n");
1160 		goto out;
1161 	}
1162 
1163 	/*
1164 	 * But the USB interrupt would cause SHANWAN controllers to
1165 	 * start rumbling non-stop, so skip step 3 for these controllers.
1166 	 */
1167 	if (sc->quirks & SHANWAN_GAMEPAD)
1168 		goto out;
1169 
1170 	ret = hid_hw_output_report(hdev, buf, 1);
1171 	if (ret < 0) {
1172 		hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1173 		ret = 0;
1174 	}
1175 
1176 out:
1177 	kfree(buf);
1178 
1179 	return ret;
1180 }
1181 
1182 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1183 {
1184 	static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1185 	u8 *buf;
1186 	int ret;
1187 
1188 	buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1189 	if (!buf)
1190 		return -ENOMEM;
1191 
1192 	ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1193 				  HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1194 
1195 	kfree(buf);
1196 
1197 	return ret;
1198 }
1199 
1200 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1201 {
1202 	static const u8 sixaxis_leds[10][4] = {
1203 				{ 0x01, 0x00, 0x00, 0x00 },
1204 				{ 0x00, 0x01, 0x00, 0x00 },
1205 				{ 0x00, 0x00, 0x01, 0x00 },
1206 				{ 0x00, 0x00, 0x00, 0x01 },
1207 				{ 0x01, 0x00, 0x00, 0x01 },
1208 				{ 0x00, 0x01, 0x00, 0x01 },
1209 				{ 0x00, 0x00, 0x01, 0x01 },
1210 				{ 0x01, 0x00, 0x01, 0x01 },
1211 				{ 0x00, 0x01, 0x01, 0x01 },
1212 				{ 0x01, 0x01, 0x01, 0x01 }
1213 	};
1214 
1215 	int id = sc->device_id;
1216 
1217 	BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1218 
1219 	if (id < 0)
1220 		return;
1221 
1222 	id %= 10;
1223 	memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1224 }
1225 
1226 static void buzz_set_leds(struct sony_sc *sc)
1227 {
1228 	struct hid_device *hdev = sc->hdev;
1229 	struct list_head *report_list =
1230 		&hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1231 	struct hid_report *report = list_entry(report_list->next,
1232 		struct hid_report, list);
1233 	s32 *value = report->field[0]->value;
1234 
1235 	BUILD_BUG_ON(MAX_LEDS < 4);
1236 
1237 	value[0] = 0x00;
1238 	value[1] = sc->led_state[0] ? 0xff : 0x00;
1239 	value[2] = sc->led_state[1] ? 0xff : 0x00;
1240 	value[3] = sc->led_state[2] ? 0xff : 0x00;
1241 	value[4] = sc->led_state[3] ? 0xff : 0x00;
1242 	value[5] = 0x00;
1243 	value[6] = 0x00;
1244 	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1245 }
1246 
1247 static void sony_set_leds(struct sony_sc *sc)
1248 {
1249 	if (!(sc->quirks & BUZZ_CONTROLLER))
1250 		sony_schedule_work(sc, SONY_WORKER_STATE);
1251 	else
1252 		buzz_set_leds(sc);
1253 }
1254 
1255 static void sony_led_set_brightness(struct led_classdev *led,
1256 				    enum led_brightness value)
1257 {
1258 	struct device *dev = led->dev->parent;
1259 	struct hid_device *hdev = to_hid_device(dev);
1260 	struct sony_sc *drv_data;
1261 
1262 	int n;
1263 	int force_update;
1264 
1265 	drv_data = hid_get_drvdata(hdev);
1266 	if (!drv_data) {
1267 		hid_err(hdev, "No device data\n");
1268 		return;
1269 	}
1270 
1271 	/*
1272 	 * The Sixaxis on USB will override any LED settings sent to it
1273 	 * and keep flashing all of the LEDs until the PS button is pressed.
1274 	 * Updates, even if redundant, must be always be sent to the
1275 	 * controller to avoid having to toggle the state of an LED just to
1276 	 * stop the flashing later on.
1277 	 */
1278 	force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1279 
1280 	for (n = 0; n < drv_data->led_count; n++) {
1281 		if (led == drv_data->leds[n] && (force_update ||
1282 			(value != drv_data->led_state[n] ||
1283 			drv_data->led_delay_on[n] ||
1284 			drv_data->led_delay_off[n]))) {
1285 
1286 			drv_data->led_state[n] = value;
1287 
1288 			/* Setting the brightness stops the blinking */
1289 			drv_data->led_delay_on[n] = 0;
1290 			drv_data->led_delay_off[n] = 0;
1291 
1292 			sony_set_leds(drv_data);
1293 			break;
1294 		}
1295 	}
1296 }
1297 
1298 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1299 {
1300 	struct device *dev = led->dev->parent;
1301 	struct hid_device *hdev = to_hid_device(dev);
1302 	struct sony_sc *drv_data;
1303 
1304 	int n;
1305 
1306 	drv_data = hid_get_drvdata(hdev);
1307 	if (!drv_data) {
1308 		hid_err(hdev, "No device data\n");
1309 		return LED_OFF;
1310 	}
1311 
1312 	for (n = 0; n < drv_data->led_count; n++) {
1313 		if (led == drv_data->leds[n])
1314 			return drv_data->led_state[n];
1315 	}
1316 
1317 	return LED_OFF;
1318 }
1319 
1320 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1321 				unsigned long *delay_off)
1322 {
1323 	struct device *dev = led->dev->parent;
1324 	struct hid_device *hdev = to_hid_device(dev);
1325 	struct sony_sc *drv_data = hid_get_drvdata(hdev);
1326 	int n;
1327 	u8 new_on, new_off;
1328 
1329 	if (!drv_data) {
1330 		hid_err(hdev, "No device data\n");
1331 		return -EINVAL;
1332 	}
1333 
1334 	/* Max delay is 255 deciseconds or 2550 milliseconds */
1335 	if (*delay_on > 2550)
1336 		*delay_on = 2550;
1337 	if (*delay_off > 2550)
1338 		*delay_off = 2550;
1339 
1340 	/* Blink at 1 Hz if both values are zero */
1341 	if (!*delay_on && !*delay_off)
1342 		*delay_on = *delay_off = 500;
1343 
1344 	new_on = *delay_on / 10;
1345 	new_off = *delay_off / 10;
1346 
1347 	for (n = 0; n < drv_data->led_count; n++) {
1348 		if (led == drv_data->leds[n])
1349 			break;
1350 	}
1351 
1352 	/* This LED is not registered on this device */
1353 	if (n >= drv_data->led_count)
1354 		return -EINVAL;
1355 
1356 	/* Don't schedule work if the values didn't change */
1357 	if (new_on != drv_data->led_delay_on[n] ||
1358 		new_off != drv_data->led_delay_off[n]) {
1359 		drv_data->led_delay_on[n] = new_on;
1360 		drv_data->led_delay_off[n] = new_off;
1361 		sony_schedule_work(drv_data, SONY_WORKER_STATE);
1362 	}
1363 
1364 	return 0;
1365 }
1366 
1367 static int sony_leds_init(struct sony_sc *sc)
1368 {
1369 	struct hid_device *hdev = sc->hdev;
1370 	int n, ret = 0;
1371 	int use_color_names;
1372 	struct led_classdev *led;
1373 	size_t name_sz;
1374 	char *name;
1375 	size_t name_len;
1376 	const char *name_fmt;
1377 	static const char * const color_name_str[] = { "red", "green", "blue",
1378 						  "global" };
1379 	u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1380 	u8 use_hw_blink[MAX_LEDS] = { 0 };
1381 
1382 	BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1383 
1384 	if (sc->quirks & BUZZ_CONTROLLER) {
1385 		sc->led_count = 4;
1386 		use_color_names = 0;
1387 		name_len = strlen("::buzz#");
1388 		name_fmt = "%s::buzz%d";
1389 		/* Validate expected report characteristics. */
1390 		if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1391 			return -ENODEV;
1392 	} else if (sc->quirks & MOTION_CONTROLLER) {
1393 		sc->led_count = 3;
1394 		memset(max_brightness, 255, 3);
1395 		use_color_names = 1;
1396 		name_len = 0;
1397 		name_fmt = "%s:%s";
1398 	} else if (sc->quirks & NAVIGATION_CONTROLLER) {
1399 		static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1400 
1401 		memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1402 		sc->led_count = 1;
1403 		memset(use_hw_blink, 1, 4);
1404 		use_color_names = 0;
1405 		name_len = strlen("::sony#");
1406 		name_fmt = "%s::sony%d";
1407 	} else {
1408 		sixaxis_set_leds_from_id(sc);
1409 		sc->led_count = 4;
1410 		memset(use_hw_blink, 1, 4);
1411 		use_color_names = 0;
1412 		name_len = strlen("::sony#");
1413 		name_fmt = "%s::sony%d";
1414 	}
1415 
1416 	/*
1417 	 * Clear LEDs as we have no way of reading their initial state. This is
1418 	 * only relevant if the driver is loaded after somebody actively set the
1419 	 * LEDs to on
1420 	 */
1421 	sony_set_leds(sc);
1422 
1423 	name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1424 
1425 	for (n = 0; n < sc->led_count; n++) {
1426 
1427 		if (use_color_names)
1428 			name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_name_str[n]) + 2;
1429 
1430 		led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1431 		if (!led) {
1432 			hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1433 			return -ENOMEM;
1434 		}
1435 
1436 		name = (void *)(&led[1]);
1437 		if (use_color_names)
1438 			snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1439 			color_name_str[n]);
1440 		else
1441 			snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1442 		led->name = name;
1443 		led->brightness = sc->led_state[n];
1444 		led->max_brightness = max_brightness[n];
1445 		led->flags = LED_CORE_SUSPENDRESUME;
1446 		led->brightness_get = sony_led_get_brightness;
1447 		led->brightness_set = sony_led_set_brightness;
1448 
1449 		if (use_hw_blink[n])
1450 			led->blink_set = sony_led_blink_set;
1451 
1452 		sc->leds[n] = led;
1453 
1454 		ret = devm_led_classdev_register(&hdev->dev, led);
1455 		if (ret) {
1456 			hid_err(hdev, "Failed to register LED %d\n", n);
1457 			return ret;
1458 		}
1459 	}
1460 
1461 	return 0;
1462 }
1463 
1464 static void sixaxis_send_output_report(struct sony_sc *sc)
1465 {
1466 	static const union sixaxis_output_report_01 default_report = {
1467 		.buf = {
1468 			0x01,
1469 			0x01, 0xff, 0x00, 0xff, 0x00,
1470 			0x00, 0x00, 0x00, 0x00, 0x00,
1471 			0xff, 0x27, 0x10, 0x00, 0x32,
1472 			0xff, 0x27, 0x10, 0x00, 0x32,
1473 			0xff, 0x27, 0x10, 0x00, 0x32,
1474 			0xff, 0x27, 0x10, 0x00, 0x32,
1475 			0x00, 0x00, 0x00, 0x00, 0x00
1476 		}
1477 	};
1478 	struct sixaxis_output_report *report =
1479 		(struct sixaxis_output_report *)sc->output_report_dmabuf;
1480 	int n;
1481 
1482 	/* Initialize the report with default values */
1483 	memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1484 
1485 #ifdef CONFIG_SONY_FF
1486 	report->rumble.right_motor_on = sc->right ? 1 : 0;
1487 	report->rumble.left_motor_force = sc->left;
1488 #endif
1489 
1490 	report->leds_bitmap |= sc->led_state[0] << 1;
1491 	report->leds_bitmap |= sc->led_state[1] << 2;
1492 	report->leds_bitmap |= sc->led_state[2] << 3;
1493 	report->leds_bitmap |= sc->led_state[3] << 4;
1494 
1495 	/* Set flag for all leds off, required for 3rd party INTEC controller */
1496 	if ((report->leds_bitmap & 0x1E) == 0)
1497 		report->leds_bitmap |= 0x20;
1498 
1499 	/*
1500 	 * The LEDs in the report are indexed in reverse order to their
1501 	 * corresponding light on the controller.
1502 	 * Index 0 = LED 4, index 1 = LED 3, etc...
1503 	 *
1504 	 * In the case of both delay values being zero (blinking disabled) the
1505 	 * default report values should be used or the controller LED will be
1506 	 * always off.
1507 	 */
1508 	for (n = 0; n < 4; n++) {
1509 		if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1510 			report->led[3 - n].duty_off = sc->led_delay_off[n];
1511 			report->led[3 - n].duty_on = sc->led_delay_on[n];
1512 		}
1513 	}
1514 
1515 	/* SHANWAN controllers require output reports via intr channel */
1516 	if (sc->quirks & SHANWAN_GAMEPAD)
1517 		hid_hw_output_report(sc->hdev, (u8 *)report,
1518 				sizeof(struct sixaxis_output_report));
1519 	else
1520 		hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
1521 				sizeof(struct sixaxis_output_report),
1522 				HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1523 }
1524 
1525 static void motion_send_output_report(struct sony_sc *sc)
1526 {
1527 	struct hid_device *hdev = sc->hdev;
1528 	struct motion_output_report_02 *report =
1529 		(struct motion_output_report_02 *)sc->output_report_dmabuf;
1530 
1531 	memset(report, 0, MOTION_REPORT_0x02_SIZE);
1532 
1533 	report->type = 0x02; /* set leds */
1534 	report->r = sc->led_state[0];
1535 	report->g = sc->led_state[1];
1536 	report->b = sc->led_state[2];
1537 
1538 #ifdef CONFIG_SONY_FF
1539 	report->rumble = max(sc->right, sc->left);
1540 #endif
1541 
1542 	hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
1543 }
1544 
1545 #ifdef CONFIG_SONY_FF
1546 static inline void sony_send_output_report(struct sony_sc *sc)
1547 {
1548 	if (sc->send_output_report)
1549 		sc->send_output_report(sc);
1550 }
1551 #endif
1552 
1553 static void sony_state_worker(struct work_struct *work)
1554 {
1555 	struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1556 
1557 	sc->send_output_report(sc);
1558 }
1559 
1560 static int sony_allocate_output_report(struct sony_sc *sc)
1561 {
1562 	if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1563 			(sc->quirks & NAVIGATION_CONTROLLER))
1564 		sc->output_report_dmabuf =
1565 			devm_kmalloc(&sc->hdev->dev,
1566 				sizeof(union sixaxis_output_report_01),
1567 				GFP_KERNEL);
1568 	else if (sc->quirks & MOTION_CONTROLLER)
1569 		sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
1570 						MOTION_REPORT_0x02_SIZE,
1571 						GFP_KERNEL);
1572 	else
1573 		return 0;
1574 
1575 	if (!sc->output_report_dmabuf)
1576 		return -ENOMEM;
1577 
1578 	return 0;
1579 }
1580 
1581 #ifdef CONFIG_SONY_FF
1582 static int sony_play_effect(struct input_dev *dev, void *data,
1583 			    struct ff_effect *effect)
1584 {
1585 	struct hid_device *hid = input_get_drvdata(dev);
1586 	struct sony_sc *sc = hid_get_drvdata(hid);
1587 
1588 	if (effect->type != FF_RUMBLE)
1589 		return 0;
1590 
1591 	sc->left = effect->u.rumble.strong_magnitude / 256;
1592 	sc->right = effect->u.rumble.weak_magnitude / 256;
1593 
1594 	sony_schedule_work(sc, SONY_WORKER_STATE);
1595 	return 0;
1596 }
1597 
1598 static int sony_init_ff(struct sony_sc *sc)
1599 {
1600 	struct hid_input *hidinput;
1601 	struct input_dev *input_dev;
1602 
1603 	if (list_empty(&sc->hdev->inputs)) {
1604 		hid_err(sc->hdev, "no inputs found\n");
1605 		return -ENODEV;
1606 	}
1607 	hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
1608 	input_dev = hidinput->input;
1609 
1610 	input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1611 	return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1612 }
1613 
1614 #else
1615 static int sony_init_ff(struct sony_sc *sc)
1616 {
1617 	return 0;
1618 }
1619 
1620 #endif
1621 
1622 static int sony_battery_get_property(struct power_supply *psy,
1623 				     enum power_supply_property psp,
1624 				     union power_supply_propval *val)
1625 {
1626 	struct sony_sc *sc = power_supply_get_drvdata(psy);
1627 	unsigned long flags;
1628 	int ret = 0;
1629 	u8 battery_capacity;
1630 	int battery_status;
1631 
1632 	spin_lock_irqsave(&sc->lock, flags);
1633 	battery_capacity = sc->battery_capacity;
1634 	battery_status = sc->battery_status;
1635 	spin_unlock_irqrestore(&sc->lock, flags);
1636 
1637 	switch (psp) {
1638 	case POWER_SUPPLY_PROP_PRESENT:
1639 		val->intval = 1;
1640 		break;
1641 	case POWER_SUPPLY_PROP_SCOPE:
1642 		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1643 		break;
1644 	case POWER_SUPPLY_PROP_CAPACITY:
1645 		val->intval = battery_capacity;
1646 		break;
1647 	case POWER_SUPPLY_PROP_STATUS:
1648 		val->intval = battery_status;
1649 		break;
1650 	default:
1651 		ret = -EINVAL;
1652 		break;
1653 	}
1654 	return ret;
1655 }
1656 
1657 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
1658 {
1659 	const char *battery_str_fmt = append_dev_id ?
1660 		"sony_controller_battery_%pMR_%i" :
1661 		"sony_controller_battery_%pMR";
1662 	struct power_supply_config psy_cfg = { .drv_data = sc, };
1663 	struct hid_device *hdev = sc->hdev;
1664 	int ret;
1665 
1666 	/*
1667 	 * Set the default battery level to 100% to avoid low battery warnings
1668 	 * if the battery is polled before the first device report is received.
1669 	 */
1670 	sc->battery_capacity = 100;
1671 
1672 	sc->battery_desc.properties = sony_battery_props;
1673 	sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
1674 	sc->battery_desc.get_property = sony_battery_get_property;
1675 	sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
1676 	sc->battery_desc.use_for_apm = 0;
1677 	sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
1678 					  battery_str_fmt, sc->mac_address, sc->device_id);
1679 	if (!sc->battery_desc.name)
1680 		return -ENOMEM;
1681 
1682 	sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
1683 					    &psy_cfg);
1684 	if (IS_ERR(sc->battery)) {
1685 		ret = PTR_ERR(sc->battery);
1686 		hid_err(hdev, "Unable to register battery device\n");
1687 		return ret;
1688 	}
1689 
1690 	power_supply_powers(sc->battery, &hdev->dev);
1691 	return 0;
1692 }
1693 
1694 /*
1695  * If a controller is plugged in via USB while already connected via Bluetooth
1696  * it will show up as two devices. A global list of connected controllers and
1697  * their MAC addresses is maintained to ensure that a device is only connected
1698  * once.
1699  *
1700  * Some USB-only devices masquerade as Sixaxis controllers and all have the
1701  * same dummy Bluetooth address, so a comparison of the connection type is
1702  * required.  Devices are only rejected in the case where two devices have
1703  * matching Bluetooth addresses on different bus types.
1704  */
1705 static inline int sony_compare_connection_type(struct sony_sc *sc0,
1706 						struct sony_sc *sc1)
1707 {
1708 	const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
1709 	const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
1710 
1711 	return sc0_not_bt == sc1_not_bt;
1712 }
1713 
1714 static int sony_check_add_dev_list(struct sony_sc *sc)
1715 {
1716 	struct sony_sc *entry;
1717 	unsigned long flags;
1718 	int ret;
1719 
1720 	spin_lock_irqsave(&sony_dev_list_lock, flags);
1721 
1722 	list_for_each_entry(entry, &sony_device_list, list_node) {
1723 		ret = memcmp(sc->mac_address, entry->mac_address,
1724 				sizeof(sc->mac_address));
1725 		if (!ret) {
1726 			if (sony_compare_connection_type(sc, entry)) {
1727 				ret = 1;
1728 			} else {
1729 				ret = -EEXIST;
1730 				hid_info(sc->hdev,
1731 				"controller with MAC address %pMR already connected\n",
1732 				sc->mac_address);
1733 			}
1734 			goto unlock;
1735 		}
1736 	}
1737 
1738 	ret = 0;
1739 	list_add(&(sc->list_node), &sony_device_list);
1740 
1741 unlock:
1742 	spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1743 	return ret;
1744 }
1745 
1746 static void sony_remove_dev_list(struct sony_sc *sc)
1747 {
1748 	unsigned long flags;
1749 
1750 	if (sc->list_node.next) {
1751 		spin_lock_irqsave(&sony_dev_list_lock, flags);
1752 		list_del(&(sc->list_node));
1753 		spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1754 	}
1755 }
1756 
1757 static int sony_get_bt_devaddr(struct sony_sc *sc)
1758 {
1759 	int ret;
1760 
1761 	/* HIDP stores the device MAC address as a string in the uniq field. */
1762 	ret = strlen(sc->hdev->uniq);
1763 	if (ret != 17)
1764 		return -EINVAL;
1765 
1766 	ret = sscanf(sc->hdev->uniq,
1767 		"%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1768 		&sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1769 		&sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1770 
1771 	if (ret != 6)
1772 		return -EINVAL;
1773 
1774 	return 0;
1775 }
1776 
1777 static int sony_check_add(struct sony_sc *sc)
1778 {
1779 	u8 *buf = NULL;
1780 	int n, ret;
1781 
1782 	if ((sc->quirks & MOTION_CONTROLLER_BT) ||
1783 	    (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
1784 	    (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1785 		/*
1786 		 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1787 		 * address from the uniq string where HIDP stores it.
1788 		 * As uniq cannot be guaranteed to be a MAC address in all cases
1789 		 * a failure of this function should not prevent the connection.
1790 		 */
1791 		if (sony_get_bt_devaddr(sc) < 0) {
1792 			hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1793 			return 0;
1794 		}
1795 	} else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
1796 			(sc->quirks & NAVIGATION_CONTROLLER_USB)) {
1797 		buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1798 		if (!buf)
1799 			return -ENOMEM;
1800 
1801 		/*
1802 		 * The MAC address of a Sixaxis controller connected via USB can
1803 		 * be retrieved with feature report 0xf2. The address begins at
1804 		 * offset 4.
1805 		 */
1806 		ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1807 				SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1808 				HID_REQ_GET_REPORT);
1809 
1810 		if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1811 			hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1812 			ret = ret < 0 ? ret : -EINVAL;
1813 			goto out_free;
1814 		}
1815 
1816 		/*
1817 		 * The Sixaxis device MAC in the report is big-endian and must
1818 		 * be byte-swapped.
1819 		 */
1820 		for (n = 0; n < 6; n++)
1821 			sc->mac_address[5-n] = buf[4+n];
1822 
1823 		snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
1824 			 "%pMR", sc->mac_address);
1825 	} else {
1826 		return 0;
1827 	}
1828 
1829 	ret = sony_check_add_dev_list(sc);
1830 
1831 out_free:
1832 
1833 	kfree(buf);
1834 
1835 	return ret;
1836 }
1837 
1838 static int sony_set_device_id(struct sony_sc *sc)
1839 {
1840 	int ret;
1841 
1842 	/*
1843 	 * Only Sixaxis controllers get an id.
1844 	 * All others are set to -1.
1845 	 */
1846 	if (sc->quirks & SIXAXIS_CONTROLLER) {
1847 		ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1848 					GFP_KERNEL);
1849 		if (ret < 0) {
1850 			sc->device_id = -1;
1851 			return ret;
1852 		}
1853 		sc->device_id = ret;
1854 	} else {
1855 		sc->device_id = -1;
1856 	}
1857 
1858 	return 0;
1859 }
1860 
1861 static void sony_release_device_id(struct sony_sc *sc)
1862 {
1863 	if (sc->device_id >= 0) {
1864 		ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1865 		sc->device_id = -1;
1866 	}
1867 }
1868 
1869 static inline void sony_init_output_report(struct sony_sc *sc,
1870 				void (*send_output_report)(struct sony_sc *))
1871 {
1872 	sc->send_output_report = send_output_report;
1873 
1874 	if (!sc->state_worker_initialized)
1875 		INIT_WORK(&sc->state_worker, sony_state_worker);
1876 
1877 	sc->state_worker_initialized = 1;
1878 }
1879 
1880 static inline void sony_cancel_work_sync(struct sony_sc *sc)
1881 {
1882 	unsigned long flags;
1883 
1884 	if (sc->state_worker_initialized) {
1885 		spin_lock_irqsave(&sc->lock, flags);
1886 		sc->state_worker_initialized = 0;
1887 		spin_unlock_irqrestore(&sc->lock, flags);
1888 		cancel_work_sync(&sc->state_worker);
1889 	}
1890 }
1891 
1892 static int sony_input_configured(struct hid_device *hdev,
1893 					struct hid_input *hidinput)
1894 {
1895 	struct sony_sc *sc = hid_get_drvdata(hdev);
1896 	int append_dev_id;
1897 	int ret;
1898 
1899 	ret = sony_set_device_id(sc);
1900 	if (ret < 0) {
1901 		hid_err(hdev, "failed to allocate the device id\n");
1902 		goto err_stop;
1903 	}
1904 
1905 	ret = append_dev_id = sony_check_add(sc);
1906 	if (ret < 0)
1907 		goto err_stop;
1908 
1909 	ret = sony_allocate_output_report(sc);
1910 	if (ret < 0) {
1911 		hid_err(hdev, "failed to allocate the output report buffer\n");
1912 		goto err_stop;
1913 	}
1914 
1915 	if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
1916 		/*
1917 		 * The Sony Sixaxis does not handle HID Output Reports on the
1918 		 * Interrupt EP like it could, so we need to force HID Output
1919 		 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1920 		 *
1921 		 * There is also another issue about HID Output Reports via USB,
1922 		 * the Sixaxis does not want the report_id as part of the data
1923 		 * packet, so we have to discard buf[0] when sending the actual
1924 		 * control message, even for numbered reports, humpf!
1925 		 *
1926 		 * Additionally, the Sixaxis on USB isn't properly initialized
1927 		 * until the PS logo button is pressed and as such won't retain
1928 		 * any state set by an output report, so the initial
1929 		 * configuration report is deferred until the first input
1930 		 * report arrives.
1931 		 */
1932 		hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1933 		hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1934 		sc->defer_initialization = 1;
1935 
1936 		ret = sixaxis_set_operational_usb(hdev);
1937 		if (ret < 0) {
1938 			hid_err(hdev, "Failed to set controller into operational mode\n");
1939 			goto err_stop;
1940 		}
1941 
1942 		sony_init_output_report(sc, sixaxis_send_output_report);
1943 	} else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
1944 		/*
1945 		 * The Navigation controller wants output reports sent on the ctrl
1946 		 * endpoint when connected via Bluetooth.
1947 		 */
1948 		hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1949 
1950 		ret = sixaxis_set_operational_bt(hdev);
1951 		if (ret < 0) {
1952 			hid_err(hdev, "Failed to set controller into operational mode\n");
1953 			goto err_stop;
1954 		}
1955 
1956 		sony_init_output_report(sc, sixaxis_send_output_report);
1957 	} else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1958 		/*
1959 		 * The Sony Sixaxis does not handle HID Output Reports on the
1960 		 * Interrupt EP and the device only becomes active when the
1961 		 * PS button is pressed. See comment for Navigation controller
1962 		 * above for more details.
1963 		 */
1964 		hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1965 		hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1966 		sc->defer_initialization = 1;
1967 
1968 		ret = sixaxis_set_operational_usb(hdev);
1969 		if (ret < 0) {
1970 			hid_err(hdev, "Failed to set controller into operational mode\n");
1971 			goto err_stop;
1972 		}
1973 
1974 		ret = sony_register_sensors(sc);
1975 		if (ret) {
1976 			hid_err(sc->hdev,
1977 			"Unable to initialize motion sensors: %d\n", ret);
1978 			goto err_stop;
1979 		}
1980 
1981 		sony_init_output_report(sc, sixaxis_send_output_report);
1982 	} else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1983 		/*
1984 		 * The Sixaxis wants output reports sent on the ctrl endpoint
1985 		 * when connected via Bluetooth.
1986 		 */
1987 		hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1988 
1989 		ret = sixaxis_set_operational_bt(hdev);
1990 		if (ret < 0) {
1991 			hid_err(hdev, "Failed to set controller into operational mode\n");
1992 			goto err_stop;
1993 		}
1994 
1995 		ret = sony_register_sensors(sc);
1996 		if (ret) {
1997 			hid_err(sc->hdev,
1998 			"Unable to initialize motion sensors: %d\n", ret);
1999 			goto err_stop;
2000 		}
2001 
2002 		sony_init_output_report(sc, sixaxis_send_output_report);
2003 	} else if (sc->quirks & NSG_MRXU_REMOTE) {
2004 		/*
2005 		 * The NSG-MRxU touchpad supports 2 touches and has a
2006 		 * resolution of 1667x1868
2007 		 */
2008 		ret = sony_register_touchpad(sc, 2,
2009 			NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2010 		if (ret) {
2011 			hid_err(sc->hdev,
2012 			"Unable to initialize multi-touch slots: %d\n",
2013 			ret);
2014 			goto err_stop;
2015 		}
2016 
2017 	} else if (sc->quirks & MOTION_CONTROLLER) {
2018 		sony_init_output_report(sc, motion_send_output_report);
2019 	} else {
2020 		ret = 0;
2021 	}
2022 
2023 	if (sc->quirks & SONY_LED_SUPPORT) {
2024 		ret = sony_leds_init(sc);
2025 		if (ret < 0)
2026 			goto err_stop;
2027 	}
2028 
2029 	if (sc->quirks & SONY_BATTERY_SUPPORT) {
2030 		ret = sony_battery_probe(sc, append_dev_id);
2031 		if (ret < 0)
2032 			goto err_stop;
2033 
2034 		/* Open the device to receive reports with battery info */
2035 		ret = hid_hw_open(hdev);
2036 		if (ret < 0) {
2037 			hid_err(hdev, "hw open failed\n");
2038 			goto err_stop;
2039 		}
2040 	}
2041 
2042 	if (sc->quirks & SONY_FF_SUPPORT) {
2043 		ret = sony_init_ff(sc);
2044 		if (ret < 0)
2045 			goto err_close;
2046 	}
2047 
2048 	return 0;
2049 err_close:
2050 	hid_hw_close(hdev);
2051 err_stop:
2052 	sony_cancel_work_sync(sc);
2053 	sony_remove_dev_list(sc);
2054 	sony_release_device_id(sc);
2055 	return ret;
2056 }
2057 
2058 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2059 {
2060 	int ret;
2061 	unsigned long quirks = id->driver_data;
2062 	struct sony_sc *sc;
2063 	struct usb_device *usbdev;
2064 	unsigned int connect_mask = HID_CONNECT_DEFAULT;
2065 
2066 	if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2067 		quirks |= FUTUREMAX_DANCE_MAT;
2068 
2069 	if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") ||
2070 	    !strcmp(hdev->name, "ShanWan PS(R) Ga`epad"))
2071 		quirks |= SHANWAN_GAMEPAD;
2072 
2073 	sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2074 	if (sc == NULL) {
2075 		hid_err(hdev, "can't alloc sony descriptor\n");
2076 		return -ENOMEM;
2077 	}
2078 
2079 	spin_lock_init(&sc->lock);
2080 
2081 	sc->quirks = quirks;
2082 	hid_set_drvdata(hdev, sc);
2083 	sc->hdev = hdev;
2084 
2085 	ret = hid_parse(hdev);
2086 	if (ret) {
2087 		hid_err(hdev, "parse failed\n");
2088 		return ret;
2089 	}
2090 
2091 	if (sc->quirks & VAIO_RDESC_CONSTANT)
2092 		connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2093 	else if (sc->quirks & SIXAXIS_CONTROLLER)
2094 		connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2095 
2096 	/* Patch the hw version on DS3 compatible devices, so applications can
2097 	 * distinguish between the default HID mappings and the mappings defined
2098 	 * by the Linux game controller spec. This is important for the SDL2
2099 	 * library, which has a game controller database, which uses device ids
2100 	 * in combination with version as a key.
2101 	 */
2102 	if (sc->quirks & SIXAXIS_CONTROLLER)
2103 		hdev->version |= 0x8000;
2104 
2105 	ret = hid_hw_start(hdev, connect_mask);
2106 	if (ret) {
2107 		hid_err(hdev, "hw start failed\n");
2108 		return ret;
2109 	}
2110 
2111 	/* sony_input_configured can fail, but this doesn't result
2112 	 * in hid_hw_start failures (intended). Check whether
2113 	 * the HID layer claimed the device else fail.
2114 	 * We don't know the actual reason for the failure, most
2115 	 * likely it is due to EEXIST in case of double connection
2116 	 * of USB and Bluetooth, but could have been due to ENOMEM
2117 	 * or other reasons as well.
2118 	 */
2119 	if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2120 		hid_err(hdev, "failed to claim input\n");
2121 		ret = -ENODEV;
2122 		goto err;
2123 	}
2124 
2125 	if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
2126 		if (!hid_is_usb(hdev)) {
2127 			ret = -EINVAL;
2128 			goto err;
2129 		}
2130 
2131 		usbdev = to_usb_device(sc->hdev->dev.parent->parent);
2132 
2133 		sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
2134 		if (!sc->ghl_urb) {
2135 			ret = -ENOMEM;
2136 			goto err;
2137 		}
2138 
2139 		if (sc->quirks & GHL_GUITAR_PS3WIIU)
2140 			ret = ghl_init_urb(sc, usbdev, ghl_ps3wiiu_magic_data,
2141 							   ARRAY_SIZE(ghl_ps3wiiu_magic_data));
2142 		else if (sc->quirks & GHL_GUITAR_PS4)
2143 			ret = ghl_init_urb(sc, usbdev, ghl_ps4_magic_data,
2144 							   ARRAY_SIZE(ghl_ps4_magic_data));
2145 		if (ret) {
2146 			hid_err(hdev, "error preparing URB\n");
2147 			goto err;
2148 		}
2149 
2150 		timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
2151 		mod_timer(&sc->ghl_poke_timer,
2152 			  jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
2153 	}
2154 
2155 	return ret;
2156 
2157 err:
2158 	hid_hw_stop(hdev);
2159 	return ret;
2160 }
2161 
2162 static void sony_remove(struct hid_device *hdev)
2163 {
2164 	struct sony_sc *sc = hid_get_drvdata(hdev);
2165 
2166 	if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
2167 		del_timer_sync(&sc->ghl_poke_timer);
2168 		usb_free_urb(sc->ghl_urb);
2169 	}
2170 
2171 	hid_hw_close(hdev);
2172 
2173 	sony_cancel_work_sync(sc);
2174 
2175 	sony_remove_dev_list(sc);
2176 
2177 	sony_release_device_id(sc);
2178 
2179 	hid_hw_stop(hdev);
2180 }
2181 
2182 #ifdef CONFIG_PM
2183 
2184 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2185 {
2186 #ifdef CONFIG_SONY_FF
2187 
2188 	/* On suspend stop any running force-feedback events */
2189 	if (SONY_FF_SUPPORT) {
2190 		struct sony_sc *sc = hid_get_drvdata(hdev);
2191 
2192 		sc->left = sc->right = 0;
2193 		sony_send_output_report(sc);
2194 	}
2195 
2196 #endif
2197 	return 0;
2198 }
2199 
2200 static int sony_resume(struct hid_device *hdev)
2201 {
2202 	struct sony_sc *sc = hid_get_drvdata(hdev);
2203 
2204 	/*
2205 	 * The Sixaxis and navigation controllers on USB need to be
2206 	 * reinitialized on resume or they won't behave properly.
2207 	 */
2208 	if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2209 		(sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2210 		sixaxis_set_operational_usb(sc->hdev);
2211 		sc->defer_initialization = 1;
2212 	}
2213 
2214 	return 0;
2215 }
2216 
2217 #endif
2218 
2219 static const struct hid_device_id sony_devices[] = {
2220 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2221 		.driver_data = SIXAXIS_CONTROLLER_USB },
2222 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2223 		.driver_data = NAVIGATION_CONTROLLER_USB },
2224 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2225 		.driver_data = NAVIGATION_CONTROLLER_BT },
2226 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2227 		.driver_data = MOTION_CONTROLLER_USB },
2228 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2229 		.driver_data = MOTION_CONTROLLER_BT },
2230 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2231 		.driver_data = SIXAXIS_CONTROLLER_BT },
2232 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2233 		.driver_data = VAIO_RDESC_CONSTANT },
2234 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2235 		.driver_data = VAIO_RDESC_CONSTANT },
2236 	/*
2237 	 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2238 	 * Logitech joystick from the device descriptor.
2239 	 */
2240 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2241 		.driver_data = BUZZ_CONTROLLER },
2242 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2243 		.driver_data = BUZZ_CONTROLLER },
2244 	/* PS3 BD Remote Control */
2245 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2246 		.driver_data = PS3REMOTE },
2247 	/* Logitech Harmony Adapter for PS3 */
2248 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2249 		.driver_data = PS3REMOTE },
2250 	/* SMK-Link PS3 BD Remote Control */
2251 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2252 		.driver_data = PS3REMOTE },
2253 	/* Nyko Core Controller for PS3 */
2254 	{ HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2255 		.driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2256 	/* SMK-Link NSG-MR5U Remote Control */
2257 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
2258 		.driver_data = NSG_MR5U_REMOTE_BT },
2259 	/* SMK-Link NSG-MR7U Remote Control */
2260 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
2261 		.driver_data = NSG_MR7U_REMOTE_BT },
2262 	/* Guitar Hero Live PS3 and Wii U guitar dongles */
2263 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
2264 		.driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
2265 	/* Guitar Hero PC Guitar Dongle */
2266 	{ HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_GUITAR_DONGLE),
2267 		.driver_data = GH_GUITAR_CONTROLLER },
2268 	/* Guitar Hero PS3 World Tour Guitar Dongle */
2269 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
2270 		.driver_data = GH_GUITAR_CONTROLLER },
2271 	/* Guitar Hero Live PS4 guitar dongles */
2272 	{ HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_PS4_GHLIVE_DONGLE),
2273 		.driver_data = GHL_GUITAR_PS4 | GH_GUITAR_CONTROLLER },
2274 	{ }
2275 };
2276 MODULE_DEVICE_TABLE(hid, sony_devices);
2277 
2278 static struct hid_driver sony_driver = {
2279 	.name             = "sony",
2280 	.id_table         = sony_devices,
2281 	.input_mapping    = sony_mapping,
2282 	.input_configured = sony_input_configured,
2283 	.probe            = sony_probe,
2284 	.remove           = sony_remove,
2285 	.report_fixup     = sony_report_fixup,
2286 	.raw_event        = sony_raw_event,
2287 
2288 #ifdef CONFIG_PM
2289 	.suspend          = sony_suspend,
2290 	.resume	          = sony_resume,
2291 	.reset_resume     = sony_resume,
2292 #endif
2293 };
2294 
2295 static int __init sony_init(void)
2296 {
2297 	dbg_hid("Sony:%s\n", __func__);
2298 
2299 	return hid_register_driver(&sony_driver);
2300 }
2301 
2302 static void __exit sony_exit(void)
2303 {
2304 	dbg_hid("Sony:%s\n", __func__);
2305 
2306 	hid_unregister_driver(&sony_driver);
2307 	ida_destroy(&sony_device_id_allocator);
2308 }
2309 module_init(sony_init);
2310 module_exit(sony_exit);
2311 
2312 MODULE_LICENSE("GPL");
2313