Merge branch 'for-4.12/sony' into for-linus

Jiri Kosina committed 9 years ago

Commit 800f3ee2 parents 18fc216 040fc003 files · +876 −814Browse files

Unified · Split

3 files

Documentation/input/event-codes.txt +4 −1
drivers/hid/hid-sony.c +864 −810
include/uapi/linux/input.h +8 −3

@@ -301,7 +301,10 @@ them as any other INPUT_PROP_BUTTONPAD device. · 300 unmodified lines
301	301	INPUT_PROP_ACCELEROMETER
302	302	-------------------------
303	303	Directional axes on this device (absolute and/or relative x, y, z) represent
304		−accelerometer data. All other axes retain their meaning. A device must not mix
	304	+accelerometer data. Some devices also report gyroscope data, which devices
	305	+can report through the rotational axes (absolute and/or relative rx, ry, rz).
	306	+
	307	+All other axes retain their meaning. A device must not mix
305	308	regular directional axes and accelerometer axes on the same event node.
306	309
307	310	Guidelines:

drivers/hid/hid-sony.c+864−810

@@ -48,19 +48,21 @@ · 47 unmodified lines
48	48	#define PS3REMOTE BIT(4)
49	49	#define DUALSHOCK4_CONTROLLER_USB BIT(5)
50	50	#define DUALSHOCK4_CONTROLLER_BT BIT(6)
51		−#define MOTION_CONTROLLER_USB BIT(7)
52		−#define MOTION_CONTROLLER_BT BIT(8)
53		−#define NAVIGATION_CONTROLLER_USB BIT(9)
54		−#define NAVIGATION_CONTROLLER_BT BIT(10)
55		−#define SINO_LITE_CONTROLLER BIT(11)
56		−#define FUTUREMAX_DANCE_MAT BIT(12)
	51	+#define DUALSHOCK4_DONGLE BIT(7)
	52	+#define MOTION_CONTROLLER_USB BIT(8)
	53	+#define MOTION_CONTROLLER_BT BIT(9)
	54	+#define NAVIGATION_CONTROLLER_USB BIT(10)
	55	+#define NAVIGATION_CONTROLLER_BT BIT(11)
	56	+#define SINO_LITE_CONTROLLER BIT(12)
	57	+#define FUTUREMAX_DANCE_MAT BIT(13)
57	58
58	59	#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB \| SIXAXIS_CONTROLLER_BT)
59	60	#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB \| MOTION_CONTROLLER_BT)
60	61	#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB \|\
61	62	NAVIGATION_CONTROLLER_BT)
62	63	#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB \|\
63		− DUALSHOCK4_CONTROLLER_BT)
	64	+ DUALSHOCK4_CONTROLLER_BT \| \
	65	+ DUALSHOCK4_DONGLE)
