hid-steam.c

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