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