projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'thermal-6.8-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[linux-2.6-block.git] / drivers / hid / hid-sony.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
bd28ce00 2/*
077147a3 3 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
bd28ce00
JS		 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
bd28ce00 8 * Copyright (c) 2008 Jiri Slaby
078328da
JK		 9 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
10 * Copyright (c) 2006-2013 Jiri Kosina
f04d5140 11 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
c4425c8f 12 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
b7289cb1 13 * Copyright (c) 2018 Todd Kelner
a4bfe13f 14 * Copyright (c) 2020-2021 Pascal Giard <pascal.giard@etsmtl.ca>
32e411d0 15 * Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
a4bfe13f 16 * Copyright (c) 2021 Daniel Nguyen <daniel.nguyen.1@ens.etsmtl.ca>
bd28ce00
JS		 17 */
18
19/*
bd28ce00
JS		 20 */
21
ad142b9e
FP		 22/*
23 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
078328da
JK		 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
bd28ce00
JS		 30#include <linux/device.h>
31#include <linux/hid.h>
32#include <linux/module.h>
5a0e3ad6 33#include <linux/slab.h>
40e32ee6 34#include <linux/leds.h>
d902f472
FP		 35#include <linux/power_supply.h>
36#include <linux/spinlock.h>
d2d782fc 37#include <linux/list.h>
8025087a 38#include <linux/idr.h>
e5606230 39#include <linux/input/mt.h>
49b9ca6c 40#include <linux/crc32.h>
cc894ac5
PG		 41#include <linux/usb.h>
42#include <linux/timer.h>
49b9ca6c 43#include <asm/unaligned.h>
bd28ce00
JS		 44
45#include "hid-ids.h"
46
6c79c18c
FP		 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)
4f1f3918
RC		 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)
cc6e0bbb 64
fee4e2d5 65#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
b3bca326 66#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
4545ee0a
SW		 67#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
68 NAVIGATION_CONTROLLER_BT)
fee4e2d5 69#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
4f1f3918
RC		 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)
b7289cb1 74#define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
60781cf4
FP		 75
76#define MAX_LEDS 4
b7289cb1
TK		 77#define NSG_MRXU_MAX_X 1667
78#define NSG_MRXU_MAX_Y 1868
0a286ef2 79
a4bfe13f
DN		 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 */
32e411d0 84#define GUITAR_TILT_USAGE 44
cc894ac5 85
a4bfe13f 86/* Magic data taken from GHLtarUtility:
cc894ac5
PG		 87 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
88 * Note: The Wii U and PS3 dongles happen to share the same!
89 */
cc894ac5
PG		 90static const char ghl_ps3wiiu_magic_data[] = {
91 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
92};
e57a67da 93
a4bfe13f
DN		 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
c5e0c1c4 101/* PS/3 Motion controller */
1adf904e 102static u8 motion_rdesc[] = {
c5e0c1c4
FP		 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), */
c5e0c1c4 108 0x75, 0x01, /* Report Size (1), */
8b2513c3 109 0x95, 0x15, /* Report Count (21), */
c5e0c1c4
FP		 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), */
8b2513c3
SW		 116 0x29, 0x15, /* Usage Maximum (15h), */
117 0x81, 0x02, /* Input (Variable), * Buttons */
118 0x95, 0x0B, /* Report Count (11), */
c5e0c1c4 119 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
8b2513c3 120 0x81, 0x03, /* Input (Constant, Variable), * Padding */
c5e0c1c4
FP		 121 0x15, 0x00, /* Logical Minimum (0), */
122 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
123 0x05, 0x01, /* Usage Page (Desktop), */
c5e0c1c4
FP		 124 0xA1, 0x00, /* Collection (Physical), */
125 0x75, 0x08, /* Report Size (8), */
8b2513c3 126 0x95, 0x01, /* Report Count (1), */
c5e0c1c4
FP		 127 0x35, 0x00, /* Physical Minimum (0), */
128 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
129 0x09, 0x30, /* Usage (X), */
8b2513c3 130 0x81, 0x02, /* Input (Variable), * Trigger */
c5e0c1c4 131 0xC0, /* End Collection, */
8b2513c3
SW		 132 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
133 0x75, 0x08, /* Report Size (8), */
134 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
c5e0c1c4 135 0x81, 0x02, /* Input (Variable), */
8b2513c3 136 0x05, 0x01, /* Usage Page (Desktop), */
c5e0c1c4 137 0x75, 0x10, /* Report Size (16), */
8b2513c3
SW		 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), */
c5e0c1c4 149 0x09, 0x01, /* Usage (Pointer), */
8b2513c3
SW		 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 */
c5e0c1c4 154 0x81, 0x02, /* Input (Variable), */
8b2513c3
SW		 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), */
c5e0c1c4
FP		 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
1adf904e 198static u8 ps3remote_rdesc[] = {
078328da
JK		 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
ef916ef5
AO		 206 /*
207 * Ignore the 1st byte, maybe it is used for a controller
208 * number but it's not needed for correct operation
209 */
078328da
JK		 210 0x75, 0x08, /* GReportSize 0x08 [8] */
211 0x95, 0x01, /* GReportCount 0x01 [1] */
212 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
213
ef916ef5
AO		 214 /*
215 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
216 * buttons multiple keypresses are allowed
217 */
078328da
JK		 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
ef916ef5
AO		 242 /*
243 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
244 * 0xff and 11th is for press indication
245 */
078328da
JK		 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
f04d5140 320static const unsigned int buzz_keymap[] = {
ad142b9e
FP		 321 /*
322 * The controller has 4 remote buzzers, each with one LED and 5
f04d5140 323 * buttons.
09593e38 324 *
f04d5140
CL		 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 */
09593e38
AO		 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,
f04d5140
CL		 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
b8f0970d 360/* The Navigation controller is a partial DS3 and uses the same HID report
454d243a 361 * and hence the same keymap indices, however not all axes/buttons
b8f0970d
RC		 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
e19a267b
RC		 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
d902f472
FP		 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
55d3b664 428struct sixaxis_led {
1adf904e
PM		 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%) */
55d3b664
FP		 434} __packed;
435
436struct sixaxis_rumble {
1adf904e
PM		 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 */
55d3b664
FP		 442} __packed;
443
444struct sixaxis_output_report {
1adf904e 445 u8 report_id;
55d3b664 446 struct sixaxis_rumble rumble;
1adf904e
PM		 447 u8 padding[4];
448 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
55d3b664
FP		 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;
1adf904e 455 u8 buf[36];
55d3b664
FP		 456};
457
c5e0c1c4
FP		 458struct motion_output_report_02 {
459 u8 type, zero;
460 u8 r, g, b;
461 u8 zero2;
462 u8 rumble;
463};
464
29b691a8 465#define SIXAXIS_REPORT_0xF2_SIZE 17
a85d67b5 466#define SIXAXIS_REPORT_0xF5_SIZE 8
41d2d425 467#define MOTION_REPORT_0x02_SIZE 49
9b2b5c9a 468
510c8b7c 469#define SENSOR_SUFFIX " Motion Sensors"
4f1f3918 470#define TOUCHPAD_SUFFIX " Touchpad"
55a07d62 471
510c8b7c
RC		 472#define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
473#define SIXAXIS_ACC_RES_PER_G 113
474
8b402c92 475static DEFINE_SPINLOCK(sony_dev_list_lock);
d2d782fc 476static LIST_HEAD(sony_device_list);
8025087a 477static DEFINE_IDA(sony_device_id_allocator);
d2d782fc 478
b5322736 479enum sony_worker {
4f1f3918 480 SONY_WORKER_STATE
b5322736
RC		 481};
482
cc6e0bbb 483struct sony_sc {
d902f472 484 spinlock_t lock;
d2d782fc 485 struct list_head list_node;
0a286ef2 486 struct hid_device *hdev;
ac797b95 487 struct input_dev *touchpad;
227c011b 488 struct input_dev *sensor_dev;
60781cf4 489 struct led_classdev *leds[MAX_LEDS];
cc6e0bbb 490 unsigned long quirks;
0a286ef2 491 struct work_struct state_worker;
09593e38 492 void (*send_output_report)(struct sony_sc *);
297d716f
KK		 493 struct power_supply *battery;
494 struct power_supply_desc battery_desc;
8025087a 495 int device_id;
1adf904e 496 u8 *output_report_dmabuf;
f04d5140 497
9f323b68 498#ifdef CONFIG_SONY_FF
1adf904e
PM		 499 u8 left;
500 u8 right;
9f323b68
SE		 501#endif
502
1adf904e 503 u8 mac_address[6];
b5322736 504 u8 state_worker_initialized;
2a242932 505 u8 defer_initialization;
1adf904e 506 u8 battery_capacity;
a76a6c18 507 int battery_status;
1adf904e 508 u8 led_state[MAX_LEDS];
1adf904e
PM		 509 u8 led_delay_on[MAX_LEDS];
510 u8 led_delay_off[MAX_LEDS];
511 u8 led_count;
80786eb9 512
cc894ac5 513 /* GH Live */
fb1a79a6 514 struct urb *ghl_urb;
cc894ac5 515 struct timer_list ghl_poke_timer;
cc6e0bbb
JK		 516};
517
405182c2
RC		 518static void sony_set_leds(struct sony_sc *sc);
519
b5322736
RC		 520static inline void sony_schedule_work(struct sony_sc *sc,
521 enum sony_worker which)
2a242932 522{
e0f6974a
RC		 523 unsigned long flags;
524
b5322736
RC		 525 switch (which) {
526 case SONY_WORKER_STATE:
e0f6974a
RC		 527 spin_lock_irqsave(&sc->lock, flags);
528 if (!sc->defer_initialization && sc->state_worker_initialized)
b5322736 529 schedule_work(&sc->state_worker);
e0f6974a 530 spin_unlock_irqrestore(&sc->lock, flags);
f2f47c38 531 break;
b5322736 532 }
2a242932
FP		 533}
534
cc894ac5
PG		 535static void ghl_magic_poke_cb(struct urb *urb)
536{
fb1a79a6
PG		 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);
cc894ac5
PG		 543}
544
545static void ghl_magic_poke(struct timer_list *t)
546{
fb1a79a6 547 int ret;
cc894ac5
PG		 548 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
549
fb1a79a6
PG		 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
a4bfe13f
DN		 555static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev,
556 const char ghl_magic_data[], u16 poke_size)
fb1a79a6
PG		 557{
558 struct usb_ctrlrequest *cr;
fb1a79a6 559 u8 *databuf;
cc894ac5 560 unsigned int pipe;
a4bfe13f 561 u16 ghl_magic_value = (((HID_OUTPUT_REPORT + 1) << 8) | ghl_magic_data[0]);
cc894ac5
PG		 562
563 pipe = usb_sndctrlpipe(usbdev, 0);
564
fb1a79a6
PG		 565 cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
566 if (cr == NULL)
567 return -ENOMEM;
cc894ac5 568
fb1a79a6
PG		 569 databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
570 if (databuf == NULL)
571 return -ENOMEM;
cc894ac5 572
fb1a79a6 573 cr->bRequestType =
cc894ac5 574 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
fb1a79a6 575 cr->bRequest = USB_REQ_SET_CONFIGURATION;
a4bfe13f 576 cr->wValue = cpu_to_le16(ghl_magic_value);
fb1a79a6
PG		 577 cr->wIndex = 0;
578 cr->wLength = cpu_to_le16(poke_size);
a4bfe13f 579 memcpy(databuf, ghl_magic_data, poke_size);
cc894ac5 580 usb_fill_control_urb(
fb1a79a6
PG		 581 sc->ghl_urb, usbdev, pipe,
582 (unsigned char *) cr, databuf, poke_size,
583 ghl_magic_poke_cb, sc);
584 return 0;
cc894ac5
PG		 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
32e411d0 594 if (abs == GUITAR_TILT_USAGE) {
cc894ac5
PG		 595 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
596 return 1;
597 }
598 }
599 return 0;
600}
601
c5e0c1c4 602static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
b2723eb7
SW		 603 unsigned int *rsize)
604{
c5e0c1c4
FP		 605 *rsize = sizeof(motion_rdesc);
606 return motion_rdesc;
b2723eb7
SW		 607}
608
1adf904e 609static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
078328da
JK		 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
b8f0970d
RC		 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
e19a267b
RC		 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
1adf904e 746static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
73e4008d 747 unsigned int *rsize)
cc6e0bbb
JK		 748{
749 struct sony_sc *sc = hid_get_drvdata(hdev);
750
4ba1eeeb 751 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
74500cc8
SM		 752 return rdesc;
753
99d24902
FLVC		 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) {
a4649184 765 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 766 /* input: data, variable, relative */
cc6e0bbb
JK		 767 rdesc[55] = 0x06;
768 }
61ab44be 769
c5e0c1c4
FP		 770 if (sc->quirks & MOTION_CONTROLLER)
771 return motion_fixup(hdev, rdesc, rsize);
772
078328da
JK		 773 if (sc->quirks & PS3REMOTE)
774 return ps3remote_fixup(hdev, rdesc, rsize);
775
e72455b8
SS		 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
73e4008d 793 return rdesc;
cc6e0bbb
JK		 794}
795
1adf904e 796static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
d902f472 797{
1adf904e 798 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
d902f472 799 unsigned long flags;
12e9a6d7 800 int offset;
a76a6c18
RC		 801 u8 battery_capacity;
802 int battery_status;
d902f472 803
ad142b9e
FP		 804 /*
805 * The sixaxis is charging if the battery value is 0xee
d902f472
FP		 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 */
12e9a6d7
SW		 810 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
811
812 if (rd[offset] >= 0xee) {
d902f472 813 battery_capacity = 100;
a76a6c18 814 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
d902f472 815 } else {
1adf904e 816 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
ac3c9a94 817 battery_capacity = sixaxis_battery_capacity[index];
a76a6c18 818 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
d902f472 819 }
d902f472
FP		 820
821 spin_lock_irqsave(&sc->lock, flags);
d902f472 822 sc->battery_capacity = battery_capacity;
a76a6c18 823 sc->battery_status = battery_status;
d902f472 824 spin_unlock_irqrestore(&sc->lock, flags);
510c8b7c
RC		 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 }
d902f472
FP		 842}
843
b7289cb1
TK		 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
c9e4d877 918static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1adf904e 919 u8 *rd, int size)
c9e4d877
SW		 920{
921 struct sony_sc *sc = hid_get_drvdata(hdev);
922
ad142b9e
FP		 923 /*
924 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
c9e4d877
SW		 925 * has to be BYTE_SWAPPED before passing up to joystick interface
926 */
fee4e2d5 927 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
8f5f0bc2
FP		 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
c9e4d877
SW		 939 swap(rd[41], rd[42]);
940 swap(rd[43], rd[44]);
941 swap(rd[45], rd[46]);
942 swap(rd[47], rd[48]);
d902f472 943
12e9a6d7
SW		 944 sixaxis_parse_report(sc, rd, size);
945 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
d902f472 946 sixaxis_parse_report(sc, rd, size);
4545ee0a
SW		 947 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
948 size == 49) {
949 sixaxis_parse_report(sc, rd, size);
b7289cb1
TK		 950 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
951 nsg_mrxu_parse_report(sc, rd, size);
952 return 1;
c9e4d877
SW		 953 }
954
2a242932
FP		 955 if (sc->defer_initialization) {
956 sc->defer_initialization = 0;
b5322736 957 sony_schedule_work(sc, SONY_WORKER_STATE);
2a242932
FP		 958 }
959
c9e4d877
SW		 960 return 0;
961}
962
f04d5140
CL		 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
078328da
JK		 992 if (sc->quirks & PS3REMOTE)
993 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
994
b8f0970d
RC		 995 if (sc->quirks & NAVIGATION_CONTROLLER)
996 return navigation_mapping(hdev, hi, field, usage, bit, max);
997
e19a267b
RC		 998 if (sc->quirks & SIXAXIS_CONTROLLER)
999 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
9131f8cc 1000
32e411d0 1001 if (sc->quirks & GH_GUITAR_CONTROLLER)
cc894ac5 1002 return guitar_mapping(hdev, hi, field, usage, bit, max);
e19a267b 1003
6f498018
BT		 1004 /* Let hid-core decide for the others */
1005 return 0;
f04d5140
CL		 1006}
1007
ac797b95 1008static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
b7289cb1 1009 int w, int h, int touch_major, int touch_minor, int orientation)
ce8efc3b 1010{
ac797b95
RC		 1011 size_t name_sz;
1012 char *name;
ce8efc3b
FP		 1013 int ret;
1014
cc070a84 1015 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
ac797b95
RC		 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
4f1f3918
RC		 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.
ac797b95 1033 */
4f1f3918 1034 name_sz = strlen(sc->hdev->name) + sizeof(TOUCHPAD_SUFFIX);
cc070a84
HZ		 1035 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1036 if (!name)
1037 return -ENOMEM;
4f1f3918 1038 snprintf(name, name_sz, "%s" TOUCHPAD_SUFFIX, sc->hdev->name);
ac797b95
RC		 1039 sc->touchpad->name = name;
1040
ac797b95
RC		 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);
ce8efc3b 1045
ac797b95
RC		 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
b7289cb1
TK		 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)
cc070a84 1066 return ret;
b7289cb1 1067
ac797b95
RC		 1068 ret = input_register_device(sc->touchpad);
1069 if (ret < 0)
cc070a84 1070 return ret;
ce8efc3b
FP		 1071
1072 return 0;
ac797b95 1073}
ce8efc3b 1074
227c011b
RC		 1075static int sony_register_sensors(struct sony_sc *sc)
1076{
1077 size_t name_sz;
1078 char *name;
1079 int ret;
1080
ea4a5fdc 1081 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
227c011b
RC		 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 */
510c8b7c 1097 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
ea4a5fdc
HZ		 1098 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1099 if (!name)
1100 return -ENOMEM;
510c8b7c 1101 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
227c011b
RC		 1102 sc->sensor_dev->name = name;
1103
510c8b7c
RC		 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);
510c8b7c
RC		 1117 }
1118
227c011b
RC		 1119 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1120
1121 ret = input_register_device(sc->sensor_dev);
1122 if (ret < 0)
ea4a5fdc 1123 return ret;
227c011b
RC		 1124
1125 return 0;
227c011b
RC		 1126}
1127
bd28ce00
JS		 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 */
816651a7 1133static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 1134{
69481059 1135 struct sony_sc *sc = hid_get_drvdata(hdev);
a85d67b5
AO		 1136 const int buf_size =
1137 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1adf904e 1138 u8 *buf;
bd28ce00 1139 int ret;
bd28ce00 1140
2e701a35 1141 buf = kmalloc(buf_size, GFP_KERNEL);
bd28ce00
JS		 1142 if (!buf)
1143 return -ENOMEM;
1144
a85d67b5
AO		 1145 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1146 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1147 if (ret < 0) {
1148 hid_err(hdev, "can't set operational mode: step 1\n");
1149 goto out;
1150 }
f204828a 1151
a7de9b86
LK		 1152 /*
1153 * Some compatible controllers like the Speedlink Strike FX and
1154 * Gasia need another query plus an USB interrupt to get operational.
1155 */
a85d67b5
AO		 1156 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1157 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1158 if (ret < 0) {
1159 hid_err(hdev, "can't set operational mode: step 2\n");
1160 goto out;
1161 }
f204828a 1162
492ca83c
BN		 1163 /*
1164 * But the USB interrupt would cause SHANWAN controllers to
69481059 1165 * start rumbling non-stop, so skip step 3 for these controllers.
492ca83c 1166 */
69481059
HY		 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;
19f4c2ba 1174 }
bd28ce00 1175
a7de9b86 1176out:
bd28ce00
JS		 1177 kfree(buf);
1178
1179 return ret;
1180}
1181
816651a7 1182static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 1183{
1adf904e
PM		 1184 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1185 u8 *buf;
9b2b5c9a
FP		 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),
b0dd72aa 1193 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
9b2b5c9a
FP		 1194
1195 kfree(buf);
1196
1197 return ret;
f9ce7c28
BN		 1198}
1199
221399b3 1200static void sixaxis_set_leds_from_id(struct sony_sc *sc)
8025087a 1201{
1adf904e 1202 static const u8 sixaxis_leds[10][4] = {
8025087a
FP		 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
221399b3
FP		 1215 int id = sc->device_id;
1216
1217 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
8025087a
FP		 1218
1219 if (id < 0)
1220 return;
1221
1222 id %= 10;
221399b3 1223 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
8025087a
FP		 1224}
1225
221399b3 1226static void buzz_set_leds(struct sony_sc *sc)
f04d5140 1227{
221399b3 1228 struct hid_device *hdev = sc->hdev;
f04d5140
CL		 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);
1adf904e 1233 s32 *value = report->field[0]->value;
f04d5140 1234
221399b3
FP		 1235 BUILD_BUG_ON(MAX_LEDS < 4);
1236
f04d5140 1237 value[0] = 0x00;
221399b3
FP		 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;
f04d5140
CL		 1242 value[5] = 0x00;
1243 value[6] = 0x00;
1244 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1245}
1246
221399b3 1247static void sony_set_leds(struct sony_sc *sc)
0a286ef2 1248{
221399b3 1249 if (!(sc->quirks & BUZZ_CONTROLLER))
b5322736 1250 sony_schedule_work(sc, SONY_WORKER_STATE);
221399b3
FP		 1251 else
1252 buzz_set_leds(sc);
0a286ef2
SE		 1253}
1254
c5382519 1255static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 1256 enum led_brightness value)
1257{
1258 struct device *dev = led->dev->parent;
ee79a8f8 1259 struct hid_device *hdev = to_hid_device(dev);
f04d5140 1260 struct sony_sc *drv_data;
f04d5140
CL		 1261
1262 int n;
b3ed458c 1263 int force_update;
f04d5140
CL		 1264
1265 drv_data = hid_get_drvdata(hdev);
2251b85f 1266 if (!drv_data) {
f04d5140
CL		 1267 hid_err(hdev, "No device data\n");
1268 return;
1269 }
f04d5140 1270
b3ed458c
FP		 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
60781cf4 1280 for (n = 0; n < drv_data->led_count; n++) {
b3ed458c
FP		 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
221399b3 1292 sony_set_leds(drv_data);
f04d5140
CL		 1293 break;
1294 }
1295 }
1296}
1297
c5382519 1298static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 1299{
1300 struct device *dev = led->dev->parent;
ee79a8f8 1301 struct hid_device *hdev = to_hid_device(dev);
f04d5140 1302 struct sony_sc *drv_data;
f04d5140
CL		 1303
1304 int n;
f04d5140
CL		 1305
1306 drv_data = hid_get_drvdata(hdev);
2251b85f 1307 if (!drv_data) {
f04d5140
CL		 1308 hid_err(hdev, "No device data\n");
1309 return LED_OFF;
1310 }
f04d5140 1311
60781cf4 1312 for (n = 0; n < drv_data->led_count; n++) {
7db7504a
SW		 1313 if (led == drv_data->leds[n])
1314 return drv_data->led_state[n];
f04d5140
CL		 1315 }
1316
7db7504a 1317 return LED_OFF;
f04d5140 1318}
f04d5140 1319
b3ed458c
FP		 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;
ee79a8f8 1324 struct hid_device *hdev = to_hid_device(dev);
b3ed458c
FP		 1325 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1326 int n;
1adf904e 1327 u8 new_on, new_off;
b3ed458c
FP		 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;
b5322736 1361 sony_schedule_work(drv_data, SONY_WORKER_STATE);
b3ed458c
FP		 1362 }
1363
1364 return 0;
1365}
1366
fa57a810 1367static int sony_leds_init(struct sony_sc *sc)
f04d5140 1368{
fa57a810 1369 struct hid_device *hdev = sc->hdev;
40e32ee6 1370 int n, ret = 0;
4f1f3918 1371 int use_color_names;
40e32ee6
JK		 1372 struct led_classdev *led;
1373 size_t name_sz;
1374 char *name;
0a286ef2
SE		 1375 size_t name_len;
1376 const char *name_fmt;
4f1f3918 1377 static const char * const color_name_str[] = { "red", "green", "blue",
b3ed458c 1378 "global" };
1adf904e
PM		 1379 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1380 u8 use_hw_blink[MAX_LEDS] = { 0 };
f04d5140 1381
fa57a810 1382 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1383
fa57a810
FP		 1384 if (sc->quirks & BUZZ_CONTROLLER) {
1385 sc->led_count = 4;
4f1f3918 1386 use_color_names = 0;
0a286ef2
SE		 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;
c5e0c1c4
FP		 1392 } else if (sc->quirks & MOTION_CONTROLLER) {
1393 sc->led_count = 3;
1394 memset(max_brightness, 255, 3);
4f1f3918 1395 use_color_names = 1;
c5e0c1c4
FP		 1396 name_len = 0;
1397 name_fmt = "%s:%s";
4545ee0a 1398 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1adf904e 1399 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
4545ee0a
SW		 1400
1401 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1402 sc->led_count = 1;
1403 memset(use_hw_blink, 1, 4);
4f1f3918 1404 use_color_names = 0;
4545ee0a
SW		 1405 name_len = strlen("::sony#");
1406 name_fmt = "%s::sony%d";
60781cf4 1407 } else {
221399b3 1408 sixaxis_set_leds_from_id(sc);
fa57a810 1409 sc->led_count = 4;
b3ed458c 1410 memset(use_hw_blink, 1, 4);
4f1f3918 1411 use_color_names = 0;
61ebca93
FP		 1412 name_len = strlen("::sony#");
1413 name_fmt = "%s::sony%d";
60781cf4
FP		 1414 }
1415
ad142b9e
FP		 1416 /*
1417 * Clear LEDs as we have no way of reading their initial state. This is
f04d5140 1418 * only relevant if the driver is loaded after somebody actively set the
ad142b9e
FP		 1419 * LEDs to on
1420 */
221399b3 1421 sony_set_leds(sc);
f04d5140 1422
0a286ef2 1423 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 1424
fa57a810 1425 for (n = 0; n < sc->led_count; n++) {
61ebca93 1426
4f1f3918
RC		 1427 if (use_color_names)
1428 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_name_str[n]) + 2;
61ebca93 1429
f2d98e2c 1430 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
40e32ee6
JK		 1431 if (!led) {
1432 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
f2d98e2c 1433 return -ENOMEM;
40e32ee6 1434 }
f04d5140 1435
40e32ee6 1436 name = (void *)(&led[1]);
4f1f3918 1437 if (use_color_names)
b3ed458c 1438 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
4f1f3918 1439 color_name_str[n]);
61ebca93
FP		 1440 else
1441 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6 1442 led->name = name;
221399b3 1443 led->brightness = sc->led_state[n];
b3ed458c 1444 led->max_brightness = max_brightness[n];
765a1077 1445 led->flags = LED_CORE_SUSPENDRESUME;
c5382519
SE		 1446 led->brightness_get = sony_led_get_brightness;
1447 led->brightness_set = sony_led_set_brightness;
f04d5140 1448
b3ed458c
FP		 1449 if (use_hw_blink[n])
1450 led->blink_set = sony_led_blink_set;
1451
8025087a
FP		 1452 sc->leds[n] = led;
1453
f2d98e2c 1454 ret = devm_led_classdev_register(&hdev->dev, led);
8cd5fcda 1455 if (ret) {
40e32ee6 1456 hid_err(hdev, "Failed to register LED %d\n", n);
f2d98e2c 1457 return ret;
f04d5140
CL		 1458 }
1459 }
f04d5140 1460
f2d98e2c 1461 return 0;
f04d5140
CL		 1462}
1463
d8aaccda 1464static void sixaxis_send_output_report(struct sony_sc *sc)
a08c22c0 1465{
9b2b5c9a 1466 static const union sixaxis_output_report_01 default_report = {
55d3b664
FP		 1467 .buf = {
1468 0x01,
ad07b7a6 1469 0x01, 0xff, 0x00, 0xff, 0x00,
55d3b664
FP		 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 }
a08c22c0 1477 };
9b2b5c9a
FP		 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));
9f323b68 1484
0a286ef2 1485#ifdef CONFIG_SONY_FF
9b2b5c9a
FP		 1486 report->rumble.right_motor_on = sc->right ? 1 : 0;
1487 report->rumble.left_motor_force = sc->left;
0a286ef2
SE		 1488#endif
1489
9b2b5c9a
FP		 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;
9f323b68 1494
88f6576f 1495 /* Set flag for all leds off, required for 3rd party INTEC controller */
9b2b5c9a
FP		 1496 if ((report->leds_bitmap & 0x1E) == 0)
1497 report->leds_bitmap |= 0x20;
88f6576f 1498
b3ed458c
FP		 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]) {
9b2b5c9a
FP		 1510 report->led[3 - n].duty_off = sc->led_delay_off[n];
1511 report->led[3 - n].duty_on = sc->led_delay_on[n];
b3ed458c
FP		 1512 }
1513 }
1514
d03213f1
HY		 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);
9f323b68
SE		 1523}
1524
d8aaccda 1525static void motion_send_output_report(struct sony_sc *sc)
c5e0c1c4 1526{
c5e0c1c4
FP		 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
41d2d425 1531 memset(report, 0, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 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
1adf904e 1542 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 1543}
1544
54f27dc5 1545#ifdef CONFIG_SONY_FF
decd946c
FP		 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}
54f27dc5 1551#endif
decd946c 1552
d8aaccda
FP		 1553static void sony_state_worker(struct work_struct *work)
1554{
1555 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
ef916ef5 1556
d8aaccda
FP		 1557 sc->send_output_report(sc);
1558}
1559
9b2b5c9a
FP		 1560static int sony_allocate_output_report(struct sony_sc *sc)
1561{
4545ee0a
SW		 1562 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1563 (sc->quirks & NAVIGATION_CONTROLLER))
9b2b5c9a 1564 sc->output_report_dmabuf =
ea58c33d
HZ		 1565 devm_kmalloc(&sc->hdev->dev,
1566 sizeof(union sixaxis_output_report_01),
9b2b5c9a 1567 GFP_KERNEL);
c5e0c1c4 1568 else if (sc->quirks & MOTION_CONTROLLER)
ea58c33d
HZ		 1569 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
1570 MOTION_REPORT_0x02_SIZE,
41d2d425 1571 GFP_KERNEL);
9b2b5c9a
FP		 1572 else
1573 return 0;
1574
1575 if (!sc->output_report_dmabuf)
1576 return -ENOMEM;
1577
1578 return 0;
1579}
1580
0a286ef2 1581#ifdef CONFIG_SONY_FF
9f323b68
SE		 1582static int sony_play_effect(struct input_dev *dev, void *data,
1583 struct ff_effect *effect)
1584{
a08c22c0 1585 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 1586 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 1587
1588 if (effect->type != FF_RUMBLE)
1589 return 0;
1590
9f323b68 1591 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 1592 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 1593
b5322736 1594 sony_schedule_work(sc, SONY_WORKER_STATE);
9f323b68 1595 return 0;
a08c22c0
SE		 1596}
1597
fa57a810 1598static int sony_init_ff(struct sony_sc *sc)
a08c22c0 1599{
d9d4b1e4
AS		 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;
a08c22c0
SE		 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
fa57a810 1615static int sony_init_ff(struct sony_sc *sc)
a08c22c0
SE		 1616{
1617 return 0;
1618}
9f323b68 1619
a08c22c0
SE		 1620#endif
1621
d902f472
FP		 1622static int sony_battery_get_property(struct power_supply *psy,
1623 enum power_supply_property psp,
1624 union power_supply_propval *val)
1625{
297d716f 1626 struct sony_sc *sc = power_supply_get_drvdata(psy);
d902f472
FP		 1627 unsigned long flags;
1628 int ret = 0;
a76a6c18
RC		 1629 u8 battery_capacity;
1630 int battery_status;
d902f472
FP		 1631
1632 spin_lock_irqsave(&sc->lock, flags);
d902f472 1633 battery_capacity = sc->battery_capacity;
a76a6c18 1634 battery_status = sc->battery_status;
d902f472
FP		 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:
a76a6c18 1648 val->intval = battery_status;
d902f472
FP		 1649 break;
1650 default:
1651 ret = -EINVAL;
1652 break;
1653 }
1654 return ret;
9f323b68
SE		 1655}
1656
0f398230 1657static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
c4e1ddf2 1658{
0f398230
FP		 1659 const char *battery_str_fmt = append_dev_id ?
1660 "sony_controller_battery_%pMR_%i" :
1661 "sony_controller_battery_%pMR";
297d716f 1662 struct power_supply_config psy_cfg = { .drv_data = sc, };
c4e1ddf2 1663 struct hid_device *hdev = sc->hdev;
d902f472 1664 int ret;
c4e1ddf2 1665
ad142b9e
FP		 1666 /*
1667 * Set the default battery level to 100% to avoid low battery warnings
d9a293a9
FP		 1668 * if the battery is polled before the first device report is received.
1669 */
1670 sc->battery_capacity = 100;
1671
297d716f
KK		 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;
8082d3f0
HZ		 1677 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
1678 battery_str_fmt, sc->mac_address, sc->device_id);
297d716f 1679 if (!sc->battery_desc.name)
d902f472 1680 return -ENOMEM;
c4e1ddf2 1681
8082d3f0 1682 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
297d716f
KK		 1683 &psy_cfg);
1684 if (IS_ERR(sc->battery)) {
1685 ret = PTR_ERR(sc->battery);
d902f472 1686 hid_err(hdev, "Unable to register battery device\n");
8082d3f0 1687 return ret;
d902f472 1688 }
c4e1ddf2 1689
297d716f 1690 power_supply_powers(sc->battery, &hdev->dev);
a08c22c0 1691 return 0;
9f323b68 1692}
a08c22c0 1693
d2d782fc
FP		 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.
0f398230
FP		 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.
d2d782fc 1704 */
0f398230
FP		 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
d2d782fc
FP		 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) {
0f398230
FP		 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",
d2d782fc 1732 sc->mac_address);
0f398230 1733 }
d2d782fc 1734 goto unlock;
c4e1ddf2
FP		 1735 }
1736 }
1737
d2d782fc
FP		 1738 ret = 0;
1739 list_add(&(sc->list_node), &sony_device_list);
c4e1ddf2 1740
d2d782fc
FP		 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;
c4e1ddf2 1749
d2d782fc
FP		 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 }
c4e1ddf2
FP		 1755}
1756
d2d782fc
FP		 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{
1adf904e 1779 u8 *buf = NULL;
d2d782fc
FP		 1780 int n, ret;
1781
4f1f3918 1782 if ((sc->quirks & MOTION_CONTROLLER_BT) ||
4545ee0a 1783 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
d2d782fc
FP		 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 }
4545ee0a
SW		 1795 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
1796 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
9b2b5c9a
FP		 1797 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1798 if (!buf)
1799 return -ENOMEM;
d2d782fc
FP		 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 */
9b2b5c9a
FP		 1806 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1807 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1808 HID_REQ_GET_REPORT);
d2d782fc 1809
9b2b5c9a 1810 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
d2d782fc 1811 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
9b2b5c9a
FP		 1812 ret = ret < 0 ? ret : -EINVAL;
1813 goto out_free;
d2d782fc
FP		 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];
5a144be3
RC		 1822
1823 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
648d4932 1824 "%pMR", sc->mac_address);
d2d782fc
FP		 1825 } else {
1826 return 0;
1827 }
1828
9b2b5c9a
FP		 1829 ret = sony_check_add_dev_list(sc);
1830
1831out_free:
1832
1833 kfree(buf);
1834
1835 return ret;
d2d782fc
FP		 1836}
1837
8025087a
FP		 1838static int sony_set_device_id(struct sony_sc *sc)
1839{
1840 int ret;
1841
1842 /*
4f1f3918 1843 * Only Sixaxis controllers get an id.
8025087a
FP		 1844 * All others are set to -1.
1845 */
4f1f3918 1846 if (sc->quirks & SIXAXIS_CONTROLLER) {
8025087a
FP		 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
d8aaccda 1869static inline void sony_init_output_report(struct sony_sc *sc,
09593e38 1870 void (*send_output_report)(struct sony_sc *))
46262047 1871{
d8aaccda
FP		 1872 sc->send_output_report = send_output_report;
1873
b5322736 1874 if (!sc->state_worker_initialized)
d8aaccda 1875 INIT_WORK(&sc->state_worker, sony_state_worker);
46262047 1876
b5322736 1877 sc->state_worker_initialized = 1;
46262047
FP		 1878}
1879
1880static inline void sony_cancel_work_sync(struct sony_sc *sc)
1881{
e0f6974a
RC		 1882 unsigned long flags;
1883
e0f6974a
RC		 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);
46262047 1888 cancel_work_sync(&sc->state_worker);
e0f6974a 1889 }
46262047 1890}
d2d782fc 1891
e1bc84d0
RC		 1892static int sony_input_configured(struct hid_device *hdev,
1893 struct hid_input *hidinput)
bd28ce00 1894{
e1bc84d0 1895 struct sony_sc *sc = hid_get_drvdata(hdev);
0f398230 1896 int append_dev_id;
e1bc84d0 1897 int ret;
bd28ce00 1898
131a8a9a 1899 ret = sony_set_device_id(sc);
9b2b5c9a 1900 if (ret < 0) {
131a8a9a 1901 hid_err(hdev, "failed to allocate the device id\n");
9b2b5c9a
FP		 1902 goto err_stop;
1903 }
1904
df848bc0
RC		 1905 ret = append_dev_id = sony_check_add(sc);
1906 if (ret < 0)
1907 goto err_stop;
1908
131a8a9a 1909 ret = sony_allocate_output_report(sc);
8025087a 1910 if (ret < 0) {
131a8a9a 1911 hid_err(hdev, "failed to allocate the output report buffer\n");
8025087a
FP		 1912 goto err_stop;
1913 }
1914
510c8b7c 1915 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
e534a935
BT		 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!
2a242932
FP		 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.
e534a935
BT		 1931 */
1932 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1933 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2a242932 1934 sc->defer_initialization = 1;
80ecc48c 1935
816651a7 1936 ret = sixaxis_set_operational_usb(hdev);
80ecc48c
RC		 1937 if (ret < 0) {
1938 hid_err(hdev, "Failed to set controller into operational mode\n");
1939 goto err_stop;
1940 }
1941
d8aaccda 1942 sony_init_output_report(sc, sixaxis_send_output_report);
510c8b7c
RC		 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
d8aaccda 1956 sony_init_output_report(sc, sixaxis_send_output_report);
510c8b7c
RC		 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) {
2078b9bb
FP		 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;
80ecc48c 1988
816651a7 1989 ret = sixaxis_set_operational_bt(hdev);
80ecc48c
RC		 1990 if (ret < 0) {
1991 hid_err(hdev, "Failed to set controller into operational mode\n");
1992 goto err_stop;
1993 }
1994
510c8b7c
RC		 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
d8aaccda 2002 sony_init_output_report(sc, sixaxis_send_output_report);
b7289cb1
TK		 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
c5e0c1c4 2017 } else if (sc->quirks & MOTION_CONTROLLER) {
d8aaccda 2018 sony_init_output_report(sc, motion_send_output_report);
0bd88dd3
FP		 2019 } else {
2020 ret = 0;
2021 }
f9ce7c28 2022
0a286ef2 2023 if (sc->quirks & SONY_LED_SUPPORT) {
fa57a810 2024 ret = sony_leds_init(sc);
0a286ef2
SE		 2025 if (ret < 0)
2026 goto err_stop;
2027 }
2028
d902f472 2029 if (sc->quirks & SONY_BATTERY_SUPPORT) {
0f398230 2030 ret = sony_battery_probe(sc, append_dev_id);
d902f472
FP		 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
c8de9dbb 2042 if (sc->quirks & SONY_FF_SUPPORT) {
fa57a810 2043 ret = sony_init_ff(sc);
c8de9dbb
FP		 2044 if (ret < 0)
2045 goto err_close;
5f5750d2 2046 }
a08c22c0 2047
bd28ce00 2048 return 0;
d902f472
FP		 2049err_close:
2050 hid_hw_close(hdev);
bd28ce00 2051err_stop:
46262047 2052 sony_cancel_work_sync(sc);
d2d782fc 2053 sony_remove_dev_list(sc);
8025087a 2054 sony_release_device_id(sc);
bd28ce00
JS		 2055 return ret;
2056}
2057
e1bc84d0
RC		 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;
fb1a79a6 2063 struct usb_device *usbdev;
e1bc84d0
RC		 2064 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2065
2066 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2067 quirks |= FUTUREMAX_DANCE_MAT;
2068
bab94e97
US		 2069 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") ||
2070 !strcmp(hdev->name, "ShanWan PS(R) Ga`epad"))
69481059
HY		 2071 quirks |= SHANWAN_GAMEPAD;
2072
e1bc84d0
RC		 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
4f1f3918 2096 /* Patch the hw version on DS3 compatible devices, so applications can
9131f8cc
RC		 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 */
4f1f3918 2102 if (sc->quirks & SIXAXIS_CONTROLLER)
9131f8cc
RC		 2103 hdev->version |= 0x8000;
2104
e1bc84d0
RC		 2105 ret = hid_hw_start(hdev, connect_mask);
2106 if (ret) {
2107 hid_err(hdev, "hw start failed\n");
2108 return ret;
2109 }
2110
4f967f6d
RC		 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");
7998193b
BT		 2121 ret = -ENODEV;
2122 goto err;
4f967f6d
RC		 2123 }
2124
a4bfe13f 2125 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
7998193b
BT		 2126 if (!hid_is_usb(hdev)) {
2127 ret = -EINVAL;
2128 goto err;
2129 }
93020953
GKH		 2130
2131 usbdev = to_usb_device(sc->hdev->dev.parent->parent);
2132
fb1a79a6 2133 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
7998193b
BT		 2134 if (!sc->ghl_urb) {
2135 ret = -ENOMEM;
2136 goto err;
2137 }
a4bfe13f
DN		 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));
fb1a79a6
PG		 2145 if (ret) {
2146 hid_err(hdev, "error preparing URB\n");
7998193b 2147 goto err;
fb1a79a6
PG		 2148 }
2149
cc894ac5
PG		 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
e1bc84d0 2155 return ret;
7998193b
BT		 2156
2157err:
b328dd02 2158 usb_free_urb(sc->ghl_urb);
e1cd4004 2159
7998193b
BT		 2160 hid_hw_stop(hdev);
2161 return ret;
e1bc84d0
RC		 2162}
2163
cc6e0bbb
JK		 2164static void sony_remove(struct hid_device *hdev)
2165{
f04d5140
CL		 2166 struct sony_sc *sc = hid_get_drvdata(hdev);
2167
a4bfe13f 2168 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
cc894ac5 2169 del_timer_sync(&sc->ghl_poke_timer);
fb1a79a6
PG		 2170 usb_free_urb(sc->ghl_urb);
2171 }
cc894ac5 2172
ac797b95
RC		 2173 hid_hw_close(hdev);
2174
46262047 2175 sony_cancel_work_sync(sc);
9f323b68 2176
d2d782fc 2177 sony_remove_dev_list(sc);
9f323b68 2178
8025087a
FP		 2179 sony_release_device_id(sc);
2180
cc6e0bbb 2181 hid_hw_stop(hdev);
cc6e0bbb
JK		 2182}
2183
decd946c
FP		 2184#ifdef CONFIG_PM
2185
2186static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2187{
decd946c 2188#ifdef CONFIG_SONY_FF
decd946c 2189
765a1077
FP		 2190 /* On suspend stop any running force-feedback events */
2191 if (SONY_FF_SUPPORT) {
2192 struct sony_sc *sc = hid_get_drvdata(hdev);
decd946c 2193
765a1077 2194 sc->left = sc->right = 0;
decd946c
FP		 2195 sony_send_output_report(sc);
2196 }
2197
765a1077 2198#endif
decd946c
FP		 2199 return 0;
2200}
2201
2202static int sony_resume(struct hid_device *hdev)
2203{
765a1077 2204 struct sony_sc *sc = hid_get_drvdata(hdev);
decd946c 2205
765a1077
FP		 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;
decd946c
FP		 2214 }
2215
2216 return 0;
2217}
2218
2219#endif
2220
bd28ce00 2221static const struct hid_device_id sony_devices[] = {
816651a7
AO		 2222 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2223 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4 2224 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 2225 .driver_data = NAVIGATION_CONTROLLER_USB },
6eabaaa0 2226 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 2227 .driver_data = NAVIGATION_CONTROLLER_BT },
c5e0c1c4 2228 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 2229 .driver_data = MOTION_CONTROLLER_USB },
a4afa854 2230 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 2231 .driver_data = MOTION_CONTROLLER_BT },
816651a7
AO		 2232 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2233 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 2234 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2235 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 2236 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2237 .driver_data = VAIO_RDESC_CONSTANT },
ef916ef5
AO		 2238 /*
2239 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2240 * Logitech joystick from the device descriptor.
2241 */
f04d5140
CL		 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 },
078328da
JK		 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 },
68a49e51
FP		 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 },
74500cc8
SM		 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 },
b7289cb1
TK		 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 },
cc894ac5 2264 /* Guitar Hero Live PS3 and Wii U guitar dongles */
32e411d0
SG		 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 */
a4bfe13f 2268 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_GUITAR_DONGLE),
32e411d0
SG		 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 },
a4bfe13f
DN		 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 },
bd28ce00
JS		 2276 { }
2277};
2278MODULE_DEVICE_TABLE(hid, sony_devices);
2279
2280static struct hid_driver sony_driver = {
ce8efc3b
FP		 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,
decd946c
FP		 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
bd28ce00 2295};
8025087a
FP		 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
8025087a 2308 hid_unregister_driver(&sony_driver);
6c40065f 2309 ida_destroy(&sony_device_id_allocator);
8025087a
FP		 2310}
2311module_init(sony_init);
2312module_exit(sony_exit);
bd28ce00 2313
bd28ce00 2314MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)