1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * HID driver for Valve Steam Controller 4 * 5 * Copyright (c) 2018 Rodrigo Rivas Costa <rodrigorivascosta@gmail.com> 6 * Copyright (c) 2022 Valve Software 7 * 8 * Supports both the wired and wireless interfaces. 9 * 10 * This controller has a builtin emulation of mouse and keyboard: the right pad 11 * can be used as a mouse, the shoulder buttons are mouse buttons, A and B 12 * buttons are ENTER and ESCAPE, and so on. This is implemented as additional 13 * HID interfaces. 14 * 15 * This is known as the "lizard mode", because apparently lizards like to use 16 * the computer from the coach, without a proper mouse and keyboard. 17 * 18 * This driver will disable the lizard mode when the input device is opened 19 * and re-enable it when the input device is closed, so as not to break user 20 * mode behaviour. The lizard_mode parameter can be used to change that. 21 * 22 * There are a few user space applications (notably Steam Client) that use 23 * the hidraw interface directly to create input devices (XTest, uinput...). 24 * In order to avoid breaking them this driver creates a layered hidraw device, 25 * so it can detect when the client is running and then: 26 * - it will not send any command to the controller. 27 * - this input device will be removed, to avoid double input of the same 28 * user action. 29 * When the client is closed, this input device will be created again. 30 * 31 * For additional functions, such as changing the right-pad margin or switching 32 * the led, you can use the user-space tool at: 33 * 34 * https://github.com/rodrigorc/steamctrl 35 */ 36 37 #include <linux/device.h> 38 #include <linux/input.h> 39 #include <linux/hid.h> 40 #include <linux/module.h> 41 #include <linux/workqueue.h> 42 #include <linux/mutex.h> 43 #include <linux/rcupdate.h> 44 #include <linux/delay.h> 45 #include <linux/power_supply.h> 46 #include "hid-ids.h" 47 48 MODULE_DESCRIPTION("HID driver for Valve Steam Controller"); 49 MODULE_LICENSE("GPL"); 50 MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>"); 51 52 static bool lizard_mode = true; 53 54 static DEFINE_MUTEX(steam_devices_lock); 55 static LIST_HEAD(steam_devices); 56 57 #define STEAM_QUIRK_WIRELESS BIT(0) 58 #define STEAM_QUIRK_DECK BIT(1) 59 60 /* Touch pads are 40 mm in diameter and 65535 units */ 61 #define STEAM_PAD_RESOLUTION 1638 62 /* Trigger runs are about 5 mm and 256 units */ 63 #define STEAM_TRIGGER_RESOLUTION 51 64 /* Joystick runs are about 5 mm and 256 units */ 65 #define STEAM_JOYSTICK_RESOLUTION 51 66 /* Trigger runs are about 6 mm and 32768 units */ 67 #define STEAM_DECK_TRIGGER_RESOLUTION 5461 68 /* Joystick runs are about 5 mm and 32768 units */ 69 #define STEAM_DECK_JOYSTICK_RESOLUTION 6553 70 /* Accelerometer has 16 bit resolution and a range of +/- 2g */ 71 #define STEAM_DECK_ACCEL_RES_PER_G 16384 72 #define STEAM_DECK_ACCEL_RANGE 32768 73 #define STEAM_DECK_ACCEL_FUZZ 32 74 /* Gyroscope has 16 bit resolution and a range of +/- 2000 dps */ 75 #define STEAM_DECK_GYRO_RES_PER_DPS 16 76 #define STEAM_DECK_GYRO_RANGE 32768 77 #define STEAM_DECK_GYRO_FUZZ 1 78 79 #define STEAM_PAD_FUZZ 256 80 81 /* 82 * Commands that can be sent in a feature report. 83 * Thanks to Valve and SDL for the names. 84 */ 85 enum { 86 ID_SET_DIGITAL_MAPPINGS = 0x80, 87 ID_CLEAR_DIGITAL_MAPPINGS = 0x81, 88 ID_GET_DIGITAL_MAPPINGS = 0x82, 89 ID_GET_ATTRIBUTES_VALUES = 0x83, 90 ID_GET_ATTRIBUTE_LABEL = 0x84, 91 ID_SET_DEFAULT_DIGITAL_MAPPINGS = 0x85, 92 ID_FACTORY_RESET = 0x86, 93 ID_SET_SETTINGS_VALUES = 0x87, 94 ID_CLEAR_SETTINGS_VALUES = 0x88, 95 ID_GET_SETTINGS_VALUES = 0x89, 96 ID_GET_SETTING_LABEL = 0x8A, 97 ID_GET_SETTINGS_MAXS = 0x8B, 98 ID_GET_SETTINGS_DEFAULTS = 0x8C, 99 ID_SET_CONTROLLER_MODE = 0x8D, 100 ID_LOAD_DEFAULT_SETTINGS = 0x8E, 101 ID_TRIGGER_HAPTIC_PULSE = 0x8F, 102 ID_TURN_OFF_CONTROLLER = 0x9F, 103 104 ID_GET_DEVICE_INFO = 0xA1, 105 106 ID_CALIBRATE_TRACKPADS = 0xA7, 107 ID_RESERVED_0 = 0xA8, 108 ID_SET_SERIAL_NUMBER = 0xA9, 109 ID_GET_TRACKPAD_CALIBRATION = 0xAA, 110 ID_GET_TRACKPAD_FACTORY_CALIBRATION = 0xAB, 111 ID_GET_TRACKPAD_RAW_DATA = 0xAC, 112 ID_ENABLE_PAIRING = 0xAD, 113 ID_GET_STRING_ATTRIBUTE = 0xAE, 114 ID_RADIO_ERASE_RECORDS = 0xAF, 115 ID_RADIO_WRITE_RECORD = 0xB0, 116 ID_SET_DONGLE_SETTING = 0xB1, 117 ID_DONGLE_DISCONNECT_DEVICE = 0xB2, 118 ID_DONGLE_COMMIT_DEVICE = 0xB3, 119 ID_DONGLE_GET_WIRELESS_STATE = 0xB4, 120 ID_CALIBRATE_GYRO = 0xB5, 121 ID_PLAY_AUDIO = 0xB6, 122 ID_AUDIO_UPDATE_START = 0xB7, 123 ID_AUDIO_UPDATE_DATA = 0xB8, 124 ID_AUDIO_UPDATE_COMPLETE = 0xB9, 125 ID_GET_CHIPID = 0xBA, 126 127 ID_CALIBRATE_JOYSTICK = 0xBF, 128 ID_CALIBRATE_ANALOG_TRIGGERS = 0xC0, 129 ID_SET_AUDIO_MAPPING = 0xC1, 130 ID_CHECK_GYRO_FW_LOAD = 0xC2, 131 ID_CALIBRATE_ANALOG = 0xC3, 132 ID_DONGLE_GET_CONNECTED_SLOTS = 0xC4, 133 134 ID_RESET_IMU = 0xCE, 135 136 ID_TRIGGER_HAPTIC_CMD = 0xEA, 137 ID_TRIGGER_RUMBLE_CMD = 0xEB, 138 }; 139 140 /* Settings IDs */ 141 enum { 142 /* 0 */ 143 SETTING_MOUSE_SENSITIVITY, 144 SETTING_MOUSE_ACCELERATION, 145 SETTING_TRACKBALL_ROTATION_ANGLE, 146 SETTING_HAPTIC_INTENSITY_UNUSED, 147 SETTING_LEFT_GAMEPAD_STICK_ENABLED, 148 SETTING_RIGHT_GAMEPAD_STICK_ENABLED, 149 SETTING_USB_DEBUG_MODE, 150 SETTING_LEFT_TRACKPAD_MODE, 151 SETTING_RIGHT_TRACKPAD_MODE, 152 SETTING_MOUSE_POINTER_ENABLED, 153 154 /* 10 */ 155 SETTING_DPAD_DEADZONE, 156 SETTING_MINIMUM_MOMENTUM_VEL, 157 SETTING_MOMENTUM_DECAY_AMMOUNT, 158 SETTING_TRACKPAD_RELATIVE_MODE_TICKS_PER_PIXEL, 159 SETTING_HAPTIC_INCREMENT, 160 SETTING_DPAD_ANGLE_SIN, 161 SETTING_DPAD_ANGLE_COS, 162 SETTING_MOMENTUM_VERTICAL_DIVISOR, 163 SETTING_MOMENTUM_MAXIMUM_VELOCITY, 164 SETTING_TRACKPAD_Z_ON, 165 166 /* 20 */ 167 SETTING_TRACKPAD_Z_OFF, 168 SETTING_SENSITIVY_SCALE_AMMOUNT, 169 SETTING_LEFT_TRACKPAD_SECONDARY_MODE, 170 SETTING_RIGHT_TRACKPAD_SECONDARY_MODE, 171 SETTING_SMOOTH_ABSOLUTE_MOUSE, 172 SETTING_STEAMBUTTON_POWEROFF_TIME, 173 SETTING_UNUSED_1, 174 SETTING_TRACKPAD_OUTER_RADIUS, 175 SETTING_TRACKPAD_Z_ON_LEFT, 176 SETTING_TRACKPAD_Z_OFF_LEFT, 177 178 /* 30 */ 179 SETTING_TRACKPAD_OUTER_SPIN_VEL, 180 SETTING_TRACKPAD_OUTER_SPIN_RADIUS, 181 SETTING_TRACKPAD_OUTER_SPIN_HORIZONTAL_ONLY, 182 SETTING_TRACKPAD_RELATIVE_MODE_DEADZONE, 183 SETTING_TRACKPAD_RELATIVE_MODE_MAX_VEL, 184 SETTING_TRACKPAD_RELATIVE_MODE_INVERT_Y, 185 SETTING_TRACKPAD_DOUBLE_TAP_BEEP_ENABLED, 186 SETTING_TRACKPAD_DOUBLE_TAP_BEEP_PERIOD, 187 SETTING_TRACKPAD_DOUBLE_TAP_BEEP_COUNT, 188 SETTING_TRACKPAD_OUTER_RADIUS_RELEASE_ON_TRANSITION, 189 190 /* 40 */ 191 SETTING_RADIAL_MODE_ANGLE, 192 SETTING_HAPTIC_INTENSITY_MOUSE_MODE, 193 SETTING_LEFT_DPAD_REQUIRES_CLICK, 194 SETTING_RIGHT_DPAD_REQUIRES_CLICK, 195 SETTING_LED_BASELINE_BRIGHTNESS, 196 SETTING_LED_USER_BRIGHTNESS, 197 SETTING_ENABLE_RAW_JOYSTICK, 198 SETTING_ENABLE_FAST_SCAN, 199 SETTING_IMU_MODE, 200 SETTING_WIRELESS_PACKET_VERSION, 201 202 /* 50 */ 203 SETTING_SLEEP_INACTIVITY_TIMEOUT, 204 SETTING_TRACKPAD_NOISE_THRESHOLD, 205 SETTING_LEFT_TRACKPAD_CLICK_PRESSURE, 206 SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE, 207 SETTING_LEFT_BUMPER_CLICK_PRESSURE, 208 SETTING_RIGHT_BUMPER_CLICK_PRESSURE, 209 SETTING_LEFT_GRIP_CLICK_PRESSURE, 210 SETTING_RIGHT_GRIP_CLICK_PRESSURE, 211 SETTING_LEFT_GRIP2_CLICK_PRESSURE, 212 SETTING_RIGHT_GRIP2_CLICK_PRESSURE, 213 214 /* 60 */ 215 SETTING_PRESSURE_MODE, 216 SETTING_CONTROLLER_TEST_MODE, 217 SETTING_TRIGGER_MODE, 218 SETTING_TRACKPAD_Z_THRESHOLD, 219 SETTING_FRAME_RATE, 220 SETTING_TRACKPAD_FILT_CTRL, 221 SETTING_TRACKPAD_CLIP, 222 SETTING_DEBUG_OUTPUT_SELECT, 223 SETTING_TRIGGER_THRESHOLD_PERCENT, 224 SETTING_TRACKPAD_FREQUENCY_HOPPING, 225 226 /* 70 */ 227 SETTING_HAPTICS_ENABLED, 228 SETTING_STEAM_WATCHDOG_ENABLE, 229 SETTING_TIMP_TOUCH_THRESHOLD_ON, 230 SETTING_TIMP_TOUCH_THRESHOLD_OFF, 231 SETTING_FREQ_HOPPING, 232 SETTING_TEST_CONTROL, 233 SETTING_HAPTIC_MASTER_GAIN_DB, 234 SETTING_THUMB_TOUCH_THRESH, 235 SETTING_DEVICE_POWER_STATUS, 236 SETTING_HAPTIC_INTENSITY, 237 238 /* 80 */ 239 SETTING_STABILIZER_ENABLED, 240 SETTING_TIMP_MODE_MTE, 241 }; 242 243 /* Input report identifiers */ 244 enum 245 { 246 ID_CONTROLLER_STATE = 1, 247 ID_CONTROLLER_DEBUG = 2, 248 ID_CONTROLLER_WIRELESS = 3, 249 ID_CONTROLLER_STATUS = 4, 250 ID_CONTROLLER_DEBUG2 = 5, 251 ID_CONTROLLER_SECONDARY_STATE = 6, 252 ID_CONTROLLER_BLE_STATE = 7, 253 ID_CONTROLLER_DECK_STATE = 9 254 }; 255 256 /* String attribute identifiers */ 257 enum { 258 ATTRIB_STR_BOARD_SERIAL, 259 ATTRIB_STR_UNIT_SERIAL, 260 }; 261 262 /* Values for GYRO_MODE (bitmask) */ 263 enum { 264 SETTING_GYRO_MODE_OFF = 0, 265 SETTING_GYRO_MODE_STEERING = BIT(0), 266 SETTING_GYRO_MODE_TILT = BIT(1), 267 SETTING_GYRO_MODE_SEND_ORIENTATION = BIT(2), 268 SETTING_GYRO_MODE_SEND_RAW_ACCEL = BIT(3), 269 SETTING_GYRO_MODE_SEND_RAW_GYRO = BIT(4), 270 }; 271 272 /* Trackpad modes */ 273 enum { 274 TRACKPAD_ABSOLUTE_MOUSE, 275 TRACKPAD_RELATIVE_MOUSE, 276 TRACKPAD_DPAD_FOUR_WAY_DISCRETE, 277 TRACKPAD_DPAD_FOUR_WAY_OVERLAP, 278 TRACKPAD_DPAD_EIGHT_WAY, 279 TRACKPAD_RADIAL_MODE, 280 TRACKPAD_ABSOLUTE_DPAD, 281 TRACKPAD_NONE, 282 TRACKPAD_GESTURE_KEYBOARD, 283 }; 284 285 /* Pad identifiers for the deck */ 286 #define STEAM_PAD_LEFT 0 287 #define STEAM_PAD_RIGHT 1 288 #define STEAM_PAD_BOTH 2 289 290 /* Other random constants */ 291 #define STEAM_SERIAL_LEN 0x15 292 293 struct steam_device { 294 struct list_head list; 295 spinlock_t lock; 296 struct hid_device *hdev, *client_hdev; 297 struct mutex report_mutex; 298 unsigned long client_opened; 299 struct input_dev __rcu *input; 300 struct input_dev __rcu *sensors; 301 unsigned long quirks; 302 struct work_struct work_connect; 303 bool connected; 304 char serial_no[STEAM_SERIAL_LEN + 1]; 305 struct power_supply_desc battery_desc; 306 struct power_supply __rcu *battery; 307 u8 battery_charge; 308 u16 voltage; 309 struct delayed_work mode_switch; 310 bool did_mode_switch; 311 bool gamepad_mode; 312 struct work_struct rumble_work; 313 u16 rumble_left; 314 u16 rumble_right; 315 unsigned int sensor_timestamp_us; 316 struct work_struct unregister_work; 317 }; 318 319 static int steam_recv_report(struct steam_device *steam, 320 u8 *data, int size) 321 { 322 struct hid_report *r; 323 u8 *buf; 324 int ret; 325 326 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0]; 327 if (!r) { 328 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n"); 329 return -EINVAL; 330 } 331 332 if (hid_report_len(r) < 64) 333 return -EINVAL; 334 335 buf = hid_alloc_report_buf(r, GFP_KERNEL); 336 if (!buf) 337 return -ENOMEM; 338 339 /* 340 * The report ID is always 0, so strip the first byte from the output. 341 * hid_report_len() is not counting the report ID, so +1 to the length 342 * or else we get a EOVERFLOW. We are safe from a buffer overflow 343 * because hid_alloc_report_buf() allocates +7 bytes. 344 */ 345 ret = hid_hw_raw_request(steam->hdev, 0x00, 346 buf, hid_report_len(r) + 1, 347 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 348 if (ret > 0) 349 memcpy(data, buf + 1, min(size, ret - 1)); 350 kfree(buf); 351 return ret; 352 } 353 354 static int steam_send_report(struct steam_device *steam, 355 u8 *cmd, int size) 356 { 357 struct hid_report *r; 358 u8 *buf; 359 unsigned int retries = 50; 360 int ret; 361 362 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0]; 363 if (!r) { 364 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n"); 365 return -EINVAL; 366 } 367 368 if (hid_report_len(r) < 64) 369 return -EINVAL; 370 371 buf = hid_alloc_report_buf(r, GFP_KERNEL); 372 if (!buf) 373 return -ENOMEM; 374 375 /* The report ID is always 0 */ 376 memcpy(buf + 1, cmd, size); 377 378 /* 379 * Sometimes the wireless controller fails with EPIPE 380 * when sending a feature report. 381 * Doing a HID_REQ_GET_REPORT and waiting for a while 382 * seems to fix that. 383 */ 384 do { 385 ret = hid_hw_raw_request(steam->hdev, 0, 386 buf, max(size, 64) + 1, 387 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 388 if (ret != -EPIPE) 389 break; 390 msleep(20); 391 } while (--retries); 392 393 kfree(buf); 394 if (ret < 0) 395 hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__, 396 ret, size, cmd); 397 return ret; 398 } 399 400 static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd) 401 { 402 return steam_send_report(steam, &cmd, 1); 403 } 404 405 static int steam_write_settings(struct steam_device *steam, 406 /* u8 reg, u16 val */...) 407 { 408 /* Send: 0x87 len (reg valLo valHi)* */ 409 u8 reg; 410 u16 val; 411 u8 cmd[64] = {ID_SET_SETTINGS_VALUES, 0x00}; 412 int ret; 413 va_list args; 414 415 va_start(args, steam); 416 for (;;) { 417 reg = va_arg(args, int); 418 if (reg == 0) 419 break; 420 val = va_arg(args, int); 421 cmd[cmd[1] + 2] = reg; 422 cmd[cmd[1] + 3] = val & 0xff; 423 cmd[cmd[1] + 4] = val >> 8; 424 cmd[1] += 3; 425 } 426 va_end(args); 427 428 ret = steam_send_report(steam, cmd, 2 + cmd[1]); 429 if (ret < 0) 430 return ret; 431 432 /* 433 * Sometimes a lingering report for this command can 434 * get read back instead of the last set report if 435 * this isn't explicitly queried 436 */ 437 return steam_recv_report(steam, cmd, 2 + cmd[1]); 438 } 439 440 static int steam_get_serial(struct steam_device *steam) 441 { 442 /* 443 * Send: 0xae 0x15 0x01 444 * Recv: 0xae 0x15 0x01 serialnumber 445 */ 446 int ret = 0; 447 u8 cmd[] = {ID_GET_STRING_ATTRIBUTE, sizeof(steam->serial_no), ATTRIB_STR_UNIT_SERIAL}; 448 u8 reply[3 + STEAM_SERIAL_LEN + 1]; 449 450 mutex_lock(&steam->report_mutex); 451 ret = steam_send_report(steam, cmd, sizeof(cmd)); 452 if (ret < 0) 453 goto out; 454 ret = steam_recv_report(steam, reply, sizeof(reply)); 455 if (ret < 0) 456 goto out; 457 if (reply[0] != ID_GET_STRING_ATTRIBUTE || reply[1] < 1 || 458 reply[1] > sizeof(steam->serial_no) || reply[2] != ATTRIB_STR_UNIT_SERIAL) { 459 ret = -EIO; 460 goto out; 461 } 462 reply[3 + STEAM_SERIAL_LEN] = 0; 463 strscpy(steam->serial_no, reply + 3, reply[1]); 464 out: 465 mutex_unlock(&steam->report_mutex); 466 return ret; 467 } 468 469 /* 470 * This command requests the wireless adaptor to post an event 471 * with the connection status. Useful if this driver is loaded when 472 * the controller is already connected. 473 */ 474 static inline int steam_request_conn_status(struct steam_device *steam) 475 { 476 int ret; 477 mutex_lock(&steam->report_mutex); 478 ret = steam_send_report_byte(steam, ID_DONGLE_GET_WIRELESS_STATE); 479 mutex_unlock(&steam->report_mutex); 480 return ret; 481 } 482 483 /* 484 * Send a haptic pulse to the trackpads 485 * Duration and interval are measured in microseconds, count is the number 486 * of pulses to send for duration time with interval microseconds between them 487 * and gain is measured in decibels, ranging from -24 to +6 488 */ 489 static inline int steam_haptic_pulse(struct steam_device *steam, u8 pad, 490 u16 duration, u16 interval, u16 count, u8 gain) 491 { 492 int ret; 493 u8 report[10] = {ID_TRIGGER_HAPTIC_PULSE, 8}; 494 495 /* Left and right are swapped on this report for legacy reasons */ 496 if (pad < STEAM_PAD_BOTH) 497 pad ^= 1; 498 499 report[2] = pad; 500 report[3] = duration & 0xFF; 501 report[4] = duration >> 8; 502 report[5] = interval & 0xFF; 503 report[6] = interval >> 8; 504 report[7] = count & 0xFF; 505 report[8] = count >> 8; 506 report[9] = gain; 507 508 mutex_lock(&steam->report_mutex); 509 ret = steam_send_report(steam, report, sizeof(report)); 510 mutex_unlock(&steam->report_mutex); 511 return ret; 512 } 513 514 static inline int steam_haptic_rumble(struct steam_device *steam, 515 u16 intensity, u16 left_speed, u16 right_speed, 516 u8 left_gain, u8 right_gain) 517 { 518 int ret; 519 u8 report[11] = {ID_TRIGGER_RUMBLE_CMD, 9}; 520 521 report[3] = intensity & 0xFF; 522 report[4] = intensity >> 8; 523 report[5] = left_speed & 0xFF; 524 report[6] = left_speed >> 8; 525 report[7] = right_speed & 0xFF; 526 report[8] = right_speed >> 8; 527 report[9] = left_gain; 528 report[10] = right_gain; 529 530 mutex_lock(&steam->report_mutex); 531 ret = steam_send_report(steam, report, sizeof(report)); 532 mutex_unlock(&steam->report_mutex); 533 return ret; 534 } 535 536 static void steam_haptic_rumble_cb(struct work_struct *work) 537 { 538 struct steam_device *steam = container_of(work, struct steam_device, 539 rumble_work); 540 steam_haptic_rumble(steam, 0, steam->rumble_left, 541 steam->rumble_right, 2, 0); 542 } 543 544 #ifdef CONFIG_STEAM_FF 545 static int steam_play_effect(struct input_dev *dev, void *data, 546 struct ff_effect *effect) 547 { 548 struct steam_device *steam = input_get_drvdata(dev); 549 550 steam->rumble_left = effect->u.rumble.strong_magnitude; 551 steam->rumble_right = effect->u.rumble.weak_magnitude; 552 553 return schedule_work(&steam->rumble_work); 554 } 555 #endif 556 557 static void steam_set_lizard_mode(struct steam_device *steam, bool enable) 558 { 559 if (steam->gamepad_mode) 560 enable = false; 561 562 if (enable) { 563 mutex_lock(&steam->report_mutex); 564 /* enable esc, enter, cursors */ 565 steam_send_report_byte(steam, ID_SET_DEFAULT_DIGITAL_MAPPINGS); 566 /* reset settings */ 567 steam_send_report_byte(steam, ID_LOAD_DEFAULT_SETTINGS); 568 mutex_unlock(&steam->report_mutex); 569 } else { 570 mutex_lock(&steam->report_mutex); 571 /* disable esc, enter, cursor */ 572 steam_send_report_byte(steam, ID_CLEAR_DIGITAL_MAPPINGS); 573 574 if (steam->quirks & STEAM_QUIRK_DECK) { 575 steam_write_settings(steam, 576 SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 577 SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 578 SETTING_LEFT_TRACKPAD_CLICK_PRESSURE, 0xFFFF, /* disable haptic click */ 579 SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE, 0xFFFF, /* disable haptic click */ 580 SETTING_STEAM_WATCHDOG_ENABLE, 0, /* disable watchdog that tests if Steam is active */ 581 0); 582 mutex_unlock(&steam->report_mutex); 583 } else { 584 steam_write_settings(steam, 585 SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 586 SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 587 0); 588 mutex_unlock(&steam->report_mutex); 589 } 590 } 591 } 592 593 static int steam_input_open(struct input_dev *dev) 594 { 595 struct steam_device *steam = input_get_drvdata(dev); 596 unsigned long flags; 597 bool set_lizard_mode; 598 599 /* 600 * Disabling lizard mode automatically is only done on the Steam 601 * Controller. On the Steam Deck, this is toggled manually by holding 602 * the options button instead, handled by steam_mode_switch_cb. 603 */ 604 if (!(steam->quirks & STEAM_QUIRK_DECK)) { 605 spin_lock_irqsave(&steam->lock, flags); 606 set_lizard_mode = !steam->client_opened && lizard_mode; 607 spin_unlock_irqrestore(&steam->lock, flags); 608 if (set_lizard_mode) 609 steam_set_lizard_mode(steam, false); 610 } 611 612 return 0; 613 } 614 615 static void steam_input_close(struct input_dev *dev) 616 { 617 struct steam_device *steam = input_get_drvdata(dev); 618 unsigned long flags; 619 bool set_lizard_mode; 620 621 if (!(steam->quirks & STEAM_QUIRK_DECK)) { 622 spin_lock_irqsave(&steam->lock, flags); 623 set_lizard_mode = !steam->client_opened && lizard_mode; 624 spin_unlock_irqrestore(&steam->lock, flags); 625 if (set_lizard_mode) 626 steam_set_lizard_mode(steam, true); 627 } 628 } 629 630 static enum power_supply_property steam_battery_props[] = { 631 POWER_SUPPLY_PROP_PRESENT, 632 POWER_SUPPLY_PROP_SCOPE, 633 POWER_SUPPLY_PROP_VOLTAGE_NOW, 634 POWER_SUPPLY_PROP_CAPACITY, 635 }; 636 637 static int steam_battery_get_property(struct power_supply *psy, 638 enum power_supply_property psp, 639 union power_supply_propval *val) 640 { 641 struct steam_device *steam = power_supply_get_drvdata(psy); 642 unsigned long flags; 643 s16 volts; 644 u8 batt; 645 int ret = 0; 646 647 spin_lock_irqsave(&steam->lock, flags); 648 volts = steam->voltage; 649 batt = steam->battery_charge; 650 spin_unlock_irqrestore(&steam->lock, flags); 651 652 switch (psp) { 653 case POWER_SUPPLY_PROP_PRESENT: 654 val->intval = 1; 655 break; 656 case POWER_SUPPLY_PROP_SCOPE: 657 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 658 break; 659 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 660 val->intval = volts * 1000; /* mV -> uV */ 661 break; 662 case POWER_SUPPLY_PROP_CAPACITY: 663 val->intval = batt; 664 break; 665 default: 666 ret = -EINVAL; 667 break; 668 } 669 return ret; 670 } 671 672 static int steam_battery_register(struct steam_device *steam) 673 { 674 struct power_supply *battery; 675 struct power_supply_config battery_cfg = { .drv_data = steam, }; 676 unsigned long flags; 677 int ret; 678 679 steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; 680 steam->battery_desc.properties = steam_battery_props; 681 steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props); 682 steam->battery_desc.get_property = steam_battery_get_property; 683 steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev, 684 GFP_KERNEL, "steam-controller-%s-battery", 685 steam->serial_no); 686 if (!steam->battery_desc.name) 687 return -ENOMEM; 688 689 /* avoid the warning of 0% battery while waiting for the first info */ 690 spin_lock_irqsave(&steam->lock, flags); 691 steam->voltage = 3000; 692 steam->battery_charge = 100; 693 spin_unlock_irqrestore(&steam->lock, flags); 694 695 battery = power_supply_register(&steam->hdev->dev, 696 &steam->battery_desc, &battery_cfg); 697 if (IS_ERR(battery)) { 698 ret = PTR_ERR(battery); 699 hid_err(steam->hdev, 700 "%s:power_supply_register failed with error %d\n", 701 __func__, ret); 702 return ret; 703 } 704 rcu_assign_pointer(steam->battery, battery); 705 power_supply_powers(battery, &steam->hdev->dev); 706 return 0; 707 } 708 709 static int steam_input_register(struct steam_device *steam) 710 { 711 struct hid_device *hdev = steam->hdev; 712 struct input_dev *input; 713 int ret; 714 715 rcu_read_lock(); 716 input = rcu_dereference(steam->input); 717 rcu_read_unlock(); 718 if (input) { 719 dbg_hid("%s: already connected\n", __func__); 720 return 0; 721 } 722 723 input = input_allocate_device(); 724 if (!input) 725 return -ENOMEM; 726 727 input_set_drvdata(input, steam); 728 input->dev.parent = &hdev->dev; 729 input->open = steam_input_open; 730 input->close = steam_input_close; 731 732 input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ? "Wireless Steam Controller" : 733 (steam->quirks & STEAM_QUIRK_DECK) ? "Steam Deck" : 734 "Steam Controller"; 735 input->phys = hdev->phys; 736 input->uniq = steam->serial_no; 737 input->id.bustype = hdev->bus; 738 input->id.vendor = hdev->vendor; 739 input->id.product = hdev->product; 740 input->id.version = hdev->version; 741 742 input_set_capability(input, EV_KEY, BTN_TR2); 743 input_set_capability(input, EV_KEY, BTN_TL2); 744 input_set_capability(input, EV_KEY, BTN_TR); 745 input_set_capability(input, EV_KEY, BTN_TL); 746 input_set_capability(input, EV_KEY, BTN_Y); 747 input_set_capability(input, EV_KEY, BTN_B); 748 input_set_capability(input, EV_KEY, BTN_X); 749 input_set_capability(input, EV_KEY, BTN_A); 750 input_set_capability(input, EV_KEY, BTN_DPAD_UP); 751 input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT); 752 input_set_capability(input, EV_KEY, BTN_DPAD_LEFT); 753 input_set_capability(input, EV_KEY, BTN_DPAD_DOWN); 754 input_set_capability(input, EV_KEY, BTN_SELECT); 755 input_set_capability(input, EV_KEY, BTN_MODE); 756 input_set_capability(input, EV_KEY, BTN_START); 757 input_set_capability(input, EV_KEY, BTN_THUMBR); 758 input_set_capability(input, EV_KEY, BTN_THUMBL); 759 input_set_capability(input, EV_KEY, BTN_THUMB); 760 input_set_capability(input, EV_KEY, BTN_THUMB2); 761 if (steam->quirks & STEAM_QUIRK_DECK) { 762 input_set_capability(input, EV_KEY, BTN_BASE); 763 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY1); 764 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY2); 765 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY3); 766 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY4); 767 } else { 768 input_set_capability(input, EV_KEY, BTN_GEAR_DOWN); 769 input_set_capability(input, EV_KEY, BTN_GEAR_UP); 770 } 771 772 input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0); 773 input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0); 774 775 input_set_abs_params(input, ABS_HAT0X, -32767, 32767, 776 STEAM_PAD_FUZZ, 0); 777 input_set_abs_params(input, ABS_HAT0Y, -32767, 32767, 778 STEAM_PAD_FUZZ, 0); 779 780 if (steam->quirks & STEAM_QUIRK_DECK) { 781 input_set_abs_params(input, ABS_HAT2Y, 0, 32767, 0, 0); 782 input_set_abs_params(input, ABS_HAT2X, 0, 32767, 0, 0); 783 784 input_set_abs_params(input, ABS_RX, -32767, 32767, 0, 0); 785 input_set_abs_params(input, ABS_RY, -32767, 32767, 0, 0); 786 787 input_set_abs_params(input, ABS_HAT1X, -32767, 32767, 788 STEAM_PAD_FUZZ, 0); 789 input_set_abs_params(input, ABS_HAT1Y, -32767, 32767, 790 STEAM_PAD_FUZZ, 0); 791 792 input_abs_set_res(input, ABS_X, STEAM_DECK_JOYSTICK_RESOLUTION); 793 input_abs_set_res(input, ABS_Y, STEAM_DECK_JOYSTICK_RESOLUTION); 794 input_abs_set_res(input, ABS_RX, STEAM_DECK_JOYSTICK_RESOLUTION); 795 input_abs_set_res(input, ABS_RY, STEAM_DECK_JOYSTICK_RESOLUTION); 796 input_abs_set_res(input, ABS_HAT1X, STEAM_PAD_RESOLUTION); 797 input_abs_set_res(input, ABS_HAT1Y, STEAM_PAD_RESOLUTION); 798 input_abs_set_res(input, ABS_HAT2Y, STEAM_DECK_TRIGGER_RESOLUTION); 799 input_abs_set_res(input, ABS_HAT2X, STEAM_DECK_TRIGGER_RESOLUTION); 800 } else { 801 input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0); 802 input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0); 803 804 input_set_abs_params(input, ABS_RX, -32767, 32767, 805 STEAM_PAD_FUZZ, 0); 806 input_set_abs_params(input, ABS_RY, -32767, 32767, 807 STEAM_PAD_FUZZ, 0); 808 809 input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION); 810 input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION); 811 input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION); 812 input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION); 813 input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION); 814 input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION); 815 } 816 input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION); 817 input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION); 818 819 #ifdef CONFIG_STEAM_FF 820 if (steam->quirks & STEAM_QUIRK_DECK) { 821 input_set_capability(input, EV_FF, FF_RUMBLE); 822 ret = input_ff_create_memless(input, NULL, steam_play_effect); 823 if (ret) 824 goto input_register_fail; 825 } 826 #endif 827 828 ret = input_register_device(input); 829 if (ret) 830 goto input_register_fail; 831 832 rcu_assign_pointer(steam->input, input); 833 return 0; 834 835 input_register_fail: 836 input_free_device(input); 837 return ret; 838 } 839 840 static int steam_sensors_register(struct steam_device *steam) 841 { 842 struct hid_device *hdev = steam->hdev; 843 struct input_dev *sensors; 844 int ret; 845 846 if (!(steam->quirks & STEAM_QUIRK_DECK)) 847 return 0; 848 849 rcu_read_lock(); 850 sensors = rcu_dereference(steam->sensors); 851 rcu_read_unlock(); 852 if (sensors) { 853 dbg_hid("%s: already connected\n", __func__); 854 return 0; 855 } 856 857 sensors = input_allocate_device(); 858 if (!sensors) 859 return -ENOMEM; 860 861 input_set_drvdata(sensors, steam); 862 sensors->dev.parent = &hdev->dev; 863 864 sensors->name = "Steam Deck Motion Sensors"; 865 sensors->phys = hdev->phys; 866 sensors->uniq = steam->serial_no; 867 sensors->id.bustype = hdev->bus; 868 sensors->id.vendor = hdev->vendor; 869 sensors->id.product = hdev->product; 870 sensors->id.version = hdev->version; 871 872 __set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit); 873 __set_bit(EV_MSC, sensors->evbit); 874 __set_bit(MSC_TIMESTAMP, sensors->mscbit); 875 876 input_set_abs_params(sensors, ABS_X, -STEAM_DECK_ACCEL_RANGE, 877 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); 878 input_set_abs_params(sensors, ABS_Y, -STEAM_DECK_ACCEL_RANGE, 879 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); 880 input_set_abs_params(sensors, ABS_Z, -STEAM_DECK_ACCEL_RANGE, 881 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); 882 input_abs_set_res(sensors, ABS_X, STEAM_DECK_ACCEL_RES_PER_G); 883 input_abs_set_res(sensors, ABS_Y, STEAM_DECK_ACCEL_RES_PER_G); 884 input_abs_set_res(sensors, ABS_Z, STEAM_DECK_ACCEL_RES_PER_G); 885 886 input_set_abs_params(sensors, ABS_RX, -STEAM_DECK_GYRO_RANGE, 887 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0); 888 input_set_abs_params(sensors, ABS_RY, -STEAM_DECK_GYRO_RANGE, 889 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0); 890 input_set_abs_params(sensors, ABS_RZ, -STEAM_DECK_GYRO_RANGE, 891 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0); 892 input_abs_set_res(sensors, ABS_RX, STEAM_DECK_GYRO_RES_PER_DPS); 893 input_abs_set_res(sensors, ABS_RY, STEAM_DECK_GYRO_RES_PER_DPS); 894 input_abs_set_res(sensors, ABS_RZ, STEAM_DECK_GYRO_RES_PER_DPS); 895 896 ret = input_register_device(sensors); 897 if (ret) 898 goto sensors_register_fail; 899 900 rcu_assign_pointer(steam->sensors, sensors); 901 return 0; 902 903 sensors_register_fail: 904 input_free_device(sensors); 905 return ret; 906 } 907 908 static void steam_input_unregister(struct steam_device *steam) 909 { 910 struct input_dev *input; 911 rcu_read_lock(); 912 input = rcu_dereference(steam->input); 913 rcu_read_unlock(); 914 if (!input) 915 return; 916 RCU_INIT_POINTER(steam->input, NULL); 917 synchronize_rcu(); 918 input_unregister_device(input); 919 } 920 921 static void steam_sensors_unregister(struct steam_device *steam) 922 { 923 struct input_dev *sensors; 924 925 if (!(steam->quirks & STEAM_QUIRK_DECK)) 926 return; 927 928 rcu_read_lock(); 929 sensors = rcu_dereference(steam->sensors); 930 rcu_read_unlock(); 931 932 if (!sensors) 933 return; 934 RCU_INIT_POINTER(steam->sensors, NULL); 935 synchronize_rcu(); 936 input_unregister_device(sensors); 937 } 938 939 static void steam_battery_unregister(struct steam_device *steam) 940 { 941 struct power_supply *battery; 942 943 rcu_read_lock(); 944 battery = rcu_dereference(steam->battery); 945 rcu_read_unlock(); 946 947 if (!battery) 948 return; 949 RCU_INIT_POINTER(steam->battery, NULL); 950 synchronize_rcu(); 951 power_supply_unregister(battery); 952 } 953 954 static int steam_register(struct steam_device *steam) 955 { 956 int ret; 957 unsigned long client_opened; 958 unsigned long flags; 959 960 /* 961 * This function can be called several times in a row with the 962 * wireless adaptor, without steam_unregister() between them, because 963 * another client send a get_connection_status command, for example. 964 * The battery and serial number are set just once per device. 965 */ 966 if (!steam->serial_no[0]) { 967 /* 968 * Unlikely, but getting the serial could fail, and it is not so 969 * important, so make up a serial number and go on. 970 */ 971 if (steam_get_serial(steam) < 0) 972 strscpy(steam->serial_no, "XXXXXXXXXX", 973 sizeof(steam->serial_no)); 974 975 hid_info(steam->hdev, "Steam Controller '%s' connected", 976 steam->serial_no); 977 978 /* ignore battery errors, we can live without it */ 979 if (steam->quirks & STEAM_QUIRK_WIRELESS) 980 steam_battery_register(steam); 981 982 mutex_lock(&steam_devices_lock); 983 if (list_empty(&steam->list)) 984 list_add(&steam->list, &steam_devices); 985 mutex_unlock(&steam_devices_lock); 986 } 987 988 spin_lock_irqsave(&steam->lock, flags); 989 client_opened = steam->client_opened; 990 spin_unlock_irqrestore(&steam->lock, flags); 991 992 if (!client_opened) { 993 steam_set_lizard_mode(steam, lizard_mode); 994 ret = steam_input_register(steam); 995 if (ret != 0) 996 goto steam_register_input_fail; 997 ret = steam_sensors_register(steam); 998 if (ret != 0) 999 goto steam_register_sensors_fail; 1000 } 1001 return 0; 1002 1003 steam_register_sensors_fail: 1004 steam_input_unregister(steam); 1005 steam_register_input_fail: 1006 return ret; 1007 } 1008 1009 static void steam_unregister(struct steam_device *steam) 1010 { 1011 steam_battery_unregister(steam); 1012 steam_sensors_unregister(steam); 1013 steam_input_unregister(steam); 1014 if (steam->serial_no[0]) { 1015 hid_info(steam->hdev, "Steam Controller '%s' disconnected", 1016 steam->serial_no); 1017 mutex_lock(&steam_devices_lock); 1018 list_del_init(&steam->list); 1019 mutex_unlock(&steam_devices_lock); 1020 steam->serial_no[0] = 0; 1021 } 1022 } 1023 1024 static void steam_work_connect_cb(struct work_struct *work) 1025 { 1026 struct steam_device *steam = container_of(work, struct steam_device, 1027 work_connect); 1028 unsigned long flags; 1029 bool connected; 1030 int ret; 1031 1032 spin_lock_irqsave(&steam->lock, flags); 1033 connected = steam->connected; 1034 spin_unlock_irqrestore(&steam->lock, flags); 1035 1036 if (connected) { 1037 ret = steam_register(steam); 1038 if (ret) { 1039 hid_err(steam->hdev, 1040 "%s:steam_register failed with error %d\n", 1041 __func__, ret); 1042 } 1043 } else { 1044 steam_unregister(steam); 1045 } 1046 } 1047 1048 static void steam_mode_switch_cb(struct work_struct *work) 1049 { 1050 struct steam_device *steam = container_of(to_delayed_work(work), 1051 struct steam_device, mode_switch); 1052 unsigned long flags; 1053 bool client_opened; 1054 if (!lizard_mode) 1055 return; 1056 1057 steam->gamepad_mode = !steam->gamepad_mode; 1058 if (steam->gamepad_mode) 1059 steam_set_lizard_mode(steam, false); 1060 else { 1061 spin_lock_irqsave(&steam->lock, flags); 1062 client_opened = steam->client_opened; 1063 spin_unlock_irqrestore(&steam->lock, flags); 1064 if (!client_opened) 1065 steam_set_lizard_mode(steam, lizard_mode); 1066 } 1067 1068 steam_haptic_pulse(steam, STEAM_PAD_RIGHT, 0x190, 0, 1, 0); 1069 if (steam->gamepad_mode) { 1070 steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x14D, 0x14D, 0x2D, 0); 1071 } else { 1072 steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x1F4, 0x1F4, 0x1E, 0); 1073 } 1074 } 1075 1076 static void steam_work_unregister_cb(struct work_struct *work) 1077 { 1078 struct steam_device *steam = container_of(work, struct steam_device, 1079 unregister_work); 1080 unsigned long flags; 1081 bool connected; 1082 bool opened; 1083 1084 spin_lock_irqsave(&steam->lock, flags); 1085 opened = steam->client_opened; 1086 connected = steam->connected; 1087 spin_unlock_irqrestore(&steam->lock, flags); 1088 1089 if (connected) { 1090 if (opened) { 1091 steam_sensors_unregister(steam); 1092 steam_input_unregister(steam); 1093 } else { 1094 steam_set_lizard_mode(steam, lizard_mode); 1095 steam_input_register(steam); 1096 steam_sensors_register(steam); 1097 } 1098 } 1099 } 1100 1101 static bool steam_is_valve_interface(struct hid_device *hdev) 1102 { 1103 struct hid_report_enum *rep_enum; 1104 1105 /* 1106 * The wired device creates 3 interfaces: 1107 * 0: emulated mouse. 1108 * 1: emulated keyboard. 1109 * 2: the real game pad. 1110 * The wireless device creates 5 interfaces: 1111 * 0: emulated keyboard. 1112 * 1-4: slots where up to 4 real game pads will be connected to. 1113 * We know which one is the real gamepad interface because they are the 1114 * only ones with a feature report. 1115 */ 1116 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT]; 1117 return !list_empty(&rep_enum->report_list); 1118 } 1119 1120 static int steam_client_ll_parse(struct hid_device *hdev) 1121 { 1122 struct steam_device *steam = hdev->driver_data; 1123 1124 return hid_parse_report(hdev, steam->hdev->dev_rdesc, 1125 steam->hdev->dev_rsize); 1126 } 1127 1128 static int steam_client_ll_start(struct hid_device *hdev) 1129 { 1130 return 0; 1131 } 1132 1133 static void steam_client_ll_stop(struct hid_device *hdev) 1134 { 1135 } 1136 1137 static int steam_client_ll_open(struct hid_device *hdev) 1138 { 1139 struct steam_device *steam = hdev->driver_data; 1140 unsigned long flags; 1141 1142 spin_lock_irqsave(&steam->lock, flags); 1143 steam->client_opened++; 1144 spin_unlock_irqrestore(&steam->lock, flags); 1145 1146 schedule_work(&steam->unregister_work); 1147 1148 return 0; 1149 } 1150 1151 static void steam_client_ll_close(struct hid_device *hdev) 1152 { 1153 struct steam_device *steam = hdev->driver_data; 1154 1155 unsigned long flags; 1156 bool connected; 1157 1158 spin_lock_irqsave(&steam->lock, flags); 1159 steam->client_opened--; 1160 connected = steam->connected && !steam->client_opened; 1161 spin_unlock_irqrestore(&steam->lock, flags); 1162 1163 schedule_work(&steam->unregister_work); 1164 } 1165 1166 static int steam_client_ll_raw_request(struct hid_device *hdev, 1167 unsigned char reportnum, u8 *buf, 1168 size_t count, unsigned char report_type, 1169 int reqtype) 1170 { 1171 struct steam_device *steam = hdev->driver_data; 1172 1173 return hid_hw_raw_request(steam->hdev, reportnum, buf, count, 1174 report_type, reqtype); 1175 } 1176 1177 static const struct hid_ll_driver steam_client_ll_driver = { 1178 .parse = steam_client_ll_parse, 1179 .start = steam_client_ll_start, 1180 .stop = steam_client_ll_stop, 1181 .open = steam_client_ll_open, 1182 .close = steam_client_ll_close, 1183 .raw_request = steam_client_ll_raw_request, 1184 }; 1185 1186 static struct hid_device *steam_create_client_hid(struct hid_device *hdev) 1187 { 1188 struct hid_device *client_hdev; 1189 1190 client_hdev = hid_allocate_device(); 1191 if (IS_ERR(client_hdev)) 1192 return client_hdev; 1193 1194 client_hdev->ll_driver = &steam_client_ll_driver; 1195 client_hdev->dev.parent = hdev->dev.parent; 1196 client_hdev->bus = hdev->bus; 1197 client_hdev->vendor = hdev->vendor; 1198 client_hdev->product = hdev->product; 1199 client_hdev->version = hdev->version; 1200 client_hdev->type = hdev->type; 1201 client_hdev->country = hdev->country; 1202 strscpy(client_hdev->name, hdev->name, 1203 sizeof(client_hdev->name)); 1204 strscpy(client_hdev->phys, hdev->phys, 1205 sizeof(client_hdev->phys)); 1206 /* 1207 * Since we use the same device info than the real interface to 1208 * trick userspace, we will be calling steam_probe recursively. 1209 * We need to recognize the client interface somehow. 1210 */ 1211 client_hdev->group = HID_GROUP_STEAM; 1212 return client_hdev; 1213 } 1214 1215 static int steam_probe(struct hid_device *hdev, 1216 const struct hid_device_id *id) 1217 { 1218 struct steam_device *steam; 1219 int ret; 1220 1221 ret = hid_parse(hdev); 1222 if (ret) { 1223 hid_err(hdev, 1224 "%s:parse of hid interface failed\n", __func__); 1225 return ret; 1226 } 1227 1228 /* 1229 * The virtual client_dev is only used for hidraw. 1230 * Also avoid the recursive probe. 1231 */ 1232 if (hdev->group == HID_GROUP_STEAM) 1233 return hid_hw_start(hdev, HID_CONNECT_HIDRAW); 1234 /* 1235 * The non-valve interfaces (mouse and keyboard emulation) are 1236 * connected without changes. 1237 */ 1238 if (!steam_is_valve_interface(hdev)) 1239 return hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1240 1241 steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL); 1242 if (!steam) 1243 return -ENOMEM; 1244 1245 steam->hdev = hdev; 1246 hid_set_drvdata(hdev, steam); 1247 spin_lock_init(&steam->lock); 1248 mutex_init(&steam->report_mutex); 1249 steam->quirks = id->driver_data; 1250 INIT_WORK(&steam->work_connect, steam_work_connect_cb); 1251 INIT_DELAYED_WORK(&steam->mode_switch, steam_mode_switch_cb); 1252 INIT_LIST_HEAD(&steam->list); 1253 INIT_WORK(&steam->rumble_work, steam_haptic_rumble_cb); 1254 steam->sensor_timestamp_us = 0; 1255 INIT_WORK(&steam->unregister_work, steam_work_unregister_cb); 1256 1257 /* 1258 * With the real steam controller interface, do not connect hidraw. 1259 * Instead, create the client_hid and connect that. 1260 */ 1261 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW); 1262 if (ret) 1263 goto err_cancel_work; 1264 1265 ret = hid_hw_open(hdev); 1266 if (ret) { 1267 hid_err(hdev, 1268 "%s:hid_hw_open\n", 1269 __func__); 1270 goto err_hw_stop; 1271 } 1272 1273 if (steam->quirks & STEAM_QUIRK_WIRELESS) { 1274 hid_info(hdev, "Steam wireless receiver connected"); 1275 /* If using a wireless adaptor ask for connection status */ 1276 steam->connected = false; 1277 steam_request_conn_status(steam); 1278 } else { 1279 /* A wired connection is always present */ 1280 steam->connected = true; 1281 ret = steam_register(steam); 1282 if (ret) { 1283 hid_err(hdev, 1284 "%s:steam_register failed with error %d\n", 1285 __func__, ret); 1286 goto err_hw_close; 1287 } 1288 } 1289 1290 steam->client_hdev = steam_create_client_hid(hdev); 1291 if (IS_ERR(steam->client_hdev)) { 1292 ret = PTR_ERR(steam->client_hdev); 1293 goto err_steam_unregister; 1294 } 1295 steam->client_hdev->driver_data = steam; 1296 1297 ret = hid_add_device(steam->client_hdev); 1298 if (ret) 1299 goto err_destroy; 1300 1301 return 0; 1302 1303 err_destroy: 1304 hid_destroy_device(steam->client_hdev); 1305 err_steam_unregister: 1306 if (steam->connected) 1307 steam_unregister(steam); 1308 err_hw_close: 1309 hid_hw_close(hdev); 1310 err_hw_stop: 1311 hid_hw_stop(hdev); 1312 err_cancel_work: 1313 cancel_work_sync(&steam->work_connect); 1314 cancel_delayed_work_sync(&steam->mode_switch); 1315 cancel_work_sync(&steam->rumble_work); 1316 cancel_work_sync(&steam->unregister_work); 1317 1318 return ret; 1319 } 1320 1321 static void steam_remove(struct hid_device *hdev) 1322 { 1323 struct steam_device *steam = hid_get_drvdata(hdev); 1324 1325 if (!steam || hdev->group == HID_GROUP_STEAM) { 1326 hid_hw_stop(hdev); 1327 return; 1328 } 1329 1330 hid_destroy_device(steam->client_hdev); 1331 cancel_delayed_work_sync(&steam->mode_switch); 1332 cancel_work_sync(&steam->work_connect); 1333 cancel_work_sync(&steam->rumble_work); 1334 cancel_work_sync(&steam->unregister_work); 1335 steam->client_hdev = NULL; 1336 steam->client_opened = 0; 1337 if (steam->quirks & STEAM_QUIRK_WIRELESS) { 1338 hid_info(hdev, "Steam wireless receiver disconnected"); 1339 } 1340 hid_hw_close(hdev); 1341 hid_hw_stop(hdev); 1342 steam_unregister(steam); 1343 } 1344 1345 static void steam_do_connect_event(struct steam_device *steam, bool connected) 1346 { 1347 unsigned long flags; 1348 bool changed; 1349 1350 spin_lock_irqsave(&steam->lock, flags); 1351 changed = steam->connected != connected; 1352 steam->connected = connected; 1353 spin_unlock_irqrestore(&steam->lock, flags); 1354 1355 if (changed && schedule_work(&steam->work_connect) == 0) 1356 dbg_hid("%s: connected=%d event already queued\n", 1357 __func__, connected); 1358 } 1359 1360 /* 1361 * Some input data in the protocol has the opposite sign. 1362 * Clamp the values to 32767..-32767 so that the range is 1363 * symmetrical and can be negated safely. 1364 */ 1365 static inline s16 steam_le16(u8 *data) 1366 { 1367 s16 x = (s16) le16_to_cpup((__le16 *)data); 1368 1369 return x == -32768 ? -32767 : x; 1370 } 1371 1372 /* 1373 * The size for this message payload is 60. 1374 * The known values are: 1375 * (* values are not sent through wireless) 1376 * (* accelerator/gyro is disabled by default) 1377 * Offset| Type | Mapped to |Meaning 1378 * -------+-------+-----------+-------------------------- 1379 * 4-7 | u32 | -- | sequence number 1380 * 8-10 | 24bit | see below | buttons 1381 * 11 | u8 | ABS_HAT2Y | left trigger 1382 * 12 | u8 | ABS_HAT2X | right trigger 1383 * 13-15 | -- | -- | always 0 1384 * 16-17 | s16 | ABS_X/ABS_HAT0X | X value 1385 * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value 1386 * 20-21 | s16 | ABS_RX | right-pad X value 1387 * 22-23 | s16 | ABS_RY | right-pad Y value 1388 * 24-25 | s16 | -- | * left trigger 1389 * 26-27 | s16 | -- | * right trigger 1390 * 28-29 | s16 | -- | * accelerometer X value 1391 * 30-31 | s16 | -- | * accelerometer Y value 1392 * 32-33 | s16 | -- | * accelerometer Z value 1393 * 34-35 | s16 | -- | gyro X value 1394 * 36-36 | s16 | -- | gyro Y value 1395 * 38-39 | s16 | -- | gyro Z value 1396 * 40-41 | s16 | -- | quaternion W value 1397 * 42-43 | s16 | -- | quaternion X value 1398 * 44-45 | s16 | -- | quaternion Y value 1399 * 46-47 | s16 | -- | quaternion Z value 1400 * 48-49 | -- | -- | always 0 1401 * 50-51 | s16 | -- | * left trigger (uncalibrated) 1402 * 52-53 | s16 | -- | * right trigger (uncalibrated) 1403 * 54-55 | s16 | -- | * joystick X value (uncalibrated) 1404 * 56-57 | s16 | -- | * joystick Y value (uncalibrated) 1405 * 58-59 | s16 | -- | * left-pad X value 1406 * 60-61 | s16 | -- | * left-pad Y value 1407 * 62-63 | u16 | -- | * battery voltage 1408 * 1409 * The buttons are: 1410 * Bit | Mapped to | Description 1411 * ------+------------+-------------------------------- 1412 * 8.0 | BTN_TR2 | right trigger fully pressed 1413 * 8.1 | BTN_TL2 | left trigger fully pressed 1414 * 8.2 | BTN_TR | right shoulder 1415 * 8.3 | BTN_TL | left shoulder 1416 * 8.4 | BTN_Y | button Y 1417 * 8.5 | BTN_B | button B 1418 * 8.6 | BTN_X | button X 1419 * 8.7 | BTN_A | button A 1420 * 9.0 | BTN_DPAD_UP | left-pad up 1421 * 9.1 | BTN_DPAD_RIGHT | left-pad right 1422 * 9.2 | BTN_DPAD_LEFT | left-pad left 1423 * 9.3 | BTN_DPAD_DOWN | left-pad down 1424 * 9.4 | BTN_SELECT | menu left 1425 * 9.5 | BTN_MODE | steam logo 1426 * 9.6 | BTN_START | menu right 1427 * 9.7 | BTN_GEAR_DOWN | left back lever 1428 * 10.0 | BTN_GEAR_UP | right back lever 1429 * 10.1 | -- | left-pad clicked 1430 * 10.2 | BTN_THUMBR | right-pad clicked 1431 * 10.3 | BTN_THUMB | left-pad touched (but see explanation below) 1432 * 10.4 | BTN_THUMB2 | right-pad touched 1433 * 10.5 | -- | unknown 1434 * 10.6 | BTN_THUMBL | joystick clicked 1435 * 10.7 | -- | lpad_and_joy 1436 */ 1437 1438 static void steam_do_input_event(struct steam_device *steam, 1439 struct input_dev *input, u8 *data) 1440 { 1441 /* 24 bits of buttons */ 1442 u8 b8, b9, b10; 1443 s16 x, y; 1444 bool lpad_touched, lpad_and_joy; 1445 1446 b8 = data[8]; 1447 b9 = data[9]; 1448 b10 = data[10]; 1449 1450 input_report_abs(input, ABS_HAT2Y, data[11]); 1451 input_report_abs(input, ABS_HAT2X, data[12]); 1452 1453 /* 1454 * These two bits tells how to interpret the values X and Y. 1455 * lpad_and_joy tells that the joystick and the lpad are used at the 1456 * same time. 1457 * lpad_touched tells whether X/Y are to be read as lpad coord or 1458 * joystick values. 1459 * (lpad_touched || lpad_and_joy) tells if the lpad is really touched. 1460 */ 1461 lpad_touched = b10 & BIT(3); 1462 lpad_and_joy = b10 & BIT(7); 1463 x = steam_le16(data + 16); 1464 y = -steam_le16(data + 18); 1465 1466 input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x); 1467 input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y); 1468 /* Check if joystick is centered */ 1469 if (lpad_touched && !lpad_and_joy) { 1470 input_report_abs(input, ABS_X, 0); 1471 input_report_abs(input, ABS_Y, 0); 1472 } 1473 /* Check if lpad is untouched */ 1474 if (!(lpad_touched || lpad_and_joy)) { 1475 input_report_abs(input, ABS_HAT0X, 0); 1476 input_report_abs(input, ABS_HAT0Y, 0); 1477 } 1478 1479 input_report_abs(input, ABS_RX, steam_le16(data + 20)); 1480 input_report_abs(input, ABS_RY, -steam_le16(data + 22)); 1481 1482 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0))); 1483 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1))); 1484 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2))); 1485 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3))); 1486 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4))); 1487 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5))); 1488 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6))); 1489 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7))); 1490 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4))); 1491 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5))); 1492 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6))); 1493 input_event(input, EV_KEY, BTN_GEAR_DOWN, !!(b9 & BIT(7))); 1494 input_event(input, EV_KEY, BTN_GEAR_UP, !!(b10 & BIT(0))); 1495 input_event(input, EV_KEY, BTN_THUMBR, !!(b10 & BIT(2))); 1496 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6))); 1497 input_event(input, EV_KEY, BTN_THUMB, lpad_touched || lpad_and_joy); 1498 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(4))); 1499 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0))); 1500 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1))); 1501 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2))); 1502 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3))); 1503 1504 input_sync(input); 1505 } 1506 1507 /* 1508 * The size for this message payload is 56. 1509 * The known values are: 1510 * Offset| Type | Mapped to |Meaning 1511 * -------+-------+-----------+-------------------------- 1512 * 4-7 | u32 | -- | sequence number 1513 * 8-15 | u64 | see below | buttons 1514 * 16-17 | s16 | ABS_HAT0X | left-pad X value 1515 * 18-19 | s16 | ABS_HAT0Y | left-pad Y value 1516 * 20-21 | s16 | ABS_HAT1X | right-pad X value 1517 * 22-23 | s16 | ABS_HAT1Y | right-pad Y value 1518 * 24-25 | s16 | IMU ABS_X | accelerometer X value 1519 * 26-27 | s16 | IMU ABS_Z | accelerometer Y value 1520 * 28-29 | s16 | IMU ABS_Y | accelerometer Z value 1521 * 30-31 | s16 | IMU ABS_RX | gyro X value 1522 * 32-33 | s16 | IMU ABS_RZ | gyro Y value 1523 * 34-35 | s16 | IMU ABS_RY | gyro Z value 1524 * 36-37 | s16 | -- | quaternion W value 1525 * 38-39 | s16 | -- | quaternion X value 1526 * 40-41 | s16 | -- | quaternion Y value 1527 * 42-43 | s16 | -- | quaternion Z value 1528 * 44-45 | u16 | ABS_HAT2Y | left trigger (uncalibrated) 1529 * 46-47 | u16 | ABS_HAT2X | right trigger (uncalibrated) 1530 * 48-49 | s16 | ABS_X | left joystick X 1531 * 50-51 | s16 | ABS_Y | left joystick Y 1532 * 52-53 | s16 | ABS_RX | right joystick X 1533 * 54-55 | s16 | ABS_RY | right joystick Y 1534 * 56-57 | u16 | -- | left pad pressure 1535 * 58-59 | u16 | -- | right pad pressure 1536 * 1537 * The buttons are: 1538 * Bit | Mapped to | Description 1539 * ------+------------+-------------------------------- 1540 * 8.0 | BTN_TR2 | right trigger fully pressed 1541 * 8.1 | BTN_TL2 | left trigger fully pressed 1542 * 8.2 | BTN_TR | right shoulder 1543 * 8.3 | BTN_TL | left shoulder 1544 * 8.4 | BTN_Y | button Y 1545 * 8.5 | BTN_B | button B 1546 * 8.6 | BTN_X | button X 1547 * 8.7 | BTN_A | button A 1548 * 9.0 | BTN_DPAD_UP | left-pad up 1549 * 9.1 | BTN_DPAD_RIGHT | left-pad right 1550 * 9.2 | BTN_DPAD_LEFT | left-pad left 1551 * 9.3 | BTN_DPAD_DOWN | left-pad down 1552 * 9.4 | BTN_SELECT | menu left 1553 * 9.5 | BTN_MODE | steam logo 1554 * 9.6 | BTN_START | menu right 1555 * 9.7 | BTN_TRIGGER_HAPPY3 | left bottom grip button 1556 * 10.0 | BTN_TRIGGER_HAPPY4 | right bottom grip button 1557 * 10.1 | BTN_THUMB | left pad pressed 1558 * 10.2 | BTN_THUMB2 | right pad pressed 1559 * 10.3 | -- | left pad touched 1560 * 10.4 | -- | right pad touched 1561 * 10.5 | -- | unknown 1562 * 10.6 | BTN_THUMBL | left joystick clicked 1563 * 10.7 | -- | unknown 1564 * 11.0 | -- | unknown 1565 * 11.1 | -- | unknown 1566 * 11.2 | BTN_THUMBR | right joystick clicked 1567 * 11.3 | -- | unknown 1568 * 11.4 | -- | unknown 1569 * 11.5 | -- | unknown 1570 * 11.6 | -- | unknown 1571 * 11.7 | -- | unknown 1572 * 12.0 | -- | unknown 1573 * 12.1 | -- | unknown 1574 * 12.2 | -- | unknown 1575 * 12.3 | -- | unknown 1576 * 12.4 | -- | unknown 1577 * 12.5 | -- | unknown 1578 * 12.6 | -- | unknown 1579 * 12.7 | -- | unknown 1580 * 13.0 | -- | unknown 1581 * 13.1 | BTN_TRIGGER_HAPPY1 | left top grip button 1582 * 13.2 | BTN_TRIGGER_HAPPY2 | right top grip button 1583 * 13.3 | -- | unknown 1584 * 13.4 | -- | unknown 1585 * 13.5 | -- | unknown 1586 * 13.6 | -- | left joystick touched 1587 * 13.7 | -- | right joystick touched 1588 * 14.0 | -- | unknown 1589 * 14.1 | -- | unknown 1590 * 14.2 | BTN_BASE | quick access button 1591 * 14.3 | -- | unknown 1592 * 14.4 | -- | unknown 1593 * 14.5 | -- | unknown 1594 * 14.6 | -- | unknown 1595 * 14.7 | -- | unknown 1596 * 15.0 | -- | unknown 1597 * 15.1 | -- | unknown 1598 * 15.2 | -- | unknown 1599 * 15.3 | -- | unknown 1600 * 15.4 | -- | unknown 1601 * 15.5 | -- | unknown 1602 * 15.6 | -- | unknown 1603 * 15.7 | -- | unknown 1604 */ 1605 static void steam_do_deck_input_event(struct steam_device *steam, 1606 struct input_dev *input, u8 *data) 1607 { 1608 u8 b8, b9, b10, b11, b13, b14; 1609 bool lpad_touched, rpad_touched; 1610 1611 b8 = data[8]; 1612 b9 = data[9]; 1613 b10 = data[10]; 1614 b11 = data[11]; 1615 b13 = data[13]; 1616 b14 = data[14]; 1617 1618 if (!(b9 & BIT(6)) && steam->did_mode_switch) { 1619 steam->did_mode_switch = false; 1620 cancel_delayed_work(&steam->mode_switch); 1621 } else if (!steam->client_opened && (b9 & BIT(6)) && !steam->did_mode_switch) { 1622 steam->did_mode_switch = true; 1623 schedule_delayed_work(&steam->mode_switch, 45 * HZ / 100); 1624 } 1625 1626 if (!steam->gamepad_mode && lizard_mode) 1627 return; 1628 1629 lpad_touched = b10 & BIT(3); 1630 rpad_touched = b10 & BIT(4); 1631 1632 if (lpad_touched) { 1633 input_report_abs(input, ABS_HAT0X, steam_le16(data + 16)); 1634 input_report_abs(input, ABS_HAT0Y, steam_le16(data + 18)); 1635 } else { 1636 input_report_abs(input, ABS_HAT0X, 0); 1637 input_report_abs(input, ABS_HAT0Y, 0); 1638 } 1639 1640 if (rpad_touched) { 1641 input_report_abs(input, ABS_HAT1X, steam_le16(data + 20)); 1642 input_report_abs(input, ABS_HAT1Y, steam_le16(data + 22)); 1643 } else { 1644 input_report_abs(input, ABS_HAT1X, 0); 1645 input_report_abs(input, ABS_HAT1Y, 0); 1646 } 1647 1648 input_report_abs(input, ABS_X, steam_le16(data + 48)); 1649 input_report_abs(input, ABS_Y, -steam_le16(data + 50)); 1650 input_report_abs(input, ABS_RX, steam_le16(data + 52)); 1651 input_report_abs(input, ABS_RY, -steam_le16(data + 54)); 1652 1653 input_report_abs(input, ABS_HAT2Y, steam_le16(data + 44)); 1654 input_report_abs(input, ABS_HAT2X, steam_le16(data + 46)); 1655 1656 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0))); 1657 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1))); 1658 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2))); 1659 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3))); 1660 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4))); 1661 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5))); 1662 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6))); 1663 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7))); 1664 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4))); 1665 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5))); 1666 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6))); 1667 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY3, !!(b9 & BIT(7))); 1668 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY4, !!(b10 & BIT(0))); 1669 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6))); 1670 input_event(input, EV_KEY, BTN_THUMBR, !!(b11 & BIT(2))); 1671 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0))); 1672 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1))); 1673 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2))); 1674 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3))); 1675 input_event(input, EV_KEY, BTN_THUMB, !!(b10 & BIT(1))); 1676 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(2))); 1677 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY1, !!(b13 & BIT(1))); 1678 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY2, !!(b13 & BIT(2))); 1679 input_event(input, EV_KEY, BTN_BASE, !!(b14 & BIT(2))); 1680 1681 input_sync(input); 1682 } 1683 1684 static void steam_do_deck_sensors_event(struct steam_device *steam, 1685 struct input_dev *sensors, u8 *data) 1686 { 1687 /* 1688 * The deck input report is received every 4 ms on average, 1689 * with a jitter of +/- 4 ms even though the USB descriptor claims 1690 * that it uses 1 kHz. 1691 * Since the HID report does not include a sensor timestamp, 1692 * use a fixed increment here. 1693 */ 1694 steam->sensor_timestamp_us += 4000; 1695 1696 if (!steam->gamepad_mode && lizard_mode) 1697 return; 1698 1699 input_event(sensors, EV_MSC, MSC_TIMESTAMP, steam->sensor_timestamp_us); 1700 input_report_abs(sensors, ABS_X, steam_le16(data + 24)); 1701 input_report_abs(sensors, ABS_Z, -steam_le16(data + 26)); 1702 input_report_abs(sensors, ABS_Y, steam_le16(data + 28)); 1703 input_report_abs(sensors, ABS_RX, steam_le16(data + 30)); 1704 input_report_abs(sensors, ABS_RZ, -steam_le16(data + 32)); 1705 input_report_abs(sensors, ABS_RY, steam_le16(data + 34)); 1706 1707 input_sync(sensors); 1708 } 1709 1710 /* 1711 * The size for this message payload is 11. 1712 * The known values are: 1713 * Offset| Type | Meaning 1714 * -------+-------+--------------------------- 1715 * 4-7 | u32 | sequence number 1716 * 8-11 | -- | always 0 1717 * 12-13 | u16 | voltage (mV) 1718 * 14 | u8 | battery percent 1719 */ 1720 static void steam_do_battery_event(struct steam_device *steam, 1721 struct power_supply *battery, u8 *data) 1722 { 1723 unsigned long flags; 1724 1725 s16 volts = steam_le16(data + 12); 1726 u8 batt = data[14]; 1727 1728 /* Creating the battery may have failed */ 1729 rcu_read_lock(); 1730 battery = rcu_dereference(steam->battery); 1731 if (likely(battery)) { 1732 spin_lock_irqsave(&steam->lock, flags); 1733 steam->voltage = volts; 1734 steam->battery_charge = batt; 1735 spin_unlock_irqrestore(&steam->lock, flags); 1736 power_supply_changed(battery); 1737 } 1738 rcu_read_unlock(); 1739 } 1740 1741 static int steam_raw_event(struct hid_device *hdev, 1742 struct hid_report *report, u8 *data, 1743 int size) 1744 { 1745 struct steam_device *steam = hid_get_drvdata(hdev); 1746 struct input_dev *input; 1747 struct input_dev *sensors; 1748 struct power_supply *battery; 1749 1750 if (!steam) 1751 return 0; 1752 1753 if (steam->client_opened) 1754 hid_input_report(steam->client_hdev, HID_FEATURE_REPORT, 1755 data, size, 0); 1756 /* 1757 * All messages are size=64, all values little-endian. 1758 * The format is: 1759 * Offset| Meaning 1760 * -------+-------------------------------------------- 1761 * 0-1 | always 0x01, 0x00, maybe protocol version? 1762 * 2 | type of message 1763 * 3 | length of the real payload (not checked) 1764 * 4-n | payload data, depends on the type 1765 * 1766 * There are these known types of message: 1767 * 0x01: input data (60 bytes) 1768 * 0x03: wireless connect/disconnect (1 byte) 1769 * 0x04: battery status (11 bytes) 1770 * 0x09: Steam Deck input data (56 bytes) 1771 */ 1772 1773 if (size != 64 || data[0] != 1 || data[1] != 0) 1774 return 0; 1775 1776 switch (data[2]) { 1777 case ID_CONTROLLER_STATE: 1778 if (steam->client_opened) 1779 return 0; 1780 rcu_read_lock(); 1781 input = rcu_dereference(steam->input); 1782 if (likely(input)) 1783 steam_do_input_event(steam, input, data); 1784 rcu_read_unlock(); 1785 break; 1786 case ID_CONTROLLER_DECK_STATE: 1787 if (steam->client_opened) 1788 return 0; 1789 rcu_read_lock(); 1790 input = rcu_dereference(steam->input); 1791 if (likely(input)) 1792 steam_do_deck_input_event(steam, input, data); 1793 sensors = rcu_dereference(steam->sensors); 1794 if (likely(sensors)) 1795 steam_do_deck_sensors_event(steam, sensors, data); 1796 rcu_read_unlock(); 1797 break; 1798 case ID_CONTROLLER_WIRELESS: 1799 /* 1800 * The payload of this event is a single byte: 1801 * 0x01: disconnected. 1802 * 0x02: connected. 1803 */ 1804 switch (data[4]) { 1805 case 0x01: 1806 steam_do_connect_event(steam, false); 1807 break; 1808 case 0x02: 1809 steam_do_connect_event(steam, true); 1810 break; 1811 } 1812 break; 1813 case ID_CONTROLLER_STATUS: 1814 if (steam->quirks & STEAM_QUIRK_WIRELESS) { 1815 rcu_read_lock(); 1816 battery = rcu_dereference(steam->battery); 1817 if (likely(battery)) { 1818 steam_do_battery_event(steam, battery, data); 1819 } else { 1820 dbg_hid( 1821 "%s: battery data without connect event\n", 1822 __func__); 1823 steam_do_connect_event(steam, true); 1824 } 1825 rcu_read_unlock(); 1826 } 1827 break; 1828 } 1829 return 0; 1830 } 1831 1832 static int steam_param_set_lizard_mode(const char *val, 1833 const struct kernel_param *kp) 1834 { 1835 struct steam_device *steam; 1836 int ret; 1837 1838 ret = param_set_bool(val, kp); 1839 if (ret) 1840 return ret; 1841 1842 mutex_lock(&steam_devices_lock); 1843 list_for_each_entry(steam, &steam_devices, list) { 1844 if (!steam->client_opened) 1845 steam_set_lizard_mode(steam, lizard_mode); 1846 } 1847 mutex_unlock(&steam_devices_lock); 1848 return 0; 1849 } 1850 1851 static const struct kernel_param_ops steam_lizard_mode_ops = { 1852 .set = steam_param_set_lizard_mode, 1853 .get = param_get_bool, 1854 }; 1855 1856 module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644); 1857 MODULE_PARM_DESC(lizard_mode, 1858 "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use"); 1859 1860 static const struct hid_device_id steam_controllers[] = { 1861 { /* Wired Steam Controller */ 1862 HID_USB_DEVICE(USB_VENDOR_ID_VALVE, 1863 USB_DEVICE_ID_STEAM_CONTROLLER) 1864 }, 1865 { /* Wireless Steam Controller */ 1866 HID_USB_DEVICE(USB_VENDOR_ID_VALVE, 1867 USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS), 1868 .driver_data = STEAM_QUIRK_WIRELESS 1869 }, 1870 { /* Steam Deck */ 1871 HID_USB_DEVICE(USB_VENDOR_ID_VALVE, 1872 USB_DEVICE_ID_STEAM_DECK), 1873 .driver_data = STEAM_QUIRK_DECK 1874 }, 1875 {} 1876 }; 1877 1878 MODULE_DEVICE_TABLE(hid, steam_controllers); 1879 1880 static struct hid_driver steam_controller_driver = { 1881 .name = "hid-steam", 1882 .id_table = steam_controllers, 1883 .probe = steam_probe, 1884 .remove = steam_remove, 1885 .raw_event = steam_raw_event, 1886 }; 1887 1888 module_hid_driver(steam_controller_driver); 1889