64	66	#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER \| BUZZ_CONTROLLER \|\
65	67	DUALSHOCK4_CONTROLLER \| MOTION_CONTROLLER \|\
66	68	NAVIGATION_CONTROLLER)
@@ -73,89 +75,6 @@ · 6 unmodified lines
73	75
74	76	#define MAX_LEDS 4
75	77
76		−/*
77		− * The Sixaxis reports both digital and analog values for each button on the
78		− * controller except for Start, Select and the PS button. The controller ends
79		− * up reporting 27 axes which causes them to spill over into the multi-touch
80		− * axis values. Additionally, the controller only has 20 actual, physical axes
81		− * so there are several unused axes in between the used ones.
82		− */
83		−static u8 sixaxis_rdesc[] = {
84		− 0x05, 0x01, /* Usage Page (Desktop), */
85		− 0x09, 0x04, /* Usage (Joystick), */
86		− 0xA1, 0x01, /* Collection (Application), */
87		− 0xA1, 0x02, /* Collection (Logical), */
88		− 0x85, 0x01, /* Report ID (1), */
89		− 0x75, 0x08, /* Report Size (8), */
90		− 0x95, 0x01, /* Report Count (1), */
91		− 0x15, 0x00, /* Logical Minimum (0), */
92		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
93		− 0x81, 0x03, /* Input (Constant, Variable), */
94		− 0x75, 0x01, /* Report Size (1), */
95		− 0x95, 0x13, /* Report Count (19), */
96		− 0x15, 0x00, /* Logical Minimum (0), */
97		− 0x25, 0x01, /* Logical Maximum (1), */
98		− 0x35, 0x00, /* Physical Minimum (0), */
99		− 0x45, 0x01, /* Physical Maximum (1), */
100		− 0x05, 0x09, /* Usage Page (Button), */
101		− 0x19, 0x01, /* Usage Minimum (01h), */
102		− 0x29, 0x13, /* Usage Maximum (13h), */
103		− 0x81, 0x02, /* Input (Variable), */
104		− 0x75, 0x01, /* Report Size (1), */
105		− 0x95, 0x0D, /* Report Count (13), */
106		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
107		− 0x81, 0x03, /* Input (Constant, Variable), */
108		− 0x15, 0x00, /* Logical Minimum (0), */
109		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
110		− 0x05, 0x01, /* Usage Page (Desktop), */
111		− 0x09, 0x01, /* Usage (Pointer), */
112		− 0xA1, 0x00, /* Collection (Physical), */
113		− 0x75, 0x08, /* Report Size (8), */
114		− 0x95, 0x04, /* Report Count (4), */
115		− 0x35, 0x00, /* Physical Minimum (0), */
116		− 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
117		− 0x09, 0x30, /* Usage (X), */
118		− 0x09, 0x31, /* Usage (Y), */
119		− 0x09, 0x32, /* Usage (Z), */
120		− 0x09, 0x35, /* Usage (Rz), */
121		− 0x81, 0x02, /* Input (Variable), */
122		− 0xC0, /* End Collection, */
123		− 0x05, 0x01, /* Usage Page (Desktop), */
124		− 0x95, 0x13, /* Report Count (19), */
125		− 0x09, 0x01, /* Usage (Pointer), */
126		− 0x81, 0x02, /* Input (Variable), */
127		− 0x95, 0x0C, /* Report Count (12), */
128		− 0x81, 0x01, /* Input (Constant), */
129		− 0x75, 0x10, /* Report Size (16), */
130		− 0x95, 0x04, /* Report Count (4), */
131		− 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */
132		− 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */
133		− 0x09, 0x01, /* Usage (Pointer), */
134		− 0x81, 0x02, /* Input (Variable), */
135		− 0xC0, /* End Collection, */
136		− 0xA1, 0x02, /* Collection (Logical), */
137		− 0x85, 0x02, /* Report ID (2), */
138		− 0x75, 0x08, /* Report Size (8), */
139		− 0x95, 0x30, /* Report Count (48), */
140		− 0x09, 0x01, /* Usage (Pointer), */
141		− 0xB1, 0x02, /* Feature (Variable), */
142		− 0xC0, /* End Collection, */
143		− 0xA1, 0x02, /* Collection (Logical), */
144		− 0x85, 0xEE, /* Report ID (238), */
145		− 0x75, 0x08, /* Report Size (8), */
146		− 0x95, 0x30, /* Report Count (48), */
147		− 0x09, 0x01, /* Usage (Pointer), */
148		− 0xB1, 0x02, /* Feature (Variable), */
149		− 0xC0, /* End Collection, */
150		− 0xA1, 0x02, /* Collection (Logical), */
151		− 0x85, 0xEF, /* Report ID (239), */
152		− 0x75, 0x08, /* Report Size (8), */
153		− 0x95, 0x30, /* Report Count (48), */
154		− 0x09, 0x01, /* Usage (Pointer), */
155		− 0xB1, 0x02, /* Feature (Variable), */
156		− 0xC0, /* End Collection, */
157		− 0xC0 /* End Collection */
158		−};
159	78
160	79	/* PS/3 Motion controller */
161	80	static u8 motion_rdesc[] = {
@@ -254,567 +173,6 @@ static u8 motion_rdesc[] = { · 92 unmodified lines
254	173	0xC0 /* End Collection */
255	174	};
256	175
257		−/* PS/3 Navigation controller */
258		−static u8 navigation_rdesc[] = {
259		− 0x05, 0x01, /* Usage Page (Desktop), */
260		− 0x09, 0x04, /* Usage (Joystick), */
261		− 0xA1, 0x01, /* Collection (Application), */
262		− 0xA1, 0x02, /* Collection (Logical), */
263		− 0x85, 0x01, /* Report ID (1), */
264		− 0x75, 0x08, /* Report Size (8), */
265		− 0x95, 0x01, /* Report Count (1), */
266		− 0x15, 0x00, /* Logical Minimum (0), */
267		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
268		− 0x81, 0x03, /* Input (Constant, Variable), */
269		− 0x75, 0x01, /* Report Size (1), */
270		− 0x95, 0x13, /* Report Count (19), */
271		− 0x15, 0x00, /* Logical Minimum (0), */
272		− 0x25, 0x01, /* Logical Maximum (1), */
273		− 0x35, 0x00, /* Physical Minimum (0), */
274		− 0x45, 0x01, /* Physical Maximum (1), */
275		− 0x05, 0x09, /* Usage Page (Button), */
276		− 0x19, 0x01, /* Usage Minimum (01h), */
277		− 0x29, 0x13, /* Usage Maximum (13h), */
278		− 0x81, 0x02, /* Input (Variable), */
279		− 0x75, 0x01, /* Report Size (1), */
280		− 0x95, 0x0D, /* Report Count (13), */
281		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
282		− 0x81, 0x03, /* Input (Constant, Variable), */
283		− 0x15, 0x00, /* Logical Minimum (0), */
284		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
285		− 0x05, 0x01, /* Usage Page (Desktop), */
286		− 0x09, 0x01, /* Usage (Pointer), */
287		− 0xA1, 0x00, /* Collection (Physical), */
288		− 0x75, 0x08, /* Report Size (8), */
289		− 0x95, 0x02, /* Report Count (2), */
290		− 0x35, 0x00, /* Physical Minimum (0), */
291		− 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
292		− 0x09, 0x30, /* Usage (X), */
293		− 0x09, 0x31, /* Usage (Y), */
294		− 0x81, 0x02, /* Input (Variable), */
295		− 0xC0, /* End Collection, */
296		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
297		− 0x95, 0x06, /* Report Count (6), */
298		− 0x81, 0x03, /* Input (Constant, Variable), */
299		− 0x05, 0x01, /* Usage Page (Desktop), */
300		− 0x75, 0x08, /* Report Size (8), */
301		− 0x95, 0x05, /* Report Count (5), */
302		− 0x09, 0x01, /* Usage (Pointer), */
303		− 0x81, 0x02, /* Input (Variable), */
304		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
305		− 0x95, 0x01, /* Report Count (1), */
306		− 0x81, 0x02, /* Input (Variable), */
307		− 0x05, 0x01, /* Usage Page (Desktop), */
308		− 0x95, 0x01, /* Report Count (1), */
309		− 0x09, 0x01, /* Usage (Pointer), */
310		− 0x81, 0x02, /* Input (Variable), */
311		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
312		− 0x95, 0x1E, /* Report Count (24), */
313		− 0x81, 0x02, /* Input (Variable), */
314		− 0x75, 0x08, /* Report Size (8), */
315		− 0x95, 0x30, /* Report Count (48), */
316		− 0x09, 0x01, /* Usage (Pointer), */
317		− 0x91, 0x02, /* Output (Variable), */
318		− 0x75, 0x08, /* Report Size (8), */
319		− 0x95, 0x30, /* Report Count (48), */
320		− 0x09, 0x01, /* Usage (Pointer), */
321		− 0xB1, 0x02, /* Feature (Variable), */
322		− 0xC0, /* End Collection, */
323		− 0xA1, 0x02, /* Collection (Logical), */
324		− 0x85, 0x02, /* Report ID (2), */
325		− 0x75, 0x08, /* Report Size (8), */
326		− 0x95, 0x30, /* Report Count (48), */
327		− 0x09, 0x01, /* Usage (Pointer), */
328		− 0xB1, 0x02, /* Feature (Variable), */
329		− 0xC0, /* End Collection, */
330		− 0xA1, 0x02, /* Collection (Logical), */
331		− 0x85, 0xEE, /* Report ID (238), */
332		− 0x75, 0x08, /* Report Size (8), */
333		− 0x95, 0x30, /* Report Count (48), */
334		− 0x09, 0x01, /* Usage (Pointer), */
335		− 0xB1, 0x02, /* Feature (Variable), */
336		− 0xC0, /* End Collection, */
337		− 0xA1, 0x02, /* Collection (Logical), */
338		− 0x85, 0xEF, /* Report ID (239), */
339		− 0x75, 0x08, /* Report Size (8), */
340		− 0x95, 0x30, /* Report Count (48), */
341		− 0x09, 0x01, /* Usage (Pointer), */
342		− 0xB1, 0x02, /* Feature (Variable), */
343		− 0xC0, /* End Collection, */
344		− 0xC0 /* End Collection */
345		−};
346		−
347		−/*
348		− * The default descriptor doesn't provide mapping for the accelerometers
349		− * or orientation sensors. This fixed descriptor maps the accelerometers
350		− * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
351		− * to usage values 0x43, 0x44 and 0x45.
352		− */
353		−static u8 dualshock4_usb_rdesc[] = {
354		− 0x05, 0x01, /* Usage Page (Desktop), */
355		− 0x09, 0x05, /* Usage (Gamepad), */
356		− 0xA1, 0x01, /* Collection (Application), */
357		− 0x85, 0x01, /* Report ID (1), */
358		− 0x09, 0x30, /* Usage (X), */
359		− 0x09, 0x31, /* Usage (Y), */
360		− 0x09, 0x32, /* Usage (Z), */
361		− 0x09, 0x35, /* Usage (Rz), */
362		− 0x15, 0x00, /* Logical Minimum (0), */
363		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
364		− 0x75, 0x08, /* Report Size (8), */
365		− 0x95, 0x04, /* Report Count (4), */
366		− 0x81, 0x02, /* Input (Variable), */
367		− 0x09, 0x39, /* Usage (Hat Switch), */
368		− 0x15, 0x00, /* Logical Minimum (0), */
369		− 0x25, 0x07, /* Logical Maximum (7), */
370		− 0x35, 0x00, /* Physical Minimum (0), */
371		− 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
372		− 0x65, 0x14, /* Unit (Degrees), */
373		− 0x75, 0x04, /* Report Size (4), */
374		− 0x95, 0x01, /* Report Count (1), */
375		− 0x81, 0x42, /* Input (Variable, Null State), */
376		− 0x65, 0x00, /* Unit, */
377		− 0x05, 0x09, /* Usage Page (Button), */
378		− 0x19, 0x01, /* Usage Minimum (01h), */
379		− 0x29, 0x0D, /* Usage Maximum (0Dh), */
380		− 0x15, 0x00, /* Logical Minimum (0), */
381		− 0x25, 0x01, /* Logical Maximum (1), */
382		− 0x75, 0x01, /* Report Size (1), */
383		− 0x95, 0x0E, /* Report Count (14), */
384		− 0x81, 0x02, /* Input (Variable), */
385		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
386		− 0x09, 0x20, /* Usage (20h), */
387		− 0x75, 0x06, /* Report Size (6), */
388		− 0x95, 0x01, /* Report Count (1), */
389		− 0x15, 0x00, /* Logical Minimum (0), */
390		− 0x25, 0x3F, /* Logical Maximum (63), */
391		− 0x81, 0x02, /* Input (Variable), */
392		− 0x05, 0x01, /* Usage Page (Desktop), */
393		− 0x09, 0x33, /* Usage (Rx), */
394		− 0x09, 0x34, /* Usage (Ry), */
395		− 0x15, 0x00, /* Logical Minimum (0), */
396		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
397		− 0x75, 0x08, /* Report Size (8), */
398		− 0x95, 0x02, /* Report Count (2), */
399		− 0x81, 0x02, /* Input (Variable), */
400		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
401		− 0x09, 0x21, /* Usage (21h), */
402		− 0x95, 0x03, /* Report Count (3), */
403		− 0x81, 0x02, /* Input (Variable), */
404		− 0x05, 0x01, /* Usage Page (Desktop), */
405		− 0x19, 0x40, /* Usage Minimum (40h), */
406		− 0x29, 0x42, /* Usage Maximum (42h), */
407		− 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
408		− 0x26, 0xFF, 0x7F, /* Logical Maximum (32767), */
409		− 0x75, 0x10, /* Report Size (16), */
410		− 0x95, 0x03, /* Report Count (3), */
411		− 0x81, 0x02, /* Input (Variable), */
412		− 0x19, 0x43, /* Usage Minimum (43h), */
413		− 0x29, 0x45, /* Usage Maximum (45h), */
414		− 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
415		− 0x26, 0xFF, 0x7F, /* Logical Maximum (32767), */
416		− 0x95, 0x03, /* Report Count (3), */
417		− 0x81, 0x02, /* Input (Variable), */
418		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
419		− 0x09, 0x21, /* Usage (21h), */
420		− 0x15, 0x00, /* Logical Minimum (0), */
421		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
422		− 0x75, 0x08, /* Report Size (8), */
423		− 0x95, 0x27, /* Report Count (39), */
424		− 0x81, 0x02, /* Input (Variable), */
425		− 0x85, 0x05, /* Report ID (5), */
426		− 0x09, 0x22, /* Usage (22h), */
427		− 0x95, 0x1F, /* Report Count (31), */
428		− 0x91, 0x02, /* Output (Variable), */
429		− 0x85, 0x04, /* Report ID (4), */
430		− 0x09, 0x23, /* Usage (23h), */
431		− 0x95, 0x24, /* Report Count (36), */
432		− 0xB1, 0x02, /* Feature (Variable), */
433		− 0x85, 0x02, /* Report ID (2), */
434		− 0x09, 0x24, /* Usage (24h), */
435		− 0x95, 0x24, /* Report Count (36), */
436		− 0xB1, 0x02, /* Feature (Variable), */
437		− 0x85, 0x08, /* Report ID (8), */
438		− 0x09, 0x25, /* Usage (25h), */
439		− 0x95, 0x03, /* Report Count (3), */
440		− 0xB1, 0x02, /* Feature (Variable), */
441		− 0x85, 0x10, /* Report ID (16), */
442		− 0x09, 0x26, /* Usage (26h), */
443		− 0x95, 0x04, /* Report Count (4), */
444		− 0xB1, 0x02, /* Feature (Variable), */
445		− 0x85, 0x11, /* Report ID (17), */
446		− 0x09, 0x27, /* Usage (27h), */
447		− 0x95, 0x02, /* Report Count (2), */
448		− 0xB1, 0x02, /* Feature (Variable), */
449		− 0x85, 0x12, /* Report ID (18), */
450		− 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
451		− 0x09, 0x21, /* Usage (21h), */
452		− 0x95, 0x0F, /* Report Count (15), */
453		− 0xB1, 0x02, /* Feature (Variable), */
454		− 0x85, 0x13, /* Report ID (19), */
455		− 0x09, 0x22, /* Usage (22h), */
456		− 0x95, 0x16, /* Report Count (22), */
457		− 0xB1, 0x02, /* Feature (Variable), */
458		− 0x85, 0x14, /* Report ID (20), */
459		− 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
460		− 0x09, 0x20, /* Usage (20h), */
461		− 0x95, 0x10, /* Report Count (16), */
462		− 0xB1, 0x02, /* Feature (Variable), */
463		− 0x85, 0x15, /* Report ID (21), */
464		− 0x09, 0x21, /* Usage (21h), */
465		− 0x95, 0x2C, /* Report Count (44), */
466		− 0xB1, 0x02, /* Feature (Variable), */
467		− 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
468		− 0x85, 0x80, /* Report ID (128), */
469		− 0x09, 0x20, /* Usage (20h), */
470		− 0x95, 0x06, /* Report Count (6), */
471		− 0xB1, 0x02, /* Feature (Variable), */
472		− 0x85, 0x81, /* Report ID (129), */
473		− 0x09, 0x21, /* Usage (21h), */
474		− 0x95, 0x06, /* Report Count (6), */
475		− 0xB1, 0x02, /* Feature (Variable), */
476		− 0x85, 0x82, /* Report ID (130), */
477		− 0x09, 0x22, /* Usage (22h), */
478		− 0x95, 0x05, /* Report Count (5), */
479		− 0xB1, 0x02, /* Feature (Variable), */
480		− 0x85, 0x83, /* Report ID (131), */
481		− 0x09, 0x23, /* Usage (23h), */
482		− 0x95, 0x01, /* Report Count (1), */
483		− 0xB1, 0x02, /* Feature (Variable), */
484		− 0x85, 0x84, /* Report ID (132), */
485		− 0x09, 0x24, /* Usage (24h), */
486		− 0x95, 0x04, /* Report Count (4), */
487		− 0xB1, 0x02, /* Feature (Variable), */
488		− 0x85, 0x85, /* Report ID (133), */
489		− 0x09, 0x25, /* Usage (25h), */
490		− 0x95, 0x06, /* Report Count (6), */
491		− 0xB1, 0x02, /* Feature (Variable), */
492		− 0x85, 0x86, /* Report ID (134), */
493		− 0x09, 0x26, /* Usage (26h), */
494		− 0x95, 0x06, /* Report Count (6), */
495		− 0xB1, 0x02, /* Feature (Variable), */
496		− 0x85, 0x87, /* Report ID (135), */
497		− 0x09, 0x27, /* Usage (27h), */
498		− 0x95, 0x23, /* Report Count (35), */
499		− 0xB1, 0x02, /* Feature (Variable), */
500		− 0x85, 0x88, /* Report ID (136), */
501		− 0x09, 0x28, /* Usage (28h), */
502		− 0x95, 0x22, /* Report Count (34), */
503		− 0xB1, 0x02, /* Feature (Variable), */
504		− 0x85, 0x89, /* Report ID (137), */
505		− 0x09, 0x29, /* Usage (29h), */
506		− 0x95, 0x02, /* Report Count (2), */
507		− 0xB1, 0x02, /* Feature (Variable), */
508		− 0x85, 0x90, /* Report ID (144), */
509		− 0x09, 0x30, /* Usage (30h), */
510		− 0x95, 0x05, /* Report Count (5), */
511		− 0xB1, 0x02, /* Feature (Variable), */
512		− 0x85, 0x91, /* Report ID (145), */
513		− 0x09, 0x31, /* Usage (31h), */
514		− 0x95, 0x03, /* Report Count (3), */
515		− 0xB1, 0x02, /* Feature (Variable), */
516		− 0x85, 0x92, /* Report ID (146), */
517		− 0x09, 0x32, /* Usage (32h), */
518		− 0x95, 0x03, /* Report Count (3), */
519		− 0xB1, 0x02, /* Feature (Variable), */
520		− 0x85, 0x93, /* Report ID (147), */
521		− 0x09, 0x33, /* Usage (33h), */
522		− 0x95, 0x0C, /* Report Count (12), */
523		− 0xB1, 0x02, /* Feature (Variable), */
524		− 0x85, 0xA0, /* Report ID (160), */
525		− 0x09, 0x40, /* Usage (40h), */
526		− 0x95, 0x06, /* Report Count (6), */
527		− 0xB1, 0x02, /* Feature (Variable), */
528		− 0x85, 0xA1, /* Report ID (161), */
529		− 0x09, 0x41, /* Usage (41h), */
530		− 0x95, 0x01, /* Report Count (1), */
531		− 0xB1, 0x02, /* Feature (Variable), */
532		− 0x85, 0xA2, /* Report ID (162), */
533		− 0x09, 0x42, /* Usage (42h), */
534		− 0x95, 0x01, /* Report Count (1), */
535		− 0xB1, 0x02, /* Feature (Variable), */
536		− 0x85, 0xA3, /* Report ID (163), */
537		− 0x09, 0x43, /* Usage (43h), */
538		− 0x95, 0x30, /* Report Count (48), */
539		− 0xB1, 0x02, /* Feature (Variable), */
540		− 0x85, 0xA4, /* Report ID (164), */
541		− 0x09, 0x44, /* Usage (44h), */
542		− 0x95, 0x0D, /* Report Count (13), */
543		− 0xB1, 0x02, /* Feature (Variable), */
544		− 0x85, 0xA5, /* Report ID (165), */
545		− 0x09, 0x45, /* Usage (45h), */
546		− 0x95, 0x15, /* Report Count (21), */
547		− 0xB1, 0x02, /* Feature (Variable), */
548		− 0x85, 0xA6, /* Report ID (166), */
549		− 0x09, 0x46, /* Usage (46h), */
550		− 0x95, 0x15, /* Report Count (21), */
551		− 0xB1, 0x02, /* Feature (Variable), */
552		− 0x85, 0xF0, /* Report ID (240), */
553		− 0x09, 0x47, /* Usage (47h), */
554		− 0x95, 0x3F, /* Report Count (63), */
555		− 0xB1, 0x02, /* Feature (Variable), */
556		− 0x85, 0xF1, /* Report ID (241), */
557		− 0x09, 0x48, /* Usage (48h), */
558		− 0x95, 0x3F, /* Report Count (63), */
559		− 0xB1, 0x02, /* Feature (Variable), */
560		− 0x85, 0xF2, /* Report ID (242), */
561		− 0x09, 0x49, /* Usage (49h), */
562		− 0x95, 0x0F, /* Report Count (15), */
563		− 0xB1, 0x02, /* Feature (Variable), */
564		− 0x85, 0xA7, /* Report ID (167), */
565		− 0x09, 0x4A, /* Usage (4Ah), */
566		− 0x95, 0x01, /* Report Count (1), */
567		− 0xB1, 0x02, /* Feature (Variable), */
568		− 0x85, 0xA8, /* Report ID (168), */
569		− 0x09, 0x4B, /* Usage (4Bh), */
570		− 0x95, 0x01, /* Report Count (1), */
571		− 0xB1, 0x02, /* Feature (Variable), */
572		− 0x85, 0xA9, /* Report ID (169), */
573		− 0x09, 0x4C, /* Usage (4Ch), */
574		− 0x95, 0x08, /* Report Count (8), */
575		− 0xB1, 0x02, /* Feature (Variable), */
576		− 0x85, 0xAA, /* Report ID (170), */
577		− 0x09, 0x4E, /* Usage (4Eh), */
578		− 0x95, 0x01, /* Report Count (1), */
579		− 0xB1, 0x02, /* Feature (Variable), */
580		− 0x85, 0xAB, /* Report ID (171), */
581		− 0x09, 0x4F, /* Usage (4Fh), */
582		− 0x95, 0x39, /* Report Count (57), */
583		− 0xB1, 0x02, /* Feature (Variable), */
584		− 0x85, 0xAC, /* Report ID (172), */
585		− 0x09, 0x50, /* Usage (50h), */
586		− 0x95, 0x39, /* Report Count (57), */
587		− 0xB1, 0x02, /* Feature (Variable), */
588		− 0x85, 0xAD, /* Report ID (173), */
589		− 0x09, 0x51, /* Usage (51h), */
590		− 0x95, 0x0B, /* Report Count (11), */
591		− 0xB1, 0x02, /* Feature (Variable), */
592		− 0x85, 0xAE, /* Report ID (174), */
593		− 0x09, 0x52, /* Usage (52h), */
594		− 0x95, 0x01, /* Report Count (1), */
595		− 0xB1, 0x02, /* Feature (Variable), */
596		− 0x85, 0xAF, /* Report ID (175), */
597		− 0x09, 0x53, /* Usage (53h), */
598		− 0x95, 0x02, /* Report Count (2), */
599		− 0xB1, 0x02, /* Feature (Variable), */
600		− 0x85, 0xB0, /* Report ID (176), */
601		− 0x09, 0x54, /* Usage (54h), */
602		− 0x95, 0x3F, /* Report Count (63), */
603		− 0xB1, 0x02, /* Feature (Variable), */
604		− 0xC0 /* End Collection */
605		−};
606		−
607		−/*
608		− * The default behavior of the Dualshock 4 is to send reports using report
609		− * type 1 when running over Bluetooth. However, when feature report 2 is
610		− * requested during the controller initialization it starts sending input
611		− * reports in report 17. Since report 17 is undefined in the default HID
612		− * descriptor the button and axis definitions must be moved to report 17 or
613		− * the HID layer won't process the received input.
614		− */
615		−static u8 dualshock4_bt_rdesc[] = {
616		− 0x05, 0x01, /* Usage Page (Desktop), */
617		− 0x09, 0x05, /* Usage (Gamepad), */
618		− 0xA1, 0x01, /* Collection (Application), */
619		− 0x85, 0x01, /* Report ID (1), */
620		− 0x75, 0x08, /* Report Size (8), */
621		− 0x95, 0x0A, /* Report Count (9), */
622		− 0x81, 0x02, /* Input (Variable), */
623		− 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
624		− 0x85, 0x02, /* Report ID (2), */
625		− 0x09, 0x24, /* Usage (24h), */
626		− 0x95, 0x24, /* Report Count (36), */
627		− 0xB1, 0x02, /* Feature (Variable), */
628		− 0x85, 0xA3, /* Report ID (163), */
629		− 0x09, 0x25, /* Usage (25h), */
630		− 0x95, 0x30, /* Report Count (48), */
631		− 0xB1, 0x02, /* Feature (Variable), */
632		− 0x85, 0x05, /* Report ID (5), */
633		− 0x09, 0x26, /* Usage (26h), */
634		− 0x95, 0x28, /* Report Count (40), */
635		− 0xB1, 0x02, /* Feature (Variable), */
636		− 0x85, 0x06, /* Report ID (6), */
637		− 0x09, 0x27, /* Usage (27h), */
638		− 0x95, 0x34, /* Report Count (52), */
639		− 0xB1, 0x02, /* Feature (Variable), */
640		− 0x85, 0x07, /* Report ID (7), */
641		− 0x09, 0x28, /* Usage (28h), */
642		− 0x95, 0x30, /* Report Count (48), */
643		− 0xB1, 0x02, /* Feature (Variable), */
644		− 0x85, 0x08, /* Report ID (8), */
645		− 0x09, 0x29, /* Usage (29h), */
646		− 0x95, 0x2F, /* Report Count (47), */
647		− 0xB1, 0x02, /* Feature (Variable), */
648		− 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
649		− 0x85, 0x03, /* Report ID (3), */
650		− 0x09, 0x21, /* Usage (21h), */
651		− 0x95, 0x26, /* Report Count (38), */
652		− 0xB1, 0x02, /* Feature (Variable), */
653		− 0x85, 0x04, /* Report ID (4), */
654		− 0x09, 0x22, /* Usage (22h), */
655		− 0x95, 0x2E, /* Report Count (46), */
656		− 0xB1, 0x02, /* Feature (Variable), */
657		− 0x85, 0xF0, /* Report ID (240), */
658		− 0x09, 0x47, /* Usage (47h), */
659		− 0x95, 0x3F, /* Report Count (63), */
660		− 0xB1, 0x02, /* Feature (Variable), */
661		− 0x85, 0xF1, /* Report ID (241), */
662		− 0x09, 0x48, /* Usage (48h), */
663		− 0x95, 0x3F, /* Report Count (63), */
664		− 0xB1, 0x02, /* Feature (Variable), */
665		− 0x85, 0xF2, /* Report ID (242), */
666		− 0x09, 0x49, /* Usage (49h), */
667		− 0x95, 0x0F, /* Report Count (15), */
668		− 0xB1, 0x02, /* Feature (Variable), */
669		− 0x85, 0x11, /* Report ID (17), */
670		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
671		− 0x09, 0x20, /* Usage (20h), */
672		− 0x95, 0x02, /* Report Count (2), */
673		− 0x81, 0x02, /* Input (Variable), */
674		− 0x05, 0x01, /* Usage Page (Desktop), */
675		− 0x09, 0x30, /* Usage (X), */
676		− 0x09, 0x31, /* Usage (Y), */
677		− 0x09, 0x32, /* Usage (Z), */
678		− 0x09, 0x35, /* Usage (Rz), */
679		− 0x15, 0x00, /* Logical Minimum (0), */
680		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
681		− 0x75, 0x08, /* Report Size (8), */
682		− 0x95, 0x04, /* Report Count (4), */
683		− 0x81, 0x02, /* Input (Variable), */
684		− 0x09, 0x39, /* Usage (Hat Switch), */
685		− 0x15, 0x00, /* Logical Minimum (0), */
686		− 0x25, 0x07, /* Logical Maximum (7), */
687		− 0x75, 0x04, /* Report Size (4), */
688		− 0x95, 0x01, /* Report Count (1), */
689		− 0x81, 0x42, /* Input (Variable, Null State), */
690		− 0x05, 0x09, /* Usage Page (Button), */
691		− 0x19, 0x01, /* Usage Minimum (01h), */
692		− 0x29, 0x0D, /* Usage Maximum (0Dh), */
693		− 0x15, 0x00, /* Logical Minimum (0), */
694		− 0x25, 0x01, /* Logical Maximum (1), */
695		− 0x75, 0x01, /* Report Size (1), */
696		− 0x95, 0x0E, /* Report Count (14), */
697		− 0x81, 0x02, /* Input (Variable), */
698		− 0x75, 0x06, /* Report Size (6), */
699		− 0x95, 0x01, /* Report Count (1), */
700		− 0x81, 0x01, /* Input (Constant), */
701		− 0x05, 0x01, /* Usage Page (Desktop), */
702		− 0x09, 0x33, /* Usage (Rx), */
703		− 0x09, 0x34, /* Usage (Ry), */
704		− 0x15, 0x00, /* Logical Minimum (0), */
705		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
706		− 0x75, 0x08, /* Report Size (8), */
707		− 0x95, 0x02, /* Report Count (2), */
708		− 0x81, 0x02, /* Input (Variable), */
709		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
710		− 0x09, 0x20, /* Usage (20h), */
711		− 0x95, 0x03, /* Report Count (3), */
712		− 0x81, 0x02, /* Input (Variable), */
713		− 0x05, 0x01, /* Usage Page (Desktop), */
714		− 0x19, 0x40, /* Usage Minimum (40h), */
715		− 0x29, 0x42, /* Usage Maximum (42h), */
716		− 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
717		− 0x26, 0xFF, 0x7F, /* Logical Maximum (32767), */
718		− 0x75, 0x10, /* Report Size (16), */
719		− 0x95, 0x03, /* Report Count (3), */
720		− 0x81, 0x02, /* Input (Variable), */
721		− 0x19, 0x43, /* Usage Minimum (43h), */
722		− 0x29, 0x45, /* Usage Maximum (45h), */
723		− 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
724		− 0x26, 0xFF, 0x7F, /* Logical Maximum (32767), */
725		− 0x95, 0x03, /* Report Count (3), */
726		− 0x81, 0x02, /* Input (Variable), */
727		− 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
728		− 0x09, 0x20, /* Usage (20h), */
729		− 0x15, 0x00, /* Logical Minimum (0), */
730		− 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
731		− 0x75, 0x08, /* Report Size (8), */
732		− 0x95, 0x31, /* Report Count (51), */
733		− 0x81, 0x02, /* Input (Variable), */
734		− 0x09, 0x21, /* Usage (21h), */
735		− 0x75, 0x08, /* Report Size (8), */
736		− 0x95, 0x4D, /* Report Count (77), */
737		− 0x91, 0x02, /* Output (Variable), */
738		− 0x85, 0x12, /* Report ID (18), */
739		− 0x09, 0x22, /* Usage (22h), */
740		− 0x95, 0x8D, /* Report Count (141), */
741		− 0x81, 0x02, /* Input (Variable), */
742		− 0x09, 0x23, /* Usage (23h), */
743		− 0x91, 0x02, /* Output (Variable), */
744		− 0x85, 0x13, /* Report ID (19), */
745		− 0x09, 0x24, /* Usage (24h), */
746		− 0x95, 0xCD, /* Report Count (205), */
747		− 0x81, 0x02, /* Input (Variable), */
748		− 0x09, 0x25, /* Usage (25h), */
749		− 0x91, 0x02, /* Output (Variable), */
750		− 0x85, 0x14, /* Report ID (20), */
751		− 0x09, 0x26, /* Usage (26h), */
752		− 0x96, 0x0D, 0x01, /* Report Count (269), */
753		− 0x81, 0x02, /* Input (Variable), */
754		− 0x09, 0x27, /* Usage (27h), */
755		− 0x91, 0x02, /* Output (Variable), */
756		− 0x85, 0x15, /* Report ID (21), */
757		− 0x09, 0x28, /* Usage (28h), */
758		− 0x96, 0x4D, 0x01, /* Report Count (333), */
759		− 0x81, 0x02, /* Input (Variable), */
760		− 0x09, 0x29, /* Usage (29h), */
761		− 0x91, 0x02, /* Output (Variable), */
762		− 0x85, 0x16, /* Report ID (22), */
763		− 0x09, 0x2A, /* Usage (2Ah), */
764		− 0x96, 0x8D, 0x01, /* Report Count (397), */
765		− 0x81, 0x02, /* Input (Variable), */
766		− 0x09, 0x2B, /* Usage (2Bh), */
767		− 0x91, 0x02, /* Output (Variable), */
768		− 0x85, 0x17, /* Report ID (23), */
769		− 0x09, 0x2C, /* Usage (2Ch), */
770		− 0x96, 0xCD, 0x01, /* Report Count (461), */
771		− 0x81, 0x02, /* Input (Variable), */
772		− 0x09, 0x2D, /* Usage (2Dh), */
773		− 0x91, 0x02, /* Output (Variable), */
774		− 0x85, 0x18, /* Report ID (24), */
775		− 0x09, 0x2E, /* Usage (2Eh), */
776		− 0x96, 0x0D, 0x02, /* Report Count (525), */
777		− 0x81, 0x02, /* Input (Variable), */
778		− 0x09, 0x2F, /* Usage (2Fh), */
779		− 0x91, 0x02, /* Output (Variable), */
780		− 0x85, 0x19, /* Report ID (25), */
781		− 0x09, 0x30, /* Usage (30h), */
782		− 0x96, 0x22, 0x02, /* Report Count (546), */
783		− 0x81, 0x02, /* Input (Variable), */
784		− 0x09, 0x31, /* Usage (31h), */
785		− 0x91, 0x02, /* Output (Variable), */
786		− 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
787		− 0x85, 0x82, /* Report ID (130), */
788		− 0x09, 0x22, /* Usage (22h), */
789		− 0x95, 0x3F, /* Report Count (63), */
790		− 0xB1, 0x02, /* Feature (Variable), */
791		− 0x85, 0x83, /* Report ID (131), */
792		− 0x09, 0x23, /* Usage (23h), */
793		− 0xB1, 0x02, /* Feature (Variable), */
794		− 0x85, 0x84, /* Report ID (132), */
795		− 0x09, 0x24, /* Usage (24h), */
796		− 0xB1, 0x02, /* Feature (Variable), */
797		− 0x85, 0x90, /* Report ID (144), */
798		− 0x09, 0x30, /* Usage (30h), */
799		− 0xB1, 0x02, /* Feature (Variable), */
800		− 0x85, 0x91, /* Report ID (145), */
801		− 0x09, 0x31, /* Usage (31h), */
802		− 0xB1, 0x02, /* Feature (Variable), */
803		− 0x85, 0x92, /* Report ID (146), */
804		− 0x09, 0x32, /* Usage (32h), */
805		− 0xB1, 0x02, /* Feature (Variable), */
806		− 0x85, 0x93, /* Report ID (147), */
807		− 0x09, 0x33, /* Usage (33h), */
808		− 0xB1, 0x02, /* Feature (Variable), */
809		− 0x85, 0xA0, /* Report ID (160), */
810		− 0x09, 0x40, /* Usage (40h), */
811		− 0xB1, 0x02, /* Feature (Variable), */
812		− 0x85, 0xA4, /* Report ID (164), */
813		− 0x09, 0x44, /* Usage (44h), */
814		− 0xB1, 0x02, /* Feature (Variable), */
815		− 0xC0 /* End Collection */
816		−};
817		−
818	176	static u8 ps3remote_rdesc[] = {
819	177	0x05, 0x01, /* GUsagePage Generic Desktop */
820	178	0x09, 0x05, /* LUsage 0x05 [Game Pad] */
@@ -977,6 +335,67 @@ static const unsigned int buzz_keymap[] = { · 156 unmodified lines
977	335	[20] = BTN_TRIGGER_HAPPY20,
978	336	};
979	337
	338	+/* The Navigation controller is a partial DS3 and uses the same HID report
	339	+ * and hence the same keymap indices, however not not all axes/buttons
	340	+ * are physically present. We use the same axis and button mapping as
	341	+ * the DS3, which uses the Linux gamepad spec.
	342	+ */
	343	+static const unsigned int navigation_absmap[] = {
	344	+ [0x30] = ABS_X,
	345	+ [0x31] = ABS_Y,
	346	+ [0x33] = ABS_Z, /* L2 */
	347	+};
	348	+
	349	+/* Buttons not physically available on the device, but still available
	350	+ * in the reports are explicitly set to 0 for documentation purposes.
	351	+ */
	352	+static const unsigned int navigation_keymap[] = {
	353	+ [0x01] = 0, /* Select */
	354	+ [0x02] = BTN_THUMBL, /* L3 */
	355	+ [0x03] = 0, /* R3 */
	356	+ [0x04] = 0, /* Start */
	357	+ [0x05] = BTN_DPAD_UP, /* Up */
	358	+ [0x06] = BTN_DPAD_RIGHT, /* Right */
	359	+ [0x07] = BTN_DPAD_DOWN, /* Down */
	360	+ [0x08] = BTN_DPAD_LEFT, /* Left */
	361	+ [0x09] = BTN_TL2, /* L2 */
	362	+ [0x0a] = 0, /* R2 */
	363	+ [0x0b] = BTN_TL, /* L1 */
	364	+ [0x0c] = 0, /* R1 */
	365	+ [0x0d] = BTN_NORTH, /* Triangle */
	366	+ [0x0e] = BTN_EAST, /* Circle */
	367	+ [0x0f] = BTN_SOUTH, /* Cross */
	368	+ [0x10] = BTN_WEST, /* Square */
	369	+ [0x11] = BTN_MODE, /* PS */
	370	+};
	371	+
	372	+static const unsigned int sixaxis_absmap[] = {
	373	+ [0x30] = ABS_X,
	374	+ [0x31] = ABS_Y,
	375	+ [0x32] = ABS_RX, /* right stick X */
	376	+ [0x35] = ABS_RY, /* right stick Y */
	377	+};
	378	+
	379	+static const unsigned int sixaxis_keymap[] = {
	380	+ [0x01] = BTN_SELECT, /* Select */
	381	+ [0x02] = BTN_THUMBL, /* L3 */
	382	+ [0x03] = BTN_THUMBR, /* R3 */
	383	+ [0x04] = BTN_START, /* Start */
	384	+ [0x05] = BTN_DPAD_UP, /* Up */
	385	+ [0x06] = BTN_DPAD_RIGHT, /* Right */
	386	+ [0x07] = BTN_DPAD_DOWN, /* Down */
	387	+ [0x08] = BTN_DPAD_LEFT, /* Left */
	388	+ [0x09] = BTN_TL2, /* L2 */
	389	+ [0x0a] = BTN_TR2, /* R2 */
	390	+ [0x0b] = BTN_TL, /* L1 */
	391	+ [0x0c] = BTN_TR, /* R1 */
	392	+ [0x0d] = BTN_NORTH, /* Triangle */
	393	+ [0x0e] = BTN_EAST, /* Circle */
	394	+ [0x0f] = BTN_SOUTH, /* Cross */
	395	+ [0x10] = BTN_WEST, /* Square */
	396	+ [0x11] = BTN_MODE, /* PS */
	397	+};
	398	+
980	399	static const unsigned int ds4_absmap[] = {
981	400	[0x30] = ABS_X,
982	401	[0x31] = ABS_Y,
@@ -1002,6 +421,10 @@ static const unsigned int ds4_keymap[] = { · 19 unmodified lines
1002	421	[0xd] = BTN_MODE, /* PS */
1003	422	};
1004	423
	424	+static const struct {int x; int y; } ds4_hat_mapping[] = {
	425	+ {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
	426	+ {0, 0}
	427	+};
1005	428
1006	429	static enum power_supply_property sony_battery_props[] = {
1007	430	POWER_SUPPLY_PROP_PRESENT,
@@ -1048,6 +471,7 @@ struct motion_output_report_02 { · 40 unmodified lines
1048	471	};
1049	472
1050	473	#define DS4_FEATURE_REPORT_0x02_SIZE 37
	474	+#define DS4_FEATURE_REPORT_0x05_SIZE 41
1051	475	#define DS4_FEATURE_REPORT_0x81_SIZE 7
1052	476	#define DS4_INPUT_REPORT_0x11_SIZE 78
1053	477	#define DS4_OUTPUT_REPORT_0x05_SIZE 32
@@ -1059,23 +483,62 @@ struct motion_output_report_02 { · 5 unmodified lines
1059	483	/* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
1060	484	* additional +2.
1061	485	*/
	486	+#define DS4_INPUT_REPORT_AXIS_OFFSET 1
1062	487	#define DS4_INPUT_REPORT_BUTTON_OFFSET 5
	488	+#define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
	489	+#define DS4_INPUT_REPORT_GYRO_X_OFFSET 13
1063	490	#define DS4_INPUT_REPORT_BATTERY_OFFSET 30
1064	491	#define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
1065	492
	493	+#define SENSOR_SUFFIX " Motion Sensors"
1066	494	#define DS4_TOUCHPAD_SUFFIX " Touchpad"
1067	495
	496	+/* Default to 4ms poll interval, which is same as USB (not adjustable). */
	497	+#define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
	498	+#define DS4_BT_MAX_POLL_INTERVAL_MS 62
	499	+#define DS4_GYRO_RES_PER_DEG_S 1024
	500	+#define DS4_ACC_RES_PER_G 8192
	501	+
	502	+#define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
	503	+#define SIXAXIS_ACC_RES_PER_G 113
	504	+
1068	505	static DEFINE_SPINLOCK(sony_dev_list_lock);
1069	506	static LIST_HEAD(sony_device_list);
1070	507	static DEFINE_IDA(sony_device_id_allocator);
1071	508
	509	+/* Used for calibration of DS4 accelerometer and gyro. */
	510	+struct ds4_calibration_data {
	511	+ int abs_code;
	512	+ short bias;
	513	+ /* Calibration requires scaling against a sensitivity value, which is a
	514	+ * float. Store sensitivity as a fraction to limit floating point
	515	+ * calculations until final calibration.
	516	+ */
	517	+ int sens_numer;
	518	+ int sens_denom;
	519	+};
	520	+
	521	+enum ds4_dongle_state {
	522	+ DONGLE_DISCONNECTED,
	523	+ DONGLE_CALIBRATING,
	524	+ DONGLE_CONNECTED,
	525	+ DONGLE_DISABLED
	526	+};
	527	+
	528	+enum sony_worker {
	529	+ SONY_WORKER_STATE,
	530	+ SONY_WORKER_HOTPLUG
	531	+};
	532	+
1072	533	struct sony_sc {
1073	534	spinlock_t lock;
1074	535	struct list_head list_node;
1075	536	struct hid_device *hdev;
1076	537	struct input_dev *touchpad;
	538	+ struct input_dev *sensor_dev;
1077	539	struct led_classdev *leds[MAX_LEDS];
1078	540	unsigned long quirks;
	541	+ struct work_struct hotplug_worker;
1079	542	struct work_struct state_worker;
1080	543	void (send_output_report)(struct sony_sc );
1081	544	struct power_supply *battery;
@@ -1089,46 +552,87 @@ struct sony_sc { · 7 unmodified lines
1089	552	#endif
1090	553
1091	554	u8 mac_address[6];
1092		− u8 worker_initialized;
	555	+ u8 hotplug_worker_initialized;
	556	+ u8 state_worker_initialized;
1093	557	u8 defer_initialization;
1094	558	u8 cable_state;
1095	559	u8 battery_charging;
1096	560	u8 battery_capacity;
1097	561	u8 led_state[MAX_LEDS];
1098		− u8 resume_led_state[MAX_LEDS];
1099	562	u8 led_delay_on[MAX_LEDS];
1100	563	u8 led_delay_off[MAX_LEDS];
1101	564	u8 led_count;
1102		− bool ds4_dongle_connected;
	565	+
	566	+ bool timestamp_initialized;
	567	+ u16 prev_timestamp;
	568	+ unsigned int timestamp_us;
	569	+
	570	+ u8 ds4_bt_poll_interval;
	571	+ enum ds4_dongle_state ds4_dongle_state;
	572	+ /* DS4 calibration data */
	573	+ struct ds4_calibration_data ds4_calib_data[6];
1103	574	};
1104	575
1105	576	static void sony_set_leds(struct sony_sc *sc);
1106	577
1107		−static inline void sony_schedule_work(struct sony_sc *sc)
	578	+static inline void sony_schedule_work(struct sony_sc *sc,
	579	+ enum sony_worker which)
1108	580	{
1109		− if (!sc->defer_initialization)
1110		− schedule_work(&sc->state_worker);
	581	+ switch (which) {
	582	+ case SONY_WORKER_STATE:
	583	+ if (!sc->defer_initialization)
	584	+ schedule_work(&sc->state_worker);
	585	+ break;
	586	+ case SONY_WORKER_HOTPLUG:
	587	+ if (sc->hotplug_worker_initialized)
	588	+ schedule_work(&sc->hotplug_worker);
	589	+ break;
	590	+ }
1111	591	}
1112	592
1113		−static u8 sixaxis_fixup(struct hid_device hdev, u8 *rdesc,
1114		− unsigned int *rsize)
	593	+static ssize_t ds4_show_poll_interval(struct device *dev,
	594	+ struct device_attribute
	595	+ attr, char buf)
1115	596	{
1116		− *rsize = sizeof(sixaxis_rdesc);
1117		− return sixaxis_rdesc;
	597	+ struct hid_device *hdev = to_hid_device(dev);
	598	+ struct sony_sc *sc = hid_get_drvdata(hdev);
	599	+
	600	+ return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
1118	601	}
1119	602
1120		−static u8 motion_fixup(struct hid_device hdev, u8 *rdesc,
1121		− unsigned int *rsize)
	603	+static ssize_t ds4_store_poll_interval(struct device *dev,
	604	+ struct device_attribute *attr,
	605	+ const char *buf, size_t count)
1122	606	{
1123		− *rsize = sizeof(motion_rdesc);
1124		− return motion_rdesc;
	607	+ struct hid_device *hdev = to_hid_device(dev);
	608	+ struct sony_sc *sc = hid_get_drvdata(hdev);
	609	+ unsigned long flags;
	610	+ u8 interval;
	611	+
	612	+ if (kstrtou8(buf, 0, &interval))
	613	+ return -EINVAL;
	614	+
	615	+ if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
	616	+ return -EINVAL;
	617	+
	618	+ spin_lock_irqsave(&sc->lock, flags);
	619	+ sc->ds4_bt_poll_interval = interval;
	620	+ spin_unlock_irqrestore(&sc->lock, flags);
	621	+
	622	+ sony_schedule_work(sc, SONY_WORKER_STATE);
	623	+
	624	+ return count;
1125	625	}
1126	626
1127		−static u8 navigation_fixup(struct hid_device hdev, u8 *rdesc,
	627	+static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
	628	+ ds4_store_poll_interval);
	629	+
	630	+
	631	+static u8 motion_fixup(struct hid_device hdev, u8 *rdesc,
1128	632	unsigned int *rsize)
1129	633	{
1130		− *rsize = sizeof(navigation_rdesc);
1131		− return navigation_rdesc;
	634	+ *rsize = sizeof(motion_rdesc);
	635	+ return motion_rdesc;
1132	636	}
1133	637
1134	638	static u8 ps3remote_fixup(struct hid_device hdev, u8 *rdesc,
@@ -1172,6 +676,102 @@ static int ps3remote_mapping(struct hid_device hdev, struct hid_input hi, · 37 unmodified lines
1172	676	return 1;
1173	677	}
1174	678
	679	+static int navigation_mapping(struct hid_device hdev, struct hid_input hi,
	680	+ struct hid_field field, struct hid_usage usage,
	681	+ unsigned long *bit, int max)
	682	+{
	683	+ if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
	684	+ unsigned int key = usage->hid & HID_USAGE;
	685	+
	686	+ if (key >= ARRAY_SIZE(sixaxis_keymap))
	687	+ return -1;
	688	+
	689	+ key = navigation_keymap[key];
	690	+ if (!key)
	691	+ return -1;
	692	+
	693	+ hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
	694	+ return 1;
	695	+ } else if (usage->hid == HID_GD_POINTER) {
	696	+ /* See comment in sixaxis_mapping, basically the L2 (and R2)
	697	+ * triggers are reported through GD Pointer.
	698	+ * In addition we ignore any analog button 'axes' and only
	699	+ * support digital buttons.
	700	+ */
	701	+ switch (usage->usage_index) {
	702	+ case 8: /* L2 */
	703	+ usage->hid = HID_GD_Z;
	704	+ break;
	705	+ default:
	706	+ return -1;
	707	+ }
	708	+
	709	+ hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
	710	+ return 1;
	711	+ } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
	712	+ unsigned int abs = usage->hid & HID_USAGE;
	713	+
	714	+ if (abs >= ARRAY_SIZE(navigation_absmap))
	715	+ return -1;
	716	+
	717	+ abs = navigation_absmap[abs];
	718	+
	719	+ hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
	720	+ return 1;
	721	+ }
	722	+
	723	+ return -1;
	724	+}
	725	+
	726	+
	727	+static int sixaxis_mapping(struct hid_device hdev, struct hid_input hi,
	728	+ struct hid_field field, struct hid_usage usage,
	729	+ unsigned long *bit, int max)
	730	+{
	731	+ if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
	732	+ unsigned int key = usage->hid & HID_USAGE;
	733	+
	734	+ if (key >= ARRAY_SIZE(sixaxis_keymap))
	735	+ return -1;
	736	+
	737	+ key = sixaxis_keymap[key];
	738	+ hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
	739	+ return 1;
	740	+ } else if (usage->hid == HID_GD_POINTER) {
	741	+ /* The DS3 provides analog values for most buttons and even
	742	+ * for HAT axes through GD Pointer. L2 and R2 are reported
	743	+ * among these as well instead of as GD Z / RZ. Remap L2
	744	+ * and R2 and ignore other analog 'button axes' as there is
	745	+ * no good way for reporting them.
	746	+ */
	747	+ switch (usage->usage_index) {
	748	+ case 8: /* L2 */
	749	+ usage->hid = HID_GD_Z;
	750	+ break;
	751	+ case 9: /* R2 */
	752	+ usage->hid = HID_GD_RZ;
	753	+ break;
	754	+ default:
	755	+ return -1;
	756	+ }
	757	+
	758	+ hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
	759	+ return 1;
	760	+ } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
	761	+ unsigned int abs = usage->hid & HID_USAGE;
	762	+
	763	+ if (abs >= ARRAY_SIZE(sixaxis_absmap))
	764	+ return -1;
	765	+
	766	+ abs = sixaxis_absmap[abs];
	767	+
	768	+ hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
	769	+ return 1;
	770	+ }
	771	+
	772	+ return -1;
	773	+}
	774	+
1175	775	static int ds4_mapping(struct hid_device hdev, struct hid_input hi,
1176	776	struct hid_field field, struct hid_usage usage,
1177	777	unsigned long *bit, int max)
@@ -1227,30 +827,9 @@ static u8 sony_report_fixup(struct hid_device hdev, u8 *rdesc, · 49 unmodified lines
1227	827	rdesc[55] = 0x06;
1228	828	}
1229	829
1230		− /*
1231		− * The default Dualshock 4 USB descriptor doesn't assign
1232		− * the gyroscope values to corresponding axes so we need a
1233		− * modified one.
1234		− */
1235		− if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1236		− hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
1237		− rdesc = dualshock4_usb_rdesc;
1238		− *rsize = sizeof(dualshock4_usb_rdesc);
1239		− } else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1240		− hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
1241		− rdesc = dualshock4_bt_rdesc;
1242		− *rsize = sizeof(dualshock4_bt_rdesc);
1243		− }
1244		−
1245		− if (sc->quirks & SIXAXIS_CONTROLLER)
1246		− return sixaxis_fixup(hdev, rdesc, rsize);
1247		−
1248	830	if (sc->quirks & MOTION_CONTROLLER)
1249	831	return motion_fixup(hdev, rdesc, rsize);
1250	832
1251		− if (sc->quirks & NAVIGATION_CONTROLLER)
1252		− return navigation_fixup(hdev, rdesc, rsize);
1253		−
1254	833	if (sc->quirks & PS3REMOTE)
1255	834	return ps3remote_fixup(hdev, rdesc, rsize);
1256	835
@@ -1288,21 +867,131 @@ static void sixaxis_parse_report(struct sony_sc sc, u8 rd, int size) · 31 unmodified lines
1288	867	sc->battery_capacity = battery_capacity;
1289	868	sc->battery_charging = battery_charging;
1290	869	spin_unlock_irqrestore(&sc->lock, flags);
	870	+
	871	+ if (sc->quirks & SIXAXIS_CONTROLLER) {
	872	+ int val;
	873	+
	874	+ offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
	875	+ val = ((rd[offset+1] << 8) \| rd[offset]) - 511;
	876	+ input_report_abs(sc->sensor_dev, ABS_X, val);
	877	+
	878	+ /* Y and Z are swapped and inversed */
	879	+ val = 511 - ((rd[offset+5] << 8) \| rd[offset+4]);
	880	+ input_report_abs(sc->sensor_dev, ABS_Y, val);
	881	+
	882	+ val = 511 - ((rd[offset+3] << 8) \| rd[offset+2]);
	883	+ input_report_abs(sc->sensor_dev, ABS_Z, val);
	884	+
	885	+ input_sync(sc->sensor_dev);
	886	+ }
1291	887	}
1292	888
1293	889	static void dualshock4_parse_report(struct sony_sc sc, u8 rd, int size)
1294	890	{
	891	+ struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
	892	+ struct hid_input, list);
	893	+ struct input_dev *input_dev = hidinput->input;
1295	894	unsigned long flags;
1296	895	int n, m, offset, num_touch_data, max_touch_data;
1297	896	u8 cable_state, battery_capacity, battery_charging;
	897	+ u16 timestamp;
1298	898
1299	899	/* When using Bluetooth the header is 2 bytes longer, so skip these. */
1300		− int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 0 : 2;
	900	+ int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
1301	901
1302	902	/* Second bit of third button byte is for the touchpad button. */
1303	903	offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
1304	904	input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1305	905
	906	+ /*
	907	+ * The default behavior of the Dualshock 4 is to send reports using
	908	+ * report type 1 when running over Bluetooth. However, when feature
	909	+ * report 2 is requested during the controller initialization it starts
	910	+ * sending input reports in report 17. Since report 17 is undefined
	911	+ * in the default HID descriptor, the HID layer won't generate events.
	912	+ * While it is possible (and this was done before) to fixup the HID
	913	+ * descriptor to add this mapping, it was better to do this manually.
	914	+ * The reason is there were various pieces software both open and closed
	915	+ * source, relying on the descriptors to be the same across various
	916	+ * operating systems. If the descriptors wouldn't match some
	917	+ * applications e.g. games on Wine would not be able to function due
	918	+ * to different descriptors, which such applications are not parsing.
	919	+ */
	920	+ if (rd[0] == 17) {
	921	+ int value;
	922	+
	923	+ offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
	924	+ input_report_abs(input_dev, ABS_X, rd[offset]);
	925	+ input_report_abs(input_dev, ABS_Y, rd[offset+1]);
	926	+ input_report_abs(input_dev, ABS_RX, rd[offset+2]);
	927	+ input_report_abs(input_dev, ABS_RY, rd[offset+3]);
	928	+
	929	+ value = rd[offset+4] & 0xf;
	930	+ if (value > 7)
	931	+ value = 8; /* Center 0, 0 */
	932	+ input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
	933	+ input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
	934	+
	935	+ input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
	936	+ input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
	937	+ input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
	938	+ input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
	939	+
	940	+ input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
	941	+ input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
	942	+ input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
	943	+ input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
	944	+ input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
	945	+ input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
	946	+ input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
	947	+ input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
	948	+
	949	+ input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
	950	+
	951	+ input_report_abs(input_dev, ABS_Z, rd[offset+7]);
	952	+ input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
	953	+
	954	+ input_sync(input_dev);
	955	+ }
	956	+
	957	+ /* Convert timestamp (in 5.33us unit) to timestamp_us */
	958	+ offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
	959	+ timestamp = get_unaligned_le16(&rd[offset]);
	960	+ if (!sc->timestamp_initialized) {
	961	+ sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
	962	+ sc->timestamp_initialized = true;
	963	+ } else {
	964	+ u16 delta;
	965	+
	966	+ if (sc->prev_timestamp > timestamp)
	967	+ delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
	968	+ else
	969	+ delta = timestamp - sc->prev_timestamp;
	970	+ sc->timestamp_us += (delta * 16) / 3;
	971	+ }
	972	+ sc->prev_timestamp = timestamp;
	973	+ input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
	974	+
	975	+ offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
	976	+ for (n = 0; n < 6; n++) {
	977	+ /* Store data in int for more precision during mult_frac. */
	978	+ int raw_data = (short)((rd[offset+1] << 8) \| rd[offset]);
	979	+ struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
	980	+
	981	+ /* High precision is needed during calibration, but the
	982	+ * calibrated values are within 32-bit.
	983	+ * Note: we swap numerator 'x' and 'numer' in mult_frac for
	984	+ * precision reasons so we don't need 64-bit.
	985	+ */
	986	+ int calib_data = mult_frac(calib->sens_numer,
	987	+ raw_data - calib->bias,
	988	+ calib->sens_denom);
	989	+
	990	+ input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
	991	+ offset += 2;
	992	+ }
	993	+ input_sync(sc->sensor_dev);
	994	+
1306	995	/*
1307	996	* The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1308	997	* and the 5th bit contains the USB cable state.
@@ -1341,7 +1030,7 @@ static void dualshock4_parse_report(struct sony_sc sc, u8 rd, int size) · 32 unmodified lines
1341	1030	* Trackpad data starts 2 bytes later (e.g. 35 for USB).
1342	1031	*/
1343	1032	offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1344		− max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 3 : 4;
	1033	+ max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1345	1034	if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1346	1035	num_touch_data = rd[offset];
1347	1036	else
@@ -1415,47 +1104,79 @@ static int sony_raw_event(struct hid_device hdev, struct hid_report report, · 67 unmodified lines
1415	1104	} else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1416	1105	size == 49) {
1417	1106	sixaxis_parse_report(sc, rd, size);
1418		− } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1419		− size == 64) \|\| ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1420		− && rd[0] == 0x11 && size == 78)) {
1421		− if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1422		− /* CRC check */
1423		− u8 bthdr = 0xA1;
1424		− u32 crc;
1425		− u32 report_crc;
	1107	+ } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
	1108	+ size == 64) {
	1109	+ dualshock4_parse_report(sc, rd, size);
	1110	+ } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
	1111	+ size == 78)) {
	1112	+ /* CRC check */
	1113	+ u8 bthdr = 0xA1;
	1114	+ u32 crc;
	1115	+ u32 report_crc;
1426	1116
1427		− crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1428		− crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1429		− report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1430		− if (crc != report_crc) {
1431		− hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1432		− report_crc, crc);
1433		− return -EILSEQ;
1434		− }
	1117	+ crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
	1118	+ crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
	1119	+ report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
	1120	+ if (crc != report_crc) {
	1121	+ hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
	1122	+ report_crc, crc);
	1123	+ return -EILSEQ;
