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