1 // SPDX-License-Identifier: GPL-2.0+
3 * HID driver for Valve Steam Controller
5 * Copyright (c) 2018 Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>
6 * Copyright (c) 2022 Valve Software
8 * Supports both the wired and wireless interfaces.
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
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.
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.
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
29 * When the client is closed, this input device will be created again.
31 * For additional functions, such as changing the right-pad margin or switching
32 * the led, you can use the user-space tool at:
34 * https://github.com/rodrigorc/steamctrl
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>
48 MODULE_LICENSE("GPL");
49 MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>");
51 static bool lizard_mode
= true;
53 static DEFINE_MUTEX(steam_devices_lock
);
54 static LIST_HEAD(steam_devices
);
56 #define STEAM_QUIRK_WIRELESS BIT(0)
57 #define STEAM_QUIRK_DECK BIT(1)
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 /* Accelerometer has 16 bit resolution and a range of +/- 2g */
70 #define STEAM_DECK_ACCEL_RES_PER_G 16384
71 #define STEAM_DECK_ACCEL_RANGE 32768
72 #define STEAM_DECK_ACCEL_FUZZ 32
73 /* Gyroscope has 16 bit resolution and a range of +/- 2000 dps */
74 #define STEAM_DECK_GYRO_RES_PER_DPS 16
75 #define STEAM_DECK_GYRO_RANGE 32768
76 #define STEAM_DECK_GYRO_FUZZ 1
78 #define STEAM_PAD_FUZZ 256
81 * Commands that can be sent in a feature report.
82 * Thanks to Valve and SDL for the names.
85 ID_SET_DIGITAL_MAPPINGS
= 0x80,
86 ID_CLEAR_DIGITAL_MAPPINGS
= 0x81,
87 ID_GET_DIGITAL_MAPPINGS
= 0x82,
88 ID_GET_ATTRIBUTES_VALUES
= 0x83,
89 ID_GET_ATTRIBUTE_LABEL
= 0x84,
90 ID_SET_DEFAULT_DIGITAL_MAPPINGS
= 0x85,
91 ID_FACTORY_RESET
= 0x86,
92 ID_SET_SETTINGS_VALUES
= 0x87,
93 ID_CLEAR_SETTINGS_VALUES
= 0x88,
94 ID_GET_SETTINGS_VALUES
= 0x89,
95 ID_GET_SETTING_LABEL
= 0x8A,
96 ID_GET_SETTINGS_MAXS
= 0x8B,
97 ID_GET_SETTINGS_DEFAULTS
= 0x8C,
98 ID_SET_CONTROLLER_MODE
= 0x8D,
99 ID_LOAD_DEFAULT_SETTINGS
= 0x8E,
100 ID_TRIGGER_HAPTIC_PULSE
= 0x8F,
101 ID_TURN_OFF_CONTROLLER
= 0x9F,
103 ID_GET_DEVICE_INFO
= 0xA1,
105 ID_CALIBRATE_TRACKPADS
= 0xA7,
106 ID_RESERVED_0
= 0xA8,
107 ID_SET_SERIAL_NUMBER
= 0xA9,
108 ID_GET_TRACKPAD_CALIBRATION
= 0xAA,
109 ID_GET_TRACKPAD_FACTORY_CALIBRATION
= 0xAB,
110 ID_GET_TRACKPAD_RAW_DATA
= 0xAC,
111 ID_ENABLE_PAIRING
= 0xAD,
112 ID_GET_STRING_ATTRIBUTE
= 0xAE,
113 ID_RADIO_ERASE_RECORDS
= 0xAF,
114 ID_RADIO_WRITE_RECORD
= 0xB0,
115 ID_SET_DONGLE_SETTING
= 0xB1,
116 ID_DONGLE_DISCONNECT_DEVICE
= 0xB2,
117 ID_DONGLE_COMMIT_DEVICE
= 0xB3,
118 ID_DONGLE_GET_WIRELESS_STATE
= 0xB4,
119 ID_CALIBRATE_GYRO
= 0xB5,
120 ID_PLAY_AUDIO
= 0xB6,
121 ID_AUDIO_UPDATE_START
= 0xB7,
122 ID_AUDIO_UPDATE_DATA
= 0xB8,
123 ID_AUDIO_UPDATE_COMPLETE
= 0xB9,
124 ID_GET_CHIPID
= 0xBA,
126 ID_CALIBRATE_JOYSTICK
= 0xBF,
127 ID_CALIBRATE_ANALOG_TRIGGERS
= 0xC0,
128 ID_SET_AUDIO_MAPPING
= 0xC1,
129 ID_CHECK_GYRO_FW_LOAD
= 0xC2,
130 ID_CALIBRATE_ANALOG
= 0xC3,
131 ID_DONGLE_GET_CONNECTED_SLOTS
= 0xC4,
135 ID_TRIGGER_HAPTIC_CMD
= 0xEA,
136 ID_TRIGGER_RUMBLE_CMD
= 0xEB,
142 SETTING_MOUSE_SENSITIVITY
,
143 SETTING_MOUSE_ACCELERATION
,
144 SETTING_TRACKBALL_ROTATION_ANGLE
,
145 SETTING_HAPTIC_INTENSITY_UNUSED
,
146 SETTING_LEFT_GAMEPAD_STICK_ENABLED
,
147 SETTING_RIGHT_GAMEPAD_STICK_ENABLED
,
148 SETTING_USB_DEBUG_MODE
,
149 SETTING_LEFT_TRACKPAD_MODE
,
150 SETTING_RIGHT_TRACKPAD_MODE
,
151 SETTING_MOUSE_POINTER_ENABLED
,
154 SETTING_DPAD_DEADZONE
,
155 SETTING_MINIMUM_MOMENTUM_VEL
,
156 SETTING_MOMENTUM_DECAY_AMMOUNT
,
157 SETTING_TRACKPAD_RELATIVE_MODE_TICKS_PER_PIXEL
,
158 SETTING_HAPTIC_INCREMENT
,
159 SETTING_DPAD_ANGLE_SIN
,
160 SETTING_DPAD_ANGLE_COS
,
161 SETTING_MOMENTUM_VERTICAL_DIVISOR
,
162 SETTING_MOMENTUM_MAXIMUM_VELOCITY
,
163 SETTING_TRACKPAD_Z_ON
,
166 SETTING_TRACKPAD_Z_OFF
,
167 SETTING_SENSITIVY_SCALE_AMMOUNT
,
168 SETTING_LEFT_TRACKPAD_SECONDARY_MODE
,
169 SETTING_RIGHT_TRACKPAD_SECONDARY_MODE
,
170 SETTING_SMOOTH_ABSOLUTE_MOUSE
,
171 SETTING_STEAMBUTTON_POWEROFF_TIME
,
173 SETTING_TRACKPAD_OUTER_RADIUS
,
174 SETTING_TRACKPAD_Z_ON_LEFT
,
175 SETTING_TRACKPAD_Z_OFF_LEFT
,
178 SETTING_TRACKPAD_OUTER_SPIN_VEL
,
179 SETTING_TRACKPAD_OUTER_SPIN_RADIUS
,
180 SETTING_TRACKPAD_OUTER_SPIN_HORIZONTAL_ONLY
,
181 SETTING_TRACKPAD_RELATIVE_MODE_DEADZONE
,
182 SETTING_TRACKPAD_RELATIVE_MODE_MAX_VEL
,
183 SETTING_TRACKPAD_RELATIVE_MODE_INVERT_Y
,
184 SETTING_TRACKPAD_DOUBLE_TAP_BEEP_ENABLED
,
185 SETTING_TRACKPAD_DOUBLE_TAP_BEEP_PERIOD
,
186 SETTING_TRACKPAD_DOUBLE_TAP_BEEP_COUNT
,
187 SETTING_TRACKPAD_OUTER_RADIUS_RELEASE_ON_TRANSITION
,
190 SETTING_RADIAL_MODE_ANGLE
,
191 SETTING_HAPTIC_INTENSITY_MOUSE_MODE
,
192 SETTING_LEFT_DPAD_REQUIRES_CLICK
,
193 SETTING_RIGHT_DPAD_REQUIRES_CLICK
,
194 SETTING_LED_BASELINE_BRIGHTNESS
,
195 SETTING_LED_USER_BRIGHTNESS
,
196 SETTING_ENABLE_RAW_JOYSTICK
,
197 SETTING_ENABLE_FAST_SCAN
,
199 SETTING_WIRELESS_PACKET_VERSION
,
202 SETTING_SLEEP_INACTIVITY_TIMEOUT
,
203 SETTING_TRACKPAD_NOISE_THRESHOLD
,
204 SETTING_LEFT_TRACKPAD_CLICK_PRESSURE
,
205 SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE
,
206 SETTING_LEFT_BUMPER_CLICK_PRESSURE
,
207 SETTING_RIGHT_BUMPER_CLICK_PRESSURE
,
208 SETTING_LEFT_GRIP_CLICK_PRESSURE
,
209 SETTING_RIGHT_GRIP_CLICK_PRESSURE
,
210 SETTING_LEFT_GRIP2_CLICK_PRESSURE
,
211 SETTING_RIGHT_GRIP2_CLICK_PRESSURE
,
214 SETTING_PRESSURE_MODE
,
215 SETTING_CONTROLLER_TEST_MODE
,
216 SETTING_TRIGGER_MODE
,
217 SETTING_TRACKPAD_Z_THRESHOLD
,
219 SETTING_TRACKPAD_FILT_CTRL
,
220 SETTING_TRACKPAD_CLIP
,
221 SETTING_DEBUG_OUTPUT_SELECT
,
222 SETTING_TRIGGER_THRESHOLD_PERCENT
,
223 SETTING_TRACKPAD_FREQUENCY_HOPPING
,
226 SETTING_HAPTICS_ENABLED
,
227 SETTING_STEAM_WATCHDOG_ENABLE
,
228 SETTING_TIMP_TOUCH_THRESHOLD_ON
,
229 SETTING_TIMP_TOUCH_THRESHOLD_OFF
,
230 SETTING_FREQ_HOPPING
,
231 SETTING_TEST_CONTROL
,
232 SETTING_HAPTIC_MASTER_GAIN_DB
,
233 SETTING_THUMB_TOUCH_THRESH
,
234 SETTING_DEVICE_POWER_STATUS
,
235 SETTING_HAPTIC_INTENSITY
,
238 SETTING_STABILIZER_ENABLED
,
239 SETTING_TIMP_MODE_MTE
,
242 /* Input report identifiers */
245 ID_CONTROLLER_STATE
= 1,
246 ID_CONTROLLER_DEBUG
= 2,
247 ID_CONTROLLER_WIRELESS
= 3,
248 ID_CONTROLLER_STATUS
= 4,
249 ID_CONTROLLER_DEBUG2
= 5,
250 ID_CONTROLLER_SECONDARY_STATE
= 6,
251 ID_CONTROLLER_BLE_STATE
= 7,
252 ID_CONTROLLER_DECK_STATE
= 9
255 /* String attribute idenitifiers */
257 ATTRIB_STR_BOARD_SERIAL
,
258 ATTRIB_STR_UNIT_SERIAL
,
261 /* Values for GYRO_MODE (bitmask) */
263 SETTING_GYRO_MODE_OFF
= 0,
264 SETTING_GYRO_MODE_STEERING
= BIT(0),
265 SETTING_GYRO_MODE_TILT
= BIT(1),
266 SETTING_GYRO_MODE_SEND_ORIENTATION
= BIT(2),
267 SETTING_GYRO_MODE_SEND_RAW_ACCEL
= BIT(3),
268 SETTING_GYRO_MODE_SEND_RAW_GYRO
= BIT(4),
273 TRACKPAD_ABSOLUTE_MOUSE
,
274 TRACKPAD_RELATIVE_MOUSE
,
275 TRACKPAD_DPAD_FOUR_WAY_DISCRETE
,
276 TRACKPAD_DPAD_FOUR_WAY_OVERLAP
,
277 TRACKPAD_DPAD_EIGHT_WAY
,
278 TRACKPAD_RADIAL_MODE
,
279 TRACKPAD_ABSOLUTE_DPAD
,
281 TRACKPAD_GESTURE_KEYBOARD
,
284 /* Pad identifiers for the deck */
285 #define STEAM_PAD_LEFT 0
286 #define STEAM_PAD_RIGHT 1
287 #define STEAM_PAD_BOTH 2
289 /* Other random constants */
290 #define STEAM_SERIAL_LEN 0x15
292 struct steam_device
{
293 struct list_head list
;
295 struct hid_device
*hdev
, *client_hdev
;
296 struct mutex report_mutex
;
297 unsigned long client_opened
;
298 struct input_dev __rcu
*input
;
299 struct input_dev __rcu
*sensors
;
300 unsigned long quirks
;
301 struct work_struct work_connect
;
303 char serial_no
[STEAM_SERIAL_LEN
+ 1];
304 struct power_supply_desc battery_desc
;
305 struct power_supply __rcu
*battery
;
308 struct delayed_work mode_switch
;
309 bool did_mode_switch
;
311 struct work_struct rumble_work
;
314 unsigned int sensor_timestamp_us
;
317 static int steam_recv_report(struct steam_device
*steam
,
320 struct hid_report
*r
;
324 r
= steam
->hdev
->report_enum
[HID_FEATURE_REPORT
].report_id_hash
[0];
326 hid_err(steam
->hdev
, "No HID_FEATURE_REPORT submitted - nothing to read\n");
330 if (hid_report_len(r
) < 64)
333 buf
= hid_alloc_report_buf(r
, GFP_KERNEL
);
338 * The report ID is always 0, so strip the first byte from the output.
339 * hid_report_len() is not counting the report ID, so +1 to the length
340 * or else we get a EOVERFLOW. We are safe from a buffer overflow
341 * because hid_alloc_report_buf() allocates +7 bytes.
343 ret
= hid_hw_raw_request(steam
->hdev
, 0x00,
344 buf
, hid_report_len(r
) + 1,
345 HID_FEATURE_REPORT
, HID_REQ_GET_REPORT
);
347 memcpy(data
, buf
+ 1, min(size
, ret
- 1));
352 static int steam_send_report(struct steam_device
*steam
,
355 struct hid_report
*r
;
357 unsigned int retries
= 50;
360 r
= steam
->hdev
->report_enum
[HID_FEATURE_REPORT
].report_id_hash
[0];
362 hid_err(steam
->hdev
, "No HID_FEATURE_REPORT submitted - nothing to read\n");
366 if (hid_report_len(r
) < 64)
369 buf
= hid_alloc_report_buf(r
, GFP_KERNEL
);
373 /* The report ID is always 0 */
374 memcpy(buf
+ 1, cmd
, size
);
377 * Sometimes the wireless controller fails with EPIPE
378 * when sending a feature report.
379 * Doing a HID_REQ_GET_REPORT and waiting for a while
383 ret
= hid_hw_raw_request(steam
->hdev
, 0,
384 buf
, max(size
, 64) + 1,
385 HID_FEATURE_REPORT
, HID_REQ_SET_REPORT
);
393 hid_err(steam
->hdev
, "%s: error %d (%*ph)\n", __func__
,
398 static inline int steam_send_report_byte(struct steam_device
*steam
, u8 cmd
)
400 return steam_send_report(steam
, &cmd
, 1);
403 static int steam_write_settings(struct steam_device
*steam
,
404 /* u8 reg, u16 val */...)
406 /* Send: 0x87 len (reg valLo valHi)* */
409 u8 cmd
[64] = {ID_SET_SETTINGS_VALUES
, 0x00};
413 va_start(args
, steam
);
415 reg
= va_arg(args
, int);
418 val
= va_arg(args
, int);
419 cmd
[cmd
[1] + 2] = reg
;
420 cmd
[cmd
[1] + 3] = val
& 0xff;
421 cmd
[cmd
[1] + 4] = val
>> 8;
426 ret
= steam_send_report(steam
, cmd
, 2 + cmd
[1]);
431 * Sometimes a lingering report for this command can
432 * get read back instead of the last set report if
433 * this isn't explicitly queried
435 return steam_recv_report(steam
, cmd
, 2 + cmd
[1]);
438 static int steam_get_serial(struct steam_device
*steam
)
441 * Send: 0xae 0x15 0x01
442 * Recv: 0xae 0x15 0x01 serialnumber
445 u8 cmd
[] = {ID_GET_STRING_ATTRIBUTE
, sizeof(steam
->serial_no
), ATTRIB_STR_UNIT_SERIAL
};
446 u8 reply
[3 + STEAM_SERIAL_LEN
+ 1];
448 mutex_lock(&steam
->report_mutex
);
449 ret
= steam_send_report(steam
, cmd
, sizeof(cmd
));
452 ret
= steam_recv_report(steam
, reply
, sizeof(reply
));
455 if (reply
[0] != ID_GET_STRING_ATTRIBUTE
|| reply
[1] < 1 ||
456 reply
[1] > sizeof(steam
->serial_no
) || reply
[2] != ATTRIB_STR_UNIT_SERIAL
) {
460 reply
[3 + STEAM_SERIAL_LEN
] = 0;
461 strscpy(steam
->serial_no
, reply
+ 3, reply
[1]);
463 mutex_unlock(&steam
->report_mutex
);
468 * This command requests the wireless adaptor to post an event
469 * with the connection status. Useful if this driver is loaded when
470 * the controller is already connected.
472 static inline int steam_request_conn_status(struct steam_device
*steam
)
475 mutex_lock(&steam
->report_mutex
);
476 ret
= steam_send_report_byte(steam
, ID_DONGLE_GET_WIRELESS_STATE
);
477 mutex_unlock(&steam
->report_mutex
);
482 * Send a haptic pulse to the trackpads
483 * Duration and interval are measured in microseconds, count is the number
484 * of pulses to send for duration time with interval microseconds between them
485 * and gain is measured in decibels, ranging from -24 to +6
487 static inline int steam_haptic_pulse(struct steam_device
*steam
, u8 pad
,
488 u16 duration
, u16 interval
, u16 count
, u8 gain
)
491 u8 report
[10] = {ID_TRIGGER_HAPTIC_PULSE
, 8};
493 /* Left and right are swapped on this report for legacy reasons */
494 if (pad
< STEAM_PAD_BOTH
)
498 report
[3] = duration
& 0xFF;
499 report
[4] = duration
>> 8;
500 report
[5] = interval
& 0xFF;
501 report
[6] = interval
>> 8;
502 report
[7] = count
& 0xFF;
503 report
[8] = count
>> 8;
506 mutex_lock(&steam
->report_mutex
);
507 ret
= steam_send_report(steam
, report
, sizeof(report
));
508 mutex_unlock(&steam
->report_mutex
);
512 static inline int steam_haptic_rumble(struct steam_device
*steam
,
513 u16 intensity
, u16 left_speed
, u16 right_speed
,
514 u8 left_gain
, u8 right_gain
)
517 u8 report
[11] = {ID_TRIGGER_RUMBLE_CMD
, 9};
519 report
[3] = intensity
& 0xFF;
520 report
[4] = intensity
>> 8;
521 report
[5] = left_speed
& 0xFF;
522 report
[6] = left_speed
>> 8;
523 report
[7] = right_speed
& 0xFF;
524 report
[8] = right_speed
>> 8;
525 report
[9] = left_gain
;
526 report
[10] = right_gain
;
528 mutex_lock(&steam
->report_mutex
);
529 ret
= steam_send_report(steam
, report
, sizeof(report
));
530 mutex_unlock(&steam
->report_mutex
);
534 static void steam_haptic_rumble_cb(struct work_struct
*work
)
536 struct steam_device
*steam
= container_of(work
, struct steam_device
,
538 steam_haptic_rumble(steam
, 0, steam
->rumble_left
,
539 steam
->rumble_right
, 2, 0);
542 #ifdef CONFIG_STEAM_FF
543 static int steam_play_effect(struct input_dev
*dev
, void *data
,
544 struct ff_effect
*effect
)
546 struct steam_device
*steam
= input_get_drvdata(dev
);
548 steam
->rumble_left
= effect
->u
.rumble
.strong_magnitude
;
549 steam
->rumble_right
= effect
->u
.rumble
.weak_magnitude
;
551 return schedule_work(&steam
->rumble_work
);
555 static void steam_set_lizard_mode(struct steam_device
*steam
, bool enable
)
557 if (steam
->gamepad_mode
)
561 mutex_lock(&steam
->report_mutex
);
562 /* enable esc, enter, cursors */
563 steam_send_report_byte(steam
, ID_SET_DEFAULT_DIGITAL_MAPPINGS
);
565 steam_send_report_byte(steam
, ID_LOAD_DEFAULT_SETTINGS
);
566 mutex_unlock(&steam
->report_mutex
);
568 mutex_lock(&steam
->report_mutex
);
569 /* disable esc, enter, cursor */
570 steam_send_report_byte(steam
, ID_CLEAR_DIGITAL_MAPPINGS
);
572 if (steam
->quirks
& STEAM_QUIRK_DECK
) {
573 steam_write_settings(steam
,
574 SETTING_LEFT_TRACKPAD_MODE
, TRACKPAD_NONE
, /* disable mouse */
575 SETTING_RIGHT_TRACKPAD_MODE
, TRACKPAD_NONE
, /* disable mouse */
576 SETTING_LEFT_TRACKPAD_CLICK_PRESSURE
, 0xFFFF, /* disable haptic click */
577 SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE
, 0xFFFF, /* disable haptic click */
578 SETTING_STEAM_WATCHDOG_ENABLE
, 0, /* disable watchdog that tests if Steam is active */
580 mutex_unlock(&steam
->report_mutex
);
582 steam_write_settings(steam
,
583 SETTING_LEFT_TRACKPAD_MODE
, TRACKPAD_NONE
, /* disable mouse */
584 SETTING_RIGHT_TRACKPAD_MODE
, TRACKPAD_NONE
, /* disable mouse */
586 mutex_unlock(&steam
->report_mutex
);
591 static int steam_input_open(struct input_dev
*dev
)
593 struct steam_device
*steam
= input_get_drvdata(dev
);
595 bool set_lizard_mode
;
598 * Disabling lizard mode automatically is only done on the Steam
599 * Controller. On the Steam Deck, this is toggled manually by holding
600 * the options button instead, handled by steam_mode_switch_cb.
602 if (!(steam
->quirks
& STEAM_QUIRK_DECK
)) {
603 spin_lock_irqsave(&steam
->lock
, flags
);
604 set_lizard_mode
= !steam
->client_opened
&& lizard_mode
;
605 spin_unlock_irqrestore(&steam
->lock
, flags
);
607 steam_set_lizard_mode(steam
, false);
613 static void steam_input_close(struct input_dev
*dev
)
615 struct steam_device
*steam
= input_get_drvdata(dev
);
617 bool set_lizard_mode
;
619 if (!(steam
->quirks
& STEAM_QUIRK_DECK
)) {
620 spin_lock_irqsave(&steam
->lock
, flags
);
621 set_lizard_mode
= !steam
->client_opened
&& lizard_mode
;
622 spin_unlock_irqrestore(&steam
->lock
, flags
);
624 steam_set_lizard_mode(steam
, true);
628 static enum power_supply_property steam_battery_props
[] = {
629 POWER_SUPPLY_PROP_PRESENT
,
630 POWER_SUPPLY_PROP_SCOPE
,
631 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
632 POWER_SUPPLY_PROP_CAPACITY
,
635 static int steam_battery_get_property(struct power_supply
*psy
,
636 enum power_supply_property psp
,
637 union power_supply_propval
*val
)
639 struct steam_device
*steam
= power_supply_get_drvdata(psy
);
645 spin_lock_irqsave(&steam
->lock
, flags
);
646 volts
= steam
->voltage
;
647 batt
= steam
->battery_charge
;
648 spin_unlock_irqrestore(&steam
->lock
, flags
);
651 case POWER_SUPPLY_PROP_PRESENT
:
654 case POWER_SUPPLY_PROP_SCOPE
:
655 val
->intval
= POWER_SUPPLY_SCOPE_DEVICE
;
657 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
658 val
->intval
= volts
* 1000; /* mV -> uV */
660 case POWER_SUPPLY_PROP_CAPACITY
:
670 static int steam_battery_register(struct steam_device
*steam
)
672 struct power_supply
*battery
;
673 struct power_supply_config battery_cfg
= { .drv_data
= steam
, };
677 steam
->battery_desc
.type
= POWER_SUPPLY_TYPE_BATTERY
;
678 steam
->battery_desc
.properties
= steam_battery_props
;
679 steam
->battery_desc
.num_properties
= ARRAY_SIZE(steam_battery_props
);
680 steam
->battery_desc
.get_property
= steam_battery_get_property
;
681 steam
->battery_desc
.name
= devm_kasprintf(&steam
->hdev
->dev
,
682 GFP_KERNEL
, "steam-controller-%s-battery",
684 if (!steam
->battery_desc
.name
)
687 /* avoid the warning of 0% battery while waiting for the first info */
688 spin_lock_irqsave(&steam
->lock
, flags
);
689 steam
->voltage
= 3000;
690 steam
->battery_charge
= 100;
691 spin_unlock_irqrestore(&steam
->lock
, flags
);
693 battery
= power_supply_register(&steam
->hdev
->dev
,
694 &steam
->battery_desc
, &battery_cfg
);
695 if (IS_ERR(battery
)) {
696 ret
= PTR_ERR(battery
);
698 "%s:power_supply_register failed with error %d\n",
702 rcu_assign_pointer(steam
->battery
, battery
);
703 power_supply_powers(battery
, &steam
->hdev
->dev
);
707 static int steam_input_register(struct steam_device
*steam
)
709 struct hid_device
*hdev
= steam
->hdev
;
710 struct input_dev
*input
;
714 input
= rcu_dereference(steam
->input
);
717 dbg_hid("%s: already connected\n", __func__
);
721 input
= input_allocate_device();
725 input_set_drvdata(input
, steam
);
726 input
->dev
.parent
= &hdev
->dev
;
727 input
->open
= steam_input_open
;
728 input
->close
= steam_input_close
;
730 input
->name
= (steam
->quirks
& STEAM_QUIRK_WIRELESS
) ? "Wireless Steam Controller" :
731 (steam
->quirks
& STEAM_QUIRK_DECK
) ? "Steam Deck" :
733 input
->phys
= hdev
->phys
;
734 input
->uniq
= steam
->serial_no
;
735 input
->id
.bustype
= hdev
->bus
;
736 input
->id
.vendor
= hdev
->vendor
;
737 input
->id
.product
= hdev
->product
;
738 input
->id
.version
= hdev
->version
;
740 input_set_capability(input
, EV_KEY
, BTN_TR2
);
741 input_set_capability(input
, EV_KEY
, BTN_TL2
);
742 input_set_capability(input
, EV_KEY
, BTN_TR
);
743 input_set_capability(input
, EV_KEY
, BTN_TL
);
744 input_set_capability(input
, EV_KEY
, BTN_Y
);
745 input_set_capability(input
, EV_KEY
, BTN_B
);
746 input_set_capability(input
, EV_KEY
, BTN_X
);
747 input_set_capability(input
, EV_KEY
, BTN_A
);
748 input_set_capability(input
, EV_KEY
, BTN_DPAD_UP
);
749 input_set_capability(input
, EV_KEY
, BTN_DPAD_RIGHT
);
750 input_set_capability(input
, EV_KEY
, BTN_DPAD_LEFT
);
751 input_set_capability(input
, EV_KEY
, BTN_DPAD_DOWN
);
752 input_set_capability(input
, EV_KEY
, BTN_SELECT
);
753 input_set_capability(input
, EV_KEY
, BTN_MODE
);
754 input_set_capability(input
, EV_KEY
, BTN_START
);
755 input_set_capability(input
, EV_KEY
, BTN_THUMBR
);
756 input_set_capability(input
, EV_KEY
, BTN_THUMBL
);
757 input_set_capability(input
, EV_KEY
, BTN_THUMB
);
758 input_set_capability(input
, EV_KEY
, BTN_THUMB2
);
759 if (steam
->quirks
& STEAM_QUIRK_DECK
) {
760 input_set_capability(input
, EV_KEY
, BTN_BASE
);
761 input_set_capability(input
, EV_KEY
, BTN_TRIGGER_HAPPY1
);
762 input_set_capability(input
, EV_KEY
, BTN_TRIGGER_HAPPY2
);
763 input_set_capability(input
, EV_KEY
, BTN_TRIGGER_HAPPY3
);
764 input_set_capability(input
, EV_KEY
, BTN_TRIGGER_HAPPY4
);
766 input_set_capability(input
, EV_KEY
, BTN_GEAR_DOWN
);
767 input_set_capability(input
, EV_KEY
, BTN_GEAR_UP
);
770 input_set_abs_params(input
, ABS_X
, -32767, 32767, 0, 0);
771 input_set_abs_params(input
, ABS_Y
, -32767, 32767, 0, 0);
773 input_set_abs_params(input
, ABS_HAT0X
, -32767, 32767,
775 input_set_abs_params(input
, ABS_HAT0Y
, -32767, 32767,
778 if (steam
->quirks
& STEAM_QUIRK_DECK
) {
779 input_set_abs_params(input
, ABS_HAT2Y
, 0, 32767, 0, 0);
780 input_set_abs_params(input
, ABS_HAT2X
, 0, 32767, 0, 0);
782 input_set_abs_params(input
, ABS_RX
, -32767, 32767, 0, 0);
783 input_set_abs_params(input
, ABS_RY
, -32767, 32767, 0, 0);
785 input_set_abs_params(input
, ABS_HAT1X
, -32767, 32767,
787 input_set_abs_params(input
, ABS_HAT1Y
, -32767, 32767,
790 input_abs_set_res(input
, ABS_X
, STEAM_DECK_JOYSTICK_RESOLUTION
);
791 input_abs_set_res(input
, ABS_Y
, STEAM_DECK_JOYSTICK_RESOLUTION
);
792 input_abs_set_res(input
, ABS_RX
, STEAM_DECK_JOYSTICK_RESOLUTION
);
793 input_abs_set_res(input
, ABS_RY
, STEAM_DECK_JOYSTICK_RESOLUTION
);
794 input_abs_set_res(input
, ABS_HAT1X
, STEAM_PAD_RESOLUTION
);
795 input_abs_set_res(input
, ABS_HAT1Y
, STEAM_PAD_RESOLUTION
);
796 input_abs_set_res(input
, ABS_HAT2Y
, STEAM_DECK_TRIGGER_RESOLUTION
);
797 input_abs_set_res(input
, ABS_HAT2X
, STEAM_DECK_TRIGGER_RESOLUTION
);
799 input_set_abs_params(input
, ABS_HAT2Y
, 0, 255, 0, 0);
800 input_set_abs_params(input
, ABS_HAT2X
, 0, 255, 0, 0);
802 input_set_abs_params(input
, ABS_RX
, -32767, 32767,
804 input_set_abs_params(input
, ABS_RY
, -32767, 32767,
807 input_abs_set_res(input
, ABS_X
, STEAM_JOYSTICK_RESOLUTION
);
808 input_abs_set_res(input
, ABS_Y
, STEAM_JOYSTICK_RESOLUTION
);
809 input_abs_set_res(input
, ABS_RX
, STEAM_PAD_RESOLUTION
);
810 input_abs_set_res(input
, ABS_RY
, STEAM_PAD_RESOLUTION
);
811 input_abs_set_res(input
, ABS_HAT2Y
, STEAM_TRIGGER_RESOLUTION
);
812 input_abs_set_res(input
, ABS_HAT2X
, STEAM_TRIGGER_RESOLUTION
);
814 input_abs_set_res(input
, ABS_HAT0X
, STEAM_PAD_RESOLUTION
);
815 input_abs_set_res(input
, ABS_HAT0Y
, STEAM_PAD_RESOLUTION
);
817 #ifdef CONFIG_STEAM_FF
818 if (steam
->quirks
& STEAM_QUIRK_DECK
) {
819 input_set_capability(input
, EV_FF
, FF_RUMBLE
);
820 ret
= input_ff_create_memless(input
, NULL
, steam_play_effect
);
822 goto input_register_fail
;
826 ret
= input_register_device(input
);
828 goto input_register_fail
;
830 rcu_assign_pointer(steam
->input
, input
);
834 input_free_device(input
);
838 static int steam_sensors_register(struct steam_device
*steam
)
840 struct hid_device
*hdev
= steam
->hdev
;
841 struct input_dev
*sensors
;
844 if (!(steam
->quirks
& STEAM_QUIRK_DECK
))
848 sensors
= rcu_dereference(steam
->sensors
);
851 dbg_hid("%s: already connected\n", __func__
);
855 sensors
= input_allocate_device();
859 input_set_drvdata(sensors
, steam
);
860 sensors
->dev
.parent
= &hdev
->dev
;
862 sensors
->name
= "Steam Deck Motion Sensors";
863 sensors
->phys
= hdev
->phys
;
864 sensors
->uniq
= steam
->serial_no
;
865 sensors
->id
.bustype
= hdev
->bus
;
866 sensors
->id
.vendor
= hdev
->vendor
;
867 sensors
->id
.product
= hdev
->product
;
868 sensors
->id
.version
= hdev
->version
;
870 __set_bit(INPUT_PROP_ACCELEROMETER
, sensors
->propbit
);
871 __set_bit(EV_MSC
, sensors
->evbit
);
872 __set_bit(MSC_TIMESTAMP
, sensors
->mscbit
);
874 input_set_abs_params(sensors
, ABS_X
, -STEAM_DECK_ACCEL_RANGE
,
875 STEAM_DECK_ACCEL_RANGE
, STEAM_DECK_ACCEL_FUZZ
, 0);
876 input_set_abs_params(sensors
, ABS_Y
, -STEAM_DECK_ACCEL_RANGE
,
877 STEAM_DECK_ACCEL_RANGE
, STEAM_DECK_ACCEL_FUZZ
, 0);
878 input_set_abs_params(sensors
, ABS_Z
, -STEAM_DECK_ACCEL_RANGE
,
879 STEAM_DECK_ACCEL_RANGE
, STEAM_DECK_ACCEL_FUZZ
, 0);
880 input_abs_set_res(sensors
, ABS_X
, STEAM_DECK_ACCEL_RES_PER_G
);
881 input_abs_set_res(sensors
, ABS_Y
, STEAM_DECK_ACCEL_RES_PER_G
);
882 input_abs_set_res(sensors
, ABS_Z
, STEAM_DECK_ACCEL_RES_PER_G
);
884 input_set_abs_params(sensors
, ABS_RX
, -STEAM_DECK_GYRO_RANGE
,
885 STEAM_DECK_GYRO_RANGE
, STEAM_DECK_GYRO_FUZZ
, 0);
886 input_set_abs_params(sensors
, ABS_RY
, -STEAM_DECK_GYRO_RANGE
,
887 STEAM_DECK_GYRO_RANGE
, STEAM_DECK_GYRO_FUZZ
, 0);
888 input_set_abs_params(sensors
, ABS_RZ
, -STEAM_DECK_GYRO_RANGE
,
889 STEAM_DECK_GYRO_RANGE
, STEAM_DECK_GYRO_FUZZ
, 0);
890 input_abs_set_res(sensors
, ABS_RX
, STEAM_DECK_GYRO_RES_PER_DPS
);
891 input_abs_set_res(sensors
, ABS_RY
, STEAM_DECK_GYRO_RES_PER_DPS
);
892 input_abs_set_res(sensors
, ABS_RZ
, STEAM_DECK_GYRO_RES_PER_DPS
);
894 ret
= input_register_device(sensors
);
896 goto sensors_register_fail
;
898 rcu_assign_pointer(steam
->sensors
, sensors
);
901 sensors_register_fail
:
902 input_free_device(sensors
);
906 static void steam_input_unregister(struct steam_device
*steam
)
908 struct input_dev
*input
;
910 input
= rcu_dereference(steam
->input
);
914 RCU_INIT_POINTER(steam
->input
, NULL
);
916 input_unregister_device(input
);
919 static void steam_sensors_unregister(struct steam_device
*steam
)
921 struct input_dev
*sensors
;
923 if (!(steam
->quirks
& STEAM_QUIRK_DECK
))
927 sensors
= rcu_dereference(steam
->sensors
);
932 RCU_INIT_POINTER(steam
->sensors
, NULL
);
934 input_unregister_device(sensors
);
937 static void steam_battery_unregister(struct steam_device
*steam
)
939 struct power_supply
*battery
;
942 battery
= rcu_dereference(steam
->battery
);
947 RCU_INIT_POINTER(steam
->battery
, NULL
);
949 power_supply_unregister(battery
);
952 static int steam_register(struct steam_device
*steam
)
955 unsigned long client_opened
;
959 * This function can be called several times in a row with the
960 * wireless adaptor, without steam_unregister() between them, because
961 * another client send a get_connection_status command, for example.
962 * The battery and serial number are set just once per device.
964 if (!steam
->serial_no
[0]) {
966 * Unlikely, but getting the serial could fail, and it is not so
967 * important, so make up a serial number and go on.
969 if (steam_get_serial(steam
) < 0)
970 strscpy(steam
->serial_no
, "XXXXXXXXXX",
971 sizeof(steam
->serial_no
));
973 hid_info(steam
->hdev
, "Steam Controller '%s' connected",
976 /* ignore battery errors, we can live without it */
977 if (steam
->quirks
& STEAM_QUIRK_WIRELESS
)
978 steam_battery_register(steam
);
980 mutex_lock(&steam_devices_lock
);
981 if (list_empty(&steam
->list
))
982 list_add(&steam
->list
, &steam_devices
);
983 mutex_unlock(&steam_devices_lock
);
986 spin_lock_irqsave(&steam
->lock
, flags
);
987 client_opened
= steam
->client_opened
;
988 spin_unlock_irqrestore(&steam
->lock
, flags
);
990 if (!client_opened
) {
991 steam_set_lizard_mode(steam
, lizard_mode
);
992 ret
= steam_input_register(steam
);
994 goto steam_register_input_fail
;
995 ret
= steam_sensors_register(steam
);
997 goto steam_register_sensors_fail
;
1001 steam_register_sensors_fail
:
1002 steam_input_unregister(steam
);
1003 steam_register_input_fail
:
1007 static void steam_unregister(struct steam_device
*steam
)
1009 steam_battery_unregister(steam
);
1010 steam_sensors_unregister(steam
);
1011 steam_input_unregister(steam
);
1012 if (steam
->serial_no
[0]) {
1013 hid_info(steam
->hdev
, "Steam Controller '%s' disconnected",
1015 mutex_lock(&steam_devices_lock
);
1016 list_del_init(&steam
->list
);
1017 mutex_unlock(&steam_devices_lock
);
1018 steam
->serial_no
[0] = 0;
1022 static void steam_work_connect_cb(struct work_struct
*work
)
1024 struct steam_device
*steam
= container_of(work
, struct steam_device
,
1026 unsigned long flags
;
1030 spin_lock_irqsave(&steam
->lock
, flags
);
1031 connected
= steam
->connected
;
1032 spin_unlock_irqrestore(&steam
->lock
, flags
);
1035 ret
= steam_register(steam
);
1037 hid_err(steam
->hdev
,
1038 "%s:steam_register failed with error %d\n",
1042 steam_unregister(steam
);
1046 static void steam_mode_switch_cb(struct work_struct
*work
)
1048 struct steam_device
*steam
= container_of(to_delayed_work(work
),
1049 struct steam_device
, mode_switch
);
1050 unsigned long flags
;
1052 steam
->gamepad_mode
= !steam
->gamepad_mode
;
1056 if (steam
->gamepad_mode
)
1057 steam_set_lizard_mode(steam
, false);
1059 spin_lock_irqsave(&steam
->lock
, flags
);
1060 client_opened
= steam
->client_opened
;
1061 spin_unlock_irqrestore(&steam
->lock
, flags
);
1063 steam_set_lizard_mode(steam
, lizard_mode
);
1066 steam_haptic_pulse(steam
, STEAM_PAD_RIGHT
, 0x190, 0, 1, 0);
1067 if (steam
->gamepad_mode
) {
1068 steam_haptic_pulse(steam
, STEAM_PAD_LEFT
, 0x14D, 0x14D, 0x2D, 0);
1070 steam_haptic_pulse(steam
, STEAM_PAD_LEFT
, 0x1F4, 0x1F4, 0x1E, 0);
1074 static bool steam_is_valve_interface(struct hid_device
*hdev
)
1076 struct hid_report_enum
*rep_enum
;
1079 * The wired device creates 3 interfaces:
1080 * 0: emulated mouse.
1081 * 1: emulated keyboard.
1082 * 2: the real game pad.
1083 * The wireless device creates 5 interfaces:
1084 * 0: emulated keyboard.
1085 * 1-4: slots where up to 4 real game pads will be connected to.
1086 * We know which one is the real gamepad interface because they are the
1087 * only ones with a feature report.
1089 rep_enum
= &hdev
->report_enum
[HID_FEATURE_REPORT
];
1090 return !list_empty(&rep_enum
->report_list
);
1093 static int steam_client_ll_parse(struct hid_device
*hdev
)
1095 struct steam_device
*steam
= hdev
->driver_data
;
1097 return hid_parse_report(hdev
, steam
->hdev
->dev_rdesc
,
1098 steam
->hdev
->dev_rsize
);
1101 static int steam_client_ll_start(struct hid_device
*hdev
)
1106 static void steam_client_ll_stop(struct hid_device
*hdev
)
1110 static int steam_client_ll_open(struct hid_device
*hdev
)
1112 struct steam_device
*steam
= hdev
->driver_data
;
1113 unsigned long flags
;
1115 spin_lock_irqsave(&steam
->lock
, flags
);
1116 steam
->client_opened
++;
1117 spin_unlock_irqrestore(&steam
->lock
, flags
);
1119 steam_sensors_unregister(steam
);
1120 steam_input_unregister(steam
);
1125 static void steam_client_ll_close(struct hid_device
*hdev
)
1127 struct steam_device
*steam
= hdev
->driver_data
;
1129 unsigned long flags
;
1132 spin_lock_irqsave(&steam
->lock
, flags
);
1133 steam
->client_opened
--;
1134 connected
= steam
->connected
&& !steam
->client_opened
;
1135 spin_unlock_irqrestore(&steam
->lock
, flags
);
1138 steam_set_lizard_mode(steam
, lizard_mode
);
1139 steam_input_register(steam
);
1140 steam_sensors_register(steam
);
1144 static int steam_client_ll_raw_request(struct hid_device
*hdev
,
1145 unsigned char reportnum
, u8
*buf
,
1146 size_t count
, unsigned char report_type
,
1149 struct steam_device
*steam
= hdev
->driver_data
;
1151 return hid_hw_raw_request(steam
->hdev
, reportnum
, buf
, count
,
1152 report_type
, reqtype
);
1155 static const struct hid_ll_driver steam_client_ll_driver
= {
1156 .parse
= steam_client_ll_parse
,
1157 .start
= steam_client_ll_start
,
1158 .stop
= steam_client_ll_stop
,
1159 .open
= steam_client_ll_open
,
1160 .close
= steam_client_ll_close
,
1161 .raw_request
= steam_client_ll_raw_request
,
1164 static struct hid_device
*steam_create_client_hid(struct hid_device
*hdev
)
1166 struct hid_device
*client_hdev
;
1168 client_hdev
= hid_allocate_device();
1169 if (IS_ERR(client_hdev
))
1172 client_hdev
->ll_driver
= &steam_client_ll_driver
;
1173 client_hdev
->dev
.parent
= hdev
->dev
.parent
;
1174 client_hdev
->bus
= hdev
->bus
;
1175 client_hdev
->vendor
= hdev
->vendor
;
1176 client_hdev
->product
= hdev
->product
;
1177 client_hdev
->version
= hdev
->version
;
1178 client_hdev
->type
= hdev
->type
;
1179 client_hdev
->country
= hdev
->country
;
1180 strscpy(client_hdev
->name
, hdev
->name
,
1181 sizeof(client_hdev
->name
));
1182 strscpy(client_hdev
->phys
, hdev
->phys
,
1183 sizeof(client_hdev
->phys
));
1185 * Since we use the same device info than the real interface to
1186 * trick userspace, we will be calling steam_probe recursively.
1187 * We need to recognize the client interface somehow.
1189 client_hdev
->group
= HID_GROUP_STEAM
;
1193 static int steam_probe(struct hid_device
*hdev
,
1194 const struct hid_device_id
*id
)
1196 struct steam_device
*steam
;
1199 ret
= hid_parse(hdev
);
1202 "%s:parse of hid interface failed\n", __func__
);
1207 * The virtual client_dev is only used for hidraw.
1208 * Also avoid the recursive probe.
1210 if (hdev
->group
== HID_GROUP_STEAM
)
1211 return hid_hw_start(hdev
, HID_CONNECT_HIDRAW
);
1213 * The non-valve interfaces (mouse and keyboard emulation) are
1214 * connected without changes.
1216 if (!steam_is_valve_interface(hdev
))
1217 return hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
1219 steam
= devm_kzalloc(&hdev
->dev
, sizeof(*steam
), GFP_KERNEL
);
1224 hid_set_drvdata(hdev
, steam
);
1225 spin_lock_init(&steam
->lock
);
1226 mutex_init(&steam
->report_mutex
);
1227 steam
->quirks
= id
->driver_data
;
1228 INIT_WORK(&steam
->work_connect
, steam_work_connect_cb
);
1229 INIT_DELAYED_WORK(&steam
->mode_switch
, steam_mode_switch_cb
);
1230 INIT_LIST_HEAD(&steam
->list
);
1231 INIT_WORK(&steam
->rumble_work
, steam_haptic_rumble_cb
);
1232 steam
->sensor_timestamp_us
= 0;
1235 * With the real steam controller interface, do not connect hidraw.
1236 * Instead, create the client_hid and connect that.
1238 ret
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
& ~HID_CONNECT_HIDRAW
);
1240 goto err_cancel_work
;
1242 ret
= hid_hw_open(hdev
);
1250 if (steam
->quirks
& STEAM_QUIRK_WIRELESS
) {
1251 hid_info(hdev
, "Steam wireless receiver connected");
1252 /* If using a wireless adaptor ask for connection status */
1253 steam
->connected
= false;
1254 steam_request_conn_status(steam
);
1256 /* A wired connection is always present */
1257 steam
->connected
= true;
1258 ret
= steam_register(steam
);
1261 "%s:steam_register failed with error %d\n",
1267 steam
->client_hdev
= steam_create_client_hid(hdev
);
1268 if (IS_ERR(steam
->client_hdev
)) {
1269 ret
= PTR_ERR(steam
->client_hdev
);
1270 goto err_stream_unregister
;
1272 steam
->client_hdev
->driver_data
= steam
;
1274 ret
= hid_add_device(steam
->client_hdev
);
1281 hid_destroy_device(steam
->client_hdev
);
1282 err_stream_unregister
:
1283 if (steam
->connected
)
1284 steam_unregister(steam
);
1290 cancel_work_sync(&steam
->work_connect
);
1291 cancel_delayed_work_sync(&steam
->mode_switch
);
1292 cancel_work_sync(&steam
->rumble_work
);
1297 static void steam_remove(struct hid_device
*hdev
)
1299 struct steam_device
*steam
= hid_get_drvdata(hdev
);
1301 if (!steam
|| hdev
->group
== HID_GROUP_STEAM
) {
1306 cancel_delayed_work_sync(&steam
->mode_switch
);
1307 cancel_work_sync(&steam
->work_connect
);
1308 hid_destroy_device(steam
->client_hdev
);
1309 steam
->client_hdev
= NULL
;
1310 steam
->client_opened
= 0;
1311 if (steam
->quirks
& STEAM_QUIRK_WIRELESS
) {
1312 hid_info(hdev
, "Steam wireless receiver disconnected");
1316 steam_unregister(steam
);
1319 static void steam_do_connect_event(struct steam_device
*steam
, bool connected
)
1321 unsigned long flags
;
1324 spin_lock_irqsave(&steam
->lock
, flags
);
1325 changed
= steam
->connected
!= connected
;
1326 steam
->connected
= connected
;
1327 spin_unlock_irqrestore(&steam
->lock
, flags
);
1329 if (changed
&& schedule_work(&steam
->work_connect
) == 0)
1330 dbg_hid("%s: connected=%d event already queued\n",
1331 __func__
, connected
);
1335 * Some input data in the protocol has the opposite sign.
1336 * Clamp the values to 32767..-32767 so that the range is
1337 * symmetrical and can be negated safely.
1339 static inline s16
steam_le16(u8
*data
)
1341 s16 x
= (s16
) le16_to_cpup((__le16
*)data
);
1343 return x
== -32768 ? -32767 : x
;
1347 * The size for this message payload is 60.
1348 * The known values are:
1349 * (* values are not sent through wireless)
1350 * (* accelerator/gyro is disabled by default)
1351 * Offset| Type | Mapped to |Meaning
1352 * -------+-------+-----------+--------------------------
1353 * 4-7 | u32 | -- | sequence number
1354 * 8-10 | 24bit | see below | buttons
1355 * 11 | u8 | ABS_HAT2Y | left trigger
1356 * 12 | u8 | ABS_HAT2X | right trigger
1357 * 13-15 | -- | -- | always 0
1358 * 16-17 | s16 | ABS_X/ABS_HAT0X | X value
1359 * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value
1360 * 20-21 | s16 | ABS_RX | right-pad X value
1361 * 22-23 | s16 | ABS_RY | right-pad Y value
1362 * 24-25 | s16 | -- | * left trigger
1363 * 26-27 | s16 | -- | * right trigger
1364 * 28-29 | s16 | -- | * accelerometer X value
1365 * 30-31 | s16 | -- | * accelerometer Y value
1366 * 32-33 | s16 | -- | * accelerometer Z value
1367 * 34-35 | s16 | -- | gyro X value
1368 * 36-36 | s16 | -- | gyro Y value
1369 * 38-39 | s16 | -- | gyro Z value
1370 * 40-41 | s16 | -- | quaternion W value
1371 * 42-43 | s16 | -- | quaternion X value
1372 * 44-45 | s16 | -- | quaternion Y value
1373 * 46-47 | s16 | -- | quaternion Z value
1374 * 48-49 | -- | -- | always 0
1375 * 50-51 | s16 | -- | * left trigger (uncalibrated)
1376 * 52-53 | s16 | -- | * right trigger (uncalibrated)
1377 * 54-55 | s16 | -- | * joystick X value (uncalibrated)
1378 * 56-57 | s16 | -- | * joystick Y value (uncalibrated)
1379 * 58-59 | s16 | -- | * left-pad X value
1380 * 60-61 | s16 | -- | * left-pad Y value
1381 * 62-63 | u16 | -- | * battery voltage
1384 * Bit | Mapped to | Description
1385 * ------+------------+--------------------------------
1386 * 8.0 | BTN_TR2 | right trigger fully pressed
1387 * 8.1 | BTN_TL2 | left trigger fully pressed
1388 * 8.2 | BTN_TR | right shoulder
1389 * 8.3 | BTN_TL | left shoulder
1390 * 8.4 | BTN_Y | button Y
1391 * 8.5 | BTN_B | button B
1392 * 8.6 | BTN_X | button X
1393 * 8.7 | BTN_A | button A
1394 * 9.0 | BTN_DPAD_UP | left-pad up
1395 * 9.1 | BTN_DPAD_RIGHT | left-pad right
1396 * 9.2 | BTN_DPAD_LEFT | left-pad left
1397 * 9.3 | BTN_DPAD_DOWN | left-pad down
1398 * 9.4 | BTN_SELECT | menu left
1399 * 9.5 | BTN_MODE | steam logo
1400 * 9.6 | BTN_START | menu right
1401 * 9.7 | BTN_GEAR_DOWN | left back lever
1402 * 10.0 | BTN_GEAR_UP | right back lever
1403 * 10.1 | -- | left-pad clicked
1404 * 10.2 | BTN_THUMBR | right-pad clicked
1405 * 10.3 | BTN_THUMB | left-pad touched (but see explanation below)
1406 * 10.4 | BTN_THUMB2 | right-pad touched
1407 * 10.5 | -- | unknown
1408 * 10.6 | BTN_THUMBL | joystick clicked
1409 * 10.7 | -- | lpad_and_joy
1412 static void steam_do_input_event(struct steam_device
*steam
,
1413 struct input_dev
*input
, u8
*data
)
1415 /* 24 bits of buttons */
1418 bool lpad_touched
, lpad_and_joy
;
1424 input_report_abs(input
, ABS_HAT2Y
, data
[11]);
1425 input_report_abs(input
, ABS_HAT2X
, data
[12]);
1428 * These two bits tells how to interpret the values X and Y.
1429 * lpad_and_joy tells that the joystick and the lpad are used at the
1431 * lpad_touched tells whether X/Y are to be read as lpad coord or
1433 * (lpad_touched || lpad_and_joy) tells if the lpad is really touched.
1435 lpad_touched
= b10
& BIT(3);
1436 lpad_and_joy
= b10
& BIT(7);
1437 x
= steam_le16(data
+ 16);
1438 y
= -steam_le16(data
+ 18);
1440 input_report_abs(input
, lpad_touched
? ABS_HAT0X
: ABS_X
, x
);
1441 input_report_abs(input
, lpad_touched
? ABS_HAT0Y
: ABS_Y
, y
);
1442 /* Check if joystick is centered */
1443 if (lpad_touched
&& !lpad_and_joy
) {
1444 input_report_abs(input
, ABS_X
, 0);
1445 input_report_abs(input
, ABS_Y
, 0);
1447 /* Check if lpad is untouched */
1448 if (!(lpad_touched
|| lpad_and_joy
)) {
1449 input_report_abs(input
, ABS_HAT0X
, 0);
1450 input_report_abs(input
, ABS_HAT0Y
, 0);
1453 input_report_abs(input
, ABS_RX
, steam_le16(data
+ 20));
1454 input_report_abs(input
, ABS_RY
, -steam_le16(data
+ 22));
1456 input_event(input
, EV_KEY
, BTN_TR2
, !!(b8
& BIT(0)));
1457 input_event(input
, EV_KEY
, BTN_TL2
, !!(b8
& BIT(1)));
1458 input_event(input
, EV_KEY
, BTN_TR
, !!(b8
& BIT(2)));
1459 input_event(input
, EV_KEY
, BTN_TL
, !!(b8
& BIT(3)));
1460 input_event(input
, EV_KEY
, BTN_Y
, !!(b8
& BIT(4)));
1461 input_event(input
, EV_KEY
, BTN_B
, !!(b8
& BIT(5)));
1462 input_event(input
, EV_KEY
, BTN_X
, !!(b8
& BIT(6)));
1463 input_event(input
, EV_KEY
, BTN_A
, !!(b8
& BIT(7)));
1464 input_event(input
, EV_KEY
, BTN_SELECT
, !!(b9
& BIT(4)));
1465 input_event(input
, EV_KEY
, BTN_MODE
, !!(b9
& BIT(5)));
1466 input_event(input
, EV_KEY
, BTN_START
, !!(b9
& BIT(6)));
1467 input_event(input
, EV_KEY
, BTN_GEAR_DOWN
, !!(b9
& BIT(7)));
1468 input_event(input
, EV_KEY
, BTN_GEAR_UP
, !!(b10
& BIT(0)));
1469 input_event(input
, EV_KEY
, BTN_THUMBR
, !!(b10
& BIT(2)));
1470 input_event(input
, EV_KEY
, BTN_THUMBL
, !!(b10
& BIT(6)));
1471 input_event(input
, EV_KEY
, BTN_THUMB
, lpad_touched
|| lpad_and_joy
);
1472 input_event(input
, EV_KEY
, BTN_THUMB2
, !!(b10
& BIT(4)));
1473 input_event(input
, EV_KEY
, BTN_DPAD_UP
, !!(b9
& BIT(0)));
1474 input_event(input
, EV_KEY
, BTN_DPAD_RIGHT
, !!(b9
& BIT(1)));
1475 input_event(input
, EV_KEY
, BTN_DPAD_LEFT
, !!(b9
& BIT(2)));
1476 input_event(input
, EV_KEY
, BTN_DPAD_DOWN
, !!(b9
& BIT(3)));
1482 * The size for this message payload is 56.
1483 * The known values are:
1484 * Offset| Type | Mapped to |Meaning
1485 * -------+-------+-----------+--------------------------
1486 * 4-7 | u32 | -- | sequence number
1487 * 8-15 | u64 | see below | buttons
1488 * 16-17 | s16 | ABS_HAT0X | left-pad X value
1489 * 18-19 | s16 | ABS_HAT0Y | left-pad Y value
1490 * 20-21 | s16 | ABS_HAT1X | right-pad X value
1491 * 22-23 | s16 | ABS_HAT1Y | right-pad Y value
1492 * 24-25 | s16 | IMU ABS_X | accelerometer X value
1493 * 26-27 | s16 | IMU ABS_Z | accelerometer Y value
1494 * 28-29 | s16 | IMU ABS_Y | accelerometer Z value
1495 * 30-31 | s16 | IMU ABS_RX | gyro X value
1496 * 32-33 | s16 | IMU ABS_RZ | gyro Y value
1497 * 34-35 | s16 | IMU ABS_RY | gyro Z value
1498 * 36-37 | s16 | -- | quaternion W value
1499 * 38-39 | s16 | -- | quaternion X value
1500 * 40-41 | s16 | -- | quaternion Y value
1501 * 42-43 | s16 | -- | quaternion Z value
1502 * 44-45 | u16 | ABS_HAT2Y | left trigger (uncalibrated)
1503 * 46-47 | u16 | ABS_HAT2X | right trigger (uncalibrated)
1504 * 48-49 | s16 | ABS_X | left joystick X
1505 * 50-51 | s16 | ABS_Y | left joystick Y
1506 * 52-53 | s16 | ABS_RX | right joystick X
1507 * 54-55 | s16 | ABS_RY | right joystick Y
1508 * 56-57 | u16 | -- | left pad pressure
1509 * 58-59 | u16 | -- | right pad pressure
1512 * Bit | Mapped to | Description
1513 * ------+------------+--------------------------------
1514 * 8.0 | BTN_TR2 | right trigger fully pressed
1515 * 8.1 | BTN_TL2 | left trigger fully pressed
1516 * 8.2 | BTN_TR | right shoulder
1517 * 8.3 | BTN_TL | left shoulder
1518 * 8.4 | BTN_Y | button Y
1519 * 8.5 | BTN_B | button B
1520 * 8.6 | BTN_X | button X
1521 * 8.7 | BTN_A | button A
1522 * 9.0 | BTN_DPAD_UP | left-pad up
1523 * 9.1 | BTN_DPAD_RIGHT | left-pad right
1524 * 9.2 | BTN_DPAD_LEFT | left-pad left
1525 * 9.3 | BTN_DPAD_DOWN | left-pad down
1526 * 9.4 | BTN_SELECT | menu left
1527 * 9.5 | BTN_MODE | steam logo
1528 * 9.6 | BTN_START | menu right
1529 * 9.7 | BTN_TRIGGER_HAPPY3 | left bottom grip button
1530 * 10.0 | BTN_TRIGGER_HAPPY4 | right bottom grip button
1531 * 10.1 | BTN_THUMB | left pad pressed
1532 * 10.2 | BTN_THUMB2 | right pad pressed
1533 * 10.3 | -- | left pad touched
1534 * 10.4 | -- | right pad touched
1535 * 10.5 | -- | unknown
1536 * 10.6 | BTN_THUMBL | left joystick clicked
1537 * 10.7 | -- | unknown
1538 * 11.0 | -- | unknown
1539 * 11.1 | -- | unknown
1540 * 11.2 | BTN_THUMBR | right joystick clicked
1541 * 11.3 | -- | unknown
1542 * 11.4 | -- | unknown
1543 * 11.5 | -- | unknown
1544 * 11.6 | -- | unknown
1545 * 11.7 | -- | unknown
1546 * 12.0 | -- | unknown
1547 * 12.1 | -- | unknown
1548 * 12.2 | -- | unknown
1549 * 12.3 | -- | unknown
1550 * 12.4 | -- | unknown
1551 * 12.5 | -- | unknown
1552 * 12.6 | -- | unknown
1553 * 12.7 | -- | unknown
1554 * 13.0 | -- | unknown
1555 * 13.1 | BTN_TRIGGER_HAPPY1 | left top grip button
1556 * 13.2 | BTN_TRIGGER_HAPPY2 | right top grip button
1557 * 13.3 | -- | unknown
1558 * 13.4 | -- | unknown
1559 * 13.5 | -- | unknown
1560 * 13.6 | -- | left joystick touched
1561 * 13.7 | -- | right joystick touched
1562 * 14.0 | -- | unknown
1563 * 14.1 | -- | unknown
1564 * 14.2 | BTN_BASE | quick access button
1565 * 14.3 | -- | unknown
1566 * 14.4 | -- | unknown
1567 * 14.5 | -- | unknown
1568 * 14.6 | -- | unknown
1569 * 14.7 | -- | unknown
1570 * 15.0 | -- | unknown
1571 * 15.1 | -- | unknown
1572 * 15.2 | -- | unknown
1573 * 15.3 | -- | unknown
1574 * 15.4 | -- | unknown
1575 * 15.5 | -- | unknown
1576 * 15.6 | -- | unknown
1577 * 15.7 | -- | unknown
1579 static void steam_do_deck_input_event(struct steam_device
*steam
,
1580 struct input_dev
*input
, u8
*data
)
1582 u8 b8
, b9
, b10
, b11
, b13
, b14
;
1583 bool lpad_touched
, rpad_touched
;
1592 if (!(b9
& BIT(6)) && steam
->did_mode_switch
) {
1593 steam
->did_mode_switch
= false;
1594 cancel_delayed_work_sync(&steam
->mode_switch
);
1595 } else if (!steam
->client_opened
&& (b9
& BIT(6)) && !steam
->did_mode_switch
) {
1596 steam
->did_mode_switch
= true;
1597 schedule_delayed_work(&steam
->mode_switch
, 45 * HZ
/ 100);
1600 if (!steam
->gamepad_mode
)
1603 lpad_touched
= b10
& BIT(3);
1604 rpad_touched
= b10
& BIT(4);
1607 input_report_abs(input
, ABS_HAT0X
, steam_le16(data
+ 16));
1608 input_report_abs(input
, ABS_HAT0Y
, steam_le16(data
+ 18));
1610 input_report_abs(input
, ABS_HAT0X
, 0);
1611 input_report_abs(input
, ABS_HAT0Y
, 0);
1615 input_report_abs(input
, ABS_HAT1X
, steam_le16(data
+ 20));
1616 input_report_abs(input
, ABS_HAT1Y
, steam_le16(data
+ 22));
1618 input_report_abs(input
, ABS_HAT1X
, 0);
1619 input_report_abs(input
, ABS_HAT1Y
, 0);
1622 input_report_abs(input
, ABS_X
, steam_le16(data
+ 48));
1623 input_report_abs(input
, ABS_Y
, -steam_le16(data
+ 50));
1624 input_report_abs(input
, ABS_RX
, steam_le16(data
+ 52));
1625 input_report_abs(input
, ABS_RY
, -steam_le16(data
+ 54));
1627 input_report_abs(input
, ABS_HAT2Y
, steam_le16(data
+ 44));
1628 input_report_abs(input
, ABS_HAT2X
, steam_le16(data
+ 46));
1630 input_event(input
, EV_KEY
, BTN_TR2
, !!(b8
& BIT(0)));
1631 input_event(input
, EV_KEY
, BTN_TL2
, !!(b8
& BIT(1)));
1632 input_event(input
, EV_KEY
, BTN_TR
, !!(b8
& BIT(2)));
1633 input_event(input
, EV_KEY
, BTN_TL
, !!(b8
& BIT(3)));
1634 input_event(input
, EV_KEY
, BTN_Y
, !!(b8
& BIT(4)));
1635 input_event(input
, EV_KEY
, BTN_B
, !!(b8
& BIT(5)));
1636 input_event(input
, EV_KEY
, BTN_X
, !!(b8
& BIT(6)));
1637 input_event(input
, EV_KEY
, BTN_A
, !!(b8
& BIT(7)));
1638 input_event(input
, EV_KEY
, BTN_SELECT
, !!(b9
& BIT(4)));
1639 input_event(input
, EV_KEY
, BTN_MODE
, !!(b9
& BIT(5)));
1640 input_event(input
, EV_KEY
, BTN_START
, !!(b9
& BIT(6)));
1641 input_event(input
, EV_KEY
, BTN_TRIGGER_HAPPY3
, !!(b9
& BIT(7)));
1642 input_event(input
, EV_KEY
, BTN_TRIGGER_HAPPY4
, !!(b10
& BIT(0)));
1643 input_event(input
, EV_KEY
, BTN_THUMBL
, !!(b10
& BIT(6)));
1644 input_event(input
, EV_KEY
, BTN_THUMBR
, !!(b11
& BIT(2)));
1645 input_event(input
, EV_KEY
, BTN_DPAD_UP
, !!(b9
& BIT(0)));
1646 input_event(input
, EV_KEY
, BTN_DPAD_RIGHT
, !!(b9
& BIT(1)));
1647 input_event(input
, EV_KEY
, BTN_DPAD_LEFT
, !!(b9
& BIT(2)));
1648 input_event(input
, EV_KEY
, BTN_DPAD_DOWN
, !!(b9
& BIT(3)));
1649 input_event(input
, EV_KEY
, BTN_THUMB
, !!(b10
& BIT(1)));
1650 input_event(input
, EV_KEY
, BTN_THUMB2
, !!(b10
& BIT(2)));
1651 input_event(input
, EV_KEY
, BTN_TRIGGER_HAPPY1
, !!(b13
& BIT(1)));
1652 input_event(input
, EV_KEY
, BTN_TRIGGER_HAPPY2
, !!(b13
& BIT(2)));
1653 input_event(input
, EV_KEY
, BTN_BASE
, !!(b14
& BIT(2)));
1658 static void steam_do_deck_sensors_event(struct steam_device
*steam
,
1659 struct input_dev
*sensors
, u8
*data
)
1662 * The deck input report is received every 4 ms on average,
1663 * with a jitter of +/- 4 ms even though the USB descriptor claims
1664 * that it uses 1 kHz.
1665 * Since the HID report does not include a sensor timestamp,
1666 * use a fixed increment here.
1668 steam
->sensor_timestamp_us
+= 4000;
1670 if (!steam
->gamepad_mode
)
1673 input_event(sensors
, EV_MSC
, MSC_TIMESTAMP
, steam
->sensor_timestamp_us
);
1674 input_report_abs(sensors
, ABS_X
, steam_le16(data
+ 24));
1675 input_report_abs(sensors
, ABS_Z
, -steam_le16(data
+ 26));
1676 input_report_abs(sensors
, ABS_Y
, steam_le16(data
+ 28));
1677 input_report_abs(sensors
, ABS_RX
, steam_le16(data
+ 30));
1678 input_report_abs(sensors
, ABS_RZ
, -steam_le16(data
+ 32));
1679 input_report_abs(sensors
, ABS_RY
, steam_le16(data
+ 34));
1681 input_sync(sensors
);
1685 * The size for this message payload is 11.
1686 * The known values are:
1687 * Offset| Type | Meaning
1688 * -------+-------+---------------------------
1689 * 4-7 | u32 | sequence number
1690 * 8-11 | -- | always 0
1691 * 12-13 | u16 | voltage (mV)
1692 * 14 | u8 | battery percent
1694 static void steam_do_battery_event(struct steam_device
*steam
,
1695 struct power_supply
*battery
, u8
*data
)
1697 unsigned long flags
;
1699 s16 volts
= steam_le16(data
+ 12);
1702 /* Creating the battery may have failed */
1704 battery
= rcu_dereference(steam
->battery
);
1705 if (likely(battery
)) {
1706 spin_lock_irqsave(&steam
->lock
, flags
);
1707 steam
->voltage
= volts
;
1708 steam
->battery_charge
= batt
;
1709 spin_unlock_irqrestore(&steam
->lock
, flags
);
1710 power_supply_changed(battery
);
1715 static int steam_raw_event(struct hid_device
*hdev
,
1716 struct hid_report
*report
, u8
*data
,
1719 struct steam_device
*steam
= hid_get_drvdata(hdev
);
1720 struct input_dev
*input
;
1721 struct input_dev
*sensors
;
1722 struct power_supply
*battery
;
1727 if (steam
->client_opened
)
1728 hid_input_report(steam
->client_hdev
, HID_FEATURE_REPORT
,
1731 * All messages are size=64, all values little-endian.
1734 * -------+--------------------------------------------
1735 * 0-1 | always 0x01, 0x00, maybe protocol version?
1736 * 2 | type of message
1737 * 3 | length of the real payload (not checked)
1738 * 4-n | payload data, depends on the type
1740 * There are these known types of message:
1741 * 0x01: input data (60 bytes)
1742 * 0x03: wireless connect/disconnect (1 byte)
1743 * 0x04: battery status (11 bytes)
1744 * 0x09: Steam Deck input data (56 bytes)
1747 if (size
!= 64 || data
[0] != 1 || data
[1] != 0)
1751 case ID_CONTROLLER_STATE
:
1752 if (steam
->client_opened
)
1755 input
= rcu_dereference(steam
->input
);
1757 steam_do_input_event(steam
, input
, data
);
1760 case ID_CONTROLLER_DECK_STATE
:
1761 if (steam
->client_opened
)
1764 input
= rcu_dereference(steam
->input
);
1766 steam_do_deck_input_event(steam
, input
, data
);
1767 sensors
= rcu_dereference(steam
->sensors
);
1768 if (likely(sensors
))
1769 steam_do_deck_sensors_event(steam
, sensors
, data
);
1772 case ID_CONTROLLER_WIRELESS
:
1774 * The payload of this event is a single byte:
1775 * 0x01: disconnected.
1780 steam_do_connect_event(steam
, false);
1783 steam_do_connect_event(steam
, true);
1787 case ID_CONTROLLER_STATUS
:
1788 if (steam
->quirks
& STEAM_QUIRK_WIRELESS
) {
1790 battery
= rcu_dereference(steam
->battery
);
1791 if (likely(battery
)) {
1792 steam_do_battery_event(steam
, battery
, data
);
1795 "%s: battery data without connect event\n",
1797 steam_do_connect_event(steam
, true);
1806 static int steam_param_set_lizard_mode(const char *val
,
1807 const struct kernel_param
*kp
)
1809 struct steam_device
*steam
;
1812 ret
= param_set_bool(val
, kp
);
1816 mutex_lock(&steam_devices_lock
);
1817 list_for_each_entry(steam
, &steam_devices
, list
) {
1818 if (!steam
->client_opened
)
1819 steam_set_lizard_mode(steam
, lizard_mode
);
1821 mutex_unlock(&steam_devices_lock
);
1825 static const struct kernel_param_ops steam_lizard_mode_ops
= {
1826 .set
= steam_param_set_lizard_mode
,
1827 .get
= param_get_bool
,
1830 module_param_cb(lizard_mode
, &steam_lizard_mode_ops
, &lizard_mode
, 0644);
1831 MODULE_PARM_DESC(lizard_mode
,
1832 "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use");
1834 static const struct hid_device_id steam_controllers
[] = {
1835 { /* Wired Steam Controller */
1836 HID_USB_DEVICE(USB_VENDOR_ID_VALVE
,
1837 USB_DEVICE_ID_STEAM_CONTROLLER
)
1839 { /* Wireless Steam Controller */
1840 HID_USB_DEVICE(USB_VENDOR_ID_VALVE
,
1841 USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS
),
1842 .driver_data
= STEAM_QUIRK_WIRELESS
1845 HID_USB_DEVICE(USB_VENDOR_ID_VALVE
,
1846 USB_DEVICE_ID_STEAM_DECK
),
1847 .driver_data
= STEAM_QUIRK_DECK
1852 MODULE_DEVICE_TABLE(hid
, steam_controllers
);
1854 static struct hid_driver steam_controller_driver
= {
1855 .name
= "hid-steam",
1856 .id_table
= steam_controllers
,
1857 .probe
= steam_probe
,
1858 .remove
= steam_remove
,
1859 .raw_event
= steam_raw_event
,
1862 module_hid_driver(steam_controller_driver
);