1435	1124	}
1436	1125
	1126	+ dualshock4_parse_report(sc, rd, size);
	1127	+ } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
	1128	+ size == 64) {
	1129	+ unsigned long flags;
	1130	+ enum ds4_dongle_state dongle_state;
	1131	+
1437	1132	/*
1438	1133	* In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1439	1134	* if a DS4 is actually connected (indicated by '0').
1440	1135	* For non-dongle, this bit is always 0 (connected).
1441	1136	*/
1442		− if (sc->hdev->vendor == USB_VENDOR_ID_SONY &&
1443		− sc->hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) {
1444		− bool connected = (rd[31] & 0x04) ? false : true;
1445		−
1446		− if (!sc->ds4_dongle_connected && connected) {
1447		− hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1448		− sony_set_leds(sc);
1449		− sc->ds4_dongle_connected = true;
1450		− } else if (sc->ds4_dongle_connected && !connected) {
1451		− hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1452		− sc->ds4_dongle_connected = false;
1453		− /* Return 0, so hidraw can get the report. */
1454		− return 0;
1455		− } else if (!sc->ds4_dongle_connected) {
1456		− /* Return 0, so hidraw can get the report. */
1457		− return 0;
1458		− }
	1137	+ bool connected = (rd[31] & 0x04) ? false : true;
	1138	+
	1139	+ spin_lock_irqsave(&sc->lock, flags);
	1140	+ dongle_state = sc->ds4_dongle_state;
	1141	+ spin_unlock_irqrestore(&sc->lock, flags);
	1142	+
	1143	+ /*
	1144	+ * The dongle always sends input reports even when no
	1145	+ * DS4 is attached. When a DS4 is connected, we need to
	1146	+ * obtain calibration data before we can use it.
	1147	+ * The code below tracks dongle state and kicks of
	1148	+ * calibration when needed and only allows us to process
	1149	+ * input if a DS4 is actually connected.
	1150	+ */
	1151	+ if (dongle_state == DONGLE_DISCONNECTED && connected) {
	1152	+ hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
	1153	+ sony_set_leds(sc);
	1154	+
	1155	+ spin_lock_irqsave(&sc->lock, flags);
	1156	+ sc->ds4_dongle_state = DONGLE_CALIBRATING;
	1157	+ spin_unlock_irqrestore(&sc->lock, flags);
	1158	+
	1159	+ sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
	1160	+
	1161	+ /* Don't process the report since we don't have
	1162	+ * calibration data, but let hidraw have it anyway.
	1163	+ */
	1164	+ return 0;
	1165	+ } else if ((dongle_state == DONGLE_CONNECTED \|\|
	1166	+ dongle_state == DONGLE_DISABLED) && !connected) {
	1167	+ hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
	1168	+
	1169	+ spin_lock_irqsave(&sc->lock, flags);
	1170	+ sc->ds4_dongle_state = DONGLE_DISCONNECTED;
	1171	+ spin_unlock_irqrestore(&sc->lock, flags);
	1172	+
	1173	+ /* Return 0, so hidraw can get the report. */
	1174	+ return 0;
	1175	+ } else if (dongle_state == DONGLE_CALIBRATING \|\|
	1176	+ dongle_state == DONGLE_DISABLED \|\|
	1177	+ dongle_state == DONGLE_DISCONNECTED) {
	1178	+ /* Return 0, so hidraw can get the report. */
	1179	+ return 0;
1459	1180	}
1460	1181
1461	1182	dualshock4_parse_report(sc, rd, size);
@@ -1463,7 +1184,7 @@ static int sony_raw_event(struct hid_device hdev, struct hid_report report, · 1 unmodified line
1463	1184
1464	1185	if (sc->defer_initialization) {
1465	1186	sc->defer_initialization = 0;
1466		− sony_schedule_work(sc);
	1187	+ sony_schedule_work(sc, SONY_WORKER_STATE);
1467	1188	}
1468	1189
1469	1190	return 0;
@@ -1501,10 +1222,16 @@ static int sony_mapping(struct hid_device hdev, struct hid_input hi, · 31 unmodified lines
1501	1222	if (sc->quirks & PS3REMOTE)
1502	1223	return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1503	1224
	1225	+ if (sc->quirks & NAVIGATION_CONTROLLER)
	1226	+ return navigation_mapping(hdev, hi, field, usage, bit, max);
	1227	+
	1228	+ if (sc->quirks & SIXAXIS_CONTROLLER)
	1229	+ return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1504	1230
1505	1231	if (sc->quirks & DUALSHOCK4_CONTROLLER)
1506	1232	return ds4_mapping(hdev, hi, field, usage, bit, max);
1507	1233
	1234	+
1508	1235	/* Let hid-core decide for the others */
1509	1236	return 0;
1510	1237	}
@@ -1541,7 +1268,7 @@ static int sony_register_touchpad(struct sony_sc *sc, int touch_count, · 30 unmodified lines
1541	1268	snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1542	1269	sc->touchpad->name = name;
1543	1270
1544		− ret = input_mt_init_slots(sc->touchpad, touch_count, 0);
	1271	+ ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1545	1272	if (ret < 0)
1546	1273	goto err;
1547	1274
@@ -1581,6 +1308,103 @@ static void sony_unregister_touchpad(struct sony_sc *sc) · 33 unmodified lines
1581	1308	sc->touchpad = NULL;
1582	1309	}
1583	1310
	1311	+static int sony_register_sensors(struct sony_sc *sc)
	1312	+{
	1313	+ size_t name_sz;
	1314	+ char *name;
	1315	+ int ret;
	1316	+ int range;
	1317	+
	1318	+ sc->sensor_dev = input_allocate_device();
	1319	+ if (!sc->sensor_dev)
	1320	+ return -ENOMEM;
	1321	+
	1322	+ input_set_drvdata(sc->sensor_dev, sc);
	1323	+ sc->sensor_dev->dev.parent = &sc->hdev->dev;
	1324	+ sc->sensor_dev->phys = sc->hdev->phys;
	1325	+ sc->sensor_dev->uniq = sc->hdev->uniq;
	1326	+ sc->sensor_dev->id.bustype = sc->hdev->bus;
	1327	+ sc->sensor_dev->id.vendor = sc->hdev->vendor;
	1328	+ sc->sensor_dev->id.product = sc->hdev->product;
	1329	+ sc->sensor_dev->id.version = sc->hdev->version;
	1330	+
	1331	+ /* Append a suffix to the controller name as there are various
	1332	+ * DS4 compatible non-Sony devices with different names.
	1333	+ */
	1334	+ name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
	1335	+ name = kzalloc(name_sz, GFP_KERNEL);
	1336	+ if (!name) {
	1337	+ ret = -ENOMEM;
	1338	+ goto err;
	1339	+ }
	1340	+ snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
	1341	+ sc->sensor_dev->name = name;
	1342	+
	1343	+ if (sc->quirks & SIXAXIS_CONTROLLER) {
	1344	+ /* For the DS3 we only support the accelerometer, which works
	1345	+ * quite well even without calibration. The device also has
	1346	+ * a 1-axis gyro, but it is very difficult to manage from within
	1347	+ * the driver even to get data, the sensor is inaccurate and
	1348	+ * the behavior is very different between hardware revisions.
	1349	+ */
	1350	+ input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
	1351	+ input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
	1352	+ input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
	1353	+ input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
	1354	+ input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
	1355	+ input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
	1356	+ } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
	1357	+ range = DS4_ACC_RES_PER_G*4;
	1358	+ input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
	1359	+ input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
	1360	+ input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
	1361	+ input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
	1362	+ input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
	1363	+ input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
	1364	+
	1365	+ range = DS4_GYRO_RES_PER_DEG_S*2048;
	1366	+ input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
	1367	+ input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
	1368	+ input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
	1369	+ input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
	1370	+ input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
	1371	+ input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
	1372	+
	1373	+ __set_bit(EV_MSC, sc->sensor_dev->evbit);
	1374	+ __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
	1375	+ }
	1376	+
	1377	+ __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
	1378	+
	1379	+ ret = input_register_device(sc->sensor_dev);
	1380	+ if (ret < 0)
	1381	+ goto err;
	1382	+
	1383	+ return 0;
	1384	+
	1385	+err:
	1386	+ kfree(sc->sensor_dev->name);
	1387	+ sc->sensor_dev->name = NULL;
	1388	+
	1389	+ input_free_device(sc->sensor_dev);
	1390	+ sc->sensor_dev = NULL;
	1391	+
	1392	+ return ret;
	1393	+}
	1394	+
	1395	+static void sony_unregister_sensors(struct sony_sc *sc)
	1396	+{
	1397	+ if (!sc->sensor_dev)
	1398	+ return;
	1399	+
	1400	+ kfree(sc->sensor_dev->name);
	1401	+ sc->sensor_dev->name = NULL;
	1402	+
	1403	+ input_unregister_device(sc->sensor_dev);
	1404	+ sc->sensor_dev = NULL;
	1405	+}
	1406	+
	1407	+
1584	1408	/*
1585	1409	* Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1586	1410	* to "operational". Without this, the ps3 controller will not report any
@@ -1646,26 +1470,176 @@ static int sixaxis_set_operational_bt(struct hid_device *hdev) · 59 unmodified lines
1646	1470	}
1647	1471
1648	1472	/*
1649		− * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1650		− * controller so that it sends full input reports of type 0x11.
	1473	+ * Request DS4 calibration data for the motion sensors.
	1474	+ * For Bluetooth this also affects the operating mode (see below).
1651	1475	*/
1652		−static int dualshock4_set_operational_bt(struct hid_device *hdev)
	1476	+static int dualshock4_get_calibration_data(struct sony_sc *sc)
1653	1477	{
1654	1478	u8 *buf;
1655	1479	int ret;
	1480	+ short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
	1481	+ short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
	1482	+ short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
	1483	+ short gyro_speed_plus, gyro_speed_minus;
	1484	+ short acc_x_plus, acc_x_minus;
	1485	+ short acc_y_plus, acc_y_minus;
	1486	+ short acc_z_plus, acc_z_minus;
	1487	+ int speed_2x;
	1488	+ int range_2g;
	1489	+
	1490	+ /* For Bluetooth we use a different request, which supports CRC.
	1491	+ * Note: in Bluetooth mode feature report 0x02 also changes the state
	1492	+ * of the controller, so that it sends input reports of type 0x11.
	1493	+ */
	1494	+ if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB \| DUALSHOCK4_DONGLE)) {
	1495	+ buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
	1496	+ if (!buf)
	1497	+ return -ENOMEM;
1656	1498
1657		− buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1658		− if (!buf)
1659		− return -ENOMEM;
	1499	+ ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
	1500	+ DS4_FEATURE_REPORT_0x02_SIZE,
	1501	+ HID_FEATURE_REPORT,
	1502	+ HID_REQ_GET_REPORT);
	1503	+ if (ret < 0)
	1504	+ goto err_stop;
	1505	+ } else {
	1506	+ u8 bthdr = 0xA3;
	1507	+ u32 crc;
	1508	+ u32 report_crc;
	1509	+ int retries;
	1510	+
	1511	+ buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
	1512	+ if (!buf)
	1513	+ return -ENOMEM;
1660	1514
1661		− ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_FEATURE_REPORT_0x02_SIZE,
1662		− HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
	1515	+ for (retries = 0; retries < 3; retries++) {
	1516	+ ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
	1517	+ DS4_FEATURE_REPORT_0x05_SIZE,
	1518	+ HID_FEATURE_REPORT,
	1519	+ HID_REQ_GET_REPORT);
	1520	+ if (ret < 0)
	1521	+ goto err_stop;
1663	1522
1664		− kfree(buf);
	1523	+ /* CRC check */
	1524	+ crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
	1525	+ crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
	1526	+ report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
	1527	+ if (crc != report_crc) {
	1528	+ hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
	1529	+ report_crc, crc);
	1530	+ if (retries < 2) {
	1531	+ hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
	1532	+ continue;
	1533	+ } else {
	1534	+ ret = -EILSEQ;
	1535	+ goto err_stop;
	1536	+ }
	1537	+ } else {
	1538	+ break;
	1539	+ }
	1540	+ }
	1541	+ }
