1864 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * HID driver for Valve Steam Controller4 *5 * Copyright (c) 2018 Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>6 * Copyright (c) 2022 Valve Software7 *8 * Supports both the wired and wireless interfaces.9 *10 * This controller has a builtin emulation of mouse and keyboard: the right pad11 * can be used as a mouse, the shoulder buttons are mouse buttons, A and B12 * buttons are ENTER and ESCAPE, and so on. This is implemented as additional13 * HID interfaces.14 *15 * This is known as the "lizard mode", because apparently lizards like to use16 * 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 opened19 * and re-enable it when the input device is closed, so as not to break user20 * 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 use23 * 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 same28 * 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 switching32 * the led, you can use the user-space tool at:33 *34 * https://github.com/rodrigorc/steamctrl35 */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_DESCRIPTION("HID driver for Valve Steam Controller");49MODULE_LICENSE("GPL");50MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>");51 52static bool lizard_mode = true;53 54static DEFINE_MUTEX(steam_devices_lock);55static 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 163862/* Trigger runs are about 5 mm and 256 units */63#define STEAM_TRIGGER_RESOLUTION 5164/* Joystick runs are about 5 mm and 256 units */65#define STEAM_JOYSTICK_RESOLUTION 5166/* Trigger runs are about 6 mm and 32768 units */67#define STEAM_DECK_TRIGGER_RESOLUTION 546168/* Joystick runs are about 5 mm and 32768 units */69#define STEAM_DECK_JOYSTICK_RESOLUTION 655370/* Accelerometer has 16 bit resolution and a range of +/- 2g */71#define STEAM_DECK_ACCEL_RES_PER_G 1638472#define STEAM_DECK_ACCEL_RANGE 3276873#define STEAM_DECK_ACCEL_FUZZ 3274/* Gyroscope has 16 bit resolution and a range of +/- 2000 dps */75#define STEAM_DECK_GYRO_RES_PER_DPS 1676#define STEAM_DECK_GYRO_RANGE 3276877#define STEAM_DECK_GYRO_FUZZ 178 79#define STEAM_PAD_FUZZ 25680 81/*82 * Commands that can be sent in a feature report.83 * Thanks to Valve and SDL for the names.84 */85enum {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 */141enum {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 */244enum245{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 = 9254};255 256/* String attribute idenitifiers */257enum {258 ATTRIB_STR_BOARD_SERIAL,259 ATTRIB_STR_UNIT_SERIAL,260};261 262/* Values for GYRO_MODE (bitmask) */263enum {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 */273enum {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 0287#define STEAM_PAD_RIGHT 1288#define STEAM_PAD_BOTH 2289 290/* Other random constants */291#define STEAM_SERIAL_LEN 0x15292 293struct 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};317 318static int steam_recv_report(struct steam_device *steam,319 u8 *data, int size)320{321 struct hid_report *r;322 u8 *buf;323 int ret;324 325 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];326 if (!r) {327 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n");328 return -EINVAL;329 }330 331 if (hid_report_len(r) < 64)332 return -EINVAL;333 334 buf = hid_alloc_report_buf(r, GFP_KERNEL);335 if (!buf)336 return -ENOMEM;337 338 /*339 * The report ID is always 0, so strip the first byte from the output.340 * hid_report_len() is not counting the report ID, so +1 to the length341 * or else we get a EOVERFLOW. We are safe from a buffer overflow342 * because hid_alloc_report_buf() allocates +7 bytes.343 */344 ret = hid_hw_raw_request(steam->hdev, 0x00,345 buf, hid_report_len(r) + 1,346 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);347 if (ret > 0)348 memcpy(data, buf + 1, min(size, ret - 1));349 kfree(buf);350 return ret;351}352 353static int steam_send_report(struct steam_device *steam,354 u8 *cmd, int size)355{356 struct hid_report *r;357 u8 *buf;358 unsigned int retries = 50;359 int ret;360 361 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];362 if (!r) {363 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n");364 return -EINVAL;365 }366 367 if (hid_report_len(r) < 64)368 return -EINVAL;369 370 buf = hid_alloc_report_buf(r, GFP_KERNEL);371 if (!buf)372 return -ENOMEM;373 374 /* The report ID is always 0 */375 memcpy(buf + 1, cmd, size);376 377 /*378 * Sometimes the wireless controller fails with EPIPE379 * when sending a feature report.380 * Doing a HID_REQ_GET_REPORT and waiting for a while381 * seems to fix that.382 */383 do {384 ret = hid_hw_raw_request(steam->hdev, 0,385 buf, max(size, 64) + 1,386 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);387 if (ret != -EPIPE)388 break;389 msleep(20);390 } while (--retries);391 392 kfree(buf);393 if (ret < 0)394 hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__,395 ret, size, cmd);396 return ret;397}398 399static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd)400{401 return steam_send_report(steam, &cmd, 1);402}403 404static int steam_write_settings(struct steam_device *steam,405 /* u8 reg, u16 val */...)406{407 /* Send: 0x87 len (reg valLo valHi)* */408 u8 reg;409 u16 val;410 u8 cmd[64] = {ID_SET_SETTINGS_VALUES, 0x00};411 int ret;412 va_list args;413 414 va_start(args, steam);415 for (;;) {416 reg = va_arg(args, int);417 if (reg == 0)418 break;419 val = va_arg(args, int);420 cmd[cmd[1] + 2] = reg;421 cmd[cmd[1] + 3] = val & 0xff;422 cmd[cmd[1] + 4] = val >> 8;423 cmd[1] += 3;424 }425 va_end(args);426 427 ret = steam_send_report(steam, cmd, 2 + cmd[1]);428 if (ret < 0)429 return ret;430 431 /*432 * Sometimes a lingering report for this command can433 * get read back instead of the last set report if434 * this isn't explicitly queried435 */436 return steam_recv_report(steam, cmd, 2 + cmd[1]);437}438 439static int steam_get_serial(struct steam_device *steam)440{441 /*442 * Send: 0xae 0x15 0x01443 * Recv: 0xae 0x15 0x01 serialnumber444 */445 int ret = 0;446 u8 cmd[] = {ID_GET_STRING_ATTRIBUTE, sizeof(steam->serial_no), ATTRIB_STR_UNIT_SERIAL};447 u8 reply[3 + STEAM_SERIAL_LEN + 1];448 449 mutex_lock(&steam->report_mutex);450 ret = steam_send_report(steam, cmd, sizeof(cmd));451 if (ret < 0)452 goto out;453 ret = steam_recv_report(steam, reply, sizeof(reply));454 if (ret < 0)455 goto out;456 if (reply[0] != ID_GET_STRING_ATTRIBUTE || reply[1] < 1 ||457 reply[1] > sizeof(steam->serial_no) || reply[2] != ATTRIB_STR_UNIT_SERIAL) {458 ret = -EIO;459 goto out;460 }461 reply[3 + STEAM_SERIAL_LEN] = 0;462 strscpy(steam->serial_no, reply + 3, reply[1]);463out:464 mutex_unlock(&steam->report_mutex);465 return ret;466}467 468/*469 * This command requests the wireless adaptor to post an event470 * with the connection status. Useful if this driver is loaded when471 * the controller is already connected.472 */473static inline int steam_request_conn_status(struct steam_device *steam)474{475 int ret;476 mutex_lock(&steam->report_mutex);477 ret = steam_send_report_byte(steam, ID_DONGLE_GET_WIRELESS_STATE);478 mutex_unlock(&steam->report_mutex);479 return ret;480}481 482/*483 * Send a haptic pulse to the trackpads484 * Duration and interval are measured in microseconds, count is the number485 * of pulses to send for duration time with interval microseconds between them486 * and gain is measured in decibels, ranging from -24 to +6487 */488static inline int steam_haptic_pulse(struct steam_device *steam, u8 pad,489 u16 duration, u16 interval, u16 count, u8 gain)490{491 int ret;492 u8 report[10] = {ID_TRIGGER_HAPTIC_PULSE, 8};493 494 /* Left and right are swapped on this report for legacy reasons */495 if (pad < STEAM_PAD_BOTH)496 pad ^= 1;497 498 report[2] = pad;499 report[3] = duration & 0xFF;500 report[4] = duration >> 8;501 report[5] = interval & 0xFF;502 report[6] = interval >> 8;503 report[7] = count & 0xFF;504 report[8] = count >> 8;505 report[9] = gain;506 507 mutex_lock(&steam->report_mutex);508 ret = steam_send_report(steam, report, sizeof(report));509 mutex_unlock(&steam->report_mutex);510 return ret;511}512 513static inline int steam_haptic_rumble(struct steam_device *steam,514 u16 intensity, u16 left_speed, u16 right_speed,515 u8 left_gain, u8 right_gain)516{517 int ret;518 u8 report[11] = {ID_TRIGGER_RUMBLE_CMD, 9};519 520 report[3] = intensity & 0xFF;521 report[4] = intensity >> 8;522 report[5] = left_speed & 0xFF;523 report[6] = left_speed >> 8;524 report[7] = right_speed & 0xFF;525 report[8] = right_speed >> 8;526 report[9] = left_gain;527 report[10] = right_gain;528 529 mutex_lock(&steam->report_mutex);530 ret = steam_send_report(steam, report, sizeof(report));531 mutex_unlock(&steam->report_mutex);532 return ret;533}534 535static void steam_haptic_rumble_cb(struct work_struct *work)536{537 struct steam_device *steam = container_of(work, struct steam_device,538 rumble_work);539 steam_haptic_rumble(steam, 0, steam->rumble_left,540 steam->rumble_right, 2, 0);541}542 543#ifdef CONFIG_STEAM_FF544static int steam_play_effect(struct input_dev *dev, void *data,545 struct ff_effect *effect)546{547 struct steam_device *steam = input_get_drvdata(dev);548 549 steam->rumble_left = effect->u.rumble.strong_magnitude;550 steam->rumble_right = effect->u.rumble.weak_magnitude;551 552 return schedule_work(&steam->rumble_work);553}554#endif555 556static void steam_set_lizard_mode(struct steam_device *steam, bool enable)557{558 if (steam->gamepad_mode)559 enable = false;560 561 if (enable) {562 mutex_lock(&steam->report_mutex);563 /* enable esc, enter, cursors */564 steam_send_report_byte(steam, ID_SET_DEFAULT_DIGITAL_MAPPINGS);565 /* reset settings */566 steam_send_report_byte(steam, ID_LOAD_DEFAULT_SETTINGS);567 mutex_unlock(&steam->report_mutex);568 } else {569 mutex_lock(&steam->report_mutex);570 /* disable esc, enter, cursor */571 steam_send_report_byte(steam, ID_CLEAR_DIGITAL_MAPPINGS);572 573 if (steam->quirks & STEAM_QUIRK_DECK) {574 steam_write_settings(steam,575 SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */576 SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */577 SETTING_LEFT_TRACKPAD_CLICK_PRESSURE, 0xFFFF, /* disable haptic click */578 SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE, 0xFFFF, /* disable haptic click */579 SETTING_STEAM_WATCHDOG_ENABLE, 0, /* disable watchdog that tests if Steam is active */580 0);581 mutex_unlock(&steam->report_mutex);582 } else {583 steam_write_settings(steam,584 SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */585 SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */586 0);587 mutex_unlock(&steam->report_mutex);588 }589 }590}591 592static int steam_input_open(struct input_dev *dev)593{594 struct steam_device *steam = input_get_drvdata(dev);595 unsigned long flags;596 bool set_lizard_mode;597 598 /*599 * Disabling lizard mode automatically is only done on the Steam600 * Controller. On the Steam Deck, this is toggled manually by holding601 * the options button instead, handled by steam_mode_switch_cb.602 */603 if (!(steam->quirks & STEAM_QUIRK_DECK)) {604 spin_lock_irqsave(&steam->lock, flags);605 set_lizard_mode = !steam->client_opened && lizard_mode;606 spin_unlock_irqrestore(&steam->lock, flags);607 if (set_lizard_mode)608 steam_set_lizard_mode(steam, false);609 }610 611 return 0;612}613 614static void steam_input_close(struct input_dev *dev)615{616 struct steam_device *steam = input_get_drvdata(dev);617 unsigned long flags;618 bool set_lizard_mode;619 620 if (!(steam->quirks & STEAM_QUIRK_DECK)) {621 spin_lock_irqsave(&steam->lock, flags);622 set_lizard_mode = !steam->client_opened && lizard_mode;623 spin_unlock_irqrestore(&steam->lock, flags);624 if (set_lizard_mode)625 steam_set_lizard_mode(steam, true);626 }627}628 629static enum power_supply_property steam_battery_props[] = {630 POWER_SUPPLY_PROP_PRESENT,631 POWER_SUPPLY_PROP_SCOPE,632 POWER_SUPPLY_PROP_VOLTAGE_NOW,633 POWER_SUPPLY_PROP_CAPACITY,634};635 636static int steam_battery_get_property(struct power_supply *psy,637 enum power_supply_property psp,638 union power_supply_propval *val)639{640 struct steam_device *steam = power_supply_get_drvdata(psy);641 unsigned long flags;642 s16 volts;643 u8 batt;644 int ret = 0;645 646 spin_lock_irqsave(&steam->lock, flags);647 volts = steam->voltage;648 batt = steam->battery_charge;649 spin_unlock_irqrestore(&steam->lock, flags);650 651 switch (psp) {652 case POWER_SUPPLY_PROP_PRESENT:653 val->intval = 1;654 break;655 case POWER_SUPPLY_PROP_SCOPE:656 val->intval = POWER_SUPPLY_SCOPE_DEVICE;657 break;658 case POWER_SUPPLY_PROP_VOLTAGE_NOW:659 val->intval = volts * 1000; /* mV -> uV */660 break;661 case POWER_SUPPLY_PROP_CAPACITY:662 val->intval = batt;663 break;664 default:665 ret = -EINVAL;666 break;667 }668 return ret;669}670 671static int steam_battery_register(struct steam_device *steam)672{673 struct power_supply *battery;674 struct power_supply_config battery_cfg = { .drv_data = steam, };675 unsigned long flags;676 int ret;677 678 steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;679 steam->battery_desc.properties = steam_battery_props;680 steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props);681 steam->battery_desc.get_property = steam_battery_get_property;682 steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev,683 GFP_KERNEL, "steam-controller-%s-battery",684 steam->serial_no);685 if (!steam->battery_desc.name)686 return -ENOMEM;687 688 /* avoid the warning of 0% battery while waiting for the first info */689 spin_lock_irqsave(&steam->lock, flags);690 steam->voltage = 3000;691 steam->battery_charge = 100;692 spin_unlock_irqrestore(&steam->lock, flags);693 694 battery = power_supply_register(&steam->hdev->dev,695 &steam->battery_desc, &battery_cfg);696 if (IS_ERR(battery)) {697 ret = PTR_ERR(battery);698 hid_err(steam->hdev,699 "%s:power_supply_register failed with error %d\n",700 __func__, ret);701 return ret;702 }703 rcu_assign_pointer(steam->battery, battery);704 power_supply_powers(battery, &steam->hdev->dev);705 return 0;706}707 708static int steam_input_register(struct steam_device *steam)709{710 struct hid_device *hdev = steam->hdev;711 struct input_dev *input;712 int ret;713 714 rcu_read_lock();715 input = rcu_dereference(steam->input);716 rcu_read_unlock();717 if (input) {718 dbg_hid("%s: already connected\n", __func__);719 return 0;720 }721 722 input = input_allocate_device();723 if (!input)724 return -ENOMEM;725 726 input_set_drvdata(input, steam);727 input->dev.parent = &hdev->dev;728 input->open = steam_input_open;729 input->close = steam_input_close;730 731 input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ? "Wireless Steam Controller" :732 (steam->quirks & STEAM_QUIRK_DECK) ? "Steam Deck" :733 "Steam Controller";734 input->phys = hdev->phys;735 input->uniq = steam->serial_no;736 input->id.bustype = hdev->bus;737 input->id.vendor = hdev->vendor;738 input->id.product = hdev->product;739 input->id.version = hdev->version;740 741 input_set_capability(input, EV_KEY, BTN_TR2);742 input_set_capability(input, EV_KEY, BTN_TL2);743 input_set_capability(input, EV_KEY, BTN_TR);744 input_set_capability(input, EV_KEY, BTN_TL);745 input_set_capability(input, EV_KEY, BTN_Y);746 input_set_capability(input, EV_KEY, BTN_B);747 input_set_capability(input, EV_KEY, BTN_X);748 input_set_capability(input, EV_KEY, BTN_A);749 input_set_capability(input, EV_KEY, BTN_DPAD_UP);750 input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT);751 input_set_capability(input, EV_KEY, BTN_DPAD_LEFT);752 input_set_capability(input, EV_KEY, BTN_DPAD_DOWN);753 input_set_capability(input, EV_KEY, BTN_SELECT);754 input_set_capability(input, EV_KEY, BTN_MODE);755 input_set_capability(input, EV_KEY, BTN_START);756 input_set_capability(input, EV_KEY, BTN_THUMBR);757 input_set_capability(input, EV_KEY, BTN_THUMBL);758 input_set_capability(input, EV_KEY, BTN_THUMB);759 input_set_capability(input, EV_KEY, BTN_THUMB2);760 if (steam->quirks & STEAM_QUIRK_DECK) {761 input_set_capability(input, EV_KEY, BTN_BASE);762 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY1);763 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY2);764 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY3);765 input_set_capability(input, EV_KEY, BTN_TRIGGER_HAPPY4);766 } else {767 input_set_capability(input, EV_KEY, BTN_GEAR_DOWN);768 input_set_capability(input, EV_KEY, BTN_GEAR_UP);769 }770 771 input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0);772 input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0);773 774 input_set_abs_params(input, ABS_HAT0X, -32767, 32767,775 STEAM_PAD_FUZZ, 0);776 input_set_abs_params(input, ABS_HAT0Y, -32767, 32767,777 STEAM_PAD_FUZZ, 0);778 779 if (steam->quirks & STEAM_QUIRK_DECK) {780 input_set_abs_params(input, ABS_HAT2Y, 0, 32767, 0, 0);781 input_set_abs_params(input, ABS_HAT2X, 0, 32767, 0, 0);782 783 input_set_abs_params(input, ABS_RX, -32767, 32767, 0, 0);784 input_set_abs_params(input, ABS_RY, -32767, 32767, 0, 0);785 786 input_set_abs_params(input, ABS_HAT1X, -32767, 32767,787 STEAM_PAD_FUZZ, 0);788 input_set_abs_params(input, ABS_HAT1Y, -32767, 32767,789 STEAM_PAD_FUZZ, 0);790 791 input_abs_set_res(input, ABS_X, STEAM_DECK_JOYSTICK_RESOLUTION);792 input_abs_set_res(input, ABS_Y, STEAM_DECK_JOYSTICK_RESOLUTION);793 input_abs_set_res(input, ABS_RX, STEAM_DECK_JOYSTICK_RESOLUTION);794 input_abs_set_res(input, ABS_RY, STEAM_DECK_JOYSTICK_RESOLUTION);795 input_abs_set_res(input, ABS_HAT1X, STEAM_PAD_RESOLUTION);796 input_abs_set_res(input, ABS_HAT1Y, STEAM_PAD_RESOLUTION);797 input_abs_set_res(input, ABS_HAT2Y, STEAM_DECK_TRIGGER_RESOLUTION);798 input_abs_set_res(input, ABS_HAT2X, STEAM_DECK_TRIGGER_RESOLUTION);799 } else {800 input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0);801 input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0);802 803 input_set_abs_params(input, ABS_RX, -32767, 32767,804 STEAM_PAD_FUZZ, 0);805 input_set_abs_params(input, ABS_RY, -32767, 32767,806 STEAM_PAD_FUZZ, 0);807 808 input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION);809 input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION);810 input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION);811 input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION);812 input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION);813 input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION);814 }815 input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION);816 input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION);817 818#ifdef CONFIG_STEAM_FF819 if (steam->quirks & STEAM_QUIRK_DECK) {820 input_set_capability(input, EV_FF, FF_RUMBLE);821 ret = input_ff_create_memless(input, NULL, steam_play_effect);822 if (ret)823 goto input_register_fail;824 }825#endif826 827 ret = input_register_device(input);828 if (ret)829 goto input_register_fail;830 831 rcu_assign_pointer(steam->input, input);832 return 0;833 834input_register_fail:835 input_free_device(input);836 return ret;837}838 839static int steam_sensors_register(struct steam_device *steam)840{841 struct hid_device *hdev = steam->hdev;842 struct input_dev *sensors;843 int ret;844 845 if (!(steam->quirks & STEAM_QUIRK_DECK))846 return 0;847 848 rcu_read_lock();849 sensors = rcu_dereference(steam->sensors);850 rcu_read_unlock();851 if (sensors) {852 dbg_hid("%s: already connected\n", __func__);853 return 0;854 }855 856 sensors = input_allocate_device();857 if (!sensors)858 return -ENOMEM;859 860 input_set_drvdata(sensors, steam);861 sensors->dev.parent = &hdev->dev;862 863 sensors->name = "Steam Deck Motion Sensors";864 sensors->phys = hdev->phys;865 sensors->uniq = steam->serial_no;866 sensors->id.bustype = hdev->bus;867 sensors->id.vendor = hdev->vendor;868 sensors->id.product = hdev->product;869 sensors->id.version = hdev->version;870 871 __set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit);872 __set_bit(EV_MSC, sensors->evbit);873 __set_bit(MSC_TIMESTAMP, sensors->mscbit);874 875 input_set_abs_params(sensors, ABS_X, -STEAM_DECK_ACCEL_RANGE,876 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0);877 input_set_abs_params(sensors, ABS_Y, -STEAM_DECK_ACCEL_RANGE,878 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0);879 input_set_abs_params(sensors, ABS_Z, -STEAM_DECK_ACCEL_RANGE,880 STEAM_DECK_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0);881 input_abs_set_res(sensors, ABS_X, STEAM_DECK_ACCEL_RES_PER_G);882 input_abs_set_res(sensors, ABS_Y, STEAM_DECK_ACCEL_RES_PER_G);883 input_abs_set_res(sensors, ABS_Z, STEAM_DECK_ACCEL_RES_PER_G);884 885 input_set_abs_params(sensors, ABS_RX, -STEAM_DECK_GYRO_RANGE,886 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0);887 input_set_abs_params(sensors, ABS_RY, -STEAM_DECK_GYRO_RANGE,888 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0);889 input_set_abs_params(sensors, ABS_RZ, -STEAM_DECK_GYRO_RANGE,890 STEAM_DECK_GYRO_RANGE, STEAM_DECK_GYRO_FUZZ, 0);891 input_abs_set_res(sensors, ABS_RX, STEAM_DECK_GYRO_RES_PER_DPS);892 input_abs_set_res(sensors, ABS_RY, STEAM_DECK_GYRO_RES_PER_DPS);893 input_abs_set_res(sensors, ABS_RZ, STEAM_DECK_GYRO_RES_PER_DPS);894 895 ret = input_register_device(sensors);896 if (ret)897 goto sensors_register_fail;898 899 rcu_assign_pointer(steam->sensors, sensors);900 return 0;901 902sensors_register_fail:903 input_free_device(sensors);904 return ret;905}906 907static void steam_input_unregister(struct steam_device *steam)908{909 struct input_dev *input;910 rcu_read_lock();911 input = rcu_dereference(steam->input);912 rcu_read_unlock();913 if (!input)914 return;915 RCU_INIT_POINTER(steam->input, NULL);916 synchronize_rcu();917 input_unregister_device(input);918}919 920static void steam_sensors_unregister(struct steam_device *steam)921{922 struct input_dev *sensors;923 924 if (!(steam->quirks & STEAM_QUIRK_DECK))925 return;926 927 rcu_read_lock();928 sensors = rcu_dereference(steam->sensors);929 rcu_read_unlock();930 931 if (!sensors)932 return;933 RCU_INIT_POINTER(steam->sensors, NULL);934 synchronize_rcu();935 input_unregister_device(sensors);936}937 938static void steam_battery_unregister(struct steam_device *steam)939{940 struct power_supply *battery;941 942 rcu_read_lock();943 battery = rcu_dereference(steam->battery);944 rcu_read_unlock();945 946 if (!battery)947 return;948 RCU_INIT_POINTER(steam->battery, NULL);949 synchronize_rcu();950 power_supply_unregister(battery);951}952 953static int steam_register(struct steam_device *steam)954{955 int ret;956 unsigned long client_opened;957 unsigned long flags;958 959 /*960 * This function can be called several times in a row with the961 * wireless adaptor, without steam_unregister() between them, because962 * another client send a get_connection_status command, for example.963 * The battery and serial number are set just once per device.964 */965 if (!steam->serial_no[0]) {966 /*967 * Unlikely, but getting the serial could fail, and it is not so968 * important, so make up a serial number and go on.969 */970 if (steam_get_serial(steam) < 0)971 strscpy(steam->serial_no, "XXXXXXXXXX",972 sizeof(steam->serial_no));973 974 hid_info(steam->hdev, "Steam Controller '%s' connected",975 steam->serial_no);976 977 /* ignore battery errors, we can live without it */978 if (steam->quirks & STEAM_QUIRK_WIRELESS)979 steam_battery_register(steam);980 981 mutex_lock(&steam_devices_lock);982 if (list_empty(&steam->list))983 list_add(&steam->list, &steam_devices);984 mutex_unlock(&steam_devices_lock);985 }986 987 spin_lock_irqsave(&steam->lock, flags);988 client_opened = steam->client_opened;989 spin_unlock_irqrestore(&steam->lock, flags);990 991 if (!client_opened) {992 steam_set_lizard_mode(steam, lizard_mode);993 ret = steam_input_register(steam);994 if (ret != 0)995 goto steam_register_input_fail;996 ret = steam_sensors_register(steam);997 if (ret != 0)998 goto steam_register_sensors_fail;999 }1000 return 0;1001 1002steam_register_sensors_fail:1003 steam_input_unregister(steam);1004steam_register_input_fail:1005 return ret;1006}1007 1008static void steam_unregister(struct steam_device *steam)1009{1010 steam_battery_unregister(steam);1011 steam_sensors_unregister(steam);1012 steam_input_unregister(steam);1013 if (steam->serial_no[0]) {1014 hid_info(steam->hdev, "Steam Controller '%s' disconnected",1015 steam->serial_no);1016 mutex_lock(&steam_devices_lock);1017 list_del_init(&steam->list);1018 mutex_unlock(&steam_devices_lock);1019 steam->serial_no[0] = 0;1020 }1021}1022 1023static void steam_work_connect_cb(struct work_struct *work)1024{1025 struct steam_device *steam = container_of(work, struct steam_device,1026 work_connect);1027 unsigned long flags;1028 bool connected;1029 int ret;1030 1031 spin_lock_irqsave(&steam->lock, flags);1032 connected = steam->connected;1033 spin_unlock_irqrestore(&steam->lock, flags);1034 1035 if (connected) {1036 ret = steam_register(steam);1037 if (ret) {1038 hid_err(steam->hdev,1039 "%s:steam_register failed with error %d\n",1040 __func__, ret);1041 }1042 } else {1043 steam_unregister(steam);1044 }1045}1046 1047static void steam_mode_switch_cb(struct work_struct *work)1048{1049 struct steam_device *steam = container_of(to_delayed_work(work),1050 struct steam_device, mode_switch);1051 unsigned long flags;1052 bool client_opened;1053 steam->gamepad_mode = !steam->gamepad_mode;1054 if (!lizard_mode)1055 return;1056 1057 if (steam->gamepad_mode)1058 steam_set_lizard_mode(steam, false);1059 else {1060 spin_lock_irqsave(&steam->lock, flags);1061 client_opened = steam->client_opened;1062 spin_unlock_irqrestore(&steam->lock, flags);1063 if (!client_opened)1064 steam_set_lizard_mode(steam, lizard_mode);1065 }1066 1067 steam_haptic_pulse(steam, STEAM_PAD_RIGHT, 0x190, 0, 1, 0);1068 if (steam->gamepad_mode) {1069 steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x14D, 0x14D, 0x2D, 0);1070 } else {1071 steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x1F4, 0x1F4, 0x1E, 0);1072 }1073}1074 1075static bool steam_is_valve_interface(struct hid_device *hdev)1076{1077 struct hid_report_enum *rep_enum;1078 1079 /*1080 * The wired device creates 3 interfaces:1081 * 0: emulated mouse.1082 * 1: emulated keyboard.1083 * 2: the real game pad.1084 * The wireless device creates 5 interfaces:1085 * 0: emulated keyboard.1086 * 1-4: slots where up to 4 real game pads will be connected to.1087 * We know which one is the real gamepad interface because they are the1088 * only ones with a feature report.1089 */1090 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];1091 return !list_empty(&rep_enum->report_list);1092}1093 1094static int steam_client_ll_parse(struct hid_device *hdev)1095{1096 struct steam_device *steam = hdev->driver_data;1097 1098 return hid_parse_report(hdev, steam->hdev->dev_rdesc,1099 steam->hdev->dev_rsize);1100}1101 1102static int steam_client_ll_start(struct hid_device *hdev)1103{1104 return 0;1105}1106 1107static void steam_client_ll_stop(struct hid_device *hdev)1108{1109}1110 1111static int steam_client_ll_open(struct hid_device *hdev)1112{1113 struct steam_device *steam = hdev->driver_data;1114 unsigned long flags;1115 1116 spin_lock_irqsave(&steam->lock, flags);1117 steam->client_opened++;1118 spin_unlock_irqrestore(&steam->lock, flags);1119 1120 steam_sensors_unregister(steam);1121 steam_input_unregister(steam);1122 1123 return 0;1124}1125 1126static void steam_client_ll_close(struct hid_device *hdev)1127{1128 struct steam_device *steam = hdev->driver_data;1129 1130 unsigned long flags;1131 bool connected;1132 1133 spin_lock_irqsave(&steam->lock, flags);1134 steam->client_opened--;1135 connected = steam->connected && !steam->client_opened;1136 spin_unlock_irqrestore(&steam->lock, flags);1137 1138 if (connected) {1139 steam_set_lizard_mode(steam, lizard_mode);1140 steam_input_register(steam);1141 steam_sensors_register(steam);1142 }1143}1144 1145static int steam_client_ll_raw_request(struct hid_device *hdev,1146 unsigned char reportnum, u8 *buf,1147 size_t count, unsigned char report_type,1148 int reqtype)1149{1150 struct steam_device *steam = hdev->driver_data;1151 1152 return hid_hw_raw_request(steam->hdev, reportnum, buf, count,1153 report_type, reqtype);1154}1155 1156static const struct hid_ll_driver steam_client_ll_driver = {1157 .parse = steam_client_ll_parse,1158 .start = steam_client_ll_start,1159 .stop = steam_client_ll_stop,1160 .open = steam_client_ll_open,1161 .close = steam_client_ll_close,1162 .raw_request = steam_client_ll_raw_request,1163};1164 1165static struct hid_device *steam_create_client_hid(struct hid_device *hdev)1166{1167 struct hid_device *client_hdev;1168 1169 client_hdev = hid_allocate_device();1170 if (IS_ERR(client_hdev))1171 return client_hdev;1172 1173 client_hdev->ll_driver = &steam_client_ll_driver;1174 client_hdev->dev.parent = hdev->dev.parent;1175 client_hdev->bus = hdev->bus;1176 client_hdev->vendor = hdev->vendor;1177 client_hdev->product = hdev->product;1178 client_hdev->version = hdev->version;1179 client_hdev->type = hdev->type;1180 client_hdev->country = hdev->country;1181 strscpy(client_hdev->name, hdev->name,1182 sizeof(client_hdev->name));1183 strscpy(client_hdev->phys, hdev->phys,1184 sizeof(client_hdev->phys));1185 /*1186 * Since we use the same device info than the real interface to1187 * trick userspace, we will be calling steam_probe recursively.1188 * We need to recognize the client interface somehow.1189 */1190 client_hdev->group = HID_GROUP_STEAM;1191 return client_hdev;1192}1193 1194static int steam_probe(struct hid_device *hdev,1195 const struct hid_device_id *id)1196{1197 struct steam_device *steam;1198 int ret;1199 1200 ret = hid_parse(hdev);1201 if (ret) {1202 hid_err(hdev,1203 "%s:parse of hid interface failed\n", __func__);1204 return ret;1205 }1206 1207 /*1208 * The virtual client_dev is only used for hidraw.1209 * Also avoid the recursive probe.1210 */1211 if (hdev->group == HID_GROUP_STEAM)1212 return hid_hw_start(hdev, HID_CONNECT_HIDRAW);1213 /*1214 * The non-valve interfaces (mouse and keyboard emulation) are1215 * connected without changes.1216 */1217 if (!steam_is_valve_interface(hdev))1218 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);1219 1220 steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL);1221 if (!steam)1222 return -ENOMEM;1223 1224 steam->hdev = hdev;1225 hid_set_drvdata(hdev, steam);1226 spin_lock_init(&steam->lock);1227 mutex_init(&steam->report_mutex);1228 steam->quirks = id->driver_data;1229 INIT_WORK(&steam->work_connect, steam_work_connect_cb);1230 INIT_DELAYED_WORK(&steam->mode_switch, steam_mode_switch_cb);1231 INIT_LIST_HEAD(&steam->list);1232 INIT_WORK(&steam->rumble_work, steam_haptic_rumble_cb);1233 steam->sensor_timestamp_us = 0;1234 1235 /*1236 * With the real steam controller interface, do not connect hidraw.1237 * Instead, create the client_hid and connect that.1238 */1239 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW);1240 if (ret)1241 goto err_cancel_work;1242 1243 ret = hid_hw_open(hdev);1244 if (ret) {1245 hid_err(hdev,1246 "%s:hid_hw_open\n",1247 __func__);1248 goto err_hw_stop;1249 }1250 1251 if (steam->quirks & STEAM_QUIRK_WIRELESS) {1252 hid_info(hdev, "Steam wireless receiver connected");1253 /* If using a wireless adaptor ask for connection status */1254 steam->connected = false;1255 steam_request_conn_status(steam);1256 } else {1257 /* A wired connection is always present */1258 steam->connected = true;1259 ret = steam_register(steam);1260 if (ret) {1261 hid_err(hdev,1262 "%s:steam_register failed with error %d\n",1263 __func__, ret);1264 goto err_hw_close;1265 }1266 }1267 1268 steam->client_hdev = steam_create_client_hid(hdev);1269 if (IS_ERR(steam->client_hdev)) {1270 ret = PTR_ERR(steam->client_hdev);1271 goto err_steam_unregister;1272 }1273 steam->client_hdev->driver_data = steam;1274 1275 ret = hid_add_device(steam->client_hdev);1276 if (ret)1277 goto err_destroy;1278 1279 return 0;1280 1281err_destroy:1282 hid_destroy_device(steam->client_hdev);1283err_steam_unregister:1284 if (steam->connected)1285 steam_unregister(steam);1286err_hw_close:1287 hid_hw_close(hdev);1288err_hw_stop:1289 hid_hw_stop(hdev);1290err_cancel_work:1291 cancel_work_sync(&steam->work_connect);1292 cancel_delayed_work_sync(&steam->mode_switch);1293 cancel_work_sync(&steam->rumble_work);1294 1295 return ret;1296}1297 1298static void steam_remove(struct hid_device *hdev)1299{1300 struct steam_device *steam = hid_get_drvdata(hdev);1301 1302 if (!steam || hdev->group == HID_GROUP_STEAM) {1303 hid_hw_stop(hdev);1304 return;1305 }1306 1307 cancel_delayed_work_sync(&steam->mode_switch);1308 cancel_work_sync(&steam->work_connect);1309 hid_destroy_device(steam->client_hdev);1310 steam->client_hdev = NULL;1311 steam->client_opened = 0;1312 if (steam->quirks & STEAM_QUIRK_WIRELESS) {1313 hid_info(hdev, "Steam wireless receiver disconnected");1314 }1315 hid_hw_close(hdev);1316 hid_hw_stop(hdev);1317 steam_unregister(steam);1318}1319 1320static void steam_do_connect_event(struct steam_device *steam, bool connected)1321{1322 unsigned long flags;1323 bool changed;1324 1325 spin_lock_irqsave(&steam->lock, flags);1326 changed = steam->connected != connected;1327 steam->connected = connected;1328 spin_unlock_irqrestore(&steam->lock, flags);1329 1330 if (changed && schedule_work(&steam->work_connect) == 0)1331 dbg_hid("%s: connected=%d event already queued\n",1332 __func__, connected);1333}1334 1335/*1336 * Some input data in the protocol has the opposite sign.1337 * Clamp the values to 32767..-32767 so that the range is1338 * symmetrical and can be negated safely.1339 */1340static inline s16 steam_le16(u8 *data)1341{1342 s16 x = (s16) le16_to_cpup((__le16 *)data);1343 1344 return x == -32768 ? -32767 : x;1345}1346 1347/*1348 * The size for this message payload is 60.1349 * The known values are:1350 * (* values are not sent through wireless)1351 * (* accelerator/gyro is disabled by default)1352 * Offset| Type | Mapped to |Meaning1353 * -------+-------+-----------+--------------------------1354 * 4-7 | u32 | -- | sequence number1355 * 8-10 | 24bit | see below | buttons1356 * 11 | u8 | ABS_HAT2Y | left trigger1357 * 12 | u8 | ABS_HAT2X | right trigger1358 * 13-15 | -- | -- | always 01359 * 16-17 | s16 | ABS_X/ABS_HAT0X | X value1360 * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value1361 * 20-21 | s16 | ABS_RX | right-pad X value1362 * 22-23 | s16 | ABS_RY | right-pad Y value1363 * 24-25 | s16 | -- | * left trigger1364 * 26-27 | s16 | -- | * right trigger1365 * 28-29 | s16 | -- | * accelerometer X value1366 * 30-31 | s16 | -- | * accelerometer Y value1367 * 32-33 | s16 | -- | * accelerometer Z value1368 * 34-35 | s16 | -- | gyro X value1369 * 36-36 | s16 | -- | gyro Y value1370 * 38-39 | s16 | -- | gyro Z value1371 * 40-41 | s16 | -- | quaternion W value1372 * 42-43 | s16 | -- | quaternion X value1373 * 44-45 | s16 | -- | quaternion Y value1374 * 46-47 | s16 | -- | quaternion Z value1375 * 48-49 | -- | -- | always 01376 * 50-51 | s16 | -- | * left trigger (uncalibrated)1377 * 52-53 | s16 | -- | * right trigger (uncalibrated)1378 * 54-55 | s16 | -- | * joystick X value (uncalibrated)1379 * 56-57 | s16 | -- | * joystick Y value (uncalibrated)1380 * 58-59 | s16 | -- | * left-pad X value1381 * 60-61 | s16 | -- | * left-pad Y value1382 * 62-63 | u16 | -- | * battery voltage1383 *1384 * The buttons are:1385 * Bit | Mapped to | Description1386 * ------+------------+--------------------------------1387 * 8.0 | BTN_TR2 | right trigger fully pressed1388 * 8.1 | BTN_TL2 | left trigger fully pressed1389 * 8.2 | BTN_TR | right shoulder1390 * 8.3 | BTN_TL | left shoulder1391 * 8.4 | BTN_Y | button Y1392 * 8.5 | BTN_B | button B1393 * 8.6 | BTN_X | button X1394 * 8.7 | BTN_A | button A1395 * 9.0 | BTN_DPAD_UP | left-pad up1396 * 9.1 | BTN_DPAD_RIGHT | left-pad right1397 * 9.2 | BTN_DPAD_LEFT | left-pad left1398 * 9.3 | BTN_DPAD_DOWN | left-pad down1399 * 9.4 | BTN_SELECT | menu left1400 * 9.5 | BTN_MODE | steam logo1401 * 9.6 | BTN_START | menu right1402 * 9.7 | BTN_GEAR_DOWN | left back lever1403 * 10.0 | BTN_GEAR_UP | right back lever1404 * 10.1 | -- | left-pad clicked1405 * 10.2 | BTN_THUMBR | right-pad clicked1406 * 10.3 | BTN_THUMB | left-pad touched (but see explanation below)1407 * 10.4 | BTN_THUMB2 | right-pad touched1408 * 10.5 | -- | unknown1409 * 10.6 | BTN_THUMBL | joystick clicked1410 * 10.7 | -- | lpad_and_joy1411 */1412 1413static void steam_do_input_event(struct steam_device *steam,1414 struct input_dev *input, u8 *data)1415{1416 /* 24 bits of buttons */1417 u8 b8, b9, b10;1418 s16 x, y;1419 bool lpad_touched, lpad_and_joy;1420 1421 b8 = data[8];1422 b9 = data[9];1423 b10 = data[10];1424 1425 input_report_abs(input, ABS_HAT2Y, data[11]);1426 input_report_abs(input, ABS_HAT2X, data[12]);1427 1428 /*1429 * These two bits tells how to interpret the values X and Y.1430 * lpad_and_joy tells that the joystick and the lpad are used at the1431 * same time.1432 * lpad_touched tells whether X/Y are to be read as lpad coord or1433 * joystick values.1434 * (lpad_touched || lpad_and_joy) tells if the lpad is really touched.1435 */1436 lpad_touched = b10 & BIT(3);1437 lpad_and_joy = b10 & BIT(7);1438 x = steam_le16(data + 16);1439 y = -steam_le16(data + 18);1440 1441 input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x);1442 input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y);1443 /* Check if joystick is centered */1444 if (lpad_touched && !lpad_and_joy) {1445 input_report_abs(input, ABS_X, 0);1446 input_report_abs(input, ABS_Y, 0);1447 }1448 /* Check if lpad is untouched */1449 if (!(lpad_touched || lpad_and_joy)) {1450 input_report_abs(input, ABS_HAT0X, 0);1451 input_report_abs(input, ABS_HAT0Y, 0);1452 }1453 1454 input_report_abs(input, ABS_RX, steam_le16(data + 20));1455 input_report_abs(input, ABS_RY, -steam_le16(data + 22));1456 1457 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0)));1458 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1)));1459 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2)));1460 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3)));1461 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4)));1462 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5)));1463 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6)));1464 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7)));1465 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4)));1466 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5)));1467 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6)));1468 input_event(input, EV_KEY, BTN_GEAR_DOWN, !!(b9 & BIT(7)));1469 input_event(input, EV_KEY, BTN_GEAR_UP, !!(b10 & BIT(0)));1470 input_event(input, EV_KEY, BTN_THUMBR, !!(b10 & BIT(2)));1471 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6)));1472 input_event(input, EV_KEY, BTN_THUMB, lpad_touched || lpad_and_joy);1473 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(4)));1474 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0)));1475 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1)));1476 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2)));1477 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3)));1478 1479 input_sync(input);1480}1481 1482/*1483 * The size for this message payload is 56.1484 * The known values are:1485 * Offset| Type | Mapped to |Meaning1486 * -------+-------+-----------+--------------------------1487 * 4-7 | u32 | -- | sequence number1488 * 8-15 | u64 | see below | buttons1489 * 16-17 | s16 | ABS_HAT0X | left-pad X value1490 * 18-19 | s16 | ABS_HAT0Y | left-pad Y value1491 * 20-21 | s16 | ABS_HAT1X | right-pad X value1492 * 22-23 | s16 | ABS_HAT1Y | right-pad Y value1493 * 24-25 | s16 | IMU ABS_X | accelerometer X value1494 * 26-27 | s16 | IMU ABS_Z | accelerometer Y value1495 * 28-29 | s16 | IMU ABS_Y | accelerometer Z value1496 * 30-31 | s16 | IMU ABS_RX | gyro X value1497 * 32-33 | s16 | IMU ABS_RZ | gyro Y value1498 * 34-35 | s16 | IMU ABS_RY | gyro Z value1499 * 36-37 | s16 | -- | quaternion W value1500 * 38-39 | s16 | -- | quaternion X value1501 * 40-41 | s16 | -- | quaternion Y value1502 * 42-43 | s16 | -- | quaternion Z value1503 * 44-45 | u16 | ABS_HAT2Y | left trigger (uncalibrated)1504 * 46-47 | u16 | ABS_HAT2X | right trigger (uncalibrated)1505 * 48-49 | s16 | ABS_X | left joystick X1506 * 50-51 | s16 | ABS_Y | left joystick Y1507 * 52-53 | s16 | ABS_RX | right joystick X1508 * 54-55 | s16 | ABS_RY | right joystick Y1509 * 56-57 | u16 | -- | left pad pressure1510 * 58-59 | u16 | -- | right pad pressure1511 *1512 * The buttons are:1513 * Bit | Mapped to | Description1514 * ------+------------+--------------------------------1515 * 8.0 | BTN_TR2 | right trigger fully pressed1516 * 8.1 | BTN_TL2 | left trigger fully pressed1517 * 8.2 | BTN_TR | right shoulder1518 * 8.3 | BTN_TL | left shoulder1519 * 8.4 | BTN_Y | button Y1520 * 8.5 | BTN_B | button B1521 * 8.6 | BTN_X | button X1522 * 8.7 | BTN_A | button A1523 * 9.0 | BTN_DPAD_UP | left-pad up1524 * 9.1 | BTN_DPAD_RIGHT | left-pad right1525 * 9.2 | BTN_DPAD_LEFT | left-pad left1526 * 9.3 | BTN_DPAD_DOWN | left-pad down1527 * 9.4 | BTN_SELECT | menu left1528 * 9.5 | BTN_MODE | steam logo1529 * 9.6 | BTN_START | menu right1530 * 9.7 | BTN_TRIGGER_HAPPY3 | left bottom grip button1531 * 10.0 | BTN_TRIGGER_HAPPY4 | right bottom grip button1532 * 10.1 | BTN_THUMB | left pad pressed1533 * 10.2 | BTN_THUMB2 | right pad pressed1534 * 10.3 | -- | left pad touched1535 * 10.4 | -- | right pad touched1536 * 10.5 | -- | unknown1537 * 10.6 | BTN_THUMBL | left joystick clicked1538 * 10.7 | -- | unknown1539 * 11.0 | -- | unknown1540 * 11.1 | -- | unknown1541 * 11.2 | BTN_THUMBR | right joystick clicked1542 * 11.3 | -- | unknown1543 * 11.4 | -- | unknown1544 * 11.5 | -- | unknown1545 * 11.6 | -- | unknown1546 * 11.7 | -- | unknown1547 * 12.0 | -- | unknown1548 * 12.1 | -- | unknown1549 * 12.2 | -- | unknown1550 * 12.3 | -- | unknown1551 * 12.4 | -- | unknown1552 * 12.5 | -- | unknown1553 * 12.6 | -- | unknown1554 * 12.7 | -- | unknown1555 * 13.0 | -- | unknown1556 * 13.1 | BTN_TRIGGER_HAPPY1 | left top grip button1557 * 13.2 | BTN_TRIGGER_HAPPY2 | right top grip button1558 * 13.3 | -- | unknown1559 * 13.4 | -- | unknown1560 * 13.5 | -- | unknown1561 * 13.6 | -- | left joystick touched1562 * 13.7 | -- | right joystick touched1563 * 14.0 | -- | unknown1564 * 14.1 | -- | unknown1565 * 14.2 | BTN_BASE | quick access button1566 * 14.3 | -- | unknown1567 * 14.4 | -- | unknown1568 * 14.5 | -- | unknown1569 * 14.6 | -- | unknown1570 * 14.7 | -- | unknown1571 * 15.0 | -- | unknown1572 * 15.1 | -- | unknown1573 * 15.2 | -- | unknown1574 * 15.3 | -- | unknown1575 * 15.4 | -- | unknown1576 * 15.5 | -- | unknown1577 * 15.6 | -- | unknown1578 * 15.7 | -- | unknown1579 */1580static void steam_do_deck_input_event(struct steam_device *steam,1581 struct input_dev *input, u8 *data)1582{1583 u8 b8, b9, b10, b11, b13, b14;1584 bool lpad_touched, rpad_touched;1585 1586 b8 = data[8];1587 b9 = data[9];1588 b10 = data[10];1589 b11 = data[11];1590 b13 = data[13];1591 b14 = data[14];1592 1593 if (!(b9 & BIT(6)) && steam->did_mode_switch) {1594 steam->did_mode_switch = false;1595 cancel_delayed_work_sync(&steam->mode_switch);1596 } else if (!steam->client_opened && (b9 & BIT(6)) && !steam->did_mode_switch) {1597 steam->did_mode_switch = true;1598 schedule_delayed_work(&steam->mode_switch, 45 * HZ / 100);1599 }1600 1601 if (!steam->gamepad_mode)1602 return;1603 1604 lpad_touched = b10 & BIT(3);1605 rpad_touched = b10 & BIT(4);1606 1607 if (lpad_touched) {1608 input_report_abs(input, ABS_HAT0X, steam_le16(data + 16));1609 input_report_abs(input, ABS_HAT0Y, steam_le16(data + 18));1610 } else {1611 input_report_abs(input, ABS_HAT0X, 0);1612 input_report_abs(input, ABS_HAT0Y, 0);1613 }1614 1615 if (rpad_touched) {1616 input_report_abs(input, ABS_HAT1X, steam_le16(data + 20));1617 input_report_abs(input, ABS_HAT1Y, steam_le16(data + 22));1618 } else {1619 input_report_abs(input, ABS_HAT1X, 0);1620 input_report_abs(input, ABS_HAT1Y, 0);1621 }1622 1623 input_report_abs(input, ABS_X, steam_le16(data + 48));1624 input_report_abs(input, ABS_Y, -steam_le16(data + 50));1625 input_report_abs(input, ABS_RX, steam_le16(data + 52));1626 input_report_abs(input, ABS_RY, -steam_le16(data + 54));1627 1628 input_report_abs(input, ABS_HAT2Y, steam_le16(data + 44));1629 input_report_abs(input, ABS_HAT2X, steam_le16(data + 46));1630 1631 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0)));1632 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1)));1633 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2)));1634 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3)));1635 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4)));1636 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5)));1637 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6)));1638 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7)));1639 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4)));1640 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5)));1641 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6)));1642 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY3, !!(b9 & BIT(7)));1643 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY4, !!(b10 & BIT(0)));1644 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6)));1645 input_event(input, EV_KEY, BTN_THUMBR, !!(b11 & BIT(2)));1646 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0)));1647 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1)));1648 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2)));1649 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3)));1650 input_event(input, EV_KEY, BTN_THUMB, !!(b10 & BIT(1)));1651 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(2)));1652 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY1, !!(b13 & BIT(1)));1653 input_event(input, EV_KEY, BTN_TRIGGER_HAPPY2, !!(b13 & BIT(2)));1654 input_event(input, EV_KEY, BTN_BASE, !!(b14 & BIT(2)));1655 1656 input_sync(input);1657}1658 1659static void steam_do_deck_sensors_event(struct steam_device *steam,1660 struct input_dev *sensors, u8 *data)1661{1662 /*1663 * The deck input report is received every 4 ms on average,1664 * with a jitter of +/- 4 ms even though the USB descriptor claims1665 * that it uses 1 kHz.1666 * Since the HID report does not include a sensor timestamp,1667 * use a fixed increment here.1668 */1669 steam->sensor_timestamp_us += 4000;1670 1671 if (!steam->gamepad_mode)1672 return;1673 1674 input_event(sensors, EV_MSC, MSC_TIMESTAMP, steam->sensor_timestamp_us);1675 input_report_abs(sensors, ABS_X, steam_le16(data + 24));1676 input_report_abs(sensors, ABS_Z, -steam_le16(data + 26));1677 input_report_abs(sensors, ABS_Y, steam_le16(data + 28));1678 input_report_abs(sensors, ABS_RX, steam_le16(data + 30));1679 input_report_abs(sensors, ABS_RZ, -steam_le16(data + 32));1680 input_report_abs(sensors, ABS_RY, steam_le16(data + 34));1681 1682 input_sync(sensors);1683}1684 1685/*1686 * The size for this message payload is 11.1687 * The known values are:1688 * Offset| Type | Meaning1689 * -------+-------+---------------------------1690 * 4-7 | u32 | sequence number1691 * 8-11 | -- | always 01692 * 12-13 | u16 | voltage (mV)1693 * 14 | u8 | battery percent1694 */1695static void steam_do_battery_event(struct steam_device *steam,1696 struct power_supply *battery, u8 *data)1697{1698 unsigned long flags;1699 1700 s16 volts = steam_le16(data + 12);1701 u8 batt = data[14];1702 1703 /* Creating the battery may have failed */1704 rcu_read_lock();1705 battery = rcu_dereference(steam->battery);1706 if (likely(battery)) {1707 spin_lock_irqsave(&steam->lock, flags);1708 steam->voltage = volts;1709 steam->battery_charge = batt;1710 spin_unlock_irqrestore(&steam->lock, flags);1711 power_supply_changed(battery);1712 }1713 rcu_read_unlock();1714}1715 1716static int steam_raw_event(struct hid_device *hdev,1717 struct hid_report *report, u8 *data,1718 int size)1719{1720 struct steam_device *steam = hid_get_drvdata(hdev);1721 struct input_dev *input;1722 struct input_dev *sensors;1723 struct power_supply *battery;1724 1725 if (!steam)1726 return 0;1727 1728 if (steam->client_opened)1729 hid_input_report(steam->client_hdev, HID_FEATURE_REPORT,1730 data, size, 0);1731 /*1732 * All messages are size=64, all values little-endian.1733 * The format is:1734 * Offset| Meaning1735 * -------+--------------------------------------------1736 * 0-1 | always 0x01, 0x00, maybe protocol version?1737 * 2 | type of message1738 * 3 | length of the real payload (not checked)1739 * 4-n | payload data, depends on the type1740 *1741 * There are these known types of message:1742 * 0x01: input data (60 bytes)1743 * 0x03: wireless connect/disconnect (1 byte)1744 * 0x04: battery status (11 bytes)1745 * 0x09: Steam Deck input data (56 bytes)1746 */1747 1748 if (size != 64 || data[0] != 1 || data[1] != 0)1749 return 0;1750 1751 switch (data[2]) {1752 case ID_CONTROLLER_STATE:1753 if (steam->client_opened)1754 return 0;1755 rcu_read_lock();1756 input = rcu_dereference(steam->input);1757 if (likely(input))1758 steam_do_input_event(steam, input, data);1759 rcu_read_unlock();1760 break;1761 case ID_CONTROLLER_DECK_STATE:1762 if (steam->client_opened)1763 return 0;1764 rcu_read_lock();1765 input = rcu_dereference(steam->input);1766 if (likely(input))1767 steam_do_deck_input_event(steam, input, data);1768 sensors = rcu_dereference(steam->sensors);1769 if (likely(sensors))1770 steam_do_deck_sensors_event(steam, sensors, data);1771 rcu_read_unlock();1772 break;1773 case ID_CONTROLLER_WIRELESS:1774 /*1775 * The payload of this event is a single byte:1776 * 0x01: disconnected.1777 * 0x02: connected.1778 */1779 switch (data[4]) {1780 case 0x01:1781 steam_do_connect_event(steam, false);1782 break;1783 case 0x02:1784 steam_do_connect_event(steam, true);1785 break;1786 }1787 break;1788 case ID_CONTROLLER_STATUS:1789 if (steam->quirks & STEAM_QUIRK_WIRELESS) {1790 rcu_read_lock();1791 battery = rcu_dereference(steam->battery);1792 if (likely(battery)) {1793 steam_do_battery_event(steam, battery, data);1794 } else {1795 dbg_hid(1796 "%s: battery data without connect event\n",1797 __func__);1798 steam_do_connect_event(steam, true);1799 }1800 rcu_read_unlock();1801 }1802 break;1803 }1804 return 0;1805}1806 1807static int steam_param_set_lizard_mode(const char *val,1808 const struct kernel_param *kp)1809{1810 struct steam_device *steam;1811 int ret;1812 1813 ret = param_set_bool(val, kp);1814 if (ret)1815 return ret;1816 1817 mutex_lock(&steam_devices_lock);1818 list_for_each_entry(steam, &steam_devices, list) {1819 if (!steam->client_opened)1820 steam_set_lizard_mode(steam, lizard_mode);1821 }1822 mutex_unlock(&steam_devices_lock);1823 return 0;1824}1825 1826static const struct kernel_param_ops steam_lizard_mode_ops = {1827 .set = steam_param_set_lizard_mode,1828 .get = param_get_bool,1829};1830 1831module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644);1832MODULE_PARM_DESC(lizard_mode,1833 "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use");1834 1835static const struct hid_device_id steam_controllers[] = {1836 { /* Wired Steam Controller */1837 HID_USB_DEVICE(USB_VENDOR_ID_VALVE,1838 USB_DEVICE_ID_STEAM_CONTROLLER)1839 },1840 { /* Wireless Steam Controller */1841 HID_USB_DEVICE(USB_VENDOR_ID_VALVE,1842 USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS),1843 .driver_data = STEAM_QUIRK_WIRELESS1844 },1845 { /* Steam Deck */1846 HID_USB_DEVICE(USB_VENDOR_ID_VALVE,1847 USB_DEVICE_ID_STEAM_DECK),1848 .driver_data = STEAM_QUIRK_DECK1849 },1850 {}1851};1852 1853MODULE_DEVICE_TABLE(hid, steam_controllers);1854 1855static struct hid_driver steam_controller_driver = {1856 .name = "hid-steam",1857 .id_table = steam_controllers,1858 .probe = steam_probe,1859 .remove = steam_remove,1860 .raw_event = steam_raw_event,1861};1862 1863module_hid_driver(steam_controller_driver);1864