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 mutex_lock(&steam->report_mutex); 563 if (enable) { 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 } else { 569 /* disable esc, enter, cursor */ 570 steam_send_report_byte(steam, ID_CLEAR_DIGITAL_MAPPINGS); 571 572 if (steam->quirks & STEAM_QUIRK_DECK) { 573 steam_write_settings(steam, 574 SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 575 SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 576 SETTING_LEFT_TRACKPAD_CLICK_PRESSURE, 0xFFFF, /* disable haptic click */ 577 SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE, 0xFFFF, /* disable haptic click */ 578 SETTING_STEAM_WATCHDOG_ENABLE, 0, /* disable watchdog that tests if Steam is active */ 579 0); 580 } else { 581 steam_write_settings(steam, 582 SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 583 SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 584 0); 585 } 586 } 587 mutex_unlock(&steam->report_mutex); 588 } 589 590 static int steam_input_open(struct input_dev *dev) 591 { 592 struct steam_device *steam = input_get_drvdata(dev); 593 unsigned long flags; 594 bool set_lizard_mode; 595 596 /* 597 * Disabling lizard mode automatically is only done on the Steam 598 * Controller. On the Steam Deck, this is toggled manually by holding 599 * the options button instead, handled by steam_mode_switch_cb. 600 */ 601 if (!(steam->quirks & STEAM_QUIRK_DECK)) { 602 spin_lock_irqsave(&steam->lock, flags); 603 set_lizard_mode = !steam->client_opened && lizard_mode; 604 spin_unlock_irqrestore(&steam->lock, flags); 605 if (set_lizard_mode) 606 steam_set_lizard_mode(steam, false); 607 } 608 609 return 0; 610 } 611 612 static void steam_input_close(struct input_dev *dev) 613 { 614 struct steam_device *steam = input_get_drvdata(dev); 615 unsigned long flags; 616 bool set_lizard_mode; 617 618 if (!(steam->quirks & STEAM_QUIRK_DECK)) { 619 spin_lock_irqsave(&steam->lock, flags); 620 set_lizard_mode = !steam->client_opened && lizard_mode; 621 spin_unlock_irqrestore(&steam->lock, flags); 622 if (set_lizard_mode) 623 steam_set_lizard_mode(steam, true); 624 } 625 } 626 627 static enum power_supply_property steam_battery_props[] = { 628 POWER_SUPPLY_PROP_PRESENT, 629 POWER_SUPPLY_PROP_SCOPE, 630 POWER_SUPPLY_PROP_VOLTAGE_NOW, 631 POWER_SUPPLY_PROP_CAPACITY, 632 }; 633 634 static int steam_battery_get_property(struct power_supply *psy, 635 enum power_supply_property psp, 636 union power_supply_propval *val) 637 { 638 struct steam_device *steam = power_supply_get_drvdata(psy); 639 unsigned long flags; 640 s16 volts; 641 u8 batt; 642 int ret = 0; 643 644 spin_lock_irqsave(&steam->lock, flags); 645 volts = steam->voltage; 646 batt = steam->battery_charge; 647 spin_unlock_irqrestore(&steam->lock, flags); 648 649 switch (psp) { 650 case POWER_SUPPLY_PROP_PRESENT: 651 val->intval = 1; 652 break; 653 case POWER_SUPPLY_PROP_SCOPE: 654 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 655 break; 656 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 657 val->intval = volts * 1000; /* mV -> uV */ 658 break; 659 case POWER_SUPPLY_PROP_CAPACITY: 660 val->intval = batt; 661 break; 662 default: 663 ret = -EINVAL; 664 break; 665 } 666 return ret; 667 } 668 669 static int steam_battery_register(struct steam_device *steam) 670 { 671 struct power_supply *battery; 672 struct power_supply_config battery_cfg = { .drv_data = steam, }; 673 unsigned long flags; 674 int ret; 675 676 steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; 677 steam->battery_desc.properties = steam_battery_props; 678 steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props); 679 steam->battery_desc.get_property = steam_battery_get_property; 680 steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev, 681 GFP_KERNEL, "steam-controller-%s-battery", 682 steam->serial_no); 683 if (!steam->battery_desc.name) 684 return -ENOMEM; 685 686 /* avoid the warning of 0% battery while waiting for the first info */ 687 spin_lock_irqsave(&steam->lock, flags); 688 steam->voltage = 3000; 689 steam->battery_charge = 100; 690 spin_unlock_irqrestore(&steam->lock, flags); 691 692 battery = power_supply_register(&steam->hdev->dev, 693 &steam->battery_desc, &battery_cfg); 694 if (IS_ERR(battery)) { 695 ret = PTR_ERR(battery); 696 hid_err(steam->hdev, 697 "%s:power_supply_register failed with error %d\n", 698 __func__, ret); 699 return ret; 700 } 701 rcu_assign_pointer(steam->battery, battery); 702 power_supply_powers(battery, &steam->hdev->dev); 703 return 0; 704 } 705 706 static int steam_input_register(struct steam_device *steam) 707 { 708 struct hid_device *hdev = steam->hdev; 709 struct input_dev *input; 710 int ret; 711 712 rcu_read_lock(); 713 input = rcu_dereference(steam->input); 714 rcu_read_unlock(); 715 if (input) { 716 dbg_hid("%s: already connected\n", __func__); 717 return 0; 718 } 719 720 input = input_allocate_device(); 721 if (!input) 722 return -ENOMEM; 723 724 input_set_drvdata(input, steam); 725 input->dev.parent = &hdev->dev; 726 input->open = steam_input_open; 727 input->close = steam_input_close; 728 729 input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ? "Wireless Steam Controller" : 730 (steam->quirks & STEAM_QUIRK_DECK) ? "Steam Deck" : 731 "Steam Controller"; 732 input->phys = hdev->phys; 733 input->uniq = steam->serial_no; 734 input->id.bustype = hdev->bus; 735 input->id.vendor = hdev->vendor; 736 input->id.product = hdev->product; 737 input->id.version = hdev->version; 738 739 input_set_capability(input, EV_KEY, BTN_TR2); 740 input_set_capability(input, EV_KEY, BTN_TL2); 741 input_set_capability(input, EV_KEY, BTN_TR); 742 input_set_capability(input, EV_KEY, BTN_TL); 743 input_set_capability(input, EV_KEY, BTN_Y); 744 input_set_capability(input, EV_KEY, BTN_B); 745 input_set_capability(input, EV_KEY, BTN_X); 746 input_set_capability(input, EV_KEY, BTN_A); 747 input_set_capability(input, EV_KEY, BTN_DPAD_UP); 748 input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT); 749 input_set_capability(input, EV_KEY, BTN_DPAD_LEFT); 750 input_set_capability(input, EV_KEY, BTN_DPAD_DOWN); 751 input_set_capability(input, EV_KEY, BTN_SELECT); 752 input_set_capability(input, EV_KEY, BTN_MODE); 753 input_set_capability(input, EV_KEY, BTN_START); 754 input_set_capability(input, EV_KEY, BTN_THUMBR); 755 input_set_capability(input, EV_KEY, BTN_THUMBL); 756 input_set_capability(input, EV_KEY, BTN_THUMB); 757 input_set_capability(input, EV_KEY, BTN_THUMB2); 758 if (steam->quirks & STEAM_QUIRK_DECK) { 759 input_set_capability(input, EV_KEY, BTN_BASE); 760 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY1); 761 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY2); 762 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY3); 763 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY4); 764 } else { 765 input_set_capability(input, EV_KEY, BTN_GEAR_DOWN); 766 input_set_capability(input, EV_KEY, BTN_GEAR_UP); 767 } 768 769 input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0); 770 input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0); 771 772 input_set_abs_params(input, ABS_HAT0X, -32767, 32767, 773 STEAM_PAD_FUZZ, 0); 774 input_set_abs_params(input, ABS_HAT0Y, -32767, 32767, 775 STEAM_PAD_FUZZ, 0); 776 777 if (steam->quirks & STEAM_QUIRK_DECK) { 778 input_set_abs_params(input, ABS_HAT2Y, 0, 32767, 0, 0); 779 input_set_abs_params(input, ABS_HAT2X, 0, 32767, 0, 0); 780 781 input_set_abs_params(input, ABS_RX, -32767, 32767, 0, 0); 782 input_set_abs_params(input, ABS_RY, -32767, 32767, 0, 0); 783 784 input_set_abs_params(input, ABS_HAT1X, -32767, 32767, 785 STEAM_PAD_FUZZ, 0); 786 input_set_abs_params(input, ABS_HAT1Y, -32767, 32767, 787 STEAM_PAD_FUZZ, 0); 788 789 input_abs_set_res(input, ABS_X, STEAM_DECK_JOYSTICK_RESOLUTION); 790 input_abs_set_res(input, ABS_Y, STEAM_DECK_JOYSTICK_RESOLUTION); 791 input_abs_set_res(input, ABS_RX, STEAM_DECK_JOYSTICK_RESOLUTION); 792 input_abs_set_res(input, ABS_RY, STEAM_DECK_JOYSTICK_RESOLUTION); 793 input_abs_set_res(input, ABS_HAT1X, STEAM_PAD_RESOLUTION); 794 input_abs_set_res(input, ABS_HAT1Y, STEAM_PAD_RESOLUTION); 795 input_abs_set_res(input, ABS_HAT2Y, STEAM_DECK_TRIGGER_RESOLUTION); 796 input_abs_set_res(input, ABS_HAT2X, STEAM_DECK_TRIGGER_RESOLUTION); 797 } else { 798 input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0); 799 input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0); 800 801 input_set_abs_params(input, ABS_RX, -32767, 32767, 802 STEAM_PAD_FUZZ, 0); 803 input_set_abs_params(input, ABS_RY, -32767, 32767, 804 STEAM_PAD_FUZZ, 0); 805 806 input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION); 807 input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION); 808 input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION); 809 input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION); 810 input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION); 811 input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION); 812 } 813 input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION); 814 input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION); 815 816 #ifdef CONFIG_STEAM_FF 817 if (steam->quirks & STEAM_QUIRK_DECK) { 818 input_set_capability(input, EV_FF, FF_RUMBLE); 819 ret = input_ff_create_memless(input, NULL, steam_play_effect); 820 if (ret) 821 goto input_register_fail; 822 } 823 #endif 824 825 ret = input_register_device(input); 826 if (ret) 827 goto input_register_fail; 828 829 rcu_assign_pointer(steam->input, input); 830 return 0; 831 832 input_register_fail: 833 input_free_device(input); 834 return ret; 835 } 836 837 static int steam_sensors_register(struct steam_device *steam) 838 { 839 struct hid_device *hdev = steam->hdev; 840 struct input_dev *sensors; 841 int ret; 842 843 if (!(steam->quirks & STEAM_QUIRK_DECK)) 844 return 0; 845 846 rcu_read_lock(); 847 sensors = rcu_dereference(steam->sensors); 848 rcu_read_unlock(); 849 if (sensors) { 850 dbg_hid("%s: already connected\n", __func__); 851 return 0; 852 } 853 854 sensors = input_allocate_device(); 855 if (!sensors) 856 return -ENOMEM; 857 858 input_set_drvdata(sensors, steam); 859 sensors->dev.parent = &hdev->dev; 860 861 sensors->name = "Steam Deck Motion Sensors"; 862 sensors->phys = hdev->phys; 863 sensors->uniq = steam->serial_no; 864 sensors->id.bustype = hdev->bus; 865 sensors->id.vendor = hdev->vendor; 866 sensors->id.product = hdev->product; 867 sensors->id.version = hdev->version; 868 869 __set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit); 870 __set_bit(EV_MSC, sensors->evbit); 871 __set_bit(MSC_TIMESTAMP, sensors->mscbit); 872 873 input_set_abs_params(sensors, ABS_X, -STEAM_DECK_ACCEL_RANGE, 874 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); 875 input_set_abs_params(sensors, ABS_Y, -STEAM_DECK_ACCEL_RANGE, 876 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); 877 input_set_abs_params(sensors, ABS_Z, -STEAM_DECK_ACCEL_RANGE, 878 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); 879 input_abs_set_res(sensors, ABS_X, STEAM_DECK_ACCEL_RES_PER_G); 880 input_abs_set_res(sensors, ABS_Y, STEAM_DECK_ACCEL_RES_PER_G); 881 input_abs_set_res(sensors, ABS_Z, STEAM_DECK_ACCEL_RES_PER_G); 882 883 input_set_abs_params(sensors, ABS_RX, -STEAM_DECK_GYRO_RANGE, 884 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0); 885 input_set_abs_params(sensors, ABS_RY, -STEAM_DECK_GYRO_RANGE, 886 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0); 887 input_set_abs_params(sensors, ABS_RZ, -STEAM_DECK_GYRO_RANGE, 888 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0); 889 input_abs_set_res(sensors, ABS_RX, STEAM_DECK_GYRO_RES_PER_DPS); 890 input_abs_set_res(sensors, ABS_RY, STEAM_DECK_GYRO_RES_PER_DPS); 891 input_abs_set_res(sensors, ABS_RZ, STEAM_DECK_GYRO_RES_PER_DPS); 892 893 ret = input_register_device(sensors); 894 if (ret) 895 goto sensors_register_fail; 896 897 rcu_assign_pointer(steam->sensors, sensors); 898 return 0; 899 900 sensors_register_fail: 901 input_free_device(sensors); 902 return ret; 903 } 904 905 static void steam_input_unregister(struct steam_device *steam) 906 { 907 struct input_dev *input; 908 rcu_read_lock(); 909 input = rcu_dereference(steam->input); 910 rcu_read_unlock(); 911 if (!input) 912 return; 913 RCU_INIT_POINTER(steam->input, NULL); 914 synchronize_rcu(); 915 input_unregister_device(input); 916 } 917 918 static void steam_sensors_unregister(struct steam_device *steam) 919 { 920 struct input_dev *sensors; 921 922 if (!(steam->quirks & STEAM_QUIRK_DECK)) 923 return; 924 925 rcu_read_lock(); 926 sensors = rcu_dereference(steam->sensors); 927 rcu_read_unlock(); 928 929 if (!sensors) 930 return; 931 RCU_INIT_POINTER(steam->sensors, NULL); 932 synchronize_rcu(); 933 input_unregister_device(sensors); 934 } 935 936 static void steam_battery_unregister(struct steam_device *steam) 937 { 938 struct power_supply *battery; 939 940 rcu_read_lock(); 941 battery = rcu_dereference(steam->battery); 942 rcu_read_unlock(); 943 944 if (!battery) 945 return; 946 RCU_INIT_POINTER(steam->battery, NULL); 947 synchronize_rcu(); 948 power_supply_unregister(battery); 949 } 950 951 static int steam_register(struct steam_device *steam) 952 { 953 int ret; 954 unsigned long client_opened; 955 unsigned long flags; 956 957 /* 958 * This function can be called several times in a row with the 959 * wireless adaptor, without steam_unregister() between them, because 960 * another client send a get_connection_status command, for example. 961 * The battery and serial number are set just once per device. 962 */ 963 if (!steam->serial_no[0]) { 964 /* 965 * Unlikely, but getting the serial could fail, and it is not so 966 * important, so make up a serial number and go on. 967 */ 968 if (steam_get_serial(steam) < 0) 969 strscpy(steam->serial_no, "XXXXXXXXXX", 970 sizeof(steam->serial_no)); 971 972 hid_info(steam->hdev, "Steam Controller '%s' connected", 973 steam->serial_no); 974 975 /* ignore battery errors, we can live without it */ 976 if (steam->quirks & STEAM_QUIRK_WIRELESS) 977 steam_battery_register(steam); 978 979 mutex_lock(&steam_devices_lock); 980 if (list_empty(&steam->list)) 981 list_add(&steam->list, &steam_devices); 982 mutex_unlock(&steam_devices_lock); 983 } 984 985 spin_lock_irqsave(&steam->lock, flags); 986 client_opened = steam->client_opened; 987 spin_unlock_irqrestore(&steam->lock, flags); 988 989 if (!client_opened) { 990 steam_set_lizard_mode(steam, lizard_mode); 991 ret = steam_input_register(steam); 992 if (ret != 0) 993 goto steam_register_input_fail; 994 ret = steam_sensors_register(steam); 995 if (ret != 0) 996 goto steam_register_sensors_fail; 997 } 998 return 0; 999 1000 steam_register_sensors_fail: 1001 steam_input_unregister(steam); 1002 steam_register_input_fail: 1003 return ret; 1004 } 1005 1006 static void steam_unregister(struct steam_device *steam) 1007 { 1008 steam_battery_unregister(steam); 1009 steam_sensors_unregister(steam); 1010 steam_input_unregister(steam); 1011 if (steam->serial_no[0]) { 1012 hid_info(steam->hdev, "Steam Controller '%s' disconnected", 1013 steam->serial_no); 1014 mutex_lock(&steam_devices_lock); 1015 list_del_init(&steam->list); 1016 mutex_unlock(&steam_devices_lock); 1017 steam->serial_no[0] = 0; 1018 } 1019 } 1020 1021 static void steam_work_connect_cb(struct work_struct *work) 1022 { 1023 struct steam_device *steam = container_of(work, struct steam_device, 1024 work_connect); 1025 unsigned long flags; 1026 bool connected; 1027 int ret; 1028 1029 spin_lock_irqsave(&steam->lock, flags); 1030 connected = steam->connected; 1031 spin_unlock_irqrestore(&steam->lock, flags); 1032 1033 if (connected) { 1034 ret = steam_register(steam); 1035 if (ret) { 1036 hid_err(steam->hdev, 1037 "%s:steam_register failed with error %d\n", 1038 __func__, ret); 1039 } 1040 } else { 1041 steam_unregister(steam); 1042 } 1043 } 1044 1045 static void steam_mode_switch_cb(struct work_struct *work) 1046 { 1047 struct steam_device *steam = container_of(to_delayed_work(work), 1048 struct steam_device, mode_switch); 1049 unsigned long flags; 1050 bool client_opened; 1051 if (!lizard_mode) 1052 return; 1053 1054 steam->gamepad_mode = !steam->gamepad_mode; 1055 if (steam->gamepad_mode) 1056 steam_set_lizard_mode(steam, false); 1057 else { 1058 spin_lock_irqsave(&steam->lock, flags); 1059 client_opened = steam->client_opened; 1060 spin_unlock_irqrestore(&steam->lock, flags); 1061 if (!client_opened) 1062 steam_set_lizard_mode(steam, lizard_mode); 1063 } 1064 1065 steam_haptic_pulse(steam, STEAM_PAD_RIGHT, 0x190, 0, 1, 0); 1066 if (steam->gamepad_mode) { 1067 steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x14D, 0x14D, 0x2D, 0); 1068 } else { 1069 steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x1F4, 0x1F4, 0x1E, 0); 1070 } 1071 } 1072 1073 static void steam_work_unregister_cb(struct work_struct *work) 1074 { 1075 struct steam_device *steam = container_of(work, struct steam_device, 1076 unregister_work); 1077 unsigned long flags; 1078 bool connected; 1079 bool opened; 1080 1081 spin_lock_irqsave(&steam->lock, flags); 1082 opened = steam->client_opened; 1083 connected = steam->connected; 1084 spin_unlock_irqrestore(&steam->lock, flags); 1085 1086 if (connected) { 1087 if (opened) { 1088 steam_sensors_unregister(steam); 1089 steam_input_unregister(steam); 1090 } else { 1091 steam_set_lizard_mode(steam, lizard_mode); 1092 steam_input_register(steam); 1093 steam_sensors_register(steam); 1094 } 1095 } 1096 } 1097 1098 static bool steam_is_valve_interface(struct hid_device *hdev) 1099 { 1100 struct hid_report_enum *rep_enum; 1101 1102 /* 1103 * The wired device creates 3 interfaces: 1104 * 0: emulated mouse. 1105 * 1: emulated keyboard. 1106 * 2: the real game pad. 1107 * The wireless device creates 5 interfaces: 1108 * 0: emulated keyboard. 1109 * 1-4: slots where up to 4 real game pads will be connected to. 1110 * We know which one is the real gamepad interface because they are the 1111 * only ones with a feature report. 1112 */ 1113 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT]; 1114 return !list_empty(&rep_enum->report_list); 1115 } 1116 1117 static int steam_client_ll_parse(struct hid_device *hdev) 1118 { 1119 struct steam_device *steam = hdev->driver_data; 1120 1121 return hid_parse_report(hdev, steam->hdev->dev_rdesc, 1122 steam->hdev->dev_rsize); 1123 } 1124 1125 static int steam_client_ll_start(struct hid_device *hdev) 1126 { 1127 return 0; 1128 } 1129 1130 static void steam_client_ll_stop(struct hid_device *hdev) 1131 { 1132 } 1133 1134 static int steam_client_ll_open(struct hid_device *hdev) 1135 { 1136 struct steam_device *steam = hdev->driver_data; 1137 unsigned long flags; 1138 1139 spin_lock_irqsave(&steam->lock, flags); 1140 steam->client_opened++; 1141 spin_unlock_irqrestore(&steam->lock, flags); 1142 1143 schedule_work(&steam->unregister_work); 1144 1145 return 0; 1146 } 1147 1148 static void steam_client_ll_close(struct hid_device *hdev) 1149 { 1150 struct steam_device *steam = hdev->driver_data; 1151 1152 unsigned long flags; 1153 1154 spin_lock_irqsave(&steam->lock, flags); 1155 steam->client_opened--; 1156 spin_unlock_irqrestore(&steam->lock, flags); 1157 1158 schedule_work(&steam->unregister_work); 1159 } 1160 1161 static int steam_client_ll_raw_request(struct hid_device *hdev, 1162 unsigned char reportnum, u8 *buf, 1163 size_t count, unsigned char report_type, 1164 int reqtype) 1165 { 1166 struct steam_device *steam = hdev->driver_data; 1167 1168 return hid_hw_raw_request(steam->hdev, reportnum, buf, count, 1169 report_type, reqtype); 1170 } 1171 1172 static const struct hid_ll_driver steam_client_ll_driver = { 1173 .parse = steam_client_ll_parse, 1174 .start = steam_client_ll_start, 1175 .stop = steam_client_ll_stop, 1176 .open = steam_client_ll_open, 1177 .close = steam_client_ll_close, 1178 .raw_request = steam_client_ll_raw_request, 1179 }; 1180 1181 static struct hid_device *steam_create_client_hid(struct hid_device *hdev) 1182 { 1183 struct hid_device *client_hdev; 1184 1185 client_hdev = hid_allocate_device(); 1186 if (IS_ERR(client_hdev)) 1187 return client_hdev; 1188 1189 client_hdev->ll_driver = &steam_client_ll_driver; 1190 client_hdev->dev.parent = hdev->dev.parent; 1191 client_hdev->bus = hdev->bus; 1192 client_hdev->vendor = hdev->vendor; 1193 client_hdev->product = hdev->product; 1194 client_hdev->version = hdev->version; 1195 client_hdev->type = hdev->type; 1196 client_hdev->country = hdev->country; 1197 strscpy(client_hdev->name, hdev->name, 1198 sizeof(client_hdev->name)); 1199 strscpy(client_hdev->phys, hdev->phys, 1200 sizeof(client_hdev->phys)); 1201 /* 1202 * Since we use the same device info than the real interface to 1203 * trick userspace, we will be calling steam_probe recursively. 1204 * We need to recognize the client interface somehow. 1205 */ 1206 client_hdev->group = HID_GROUP_STEAM; 1207 return client_hdev; 1208 } 1209 1210 static int steam_probe(struct hid_device *hdev, 1211 const struct hid_device_id *id) 1212 { 1213 struct steam_device *steam; 1214 int ret; 1215 1216 ret = hid_parse(hdev); 1217 if (ret) { 1218 hid_err(hdev, 1219 "%s:parse of hid interface failed\n", __func__); 1220 return ret; 1221 } 1222 1223 /* 1224 * The virtual client_dev is only used for hidraw. 1225 * Also avoid the recursive probe. 1226 */ 1227 if (hdev->group == HID_GROUP_STEAM) 1228 return hid_hw_start(hdev, HID_CONNECT_HIDRAW); 1229 /* 1230 * The non-valve interfaces (mouse and keyboard emulation) are 1231 * connected without changes. 1232 */ 1233 if (!steam_is_valve_interface(hdev)) 1234 return hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1235 1236 steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL); 1237 if (!steam) 1238 return -ENOMEM; 1239 1240 steam->hdev = hdev; 1241 hid_set_drvdata(hdev, steam); 1242 spin_lock_init(&steam->lock); 1243 mutex_init(&steam->report_mutex); 1244 steam->quirks = id->driver_data; 1245 INIT_WORK(&steam->work_connect, steam_work_connect_cb); 1246 INIT_DELAYED_WORK(&steam->mode_switch, steam_mode_switch_cb); 1247 INIT_LIST_HEAD(&steam->list); 1248 INIT_WORK(&steam->rumble_work, steam_haptic_rumble_cb); 1249 steam->sensor_timestamp_us = 0; 1250 INIT_WORK(&steam->unregister_work, steam_work_unregister_cb); 1251 1252 /* 1253 * With the real steam controller interface, do not connect hidraw. 1254 * Instead, create the client_hid and connect that. 1255 */ 1256 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW); 1257 if (ret) 1258 goto err_cancel_work; 1259 1260 ret = hid_hw_open(hdev); 1261 if (ret) { 1262 hid_err(hdev, 1263 "%s:hid_hw_open\n", 1264 __func__); 1265 goto err_hw_stop; 1266 } 1267 1268 if (steam->quirks & STEAM_QUIRK_WIRELESS) { 1269 hid_info(hdev, "Steam wireless receiver connected"); 1270 /* If using a wireless adaptor ask for connection status */ 1271 steam->connected = false; 1272 steam_request_conn_status(steam); 1273 } else { 1274 /* A wired connection is always present */ 1275 steam->connected = true; 1276 ret = steam_register(steam); 1277 if (ret) { 1278 hid_err(hdev, 1279 "%s:steam_register failed with error %d\n", 1280 __func__, ret); 1281 goto err_hw_close; 1282 } 1283 } 1284 1285 steam->client_hdev = steam_create_client_hid(hdev); 1286 if (IS_ERR(steam->client_hdev)) { 1287 ret = PTR_ERR(steam->client_hdev); 1288 goto err_steam_unregister; 1289 } 1290 steam->client_hdev->driver_data = steam; 1291 1292 ret = hid_add_device(steam->client_hdev); 1293 if (ret) 1294 goto err_destroy; 1295 1296 return 0; 1297 1298 err_destroy: 1299 hid_destroy_device(steam->client_hdev); 1300 err_steam_unregister: 1301 if (steam->connected) 1302 steam_unregister(steam); 1303 err_hw_close: 1304 hid_hw_close(hdev); 1305 err_hw_stop: 1306 hid_hw_stop(hdev); 1307 err_cancel_work: 1308 cancel_work_sync(&steam->work_connect); 1309 cancel_delayed_work_sync(&steam->mode_switch); 1310 cancel_work_sync(&steam->rumble_work); 1311 cancel_work_sync(&steam->unregister_work); 1312 1313 return ret; 1314 } 1315 1316 static void steam_remove(struct hid_device *hdev) 1317 { 1318 struct steam_device *steam = hid_get_drvdata(hdev); 1319 1320 if (!steam || hdev->group == HID_GROUP_STEAM) { 1321 hid_hw_stop(hdev); 1322 return; 1323 } 1324 1325 hid_destroy_device(steam->client_hdev); 1326 cancel_delayed_work_sync(&steam->mode_switch); 1327 cancel_work_sync(&steam->work_connect); 1328 cancel_work_sync(&steam->rumble_work); 1329 cancel_work_sync(&steam->unregister_work); 1330 steam->client_hdev = NULL; 1331 steam->client_opened = 0; 1332 if (steam->quirks & STEAM_QUIRK_WIRELESS) { 1333 hid_info(hdev, "Steam wireless receiver disconnected"); 1334 } 1335 hid_hw_close(hdev); 1336 hid_hw_stop(hdev); 1337 steam_unregister(steam); 1338 } 1339 1340 static void steam_do_connect_event(struct steam_device *steam, bool connected) 1341 { 1342 unsigned long flags; 1343 bool changed; 1344 1345 spin_lock_irqsave(&steam->lock, flags); 1346 changed = steam->connected != connected; 1347 steam->connected = connected; 1348 spin_unlock_irqrestore(&steam->lock, flags); 1349 1350 if (changed && schedule_work(&steam->work_connect) == 0) 1351 dbg_hid("%s: connected=%d event already queued\n", 1352 __func__, connected); 1353 } 1354 1355 /* 1356 * Some input data in the protocol has the opposite sign. 1357 * Clamp the values to 32767..-32767 so that the range is 1358 * symmetrical and can be negated safely. 1359 */ 1360 static inline s16 steam_le16(u8 *data) 1361 { 1362 s16 x = (s16) le16_to_cpup((__le16 *)data); 1363 1364 return x == -32768 ? -32767 : x; 1365 } 1366 1367 /* 1368 * The size for this message payload is 60. 1369 * The known values are: 1370 * (* values are not sent through wireless) 1371 * (* accelerator/gyro is disabled by default) 1372 * Offset| Type | Mapped to |Meaning 1373 * -------+-------+-----------+-------------------------- 1374 * 4-7 | u32 | -- | sequence number 1375 * 8-10 | 24bit | see below | buttons 1376 * 11 | u8 | ABS_HAT2Y | left trigger 1377 * 12 | u8 | ABS_HAT2X | right trigger 1378 * 13-15 | -- | -- | always 0 1379 * 16-17 | s16 | ABS_X/ABS_HAT0X | X value 1380 * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value 1381 * 20-21 | s16 | ABS_RX | right-pad X value 1382 * 22-23 | s16 | ABS_RY | right-pad Y value 1383 * 24-25 | s16 | -- | * left trigger 1384 * 26-27 | s16 | -- | * right trigger 1385 * 28-29 | s16 | -- | * accelerometer X value 1386 * 30-31 | s16 | -- | * accelerometer Y value 1387 * 32-33 | s16 | -- | * accelerometer Z value 1388 * 34-35 | s16 | -- | gyro X value 1389 * 36-36 | s16 | -- | gyro Y value 1390 * 38-39 | s16 | -- | gyro Z value 1391 * 40-41 | s16 | -- | quaternion W value 1392 * 42-43 | s16 | -- | quaternion X value 1393 * 44-45 | s16 | -- | quaternion Y value 1394 * 46-47 | s16 | -- | quaternion Z value 1395 * 48-49 | -- | -- | always 0 1396 * 50-51 | s16 | -- | * left trigger (uncalibrated) 1397 * 52-53 | s16 | -- | * right trigger (uncalibrated) 1398 * 54-55 | s16 | -- | * joystick X value (uncalibrated) 1399 * 56-57 | s16 | -- | * joystick Y value (uncalibrated) 1400 * 58-59 | s16 | -- | * left-pad X value 1401 * 60-61 | s16 | -- | * left-pad Y value 1402 * 62-63 | u16 | -- | * battery voltage 1403 * 1404 * The buttons are: 1405 * Bit | Mapped to | Description 1406 * ------+------------+-------------------------------- 1407 * 8.0 | BTN_TR2 | right trigger fully pressed 1408 * 8.1 | BTN_TL2 | left trigger fully pressed 1409 * 8.2 | BTN_TR | right shoulder 1410 * 8.3 | BTN_TL | left shoulder 1411 * 8.4 | BTN_Y | button Y 1412 * 8.5 | BTN_B | button B 1413 * 8.6 | BTN_X | button X 1414 * 8.7 | BTN_A | button A 1415 * 9.0 | BTN_DPAD_UP | left-pad up 1416 * 9.1 | BTN_DPAD_RIGHT | left-pad right 1417 * 9.2 | BTN_DPAD_LEFT | left-pad left 1418 * 9.3 | BTN_DPAD_DOWN | left-pad down 1419 * 9.4 | BTN_SELECT | menu left 1420 * 9.5 | BTN_MODE | steam logo 1421 * 9.6 | BTN_START | menu right 1422 * 9.7 | BTN_GEAR_DOWN | left back lever 1423 * 10.0 | BTN_GEAR_UP | right back lever 1424 * 10.1 | -- | left-pad clicked 1425 * 10.2 | BTN_THUMBR | right-pad clicked 1426 * 10.3 | BTN_THUMB | left-pad touched (but see explanation below) 1427 * 10.4 | BTN_THUMB2 | right-pad touched 1428 * 10.5 | -- | unknown 1429 * 10.6 | BTN_THUMBL | joystick clicked 1430 * 10.7 | -- | lpad_and_joy 1431 */ 1432 1433 static void steam_do_input_event(struct steam_device *steam, 1434 struct input_dev *input, u8 *data) 1435 { 1436 /* 24 bits of buttons */ 1437 u8 b8, b9, b10; 1438 s16 x, y; 1439 bool lpad_touched, lpad_and_joy; 1440 1441 b8 = data[8]; 1442 b9 = data[9]; 1443 b10 = data[10]; 1444 1445 input_report_abs(input, ABS_HAT2Y, data[11]); 1446 input_report_abs(input, ABS_HAT2X, data[12]); 1447 1448 /* 1449 * These two bits tells how to interpret the values X and Y. 1450 * lpad_and_joy tells that the joystick and the lpad are used at the 1451 * same time. 1452 * lpad_touched tells whether X/Y are to be read as lpad coord or 1453 * joystick values. 1454 * (lpad_touched || lpad_and_joy) tells if the lpad is really touched. 1455 */ 1456 lpad_touched = b10 & BIT(3); 1457 lpad_and_joy = b10 & BIT(7); 1458 x = steam_le16(data + 16); 1459 y = -steam_le16(data + 18); 1460 1461 input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x); 1462 input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y); 1463 /* Check if joystick is centered */ 1464 if (lpad_touched && !lpad_and_joy) { 1465 input_report_abs(input, ABS_X, 0); 1466 input_report_abs(input, ABS_Y, 0); 1467 } 1468 /* Check if lpad is untouched */ 1469 if (!(lpad_touched || lpad_and_joy)) { 1470 input_report_abs(input, ABS_HAT0X, 0); 1471 input_report_abs(input, ABS_HAT0Y, 0); 1472 } 1473 1474 input_report_abs(input, ABS_RX, steam_le16(data + 20)); 1475 input_report_abs(input, ABS_RY, -steam_le16(data + 22)); 1476 1477 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0))); 1478 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1))); 1479 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2))); 1480 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3))); 1481 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4))); 1482 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5))); 1483 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6))); 1484 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7))); 1485 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4))); 1486 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5))); 1487 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6))); 1488 input_event(input, EV_KEY, BTN_GEAR_DOWN, !!(b9 & BIT(7))); 1489 input_event(input, EV_KEY, BTN_GEAR_UP, !!(b10 & BIT(0))); 1490 input_event(input, EV_KEY, BTN_THUMBR, !!(b10 & BIT(2))); 1491 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6))); 1492 input_event(input, EV_KEY, BTN_THUMB, lpad_touched || lpad_and_joy); 1493 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(4))); 1494 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0))); 1495 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1))); 1496 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2))); 1497 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3))); 1498 1499 input_sync(input); 1500 } 1501 1502 /* 1503 * The size for this message payload is 56. 1504 * The known values are: 1505 * Offset| Type | Mapped to |Meaning 1506 * -------+-------+-----------+-------------------------- 1507 * 4-7 | u32 | -- | sequence number 1508 * 8-15 | u64 | see below | buttons 1509 * 16-17 | s16 | ABS_HAT0X | left-pad X value 1510 * 18-19 | s16 | ABS_HAT0Y | left-pad Y value 1511 * 20-21 | s16 | ABS_HAT1X | right-pad X value 1512 * 22-23 | s16 | ABS_HAT1Y | right-pad Y value 1513 * 24-25 | s16 | IMU ABS_X | accelerometer X value 1514 * 26-27 | s16 | IMU ABS_Z | accelerometer Y value 1515 * 28-29 | s16 | IMU ABS_Y | accelerometer Z value 1516 * 30-31 | s16 | IMU ABS_RX | gyro X value 1517 * 32-33 | s16 | IMU ABS_RZ | gyro Y value 1518 * 34-35 | s16 | IMU ABS_RY | gyro Z value 1519 * 36-37 | s16 | -- | quaternion W value 1520 * 38-39 | s16 | -- | quaternion X value 1521 * 40-41 | s16 | -- | quaternion Y value 1522 * 42-43 | s16 | -- | quaternion Z value 1523 * 44-45 | u16 | ABS_HAT2Y | left trigger (uncalibrated) 1524 * 46-47 | u16 | ABS_HAT2X | right trigger (uncalibrated) 1525 * 48-49 | s16 | ABS_X | left joystick X 1526 * 50-51 | s16 | ABS_Y | left joystick Y 1527 * 52-53 | s16 | ABS_RX | right joystick X 1528 * 54-55 | s16 | ABS_RY | right joystick Y 1529 * 56-57 | u16 | -- | left pad pressure 1530 * 58-59 | u16 | -- | right pad pressure 1531 * 1532 * The buttons are: 1533 * Bit | Mapped to | Description 1534 * ------+------------+-------------------------------- 1535 * 8.0 | BTN_TR2 | right trigger fully pressed 1536 * 8.1 | BTN_TL2 | left trigger fully pressed 1537 * 8.2 | BTN_TR | right shoulder 1538 * 8.3 | BTN_TL | left shoulder 1539 * 8.4 | BTN_Y | button Y 1540 * 8.5 | BTN_B | button B 1541 * 8.6 | BTN_X | button X 1542 * 8.7 | BTN_A | button A 1543 * 9.0 | BTN_DPAD_UP | left-pad up 1544 * 9.1 | BTN_DPAD_RIGHT | left-pad right 1545 * 9.2 | BTN_DPAD_LEFT | left-pad left 1546 * 9.3 | BTN_DPAD_DOWN | left-pad down 1547 * 9.4 | BTN_SELECT | menu left 1548 * 9.5 | BTN_MODE | steam logo 1549 * 9.6 | BTN_START | menu right 1550 * 9.7 | BTN_TRIGGER_HAPPY3 | left bottom grip button 1551 * 10.0 | BTN_TRIGGER_HAPPY4 | right bottom grip button 1552 * 10.1 | BTN_THUMB | left pad pressed 1553 * 10.2 | BTN_THUMB2 | right pad pressed 1554 * 10.3 | -- | left pad touched 1555 * 10.4 | -- | right pad touched 1556 * 10.5 | -- | unknown 1557 * 10.6 | BTN_THUMBL | left joystick clicked 1558 * 10.7 | -- | unknown 1559 * 11.0 | -- | unknown 1560 * 11.1 | -- | unknown 1561 * 11.2 | BTN_THUMBR | right joystick clicked 1562 * 11.3 | -- | unknown 1563 * 11.4 | -- | unknown 1564 * 11.5 | -- | unknown 1565 * 11.6 | -- | unknown 1566 * 11.7 | -- | unknown 1567 * 12.0 | -- | unknown 1568 * 12.1 | -- | unknown 1569 * 12.2 | -- | unknown 1570 * 12.3 | -- | unknown 1571 * 12.4 | -- | unknown 1572 * 12.5 | -- | unknown 1573 * 12.6 | -- | unknown 1574 * 12.7 | -- | unknown 1575 * 13.0 | -- | unknown 1576 * 13.1 | BTN_TRIGGER_HAPPY1 | left top grip button 1577 * 13.2 | BTN_TRIGGER_HAPPY2 | right top grip button 1578 * 13.3 | -- | unknown 1579 * 13.4 | -- | unknown 1580 * 13.5 | -- | unknown 1581 * 13.6 | -- | left joystick touched 1582 * 13.7 | -- | right joystick touched 1583 * 14.0 | -- | unknown 1584 * 14.1 | -- | unknown 1585 * 14.2 | BTN_BASE | quick access button 1586 * 14.3 | -- | unknown 1587 * 14.4 | -- | unknown 1588 * 14.5 | -- | unknown 1589 * 14.6 | -- | unknown 1590 * 14.7 | -- | unknown 1591 * 15.0 | -- | unknown 1592 * 15.1 | -- | unknown 1593 * 15.2 | -- | unknown 1594 * 15.3 | -- | unknown 1595 * 15.4 | -- | unknown 1596 * 15.5 | -- | unknown 1597 * 15.6 | -- | unknown 1598 * 15.7 | -- | unknown 1599 */ 1600 static void steam_do_deck_input_event(struct steam_device *steam, 1601 struct input_dev *input, u8 *data) 1602 { 1603 u8 b8, b9, b10, b11, b13, b14; 1604 bool lpad_touched, rpad_touched; 1605 1606 b8 = data[8]; 1607 b9 = data[9]; 1608 b10 = data[10]; 1609 b11 = data[11]; 1610 b13 = data[13]; 1611 b14 = data[14]; 1612 1613 if (!(b9 & BIT(6)) && steam->did_mode_switch) { 1614 steam->did_mode_switch = false; 1615 cancel_delayed_work(&steam->mode_switch); 1616 } else if (!steam->client_opened && (b9 & BIT(6)) && !steam->did_mode_switch) { 1617 steam->did_mode_switch = true; 1618 schedule_delayed_work(&steam->mode_switch, 45 * HZ / 100); 1619 } 1620 1621 if (!steam->gamepad_mode && lizard_mode) 1622 return; 1623 1624 lpad_touched = b10 & BIT(3); 1625 rpad_touched = b10 & BIT(4); 1626 1627 if (lpad_touched) { 1628 input_report_abs(input, ABS_HAT0X, steam_le16(data + 16)); 1629 input_report_abs(input, ABS_HAT0Y, steam_le16(data + 18)); 1630 } else { 1631 input_report_abs(input, ABS_HAT0X, 0); 1632 input_report_abs(input, ABS_HAT0Y, 0); 1633 } 1634 1635 if (rpad_touched) { 1636 input_report_abs(input, ABS_HAT1X, steam_le16(data + 20)); 1637 input_report_abs(input, ABS_HAT1Y, steam_le16(data + 22)); 1638 } else { 1639 input_report_abs(input, ABS_HAT1X, 0); 1640 input_report_abs(input, ABS_HAT1Y, 0); 1641 } 1642 1643 input_report_abs(input, ABS_X, steam_le16(data + 48)); 1644 input_report_abs(input, ABS_Y, -steam_le16(data + 50)); 1645 input_report_abs(input, ABS_RX, steam_le16(data + 52)); 1646 input_report_abs(input, ABS_RY, -steam_le16(data + 54)); 1647 1648 input_report_abs(input, ABS_HAT2Y, steam_le16(data + 44)); 1649 input_report_abs(input, ABS_HAT2X, steam_le16(data + 46)); 1650 1651 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0))); 1652 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1))); 1653 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2))); 1654 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3))); 1655 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4))); 1656 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5))); 1657 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6))); 1658 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7))); 1659 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4))); 1660 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5))); 1661 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6))); 1662 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY3, !!(b9 & BIT(7))); 1663 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY4, !!(b10 & BIT(0))); 1664 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6))); 1665 input_event(input, EV_KEY, BTN_THUMBR, !!(b11 & BIT(2))); 1666 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0))); 1667 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1))); 1668 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2))); 1669 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3))); 1670 input_event(input, EV_KEY, BTN_THUMB, !!(b10 & BIT(1))); 1671 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(2))); 1672 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY1, !!(b13 & BIT(1))); 1673 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY2, !!(b13 & BIT(2))); 1674 input_event(input, EV_KEY, BTN_BASE, !!(b14 & BIT(2))); 1675 1676 input_sync(input); 1677 } 1678 1679 static void steam_do_deck_sensors_event(struct steam_device *steam, 1680 struct input_dev *sensors, u8 *data) 1681 { 1682 /* 1683 * The deck input report is received every 4 ms on average, 1684 * with a jitter of +/- 4 ms even though the USB descriptor claims 1685 * that it uses 1 kHz. 1686 * Since the HID report does not include a sensor timestamp, 1687 * use a fixed increment here. 1688 */ 1689 steam->sensor_timestamp_us += 4000; 1690 1691 if (!steam->gamepad_mode && lizard_mode) 1692 return; 1693 1694 input_event(sensors, EV_MSC, MSC_TIMESTAMP, steam->sensor_timestamp_us); 1695 input_report_abs(sensors, ABS_X, steam_le16(data + 24)); 1696 input_report_abs(sensors, ABS_Z, -steam_le16(data + 26)); 1697 input_report_abs(sensors, ABS_Y, steam_le16(data + 28)); 1698 input_report_abs(sensors, ABS_RX, steam_le16(data + 30)); 1699 input_report_abs(sensors, ABS_RZ, -steam_le16(data + 32)); 1700 input_report_abs(sensors, ABS_RY, steam_le16(data + 34)); 1701 1702 input_sync(sensors); 1703 } 1704 1705 /* 1706 * The size for this message payload is 11. 1707 * The known values are: 1708 * Offset| Type | Meaning 1709 * -------+-------+--------------------------- 1710 * 4-7 | u32 | sequence number 1711 * 8-11 | -- | always 0 1712 * 12-13 | u16 | voltage (mV) 1713 * 14 | u8 | battery percent 1714 */ 1715 static void steam_do_battery_event(struct steam_device *steam, 1716 struct power_supply *battery, u8 *data) 1717 { 1718 unsigned long flags; 1719 1720 s16 volts = steam_le16(data + 12); 1721 u8 batt = data[14]; 1722 1723 /* Creating the battery may have failed */ 1724 rcu_read_lock(); 1725 battery = rcu_dereference(steam->battery); 1726 if (likely(battery)) { 1727 spin_lock_irqsave(&steam->lock, flags); 1728 steam->voltage = volts; 1729 steam->battery_charge = batt; 1730 spin_unlock_irqrestore(&steam->lock, flags); 1731 power_supply_changed(battery); 1732 } 1733 rcu_read_unlock(); 1734 } 1735 1736 static int steam_raw_event(struct hid_device *hdev, 1737 struct hid_report *report, u8 *data, 1738 int size) 1739 { 1740 struct steam_device *steam = hid_get_drvdata(hdev); 1741 struct input_dev *input; 1742 struct input_dev *sensors; 1743 struct power_supply *battery; 1744 1745 if (!steam) 1746 return 0; 1747 1748 if (steam->client_opened) 1749 hid_input_report(steam->client_hdev, HID_FEATURE_REPORT, 1750 data, size, 0); 1751 /* 1752 * All messages are size=64, all values little-endian. 1753 * The format is: 1754 * Offset| Meaning 1755 * -------+-------------------------------------------- 1756 * 0-1 | always 0x01, 0x00, maybe protocol version? 1757 * 2 | type of message 1758 * 3 | length of the real payload (not checked) 1759 * 4-n | payload data, depends on the type 1760 * 1761 * There are these known types of message: 1762 * 0x01: input data (60 bytes) 1763 * 0x03: wireless connect/disconnect (1 byte) 1764 * 0x04: battery status (11 bytes) 1765 * 0x09: Steam Deck input data (56 bytes) 1766 */ 1767 1768 if (size != 64 || data[0] != 1 || data[1] != 0) 1769 return 0; 1770 1771 switch (data[2]) { 1772 case ID_CONTROLLER_STATE: 1773 if (steam->client_opened) 1774 return 0; 1775 rcu_read_lock(); 1776 input = rcu_dereference(steam->input); 1777 if (likely(input)) 1778 steam_do_input_event(steam, input, data); 1779 rcu_read_unlock(); 1780 break; 1781 case ID_CONTROLLER_DECK_STATE: 1782 if (steam->client_opened) 1783 return 0; 1784 rcu_read_lock(); 1785 input = rcu_dereference(steam->input); 1786 if (likely(input)) 1787 steam_do_deck_input_event(steam, input, data); 1788 sensors = rcu_dereference(steam->sensors); 1789 if (likely(sensors)) 1790 steam_do_deck_sensors_event(steam, sensors, data); 1791 rcu_read_unlock(); 1792 break; 1793 case ID_CONTROLLER_WIRELESS: 1794 /* 1795 * The payload of this event is a single byte: 1796 * 0x01: disconnected. 1797 * 0x02: connected. 1798 */ 1799 switch (data[4]) { 1800 case 0x01: 1801 steam_do_connect_event(steam, false); 1802 break; 1803 case 0x02: 1804 steam_do_connect_event(steam, true); 1805 break; 1806 } 1807 break; 1808 case ID_CONTROLLER_STATUS: 1809 if (steam->quirks & STEAM_QUIRK_WIRELESS) { 1810 rcu_read_lock(); 1811 battery = rcu_dereference(steam->battery); 1812 if (likely(battery)) { 1813 steam_do_battery_event(steam, battery, data); 1814 } else { 1815 dbg_hid( 1816 "%s: battery data without connect event\n", 1817 __func__); 1818 steam_do_connect_event(steam, true); 1819 } 1820 rcu_read_unlock(); 1821 } 1822 break; 1823 } 1824 return 0; 1825 } 1826 1827 static int steam_param_set_lizard_mode(const char *val, 1828 const struct kernel_param *kp) 1829 { 1830 struct steam_device *steam; 1831 int ret; 1832 1833 ret = param_set_bool(val, kp); 1834 if (ret) 1835 return ret; 1836 1837 mutex_lock(&steam_devices_lock); 1838 list_for_each_entry(steam, &steam_devices, list) { 1839 if (!steam->client_opened) 1840 steam_set_lizard_mode(steam, lizard_mode); 1841 } 1842 mutex_unlock(&steam_devices_lock); 1843 return 0; 1844 } 1845 1846 static const struct kernel_param_ops steam_lizard_mode_ops = { 1847 .set = steam_param_set_lizard_mode, 1848 .get = param_get_bool, 1849 }; 1850 1851 module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644); 1852 MODULE_PARM_DESC(lizard_mode, 1853 "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use"); 1854 1855 static const struct hid_device_id steam_controllers[] = { 1856 { /* Wired Steam Controller */ 1857 HID_USB_DEVICE(USB_VENDOR_ID_VALVE, 1858 USB_DEVICE_ID_STEAM_CONTROLLER) 1859 }, 1860 { /* Wireless Steam Controller */ 1861 HID_USB_DEVICE(USB_VENDOR_ID_VALVE, 1862 USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS), 1863 .driver_data = STEAM_QUIRK_WIRELESS 1864 }, 1865 { /* Steam Deck */ 1866 HID_USB_DEVICE(USB_VENDOR_ID_VALVE, 1867 USB_DEVICE_ID_STEAM_DECK), 1868 .driver_data = STEAM_QUIRK_DECK 1869 }, 1870 {} 1871 }; 1872 1873 MODULE_DEVICE_TABLE(hid, steam_controllers); 1874 1875 static struct hid_driver steam_controller_driver = { 1876 .name = "hid-steam", 1877 .id_table = steam_controllers, 1878 .probe = steam_probe, 1879 .remove = steam_remove, 1880 .raw_event = steam_raw_event, 1881 }; 1882 1883 module_hid_driver(steam_controller_driver); 1884