1665	1542
	1543	+ gyro_pitch_bias = get_unaligned_le16(&buf[1]);
	1544	+ gyro_yaw_bias = get_unaligned_le16(&buf[3]);
	1545	+ gyro_roll_bias = get_unaligned_le16(&buf[5]);
	1546	+ if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
	1547	+ gyro_pitch_plus = get_unaligned_le16(&buf[7]);
	1548	+ gyro_pitch_minus = get_unaligned_le16(&buf[9]);
	1549	+ gyro_yaw_plus = get_unaligned_le16(&buf[11]);
	1550	+ gyro_yaw_minus = get_unaligned_le16(&buf[13]);
	1551	+ gyro_roll_plus = get_unaligned_le16(&buf[15]);
	1552	+ gyro_roll_minus = get_unaligned_le16(&buf[17]);
	1553	+ } else {
	1554	+ /* BT + Dongle */
	1555	+ gyro_pitch_plus = get_unaligned_le16(&buf[7]);
	1556	+ gyro_yaw_plus = get_unaligned_le16(&buf[9]);
	1557	+ gyro_roll_plus = get_unaligned_le16(&buf[11]);
	1558	+ gyro_pitch_minus = get_unaligned_le16(&buf[13]);
	1559	+ gyro_yaw_minus = get_unaligned_le16(&buf[15]);
	1560	+ gyro_roll_minus = get_unaligned_le16(&buf[17]);
	1561	+ }
	1562	+ gyro_speed_plus = get_unaligned_le16(&buf[19]);
	1563	+ gyro_speed_minus = get_unaligned_le16(&buf[21]);
	1564	+ acc_x_plus = get_unaligned_le16(&buf[23]);
	1565	+ acc_x_minus = get_unaligned_le16(&buf[25]);
	1566	+ acc_y_plus = get_unaligned_le16(&buf[27]);
	1567	+ acc_y_minus = get_unaligned_le16(&buf[29]);
	1568	+ acc_z_plus = get_unaligned_le16(&buf[31]);
	1569	+ acc_z_minus = get_unaligned_le16(&buf[33]);
	1570	+
	1571	+ /* Set gyroscope calibration and normalization parameters.
	1572	+ * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
	1573	+ */
	1574	+ speed_2x = (gyro_speed_plus + gyro_speed_minus);
	1575	+ sc->ds4_calib_data[0].abs_code = ABS_RX;
	1576	+ sc->ds4_calib_data[0].bias = gyro_pitch_bias;
	1577	+ sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
	1578	+ sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
	1579	+
	1580	+ sc->ds4_calib_data[1].abs_code = ABS_RY;
	1581	+ sc->ds4_calib_data[1].bias = gyro_yaw_bias;
	1582	+ sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
	1583	+ sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
	1584	+
	1585	+ sc->ds4_calib_data[2].abs_code = ABS_RZ;
	1586	+ sc->ds4_calib_data[2].bias = gyro_roll_bias;
	1587	+ sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
	1588	+ sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
	1589	+
	1590	+ /* Set accelerometer calibration and normalization parameters.
	1591	+ * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
	1592	+ */
	1593	+ range_2g = acc_x_plus - acc_x_minus;
	1594	+ sc->ds4_calib_data[3].abs_code = ABS_X;
	1595	+ sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
	1596	+ sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
	1597	+ sc->ds4_calib_data[3].sens_denom = range_2g;
	1598	+
	1599	+ range_2g = acc_y_plus - acc_y_minus;
	1600	+ sc->ds4_calib_data[4].abs_code = ABS_Y;
	1601	+ sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
	1602	+ sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
	1603	+ sc->ds4_calib_data[4].sens_denom = range_2g;
	1604	+
	1605	+ range_2g = acc_z_plus - acc_z_minus;
	1606	+ sc->ds4_calib_data[5].abs_code = ABS_Z;
	1607	+ sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
	1608	+ sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
	1609	+ sc->ds4_calib_data[5].sens_denom = range_2g;
	1610	+
	1611	+err_stop:
	1612	+ kfree(buf);
