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