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