1666	1613	return ret;
1667	1614	}
1668	1615
	1616	+static void dualshock4_calibration_work(struct work_struct *work)
	1617	+{
	1618	+ struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
	1619	+ unsigned long flags;
	1620	+ enum ds4_dongle_state dongle_state;
	1621	+ int ret;
	1622	+
	1623	+ ret = dualshock4_get_calibration_data(sc);
	1624	+ if (ret < 0) {
	1625	+ /* This call is very unlikely to fail for the dongle. When it
	1626	+ * fails we are probably in a very bad state, so mark the
	1627	+ * dongle as disabled. We will re-enable the dongle if a new
	1628	+ * DS4 hotplug is detect from sony_raw_event as any issues
	1629	+ * are likely resolved then (the dongle is quite stupid).
	1630	+ */
	1631	+ hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
	1632	+ dongle_state = DONGLE_DISABLED;
	1633	+ } else {
	1634	+ hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
	1635	+ dongle_state = DONGLE_CONNECTED;
	1636	+ }
	1637	+
	1638	+ spin_lock_irqsave(&sc->lock, flags);
	1639	+ sc->ds4_dongle_state = dongle_state;
	1640	+ spin_unlock_irqrestore(&sc->lock, flags);
	1641	+}
	1642	+
1669	1643	static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1670	1644	{
1671	1645	static const u8 sixaxis_leds[10][4] = {
@@ -1696,10 +1670,10 @@ static void dualshock4_set_leds_from_id(struct sony_sc *sc) · 24 unmodified lines
1696	1670	{
1697	1671	/* The first 4 color/index entries match what the PS4 assigns */
1698	1672	static const u8 color_code[7][3] = {
1699		− /* Blue */ { 0x00, 0x00, 0x01 },
1700		− /* Red */ { 0x01, 0x00, 0x00 },
1701		− /* Green */ { 0x00, 0x01, 0x00 },
1702		− /* Pink */ { 0x02, 0x00, 0x01 },
	1673	+ /* Blue */ { 0x00, 0x00, 0x40 },
	1674	+ /* Red */ { 0x40, 0x00, 0x00 },
	1675	+ /* Green */ { 0x00, 0x40, 0x00 },
	1676	+ /* Pink */ { 0x20, 0x00, 0x20 },
1703	1677	/* Orange */ { 0x02, 0x01, 0x00 },
1704	1678	/* Teal */ { 0x00, 0x01, 0x01 },
1705	1679	/* White */ { 0x01, 0x01, 0x01 }
@@ -1740,7 +1714,7 @@ static void buzz_set_leds(struct sony_sc *sc) · 34 unmodified lines
1740	1714	static void sony_set_leds(struct sony_sc *sc)
1741	1715	{
1742	1716	if (!(sc->quirks & BUZZ_CONTROLLER))
1743		− sony_schedule_work(sc);
	1717	+ sony_schedule_work(sc, SONY_WORKER_STATE);
1744	1718	else
1745	1719	buzz_set_leds(sc);
1746	1720	}
@@ -1851,7 +1825,7 @@ static int sony_led_blink_set(struct led_classdev led, unsigned long delay_on, · 104 unmodified lines
1851	1825	new_off != drv_data->led_delay_off[n]) {
1852	1826	drv_data->led_delay_on[n] = new_on;
1853	1827	drv_data->led_delay_off[n] = new_off;
1854		− sony_schedule_work(drv_data);
	1828	+ sony_schedule_work(drv_data, SONY_WORKER_STATE);
1855	1829	}
1856	1830
1857	1831	return 0;
@@ -1964,6 +1938,7 @@ static int sony_leds_init(struct sony_sc *sc) · 106 unmodified lines
1964	1938	led->name = name;
1965	1939	led->brightness = sc->led_state[n];
1966	1940	led->max_brightness = max_brightness[n];
	1941	+ led->flags = LED_CORE_SUSPENDRESUME;
1967	1942	led->brightness_get = sony_led_get_brightness;
1968	1943	led->brightness_set = sony_led_set_brightness;
1969	1944
@@ -2052,26 +2027,24 @@ static void dualshock4_send_output_report(struct sony_sc *sc) · 82 unmodified lines
2052	2027	int offset;
2053	2028
2054	2029	/*
2055		− * NOTE: The buf[1] field of the Bluetooth report controls
2056		− * the Dualshock 4 reporting rate.
2057		− *
2058		− * Known values include:
2059		− *
2060		− * 0x80 - 1000hz (full speed)
2061		− * 0xA0 - 31hz
2062		− * 0xB0 - 20hz
2063		− * 0xD0 - 66hz
	2030	+ * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
	2031	+ * control the interval at which Dualshock 4 reports data:
	2032	+ * 0x00 - 1ms
	2033	+ * 0x01 - 1ms
	2034	+ * 0x02 - 2ms
	2035	+ * 0x3E - 62ms
	2036	+ * 0x3F - disabled
2064	2037	*/
2065		− if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
	2038	+ if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB \| DUALSHOCK4_DONGLE)) {
2066	2039	memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2067	2040	buf[0] = 0x05;
2068		− buf[1] = 0xFF;
	2041	+ buf[1] = 0x07; /* blink + LEDs + motor */
2069	2042	offset = 4;
2070	2043	} else {
2071	2044	memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2072	2045	buf[0] = 0x11;
2073		− buf[1] = 0xC0; /* HID + CRC */
2074		− buf[3] = 0x0F;
	2046	+ buf[1] = 0xC0 /* HID + CRC */ \| sc->ds4_bt_poll_interval;
	2047	+ buf[3] = 0x07; /* blink + LEDs + motor */
2075	2048	offset = 6;
2076	2049	}
2077	2050
@@ -2095,7 +2068,7 @@ static void dualshock4_send_output_report(struct sony_sc *sc) · 17 unmodified lines
2095	2068	buf[offset++] = sc->led_delay_on[3];
2096	2069	buf[offset++] = sc->led_delay_off[3];
2097	2070
2098		− if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
	2071	+ if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB \| DUALSHOCK4_DONGLE))
