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