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