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