1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * HID driver for Sony / PS2 / PS3 / PS4 BD devices. 4 * 5 * Copyright (c) 1999 Andreas Gal 6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 8 * Copyright (c) 2008 Jiri Slaby 9 * Copyright (c) 2012 David Dillow <dave@thedillows.org> 10 * Copyright (c) 2006-2013 Jiri Kosina 11 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com> 12 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com> 13 * Copyright (c) 2018 Todd Kelner 14 * Copyright (c) 2020 Pascal Giard <pascal.giard@etsmtl.ca> 15 */ 16 17 /* 18 */ 19 20 /* 21 * NOTE: in order for the Sony PS3 BD Remote Control to be found by 22 * a Bluetooth host, the key combination Start+Enter has to be kept pressed 23 * for about 7 seconds with the Bluetooth Host Controller in discovering mode. 24 * 25 * There will be no PIN request from the device. 26 */ 27 28 #include <linux/device.h> 29 #include <linux/hid.h> 30 #include <linux/module.h> 31 #include <linux/slab.h> 32 #include <linux/leds.h> 33 #include <linux/power_supply.h> 34 #include <linux/spinlock.h> 35 #include <linux/list.h> 36 #include <linux/idr.h> 37 #include <linux/input/mt.h> 38 #include <linux/crc32.h> 39 #include <linux/usb.h> 40 #include <linux/timer.h> 41 #include <asm/unaligned.h> 42 43 #include "hid-ids.h" 44 45 #define VAIO_RDESC_CONSTANT BIT(0) 46 #define SIXAXIS_CONTROLLER_USB BIT(1) 47 #define SIXAXIS_CONTROLLER_BT BIT(2) 48 #define BUZZ_CONTROLLER BIT(3) 49 #define PS3REMOTE BIT(4) 50 #define DUALSHOCK4_CONTROLLER_USB BIT(5) 51 #define DUALSHOCK4_CONTROLLER_BT BIT(6) 52 #define DUALSHOCK4_DONGLE BIT(7) 53 #define MOTION_CONTROLLER_USB BIT(8) 54 #define MOTION_CONTROLLER_BT BIT(9) 55 #define NAVIGATION_CONTROLLER_USB BIT(10) 56 #define NAVIGATION_CONTROLLER_BT BIT(11) 57 #define SINO_LITE_CONTROLLER BIT(12) 58 #define FUTUREMAX_DANCE_MAT BIT(13) 59 #define NSG_MR5U_REMOTE_BT BIT(14) 60 #define NSG_MR7U_REMOTE_BT BIT(15) 61 #define SHANWAN_GAMEPAD BIT(16) 62 #define GHL_GUITAR_PS3WIIU BIT(17) 63 64 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT) 65 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT) 66 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\ 67 NAVIGATION_CONTROLLER_BT) 68 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\ 69 DUALSHOCK4_CONTROLLER_BT | \ 70 DUALSHOCK4_DONGLE) 71 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\ 72 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\ 73 NAVIGATION_CONTROLLER) 74 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\ 75 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER) 76 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\ 77 MOTION_CONTROLLER) 78 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\ 79 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT) 80 #define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT) 81 82 #define MAX_LEDS 4 83 #define NSG_MRXU_MAX_X 1667 84 #define NSG_MRXU_MAX_Y 1868 85 86 #define GHL_GUITAR_POKE_INTERVAL 10 /* In seconds */ 87 #define GHL_GUITAR_TILT_USAGE 44 88 89 /* Magic value and data taken from GHLtarUtility: 90 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs 91 * Note: The Wii U and PS3 dongles happen to share the same! 92 */ 93 static const u16 ghl_ps3wiiu_magic_value = 0x201; 94 static const char ghl_ps3wiiu_magic_data[] = { 95 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00 96 }; 97 98 /* PS/3 Motion controller */ 99 static u8 motion_rdesc[] = { 100 0x05, 0x01, /* Usage Page (Desktop), */ 101 0x09, 0x04, /* Usage (Joystick), */ 102 0xA1, 0x01, /* Collection (Application), */ 103 0xA1, 0x02, /* Collection (Logical), */ 104 0x85, 0x01, /* Report ID (1), */ 105 0x75, 0x01, /* Report Size (1), */ 106 0x95, 0x15, /* Report Count (21), */ 107 0x15, 0x00, /* Logical Minimum (0), */ 108 0x25, 0x01, /* Logical Maximum (1), */ 109 0x35, 0x00, /* Physical Minimum (0), */ 110 0x45, 0x01, /* Physical Maximum (1), */ 111 0x05, 0x09, /* Usage Page (Button), */ 112 0x19, 0x01, /* Usage Minimum (01h), */ 113 0x29, 0x15, /* Usage Maximum (15h), */ 114 0x81, 0x02, /* Input (Variable), * Buttons */ 115 0x95, 0x0B, /* Report Count (11), */ 116 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 117 0x81, 0x03, /* Input (Constant, Variable), * Padding */ 118 0x15, 0x00, /* Logical Minimum (0), */ 119 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 120 0x05, 0x01, /* Usage Page (Desktop), */ 121 0xA1, 0x00, /* Collection (Physical), */ 122 0x75, 0x08, /* Report Size (8), */ 123 0x95, 0x01, /* Report Count (1), */ 124 0x35, 0x00, /* Physical Minimum (0), */ 125 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 126 0x09, 0x30, /* Usage (X), */ 127 0x81, 0x02, /* Input (Variable), * Trigger */ 128 0xC0, /* End Collection, */ 129 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 130 0x75, 0x08, /* Report Size (8), */ 131 0x95, 0x07, /* Report Count (7), * skip 7 bytes */ 132 0x81, 0x02, /* Input (Variable), */ 133 0x05, 0x01, /* Usage Page (Desktop), */ 134 0x75, 0x10, /* Report Size (16), */ 135 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */ 136 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */ 137 0x95, 0x03, /* Report Count (3), * 3x Accels */ 138 0x09, 0x33, /* Usage (rX), */ 139 0x09, 0x34, /* Usage (rY), */ 140 0x09, 0x35, /* Usage (rZ), */ 141 0x81, 0x02, /* Input (Variable), */ 142 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 143 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */ 144 0x81, 0x02, /* Input (Variable), */ 145 0x05, 0x01, /* Usage Page (Desktop), */ 146 0x09, 0x01, /* Usage (Pointer), */ 147 0x95, 0x03, /* Report Count (3), * 3x Gyros */ 148 0x81, 0x02, /* Input (Variable), */ 149 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 150 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */ 151 0x81, 0x02, /* Input (Variable), */ 152 0x75, 0x0C, /* Report Size (12), */ 153 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */ 154 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */ 155 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */ 156 0x81, 0x02, /* Input (Variable), */ 157 0x75, 0x08, /* Report Size (8), */ 158 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 159 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 160 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */ 161 0x81, 0x02, /* Input (Variable), */ 162 0x75, 0x08, /* Report Size (8), */ 163 0x95, 0x30, /* Report Count (48), */ 164 0x09, 0x01, /* Usage (Pointer), */ 165 0x91, 0x02, /* Output (Variable), */ 166 0x75, 0x08, /* Report Size (8), */ 167 0x95, 0x30, /* Report Count (48), */ 168 0x09, 0x01, /* Usage (Pointer), */ 169 0xB1, 0x02, /* Feature (Variable), */ 170 0xC0, /* End Collection, */ 171 0xA1, 0x02, /* Collection (Logical), */ 172 0x85, 0x02, /* Report ID (2), */ 173 0x75, 0x08, /* Report Size (8), */ 174 0x95, 0x30, /* Report Count (48), */ 175 0x09, 0x01, /* Usage (Pointer), */ 176 0xB1, 0x02, /* Feature (Variable), */ 177 0xC0, /* End Collection, */ 178 0xA1, 0x02, /* Collection (Logical), */ 179 0x85, 0xEE, /* Report ID (238), */ 180 0x75, 0x08, /* Report Size (8), */ 181 0x95, 0x30, /* Report Count (48), */ 182 0x09, 0x01, /* Usage (Pointer), */ 183 0xB1, 0x02, /* Feature (Variable), */ 184 0xC0, /* End Collection, */ 185 0xA1, 0x02, /* Collection (Logical), */ 186 0x85, 0xEF, /* Report ID (239), */ 187 0x75, 0x08, /* Report Size (8), */ 188 0x95, 0x30, /* Report Count (48), */ 189 0x09, 0x01, /* Usage (Pointer), */ 190 0xB1, 0x02, /* Feature (Variable), */ 191 0xC0, /* End Collection, */ 192 0xC0 /* End Collection */ 193 }; 194 195 static u8 ps3remote_rdesc[] = { 196 0x05, 0x01, /* GUsagePage Generic Desktop */ 197 0x09, 0x05, /* LUsage 0x05 [Game Pad] */ 198 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */ 199 200 /* Use collection 1 for joypad buttons */ 201 0xA1, 0x02, /* MCollection Logical (interrelated data) */ 202 203 /* 204 * Ignore the 1st byte, maybe it is used for a controller 205 * number but it's not needed for correct operation 206 */ 207 0x75, 0x08, /* GReportSize 0x08 [8] */ 208 0x95, 0x01, /* GReportCount 0x01 [1] */ 209 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */ 210 211 /* 212 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these 213 * buttons multiple keypresses are allowed 214 */ 215 0x05, 0x09, /* GUsagePage Button */ 216 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */ 217 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */ 218 0x14, /* GLogicalMinimum [0] */ 219 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */ 220 0x75, 0x01, /* GReportSize 0x01 [1] */ 221 0x95, 0x18, /* GReportCount 0x18 [24] */ 222 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */ 223 224 0xC0, /* MEndCollection */ 225 226 /* Use collection 2 for remote control buttons */ 227 0xA1, 0x02, /* MCollection Logical (interrelated data) */ 228 229 /* 5th byte is used for remote control buttons */ 230 0x05, 0x09, /* GUsagePage Button */ 231 0x18, /* LUsageMinimum [No button pressed] */ 232 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */ 233 0x14, /* GLogicalMinimum [0] */ 234 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */ 235 0x75, 0x08, /* GReportSize 0x08 [8] */ 236 0x95, 0x01, /* GReportCount 0x01 [1] */ 237 0x80, /* MInput */ 238 239 /* 240 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at 241 * 0xff and 11th is for press indication 242 */ 243 0x75, 0x08, /* GReportSize 0x08 [8] */ 244 0x95, 0x06, /* GReportCount 0x06 [6] */ 245 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */ 246 247 /* 12th byte is for battery strength */ 248 0x05, 0x06, /* GUsagePage Generic Device Controls */ 249 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */ 250 0x14, /* GLogicalMinimum [0] */ 251 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */ 252 0x75, 0x08, /* GReportSize 0x08 [8] */ 253 0x95, 0x01, /* GReportCount 0x01 [1] */ 254 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */ 255 256 0xC0, /* MEndCollection */ 257 258 0xC0 /* MEndCollection [Game Pad] */ 259 }; 260 261 static const unsigned int ps3remote_keymap_joypad_buttons[] = { 262 [0x01] = KEY_SELECT, 263 [0x02] = BTN_THUMBL, /* L3 */ 264 [0x03] = BTN_THUMBR, /* R3 */ 265 [0x04] = BTN_START, 266 [0x05] = KEY_UP, 267 [0x06] = KEY_RIGHT, 268 [0x07] = KEY_DOWN, 269 [0x08] = KEY_LEFT, 270 [0x09] = BTN_TL2, /* L2 */ 271 [0x0a] = BTN_TR2, /* R2 */ 272 [0x0b] = BTN_TL, /* L1 */ 273 [0x0c] = BTN_TR, /* R1 */ 274 [0x0d] = KEY_OPTION, /* options/triangle */ 275 [0x0e] = KEY_BACK, /* back/circle */ 276 [0x0f] = BTN_0, /* cross */ 277 [0x10] = KEY_SCREEN, /* view/square */ 278 [0x11] = KEY_HOMEPAGE, /* PS button */ 279 [0x14] = KEY_ENTER, 280 }; 281 static const unsigned int ps3remote_keymap_remote_buttons[] = { 282 [0x00] = KEY_1, 283 [0x01] = KEY_2, 284 [0x02] = KEY_3, 285 [0x03] = KEY_4, 286 [0x04] = KEY_5, 287 [0x05] = KEY_6, 288 [0x06] = KEY_7, 289 [0x07] = KEY_8, 290 [0x08] = KEY_9, 291 [0x09] = KEY_0, 292 [0x0e] = KEY_ESC, /* return */ 293 [0x0f] = KEY_CLEAR, 294 [0x16] = KEY_EJECTCD, 295 [0x1a] = KEY_MENU, /* top menu */ 296 [0x28] = KEY_TIME, 297 [0x30] = KEY_PREVIOUS, 298 [0x31] = KEY_NEXT, 299 [0x32] = KEY_PLAY, 300 [0x33] = KEY_REWIND, /* scan back */ 301 [0x34] = KEY_FORWARD, /* scan forward */ 302 [0x38] = KEY_STOP, 303 [0x39] = KEY_PAUSE, 304 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */ 305 [0x60] = KEY_FRAMEBACK, /* slow/step back */ 306 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */ 307 [0x63] = KEY_SUBTITLE, 308 [0x64] = KEY_AUDIO, 309 [0x65] = KEY_ANGLE, 310 [0x70] = KEY_INFO, /* display */ 311 [0x80] = KEY_BLUE, 312 [0x81] = KEY_RED, 313 [0x82] = KEY_GREEN, 314 [0x83] = KEY_YELLOW, 315 }; 316 317 static const unsigned int buzz_keymap[] = { 318 /* 319 * The controller has 4 remote buzzers, each with one LED and 5 320 * buttons. 321 * 322 * We use the mapping chosen by the controller, which is: 323 * 324 * Key Offset 325 * ------------------- 326 * Buzz 1 327 * Blue 5 328 * Orange 4 329 * Green 3 330 * Yellow 2 331 * 332 * So, for example, the orange button on the third buzzer is mapped to 333 * BTN_TRIGGER_HAPPY14 334 */ 335 [1] = BTN_TRIGGER_HAPPY1, 336 [2] = BTN_TRIGGER_HAPPY2, 337 [3] = BTN_TRIGGER_HAPPY3, 338 [4] = BTN_TRIGGER_HAPPY4, 339 [5] = BTN_TRIGGER_HAPPY5, 340 [6] = BTN_TRIGGER_HAPPY6, 341 [7] = BTN_TRIGGER_HAPPY7, 342 [8] = BTN_TRIGGER_HAPPY8, 343 [9] = BTN_TRIGGER_HAPPY9, 344 [10] = BTN_TRIGGER_HAPPY10, 345 [11] = BTN_TRIGGER_HAPPY11, 346 [12] = BTN_TRIGGER_HAPPY12, 347 [13] = BTN_TRIGGER_HAPPY13, 348 [14] = BTN_TRIGGER_HAPPY14, 349 [15] = BTN_TRIGGER_HAPPY15, 350 [16] = BTN_TRIGGER_HAPPY16, 351 [17] = BTN_TRIGGER_HAPPY17, 352 [18] = BTN_TRIGGER_HAPPY18, 353 [19] = BTN_TRIGGER_HAPPY19, 354 [20] = BTN_TRIGGER_HAPPY20, 355 }; 356 357 /* The Navigation controller is a partial DS3 and uses the same HID report 358 * and hence the same keymap indices, however not not all axes/buttons 359 * are physically present. We use the same axis and button mapping as 360 * the DS3, which uses the Linux gamepad spec. 361 */ 362 static const unsigned int navigation_absmap[] = { 363 [0x30] = ABS_X, 364 [0x31] = ABS_Y, 365 [0x33] = ABS_Z, /* L2 */ 366 }; 367 368 /* Buttons not physically available on the device, but still available 369 * in the reports are explicitly set to 0 for documentation purposes. 370 */ 371 static const unsigned int navigation_keymap[] = { 372 [0x01] = 0, /* Select */ 373 [0x02] = BTN_THUMBL, /* L3 */ 374 [0x03] = 0, /* R3 */ 375 [0x04] = 0, /* Start */ 376 [0x05] = BTN_DPAD_UP, /* Up */ 377 [0x06] = BTN_DPAD_RIGHT, /* Right */ 378 [0x07] = BTN_DPAD_DOWN, /* Down */ 379 [0x08] = BTN_DPAD_LEFT, /* Left */ 380 [0x09] = BTN_TL2, /* L2 */ 381 [0x0a] = 0, /* R2 */ 382 [0x0b] = BTN_TL, /* L1 */ 383 [0x0c] = 0, /* R1 */ 384 [0x0d] = BTN_NORTH, /* Triangle */ 385 [0x0e] = BTN_EAST, /* Circle */ 386 [0x0f] = BTN_SOUTH, /* Cross */ 387 [0x10] = BTN_WEST, /* Square */ 388 [0x11] = BTN_MODE, /* PS */ 389 }; 390 391 static const unsigned int sixaxis_absmap[] = { 392 [0x30] = ABS_X, 393 [0x31] = ABS_Y, 394 [0x32] = ABS_RX, /* right stick X */ 395 [0x35] = ABS_RY, /* right stick Y */ 396 }; 397 398 static const unsigned int sixaxis_keymap[] = { 399 [0x01] = BTN_SELECT, /* Select */ 400 [0x02] = BTN_THUMBL, /* L3 */ 401 [0x03] = BTN_THUMBR, /* R3 */ 402 [0x04] = BTN_START, /* Start */ 403 [0x05] = BTN_DPAD_UP, /* Up */ 404 [0x06] = BTN_DPAD_RIGHT, /* Right */ 405 [0x07] = BTN_DPAD_DOWN, /* Down */ 406 [0x08] = BTN_DPAD_LEFT, /* Left */ 407 [0x09] = BTN_TL2, /* L2 */ 408 [0x0a] = BTN_TR2, /* R2 */ 409 [0x0b] = BTN_TL, /* L1 */ 410 [0x0c] = BTN_TR, /* R1 */ 411 [0x0d] = BTN_NORTH, /* Triangle */ 412 [0x0e] = BTN_EAST, /* Circle */ 413 [0x0f] = BTN_SOUTH, /* Cross */ 414 [0x10] = BTN_WEST, /* Square */ 415 [0x11] = BTN_MODE, /* PS */ 416 }; 417 418 static const unsigned int ds4_absmap[] = { 419 [0x30] = ABS_X, 420 [0x31] = ABS_Y, 421 [0x32] = ABS_RX, /* right stick X */ 422 [0x33] = ABS_Z, /* L2 */ 423 [0x34] = ABS_RZ, /* R2 */ 424 [0x35] = ABS_RY, /* right stick Y */ 425 }; 426 427 static const unsigned int ds4_keymap[] = { 428 [0x1] = BTN_WEST, /* Square */ 429 [0x2] = BTN_SOUTH, /* Cross */ 430 [0x3] = BTN_EAST, /* Circle */ 431 [0x4] = BTN_NORTH, /* Triangle */ 432 [0x5] = BTN_TL, /* L1 */ 433 [0x6] = BTN_TR, /* R1 */ 434 [0x7] = BTN_TL2, /* L2 */ 435 [0x8] = BTN_TR2, /* R2 */ 436 [0x9] = BTN_SELECT, /* Share */ 437 [0xa] = BTN_START, /* Options */ 438 [0xb] = BTN_THUMBL, /* L3 */ 439 [0xc] = BTN_THUMBR, /* R3 */ 440 [0xd] = BTN_MODE, /* PS */ 441 }; 442 443 static const struct {int x; int y; } ds4_hat_mapping[] = { 444 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, 445 {0, 0} 446 }; 447 448 static enum power_supply_property sony_battery_props[] = { 449 POWER_SUPPLY_PROP_PRESENT, 450 POWER_SUPPLY_PROP_CAPACITY, 451 POWER_SUPPLY_PROP_SCOPE, 452 POWER_SUPPLY_PROP_STATUS, 453 }; 454 455 struct sixaxis_led { 456 u8 time_enabled; /* the total time the led is active (0xff means forever) */ 457 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */ 458 u8 enabled; 459 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */ 460 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */ 461 } __packed; 462 463 struct sixaxis_rumble { 464 u8 padding; 465 u8 right_duration; /* Right motor duration (0xff means forever) */ 466 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */ 467 u8 left_duration; /* Left motor duration (0xff means forever) */ 468 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */ 469 } __packed; 470 471 struct sixaxis_output_report { 472 u8 report_id; 473 struct sixaxis_rumble rumble; 474 u8 padding[4]; 475 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */ 476 struct sixaxis_led led[4]; /* LEDx at (4 - x) */ 477 struct sixaxis_led _reserved; /* LED5, not actually soldered */ 478 } __packed; 479 480 union sixaxis_output_report_01 { 481 struct sixaxis_output_report data; 482 u8 buf[36]; 483 }; 484 485 struct motion_output_report_02 { 486 u8 type, zero; 487 u8 r, g, b; 488 u8 zero2; 489 u8 rumble; 490 }; 491 492 #define DS4_FEATURE_REPORT_0x02_SIZE 37 493 #define DS4_FEATURE_REPORT_0x05_SIZE 41 494 #define DS4_FEATURE_REPORT_0x81_SIZE 7 495 #define DS4_FEATURE_REPORT_0xA3_SIZE 49 496 #define DS4_INPUT_REPORT_0x11_SIZE 78 497 #define DS4_OUTPUT_REPORT_0x05_SIZE 32 498 #define DS4_OUTPUT_REPORT_0x11_SIZE 78 499 #define SIXAXIS_REPORT_0xF2_SIZE 17 500 #define SIXAXIS_REPORT_0xF5_SIZE 8 501 #define MOTION_REPORT_0x02_SIZE 49 502 503 /* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an 504 * additional +2. 505 */ 506 #define DS4_INPUT_REPORT_AXIS_OFFSET 1 507 #define DS4_INPUT_REPORT_BUTTON_OFFSET 5 508 #define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10 509 #define DS4_INPUT_REPORT_GYRO_X_OFFSET 13 510 #define DS4_INPUT_REPORT_BATTERY_OFFSET 30 511 #define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33 512 513 #define SENSOR_SUFFIX " Motion Sensors" 514 #define DS4_TOUCHPAD_SUFFIX " Touchpad" 515 516 /* Default to 4ms poll interval, which is same as USB (not adjustable). */ 517 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4 518 #define DS4_BT_MAX_POLL_INTERVAL_MS 62 519 #define DS4_GYRO_RES_PER_DEG_S 1024 520 #define DS4_ACC_RES_PER_G 8192 521 522 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41 523 #define SIXAXIS_ACC_RES_PER_G 113 524 525 static DEFINE_SPINLOCK(sony_dev_list_lock); 526 static LIST_HEAD(sony_device_list); 527 static DEFINE_IDA(sony_device_id_allocator); 528 529 /* Used for calibration of DS4 accelerometer and gyro. */ 530 struct ds4_calibration_data { 531 int abs_code; 532 short bias; 533 /* Calibration requires scaling against a sensitivity value, which is a 534 * float. Store sensitivity as a fraction to limit floating point 535 * calculations until final calibration. 536 */ 537 int sens_numer; 538 int sens_denom; 539 }; 540 541 enum ds4_dongle_state { 542 DONGLE_DISCONNECTED, 543 DONGLE_CALIBRATING, 544 DONGLE_CONNECTED, 545 DONGLE_DISABLED 546 }; 547 548 enum sony_worker { 549 SONY_WORKER_STATE, 550 SONY_WORKER_HOTPLUG 551 }; 552 553 struct sony_sc { 554 spinlock_t lock; 555 struct list_head list_node; 556 struct hid_device *hdev; 557 struct input_dev *touchpad; 558 struct input_dev *sensor_dev; 559 struct led_classdev *leds[MAX_LEDS]; 560 unsigned long quirks; 561 struct work_struct hotplug_worker; 562 struct work_struct state_worker; 563 void (*send_output_report)(struct sony_sc *); 564 struct power_supply *battery; 565 struct power_supply_desc battery_desc; 566 int device_id; 567 unsigned fw_version; 568 bool fw_version_created; 569 unsigned hw_version; 570 bool hw_version_created; 571 u8 *output_report_dmabuf; 572 573 #ifdef CONFIG_SONY_FF 574 u8 left; 575 u8 right; 576 #endif 577 578 u8 mac_address[6]; 579 u8 hotplug_worker_initialized; 580 u8 state_worker_initialized; 581 u8 defer_initialization; 582 u8 battery_capacity; 583 int battery_status; 584 u8 led_state[MAX_LEDS]; 585 u8 led_delay_on[MAX_LEDS]; 586 u8 led_delay_off[MAX_LEDS]; 587 u8 led_count; 588 589 bool timestamp_initialized; 590 u16 prev_timestamp; 591 unsigned int timestamp_us; 592 593 u8 ds4_bt_poll_interval; 594 enum ds4_dongle_state ds4_dongle_state; 595 /* DS4 calibration data */ 596 struct ds4_calibration_data ds4_calib_data[6]; 597 /* GH Live */ 598 struct timer_list ghl_poke_timer; 599 struct usb_ctrlrequest *ghl_cr; 600 u8 *ghl_databuf; 601 }; 602 603 static void sony_set_leds(struct sony_sc *sc); 604 605 static inline void sony_schedule_work(struct sony_sc *sc, 606 enum sony_worker which) 607 { 608 unsigned long flags; 609 610 switch (which) { 611 case SONY_WORKER_STATE: 612 spin_lock_irqsave(&sc->lock, flags); 613 if (!sc->defer_initialization && sc->state_worker_initialized) 614 schedule_work(&sc->state_worker); 615 spin_unlock_irqrestore(&sc->lock, flags); 616 break; 617 case SONY_WORKER_HOTPLUG: 618 if (sc->hotplug_worker_initialized) 619 schedule_work(&sc->hotplug_worker); 620 break; 621 } 622 } 623 624 static void ghl_magic_poke_cb(struct urb *urb) 625 { 626 if (urb) { 627 /* Free sc->ghl_cr and sc->ghl_databuf allocated in 628 * ghl_magic_poke() 629 */ 630 kfree(urb->setup_packet); 631 kfree(urb->transfer_buffer); 632 } 633 } 634 635 static void ghl_magic_poke(struct timer_list *t) 636 { 637 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer); 638 639 int ret; 640 unsigned int pipe; 641 struct urb *urb; 642 struct usb_device *usbdev = to_usb_device(sc->hdev->dev.parent->parent); 643 const u16 poke_size = 644 ARRAY_SIZE(ghl_ps3wiiu_magic_data); 645 646 pipe = usb_sndctrlpipe(usbdev, 0); 647 648 if (!sc->ghl_cr) { 649 sc->ghl_cr = kzalloc(sizeof(*sc->ghl_cr), GFP_ATOMIC); 650 if (!sc->ghl_cr) 651 goto resched; 652 } 653 654 if (!sc->ghl_databuf) { 655 sc->ghl_databuf = kzalloc(poke_size, GFP_ATOMIC); 656 if (!sc->ghl_databuf) 657 goto resched; 658 } 659 660 urb = usb_alloc_urb(0, GFP_ATOMIC); 661 if (!urb) 662 goto resched; 663 664 sc->ghl_cr->bRequestType = 665 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT; 666 sc->ghl_cr->bRequest = USB_REQ_SET_CONFIGURATION; 667 sc->ghl_cr->wValue = cpu_to_le16(ghl_ps3wiiu_magic_value); 668 sc->ghl_cr->wIndex = 0; 669 sc->ghl_cr->wLength = cpu_to_le16(poke_size); 670 memcpy(sc->ghl_databuf, ghl_ps3wiiu_magic_data, poke_size); 671 672 usb_fill_control_urb( 673 urb, usbdev, pipe, 674 (unsigned char *) sc->ghl_cr, sc->ghl_databuf, 675 poke_size, ghl_magic_poke_cb, NULL); 676 ret = usb_submit_urb(urb, GFP_ATOMIC); 677 if (ret < 0) { 678 kfree(sc->ghl_databuf); 679 kfree(sc->ghl_cr); 680 } 681 usb_free_urb(urb); 682 683 resched: 684 /* Reschedule for next time */ 685 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ); 686 } 687 688 static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi, 689 struct hid_field *field, struct hid_usage *usage, 690 unsigned long **bit, int *max) 691 { 692 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) { 693 unsigned int abs = usage->hid & HID_USAGE; 694 695 if (abs == GHL_GUITAR_TILT_USAGE) { 696 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY); 697 return 1; 698 } 699 } 700 return 0; 701 } 702 703 static ssize_t ds4_show_poll_interval(struct device *dev, 704 struct device_attribute 705 *attr, char *buf) 706 { 707 struct hid_device *hdev = to_hid_device(dev); 708 struct sony_sc *sc = hid_get_drvdata(hdev); 709 710 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval); 711 } 712 713 static ssize_t ds4_store_poll_interval(struct device *dev, 714 struct device_attribute *attr, 715 const char *buf, size_t count) 716 { 717 struct hid_device *hdev = to_hid_device(dev); 718 struct sony_sc *sc = hid_get_drvdata(hdev); 719 unsigned long flags; 720 u8 interval; 721 722 if (kstrtou8(buf, 0, &interval)) 723 return -EINVAL; 724 725 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS) 726 return -EINVAL; 727 728 spin_lock_irqsave(&sc->lock, flags); 729 sc->ds4_bt_poll_interval = interval; 730 spin_unlock_irqrestore(&sc->lock, flags); 731 732 sony_schedule_work(sc, SONY_WORKER_STATE); 733 734 return count; 735 } 736 737 static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval, 738 ds4_store_poll_interval); 739 740 static ssize_t sony_show_firmware_version(struct device *dev, 741 struct device_attribute 742 *attr, char *buf) 743 { 744 struct hid_device *hdev = to_hid_device(dev); 745 struct sony_sc *sc = hid_get_drvdata(hdev); 746 747 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version); 748 } 749 750 static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL); 751 752 static ssize_t sony_show_hardware_version(struct device *dev, 753 struct device_attribute 754 *attr, char *buf) 755 { 756 struct hid_device *hdev = to_hid_device(dev); 757 struct sony_sc *sc = hid_get_drvdata(hdev); 758 759 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version); 760 } 761 762 static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL); 763 764 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc, 765 unsigned int *rsize) 766 { 767 *rsize = sizeof(motion_rdesc); 768 return motion_rdesc; 769 } 770 771 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc, 772 unsigned int *rsize) 773 { 774 *rsize = sizeof(ps3remote_rdesc); 775 return ps3remote_rdesc; 776 } 777 778 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi, 779 struct hid_field *field, struct hid_usage *usage, 780 unsigned long **bit, int *max) 781 { 782 unsigned int key = usage->hid & HID_USAGE; 783 784 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 785 return -1; 786 787 switch (usage->collection_index) { 788 case 1: 789 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons)) 790 return -1; 791 792 key = ps3remote_keymap_joypad_buttons[key]; 793 if (!key) 794 return -1; 795 break; 796 case 2: 797 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons)) 798 return -1; 799 800 key = ps3remote_keymap_remote_buttons[key]; 801 if (!key) 802 return -1; 803 break; 804 default: 805 return -1; 806 } 807 808 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 809 return 1; 810 } 811 812 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi, 813 struct hid_field *field, struct hid_usage *usage, 814 unsigned long **bit, int *max) 815 { 816 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 817 unsigned int key = usage->hid & HID_USAGE; 818 819 if (key >= ARRAY_SIZE(sixaxis_keymap)) 820 return -1; 821 822 key = navigation_keymap[key]; 823 if (!key) 824 return -1; 825 826 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 827 return 1; 828 } else if (usage->hid == HID_GD_POINTER) { 829 /* See comment in sixaxis_mapping, basically the L2 (and R2) 830 * triggers are reported through GD Pointer. 831 * In addition we ignore any analog button 'axes' and only 832 * support digital buttons. 833 */ 834 switch (usage->usage_index) { 835 case 8: /* L2 */ 836 usage->hid = HID_GD_Z; 837 break; 838 default: 839 return -1; 840 } 841 842 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf); 843 return 1; 844 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) { 845 unsigned int abs = usage->hid & HID_USAGE; 846 847 if (abs >= ARRAY_SIZE(navigation_absmap)) 848 return -1; 849 850 abs = navigation_absmap[abs]; 851 852 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs); 853 return 1; 854 } 855 856 return -1; 857 } 858 859 860 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi, 861 struct hid_field *field, struct hid_usage *usage, 862 unsigned long **bit, int *max) 863 { 864 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 865 unsigned int key = usage->hid & HID_USAGE; 866 867 if (key >= ARRAY_SIZE(sixaxis_keymap)) 868 return -1; 869 870 key = sixaxis_keymap[key]; 871 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 872 return 1; 873 } else if (usage->hid == HID_GD_POINTER) { 874 /* The DS3 provides analog values for most buttons and even 875 * for HAT axes through GD Pointer. L2 and R2 are reported 876 * among these as well instead of as GD Z / RZ. Remap L2 877 * and R2 and ignore other analog 'button axes' as there is 878 * no good way for reporting them. 879 */ 880 switch (usage->usage_index) { 881 case 8: /* L2 */ 882 usage->hid = HID_GD_Z; 883 break; 884 case 9: /* R2 */ 885 usage->hid = HID_GD_RZ; 886 break; 887 default: 888 return -1; 889 } 890 891 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf); 892 return 1; 893 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) { 894 unsigned int abs = usage->hid & HID_USAGE; 895 896 if (abs >= ARRAY_SIZE(sixaxis_absmap)) 897 return -1; 898 899 abs = sixaxis_absmap[abs]; 900 901 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs); 902 return 1; 903 } 904 905 return -1; 906 } 907 908 static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi, 909 struct hid_field *field, struct hid_usage *usage, 910 unsigned long **bit, int *max) 911 { 912 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 913 unsigned int key = usage->hid & HID_USAGE; 914 915 if (key >= ARRAY_SIZE(ds4_keymap)) 916 return -1; 917 918 key = ds4_keymap[key]; 919 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 920 return 1; 921 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) { 922 unsigned int abs = usage->hid & HID_USAGE; 923 924 /* Let the HID parser deal with the HAT. */ 925 if (usage->hid == HID_GD_HATSWITCH) 926 return 0; 927 928 if (abs >= ARRAY_SIZE(ds4_absmap)) 929 return -1; 930 931 abs = ds4_absmap[abs]; 932 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs); 933 return 1; 934 } 935 936 return 0; 937 } 938 939 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc, 940 unsigned int *rsize) 941 { 942 struct sony_sc *sc = hid_get_drvdata(hdev); 943 944 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT)) 945 return rdesc; 946 947 /* 948 * Some Sony RF receivers wrongly declare the mouse pointer as a 949 * a constant non-data variable. 950 */ 951 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 && 952 /* usage page: generic desktop controls */ 953 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */ 954 /* usage: mouse */ 955 rdesc[2] == 0x09 && rdesc[3] == 0x02 && 956 /* input (usage page for x,y axes): constant, variable, relative */ 957 rdesc[54] == 0x81 && rdesc[55] == 0x07) { 958 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n"); 959 /* input: data, variable, relative */ 960 rdesc[55] = 0x06; 961 } 962 963 if (sc->quirks & MOTION_CONTROLLER) 964 return motion_fixup(hdev, rdesc, rsize); 965 966 if (sc->quirks & PS3REMOTE) 967 return ps3remote_fixup(hdev, rdesc, rsize); 968 969 /* 970 * Some knock-off USB dongles incorrectly report their button count 971 * as 13 instead of 16 causing three non-functional buttons. 972 */ 973 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 && 974 /* Report Count (13) */ 975 rdesc[23] == 0x95 && rdesc[24] == 0x0D && 976 /* Usage Maximum (13) */ 977 rdesc[37] == 0x29 && rdesc[38] == 0x0D && 978 /* Report Count (3) */ 979 rdesc[43] == 0x95 && rdesc[44] == 0x03) { 980 hid_info(hdev, "Fixing up USB dongle report descriptor\n"); 981 rdesc[24] = 0x10; 982 rdesc[38] = 0x10; 983 rdesc[44] = 0x00; 984 } 985 986 return rdesc; 987 } 988 989 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size) 990 { 991 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 }; 992 unsigned long flags; 993 int offset; 994 u8 battery_capacity; 995 int battery_status; 996 997 /* 998 * The sixaxis is charging if the battery value is 0xee 999 * and it is fully charged if the value is 0xef. 1000 * It does not report the actual level while charging so it 1001 * is set to 100% while charging is in progress. 1002 */ 1003 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30; 1004 1005 if (rd[offset] >= 0xee) { 1006 battery_capacity = 100; 1007 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING; 1008 } else { 1009 u8 index = rd[offset] <= 5 ? rd[offset] : 5; 1010 battery_capacity = sixaxis_battery_capacity[index]; 1011 battery_status = POWER_SUPPLY_STATUS_DISCHARGING; 1012 } 1013 1014 spin_lock_irqsave(&sc->lock, flags); 1015 sc->battery_capacity = battery_capacity; 1016 sc->battery_status = battery_status; 1017 spin_unlock_irqrestore(&sc->lock, flags); 1018 1019 if (sc->quirks & SIXAXIS_CONTROLLER) { 1020 int val; 1021 1022 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET; 1023 val = ((rd[offset+1] << 8) | rd[offset]) - 511; 1024 input_report_abs(sc->sensor_dev, ABS_X, val); 1025 1026 /* Y and Z are swapped and inversed */ 1027 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]); 1028 input_report_abs(sc->sensor_dev, ABS_Y, val); 1029 1030 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]); 1031 input_report_abs(sc->sensor_dev, ABS_Z, val); 1032 1033 input_sync(sc->sensor_dev); 1034 } 1035 } 1036 1037 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size) 1038 { 1039 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next, 1040 struct hid_input, list); 1041 struct input_dev *input_dev = hidinput->input; 1042 unsigned long flags; 1043 int n, m, offset, num_touch_data, max_touch_data; 1044 u8 cable_state, battery_capacity; 1045 int battery_status; 1046 u16 timestamp; 1047 1048 /* When using Bluetooth the header is 2 bytes longer, so skip these. */ 1049 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0; 1050 1051 /* Second bit of third button byte is for the touchpad button. */ 1052 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET; 1053 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2); 1054 1055 /* 1056 * The default behavior of the Dualshock 4 is to send reports using 1057 * report type 1 when running over Bluetooth. However, when feature 1058 * report 2 is requested during the controller initialization it starts 1059 * sending input reports in report 17. Since report 17 is undefined 1060 * in the default HID descriptor, the HID layer won't generate events. 1061 * While it is possible (and this was done before) to fixup the HID 1062 * descriptor to add this mapping, it was better to do this manually. 1063 * The reason is there were various pieces software both open and closed 1064 * source, relying on the descriptors to be the same across various 1065 * operating systems. If the descriptors wouldn't match some 1066 * applications e.g. games on Wine would not be able to function due 1067 * to different descriptors, which such applications are not parsing. 1068 */ 1069 if (rd[0] == 17) { 1070 int value; 1071 1072 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET; 1073 input_report_abs(input_dev, ABS_X, rd[offset]); 1074 input_report_abs(input_dev, ABS_Y, rd[offset+1]); 1075 input_report_abs(input_dev, ABS_RX, rd[offset+2]); 1076 input_report_abs(input_dev, ABS_RY, rd[offset+3]); 1077 1078 value = rd[offset+4] & 0xf; 1079 if (value > 7) 1080 value = 8; /* Center 0, 0 */ 1081 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x); 1082 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y); 1083 1084 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10); 1085 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20); 1086 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40); 1087 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80); 1088 1089 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1); 1090 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2); 1091 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4); 1092 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8); 1093 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10); 1094 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20); 1095 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40); 1096 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80); 1097 1098 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1); 1099 1100 input_report_abs(input_dev, ABS_Z, rd[offset+7]); 1101 input_report_abs(input_dev, ABS_RZ, rd[offset+8]); 1102 1103 input_sync(input_dev); 1104 } 1105 1106 /* Convert timestamp (in 5.33us unit) to timestamp_us */ 1107 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET; 1108 timestamp = get_unaligned_le16(&rd[offset]); 1109 if (!sc->timestamp_initialized) { 1110 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3; 1111 sc->timestamp_initialized = true; 1112 } else { 1113 u16 delta; 1114 1115 if (sc->prev_timestamp > timestamp) 1116 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1); 1117 else 1118 delta = timestamp - sc->prev_timestamp; 1119 sc->timestamp_us += (delta * 16) / 3; 1120 } 1121 sc->prev_timestamp = timestamp; 1122 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us); 1123 1124 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET; 1125 for (n = 0; n < 6; n++) { 1126 /* Store data in int for more precision during mult_frac. */ 1127 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]); 1128 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n]; 1129 1130 /* High precision is needed during calibration, but the 1131 * calibrated values are within 32-bit. 1132 * Note: we swap numerator 'x' and 'numer' in mult_frac for 1133 * precision reasons so we don't need 64-bit. 1134 */ 1135 int calib_data = mult_frac(calib->sens_numer, 1136 raw_data - calib->bias, 1137 calib->sens_denom); 1138 1139 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data); 1140 offset += 2; 1141 } 1142 input_sync(sc->sensor_dev); 1143 1144 /* 1145 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level 1146 * and the 5th bit contains the USB cable state. 1147 */ 1148 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET; 1149 cable_state = (rd[offset] >> 4) & 0x01; 1150 1151 /* 1152 * Interpretation of the battery_capacity data depends on the cable state. 1153 * When no cable is connected (bit4 is 0): 1154 * - 0:10: percentage in units of 10%. 1155 * When a cable is plugged in: 1156 * - 0-10: percentage in units of 10%. 1157 * - 11: battery is full 1158 * - 14: not charging due to Voltage or temperature error 1159 * - 15: charge error 1160 */ 1161 if (cable_state) { 1162 u8 battery_data = rd[offset] & 0xf; 1163 1164 if (battery_data < 10) { 1165 /* Take the mid-point for each battery capacity value, 1166 * because on the hardware side 0 = 0-9%, 1=10-19%, etc. 1167 * This matches official platform behavior, which does 1168 * the same. 1169 */ 1170 battery_capacity = battery_data * 10 + 5; 1171 battery_status = POWER_SUPPLY_STATUS_CHARGING; 1172 } else if (battery_data == 10) { 1173 battery_capacity = 100; 1174 battery_status = POWER_SUPPLY_STATUS_CHARGING; 1175 } else if (battery_data == 11) { 1176 battery_capacity = 100; 1177 battery_status = POWER_SUPPLY_STATUS_FULL; 1178 } else { /* 14, 15 and undefined values */ 1179 battery_capacity = 0; 1180 battery_status = POWER_SUPPLY_STATUS_UNKNOWN; 1181 } 1182 } else { 1183 u8 battery_data = rd[offset] & 0xf; 1184 1185 if (battery_data < 10) 1186 battery_capacity = battery_data * 10 + 5; 1187 else /* 10 */ 1188 battery_capacity = 100; 1189 1190 battery_status = POWER_SUPPLY_STATUS_DISCHARGING; 1191 } 1192 1193 spin_lock_irqsave(&sc->lock, flags); 1194 sc->battery_capacity = battery_capacity; 1195 sc->battery_status = battery_status; 1196 spin_unlock_irqrestore(&sc->lock, flags); 1197 1198 /* 1199 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB 1200 * and 35 on Bluetooth. 1201 * The first byte indicates the number of touch data in the report. 1202 * Trackpad data starts 2 bytes later (e.g. 35 for USB). 1203 */ 1204 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET; 1205 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3; 1206 if (rd[offset] > 0 && rd[offset] <= max_touch_data) 1207 num_touch_data = rd[offset]; 1208 else 1209 num_touch_data = 1; 1210 offset += 1; 1211 1212 for (m = 0; m < num_touch_data; m++) { 1213 /* Skip past timestamp */ 1214 offset += 1; 1215 1216 /* 1217 * The first 7 bits of the first byte is a counter and bit 8 is 1218 * a touch indicator that is 0 when pressed and 1 when not 1219 * pressed. 1220 * The next 3 bytes are two 12 bit touch coordinates, X and Y. 1221 * The data for the second touch is in the same format and 1222 * immediately follows the data for the first. 1223 */ 1224 for (n = 0; n < 2; n++) { 1225 u16 x, y; 1226 bool active; 1227 1228 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8); 1229 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4); 1230 1231 active = !(rd[offset] >> 7); 1232 input_mt_slot(sc->touchpad, n); 1233 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active); 1234 1235 if (active) { 1236 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x); 1237 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y); 1238 } 1239 1240 offset += 4; 1241 } 1242 input_mt_sync_frame(sc->touchpad); 1243 input_sync(sc->touchpad); 1244 } 1245 } 1246 1247 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size) 1248 { 1249 int n, offset, relx, rely; 1250 u8 active; 1251 1252 /* 1253 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and 1254 * the touch-related data starts at offset 2. 1255 * For the first byte, bit 0 is set when touchpad button is pressed. 1256 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed. 1257 * This drag key is mapped to BTN_LEFT. It is operational only when a 1258 * touch point is active. 1259 * Bit 4 is set when only the first touch point is active. 1260 * Bit 6 is set when only the second touch point is active. 1261 * Bits 5 and 7 are set when both touch points are active. 1262 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch. 1263 * The following byte, offset 5, has the touch width and length. 1264 * Bits 0-4=X (width), bits 5-7=Y (length). 1265 * A signed relative X coordinate is at offset 6. 1266 * The bytes at offset 7-9 are the second touch X/Y coordinates. 1267 * Offset 10 has the second touch width and length. 1268 * Offset 11 has the relative Y coordinate. 1269 */ 1270 offset = 1; 1271 1272 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F); 1273 active = (rd[offset] >> 4); 1274 relx = (s8) rd[offset+5]; 1275 rely = ((s8) rd[offset+10]) * -1; 1276 1277 offset++; 1278 1279 for (n = 0; n < 2; n++) { 1280 u16 x, y; 1281 u8 contactx, contacty; 1282 1283 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8); 1284 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4); 1285 1286 input_mt_slot(sc->touchpad, n); 1287 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03); 1288 1289 if (active & 0x03) { 1290 contactx = rd[offset+3] & 0x0F; 1291 contacty = rd[offset+3] >> 4; 1292 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR, 1293 max(contactx, contacty)); 1294 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR, 1295 min(contactx, contacty)); 1296 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION, 1297 (bool) (contactx > contacty)); 1298 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x); 1299 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, 1300 NSG_MRXU_MAX_Y - y); 1301 /* 1302 * The relative coordinates belong to the first touch 1303 * point, when present, or to the second touch point 1304 * when the first is not active. 1305 */ 1306 if ((n == 0) || ((n == 1) && (active & 0x01))) { 1307 input_report_rel(sc->touchpad, REL_X, relx); 1308 input_report_rel(sc->touchpad, REL_Y, rely); 1309 } 1310 } 1311 1312 offset += 5; 1313 active >>= 2; 1314 } 1315 1316 input_mt_sync_frame(sc->touchpad); 1317 1318 input_sync(sc->touchpad); 1319 } 1320 1321 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report, 1322 u8 *rd, int size) 1323 { 1324 struct sony_sc *sc = hid_get_drvdata(hdev); 1325 1326 /* 1327 * Sixaxis HID report has acclerometers/gyro with MSByte first, this 1328 * has to be BYTE_SWAPPED before passing up to joystick interface 1329 */ 1330 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) { 1331 /* 1332 * When connected via Bluetooth the Sixaxis occasionally sends 1333 * a report with the second byte 0xff and the rest zeroed. 1334 * 1335 * This report does not reflect the actual state of the 1336 * controller must be ignored to avoid generating false input 1337 * events. 1338 */ 1339 if (rd[1] == 0xff) 1340 return -EINVAL; 1341 1342 swap(rd[41], rd[42]); 1343 swap(rd[43], rd[44]); 1344 swap(rd[45], rd[46]); 1345 swap(rd[47], rd[48]); 1346 1347 sixaxis_parse_report(sc, rd, size); 1348 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) { 1349 sixaxis_parse_report(sc, rd, size); 1350 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 && 1351 size == 49) { 1352 sixaxis_parse_report(sc, rd, size); 1353 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 && 1354 size == 64) { 1355 dualshock4_parse_report(sc, rd, size); 1356 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 && 1357 size == 78)) { 1358 /* CRC check */ 1359 u8 bthdr = 0xA1; 1360 u32 crc; 1361 u32 report_crc; 1362 1363 crc = crc32_le(0xFFFFFFFF, &bthdr, 1); 1364 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4); 1365 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]); 1366 if (crc != report_crc) { 1367 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n", 1368 report_crc, crc); 1369 return -EILSEQ; 1370 } 1371 1372 dualshock4_parse_report(sc, rd, size); 1373 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 && 1374 size == 64) { 1375 unsigned long flags; 1376 enum ds4_dongle_state dongle_state; 1377 1378 /* 1379 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates 1380 * if a DS4 is actually connected (indicated by '0'). 1381 * For non-dongle, this bit is always 0 (connected). 1382 */ 1383 bool connected = (rd[31] & 0x04) ? false : true; 1384 1385 spin_lock_irqsave(&sc->lock, flags); 1386 dongle_state = sc->ds4_dongle_state; 1387 spin_unlock_irqrestore(&sc->lock, flags); 1388 1389 /* 1390 * The dongle always sends input reports even when no 1391 * DS4 is attached. When a DS4 is connected, we need to 1392 * obtain calibration data before we can use it. 1393 * The code below tracks dongle state and kicks of 1394 * calibration when needed and only allows us to process 1395 * input if a DS4 is actually connected. 1396 */ 1397 if (dongle_state == DONGLE_DISCONNECTED && connected) { 1398 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n"); 1399 sony_set_leds(sc); 1400 1401 spin_lock_irqsave(&sc->lock, flags); 1402 sc->ds4_dongle_state = DONGLE_CALIBRATING; 1403 spin_unlock_irqrestore(&sc->lock, flags); 1404 1405 sony_schedule_work(sc, SONY_WORKER_HOTPLUG); 1406 1407 /* Don't process the report since we don't have 1408 * calibration data, but let hidraw have it anyway. 1409 */ 1410 return 0; 1411 } else if ((dongle_state == DONGLE_CONNECTED || 1412 dongle_state == DONGLE_DISABLED) && !connected) { 1413 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n"); 1414 1415 spin_lock_irqsave(&sc->lock, flags); 1416 sc->ds4_dongle_state = DONGLE_DISCONNECTED; 1417 spin_unlock_irqrestore(&sc->lock, flags); 1418 1419 /* Return 0, so hidraw can get the report. */ 1420 return 0; 1421 } else if (dongle_state == DONGLE_CALIBRATING || 1422 dongle_state == DONGLE_DISABLED || 1423 dongle_state == DONGLE_DISCONNECTED) { 1424 /* Return 0, so hidraw can get the report. */ 1425 return 0; 1426 } 1427 1428 dualshock4_parse_report(sc, rd, size); 1429 1430 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) { 1431 nsg_mrxu_parse_report(sc, rd, size); 1432 return 1; 1433 } 1434 1435 if (sc->defer_initialization) { 1436 sc->defer_initialization = 0; 1437 sony_schedule_work(sc, SONY_WORKER_STATE); 1438 } 1439 1440 return 0; 1441 } 1442 1443 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi, 1444 struct hid_field *field, struct hid_usage *usage, 1445 unsigned long **bit, int *max) 1446 { 1447 struct sony_sc *sc = hid_get_drvdata(hdev); 1448 1449 if (sc->quirks & BUZZ_CONTROLLER) { 1450 unsigned int key = usage->hid & HID_USAGE; 1451 1452 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 1453 return -1; 1454 1455 switch (usage->collection_index) { 1456 case 1: 1457 if (key >= ARRAY_SIZE(buzz_keymap)) 1458 return -1; 1459 1460 key = buzz_keymap[key]; 1461 if (!key) 1462 return -1; 1463 break; 1464 default: 1465 return -1; 1466 } 1467 1468 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 1469 return 1; 1470 } 1471 1472 if (sc->quirks & PS3REMOTE) 1473 return ps3remote_mapping(hdev, hi, field, usage, bit, max); 1474 1475 if (sc->quirks & NAVIGATION_CONTROLLER) 1476 return navigation_mapping(hdev, hi, field, usage, bit, max); 1477 1478 if (sc->quirks & SIXAXIS_CONTROLLER) 1479 return sixaxis_mapping(hdev, hi, field, usage, bit, max); 1480 1481 if (sc->quirks & DUALSHOCK4_CONTROLLER) 1482 return ds4_mapping(hdev, hi, field, usage, bit, max); 1483 1484 if (sc->quirks & GHL_GUITAR_PS3WIIU) 1485 return guitar_mapping(hdev, hi, field, usage, bit, max); 1486 1487 /* Let hid-core decide for the others */ 1488 return 0; 1489 } 1490 1491 static int sony_register_touchpad(struct sony_sc *sc, int touch_count, 1492 int w, int h, int touch_major, int touch_minor, int orientation) 1493 { 1494 size_t name_sz; 1495 char *name; 1496 int ret; 1497 1498 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev); 1499 if (!sc->touchpad) 1500 return -ENOMEM; 1501 1502 input_set_drvdata(sc->touchpad, sc); 1503 sc->touchpad->dev.parent = &sc->hdev->dev; 1504 sc->touchpad->phys = sc->hdev->phys; 1505 sc->touchpad->uniq = sc->hdev->uniq; 1506 sc->touchpad->id.bustype = sc->hdev->bus; 1507 sc->touchpad->id.vendor = sc->hdev->vendor; 1508 sc->touchpad->id.product = sc->hdev->product; 1509 sc->touchpad->id.version = sc->hdev->version; 1510 1511 /* Append a suffix to the controller name as there are various 1512 * DS4 compatible non-Sony devices with different names. 1513 */ 1514 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX); 1515 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL); 1516 if (!name) 1517 return -ENOMEM; 1518 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name); 1519 sc->touchpad->name = name; 1520 1521 /* We map the button underneath the touchpad to BTN_LEFT. */ 1522 __set_bit(EV_KEY, sc->touchpad->evbit); 1523 __set_bit(BTN_LEFT, sc->touchpad->keybit); 1524 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit); 1525 1526 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0); 1527 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0); 1528 1529 if (touch_major > 0) { 1530 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR, 1531 0, touch_major, 0, 0); 1532 if (touch_minor > 0) 1533 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR, 1534 0, touch_minor, 0, 0); 1535 if (orientation > 0) 1536 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION, 1537 0, orientation, 0, 0); 1538 } 1539 1540 if (sc->quirks & NSG_MRXU_REMOTE) { 1541 __set_bit(EV_REL, sc->touchpad->evbit); 1542 } 1543 1544 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER); 1545 if (ret < 0) 1546 return ret; 1547 1548 ret = input_register_device(sc->touchpad); 1549 if (ret < 0) 1550 return ret; 1551 1552 return 0; 1553 } 1554 1555 static int sony_register_sensors(struct sony_sc *sc) 1556 { 1557 size_t name_sz; 1558 char *name; 1559 int ret; 1560 int range; 1561 1562 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev); 1563 if (!sc->sensor_dev) 1564 return -ENOMEM; 1565 1566 input_set_drvdata(sc->sensor_dev, sc); 1567 sc->sensor_dev->dev.parent = &sc->hdev->dev; 1568 sc->sensor_dev->phys = sc->hdev->phys; 1569 sc->sensor_dev->uniq = sc->hdev->uniq; 1570 sc->sensor_dev->id.bustype = sc->hdev->bus; 1571 sc->sensor_dev->id.vendor = sc->hdev->vendor; 1572 sc->sensor_dev->id.product = sc->hdev->product; 1573 sc->sensor_dev->id.version = sc->hdev->version; 1574 1575 /* Append a suffix to the controller name as there are various 1576 * DS4 compatible non-Sony devices with different names. 1577 */ 1578 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX); 1579 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL); 1580 if (!name) 1581 return -ENOMEM; 1582 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name); 1583 sc->sensor_dev->name = name; 1584 1585 if (sc->quirks & SIXAXIS_CONTROLLER) { 1586 /* For the DS3 we only support the accelerometer, which works 1587 * quite well even without calibration. The device also has 1588 * a 1-axis gyro, but it is very difficult to manage from within 1589 * the driver even to get data, the sensor is inaccurate and 1590 * the behavior is very different between hardware revisions. 1591 */ 1592 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0); 1593 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0); 1594 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0); 1595 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G); 1596 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G); 1597 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G); 1598 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) { 1599 range = DS4_ACC_RES_PER_G*4; 1600 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0); 1601 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0); 1602 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0); 1603 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G); 1604 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G); 1605 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G); 1606 1607 range = DS4_GYRO_RES_PER_DEG_S*2048; 1608 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0); 1609 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0); 1610 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0); 1611 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S); 1612 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S); 1613 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S); 1614 1615 __set_bit(EV_MSC, sc->sensor_dev->evbit); 1616 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit); 1617 } 1618 1619 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit); 1620 1621 ret = input_register_device(sc->sensor_dev); 1622 if (ret < 0) 1623 return ret; 1624 1625 return 0; 1626 } 1627 1628 /* 1629 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller 1630 * to "operational". Without this, the ps3 controller will not report any 1631 * events. 1632 */ 1633 static int sixaxis_set_operational_usb(struct hid_device *hdev) 1634 { 1635 struct sony_sc *sc = hid_get_drvdata(hdev); 1636 const int buf_size = 1637 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE); 1638 u8 *buf; 1639 int ret; 1640 1641 buf = kmalloc(buf_size, GFP_KERNEL); 1642 if (!buf) 1643 return -ENOMEM; 1644 1645 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE, 1646 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1647 if (ret < 0) { 1648 hid_err(hdev, "can't set operational mode: step 1\n"); 1649 goto out; 1650 } 1651 1652 /* 1653 * Some compatible controllers like the Speedlink Strike FX and 1654 * Gasia need another query plus an USB interrupt to get operational. 1655 */ 1656 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE, 1657 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1658 if (ret < 0) { 1659 hid_err(hdev, "can't set operational mode: step 2\n"); 1660 goto out; 1661 } 1662 1663 /* 1664 * But the USB interrupt would cause SHANWAN controllers to 1665 * start rumbling non-stop, so skip step 3 for these controllers. 1666 */ 1667 if (sc->quirks & SHANWAN_GAMEPAD) 1668 goto out; 1669 1670 ret = hid_hw_output_report(hdev, buf, 1); 1671 if (ret < 0) { 1672 hid_info(hdev, "can't set operational mode: step 3, ignoring\n"); 1673 ret = 0; 1674 } 1675 1676 out: 1677 kfree(buf); 1678 1679 return ret; 1680 } 1681 1682 static int sixaxis_set_operational_bt(struct hid_device *hdev) 1683 { 1684 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 }; 1685 u8 *buf; 1686 int ret; 1687 1688 buf = kmemdup(report, sizeof(report), GFP_KERNEL); 1689 if (!buf) 1690 return -ENOMEM; 1691 1692 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report), 1693 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 1694 1695 kfree(buf); 1696 1697 return ret; 1698 } 1699 1700 /* 1701 * Request DS4 calibration data for the motion sensors. 1702 * For Bluetooth this also affects the operating mode (see below). 1703 */ 1704 static int dualshock4_get_calibration_data(struct sony_sc *sc) 1705 { 1706 u8 *buf; 1707 int ret; 1708 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus; 1709 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus; 1710 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus; 1711 short gyro_speed_plus, gyro_speed_minus; 1712 short acc_x_plus, acc_x_minus; 1713 short acc_y_plus, acc_y_minus; 1714 short acc_z_plus, acc_z_minus; 1715 int speed_2x; 1716 int range_2g; 1717 1718 /* For Bluetooth we use a different request, which supports CRC. 1719 * Note: in Bluetooth mode feature report 0x02 also changes the state 1720 * of the controller, so that it sends input reports of type 0x11. 1721 */ 1722 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) { 1723 int retries; 1724 1725 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL); 1726 if (!buf) 1727 return -ENOMEM; 1728 1729 /* We should normally receive the feature report data we asked 1730 * for, but hidraw applications such as Steam can issue feature 1731 * reports as well. In particular for Dongle reconnects, Steam 1732 * and this function are competing resulting in often receiving 1733 * data for a different HID report, so retry a few times. 1734 */ 1735 for (retries = 0; retries < 3; retries++) { 1736 ret = hid_hw_raw_request(sc->hdev, 0x02, buf, 1737 DS4_FEATURE_REPORT_0x02_SIZE, 1738 HID_FEATURE_REPORT, 1739 HID_REQ_GET_REPORT); 1740 if (ret < 0) 1741 goto err_stop; 1742 1743 if (buf[0] != 0x02) { 1744 if (retries < 2) { 1745 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n"); 1746 continue; 1747 } else { 1748 ret = -EILSEQ; 1749 goto err_stop; 1750 } 1751 } else { 1752 break; 1753 } 1754 } 1755 } else { 1756 u8 bthdr = 0xA3; 1757 u32 crc; 1758 u32 report_crc; 1759 int retries; 1760 1761 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL); 1762 if (!buf) 1763 return -ENOMEM; 1764 1765 for (retries = 0; retries < 3; retries++) { 1766 ret = hid_hw_raw_request(sc->hdev, 0x05, buf, 1767 DS4_FEATURE_REPORT_0x05_SIZE, 1768 HID_FEATURE_REPORT, 1769 HID_REQ_GET_REPORT); 1770 if (ret < 0) 1771 goto err_stop; 1772 1773 /* CRC check */ 1774 crc = crc32_le(0xFFFFFFFF, &bthdr, 1); 1775 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4); 1776 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]); 1777 if (crc != report_crc) { 1778 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n", 1779 report_crc, crc); 1780 if (retries < 2) { 1781 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n"); 1782 continue; 1783 } else { 1784 ret = -EILSEQ; 1785 goto err_stop; 1786 } 1787 } else { 1788 break; 1789 } 1790 } 1791 } 1792 1793 gyro_pitch_bias = get_unaligned_le16(&buf[1]); 1794 gyro_yaw_bias = get_unaligned_le16(&buf[3]); 1795 gyro_roll_bias = get_unaligned_le16(&buf[5]); 1796 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) { 1797 gyro_pitch_plus = get_unaligned_le16(&buf[7]); 1798 gyro_pitch_minus = get_unaligned_le16(&buf[9]); 1799 gyro_yaw_plus = get_unaligned_le16(&buf[11]); 1800 gyro_yaw_minus = get_unaligned_le16(&buf[13]); 1801 gyro_roll_plus = get_unaligned_le16(&buf[15]); 1802 gyro_roll_minus = get_unaligned_le16(&buf[17]); 1803 } else { 1804 /* BT + Dongle */ 1805 gyro_pitch_plus = get_unaligned_le16(&buf[7]); 1806 gyro_yaw_plus = get_unaligned_le16(&buf[9]); 1807 gyro_roll_plus = get_unaligned_le16(&buf[11]); 1808 gyro_pitch_minus = get_unaligned_le16(&buf[13]); 1809 gyro_yaw_minus = get_unaligned_le16(&buf[15]); 1810 gyro_roll_minus = get_unaligned_le16(&buf[17]); 1811 } 1812 gyro_speed_plus = get_unaligned_le16(&buf[19]); 1813 gyro_speed_minus = get_unaligned_le16(&buf[21]); 1814 acc_x_plus = get_unaligned_le16(&buf[23]); 1815 acc_x_minus = get_unaligned_le16(&buf[25]); 1816 acc_y_plus = get_unaligned_le16(&buf[27]); 1817 acc_y_minus = get_unaligned_le16(&buf[29]); 1818 acc_z_plus = get_unaligned_le16(&buf[31]); 1819 acc_z_minus = get_unaligned_le16(&buf[33]); 1820 1821 /* Set gyroscope calibration and normalization parameters. 1822 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s. 1823 */ 1824 speed_2x = (gyro_speed_plus + gyro_speed_minus); 1825 sc->ds4_calib_data[0].abs_code = ABS_RX; 1826 sc->ds4_calib_data[0].bias = gyro_pitch_bias; 1827 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S; 1828 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus; 1829 1830 sc->ds4_calib_data[1].abs_code = ABS_RY; 1831 sc->ds4_calib_data[1].bias = gyro_yaw_bias; 1832 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S; 1833 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus; 1834 1835 sc->ds4_calib_data[2].abs_code = ABS_RZ; 1836 sc->ds4_calib_data[2].bias = gyro_roll_bias; 1837 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S; 1838 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus; 1839 1840 /* Set accelerometer calibration and normalization parameters. 1841 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G. 1842 */ 1843 range_2g = acc_x_plus - acc_x_minus; 1844 sc->ds4_calib_data[3].abs_code = ABS_X; 1845 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2; 1846 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G; 1847 sc->ds4_calib_data[3].sens_denom = range_2g; 1848 1849 range_2g = acc_y_plus - acc_y_minus; 1850 sc->ds4_calib_data[4].abs_code = ABS_Y; 1851 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2; 1852 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G; 1853 sc->ds4_calib_data[4].sens_denom = range_2g; 1854 1855 range_2g = acc_z_plus - acc_z_minus; 1856 sc->ds4_calib_data[5].abs_code = ABS_Z; 1857 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2; 1858 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G; 1859 sc->ds4_calib_data[5].sens_denom = range_2g; 1860 1861 err_stop: 1862 kfree(buf); 1863 return ret; 1864 } 1865 1866 static void dualshock4_calibration_work(struct work_struct *work) 1867 { 1868 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker); 1869 unsigned long flags; 1870 enum ds4_dongle_state dongle_state; 1871 int ret; 1872 1873 ret = dualshock4_get_calibration_data(sc); 1874 if (ret < 0) { 1875 /* This call is very unlikely to fail for the dongle. When it 1876 * fails we are probably in a very bad state, so mark the 1877 * dongle as disabled. We will re-enable the dongle if a new 1878 * DS4 hotplug is detect from sony_raw_event as any issues 1879 * are likely resolved then (the dongle is quite stupid). 1880 */ 1881 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n"); 1882 dongle_state = DONGLE_DISABLED; 1883 } else { 1884 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n"); 1885 dongle_state = DONGLE_CONNECTED; 1886 } 1887 1888 spin_lock_irqsave(&sc->lock, flags); 1889 sc->ds4_dongle_state = dongle_state; 1890 spin_unlock_irqrestore(&sc->lock, flags); 1891 } 1892 1893 static int dualshock4_get_version_info(struct sony_sc *sc) 1894 { 1895 u8 *buf; 1896 int ret; 1897 1898 buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL); 1899 if (!buf) 1900 return -ENOMEM; 1901 1902 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf, 1903 DS4_FEATURE_REPORT_0xA3_SIZE, 1904 HID_FEATURE_REPORT, 1905 HID_REQ_GET_REPORT); 1906 if (ret < 0) { 1907 kfree(buf); 1908 return ret; 1909 } 1910 1911 sc->hw_version = get_unaligned_le16(&buf[35]); 1912 sc->fw_version = get_unaligned_le16(&buf[41]); 1913 1914 kfree(buf); 1915 return 0; 1916 } 1917 1918 static void sixaxis_set_leds_from_id(struct sony_sc *sc) 1919 { 1920 static const u8 sixaxis_leds[10][4] = { 1921 { 0x01, 0x00, 0x00, 0x00 }, 1922 { 0x00, 0x01, 0x00, 0x00 }, 1923 { 0x00, 0x00, 0x01, 0x00 }, 1924 { 0x00, 0x00, 0x00, 0x01 }, 1925 { 0x01, 0x00, 0x00, 0x01 }, 1926 { 0x00, 0x01, 0x00, 0x01 }, 1927 { 0x00, 0x00, 0x01, 0x01 }, 1928 { 0x01, 0x00, 0x01, 0x01 }, 1929 { 0x00, 0x01, 0x01, 0x01 }, 1930 { 0x01, 0x01, 0x01, 0x01 } 1931 }; 1932 1933 int id = sc->device_id; 1934 1935 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0])); 1936 1937 if (id < 0) 1938 return; 1939 1940 id %= 10; 1941 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id])); 1942 } 1943 1944 static void dualshock4_set_leds_from_id(struct sony_sc *sc) 1945 { 1946 /* The first 4 color/index entries match what the PS4 assigns */ 1947 static const u8 color_code[7][3] = { 1948 /* Blue */ { 0x00, 0x00, 0x40 }, 1949 /* Red */ { 0x40, 0x00, 0x00 }, 1950 /* Green */ { 0x00, 0x40, 0x00 }, 1951 /* Pink */ { 0x20, 0x00, 0x20 }, 1952 /* Orange */ { 0x02, 0x01, 0x00 }, 1953 /* Teal */ { 0x00, 0x01, 0x01 }, 1954 /* White */ { 0x01, 0x01, 0x01 } 1955 }; 1956 1957 int id = sc->device_id; 1958 1959 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0])); 1960 1961 if (id < 0) 1962 return; 1963 1964 id %= 7; 1965 memcpy(sc->led_state, color_code[id], sizeof(color_code[id])); 1966 } 1967 1968 static void buzz_set_leds(struct sony_sc *sc) 1969 { 1970 struct hid_device *hdev = sc->hdev; 1971 struct list_head *report_list = 1972 &hdev->report_enum[HID_OUTPUT_REPORT].report_list; 1973 struct hid_report *report = list_entry(report_list->next, 1974 struct hid_report, list); 1975 s32 *value = report->field[0]->value; 1976 1977 BUILD_BUG_ON(MAX_LEDS < 4); 1978 1979 value[0] = 0x00; 1980 value[1] = sc->led_state[0] ? 0xff : 0x00; 1981 value[2] = sc->led_state[1] ? 0xff : 0x00; 1982 value[3] = sc->led_state[2] ? 0xff : 0x00; 1983 value[4] = sc->led_state[3] ? 0xff : 0x00; 1984 value[5] = 0x00; 1985 value[6] = 0x00; 1986 hid_hw_request(hdev, report, HID_REQ_SET_REPORT); 1987 } 1988 1989 static void sony_set_leds(struct sony_sc *sc) 1990 { 1991 if (!(sc->quirks & BUZZ_CONTROLLER)) 1992 sony_schedule_work(sc, SONY_WORKER_STATE); 1993 else 1994 buzz_set_leds(sc); 1995 } 1996 1997 static void sony_led_set_brightness(struct led_classdev *led, 1998 enum led_brightness value) 1999 { 2000 struct device *dev = led->dev->parent; 2001 struct hid_device *hdev = to_hid_device(dev); 2002 struct sony_sc *drv_data; 2003 2004 int n; 2005 int force_update; 2006 2007 drv_data = hid_get_drvdata(hdev); 2008 if (!drv_data) { 2009 hid_err(hdev, "No device data\n"); 2010 return; 2011 } 2012 2013 /* 2014 * The Sixaxis on USB will override any LED settings sent to it 2015 * and keep flashing all of the LEDs until the PS button is pressed. 2016 * Updates, even if redundant, must be always be sent to the 2017 * controller to avoid having to toggle the state of an LED just to 2018 * stop the flashing later on. 2019 */ 2020 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB); 2021 2022 for (n = 0; n < drv_data->led_count; n++) { 2023 if (led == drv_data->leds[n] && (force_update || 2024 (value != drv_data->led_state[n] || 2025 drv_data->led_delay_on[n] || 2026 drv_data->led_delay_off[n]))) { 2027 2028 drv_data->led_state[n] = value; 2029 2030 /* Setting the brightness stops the blinking */ 2031 drv_data->led_delay_on[n] = 0; 2032 drv_data->led_delay_off[n] = 0; 2033 2034 sony_set_leds(drv_data); 2035 break; 2036 } 2037 } 2038 } 2039 2040 static enum led_brightness sony_led_get_brightness(struct led_classdev *led) 2041 { 2042 struct device *dev = led->dev->parent; 2043 struct hid_device *hdev = to_hid_device(dev); 2044 struct sony_sc *drv_data; 2045 2046 int n; 2047 2048 drv_data = hid_get_drvdata(hdev); 2049 if (!drv_data) { 2050 hid_err(hdev, "No device data\n"); 2051 return LED_OFF; 2052 } 2053 2054 for (n = 0; n < drv_data->led_count; n++) { 2055 if (led == drv_data->leds[n]) 2056 return drv_data->led_state[n]; 2057 } 2058 2059 return LED_OFF; 2060 } 2061 2062 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on, 2063 unsigned long *delay_off) 2064 { 2065 struct device *dev = led->dev->parent; 2066 struct hid_device *hdev = to_hid_device(dev); 2067 struct sony_sc *drv_data = hid_get_drvdata(hdev); 2068 int n; 2069 u8 new_on, new_off; 2070 2071 if (!drv_data) { 2072 hid_err(hdev, "No device data\n"); 2073 return -EINVAL; 2074 } 2075 2076 /* Max delay is 255 deciseconds or 2550 milliseconds */ 2077 if (*delay_on > 2550) 2078 *delay_on = 2550; 2079 if (*delay_off > 2550) 2080 *delay_off = 2550; 2081 2082 /* Blink at 1 Hz if both values are zero */ 2083 if (!*delay_on && !*delay_off) 2084 *delay_on = *delay_off = 500; 2085 2086 new_on = *delay_on / 10; 2087 new_off = *delay_off / 10; 2088 2089 for (n = 0; n < drv_data->led_count; n++) { 2090 if (led == drv_data->leds[n]) 2091 break; 2092 } 2093 2094 /* This LED is not registered on this device */ 2095 if (n >= drv_data->led_count) 2096 return -EINVAL; 2097 2098 /* Don't schedule work if the values didn't change */ 2099 if (new_on != drv_data->led_delay_on[n] || 2100 new_off != drv_data->led_delay_off[n]) { 2101 drv_data->led_delay_on[n] = new_on; 2102 drv_data->led_delay_off[n] = new_off; 2103 sony_schedule_work(drv_data, SONY_WORKER_STATE); 2104 } 2105 2106 return 0; 2107 } 2108 2109 static int sony_leds_init(struct sony_sc *sc) 2110 { 2111 struct hid_device *hdev = sc->hdev; 2112 int n, ret = 0; 2113 int use_ds4_names; 2114 struct led_classdev *led; 2115 size_t name_sz; 2116 char *name; 2117 size_t name_len; 2118 const char *name_fmt; 2119 static const char * const ds4_name_str[] = { "red", "green", "blue", 2120 "global" }; 2121 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 }; 2122 u8 use_hw_blink[MAX_LEDS] = { 0 }; 2123 2124 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT)); 2125 2126 if (sc->quirks & BUZZ_CONTROLLER) { 2127 sc->led_count = 4; 2128 use_ds4_names = 0; 2129 name_len = strlen("::buzz#"); 2130 name_fmt = "%s::buzz%d"; 2131 /* Validate expected report characteristics. */ 2132 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7)) 2133 return -ENODEV; 2134 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) { 2135 dualshock4_set_leds_from_id(sc); 2136 sc->led_state[3] = 1; 2137 sc->led_count = 4; 2138 memset(max_brightness, 255, 3); 2139 use_hw_blink[3] = 1; 2140 use_ds4_names = 1; 2141 name_len = 0; 2142 name_fmt = "%s:%s"; 2143 } else if (sc->quirks & MOTION_CONTROLLER) { 2144 sc->led_count = 3; 2145 memset(max_brightness, 255, 3); 2146 use_ds4_names = 1; 2147 name_len = 0; 2148 name_fmt = "%s:%s"; 2149 } else if (sc->quirks & NAVIGATION_CONTROLLER) { 2150 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00}; 2151 2152 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds)); 2153 sc->led_count = 1; 2154 memset(use_hw_blink, 1, 4); 2155 use_ds4_names = 0; 2156 name_len = strlen("::sony#"); 2157 name_fmt = "%s::sony%d"; 2158 } else { 2159 sixaxis_set_leds_from_id(sc); 2160 sc->led_count = 4; 2161 memset(use_hw_blink, 1, 4); 2162 use_ds4_names = 0; 2163 name_len = strlen("::sony#"); 2164 name_fmt = "%s::sony%d"; 2165 } 2166 2167 /* 2168 * Clear LEDs as we have no way of reading their initial state. This is 2169 * only relevant if the driver is loaded after somebody actively set the 2170 * LEDs to on 2171 */ 2172 sony_set_leds(sc); 2173 2174 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1; 2175 2176 for (n = 0; n < sc->led_count; n++) { 2177 2178 if (use_ds4_names) 2179 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2; 2180 2181 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL); 2182 if (!led) { 2183 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n); 2184 return -ENOMEM; 2185 } 2186 2187 name = (void *)(&led[1]); 2188 if (use_ds4_names) 2189 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), 2190 ds4_name_str[n]); 2191 else 2192 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1); 2193 led->name = name; 2194 led->brightness = sc->led_state[n]; 2195 led->max_brightness = max_brightness[n]; 2196 led->flags = LED_CORE_SUSPENDRESUME; 2197 led->brightness_get = sony_led_get_brightness; 2198 led->brightness_set = sony_led_set_brightness; 2199 2200 if (use_hw_blink[n]) 2201 led->blink_set = sony_led_blink_set; 2202 2203 sc->leds[n] = led; 2204 2205 ret = devm_led_classdev_register(&hdev->dev, led); 2206 if (ret) { 2207 hid_err(hdev, "Failed to register LED %d\n", n); 2208 return ret; 2209 } 2210 } 2211 2212 return 0; 2213 } 2214 2215 static void sixaxis_send_output_report(struct sony_sc *sc) 2216 { 2217 static const union sixaxis_output_report_01 default_report = { 2218 .buf = { 2219 0x01, 2220 0x01, 0xff, 0x00, 0xff, 0x00, 2221 0x00, 0x00, 0x00, 0x00, 0x00, 2222 0xff, 0x27, 0x10, 0x00, 0x32, 2223 0xff, 0x27, 0x10, 0x00, 0x32, 2224 0xff, 0x27, 0x10, 0x00, 0x32, 2225 0xff, 0x27, 0x10, 0x00, 0x32, 2226 0x00, 0x00, 0x00, 0x00, 0x00 2227 } 2228 }; 2229 struct sixaxis_output_report *report = 2230 (struct sixaxis_output_report *)sc->output_report_dmabuf; 2231 int n; 2232 2233 /* Initialize the report with default values */ 2234 memcpy(report, &default_report, sizeof(struct sixaxis_output_report)); 2235 2236 #ifdef CONFIG_SONY_FF 2237 report->rumble.right_motor_on = sc->right ? 1 : 0; 2238 report->rumble.left_motor_force = sc->left; 2239 #endif 2240 2241 report->leds_bitmap |= sc->led_state[0] << 1; 2242 report->leds_bitmap |= sc->led_state[1] << 2; 2243 report->leds_bitmap |= sc->led_state[2] << 3; 2244 report->leds_bitmap |= sc->led_state[3] << 4; 2245 2246 /* Set flag for all leds off, required for 3rd party INTEC controller */ 2247 if ((report->leds_bitmap & 0x1E) == 0) 2248 report->leds_bitmap |= 0x20; 2249 2250 /* 2251 * The LEDs in the report are indexed in reverse order to their 2252 * corresponding light on the controller. 2253 * Index 0 = LED 4, index 1 = LED 3, etc... 2254 * 2255 * In the case of both delay values being zero (blinking disabled) the 2256 * default report values should be used or the controller LED will be 2257 * always off. 2258 */ 2259 for (n = 0; n < 4; n++) { 2260 if (sc->led_delay_on[n] || sc->led_delay_off[n]) { 2261 report->led[3 - n].duty_off = sc->led_delay_off[n]; 2262 report->led[3 - n].duty_on = sc->led_delay_on[n]; 2263 } 2264 } 2265 2266 /* SHANWAN controllers require output reports via intr channel */ 2267 if (sc->quirks & SHANWAN_GAMEPAD) 2268 hid_hw_output_report(sc->hdev, (u8 *)report, 2269 sizeof(struct sixaxis_output_report)); 2270 else 2271 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report, 2272 sizeof(struct sixaxis_output_report), 2273 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT); 2274 } 2275 2276 static void dualshock4_send_output_report(struct sony_sc *sc) 2277 { 2278 struct hid_device *hdev = sc->hdev; 2279 u8 *buf = sc->output_report_dmabuf; 2280 int offset; 2281 2282 /* 2283 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report 2284 * control the interval at which Dualshock 4 reports data: 2285 * 0x00 - 1ms 2286 * 0x01 - 1ms 2287 * 0x02 - 2ms 2288 * 0x3E - 62ms 2289 * 0x3F - disabled 2290 */ 2291 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) { 2292 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE); 2293 buf[0] = 0x05; 2294 buf[1] = 0x07; /* blink + LEDs + motor */ 2295 offset = 4; 2296 } else { 2297 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE); 2298 buf[0] = 0x11; 2299 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval; 2300 buf[3] = 0x07; /* blink + LEDs + motor */ 2301 offset = 6; 2302 } 2303 2304 #ifdef CONFIG_SONY_FF 2305 buf[offset++] = sc->right; 2306 buf[offset++] = sc->left; 2307 #else 2308 offset += 2; 2309 #endif 2310 2311 /* LED 3 is the global control */ 2312 if (sc->led_state[3]) { 2313 buf[offset++] = sc->led_state[0]; 2314 buf[offset++] = sc->led_state[1]; 2315 buf[offset++] = sc->led_state[2]; 2316 } else { 2317 offset += 3; 2318 } 2319 2320 /* If both delay values are zero the DualShock 4 disables blinking. */ 2321 buf[offset++] = sc->led_delay_on[3]; 2322 buf[offset++] = sc->led_delay_off[3]; 2323 2324 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) 2325 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE); 2326 else { 2327 /* CRC generation */ 2328 u8 bthdr = 0xA2; 2329 u32 crc; 2330 2331 crc = crc32_le(0xFFFFFFFF, &bthdr, 1); 2332 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4); 2333 put_unaligned_le32(crc, &buf[74]); 2334 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE); 2335 } 2336 } 2337 2338 static void motion_send_output_report(struct sony_sc *sc) 2339 { 2340 struct hid_device *hdev = sc->hdev; 2341 struct motion_output_report_02 *report = 2342 (struct motion_output_report_02 *)sc->output_report_dmabuf; 2343 2344 memset(report, 0, MOTION_REPORT_0x02_SIZE); 2345 2346 report->type = 0x02; /* set leds */ 2347 report->r = sc->led_state[0]; 2348 report->g = sc->led_state[1]; 2349 report->b = sc->led_state[2]; 2350 2351 #ifdef CONFIG_SONY_FF 2352 report->rumble = max(sc->right, sc->left); 2353 #endif 2354 2355 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE); 2356 } 2357 2358 static inline void sony_send_output_report(struct sony_sc *sc) 2359 { 2360 if (sc->send_output_report) 2361 sc->send_output_report(sc); 2362 } 2363 2364 static void sony_state_worker(struct work_struct *work) 2365 { 2366 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker); 2367 2368 sc->send_output_report(sc); 2369 } 2370 2371 static int sony_allocate_output_report(struct sony_sc *sc) 2372 { 2373 if ((sc->quirks & SIXAXIS_CONTROLLER) || 2374 (sc->quirks & NAVIGATION_CONTROLLER)) 2375 sc->output_report_dmabuf = 2376 devm_kmalloc(&sc->hdev->dev, 2377 sizeof(union sixaxis_output_report_01), 2378 GFP_KERNEL); 2379 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) 2380 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev, 2381 DS4_OUTPUT_REPORT_0x11_SIZE, 2382 GFP_KERNEL); 2383 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) 2384 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev, 2385 DS4_OUTPUT_REPORT_0x05_SIZE, 2386 GFP_KERNEL); 2387 else if (sc->quirks & MOTION_CONTROLLER) 2388 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev, 2389 MOTION_REPORT_0x02_SIZE, 2390 GFP_KERNEL); 2391 else 2392 return 0; 2393 2394 if (!sc->output_report_dmabuf) 2395 return -ENOMEM; 2396 2397 return 0; 2398 } 2399 2400 #ifdef CONFIG_SONY_FF 2401 static int sony_play_effect(struct input_dev *dev, void *data, 2402 struct ff_effect *effect) 2403 { 2404 struct hid_device *hid = input_get_drvdata(dev); 2405 struct sony_sc *sc = hid_get_drvdata(hid); 2406 2407 if (effect->type != FF_RUMBLE) 2408 return 0; 2409 2410 sc->left = effect->u.rumble.strong_magnitude / 256; 2411 sc->right = effect->u.rumble.weak_magnitude / 256; 2412 2413 sony_schedule_work(sc, SONY_WORKER_STATE); 2414 return 0; 2415 } 2416 2417 static int sony_init_ff(struct sony_sc *sc) 2418 { 2419 struct hid_input *hidinput; 2420 struct input_dev *input_dev; 2421 2422 if (list_empty(&sc->hdev->inputs)) { 2423 hid_err(sc->hdev, "no inputs found\n"); 2424 return -ENODEV; 2425 } 2426 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list); 2427 input_dev = hidinput->input; 2428 2429 input_set_capability(input_dev, EV_FF, FF_RUMBLE); 2430 return input_ff_create_memless(input_dev, NULL, sony_play_effect); 2431 } 2432 2433 #else 2434 static int sony_init_ff(struct sony_sc *sc) 2435 { 2436 return 0; 2437 } 2438 2439 #endif 2440 2441 static int sony_battery_get_property(struct power_supply *psy, 2442 enum power_supply_property psp, 2443 union power_supply_propval *val) 2444 { 2445 struct sony_sc *sc = power_supply_get_drvdata(psy); 2446 unsigned long flags; 2447 int ret = 0; 2448 u8 battery_capacity; 2449 int battery_status; 2450 2451 spin_lock_irqsave(&sc->lock, flags); 2452 battery_capacity = sc->battery_capacity; 2453 battery_status = sc->battery_status; 2454 spin_unlock_irqrestore(&sc->lock, flags); 2455 2456 switch (psp) { 2457 case POWER_SUPPLY_PROP_PRESENT: 2458 val->intval = 1; 2459 break; 2460 case POWER_SUPPLY_PROP_SCOPE: 2461 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 2462 break; 2463 case POWER_SUPPLY_PROP_CAPACITY: 2464 val->intval = battery_capacity; 2465 break; 2466 case POWER_SUPPLY_PROP_STATUS: 2467 val->intval = battery_status; 2468 break; 2469 default: 2470 ret = -EINVAL; 2471 break; 2472 } 2473 return ret; 2474 } 2475 2476 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id) 2477 { 2478 const char *battery_str_fmt = append_dev_id ? 2479 "sony_controller_battery_%pMR_%i" : 2480 "sony_controller_battery_%pMR"; 2481 struct power_supply_config psy_cfg = { .drv_data = sc, }; 2482 struct hid_device *hdev = sc->hdev; 2483 int ret; 2484 2485 /* 2486 * Set the default battery level to 100% to avoid low battery warnings 2487 * if the battery is polled before the first device report is received. 2488 */ 2489 sc->battery_capacity = 100; 2490 2491 sc->battery_desc.properties = sony_battery_props; 2492 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props); 2493 sc->battery_desc.get_property = sony_battery_get_property; 2494 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; 2495 sc->battery_desc.use_for_apm = 0; 2496 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL, 2497 battery_str_fmt, sc->mac_address, sc->device_id); 2498 if (!sc->battery_desc.name) 2499 return -ENOMEM; 2500 2501 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc, 2502 &psy_cfg); 2503 if (IS_ERR(sc->battery)) { 2504 ret = PTR_ERR(sc->battery); 2505 hid_err(hdev, "Unable to register battery device\n"); 2506 return ret; 2507 } 2508 2509 power_supply_powers(sc->battery, &hdev->dev); 2510 return 0; 2511 } 2512 2513 /* 2514 * If a controller is plugged in via USB while already connected via Bluetooth 2515 * it will show up as two devices. A global list of connected controllers and 2516 * their MAC addresses is maintained to ensure that a device is only connected 2517 * once. 2518 * 2519 * Some USB-only devices masquerade as Sixaxis controllers and all have the 2520 * same dummy Bluetooth address, so a comparison of the connection type is 2521 * required. Devices are only rejected in the case where two devices have 2522 * matching Bluetooth addresses on different bus types. 2523 */ 2524 static inline int sony_compare_connection_type(struct sony_sc *sc0, 2525 struct sony_sc *sc1) 2526 { 2527 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE); 2528 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE); 2529 2530 return sc0_not_bt == sc1_not_bt; 2531 } 2532 2533 static int sony_check_add_dev_list(struct sony_sc *sc) 2534 { 2535 struct sony_sc *entry; 2536 unsigned long flags; 2537 int ret; 2538 2539 spin_lock_irqsave(&sony_dev_list_lock, flags); 2540 2541 list_for_each_entry(entry, &sony_device_list, list_node) { 2542 ret = memcmp(sc->mac_address, entry->mac_address, 2543 sizeof(sc->mac_address)); 2544 if (!ret) { 2545 if (sony_compare_connection_type(sc, entry)) { 2546 ret = 1; 2547 } else { 2548 ret = -EEXIST; 2549 hid_info(sc->hdev, 2550 "controller with MAC address %pMR already connected\n", 2551 sc->mac_address); 2552 } 2553 goto unlock; 2554 } 2555 } 2556 2557 ret = 0; 2558 list_add(&(sc->list_node), &sony_device_list); 2559 2560 unlock: 2561 spin_unlock_irqrestore(&sony_dev_list_lock, flags); 2562 return ret; 2563 } 2564 2565 static void sony_remove_dev_list(struct sony_sc *sc) 2566 { 2567 unsigned long flags; 2568 2569 if (sc->list_node.next) { 2570 spin_lock_irqsave(&sony_dev_list_lock, flags); 2571 list_del(&(sc->list_node)); 2572 spin_unlock_irqrestore(&sony_dev_list_lock, flags); 2573 } 2574 } 2575 2576 static int sony_get_bt_devaddr(struct sony_sc *sc) 2577 { 2578 int ret; 2579 2580 /* HIDP stores the device MAC address as a string in the uniq field. */ 2581 ret = strlen(sc->hdev->uniq); 2582 if (ret != 17) 2583 return -EINVAL; 2584 2585 ret = sscanf(sc->hdev->uniq, 2586 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx", 2587 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3], 2588 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]); 2589 2590 if (ret != 6) 2591 return -EINVAL; 2592 2593 return 0; 2594 } 2595 2596 static int sony_check_add(struct sony_sc *sc) 2597 { 2598 u8 *buf = NULL; 2599 int n, ret; 2600 2601 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) || 2602 (sc->quirks & MOTION_CONTROLLER_BT) || 2603 (sc->quirks & NAVIGATION_CONTROLLER_BT) || 2604 (sc->quirks & SIXAXIS_CONTROLLER_BT)) { 2605 /* 2606 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC 2607 * address from the uniq string where HIDP stores it. 2608 * As uniq cannot be guaranteed to be a MAC address in all cases 2609 * a failure of this function should not prevent the connection. 2610 */ 2611 if (sony_get_bt_devaddr(sc) < 0) { 2612 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n"); 2613 return 0; 2614 } 2615 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) { 2616 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL); 2617 if (!buf) 2618 return -ENOMEM; 2619 2620 /* 2621 * The MAC address of a DS4 controller connected via USB can be 2622 * retrieved with feature report 0x81. The address begins at 2623 * offset 1. 2624 */ 2625 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, 2626 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT, 2627 HID_REQ_GET_REPORT); 2628 2629 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) { 2630 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n"); 2631 ret = ret < 0 ? ret : -EINVAL; 2632 goto out_free; 2633 } 2634 2635 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address)); 2636 2637 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq), 2638 "%pMR", sc->mac_address); 2639 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) || 2640 (sc->quirks & NAVIGATION_CONTROLLER_USB)) { 2641 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL); 2642 if (!buf) 2643 return -ENOMEM; 2644 2645 /* 2646 * The MAC address of a Sixaxis controller connected via USB can 2647 * be retrieved with feature report 0xf2. The address begins at 2648 * offset 4. 2649 */ 2650 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, 2651 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT, 2652 HID_REQ_GET_REPORT); 2653 2654 if (ret != SIXAXIS_REPORT_0xF2_SIZE) { 2655 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n"); 2656 ret = ret < 0 ? ret : -EINVAL; 2657 goto out_free; 2658 } 2659 2660 /* 2661 * The Sixaxis device MAC in the report is big-endian and must 2662 * be byte-swapped. 2663 */ 2664 for (n = 0; n < 6; n++) 2665 sc->mac_address[5-n] = buf[4+n]; 2666 2667 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq), 2668 "%pMR", sc->mac_address); 2669 } else { 2670 return 0; 2671 } 2672 2673 ret = sony_check_add_dev_list(sc); 2674 2675 out_free: 2676 2677 kfree(buf); 2678 2679 return ret; 2680 } 2681 2682 static int sony_set_device_id(struct sony_sc *sc) 2683 { 2684 int ret; 2685 2686 /* 2687 * Only DualShock 4 or Sixaxis controllers get an id. 2688 * All others are set to -1. 2689 */ 2690 if ((sc->quirks & SIXAXIS_CONTROLLER) || 2691 (sc->quirks & DUALSHOCK4_CONTROLLER)) { 2692 ret = ida_simple_get(&sony_device_id_allocator, 0, 0, 2693 GFP_KERNEL); 2694 if (ret < 0) { 2695 sc->device_id = -1; 2696 return ret; 2697 } 2698 sc->device_id = ret; 2699 } else { 2700 sc->device_id = -1; 2701 } 2702 2703 return 0; 2704 } 2705 2706 static void sony_release_device_id(struct sony_sc *sc) 2707 { 2708 if (sc->device_id >= 0) { 2709 ida_simple_remove(&sony_device_id_allocator, sc->device_id); 2710 sc->device_id = -1; 2711 } 2712 } 2713 2714 static inline void sony_init_output_report(struct sony_sc *sc, 2715 void (*send_output_report)(struct sony_sc *)) 2716 { 2717 sc->send_output_report = send_output_report; 2718 2719 if (!sc->state_worker_initialized) 2720 INIT_WORK(&sc->state_worker, sony_state_worker); 2721 2722 sc->state_worker_initialized = 1; 2723 } 2724 2725 static inline void sony_cancel_work_sync(struct sony_sc *sc) 2726 { 2727 unsigned long flags; 2728 2729 if (sc->hotplug_worker_initialized) 2730 cancel_work_sync(&sc->hotplug_worker); 2731 if (sc->state_worker_initialized) { 2732 spin_lock_irqsave(&sc->lock, flags); 2733 sc->state_worker_initialized = 0; 2734 spin_unlock_irqrestore(&sc->lock, flags); 2735 cancel_work_sync(&sc->state_worker); 2736 } 2737 } 2738 2739 static int sony_input_configured(struct hid_device *hdev, 2740 struct hid_input *hidinput) 2741 { 2742 struct sony_sc *sc = hid_get_drvdata(hdev); 2743 int append_dev_id; 2744 int ret; 2745 2746 ret = sony_set_device_id(sc); 2747 if (ret < 0) { 2748 hid_err(hdev, "failed to allocate the device id\n"); 2749 goto err_stop; 2750 } 2751 2752 ret = append_dev_id = sony_check_add(sc); 2753 if (ret < 0) 2754 goto err_stop; 2755 2756 ret = sony_allocate_output_report(sc); 2757 if (ret < 0) { 2758 hid_err(hdev, "failed to allocate the output report buffer\n"); 2759 goto err_stop; 2760 } 2761 2762 if (sc->quirks & NAVIGATION_CONTROLLER_USB) { 2763 /* 2764 * The Sony Sixaxis does not handle HID Output Reports on the 2765 * Interrupt EP like it could, so we need to force HID Output 2766 * Reports to use HID_REQ_SET_REPORT on the Control EP. 2767 * 2768 * There is also another issue about HID Output Reports via USB, 2769 * the Sixaxis does not want the report_id as part of the data 2770 * packet, so we have to discard buf[0] when sending the actual 2771 * control message, even for numbered reports, humpf! 2772 * 2773 * Additionally, the Sixaxis on USB isn't properly initialized 2774 * until the PS logo button is pressed and as such won't retain 2775 * any state set by an output report, so the initial 2776 * configuration report is deferred until the first input 2777 * report arrives. 2778 */ 2779 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 2780 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID; 2781 sc->defer_initialization = 1; 2782 2783 ret = sixaxis_set_operational_usb(hdev); 2784 if (ret < 0) { 2785 hid_err(hdev, "Failed to set controller into operational mode\n"); 2786 goto err_stop; 2787 } 2788 2789 sony_init_output_report(sc, sixaxis_send_output_report); 2790 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) { 2791 /* 2792 * The Navigation controller wants output reports sent on the ctrl 2793 * endpoint when connected via Bluetooth. 2794 */ 2795 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 2796 2797 ret = sixaxis_set_operational_bt(hdev); 2798 if (ret < 0) { 2799 hid_err(hdev, "Failed to set controller into operational mode\n"); 2800 goto err_stop; 2801 } 2802 2803 sony_init_output_report(sc, sixaxis_send_output_report); 2804 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 2805 /* 2806 * The Sony Sixaxis does not handle HID Output Reports on the 2807 * Interrupt EP and the device only becomes active when the 2808 * PS button is pressed. See comment for Navigation controller 2809 * above for more details. 2810 */ 2811 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 2812 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID; 2813 sc->defer_initialization = 1; 2814 2815 ret = sixaxis_set_operational_usb(hdev); 2816 if (ret < 0) { 2817 hid_err(hdev, "Failed to set controller into operational mode\n"); 2818 goto err_stop; 2819 } 2820 2821 ret = sony_register_sensors(sc); 2822 if (ret) { 2823 hid_err(sc->hdev, 2824 "Unable to initialize motion sensors: %d\n", ret); 2825 goto err_stop; 2826 } 2827 2828 sony_init_output_report(sc, sixaxis_send_output_report); 2829 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) { 2830 /* 2831 * The Sixaxis wants output reports sent on the ctrl endpoint 2832 * when connected via Bluetooth. 2833 */ 2834 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 2835 2836 ret = sixaxis_set_operational_bt(hdev); 2837 if (ret < 0) { 2838 hid_err(hdev, "Failed to set controller into operational mode\n"); 2839 goto err_stop; 2840 } 2841 2842 ret = sony_register_sensors(sc); 2843 if (ret) { 2844 hid_err(sc->hdev, 2845 "Unable to initialize motion sensors: %d\n", ret); 2846 goto err_stop; 2847 } 2848 2849 sony_init_output_report(sc, sixaxis_send_output_report); 2850 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) { 2851 ret = dualshock4_get_calibration_data(sc); 2852 if (ret < 0) { 2853 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n"); 2854 goto err_stop; 2855 } 2856 2857 ret = dualshock4_get_version_info(sc); 2858 if (ret < 0) { 2859 hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n"); 2860 goto err_stop; 2861 } 2862 2863 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version); 2864 if (ret) { 2865 hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret); 2866 goto err_stop; 2867 } 2868 sc->fw_version_created = true; 2869 2870 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version); 2871 if (ret) { 2872 hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret); 2873 goto err_stop; 2874 } 2875 sc->hw_version_created = true; 2876 2877 /* 2878 * The Dualshock 4 touchpad supports 2 touches and has a 2879 * resolution of 1920x942 (44.86 dots/mm). 2880 */ 2881 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0); 2882 if (ret) { 2883 hid_err(sc->hdev, 2884 "Unable to initialize multi-touch slots: %d\n", 2885 ret); 2886 goto err_stop; 2887 } 2888 2889 ret = sony_register_sensors(sc); 2890 if (ret) { 2891 hid_err(sc->hdev, 2892 "Unable to initialize motion sensors: %d\n", ret); 2893 goto err_stop; 2894 } 2895 2896 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) { 2897 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS; 2898 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval); 2899 if (ret) 2900 hid_warn(sc->hdev, 2901 "can't create sysfs bt_poll_interval attribute err: %d\n", 2902 ret); 2903 } 2904 2905 if (sc->quirks & DUALSHOCK4_DONGLE) { 2906 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work); 2907 sc->hotplug_worker_initialized = 1; 2908 sc->ds4_dongle_state = DONGLE_DISCONNECTED; 2909 } 2910 2911 sony_init_output_report(sc, dualshock4_send_output_report); 2912 } else if (sc->quirks & NSG_MRXU_REMOTE) { 2913 /* 2914 * The NSG-MRxU touchpad supports 2 touches and has a 2915 * resolution of 1667x1868 2916 */ 2917 ret = sony_register_touchpad(sc, 2, 2918 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1); 2919 if (ret) { 2920 hid_err(sc->hdev, 2921 "Unable to initialize multi-touch slots: %d\n", 2922 ret); 2923 goto err_stop; 2924 } 2925 2926 } else if (sc->quirks & MOTION_CONTROLLER) { 2927 sony_init_output_report(sc, motion_send_output_report); 2928 } else { 2929 ret = 0; 2930 } 2931 2932 if (sc->quirks & SONY_LED_SUPPORT) { 2933 ret = sony_leds_init(sc); 2934 if (ret < 0) 2935 goto err_stop; 2936 } 2937 2938 if (sc->quirks & SONY_BATTERY_SUPPORT) { 2939 ret = sony_battery_probe(sc, append_dev_id); 2940 if (ret < 0) 2941 goto err_stop; 2942 2943 /* Open the device to receive reports with battery info */ 2944 ret = hid_hw_open(hdev); 2945 if (ret < 0) { 2946 hid_err(hdev, "hw open failed\n"); 2947 goto err_stop; 2948 } 2949 } 2950 2951 if (sc->quirks & SONY_FF_SUPPORT) { 2952 ret = sony_init_ff(sc); 2953 if (ret < 0) 2954 goto err_close; 2955 } 2956 2957 return 0; 2958 err_close: 2959 hid_hw_close(hdev); 2960 err_stop: 2961 /* Piggy back on the default ds4_bt_ poll_interval to determine 2962 * if we need to remove the file as we don't know for sure if we 2963 * executed that logic. 2964 */ 2965 if (sc->ds4_bt_poll_interval) 2966 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval); 2967 if (sc->fw_version_created) 2968 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version); 2969 if (sc->hw_version_created) 2970 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version); 2971 sony_cancel_work_sync(sc); 2972 sony_remove_dev_list(sc); 2973 sony_release_device_id(sc); 2974 return ret; 2975 } 2976 2977 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) 2978 { 2979 int ret; 2980 unsigned long quirks = id->driver_data; 2981 struct sony_sc *sc; 2982 unsigned int connect_mask = HID_CONNECT_DEFAULT; 2983 2984 if (!strcmp(hdev->name, "FutureMax Dance Mat")) 2985 quirks |= FUTUREMAX_DANCE_MAT; 2986 2987 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad")) 2988 quirks |= SHANWAN_GAMEPAD; 2989 2990 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL); 2991 if (sc == NULL) { 2992 hid_err(hdev, "can't alloc sony descriptor\n"); 2993 return -ENOMEM; 2994 } 2995 2996 spin_lock_init(&sc->lock); 2997 2998 sc->quirks = quirks; 2999 hid_set_drvdata(hdev, sc); 3000 sc->hdev = hdev; 3001 3002 ret = hid_parse(hdev); 3003 if (ret) { 3004 hid_err(hdev, "parse failed\n"); 3005 return ret; 3006 } 3007 3008 if (sc->quirks & VAIO_RDESC_CONSTANT) 3009 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 3010 else if (sc->quirks & SIXAXIS_CONTROLLER) 3011 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 3012 3013 /* Patch the hw version on DS3/4 compatible devices, so applications can 3014 * distinguish between the default HID mappings and the mappings defined 3015 * by the Linux game controller spec. This is important for the SDL2 3016 * library, which has a game controller database, which uses device ids 3017 * in combination with version as a key. 3018 */ 3019 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)) 3020 hdev->version |= 0x8000; 3021 3022 ret = hid_hw_start(hdev, connect_mask); 3023 if (ret) { 3024 hid_err(hdev, "hw start failed\n"); 3025 return ret; 3026 } 3027 3028 /* sony_input_configured can fail, but this doesn't result 3029 * in hid_hw_start failures (intended). Check whether 3030 * the HID layer claimed the device else fail. 3031 * We don't know the actual reason for the failure, most 3032 * likely it is due to EEXIST in case of double connection 3033 * of USB and Bluetooth, but could have been due to ENOMEM 3034 * or other reasons as well. 3035 */ 3036 if (!(hdev->claimed & HID_CLAIMED_INPUT)) { 3037 hid_err(hdev, "failed to claim input\n"); 3038 hid_hw_stop(hdev); 3039 return -ENODEV; 3040 } 3041 3042 if (sc->quirks & GHL_GUITAR_PS3WIIU) { 3043 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0); 3044 mod_timer(&sc->ghl_poke_timer, 3045 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ); 3046 } 3047 3048 return ret; 3049 } 3050 3051 static void sony_remove(struct hid_device *hdev) 3052 { 3053 struct sony_sc *sc = hid_get_drvdata(hdev); 3054 3055 if (sc->quirks & GHL_GUITAR_PS3WIIU) 3056 del_timer_sync(&sc->ghl_poke_timer); 3057 3058 hid_hw_close(hdev); 3059 3060 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) 3061 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval); 3062 3063 if (sc->fw_version_created) 3064 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version); 3065 3066 if (sc->hw_version_created) 3067 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version); 3068 3069 sony_cancel_work_sync(sc); 3070 3071 sony_remove_dev_list(sc); 3072 3073 sony_release_device_id(sc); 3074 3075 hid_hw_stop(hdev); 3076 } 3077 3078 #ifdef CONFIG_PM 3079 3080 static int sony_suspend(struct hid_device *hdev, pm_message_t message) 3081 { 3082 #ifdef CONFIG_SONY_FF 3083 3084 /* On suspend stop any running force-feedback events */ 3085 if (SONY_FF_SUPPORT) { 3086 struct sony_sc *sc = hid_get_drvdata(hdev); 3087 3088 sc->left = sc->right = 0; 3089 sony_send_output_report(sc); 3090 } 3091 3092 #endif 3093 return 0; 3094 } 3095 3096 static int sony_resume(struct hid_device *hdev) 3097 { 3098 struct sony_sc *sc = hid_get_drvdata(hdev); 3099 3100 /* 3101 * The Sixaxis and navigation controllers on USB need to be 3102 * reinitialized on resume or they won't behave properly. 3103 */ 3104 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) || 3105 (sc->quirks & NAVIGATION_CONTROLLER_USB)) { 3106 sixaxis_set_operational_usb(sc->hdev); 3107 sc->defer_initialization = 1; 3108 } 3109 3110 return 0; 3111 } 3112 3113 #endif 3114 3115 static const struct hid_device_id sony_devices[] = { 3116 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 3117 .driver_data = SIXAXIS_CONTROLLER_USB }, 3118 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER), 3119 .driver_data = NAVIGATION_CONTROLLER_USB }, 3120 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER), 3121 .driver_data = NAVIGATION_CONTROLLER_BT }, 3122 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER), 3123 .driver_data = MOTION_CONTROLLER_USB }, 3124 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER), 3125 .driver_data = MOTION_CONTROLLER_BT }, 3126 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 3127 .driver_data = SIXAXIS_CONTROLLER_BT }, 3128 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE), 3129 .driver_data = VAIO_RDESC_CONSTANT }, 3130 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE), 3131 .driver_data = VAIO_RDESC_CONSTANT }, 3132 /* 3133 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as 3134 * Logitech joystick from the device descriptor. 3135 */ 3136 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER), 3137 .driver_data = BUZZ_CONTROLLER }, 3138 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER), 3139 .driver_data = BUZZ_CONTROLLER }, 3140 /* PS3 BD Remote Control */ 3141 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE), 3142 .driver_data = PS3REMOTE }, 3143 /* Logitech Harmony Adapter for PS3 */ 3144 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3), 3145 .driver_data = PS3REMOTE }, 3146 /* SMK-Link PS3 BD Remote Control */ 3147 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE), 3148 .driver_data = PS3REMOTE }, 3149 /* Sony Dualshock 4 controllers for PS4 */ 3150 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER), 3151 .driver_data = DUALSHOCK4_CONTROLLER_USB }, 3152 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER), 3153 .driver_data = DUALSHOCK4_CONTROLLER_BT }, 3154 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2), 3155 .driver_data = DUALSHOCK4_CONTROLLER_USB }, 3156 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2), 3157 .driver_data = DUALSHOCK4_CONTROLLER_BT }, 3158 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE), 3159 .driver_data = DUALSHOCK4_DONGLE }, 3160 /* Nyko Core Controller for PS3 */ 3161 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER), 3162 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER }, 3163 /* SMK-Link NSG-MR5U Remote Control */ 3164 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE), 3165 .driver_data = NSG_MR5U_REMOTE_BT }, 3166 /* SMK-Link NSG-MR7U Remote Control */ 3167 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE), 3168 .driver_data = NSG_MR7U_REMOTE_BT }, 3169 /* Guitar Hero Live PS3 and Wii U guitar dongles */ 3170 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_GHLIVE, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE), 3171 .driver_data = GHL_GUITAR_PS3WIIU}, 3172 { } 3173 }; 3174 MODULE_DEVICE_TABLE(hid, sony_devices); 3175 3176 static struct hid_driver sony_driver = { 3177 .name = "sony", 3178 .id_table = sony_devices, 3179 .input_mapping = sony_mapping, 3180 .input_configured = sony_input_configured, 3181 .probe = sony_probe, 3182 .remove = sony_remove, 3183 .report_fixup = sony_report_fixup, 3184 .raw_event = sony_raw_event, 3185 3186 #ifdef CONFIG_PM 3187 .suspend = sony_suspend, 3188 .resume = sony_resume, 3189 .reset_resume = sony_resume, 3190 #endif 3191 }; 3192 3193 static int __init sony_init(void) 3194 { 3195 dbg_hid("Sony:%s\n", __func__); 3196 3197 return hid_register_driver(&sony_driver); 3198 } 3199 3200 static void __exit sony_exit(void) 3201 { 3202 dbg_hid("Sony:%s\n", __func__); 3203 3204 hid_unregister_driver(&sony_driver); 3205 ida_destroy(&sony_device_id_allocator); 3206 } 3207 module_init(sony_init); 3208 module_exit(sony_exit); 3209 3210 MODULE_LICENSE("GPL"); 3211