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 static spinlock_t sony_dev_list_lock; 802 static LIST_HEAD(sony_device_list); 803 static DEFINE_IDA(sony_device_id_allocator); 804 805 struct sony_sc { 806 spinlock_t lock; 807 struct list_head list_node; 808 struct hid_device *hdev; 809 struct led_classdev *leds[MAX_LEDS]; 810 unsigned long quirks; 811 struct work_struct state_worker; 812 struct power_supply battery; 813 int device_id; 814 815 #ifdef CONFIG_SONY_FF 816 __u8 left; 817 __u8 right; 818 #endif 819 820 __u8 mac_address[6]; 821 __u8 worker_initialized; 822 __u8 cable_state; 823 __u8 battery_charging; 824 __u8 battery_capacity; 825 __u8 led_state[MAX_LEDS]; 826 __u8 led_delay_on[MAX_LEDS]; 827 __u8 led_delay_off[MAX_LEDS]; 828 __u8 led_count; 829 }; 830 831 static __u8 *sixaxis_fixup(struct hid_device *hdev, __u8 *rdesc, 832 unsigned int *rsize) 833 { 834 *rsize = sizeof(sixaxis_rdesc); 835 return sixaxis_rdesc; 836 } 837 838 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc, 839 unsigned int *rsize) 840 { 841 *rsize = sizeof(ps3remote_rdesc); 842 return ps3remote_rdesc; 843 } 844 845 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi, 846 struct hid_field *field, struct hid_usage *usage, 847 unsigned long **bit, int *max) 848 { 849 unsigned int key = usage->hid & HID_USAGE; 850 851 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 852 return -1; 853 854 switch (usage->collection_index) { 855 case 1: 856 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons)) 857 return -1; 858 859 key = ps3remote_keymap_joypad_buttons[key]; 860 if (!key) 861 return -1; 862 break; 863 case 2: 864 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons)) 865 return -1; 866 867 key = ps3remote_keymap_remote_buttons[key]; 868 if (!key) 869 return -1; 870 break; 871 default: 872 return -1; 873 } 874 875 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 876 return 1; 877 } 878 879 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc, 880 unsigned int *rsize) 881 { 882 struct sony_sc *sc = hid_get_drvdata(hdev); 883 884 /* 885 * Some Sony RF receivers wrongly declare the mouse pointer as a 886 * a constant non-data variable. 887 */ 888 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 && 889 /* usage page: generic desktop controls */ 890 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */ 891 /* usage: mouse */ 892 rdesc[2] == 0x09 && rdesc[3] == 0x02 && 893 /* input (usage page for x,y axes): constant, variable, relative */ 894 rdesc[54] == 0x81 && rdesc[55] == 0x07) { 895 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n"); 896 /* input: data, variable, relative */ 897 rdesc[55] = 0x06; 898 } 899 900 /* 901 * The default Dualshock 4 USB descriptor doesn't assign 902 * the gyroscope values to corresponding axes so we need a 903 * modified one. 904 */ 905 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) { 906 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n"); 907 rdesc = dualshock4_usb_rdesc; 908 *rsize = sizeof(dualshock4_usb_rdesc); 909 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) { 910 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n"); 911 rdesc = dualshock4_bt_rdesc; 912 *rsize = sizeof(dualshock4_bt_rdesc); 913 } 914 915 if (sc->quirks & SIXAXIS_CONTROLLER) 916 return sixaxis_fixup(hdev, rdesc, rsize); 917 918 if (sc->quirks & PS3REMOTE) 919 return ps3remote_fixup(hdev, rdesc, rsize); 920 921 return rdesc; 922 } 923 924 static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size) 925 { 926 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 }; 927 unsigned long flags; 928 __u8 cable_state, battery_capacity, battery_charging; 929 930 /* 931 * The sixaxis is charging if the battery value is 0xee 932 * and it is fully charged if the value is 0xef. 933 * It does not report the actual level while charging so it 934 * is set to 100% while charging is in progress. 935 */ 936 if (rd[30] >= 0xee) { 937 battery_capacity = 100; 938 battery_charging = !(rd[30] & 0x01); 939 cable_state = 1; 940 } else { 941 __u8 index = rd[30] <= 5 ? rd[30] : 5; 942 battery_capacity = sixaxis_battery_capacity[index]; 943 battery_charging = 0; 944 cable_state = 0; 945 } 946 947 spin_lock_irqsave(&sc->lock, flags); 948 sc->cable_state = cable_state; 949 sc->battery_capacity = battery_capacity; 950 sc->battery_charging = battery_charging; 951 spin_unlock_irqrestore(&sc->lock, flags); 952 } 953 954 static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size) 955 { 956 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next, 957 struct hid_input, list); 958 struct input_dev *input_dev = hidinput->input; 959 unsigned long flags; 960 int n, offset; 961 __u8 cable_state, battery_capacity, battery_charging; 962 963 /* 964 * Battery and touchpad data starts at byte 30 in the USB report and 965 * 32 in Bluetooth report. 966 */ 967 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32; 968 969 /* 970 * The lower 4 bits of byte 30 contain the battery level 971 * and the 5th bit contains the USB cable state. 972 */ 973 cable_state = (rd[offset] >> 4) & 0x01; 974 battery_capacity = rd[offset] & 0x0F; 975 976 /* 977 * When a USB power source is connected the battery level ranges from 978 * 0 to 10, and when running on battery power it ranges from 0 to 9. 979 * A battery level above 10 when plugged in means charge completed. 980 */ 981 if (!cable_state || battery_capacity > 10) 982 battery_charging = 0; 983 else 984 battery_charging = 1; 985 986 if (!cable_state) 987 battery_capacity++; 988 if (battery_capacity > 10) 989 battery_capacity = 10; 990 991 battery_capacity *= 10; 992 993 spin_lock_irqsave(&sc->lock, flags); 994 sc->cable_state = cable_state; 995 sc->battery_capacity = battery_capacity; 996 sc->battery_charging = battery_charging; 997 spin_unlock_irqrestore(&sc->lock, flags); 998 999 offset += 5; 1000 1001 /* 1002 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB 1003 * and 37 on Bluetooth. 1004 * The first 7 bits of the first byte is a counter and bit 8 is a touch 1005 * indicator that is 0 when pressed and 1 when not pressed. 1006 * The next 3 bytes are two 12 bit touch coordinates, X and Y. 1007 * The data for the second touch is in the same format and immediatly 1008 * follows the data for the first. 1009 */ 1010 for (n = 0; n < 2; n++) { 1011 __u16 x, y; 1012 1013 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8); 1014 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4); 1015 1016 input_mt_slot(input_dev, n); 1017 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1018 !(rd[offset] >> 7)); 1019 input_report_abs(input_dev, ABS_MT_POSITION_X, x); 1020 input_report_abs(input_dev, ABS_MT_POSITION_Y, y); 1021 1022 offset += 4; 1023 } 1024 } 1025 1026 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report, 1027 __u8 *rd, int size) 1028 { 1029 struct sony_sc *sc = hid_get_drvdata(hdev); 1030 1031 /* 1032 * Sixaxis HID report has acclerometers/gyro with MSByte first, this 1033 * has to be BYTE_SWAPPED before passing up to joystick interface 1034 */ 1035 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) { 1036 swap(rd[41], rd[42]); 1037 swap(rd[43], rd[44]); 1038 swap(rd[45], rd[46]); 1039 swap(rd[47], rd[48]); 1040 1041 sixaxis_parse_report(sc, rd, size); 1042 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 && 1043 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) 1044 && rd[0] == 0x11 && size == 78)) { 1045 dualshock4_parse_report(sc, rd, size); 1046 } 1047 1048 return 0; 1049 } 1050 1051 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi, 1052 struct hid_field *field, struct hid_usage *usage, 1053 unsigned long **bit, int *max) 1054 { 1055 struct sony_sc *sc = hid_get_drvdata(hdev); 1056 1057 if (sc->quirks & BUZZ_CONTROLLER) { 1058 unsigned int key = usage->hid & HID_USAGE; 1059 1060 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 1061 return -1; 1062 1063 switch (usage->collection_index) { 1064 case 1: 1065 if (key >= ARRAY_SIZE(buzz_keymap)) 1066 return -1; 1067 1068 key = buzz_keymap[key]; 1069 if (!key) 1070 return -1; 1071 break; 1072 default: 1073 return -1; 1074 } 1075 1076 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 1077 return 1; 1078 } 1079 1080 if (sc->quirks & PS3REMOTE) 1081 return ps3remote_mapping(hdev, hi, field, usage, bit, max); 1082 1083 /* Let hid-core decide for the others */ 1084 return 0; 1085 } 1086 1087 static int sony_register_touchpad(struct hid_input *hi, int touch_count, 1088 int w, int h) 1089 { 1090 struct input_dev *input_dev = hi->input; 1091 int ret; 1092 1093 ret = input_mt_init_slots(input_dev, touch_count, 0); 1094 if (ret < 0) 1095 return ret; 1096 1097 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0); 1098 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0); 1099 1100 return 0; 1101 } 1102 1103 static void sony_input_configured(struct hid_device *hdev, 1104 struct hid_input *hidinput) 1105 { 1106 struct sony_sc *sc = hid_get_drvdata(hdev); 1107 1108 /* 1109 * The Dualshock 4 touchpad supports 2 touches and has a 1110 * resolution of 1920x942 (44.86 dots/mm). 1111 */ 1112 if (sc->quirks & DUALSHOCK4_CONTROLLER) { 1113 if (sony_register_touchpad(hidinput, 2, 1920, 942) != 0) 1114 hid_err(sc->hdev, 1115 "Unable to initialize multi-touch slots\n"); 1116 } 1117 } 1118 1119 /* 1120 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller 1121 * to "operational". Without this, the ps3 controller will not report any 1122 * events. 1123 */ 1124 static int sixaxis_set_operational_usb(struct hid_device *hdev) 1125 { 1126 int ret; 1127 char *buf = kmalloc(18, GFP_KERNEL); 1128 1129 if (!buf) 1130 return -ENOMEM; 1131 1132 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT, 1133 HID_REQ_GET_REPORT); 1134 1135 if (ret < 0) 1136 hid_err(hdev, "can't set operational mode\n"); 1137 1138 kfree(buf); 1139 1140 return ret; 1141 } 1142 1143 static int sixaxis_set_operational_bt(struct hid_device *hdev) 1144 { 1145 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 }; 1146 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf), 1147 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 1148 } 1149 1150 /* 1151 * Requesting feature report 0x02 in Bluetooth mode changes the state of the 1152 * controller so that it sends full input reports of type 0x11. 1153 */ 1154 static int dualshock4_set_operational_bt(struct hid_device *hdev) 1155 { 1156 __u8 buf[37] = { 0 }; 1157 1158 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf), 1159 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1160 } 1161 1162 static void sixaxis_set_leds_from_id(int id, __u8 values[MAX_LEDS]) 1163 { 1164 static const __u8 sixaxis_leds[10][4] = { 1165 { 0x01, 0x00, 0x00, 0x00 }, 1166 { 0x00, 0x01, 0x00, 0x00 }, 1167 { 0x00, 0x00, 0x01, 0x00 }, 1168 { 0x00, 0x00, 0x00, 0x01 }, 1169 { 0x01, 0x00, 0x00, 0x01 }, 1170 { 0x00, 0x01, 0x00, 0x01 }, 1171 { 0x00, 0x00, 0x01, 0x01 }, 1172 { 0x01, 0x00, 0x01, 0x01 }, 1173 { 0x00, 0x01, 0x01, 0x01 }, 1174 { 0x01, 0x01, 0x01, 0x01 } 1175 }; 1176 1177 BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0])); 1178 1179 if (id < 0) 1180 return; 1181 1182 id %= 10; 1183 memcpy(values, sixaxis_leds[id], sizeof(sixaxis_leds[id])); 1184 } 1185 1186 static void dualshock4_set_leds_from_id(int id, __u8 values[MAX_LEDS]) 1187 { 1188 /* The first 4 color/index entries match what the PS4 assigns */ 1189 static const __u8 color_code[7][3] = { 1190 /* Blue */ { 0x00, 0x00, 0x01 }, 1191 /* Red */ { 0x01, 0x00, 0x00 }, 1192 /* Green */ { 0x00, 0x01, 0x00 }, 1193 /* Pink */ { 0x02, 0x00, 0x01 }, 1194 /* Orange */ { 0x02, 0x01, 0x00 }, 1195 /* Teal */ { 0x00, 0x01, 0x01 }, 1196 /* White */ { 0x01, 0x01, 0x01 } 1197 }; 1198 1199 BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0])); 1200 1201 if (id < 0) 1202 return; 1203 1204 id %= 7; 1205 memcpy(values, color_code[id], sizeof(color_code[id])); 1206 } 1207 1208 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds) 1209 { 1210 struct list_head *report_list = 1211 &hdev->report_enum[HID_OUTPUT_REPORT].report_list; 1212 struct hid_report *report = list_entry(report_list->next, 1213 struct hid_report, list); 1214 __s32 *value = report->field[0]->value; 1215 1216 value[0] = 0x00; 1217 value[1] = leds[0] ? 0xff : 0x00; 1218 value[2] = leds[1] ? 0xff : 0x00; 1219 value[3] = leds[2] ? 0xff : 0x00; 1220 value[4] = leds[3] ? 0xff : 0x00; 1221 value[5] = 0x00; 1222 value[6] = 0x00; 1223 hid_hw_request(hdev, report, HID_REQ_SET_REPORT); 1224 } 1225 1226 static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count) 1227 { 1228 int n; 1229 1230 BUG_ON(count > MAX_LEDS); 1231 1232 if (sc->quirks & BUZZ_CONTROLLER && count == 4) { 1233 buzz_set_leds(sc->hdev, leds); 1234 } else { 1235 for (n = 0; n < count; n++) 1236 sc->led_state[n] = leds[n]; 1237 schedule_work(&sc->state_worker); 1238 } 1239 } 1240 1241 static void sony_led_set_brightness(struct led_classdev *led, 1242 enum led_brightness value) 1243 { 1244 struct device *dev = led->dev->parent; 1245 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 1246 struct sony_sc *drv_data; 1247 1248 int n; 1249 int force_update; 1250 1251 drv_data = hid_get_drvdata(hdev); 1252 if (!drv_data) { 1253 hid_err(hdev, "No device data\n"); 1254 return; 1255 } 1256 1257 /* 1258 * The Sixaxis on USB will override any LED settings sent to it 1259 * and keep flashing all of the LEDs until the PS button is pressed. 1260 * Updates, even if redundant, must be always be sent to the 1261 * controller to avoid having to toggle the state of an LED just to 1262 * stop the flashing later on. 1263 */ 1264 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB); 1265 1266 for (n = 0; n < drv_data->led_count; n++) { 1267 if (led == drv_data->leds[n] && (force_update || 1268 (value != drv_data->led_state[n] || 1269 drv_data->led_delay_on[n] || 1270 drv_data->led_delay_off[n]))) { 1271 1272 drv_data->led_state[n] = value; 1273 1274 /* Setting the brightness stops the blinking */ 1275 drv_data->led_delay_on[n] = 0; 1276 drv_data->led_delay_off[n] = 0; 1277 1278 sony_set_leds(drv_data, drv_data->led_state, 1279 drv_data->led_count); 1280 break; 1281 } 1282 } 1283 } 1284 1285 static enum led_brightness sony_led_get_brightness(struct led_classdev *led) 1286 { 1287 struct device *dev = led->dev->parent; 1288 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 1289 struct sony_sc *drv_data; 1290 1291 int n; 1292 1293 drv_data = hid_get_drvdata(hdev); 1294 if (!drv_data) { 1295 hid_err(hdev, "No device data\n"); 1296 return LED_OFF; 1297 } 1298 1299 for (n = 0; n < drv_data->led_count; n++) { 1300 if (led == drv_data->leds[n]) 1301 return drv_data->led_state[n]; 1302 } 1303 1304 return LED_OFF; 1305 } 1306 1307 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on, 1308 unsigned long *delay_off) 1309 { 1310 struct device *dev = led->dev->parent; 1311 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 1312 struct sony_sc *drv_data = hid_get_drvdata(hdev); 1313 int n; 1314 __u8 new_on, new_off; 1315 1316 if (!drv_data) { 1317 hid_err(hdev, "No device data\n"); 1318 return -EINVAL; 1319 } 1320 1321 /* Max delay is 255 deciseconds or 2550 milliseconds */ 1322 if (*delay_on > 2550) 1323 *delay_on = 2550; 1324 if (*delay_off > 2550) 1325 *delay_off = 2550; 1326 1327 /* Blink at 1 Hz if both values are zero */ 1328 if (!*delay_on && !*delay_off) 1329 *delay_on = *delay_off = 500; 1330 1331 new_on = *delay_on / 10; 1332 new_off = *delay_off / 10; 1333 1334 for (n = 0; n < drv_data->led_count; n++) { 1335 if (led == drv_data->leds[n]) 1336 break; 1337 } 1338 1339 /* This LED is not registered on this device */ 1340 if (n >= drv_data->led_count) 1341 return -EINVAL; 1342 1343 /* Don't schedule work if the values didn't change */ 1344 if (new_on != drv_data->led_delay_on[n] || 1345 new_off != drv_data->led_delay_off[n]) { 1346 drv_data->led_delay_on[n] = new_on; 1347 drv_data->led_delay_off[n] = new_off; 1348 schedule_work(&drv_data->state_worker); 1349 } 1350 1351 return 0; 1352 } 1353 1354 static void sony_leds_remove(struct sony_sc *sc) 1355 { 1356 struct led_classdev *led; 1357 int n; 1358 1359 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT)); 1360 1361 for (n = 0; n < sc->led_count; n++) { 1362 led = sc->leds[n]; 1363 sc->leds[n] = NULL; 1364 if (!led) 1365 continue; 1366 led_classdev_unregister(led); 1367 kfree(led); 1368 } 1369 1370 sc->led_count = 0; 1371 } 1372 1373 static int sony_leds_init(struct sony_sc *sc) 1374 { 1375 struct hid_device *hdev = sc->hdev; 1376 int n, ret = 0; 1377 int use_ds4_names; 1378 struct led_classdev *led; 1379 size_t name_sz; 1380 char *name; 1381 size_t name_len; 1382 const char *name_fmt; 1383 static const char * const ds4_name_str[] = { "red", "green", "blue", 1384 "global" }; 1385 __u8 initial_values[MAX_LEDS] = { 0 }; 1386 __u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 }; 1387 __u8 use_hw_blink[MAX_LEDS] = { 0 }; 1388 1389 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT)); 1390 1391 if (sc->quirks & BUZZ_CONTROLLER) { 1392 sc->led_count = 4; 1393 use_ds4_names = 0; 1394 name_len = strlen("::buzz#"); 1395 name_fmt = "%s::buzz%d"; 1396 /* Validate expected report characteristics. */ 1397 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7)) 1398 return -ENODEV; 1399 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) { 1400 dualshock4_set_leds_from_id(sc->device_id, initial_values); 1401 initial_values[3] = 1; 1402 sc->led_count = 4; 1403 memset(max_brightness, 255, 3); 1404 use_hw_blink[3] = 1; 1405 use_ds4_names = 1; 1406 name_len = 0; 1407 name_fmt = "%s:%s"; 1408 } else { 1409 sixaxis_set_leds_from_id(sc->device_id, initial_values); 1410 sc->led_count = 4; 1411 memset(use_hw_blink, 1, 4); 1412 use_ds4_names = 0; 1413 name_len = strlen("::sony#"); 1414 name_fmt = "%s::sony%d"; 1415 } 1416 1417 /* 1418 * Clear LEDs as we have no way of reading their initial state. This is 1419 * only relevant if the driver is loaded after somebody actively set the 1420 * LEDs to on 1421 */ 1422 sony_set_leds(sc, initial_values, sc->led_count); 1423 1424 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1; 1425 1426 for (n = 0; n < sc->led_count; n++) { 1427 1428 if (use_ds4_names) 1429 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2; 1430 1431 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL); 1432 if (!led) { 1433 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n); 1434 ret = -ENOMEM; 1435 goto error_leds; 1436 } 1437 1438 name = (void *)(&led[1]); 1439 if (use_ds4_names) 1440 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), 1441 ds4_name_str[n]); 1442 else 1443 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1); 1444 led->name = name; 1445 led->brightness = initial_values[n]; 1446 led->max_brightness = max_brightness[n]; 1447 led->brightness_get = sony_led_get_brightness; 1448 led->brightness_set = sony_led_set_brightness; 1449 1450 if (use_hw_blink[n]) 1451 led->blink_set = sony_led_blink_set; 1452 1453 sc->leds[n] = led; 1454 1455 ret = led_classdev_register(&hdev->dev, led); 1456 if (ret) { 1457 hid_err(hdev, "Failed to register LED %d\n", n); 1458 sc->leds[n] = NULL; 1459 kfree(led); 1460 goto error_leds; 1461 } 1462 } 1463 1464 return ret; 1465 1466 error_leds: 1467 sony_leds_remove(sc); 1468 1469 return ret; 1470 } 1471 1472 static void sixaxis_state_worker(struct work_struct *work) 1473 { 1474 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker); 1475 int n; 1476 union sixaxis_output_report_01 report = { 1477 .buf = { 1478 0x01, 1479 0x00, 0xff, 0x00, 0xff, 0x00, 1480 0x00, 0x00, 0x00, 0x00, 0x00, 1481 0xff, 0x27, 0x10, 0x00, 0x32, 1482 0xff, 0x27, 0x10, 0x00, 0x32, 1483 0xff, 0x27, 0x10, 0x00, 0x32, 1484 0xff, 0x27, 0x10, 0x00, 0x32, 1485 0x00, 0x00, 0x00, 0x00, 0x00 1486 } 1487 }; 1488 1489 #ifdef CONFIG_SONY_FF 1490 report.data.rumble.right_motor_on = sc->right ? 1 : 0; 1491 report.data.rumble.left_motor_force = sc->left; 1492 #endif 1493 1494 report.data.leds_bitmap |= sc->led_state[0] << 1; 1495 report.data.leds_bitmap |= sc->led_state[1] << 2; 1496 report.data.leds_bitmap |= sc->led_state[2] << 3; 1497 report.data.leds_bitmap |= sc->led_state[3] << 4; 1498 1499 /* Set flag for all leds off, required for 3rd party INTEC controller */ 1500 if ((report.data.leds_bitmap & 0x1E) == 0) 1501 report.data.leds_bitmap |= 0x20; 1502 1503 /* 1504 * The LEDs in the report are indexed in reverse order to their 1505 * corresponding light on the controller. 1506 * Index 0 = LED 4, index 1 = LED 3, etc... 1507 * 1508 * In the case of both delay values being zero (blinking disabled) the 1509 * default report values should be used or the controller LED will be 1510 * always off. 1511 */ 1512 for (n = 0; n < 4; n++) { 1513 if (sc->led_delay_on[n] || sc->led_delay_off[n]) { 1514 report.data.led[3 - n].duty_off = sc->led_delay_off[n]; 1515 report.data.led[3 - n].duty_on = sc->led_delay_on[n]; 1516 } 1517 } 1518 1519 hid_hw_raw_request(sc->hdev, report.data.report_id, report.buf, 1520 sizeof(report), HID_OUTPUT_REPORT, HID_REQ_SET_REPORT); 1521 } 1522 1523 static void dualshock4_state_worker(struct work_struct *work) 1524 { 1525 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker); 1526 struct hid_device *hdev = sc->hdev; 1527 int offset; 1528 1529 __u8 buf[78] = { 0 }; 1530 1531 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) { 1532 buf[0] = 0x05; 1533 buf[1] = 0xFF; 1534 offset = 4; 1535 } else { 1536 buf[0] = 0x11; 1537 buf[1] = 0xB0; 1538 buf[3] = 0x0F; 1539 offset = 6; 1540 } 1541 1542 #ifdef CONFIG_SONY_FF 1543 buf[offset++] = sc->right; 1544 buf[offset++] = sc->left; 1545 #else 1546 offset += 2; 1547 #endif 1548 1549 /* LED 3 is the global control */ 1550 if (sc->led_state[3]) { 1551 buf[offset++] = sc->led_state[0]; 1552 buf[offset++] = sc->led_state[1]; 1553 buf[offset++] = sc->led_state[2]; 1554 } else { 1555 offset += 3; 1556 } 1557 1558 /* If both delay values are zero the DualShock 4 disables blinking. */ 1559 buf[offset++] = sc->led_delay_on[3]; 1560 buf[offset++] = sc->led_delay_off[3]; 1561 1562 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) 1563 hid_hw_output_report(hdev, buf, 32); 1564 else 1565 hid_hw_raw_request(hdev, 0x11, buf, 78, 1566 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT); 1567 } 1568 1569 #ifdef CONFIG_SONY_FF 1570 static int sony_play_effect(struct input_dev *dev, void *data, 1571 struct ff_effect *effect) 1572 { 1573 struct hid_device *hid = input_get_drvdata(dev); 1574 struct sony_sc *sc = hid_get_drvdata(hid); 1575 1576 if (effect->type != FF_RUMBLE) 1577 return 0; 1578 1579 sc->left = effect->u.rumble.strong_magnitude / 256; 1580 sc->right = effect->u.rumble.weak_magnitude / 256; 1581 1582 schedule_work(&sc->state_worker); 1583 return 0; 1584 } 1585 1586 static int sony_init_ff(struct sony_sc *sc) 1587 { 1588 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next, 1589 struct hid_input, list); 1590 struct input_dev *input_dev = hidinput->input; 1591 1592 input_set_capability(input_dev, EV_FF, FF_RUMBLE); 1593 return input_ff_create_memless(input_dev, NULL, sony_play_effect); 1594 } 1595 1596 #else 1597 static int sony_init_ff(struct sony_sc *sc) 1598 { 1599 return 0; 1600 } 1601 1602 #endif 1603 1604 static int sony_battery_get_property(struct power_supply *psy, 1605 enum power_supply_property psp, 1606 union power_supply_propval *val) 1607 { 1608 struct sony_sc *sc = container_of(psy, struct sony_sc, battery); 1609 unsigned long flags; 1610 int ret = 0; 1611 u8 battery_charging, battery_capacity, cable_state; 1612 1613 spin_lock_irqsave(&sc->lock, flags); 1614 battery_charging = sc->battery_charging; 1615 battery_capacity = sc->battery_capacity; 1616 cable_state = sc->cable_state; 1617 spin_unlock_irqrestore(&sc->lock, flags); 1618 1619 switch (psp) { 1620 case POWER_SUPPLY_PROP_PRESENT: 1621 val->intval = 1; 1622 break; 1623 case POWER_SUPPLY_PROP_SCOPE: 1624 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 1625 break; 1626 case POWER_SUPPLY_PROP_CAPACITY: 1627 val->intval = battery_capacity; 1628 break; 1629 case POWER_SUPPLY_PROP_STATUS: 1630 if (battery_charging) 1631 val->intval = POWER_SUPPLY_STATUS_CHARGING; 1632 else 1633 if (battery_capacity == 100 && cable_state) 1634 val->intval = POWER_SUPPLY_STATUS_FULL; 1635 else 1636 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 1637 break; 1638 default: 1639 ret = -EINVAL; 1640 break; 1641 } 1642 return ret; 1643 } 1644 1645 static int sony_battery_probe(struct sony_sc *sc) 1646 { 1647 struct hid_device *hdev = sc->hdev; 1648 int ret; 1649 1650 /* 1651 * Set the default battery level to 100% to avoid low battery warnings 1652 * if the battery is polled before the first device report is received. 1653 */ 1654 sc->battery_capacity = 100; 1655 1656 sc->battery.properties = sony_battery_props; 1657 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props); 1658 sc->battery.get_property = sony_battery_get_property; 1659 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY; 1660 sc->battery.use_for_apm = 0; 1661 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR", 1662 sc->mac_address); 1663 if (!sc->battery.name) 1664 return -ENOMEM; 1665 1666 ret = power_supply_register(&hdev->dev, &sc->battery); 1667 if (ret) { 1668 hid_err(hdev, "Unable to register battery device\n"); 1669 goto err_free; 1670 } 1671 1672 power_supply_powers(&sc->battery, &hdev->dev); 1673 return 0; 1674 1675 err_free: 1676 kfree(sc->battery.name); 1677 sc->battery.name = NULL; 1678 return ret; 1679 } 1680 1681 static void sony_battery_remove(struct sony_sc *sc) 1682 { 1683 if (!sc->battery.name) 1684 return; 1685 1686 power_supply_unregister(&sc->battery); 1687 kfree(sc->battery.name); 1688 sc->battery.name = NULL; 1689 } 1690 1691 /* 1692 * If a controller is plugged in via USB while already connected via Bluetooth 1693 * it will show up as two devices. A global list of connected controllers and 1694 * their MAC addresses is maintained to ensure that a device is only connected 1695 * once. 1696 */ 1697 static int sony_check_add_dev_list(struct sony_sc *sc) 1698 { 1699 struct sony_sc *entry; 1700 unsigned long flags; 1701 int ret; 1702 1703 spin_lock_irqsave(&sony_dev_list_lock, flags); 1704 1705 list_for_each_entry(entry, &sony_device_list, list_node) { 1706 ret = memcmp(sc->mac_address, entry->mac_address, 1707 sizeof(sc->mac_address)); 1708 if (!ret) { 1709 ret = -EEXIST; 1710 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n", 1711 sc->mac_address); 1712 goto unlock; 1713 } 1714 } 1715 1716 ret = 0; 1717 list_add(&(sc->list_node), &sony_device_list); 1718 1719 unlock: 1720 spin_unlock_irqrestore(&sony_dev_list_lock, flags); 1721 return ret; 1722 } 1723 1724 static void sony_remove_dev_list(struct sony_sc *sc) 1725 { 1726 unsigned long flags; 1727 1728 if (sc->list_node.next) { 1729 spin_lock_irqsave(&sony_dev_list_lock, flags); 1730 list_del(&(sc->list_node)); 1731 spin_unlock_irqrestore(&sony_dev_list_lock, flags); 1732 } 1733 } 1734 1735 static int sony_get_bt_devaddr(struct sony_sc *sc) 1736 { 1737 int ret; 1738 1739 /* HIDP stores the device MAC address as a string in the uniq field. */ 1740 ret = strlen(sc->hdev->uniq); 1741 if (ret != 17) 1742 return -EINVAL; 1743 1744 ret = sscanf(sc->hdev->uniq, 1745 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx", 1746 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3], 1747 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]); 1748 1749 if (ret != 6) 1750 return -EINVAL; 1751 1752 return 0; 1753 } 1754 1755 static int sony_check_add(struct sony_sc *sc) 1756 { 1757 int n, ret; 1758 1759 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) || 1760 (sc->quirks & SIXAXIS_CONTROLLER_BT)) { 1761 /* 1762 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC 1763 * address from the uniq string where HIDP stores it. 1764 * As uniq cannot be guaranteed to be a MAC address in all cases 1765 * a failure of this function should not prevent the connection. 1766 */ 1767 if (sony_get_bt_devaddr(sc) < 0) { 1768 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n"); 1769 return 0; 1770 } 1771 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) { 1772 __u8 buf[7]; 1773 1774 /* 1775 * The MAC address of a DS4 controller connected via USB can be 1776 * retrieved with feature report 0x81. The address begins at 1777 * offset 1. 1778 */ 1779 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf), 1780 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1781 1782 if (ret != 7) { 1783 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n"); 1784 return ret < 0 ? ret : -EINVAL; 1785 } 1786 1787 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address)); 1788 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 1789 __u8 buf[18]; 1790 1791 /* 1792 * The MAC address of a Sixaxis controller connected via USB can 1793 * be retrieved with feature report 0xf2. The address begins at 1794 * offset 4. 1795 */ 1796 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf), 1797 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1798 1799 if (ret != 18) { 1800 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n"); 1801 return ret < 0 ? ret : -EINVAL; 1802 } 1803 1804 /* 1805 * The Sixaxis device MAC in the report is big-endian and must 1806 * be byte-swapped. 1807 */ 1808 for (n = 0; n < 6; n++) 1809 sc->mac_address[5-n] = buf[4+n]; 1810 } else { 1811 return 0; 1812 } 1813 1814 return sony_check_add_dev_list(sc); 1815 } 1816 1817 static int sony_set_device_id(struct sony_sc *sc) 1818 { 1819 int ret; 1820 1821 /* 1822 * Only DualShock 4 or Sixaxis controllers get an id. 1823 * All others are set to -1. 1824 */ 1825 if ((sc->quirks & SIXAXIS_CONTROLLER) || 1826 (sc->quirks & DUALSHOCK4_CONTROLLER)) { 1827 ret = ida_simple_get(&sony_device_id_allocator, 0, 0, 1828 GFP_KERNEL); 1829 if (ret < 0) { 1830 sc->device_id = -1; 1831 return ret; 1832 } 1833 sc->device_id = ret; 1834 } else { 1835 sc->device_id = -1; 1836 } 1837 1838 return 0; 1839 } 1840 1841 static void sony_release_device_id(struct sony_sc *sc) 1842 { 1843 if (sc->device_id >= 0) { 1844 ida_simple_remove(&sony_device_id_allocator, sc->device_id); 1845 sc->device_id = -1; 1846 } 1847 } 1848 1849 static inline void sony_init_work(struct sony_sc *sc, 1850 void (*worker)(struct work_struct *)) 1851 { 1852 if (!sc->worker_initialized) 1853 INIT_WORK(&sc->state_worker, worker); 1854 1855 sc->worker_initialized = 1; 1856 } 1857 1858 static inline void sony_cancel_work_sync(struct sony_sc *sc) 1859 { 1860 if (sc->worker_initialized) 1861 cancel_work_sync(&sc->state_worker); 1862 } 1863 1864 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) 1865 { 1866 int ret; 1867 unsigned long quirks = id->driver_data; 1868 struct sony_sc *sc; 1869 unsigned int connect_mask = HID_CONNECT_DEFAULT; 1870 1871 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL); 1872 if (sc == NULL) { 1873 hid_err(hdev, "can't alloc sony descriptor\n"); 1874 return -ENOMEM; 1875 } 1876 1877 sc->quirks = quirks; 1878 hid_set_drvdata(hdev, sc); 1879 sc->hdev = hdev; 1880 1881 ret = hid_parse(hdev); 1882 if (ret) { 1883 hid_err(hdev, "parse failed\n"); 1884 return ret; 1885 } 1886 1887 if (sc->quirks & VAIO_RDESC_CONSTANT) 1888 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 1889 else if (sc->quirks & SIXAXIS_CONTROLLER) 1890 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 1891 1892 ret = hid_hw_start(hdev, connect_mask); 1893 if (ret) { 1894 hid_err(hdev, "hw start failed\n"); 1895 return ret; 1896 } 1897 1898 ret = sony_set_device_id(sc); 1899 if (ret < 0) { 1900 hid_err(hdev, "failed to allocate the device id\n"); 1901 goto err_stop; 1902 } 1903 1904 if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 1905 /* 1906 * The Sony Sixaxis does not handle HID Output Reports on the 1907 * Interrupt EP like it could, so we need to force HID Output 1908 * Reports to use HID_REQ_SET_REPORT on the Control EP. 1909 * 1910 * There is also another issue about HID Output Reports via USB, 1911 * the Sixaxis does not want the report_id as part of the data 1912 * packet, so we have to discard buf[0] when sending the actual 1913 * control message, even for numbered reports, humpf! 1914 */ 1915 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1916 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID; 1917 ret = sixaxis_set_operational_usb(hdev); 1918 sony_init_work(sc, sixaxis_state_worker); 1919 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) { 1920 /* 1921 * The Sixaxis wants output reports sent on the ctrl endpoint 1922 * when connected via Bluetooth. 1923 */ 1924 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1925 ret = sixaxis_set_operational_bt(hdev); 1926 sony_init_work(sc, sixaxis_state_worker); 1927 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) { 1928 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) { 1929 /* 1930 * The DualShock 4 wants output reports sent on the ctrl 1931 * endpoint when connected via Bluetooth. 1932 */ 1933 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1934 ret = dualshock4_set_operational_bt(hdev); 1935 if (ret < 0) { 1936 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n"); 1937 goto err_stop; 1938 } 1939 } 1940 1941 sony_init_work(sc, dualshock4_state_worker); 1942 } else { 1943 ret = 0; 1944 } 1945 1946 if (ret < 0) 1947 goto err_stop; 1948 1949 ret = sony_check_add(sc); 1950 if (ret < 0) 1951 goto err_stop; 1952 1953 if (sc->quirks & SONY_LED_SUPPORT) { 1954 ret = sony_leds_init(sc); 1955 if (ret < 0) 1956 goto err_stop; 1957 } 1958 1959 if (sc->quirks & SONY_BATTERY_SUPPORT) { 1960 ret = sony_battery_probe(sc); 1961 if (ret < 0) 1962 goto err_stop; 1963 1964 /* Open the device to receive reports with battery info */ 1965 ret = hid_hw_open(hdev); 1966 if (ret < 0) { 1967 hid_err(hdev, "hw open failed\n"); 1968 goto err_stop; 1969 } 1970 } 1971 1972 if (sc->quirks & SONY_FF_SUPPORT) { 1973 ret = sony_init_ff(sc); 1974 if (ret < 0) 1975 goto err_close; 1976 } 1977 1978 return 0; 1979 err_close: 1980 hid_hw_close(hdev); 1981 err_stop: 1982 if (sc->quirks & SONY_LED_SUPPORT) 1983 sony_leds_remove(sc); 1984 if (sc->quirks & SONY_BATTERY_SUPPORT) 1985 sony_battery_remove(sc); 1986 sony_cancel_work_sync(sc); 1987 sony_remove_dev_list(sc); 1988 sony_release_device_id(sc); 1989 hid_hw_stop(hdev); 1990 return ret; 1991 } 1992 1993 static void sony_remove(struct hid_device *hdev) 1994 { 1995 struct sony_sc *sc = hid_get_drvdata(hdev); 1996 1997 if (sc->quirks & SONY_LED_SUPPORT) 1998 sony_leds_remove(sc); 1999 2000 if (sc->quirks & SONY_BATTERY_SUPPORT) { 2001 hid_hw_close(hdev); 2002 sony_battery_remove(sc); 2003 } 2004 2005 sony_cancel_work_sync(sc); 2006 2007 sony_remove_dev_list(sc); 2008 2009 sony_release_device_id(sc); 2010 2011 hid_hw_stop(hdev); 2012 } 2013 2014 static const struct hid_device_id sony_devices[] = { 2015 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 2016 .driver_data = SIXAXIS_CONTROLLER_USB }, 2017 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER), 2018 .driver_data = SIXAXIS_CONTROLLER_USB }, 2019 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 2020 .driver_data = SIXAXIS_CONTROLLER_BT }, 2021 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE), 2022 .driver_data = VAIO_RDESC_CONSTANT }, 2023 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE), 2024 .driver_data = VAIO_RDESC_CONSTANT }, 2025 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as 2026 * Logitech joystick from the device descriptor. */ 2027 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER), 2028 .driver_data = BUZZ_CONTROLLER }, 2029 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER), 2030 .driver_data = BUZZ_CONTROLLER }, 2031 /* PS3 BD Remote Control */ 2032 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE), 2033 .driver_data = PS3REMOTE }, 2034 /* Logitech Harmony Adapter for PS3 */ 2035 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3), 2036 .driver_data = PS3REMOTE }, 2037 /* Sony Dualshock 4 controllers for PS4 */ 2038 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER), 2039 .driver_data = DUALSHOCK4_CONTROLLER_USB }, 2040 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER), 2041 .driver_data = DUALSHOCK4_CONTROLLER_BT }, 2042 { } 2043 }; 2044 MODULE_DEVICE_TABLE(hid, sony_devices); 2045 2046 static struct hid_driver sony_driver = { 2047 .name = "sony", 2048 .id_table = sony_devices, 2049 .input_mapping = sony_mapping, 2050 .input_configured = sony_input_configured, 2051 .probe = sony_probe, 2052 .remove = sony_remove, 2053 .report_fixup = sony_report_fixup, 2054 .raw_event = sony_raw_event 2055 }; 2056 2057 static int __init sony_init(void) 2058 { 2059 dbg_hid("Sony:%s\n", __func__); 2060 2061 return hid_register_driver(&sony_driver); 2062 } 2063 2064 static void __exit sony_exit(void) 2065 { 2066 dbg_hid("Sony:%s\n", __func__); 2067 2068 ida_destroy(&sony_device_id_allocator); 2069 hid_unregister_driver(&sony_driver); 2070 } 2071 module_init(sony_init); 2072 module_exit(sony_exit); 2073 2074 MODULE_LICENSE("GPL"); 2075