// SPDX-License-Identifier: GPL-2.0+ /* * HID driver for Valve Steam Controller * * Copyright (c) 2018 Rodrigo Rivas Costa * Copyright (c) 2022 Valve Software * * Supports both the wired and wireless interfaces. * * This controller has a builtin emulation of mouse and keyboard: the right pad * can be used as a mouse, the shoulder buttons are mouse buttons, A and B * buttons are ENTER and ESCAPE, and so on. This is implemented as additional * HID interfaces. * * This is known as the "lizard mode", because apparently lizards like to use * the computer from the coach, without a proper mouse and keyboard. * * This driver will disable the lizard mode when the input device is opened * and re-enable it when the input device is closed, so as not to break user * mode behaviour. The lizard_mode parameter can be used to change that. * * There are a few user space applications (notably Steam Client) that use * the hidraw interface directly to create input devices (XTest, uinput...). * In order to avoid breaking them this driver creates a layered hidraw device, * so it can detect when the client is running and then: * - it will not send any command to the controller. * - this input device will be removed, to avoid double input of the same * user action. * When the client is closed, this input device will be created again. * * For additional functions, such as changing the right-pad margin or switching * the led, you can use the user-space tool at: * * https://github.com/rodrigorc/steamctrl */ #include #include #include #include #include #include #include #include #include #include #include #include "hid-ids.h" MODULE_DESCRIPTION("HID driver for Valve Steam Controller"); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Rodrigo Rivas Costa "); MODULE_AUTHOR("Vicki Pfau "); static bool lizard_mode = true; static DEFINE_MUTEX(steam_devices_lock); static LIST_HEAD(steam_devices); #define STEAM_QUIRK_WIRELESS BIT(0) #define STEAM_QUIRK_DECK BIT(1) #define STEAM_QUIRK_IBEX BIT(2) #define STEAM_QUIRK_BLE BIT(3) /* Touch pads are 40 mm in diameter and 65535 units */ #define STEAM_PAD_RESOLUTION 1638 /* Trigger runs are about 5 mm and 256 units */ #define STEAM_TRIGGER_RESOLUTION 51 /* Joystick runs are about 5 mm and 256 units */ #define STEAM_JOYSTICK_RESOLUTION 51 /* Trigger runs are about 6 mm and 32768 units */ #define STEAM_DECK_TRIGGER_RESOLUTION 5461 /* Joystick runs are about 5 mm and 32768 units */ #define STEAM_DECK_JOYSTICK_RESOLUTION 6553 /* Accelerometer has 16 bit resolution and a range of +/- 2g */ #define STEAM_ACCEL_RES_PER_G 16384 #define STEAM_ACCEL_RANGE 32768 #define STEAM_ACCEL_FUZZ 128 #define STEAM_DECK_ACCEL_FUZZ 32 /* Gyroscope has 16 bit resolution and a range of +/- 2000 dps */ #define STEAM_GYRO_RES_PER_DPS 16 #define STEAM_GYRO_RANGE 32768 #define STEAM_GYRO_FUZZ 0 #define STEAM_PAD_FUZZ 256 /* * Commands that can be sent in a feature report. * Thanks to Valve and SDL for the names. */ enum { ID_SET_DIGITAL_MAPPINGS = 0x80, ID_CLEAR_DIGITAL_MAPPINGS = 0x81, ID_GET_DIGITAL_MAPPINGS = 0x82, ID_GET_ATTRIBUTES_VALUES = 0x83, ID_GET_ATTRIBUTE_LABEL = 0x84, ID_SET_DEFAULT_DIGITAL_MAPPINGS = 0x85, ID_FACTORY_RESET = 0x86, ID_SET_SETTINGS_VALUES = 0x87, ID_CLEAR_SETTINGS_VALUES = 0x88, ID_GET_SETTINGS_VALUES = 0x89, ID_GET_SETTING_LABEL = 0x8A, ID_GET_SETTINGS_MAXS = 0x8B, ID_GET_SETTINGS_DEFAULTS = 0x8C, ID_SET_CONTROLLER_MODE = 0x8D, ID_LOAD_DEFAULT_SETTINGS = 0x8E, ID_TRIGGER_HAPTIC_PULSE = 0x8F, ID_TURN_OFF_CONTROLLER = 0x9F, ID_GET_DEVICE_INFO = 0xA1, ID_CALIBRATE_TRACKPADS = 0xA7, ID_RESERVED_0 = 0xA8, ID_SET_SERIAL_NUMBER = 0xA9, ID_GET_TRACKPAD_CALIBRATION = 0xAA, ID_GET_TRACKPAD_FACTORY_CALIBRATION = 0xAB, ID_GET_TRACKPAD_RAW_DATA = 0xAC, ID_ENABLE_PAIRING = 0xAD, ID_GET_STRING_ATTRIBUTE = 0xAE, ID_RADIO_ERASE_RECORDS = 0xAF, ID_RADIO_WRITE_RECORD = 0xB0, ID_SET_DONGLE_SETTING = 0xB1, ID_DONGLE_DISCONNECT_DEVICE = 0xB2, ID_DONGLE_COMMIT_DEVICE = 0xB3, ID_DONGLE_GET_WIRELESS_STATE = 0xB4, ID_CALIBRATE_GYRO = 0xB5, ID_PLAY_AUDIO = 0xB6, ID_AUDIO_UPDATE_START = 0xB7, ID_AUDIO_UPDATE_DATA = 0xB8, ID_AUDIO_UPDATE_COMPLETE = 0xB9, ID_GET_CHIPID = 0xBA, ID_CALIBRATE_JOYSTICK = 0xBF, ID_CALIBRATE_ANALOG_TRIGGERS = 0xC0, ID_SET_AUDIO_MAPPING = 0xC1, ID_CHECK_GYRO_FW_LOAD = 0xC2, ID_CALIBRATE_ANALOG = 0xC3, ID_DONGLE_GET_CONNECTED_SLOTS = 0xC4, ID_RESET_IMU = 0xCE, ID_TRIGGER_HAPTIC_CMD = 0xEA, ID_TRIGGER_RUMBLE_CMD = 0xEB, }; /* Settings IDs */ enum { /* 0 */ SETTING_MOUSE_SENSITIVITY, SETTING_MOUSE_ACCELERATION, SETTING_TRACKBALL_ROTATION_ANGLE, SETTING_HAPTIC_INTENSITY_UNUSED, SETTING_LEFT_GAMEPAD_STICK_ENABLED, SETTING_RIGHT_GAMEPAD_STICK_ENABLED, SETTING_USB_DEBUG_MODE, SETTING_LEFT_TRACKPAD_MODE, SETTING_RIGHT_TRACKPAD_MODE, SETTING_LIZARD_MODE, /* 10 */ SETTING_DPAD_DEADZONE, SETTING_MINIMUM_MOMENTUM_VEL, SETTING_MOMENTUM_DECAY_AMMOUNT, SETTING_TRACKPAD_RELATIVE_MODE_TICKS_PER_PIXEL, SETTING_HAPTIC_INCREMENT, SETTING_DPAD_ANGLE_SIN, SETTING_DPAD_ANGLE_COS, SETTING_MOMENTUM_VERTICAL_DIVISOR, SETTING_MOMENTUM_MAXIMUM_VELOCITY, SETTING_TRACKPAD_Z_ON, /* 20 */ SETTING_TRACKPAD_Z_OFF, SETTING_SENSITIVY_SCALE_AMMOUNT, SETTING_LEFT_TRACKPAD_SECONDARY_MODE, SETTING_RIGHT_TRACKPAD_SECONDARY_MODE, SETTING_SMOOTH_ABSOLUTE_MOUSE, SETTING_STEAMBUTTON_POWEROFF_TIME, SETTING_UNUSED_1, SETTING_TRACKPAD_OUTER_RADIUS, SETTING_TRACKPAD_Z_ON_LEFT, SETTING_TRACKPAD_Z_OFF_LEFT, /* 30 */ SETTING_TRACKPAD_OUTER_SPIN_VEL, SETTING_TRACKPAD_OUTER_SPIN_RADIUS, SETTING_TRACKPAD_OUTER_SPIN_HORIZONTAL_ONLY, SETTING_TRACKPAD_RELATIVE_MODE_DEADZONE, SETTING_TRACKPAD_RELATIVE_MODE_MAX_VEL, SETTING_TRACKPAD_RELATIVE_MODE_INVERT_Y, SETTING_TRACKPAD_DOUBLE_TAP_BEEP_ENABLED, SETTING_TRACKPAD_DOUBLE_TAP_BEEP_PERIOD, SETTING_TRACKPAD_DOUBLE_TAP_BEEP_COUNT, SETTING_TRACKPAD_OUTER_RADIUS_RELEASE_ON_TRANSITION, /* 40 */ SETTING_RADIAL_MODE_ANGLE, SETTING_HAPTIC_INTENSITY_MOUSE_MODE, SETTING_LEFT_DPAD_REQUIRES_CLICK, SETTING_RIGHT_DPAD_REQUIRES_CLICK, SETTING_LED_BASELINE_BRIGHTNESS, SETTING_LED_USER_BRIGHTNESS, SETTING_ENABLE_RAW_JOYSTICK, SETTING_ENABLE_FAST_SCAN, SETTING_IMU_MODE, SETTING_WIRELESS_PACKET_VERSION, /* 50 */ SETTING_SLEEP_INACTIVITY_TIMEOUT, SETTING_TRACKPAD_NOISE_THRESHOLD, SETTING_LEFT_TRACKPAD_CLICK_PRESSURE, SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE, SETTING_LEFT_BUMPER_CLICK_PRESSURE, SETTING_RIGHT_BUMPER_CLICK_PRESSURE, SETTING_LEFT_GRIP_CLICK_PRESSURE, SETTING_RIGHT_GRIP_CLICK_PRESSURE, SETTING_LEFT_GRIP2_CLICK_PRESSURE, SETTING_RIGHT_GRIP2_CLICK_PRESSURE, /* 60 */ SETTING_PRESSURE_MODE, SETTING_CONTROLLER_TEST_MODE, SETTING_TRIGGER_MODE, SETTING_TRACKPAD_Z_THRESHOLD, SETTING_FRAME_RATE, SETTING_TRACKPAD_FILT_CTRL, SETTING_TRACKPAD_CLIP, SETTING_DEBUG_OUTPUT_SELECT, SETTING_TRIGGER_THRESHOLD_PERCENT, SETTING_TRACKPAD_FREQUENCY_HOPPING, /* 70 */ SETTING_HAPTICS_ENABLED, SETTING_STEAM_WATCHDOG_ENABLE, SETTING_TIMP_TOUCH_THRESHOLD_ON, SETTING_TIMP_TOUCH_THRESHOLD_OFF, SETTING_FREQ_HOPPING, SETTING_TEST_CONTROL, SETTING_HAPTIC_MASTER_GAIN_DB, SETTING_THUMB_TOUCH_THRESH, SETTING_DEVICE_POWER_STATUS, SETTING_HAPTIC_INTENSITY, /* 80 */ SETTING_STABILIZER_ENABLED, SETTING_TIMP_MODE_MTE, }; /* Input report identifiers */ enum { ID_CONTROLLER_STATE = 1, ID_CONTROLLER_DEBUG = 2, ID_CONTROLLER_WIRELESS = 3, ID_CONTROLLER_STATUS = 4, ID_CONTROLLER_DEBUG2 = 5, ID_CONTROLLER_SECONDARY_STATE = 6, ID_CONTROLLER_BLE_STATE = 7, ID_CONTROLLER_DECK_STATE = 9, }; /* Read-only attributes */ enum { ATTRIB_UNIQUE_ID, // deprecated ATTRIB_PRODUCT_ID, ATTRIB_PRODUCT_REVISON, // deprecated ATTRIB_CAPABILITIES = ATTRIB_PRODUCT_REVISON, // intentional aliasing ATTRIB_FIRMWARE_VERSION, // deprecated ATTRIB_FIRMWARE_BUILD_TIME, ATTRIB_RADIO_FIRMWARE_BUILD_TIME, ATTRIB_RADIO_DEVICE_ID0, ATTRIB_RADIO_DEVICE_ID1, ATTRIB_DONGLE_FIRMWARE_BUILD_TIME, ATTRIB_HW_ID, // AKA BOARD_REVISION, ATTRIB_BOOTLOADER_BUILD_TIME, ATTRIB_CONNECTION_INTERVAL_IN_US, ATTRIB_SECONDARY_FIRMWARE_BUILD_TIME, ATTRIB_SECONDARY_BOOTLOADER_BUILD_TIME, ATTRIB_SECONDARY_HW_ID, // AKA BOARD_REVISION, ATTRIB_STREAMING, ATTRIB_TRACKPAD_ID, ATTRIB_SECONDARY_TRACKPAD_ID, ATTRIB_COUNT }; /* String attribute identifiers */ enum { ATTRIB_STR_BOARD_SERIAL, ATTRIB_STR_UNIT_SERIAL, }; /* Values for IMU_MODE (bitmask) */ enum { SETTING_IMU_MODE_OFF = 0, SETTING_IMU_MODE_STEERING = BIT(0), SETTING_IMU_MODE_TILT = BIT(1), SETTING_IMU_MODE_SEND_ORIENTATION = BIT(2), SETTING_IMU_MODE_SEND_RAW_ACCEL = BIT(3), SETTING_IMU_MODE_SEND_RAW_GYRO = BIT(4), }; /* Trackpad modes */ enum { TRACKPAD_ABSOLUTE_MOUSE, TRACKPAD_RELATIVE_MOUSE, TRACKPAD_DPAD_FOUR_WAY_DISCRETE, TRACKPAD_DPAD_FOUR_WAY_OVERLAP, TRACKPAD_DPAD_EIGHT_WAY, TRACKPAD_RADIAL_MODE, TRACKPAD_ABSOLUTE_DPAD, TRACKPAD_NONE, TRACKPAD_GESTURE_KEYBOARD, }; /* Report identifiers (Ibex only) */ enum { /* Feature */ REPORT_ID_FEATURES_CONTROLLER = 1, REPORT_ID_FEATURES_DONGLE = 2, /* Input */ REPORT_ID_INPUT = 0x42, REPORT_ID_BATTERY = 0x43, REPORT_ID_INPUT2 = 0x45, REPORT_ID_WIRELESS_EVENT = 0x79, /* Output */ REPORT_ID_HAPTIC_RUMBLE = 0x80, REPORT_ID_HAPTIC_PULSE = 0x81, REPORT_ID_HAPTIC_COMMAND = 0x82, REPORT_ID_HAPTIC_LFO_TONE = 0x83, REPORT_ID_HAPTIC_LOG_SWEEP = 0x84, REPORT_ID_HAPTIC_SCRIPT = 0x85, }; /* Ibex charge state */ enum { CHARGE_STATE_DISCHARGING = 1, CHARGE_STATE_CHARGING = 2, CHARGE_STATE_CHARGING_DONE = 4, }; /* Ibex wireless events */ enum { WIRELESS_EVENT_DISCONNECT = 1, WIRELESS_EVENT_CONNECT = 2, WIRELESS_EVENT_PAIR = 3, }; struct steam_controller_attribute { unsigned char tag; __le32 value; } __packed; struct steam_ibex_battery_status { u8 charge_state; u8 battery_level; __le16 battery_voltage; __le16 system_voltage; __le16 input_voltage; __le16 battery_current; __le16 input_current; __le16 temperature; }; struct steam_ibex_haptic_rumble { u8 type; __le16 intensity; struct { __le16 speed; u8 gain; } __packed left, right; } __packed; static_assert(sizeof(struct steam_ibex_haptic_rumble) == 9); struct steam_ibex_haptic_pulse { u8 side; __le16 on_us; __le16 off_us; __le16 repeat_count; } __packed; static_assert(sizeof(struct steam_ibex_haptic_pulse) == 7); struct steam_ibex_output_report { u8 id; union { struct steam_ibex_haptic_rumble rumble; struct steam_ibex_haptic_pulse pulse; }; } __packed; /* Pad identifiers for the deck */ #define STEAM_PAD_LEFT 0 #define STEAM_PAD_RIGHT 1 #define STEAM_PAD_BOTH 2 /* Other random constants */ #define STEAM_SERIAL_LEN 0x15 struct steam_device { struct list_head list; spinlock_t lock; struct hid_device *hdev, *client_hdev; struct mutex report_mutex; struct mutex registration_mutex; unsigned long client_opened; struct input_dev __rcu *input; struct input_dev __rcu *sensors; unsigned long quirks; struct work_struct work_connect; bool connected; bool registered; char serial_no[STEAM_SERIAL_LEN + 1]; struct power_supply_desc battery_desc; struct power_supply __rcu *battery; u8 battery_charge; u8 battery_status; u16 battery_temp; u16 battery_voltage; u16 battery_current; struct delayed_work mode_switch; bool did_mode_switch; bool gamepad_mode; struct work_struct rumble_work; struct delayed_work coalesce_rumble_work; u16 rumble_left; u16 rumble_right; unsigned int sensor_timestamp_us; unsigned int sensor_update_rate_us; }; static int steam_recv_report_id(struct steam_device *steam, u8 *data, int size, u8 report_id) { struct hid_report *r; u8 *buf; unsigned int retries = 50; int ret; u32 len; /* * All reports start with a two byte header. * We must read at least two bytes to get a sensible output. */ if (size < 2) return -EINVAL; r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[report_id]; if (!r) { hid_err(steam->hdev, "No HID_FEATURE_REPORT present for ID %u\n", report_id); return -EINVAL; } len = hid_report_len(r); if (len < 64) return -EINVAL; buf = hid_alloc_report_buf(r, GFP_KERNEL); if (!buf) return -ENOMEM; /* * The report ID is consistent, so strip the first byte from the output. * hid_report_len() is not counting the report ID, so +1 to the length * or else we get a EOVERFLOW. We are safe from a buffer overflow * because hid_alloc_report_buf() allocates +7 bytes. */ if (!(steam->quirks & STEAM_QUIRK_IBEX)) len += 1; /* * Sometimes the wireless controller fails with EPIPE * when sending a feature report. * Doing a HID_REQ_GET_REPORT and waiting for a while * seems to fix that. */ do { ret = hid_hw_raw_request(steam->hdev, report_id, buf, len, HID_FEATURE_REPORT, HID_REQ_GET_REPORT); if (ret != -EPIPE) break; msleep(20); } while (--retries); if (ret > 0) { /* Remove the report ID from the return buffer */ ret--; size = min(size, ret); memcpy(data, buf + 1, size); } kfree(buf); /* * Don't log if the failure is -ENODEV, as this * can happen normally on disconnect. */ if (ret < 0 && ret != -ENODEV) hid_err(steam->hdev, "%s: error %d\n", __func__, ret); else if (ret > 0) hid_dbg(steam->hdev, "Received report %*ph\n", size, data); if (ret < 0) return ret; if (ret < 2) { hid_err(steam->hdev, "%s: reply too short\n", __func__); return -EPROTO; } if (ret < data[1] + 2) { hid_err(steam->hdev, "%s: expected %u bytes, read %i\n", __func__, data[1] + 2, ret); return -EPROTO; } return size; } static int steam_send_report_id(struct steam_device *steam, u8 *cmd, int size, u8 report_id) { struct hid_report *r; u8 *buf; unsigned int retries = 50; int ret; u32 len; r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[report_id]; if (!r) { hid_err(steam->hdev, "No HID_FEATURE_REPORT present for ID %u\n", report_id); return -EINVAL; } len = hid_report_len(r); if (len < 64) return -EINVAL; buf = hid_alloc_report_buf(r, GFP_KERNEL); if (!buf) return -ENOMEM; /* The report ID is always consistent */ buf[0] = report_id; memcpy(buf + 1, cmd, size); hid_dbg(steam->hdev, "Sending report %*ph\n", size, cmd); if (!(steam->quirks & STEAM_QUIRK_IBEX)) len += 1; /* * Sometimes the wireless controller fails with EPIPE * when sending a feature report. * Doing a HID_REQ_SET_REPORT and waiting for a while * seems to fix that. */ do { ret = hid_hw_raw_request(steam->hdev, report_id, buf, max(size + 1, len), HID_FEATURE_REPORT, HID_REQ_SET_REPORT); if (ret != -EPIPE) break; msleep(20); } while (--retries); kfree(buf); /* * Don't log if the failure is -ENODEV, as this * can happen normally on disconnect. */ if (ret < 0 && ret != -ENODEV) hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__, ret, size, cmd); return ret; } static int steam_send_report(struct steam_device *steam, u8 *cmd, int size) { u8 report_id; if (steam->quirks & STEAM_QUIRK_IBEX) report_id = REPORT_ID_FEATURES_CONTROLLER; else report_id = 0; return steam_send_report_id(steam, cmd, size, report_id); } static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd) { return steam_send_report(steam, &cmd, 1); } static int steam_write_settings(struct steam_device *steam, /* u8 reg, u16 val */...) { /* Send: 0x87 len (reg valLo valHi)* */ u8 reg; u16 val; u8 cmd[64] = {ID_SET_SETTINGS_VALUES, 0x00}; va_list args; va_start(args, steam); for (;;) { reg = va_arg(args, int); if (reg == 0) break; val = va_arg(args, int); cmd[cmd[1] + 2] = reg; cmd[cmd[1] + 3] = val & 0xff; cmd[cmd[1] + 4] = val >> 8; cmd[1] += 3; } va_end(args); return steam_send_report(steam, cmd, 2 + cmd[1]); } static int steam_exchange_report_id(struct steam_device *steam, u8 *cmd, int csize, u8 *reply, int rsize, u8 report_id) { unsigned int retries = 5; int ret; do { ret = steam_send_report_id(steam, cmd, csize, report_id); if (ret < 0) return ret; ret = steam_recv_report_id(steam, reply, rsize, report_id); /* * Sometimes this can fail on the first few tries on the Steam * Controller (2015). It appears to be a firmware bug, and Steam * itself just retries, so we should also retry a few times to * see if we get it. */ if (ret == -EPROTO) continue; if (ret < 0) { hid_err(steam->hdev, "%s: error reading reply (%*ph)\n", __func__, csize, cmd); return ret; } if (reply[0] == cmd[0] && reply[1] >= 1) break; if (retries > 0) continue; hid_err(steam->hdev, "%s: invalid reply (%*ph)\n", __func__, rsize, reply); return -EPROTO; } while (retries--); return ret; } static int steam_exchange_report(struct steam_device *steam, u8 *cmd, int csize, u8 *reply, int rsize) { u8 report_id; if (steam->quirks & STEAM_QUIRK_IBEX) report_id = REPORT_ID_FEATURES_CONTROLLER; else report_id = 0; return steam_exchange_report_id(steam, cmd, csize, reply, rsize, report_id); } static int steam_get_serial(struct steam_device *steam) { /* * Send: 0xae 0x15 0x01 * Recv: 0xae 0x15 0x01 serialnumber */ int ret = 0; u8 cmd[] = {ID_GET_STRING_ATTRIBUTE, sizeof(steam->serial_no), ATTRIB_STR_UNIT_SERIAL}; u8 reply[3 + STEAM_SERIAL_LEN + 1] = {0}; ret = steam_exchange_report(steam, cmd, sizeof(cmd), reply, sizeof(reply)); if (ret < 0) return ret; if (reply[1] > sizeof(steam->serial_no) || reply[2] != ATTRIB_STR_UNIT_SERIAL) { hid_err(steam->hdev, "%s: invalid reply (%*ph)\n", __func__, (int)sizeof(reply), reply); return -EIO; } strscpy(steam->serial_no, reply + 3, reply[1]); return ret; } static int steam_get_attributes(struct steam_device *steam) { int ret = 0; u8 cmd[] = {ID_GET_ATTRIBUTES_VALUES, 0}; u8 reply[64] = {}; u8 size; int i; struct steam_controller_attribute *attr; ret = steam_exchange_report(steam, cmd, sizeof(cmd), reply, sizeof(reply)); if (ret < 0) return ret; if (reply[1] < 2) { hid_err(steam->hdev, "%s: invalid reply (%*ph)\n", __func__, (int)sizeof(reply), reply); return -EIO; } size = min(reply[1], sizeof(reply) - 2); for (i = 0; i + sizeof(*attr) <= size; i += sizeof(*attr)) { attr = (struct steam_controller_attribute *)&reply[i + 2]; if (attr->tag == ATTRIB_CONNECTION_INTERVAL_IN_US) { steam->sensor_update_rate_us = get_unaligned_le32(&attr->value); hid_dbg(steam->hdev, "Sensor update rate: %uus\n", steam->sensor_update_rate_us); } } return 0; } static int steam_get_conn_status(struct steam_device *steam) { int ret = 0; u8 cmd[] = {ID_DONGLE_GET_WIRELESS_STATE}; u8 reply[3] = {}; u8 report_id; if (steam->quirks & STEAM_QUIRK_IBEX) report_id = REPORT_ID_FEATURES_DONGLE; else report_id = 0; guard(mutex)(&steam->report_mutex); ret = steam_exchange_report_id(steam, cmd, sizeof(cmd), reply, sizeof(reply), report_id); if (ret < 0) return ret; if (reply[0] != ID_DONGLE_GET_WIRELESS_STATE || reply[1] < 1) { hid_err(steam->hdev, "%s: invalid reply (%*ph)\n", __func__, (int)sizeof(reply), reply); return -EIO; } return reply[2]; } /* * Send a haptic pulse to the trackpads * Duration and interval are measured in microseconds, count is the number * of pulses to send for duration time with interval microseconds between them * and gain is measured in decibels, ranging from -24 to +6 */ static inline int steam_haptic_pulse(struct steam_device *steam, u8 pad, u16 duration, u16 interval, u16 count, u8 gain) { int ret; /* Left and right are swapped on this report for legacy reasons */ if (pad < STEAM_PAD_BOTH) pad ^= 1; if (steam->quirks & STEAM_QUIRK_IBEX) { struct steam_ibex_output_report *report = kzalloc(sizeof(struct steam_ibex_output_report), GFP_KERNEL); if (!report) return -ENOMEM; report->id = REPORT_ID_HAPTIC_PULSE; report->pulse.side = pad; put_unaligned_le16(duration, &report->pulse.on_us); put_unaligned_le16(interval, &report->pulse.off_us); put_unaligned_le16(count, &report->pulse.repeat_count); ret = hid_hw_output_report(steam->hdev, (u8 *)report, 8); kfree(report); } else { u8 report[10] = {ID_TRIGGER_HAPTIC_PULSE, 8, pad}; report[3] = duration & 0xFF; report[4] = duration >> 8; report[5] = interval & 0xFF; report[6] = interval >> 8; report[7] = count & 0xFF; report[8] = count >> 8; report[9] = gain; ret = steam_send_report(steam, report, 10); } return ret; } static inline int steam_haptic_rumble(struct steam_device *steam, u16 intensity, u16 left_speed, u16 right_speed, u8 left_gain, u8 right_gain) { int ret; if (steam->quirks & STEAM_QUIRK_IBEX) { struct steam_ibex_output_report *report = kzalloc(sizeof(struct steam_ibex_output_report), GFP_KERNEL); if (!report) return -ENOMEM; report->id = REPORT_ID_HAPTIC_RUMBLE; put_unaligned_le16(intensity, &report->rumble.intensity); put_unaligned_le16(left_speed, &report->rumble.left.speed); report->rumble.left.gain = left_gain; put_unaligned_le16(right_speed, &report->rumble.right.speed); report->rumble.right.gain = right_gain; ret = hid_hw_output_report(steam->hdev, (u8 *)report, 10); kfree(report); } else { u8 report[11] = {ID_TRIGGER_RUMBLE_CMD, 9}; report[3] = intensity & 0xFF; report[4] = intensity >> 8; report[5] = left_speed & 0xFF; report[6] = left_speed >> 8; report[7] = right_speed & 0xFF; report[8] = right_speed >> 8; report[9] = left_gain; report[10] = right_gain; ret = steam_send_report(steam, report, sizeof(report)); } return ret; } static void steam_haptic_rumble_cb(struct work_struct *work) { struct steam_device *steam = container_of(work, struct steam_device, rumble_work); mutex_lock(&steam->report_mutex); steam_haptic_rumble(steam, 0, steam->rumble_left, steam->rumble_right, 2, 0); mutex_unlock(&steam->report_mutex); } static void steam_coalesce_rumble_cb(struct work_struct *work) { struct steam_device *steam = container_of(to_delayed_work(work), struct steam_device, coalesce_rumble_work); mutex_lock(&steam->report_mutex); steam_haptic_rumble(steam, 0, steam->rumble_left, steam->rumble_right, 2, 0); mutex_unlock(&steam->report_mutex); if (steam->rumble_left || steam->rumble_right) schedule_delayed_work(&steam->coalesce_rumble_work, HZ / 20); } #ifdef CONFIG_STEAM_FF static int steam_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect) { struct steam_device *steam = input_get_drvdata(dev); steam->rumble_left = effect->u.rumble.strong_magnitude; steam->rumble_right = effect->u.rumble.weak_magnitude; /* * The interface gets somewhat overloaded when too many rumble * packets are sent in a row, so Steam throttles it to 20 Hz */ if (delayed_work_pending(&steam->coalesce_rumble_work)) return 0; schedule_delayed_work(&steam->coalesce_rumble_work, HZ / 20); return schedule_work(&steam->rumble_work); } #endif static void steam_set_lizard_mode(struct steam_device *steam, bool enable) { if (steam->gamepad_mode) enable = false; if (enable) { /* enable esc, enter, cursors */ steam_send_report_byte(steam, ID_SET_DEFAULT_DIGITAL_MAPPINGS); /* reset settings */ steam_send_report_byte(steam, ID_LOAD_DEFAULT_SETTINGS); } else { /* disable esc, enter, cursor */ steam_send_report_byte(steam, ID_CLEAR_DIGITAL_MAPPINGS); if (steam->quirks & (STEAM_QUIRK_DECK | STEAM_QUIRK_IBEX)) steam_write_settings(steam, /* disable lizard mode */ SETTING_LIZARD_MODE, 0, /* disable watchdog that tests if Steam is active */ SETTING_STEAM_WATCHDOG_ENABLE, 0, 0); else steam_write_settings(steam, SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE, /* disable mouse */ 0); } } static int steam_input_open(struct input_dev *dev) { struct steam_device *steam = input_get_drvdata(dev); unsigned long flags; bool client_opened; /* * Disabling lizard mode automatically is only done on the Steam * Controller. On the Steam Deck, this is toggled manually by holding * the options button instead, handled by steam_mode_switch_cb. */ if (!(steam->quirks & (STEAM_QUIRK_DECK | STEAM_QUIRK_IBEX))) { spin_lock_irqsave(&steam->lock, flags); client_opened = steam->client_opened; spin_unlock_irqrestore(&steam->lock, flags); guard(mutex)(&steam->report_mutex); if (!client_opened && lizard_mode) steam_set_lizard_mode(steam, false); } return 0; } static void steam_input_close(struct input_dev *dev) { struct steam_device *steam = input_get_drvdata(dev); unsigned long flags; bool client_opened; if (!(steam->quirks & (STEAM_QUIRK_DECK | STEAM_QUIRK_IBEX))) { spin_lock_irqsave(&steam->lock, flags); client_opened = steam->client_opened; spin_unlock_irqrestore(&steam->lock, flags); guard(mutex)(&steam->report_mutex); if (!client_opened && lizard_mode) steam_set_lizard_mode(steam, true); } } static int steam_sensor_open(struct input_dev *dev) { struct steam_device *steam = input_get_drvdata(dev); scoped_guard(spinlock_irqsave, &steam->lock) { if (steam->client_opened) return 0; } guard(mutex)(&steam->report_mutex); steam_write_settings(steam, SETTING_IMU_MODE, SETTING_IMU_MODE_SEND_RAW_ACCEL | SETTING_IMU_MODE_SEND_RAW_GYRO, 0); return 0; } static void steam_sensor_close(struct input_dev *dev) { struct steam_device *steam = input_get_drvdata(dev); scoped_guard(spinlock_irqsave, &steam->lock) { if (steam->client_opened) return; } guard(mutex)(&steam->report_mutex); steam_write_settings(steam, SETTING_IMU_MODE, 0, 0); } static enum power_supply_property steam_battery_props[] = { POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_SCOPE, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_CAPACITY, }; static int steam_battery_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct steam_device *steam = power_supply_get_drvdata(psy); unsigned long flags; u16 volts; u16 curr; u16 temp; u8 batt; u8 status; int ret = 0; spin_lock_irqsave(&steam->lock, flags); volts = steam->battery_voltage; curr = steam->battery_current; batt = steam->battery_charge; temp = steam->battery_temp; status = steam->battery_status; spin_unlock_irqrestore(&steam->lock, flags); switch (psp) { case POWER_SUPPLY_PROP_PRESENT: val->intval = 1; break; case POWER_SUPPLY_PROP_STATUS: val->intval = status; break; case POWER_SUPPLY_PROP_SCOPE: val->intval = POWER_SUPPLY_SCOPE_DEVICE; break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: val->intval = volts * 1000; /* mV -> uV */ break; case POWER_SUPPLY_PROP_CURRENT_NOW: val->intval = curr * 1000; /* mA -> uA */ break; case POWER_SUPPLY_PROP_TEMP: val->intval = temp / 100; /* thousandths °C -> tenths °C */ break; case POWER_SUPPLY_PROP_CAPACITY: val->intval = batt; break; default: ret = -EINVAL; break; } return ret; } static enum power_supply_property steam_ibex_battery_props[] = { POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_SCOPE, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_CURRENT_NOW, POWER_SUPPLY_PROP_CAPACITY, POWER_SUPPLY_PROP_TEMP, }; static int steam_battery_register(struct steam_device *steam) { struct power_supply *battery; struct power_supply_config battery_cfg = { .drv_data = steam, }; unsigned long flags; int ret; steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; if (steam->quirks & STEAM_QUIRK_IBEX) { steam->battery_desc.properties = steam_ibex_battery_props; steam->battery_desc.num_properties = ARRAY_SIZE(steam_ibex_battery_props); /* * Ibex needs a shorter name as it has a temperature and the * thermal zone name length limit is 20 characters. It's more * ambiguous sounding, so let's only use it when needed. */ steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev, GFP_KERNEL, "steam-%s", steam->serial_no); } else { steam->battery_desc.properties = steam_battery_props; steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props); steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev, GFP_KERNEL, "steam-controller-%s-battery", steam->serial_no); } steam->battery_desc.get_property = steam_battery_get_property; if (!steam->battery_desc.name) return -ENOMEM; /* avoid the warning of 0% battery while waiting for the first info */ spin_lock_irqsave(&steam->lock, flags); steam->battery_voltage = 3000; steam->battery_charge = 100; steam->battery_current = 0; steam->battery_temp = 20000; steam->battery_status = POWER_SUPPLY_STATUS_UNKNOWN; spin_unlock_irqrestore(&steam->lock, flags); battery = power_supply_register(&steam->hdev->dev, &steam->battery_desc, &battery_cfg); if (IS_ERR(battery)) { ret = PTR_ERR(battery); devm_kfree(&steam->hdev->dev, steam->battery_desc.name); hid_err(steam->hdev, "%s:power_supply_register failed with error %d\n", __func__, ret); return ret; } rcu_assign_pointer(steam->battery, battery); power_supply_powers(battery, &steam->hdev->dev); return 0; } static int steam_input_register(struct steam_device *steam) { struct hid_device *hdev = steam->hdev; struct input_dev *input; int ret; rcu_read_lock(); input = rcu_dereference(steam->input); rcu_read_unlock(); if (input) { dbg_hid("%s: already connected\n", __func__); return 0; } input = input_allocate_device(); if (!input) return -ENOMEM; input_set_drvdata(input, steam); input->dev.parent = &hdev->dev; input->open = steam_input_open; input->close = steam_input_close; input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ? "Wireless Steam Controller" : (steam->quirks & STEAM_QUIRK_DECK) ? "Steam Deck" : "Steam Controller"; input->phys = hdev->phys; input->uniq = steam->serial_no; input->id.bustype = hdev->bus; input->id.vendor = hdev->vendor; input->id.product = hdev->product; input->id.version = hdev->version; input_set_capability(input, EV_KEY, BTN_TR2); input_set_capability(input, EV_KEY, BTN_TL2); input_set_capability(input, EV_KEY, BTN_TR); input_set_capability(input, EV_KEY, BTN_TL); input_set_capability(input, EV_KEY, BTN_Y); input_set_capability(input, EV_KEY, BTN_B); input_set_capability(input, EV_KEY, BTN_X); input_set_capability(input, EV_KEY, BTN_A); input_set_capability(input, EV_KEY, BTN_DPAD_UP); input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT); input_set_capability(input, EV_KEY, BTN_DPAD_LEFT); input_set_capability(input, EV_KEY, BTN_DPAD_DOWN); input_set_capability(input, EV_KEY, BTN_SELECT); input_set_capability(input, EV_KEY, BTN_MODE); input_set_capability(input, EV_KEY, BTN_START); input_set_capability(input, EV_KEY, BTN_THUMBR); input_set_capability(input, EV_KEY, BTN_THUMBL); input_set_capability(input, EV_KEY, BTN_THUMB); input_set_capability(input, EV_KEY, BTN_THUMB2); input_set_capability(input, EV_KEY, BTN_GRIPL); input_set_capability(input, EV_KEY, BTN_GRIPR); if (steam->quirks & (STEAM_QUIRK_DECK | STEAM_QUIRK_IBEX)) { input_set_capability(input, EV_KEY, BTN_BASE); input_set_capability(input, EV_KEY, BTN_GRIPL2); input_set_capability(input, EV_KEY, BTN_GRIPR2); } input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0); input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0); input_set_abs_params(input, ABS_HAT0X, -32767, 32767, STEAM_PAD_FUZZ, 0); input_set_abs_params(input, ABS_HAT0Y, -32767, 32767, STEAM_PAD_FUZZ, 0); if (steam->quirks & (STEAM_QUIRK_DECK | STEAM_QUIRK_IBEX)) { input_set_abs_params(input, ABS_HAT2Y, 0, 32767, 0, 0); input_set_abs_params(input, ABS_HAT2X, 0, 32767, 0, 0); input_set_abs_params(input, ABS_RX, -32767, 32767, 0, 0); input_set_abs_params(input, ABS_RY, -32767, 32767, 0, 0); input_set_abs_params(input, ABS_HAT1X, -32767, 32767, STEAM_PAD_FUZZ, 0); input_set_abs_params(input, ABS_HAT1Y, -32767, 32767, STEAM_PAD_FUZZ, 0); input_abs_set_res(input, ABS_X, STEAM_DECK_JOYSTICK_RESOLUTION); input_abs_set_res(input, ABS_Y, STEAM_DECK_JOYSTICK_RESOLUTION); input_abs_set_res(input, ABS_RX, STEAM_DECK_JOYSTICK_RESOLUTION); input_abs_set_res(input, ABS_RY, STEAM_DECK_JOYSTICK_RESOLUTION); input_abs_set_res(input, ABS_HAT1X, STEAM_PAD_RESOLUTION); input_abs_set_res(input, ABS_HAT1Y, STEAM_PAD_RESOLUTION); input_abs_set_res(input, ABS_HAT2Y, STEAM_DECK_TRIGGER_RESOLUTION); input_abs_set_res(input, ABS_HAT2X, STEAM_DECK_TRIGGER_RESOLUTION); } else { input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0); input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0); input_set_abs_params(input, ABS_RX, -32767, 32767, STEAM_PAD_FUZZ, 0); input_set_abs_params(input, ABS_RY, -32767, 32767, STEAM_PAD_FUZZ, 0); input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION); input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION); input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION); input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION); input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION); input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION); } input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION); input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION); #ifdef CONFIG_STEAM_FF if (steam->quirks & (STEAM_QUIRK_DECK | STEAM_QUIRK_IBEX)) { input_set_capability(input, EV_FF, FF_RUMBLE); ret = input_ff_create_memless(input, NULL, steam_play_effect); if (ret) goto input_register_fail; } #endif ret = input_register_device(input); if (ret) goto input_register_fail; rcu_assign_pointer(steam->input, input); return 0; input_register_fail: input_free_device(input); return ret; } static int steam_sensors_register(struct steam_device *steam) { struct hid_device *hdev = steam->hdev; struct input_dev *sensors; int ret; bool needs_open_close; rcu_read_lock(); sensors = rcu_dereference(steam->sensors); rcu_read_unlock(); if (sensors) { dbg_hid("%s: already connected\n", __func__); return 0; } sensors = input_allocate_device(); if (!sensors) return -ENOMEM; input_set_drvdata(sensors, steam); sensors->dev.parent = &hdev->dev; /* * The open/close calls are needed in these specific cases: * * - Steam Controller (2015): Always * - Steam Deck: Never * - Steam Controller (2026): Only when wireless/BLE */ if (steam->quirks & STEAM_QUIRK_DECK) needs_open_close = false; else if (steam->quirks & (STEAM_QUIRK_WIRELESS | STEAM_QUIRK_BLE)) /* Both wireless Steam Controller setups */ needs_open_close = true; else if (steam->quirks & STEAM_QUIRK_IBEX) /* Wired Steam Controller (2026) */ needs_open_close = false; else /* Wired Steam Controller (2015) */ needs_open_close = true; if (needs_open_close) { sensors->open = steam_sensor_open; sensors->close = steam_sensor_close; } sensors->name = steam->quirks & STEAM_QUIRK_DECK ? "Steam Deck Motion Sensors" : "Steam Controller Motion Sensors"; sensors->phys = hdev->phys; sensors->uniq = steam->serial_no; sensors->id.bustype = hdev->bus; sensors->id.vendor = hdev->vendor; sensors->id.product = hdev->product; sensors->id.version = hdev->version; __set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit); __set_bit(EV_MSC, sensors->evbit); __set_bit(MSC_TIMESTAMP, sensors->mscbit); if (steam->quirks & STEAM_QUIRK_DECK) { input_set_abs_params(sensors, ABS_X, -STEAM_ACCEL_RANGE, STEAM_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); input_set_abs_params(sensors, ABS_Y, -STEAM_ACCEL_RANGE, STEAM_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); input_set_abs_params(sensors, ABS_Z, -STEAM_ACCEL_RANGE, STEAM_ACCEL_RANGE, STEAM_DECK_ACCEL_FUZZ, 0); } else { input_set_abs_params(sensors, ABS_X, -STEAM_ACCEL_RANGE, STEAM_ACCEL_RANGE, STEAM_ACCEL_FUZZ, 0); input_set_abs_params(sensors, ABS_Y, -STEAM_ACCEL_RANGE, STEAM_ACCEL_RANGE, STEAM_ACCEL_FUZZ, 0); input_set_abs_params(sensors, ABS_Z, -STEAM_ACCEL_RANGE, STEAM_ACCEL_RANGE, STEAM_ACCEL_FUZZ, 0); } input_abs_set_res(sensors, ABS_X, STEAM_ACCEL_RES_PER_G); input_abs_set_res(sensors, ABS_Y, STEAM_ACCEL_RES_PER_G); input_abs_set_res(sensors, ABS_Z, STEAM_ACCEL_RES_PER_G); input_set_abs_params(sensors, ABS_RX, -STEAM_GYRO_RANGE, STEAM_GYRO_RANGE, STEAM_GYRO_FUZZ, 0); input_set_abs_params(sensors, ABS_RY, -STEAM_GYRO_RANGE, STEAM_GYRO_RANGE, STEAM_GYRO_FUZZ, 0); input_set_abs_params(sensors, ABS_RZ, -STEAM_GYRO_RANGE, STEAM_GYRO_RANGE, STEAM_GYRO_FUZZ, 0); input_abs_set_res(sensors, ABS_RX, STEAM_GYRO_RES_PER_DPS); input_abs_set_res(sensors, ABS_RY, STEAM_GYRO_RES_PER_DPS); input_abs_set_res(sensors, ABS_RZ, STEAM_GYRO_RES_PER_DPS); ret = input_register_device(sensors); if (ret) goto sensors_register_fail; rcu_assign_pointer(steam->sensors, sensors); return 0; sensors_register_fail: input_free_device(sensors); return ret; } static void steam_input_unregister(struct steam_device *steam) { struct input_dev *input; rcu_read_lock(); input = rcu_dereference(steam->input); rcu_read_unlock(); if (!input) return; RCU_INIT_POINTER(steam->input, NULL); synchronize_rcu(); input_unregister_device(input); } static void steam_sensors_unregister(struct steam_device *steam) { struct input_dev *sensors; rcu_read_lock(); sensors = rcu_dereference(steam->sensors); rcu_read_unlock(); if (!sensors) return; RCU_INIT_POINTER(steam->sensors, NULL); synchronize_rcu(); input_unregister_device(sensors); } static void steam_battery_unregister(struct steam_device *steam) { struct power_supply *battery; rcu_read_lock(); battery = rcu_dereference(steam->battery); rcu_read_unlock(); if (!battery) return; RCU_INIT_POINTER(steam->battery, NULL); synchronize_rcu(); power_supply_unregister(battery); devm_kfree(&steam->hdev->dev, steam->battery_desc.name); } static int steam_register(struct steam_device *steam) { int ret; mutex_lock(&steam->registration_mutex); /* * This function can be called several times in a row with the * wireless adaptor, without steam_unregister() between them, because * another client send a get_connection_status command, for example. */ if (steam->registered) { mutex_unlock(&steam->registration_mutex); return 0; } mutex_lock(&steam->report_mutex); /* * Unlikely, but getting the serial could fail, and it is not so * important, so make up a serial number and go on. */ if (steam_get_serial(steam) < 0 || !steam->serial_no[0]) strscpy(steam->serial_no, "XXXXXXXXXX", sizeof(steam->serial_no)); ret = steam_get_attributes(steam); if (ret < 0) hid_err(steam->hdev, "%s:steam_get_attributes failed with error %d\n", __func__, ret); hid_info(steam->hdev, "Steam %s '%s' connected", steam->quirks & STEAM_QUIRK_DECK ? "Deck" : "Controller", steam->serial_no); steam_set_lizard_mode(steam, lizard_mode); mutex_unlock(&steam->report_mutex); /* ignore battery errors, we can live without it */ if (steam->quirks & (STEAM_QUIRK_WIRELESS | STEAM_QUIRK_IBEX)) steam_battery_register(steam); ret = steam_input_register(steam); if (ret != 0) goto steam_register_input_fail; ret = steam_sensors_register(steam); if (ret != 0) goto steam_register_sensors_fail; steam->registered = true; mutex_unlock(&steam->registration_mutex); mutex_lock(&steam_devices_lock); if (list_empty(&steam->list)) list_add(&steam->list, &steam_devices); mutex_unlock(&steam_devices_lock); return 0; steam_register_sensors_fail: steam_input_unregister(steam); steam_register_input_fail: steam_battery_unregister(steam); mutex_unlock(&steam->registration_mutex); cancel_work_sync(&steam->rumble_work); cancel_delayed_work_sync(&steam->mode_switch); cancel_delayed_work_sync(&steam->coalesce_rumble_work); return ret; } static void steam_unregister(struct steam_device *steam) { if (!steam->registered) return; hid_info(steam->hdev, "Steam %s '%s' disconnected", steam->quirks & STEAM_QUIRK_DECK ? "Deck" : "Controller", steam->serial_no); mutex_lock(&steam->registration_mutex); steam->registered = false; steam_battery_unregister(steam); steam_sensors_unregister(steam); steam_input_unregister(steam); mutex_unlock(&steam->registration_mutex); cancel_work_sync(&steam->rumble_work); cancel_delayed_work_sync(&steam->mode_switch); cancel_delayed_work_sync(&steam->coalesce_rumble_work); mutex_lock(&steam_devices_lock); list_del_init(&steam->list); mutex_unlock(&steam_devices_lock); } static void steam_work_connect_cb(struct work_struct *work) { struct steam_device *steam = container_of(work, struct steam_device, work_connect); unsigned long flags; bool connected; bool opened; int ret; spin_lock_irqsave(&steam->lock, flags); opened = steam->client_opened; connected = steam->connected; spin_unlock_irqrestore(&steam->lock, flags); if (connected && !opened) { ret = steam_register(steam); if (ret) hid_err(steam->hdev, "%s:steam_register failed with error %d\n", __func__, ret); } else { steam_unregister(steam); } } static void steam_mode_switch_cb(struct work_struct *work) { struct steam_device *steam = container_of(to_delayed_work(work), struct steam_device, mode_switch); unsigned long flags; bool client_opened; bool gamepad_mode; if (!lizard_mode) return; spin_lock_irqsave(&steam->lock, flags); steam->gamepad_mode = !steam->gamepad_mode; gamepad_mode = steam->gamepad_mode; client_opened = steam->client_opened; spin_unlock_irqrestore(&steam->lock, flags); hid_dbg(steam->hdev, "%s: switching gamepad mode to %i\n", __func__, gamepad_mode); if (gamepad_mode) { guard(mutex)(&steam->report_mutex); steam_set_lizard_mode(steam, false); } else { struct input_dev *input; struct input_dev *sensors; if (!client_opened) { guard(mutex)(&steam->report_mutex); steam_set_lizard_mode(steam, lizard_mode); } /* * Zero out inputs so it doesn't look like we're holding * anything indefinitely. */ guard(spinlock_irqsave)(&steam->lock); rcu_read_lock(); input = rcu_dereference(steam->input); if (likely(input)) { input_report_key(input, BTN_TR2, 0); input_report_key(input, BTN_TL2, 0); input_report_key(input, BTN_TR, 0); input_report_key(input, BTN_TL, 0); input_report_key(input, BTN_Y, 0); input_report_key(input, BTN_B, 0); input_report_key(input, BTN_X, 0); input_report_key(input, BTN_A, 0); input_report_key(input, BTN_DPAD_UP, 0); input_report_key(input, BTN_DPAD_RIGHT, 0); input_report_key(input, BTN_DPAD_LEFT, 0); input_report_key(input, BTN_DPAD_DOWN, 0); input_report_key(input, BTN_SELECT, 0); input_report_key(input, BTN_MODE, 0); input_report_key(input, BTN_START, 0); input_report_key(input, BTN_THUMBR, 0); input_report_key(input, BTN_THUMBL, 0); input_report_key(input, BTN_THUMB, 0); input_report_key(input, BTN_THUMB2, 0); input_report_key(input, BTN_GRIPL, 0); input_report_key(input, BTN_GRIPR, 0); input_report_abs(input, ABS_X, 0); input_report_abs(input, ABS_Y, 0); input_report_abs(input, ABS_RX, 0); input_report_abs(input, ABS_RY, 0); input_report_abs(input, ABS_HAT0X, 0); input_report_abs(input, ABS_HAT0Y, 0); input_report_abs(input, ABS_HAT2Y, 0); input_report_abs(input, ABS_HAT2X, 0); if (steam->quirks & (STEAM_QUIRK_DECK | STEAM_QUIRK_IBEX)) { input_report_key(input, BTN_BASE, 0); input_report_key(input, BTN_GRIPL2, 0); input_report_key(input, BTN_GRIPR2, 0); input_report_abs(input, ABS_HAT1X, 0); input_report_abs(input, ABS_HAT1Y, 0); } input_sync(input); } sensors = rcu_dereference(steam->sensors); if (likely(sensors)) { /* Skip accelerometers since 0 isn't a neutral input */ input_report_abs(sensors, ABS_RX, 0); input_report_abs(sensors, ABS_RY, 0); input_report_abs(sensors, ABS_RZ, 0); input_sync(sensors); } rcu_read_unlock(); } guard(mutex)(&steam->report_mutex); steam_haptic_pulse(steam, STEAM_PAD_RIGHT, 0x190, 0, 1, 0); if (gamepad_mode) { steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x14D, 0x14D, 0x2D, 0); } else { steam_haptic_pulse(steam, STEAM_PAD_LEFT, 0x1F4, 0x1F4, 0x1E, 0); } } static bool steam_is_valve_interface(struct hid_device *hdev, int quirks) { struct hid_report_enum *rep_enum; /* * The 2015 wired controller creates 3 interfaces: * 0: emulated mouse. * 1: emulated keyboard. * 2: the real game pad. * The 2015 wireless adapter creates 5 interfaces: * 0: emulated keyboard. * 1-4: slots where up to 4 real controllers will be connected to. * The Steam Deck creates 5 interfaces: * 0: emulated mouse. * 1: emulated keyboard. * 2: the real game pad. * 3-4: internal device comms (not HID). * The 2026 wired controller creates 1 unified interface. * The 2026 wireless puck creates 7 interfaces: * 0-1: internal device comms (not HID). * 2-5: slots where up to 4 real controllers will be connected to. * 6: basic pogo pin interface. * * We know which one is the real controller interface for the pre-2026 * controllers because they are the only ones with a feature report. * * The puck's pogo pin interface should be ignored as it's stripped * down. It has one collection with usage page FF00 with usage ID 2. */ if (quirks & STEAM_QUIRK_IBEX) { /* There is only one BLE HID interface */ if (quirks & STEAM_QUIRK_BLE) return true; if (hdev->maxcollection < 1) return true; return hdev->collection[0].usage != 0xFF000002; } rep_enum = &hdev->report_enum[HID_FEATURE_REPORT]; return !list_empty(&rep_enum->report_list); } static int steam_client_ll_parse(struct hid_device *hdev) { struct steam_device *steam = hdev->driver_data; return hid_parse_report(hdev, steam->hdev->dev_rdesc, steam->hdev->dev_rsize); } static int steam_client_ll_start(struct hid_device *hdev) { return 0; } static void steam_client_ll_stop(struct hid_device *hdev) { } static int steam_client_ll_open(struct hid_device *hdev) { struct steam_device *steam = hdev->driver_data; unsigned long flags; spin_lock_irqsave(&steam->lock, flags); steam->client_opened++; spin_unlock_irqrestore(&steam->lock, flags); schedule_work(&steam->work_connect); return 0; } static void steam_client_ll_close(struct hid_device *hdev) { struct steam_device *steam = hdev->driver_data; unsigned long flags; spin_lock_irqsave(&steam->lock, flags); steam->client_opened--; spin_unlock_irqrestore(&steam->lock, flags); schedule_work(&steam->work_connect); } static int steam_client_ll_raw_request(struct hid_device *hdev, unsigned char reportnum, u8 *buf, size_t count, unsigned char report_type, int reqtype) { struct steam_device *steam = hdev->driver_data; return hid_hw_raw_request(steam->hdev, reportnum, buf, count, report_type, reqtype); } static int steam_client_ll_output_report(struct hid_device *hdev, u8 *buf, size_t count) { struct steam_device *steam = hdev->driver_data; return hid_hw_output_report(steam->hdev, buf, count); } static const struct hid_ll_driver steam_client_ll_driver = { .parse = steam_client_ll_parse, .start = steam_client_ll_start, .stop = steam_client_ll_stop, .open = steam_client_ll_open, .close = steam_client_ll_close, .raw_request = steam_client_ll_raw_request, .output_report = steam_client_ll_output_report, }; static struct hid_device *steam_create_client_hid(struct hid_device *hdev) { struct hid_device *client_hdev; client_hdev = hid_allocate_device(); if (IS_ERR(client_hdev)) return client_hdev; client_hdev->ll_driver = &steam_client_ll_driver; client_hdev->dev.parent = hdev->dev.parent; client_hdev->bus = hdev->bus; client_hdev->vendor = hdev->vendor; client_hdev->product = hdev->product; client_hdev->version = hdev->version; client_hdev->type = hdev->type; client_hdev->country = hdev->country; strscpy(client_hdev->name, hdev->name, sizeof(client_hdev->name)); strscpy(client_hdev->phys, hdev->phys, sizeof(client_hdev->phys)); /* * Since we use the same device info than the real interface to * trick userspace, we will be calling steam_probe recursively. * We need to recognize the client interface somehow. */ client_hdev->group = HID_GROUP_STEAM; return client_hdev; } static int steam_probe(struct hid_device *hdev, const struct hid_device_id *id) { struct steam_device *steam; int ret; ret = hid_parse(hdev); if (ret) { hid_err(hdev, "%s:parse of hid interface failed\n", __func__); return ret; } /* * The virtual client_dev is only used for hidraw. * Also avoid the recursive probe. */ if (hdev->group == HID_GROUP_STEAM) return hid_hw_start(hdev, HID_CONNECT_HIDRAW); /* * The non-valve interfaces (mouse and keyboard emulation) are * connected without changes. */ if (!steam_is_valve_interface(hdev, id->driver_data)) return hid_hw_start(hdev, HID_CONNECT_DEFAULT); steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL); if (!steam) return -ENOMEM; steam->hdev = hdev; hid_set_drvdata(hdev, steam); spin_lock_init(&steam->lock); mutex_init(&steam->report_mutex); mutex_init(&steam->registration_mutex); steam->quirks = id->driver_data; INIT_WORK(&steam->work_connect, steam_work_connect_cb); INIT_DELAYED_WORK(&steam->mode_switch, steam_mode_switch_cb); INIT_LIST_HEAD(&steam->list); INIT_WORK(&steam->rumble_work, steam_haptic_rumble_cb); INIT_DELAYED_WORK(&steam->coalesce_rumble_work, steam_coalesce_rumble_cb); steam->sensor_timestamp_us = 0; if (steam->quirks & STEAM_QUIRK_DECK) steam->sensor_update_rate_us = 4000; else steam->sensor_update_rate_us = 9000; /* * With the real steam controller interface, do not connect hidraw. * Instead, create the client_hid and connect that. */ ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW); if (ret) goto err_cancel_work; ret = hid_hw_open(hdev); if (ret) { hid_err(hdev, "%s:hid_hw_open\n", __func__); goto err_hw_stop; } steam->connected = true; if (steam->quirks & STEAM_QUIRK_WIRELESS) { hid_info(hdev, "Steam wireless receiver connected"); /* If using a wireless adaptor ask for connection status */ steam->connected = false; ret = steam_get_conn_status(steam); if (ret < 0) hid_err(hdev, "%s:steam_get_conn_status failed with error %d\n", __func__, ret); else if (ret == WIRELESS_EVENT_CONNECT) steam->connected = true; } if (steam->connected) { ret = steam_register(steam); if (ret) { hid_err(hdev, "%s:steam_register failed with error %d\n", __func__, ret); goto err_hw_close; } } steam->client_hdev = steam_create_client_hid(hdev); if (IS_ERR(steam->client_hdev)) { ret = PTR_ERR(steam->client_hdev); goto err_steam_unregister; } steam->client_hdev->driver_data = steam; ret = hid_add_device(steam->client_hdev); if (ret) goto err_destroy; return 0; err_destroy: hid_destroy_device(steam->client_hdev); err_steam_unregister: if (steam->connected) steam_unregister(steam); err_hw_close: hid_hw_close(hdev); err_hw_stop: hid_hw_stop(hdev); err_cancel_work: cancel_work_sync(&steam->work_connect); cancel_delayed_work_sync(&steam->mode_switch); cancel_work_sync(&steam->rumble_work); cancel_delayed_work_sync(&steam->coalesce_rumble_work); return ret; } static void steam_remove(struct hid_device *hdev) { struct steam_device *steam = hid_get_drvdata(hdev); unsigned long flags; if (!steam || hdev->group == HID_GROUP_STEAM) { hid_hw_stop(hdev); return; } hid_hw_close(hdev); hid_destroy_device(steam->client_hdev); spin_lock_irqsave(&steam->lock, flags); steam->client_opened = 0; spin_unlock_irqrestore(&steam->lock, flags); cancel_work_sync(&steam->work_connect); if (steam->quirks & STEAM_QUIRK_WIRELESS) { hid_info(hdev, "Steam wireless receiver disconnected"); } steam_unregister(steam); hid_hw_stop(hdev); } static void steam_do_connect_event(struct steam_device *steam, bool connected) { bool changed; changed = steam->connected != connected; steam->connected = connected; if (changed && schedule_work(&steam->work_connect) == 0) dbg_hid("%s: connected=%d event already queued\n", __func__, connected); } /* * Some input data in the protocol has the opposite sign. * Clamp the values to 32767..-32767 so that the range is * symmetrical and can be negated safely. */ static inline s16 steam_le16(const u8 *data) { s16 x = (s16) get_unaligned_le16((const __le16 *)data); return x == -32768 ? -32767 : x; } struct steam_button_mapping { int code; u8 byte; u8 bit; }; struct steam_axis_mapping { int code; s8 sign; u8 byte; }; static void steam_map_buttons(struct input_dev *input, const struct steam_button_mapping *mappings, const u8 *data) { const struct steam_button_mapping *mapping; for (mapping = mappings; mapping->code; mapping++) input_report_key(input, mapping->code, data[mapping->byte] & BIT(mapping->bit)); } static void steam_map_axes(struct input_dev *input, const struct steam_axis_mapping *mappings, const u8 *data) { const struct steam_axis_mapping *mapping; for (mapping = mappings; mapping->sign; mapping++) input_report_abs(input, mapping->code, mapping->sign * steam_le16(&data[mapping->byte])); } /* * The size for this message payload is 60. * The known values are: * (* values are not sent through wireless) * (* accelerator/gyro is disabled by default) * Offset| Type | Mapped to |Meaning * -------+-------+-----------+-------------------------- * 4-7 | u32 | -- | sequence number * 8-10 | 24bit | see below | buttons * 11 | u8 | ABS_HAT2Y | left trigger * 12 | u8 | ABS_HAT2X | right trigger * 13-15 | -- | -- | always 0 * 16-17 | s16 | ABS_X/ABS_HAT0X | X value * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value * 20-21 | s16 | ABS_RX | right-pad X value * 22-23 | s16 | ABS_RY | right-pad Y value * 24-25 | s16 | -- | * left trigger * 26-27 | s16 | -- | * right trigger * 28-29 | s16 | -- | * accelerometer X value * 30-31 | s16 | -- | * accelerometer Y value * 32-33 | s16 | -- | * accelerometer Z value * 34-35 | s16 | -- | gyro X value * 36-36 | s16 | -- | gyro Y value * 38-39 | s16 | -- | gyro Z value * 40-41 | s16 | -- | quaternion W value * 42-43 | s16 | -- | quaternion X value * 44-45 | s16 | -- | quaternion Y value * 46-47 | s16 | -- | quaternion Z value * 48-49 | -- | -- | always 0 * 50-51 | s16 | -- | * left trigger (uncalibrated) * 52-53 | s16 | -- | * right trigger (uncalibrated) * 54-55 | s16 | -- | * joystick X value (uncalibrated) * 56-57 | s16 | -- | * joystick Y value (uncalibrated) * 58-59 | s16 | -- | * left-pad X value * 60-61 | s16 | -- | * left-pad Y value * 62-63 | u16 | -- | * battery voltage * * The buttons are: * Bit | Mapped to | Description * ------+------------+-------------------------------- * 8.0 | BTN_TR2 | right trigger fully pressed * 8.1 | BTN_TL2 | left trigger fully pressed * 8.2 | BTN_TR | right shoulder * 8.3 | BTN_TL | left shoulder * 8.4 | BTN_Y | button Y * 8.5 | BTN_B | button B * 8.6 | BTN_X | button X * 8.7 | BTN_A | button A * 9.0 | BTN_DPAD_UP | left-pad up * 9.1 | BTN_DPAD_RIGHT | left-pad right * 9.2 | BTN_DPAD_LEFT | left-pad left * 9.3 | BTN_DPAD_DOWN | left-pad down * 9.4 | BTN_SELECT | view * 9.5 | BTN_MODE | steam logo * 9.6 | BTN_START | menu * 9.7 | BTN_GRIPL | left back lever * 10.0 | BTN_GRIPR | right back lever * 10.1 | -- | left-pad clicked * 10.2 | BTN_THUMBR | right-pad clicked * 10.3 | BTN_THUMB | left-pad touched (but see explanation below) * 10.4 | BTN_THUMB2 | right-pad touched * 10.5 | -- | unknown * 10.6 | BTN_THUMBL | joystick clicked * 10.7 | -- | lpad_and_joy */ static const struct steam_button_mapping steam_controller_button_mappings[] = { { BTN_TR2, 8, 0 }, { BTN_TL2, 8, 1 }, { BTN_TR, 8, 2 }, { BTN_TL, 8, 3 }, { BTN_Y, 8, 4 }, { BTN_B, 8, 5 }, { BTN_X, 8, 6 }, { BTN_A, 8, 7 }, { BTN_SELECT, 9, 4 }, { BTN_MODE, 9, 5 }, { BTN_START, 9, 6 }, { BTN_GRIPL, 9, 7 }, { BTN_GRIPR, 10, 0 }, { BTN_THUMBR, 10, 2 }, { BTN_THUMBL, 10, 6 }, { BTN_THUMB2, 10, 4 }, { BTN_DPAD_UP, 9, 0 }, { BTN_DPAD_RIGHT, 9, 1 }, { BTN_DPAD_LEFT, 9, 2 }, { BTN_DPAD_DOWN, 9, 3 }, { /* sentinel */ }, }; static const struct steam_axis_mapping steam_controller_axis_mappings[] = { { ABS_RX, 1, 20 }, { ABS_RY, -1, 22 }, { /* sentinel */ }, }; static const struct steam_axis_mapping steam_controller_imu_mappings[] = { { ABS_X, 1, 28 }, { ABS_Z, -1, 30 }, { ABS_Y, 1, 32 }, { ABS_RX, 1, 34 }, { ABS_RZ, 1, 36 }, { ABS_RY, 1, 38 }, { /* sentinel */ }, }; static void steam_do_input_event(struct steam_device *steam, struct input_dev *input, u8 *data) { s16 x, y; bool lpad_touched, lpad_and_joy; input_report_abs(input, ABS_HAT2Y, data[11]); input_report_abs(input, ABS_HAT2X, data[12]); /* * These two bits tells how to interpret the values X and Y. * lpad_and_joy tells that the joystick and the lpad are used at the * same time. * lpad_touched tells whether X/Y are to be read as lpad coord or * joystick values. * (lpad_touched || lpad_and_joy) tells if the lpad is really touched. */ lpad_touched = data[10] & BIT(3); lpad_and_joy = data[10] & BIT(7); x = steam_le16(data + 16); y = -steam_le16(data + 18); input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x); input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y); /* Check if joystick is centered */ if (lpad_touched && !lpad_and_joy) { input_report_abs(input, ABS_X, 0); input_report_abs(input, ABS_Y, 0); } /* Check if lpad is untouched */ if (!(lpad_touched || lpad_and_joy)) { input_report_abs(input, ABS_HAT0X, 0); input_report_abs(input, ABS_HAT0Y, 0); } input_report_key(input, BTN_THUMB, lpad_touched || lpad_and_joy); steam_map_buttons(input, steam_controller_button_mappings, data); steam_map_axes(input, steam_controller_axis_mappings, data); input_sync(input); } static void steam_do_sensors_event(struct steam_device *steam, struct input_dev *sensors, u8 *data) { steam->sensor_timestamp_us += steam->sensor_update_rate_us; input_event(sensors, EV_MSC, MSC_TIMESTAMP, steam->sensor_timestamp_us); steam_map_axes(sensors, steam_controller_imu_mappings, data); input_sync(sensors); } /* * The size for this message payload is 56. * The known values are: * Offset| Type | Mapped to |Meaning * -------+-------+-----------+-------------------------- * 4-7 | u32 | -- | sequence number * 8-15 | u64 | see below | buttons * 16-17 | s16 | ABS_HAT0X | left-pad X value * 18-19 | s16 | ABS_HAT0Y | left-pad Y value * 20-21 | s16 | ABS_HAT1X | right-pad X value * 22-23 | s16 | ABS_HAT1Y | right-pad Y value * 24-25 | s16 | IMU ABS_X | accelerometer X value * 26-27 | s16 | IMU ABS_Z | accelerometer Y value * 28-29 | s16 | IMU ABS_Y | accelerometer Z value * 30-31 | s16 | IMU ABS_RX | gyro X value * 32-33 | s16 | IMU ABS_RZ | gyro Y value * 34-35 | s16 | IMU ABS_RY | gyro Z value * 36-37 | s16 | -- | quaternion W value * 38-39 | s16 | -- | quaternion X value * 40-41 | s16 | -- | quaternion Y value * 42-43 | s16 | -- | quaternion Z value * 44-45 | u16 | ABS_HAT2Y | left trigger (uncalibrated) * 46-47 | u16 | ABS_HAT2X | right trigger (uncalibrated) * 48-49 | s16 | ABS_X | left joystick X * 50-51 | s16 | ABS_Y | left joystick Y * 52-53 | s16 | ABS_RX | right joystick X * 54-55 | s16 | ABS_RY | right joystick Y * 56-57 | u16 | -- | left pad pressure * 58-59 | u16 | -- | right pad pressure * * The buttons are: * Bit | Mapped to | Description * ------+------------+-------------------------------- * 8.0 | BTN_TR2 | right trigger fully pressed * 8.1 | BTN_TL2 | left trigger fully pressed * 8.2 | BTN_TR | right shoulder * 8.3 | BTN_TL | left shoulder * 8.4 | BTN_Y | button Y * 8.5 | BTN_B | button B * 8.6 | BTN_X | button X * 8.7 | BTN_A | button A * 9.0 | BTN_DPAD_UP | left-pad up * 9.1 | BTN_DPAD_RIGHT | left-pad right * 9.2 | BTN_DPAD_LEFT | left-pad left * 9.3 | BTN_DPAD_DOWN | left-pad down * 9.4 | BTN_SELECT | view * 9.5 | BTN_MODE | steam logo * 9.6 | BTN_START | menu * 9.7 | BTN_GRIPL2 | left bottom grip button * 10.0 | BTN_GRIPR2 | right bottom grip button * 10.1 | BTN_THUMB | left pad pressed * 10.2 | BTN_THUMB2 | right pad pressed * 10.3 | -- | left pad touched * 10.4 | -- | right pad touched * 10.5 | -- | unknown * 10.6 | BTN_THUMBL | left joystick clicked * 10.7 | -- | unknown * 11.0 | -- | unknown * 11.1 | -- | unknown * 11.2 | BTN_THUMBR | right joystick clicked * 11.3 | -- | unknown * 11.4 | -- | unknown * 11.5 | -- | unknown * 11.6 | -- | unknown * 11.7 | -- | unknown * 12.0 | -- | unknown * 12.1 | -- | unknown * 12.2 | -- | unknown * 12.3 | -- | unknown * 12.4 | -- | unknown * 12.5 | -- | unknown * 12.6 | -- | unknown * 12.7 | -- | unknown * 13.0 | -- | unknown * 13.1 | BTN_GRIPL | left top grip button * 13.2 | BTN_GRIPR | right top grip button * 13.3 | -- | unknown * 13.4 | -- | unknown * 13.5 | -- | unknown * 13.6 | -- | left joystick touched * 13.7 | -- | right joystick touched * 14.0 | -- | unknown * 14.1 | -- | unknown * 14.2 | BTN_BASE | quick access button * 14.3 | -- | unknown * 14.4 | -- | unknown * 14.5 | -- | unknown * 14.6 | -- | unknown * 14.7 | -- | unknown * 15.0 | -- | unknown * 15.1 | -- | unknown * 15.2 | -- | unknown * 15.3 | -- | unknown * 15.4 | -- | unknown * 15.5 | -- | unknown * 15.6 | -- | unknown * 15.7 | -- | unknown */ static const struct steam_button_mapping steam_deck_button_mappings[] = { { BTN_TR2, 8, 0 }, { BTN_TL2, 8, 1 }, { BTN_TR, 8, 2 }, { BTN_TL, 8, 3 }, { BTN_Y, 8, 4 }, { BTN_B, 8, 5 }, { BTN_X, 8, 6 }, { BTN_A, 8, 7 }, { BTN_SELECT, 9, 4 }, { BTN_MODE, 9, 5 }, { BTN_START, 9, 6 }, { BTN_GRIPL2, 9, 7 }, { BTN_GRIPR2, 10, 0 }, { BTN_THUMBL, 10, 6 }, { BTN_THUMBR, 11, 2 }, { BTN_DPAD_UP, 9, 0 }, { BTN_DPAD_RIGHT, 9, 1 }, { BTN_DPAD_LEFT, 9, 2 }, { BTN_DPAD_DOWN, 9, 3 }, { BTN_THUMB, 10, 1 }, { BTN_THUMB2, 10, 2 }, { BTN_GRIPL, 13, 1 }, { BTN_GRIPR, 13, 2 }, { BTN_BASE, 14, 2 }, { /* sentinel */ }, }; static const struct steam_axis_mapping steam_deck_axis_mappings[] = { { ABS_X, 1, 48 }, { ABS_Y, -1, 50 }, { ABS_RX, 1, 52 }, { ABS_RY, -1, 54 }, { ABS_HAT2Y, 1, 44 }, { ABS_HAT2X, 1, 46 }, { /* sentinel */ }, }; static const struct steam_axis_mapping steam_deck_imu_mappings[] = { { ABS_X, 1, 24 }, { ABS_Z, -1, 26 }, { ABS_Y, 1, 28 }, { ABS_RX, 1, 30 }, { ABS_RZ, -1, 32 }, { ABS_RY, 1, 34 }, { /* sentinel */ }, }; static void steam_do_deck_input_event(struct steam_device *steam, struct input_dev *input, u8 *data) { bool start_pressed; bool lpad_touched, rpad_touched; start_pressed = data[9] & BIT(6); if (!start_pressed && steam->did_mode_switch) { steam->did_mode_switch = false; cancel_delayed_work(&steam->mode_switch); } else if (!steam->client_opened && start_pressed && !steam->did_mode_switch) { hid_dbg(steam->hdev, "%s: doing mode switch\n", __func__); steam->did_mode_switch = true; schedule_delayed_work(&steam->mode_switch, 45 * HZ / 100); } if (!steam->gamepad_mode && lizard_mode) return; lpad_touched = data[10] & BIT(3); rpad_touched = data[10] & BIT(4); if (lpad_touched) { input_report_abs(input, ABS_HAT0X, steam_le16(data + 16)); input_report_abs(input, ABS_HAT0Y, steam_le16(data + 18)); } else { input_report_abs(input, ABS_HAT0X, 0); input_report_abs(input, ABS_HAT0Y, 0); } if (rpad_touched) { input_report_abs(input, ABS_HAT1X, steam_le16(data + 20)); input_report_abs(input, ABS_HAT1Y, steam_le16(data + 22)); } else { input_report_abs(input, ABS_HAT1X, 0); input_report_abs(input, ABS_HAT1Y, 0); } steam_map_buttons(input, steam_deck_button_mappings, data); steam_map_axes(input, steam_deck_axis_mappings, data); input_sync(input); } static void steam_do_deck_sensors_event(struct steam_device *steam, struct input_dev *sensors, u8 *data) { steam->sensor_timestamp_us += steam->sensor_update_rate_us; if (!steam->gamepad_mode && lizard_mode) return; input_event(sensors, EV_MSC, MSC_TIMESTAMP, steam->sensor_timestamp_us); steam_map_axes(sensors, steam_deck_imu_mappings, data); input_sync(sensors); } /* * The size for this message payload is 11. * The known values are: * Offset| Type | Meaning * -------+-------+--------------------------- * 4-7 | u32 | sequence number * 8-11 | -- | always 0 * 12-13 | u16 | voltage (mV) * 14 | u8 | battery percent */ static void steam_do_battery_event(struct steam_device *steam, struct power_supply *battery, u8 *data) { s16 volts = steam_le16(data + 12); u8 batt = data[14]; /* Creating the battery may have failed */ rcu_read_lock(); battery = rcu_dereference(steam->battery); if (likely(battery)) { steam->battery_voltage = volts; steam->battery_charge = batt; power_supply_changed(battery); } rcu_read_unlock(); } /* * The size for this message payload is 53 in REPORT_ID_INPUT and 45 in REPORT_ID_INPUT2. * The values are: * (* values only in REPORT_ID_INPUT) * Offset| Type | Mapped to |Meaning * -------+-------+-----------+-------------------------- * 1 | u8 | -- | sequence number * 2-5 | u32 | see below | buttons * 6-7 | s16 | ABS_HAT2Y | left trigger (uncalibrated) * 8-9 | s16 | ABS_HAT2X | right trigger (uncalibrated) * 10-11 | s16 | ABS_X | left joystick X * 12-13 | s16 | ABS_Y | left joystick Y * 14-15 | s16 | ABS_RX | right joystick X * 16-17 | s16 | ABS_RY | right joystick Y * 18-19 | s16 | ABS_HAT0X | left-pad X value * 20-21 | s16 | ABS_HAT0Y | left-pad Y value * 22-23 | u16 | -- | left pad pressure * 24-25 | s16 | ABS_HAT1X | right-pad X value * 26-27 | s16 | ABS_HAT1Y | right-pad Y value * 28-29 | u16 | -- | right pad pressure * 30-33 | u32 | IMU MSC_TIMESTAMP | IMU timestamp * 34-35 | s16 | IMU ABS_X | accelerometer X value * 36-37 | s16 | IMU ABS_Z | accelerometer Y value * 38-39 | s16 | IMU ABS_Y | accelerometer Z value * 40-41 | s16 | IMU ABS_RX | gyro X value * 42-43 | s16 | IMU ABS_RZ | gyro Y value * 44-45 | s16 | IMU ABS_RY | gyro Z value * 46-47 | s16 | -- | * quaternion W value * 48-49 | s16 | -- | * quaternion X value * 50-51 | s16 | -- | * quaternion Y value * 52-53 | s16 | -- | * quaternion Z value * * The buttons are: * Bit | Mapped to | Description * ------+------------+-------------------------------- * 2.0 | BTN_A | button A * 2.1 | BTN_B | button B * 2.2 | BTN_X | button X * 2.3 | BTN_Y | button Y * 2.4 | BTN_BASE | quick access button * 2.5 | BTN_THUMBR | right joystick clicked * 2.6 | BTN_START | menu * 2.7 | BTN_GRIPR | right top grip button * 3.0 | BTN_GRIPR2 | right bottom grip button * 3.1 | BTN_TR | right shoulder * 3.2 | BTN_DPAD_DOWN | left-pad down * 3.3 | BTN_DPAD_RIGHT | left-pad right * 3.4 | BTN_DPAD_LEFT | left-pad left * 3.5 | BTN_DPAD_UP | left-pad up * 3.6 | BTN_SELECT | view * 3.7 | BTN_THUMBL | left joystick clicked * 4.0 | BTN_MODE | steam logo * 4.1 | BTN_GRIPL | left top grip button * 4.2 | BTN_GRIPL2 | left bottom grip button * 4.3 | BTN_TL | left shoulder * 4.4 | -- | right joystick touched * 4.5 | -- | right pad touched * 4.6 | BTN_THUMB2 | right pad pressed * 4.7 | BTN_TR2 | right trigger fully pressed * 5.0 | -- | left joystick touched * 5.1 | -- | left pad touched * 5.2 | BTN_THUMB | left pad pressed * 5.3 | BTN_TL2 | left trigger fully pressed * 5.4 | -- | right grip touch * 5.5 | -- | left grip touch * 5.6 | -- | unmapped * 5.7 | -- | unmapped */ static const struct steam_button_mapping steam_ibex_button_mappings[] = { { BTN_A, 2, 0 }, { BTN_B, 2, 1 }, { BTN_X, 2, 2 }, { BTN_Y, 2, 3 }, { BTN_BASE, 2, 4 }, { BTN_THUMBR, 2, 5 }, { BTN_START, 2, 6 }, { BTN_GRIPR, 2, 7 }, { BTN_GRIPR2, 3, 0 }, { BTN_TR, 3, 1 }, { BTN_DPAD_DOWN, 3, 2 }, { BTN_DPAD_RIGHT, 3, 3 }, { BTN_DPAD_LEFT, 3, 4 }, { BTN_DPAD_UP, 3, 5 }, { BTN_SELECT, 3, 6 }, { BTN_THUMBL, 3, 7 }, { BTN_MODE, 4, 0 }, { BTN_GRIPL, 4, 1 }, { BTN_GRIPL2, 4, 2 }, { BTN_TL, 4, 3 }, { BTN_THUMB2, 4, 6 }, { BTN_TR2, 4, 7 }, { BTN_THUMB, 5, 2 }, { BTN_TL2, 5, 3 }, { /* sentinel */ }, }; static const struct steam_axis_mapping steam_ibex_axis_mappings[] = { { ABS_X, 1, 10 }, { ABS_Y, -1, 12 }, { ABS_RX, 1, 14 }, { ABS_RY, -1, 16 }, { ABS_HAT2Y, 1, 6 }, { ABS_HAT2X, 1, 8 }, { /* sentinel */ }, }; static const struct steam_axis_mapping steam_ibex_imu_mappings[] = { { ABS_X, 1, 34 }, { ABS_Z, -1, 36 }, { ABS_Y, 1, 38 }, { ABS_RX, 1, 40 }, { ABS_RZ, -1, 42 }, { ABS_RY, 1, 44 }, { /* sentinel */ }, }; static void steam_do_ibex_input_event(struct steam_device *steam, struct input_dev *input, const u8 *data) { bool start_pressed; bool lpad_touched, rpad_touched; start_pressed = data[2] & BIT(6); if (!start_pressed && steam->did_mode_switch) { steam->did_mode_switch = false; cancel_delayed_work(&steam->mode_switch); } else if (!steam->client_opened && start_pressed && !steam->did_mode_switch) { steam->did_mode_switch = true; schedule_delayed_work(&steam->mode_switch, 45 * HZ / 100); } if (!steam->gamepad_mode && lizard_mode) return; lpad_touched = data[5] & BIT(1); rpad_touched = data[4] & BIT(5); if (lpad_touched) { input_report_abs(input, ABS_HAT0X, steam_le16(data + 18)); input_report_abs(input, ABS_HAT0Y, steam_le16(data + 20)); } else { input_report_abs(input, ABS_HAT0X, 0); input_report_abs(input, ABS_HAT0Y, 0); } if (rpad_touched) { input_report_abs(input, ABS_HAT1X, steam_le16(data + 24)); input_report_abs(input, ABS_HAT1Y, steam_le16(data + 26)); } else { input_report_abs(input, ABS_HAT1X, 0); input_report_abs(input, ABS_HAT1Y, 0); } steam_map_buttons(input, steam_ibex_button_mappings, data); steam_map_axes(input, steam_ibex_axis_mappings, data); input_sync(input); } static void steam_do_ibex_sensors_event(struct steam_device *steam, struct input_dev *sensors, const u8 *data) { u32 timestamp; if (!steam->gamepad_mode && lizard_mode) return; timestamp = (u32) get_unaligned_le32((__le32 *)&data[30]); input_event(sensors, EV_MSC, MSC_TIMESTAMP, timestamp); steam_map_axes(sensors, steam_ibex_imu_mappings, data); input_sync(sensors); } static void steam_do_ibex_battery_event(struct steam_device *steam, struct power_supply *battery, const struct steam_ibex_battery_status *data) { /* Creating the battery may have failed */ guard(rcu)(); battery = rcu_dereference(steam->battery); if (!likely(battery)) return; steam->battery_voltage = get_unaligned_le16(&data->battery_voltage); steam->battery_current = get_unaligned_le16(&data->battery_current); steam->battery_temp = get_unaligned_le16(&data->temperature); steam->battery_charge = data->battery_level; switch (data->charge_state) { case CHARGE_STATE_CHARGING: steam->battery_status = POWER_SUPPLY_STATUS_CHARGING; break; case CHARGE_STATE_DISCHARGING: steam->battery_status = POWER_SUPPLY_STATUS_DISCHARGING; break; case CHARGE_STATE_CHARGING_DONE: steam->battery_status = POWER_SUPPLY_STATUS_FULL; break; default: steam->battery_status = POWER_SUPPLY_STATUS_UNKNOWN; break; } power_supply_changed(battery); } static int steam_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) { struct steam_device *steam = hid_get_drvdata(hdev); struct input_dev *input; struct input_dev *sensors; struct power_supply *battery; if (!steam) return 0; guard(spinlock_irqsave)(&steam->lock); if (steam->client_opened) hid_input_report(steam->client_hdev, report->type, data, size, 0); /* Ibex uses a different report format */ if (steam->quirks & STEAM_QUIRK_IBEX) { if (report->type != HID_INPUT_REPORT) return 0; switch (report->id) { case REPORT_ID_INPUT: if (size != 54) return 0; if (steam->client_opened) return 0; rcu_read_lock(); input = rcu_dereference(steam->input); if (likely(input)) { steam_do_ibex_input_event(steam, input, data); } else { dbg_hid("%s: input data without connect event\n", __func__); steam_do_connect_event(steam, true); } sensors = rcu_dereference(steam->sensors); if (likely(sensors)) steam_do_ibex_sensors_event(steam, sensors, data); rcu_read_unlock(); break; case REPORT_ID_INPUT2: if (size != 46) return 0; if (steam->client_opened) return 0; rcu_read_lock(); input = rcu_dereference(steam->input); if (likely(input)) { steam_do_ibex_input_event(steam, input, data); } else { dbg_hid("%s: input data without connect event\n", __func__); steam_do_connect_event(steam, true); } sensors = rcu_dereference(steam->sensors); if (likely(sensors)) steam_do_ibex_sensors_event(steam, sensors, data); rcu_read_unlock(); break; case REPORT_ID_BATTERY: if (size != 15) return 0; rcu_read_lock(); battery = rcu_dereference(steam->battery); if (likely(battery)) { steam_do_ibex_battery_event(steam, battery, (const struct steam_ibex_battery_status *)&data[1]); } else { dbg_hid("%s: battery data without connect event\n", __func__); steam_do_connect_event(steam, true); } rcu_read_unlock(); break; case REPORT_ID_WIRELESS_EVENT: if (size != 2) return 0; switch (data[1]) { case WIRELESS_EVENT_DISCONNECT: steam_do_connect_event(steam, false); break; case WIRELESS_EVENT_CONNECT: steam_do_connect_event(steam, true); break; } break; } return 0; } /* * All messages are size=64, all values little-endian. * The format is: * Offset| Meaning * -------+-------------------------------------------- * 0-1 | always 0x01, 0x00, maybe protocol version? * 2 | type of message * 3 | length of the real payload (not checked) * 4-n | payload data, depends on the type * * There are these known types of message: * 0x01: input data (60 bytes) * 0x03: wireless connect/disconnect (1 byte) * 0x04: battery status (11 bytes) * 0x09: Steam Deck input data (56 bytes) */ if (size != 64 || data[0] != 1 || data[1] != 0) return 0; switch (data[2]) { case ID_CONTROLLER_STATE: if (steam->client_opened) return 0; rcu_read_lock(); input = rcu_dereference(steam->input); if (likely(input)) steam_do_input_event(steam, input, data); sensors = rcu_dereference(steam->sensors); if (likely(sensors)) steam_do_sensors_event(steam, sensors, data); rcu_read_unlock(); break; case ID_CONTROLLER_DECK_STATE: if (steam->client_opened) return 0; rcu_read_lock(); input = rcu_dereference(steam->input); if (likely(input)) steam_do_deck_input_event(steam, input, data); sensors = rcu_dereference(steam->sensors); if (likely(sensors)) steam_do_deck_sensors_event(steam, sensors, data); rcu_read_unlock(); break; case ID_CONTROLLER_WIRELESS: /* * The payload of this event is a single byte: * 0x01: disconnected. * 0x02: connected. */ switch (data[4]) { case 0x01: steam_do_connect_event(steam, false); break; case 0x02: steam_do_connect_event(steam, true); break; } break; case ID_CONTROLLER_STATUS: if (steam->quirks & STEAM_QUIRK_WIRELESS) { rcu_read_lock(); battery = rcu_dereference(steam->battery); if (likely(battery)) { steam_do_battery_event(steam, battery, data); } else { dbg_hid( "%s: battery data without connect event\n", __func__); steam_do_connect_event(steam, true); } rcu_read_unlock(); } break; } return 0; } static int steam_param_set_lizard_mode(const char *val, const struct kernel_param *kp) { struct steam_device *steam; int ret; bool client_opened; unsigned long flags; ret = param_set_bool(val, kp); if (ret) return ret; mutex_lock(&steam_devices_lock); list_for_each_entry(steam, &steam_devices, list) { spin_lock_irqsave(&steam->lock, flags); client_opened = steam->client_opened; spin_unlock_irqrestore(&steam->lock, flags); if (!client_opened) { guard(mutex)(&steam->report_mutex); steam_set_lizard_mode(steam, lizard_mode); } } mutex_unlock(&steam_devices_lock); return 0; } static const struct kernel_param_ops steam_lizard_mode_ops = { .set = steam_param_set_lizard_mode, .get = param_get_bool, }; module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644); MODULE_PARM_DESC(lizard_mode, "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use"); static const struct hid_device_id steam_controllers[] = { { /* Wired Steam Controller (2015) */ HID_USB_DEVICE(USB_VENDOR_ID_VALVE, USB_DEVICE_ID_STEAM_CONTROLLER) }, { /* Wireless Steam Controller (2015) */ HID_USB_DEVICE(USB_VENDOR_ID_VALVE, USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS), .driver_data = STEAM_QUIRK_WIRELESS }, { /* Steam Deck */ HID_USB_DEVICE(USB_VENDOR_ID_VALVE, USB_DEVICE_ID_STEAM_DECK), .driver_data = STEAM_QUIRK_DECK }, { /* Steam Controller (2026) wired */ HID_USB_DEVICE(USB_VENDOR_ID_VALVE, USB_DEVICE_ID_STEAM_CONTROLLER_IBEX), .driver_data = STEAM_QUIRK_IBEX }, { /* Steam Controller (2026) BLE */ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_VALVE, USB_DEVICE_ID_STEAM_CONTROLLER_IBEX_BLE), .driver_data = STEAM_QUIRK_IBEX | STEAM_QUIRK_BLE }, { /* Steam Controller (2026) Puck */ HID_USB_DEVICE(USB_VENDOR_ID_VALVE, USB_DEVICE_ID_STEAM_CONTROLLER_PROTEUS), .driver_data = STEAM_QUIRK_IBEX | STEAM_QUIRK_WIRELESS }, { /* Steam Controller (2026) Steam Machine internal receiver */ HID_USB_DEVICE(USB_VENDOR_ID_VALVE, USB_DEVICE_ID_STEAM_CONTROLLER_NEREID), .driver_data = STEAM_QUIRK_IBEX | STEAM_QUIRK_WIRELESS }, {} }; MODULE_DEVICE_TABLE(hid, steam_controllers); static struct hid_driver steam_controller_driver = { .name = "hid-steam", .id_table = steam_controllers, .probe = steam_probe, .remove = steam_remove, .raw_event = steam_raw_event, }; module_hid_driver(steam_controller_driver);