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 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");
1/*
2 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
3 *
4 * Copyright (c) 1999 Andreas Gal
5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7 * Copyright (c) 2008 Jiri Slaby
8 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
11 * Copyright (c) 2014 Frank Praznik <frank.praznik@gmail.com>
12 */
13
14/*
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the Free
17 * Software Foundation; either version 2 of the License, or (at your option)
18 * any later version.
19 */
20
21/*
22 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
23 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
24 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
25 *
26 * There will be no PIN request from the device.
27 */
28
29#include <linux/device.h>
30#include <linux/hid.h>
31#include <linux/module.h>
32#include <linux/slab.h>
33#include <linux/leds.h>
34#include <linux/power_supply.h>
35#include <linux/spinlock.h>
36#include <linux/list.h>
37#include <linux/idr.h>
38#include <linux/input/mt.h>
39
40#include "hid-ids.h"
41
42#define VAIO_RDESC_CONSTANT BIT(0)
43#define SIXAXIS_CONTROLLER_USB BIT(1)
44#define SIXAXIS_CONTROLLER_BT BIT(2)
45#define BUZZ_CONTROLLER BIT(3)
46#define PS3REMOTE BIT(4)
47#define DUALSHOCK4_CONTROLLER_USB BIT(5)
48#define DUALSHOCK4_CONTROLLER_BT BIT(6)
49#define MOTION_CONTROLLER_USB BIT(7)
50#define MOTION_CONTROLLER_BT BIT(8)
51#define NAVIGATION_CONTROLLER_USB BIT(9)
52#define NAVIGATION_CONTROLLER_BT BIT(10)
53#define SINO_LITE_CONTROLLER BIT(11)
54
55#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
56#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
57#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
58 NAVIGATION_CONTROLLER_BT)
59#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
60 DUALSHOCK4_CONTROLLER_BT)
61#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
62 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
63 NAVIGATION_CONTROLLER)
64#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
65 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
66#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
67 MOTION_CONTROLLER)
68
69#define MAX_LEDS 4
70
71/*
72 * The Sixaxis reports both digital and analog values for each button on the
73 * controller except for Start, Select and the PS button. The controller ends
74 * up reporting 27 axes which causes them to spill over into the multi-touch
75 * axis values. Additionally, the controller only has 20 actual, physical axes
76 * so there are several unused axes in between the used ones.
77 */
78static u8 sixaxis_rdesc[] = {
79 0x05, 0x01, /* Usage Page (Desktop), */
80 0x09, 0x04, /* Usage (Joystick), */
81 0xA1, 0x01, /* Collection (Application), */
82 0xA1, 0x02, /* Collection (Logical), */
83 0x85, 0x01, /* Report ID (1), */
84 0x75, 0x08, /* Report Size (8), */
85 0x95, 0x01, /* Report Count (1), */
86 0x15, 0x00, /* Logical Minimum (0), */
87 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
88 0x81, 0x03, /* Input (Constant, Variable), */
89 0x75, 0x01, /* Report Size (1), */
90 0x95, 0x13, /* Report Count (19), */
91 0x15, 0x00, /* Logical Minimum (0), */
92 0x25, 0x01, /* Logical Maximum (1), */
93 0x35, 0x00, /* Physical Minimum (0), */
94 0x45, 0x01, /* Physical Maximum (1), */
95 0x05, 0x09, /* Usage Page (Button), */
96 0x19, 0x01, /* Usage Minimum (01h), */
97 0x29, 0x13, /* Usage Maximum (13h), */
98 0x81, 0x02, /* Input (Variable), */
99 0x75, 0x01, /* Report Size (1), */
100 0x95, 0x0D, /* Report Count (13), */
101 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
102 0x81, 0x03, /* Input (Constant, Variable), */
103 0x15, 0x00, /* Logical Minimum (0), */
104 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
105 0x05, 0x01, /* Usage Page (Desktop), */
106 0x09, 0x01, /* Usage (Pointer), */
107 0xA1, 0x00, /* Collection (Physical), */
108 0x75, 0x08, /* Report Size (8), */
109 0x95, 0x04, /* Report Count (4), */
110 0x35, 0x00, /* Physical Minimum (0), */
111 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
112 0x09, 0x30, /* Usage (X), */
113 0x09, 0x31, /* Usage (Y), */
114 0x09, 0x32, /* Usage (Z), */
115 0x09, 0x35, /* Usage (Rz), */
116 0x81, 0x02, /* Input (Variable), */
117 0xC0, /* End Collection, */
118 0x05, 0x01, /* Usage Page (Desktop), */
119 0x95, 0x13, /* Report Count (19), */
120 0x09, 0x01, /* Usage (Pointer), */
121 0x81, 0x02, /* Input (Variable), */
122 0x95, 0x0C, /* Report Count (12), */
123 0x81, 0x01, /* Input (Constant), */
124 0x75, 0x10, /* Report Size (16), */
125 0x95, 0x04, /* Report Count (4), */
126 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */
127 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */
128 0x09, 0x01, /* Usage (Pointer), */
129 0x81, 0x02, /* Input (Variable), */
130 0xC0, /* End Collection, */
131 0xA1, 0x02, /* Collection (Logical), */
132 0x85, 0x02, /* Report ID (2), */
133 0x75, 0x08, /* Report Size (8), */
134 0x95, 0x30, /* Report Count (48), */
135 0x09, 0x01, /* Usage (Pointer), */
136 0xB1, 0x02, /* Feature (Variable), */
137 0xC0, /* End Collection, */
138 0xA1, 0x02, /* Collection (Logical), */
139 0x85, 0xEE, /* Report ID (238), */
140 0x75, 0x08, /* Report Size (8), */
141 0x95, 0x30, /* Report Count (48), */
142 0x09, 0x01, /* Usage (Pointer), */
143 0xB1, 0x02, /* Feature (Variable), */
144 0xC0, /* End Collection, */
145 0xA1, 0x02, /* Collection (Logical), */
146 0x85, 0xEF, /* Report ID (239), */
147 0x75, 0x08, /* Report Size (8), */
148 0x95, 0x30, /* Report Count (48), */
149 0x09, 0x01, /* Usage (Pointer), */
150 0xB1, 0x02, /* Feature (Variable), */
151 0xC0, /* End Collection, */
152 0xC0 /* End Collection */
153};
154
155/* PS/3 Motion controller */
156static u8 motion_rdesc[] = {
157 0x05, 0x01, /* Usage Page (Desktop), */
158 0x09, 0x04, /* Usage (Joystick), */
159 0xA1, 0x01, /* Collection (Application), */
160 0xA1, 0x02, /* Collection (Logical), */
161 0x85, 0x01, /* Report ID (1), */
162 0x75, 0x01, /* Report Size (1), */
163 0x95, 0x15, /* Report Count (21), */
164 0x15, 0x00, /* Logical Minimum (0), */
165 0x25, 0x01, /* Logical Maximum (1), */
166 0x35, 0x00, /* Physical Minimum (0), */
167 0x45, 0x01, /* Physical Maximum (1), */
168 0x05, 0x09, /* Usage Page (Button), */
169 0x19, 0x01, /* Usage Minimum (01h), */
170 0x29, 0x15, /* Usage Maximum (15h), */
171 0x81, 0x02, /* Input (Variable), * Buttons */
172 0x95, 0x0B, /* Report Count (11), */
173 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
174 0x81, 0x03, /* Input (Constant, Variable), * Padding */
175 0x15, 0x00, /* Logical Minimum (0), */
176 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
177 0x05, 0x01, /* Usage Page (Desktop), */
178 0xA1, 0x00, /* Collection (Physical), */
179 0x75, 0x08, /* Report Size (8), */
180 0x95, 0x01, /* Report Count (1), */
181 0x35, 0x00, /* Physical Minimum (0), */
182 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
183 0x09, 0x30, /* Usage (X), */
184 0x81, 0x02, /* Input (Variable), * Trigger */
185 0xC0, /* End Collection, */
186 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
187 0x75, 0x08, /* Report Size (8), */
188 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
189 0x81, 0x02, /* Input (Variable), */
190 0x05, 0x01, /* Usage Page (Desktop), */
191 0x75, 0x10, /* Report Size (16), */
192 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
193 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
194 0x95, 0x03, /* Report Count (3), * 3x Accels */
195 0x09, 0x33, /* Usage (rX), */
196 0x09, 0x34, /* Usage (rY), */
197 0x09, 0x35, /* Usage (rZ), */
198 0x81, 0x02, /* Input (Variable), */
199 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
200 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
201 0x81, 0x02, /* Input (Variable), */
202 0x05, 0x01, /* Usage Page (Desktop), */
203 0x09, 0x01, /* Usage (Pointer), */
204 0x95, 0x03, /* Report Count (3), * 3x Gyros */
205 0x81, 0x02, /* Input (Variable), */
206 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
207 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
208 0x81, 0x02, /* Input (Variable), */
209 0x75, 0x0C, /* Report Size (12), */
210 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
211 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
212 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
213 0x81, 0x02, /* Input (Variable), */
214 0x75, 0x08, /* Report Size (8), */
215 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
216 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
217 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
218 0x81, 0x02, /* Input (Variable), */
219 0x75, 0x08, /* Report Size (8), */
220 0x95, 0x30, /* Report Count (48), */
221 0x09, 0x01, /* Usage (Pointer), */
222 0x91, 0x02, /* Output (Variable), */
223 0x75, 0x08, /* Report Size (8), */
224 0x95, 0x30, /* Report Count (48), */
225 0x09, 0x01, /* Usage (Pointer), */
226 0xB1, 0x02, /* Feature (Variable), */
227 0xC0, /* End Collection, */
228 0xA1, 0x02, /* Collection (Logical), */
229 0x85, 0x02, /* Report ID (2), */
230 0x75, 0x08, /* Report Size (8), */
231 0x95, 0x30, /* Report Count (48), */
232 0x09, 0x01, /* Usage (Pointer), */
233 0xB1, 0x02, /* Feature (Variable), */
234 0xC0, /* End Collection, */
235 0xA1, 0x02, /* Collection (Logical), */
236 0x85, 0xEE, /* Report ID (238), */
237 0x75, 0x08, /* Report Size (8), */
238 0x95, 0x30, /* Report Count (48), */
239 0x09, 0x01, /* Usage (Pointer), */
240 0xB1, 0x02, /* Feature (Variable), */
241 0xC0, /* End Collection, */
242 0xA1, 0x02, /* Collection (Logical), */
243 0x85, 0xEF, /* Report ID (239), */
244 0x75, 0x08, /* Report Size (8), */
245 0x95, 0x30, /* Report Count (48), */
246 0x09, 0x01, /* Usage (Pointer), */
247 0xB1, 0x02, /* Feature (Variable), */
248 0xC0, /* End Collection, */
249 0xC0 /* End Collection */
250};
251
252/* PS/3 Navigation controller */
253static u8 navigation_rdesc[] = {
254 0x05, 0x01, /* Usage Page (Desktop), */
255 0x09, 0x04, /* Usage (Joystick), */
256 0xA1, 0x01, /* Collection (Application), */
257 0xA1, 0x02, /* Collection (Logical), */
258 0x85, 0x01, /* Report ID (1), */
259 0x75, 0x08, /* Report Size (8), */
260 0x95, 0x01, /* Report Count (1), */
261 0x15, 0x00, /* Logical Minimum (0), */
262 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
263 0x81, 0x03, /* Input (Constant, Variable), */
264 0x75, 0x01, /* Report Size (1), */
265 0x95, 0x13, /* Report Count (19), */
266 0x15, 0x00, /* Logical Minimum (0), */
267 0x25, 0x01, /* Logical Maximum (1), */
268 0x35, 0x00, /* Physical Minimum (0), */
269 0x45, 0x01, /* Physical Maximum (1), */
270 0x05, 0x09, /* Usage Page (Button), */
271 0x19, 0x01, /* Usage Minimum (01h), */
272 0x29, 0x13, /* Usage Maximum (13h), */
273 0x81, 0x02, /* Input (Variable), */
274 0x75, 0x01, /* Report Size (1), */
275 0x95, 0x0D, /* Report Count (13), */
276 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
277 0x81, 0x03, /* Input (Constant, Variable), */
278 0x15, 0x00, /* Logical Minimum (0), */
279 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
280 0x05, 0x01, /* Usage Page (Desktop), */
281 0x09, 0x01, /* Usage (Pointer), */
282 0xA1, 0x00, /* Collection (Physical), */
283 0x75, 0x08, /* Report Size (8), */
284 0x95, 0x02, /* Report Count (2), */
285 0x35, 0x00, /* Physical Minimum (0), */
286 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
287 0x09, 0x30, /* Usage (X), */
288 0x09, 0x31, /* Usage (Y), */
289 0x81, 0x02, /* Input (Variable), */
290 0xC0, /* End Collection, */
291 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
292 0x95, 0x06, /* Report Count (6), */
293 0x81, 0x03, /* Input (Constant, Variable), */
294 0x05, 0x01, /* Usage Page (Desktop), */
295 0x75, 0x08, /* Report Size (8), */
296 0x95, 0x05, /* Report Count (5), */
297 0x09, 0x01, /* Usage (Pointer), */
298 0x81, 0x02, /* Input (Variable), */
299 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
300 0x95, 0x01, /* Report Count (1), */
301 0x81, 0x02, /* Input (Variable), */
302 0x05, 0x01, /* Usage Page (Desktop), */
303 0x95, 0x01, /* Report Count (1), */
304 0x09, 0x01, /* Usage (Pointer), */
305 0x81, 0x02, /* Input (Variable), */
306 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
307 0x95, 0x1E, /* Report Count (24), */
308 0x81, 0x02, /* Input (Variable), */
309 0x75, 0x08, /* Report Size (8), */
310 0x95, 0x30, /* Report Count (48), */
311 0x09, 0x01, /* Usage (Pointer), */
312 0x91, 0x02, /* Output (Variable), */
313 0x75, 0x08, /* Report Size (8), */
314 0x95, 0x30, /* Report Count (48), */
315 0x09, 0x01, /* Usage (Pointer), */
316 0xB1, 0x02, /* Feature (Variable), */
317 0xC0, /* End Collection, */
318 0xA1, 0x02, /* Collection (Logical), */
319 0x85, 0x02, /* Report ID (2), */
320 0x75, 0x08, /* Report Size (8), */
321 0x95, 0x30, /* Report Count (48), */
322 0x09, 0x01, /* Usage (Pointer), */
323 0xB1, 0x02, /* Feature (Variable), */
324 0xC0, /* End Collection, */
325 0xA1, 0x02, /* Collection (Logical), */
326 0x85, 0xEE, /* Report ID (238), */
327 0x75, 0x08, /* Report Size (8), */
328 0x95, 0x30, /* Report Count (48), */
329 0x09, 0x01, /* Usage (Pointer), */
330 0xB1, 0x02, /* Feature (Variable), */
331 0xC0, /* End Collection, */
332 0xA1, 0x02, /* Collection (Logical), */
333 0x85, 0xEF, /* Report ID (239), */
334 0x75, 0x08, /* Report Size (8), */
335 0x95, 0x30, /* Report Count (48), */
336 0x09, 0x01, /* Usage (Pointer), */
337 0xB1, 0x02, /* Feature (Variable), */
338 0xC0, /* End Collection, */
339 0xC0 /* End Collection */
340};
341
342/*
343 * The default descriptor doesn't provide mapping for the accelerometers
344 * or orientation sensors. This fixed descriptor maps the accelerometers
345 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
346 * to usage values 0x43, 0x44 and 0x45.
347 */
348static u8 dualshock4_usb_rdesc[] = {
349 0x05, 0x01, /* Usage Page (Desktop), */
350 0x09, 0x05, /* Usage (Gamepad), */
351 0xA1, 0x01, /* Collection (Application), */
352 0x85, 0x01, /* Report ID (1), */
353 0x09, 0x30, /* Usage (X), */
354 0x09, 0x31, /* Usage (Y), */
355 0x09, 0x32, /* Usage (Z), */
356 0x09, 0x35, /* Usage (Rz), */
357 0x15, 0x00, /* Logical Minimum (0), */
358 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
359 0x75, 0x08, /* Report Size (8), */
360 0x95, 0x04, /* Report Count (4), */
361 0x81, 0x02, /* Input (Variable), */
362 0x09, 0x39, /* Usage (Hat Switch), */
363 0x15, 0x00, /* Logical Minimum (0), */
364 0x25, 0x07, /* Logical Maximum (7), */
365 0x35, 0x00, /* Physical Minimum (0), */
366 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
367 0x65, 0x14, /* Unit (Degrees), */
368 0x75, 0x04, /* Report Size (4), */
369 0x95, 0x01, /* Report Count (1), */
370 0x81, 0x42, /* Input (Variable, Null State), */
371 0x65, 0x00, /* Unit, */
372 0x05, 0x09, /* Usage Page (Button), */
373 0x19, 0x01, /* Usage Minimum (01h), */
374 0x29, 0x0E, /* Usage Maximum (0Eh), */
375 0x15, 0x00, /* Logical Minimum (0), */
376 0x25, 0x01, /* Logical Maximum (1), */
377 0x75, 0x01, /* Report Size (1), */
378 0x95, 0x0E, /* Report Count (14), */
379 0x81, 0x02, /* Input (Variable), */
380 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
381 0x09, 0x20, /* Usage (20h), */
382 0x75, 0x06, /* Report Size (6), */
383 0x95, 0x01, /* Report Count (1), */
384 0x15, 0x00, /* Logical Minimum (0), */
385 0x25, 0x3F, /* Logical Maximum (63), */
386 0x81, 0x02, /* Input (Variable), */
387 0x05, 0x01, /* Usage Page (Desktop), */
388 0x09, 0x33, /* Usage (Rx), */
389 0x09, 0x34, /* Usage (Ry), */
390 0x15, 0x00, /* Logical Minimum (0), */
391 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
392 0x75, 0x08, /* Report Size (8), */
393 0x95, 0x02, /* Report Count (2), */
394 0x81, 0x02, /* Input (Variable), */
395 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
396 0x09, 0x21, /* Usage (21h), */
397 0x95, 0x03, /* Report Count (3), */
398 0x81, 0x02, /* Input (Variable), */
399 0x05, 0x01, /* Usage Page (Desktop), */
400 0x19, 0x40, /* Usage Minimum (40h), */
401 0x29, 0x42, /* Usage Maximum (42h), */
402 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
403 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
404 0x75, 0x10, /* Report Size (16), */
405 0x95, 0x03, /* Report Count (3), */
406 0x81, 0x02, /* Input (Variable), */
407 0x19, 0x43, /* Usage Minimum (43h), */
408 0x29, 0x45, /* Usage Maximum (45h), */
409 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
410 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
411 0x95, 0x03, /* Report Count (3), */
412 0x81, 0x02, /* Input (Variable), */
413 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
414 0x09, 0x21, /* Usage (21h), */
415 0x15, 0x00, /* Logical Minimum (0), */
416 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
417 0x75, 0x08, /* Report Size (8), */
418 0x95, 0x27, /* Report Count (39), */
419 0x81, 0x02, /* Input (Variable), */
420 0x85, 0x05, /* Report ID (5), */
421 0x09, 0x22, /* Usage (22h), */
422 0x95, 0x1F, /* Report Count (31), */
423 0x91, 0x02, /* Output (Variable), */
424 0x85, 0x04, /* Report ID (4), */
425 0x09, 0x23, /* Usage (23h), */
426 0x95, 0x24, /* Report Count (36), */
427 0xB1, 0x02, /* Feature (Variable), */
428 0x85, 0x02, /* Report ID (2), */
429 0x09, 0x24, /* Usage (24h), */
430 0x95, 0x24, /* Report Count (36), */
431 0xB1, 0x02, /* Feature (Variable), */
432 0x85, 0x08, /* Report ID (8), */
433 0x09, 0x25, /* Usage (25h), */
434 0x95, 0x03, /* Report Count (3), */
435 0xB1, 0x02, /* Feature (Variable), */
436 0x85, 0x10, /* Report ID (16), */
437 0x09, 0x26, /* Usage (26h), */
438 0x95, 0x04, /* Report Count (4), */
439 0xB1, 0x02, /* Feature (Variable), */
440 0x85, 0x11, /* Report ID (17), */
441 0x09, 0x27, /* Usage (27h), */
442 0x95, 0x02, /* Report Count (2), */
443 0xB1, 0x02, /* Feature (Variable), */
444 0x85, 0x12, /* Report ID (18), */
445 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
446 0x09, 0x21, /* Usage (21h), */
447 0x95, 0x0F, /* Report Count (15), */
448 0xB1, 0x02, /* Feature (Variable), */
449 0x85, 0x13, /* Report ID (19), */
450 0x09, 0x22, /* Usage (22h), */
451 0x95, 0x16, /* Report Count (22), */
452 0xB1, 0x02, /* Feature (Variable), */
453 0x85, 0x14, /* Report ID (20), */
454 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
455 0x09, 0x20, /* Usage (20h), */
456 0x95, 0x10, /* Report Count (16), */
457 0xB1, 0x02, /* Feature (Variable), */
458 0x85, 0x15, /* Report ID (21), */
459 0x09, 0x21, /* Usage (21h), */
460 0x95, 0x2C, /* Report Count (44), */
461 0xB1, 0x02, /* Feature (Variable), */
462 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
463 0x85, 0x80, /* Report ID (128), */
464 0x09, 0x20, /* Usage (20h), */
465 0x95, 0x06, /* Report Count (6), */
466 0xB1, 0x02, /* Feature (Variable), */
467 0x85, 0x81, /* Report ID (129), */
468 0x09, 0x21, /* Usage (21h), */
469 0x95, 0x06, /* Report Count (6), */
470 0xB1, 0x02, /* Feature (Variable), */
471 0x85, 0x82, /* Report ID (130), */
472 0x09, 0x22, /* Usage (22h), */
473 0x95, 0x05, /* Report Count (5), */
474 0xB1, 0x02, /* Feature (Variable), */
475 0x85, 0x83, /* Report ID (131), */
476 0x09, 0x23, /* Usage (23h), */
477 0x95, 0x01, /* Report Count (1), */
478 0xB1, 0x02, /* Feature (Variable), */
479 0x85, 0x84, /* Report ID (132), */
480 0x09, 0x24, /* Usage (24h), */
481 0x95, 0x04, /* Report Count (4), */
482 0xB1, 0x02, /* Feature (Variable), */
483 0x85, 0x85, /* Report ID (133), */
484 0x09, 0x25, /* Usage (25h), */
485 0x95, 0x06, /* Report Count (6), */
486 0xB1, 0x02, /* Feature (Variable), */
487 0x85, 0x86, /* Report ID (134), */
488 0x09, 0x26, /* Usage (26h), */
489 0x95, 0x06, /* Report Count (6), */
490 0xB1, 0x02, /* Feature (Variable), */
491 0x85, 0x87, /* Report ID (135), */
492 0x09, 0x27, /* Usage (27h), */
493 0x95, 0x23, /* Report Count (35), */
494 0xB1, 0x02, /* Feature (Variable), */
495 0x85, 0x88, /* Report ID (136), */
496 0x09, 0x28, /* Usage (28h), */
497 0x95, 0x22, /* Report Count (34), */
498 0xB1, 0x02, /* Feature (Variable), */
499 0x85, 0x89, /* Report ID (137), */
500 0x09, 0x29, /* Usage (29h), */
501 0x95, 0x02, /* Report Count (2), */
502 0xB1, 0x02, /* Feature (Variable), */
503 0x85, 0x90, /* Report ID (144), */
504 0x09, 0x30, /* Usage (30h), */
505 0x95, 0x05, /* Report Count (5), */
506 0xB1, 0x02, /* Feature (Variable), */
507 0x85, 0x91, /* Report ID (145), */
508 0x09, 0x31, /* Usage (31h), */
509 0x95, 0x03, /* Report Count (3), */
510 0xB1, 0x02, /* Feature (Variable), */
511 0x85, 0x92, /* Report ID (146), */
512 0x09, 0x32, /* Usage (32h), */
513 0x95, 0x03, /* Report Count (3), */
514 0xB1, 0x02, /* Feature (Variable), */
515 0x85, 0x93, /* Report ID (147), */
516 0x09, 0x33, /* Usage (33h), */
517 0x95, 0x0C, /* Report Count (12), */
518 0xB1, 0x02, /* Feature (Variable), */
519 0x85, 0xA0, /* Report ID (160), */
520 0x09, 0x40, /* Usage (40h), */
521 0x95, 0x06, /* Report Count (6), */
522 0xB1, 0x02, /* Feature (Variable), */
523 0x85, 0xA1, /* Report ID (161), */
524 0x09, 0x41, /* Usage (41h), */
525 0x95, 0x01, /* Report Count (1), */
526 0xB1, 0x02, /* Feature (Variable), */
527 0x85, 0xA2, /* Report ID (162), */
528 0x09, 0x42, /* Usage (42h), */
529 0x95, 0x01, /* Report Count (1), */
530 0xB1, 0x02, /* Feature (Variable), */
531 0x85, 0xA3, /* Report ID (163), */
532 0x09, 0x43, /* Usage (43h), */
533 0x95, 0x30, /* Report Count (48), */
534 0xB1, 0x02, /* Feature (Variable), */
535 0x85, 0xA4, /* Report ID (164), */
536 0x09, 0x44, /* Usage (44h), */
537 0x95, 0x0D, /* Report Count (13), */
538 0xB1, 0x02, /* Feature (Variable), */
539 0x85, 0xA5, /* Report ID (165), */
540 0x09, 0x45, /* Usage (45h), */
541 0x95, 0x15, /* Report Count (21), */
542 0xB1, 0x02, /* Feature (Variable), */
543 0x85, 0xA6, /* Report ID (166), */
544 0x09, 0x46, /* Usage (46h), */
545 0x95, 0x15, /* Report Count (21), */
546 0xB1, 0x02, /* Feature (Variable), */
547 0x85, 0xF0, /* Report ID (240), */
548 0x09, 0x47, /* Usage (47h), */
549 0x95, 0x3F, /* Report Count (63), */
550 0xB1, 0x02, /* Feature (Variable), */
551 0x85, 0xF1, /* Report ID (241), */
552 0x09, 0x48, /* Usage (48h), */
553 0x95, 0x3F, /* Report Count (63), */
554 0xB1, 0x02, /* Feature (Variable), */
555 0x85, 0xF2, /* Report ID (242), */
556 0x09, 0x49, /* Usage (49h), */
557 0x95, 0x0F, /* Report Count (15), */
558 0xB1, 0x02, /* Feature (Variable), */
559 0x85, 0xA7, /* Report ID (167), */
560 0x09, 0x4A, /* Usage (4Ah), */
561 0x95, 0x01, /* Report Count (1), */
562 0xB1, 0x02, /* Feature (Variable), */
563 0x85, 0xA8, /* Report ID (168), */
564 0x09, 0x4B, /* Usage (4Bh), */
565 0x95, 0x01, /* Report Count (1), */
566 0xB1, 0x02, /* Feature (Variable), */
567 0x85, 0xA9, /* Report ID (169), */
568 0x09, 0x4C, /* Usage (4Ch), */
569 0x95, 0x08, /* Report Count (8), */
570 0xB1, 0x02, /* Feature (Variable), */
571 0x85, 0xAA, /* Report ID (170), */
572 0x09, 0x4E, /* Usage (4Eh), */
573 0x95, 0x01, /* Report Count (1), */
574 0xB1, 0x02, /* Feature (Variable), */
575 0x85, 0xAB, /* Report ID (171), */
576 0x09, 0x4F, /* Usage (4Fh), */
577 0x95, 0x39, /* Report Count (57), */
578 0xB1, 0x02, /* Feature (Variable), */
579 0x85, 0xAC, /* Report ID (172), */
580 0x09, 0x50, /* Usage (50h), */
581 0x95, 0x39, /* Report Count (57), */
582 0xB1, 0x02, /* Feature (Variable), */
583 0x85, 0xAD, /* Report ID (173), */
584 0x09, 0x51, /* Usage (51h), */
585 0x95, 0x0B, /* Report Count (11), */
586 0xB1, 0x02, /* Feature (Variable), */
587 0x85, 0xAE, /* Report ID (174), */
588 0x09, 0x52, /* Usage (52h), */
589 0x95, 0x01, /* Report Count (1), */
590 0xB1, 0x02, /* Feature (Variable), */
591 0x85, 0xAF, /* Report ID (175), */
592 0x09, 0x53, /* Usage (53h), */
593 0x95, 0x02, /* Report Count (2), */
594 0xB1, 0x02, /* Feature (Variable), */
595 0x85, 0xB0, /* Report ID (176), */
596 0x09, 0x54, /* Usage (54h), */
597 0x95, 0x3F, /* Report Count (63), */
598 0xB1, 0x02, /* Feature (Variable), */
599 0xC0 /* End Collection */
600};
601
602/*
603 * The default behavior of the Dualshock 4 is to send reports using report
604 * type 1 when running over Bluetooth. However, when feature report 2 is
605 * requested during the controller initialization it starts sending input
606 * reports in report 17. Since report 17 is undefined in the default HID
607 * descriptor the button and axis definitions must be moved to report 17 or
608 * the HID layer won't process the received input.
609 */
610static u8 dualshock4_bt_rdesc[] = {
611 0x05, 0x01, /* Usage Page (Desktop), */
612 0x09, 0x05, /* Usage (Gamepad), */
613 0xA1, 0x01, /* Collection (Application), */
614 0x85, 0x01, /* Report ID (1), */
615 0x75, 0x08, /* Report Size (8), */
616 0x95, 0x0A, /* Report Count (9), */
617 0x81, 0x02, /* Input (Variable), */
618 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
619 0x85, 0x02, /* Report ID (2), */
620 0x09, 0x24, /* Usage (24h), */
621 0x95, 0x24, /* Report Count (36), */
622 0xB1, 0x02, /* Feature (Variable), */
623 0x85, 0xA3, /* Report ID (163), */
624 0x09, 0x25, /* Usage (25h), */
625 0x95, 0x30, /* Report Count (48), */
626 0xB1, 0x02, /* Feature (Variable), */
627 0x85, 0x05, /* Report ID (5), */
628 0x09, 0x26, /* Usage (26h), */
629 0x95, 0x28, /* Report Count (40), */
630 0xB1, 0x02, /* Feature (Variable), */
631 0x85, 0x06, /* Report ID (6), */
632 0x09, 0x27, /* Usage (27h), */
633 0x95, 0x34, /* Report Count (52), */
634 0xB1, 0x02, /* Feature (Variable), */
635 0x85, 0x07, /* Report ID (7), */
636 0x09, 0x28, /* Usage (28h), */
637 0x95, 0x30, /* Report Count (48), */
638 0xB1, 0x02, /* Feature (Variable), */
639 0x85, 0x08, /* Report ID (8), */
640 0x09, 0x29, /* Usage (29h), */
641 0x95, 0x2F, /* Report Count (47), */
642 0xB1, 0x02, /* Feature (Variable), */
643 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
644 0x85, 0x03, /* Report ID (3), */
645 0x09, 0x21, /* Usage (21h), */
646 0x95, 0x26, /* Report Count (38), */
647 0xB1, 0x02, /* Feature (Variable), */
648 0x85, 0x04, /* Report ID (4), */
649 0x09, 0x22, /* Usage (22h), */
650 0x95, 0x2E, /* Report Count (46), */
651 0xB1, 0x02, /* Feature (Variable), */
652 0x85, 0xF0, /* Report ID (240), */
653 0x09, 0x47, /* Usage (47h), */
654 0x95, 0x3F, /* Report Count (63), */
655 0xB1, 0x02, /* Feature (Variable), */
656 0x85, 0xF1, /* Report ID (241), */
657 0x09, 0x48, /* Usage (48h), */
658 0x95, 0x3F, /* Report Count (63), */
659 0xB1, 0x02, /* Feature (Variable), */
660 0x85, 0xF2, /* Report ID (242), */
661 0x09, 0x49, /* Usage (49h), */
662 0x95, 0x0F, /* Report Count (15), */
663 0xB1, 0x02, /* Feature (Variable), */
664 0x85, 0x11, /* Report ID (17), */
665 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
666 0x09, 0x20, /* Usage (20h), */
667 0x95, 0x02, /* Report Count (2), */
668 0x81, 0x02, /* Input (Variable), */
669 0x05, 0x01, /* Usage Page (Desktop), */
670 0x09, 0x30, /* Usage (X), */
671 0x09, 0x31, /* Usage (Y), */
672 0x09, 0x32, /* Usage (Z), */
673 0x09, 0x35, /* Usage (Rz), */
674 0x15, 0x00, /* Logical Minimum (0), */
675 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
676 0x75, 0x08, /* Report Size (8), */
677 0x95, 0x04, /* Report Count (4), */
678 0x81, 0x02, /* Input (Variable), */
679 0x09, 0x39, /* Usage (Hat Switch), */
680 0x15, 0x00, /* Logical Minimum (0), */
681 0x25, 0x07, /* Logical Maximum (7), */
682 0x75, 0x04, /* Report Size (4), */
683 0x95, 0x01, /* Report Count (1), */
684 0x81, 0x42, /* Input (Variable, Null State), */
685 0x05, 0x09, /* Usage Page (Button), */
686 0x19, 0x01, /* Usage Minimum (01h), */
687 0x29, 0x0E, /* Usage Maximum (0Eh), */
688 0x15, 0x00, /* Logical Minimum (0), */
689 0x25, 0x01, /* Logical Maximum (1), */
690 0x75, 0x01, /* Report Size (1), */
691 0x95, 0x0E, /* Report Count (14), */
692 0x81, 0x02, /* Input (Variable), */
693 0x75, 0x06, /* Report Size (6), */
694 0x95, 0x01, /* Report Count (1), */
695 0x81, 0x01, /* Input (Constant), */
696 0x05, 0x01, /* Usage Page (Desktop), */
697 0x09, 0x33, /* Usage (Rx), */
698 0x09, 0x34, /* Usage (Ry), */
699 0x15, 0x00, /* Logical Minimum (0), */
700 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
701 0x75, 0x08, /* Report Size (8), */
702 0x95, 0x02, /* Report Count (2), */
703 0x81, 0x02, /* Input (Variable), */
704 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
705 0x09, 0x20, /* Usage (20h), */
706 0x95, 0x03, /* Report Count (3), */
707 0x81, 0x02, /* Input (Variable), */
708 0x05, 0x01, /* Usage Page (Desktop), */
709 0x19, 0x40, /* Usage Minimum (40h), */
710 0x29, 0x42, /* Usage Maximum (42h), */
711 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
712 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
713 0x75, 0x10, /* Report Size (16), */
714 0x95, 0x03, /* Report Count (3), */
715 0x81, 0x02, /* Input (Variable), */
716 0x19, 0x43, /* Usage Minimum (43h), */
717 0x29, 0x45, /* Usage Maximum (45h), */
718 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
719 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
720 0x95, 0x03, /* Report Count (3), */
721 0x81, 0x02, /* Input (Variable), */
722 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
723 0x09, 0x20, /* Usage (20h), */
724 0x15, 0x00, /* Logical Minimum (0), */
725 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
726 0x75, 0x08, /* Report Size (8), */
727 0x95, 0x31, /* Report Count (51), */
728 0x81, 0x02, /* Input (Variable), */
729 0x09, 0x21, /* Usage (21h), */
730 0x75, 0x08, /* Report Size (8), */
731 0x95, 0x4D, /* Report Count (77), */
732 0x91, 0x02, /* Output (Variable), */
733 0x85, 0x12, /* Report ID (18), */
734 0x09, 0x22, /* Usage (22h), */
735 0x95, 0x8D, /* Report Count (141), */
736 0x81, 0x02, /* Input (Variable), */
737 0x09, 0x23, /* Usage (23h), */
738 0x91, 0x02, /* Output (Variable), */
739 0x85, 0x13, /* Report ID (19), */
740 0x09, 0x24, /* Usage (24h), */
741 0x95, 0xCD, /* Report Count (205), */
742 0x81, 0x02, /* Input (Variable), */
743 0x09, 0x25, /* Usage (25h), */
744 0x91, 0x02, /* Output (Variable), */
745 0x85, 0x14, /* Report ID (20), */
746 0x09, 0x26, /* Usage (26h), */
747 0x96, 0x0D, 0x01, /* Report Count (269), */
748 0x81, 0x02, /* Input (Variable), */
749 0x09, 0x27, /* Usage (27h), */
750 0x91, 0x02, /* Output (Variable), */
751 0x85, 0x15, /* Report ID (21), */
752 0x09, 0x28, /* Usage (28h), */
753 0x96, 0x4D, 0x01, /* Report Count (333), */
754 0x81, 0x02, /* Input (Variable), */
755 0x09, 0x29, /* Usage (29h), */
756 0x91, 0x02, /* Output (Variable), */
757 0x85, 0x16, /* Report ID (22), */
758 0x09, 0x2A, /* Usage (2Ah), */
759 0x96, 0x8D, 0x01, /* Report Count (397), */
760 0x81, 0x02, /* Input (Variable), */
761 0x09, 0x2B, /* Usage (2Bh), */
762 0x91, 0x02, /* Output (Variable), */
763 0x85, 0x17, /* Report ID (23), */
764 0x09, 0x2C, /* Usage (2Ch), */
765 0x96, 0xCD, 0x01, /* Report Count (461), */
766 0x81, 0x02, /* Input (Variable), */
767 0x09, 0x2D, /* Usage (2Dh), */
768 0x91, 0x02, /* Output (Variable), */
769 0x85, 0x18, /* Report ID (24), */
770 0x09, 0x2E, /* Usage (2Eh), */
771 0x96, 0x0D, 0x02, /* Report Count (525), */
772 0x81, 0x02, /* Input (Variable), */
773 0x09, 0x2F, /* Usage (2Fh), */
774 0x91, 0x02, /* Output (Variable), */
775 0x85, 0x19, /* Report ID (25), */
776 0x09, 0x30, /* Usage (30h), */
777 0x96, 0x22, 0x02, /* Report Count (546), */
778 0x81, 0x02, /* Input (Variable), */
779 0x09, 0x31, /* Usage (31h), */
780 0x91, 0x02, /* Output (Variable), */
781 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
782 0x85, 0x82, /* Report ID (130), */
783 0x09, 0x22, /* Usage (22h), */
784 0x95, 0x3F, /* Report Count (63), */
785 0xB1, 0x02, /* Feature (Variable), */
786 0x85, 0x83, /* Report ID (131), */
787 0x09, 0x23, /* Usage (23h), */
788 0xB1, 0x02, /* Feature (Variable), */
789 0x85, 0x84, /* Report ID (132), */
790 0x09, 0x24, /* Usage (24h), */
791 0xB1, 0x02, /* Feature (Variable), */
792 0x85, 0x90, /* Report ID (144), */
793 0x09, 0x30, /* Usage (30h), */
794 0xB1, 0x02, /* Feature (Variable), */
795 0x85, 0x91, /* Report ID (145), */
796 0x09, 0x31, /* Usage (31h), */
797 0xB1, 0x02, /* Feature (Variable), */
798 0x85, 0x92, /* Report ID (146), */
799 0x09, 0x32, /* Usage (32h), */
800 0xB1, 0x02, /* Feature (Variable), */
801 0x85, 0x93, /* Report ID (147), */
802 0x09, 0x33, /* Usage (33h), */
803 0xB1, 0x02, /* Feature (Variable), */
804 0x85, 0xA0, /* Report ID (160), */
805 0x09, 0x40, /* Usage (40h), */
806 0xB1, 0x02, /* Feature (Variable), */
807 0x85, 0xA4, /* Report ID (164), */
808 0x09, 0x44, /* Usage (44h), */
809 0xB1, 0x02, /* Feature (Variable), */
810 0xC0 /* End Collection */
811};
812
813static u8 ps3remote_rdesc[] = {
814 0x05, 0x01, /* GUsagePage Generic Desktop */
815 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
816 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
817
818 /* Use collection 1 for joypad buttons */
819 0xA1, 0x02, /* MCollection Logical (interrelated data) */
820
821 /*
822 * Ignore the 1st byte, maybe it is used for a controller
823 * number but it's not needed for correct operation
824 */
825 0x75, 0x08, /* GReportSize 0x08 [8] */
826 0x95, 0x01, /* GReportCount 0x01 [1] */
827 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
828
829 /*
830 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
831 * buttons multiple keypresses are allowed
832 */
833 0x05, 0x09, /* GUsagePage Button */
834 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
835 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
836 0x14, /* GLogicalMinimum [0] */
837 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
838 0x75, 0x01, /* GReportSize 0x01 [1] */
839 0x95, 0x18, /* GReportCount 0x18 [24] */
840 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
841
842 0xC0, /* MEndCollection */
843
844 /* Use collection 2 for remote control buttons */
845 0xA1, 0x02, /* MCollection Logical (interrelated data) */
846
847 /* 5th byte is used for remote control buttons */
848 0x05, 0x09, /* GUsagePage Button */
849 0x18, /* LUsageMinimum [No button pressed] */
850 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
851 0x14, /* GLogicalMinimum [0] */
852 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
853 0x75, 0x08, /* GReportSize 0x08 [8] */
854 0x95, 0x01, /* GReportCount 0x01 [1] */
855 0x80, /* MInput */
856
857 /*
858 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
859 * 0xff and 11th is for press indication
860 */
861 0x75, 0x08, /* GReportSize 0x08 [8] */
862 0x95, 0x06, /* GReportCount 0x06 [6] */
863 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
864
865 /* 12th byte is for battery strength */
866 0x05, 0x06, /* GUsagePage Generic Device Controls */
867 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
868 0x14, /* GLogicalMinimum [0] */
869 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
870 0x75, 0x08, /* GReportSize 0x08 [8] */
871 0x95, 0x01, /* GReportCount 0x01 [1] */
872 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
873
874 0xC0, /* MEndCollection */
875
876 0xC0 /* MEndCollection [Game Pad] */
877};
878
879static const unsigned int ps3remote_keymap_joypad_buttons[] = {
880 [0x01] = KEY_SELECT,
881 [0x02] = BTN_THUMBL, /* L3 */
882 [0x03] = BTN_THUMBR, /* R3 */
883 [0x04] = BTN_START,
884 [0x05] = KEY_UP,
885 [0x06] = KEY_RIGHT,
886 [0x07] = KEY_DOWN,
887 [0x08] = KEY_LEFT,
888 [0x09] = BTN_TL2, /* L2 */
889 [0x0a] = BTN_TR2, /* R2 */
890 [0x0b] = BTN_TL, /* L1 */
891 [0x0c] = BTN_TR, /* R1 */
892 [0x0d] = KEY_OPTION, /* options/triangle */
893 [0x0e] = KEY_BACK, /* back/circle */
894 [0x0f] = BTN_0, /* cross */
895 [0x10] = KEY_SCREEN, /* view/square */
896 [0x11] = KEY_HOMEPAGE, /* PS button */
897 [0x14] = KEY_ENTER,
898};
899static const unsigned int ps3remote_keymap_remote_buttons[] = {
900 [0x00] = KEY_1,
901 [0x01] = KEY_2,
902 [0x02] = KEY_3,
903 [0x03] = KEY_4,
904 [0x04] = KEY_5,
905 [0x05] = KEY_6,
906 [0x06] = KEY_7,
907 [0x07] = KEY_8,
908 [0x08] = KEY_9,
909 [0x09] = KEY_0,
910 [0x0e] = KEY_ESC, /* return */
911 [0x0f] = KEY_CLEAR,
912 [0x16] = KEY_EJECTCD,
913 [0x1a] = KEY_MENU, /* top menu */
914 [0x28] = KEY_TIME,
915 [0x30] = KEY_PREVIOUS,
916 [0x31] = KEY_NEXT,
917 [0x32] = KEY_PLAY,
918 [0x33] = KEY_REWIND, /* scan back */
919 [0x34] = KEY_FORWARD, /* scan forward */
920 [0x38] = KEY_STOP,
921 [0x39] = KEY_PAUSE,
922 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
923 [0x60] = KEY_FRAMEBACK, /* slow/step back */
924 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
925 [0x63] = KEY_SUBTITLE,
926 [0x64] = KEY_AUDIO,
927 [0x65] = KEY_ANGLE,
928 [0x70] = KEY_INFO, /* display */
929 [0x80] = KEY_BLUE,
930 [0x81] = KEY_RED,
931 [0x82] = KEY_GREEN,
932 [0x83] = KEY_YELLOW,
933};
934
935static const unsigned int buzz_keymap[] = {
936 /*
937 * The controller has 4 remote buzzers, each with one LED and 5
938 * buttons.
939 *
940 * We use the mapping chosen by the controller, which is:
941 *
942 * Key Offset
943 * -------------------
944 * Buzz 1
945 * Blue 5
946 * Orange 4
947 * Green 3
948 * Yellow 2
949 *
950 * So, for example, the orange button on the third buzzer is mapped to
951 * BTN_TRIGGER_HAPPY14
952 */
953 [1] = BTN_TRIGGER_HAPPY1,
954 [2] = BTN_TRIGGER_HAPPY2,
955 [3] = BTN_TRIGGER_HAPPY3,
956 [4] = BTN_TRIGGER_HAPPY4,
957 [5] = BTN_TRIGGER_HAPPY5,
958 [6] = BTN_TRIGGER_HAPPY6,
959 [7] = BTN_TRIGGER_HAPPY7,
960 [8] = BTN_TRIGGER_HAPPY8,
961 [9] = BTN_TRIGGER_HAPPY9,
962 [10] = BTN_TRIGGER_HAPPY10,
963 [11] = BTN_TRIGGER_HAPPY11,
964 [12] = BTN_TRIGGER_HAPPY12,
965 [13] = BTN_TRIGGER_HAPPY13,
966 [14] = BTN_TRIGGER_HAPPY14,
967 [15] = BTN_TRIGGER_HAPPY15,
968 [16] = BTN_TRIGGER_HAPPY16,
969 [17] = BTN_TRIGGER_HAPPY17,
970 [18] = BTN_TRIGGER_HAPPY18,
971 [19] = BTN_TRIGGER_HAPPY19,
972 [20] = BTN_TRIGGER_HAPPY20,
973};
974
975static enum power_supply_property sony_battery_props[] = {
976 POWER_SUPPLY_PROP_PRESENT,
977 POWER_SUPPLY_PROP_CAPACITY,
978 POWER_SUPPLY_PROP_SCOPE,
979 POWER_SUPPLY_PROP_STATUS,
980};
981
982struct sixaxis_led {
983 u8 time_enabled; /* the total time the led is active (0xff means forever) */
984 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
985 u8 enabled;
986 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
987 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
988} __packed;
989
990struct sixaxis_rumble {
991 u8 padding;
992 u8 right_duration; /* Right motor duration (0xff means forever) */
993 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
994 u8 left_duration; /* Left motor duration (0xff means forever) */
995 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
996} __packed;
997
998struct sixaxis_output_report {
999 u8 report_id;
1000 struct sixaxis_rumble rumble;
1001 u8 padding[4];
1002 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
1003 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
1004 struct sixaxis_led _reserved; /* LED5, not actually soldered */
1005} __packed;
1006
1007union sixaxis_output_report_01 {
1008 struct sixaxis_output_report data;
1009 u8 buf[36];
1010};
1011
1012struct motion_output_report_02 {
1013 u8 type, zero;
1014 u8 r, g, b;
1015 u8 zero2;
1016 u8 rumble;
1017};
1018
1019#define DS4_REPORT_0x02_SIZE 37
1020#define DS4_REPORT_0x05_SIZE 32
1021#define DS4_REPORT_0x11_SIZE 78
1022#define DS4_REPORT_0x81_SIZE 7
1023#define SIXAXIS_REPORT_0xF2_SIZE 17
1024#define SIXAXIS_REPORT_0xF5_SIZE 8
1025#define MOTION_REPORT_0x02_SIZE 49
1026
1027static DEFINE_SPINLOCK(sony_dev_list_lock);
1028static LIST_HEAD(sony_device_list);
1029static DEFINE_IDA(sony_device_id_allocator);
1030
1031struct sony_sc {
1032 spinlock_t lock;
1033 struct list_head list_node;
1034 struct hid_device *hdev;
1035 struct led_classdev *leds[MAX_LEDS];
1036 unsigned long quirks;
1037 struct work_struct state_worker;
1038 void (*send_output_report)(struct sony_sc *);
1039 struct power_supply *battery;
1040 struct power_supply_desc battery_desc;
1041 int device_id;
1042 u8 *output_report_dmabuf;
1043
1044#ifdef CONFIG_SONY_FF
1045 u8 left;
1046 u8 right;
1047#endif
1048
1049 u8 mac_address[6];
1050 u8 worker_initialized;
1051 u8 cable_state;
1052 u8 battery_charging;
1053 u8 battery_capacity;
1054 u8 led_state[MAX_LEDS];
1055 u8 resume_led_state[MAX_LEDS];
1056 u8 led_delay_on[MAX_LEDS];
1057 u8 led_delay_off[MAX_LEDS];
1058 u8 led_count;
1059};
1060
1061static u8 *sixaxis_fixup(struct hid_device *hdev, u8 *rdesc,
1062 unsigned int *rsize)
1063{
1064 *rsize = sizeof(sixaxis_rdesc);
1065 return sixaxis_rdesc;
1066}
1067
1068static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
1069 unsigned int *rsize)
1070{
1071 *rsize = sizeof(motion_rdesc);
1072 return motion_rdesc;
1073}
1074
1075static u8 *navigation_fixup(struct hid_device *hdev, u8 *rdesc,
1076 unsigned int *rsize)
1077{
1078 *rsize = sizeof(navigation_rdesc);
1079 return navigation_rdesc;
1080}
1081
1082static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
1083 unsigned int *rsize)
1084{
1085 *rsize = sizeof(ps3remote_rdesc);
1086 return ps3remote_rdesc;
1087}
1088
1089static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
1090 struct hid_field *field, struct hid_usage *usage,
1091 unsigned long **bit, int *max)
1092{
1093 unsigned int key = usage->hid & HID_USAGE;
1094
1095 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1096 return -1;
1097
1098 switch (usage->collection_index) {
1099 case 1:
1100 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
1101 return -1;
1102
1103 key = ps3remote_keymap_joypad_buttons[key];
1104 if (!key)
1105 return -1;
1106 break;
1107 case 2:
1108 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
1109 return -1;
1110
1111 key = ps3remote_keymap_remote_buttons[key];
1112 if (!key)
1113 return -1;
1114 break;
1115 default:
1116 return -1;
1117 }
1118
1119 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1120 return 1;
1121}
1122
1123static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
1124 unsigned int *rsize)
1125{
1126 struct sony_sc *sc = hid_get_drvdata(hdev);
1127
1128 if (sc->quirks & SINO_LITE_CONTROLLER)
1129 return rdesc;
1130
1131 /*
1132 * Some Sony RF receivers wrongly declare the mouse pointer as a
1133 * a constant non-data variable.
1134 */
1135 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
1136 /* usage page: generic desktop controls */
1137 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
1138 /* usage: mouse */
1139 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
1140 /* input (usage page for x,y axes): constant, variable, relative */
1141 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
1142 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
1143 /* input: data, variable, relative */
1144 rdesc[55] = 0x06;
1145 }
1146
1147 /*
1148 * The default Dualshock 4 USB descriptor doesn't assign
1149 * the gyroscope values to corresponding axes so we need a
1150 * modified one.
1151 */
1152 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1153 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
1154 rdesc = dualshock4_usb_rdesc;
1155 *rsize = sizeof(dualshock4_usb_rdesc);
1156 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1157 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
1158 rdesc = dualshock4_bt_rdesc;
1159 *rsize = sizeof(dualshock4_bt_rdesc);
1160 }
1161
1162 if (sc->quirks & SIXAXIS_CONTROLLER)
1163 return sixaxis_fixup(hdev, rdesc, rsize);
1164
1165 if (sc->quirks & MOTION_CONTROLLER)
1166 return motion_fixup(hdev, rdesc, rsize);
1167
1168 if (sc->quirks & NAVIGATION_CONTROLLER)
1169 return navigation_fixup(hdev, rdesc, rsize);
1170
1171 if (sc->quirks & PS3REMOTE)
1172 return ps3remote_fixup(hdev, rdesc, rsize);
1173
1174 return rdesc;
1175}
1176
1177static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
1178{
1179 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
1180 unsigned long flags;
1181 int offset;
1182 u8 cable_state, battery_capacity, battery_charging;
1183
1184 /*
1185 * The sixaxis is charging if the battery value is 0xee
1186 * and it is fully charged if the value is 0xef.
1187 * It does not report the actual level while charging so it
1188 * is set to 100% while charging is in progress.
1189 */
1190 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1191
1192 if (rd[offset] >= 0xee) {
1193 battery_capacity = 100;
1194 battery_charging = !(rd[offset] & 0x01);
1195 cable_state = 1;
1196 } else {
1197 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
1198 battery_capacity = sixaxis_battery_capacity[index];
1199 battery_charging = 0;
1200 cable_state = 0;
1201 }
1202
1203 spin_lock_irqsave(&sc->lock, flags);
1204 sc->cable_state = cable_state;
1205 sc->battery_capacity = battery_capacity;
1206 sc->battery_charging = battery_charging;
1207 spin_unlock_irqrestore(&sc->lock, flags);
1208}
1209
1210static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
1211{
1212 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1213 struct hid_input, list);
1214 struct input_dev *input_dev = hidinput->input;
1215 unsigned long flags;
1216 int n, offset;
1217 u8 cable_state, battery_capacity, battery_charging;
1218
1219 /*
1220 * Battery and touchpad data starts at byte 30 in the USB report and
1221 * 32 in Bluetooth report.
1222 */
1223 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
1224
1225 /*
1226 * The lower 4 bits of byte 30 contain the battery level
1227 * and the 5th bit contains the USB cable state.
1228 */
1229 cable_state = (rd[offset] >> 4) & 0x01;
1230 battery_capacity = rd[offset] & 0x0F;
1231
1232 /*
1233 * When a USB power source is connected the battery level ranges from
1234 * 0 to 10, and when running on battery power it ranges from 0 to 9.
1235 * A battery level above 10 when plugged in means charge completed.
1236 */
1237 if (!cable_state || battery_capacity > 10)
1238 battery_charging = 0;
1239 else
1240 battery_charging = 1;
1241
1242 if (!cable_state)
1243 battery_capacity++;
1244 if (battery_capacity > 10)
1245 battery_capacity = 10;
1246
1247 battery_capacity *= 10;
1248
1249 spin_lock_irqsave(&sc->lock, flags);
1250 sc->cable_state = cable_state;
1251 sc->battery_capacity = battery_capacity;
1252 sc->battery_charging = battery_charging;
1253 spin_unlock_irqrestore(&sc->lock, flags);
1254
1255 offset += 5;
1256
1257 /*
1258 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
1259 * and 37 on Bluetooth.
1260 * The first 7 bits of the first byte is a counter and bit 8 is a touch
1261 * indicator that is 0 when pressed and 1 when not pressed.
1262 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1263 * The data for the second touch is in the same format and immediatly
1264 * follows the data for the first.
1265 */
1266 for (n = 0; n < 2; n++) {
1267 u16 x, y;
1268
1269 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1270 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1271
1272 input_mt_slot(input_dev, n);
1273 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
1274 !(rd[offset] >> 7));
1275 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1276 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1277
1278 offset += 4;
1279 }
1280}
1281
1282static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1283 u8 *rd, int size)
1284{
1285 struct sony_sc *sc = hid_get_drvdata(hdev);
1286
1287 /*
1288 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1289 * has to be BYTE_SWAPPED before passing up to joystick interface
1290 */
1291 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1292 /*
1293 * When connected via Bluetooth the Sixaxis occasionally sends
1294 * a report with the second byte 0xff and the rest zeroed.
1295 *
1296 * This report does not reflect the actual state of the
1297 * controller must be ignored to avoid generating false input
1298 * events.
1299 */
1300 if (rd[1] == 0xff)
1301 return -EINVAL;
1302
1303 swap(rd[41], rd[42]);
1304 swap(rd[43], rd[44]);
1305 swap(rd[45], rd[46]);
1306 swap(rd[47], rd[48]);
1307
1308 sixaxis_parse_report(sc, rd, size);
1309 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1310 sixaxis_parse_report(sc, rd, size);
1311 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1312 size == 49) {
1313 sixaxis_parse_report(sc, rd, size);
1314 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1315 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1316 && rd[0] == 0x11 && size == 78)) {
1317 dualshock4_parse_report(sc, rd, size);
1318 }
1319
1320 return 0;
1321}
1322
1323static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1324 struct hid_field *field, struct hid_usage *usage,
1325 unsigned long **bit, int *max)
1326{
1327 struct sony_sc *sc = hid_get_drvdata(hdev);
1328
1329 if (sc->quirks & BUZZ_CONTROLLER) {
1330 unsigned int key = usage->hid & HID_USAGE;
1331
1332 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1333 return -1;
1334
1335 switch (usage->collection_index) {
1336 case 1:
1337 if (key >= ARRAY_SIZE(buzz_keymap))
1338 return -1;
1339
1340 key = buzz_keymap[key];
1341 if (!key)
1342 return -1;
1343 break;
1344 default:
1345 return -1;
1346 }
1347
1348 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1349 return 1;
1350 }
1351
1352 if (sc->quirks & PS3REMOTE)
1353 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1354
1355 /* Let hid-core decide for the others */
1356 return 0;
1357}
1358
1359static int sony_register_touchpad(struct hid_input *hi, int touch_count,
1360 int w, int h)
1361{
1362 struct input_dev *input_dev = hi->input;
1363 int ret;
1364
1365 ret = input_mt_init_slots(input_dev, touch_count, 0);
1366 if (ret < 0)
1367 return ret;
1368
1369 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1370 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1371
1372 return 0;
1373}
1374
1375static int sony_input_configured(struct hid_device *hdev,
1376 struct hid_input *hidinput)
1377{
1378 struct sony_sc *sc = hid_get_drvdata(hdev);
1379 int ret;
1380
1381 /*
1382 * The Dualshock 4 touchpad supports 2 touches and has a
1383 * resolution of 1920x942 (44.86 dots/mm).
1384 */
1385 if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1386 ret = sony_register_touchpad(hidinput, 2, 1920, 942);
1387 if (ret) {
1388 hid_err(sc->hdev,
1389 "Unable to initialize multi-touch slots: %d\n",
1390 ret);
1391 return ret;
1392 }
1393 }
1394
1395 return 0;
1396}
1397
1398/*
1399 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1400 * to "operational". Without this, the ps3 controller will not report any
1401 * events.
1402 */
1403static int sixaxis_set_operational_usb(struct hid_device *hdev)
1404{
1405 const int buf_size =
1406 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1407 u8 *buf;
1408 int ret;
1409
1410 buf = kmalloc(buf_size, GFP_KERNEL);
1411 if (!buf)
1412 return -ENOMEM;
1413
1414 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1415 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1416 if (ret < 0) {
1417 hid_err(hdev, "can't set operational mode: step 1\n");
1418 goto out;
1419 }
1420
1421 /*
1422 * Some compatible controllers like the Speedlink Strike FX and
1423 * Gasia need another query plus an USB interrupt to get operational.
1424 */
1425 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1426 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1427 if (ret < 0) {
1428 hid_err(hdev, "can't set operational mode: step 2\n");
1429 goto out;
1430 }
1431
1432 ret = hid_hw_output_report(hdev, buf, 1);
1433 if (ret < 0) {
1434 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1435 ret = 0;
1436 }
1437
1438out:
1439 kfree(buf);
1440
1441 return ret;
1442}
1443
1444static int sixaxis_set_operational_bt(struct hid_device *hdev)
1445{
1446 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1447 u8 *buf;
1448 int ret;
1449
1450 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1451 if (!buf)
1452 return -ENOMEM;
1453
1454 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1455 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1456
1457 kfree(buf);
1458
1459 return ret;
1460}
1461
1462/*
1463 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1464 * controller so that it sends full input reports of type 0x11.
1465 */
1466static int dualshock4_set_operational_bt(struct hid_device *hdev)
1467{
1468 u8 *buf;
1469 int ret;
1470
1471 buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1472 if (!buf)
1473 return -ENOMEM;
1474
1475 ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
1476 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1477
1478 kfree(buf);
1479
1480 return ret;
1481}
1482
1483static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1484{
1485 static const u8 sixaxis_leds[10][4] = {
1486 { 0x01, 0x00, 0x00, 0x00 },
1487 { 0x00, 0x01, 0x00, 0x00 },
1488 { 0x00, 0x00, 0x01, 0x00 },
1489 { 0x00, 0x00, 0x00, 0x01 },
1490 { 0x01, 0x00, 0x00, 0x01 },
1491 { 0x00, 0x01, 0x00, 0x01 },
1492 { 0x00, 0x00, 0x01, 0x01 },
1493 { 0x01, 0x00, 0x01, 0x01 },
1494 { 0x00, 0x01, 0x01, 0x01 },
1495 { 0x01, 0x01, 0x01, 0x01 }
1496 };
1497
1498 int id = sc->device_id;
1499
1500 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1501
1502 if (id < 0)
1503 return;
1504
1505 id %= 10;
1506 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1507}
1508
1509static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1510{
1511 /* The first 4 color/index entries match what the PS4 assigns */
1512 static const u8 color_code[7][3] = {
1513 /* Blue */ { 0x00, 0x00, 0x01 },
1514 /* Red */ { 0x01, 0x00, 0x00 },
1515 /* Green */ { 0x00, 0x01, 0x00 },
1516 /* Pink */ { 0x02, 0x00, 0x01 },
1517 /* Orange */ { 0x02, 0x01, 0x00 },
1518 /* Teal */ { 0x00, 0x01, 0x01 },
1519 /* White */ { 0x01, 0x01, 0x01 }
1520 };
1521
1522 int id = sc->device_id;
1523
1524 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1525
1526 if (id < 0)
1527 return;
1528
1529 id %= 7;
1530 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1531}
1532
1533static void buzz_set_leds(struct sony_sc *sc)
1534{
1535 struct hid_device *hdev = sc->hdev;
1536 struct list_head *report_list =
1537 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1538 struct hid_report *report = list_entry(report_list->next,
1539 struct hid_report, list);
1540 s32 *value = report->field[0]->value;
1541
1542 BUILD_BUG_ON(MAX_LEDS < 4);
1543
1544 value[0] = 0x00;
1545 value[1] = sc->led_state[0] ? 0xff : 0x00;
1546 value[2] = sc->led_state[1] ? 0xff : 0x00;
1547 value[3] = sc->led_state[2] ? 0xff : 0x00;
1548 value[4] = sc->led_state[3] ? 0xff : 0x00;
1549 value[5] = 0x00;
1550 value[6] = 0x00;
1551 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1552}
1553
1554static void sony_set_leds(struct sony_sc *sc)
1555{
1556 if (!(sc->quirks & BUZZ_CONTROLLER))
1557 schedule_work(&sc->state_worker);
1558 else
1559 buzz_set_leds(sc);
1560}
1561
1562static void sony_led_set_brightness(struct led_classdev *led,
1563 enum led_brightness value)
1564{
1565 struct device *dev = led->dev->parent;
1566 struct hid_device *hdev = to_hid_device(dev);
1567 struct sony_sc *drv_data;
1568
1569 int n;
1570 int force_update;
1571
1572 drv_data = hid_get_drvdata(hdev);
1573 if (!drv_data) {
1574 hid_err(hdev, "No device data\n");
1575 return;
1576 }
1577
1578 /*
1579 * The Sixaxis on USB will override any LED settings sent to it
1580 * and keep flashing all of the LEDs until the PS button is pressed.
1581 * Updates, even if redundant, must be always be sent to the
1582 * controller to avoid having to toggle the state of an LED just to
1583 * stop the flashing later on.
1584 */
1585 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1586
1587 for (n = 0; n < drv_data->led_count; n++) {
1588 if (led == drv_data->leds[n] && (force_update ||
1589 (value != drv_data->led_state[n] ||
1590 drv_data->led_delay_on[n] ||
1591 drv_data->led_delay_off[n]))) {
1592
1593 drv_data->led_state[n] = value;
1594
1595 /* Setting the brightness stops the blinking */
1596 drv_data->led_delay_on[n] = 0;
1597 drv_data->led_delay_off[n] = 0;
1598
1599 sony_set_leds(drv_data);
1600 break;
1601 }
1602 }
1603}
1604
1605static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1606{
1607 struct device *dev = led->dev->parent;
1608 struct hid_device *hdev = to_hid_device(dev);
1609 struct sony_sc *drv_data;
1610
1611 int n;
1612
1613 drv_data = hid_get_drvdata(hdev);
1614 if (!drv_data) {
1615 hid_err(hdev, "No device data\n");
1616 return LED_OFF;
1617 }
1618
1619 for (n = 0; n < drv_data->led_count; n++) {
1620 if (led == drv_data->leds[n])
1621 return drv_data->led_state[n];
1622 }
1623
1624 return LED_OFF;
1625}
1626
1627static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1628 unsigned long *delay_off)
1629{
1630 struct device *dev = led->dev->parent;
1631 struct hid_device *hdev = to_hid_device(dev);
1632 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1633 int n;
1634 u8 new_on, new_off;
1635
1636 if (!drv_data) {
1637 hid_err(hdev, "No device data\n");
1638 return -EINVAL;
1639 }
1640
1641 /* Max delay is 255 deciseconds or 2550 milliseconds */
1642 if (*delay_on > 2550)
1643 *delay_on = 2550;
1644 if (*delay_off > 2550)
1645 *delay_off = 2550;
1646
1647 /* Blink at 1 Hz if both values are zero */
1648 if (!*delay_on && !*delay_off)
1649 *delay_on = *delay_off = 500;
1650
1651 new_on = *delay_on / 10;
1652 new_off = *delay_off / 10;
1653
1654 for (n = 0; n < drv_data->led_count; n++) {
1655 if (led == drv_data->leds[n])
1656 break;
1657 }
1658
1659 /* This LED is not registered on this device */
1660 if (n >= drv_data->led_count)
1661 return -EINVAL;
1662
1663 /* Don't schedule work if the values didn't change */
1664 if (new_on != drv_data->led_delay_on[n] ||
1665 new_off != drv_data->led_delay_off[n]) {
1666 drv_data->led_delay_on[n] = new_on;
1667 drv_data->led_delay_off[n] = new_off;
1668 schedule_work(&drv_data->state_worker);
1669 }
1670
1671 return 0;
1672}
1673
1674static void sony_leds_remove(struct sony_sc *sc)
1675{
1676 struct led_classdev *led;
1677 int n;
1678
1679 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1680
1681 for (n = 0; n < sc->led_count; n++) {
1682 led = sc->leds[n];
1683 sc->leds[n] = NULL;
1684 if (!led)
1685 continue;
1686 led_classdev_unregister(led);
1687 kfree(led);
1688 }
1689
1690 sc->led_count = 0;
1691}
1692
1693static int sony_leds_init(struct sony_sc *sc)
1694{
1695 struct hid_device *hdev = sc->hdev;
1696 int n, ret = 0;
1697 int use_ds4_names;
1698 struct led_classdev *led;
1699 size_t name_sz;
1700 char *name;
1701 size_t name_len;
1702 const char *name_fmt;
1703 static const char * const ds4_name_str[] = { "red", "green", "blue",
1704 "global" };
1705 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1706 u8 use_hw_blink[MAX_LEDS] = { 0 };
1707
1708 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1709
1710 if (sc->quirks & BUZZ_CONTROLLER) {
1711 sc->led_count = 4;
1712 use_ds4_names = 0;
1713 name_len = strlen("::buzz#");
1714 name_fmt = "%s::buzz%d";
1715 /* Validate expected report characteristics. */
1716 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1717 return -ENODEV;
1718 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1719 dualshock4_set_leds_from_id(sc);
1720 sc->led_state[3] = 1;
1721 sc->led_count = 4;
1722 memset(max_brightness, 255, 3);
1723 use_hw_blink[3] = 1;
1724 use_ds4_names = 1;
1725 name_len = 0;
1726 name_fmt = "%s:%s";
1727 } else if (sc->quirks & MOTION_CONTROLLER) {
1728 sc->led_count = 3;
1729 memset(max_brightness, 255, 3);
1730 use_ds4_names = 1;
1731 name_len = 0;
1732 name_fmt = "%s:%s";
1733 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1734 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1735
1736 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1737 sc->led_count = 1;
1738 memset(use_hw_blink, 1, 4);
1739 use_ds4_names = 0;
1740 name_len = strlen("::sony#");
1741 name_fmt = "%s::sony%d";
1742 } else {
1743 sixaxis_set_leds_from_id(sc);
1744 sc->led_count = 4;
1745 memset(use_hw_blink, 1, 4);
1746 use_ds4_names = 0;
1747 name_len = strlen("::sony#");
1748 name_fmt = "%s::sony%d";
1749 }
1750
1751 /*
1752 * Clear LEDs as we have no way of reading their initial state. This is
1753 * only relevant if the driver is loaded after somebody actively set the
1754 * LEDs to on
1755 */
1756 sony_set_leds(sc);
1757
1758 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1759
1760 for (n = 0; n < sc->led_count; n++) {
1761
1762 if (use_ds4_names)
1763 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1764
1765 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1766 if (!led) {
1767 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1768 ret = -ENOMEM;
1769 goto error_leds;
1770 }
1771
1772 name = (void *)(&led[1]);
1773 if (use_ds4_names)
1774 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1775 ds4_name_str[n]);
1776 else
1777 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1778 led->name = name;
1779 led->brightness = sc->led_state[n];
1780 led->max_brightness = max_brightness[n];
1781 led->brightness_get = sony_led_get_brightness;
1782 led->brightness_set = sony_led_set_brightness;
1783
1784 if (use_hw_blink[n])
1785 led->blink_set = sony_led_blink_set;
1786
1787 sc->leds[n] = led;
1788
1789 ret = led_classdev_register(&hdev->dev, led);
1790 if (ret) {
1791 hid_err(hdev, "Failed to register LED %d\n", n);
1792 sc->leds[n] = NULL;
1793 kfree(led);
1794 goto error_leds;
1795 }
1796 }
1797
1798 return ret;
1799
1800error_leds:
1801 sony_leds_remove(sc);
1802
1803 return ret;
1804}
1805
1806static void sixaxis_send_output_report(struct sony_sc *sc)
1807{
1808 static const union sixaxis_output_report_01 default_report = {
1809 .buf = {
1810 0x01,
1811 0x01, 0xff, 0x00, 0xff, 0x00,
1812 0x00, 0x00, 0x00, 0x00, 0x00,
1813 0xff, 0x27, 0x10, 0x00, 0x32,
1814 0xff, 0x27, 0x10, 0x00, 0x32,
1815 0xff, 0x27, 0x10, 0x00, 0x32,
1816 0xff, 0x27, 0x10, 0x00, 0x32,
1817 0x00, 0x00, 0x00, 0x00, 0x00
1818 }
1819 };
1820 struct sixaxis_output_report *report =
1821 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1822 int n;
1823
1824 /* Initialize the report with default values */
1825 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1826
1827#ifdef CONFIG_SONY_FF
1828 report->rumble.right_motor_on = sc->right ? 1 : 0;
1829 report->rumble.left_motor_force = sc->left;
1830#endif
1831
1832 report->leds_bitmap |= sc->led_state[0] << 1;
1833 report->leds_bitmap |= sc->led_state[1] << 2;
1834 report->leds_bitmap |= sc->led_state[2] << 3;
1835 report->leds_bitmap |= sc->led_state[3] << 4;
1836
1837 /* Set flag for all leds off, required for 3rd party INTEC controller */
1838 if ((report->leds_bitmap & 0x1E) == 0)
1839 report->leds_bitmap |= 0x20;
1840
1841 /*
1842 * The LEDs in the report are indexed in reverse order to their
1843 * corresponding light on the controller.
1844 * Index 0 = LED 4, index 1 = LED 3, etc...
1845 *
1846 * In the case of both delay values being zero (blinking disabled) the
1847 * default report values should be used or the controller LED will be
1848 * always off.
1849 */
1850 for (n = 0; n < 4; n++) {
1851 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1852 report->led[3 - n].duty_off = sc->led_delay_off[n];
1853 report->led[3 - n].duty_on = sc->led_delay_on[n];
1854 }
1855 }
1856
1857 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
1858 sizeof(struct sixaxis_output_report),
1859 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1860}
1861
1862static void dualshock4_send_output_report(struct sony_sc *sc)
1863{
1864 struct hid_device *hdev = sc->hdev;
1865 u8 *buf = sc->output_report_dmabuf;
1866 int offset;
1867
1868 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1869 memset(buf, 0, DS4_REPORT_0x05_SIZE);
1870 buf[0] = 0x05;
1871 buf[1] = 0xFF;
1872 offset = 4;
1873 } else {
1874 memset(buf, 0, DS4_REPORT_0x11_SIZE);
1875 buf[0] = 0x11;
1876 buf[1] = 0x80;
1877 buf[3] = 0x0F;
1878 offset = 6;
1879 }
1880
1881#ifdef CONFIG_SONY_FF
1882 buf[offset++] = sc->right;
1883 buf[offset++] = sc->left;
1884#else
1885 offset += 2;
1886#endif
1887
1888 /* LED 3 is the global control */
1889 if (sc->led_state[3]) {
1890 buf[offset++] = sc->led_state[0];
1891 buf[offset++] = sc->led_state[1];
1892 buf[offset++] = sc->led_state[2];
1893 } else {
1894 offset += 3;
1895 }
1896
1897 /* If both delay values are zero the DualShock 4 disables blinking. */
1898 buf[offset++] = sc->led_delay_on[3];
1899 buf[offset++] = sc->led_delay_off[3];
1900
1901 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1902 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
1903 else
1904 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
1905 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1906}
1907
1908static void motion_send_output_report(struct sony_sc *sc)
1909{
1910 struct hid_device *hdev = sc->hdev;
1911 struct motion_output_report_02 *report =
1912 (struct motion_output_report_02 *)sc->output_report_dmabuf;
1913
1914 memset(report, 0, MOTION_REPORT_0x02_SIZE);
1915
1916 report->type = 0x02; /* set leds */
1917 report->r = sc->led_state[0];
1918 report->g = sc->led_state[1];
1919 report->b = sc->led_state[2];
1920
1921#ifdef CONFIG_SONY_FF
1922 report->rumble = max(sc->right, sc->left);
1923#endif
1924
1925 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
1926}
1927
1928static inline void sony_send_output_report(struct sony_sc *sc)
1929{
1930 if (sc->send_output_report)
1931 sc->send_output_report(sc);
1932}
1933
1934static void sony_state_worker(struct work_struct *work)
1935{
1936 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1937
1938 sc->send_output_report(sc);
1939}
1940
1941static int sony_allocate_output_report(struct sony_sc *sc)
1942{
1943 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1944 (sc->quirks & NAVIGATION_CONTROLLER))
1945 sc->output_report_dmabuf =
1946 kmalloc(sizeof(union sixaxis_output_report_01),
1947 GFP_KERNEL);
1948 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1949 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1950 GFP_KERNEL);
1951 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1952 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1953 GFP_KERNEL);
1954 else if (sc->quirks & MOTION_CONTROLLER)
1955 sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
1956 GFP_KERNEL);
1957 else
1958 return 0;
1959
1960 if (!sc->output_report_dmabuf)
1961 return -ENOMEM;
1962
1963 return 0;
1964}
1965
1966#ifdef CONFIG_SONY_FF
1967static int sony_play_effect(struct input_dev *dev, void *data,
1968 struct ff_effect *effect)
1969{
1970 struct hid_device *hid = input_get_drvdata(dev);
1971 struct sony_sc *sc = hid_get_drvdata(hid);
1972
1973 if (effect->type != FF_RUMBLE)
1974 return 0;
1975
1976 sc->left = effect->u.rumble.strong_magnitude / 256;
1977 sc->right = effect->u.rumble.weak_magnitude / 256;
1978
1979 schedule_work(&sc->state_worker);
1980 return 0;
1981}
1982
1983static int sony_init_ff(struct sony_sc *sc)
1984{
1985 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1986 struct hid_input, list);
1987 struct input_dev *input_dev = hidinput->input;
1988
1989 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1990 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1991}
1992
1993#else
1994static int sony_init_ff(struct sony_sc *sc)
1995{
1996 return 0;
1997}
1998
1999#endif
2000
2001static int sony_battery_get_property(struct power_supply *psy,
2002 enum power_supply_property psp,
2003 union power_supply_propval *val)
2004{
2005 struct sony_sc *sc = power_supply_get_drvdata(psy);
2006 unsigned long flags;
2007 int ret = 0;
2008 u8 battery_charging, battery_capacity, cable_state;
2009
2010 spin_lock_irqsave(&sc->lock, flags);
2011 battery_charging = sc->battery_charging;
2012 battery_capacity = sc->battery_capacity;
2013 cable_state = sc->cable_state;
2014 spin_unlock_irqrestore(&sc->lock, flags);
2015
2016 switch (psp) {
2017 case POWER_SUPPLY_PROP_PRESENT:
2018 val->intval = 1;
2019 break;
2020 case POWER_SUPPLY_PROP_SCOPE:
2021 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2022 break;
2023 case POWER_SUPPLY_PROP_CAPACITY:
2024 val->intval = battery_capacity;
2025 break;
2026 case POWER_SUPPLY_PROP_STATUS:
2027 if (battery_charging)
2028 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2029 else
2030 if (battery_capacity == 100 && cable_state)
2031 val->intval = POWER_SUPPLY_STATUS_FULL;
2032 else
2033 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2034 break;
2035 default:
2036 ret = -EINVAL;
2037 break;
2038 }
2039 return ret;
2040}
2041
2042static int sony_battery_probe(struct sony_sc *sc)
2043{
2044 struct power_supply_config psy_cfg = { .drv_data = sc, };
2045 struct hid_device *hdev = sc->hdev;
2046 int ret;
2047
2048 /*
2049 * Set the default battery level to 100% to avoid low battery warnings
2050 * if the battery is polled before the first device report is received.
2051 */
2052 sc->battery_capacity = 100;
2053
2054 sc->battery_desc.properties = sony_battery_props;
2055 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2056 sc->battery_desc.get_property = sony_battery_get_property;
2057 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2058 sc->battery_desc.use_for_apm = 0;
2059 sc->battery_desc.name = kasprintf(GFP_KERNEL,
2060 "sony_controller_battery_%pMR",
2061 sc->mac_address);
2062 if (!sc->battery_desc.name)
2063 return -ENOMEM;
2064
2065 sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
2066 &psy_cfg);
2067 if (IS_ERR(sc->battery)) {
2068 ret = PTR_ERR(sc->battery);
2069 hid_err(hdev, "Unable to register battery device\n");
2070 goto err_free;
2071 }
2072
2073 power_supply_powers(sc->battery, &hdev->dev);
2074 return 0;
2075
2076err_free:
2077 kfree(sc->battery_desc.name);
2078 sc->battery_desc.name = NULL;
2079 return ret;
2080}
2081
2082static void sony_battery_remove(struct sony_sc *sc)
2083{
2084 if (!sc->battery_desc.name)
2085 return;
2086
2087 power_supply_unregister(sc->battery);
2088 kfree(sc->battery_desc.name);
2089 sc->battery_desc.name = NULL;
2090}
2091
2092/*
2093 * If a controller is plugged in via USB while already connected via Bluetooth
2094 * it will show up as two devices. A global list of connected controllers and
2095 * their MAC addresses is maintained to ensure that a device is only connected
2096 * once.
2097 */
2098static int sony_check_add_dev_list(struct sony_sc *sc)
2099{
2100 struct sony_sc *entry;
2101 unsigned long flags;
2102 int ret;
2103
2104 spin_lock_irqsave(&sony_dev_list_lock, flags);
2105
2106 list_for_each_entry(entry, &sony_device_list, list_node) {
2107 ret = memcmp(sc->mac_address, entry->mac_address,
2108 sizeof(sc->mac_address));
2109 if (!ret) {
2110 ret = -EEXIST;
2111 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
2112 sc->mac_address);
2113 goto unlock;
2114 }
2115 }
2116
2117 ret = 0;
2118 list_add(&(sc->list_node), &sony_device_list);
2119
2120unlock:
2121 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2122 return ret;
2123}
2124
2125static void sony_remove_dev_list(struct sony_sc *sc)
2126{
2127 unsigned long flags;
2128
2129 if (sc->list_node.next) {
2130 spin_lock_irqsave(&sony_dev_list_lock, flags);
2131 list_del(&(sc->list_node));
2132 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2133 }
2134}
2135
2136static int sony_get_bt_devaddr(struct sony_sc *sc)
2137{
2138 int ret;
2139
2140 /* HIDP stores the device MAC address as a string in the uniq field. */
2141 ret = strlen(sc->hdev->uniq);
2142 if (ret != 17)
2143 return -EINVAL;
2144
2145 ret = sscanf(sc->hdev->uniq,
2146 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2147 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2148 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2149
2150 if (ret != 6)
2151 return -EINVAL;
2152
2153 return 0;
2154}
2155
2156static int sony_check_add(struct sony_sc *sc)
2157{
2158 u8 *buf = NULL;
2159 int n, ret;
2160
2161 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2162 (sc->quirks & MOTION_CONTROLLER_BT) ||
2163 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2164 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2165 /*
2166 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2167 * address from the uniq string where HIDP stores it.
2168 * As uniq cannot be guaranteed to be a MAC address in all cases
2169 * a failure of this function should not prevent the connection.
2170 */
2171 if (sony_get_bt_devaddr(sc) < 0) {
2172 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2173 return 0;
2174 }
2175 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
2176 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
2177 if (!buf)
2178 return -ENOMEM;
2179
2180 /*
2181 * The MAC address of a DS4 controller connected via USB can be
2182 * retrieved with feature report 0x81. The address begins at
2183 * offset 1.
2184 */
2185 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2186 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2187 HID_REQ_GET_REPORT);
2188
2189 if (ret != DS4_REPORT_0x81_SIZE) {
2190 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2191 ret = ret < 0 ? ret : -EINVAL;
2192 goto out_free;
2193 }
2194
2195 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2196 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2197 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2198 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2199 if (!buf)
2200 return -ENOMEM;
2201
2202 /*
2203 * The MAC address of a Sixaxis controller connected via USB can
2204 * be retrieved with feature report 0xf2. The address begins at
2205 * offset 4.
2206 */
2207 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2208 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2209 HID_REQ_GET_REPORT);
2210
2211 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2212 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2213 ret = ret < 0 ? ret : -EINVAL;
2214 goto out_free;
2215 }
2216
2217 /*
2218 * The Sixaxis device MAC in the report is big-endian and must
2219 * be byte-swapped.
2220 */
2221 for (n = 0; n < 6; n++)
2222 sc->mac_address[5-n] = buf[4+n];
2223 } else {
2224 return 0;
2225 }
2226
2227 ret = sony_check_add_dev_list(sc);
2228
2229out_free:
2230
2231 kfree(buf);
2232
2233 return ret;
2234}
2235
2236static int sony_set_device_id(struct sony_sc *sc)
2237{
2238 int ret;
2239
2240 /*
2241 * Only DualShock 4 or Sixaxis controllers get an id.
2242 * All others are set to -1.
2243 */
2244 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2245 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2246 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2247 GFP_KERNEL);
2248 if (ret < 0) {
2249 sc->device_id = -1;
2250 return ret;
2251 }
2252 sc->device_id = ret;
2253 } else {
2254 sc->device_id = -1;
2255 }
2256
2257 return 0;
2258}
2259
2260static void sony_release_device_id(struct sony_sc *sc)
2261{
2262 if (sc->device_id >= 0) {
2263 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2264 sc->device_id = -1;
2265 }
2266}
2267
2268static inline void sony_init_output_report(struct sony_sc *sc,
2269 void (*send_output_report)(struct sony_sc *))
2270{
2271 sc->send_output_report = send_output_report;
2272
2273 if (!sc->worker_initialized)
2274 INIT_WORK(&sc->state_worker, sony_state_worker);
2275
2276 sc->worker_initialized = 1;
2277}
2278
2279static inline void sony_cancel_work_sync(struct sony_sc *sc)
2280{
2281 if (sc->worker_initialized)
2282 cancel_work_sync(&sc->state_worker);
2283}
2284
2285static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2286{
2287 int ret;
2288 unsigned long quirks = id->driver_data;
2289 struct sony_sc *sc;
2290 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2291
2292 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2293 if (sc == NULL) {
2294 hid_err(hdev, "can't alloc sony descriptor\n");
2295 return -ENOMEM;
2296 }
2297
2298 spin_lock_init(&sc->lock);
2299
2300 sc->quirks = quirks;
2301 hid_set_drvdata(hdev, sc);
2302 sc->hdev = hdev;
2303
2304 ret = hid_parse(hdev);
2305 if (ret) {
2306 hid_err(hdev, "parse failed\n");
2307 return ret;
2308 }
2309
2310 if (sc->quirks & VAIO_RDESC_CONSTANT)
2311 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2312 else if (sc->quirks & SIXAXIS_CONTROLLER)
2313 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2314
2315 ret = hid_hw_start(hdev, connect_mask);
2316 if (ret) {
2317 hid_err(hdev, "hw start failed\n");
2318 return ret;
2319 }
2320
2321 ret = sony_set_device_id(sc);
2322 if (ret < 0) {
2323 hid_err(hdev, "failed to allocate the device id\n");
2324 goto err_stop;
2325 }
2326
2327 ret = sony_allocate_output_report(sc);
2328 if (ret < 0) {
2329 hid_err(hdev, "failed to allocate the output report buffer\n");
2330 goto err_stop;
2331 }
2332
2333 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2334 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2335 /*
2336 * The Sony Sixaxis does not handle HID Output Reports on the
2337 * Interrupt EP like it could, so we need to force HID Output
2338 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2339 *
2340 * There is also another issue about HID Output Reports via USB,
2341 * the Sixaxis does not want the report_id as part of the data
2342 * packet, so we have to discard buf[0] when sending the actual
2343 * control message, even for numbered reports, humpf!
2344 */
2345 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2346 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2347 ret = sixaxis_set_operational_usb(hdev);
2348 sony_init_output_report(sc, sixaxis_send_output_report);
2349 } else if ((sc->quirks & SIXAXIS_CONTROLLER_BT) ||
2350 (sc->quirks & NAVIGATION_CONTROLLER_BT)) {
2351 /*
2352 * The Sixaxis wants output reports sent on the ctrl endpoint
2353 * when connected via Bluetooth.
2354 */
2355 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2356 ret = sixaxis_set_operational_bt(hdev);
2357 sony_init_output_report(sc, sixaxis_send_output_report);
2358 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2359 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2360 /*
2361 * The DualShock 4 wants output reports sent on the ctrl
2362 * endpoint when connected via Bluetooth.
2363 */
2364 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2365 ret = dualshock4_set_operational_bt(hdev);
2366 if (ret < 0) {
2367 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2368 goto err_stop;
2369 }
2370 }
2371
2372 sony_init_output_report(sc, dualshock4_send_output_report);
2373 } else if (sc->quirks & MOTION_CONTROLLER) {
2374 sony_init_output_report(sc, motion_send_output_report);
2375 } else {
2376 ret = 0;
2377 }
2378
2379 if (ret < 0)
2380 goto err_stop;
2381
2382 ret = sony_check_add(sc);
2383 if (ret < 0)
2384 goto err_stop;
2385
2386 if (sc->quirks & SONY_LED_SUPPORT) {
2387 ret = sony_leds_init(sc);
2388 if (ret < 0)
2389 goto err_stop;
2390 }
2391
2392 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2393 ret = sony_battery_probe(sc);
2394 if (ret < 0)
2395 goto err_stop;
2396
2397 /* Open the device to receive reports with battery info */
2398 ret = hid_hw_open(hdev);
2399 if (ret < 0) {
2400 hid_err(hdev, "hw open failed\n");
2401 goto err_stop;
2402 }
2403 }
2404
2405 if (sc->quirks & SONY_FF_SUPPORT) {
2406 ret = sony_init_ff(sc);
2407 if (ret < 0)
2408 goto err_close;
2409 }
2410
2411 return 0;
2412err_close:
2413 hid_hw_close(hdev);
2414err_stop:
2415 if (sc->quirks & SONY_LED_SUPPORT)
2416 sony_leds_remove(sc);
2417 if (sc->quirks & SONY_BATTERY_SUPPORT)
2418 sony_battery_remove(sc);
2419 sony_cancel_work_sync(sc);
2420 kfree(sc->output_report_dmabuf);
2421 sony_remove_dev_list(sc);
2422 sony_release_device_id(sc);
2423 hid_hw_stop(hdev);
2424 return ret;
2425}
2426
2427static void sony_remove(struct hid_device *hdev)
2428{
2429 struct sony_sc *sc = hid_get_drvdata(hdev);
2430
2431 if (sc->quirks & SONY_LED_SUPPORT)
2432 sony_leds_remove(sc);
2433
2434 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2435 hid_hw_close(hdev);
2436 sony_battery_remove(sc);
2437 }
2438
2439 sony_cancel_work_sync(sc);
2440
2441 kfree(sc->output_report_dmabuf);
2442
2443 sony_remove_dev_list(sc);
2444
2445 sony_release_device_id(sc);
2446
2447 hid_hw_stop(hdev);
2448}
2449
2450#ifdef CONFIG_PM
2451
2452static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2453{
2454 /*
2455 * On suspend save the current LED state,
2456 * stop running force-feedback and blank the LEDS.
2457 */
2458 if (SONY_LED_SUPPORT || SONY_FF_SUPPORT) {
2459 struct sony_sc *sc = hid_get_drvdata(hdev);
2460
2461#ifdef CONFIG_SONY_FF
2462 sc->left = sc->right = 0;
2463#endif
2464
2465 memcpy(sc->resume_led_state, sc->led_state,
2466 sizeof(sc->resume_led_state));
2467 memset(sc->led_state, 0, sizeof(sc->led_state));
2468
2469 sony_send_output_report(sc);
2470 }
2471
2472 return 0;
2473}
2474
2475static int sony_resume(struct hid_device *hdev)
2476{
2477 /* Restore the state of controller LEDs on resume */
2478 if (SONY_LED_SUPPORT) {
2479 struct sony_sc *sc = hid_get_drvdata(hdev);
2480
2481 memcpy(sc->led_state, sc->resume_led_state,
2482 sizeof(sc->led_state));
2483
2484 /*
2485 * The Sixaxis and navigation controllers on USB need to be
2486 * reinitialized on resume or they won't behave properly.
2487 */
2488 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2489 (sc->quirks & NAVIGATION_CONTROLLER_USB))
2490 sixaxis_set_operational_usb(sc->hdev);
2491
2492 sony_set_leds(sc);
2493 }
2494
2495 return 0;
2496}
2497
2498#endif
2499
2500static const struct hid_device_id sony_devices[] = {
2501 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2502 .driver_data = SIXAXIS_CONTROLLER_USB },
2503 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2504 .driver_data = NAVIGATION_CONTROLLER_USB },
2505 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2506 .driver_data = NAVIGATION_CONTROLLER_BT },
2507 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2508 .driver_data = MOTION_CONTROLLER_USB },
2509 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2510 .driver_data = MOTION_CONTROLLER_BT },
2511 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2512 .driver_data = SIXAXIS_CONTROLLER_BT },
2513 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2514 .driver_data = VAIO_RDESC_CONSTANT },
2515 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2516 .driver_data = VAIO_RDESC_CONSTANT },
2517 /*
2518 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2519 * Logitech joystick from the device descriptor.
2520 */
2521 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2522 .driver_data = BUZZ_CONTROLLER },
2523 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2524 .driver_data = BUZZ_CONTROLLER },
2525 /* PS3 BD Remote Control */
2526 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2527 .driver_data = PS3REMOTE },
2528 /* Logitech Harmony Adapter for PS3 */
2529 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2530 .driver_data = PS3REMOTE },
2531 /* SMK-Link PS3 BD Remote Control */
2532 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2533 .driver_data = PS3REMOTE },
2534 /* Sony Dualshock 4 controllers for PS4 */
2535 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2536 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2537 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2538 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2539 /* Nyko Core Controller for PS3 */
2540 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2541 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2542 { }
2543};
2544MODULE_DEVICE_TABLE(hid, sony_devices);
2545
2546static struct hid_driver sony_driver = {
2547 .name = "sony",
2548 .id_table = sony_devices,
2549 .input_mapping = sony_mapping,
2550 .input_configured = sony_input_configured,
2551 .probe = sony_probe,
2552 .remove = sony_remove,
2553 .report_fixup = sony_report_fixup,
2554 .raw_event = sony_raw_event,
2555
2556#ifdef CONFIG_PM
2557 .suspend = sony_suspend,
2558 .resume = sony_resume,
2559 .reset_resume = sony_resume,
2560#endif
2561};
2562
2563static int __init sony_init(void)
2564{
2565 dbg_hid("Sony:%s\n", __func__);
2566
2567 return hid_register_driver(&sony_driver);
2568}
2569
2570static void __exit sony_exit(void)
2571{
2572 dbg_hid("Sony:%s\n", __func__);
2573
2574 hid_unregister_driver(&sony_driver);
2575 ida_destroy(&sony_device_id_allocator);
2576}
2577module_init(sony_init);
2578module_exit(sony_exit);
2579
2580MODULE_LICENSE("GPL");