1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * HID driver for Sony / PS2 / PS3 / PS4 BD devices. 4 * 5 * Copyright (c) 1999 Andreas Gal 6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 8 * Copyright (c) 2008 Jiri Slaby 9 * Copyright (c) 2012 David Dillow <dave@thedillows.org> 10 * Copyright (c) 2006-2013 Jiri Kosina 11 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com> 12 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com> 13 * Copyright (c) 2018 Todd Kelner 14 * Copyright (c) 2020-2021 Pascal Giard <pascal.giard@etsmtl.ca> 15 * Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com> 16 * Copyright (c) 2021 Daniel Nguyen <daniel.nguyen.1@ens.etsmtl.ca> 17 */ 18 19 /* 20 */ 21 22 /* 23 * NOTE: in order for the Sony PS3 BD Remote Control to be found by 24 * a Bluetooth host, the key combination Start+Enter has to be kept pressed 25 * for about 7 seconds with the Bluetooth Host Controller in discovering mode. 26 * 27 * There will be no PIN request from the device. 28 */ 29 30 #include <linux/device.h> 31 #include <linux/hid.h> 32 #include <linux/module.h> 33 #include <linux/slab.h> 34 #include <linux/leds.h> 35 #include <linux/power_supply.h> 36 #include <linux/spinlock.h> 37 #include <linux/list.h> 38 #include <linux/idr.h> 39 #include <linux/input/mt.h> 40 #include <linux/crc32.h> 41 #include <linux/usb.h> 42 #include <linux/timer.h> 43 #include <asm/unaligned.h> 44 45 #include "hid-ids.h" 46 47 #define VAIO_RDESC_CONSTANT BIT(0) 48 #define SIXAXIS_CONTROLLER_USB BIT(1) 49 #define SIXAXIS_CONTROLLER_BT BIT(2) 50 #define BUZZ_CONTROLLER BIT(3) 51 #define PS3REMOTE BIT(4) 52 #define MOTION_CONTROLLER_USB BIT(5) 53 #define MOTION_CONTROLLER_BT BIT(6) 54 #define NAVIGATION_CONTROLLER_USB BIT(7) 55 #define NAVIGATION_CONTROLLER_BT BIT(8) 56 #define SINO_LITE_CONTROLLER BIT(9) 57 #define FUTUREMAX_DANCE_MAT BIT(10) 58 #define NSG_MR5U_REMOTE_BT BIT(11) 59 #define NSG_MR7U_REMOTE_BT BIT(12) 60 #define SHANWAN_GAMEPAD BIT(13) 61 #define GH_GUITAR_CONTROLLER BIT(14) 62 #define GHL_GUITAR_PS3WIIU BIT(15) 63 #define GHL_GUITAR_PS4 BIT(16) 64 65 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT) 66 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT) 67 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\ 68 NAVIGATION_CONTROLLER_BT) 69 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\ 70 MOTION_CONTROLLER | NAVIGATION_CONTROLLER) 71 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER) 72 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER) 73 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT) 74 #define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT) 75 76 #define MAX_LEDS 4 77 #define NSG_MRXU_MAX_X 1667 78 #define NSG_MRXU_MAX_Y 1868 79 80 /* The PS3/Wii U dongles require a poke every 10 seconds, but the PS4 81 * requires one every 8 seconds. Using 8 seconds for all for simplicity. 82 */ 83 #define GHL_GUITAR_POKE_INTERVAL 8 /* In seconds */ 84 #define GUITAR_TILT_USAGE 44 85 86 /* Magic data taken from GHLtarUtility: 87 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs 88 * Note: The Wii U and PS3 dongles happen to share the same! 89 */ 90 static const char ghl_ps3wiiu_magic_data[] = { 91 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00 92 }; 93 94 /* Magic data for the PS4 dongles sniffed with a USB protocol 95 * analyzer. 96 */ 97 static const char ghl_ps4_magic_data[] = { 98 0x30, 0x02, 0x08, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00 99 }; 100 101 /* PS/3 Motion controller */ 102 static u8 motion_rdesc[] = { 103 0x05, 0x01, /* Usage Page (Desktop), */ 104 0x09, 0x04, /* Usage (Joystick), */ 105 0xA1, 0x01, /* Collection (Application), */ 106 0xA1, 0x02, /* Collection (Logical), */ 107 0x85, 0x01, /* Report ID (1), */ 108 0x75, 0x01, /* Report Size (1), */ 109 0x95, 0x15, /* Report Count (21), */ 110 0x15, 0x00, /* Logical Minimum (0), */ 111 0x25, 0x01, /* Logical Maximum (1), */ 112 0x35, 0x00, /* Physical Minimum (0), */ 113 0x45, 0x01, /* Physical Maximum (1), */ 114 0x05, 0x09, /* Usage Page (Button), */ 115 0x19, 0x01, /* Usage Minimum (01h), */ 116 0x29, 0x15, /* Usage Maximum (15h), */ 117 0x81, 0x02, /* Input (Variable), * Buttons */ 118 0x95, 0x0B, /* Report Count (11), */ 119 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 120 0x81, 0x03, /* Input (Constant, Variable), * Padding */ 121 0x15, 0x00, /* Logical Minimum (0), */ 122 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 123 0x05, 0x01, /* Usage Page (Desktop), */ 124 0xA1, 0x00, /* Collection (Physical), */ 125 0x75, 0x08, /* Report Size (8), */ 126 0x95, 0x01, /* Report Count (1), */ 127 0x35, 0x00, /* Physical Minimum (0), */ 128 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 129 0x09, 0x30, /* Usage (X), */ 130 0x81, 0x02, /* Input (Variable), * Trigger */ 131 0xC0, /* End Collection, */ 132 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 133 0x75, 0x08, /* Report Size (8), */ 134 0x95, 0x07, /* Report Count (7), * skip 7 bytes */ 135 0x81, 0x02, /* Input (Variable), */ 136 0x05, 0x01, /* Usage Page (Desktop), */ 137 0x75, 0x10, /* Report Size (16), */ 138 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */ 139 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */ 140 0x95, 0x03, /* Report Count (3), * 3x Accels */ 141 0x09, 0x33, /* Usage (rX), */ 142 0x09, 0x34, /* Usage (rY), */ 143 0x09, 0x35, /* Usage (rZ), */ 144 0x81, 0x02, /* Input (Variable), */ 145 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 146 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */ 147 0x81, 0x02, /* Input (Variable), */ 148 0x05, 0x01, /* Usage Page (Desktop), */ 149 0x09, 0x01, /* Usage (Pointer), */ 150 0x95, 0x03, /* Report Count (3), * 3x Gyros */ 151 0x81, 0x02, /* Input (Variable), */ 152 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 153 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */ 154 0x81, 0x02, /* Input (Variable), */ 155 0x75, 0x0C, /* Report Size (12), */ 156 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */ 157 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */ 158 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */ 159 0x81, 0x02, /* Input (Variable), */ 160 0x75, 0x08, /* Report Size (8), */ 161 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 162 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 163 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */ 164 0x81, 0x02, /* Input (Variable), */ 165 0x75, 0x08, /* Report Size (8), */ 166 0x95, 0x30, /* Report Count (48), */ 167 0x09, 0x01, /* Usage (Pointer), */ 168 0x91, 0x02, /* Output (Variable), */ 169 0x75, 0x08, /* Report Size (8), */ 170 0x95, 0x30, /* Report Count (48), */ 171 0x09, 0x01, /* Usage (Pointer), */ 172 0xB1, 0x02, /* Feature (Variable), */ 173 0xC0, /* End Collection, */ 174 0xA1, 0x02, /* Collection (Logical), */ 175 0x85, 0x02, /* Report ID (2), */ 176 0x75, 0x08, /* Report Size (8), */ 177 0x95, 0x30, /* Report Count (48), */ 178 0x09, 0x01, /* Usage (Pointer), */ 179 0xB1, 0x02, /* Feature (Variable), */ 180 0xC0, /* End Collection, */ 181 0xA1, 0x02, /* Collection (Logical), */ 182 0x85, 0xEE, /* Report ID (238), */ 183 0x75, 0x08, /* Report Size (8), */ 184 0x95, 0x30, /* Report Count (48), */ 185 0x09, 0x01, /* Usage (Pointer), */ 186 0xB1, 0x02, /* Feature (Variable), */ 187 0xC0, /* End Collection, */ 188 0xA1, 0x02, /* Collection (Logical), */ 189 0x85, 0xEF, /* Report ID (239), */ 190 0x75, 0x08, /* Report Size (8), */ 191 0x95, 0x30, /* Report Count (48), */ 192 0x09, 0x01, /* Usage (Pointer), */ 193 0xB1, 0x02, /* Feature (Variable), */ 194 0xC0, /* End Collection, */ 195 0xC0 /* End Collection */ 196 }; 197 198 static u8 ps3remote_rdesc[] = { 199 0x05, 0x01, /* GUsagePage Generic Desktop */ 200 0x09, 0x05, /* LUsage 0x05 [Game Pad] */ 201 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */ 202 203 /* Use collection 1 for joypad buttons */ 204 0xA1, 0x02, /* MCollection Logical (interrelated data) */ 205 206 /* 207 * Ignore the 1st byte, maybe it is used for a controller 208 * number but it's not needed for correct operation 209 */ 210 0x75, 0x08, /* GReportSize 0x08 [8] */ 211 0x95, 0x01, /* GReportCount 0x01 [1] */ 212 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */ 213 214 /* 215 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these 216 * buttons multiple keypresses are allowed 217 */ 218 0x05, 0x09, /* GUsagePage Button */ 219 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */ 220 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */ 221 0x14, /* GLogicalMinimum [0] */ 222 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */ 223 0x75, 0x01, /* GReportSize 0x01 [1] */ 224 0x95, 0x18, /* GReportCount 0x18 [24] */ 225 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */ 226 227 0xC0, /* MEndCollection */ 228 229 /* Use collection 2 for remote control buttons */ 230 0xA1, 0x02, /* MCollection Logical (interrelated data) */ 231 232 /* 5th byte is used for remote control buttons */ 233 0x05, 0x09, /* GUsagePage Button */ 234 0x18, /* LUsageMinimum [No button pressed] */ 235 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */ 236 0x14, /* GLogicalMinimum [0] */ 237 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */ 238 0x75, 0x08, /* GReportSize 0x08 [8] */ 239 0x95, 0x01, /* GReportCount 0x01 [1] */ 240 0x80, /* MInput */ 241 242 /* 243 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at 244 * 0xff and 11th is for press indication 245 */ 246 0x75, 0x08, /* GReportSize 0x08 [8] */ 247 0x95, 0x06, /* GReportCount 0x06 [6] */ 248 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */ 249 250 /* 12th byte is for battery strength */ 251 0x05, 0x06, /* GUsagePage Generic Device Controls */ 252 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */ 253 0x14, /* GLogicalMinimum [0] */ 254 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */ 255 0x75, 0x08, /* GReportSize 0x08 [8] */ 256 0x95, 0x01, /* GReportCount 0x01 [1] */ 257 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */ 258 259 0xC0, /* MEndCollection */ 260 261 0xC0 /* MEndCollection [Game Pad] */ 262 }; 263 264 static const unsigned int ps3remote_keymap_joypad_buttons[] = { 265 [0x01] = KEY_SELECT, 266 [0x02] = BTN_THUMBL, /* L3 */ 267 [0x03] = BTN_THUMBR, /* R3 */ 268 [0x04] = BTN_START, 269 [0x05] = KEY_UP, 270 [0x06] = KEY_RIGHT, 271 [0x07] = KEY_DOWN, 272 [0x08] = KEY_LEFT, 273 [0x09] = BTN_TL2, /* L2 */ 274 [0x0a] = BTN_TR2, /* R2 */ 275 [0x0b] = BTN_TL, /* L1 */ 276 [0x0c] = BTN_TR, /* R1 */ 277 [0x0d] = KEY_OPTION, /* options/triangle */ 278 [0x0e] = KEY_BACK, /* back/circle */ 279 [0x0f] = BTN_0, /* cross */ 280 [0x10] = KEY_SCREEN, /* view/square */ 281 [0x11] = KEY_HOMEPAGE, /* PS button */ 282 [0x14] = KEY_ENTER, 283 }; 284 static const unsigned int ps3remote_keymap_remote_buttons[] = { 285 [0x00] = KEY_1, 286 [0x01] = KEY_2, 287 [0x02] = KEY_3, 288 [0x03] = KEY_4, 289 [0x04] = KEY_5, 290 [0x05] = KEY_6, 291 [0x06] = KEY_7, 292 [0x07] = KEY_8, 293 [0x08] = KEY_9, 294 [0x09] = KEY_0, 295 [0x0e] = KEY_ESC, /* return */ 296 [0x0f] = KEY_CLEAR, 297 [0x16] = KEY_EJECTCD, 298 [0x1a] = KEY_MENU, /* top menu */ 299 [0x28] = KEY_TIME, 300 [0x30] = KEY_PREVIOUS, 301 [0x31] = KEY_NEXT, 302 [0x32] = KEY_PLAY, 303 [0x33] = KEY_REWIND, /* scan back */ 304 [0x34] = KEY_FORWARD, /* scan forward */ 305 [0x38] = KEY_STOP, 306 [0x39] = KEY_PAUSE, 307 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */ 308 [0x60] = KEY_FRAMEBACK, /* slow/step back */ 309 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */ 310 [0x63] = KEY_SUBTITLE, 311 [0x64] = KEY_AUDIO, 312 [0x65] = KEY_ANGLE, 313 [0x70] = KEY_INFO, /* display */ 314 [0x80] = KEY_BLUE, 315 [0x81] = KEY_RED, 316 [0x82] = KEY_GREEN, 317 [0x83] = KEY_YELLOW, 318 }; 319 320 static const unsigned int buzz_keymap[] = { 321 /* 322 * The controller has 4 remote buzzers, each with one LED and 5 323 * buttons. 324 * 325 * We use the mapping chosen by the controller, which is: 326 * 327 * Key Offset 328 * ------------------- 329 * Buzz 1 330 * Blue 5 331 * Orange 4 332 * Green 3 333 * Yellow 2 334 * 335 * So, for example, the orange button on the third buzzer is mapped to 336 * BTN_TRIGGER_HAPPY14 337 */ 338 [1] = BTN_TRIGGER_HAPPY1, 339 [2] = BTN_TRIGGER_HAPPY2, 340 [3] = BTN_TRIGGER_HAPPY3, 341 [4] = BTN_TRIGGER_HAPPY4, 342 [5] = BTN_TRIGGER_HAPPY5, 343 [6] = BTN_TRIGGER_HAPPY6, 344 [7] = BTN_TRIGGER_HAPPY7, 345 [8] = BTN_TRIGGER_HAPPY8, 346 [9] = BTN_TRIGGER_HAPPY9, 347 [10] = BTN_TRIGGER_HAPPY10, 348 [11] = BTN_TRIGGER_HAPPY11, 349 [12] = BTN_TRIGGER_HAPPY12, 350 [13] = BTN_TRIGGER_HAPPY13, 351 [14] = BTN_TRIGGER_HAPPY14, 352 [15] = BTN_TRIGGER_HAPPY15, 353 [16] = BTN_TRIGGER_HAPPY16, 354 [17] = BTN_TRIGGER_HAPPY17, 355 [18] = BTN_TRIGGER_HAPPY18, 356 [19] = BTN_TRIGGER_HAPPY19, 357 [20] = BTN_TRIGGER_HAPPY20, 358 }; 359 360 /* The Navigation controller is a partial DS3 and uses the same HID report 361 * and hence the same keymap indices, however not all axes/buttons 362 * are physically present. We use the same axis and button mapping as 363 * the DS3, which uses the Linux gamepad spec. 364 */ 365 static const unsigned int navigation_absmap[] = { 366 [0x30] = ABS_X, 367 [0x31] = ABS_Y, 368 [0x33] = ABS_Z, /* L2 */ 369 }; 370 371 /* Buttons not physically available on the device, but still available 372 * in the reports are explicitly set to 0 for documentation purposes. 373 */ 374 static const unsigned int navigation_keymap[] = { 375 [0x01] = 0, /* Select */ 376 [0x02] = BTN_THUMBL, /* L3 */ 377 [0x03] = 0, /* R3 */ 378 [0x04] = 0, /* Start */ 379 [0x05] = BTN_DPAD_UP, /* Up */ 380 [0x06] = BTN_DPAD_RIGHT, /* Right */ 381 [0x07] = BTN_DPAD_DOWN, /* Down */ 382 [0x08] = BTN_DPAD_LEFT, /* Left */ 383 [0x09] = BTN_TL2, /* L2 */ 384 [0x0a] = 0, /* R2 */ 385 [0x0b] = BTN_TL, /* L1 */ 386 [0x0c] = 0, /* R1 */ 387 [0x0d] = BTN_NORTH, /* Triangle */ 388 [0x0e] = BTN_EAST, /* Circle */ 389 [0x0f] = BTN_SOUTH, /* Cross */ 390 [0x10] = BTN_WEST, /* Square */ 391 [0x11] = BTN_MODE, /* PS */ 392 }; 393 394 static const unsigned int sixaxis_absmap[] = { 395 [0x30] = ABS_X, 396 [0x31] = ABS_Y, 397 [0x32] = ABS_RX, /* right stick X */ 398 [0x35] = ABS_RY, /* right stick Y */ 399 }; 400 401 static const unsigned int sixaxis_keymap[] = { 402 [0x01] = BTN_SELECT, /* Select */ 403 [0x02] = BTN_THUMBL, /* L3 */ 404 [0x03] = BTN_THUMBR, /* R3 */ 405 [0x04] = BTN_START, /* Start */ 406 [0x05] = BTN_DPAD_UP, /* Up */ 407 [0x06] = BTN_DPAD_RIGHT, /* Right */ 408 [0x07] = BTN_DPAD_DOWN, /* Down */ 409 [0x08] = BTN_DPAD_LEFT, /* Left */ 410 [0x09] = BTN_TL2, /* L2 */ 411 [0x0a] = BTN_TR2, /* R2 */ 412 [0x0b] = BTN_TL, /* L1 */ 413 [0x0c] = BTN_TR, /* R1 */ 414 [0x0d] = BTN_NORTH, /* Triangle */ 415 [0x0e] = BTN_EAST, /* Circle */ 416 [0x0f] = BTN_SOUTH, /* Cross */ 417 [0x10] = BTN_WEST, /* Square */ 418 [0x11] = BTN_MODE, /* PS */ 419 }; 420 421 static enum power_supply_property sony_battery_props[] = { 422 POWER_SUPPLY_PROP_PRESENT, 423 POWER_SUPPLY_PROP_CAPACITY, 424 POWER_SUPPLY_PROP_SCOPE, 425 POWER_SUPPLY_PROP_STATUS, 426 }; 427 428 struct sixaxis_led { 429 u8 time_enabled; /* the total time the led is active (0xff means forever) */ 430 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */ 431 u8 enabled; 432 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */ 433 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */ 434 } __packed; 435 436 struct sixaxis_rumble { 437 u8 padding; 438 u8 right_duration; /* Right motor duration (0xff means forever) */ 439 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */ 440 u8 left_duration; /* Left motor duration (0xff means forever) */ 441 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */ 442 } __packed; 443 444 struct sixaxis_output_report { 445 u8 report_id; 446 struct sixaxis_rumble rumble; 447 u8 padding[4]; 448 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */ 449 struct sixaxis_led led[4]; /* LEDx at (4 - x) */ 450 struct sixaxis_led _reserved; /* LED5, not actually soldered */ 451 } __packed; 452 453 union sixaxis_output_report_01 { 454 struct sixaxis_output_report data; 455 u8 buf[36]; 456 }; 457 458 struct motion_output_report_02 { 459 u8 type, zero; 460 u8 r, g, b; 461 u8 zero2; 462 u8 rumble; 463 }; 464 465 #define SIXAXIS_REPORT_0xF2_SIZE 17 466 #define SIXAXIS_REPORT_0xF5_SIZE 8 467 #define MOTION_REPORT_0x02_SIZE 49 468 469 #define SENSOR_SUFFIX " Motion Sensors" 470 #define TOUCHPAD_SUFFIX " Touchpad" 471 472 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41 473 #define SIXAXIS_ACC_RES_PER_G 113 474 475 static DEFINE_SPINLOCK(sony_dev_list_lock); 476 static LIST_HEAD(sony_device_list); 477 static DEFINE_IDA(sony_device_id_allocator); 478 479 enum sony_worker { 480 SONY_WORKER_STATE 481 }; 482 483 struct sony_sc { 484 spinlock_t lock; 485 struct list_head list_node; 486 struct hid_device *hdev; 487 struct input_dev *touchpad; 488 struct input_dev *sensor_dev; 489 struct led_classdev *leds[MAX_LEDS]; 490 unsigned long quirks; 491 struct work_struct state_worker; 492 void (*send_output_report)(struct sony_sc *); 493 struct power_supply *battery; 494 struct power_supply_desc battery_desc; 495 int device_id; 496 u8 *output_report_dmabuf; 497 498 #ifdef CONFIG_SONY_FF 499 u8 left; 500 u8 right; 501 #endif 502 503 u8 mac_address[6]; 504 u8 state_worker_initialized; 505 u8 defer_initialization; 506 u8 battery_capacity; 507 int battery_status; 508 u8 led_state[MAX_LEDS]; 509 u8 led_delay_on[MAX_LEDS]; 510 u8 led_delay_off[MAX_LEDS]; 511 u8 led_count; 512 513 /* GH Live */ 514 struct urb *ghl_urb; 515 struct timer_list ghl_poke_timer; 516 }; 517 518 static void sony_set_leds(struct sony_sc *sc); 519 520 static inline void sony_schedule_work(struct sony_sc *sc, 521 enum sony_worker which) 522 { 523 unsigned long flags; 524 525 switch (which) { 526 case SONY_WORKER_STATE: 527 spin_lock_irqsave(&sc->lock, flags); 528 if (!sc->defer_initialization && sc->state_worker_initialized) 529 schedule_work(&sc->state_worker); 530 spin_unlock_irqrestore(&sc->lock, flags); 531 break; 532 } 533 } 534 535 static void ghl_magic_poke_cb(struct urb *urb) 536 { 537 struct sony_sc *sc = urb->context; 538 539 if (urb->status < 0) 540 hid_err(sc->hdev, "URB transfer failed : %d", urb->status); 541 542 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ); 543 } 544 545 static void ghl_magic_poke(struct timer_list *t) 546 { 547 int ret; 548 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer); 549 550 ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC); 551 if (ret < 0) 552 hid_err(sc->hdev, "usb_submit_urb failed: %d", ret); 553 } 554 555 static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev, 556 const char ghl_magic_data[], u16 poke_size) 557 { 558 struct usb_ctrlrequest *cr; 559 u8 *databuf; 560 unsigned int pipe; 561 u16 ghl_magic_value = (((HID_OUTPUT_REPORT + 1) << 8) | ghl_magic_data[0]); 562 563 pipe = usb_sndctrlpipe(usbdev, 0); 564 565 cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC); 566 if (cr == NULL) 567 return -ENOMEM; 568 569 databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC); 570 if (databuf == NULL) 571 return -ENOMEM; 572 573 cr->bRequestType = 574 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT; 575 cr->bRequest = USB_REQ_SET_CONFIGURATION; 576 cr->wValue = cpu_to_le16(ghl_magic_value); 577 cr->wIndex = 0; 578 cr->wLength = cpu_to_le16(poke_size); 579 memcpy(databuf, ghl_magic_data, poke_size); 580 usb_fill_control_urb( 581 sc->ghl_urb, usbdev, pipe, 582 (unsigned char *) cr, databuf, poke_size, 583 ghl_magic_poke_cb, sc); 584 return 0; 585 } 586 587 static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi, 588 struct hid_field *field, struct hid_usage *usage, 589 unsigned long **bit, int *max) 590 { 591 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) { 592 unsigned int abs = usage->hid & HID_USAGE; 593 594 if (abs == GUITAR_TILT_USAGE) { 595 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY); 596 return 1; 597 } 598 } 599 return 0; 600 } 601 602 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc, 603 unsigned int *rsize) 604 { 605 *rsize = sizeof(motion_rdesc); 606 return motion_rdesc; 607 } 608 609 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc, 610 unsigned int *rsize) 611 { 612 *rsize = sizeof(ps3remote_rdesc); 613 return ps3remote_rdesc; 614 } 615 616 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi, 617 struct hid_field *field, struct hid_usage *usage, 618 unsigned long **bit, int *max) 619 { 620 unsigned int key = usage->hid & HID_USAGE; 621 622 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 623 return -1; 624 625 switch (usage->collection_index) { 626 case 1: 627 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons)) 628 return -1; 629 630 key = ps3remote_keymap_joypad_buttons[key]; 631 if (!key) 632 return -1; 633 break; 634 case 2: 635 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons)) 636 return -1; 637 638 key = ps3remote_keymap_remote_buttons[key]; 639 if (!key) 640 return -1; 641 break; 642 default: 643 return -1; 644 } 645 646 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 647 return 1; 648 } 649 650 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi, 651 struct hid_field *field, struct hid_usage *usage, 652 unsigned long **bit, int *max) 653 { 654 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 655 unsigned int key = usage->hid & HID_USAGE; 656 657 if (key >= ARRAY_SIZE(sixaxis_keymap)) 658 return -1; 659 660 key = navigation_keymap[key]; 661 if (!key) 662 return -1; 663 664 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 665 return 1; 666 } else if (usage->hid == HID_GD_POINTER) { 667 /* See comment in sixaxis_mapping, basically the L2 (and R2) 668 * triggers are reported through GD Pointer. 669 * In addition we ignore any analog button 'axes' and only 670 * support digital buttons. 671 */ 672 switch (usage->usage_index) { 673 case 8: /* L2 */ 674 usage->hid = HID_GD_Z; 675 break; 676 default: 677 return -1; 678 } 679 680 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf); 681 return 1; 682 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) { 683 unsigned int abs = usage->hid & HID_USAGE; 684 685 if (abs >= ARRAY_SIZE(navigation_absmap)) 686 return -1; 687 688 abs = navigation_absmap[abs]; 689 690 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs); 691 return 1; 692 } 693 694 return -1; 695 } 696 697 698 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi, 699 struct hid_field *field, struct hid_usage *usage, 700 unsigned long **bit, int *max) 701 { 702 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 703 unsigned int key = usage->hid & HID_USAGE; 704 705 if (key >= ARRAY_SIZE(sixaxis_keymap)) 706 return -1; 707 708 key = sixaxis_keymap[key]; 709 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 710 return 1; 711 } else if (usage->hid == HID_GD_POINTER) { 712 /* The DS3 provides analog values for most buttons and even 713 * for HAT axes through GD Pointer. L2 and R2 are reported 714 * among these as well instead of as GD Z / RZ. Remap L2 715 * and R2 and ignore other analog 'button axes' as there is 716 * no good way for reporting them. 717 */ 718 switch (usage->usage_index) { 719 case 8: /* L2 */ 720 usage->hid = HID_GD_Z; 721 break; 722 case 9: /* R2 */ 723 usage->hid = HID_GD_RZ; 724 break; 725 default: 726 return -1; 727 } 728 729 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf); 730 return 1; 731 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) { 732 unsigned int abs = usage->hid & HID_USAGE; 733 734 if (abs >= ARRAY_SIZE(sixaxis_absmap)) 735 return -1; 736 737 abs = sixaxis_absmap[abs]; 738 739 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs); 740 return 1; 741 } 742 743 return -1; 744 } 745 746 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc, 747 unsigned int *rsize) 748 { 749 struct sony_sc *sc = hid_get_drvdata(hdev); 750 751 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT)) 752 return rdesc; 753 754 /* 755 * Some Sony RF receivers wrongly declare the mouse pointer as a 756 * a constant non-data variable. 757 */ 758 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 && 759 /* usage page: generic desktop controls */ 760 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */ 761 /* usage: mouse */ 762 rdesc[2] == 0x09 && rdesc[3] == 0x02 && 763 /* input (usage page for x,y axes): constant, variable, relative */ 764 rdesc[54] == 0x81 && rdesc[55] == 0x07) { 765 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n"); 766 /* input: data, variable, relative */ 767 rdesc[55] = 0x06; 768 } 769 770 if (sc->quirks & MOTION_CONTROLLER) 771 return motion_fixup(hdev, rdesc, rsize); 772 773 if (sc->quirks & PS3REMOTE) 774 return ps3remote_fixup(hdev, rdesc, rsize); 775 776 /* 777 * Some knock-off USB dongles incorrectly report their button count 778 * as 13 instead of 16 causing three non-functional buttons. 779 */ 780 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 && 781 /* Report Count (13) */ 782 rdesc[23] == 0x95 && rdesc[24] == 0x0D && 783 /* Usage Maximum (13) */ 784 rdesc[37] == 0x29 && rdesc[38] == 0x0D && 785 /* Report Count (3) */ 786 rdesc[43] == 0x95 && rdesc[44] == 0x03) { 787 hid_info(hdev, "Fixing up USB dongle report descriptor\n"); 788 rdesc[24] = 0x10; 789 rdesc[38] = 0x10; 790 rdesc[44] = 0x00; 791 } 792 793 return rdesc; 794 } 795 796 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size) 797 { 798 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 }; 799 unsigned long flags; 800 int offset; 801 u8 battery_capacity; 802 int battery_status; 803 804 /* 805 * The sixaxis is charging if the battery value is 0xee 806 * and it is fully charged if the value is 0xef. 807 * It does not report the actual level while charging so it 808 * is set to 100% while charging is in progress. 809 */ 810 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30; 811 812 if (rd[offset] >= 0xee) { 813 battery_capacity = 100; 814 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING; 815 } else { 816 u8 index = rd[offset] <= 5 ? rd[offset] : 5; 817 battery_capacity = sixaxis_battery_capacity[index]; 818 battery_status = POWER_SUPPLY_STATUS_DISCHARGING; 819 } 820 821 spin_lock_irqsave(&sc->lock, flags); 822 sc->battery_capacity = battery_capacity; 823 sc->battery_status = battery_status; 824 spin_unlock_irqrestore(&sc->lock, flags); 825 826 if (sc->quirks & SIXAXIS_CONTROLLER) { 827 int val; 828 829 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET; 830 val = ((rd[offset+1] << 8) | rd[offset]) - 511; 831 input_report_abs(sc->sensor_dev, ABS_X, val); 832 833 /* Y and Z are swapped and inversed */ 834 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]); 835 input_report_abs(sc->sensor_dev, ABS_Y, val); 836 837 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]); 838 input_report_abs(sc->sensor_dev, ABS_Z, val); 839 840 input_sync(sc->sensor_dev); 841 } 842 } 843 844 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size) 845 { 846 int n, offset, relx, rely; 847 u8 active; 848 849 /* 850 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and 851 * the touch-related data starts at offset 2. 852 * For the first byte, bit 0 is set when touchpad button is pressed. 853 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed. 854 * This drag key is mapped to BTN_LEFT. It is operational only when a 855 * touch point is active. 856 * Bit 4 is set when only the first touch point is active. 857 * Bit 6 is set when only the second touch point is active. 858 * Bits 5 and 7 are set when both touch points are active. 859 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch. 860 * The following byte, offset 5, has the touch width and length. 861 * Bits 0-4=X (width), bits 5-7=Y (length). 862 * A signed relative X coordinate is at offset 6. 863 * The bytes at offset 7-9 are the second touch X/Y coordinates. 864 * Offset 10 has the second touch width and length. 865 * Offset 11 has the relative Y coordinate. 866 */ 867 offset = 1; 868 869 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F); 870 active = (rd[offset] >> 4); 871 relx = (s8) rd[offset+5]; 872 rely = ((s8) rd[offset+10]) * -1; 873 874 offset++; 875 876 for (n = 0; n < 2; n++) { 877 u16 x, y; 878 u8 contactx, contacty; 879 880 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8); 881 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4); 882 883 input_mt_slot(sc->touchpad, n); 884 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03); 885 886 if (active & 0x03) { 887 contactx = rd[offset+3] & 0x0F; 888 contacty = rd[offset+3] >> 4; 889 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR, 890 max(contactx, contacty)); 891 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR, 892 min(contactx, contacty)); 893 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION, 894 (bool) (contactx > contacty)); 895 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x); 896 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, 897 NSG_MRXU_MAX_Y - y); 898 /* 899 * The relative coordinates belong to the first touch 900 * point, when present, or to the second touch point 901 * when the first is not active. 902 */ 903 if ((n == 0) || ((n == 1) && (active & 0x01))) { 904 input_report_rel(sc->touchpad, REL_X, relx); 905 input_report_rel(sc->touchpad, REL_Y, rely); 906 } 907 } 908 909 offset += 5; 910 active >>= 2; 911 } 912 913 input_mt_sync_frame(sc->touchpad); 914 915 input_sync(sc->touchpad); 916 } 917 918 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report, 919 u8 *rd, int size) 920 { 921 struct sony_sc *sc = hid_get_drvdata(hdev); 922 923 /* 924 * Sixaxis HID report has acclerometers/gyro with MSByte first, this 925 * has to be BYTE_SWAPPED before passing up to joystick interface 926 */ 927 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) { 928 /* 929 * When connected via Bluetooth the Sixaxis occasionally sends 930 * a report with the second byte 0xff and the rest zeroed. 931 * 932 * This report does not reflect the actual state of the 933 * controller must be ignored to avoid generating false input 934 * events. 935 */ 936 if (rd[1] == 0xff) 937 return -EINVAL; 938 939 swap(rd[41], rd[42]); 940 swap(rd[43], rd[44]); 941 swap(rd[45], rd[46]); 942 swap(rd[47], rd[48]); 943 944 sixaxis_parse_report(sc, rd, size); 945 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) { 946 sixaxis_parse_report(sc, rd, size); 947 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 && 948 size == 49) { 949 sixaxis_parse_report(sc, rd, size); 950 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) { 951 nsg_mrxu_parse_report(sc, rd, size); 952 return 1; 953 } 954 955 if (sc->defer_initialization) { 956 sc->defer_initialization = 0; 957 sony_schedule_work(sc, SONY_WORKER_STATE); 958 } 959 960 return 0; 961 } 962 963 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi, 964 struct hid_field *field, struct hid_usage *usage, 965 unsigned long **bit, int *max) 966 { 967 struct sony_sc *sc = hid_get_drvdata(hdev); 968 969 if (sc->quirks & BUZZ_CONTROLLER) { 970 unsigned int key = usage->hid & HID_USAGE; 971 972 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 973 return -1; 974 975 switch (usage->collection_index) { 976 case 1: 977 if (key >= ARRAY_SIZE(buzz_keymap)) 978 return -1; 979 980 key = buzz_keymap[key]; 981 if (!key) 982 return -1; 983 break; 984 default: 985 return -1; 986 } 987 988 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 989 return 1; 990 } 991 992 if (sc->quirks & PS3REMOTE) 993 return ps3remote_mapping(hdev, hi, field, usage, bit, max); 994 995 if (sc->quirks & NAVIGATION_CONTROLLER) 996 return navigation_mapping(hdev, hi, field, usage, bit, max); 997 998 if (sc->quirks & SIXAXIS_CONTROLLER) 999 return sixaxis_mapping(hdev, hi, field, usage, bit, max); 1000 1001 if (sc->quirks & GH_GUITAR_CONTROLLER) 1002 return guitar_mapping(hdev, hi, field, usage, bit, max); 1003 1004 /* Let hid-core decide for the others */ 1005 return 0; 1006 } 1007 1008 static int sony_register_touchpad(struct sony_sc *sc, int touch_count, 1009 int w, int h, int touch_major, int touch_minor, int orientation) 1010 { 1011 size_t name_sz; 1012 char *name; 1013 int ret; 1014 1015 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev); 1016 if (!sc->touchpad) 1017 return -ENOMEM; 1018 1019 input_set_drvdata(sc->touchpad, sc); 1020 sc->touchpad->dev.parent = &sc->hdev->dev; 1021 sc->touchpad->phys = sc->hdev->phys; 1022 sc->touchpad->uniq = sc->hdev->uniq; 1023 sc->touchpad->id.bustype = sc->hdev->bus; 1024 sc->touchpad->id.vendor = sc->hdev->vendor; 1025 sc->touchpad->id.product = sc->hdev->product; 1026 sc->touchpad->id.version = sc->hdev->version; 1027 1028 /* This suffix was originally apended when hid-sony also 1029 * supported DS4 devices. The DS4 was implemented using multiple 1030 * evdev nodes and hence had the need to separete them out using 1031 * a suffix. Other devices which were added later like Sony TV remotes 1032 * inhirited this suffix. 1033 */ 1034 name_sz = strlen(sc->hdev->name) + sizeof(TOUCHPAD_SUFFIX); 1035 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL); 1036 if (!name) 1037 return -ENOMEM; 1038 snprintf(name, name_sz, "%s" TOUCHPAD_SUFFIX, sc->hdev->name); 1039 sc->touchpad->name = name; 1040 1041 /* We map the button underneath the touchpad to BTN_LEFT. */ 1042 __set_bit(EV_KEY, sc->touchpad->evbit); 1043 __set_bit(BTN_LEFT, sc->touchpad->keybit); 1044 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit); 1045 1046 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0); 1047 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0); 1048 1049 if (touch_major > 0) { 1050 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR, 1051 0, touch_major, 0, 0); 1052 if (touch_minor > 0) 1053 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR, 1054 0, touch_minor, 0, 0); 1055 if (orientation > 0) 1056 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION, 1057 0, orientation, 0, 0); 1058 } 1059 1060 if (sc->quirks & NSG_MRXU_REMOTE) { 1061 __set_bit(EV_REL, sc->touchpad->evbit); 1062 } 1063 1064 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER); 1065 if (ret < 0) 1066 return ret; 1067 1068 ret = input_register_device(sc->touchpad); 1069 if (ret < 0) 1070 return ret; 1071 1072 return 0; 1073 } 1074 1075 static int sony_register_sensors(struct sony_sc *sc) 1076 { 1077 size_t name_sz; 1078 char *name; 1079 int ret; 1080 1081 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev); 1082 if (!sc->sensor_dev) 1083 return -ENOMEM; 1084 1085 input_set_drvdata(sc->sensor_dev, sc); 1086 sc->sensor_dev->dev.parent = &sc->hdev->dev; 1087 sc->sensor_dev->phys = sc->hdev->phys; 1088 sc->sensor_dev->uniq = sc->hdev->uniq; 1089 sc->sensor_dev->id.bustype = sc->hdev->bus; 1090 sc->sensor_dev->id.vendor = sc->hdev->vendor; 1091 sc->sensor_dev->id.product = sc->hdev->product; 1092 sc->sensor_dev->id.version = sc->hdev->version; 1093 1094 /* Append a suffix to the controller name as there are various 1095 * DS4 compatible non-Sony devices with different names. 1096 */ 1097 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX); 1098 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL); 1099 if (!name) 1100 return -ENOMEM; 1101 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name); 1102 sc->sensor_dev->name = name; 1103 1104 if (sc->quirks & SIXAXIS_CONTROLLER) { 1105 /* For the DS3 we only support the accelerometer, which works 1106 * quite well even without calibration. The device also has 1107 * a 1-axis gyro, but it is very difficult to manage from within 1108 * the driver even to get data, the sensor is inaccurate and 1109 * the behavior is very different between hardware revisions. 1110 */ 1111 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0); 1112 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0); 1113 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0); 1114 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G); 1115 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G); 1116 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G); 1117 } 1118 1119 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit); 1120 1121 ret = input_register_device(sc->sensor_dev); 1122 if (ret < 0) 1123 return ret; 1124 1125 return 0; 1126 } 1127 1128 /* 1129 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller 1130 * to "operational". Without this, the ps3 controller will not report any 1131 * events. 1132 */ 1133 static int sixaxis_set_operational_usb(struct hid_device *hdev) 1134 { 1135 struct sony_sc *sc = hid_get_drvdata(hdev); 1136 const int buf_size = 1137 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE); 1138 u8 *buf; 1139 int ret; 1140 1141 buf = kmalloc(buf_size, GFP_KERNEL); 1142 if (!buf) 1143 return -ENOMEM; 1144 1145 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE, 1146 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1147 if (ret < 0) { 1148 hid_err(hdev, "can't set operational mode: step 1\n"); 1149 goto out; 1150 } 1151 1152 /* 1153 * Some compatible controllers like the Speedlink Strike FX and 1154 * Gasia need another query plus an USB interrupt to get operational. 1155 */ 1156 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE, 1157 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1158 if (ret < 0) { 1159 hid_err(hdev, "can't set operational mode: step 2\n"); 1160 goto out; 1161 } 1162 1163 /* 1164 * But the USB interrupt would cause SHANWAN controllers to 1165 * start rumbling non-stop, so skip step 3 for these controllers. 1166 */ 1167 if (sc->quirks & SHANWAN_GAMEPAD) 1168 goto out; 1169 1170 ret = hid_hw_output_report(hdev, buf, 1); 1171 if (ret < 0) { 1172 hid_info(hdev, "can't set operational mode: step 3, ignoring\n"); 1173 ret = 0; 1174 } 1175 1176 out: 1177 kfree(buf); 1178 1179 return ret; 1180 } 1181 1182 static int sixaxis_set_operational_bt(struct hid_device *hdev) 1183 { 1184 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 }; 1185 u8 *buf; 1186 int ret; 1187 1188 buf = kmemdup(report, sizeof(report), GFP_KERNEL); 1189 if (!buf) 1190 return -ENOMEM; 1191 1192 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report), 1193 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 1194 1195 kfree(buf); 1196 1197 return ret; 1198 } 1199 1200 static void sixaxis_set_leds_from_id(struct sony_sc *sc) 1201 { 1202 static const u8 sixaxis_leds[10][4] = { 1203 { 0x01, 0x00, 0x00, 0x00 }, 1204 { 0x00, 0x01, 0x00, 0x00 }, 1205 { 0x00, 0x00, 0x01, 0x00 }, 1206 { 0x00, 0x00, 0x00, 0x01 }, 1207 { 0x01, 0x00, 0x00, 0x01 }, 1208 { 0x00, 0x01, 0x00, 0x01 }, 1209 { 0x00, 0x00, 0x01, 0x01 }, 1210 { 0x01, 0x00, 0x01, 0x01 }, 1211 { 0x00, 0x01, 0x01, 0x01 }, 1212 { 0x01, 0x01, 0x01, 0x01 } 1213 }; 1214 1215 int id = sc->device_id; 1216 1217 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0])); 1218 1219 if (id < 0) 1220 return; 1221 1222 id %= 10; 1223 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id])); 1224 } 1225 1226 static void buzz_set_leds(struct sony_sc *sc) 1227 { 1228 struct hid_device *hdev = sc->hdev; 1229 struct list_head *report_list = 1230 &hdev->report_enum[HID_OUTPUT_REPORT].report_list; 1231 struct hid_report *report = list_entry(report_list->next, 1232 struct hid_report, list); 1233 s32 *value = report->field[0]->value; 1234 1235 BUILD_BUG_ON(MAX_LEDS < 4); 1236 1237 value[0] = 0x00; 1238 value[1] = sc->led_state[0] ? 0xff : 0x00; 1239 value[2] = sc->led_state[1] ? 0xff : 0x00; 1240 value[3] = sc->led_state[2] ? 0xff : 0x00; 1241 value[4] = sc->led_state[3] ? 0xff : 0x00; 1242 value[5] = 0x00; 1243 value[6] = 0x00; 1244 hid_hw_request(hdev, report, HID_REQ_SET_REPORT); 1245 } 1246 1247 static void sony_set_leds(struct sony_sc *sc) 1248 { 1249 if (!(sc->quirks & BUZZ_CONTROLLER)) 1250 sony_schedule_work(sc, SONY_WORKER_STATE); 1251 else 1252 buzz_set_leds(sc); 1253 } 1254 1255 static void sony_led_set_brightness(struct led_classdev *led, 1256 enum led_brightness value) 1257 { 1258 struct device *dev = led->dev->parent; 1259 struct hid_device *hdev = to_hid_device(dev); 1260 struct sony_sc *drv_data; 1261 1262 int n; 1263 int force_update; 1264 1265 drv_data = hid_get_drvdata(hdev); 1266 if (!drv_data) { 1267 hid_err(hdev, "No device data\n"); 1268 return; 1269 } 1270 1271 /* 1272 * The Sixaxis on USB will override any LED settings sent to it 1273 * and keep flashing all of the LEDs until the PS button is pressed. 1274 * Updates, even if redundant, must be always be sent to the 1275 * controller to avoid having to toggle the state of an LED just to 1276 * stop the flashing later on. 1277 */ 1278 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB); 1279 1280 for (n = 0; n < drv_data->led_count; n++) { 1281 if (led == drv_data->leds[n] && (force_update || 1282 (value != drv_data->led_state[n] || 1283 drv_data->led_delay_on[n] || 1284 drv_data->led_delay_off[n]))) { 1285 1286 drv_data->led_state[n] = value; 1287 1288 /* Setting the brightness stops the blinking */ 1289 drv_data->led_delay_on[n] = 0; 1290 drv_data->led_delay_off[n] = 0; 1291 1292 sony_set_leds(drv_data); 1293 break; 1294 } 1295 } 1296 } 1297 1298 static enum led_brightness sony_led_get_brightness(struct led_classdev *led) 1299 { 1300 struct device *dev = led->dev->parent; 1301 struct hid_device *hdev = to_hid_device(dev); 1302 struct sony_sc *drv_data; 1303 1304 int n; 1305 1306 drv_data = hid_get_drvdata(hdev); 1307 if (!drv_data) { 1308 hid_err(hdev, "No device data\n"); 1309 return LED_OFF; 1310 } 1311 1312 for (n = 0; n < drv_data->led_count; n++) { 1313 if (led == drv_data->leds[n]) 1314 return drv_data->led_state[n]; 1315 } 1316 1317 return LED_OFF; 1318 } 1319 1320 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on, 1321 unsigned long *delay_off) 1322 { 1323 struct device *dev = led->dev->parent; 1324 struct hid_device *hdev = to_hid_device(dev); 1325 struct sony_sc *drv_data = hid_get_drvdata(hdev); 1326 int n; 1327 u8 new_on, new_off; 1328 1329 if (!drv_data) { 1330 hid_err(hdev, "No device data\n"); 1331 return -EINVAL; 1332 } 1333 1334 /* Max delay is 255 deciseconds or 2550 milliseconds */ 1335 if (*delay_on > 2550) 1336 *delay_on = 2550; 1337 if (*delay_off > 2550) 1338 *delay_off = 2550; 1339 1340 /* Blink at 1 Hz if both values are zero */ 1341 if (!*delay_on && !*delay_off) 1342 *delay_on = *delay_off = 500; 1343 1344 new_on = *delay_on / 10; 1345 new_off = *delay_off / 10; 1346 1347 for (n = 0; n < drv_data->led_count; n++) { 1348 if (led == drv_data->leds[n]) 1349 break; 1350 } 1351 1352 /* This LED is not registered on this device */ 1353 if (n >= drv_data->led_count) 1354 return -EINVAL; 1355 1356 /* Don't schedule work if the values didn't change */ 1357 if (new_on != drv_data->led_delay_on[n] || 1358 new_off != drv_data->led_delay_off[n]) { 1359 drv_data->led_delay_on[n] = new_on; 1360 drv_data->led_delay_off[n] = new_off; 1361 sony_schedule_work(drv_data, SONY_WORKER_STATE); 1362 } 1363 1364 return 0; 1365 } 1366 1367 static int sony_leds_init(struct sony_sc *sc) 1368 { 1369 struct hid_device *hdev = sc->hdev; 1370 int n, ret = 0; 1371 int use_color_names; 1372 struct led_classdev *led; 1373 size_t name_sz; 1374 char *name; 1375 size_t name_len; 1376 const char *name_fmt; 1377 static const char * const color_name_str[] = { "red", "green", "blue", 1378 "global" }; 1379 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 }; 1380 u8 use_hw_blink[MAX_LEDS] = { 0 }; 1381 1382 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT)); 1383 1384 if (sc->quirks & BUZZ_CONTROLLER) { 1385 sc->led_count = 4; 1386 use_color_names = 0; 1387 name_len = strlen("::buzz#"); 1388 name_fmt = "%s::buzz%d"; 1389 /* Validate expected report characteristics. */ 1390 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7)) 1391 return -ENODEV; 1392 } else if (sc->quirks & MOTION_CONTROLLER) { 1393 sc->led_count = 3; 1394 memset(max_brightness, 255, 3); 1395 use_color_names = 1; 1396 name_len = 0; 1397 name_fmt = "%s:%s"; 1398 } else if (sc->quirks & NAVIGATION_CONTROLLER) { 1399 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00}; 1400 1401 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds)); 1402 sc->led_count = 1; 1403 memset(use_hw_blink, 1, 4); 1404 use_color_names = 0; 1405 name_len = strlen("::sony#"); 1406 name_fmt = "%s::sony%d"; 1407 } else { 1408 sixaxis_set_leds_from_id(sc); 1409 sc->led_count = 4; 1410 memset(use_hw_blink, 1, 4); 1411 use_color_names = 0; 1412 name_len = strlen("::sony#"); 1413 name_fmt = "%s::sony%d"; 1414 } 1415 1416 /* 1417 * Clear LEDs as we have no way of reading their initial state. This is 1418 * only relevant if the driver is loaded after somebody actively set the 1419 * LEDs to on 1420 */ 1421 sony_set_leds(sc); 1422 1423 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1; 1424 1425 for (n = 0; n < sc->led_count; n++) { 1426 1427 if (use_color_names) 1428 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_name_str[n]) + 2; 1429 1430 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL); 1431 if (!led) { 1432 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n); 1433 return -ENOMEM; 1434 } 1435 1436 name = (void *)(&led[1]); 1437 if (use_color_names) 1438 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), 1439 color_name_str[n]); 1440 else 1441 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1); 1442 led->name = name; 1443 led->brightness = sc->led_state[n]; 1444 led->max_brightness = max_brightness[n]; 1445 led->flags = LED_CORE_SUSPENDRESUME; 1446 led->brightness_get = sony_led_get_brightness; 1447 led->brightness_set = sony_led_set_brightness; 1448 1449 if (use_hw_blink[n]) 1450 led->blink_set = sony_led_blink_set; 1451 1452 sc->leds[n] = led; 1453 1454 ret = devm_led_classdev_register(&hdev->dev, led); 1455 if (ret) { 1456 hid_err(hdev, "Failed to register LED %d\n", n); 1457 return ret; 1458 } 1459 } 1460 1461 return 0; 1462 } 1463 1464 static void sixaxis_send_output_report(struct sony_sc *sc) 1465 { 1466 static const union sixaxis_output_report_01 default_report = { 1467 .buf = { 1468 0x01, 1469 0x01, 0xff, 0x00, 0xff, 0x00, 1470 0x00, 0x00, 0x00, 0x00, 0x00, 1471 0xff, 0x27, 0x10, 0x00, 0x32, 1472 0xff, 0x27, 0x10, 0x00, 0x32, 1473 0xff, 0x27, 0x10, 0x00, 0x32, 1474 0xff, 0x27, 0x10, 0x00, 0x32, 1475 0x00, 0x00, 0x00, 0x00, 0x00 1476 } 1477 }; 1478 struct sixaxis_output_report *report = 1479 (struct sixaxis_output_report *)sc->output_report_dmabuf; 1480 int n; 1481 1482 /* Initialize the report with default values */ 1483 memcpy(report, &default_report, sizeof(struct sixaxis_output_report)); 1484 1485 #ifdef CONFIG_SONY_FF 1486 report->rumble.right_motor_on = sc->right ? 1 : 0; 1487 report->rumble.left_motor_force = sc->left; 1488 #endif 1489 1490 report->leds_bitmap |= sc->led_state[0] << 1; 1491 report->leds_bitmap |= sc->led_state[1] << 2; 1492 report->leds_bitmap |= sc->led_state[2] << 3; 1493 report->leds_bitmap |= sc->led_state[3] << 4; 1494 1495 /* Set flag for all leds off, required for 3rd party INTEC controller */ 1496 if ((report->leds_bitmap & 0x1E) == 0) 1497 report->leds_bitmap |= 0x20; 1498 1499 /* 1500 * The LEDs in the report are indexed in reverse order to their 1501 * corresponding light on the controller. 1502 * Index 0 = LED 4, index 1 = LED 3, etc... 1503 * 1504 * In the case of both delay values being zero (blinking disabled) the 1505 * default report values should be used or the controller LED will be 1506 * always off. 1507 */ 1508 for (n = 0; n < 4; n++) { 1509 if (sc->led_delay_on[n] || sc->led_delay_off[n]) { 1510 report->led[3 - n].duty_off = sc->led_delay_off[n]; 1511 report->led[3 - n].duty_on = sc->led_delay_on[n]; 1512 } 1513 } 1514 1515 /* SHANWAN controllers require output reports via intr channel */ 1516 if (sc->quirks & SHANWAN_GAMEPAD) 1517 hid_hw_output_report(sc->hdev, (u8 *)report, 1518 sizeof(struct sixaxis_output_report)); 1519 else 1520 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report, 1521 sizeof(struct sixaxis_output_report), 1522 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT); 1523 } 1524 1525 static void motion_send_output_report(struct sony_sc *sc) 1526 { 1527 struct hid_device *hdev = sc->hdev; 1528 struct motion_output_report_02 *report = 1529 (struct motion_output_report_02 *)sc->output_report_dmabuf; 1530 1531 memset(report, 0, MOTION_REPORT_0x02_SIZE); 1532 1533 report->type = 0x02; /* set leds */ 1534 report->r = sc->led_state[0]; 1535 report->g = sc->led_state[1]; 1536 report->b = sc->led_state[2]; 1537 1538 #ifdef CONFIG_SONY_FF 1539 report->rumble = max(sc->right, sc->left); 1540 #endif 1541 1542 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE); 1543 } 1544 1545 #ifdef CONFIG_SONY_FF 1546 static inline void sony_send_output_report(struct sony_sc *sc) 1547 { 1548 if (sc->send_output_report) 1549 sc->send_output_report(sc); 1550 } 1551 #endif 1552 1553 static void sony_state_worker(struct work_struct *work) 1554 { 1555 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker); 1556 1557 sc->send_output_report(sc); 1558 } 1559 1560 static int sony_allocate_output_report(struct sony_sc *sc) 1561 { 1562 if ((sc->quirks & SIXAXIS_CONTROLLER) || 1563 (sc->quirks & NAVIGATION_CONTROLLER)) 1564 sc->output_report_dmabuf = 1565 devm_kmalloc(&sc->hdev->dev, 1566 sizeof(union sixaxis_output_report_01), 1567 GFP_KERNEL); 1568 else if (sc->quirks & MOTION_CONTROLLER) 1569 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev, 1570 MOTION_REPORT_0x02_SIZE, 1571 GFP_KERNEL); 1572 else 1573 return 0; 1574 1575 if (!sc->output_report_dmabuf) 1576 return -ENOMEM; 1577 1578 return 0; 1579 } 1580 1581 #ifdef CONFIG_SONY_FF 1582 static int sony_play_effect(struct input_dev *dev, void *data, 1583 struct ff_effect *effect) 1584 { 1585 struct hid_device *hid = input_get_drvdata(dev); 1586 struct sony_sc *sc = hid_get_drvdata(hid); 1587 1588 if (effect->type != FF_RUMBLE) 1589 return 0; 1590 1591 sc->left = effect->u.rumble.strong_magnitude / 256; 1592 sc->right = effect->u.rumble.weak_magnitude / 256; 1593 1594 sony_schedule_work(sc, SONY_WORKER_STATE); 1595 return 0; 1596 } 1597 1598 static int sony_init_ff(struct sony_sc *sc) 1599 { 1600 struct hid_input *hidinput; 1601 struct input_dev *input_dev; 1602 1603 if (list_empty(&sc->hdev->inputs)) { 1604 hid_err(sc->hdev, "no inputs found\n"); 1605 return -ENODEV; 1606 } 1607 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list); 1608 input_dev = hidinput->input; 1609 1610 input_set_capability(input_dev, EV_FF, FF_RUMBLE); 1611 return input_ff_create_memless(input_dev, NULL, sony_play_effect); 1612 } 1613 1614 #else 1615 static int sony_init_ff(struct sony_sc *sc) 1616 { 1617 return 0; 1618 } 1619 1620 #endif 1621 1622 static int sony_battery_get_property(struct power_supply *psy, 1623 enum power_supply_property psp, 1624 union power_supply_propval *val) 1625 { 1626 struct sony_sc *sc = power_supply_get_drvdata(psy); 1627 unsigned long flags; 1628 int ret = 0; 1629 u8 battery_capacity; 1630 int battery_status; 1631 1632 spin_lock_irqsave(&sc->lock, flags); 1633 battery_capacity = sc->battery_capacity; 1634 battery_status = sc->battery_status; 1635 spin_unlock_irqrestore(&sc->lock, flags); 1636 1637 switch (psp) { 1638 case POWER_SUPPLY_PROP_PRESENT: 1639 val->intval = 1; 1640 break; 1641 case POWER_SUPPLY_PROP_SCOPE: 1642 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 1643 break; 1644 case POWER_SUPPLY_PROP_CAPACITY: 1645 val->intval = battery_capacity; 1646 break; 1647 case POWER_SUPPLY_PROP_STATUS: 1648 val->intval = battery_status; 1649 break; 1650 default: 1651 ret = -EINVAL; 1652 break; 1653 } 1654 return ret; 1655 } 1656 1657 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id) 1658 { 1659 const char *battery_str_fmt = append_dev_id ? 1660 "sony_controller_battery_%pMR_%i" : 1661 "sony_controller_battery_%pMR"; 1662 struct power_supply_config psy_cfg = { .drv_data = sc, }; 1663 struct hid_device *hdev = sc->hdev; 1664 int ret; 1665 1666 /* 1667 * Set the default battery level to 100% to avoid low battery warnings 1668 * if the battery is polled before the first device report is received. 1669 */ 1670 sc->battery_capacity = 100; 1671 1672 sc->battery_desc.properties = sony_battery_props; 1673 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props); 1674 sc->battery_desc.get_property = sony_battery_get_property; 1675 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; 1676 sc->battery_desc.use_for_apm = 0; 1677 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL, 1678 battery_str_fmt, sc->mac_address, sc->device_id); 1679 if (!sc->battery_desc.name) 1680 return -ENOMEM; 1681 1682 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc, 1683 &psy_cfg); 1684 if (IS_ERR(sc->battery)) { 1685 ret = PTR_ERR(sc->battery); 1686 hid_err(hdev, "Unable to register battery device\n"); 1687 return ret; 1688 } 1689 1690 power_supply_powers(sc->battery, &hdev->dev); 1691 return 0; 1692 } 1693 1694 /* 1695 * If a controller is plugged in via USB while already connected via Bluetooth 1696 * it will show up as two devices. A global list of connected controllers and 1697 * their MAC addresses is maintained to ensure that a device is only connected 1698 * once. 1699 * 1700 * Some USB-only devices masquerade as Sixaxis controllers and all have the 1701 * same dummy Bluetooth address, so a comparison of the connection type is 1702 * required. Devices are only rejected in the case where two devices have 1703 * matching Bluetooth addresses on different bus types. 1704 */ 1705 static inline int sony_compare_connection_type(struct sony_sc *sc0, 1706 struct sony_sc *sc1) 1707 { 1708 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE); 1709 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE); 1710 1711 return sc0_not_bt == sc1_not_bt; 1712 } 1713 1714 static int sony_check_add_dev_list(struct sony_sc *sc) 1715 { 1716 struct sony_sc *entry; 1717 unsigned long flags; 1718 int ret; 1719 1720 spin_lock_irqsave(&sony_dev_list_lock, flags); 1721 1722 list_for_each_entry(entry, &sony_device_list, list_node) { 1723 ret = memcmp(sc->mac_address, entry->mac_address, 1724 sizeof(sc->mac_address)); 1725 if (!ret) { 1726 if (sony_compare_connection_type(sc, entry)) { 1727 ret = 1; 1728 } else { 1729 ret = -EEXIST; 1730 hid_info(sc->hdev, 1731 "controller with MAC address %pMR already connected\n", 1732 sc->mac_address); 1733 } 1734 goto unlock; 1735 } 1736 } 1737 1738 ret = 0; 1739 list_add(&(sc->list_node), &sony_device_list); 1740 1741 unlock: 1742 spin_unlock_irqrestore(&sony_dev_list_lock, flags); 1743 return ret; 1744 } 1745 1746 static void sony_remove_dev_list(struct sony_sc *sc) 1747 { 1748 unsigned long flags; 1749 1750 if (sc->list_node.next) { 1751 spin_lock_irqsave(&sony_dev_list_lock, flags); 1752 list_del(&(sc->list_node)); 1753 spin_unlock_irqrestore(&sony_dev_list_lock, flags); 1754 } 1755 } 1756 1757 static int sony_get_bt_devaddr(struct sony_sc *sc) 1758 { 1759 int ret; 1760 1761 /* HIDP stores the device MAC address as a string in the uniq field. */ 1762 ret = strlen(sc->hdev->uniq); 1763 if (ret != 17) 1764 return -EINVAL; 1765 1766 ret = sscanf(sc->hdev->uniq, 1767 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx", 1768 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3], 1769 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]); 1770 1771 if (ret != 6) 1772 return -EINVAL; 1773 1774 return 0; 1775 } 1776 1777 static int sony_check_add(struct sony_sc *sc) 1778 { 1779 u8 *buf = NULL; 1780 int n, ret; 1781 1782 if ((sc->quirks & MOTION_CONTROLLER_BT) || 1783 (sc->quirks & NAVIGATION_CONTROLLER_BT) || 1784 (sc->quirks & SIXAXIS_CONTROLLER_BT)) { 1785 /* 1786 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC 1787 * address from the uniq string where HIDP stores it. 1788 * As uniq cannot be guaranteed to be a MAC address in all cases 1789 * a failure of this function should not prevent the connection. 1790 */ 1791 if (sony_get_bt_devaddr(sc) < 0) { 1792 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n"); 1793 return 0; 1794 } 1795 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) || 1796 (sc->quirks & NAVIGATION_CONTROLLER_USB)) { 1797 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL); 1798 if (!buf) 1799 return -ENOMEM; 1800 1801 /* 1802 * The MAC address of a Sixaxis controller connected via USB can 1803 * be retrieved with feature report 0xf2. The address begins at 1804 * offset 4. 1805 */ 1806 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, 1807 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT, 1808 HID_REQ_GET_REPORT); 1809 1810 if (ret != SIXAXIS_REPORT_0xF2_SIZE) { 1811 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n"); 1812 ret = ret < 0 ? ret : -EINVAL; 1813 goto out_free; 1814 } 1815 1816 /* 1817 * The Sixaxis device MAC in the report is big-endian and must 1818 * be byte-swapped. 1819 */ 1820 for (n = 0; n < 6; n++) 1821 sc->mac_address[5-n] = buf[4+n]; 1822 1823 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq), 1824 "%pMR", sc->mac_address); 1825 } else { 1826 return 0; 1827 } 1828 1829 ret = sony_check_add_dev_list(sc); 1830 1831 out_free: 1832 1833 kfree(buf); 1834 1835 return ret; 1836 } 1837 1838 static int sony_set_device_id(struct sony_sc *sc) 1839 { 1840 int ret; 1841 1842 /* 1843 * Only Sixaxis controllers get an id. 1844 * All others are set to -1. 1845 */ 1846 if (sc->quirks & SIXAXIS_CONTROLLER) { 1847 ret = ida_alloc(&sony_device_id_allocator, GFP_KERNEL); 1848 if (ret < 0) { 1849 sc->device_id = -1; 1850 return ret; 1851 } 1852 sc->device_id = ret; 1853 } else { 1854 sc->device_id = -1; 1855 } 1856 1857 return 0; 1858 } 1859 1860 static void sony_release_device_id(struct sony_sc *sc) 1861 { 1862 if (sc->device_id >= 0) { 1863 ida_free(&sony_device_id_allocator, sc->device_id); 1864 sc->device_id = -1; 1865 } 1866 } 1867 1868 static inline void sony_init_output_report(struct sony_sc *sc, 1869 void (*send_output_report)(struct sony_sc *)) 1870 { 1871 sc->send_output_report = send_output_report; 1872 1873 if (!sc->state_worker_initialized) 1874 INIT_WORK(&sc->state_worker, sony_state_worker); 1875 1876 sc->state_worker_initialized = 1; 1877 } 1878 1879 static inline void sony_cancel_work_sync(struct sony_sc *sc) 1880 { 1881 unsigned long flags; 1882 1883 if (sc->state_worker_initialized) { 1884 spin_lock_irqsave(&sc->lock, flags); 1885 sc->state_worker_initialized = 0; 1886 spin_unlock_irqrestore(&sc->lock, flags); 1887 cancel_work_sync(&sc->state_worker); 1888 } 1889 } 1890 1891 static int sony_input_configured(struct hid_device *hdev, 1892 struct hid_input *hidinput) 1893 { 1894 struct sony_sc *sc = hid_get_drvdata(hdev); 1895 int append_dev_id; 1896 int ret; 1897 1898 ret = sony_set_device_id(sc); 1899 if (ret < 0) { 1900 hid_err(hdev, "failed to allocate the device id\n"); 1901 goto err_stop; 1902 } 1903 1904 ret = append_dev_id = sony_check_add(sc); 1905 if (ret < 0) 1906 goto err_stop; 1907 1908 ret = sony_allocate_output_report(sc); 1909 if (ret < 0) { 1910 hid_err(hdev, "failed to allocate the output report buffer\n"); 1911 goto err_stop; 1912 } 1913 1914 if (sc->quirks & NAVIGATION_CONTROLLER_USB) { 1915 /* 1916 * The Sony Sixaxis does not handle HID Output Reports on the 1917 * Interrupt EP like it could, so we need to force HID Output 1918 * Reports to use HID_REQ_SET_REPORT on the Control EP. 1919 * 1920 * There is also another issue about HID Output Reports via USB, 1921 * the Sixaxis does not want the report_id as part of the data 1922 * packet, so we have to discard buf[0] when sending the actual 1923 * control message, even for numbered reports, humpf! 1924 * 1925 * Additionally, the Sixaxis on USB isn't properly initialized 1926 * until the PS logo button is pressed and as such won't retain 1927 * any state set by an output report, so the initial 1928 * configuration report is deferred until the first input 1929 * report arrives. 1930 */ 1931 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1932 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID; 1933 sc->defer_initialization = 1; 1934 1935 ret = sixaxis_set_operational_usb(hdev); 1936 if (ret < 0) { 1937 hid_err(hdev, "Failed to set controller into operational mode\n"); 1938 goto err_stop; 1939 } 1940 1941 sony_init_output_report(sc, sixaxis_send_output_report); 1942 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) { 1943 /* 1944 * The Navigation controller wants output reports sent on the ctrl 1945 * endpoint when connected via Bluetooth. 1946 */ 1947 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1948 1949 ret = sixaxis_set_operational_bt(hdev); 1950 if (ret < 0) { 1951 hid_err(hdev, "Failed to set controller into operational mode\n"); 1952 goto err_stop; 1953 } 1954 1955 sony_init_output_report(sc, sixaxis_send_output_report); 1956 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 1957 /* 1958 * The Sony Sixaxis does not handle HID Output Reports on the 1959 * Interrupt EP and the device only becomes active when the 1960 * PS button is pressed. See comment for Navigation controller 1961 * above for more details. 1962 */ 1963 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1964 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID; 1965 sc->defer_initialization = 1; 1966 1967 ret = sixaxis_set_operational_usb(hdev); 1968 if (ret < 0) { 1969 hid_err(hdev, "Failed to set controller into operational mode\n"); 1970 goto err_stop; 1971 } 1972 1973 ret = sony_register_sensors(sc); 1974 if (ret) { 1975 hid_err(sc->hdev, 1976 "Unable to initialize motion sensors: %d\n", ret); 1977 goto err_stop; 1978 } 1979 1980 sony_init_output_report(sc, sixaxis_send_output_report); 1981 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) { 1982 /* 1983 * The Sixaxis wants output reports sent on the ctrl endpoint 1984 * when connected via Bluetooth. 1985 */ 1986 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1987 1988 ret = sixaxis_set_operational_bt(hdev); 1989 if (ret < 0) { 1990 hid_err(hdev, "Failed to set controller into operational mode\n"); 1991 goto err_stop; 1992 } 1993 1994 ret = sony_register_sensors(sc); 1995 if (ret) { 1996 hid_err(sc->hdev, 1997 "Unable to initialize motion sensors: %d\n", ret); 1998 goto err_stop; 1999 } 2000 2001 sony_init_output_report(sc, sixaxis_send_output_report); 2002 } else if (sc->quirks & NSG_MRXU_REMOTE) { 2003 /* 2004 * The NSG-MRxU touchpad supports 2 touches and has a 2005 * resolution of 1667x1868 2006 */ 2007 ret = sony_register_touchpad(sc, 2, 2008 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1); 2009 if (ret) { 2010 hid_err(sc->hdev, 2011 "Unable to initialize multi-touch slots: %d\n", 2012 ret); 2013 goto err_stop; 2014 } 2015 2016 } else if (sc->quirks & MOTION_CONTROLLER) { 2017 sony_init_output_report(sc, motion_send_output_report); 2018 } 2019 2020 if (sc->quirks & SONY_LED_SUPPORT) { 2021 ret = sony_leds_init(sc); 2022 if (ret < 0) 2023 goto err_stop; 2024 } 2025 2026 if (sc->quirks & SONY_BATTERY_SUPPORT) { 2027 ret = sony_battery_probe(sc, append_dev_id); 2028 if (ret < 0) 2029 goto err_stop; 2030 2031 /* Open the device to receive reports with battery info */ 2032 ret = hid_hw_open(hdev); 2033 if (ret < 0) { 2034 hid_err(hdev, "hw open failed\n"); 2035 goto err_stop; 2036 } 2037 } 2038 2039 if (sc->quirks & SONY_FF_SUPPORT) { 2040 ret = sony_init_ff(sc); 2041 if (ret < 0) 2042 goto err_close; 2043 } 2044 2045 return 0; 2046 err_close: 2047 hid_hw_close(hdev); 2048 err_stop: 2049 sony_cancel_work_sync(sc); 2050 sony_remove_dev_list(sc); 2051 sony_release_device_id(sc); 2052 return ret; 2053 } 2054 2055 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) 2056 { 2057 int ret; 2058 unsigned long quirks = id->driver_data; 2059 struct sony_sc *sc; 2060 struct usb_device *usbdev; 2061 unsigned int connect_mask = HID_CONNECT_DEFAULT; 2062 2063 if (!strcmp(hdev->name, "FutureMax Dance Mat")) 2064 quirks |= FUTUREMAX_DANCE_MAT; 2065 2066 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") || 2067 !strcmp(hdev->name, "ShanWan PS(R) Ga`epad")) 2068 quirks |= SHANWAN_GAMEPAD; 2069 2070 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL); 2071 if (sc == NULL) { 2072 hid_err(hdev, "can't alloc sony descriptor\n"); 2073 return -ENOMEM; 2074 } 2075 2076 spin_lock_init(&sc->lock); 2077 2078 sc->quirks = quirks; 2079 hid_set_drvdata(hdev, sc); 2080 sc->hdev = hdev; 2081 2082 ret = hid_parse(hdev); 2083 if (ret) { 2084 hid_err(hdev, "parse failed\n"); 2085 return ret; 2086 } 2087 2088 if (sc->quirks & VAIO_RDESC_CONSTANT) 2089 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 2090 else if (sc->quirks & SIXAXIS_CONTROLLER) 2091 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 2092 2093 /* Patch the hw version on DS3 compatible devices, so applications can 2094 * distinguish between the default HID mappings and the mappings defined 2095 * by the Linux game controller spec. This is important for the SDL2 2096 * library, which has a game controller database, which uses device ids 2097 * in combination with version as a key. 2098 */ 2099 if (sc->quirks & SIXAXIS_CONTROLLER) 2100 hdev->version |= 0x8000; 2101 2102 ret = hid_hw_start(hdev, connect_mask); 2103 if (ret) { 2104 hid_err(hdev, "hw start failed\n"); 2105 return ret; 2106 } 2107 2108 /* sony_input_configured can fail, but this doesn't result 2109 * in hid_hw_start failures (intended). Check whether 2110 * the HID layer claimed the device else fail. 2111 * We don't know the actual reason for the failure, most 2112 * likely it is due to EEXIST in case of double connection 2113 * of USB and Bluetooth, but could have been due to ENOMEM 2114 * or other reasons as well. 2115 */ 2116 if (!(hdev->claimed & HID_CLAIMED_INPUT)) { 2117 hid_err(hdev, "failed to claim input\n"); 2118 ret = -ENODEV; 2119 goto err; 2120 } 2121 2122 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) { 2123 if (!hid_is_usb(hdev)) { 2124 ret = -EINVAL; 2125 goto err; 2126 } 2127 2128 usbdev = to_usb_device(sc->hdev->dev.parent->parent); 2129 2130 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC); 2131 if (!sc->ghl_urb) { 2132 ret = -ENOMEM; 2133 goto err; 2134 } 2135 2136 if (sc->quirks & GHL_GUITAR_PS3WIIU) 2137 ret = ghl_init_urb(sc, usbdev, ghl_ps3wiiu_magic_data, 2138 ARRAY_SIZE(ghl_ps3wiiu_magic_data)); 2139 else if (sc->quirks & GHL_GUITAR_PS4) 2140 ret = ghl_init_urb(sc, usbdev, ghl_ps4_magic_data, 2141 ARRAY_SIZE(ghl_ps4_magic_data)); 2142 if (ret) { 2143 hid_err(hdev, "error preparing URB\n"); 2144 goto err; 2145 } 2146 2147 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0); 2148 mod_timer(&sc->ghl_poke_timer, 2149 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ); 2150 } 2151 2152 return ret; 2153 2154 err: 2155 usb_free_urb(sc->ghl_urb); 2156 2157 hid_hw_stop(hdev); 2158 return ret; 2159 } 2160 2161 static void sony_remove(struct hid_device *hdev) 2162 { 2163 struct sony_sc *sc = hid_get_drvdata(hdev); 2164 2165 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) { 2166 del_timer_sync(&sc->ghl_poke_timer); 2167 usb_free_urb(sc->ghl_urb); 2168 } 2169 2170 hid_hw_close(hdev); 2171 2172 sony_cancel_work_sync(sc); 2173 2174 sony_remove_dev_list(sc); 2175 2176 sony_release_device_id(sc); 2177 2178 hid_hw_stop(hdev); 2179 } 2180 2181 #ifdef CONFIG_PM 2182 2183 static int sony_suspend(struct hid_device *hdev, pm_message_t message) 2184 { 2185 #ifdef CONFIG_SONY_FF 2186 2187 /* On suspend stop any running force-feedback events */ 2188 if (SONY_FF_SUPPORT) { 2189 struct sony_sc *sc = hid_get_drvdata(hdev); 2190 2191 sc->left = sc->right = 0; 2192 sony_send_output_report(sc); 2193 } 2194 2195 #endif 2196 return 0; 2197 } 2198 2199 static int sony_resume(struct hid_device *hdev) 2200 { 2201 struct sony_sc *sc = hid_get_drvdata(hdev); 2202 2203 /* 2204 * The Sixaxis and navigation controllers on USB need to be 2205 * reinitialized on resume or they won't behave properly. 2206 */ 2207 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) || 2208 (sc->quirks & NAVIGATION_CONTROLLER_USB)) { 2209 sixaxis_set_operational_usb(sc->hdev); 2210 sc->defer_initialization = 1; 2211 } 2212 2213 return 0; 2214 } 2215 2216 #endif 2217 2218 static const struct hid_device_id sony_devices[] = { 2219 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 2220 .driver_data = SIXAXIS_CONTROLLER_USB }, 2221 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER), 2222 .driver_data = NAVIGATION_CONTROLLER_USB }, 2223 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER), 2224 .driver_data = NAVIGATION_CONTROLLER_BT }, 2225 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER), 2226 .driver_data = MOTION_CONTROLLER_USB }, 2227 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER), 2228 .driver_data = MOTION_CONTROLLER_BT }, 2229 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 2230 .driver_data = SIXAXIS_CONTROLLER_BT }, 2231 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE), 2232 .driver_data = VAIO_RDESC_CONSTANT }, 2233 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE), 2234 .driver_data = VAIO_RDESC_CONSTANT }, 2235 /* 2236 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as 2237 * Logitech joystick from the device descriptor. 2238 */ 2239 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER), 2240 .driver_data = BUZZ_CONTROLLER }, 2241 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER), 2242 .driver_data = BUZZ_CONTROLLER }, 2243 /* PS3 BD Remote Control */ 2244 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE), 2245 .driver_data = PS3REMOTE }, 2246 /* Logitech Harmony Adapter for PS3 */ 2247 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3), 2248 .driver_data = PS3REMOTE }, 2249 /* SMK-Link PS3 BD Remote Control */ 2250 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE), 2251 .driver_data = PS3REMOTE }, 2252 /* Nyko Core Controller for PS3 */ 2253 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER), 2254 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER }, 2255 /* SMK-Link NSG-MR5U Remote Control */ 2256 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE), 2257 .driver_data = NSG_MR5U_REMOTE_BT }, 2258 /* SMK-Link NSG-MR7U Remote Control */ 2259 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE), 2260 .driver_data = NSG_MR7U_REMOTE_BT }, 2261 /* Guitar Hero Live PS3 and Wii U guitar dongles */ 2262 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE), 2263 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER }, 2264 /* Guitar Hero PC Guitar Dongle */ 2265 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_GUITAR_DONGLE), 2266 .driver_data = GH_GUITAR_CONTROLLER }, 2267 /* Guitar Hero PS3 World Tour Guitar Dongle */ 2268 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE), 2269 .driver_data = GH_GUITAR_CONTROLLER }, 2270 /* Guitar Hero Live PS4 guitar dongles */ 2271 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_PS4_GHLIVE_DONGLE), 2272 .driver_data = GHL_GUITAR_PS4 | GH_GUITAR_CONTROLLER }, 2273 { } 2274 }; 2275 MODULE_DEVICE_TABLE(hid, sony_devices); 2276 2277 static struct hid_driver sony_driver = { 2278 .name = "sony", 2279 .id_table = sony_devices, 2280 .input_mapping = sony_mapping, 2281 .input_configured = sony_input_configured, 2282 .probe = sony_probe, 2283 .remove = sony_remove, 2284 .report_fixup = sony_report_fixup, 2285 .raw_event = sony_raw_event, 2286 2287 #ifdef CONFIG_PM 2288 .suspend = sony_suspend, 2289 .resume = sony_resume, 2290 .reset_resume = sony_resume, 2291 #endif 2292 }; 2293 2294 static int __init sony_init(void) 2295 { 2296 dbg_hid("Sony:%s\n", __func__); 2297 2298 return hid_register_driver(&sony_driver); 2299 } 2300 2301 static void __exit sony_exit(void) 2302 { 2303 dbg_hid("Sony:%s\n", __func__); 2304 2305 hid_unregister_driver(&sony_driver); 2306 ida_destroy(&sony_device_id_allocator); 2307 } 2308 module_init(sony_init); 2309 module_exit(sony_exit); 2310 2311 MODULE_DESCRIPTION("HID driver for Sony / PS2 / PS3 / PS4 BD devices"); 2312 MODULE_LICENSE("GPL"); 2313