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