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