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 <linux/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 const 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 const 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(work: &sc->state_worker);
530	spin_unlock_irqrestore(lock: &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(timer: &sc->ghl_poke_timer, expires: 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 = timer_container_of(sc, t, ghl_poke_timer);
549
550	ret = usb_submit_urb(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(dev: &sc->hdev->dev, size: sizeof(*cr), GFP_ATOMIC);
566	if (cr == NULL)
567	return -ENOMEM;
568
569	databuf = devm_kzalloc(dev: &sc->hdev->dev, size: 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	urb: sc->ghl_urb, dev: usbdev, pipe,
582	setup_packet: (unsigned char *) cr, transfer_buffer: databuf, buffer_length: poke_size,
583	complete_fn: ghl_magic_poke_cb, context: 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(hidinput: hi, usage, bit, max, EV_ABS, ABS_RY);
596	return 1;
597	}
598	}
599	return 0;
600	}
601
602	static const 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 const 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(hidinput: hi, usage, bit, max, EV_KEY, c: 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(hidinput: hi, usage, bit, max, EV_KEY, c: 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(hidinput: hi, usage, bit, max, EV_ABS, c: 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(hidinput: hi, usage, bit, max, EV_ABS, c: 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(hidinput: hi, usage, bit, max, EV_KEY, c: 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(hidinput: hi, usage, bit, max, EV_ABS, c: 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(hidinput: hi, usage, bit, max, EV_ABS, c: abs);
740	return 1;
741	}
742
743	return -1;
744	}
745
746	static const 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(lock: &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(dev: sc->sensor_dev, ABS_X, value: val);
832
833	/* Y and Z are swapped and inversed */
834	val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
835	input_report_abs(dev: sc->sensor_dev, ABS_Y, value: val);
836
837	val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
838	input_report_abs(dev: sc->sensor_dev, ABS_Z, value: val);
839
840	input_sync(dev: 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(dev: sc->touchpad, BTN_LEFT, value: 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(dev: sc->touchpad, slot: n);
884	input_mt_report_slot_state(dev: sc->touchpad, MT_TOOL_FINGER, active: active & 0x03);
885
886	if (active & 0x03) {
887	contactx = rd[offset+3] & 0x0F;
888	contacty = rd[offset+3] >> 4;
889	input_report_abs(dev: sc->touchpad, ABS_MT_TOUCH_MAJOR,
890	max(contactx, contacty));
891	input_report_abs(dev: sc->touchpad, ABS_MT_TOUCH_MINOR,
892	min(contactx, contacty));
893	input_report_abs(dev: sc->touchpad, ABS_MT_ORIENTATION,
894	value: (bool) (contactx > contacty));
895	input_report_abs(dev: sc->touchpad, ABS_MT_POSITION_X, value: x);
896	input_report_abs(dev: 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(dev: sc->touchpad, REL_X, value: relx);
905	input_report_rel(dev: sc->touchpad, REL_Y, value: rely);
906	}
907	}
908
909	offset += 5;
910	active >>= 2;
911	}
912
913	input_mt_sync_frame(dev: sc->touchpad);
914
915	input_sync(dev: 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, which: 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(hidinput: hi, usage, bit, max, EV_KEY, c: 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(dev: sc->touchpad, data: 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(dev: &sc->hdev->dev, size: name_sz, GFP_KERNEL);
1036	if (!name)
1037	return -ENOMEM;
1038	snprintf(buf: name, size: name_sz, fmt: "%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(dev: sc->touchpad, ABS_MT_POSITION_X, min: 0, max: w, fuzz: 0, flat: 0);
1047	input_set_abs_params(dev: sc->touchpad, ABS_MT_POSITION_Y, min: 0, max: h, fuzz: 0, flat: 0);
1048
1049	if (touch_major > 0) {
1050	input_set_abs_params(dev: sc->touchpad, ABS_MT_TOUCH_MAJOR,
1051	min: 0, max: touch_major, fuzz: 0, flat: 0);
1052	if (touch_minor > 0)
1053	input_set_abs_params(dev: sc->touchpad, ABS_MT_TOUCH_MINOR,
1054	min: 0, max: touch_minor, fuzz: 0, flat: 0);
1055	if (orientation > 0)
1056	input_set_abs_params(dev: sc->touchpad, ABS_MT_ORIENTATION,
1057	min: 0, max: orientation, fuzz: 0, flat: 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(dev: sc->touchpad, num_slots: 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(dev: sc->sensor_dev, data: 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(dev: &sc->hdev->dev, size: name_sz, GFP_KERNEL);
1099	if (!name)
1100	return -ENOMEM;
1101	snprintf(buf: name, size: name_sz, fmt: "%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(dev: sc->sensor_dev, ABS_X, min: -512, max: 511, fuzz: 4, flat: 0);
1112	input_set_abs_params(dev: sc->sensor_dev, ABS_Y, min: -512, max: 511, fuzz: 4, flat: 0);
1113	input_set_abs_params(dev: sc->sensor_dev, ABS_Z, min: -512, max: 511, fuzz: 4, flat: 0);
1114	input_abs_set_res(dev: sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1115	input_abs_set_res(dev: sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1116	input_abs_set_res(dev: 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, reportnum: 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1146	rtype: HID_FEATURE_REPORT, reqtype: 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, reportnum: 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1157	rtype: HID_FEATURE_REPORT, reqtype: 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, len: 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(objp: 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, reportnum: buf[0], buf, len: sizeof(report),
1193	rtype: HID_FEATURE_REPORT, reqtype: HID_REQ_SET_REPORT);
1194
1195	kfree(objp: 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, reqtype: 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, which: 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(sc: 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(sc: drv_data, which: 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	if (WARN_ON(!(sc->quirks & SONY_LED_SUPPORT)))
1383	return -EINVAL;
1384
1385	if (sc->quirks & BUZZ_CONTROLLER) {
1386	sc->led_count = 4;
1387	use_color_names = 0;
1388	name_len = strlen("::buzz#");
1389	name_fmt = "%s::buzz%d";
1390	/* Validate expected report characteristics. */
1391	if (!hid_validate_values(hid: hdev, type: HID_OUTPUT_REPORT, id: 0, field_index: 0, report_counts: 7))
1392	return -ENODEV;
1393	} else if (sc->quirks & MOTION_CONTROLLER) {
1394	sc->led_count = 3;
1395	memset(max_brightness, 255, 3);
1396	use_color_names = 1;
1397	name_len = 0;
1398	name_fmt = "%s:%s";
1399	} else if (sc->quirks & NAVIGATION_CONTROLLER) {
1400	static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1401
1402	memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1403	sc->led_count = 1;
1404	memset(use_hw_blink, 1, 4);
1405	use_color_names = 0;
1406	name_len = strlen("::sony#");
1407	name_fmt = "%s::sony%d";
1408	} else {
1409	sixaxis_set_leds_from_id(sc);
1410	sc->led_count = 4;
1411	memset(use_hw_blink, 1, 4);
1412	use_color_names = 0;
1413	name_len = strlen("::sony#");
1414	name_fmt = "%s::sony%d";
1415	}
1416
1417	/*
1418	* Clear LEDs as we have no way of reading their initial state. This is
1419	* only relevant if the driver is loaded after somebody actively set the
1420	* LEDs to on
1421	*/
1422	sony_set_leds(sc);
1423
1424	name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1425
1426	for (n = 0; n < sc->led_count; n++) {
1427
1428	if (use_color_names)
1429	name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_name_str[n]) + 2;
1430
1431	led = devm_kzalloc(dev: &hdev->dev, size: sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1432	if (!led) {
1433	hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1434	return -ENOMEM;
1435	}
1436
1437	name = (void *)(&led[1]);
1438	if (use_color_names)
1439	snprintf(buf: name, size: name_sz, fmt: name_fmt, dev_name(dev: &hdev->dev),
1440	color_name_str[n]);
1441	else
1442	snprintf(buf: name, size: name_sz, fmt: name_fmt, dev_name(dev: &hdev->dev), n + 1);
1443	led->name = name;
1444	led->brightness = sc->led_state[n];
1445	led->max_brightness = max_brightness[n];
1446	led->flags = LED_CORE_SUSPENDRESUME;
1447	led->brightness_get = sony_led_get_brightness;
1448	led->brightness_set = sony_led_set_brightness;
1449
1450	if (use_hw_blink[n])
1451	led->blink_set = sony_led_blink_set;
1452
1453	sc->leds[n] = led;
1454
1455	ret = devm_led_classdev_register(parent: &hdev->dev, led_cdev: led);
1456	if (ret) {
1457	hid_err(hdev, "Failed to register LED %d\n", n);
1458	return ret;
1459	}
1460	}
1461
1462	return 0;
1463	}
1464
1465	static void sixaxis_send_output_report(struct sony_sc *sc)
1466	{
1467	static const union sixaxis_output_report_01 default_report = {
1468	.buf = {
1469	0x01,
1470	0x01, 0xff, 0x00, 0xff, 0x00,
1471	0x00, 0x00, 0x00, 0x00, 0x00,
1472	0xff, 0x27, 0x10, 0x00, 0x32,
1473	0xff, 0x27, 0x10, 0x00, 0x32,
1474	0xff, 0x27, 0x10, 0x00, 0x32,
1475	0xff, 0x27, 0x10, 0x00, 0x32,
1476	0x00, 0x00, 0x00, 0x00, 0x00
1477	}
1478	};
1479	struct sixaxis_output_report *report =
1480	(struct sixaxis_output_report *)sc->output_report_dmabuf;
1481	int n;
1482
1483	/* Initialize the report with default values */
1484	memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1485
1486	#ifdef CONFIG_SONY_FF
1487	report->rumble.right_motor_on = sc->right ? 1 : 0;
1488	report->rumble.left_motor_force = sc->left;
1489	#endif
1490
1491	report->leds_bitmap |= sc->led_state[0] << 1;
1492	report->leds_bitmap |= sc->led_state[1] << 2;
1493	report->leds_bitmap |= sc->led_state[2] << 3;
1494	report->leds_bitmap |= sc->led_state[3] << 4;
1495
1496	/* Set flag for all leds off, required for 3rd party INTEC controller */
1497	if ((report->leds_bitmap & 0x1E) == 0)
1498	report->leds_bitmap |= 0x20;
1499
1500	/*
1501	* The LEDs in the report are indexed in reverse order to their
1502	* corresponding light on the controller.
1503	* Index 0 = LED 4, index 1 = LED 3, etc...
1504	*
1505	* In the case of both delay values being zero (blinking disabled) the
1506	* default report values should be used or the controller LED will be
1507	* always off.
1508	*/
1509	for (n = 0; n < 4; n++) {
1510	if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1511	report->led[3 - n].duty_off = sc->led_delay_off[n];
1512	report->led[3 - n].duty_on = sc->led_delay_on[n];
1513	}
1514	}
1515
1516	/* SHANWAN controllers require output reports via intr channel */
1517	if (sc->quirks & SHANWAN_GAMEPAD)
1518	hid_hw_output_report(hdev: sc->hdev, buf: (u8 *)report,
1519	len: sizeof(struct sixaxis_output_report));
1520	else
1521	hid_hw_raw_request(hdev: sc->hdev, reportnum: report->report_id, buf: (u8 *)report,
1522	len: sizeof(struct sixaxis_output_report),
1523	rtype: HID_OUTPUT_REPORT, reqtype: HID_REQ_SET_REPORT);
1524	}
1525
1526	static void motion_send_output_report(struct sony_sc *sc)
1527	{
1528	struct hid_device *hdev = sc->hdev;
1529	struct motion_output_report_02 *report =
1530	(struct motion_output_report_02 *)sc->output_report_dmabuf;
1531
1532	memset(report, 0, MOTION_REPORT_0x02_SIZE);
1533
1534	report->type = 0x02; /* set leds */
1535	report->r = sc->led_state[0];
1536	report->g = sc->led_state[1];
1537	report->b = sc->led_state[2];
1538
1539	#ifdef CONFIG_SONY_FF
1540	report->rumble = max(sc->right, sc->left);
1541	#endif
1542
1543	hid_hw_output_report(hdev, buf: (u8 *)report, MOTION_REPORT_0x02_SIZE);
1544	}
1545
1546	#ifdef CONFIG_SONY_FF
1547	static inline void sony_send_output_report(struct sony_sc *sc)
1548	{
1549	if (sc->send_output_report)
1550	sc->send_output_report(sc);
1551	}
1552	#endif
1553
1554	static void sony_state_worker(struct work_struct *work)
1555	{
1556	struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1557
1558	sc->send_output_report(sc);
1559	}
1560
1561	static int sony_allocate_output_report(struct sony_sc *sc)
1562	{
1563	if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1564	(sc->quirks & NAVIGATION_CONTROLLER))
1565	sc->output_report_dmabuf =
1566	devm_kmalloc(dev: &sc->hdev->dev,
1567	size: sizeof(union sixaxis_output_report_01),
1568	GFP_KERNEL);
1569	else if (sc->quirks & MOTION_CONTROLLER)
1570	sc->output_report_dmabuf = devm_kmalloc(dev: &sc->hdev->dev,
1571	MOTION_REPORT_0x02_SIZE,
1572	GFP_KERNEL);
1573	else
1574	return 0;
1575
1576	if (!sc->output_report_dmabuf)
1577	return -ENOMEM;
1578
1579	return 0;
1580	}
1581
1582	#ifdef CONFIG_SONY_FF
1583	static int sony_play_effect(struct input_dev *dev, void *data,
1584	struct ff_effect *effect)
1585	{
1586	struct hid_device *hid = input_get_drvdata(dev);
1587	struct sony_sc *sc = hid_get_drvdata(hdev: hid);
1588
1589	if (effect->type != FF_RUMBLE)
1590	return 0;
1591
1592	sc->left = effect->u.rumble.strong_magnitude / 256;
1593	sc->right = effect->u.rumble.weak_magnitude / 256;
1594
1595	sony_schedule_work(sc, which: SONY_WORKER_STATE);
1596	return 0;
1597	}
1598
1599	static int sony_init_ff(struct sony_sc *sc)
1600	{
1601	struct hid_input *hidinput;
1602	struct input_dev *input_dev;
1603
1604	if (list_empty(head: &sc->hdev->inputs)) {
1605	hid_err(sc->hdev, "no inputs found\n");
1606	return -ENODEV;
1607	}
1608	hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
1609	input_dev = hidinput->input;
1610
1611	input_set_capability(dev: input_dev, EV_FF, FF_RUMBLE);
1612	return input_ff_create_memless(dev: input_dev, NULL, play_effect: sony_play_effect);
1613	}
1614
1615	#else
1616	static int sony_init_ff(struct sony_sc *sc)
1617	{
1618	return 0;
1619	}
1620
1621	#endif
1622
1623	static int sony_battery_get_property(struct power_supply *psy,
1624	enum power_supply_property psp,
1625	union power_supply_propval *val)
1626	{
1627	struct sony_sc *sc = power_supply_get_drvdata(psy);
1628	unsigned long flags;
1629	int ret = 0;
1630	u8 battery_capacity;
1631	int battery_status;
1632
1633	spin_lock_irqsave(&sc->lock, flags);
1634	battery_capacity = sc->battery_capacity;
1635	battery_status = sc->battery_status;
1636	spin_unlock_irqrestore(lock: &sc->lock, flags);
1637
1638	switch (psp) {
1639	case POWER_SUPPLY_PROP_PRESENT:
1640	val->intval = 1;
1641	break;
1642	case POWER_SUPPLY_PROP_SCOPE:
1643	val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1644	break;
1645	case POWER_SUPPLY_PROP_CAPACITY:
1646	val->intval = battery_capacity;
1647	break;
1648	case POWER_SUPPLY_PROP_STATUS:
1649	val->intval = battery_status;
1650	break;
1651	default:
1652	ret = -EINVAL;
1653	break;
1654	}
1655	return ret;
1656	}
1657
1658	static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
1659	{
1660	const char *battery_str_fmt = append_dev_id ?
1661	"sony_controller_battery_%pMR_%i" :
1662	"sony_controller_battery_%pMR";
1663	struct power_supply_config psy_cfg = { .drv_data = sc, };
1664	struct hid_device *hdev = sc->hdev;
1665	int ret;
1666
1667	/*
1668	* Set the default battery level to 100% to avoid low battery warnings
1669	* if the battery is polled before the first device report is received.
1670	*/
1671	sc->battery_capacity = 100;
1672
1673	sc->battery_desc.properties = sony_battery_props;
1674	sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
1675	sc->battery_desc.get_property = sony_battery_get_property;
1676	sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
1677	sc->battery_desc.use_for_apm = 0;
1678	sc->battery_desc.name = devm_kasprintf(dev: &hdev->dev, GFP_KERNEL,
1679	fmt: battery_str_fmt, sc->mac_address, sc->device_id);
1680	if (!sc->battery_desc.name)
1681	return -ENOMEM;
1682
1683	sc->battery = devm_power_supply_register(parent: &hdev->dev, desc: &sc->battery_desc,
1684	cfg: &psy_cfg);
1685	if (IS_ERR(ptr: sc->battery)) {
1686	ret = PTR_ERR(ptr: sc->battery);
1687	hid_err(hdev, "Unable to register battery device\n");
1688	return ret;
1689	}
1690
1691	power_supply_powers(psy: sc->battery, dev: &hdev->dev);
1692	return 0;
1693	}
1694
1695	/*
1696	* If a controller is plugged in via USB while already connected via Bluetooth
1697	* it will show up as two devices. A global list of connected controllers and
1698	* their MAC addresses is maintained to ensure that a device is only connected
1699	* once.
1700	*
1701	* Some USB-only devices masquerade as Sixaxis controllers and all have the
1702	* same dummy Bluetooth address, so a comparison of the connection type is
1703	* required. Devices are only rejected in the case where two devices have
1704	* matching Bluetooth addresses on different bus types.
1705	*/
1706	static inline int sony_compare_connection_type(struct sony_sc *sc0,
1707	struct sony_sc *sc1)
1708	{
1709	const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
1710	const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
1711
1712	return sc0_not_bt == sc1_not_bt;
1713	}
1714
1715	static int sony_check_add_dev_list(struct sony_sc *sc)
1716	{
1717	struct sony_sc *entry;
1718	unsigned long flags;
1719	int ret;
1720
1721	spin_lock_irqsave(&sony_dev_list_lock, flags);
1722
1723	list_for_each_entry(entry, &sony_device_list, list_node) {
1724	ret = memcmp(p: sc->mac_address, q: entry->mac_address,
1725	size: sizeof(sc->mac_address));
1726	if (!ret) {
1727	if (sony_compare_connection_type(sc0: sc, sc1: entry)) {
1728	ret = 1;
1729	} else {
1730	ret = -EEXIST;
1731	hid_info(sc->hdev,
1732	"controller with MAC address %pMR already connected\n",
1733	sc->mac_address);
1734	}
1735	goto unlock;
1736	}
1737	}
1738
1739	ret = 0;
1740	list_add(new: &(sc->list_node), head: &sony_device_list);
1741
1742	unlock:
1743	spin_unlock_irqrestore(lock: &sony_dev_list_lock, flags);
1744	return ret;
1745	}
1746
1747	static void sony_remove_dev_list(struct sony_sc *sc)
1748	{
1749	unsigned long flags;
1750
1751	if (sc->list_node.next) {
1752	spin_lock_irqsave(&sony_dev_list_lock, flags);
1753	list_del(entry: &(sc->list_node));
1754	spin_unlock_irqrestore(lock: &sony_dev_list_lock, flags);
1755	}
1756	}
1757
1758	static int sony_get_bt_devaddr(struct sony_sc *sc)
1759	{
1760	int ret;
1761
1762	/* HIDP stores the device MAC address as a string in the uniq field. */
1763	ret = strlen(sc->hdev->uniq);
1764	if (ret != 17)
1765	return -EINVAL;
1766
1767	ret = sscanf(sc->hdev->uniq,
1768	"%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1769	&sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1770	&sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1771
1772	if (ret != 6)
1773	return -EINVAL;
1774
1775	return 0;
1776	}
1777
1778	static int sony_check_add(struct sony_sc *sc)
1779	{
1780	u8 *buf = NULL;
1781	int n, ret;
1782
1783	if ((sc->quirks & MOTION_CONTROLLER_BT) ||
1784	(sc->quirks & NAVIGATION_CONTROLLER_BT) ||
1785	(sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1786	/*
1787	* sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1788	* address from the uniq string where HIDP stores it.
1789	* As uniq cannot be guaranteed to be a MAC address in all cases
1790	* a failure of this function should not prevent the connection.
1791	*/
1792	if (sony_get_bt_devaddr(sc) < 0) {
1793	hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1794	return 0;
1795	}
1796	} else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
1797	(sc->quirks & NAVIGATION_CONTROLLER_USB)) {
1798	buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1799	if (!buf)
1800	return -ENOMEM;
1801
1802	/*
1803	* The MAC address of a Sixaxis controller connected via USB can
1804	* be retrieved with feature report 0xf2. The address begins at
1805	* offset 4.
1806	*/
1807	ret = hid_hw_raw_request(hdev: sc->hdev, reportnum: 0xf2, buf,
1808	SIXAXIS_REPORT_0xF2_SIZE, rtype: HID_FEATURE_REPORT,
1809	reqtype: HID_REQ_GET_REPORT);
1810
1811	if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1812	hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1813	ret = ret < 0 ? ret : -EINVAL;
1814	goto out_free;
1815	}
1816
1817	/*
1818	* The Sixaxis device MAC in the report is big-endian and must
1819	* be byte-swapped.
1820	*/
1821	for (n = 0; n < 6; n++)
1822	sc->mac_address[5-n] = buf[4+n];
1823
1824	snprintf(buf: sc->hdev->uniq, size: sizeof(sc->hdev->uniq),
1825	fmt: "%pMR", sc->mac_address);
1826	} else {
1827	return 0;
1828	}
1829
1830	ret = sony_check_add_dev_list(sc);
1831
1832	out_free:
1833
1834	kfree(objp: buf);
1835
1836	return ret;
1837	}
1838
1839	static int sony_set_device_id(struct sony_sc *sc)
1840	{
1841	int ret;
1842
1843	/*
1844	* Only Sixaxis controllers get an id.
1845	* All others are set to -1.
1846	*/
1847	if (sc->quirks & SIXAXIS_CONTROLLER) {
1848	ret = ida_alloc(ida: &sony_device_id_allocator, 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_free(&sony_device_id_allocator, id: 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(lock: &sc->lock, flags);
1888	cancel_work_sync(work: &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, send_output_report: 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, send_output_report: 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, send_output_report: 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, send_output_report: 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, touch_count: 2,
2009	NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, touch_major: 15, touch_minor: 15, orientation: 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, send_output_report: motion_send_output_report);
2019	}
2020
2021	if (sc->quirks & SONY_LED_SUPPORT) {
2022	ret = sony_leds_init(sc);
2023	if (ret < 0)
2024	goto err_stop;
2025	}
2026
2027	if (sc->quirks & SONY_BATTERY_SUPPORT) {
2028	ret = sony_battery_probe(sc, append_dev_id);
2029	if (ret < 0)
2030	goto err_stop;
2031
2032	/* Open the device to receive reports with battery info */
2033	ret = hid_hw_open(hdev);
2034	if (ret < 0) {
2035	hid_err(hdev, "hw open failed\n");
2036	goto err_stop;
2037	}
2038	}
2039
2040	if (sc->quirks & SONY_FF_SUPPORT) {
2041	ret = sony_init_ff(sc);
2042	if (ret < 0)
2043	goto err_close;
2044	}
2045
2046	return 0;
2047	err_close:
2048	hid_hw_close(hdev);
2049	err_stop:
2050	sony_cancel_work_sync(sc);
2051	sony_remove_dev_list(sc);
2052	sony_release_device_id(sc);
2053	return ret;
2054	}
2055
2056	static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2057	{
2058	int ret;
2059	unsigned long quirks = id->driver_data;
2060	struct sony_sc *sc;
2061	struct usb_device *usbdev;
2062	unsigned int connect_mask = HID_CONNECT_DEFAULT;
2063
2064	if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2065	quirks |= FUTUREMAX_DANCE_MAT;
2066
2067	if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") ||
2068	!strcmp(hdev->name, "ShanWan PS(R) Ga`epad"))
2069	quirks |= SHANWAN_GAMEPAD;
2070
2071	sc = devm_kzalloc(dev: &hdev->dev, size: sizeof(*sc), GFP_KERNEL);
2072	if (sc == NULL) {
2073	hid_err(hdev, "can't alloc sony descriptor\n");
2074	return -ENOMEM;
2075	}
2076
2077	spin_lock_init(&sc->lock);
2078
2079	sc->quirks = quirks;
2080	hid_set_drvdata(hdev, data: sc);
2081	sc->hdev = hdev;
2082
2083	ret = hid_parse(hdev);
2084	if (ret) {
2085	hid_err(hdev, "parse failed\n");
2086	return ret;
2087	}
2088
2089	if (sc->quirks & VAIO_RDESC_CONSTANT)
2090	connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2091	else if (sc->quirks & SIXAXIS_CONTROLLER)
2092	connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2093
2094	/* Patch the hw version on DS3 compatible devices, so applications can
2095	* distinguish between the default HID mappings and the mappings defined
2096	* by the Linux game controller spec. This is important for the SDL2
2097	* library, which has a game controller database, which uses device ids
2098	* in combination with version as a key.
2099	*/
2100	if (sc->quirks & SIXAXIS_CONTROLLER)
2101	hdev->version |= 0x8000;
2102
2103	ret = hid_hw_start(hdev, connect_mask);
2104	if (ret) {
2105	hid_err(hdev, "hw start failed\n");
2106	return ret;
2107	}
2108
2109	/* sony_input_configured can fail, but this doesn't result
2110	* in hid_hw_start failures (intended). Check whether
2111	* the HID layer claimed the device else fail.
2112	* We don't know the actual reason for the failure, most
2113	* likely it is due to EEXIST in case of double connection
2114	* of USB and Bluetooth, but could have been due to ENOMEM
2115	* or other reasons as well.
2116	*/
2117	if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2118	hid_err(hdev, "failed to claim input\n");
2119	ret = -ENODEV;
2120	goto err;
2121	}
2122
2123	if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
2124	if (!hid_is_usb(hdev)) {
2125	ret = -EINVAL;
2126	goto err;
2127	}
2128
2129	usbdev = to_usb_device(sc->hdev->dev.parent->parent);
2130
2131	sc->ghl_urb = usb_alloc_urb(iso_packets: 0, GFP_ATOMIC);
2132	if (!sc->ghl_urb) {
2133	ret = -ENOMEM;
2134	goto err;
2135	}
2136
2137	if (sc->quirks & GHL_GUITAR_PS3WIIU)
2138	ret = ghl_init_urb(sc, usbdev, ghl_magic_data: ghl_ps3wiiu_magic_data,
2139	ARRAY_SIZE(ghl_ps3wiiu_magic_data));
2140	else if (sc->quirks & GHL_GUITAR_PS4)
2141	ret = ghl_init_urb(sc, usbdev, ghl_magic_data: ghl_ps4_magic_data,
2142	ARRAY_SIZE(ghl_ps4_magic_data));
2143	if (ret) {
2144	hid_err(hdev, "error preparing URB\n");
2145	goto err;
2146	}
2147
2148	timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
2149	mod_timer(timer: &sc->ghl_poke_timer,
2150	expires: jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
2151	}
2152
2153	return ret;
2154
2155	err:
2156	usb_free_urb(urb: sc->ghl_urb);
2157
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	timer_delete_sync(timer: &sc->ghl_poke_timer);
2168	usb_free_urb(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(hdev: 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(ida: &sony_device_id_allocator);
2308	}
2309	module_init(sony_init);
2310	module_exit(sony_exit);
2311
2312	MODULE_DESCRIPTION("HID driver for Sony / PS2 / PS3 / PS4 BD devices");
2313	MODULE_LICENSE("GPL");
2314