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
48	MODULE_LICENSE("GPL");
49	MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>");
50
51	static bool lizard_mode = true;
52
53	static DEFINE_MUTEX(steam_devices_lock);
54	static 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	*/
76	enum {
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 */
132	enum {
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 */
235	enum
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 */
248	enum {
249	ATTRIB_STR_BOARD_SERIAL,
250	ATTRIB_STR_UNIT_SERIAL,
251	};
252
253	/* Values for GYRO_MODE (bitmask) */
254	enum {
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 */
264	enum {
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
284	struct 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
307	static 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(report: r) < 64)
321	return -EINVAL;
322
323	buf = hid_alloc_report_buf(report: 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(hdev: steam->hdev, reportnum: 0x00,
334	buf, len: hid_report_len(report: r) + 1,
335	rtype: HID_FEATURE_REPORT, reqtype: HID_REQ_GET_REPORT);
336	if (ret > 0)
337	memcpy(data, buf + 1, min(size, ret - 1));
338	kfree(objp: buf);
339	return ret;
340	}
341
342	static 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(report: r) < 64)
357	return -EINVAL;
358
359	buf = hid_alloc_report_buf(report: 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(hdev: steam->hdev, reportnum: 0,
374	buf, max(size, 64) + 1,
375	rtype: HID_FEATURE_REPORT, reqtype: HID_REQ_SET_REPORT);
376	if (ret != -EPIPE)
377	break;
378	msleep(msecs: 20);
379	} while (--retries);
380
381	kfree(objp: 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
388	static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd)
389	{
390	return steam_send_report(steam, cmd: &cmd, size: 1);
391	}
392
393	static 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, size: 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, data: cmd, size: 2 + cmd[1]);
426	}
427
428	static 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, size: sizeof(cmd));
440	if (ret < 0)
441	goto out;
442	ret = steam_recv_report(steam, data: reply, size: 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]);
452	out:
453	mutex_unlock(lock: &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	*/
462	static 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, cmd: ID_DONGLE_GET_WIRELESS_STATE);
467	mutex_unlock(lock: &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	*/
477	static 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, cmd: report, size: sizeof(report));
498	mutex_unlock(lock: &steam->report_mutex);
499	return ret;
500	}
501
502	static 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, cmd: report, size: sizeof(report));
520	mutex_unlock(lock: &steam->report_mutex);
521	return ret;
522	}
523
524	static 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, intensity: 0, left_speed: steam->rumble_left,
529	right_speed: steam->rumble_right, left_gain: 2, right_gain: 0);
530	}
531
532	#ifdef CONFIG_STEAM_FF
533	static 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(work: &steam->rumble_work);
542	}
543	#endif
544
545	static 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, cmd: ID_SET_DEFAULT_DIGITAL_MAPPINGS);
554	/* reset settings */
555	steam_send_report_byte(steam, cmd: ID_LOAD_DEFAULT_SETTINGS);
556	mutex_unlock(lock: &steam->report_mutex);
557	} else {
558	mutex_lock(&steam->report_mutex);
559	/* disable esc, enter, cursor */
560	steam_send_report_byte(steam, cmd: 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(lock: &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(lock: &steam->report_mutex);
577	}
578	}
579	}
580
581	static 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(lock: &steam->lock, flags);
596	if (set_lizard_mode)
597	steam_set_lizard_mode(steam, enable: false);
598	}
599
600	return 0;
601	}
602
603	static 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(lock: &steam->lock, flags);
613	if (set_lizard_mode)
614	steam_set_lizard_mode(steam, enable: true);
615	}
616	}
617
618	static 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
625	static 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(lock: &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
660	static 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(dev: &steam->hdev->dev,
672	GFP_KERNEL, fmt: "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(lock: &steam->lock, flags);
682
683	battery = power_supply_register(parent: &steam->hdev->dev,
684	desc: &steam->battery_desc, cfg: &battery_cfg);
685	if (IS_ERR(ptr: battery)) {
686	ret = PTR_ERR(ptr: 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(psy: battery, dev: &steam->hdev->dev);
694	return 0;
695	}
696
697	static 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(dev: input, data: 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(dev: input, EV_KEY, BTN_TR2);
731	input_set_capability(dev: input, EV_KEY, BTN_TL2);
732	input_set_capability(dev: input, EV_KEY, BTN_TR);
733	input_set_capability(dev: input, EV_KEY, BTN_TL);
734	input_set_capability(dev: input, EV_KEY, BTN_Y);
735	input_set_capability(dev: input, EV_KEY, BTN_B);
736	input_set_capability(dev: input, EV_KEY, BTN_X);
737	input_set_capability(dev: input, EV_KEY, BTN_A);
738	input_set_capability(dev: input, EV_KEY, BTN_DPAD_UP);
739	input_set_capability(dev: input, EV_KEY, BTN_DPAD_RIGHT);
740	input_set_capability(dev: input, EV_KEY, BTN_DPAD_LEFT);
741	input_set_capability(dev: input, EV_KEY, BTN_DPAD_DOWN);
742	input_set_capability(dev: input, EV_KEY, BTN_SELECT);
743	input_set_capability(dev: input, EV_KEY, BTN_MODE);
744	input_set_capability(dev: input, EV_KEY, BTN_START);
745	input_set_capability(dev: input, EV_KEY, BTN_THUMBR);
746	input_set_capability(dev: input, EV_KEY, BTN_THUMBL);
747	input_set_capability(dev: input, EV_KEY, BTN_THUMB);
748	input_set_capability(dev: input, EV_KEY, BTN_THUMB2);
749	if (steam->quirks & STEAM_QUIRK_DECK) {
750	input_set_capability(dev: input, EV_KEY, BTN_BASE);
751	input_set_capability(dev: input, EV_KEY, BTN_TRIGGER_HAPPY1);
752	input_set_capability(dev: input, EV_KEY, BTN_TRIGGER_HAPPY2);
753	input_set_capability(dev: input, EV_KEY, BTN_TRIGGER_HAPPY3);
754	input_set_capability(dev: input, EV_KEY, BTN_TRIGGER_HAPPY4);
755	} else {
756	input_set_capability(dev: input, EV_KEY, BTN_GEAR_DOWN);
757	input_set_capability(dev: input, EV_KEY, BTN_GEAR_UP);
758	}
759
760	input_set_abs_params(dev: input, ABS_X, min: -32767, max: 32767, fuzz: 0, flat: 0);
761	input_set_abs_params(dev: input, ABS_Y, min: -32767, max: 32767, fuzz: 0, flat: 0);
762
763	input_set_abs_params(dev: input, ABS_HAT0X, min: -32767, max: 32767,
764	STEAM_PAD_FUZZ, flat: 0);
765	input_set_abs_params(dev: input, ABS_HAT0Y, min: -32767, max: 32767,
766	STEAM_PAD_FUZZ, flat: 0);
767
768	if (steam->quirks & STEAM_QUIRK_DECK) {
769	input_set_abs_params(dev: input, ABS_HAT2Y, min: 0, max: 32767, fuzz: 0, flat: 0);
770	input_set_abs_params(dev: input, ABS_HAT2X, min: 0, max: 32767, fuzz: 0, flat: 0);
771
772	input_set_abs_params(dev: input, ABS_RX, min: -32767, max: 32767, fuzz: 0, flat: 0);
773	input_set_abs_params(dev: input, ABS_RY, min: -32767, max: 32767, fuzz: 0, flat: 0);
774
775	input_set_abs_params(dev: input, ABS_HAT1X, min: -32767, max: 32767,
776	STEAM_PAD_FUZZ, flat: 0);
777	input_set_abs_params(dev: input, ABS_HAT1Y, min: -32767, max: 32767,
778	STEAM_PAD_FUZZ, flat: 0);
779
780	input_abs_set_res(dev: input, ABS_X, STEAM_DECK_JOYSTICK_RESOLUTION);
781	input_abs_set_res(dev: input, ABS_Y, STEAM_DECK_JOYSTICK_RESOLUTION);
782	input_abs_set_res(dev: input, ABS_RX, STEAM_DECK_JOYSTICK_RESOLUTION);
783	input_abs_set_res(dev: input, ABS_RY, STEAM_DECK_JOYSTICK_RESOLUTION);
784	input_abs_set_res(dev: input, ABS_HAT1X, STEAM_PAD_RESOLUTION);
785	input_abs_set_res(dev: input, ABS_HAT1Y, STEAM_PAD_RESOLUTION);
786	input_abs_set_res(dev: input, ABS_HAT2Y, STEAM_DECK_TRIGGER_RESOLUTION);
787	input_abs_set_res(dev: input, ABS_HAT2X, STEAM_DECK_TRIGGER_RESOLUTION);
788	} else {
789	input_set_abs_params(dev: input, ABS_HAT2Y, min: 0, max: 255, fuzz: 0, flat: 0);
790	input_set_abs_params(dev: input, ABS_HAT2X, min: 0, max: 255, fuzz: 0, flat: 0);
791
792	input_set_abs_params(dev: input, ABS_RX, min: -32767, max: 32767,
793	STEAM_PAD_FUZZ, flat: 0);
794	input_set_abs_params(dev: input, ABS_RY, min: -32767, max: 32767,
795	STEAM_PAD_FUZZ, flat: 0);
796
797	input_abs_set_res(dev: input, ABS_X, STEAM_JOYSTICK_RESOLUTION);
798	input_abs_set_res(dev: input, ABS_Y, STEAM_JOYSTICK_RESOLUTION);
799	input_abs_set_res(dev: input, ABS_RX, STEAM_PAD_RESOLUTION);
800	input_abs_set_res(dev: input, ABS_RY, STEAM_PAD_RESOLUTION);
801	input_abs_set_res(dev: input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION);
802	input_abs_set_res(dev: input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION);
803	}
804	input_abs_set_res(dev: input, ABS_HAT0X, STEAM_PAD_RESOLUTION);
805	input_abs_set_res(dev: input, ABS_HAT0Y, STEAM_PAD_RESOLUTION);
806
807	#ifdef CONFIG_STEAM_FF
808	if (steam->quirks & STEAM_QUIRK_DECK) {
809	input_set_capability(dev: input, EV_FF, FF_RUMBLE);
810	ret = input_ff_create_memless(dev: input, NULL, play_effect: 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
823	input_register_fail:
824	input_free_device(dev: input);
825	return ret;
826	}
827
828	static 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
841	static 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(psy: battery);
854	}
855
856	static 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(head: &steam->list))
886	list_add(new: &steam->list, head: &steam_devices);
887	mutex_unlock(lock: &steam_devices_lock);
888	}
889
890	spin_lock_irqsave(&steam->lock, flags);
891	client_opened = steam->client_opened;
892	spin_unlock_irqrestore(lock: &steam->lock, flags);
893	if (!client_opened) {
894	steam_set_lizard_mode(steam, enable: lizard_mode);
895	ret = steam_input_register(steam);
896	} else
897	ret = 0;
898
899	return ret;
900	}
901
902	static 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(entry: &steam->list);
911	mutex_unlock(lock: &steam_devices_lock);
912	steam->serial_no[0] = 0;
913	}
914	}
915
916	static 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(lock: &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
940	static 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, enable: false);
952	else {
953	spin_lock_irqsave(&steam->lock, flags);
954	client_opened = steam->client_opened;
955	spin_unlock_irqrestore(lock: &steam->lock, flags);
956	if (!client_opened)
957	steam_set_lizard_mode(steam, enable: lizard_mode);
958	}
959
960	steam_haptic_pulse(steam, STEAM_PAD_RIGHT, duration: 0x190, interval: 0, count: 1, gain: 0);
961	if (steam->gamepad_mode) {
962	steam_haptic_pulse(steam, STEAM_PAD_LEFT, duration: 0x14D, interval: 0x14D, count: 0x2D, gain: 0);
963	} else {
964	steam_haptic_pulse(steam, STEAM_PAD_LEFT, duration: 0x1F4, interval: 0x1F4, count: 0x1E, gain: 0);
965	}
966	}
967
968	static 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(head: &rep_enum->report_list);
985	}
986
987	static int steam_client_ll_parse(struct hid_device *hdev)
988	{
989	struct steam_device *steam = hdev->driver_data;
990
991	return hid_parse_report(hid: hdev, start: steam->hdev->dev_rdesc,
992	size: steam->hdev->dev_rsize);
993	}
994
995	static int steam_client_ll_start(struct hid_device *hdev)
996	{
997	return 0;
998	}
999
1000	static void steam_client_ll_stop(struct hid_device *hdev)
1001	{
1002	}
1003
1004	static 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(lock: &steam->lock, flags);
1012
1013	steam_input_unregister(steam);
1014
1015	return 0;
1016	}
1017
1018	static 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(lock: &steam->lock, flags);
1029
1030	if (connected) {
1031	steam_set_lizard_mode(steam, enable: lizard_mode);
1032	steam_input_register(steam);
1033	}
1034	}
1035
1036	static 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(hdev: steam->hdev, reportnum, buf, len: count,
1044	rtype: report_type, reqtype);
1045	}
1046
1047	static 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
1056	static 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(ptr: 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
1085	static 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(dev: &hdev->dev, size: sizeof(*steam), GFP_KERNEL);
1112	if (!steam)
1113	return -ENOMEM;
1114
1115	steam->hdev = hdev;
1116	hid_set_drvdata(hdev, data: 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(list: &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(ptr: steam->client_hdev)) {
1160	ret = PTR_ERR(ptr: 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
1171	err_destroy:
1172	hid_destroy_device(steam->client_hdev);
1173	err_stream_unregister:
1174	if (steam->connected)
1175	steam_unregister(steam);
1176	err_hw_close:
1177	hid_hw_close(hdev);
1178	err_hw_stop:
1179	hid_hw_stop(hdev);
1180	err_cancel_work:
1181	cancel_work_sync(work: &steam->work_connect);
1182	cancel_delayed_work_sync(dwork: &steam->mode_switch);
1183	cancel_work_sync(work: &steam->rumble_work);
1184
1185	return ret;
1186	}
1187
1188	static 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(dwork: &steam->mode_switch);
1198	cancel_work_sync(work: &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
1210	static 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(lock: &steam->lock, flags);
1219
1220	if (changed && schedule_work(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	*/
1230	static inline s16 steam_le16(u8 *data)
1231	{
1232	s16 x = (s16) le16_to_cpup(p: (__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
1303	static 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(dev: input, ABS_HAT2Y, value: data[11]);
1316	input_report_abs(dev: input, ABS_HAT2X, value: 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: data + 16);
1329	y = -steam_le16(data: data + 18);
1330
1331	input_report_abs(dev: input, code: lpad_touched ? ABS_HAT0X : ABS_X, value: x);
1332	input_report_abs(dev: input, code: lpad_touched ? ABS_HAT0Y : ABS_Y, value: y);
1333	/* Check if joystick is centered */
1334	if (lpad_touched && !lpad_and_joy) {
1335	input_report_abs(dev: input, ABS_X, value: 0);
1336	input_report_abs(dev: input, ABS_Y, value: 0);
1337	}
1338	/* Check if lpad is untouched */
1339	if (!(lpad_touched || lpad_and_joy)) {
1340	input_report_abs(dev: input, ABS_HAT0X, value: 0);
1341	input_report_abs(dev: input, ABS_HAT0Y, value: 0);
1342	}
1343
1344	input_report_abs(dev: input, ABS_RX, value: steam_le16(data: data + 20));
1345	input_report_abs(dev: input, ABS_RY, value: -steam_le16(data: data + 22));
1346
1347	input_event(dev: input, EV_KEY, BTN_TR2, value: !!(b8 & BIT(0)));
1348	input_event(dev: input, EV_KEY, BTN_TL2, value: !!(b8 & BIT(1)));
1349	input_event(dev: input, EV_KEY, BTN_TR, value: !!(b8 & BIT(2)));
1350	input_event(dev: input, EV_KEY, BTN_TL, value: !!(b8 & BIT(3)));
1351	input_event(dev: input, EV_KEY, BTN_Y, value: !!(b8 & BIT(4)));
1352	input_event(dev: input, EV_KEY, BTN_B, value: !!(b8 & BIT(5)));
1353	input_event(dev: input, EV_KEY, BTN_X, value: !!(b8 & BIT(6)));
1354	input_event(dev: input, EV_KEY, BTN_A, value: !!(b8 & BIT(7)));
1355	input_event(dev: input, EV_KEY, BTN_SELECT, value: !!(b9 & BIT(4)));
1356	input_event(dev: input, EV_KEY, BTN_MODE, value: !!(b9 & BIT(5)));
1357	input_event(dev: input, EV_KEY, BTN_START, value: !!(b9 & BIT(6)));
1358	input_event(dev: input, EV_KEY, BTN_GEAR_DOWN, value: !!(b9 & BIT(7)));
1359	input_event(dev: input, EV_KEY, BTN_GEAR_UP, value: !!(b10 & BIT(0)));
1360	input_event(dev: input, EV_KEY, BTN_THUMBR, value: !!(b10 & BIT(2)));
1361	input_event(dev: input, EV_KEY, BTN_THUMBL, value: !!(b10 & BIT(6)));
1362	input_event(dev: input, EV_KEY, BTN_THUMB, value: lpad_touched || lpad_and_joy);
1363	input_event(dev: input, EV_KEY, BTN_THUMB2, value: !!(b10 & BIT(4)));
1364	input_event(dev: input, EV_KEY, BTN_DPAD_UP, value: !!(b9 & BIT(0)));
1365	input_event(dev: input, EV_KEY, BTN_DPAD_RIGHT, value: !!(b9 & BIT(1)));
1366	input_event(dev: input, EV_KEY, BTN_DPAD_LEFT, value: !!(b9 & BIT(2)));
1367	input_event(dev: input, EV_KEY, BTN_DPAD_DOWN, value: !!(b9 & BIT(3)));
1368
1369	input_sync(dev: 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	*/
1470	static 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(dwork: &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(dwork: &steam->mode_switch, delay: 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(dev: input, ABS_HAT0X, value: steam_le16(data: data + 16));
1499	input_report_abs(dev: input, ABS_HAT0Y, value: steam_le16(data: data + 18));
1500	} else {
1501	input_report_abs(dev: input, ABS_HAT0X, value: 0);
1502	input_report_abs(dev: input, ABS_HAT0Y, value: 0);
1503	}
1504
1505	if (rpad_touched) {
1506	input_report_abs(dev: input, ABS_HAT1X, value: steam_le16(data: data + 20));
1507	input_report_abs(dev: input, ABS_HAT1Y, value: steam_le16(data: data + 22));
1508	} else {
1509	input_report_abs(dev: input, ABS_HAT1X, value: 0);
1510	input_report_abs(dev: input, ABS_HAT1Y, value: 0);
1511	}
1512
1513	input_report_abs(dev: input, ABS_X, value: steam_le16(data: data + 48));
1514	input_report_abs(dev: input, ABS_Y, value: -steam_le16(data: data + 50));
1515	input_report_abs(dev: input, ABS_RX, value: steam_le16(data: data + 52));
1516	input_report_abs(dev: input, ABS_RY, value: -steam_le16(data: data + 54));
1517
1518	input_report_abs(dev: input, ABS_HAT2Y, value: steam_le16(data: data + 44));
1519	input_report_abs(dev: input, ABS_HAT2X, value: steam_le16(data: data + 46));
1520
1521	input_event(dev: input, EV_KEY, BTN_TR2, value: !!(b8 & BIT(0)));
1522	input_event(dev: input, EV_KEY, BTN_TL2, value: !!(b8 & BIT(1)));
1523	input_event(dev: input, EV_KEY, BTN_TR, value: !!(b8 & BIT(2)));
1524	input_event(dev: input, EV_KEY, BTN_TL, value: !!(b8 & BIT(3)));
1525	input_event(dev: input, EV_KEY, BTN_Y, value: !!(b8 & BIT(4)));
1526	input_event(dev: input, EV_KEY, BTN_B, value: !!(b8 & BIT(5)));
1527	input_event(dev: input, EV_KEY, BTN_X, value: !!(b8 & BIT(6)));
1528	input_event(dev: input, EV_KEY, BTN_A, value: !!(b8 & BIT(7)));
1529	input_event(dev: input, EV_KEY, BTN_SELECT, value: !!(b9 & BIT(4)));
1530	input_event(dev: input, EV_KEY, BTN_MODE, value: !!(b9 & BIT(5)));
1531	input_event(dev: input, EV_KEY, BTN_START, value: !!(b9 & BIT(6)));
1532	input_event(dev: input, EV_KEY, BTN_TRIGGER_HAPPY3, value: !!(b9 & BIT(7)));
1533	input_event(dev: input, EV_KEY, BTN_TRIGGER_HAPPY4, value: !!(b10 & BIT(0)));
1534	input_event(dev: input, EV_KEY, BTN_THUMBL, value: !!(b10 & BIT(6)));
1535	input_event(dev: input, EV_KEY, BTN_THUMBR, value: !!(b11 & BIT(2)));
1536	input_event(dev: input, EV_KEY, BTN_DPAD_UP, value: !!(b9 & BIT(0)));
1537	input_event(dev: input, EV_KEY, BTN_DPAD_RIGHT, value: !!(b9 & BIT(1)));
1538	input_event(dev: input, EV_KEY, BTN_DPAD_LEFT, value: !!(b9 & BIT(2)));
1539	input_event(dev: input, EV_KEY, BTN_DPAD_DOWN, value: !!(b9 & BIT(3)));
1540	input_event(dev: input, EV_KEY, BTN_THUMB, value: !!(b10 & BIT(1)));
1541	input_event(dev: input, EV_KEY, BTN_THUMB2, value: !!(b10 & BIT(2)));
1542	input_event(dev: input, EV_KEY, BTN_TRIGGER_HAPPY1, value: !!(b13 & BIT(1)));
1543	input_event(dev: input, EV_KEY, BTN_TRIGGER_HAPPY2, value: !!(b13 & BIT(2)));
1544	input_event(dev: input, EV_KEY, BTN_BASE, value: !!(b14 & BIT(2)));
1545
1546	input_sync(dev: 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	*/
1559	static 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: 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(lock: &steam->lock, flags);
1575	power_supply_changed(psy: battery);
1576	}
1577	rcu_read_unlock();
1578	}
1579
1580	static 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(hid: steam->client_hdev, type: HID_FEATURE_REPORT,
1593	data, size, interrupt: 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, connected: false);
1642	break;
1643	case 0x02:
1644	steam_do_connect_event(steam, connected: 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, connected: true);
1659	}
1660	rcu_read_unlock();
1661	}
1662	break;
1663	}
1664	return 0;
1665	}
1666
1667	static 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, enable: lizard_mode);
1681	}
1682	mutex_unlock(lock: &steam_devices_lock);
1683	return 0;
1684	}
1685
1686	static const struct kernel_param_ops steam_lizard_mode_ops = {
1687	.set = steam_param_set_lizard_mode,
1688	.get = param_get_bool,
1689	};
1690
1691	module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644);
1692	MODULE_PARM_DESC(lizard_mode,
1693	"Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use");
1694
1695	static 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
1713	MODULE_DEVICE_TABLE(hid, steam_controllers);
1714
1715	static 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
1723	module_hid_driver(steam_controller_driver);
1724