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