2099	2072	hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2100	2073	else {
2101	2074	/* CRC generation */
@@ -2152,7 +2125,7 @@ static int sony_allocate_output_report(struct sony_sc *sc) · 50 unmodified lines
2152	2125	else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2153	2126	sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x11_SIZE,
2154	2127	GFP_KERNEL);
2155		− else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
	2128	+ else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB \| DUALSHOCK4_DONGLE))
2156	2129	sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x05_SIZE,
2157	2130	GFP_KERNEL);
2158	2131	else if (sc->quirks & MOTION_CONTROLLER)
@@ -2180,7 +2153,7 @@ static int sony_play_effect(struct input_dev dev, void data, · 21 unmodified lines
2180	2153	sc->left = effect->u.rumble.strong_magnitude / 256;
2181	2154	sc->right = effect->u.rumble.weak_magnitude / 256;
2182	2155
2183		− sony_schedule_work(sc);
	2156	+ sony_schedule_work(sc, SONY_WORKER_STATE);
2184	2157	return 0;
2185	2158	}
2186	2159
@@ -2397,7 +2370,7 @@ static int sony_check_add(struct sony_sc *sc) · 210 unmodified lines
2397	2370	hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2398	2371	return 0;
2399	2372	}
2400		− } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
	2373	+ } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB \| DUALSHOCK4_DONGLE)) {
2401	2374	buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2402	2375	if (!buf)
2403	2376	return -ENOMEM;
@@ -2451,6 +2424,12 @@ static int sony_check_add(struct sony_sc *sc) · 47 unmodified lines
2451	2424	*/
2452	2425	for (n = 0; n < 6; n++)
2453	2426	sc->mac_address[5-n] = buf[4+n];
	2427	+
	2428	+ snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
	2429	+ "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
	2430	+ sc->mac_address[5], sc->mac_address[4],
	2431	+ sc->mac_address[3], sc->mac_address[2],
	2432	+ sc->mac_address[1], sc->mac_address[0]);
