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