2454	2433	} else {
2455	2434	return 0;
2456	2435	}
@@ -2501,18 +2480,21 @@ static inline void sony_init_output_report(struct sony_sc *sc, · 44 unmodified lines
2501	2480	{
2502	2481	sc->send_output_report = send_output_report;
2503	2482
2504		− if (!sc->worker_initialized)
	2483	+ if (!sc->state_worker_initialized)
2505	2484	INIT_WORK(&sc->state_worker, sony_state_worker);
2506	2485
2507		− sc->worker_initialized = 1;
	2486	+ sc->state_worker_initialized = 1;
2508	2487	}
2509	2488
2510	2489	static inline void sony_cancel_work_sync(struct sony_sc *sc)
2511	2490	{
2512		− if (sc->worker_initialized)
	2491	+ if (sc->hotplug_worker_initialized)
	2492	+ cancel_work_sync(&sc->hotplug_worker);
	2493	+ if (sc->state_worker_initialized)
2513	2494	cancel_work_sync(&sc->state_worker);
2514	2495	}
2515	2496
	2497	+
2516	2498	static int sony_input_configured(struct hid_device *hdev,
2517	2499	struct hid_input *hidinput)
2518	2500	{
@@ -2526,14 +2508,17 @@ static int sony_input_configured(struct hid_device *hdev, · 7 unmodified lines
2526	2508	goto err_stop;
2527	2509	}
2528	2510
	2511	+ ret = append_dev_id = sony_check_add(sc);
	2512	+ if (ret < 0)
	2513	+ goto err_stop;
	2514	+
2529	2515	ret = sony_allocate_output_report(sc);
2530	2516	if (ret < 0) {
2531	2517	hid_err(hdev, "failed to allocate the output report buffer\n");
2532	2518	goto err_stop;
2533	2519	}
2534	2520
2535		− if ((sc->quirks & SIXAXIS_CONTROLLER_USB) \|\|
2536		− (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
	2521	+ if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2537	2522	/*
2538	2523	* The Sony Sixaxis does not handle HID Output Reports on the
2539	2524	* Interrupt EP like it could, so we need to force HID Output
@@ -2553,24 +2538,79 @@ static int sony_input_configured(struct hid_device *hdev, · 13 unmodified lines
2553	2538	hdev->quirks \|= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2554	2539	hdev->quirks \|= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2555	2540	sc->defer_initialization = 1;
	2541	+
2556	2542	ret = sixaxis_set_operational_usb(hdev);
	2543	+ if (ret < 0) {
	2544	+ hid_err(hdev, "Failed to set controller into operational mode\n");
	2545	+ goto err_stop;
	2546	+ }
	2547	+
	2548	+ sony_init_output_report(sc, sixaxis_send_output_report);
	2549	+ } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
	2550	+ /*
	2551	+ * The Navigation controller wants output reports sent on the ctrl
	2552	+ * endpoint when connected via Bluetooth.
	2553	+ */
	2554	+ hdev->quirks \|= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
	2555	+
	2556	+ ret = sixaxis_set_operational_bt(hdev);
	2557	+ if (ret < 0) {
	2558	+ hid_err(hdev, "Failed to set controller into operational mode\n");
	2559	+ goto err_stop;
	2560	+ }
	2561	+
2557	2562	sony_init_output_report(sc, sixaxis_send_output_report);
2558		− } else if ((sc->quirks & SIXAXIS_CONTROLLER_BT) \|\|
2559		− (sc->quirks & NAVIGATION_CONTROLLER_BT)) {
	2563	+ } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
	2564	+ /*
	2565	+ * The Sony Sixaxis does not handle HID Output Reports on the
	2566	+ * Interrupt EP and the device only becomes active when the
	2567	+ * PS button is pressed. See comment for Navigation controller
	2568	+ * above for more details.
	2569	+ */
	2570	+ hdev->quirks \|= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
	2571	+ hdev->quirks \|= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
	2572	+ sc->defer_initialization = 1;
	2573	+
	2574	+ ret = sixaxis_set_operational_usb(hdev);
	2575	+ if (ret < 0) {
	2576	+ hid_err(hdev, "Failed to set controller into operational mode\n");
	2577	+ goto err_stop;
	2578	+ }
	2579	+
	2580	+ ret = sony_register_sensors(sc);
	2581	+ if (ret) {
	2582	+ hid_err(sc->hdev,
	2583	+ "Unable to initialize motion sensors: %d\n", ret);
	2584	+ goto err_stop;
	2585	+ }
	2586	+
	2587	+ sony_init_output_report(sc, sixaxis_send_output_report);
	2588	+ } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2560	2589	/*
2561	2590	* The Sixaxis wants output reports sent on the ctrl endpoint
2562	2591	* when connected via Bluetooth.
2563	2592	*/
2564	2593	hdev->quirks \|= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
	2594	+
2565	2595	ret = sixaxis_set_operational_bt(hdev);
	2596	+ if (ret < 0) {
	2597	+ hid_err(hdev, "Failed to set controller into operational mode\n");
	2598	+ goto err_stop;
	2599	+ }
	2600	+
	2601	+ ret = sony_register_sensors(sc);
	2602	+ if (ret) {
	2603	+ hid_err(sc->hdev,
	2604	+ "Unable to initialize motion sensors: %d\n", ret);
	2605	+ goto err_stop;
	2606	+ }
	2607	+
2566	2608	sony_init_output_report(sc, sixaxis_send_output_report);
2567	2609	} else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2568		− if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2569		− ret = dualshock4_set_operational_bt(hdev);
2570		− if (ret < 0) {
2571		− hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2572		− goto err_stop;
2573		− }
	2610	+ ret = dualshock4_get_calibration_data(sc);
	2611	+ if (ret < 0) {
	2612	+ hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
	2613	+ goto err_stop;
2574	2614	}
2575	2615
2576	2616	/*
@@ -2585,6 +2625,28 @@ static int sony_input_configured(struct hid_device *hdev, · 8 unmodified lines
2585	2625	goto err_stop;
2586	2626	}
2587	2627
	2628	+ ret = sony_register_sensors(sc);
	2629	+ if (ret) {
	2630	+ hid_err(sc->hdev,
	2631	+ "Unable to initialize motion sensors: %d\n", ret);
	2632	+ goto err_stop;
	2633	+ }
	2634	+
	2635	+ if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
	2636	+ sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
	2637	+ ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
	2638	+ if (ret)
	2639	+ hid_warn(sc->hdev,
	2640	+ "can't create sysfs bt_poll_interval attribute err: %d\n",
	2641	+ ret);
	2642	+ }
	2643	+
	2644	+ if (sc->quirks & DUALSHOCK4_DONGLE) {
	2645	+ INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
	2646	+ sc->hotplug_worker_initialized = 1;
	2647	+ sc->ds4_dongle_state = DONGLE_DISCONNECTED;
	2648	+ }
	2649	+
2588	2650	sony_init_output_report(sc, dualshock4_send_output_report);
2589	2651	} else if (sc->quirks & MOTION_CONTROLLER) {
2590	2652	sony_init_output_report(sc, motion_send_output_report);
@@ -2592,13 +2654,6 @@ static int sony_input_configured(struct hid_device *hdev, · 1 unmodified line
2592	2654	ret = 0;
2593	2655	}
2594	2656
2595		− if (ret < 0)
2596		− goto err_stop;
2597		−
2598		− ret = append_dev_id = sony_check_add(sc);
2599		− if (ret < 0)
2600		− goto err_stop;
2601		−
2602	2657	if (sc->quirks & SONY_LED_SUPPORT) {
2603	2658	ret = sony_leds_init(sc);
2604	2659	if (ret < 0)
@@ -2628,12 +2683,20 @@ static int sony_input_configured(struct hid_device *hdev, · 23 unmodified lines
2628	2683	err_close:
2629	2684	hid_hw_close(hdev);
2630	2685	err_stop:
	2686	+ /* Piggy back on the default ds4_bt_ poll_interval to determine
	2687	+ * if we need to remove the file as we don't know for sure if we
	2688	+ * executed that logic.
	2689	+ */
	2690	+ if (sc->ds4_bt_poll_interval)
	2691	+ device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2631	2692	if (sc->quirks & SONY_LED_SUPPORT)
2632	2693	sony_leds_remove(sc);
2633	2694	if (sc->quirks & SONY_BATTERY_SUPPORT)
2634	2695	sony_battery_remove(sc);
2635	2696	if (sc->touchpad)
2636	2697	sony_unregister_touchpad(sc);
	2698	+ if (sc->sensor_dev)
	2699	+ sony_unregister_sensors(sc);
2637	2700	sony_cancel_work_sync(sc);
2638	2701	kfree(sc->output_report_dmabuf);
2639	2702	sony_remove_dev_list(sc);
@@ -2675,13 +2738,13 @@ static int sony_probe(struct hid_device hdev, const struct hid_device_id id) · 35 unmodified lines
2675	2738	else if (sc->quirks & SIXAXIS_CONTROLLER)
2676	2739	connect_mask \|= HID_CONNECT_HIDDEV_FORCE;
2677	2740
2678		− /* Patch the hw version on DS4 compatible devices, so applications can
	2741	+ /* Patch the hw version on DS3/4 compatible devices, so applications can
2679	2742	* distinguish between the default HID mappings and the mappings defined
2680	2743	* by the Linux game controller spec. This is important for the SDL2
2681	2744	* library, which has a game controller database, which uses device ids
2682	2745	* in combination with version as a key.
2683	2746	*/
2684		− if (sc->quirks & DUALSHOCK4_CONTROLLER)
	2747	+ if (sc->quirks & (SIXAXIS_CONTROLLER \| DUALSHOCK4_CONTROLLER))
2685	2748	hdev->version \|= 0x8000;
2686	2749
2687	2750	ret = hid_hw_start(hdev, connect_mask);
@@ -2721,6 +2784,12 @@ static void sony_remove(struct hid_device *hdev) · 33 unmodified lines
2721	2784	if (sc->touchpad)
2722	2785	sony_unregister_touchpad(sc);
2723	2786
	2787	+ if (sc->sensor_dev)
	2788	+ sony_unregister_sensors(sc);
	2789	+
	2790	+ if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
	2791	+ device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
	2792	+
2724	2793	sony_cancel_work_sync(sc);
2725	2794
2726	2795	kfree(sc->output_report_dmabuf);
@@ -2736,47 +2805,32 @@ static void sony_remove(struct hid_device *hdev) · 9 unmodified lines
2736	2805
2737	2806	static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2738	2807	{
2739		− /*
2740		− * On suspend save the current LED state,
2741		− * stop running force-feedback and blank the LEDS.
2742		− */
2743		− if (SONY_LED_SUPPORT \|\| SONY_FF_SUPPORT) {
2744		− struct sony_sc *sc = hid_get_drvdata(hdev);
2745		−
2746	2808	#ifdef CONFIG_SONY_FF
2747		− sc->left = sc->right = 0;
2748		−#endif
2749	2809
2750		− memcpy(sc->resume_led_state, sc->led_state,
2751		− sizeof(sc->resume_led_state));
2752		− memset(sc->led_state, 0, sizeof(sc->led_state));
	2810	+ /* On suspend stop any running force-feedback events */
	2811	+ if (SONY_FF_SUPPORT) {
	2812	+ struct sony_sc *sc = hid_get_drvdata(hdev);
2753	2813
	2814	+ sc->left = sc->right = 0;
2754	2815	sony_send_output_report(sc);
2755	2816	}
2756	2817
	2818	+#endif
2757	2819	return 0;
2758	2820	}
2759	2821
2760	2822	static int sony_resume(struct hid_device *hdev)
2761	2823	{
2762		− /* Restore the state of controller LEDs on resume */
2763		− if (SONY_LED_SUPPORT) {
2764		− struct sony_sc *sc = hid_get_drvdata(hdev);
2765		−
2766		− memcpy(sc->led_state, sc->resume_led_state,
2767		− sizeof(sc->led_state));
2768		−
2769		− /*
2770		− * The Sixaxis and navigation controllers on USB need to be
2771		− * reinitialized on resume or they won't behave properly.
2772		− */
2773		− if ((sc->quirks & SIXAXIS_CONTROLLER_USB) \|\|
2774		− (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2775		− sixaxis_set_operational_usb(sc->hdev);
2776		− sc->defer_initialization = 1;
2777		− }
	2824	+ struct sony_sc *sc = hid_get_drvdata(hdev);
2778	2825
2779		− sony_set_leds(sc);
	2826	+ /*
	2827	+ * The Sixaxis and navigation controllers on USB need to be
	2828	+ * reinitialized on resume or they won't behave properly.
	2829	+ */
	2830	+ if ((sc->quirks & SIXAXIS_CONTROLLER_USB) \|\|
	2831	+ (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
	2832	+ sixaxis_set_operational_usb(sc->hdev);
	2833	+ sc->defer_initialization = 1;
2780	2834	}
2781	2835
2782	2836	return 0;
@@ -2828,7 +2882,7 @@ static const struct hid_device_id sony_devices[] = { · 45 unmodified lines
2828	2882	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2829	2883	.driver_data = DUALSHOCK4_CONTROLLER_BT },
2830	2884	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
2831		− .driver_data = DUALSHOCK4_CONTROLLER_USB },
	2885	+ .driver_data = DUALSHOCK4_DONGLE },
2832	2886	/* Nyko Core Controller for PS3 */
2833	2887	{ HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2834	2888	.driver_data = SIXAXIS_CONTROLLER_USB \| SINO_LITE_CONTROLLER },

include/uapi/linux/input.h+8−3

@@ -61,9 +61,14 @@ struct input_id { · 60 unmodified lines
61	61	* Note that input core does not clamp reported values to the
62	62	* [minimum, maximum] limits, such task is left to userspace.
63	63	*
64		− * Resolution for main axes (ABS_X, ABS_Y, ABS_Z) is reported in
65		− * units per millimeter (units/mm), resolution for rotational axes
66		− * (ABS_RX, ABS_RY, ABS_RZ) is reported in units per radian.
	64	+ * The default resolution for main axes (ABS_X, ABS_Y, ABS_Z)
	65	+ * is reported in units per millimeter (units/mm), resolution
	66	+ * for rotational axes (ABS_RX, ABS_RY, ABS_RZ) is reported
	67	+ * in units per radian.
	68	+ * When INPUT_PROP_ACCELEROMETER is set the resolution changes.
	69	+ * The main axes (ABS_X, ABS_Y, ABS_Z) are then reported in
	70	+ * in units per g (units/g) and in units per degree per second
	71	+ * (units/deg/s) for rotational axes (ABS_RX, ABS_RY, ABS_RZ).
67	72	*/
68	73	struct input_absinfo {
69	74	__s32 value;