Loading...
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 *
7 * Supports both the wired and wireless interfaces.
8 *
9 * This controller has a builtin emulation of mouse and keyboard: the right pad
10 * can be used as a mouse, the shoulder buttons are mouse buttons, A and B
11 * buttons are ENTER and ESCAPE, and so on. This is implemented as additional
12 * HID interfaces.
13 *
14 * This is known as the "lizard mode", because apparently lizards like to use
15 * the computer from the coach, without a proper mouse and keyboard.
16 *
17 * This driver will disable the lizard mode when the input device is opened
18 * and re-enable it when the input device is closed, so as not to break user
19 * mode behaviour. The lizard_mode parameter can be used to change that.
20 *
21 * There are a few user space applications (notably Steam Client) that use
22 * the hidraw interface directly to create input devices (XTest, uinput...).
23 * In order to avoid breaking them this driver creates a layered hidraw device,
24 * so it can detect when the client is running and then:
25 * - it will not send any command to the controller.
26 * - this input device will be removed, to avoid double input of the same
27 * user action.
28 * When the client is closed, this input device will be created again.
29 *
30 * For additional functions, such as changing the right-pad margin or switching
31 * the led, you can use the user-space tool at:
32 *
33 * https://github.com/rodrigorc/steamctrl
34 */
35
36#include <linux/device.h>
37#include <linux/input.h>
38#include <linux/hid.h>
39#include <linux/module.h>
40#include <linux/workqueue.h>
41#include <linux/mutex.h>
42#include <linux/rcupdate.h>
43#include <linux/delay.h>
44#include <linux/power_supply.h>
45#include "hid-ids.h"
46
47MODULE_LICENSE("GPL");
48MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>");
49
50static bool lizard_mode = true;
51
52static DEFINE_MUTEX(steam_devices_lock);
53static LIST_HEAD(steam_devices);
54
55#define STEAM_QUIRK_WIRELESS BIT(0)
56
57/* Touch pads are 40 mm in diameter and 65535 units */
58#define STEAM_PAD_RESOLUTION 1638
59/* Trigger runs are about 5 mm and 256 units */
60#define STEAM_TRIGGER_RESOLUTION 51
61/* Joystick runs are about 5 mm and 256 units */
62#define STEAM_JOYSTICK_RESOLUTION 51
63
64#define STEAM_PAD_FUZZ 256
65
66/*
67 * Commands that can be sent in a feature report.
68 * Thanks to Valve for some valuable hints.
69 */
70#define STEAM_CMD_SET_MAPPINGS 0x80
71#define STEAM_CMD_CLEAR_MAPPINGS 0x81
72#define STEAM_CMD_GET_MAPPINGS 0x82
73#define STEAM_CMD_GET_ATTRIB 0x83
74#define STEAM_CMD_GET_ATTRIB_LABEL 0x84
75#define STEAM_CMD_DEFAULT_MAPPINGS 0x85
76#define STEAM_CMD_FACTORY_RESET 0x86
77#define STEAM_CMD_WRITE_REGISTER 0x87
78#define STEAM_CMD_CLEAR_REGISTER 0x88
79#define STEAM_CMD_READ_REGISTER 0x89
80#define STEAM_CMD_GET_REGISTER_LABEL 0x8a
81#define STEAM_CMD_GET_REGISTER_MAX 0x8b
82#define STEAM_CMD_GET_REGISTER_DEFAULT 0x8c
83#define STEAM_CMD_SET_MODE 0x8d
84#define STEAM_CMD_DEFAULT_MOUSE 0x8e
85#define STEAM_CMD_FORCEFEEDBAK 0x8f
86#define STEAM_CMD_REQUEST_COMM_STATUS 0xb4
87#define STEAM_CMD_GET_SERIAL 0xae
88
89/* Some useful register ids */
90#define STEAM_REG_LPAD_MODE 0x07
91#define STEAM_REG_RPAD_MODE 0x08
92#define STEAM_REG_RPAD_MARGIN 0x18
93#define STEAM_REG_LED 0x2d
94#define STEAM_REG_GYRO_MODE 0x30
95
96/* Raw event identifiers */
97#define STEAM_EV_INPUT_DATA 0x01
98#define STEAM_EV_CONNECT 0x03
99#define STEAM_EV_BATTERY 0x04
100
101/* Values for GYRO_MODE (bitmask) */
102#define STEAM_GYRO_MODE_OFF 0x0000
103#define STEAM_GYRO_MODE_STEERING 0x0001
104#define STEAM_GYRO_MODE_TILT 0x0002
105#define STEAM_GYRO_MODE_SEND_ORIENTATION 0x0004
106#define STEAM_GYRO_MODE_SEND_RAW_ACCEL 0x0008
107#define STEAM_GYRO_MODE_SEND_RAW_GYRO 0x0010
108
109/* Other random constants */
110#define STEAM_SERIAL_LEN 10
111
112struct steam_device {
113 struct list_head list;
114 spinlock_t lock;
115 struct hid_device *hdev, *client_hdev;
116 struct mutex mutex;
117 bool client_opened;
118 struct input_dev __rcu *input;
119 unsigned long quirks;
120 struct work_struct work_connect;
121 bool connected;
122 char serial_no[STEAM_SERIAL_LEN + 1];
123 struct power_supply_desc battery_desc;
124 struct power_supply __rcu *battery;
125 u8 battery_charge;
126 u16 voltage;
127};
128
129static int steam_recv_report(struct steam_device *steam,
130 u8 *data, int size)
131{
132 struct hid_report *r;
133 u8 *buf;
134 int ret;
135
136 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
137 if (hid_report_len(r) < 64)
138 return -EINVAL;
139
140 buf = hid_alloc_report_buf(r, GFP_KERNEL);
141 if (!buf)
142 return -ENOMEM;
143
144 /*
145 * The report ID is always 0, so strip the first byte from the output.
146 * hid_report_len() is not counting the report ID, so +1 to the length
147 * or else we get a EOVERFLOW. We are safe from a buffer overflow
148 * because hid_alloc_report_buf() allocates +7 bytes.
149 */
150 ret = hid_hw_raw_request(steam->hdev, 0x00,
151 buf, hid_report_len(r) + 1,
152 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
153 if (ret > 0)
154 memcpy(data, buf + 1, min(size, ret - 1));
155 kfree(buf);
156 return ret;
157}
158
159static int steam_send_report(struct steam_device *steam,
160 u8 *cmd, int size)
161{
162 struct hid_report *r;
163 u8 *buf;
164 unsigned int retries = 50;
165 int ret;
166
167 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
168 if (hid_report_len(r) < 64)
169 return -EINVAL;
170
171 buf = hid_alloc_report_buf(r, GFP_KERNEL);
172 if (!buf)
173 return -ENOMEM;
174
175 /* The report ID is always 0 */
176 memcpy(buf + 1, cmd, size);
177
178 /*
179 * Sometimes the wireless controller fails with EPIPE
180 * when sending a feature report.
181 * Doing a HID_REQ_GET_REPORT and waiting for a while
182 * seems to fix that.
183 */
184 do {
185 ret = hid_hw_raw_request(steam->hdev, 0,
186 buf, size + 1,
187 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
188 if (ret != -EPIPE)
189 break;
190 msleep(20);
191 } while (--retries);
192
193 kfree(buf);
194 if (ret < 0)
195 hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__,
196 ret, size, cmd);
197 return ret;
198}
199
200static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd)
201{
202 return steam_send_report(steam, &cmd, 1);
203}
204
205static int steam_write_registers(struct steam_device *steam,
206 /* u8 reg, u16 val */...)
207{
208 /* Send: 0x87 len (reg valLo valHi)* */
209 u8 reg;
210 u16 val;
211 u8 cmd[64] = {STEAM_CMD_WRITE_REGISTER, 0x00};
212 va_list args;
213
214 va_start(args, steam);
215 for (;;) {
216 reg = va_arg(args, int);
217 if (reg == 0)
218 break;
219 val = va_arg(args, int);
220 cmd[cmd[1] + 2] = reg;
221 cmd[cmd[1] + 3] = val & 0xff;
222 cmd[cmd[1] + 4] = val >> 8;
223 cmd[1] += 3;
224 }
225 va_end(args);
226
227 return steam_send_report(steam, cmd, 2 + cmd[1]);
228}
229
230static int steam_get_serial(struct steam_device *steam)
231{
232 /*
233 * Send: 0xae 0x15 0x01
234 * Recv: 0xae 0x15 0x01 serialnumber (10 chars)
235 */
236 int ret;
237 u8 cmd[] = {STEAM_CMD_GET_SERIAL, 0x15, 0x01};
238 u8 reply[3 + STEAM_SERIAL_LEN + 1];
239
240 ret = steam_send_report(steam, cmd, sizeof(cmd));
241 if (ret < 0)
242 return ret;
243 ret = steam_recv_report(steam, reply, sizeof(reply));
244 if (ret < 0)
245 return ret;
246 if (reply[0] != 0xae || reply[1] != 0x15 || reply[2] != 0x01)
247 return -EIO;
248 reply[3 + STEAM_SERIAL_LEN] = 0;
249 strlcpy(steam->serial_no, reply + 3, sizeof(steam->serial_no));
250 return 0;
251}
252
253/*
254 * This command requests the wireless adaptor to post an event
255 * with the connection status. Useful if this driver is loaded when
256 * the controller is already connected.
257 */
258static inline int steam_request_conn_status(struct steam_device *steam)
259{
260 return steam_send_report_byte(steam, STEAM_CMD_REQUEST_COMM_STATUS);
261}
262
263static void steam_set_lizard_mode(struct steam_device *steam, bool enable)
264{
265 if (enable) {
266 /* enable esc, enter, cursors */
267 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MAPPINGS);
268 /* enable mouse */
269 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MOUSE);
270 steam_write_registers(steam,
271 STEAM_REG_RPAD_MARGIN, 0x01, /* enable margin */
272 0);
273 } else {
274 /* disable esc, enter, cursor */
275 steam_send_report_byte(steam, STEAM_CMD_CLEAR_MAPPINGS);
276 steam_write_registers(steam,
277 STEAM_REG_RPAD_MODE, 0x07, /* disable mouse */
278 STEAM_REG_RPAD_MARGIN, 0x00, /* disable margin */
279 0);
280 }
281}
282
283static int steam_input_open(struct input_dev *dev)
284{
285 struct steam_device *steam = input_get_drvdata(dev);
286
287 mutex_lock(&steam->mutex);
288 if (!steam->client_opened && lizard_mode)
289 steam_set_lizard_mode(steam, false);
290 mutex_unlock(&steam->mutex);
291 return 0;
292}
293
294static void steam_input_close(struct input_dev *dev)
295{
296 struct steam_device *steam = input_get_drvdata(dev);
297
298 mutex_lock(&steam->mutex);
299 if (!steam->client_opened && lizard_mode)
300 steam_set_lizard_mode(steam, true);
301 mutex_unlock(&steam->mutex);
302}
303
304static enum power_supply_property steam_battery_props[] = {
305 POWER_SUPPLY_PROP_PRESENT,
306 POWER_SUPPLY_PROP_SCOPE,
307 POWER_SUPPLY_PROP_VOLTAGE_NOW,
308 POWER_SUPPLY_PROP_CAPACITY,
309};
310
311static int steam_battery_get_property(struct power_supply *psy,
312 enum power_supply_property psp,
313 union power_supply_propval *val)
314{
315 struct steam_device *steam = power_supply_get_drvdata(psy);
316 unsigned long flags;
317 s16 volts;
318 u8 batt;
319 int ret = 0;
320
321 spin_lock_irqsave(&steam->lock, flags);
322 volts = steam->voltage;
323 batt = steam->battery_charge;
324 spin_unlock_irqrestore(&steam->lock, flags);
325
326 switch (psp) {
327 case POWER_SUPPLY_PROP_PRESENT:
328 val->intval = 1;
329 break;
330 case POWER_SUPPLY_PROP_SCOPE:
331 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
332 break;
333 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
334 val->intval = volts * 1000; /* mV -> uV */
335 break;
336 case POWER_SUPPLY_PROP_CAPACITY:
337 val->intval = batt;
338 break;
339 default:
340 ret = -EINVAL;
341 break;
342 }
343 return ret;
344}
345
346static int steam_battery_register(struct steam_device *steam)
347{
348 struct power_supply *battery;
349 struct power_supply_config battery_cfg = { .drv_data = steam, };
350 unsigned long flags;
351 int ret;
352
353 steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
354 steam->battery_desc.properties = steam_battery_props;
355 steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props);
356 steam->battery_desc.get_property = steam_battery_get_property;
357 steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev,
358 GFP_KERNEL, "steam-controller-%s-battery",
359 steam->serial_no);
360 if (!steam->battery_desc.name)
361 return -ENOMEM;
362
363 /* avoid the warning of 0% battery while waiting for the first info */
364 spin_lock_irqsave(&steam->lock, flags);
365 steam->voltage = 3000;
366 steam->battery_charge = 100;
367 spin_unlock_irqrestore(&steam->lock, flags);
368
369 battery = power_supply_register(&steam->hdev->dev,
370 &steam->battery_desc, &battery_cfg);
371 if (IS_ERR(battery)) {
372 ret = PTR_ERR(battery);
373 hid_err(steam->hdev,
374 "%s:power_supply_register failed with error %d\n",
375 __func__, ret);
376 return ret;
377 }
378 rcu_assign_pointer(steam->battery, battery);
379 power_supply_powers(battery, &steam->hdev->dev);
380 return 0;
381}
382
383static int steam_input_register(struct steam_device *steam)
384{
385 struct hid_device *hdev = steam->hdev;
386 struct input_dev *input;
387 int ret;
388
389 rcu_read_lock();
390 input = rcu_dereference(steam->input);
391 rcu_read_unlock();
392 if (input) {
393 dbg_hid("%s: already connected\n", __func__);
394 return 0;
395 }
396
397 input = input_allocate_device();
398 if (!input)
399 return -ENOMEM;
400
401 input_set_drvdata(input, steam);
402 input->dev.parent = &hdev->dev;
403 input->open = steam_input_open;
404 input->close = steam_input_close;
405
406 input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ?
407 "Wireless Steam Controller" :
408 "Steam Controller";
409 input->phys = hdev->phys;
410 input->uniq = steam->serial_no;
411 input->id.bustype = hdev->bus;
412 input->id.vendor = hdev->vendor;
413 input->id.product = hdev->product;
414 input->id.version = hdev->version;
415
416 input_set_capability(input, EV_KEY, BTN_TR2);
417 input_set_capability(input, EV_KEY, BTN_TL2);
418 input_set_capability(input, EV_KEY, BTN_TR);
419 input_set_capability(input, EV_KEY, BTN_TL);
420 input_set_capability(input, EV_KEY, BTN_Y);
421 input_set_capability(input, EV_KEY, BTN_B);
422 input_set_capability(input, EV_KEY, BTN_X);
423 input_set_capability(input, EV_KEY, BTN_A);
424 input_set_capability(input, EV_KEY, BTN_DPAD_UP);
425 input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT);
426 input_set_capability(input, EV_KEY, BTN_DPAD_LEFT);
427 input_set_capability(input, EV_KEY, BTN_DPAD_DOWN);
428 input_set_capability(input, EV_KEY, BTN_SELECT);
429 input_set_capability(input, EV_KEY, BTN_MODE);
430 input_set_capability(input, EV_KEY, BTN_START);
431 input_set_capability(input, EV_KEY, BTN_GEAR_DOWN);
432 input_set_capability(input, EV_KEY, BTN_GEAR_UP);
433 input_set_capability(input, EV_KEY, BTN_THUMBR);
434 input_set_capability(input, EV_KEY, BTN_THUMBL);
435 input_set_capability(input, EV_KEY, BTN_THUMB);
436 input_set_capability(input, EV_KEY, BTN_THUMB2);
437
438 input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0);
439 input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0);
440 input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0);
441 input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0);
442 input_set_abs_params(input, ABS_RX, -32767, 32767,
443 STEAM_PAD_FUZZ, 0);
444 input_set_abs_params(input, ABS_RY, -32767, 32767,
445 STEAM_PAD_FUZZ, 0);
446 input_set_abs_params(input, ABS_HAT0X, -32767, 32767,
447 STEAM_PAD_FUZZ, 0);
448 input_set_abs_params(input, ABS_HAT0Y, -32767, 32767,
449 STEAM_PAD_FUZZ, 0);
450 input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION);
451 input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION);
452 input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION);
453 input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION);
454 input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION);
455 input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION);
456 input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION);
457 input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION);
458
459 ret = input_register_device(input);
460 if (ret)
461 goto input_register_fail;
462
463 rcu_assign_pointer(steam->input, input);
464 return 0;
465
466input_register_fail:
467 input_free_device(input);
468 return ret;
469}
470
471static void steam_input_unregister(struct steam_device *steam)
472{
473 struct input_dev *input;
474 rcu_read_lock();
475 input = rcu_dereference(steam->input);
476 rcu_read_unlock();
477 if (!input)
478 return;
479 RCU_INIT_POINTER(steam->input, NULL);
480 synchronize_rcu();
481 input_unregister_device(input);
482}
483
484static void steam_battery_unregister(struct steam_device *steam)
485{
486 struct power_supply *battery;
487
488 rcu_read_lock();
489 battery = rcu_dereference(steam->battery);
490 rcu_read_unlock();
491
492 if (!battery)
493 return;
494 RCU_INIT_POINTER(steam->battery, NULL);
495 synchronize_rcu();
496 power_supply_unregister(battery);
497}
498
499static int steam_register(struct steam_device *steam)
500{
501 int ret;
502 bool client_opened;
503
504 /*
505 * This function can be called several times in a row with the
506 * wireless adaptor, without steam_unregister() between them, because
507 * another client send a get_connection_status command, for example.
508 * The battery and serial number are set just once per device.
509 */
510 if (!steam->serial_no[0]) {
511 /*
512 * Unlikely, but getting the serial could fail, and it is not so
513 * important, so make up a serial number and go on.
514 */
515 mutex_lock(&steam->mutex);
516 if (steam_get_serial(steam) < 0)
517 strlcpy(steam->serial_no, "XXXXXXXXXX",
518 sizeof(steam->serial_no));
519 mutex_unlock(&steam->mutex);
520
521 hid_info(steam->hdev, "Steam Controller '%s' connected",
522 steam->serial_no);
523
524 /* ignore battery errors, we can live without it */
525 if (steam->quirks & STEAM_QUIRK_WIRELESS)
526 steam_battery_register(steam);
527
528 mutex_lock(&steam_devices_lock);
529 if (list_empty(&steam->list))
530 list_add(&steam->list, &steam_devices);
531 mutex_unlock(&steam_devices_lock);
532 }
533
534 mutex_lock(&steam->mutex);
535 client_opened = steam->client_opened;
536 if (!client_opened)
537 steam_set_lizard_mode(steam, lizard_mode);
538 mutex_unlock(&steam->mutex);
539
540 if (!client_opened)
541 ret = steam_input_register(steam);
542 else
543 ret = 0;
544
545 return ret;
546}
547
548static void steam_unregister(struct steam_device *steam)
549{
550 steam_battery_unregister(steam);
551 steam_input_unregister(steam);
552 if (steam->serial_no[0]) {
553 hid_info(steam->hdev, "Steam Controller '%s' disconnected",
554 steam->serial_no);
555 mutex_lock(&steam_devices_lock);
556 list_del_init(&steam->list);
557 mutex_unlock(&steam_devices_lock);
558 steam->serial_no[0] = 0;
559 }
560}
561
562static void steam_work_connect_cb(struct work_struct *work)
563{
564 struct steam_device *steam = container_of(work, struct steam_device,
565 work_connect);
566 unsigned long flags;
567 bool connected;
568 int ret;
569
570 spin_lock_irqsave(&steam->lock, flags);
571 connected = steam->connected;
572 spin_unlock_irqrestore(&steam->lock, flags);
573
574 if (connected) {
575 ret = steam_register(steam);
576 if (ret) {
577 hid_err(steam->hdev,
578 "%s:steam_register failed with error %d\n",
579 __func__, ret);
580 }
581 } else {
582 steam_unregister(steam);
583 }
584}
585
586static bool steam_is_valve_interface(struct hid_device *hdev)
587{
588 struct hid_report_enum *rep_enum;
589
590 /*
591 * The wired device creates 3 interfaces:
592 * 0: emulated mouse.
593 * 1: emulated keyboard.
594 * 2: the real game pad.
595 * The wireless device creates 5 interfaces:
596 * 0: emulated keyboard.
597 * 1-4: slots where up to 4 real game pads will be connected to.
598 * We know which one is the real gamepad interface because they are the
599 * only ones with a feature report.
600 */
601 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
602 return !list_empty(&rep_enum->report_list);
603}
604
605static int steam_client_ll_parse(struct hid_device *hdev)
606{
607 struct steam_device *steam = hdev->driver_data;
608
609 return hid_parse_report(hdev, steam->hdev->dev_rdesc,
610 steam->hdev->dev_rsize);
611}
612
613static int steam_client_ll_start(struct hid_device *hdev)
614{
615 return 0;
616}
617
618static void steam_client_ll_stop(struct hid_device *hdev)
619{
620}
621
622static int steam_client_ll_open(struct hid_device *hdev)
623{
624 struct steam_device *steam = hdev->driver_data;
625
626 mutex_lock(&steam->mutex);
627 steam->client_opened = true;
628 mutex_unlock(&steam->mutex);
629
630 steam_input_unregister(steam);
631
632 return 0;
633}
634
635static void steam_client_ll_close(struct hid_device *hdev)
636{
637 struct steam_device *steam = hdev->driver_data;
638
639 unsigned long flags;
640 bool connected;
641
642 spin_lock_irqsave(&steam->lock, flags);
643 connected = steam->connected;
644 spin_unlock_irqrestore(&steam->lock, flags);
645
646 mutex_lock(&steam->mutex);
647 steam->client_opened = false;
648 if (connected)
649 steam_set_lizard_mode(steam, lizard_mode);
650 mutex_unlock(&steam->mutex);
651
652 if (connected)
653 steam_input_register(steam);
654}
655
656static int steam_client_ll_raw_request(struct hid_device *hdev,
657 unsigned char reportnum, u8 *buf,
658 size_t count, unsigned char report_type,
659 int reqtype)
660{
661 struct steam_device *steam = hdev->driver_data;
662
663 return hid_hw_raw_request(steam->hdev, reportnum, buf, count,
664 report_type, reqtype);
665}
666
667static struct hid_ll_driver steam_client_ll_driver = {
668 .parse = steam_client_ll_parse,
669 .start = steam_client_ll_start,
670 .stop = steam_client_ll_stop,
671 .open = steam_client_ll_open,
672 .close = steam_client_ll_close,
673 .raw_request = steam_client_ll_raw_request,
674};
675
676static struct hid_device *steam_create_client_hid(struct hid_device *hdev)
677{
678 struct hid_device *client_hdev;
679
680 client_hdev = hid_allocate_device();
681 if (IS_ERR(client_hdev))
682 return client_hdev;
683
684 client_hdev->ll_driver = &steam_client_ll_driver;
685 client_hdev->dev.parent = hdev->dev.parent;
686 client_hdev->bus = hdev->bus;
687 client_hdev->vendor = hdev->vendor;
688 client_hdev->product = hdev->product;
689 client_hdev->version = hdev->version;
690 client_hdev->type = hdev->type;
691 client_hdev->country = hdev->country;
692 strlcpy(client_hdev->name, hdev->name,
693 sizeof(client_hdev->name));
694 strlcpy(client_hdev->phys, hdev->phys,
695 sizeof(client_hdev->phys));
696 /*
697 * Since we use the same device info than the real interface to
698 * trick userspace, we will be calling steam_probe recursively.
699 * We need to recognize the client interface somehow.
700 */
701 client_hdev->group = HID_GROUP_STEAM;
702 return client_hdev;
703}
704
705static int steam_probe(struct hid_device *hdev,
706 const struct hid_device_id *id)
707{
708 struct steam_device *steam;
709 int ret;
710
711 ret = hid_parse(hdev);
712 if (ret) {
713 hid_err(hdev,
714 "%s:parse of hid interface failed\n", __func__);
715 return ret;
716 }
717
718 /*
719 * The virtual client_dev is only used for hidraw.
720 * Also avoid the recursive probe.
721 */
722 if (hdev->group == HID_GROUP_STEAM)
723 return hid_hw_start(hdev, HID_CONNECT_HIDRAW);
724 /*
725 * The non-valve interfaces (mouse and keyboard emulation) are
726 * connected without changes.
727 */
728 if (!steam_is_valve_interface(hdev))
729 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
730
731 steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL);
732 if (!steam) {
733 ret = -ENOMEM;
734 goto steam_alloc_fail;
735 }
736 steam->hdev = hdev;
737 hid_set_drvdata(hdev, steam);
738 spin_lock_init(&steam->lock);
739 mutex_init(&steam->mutex);
740 steam->quirks = id->driver_data;
741 INIT_WORK(&steam->work_connect, steam_work_connect_cb);
742 INIT_LIST_HEAD(&steam->list);
743
744 steam->client_hdev = steam_create_client_hid(hdev);
745 if (IS_ERR(steam->client_hdev)) {
746 ret = PTR_ERR(steam->client_hdev);
747 goto client_hdev_fail;
748 }
749 steam->client_hdev->driver_data = steam;
750
751 /*
752 * With the real steam controller interface, do not connect hidraw.
753 * Instead, create the client_hid and connect that.
754 */
755 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW);
756 if (ret)
757 goto hid_hw_start_fail;
758
759 ret = hid_add_device(steam->client_hdev);
760 if (ret)
761 goto client_hdev_add_fail;
762
763 ret = hid_hw_open(hdev);
764 if (ret) {
765 hid_err(hdev,
766 "%s:hid_hw_open\n",
767 __func__);
768 goto hid_hw_open_fail;
769 }
770
771 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
772 hid_info(hdev, "Steam wireless receiver connected");
773 /* If using a wireless adaptor ask for connection status */
774 steam->connected = false;
775 steam_request_conn_status(steam);
776 } else {
777 /* A wired connection is always present */
778 steam->connected = true;
779 ret = steam_register(steam);
780 if (ret) {
781 hid_err(hdev,
782 "%s:steam_register failed with error %d\n",
783 __func__, ret);
784 goto input_register_fail;
785 }
786 }
787
788 return 0;
789
790input_register_fail:
791hid_hw_open_fail:
792client_hdev_add_fail:
793 hid_hw_stop(hdev);
794hid_hw_start_fail:
795 hid_destroy_device(steam->client_hdev);
796client_hdev_fail:
797 cancel_work_sync(&steam->work_connect);
798steam_alloc_fail:
799 hid_err(hdev, "%s: failed with error %d\n",
800 __func__, ret);
801 return ret;
802}
803
804static void steam_remove(struct hid_device *hdev)
805{
806 struct steam_device *steam = hid_get_drvdata(hdev);
807
808 if (!steam || hdev->group == HID_GROUP_STEAM) {
809 hid_hw_stop(hdev);
810 return;
811 }
812
813 hid_destroy_device(steam->client_hdev);
814 steam->client_opened = false;
815 cancel_work_sync(&steam->work_connect);
816 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
817 hid_info(hdev, "Steam wireless receiver disconnected");
818 }
819 hid_hw_close(hdev);
820 hid_hw_stop(hdev);
821 steam_unregister(steam);
822}
823
824static void steam_do_connect_event(struct steam_device *steam, bool connected)
825{
826 unsigned long flags;
827 bool changed;
828
829 spin_lock_irqsave(&steam->lock, flags);
830 changed = steam->connected != connected;
831 steam->connected = connected;
832 spin_unlock_irqrestore(&steam->lock, flags);
833
834 if (changed && schedule_work(&steam->work_connect) == 0)
835 dbg_hid("%s: connected=%d event already queued\n",
836 __func__, connected);
837}
838
839/*
840 * Some input data in the protocol has the opposite sign.
841 * Clamp the values to 32767..-32767 so that the range is
842 * symmetrical and can be negated safely.
843 */
844static inline s16 steam_le16(u8 *data)
845{
846 s16 x = (s16) le16_to_cpup((__le16 *)data);
847
848 return x == -32768 ? -32767 : x;
849}
850
851/*
852 * The size for this message payload is 60.
853 * The known values are:
854 * (* values are not sent through wireless)
855 * (* accelerator/gyro is disabled by default)
856 * Offset| Type | Mapped to |Meaning
857 * -------+-------+-----------+--------------------------
858 * 4-7 | u32 | -- | sequence number
859 * 8-10 | 24bit | see below | buttons
860 * 11 | u8 | ABS_HAT2Y | left trigger
861 * 12 | u8 | ABS_HAT2X | right trigger
862 * 13-15 | -- | -- | always 0
863 * 16-17 | s16 | ABS_X/ABS_HAT0X | X value
864 * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value
865 * 20-21 | s16 | ABS_RX | right-pad X value
866 * 22-23 | s16 | ABS_RY | right-pad Y value
867 * 24-25 | s16 | -- | * left trigger
868 * 26-27 | s16 | -- | * right trigger
869 * 28-29 | s16 | -- | * accelerometer X value
870 * 30-31 | s16 | -- | * accelerometer Y value
871 * 32-33 | s16 | -- | * accelerometer Z value
872 * 34-35 | s16 | -- | gyro X value
873 * 36-36 | s16 | -- | gyro Y value
874 * 38-39 | s16 | -- | gyro Z value
875 * 40-41 | s16 | -- | quaternion W value
876 * 42-43 | s16 | -- | quaternion X value
877 * 44-45 | s16 | -- | quaternion Y value
878 * 46-47 | s16 | -- | quaternion Z value
879 * 48-49 | -- | -- | always 0
880 * 50-51 | s16 | -- | * left trigger (uncalibrated)
881 * 52-53 | s16 | -- | * right trigger (uncalibrated)
882 * 54-55 | s16 | -- | * joystick X value (uncalibrated)
883 * 56-57 | s16 | -- | * joystick Y value (uncalibrated)
884 * 58-59 | s16 | -- | * left-pad X value
885 * 60-61 | s16 | -- | * left-pad Y value
886 * 62-63 | u16 | -- | * battery voltage
887 *
888 * The buttons are:
889 * Bit | Mapped to | Description
890 * ------+------------+--------------------------------
891 * 8.0 | BTN_TR2 | right trigger fully pressed
892 * 8.1 | BTN_TL2 | left trigger fully pressed
893 * 8.2 | BTN_TR | right shoulder
894 * 8.3 | BTN_TL | left shoulder
895 * 8.4 | BTN_Y | button Y
896 * 8.5 | BTN_B | button B
897 * 8.6 | BTN_X | button X
898 * 8.7 | BTN_A | button A
899 * 9.0 | BTN_DPAD_UP | lef-pad up
900 * 9.1 | BTN_DPAD_RIGHT | lef-pad right
901 * 9.2 | BTN_DPAD_LEFT | lef-pad left
902 * 9.3 | BTN_DPAD_DOWN | lef-pad down
903 * 9.4 | BTN_SELECT | menu left
904 * 9.5 | BTN_MODE | steam logo
905 * 9.6 | BTN_START | menu right
906 * 9.7 | BTN_GEAR_DOWN | left back lever
907 * 10.0 | BTN_GEAR_UP | right back lever
908 * 10.1 | -- | left-pad clicked
909 * 10.2 | BTN_THUMBR | right-pad clicked
910 * 10.3 | BTN_THUMB | left-pad touched (but see explanation below)
911 * 10.4 | BTN_THUMB2 | right-pad touched
912 * 10.5 | -- | unknown
913 * 10.6 | BTN_THUMBL | joystick clicked
914 * 10.7 | -- | lpad_and_joy
915 */
916
917static void steam_do_input_event(struct steam_device *steam,
918 struct input_dev *input, u8 *data)
919{
920 /* 24 bits of buttons */
921 u8 b8, b9, b10;
922 s16 x, y;
923 bool lpad_touched, lpad_and_joy;
924
925 b8 = data[8];
926 b9 = data[9];
927 b10 = data[10];
928
929 input_report_abs(input, ABS_HAT2Y, data[11]);
930 input_report_abs(input, ABS_HAT2X, data[12]);
931
932 /*
933 * These two bits tells how to interpret the values X and Y.
934 * lpad_and_joy tells that the joystick and the lpad are used at the
935 * same time.
936 * lpad_touched tells whether X/Y are to be read as lpad coord or
937 * joystick values.
938 * (lpad_touched || lpad_and_joy) tells if the lpad is really touched.
939 */
940 lpad_touched = b10 & BIT(3);
941 lpad_and_joy = b10 & BIT(7);
942 x = steam_le16(data + 16);
943 y = -steam_le16(data + 18);
944
945 input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x);
946 input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y);
947 /* Check if joystick is centered */
948 if (lpad_touched && !lpad_and_joy) {
949 input_report_abs(input, ABS_X, 0);
950 input_report_abs(input, ABS_Y, 0);
951 }
952 /* Check if lpad is untouched */
953 if (!(lpad_touched || lpad_and_joy)) {
954 input_report_abs(input, ABS_HAT0X, 0);
955 input_report_abs(input, ABS_HAT0Y, 0);
956 }
957
958 input_report_abs(input, ABS_RX, steam_le16(data + 20));
959 input_report_abs(input, ABS_RY, -steam_le16(data + 22));
960
961 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0)));
962 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1)));
963 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2)));
964 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3)));
965 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4)));
966 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5)));
967 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6)));
968 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7)));
969 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4)));
970 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5)));
971 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6)));
972 input_event(input, EV_KEY, BTN_GEAR_DOWN, !!(b9 & BIT(7)));
973 input_event(input, EV_KEY, BTN_GEAR_UP, !!(b10 & BIT(0)));
974 input_event(input, EV_KEY, BTN_THUMBR, !!(b10 & BIT(2)));
975 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6)));
976 input_event(input, EV_KEY, BTN_THUMB, lpad_touched || lpad_and_joy);
977 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(4)));
978 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0)));
979 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1)));
980 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2)));
981 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3)));
982
983 input_sync(input);
984}
985
986/*
987 * The size for this message payload is 11.
988 * The known values are:
989 * Offset| Type | Meaning
990 * -------+-------+---------------------------
991 * 4-7 | u32 | sequence number
992 * 8-11 | -- | always 0
993 * 12-13 | u16 | voltage (mV)
994 * 14 | u8 | battery percent
995 */
996static void steam_do_battery_event(struct steam_device *steam,
997 struct power_supply *battery, u8 *data)
998{
999 unsigned long flags;
1000
1001 s16 volts = steam_le16(data + 12);
1002 u8 batt = data[14];
1003
1004 /* Creating the battery may have failed */
1005 rcu_read_lock();
1006 battery = rcu_dereference(steam->battery);
1007 if (likely(battery)) {
1008 spin_lock_irqsave(&steam->lock, flags);
1009 steam->voltage = volts;
1010 steam->battery_charge = batt;
1011 spin_unlock_irqrestore(&steam->lock, flags);
1012 power_supply_changed(battery);
1013 }
1014 rcu_read_unlock();
1015}
1016
1017static int steam_raw_event(struct hid_device *hdev,
1018 struct hid_report *report, u8 *data,
1019 int size)
1020{
1021 struct steam_device *steam = hid_get_drvdata(hdev);
1022 struct input_dev *input;
1023 struct power_supply *battery;
1024
1025 if (!steam)
1026 return 0;
1027
1028 if (steam->client_opened)
1029 hid_input_report(steam->client_hdev, HID_FEATURE_REPORT,
1030 data, size, 0);
1031 /*
1032 * All messages are size=64, all values little-endian.
1033 * The format is:
1034 * Offset| Meaning
1035 * -------+--------------------------------------------
1036 * 0-1 | always 0x01, 0x00, maybe protocol version?
1037 * 2 | type of message
1038 * 3 | length of the real payload (not checked)
1039 * 4-n | payload data, depends on the type
1040 *
1041 * There are these known types of message:
1042 * 0x01: input data (60 bytes)
1043 * 0x03: wireless connect/disconnect (1 byte)
1044 * 0x04: battery status (11 bytes)
1045 */
1046
1047 if (size != 64 || data[0] != 1 || data[1] != 0)
1048 return 0;
1049
1050 switch (data[2]) {
1051 case STEAM_EV_INPUT_DATA:
1052 if (steam->client_opened)
1053 return 0;
1054 rcu_read_lock();
1055 input = rcu_dereference(steam->input);
1056 if (likely(input))
1057 steam_do_input_event(steam, input, data);
1058 rcu_read_unlock();
1059 break;
1060 case STEAM_EV_CONNECT:
1061 /*
1062 * The payload of this event is a single byte:
1063 * 0x01: disconnected.
1064 * 0x02: connected.
1065 */
1066 switch (data[4]) {
1067 case 0x01:
1068 steam_do_connect_event(steam, false);
1069 break;
1070 case 0x02:
1071 steam_do_connect_event(steam, true);
1072 break;
1073 }
1074 break;
1075 case STEAM_EV_BATTERY:
1076 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
1077 rcu_read_lock();
1078 battery = rcu_dereference(steam->battery);
1079 if (likely(battery)) {
1080 steam_do_battery_event(steam, battery, data);
1081 } else {
1082 dbg_hid(
1083 "%s: battery data without connect event\n",
1084 __func__);
1085 steam_do_connect_event(steam, true);
1086 }
1087 rcu_read_unlock();
1088 }
1089 break;
1090 }
1091 return 0;
1092}
1093
1094static int steam_param_set_lizard_mode(const char *val,
1095 const struct kernel_param *kp)
1096{
1097 struct steam_device *steam;
1098 int ret;
1099
1100 ret = param_set_bool(val, kp);
1101 if (ret)
1102 return ret;
1103
1104 mutex_lock(&steam_devices_lock);
1105 list_for_each_entry(steam, &steam_devices, list) {
1106 mutex_lock(&steam->mutex);
1107 if (!steam->client_opened)
1108 steam_set_lizard_mode(steam, lizard_mode);
1109 mutex_unlock(&steam->mutex);
1110 }
1111 mutex_unlock(&steam_devices_lock);
1112 return 0;
1113}
1114
1115static const struct kernel_param_ops steam_lizard_mode_ops = {
1116 .set = steam_param_set_lizard_mode,
1117 .get = param_get_bool,
1118};
1119
1120module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644);
1121MODULE_PARM_DESC(lizard_mode,
1122 "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use");
1123
1124static const struct hid_device_id steam_controllers[] = {
1125 { /* Wired Steam Controller */
1126 HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
1127 USB_DEVICE_ID_STEAM_CONTROLLER)
1128 },
1129 { /* Wireless Steam Controller */
1130 HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
1131 USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS),
1132 .driver_data = STEAM_QUIRK_WIRELESS
1133 },
1134 {}
1135};
1136
1137MODULE_DEVICE_TABLE(hid, steam_controllers);
1138
1139static struct hid_driver steam_controller_driver = {
1140 .name = "hid-steam",
1141 .id_table = steam_controllers,
1142 .probe = steam_probe,
1143 .remove = steam_remove,
1144 .raw_event = steam_raw_event,
1145};
1146
1147module_hid_driver(steam_controller_driver);
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 *
7 * Supports both the wired and wireless interfaces.
8 *
9 * This controller has a builtin emulation of mouse and keyboard: the right pad
10 * can be used as a mouse, the shoulder buttons are mouse buttons, A and B
11 * buttons are ENTER and ESCAPE, and so on. This is implemented as additional
12 * HID interfaces.
13 *
14 * This is known as the "lizard mode", because apparently lizards like to use
15 * the computer from the coach, without a proper mouse and keyboard.
16 *
17 * This driver will disable the lizard mode when the input device is opened
18 * and re-enable it when the input device is closed, so as not to break user
19 * mode behaviour. The lizard_mode parameter can be used to change that.
20 *
21 * There are a few user space applications (notably Steam Client) that use
22 * the hidraw interface directly to create input devices (XTest, uinput...).
23 * In order to avoid breaking them this driver creates a layered hidraw device,
24 * so it can detect when the client is running and then:
25 * - it will not send any command to the controller.
26 * - this input device will be removed, to avoid double input of the same
27 * user action.
28 * When the client is closed, this input device will be created again.
29 *
30 * For additional functions, such as changing the right-pad margin or switching
31 * the led, you can use the user-space tool at:
32 *
33 * https://github.com/rodrigorc/steamctrl
34 */
35
36#include <linux/device.h>
37#include <linux/input.h>
38#include <linux/hid.h>
39#include <linux/module.h>
40#include <linux/workqueue.h>
41#include <linux/mutex.h>
42#include <linux/rcupdate.h>
43#include <linux/delay.h>
44#include <linux/power_supply.h>
45#include "hid-ids.h"
46
47MODULE_LICENSE("GPL");
48MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>");
49
50static bool lizard_mode = true;
51
52static DEFINE_MUTEX(steam_devices_lock);
53static LIST_HEAD(steam_devices);
54
55#define STEAM_QUIRK_WIRELESS BIT(0)
56
57/* Touch pads are 40 mm in diameter and 65535 units */
58#define STEAM_PAD_RESOLUTION 1638
59/* Trigger runs are about 5 mm and 256 units */
60#define STEAM_TRIGGER_RESOLUTION 51
61/* Joystick runs are about 5 mm and 256 units */
62#define STEAM_JOYSTICK_RESOLUTION 51
63
64#define STEAM_PAD_FUZZ 256
65
66/*
67 * Commands that can be sent in a feature report.
68 * Thanks to Valve for some valuable hints.
69 */
70#define STEAM_CMD_SET_MAPPINGS 0x80
71#define STEAM_CMD_CLEAR_MAPPINGS 0x81
72#define STEAM_CMD_GET_MAPPINGS 0x82
73#define STEAM_CMD_GET_ATTRIB 0x83
74#define STEAM_CMD_GET_ATTRIB_LABEL 0x84
75#define STEAM_CMD_DEFAULT_MAPPINGS 0x85
76#define STEAM_CMD_FACTORY_RESET 0x86
77#define STEAM_CMD_WRITE_REGISTER 0x87
78#define STEAM_CMD_CLEAR_REGISTER 0x88
79#define STEAM_CMD_READ_REGISTER 0x89
80#define STEAM_CMD_GET_REGISTER_LABEL 0x8a
81#define STEAM_CMD_GET_REGISTER_MAX 0x8b
82#define STEAM_CMD_GET_REGISTER_DEFAULT 0x8c
83#define STEAM_CMD_SET_MODE 0x8d
84#define STEAM_CMD_DEFAULT_MOUSE 0x8e
85#define STEAM_CMD_FORCEFEEDBAK 0x8f
86#define STEAM_CMD_REQUEST_COMM_STATUS 0xb4
87#define STEAM_CMD_GET_SERIAL 0xae
88
89/* Some useful register ids */
90#define STEAM_REG_LPAD_MODE 0x07
91#define STEAM_REG_RPAD_MODE 0x08
92#define STEAM_REG_RPAD_MARGIN 0x18
93#define STEAM_REG_LED 0x2d
94#define STEAM_REG_GYRO_MODE 0x30
95
96/* Raw event identifiers */
97#define STEAM_EV_INPUT_DATA 0x01
98#define STEAM_EV_CONNECT 0x03
99#define STEAM_EV_BATTERY 0x04
100
101/* Values for GYRO_MODE (bitmask) */
102#define STEAM_GYRO_MODE_OFF 0x0000
103#define STEAM_GYRO_MODE_STEERING 0x0001
104#define STEAM_GYRO_MODE_TILT 0x0002
105#define STEAM_GYRO_MODE_SEND_ORIENTATION 0x0004
106#define STEAM_GYRO_MODE_SEND_RAW_ACCEL 0x0008
107#define STEAM_GYRO_MODE_SEND_RAW_GYRO 0x0010
108
109/* Other random constants */
110#define STEAM_SERIAL_LEN 10
111
112struct steam_device {
113 struct list_head list;
114 spinlock_t lock;
115 struct hid_device *hdev, *client_hdev;
116 struct mutex mutex;
117 bool client_opened;
118 struct input_dev __rcu *input;
119 unsigned long quirks;
120 struct work_struct work_connect;
121 bool connected;
122 char serial_no[STEAM_SERIAL_LEN + 1];
123 struct power_supply_desc battery_desc;
124 struct power_supply __rcu *battery;
125 u8 battery_charge;
126 u16 voltage;
127};
128
129static int steam_recv_report(struct steam_device *steam,
130 u8 *data, int size)
131{
132 struct hid_report *r;
133 u8 *buf;
134 int ret;
135
136 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
137 if (!r) {
138 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n");
139 return -EINVAL;
140 }
141
142 if (hid_report_len(r) < 64)
143 return -EINVAL;
144
145 buf = hid_alloc_report_buf(r, GFP_KERNEL);
146 if (!buf)
147 return -ENOMEM;
148
149 /*
150 * The report ID is always 0, so strip the first byte from the output.
151 * hid_report_len() is not counting the report ID, so +1 to the length
152 * or else we get a EOVERFLOW. We are safe from a buffer overflow
153 * because hid_alloc_report_buf() allocates +7 bytes.
154 */
155 ret = hid_hw_raw_request(steam->hdev, 0x00,
156 buf, hid_report_len(r) + 1,
157 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
158 if (ret > 0)
159 memcpy(data, buf + 1, min(size, ret - 1));
160 kfree(buf);
161 return ret;
162}
163
164static int steam_send_report(struct steam_device *steam,
165 u8 *cmd, int size)
166{
167 struct hid_report *r;
168 u8 *buf;
169 unsigned int retries = 50;
170 int ret;
171
172 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
173 if (!r) {
174 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n");
175 return -EINVAL;
176 }
177
178 if (hid_report_len(r) < 64)
179 return -EINVAL;
180
181 buf = hid_alloc_report_buf(r, GFP_KERNEL);
182 if (!buf)
183 return -ENOMEM;
184
185 /* The report ID is always 0 */
186 memcpy(buf + 1, cmd, size);
187
188 /*
189 * Sometimes the wireless controller fails with EPIPE
190 * when sending a feature report.
191 * Doing a HID_REQ_GET_REPORT and waiting for a while
192 * seems to fix that.
193 */
194 do {
195 ret = hid_hw_raw_request(steam->hdev, 0,
196 buf, size + 1,
197 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
198 if (ret != -EPIPE)
199 break;
200 msleep(20);
201 } while (--retries);
202
203 kfree(buf);
204 if (ret < 0)
205 hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__,
206 ret, size, cmd);
207 return ret;
208}
209
210static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd)
211{
212 return steam_send_report(steam, &cmd, 1);
213}
214
215static int steam_write_registers(struct steam_device *steam,
216 /* u8 reg, u16 val */...)
217{
218 /* Send: 0x87 len (reg valLo valHi)* */
219 u8 reg;
220 u16 val;
221 u8 cmd[64] = {STEAM_CMD_WRITE_REGISTER, 0x00};
222 va_list args;
223
224 va_start(args, steam);
225 for (;;) {
226 reg = va_arg(args, int);
227 if (reg == 0)
228 break;
229 val = va_arg(args, int);
230 cmd[cmd[1] + 2] = reg;
231 cmd[cmd[1] + 3] = val & 0xff;
232 cmd[cmd[1] + 4] = val >> 8;
233 cmd[1] += 3;
234 }
235 va_end(args);
236
237 return steam_send_report(steam, cmd, 2 + cmd[1]);
238}
239
240static int steam_get_serial(struct steam_device *steam)
241{
242 /*
243 * Send: 0xae 0x15 0x01
244 * Recv: 0xae 0x15 0x01 serialnumber (10 chars)
245 */
246 int ret;
247 u8 cmd[] = {STEAM_CMD_GET_SERIAL, 0x15, 0x01};
248 u8 reply[3 + STEAM_SERIAL_LEN + 1];
249
250 ret = steam_send_report(steam, cmd, sizeof(cmd));
251 if (ret < 0)
252 return ret;
253 ret = steam_recv_report(steam, reply, sizeof(reply));
254 if (ret < 0)
255 return ret;
256 if (reply[0] != 0xae || reply[1] != 0x15 || reply[2] != 0x01)
257 return -EIO;
258 reply[3 + STEAM_SERIAL_LEN] = 0;
259 strscpy(steam->serial_no, reply + 3, sizeof(steam->serial_no));
260 return 0;
261}
262
263/*
264 * This command requests the wireless adaptor to post an event
265 * with the connection status. Useful if this driver is loaded when
266 * the controller is already connected.
267 */
268static inline int steam_request_conn_status(struct steam_device *steam)
269{
270 return steam_send_report_byte(steam, STEAM_CMD_REQUEST_COMM_STATUS);
271}
272
273static void steam_set_lizard_mode(struct steam_device *steam, bool enable)
274{
275 if (enable) {
276 /* enable esc, enter, cursors */
277 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MAPPINGS);
278 /* enable mouse */
279 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MOUSE);
280 steam_write_registers(steam,
281 STEAM_REG_RPAD_MARGIN, 0x01, /* enable margin */
282 0);
283 } else {
284 /* disable esc, enter, cursor */
285 steam_send_report_byte(steam, STEAM_CMD_CLEAR_MAPPINGS);
286 steam_write_registers(steam,
287 STEAM_REG_RPAD_MODE, 0x07, /* disable mouse */
288 STEAM_REG_RPAD_MARGIN, 0x00, /* disable margin */
289 0);
290 }
291}
292
293static int steam_input_open(struct input_dev *dev)
294{
295 struct steam_device *steam = input_get_drvdata(dev);
296
297 mutex_lock(&steam->mutex);
298 if (!steam->client_opened && lizard_mode)
299 steam_set_lizard_mode(steam, false);
300 mutex_unlock(&steam->mutex);
301 return 0;
302}
303
304static void steam_input_close(struct input_dev *dev)
305{
306 struct steam_device *steam = input_get_drvdata(dev);
307
308 mutex_lock(&steam->mutex);
309 if (!steam->client_opened && lizard_mode)
310 steam_set_lizard_mode(steam, true);
311 mutex_unlock(&steam->mutex);
312}
313
314static enum power_supply_property steam_battery_props[] = {
315 POWER_SUPPLY_PROP_PRESENT,
316 POWER_SUPPLY_PROP_SCOPE,
317 POWER_SUPPLY_PROP_VOLTAGE_NOW,
318 POWER_SUPPLY_PROP_CAPACITY,
319};
320
321static int steam_battery_get_property(struct power_supply *psy,
322 enum power_supply_property psp,
323 union power_supply_propval *val)
324{
325 struct steam_device *steam = power_supply_get_drvdata(psy);
326 unsigned long flags;
327 s16 volts;
328 u8 batt;
329 int ret = 0;
330
331 spin_lock_irqsave(&steam->lock, flags);
332 volts = steam->voltage;
333 batt = steam->battery_charge;
334 spin_unlock_irqrestore(&steam->lock, flags);
335
336 switch (psp) {
337 case POWER_SUPPLY_PROP_PRESENT:
338 val->intval = 1;
339 break;
340 case POWER_SUPPLY_PROP_SCOPE:
341 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
342 break;
343 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
344 val->intval = volts * 1000; /* mV -> uV */
345 break;
346 case POWER_SUPPLY_PROP_CAPACITY:
347 val->intval = batt;
348 break;
349 default:
350 ret = -EINVAL;
351 break;
352 }
353 return ret;
354}
355
356static int steam_battery_register(struct steam_device *steam)
357{
358 struct power_supply *battery;
359 struct power_supply_config battery_cfg = { .drv_data = steam, };
360 unsigned long flags;
361 int ret;
362
363 steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
364 steam->battery_desc.properties = steam_battery_props;
365 steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props);
366 steam->battery_desc.get_property = steam_battery_get_property;
367 steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev,
368 GFP_KERNEL, "steam-controller-%s-battery",
369 steam->serial_no);
370 if (!steam->battery_desc.name)
371 return -ENOMEM;
372
373 /* avoid the warning of 0% battery while waiting for the first info */
374 spin_lock_irqsave(&steam->lock, flags);
375 steam->voltage = 3000;
376 steam->battery_charge = 100;
377 spin_unlock_irqrestore(&steam->lock, flags);
378
379 battery = power_supply_register(&steam->hdev->dev,
380 &steam->battery_desc, &battery_cfg);
381 if (IS_ERR(battery)) {
382 ret = PTR_ERR(battery);
383 hid_err(steam->hdev,
384 "%s:power_supply_register failed with error %d\n",
385 __func__, ret);
386 return ret;
387 }
388 rcu_assign_pointer(steam->battery, battery);
389 power_supply_powers(battery, &steam->hdev->dev);
390 return 0;
391}
392
393static int steam_input_register(struct steam_device *steam)
394{
395 struct hid_device *hdev = steam->hdev;
396 struct input_dev *input;
397 int ret;
398
399 rcu_read_lock();
400 input = rcu_dereference(steam->input);
401 rcu_read_unlock();
402 if (input) {
403 dbg_hid("%s: already connected\n", __func__);
404 return 0;
405 }
406
407 input = input_allocate_device();
408 if (!input)
409 return -ENOMEM;
410
411 input_set_drvdata(input, steam);
412 input->dev.parent = &hdev->dev;
413 input->open = steam_input_open;
414 input->close = steam_input_close;
415
416 input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ?
417 "Wireless Steam Controller" :
418 "Steam Controller";
419 input->phys = hdev->phys;
420 input->uniq = steam->serial_no;
421 input->id.bustype = hdev->bus;
422 input->id.vendor = hdev->vendor;
423 input->id.product = hdev->product;
424 input->id.version = hdev->version;
425
426 input_set_capability(input, EV_KEY, BTN_TR2);
427 input_set_capability(input, EV_KEY, BTN_TL2);
428 input_set_capability(input, EV_KEY, BTN_TR);
429 input_set_capability(input, EV_KEY, BTN_TL);
430 input_set_capability(input, EV_KEY, BTN_Y);
431 input_set_capability(input, EV_KEY, BTN_B);
432 input_set_capability(input, EV_KEY, BTN_X);
433 input_set_capability(input, EV_KEY, BTN_A);
434 input_set_capability(input, EV_KEY, BTN_DPAD_UP);
435 input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT);
436 input_set_capability(input, EV_KEY, BTN_DPAD_LEFT);
437 input_set_capability(input, EV_KEY, BTN_DPAD_DOWN);
438 input_set_capability(input, EV_KEY, BTN_SELECT);
439 input_set_capability(input, EV_KEY, BTN_MODE);
440 input_set_capability(input, EV_KEY, BTN_START);
441 input_set_capability(input, EV_KEY, BTN_GEAR_DOWN);
442 input_set_capability(input, EV_KEY, BTN_GEAR_UP);
443 input_set_capability(input, EV_KEY, BTN_THUMBR);
444 input_set_capability(input, EV_KEY, BTN_THUMBL);
445 input_set_capability(input, EV_KEY, BTN_THUMB);
446 input_set_capability(input, EV_KEY, BTN_THUMB2);
447
448 input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0);
449 input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0);
450 input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0);
451 input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0);
452 input_set_abs_params(input, ABS_RX, -32767, 32767,
453 STEAM_PAD_FUZZ, 0);
454 input_set_abs_params(input, ABS_RY, -32767, 32767,
455 STEAM_PAD_FUZZ, 0);
456 input_set_abs_params(input, ABS_HAT0X, -32767, 32767,
457 STEAM_PAD_FUZZ, 0);
458 input_set_abs_params(input, ABS_HAT0Y, -32767, 32767,
459 STEAM_PAD_FUZZ, 0);
460 input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION);
461 input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION);
462 input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION);
463 input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION);
464 input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION);
465 input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION);
466 input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION);
467 input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION);
468
469 ret = input_register_device(input);
470 if (ret)
471 goto input_register_fail;
472
473 rcu_assign_pointer(steam->input, input);
474 return 0;
475
476input_register_fail:
477 input_free_device(input);
478 return ret;
479}
480
481static void steam_input_unregister(struct steam_device *steam)
482{
483 struct input_dev *input;
484 rcu_read_lock();
485 input = rcu_dereference(steam->input);
486 rcu_read_unlock();
487 if (!input)
488 return;
489 RCU_INIT_POINTER(steam->input, NULL);
490 synchronize_rcu();
491 input_unregister_device(input);
492}
493
494static void steam_battery_unregister(struct steam_device *steam)
495{
496 struct power_supply *battery;
497
498 rcu_read_lock();
499 battery = rcu_dereference(steam->battery);
500 rcu_read_unlock();
501
502 if (!battery)
503 return;
504 RCU_INIT_POINTER(steam->battery, NULL);
505 synchronize_rcu();
506 power_supply_unregister(battery);
507}
508
509static int steam_register(struct steam_device *steam)
510{
511 int ret;
512 bool client_opened;
513
514 /*
515 * This function can be called several times in a row with the
516 * wireless adaptor, without steam_unregister() between them, because
517 * another client send a get_connection_status command, for example.
518 * The battery and serial number are set just once per device.
519 */
520 if (!steam->serial_no[0]) {
521 /*
522 * Unlikely, but getting the serial could fail, and it is not so
523 * important, so make up a serial number and go on.
524 */
525 mutex_lock(&steam->mutex);
526 if (steam_get_serial(steam) < 0)
527 strscpy(steam->serial_no, "XXXXXXXXXX",
528 sizeof(steam->serial_no));
529 mutex_unlock(&steam->mutex);
530
531 hid_info(steam->hdev, "Steam Controller '%s' connected",
532 steam->serial_no);
533
534 /* ignore battery errors, we can live without it */
535 if (steam->quirks & STEAM_QUIRK_WIRELESS)
536 steam_battery_register(steam);
537
538 mutex_lock(&steam_devices_lock);
539 if (list_empty(&steam->list))
540 list_add(&steam->list, &steam_devices);
541 mutex_unlock(&steam_devices_lock);
542 }
543
544 mutex_lock(&steam->mutex);
545 client_opened = steam->client_opened;
546 if (!client_opened)
547 steam_set_lizard_mode(steam, lizard_mode);
548 mutex_unlock(&steam->mutex);
549
550 if (!client_opened)
551 ret = steam_input_register(steam);
552 else
553 ret = 0;
554
555 return ret;
556}
557
558static void steam_unregister(struct steam_device *steam)
559{
560 steam_battery_unregister(steam);
561 steam_input_unregister(steam);
562 if (steam->serial_no[0]) {
563 hid_info(steam->hdev, "Steam Controller '%s' disconnected",
564 steam->serial_no);
565 mutex_lock(&steam_devices_lock);
566 list_del_init(&steam->list);
567 mutex_unlock(&steam_devices_lock);
568 steam->serial_no[0] = 0;
569 }
570}
571
572static void steam_work_connect_cb(struct work_struct *work)
573{
574 struct steam_device *steam = container_of(work, struct steam_device,
575 work_connect);
576 unsigned long flags;
577 bool connected;
578 int ret;
579
580 spin_lock_irqsave(&steam->lock, flags);
581 connected = steam->connected;
582 spin_unlock_irqrestore(&steam->lock, flags);
583
584 if (connected) {
585 ret = steam_register(steam);
586 if (ret) {
587 hid_err(steam->hdev,
588 "%s:steam_register failed with error %d\n",
589 __func__, ret);
590 }
591 } else {
592 steam_unregister(steam);
593 }
594}
595
596static bool steam_is_valve_interface(struct hid_device *hdev)
597{
598 struct hid_report_enum *rep_enum;
599
600 /*
601 * The wired device creates 3 interfaces:
602 * 0: emulated mouse.
603 * 1: emulated keyboard.
604 * 2: the real game pad.
605 * The wireless device creates 5 interfaces:
606 * 0: emulated keyboard.
607 * 1-4: slots where up to 4 real game pads will be connected to.
608 * We know which one is the real gamepad interface because they are the
609 * only ones with a feature report.
610 */
611 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
612 return !list_empty(&rep_enum->report_list);
613}
614
615static int steam_client_ll_parse(struct hid_device *hdev)
616{
617 struct steam_device *steam = hdev->driver_data;
618
619 return hid_parse_report(hdev, steam->hdev->dev_rdesc,
620 steam->hdev->dev_rsize);
621}
622
623static int steam_client_ll_start(struct hid_device *hdev)
624{
625 return 0;
626}
627
628static void steam_client_ll_stop(struct hid_device *hdev)
629{
630}
631
632static int steam_client_ll_open(struct hid_device *hdev)
633{
634 struct steam_device *steam = hdev->driver_data;
635
636 mutex_lock(&steam->mutex);
637 steam->client_opened = true;
638 mutex_unlock(&steam->mutex);
639
640 steam_input_unregister(steam);
641
642 return 0;
643}
644
645static void steam_client_ll_close(struct hid_device *hdev)
646{
647 struct steam_device *steam = hdev->driver_data;
648
649 unsigned long flags;
650 bool connected;
651
652 spin_lock_irqsave(&steam->lock, flags);
653 connected = steam->connected;
654 spin_unlock_irqrestore(&steam->lock, flags);
655
656 mutex_lock(&steam->mutex);
657 steam->client_opened = false;
658 if (connected)
659 steam_set_lizard_mode(steam, lizard_mode);
660 mutex_unlock(&steam->mutex);
661
662 if (connected)
663 steam_input_register(steam);
664}
665
666static int steam_client_ll_raw_request(struct hid_device *hdev,
667 unsigned char reportnum, u8 *buf,
668 size_t count, unsigned char report_type,
669 int reqtype)
670{
671 struct steam_device *steam = hdev->driver_data;
672
673 return hid_hw_raw_request(steam->hdev, reportnum, buf, count,
674 report_type, reqtype);
675}
676
677static struct hid_ll_driver steam_client_ll_driver = {
678 .parse = steam_client_ll_parse,
679 .start = steam_client_ll_start,
680 .stop = steam_client_ll_stop,
681 .open = steam_client_ll_open,
682 .close = steam_client_ll_close,
683 .raw_request = steam_client_ll_raw_request,
684};
685
686static struct hid_device *steam_create_client_hid(struct hid_device *hdev)
687{
688 struct hid_device *client_hdev;
689
690 client_hdev = hid_allocate_device();
691 if (IS_ERR(client_hdev))
692 return client_hdev;
693
694 client_hdev->ll_driver = &steam_client_ll_driver;
695 client_hdev->dev.parent = hdev->dev.parent;
696 client_hdev->bus = hdev->bus;
697 client_hdev->vendor = hdev->vendor;
698 client_hdev->product = hdev->product;
699 client_hdev->version = hdev->version;
700 client_hdev->type = hdev->type;
701 client_hdev->country = hdev->country;
702 strscpy(client_hdev->name, hdev->name,
703 sizeof(client_hdev->name));
704 strscpy(client_hdev->phys, hdev->phys,
705 sizeof(client_hdev->phys));
706 /*
707 * Since we use the same device info than the real interface to
708 * trick userspace, we will be calling steam_probe recursively.
709 * We need to recognize the client interface somehow.
710 */
711 client_hdev->group = HID_GROUP_STEAM;
712 return client_hdev;
713}
714
715static int steam_probe(struct hid_device *hdev,
716 const struct hid_device_id *id)
717{
718 struct steam_device *steam;
719 int ret;
720
721 ret = hid_parse(hdev);
722 if (ret) {
723 hid_err(hdev,
724 "%s:parse of hid interface failed\n", __func__);
725 return ret;
726 }
727
728 /*
729 * The virtual client_dev is only used for hidraw.
730 * Also avoid the recursive probe.
731 */
732 if (hdev->group == HID_GROUP_STEAM)
733 return hid_hw_start(hdev, HID_CONNECT_HIDRAW);
734 /*
735 * The non-valve interfaces (mouse and keyboard emulation) are
736 * connected without changes.
737 */
738 if (!steam_is_valve_interface(hdev))
739 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
740
741 steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL);
742 if (!steam) {
743 ret = -ENOMEM;
744 goto steam_alloc_fail;
745 }
746 steam->hdev = hdev;
747 hid_set_drvdata(hdev, steam);
748 spin_lock_init(&steam->lock);
749 mutex_init(&steam->mutex);
750 steam->quirks = id->driver_data;
751 INIT_WORK(&steam->work_connect, steam_work_connect_cb);
752 INIT_LIST_HEAD(&steam->list);
753
754 steam->client_hdev = steam_create_client_hid(hdev);
755 if (IS_ERR(steam->client_hdev)) {
756 ret = PTR_ERR(steam->client_hdev);
757 goto client_hdev_fail;
758 }
759 steam->client_hdev->driver_data = steam;
760
761 /*
762 * With the real steam controller interface, do not connect hidraw.
763 * Instead, create the client_hid and connect that.
764 */
765 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW);
766 if (ret)
767 goto hid_hw_start_fail;
768
769 ret = hid_add_device(steam->client_hdev);
770 if (ret)
771 goto client_hdev_add_fail;
772
773 ret = hid_hw_open(hdev);
774 if (ret) {
775 hid_err(hdev,
776 "%s:hid_hw_open\n",
777 __func__);
778 goto hid_hw_open_fail;
779 }
780
781 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
782 hid_info(hdev, "Steam wireless receiver connected");
783 /* If using a wireless adaptor ask for connection status */
784 steam->connected = false;
785 steam_request_conn_status(steam);
786 } else {
787 /* A wired connection is always present */
788 steam->connected = true;
789 ret = steam_register(steam);
790 if (ret) {
791 hid_err(hdev,
792 "%s:steam_register failed with error %d\n",
793 __func__, ret);
794 goto input_register_fail;
795 }
796 }
797
798 return 0;
799
800input_register_fail:
801hid_hw_open_fail:
802client_hdev_add_fail:
803 hid_hw_stop(hdev);
804hid_hw_start_fail:
805 hid_destroy_device(steam->client_hdev);
806client_hdev_fail:
807 cancel_work_sync(&steam->work_connect);
808steam_alloc_fail:
809 hid_err(hdev, "%s: failed with error %d\n",
810 __func__, ret);
811 return ret;
812}
813
814static void steam_remove(struct hid_device *hdev)
815{
816 struct steam_device *steam = hid_get_drvdata(hdev);
817
818 if (!steam || hdev->group == HID_GROUP_STEAM) {
819 hid_hw_stop(hdev);
820 return;
821 }
822
823 hid_destroy_device(steam->client_hdev);
824 steam->client_opened = false;
825 cancel_work_sync(&steam->work_connect);
826 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
827 hid_info(hdev, "Steam wireless receiver disconnected");
828 }
829 hid_hw_close(hdev);
830 hid_hw_stop(hdev);
831 steam_unregister(steam);
832}
833
834static void steam_do_connect_event(struct steam_device *steam, bool connected)
835{
836 unsigned long flags;
837 bool changed;
838
839 spin_lock_irqsave(&steam->lock, flags);
840 changed = steam->connected != connected;
841 steam->connected = connected;
842 spin_unlock_irqrestore(&steam->lock, flags);
843
844 if (changed && schedule_work(&steam->work_connect) == 0)
845 dbg_hid("%s: connected=%d event already queued\n",
846 __func__, connected);
847}
848
849/*
850 * Some input data in the protocol has the opposite sign.
851 * Clamp the values to 32767..-32767 so that the range is
852 * symmetrical and can be negated safely.
853 */
854static inline s16 steam_le16(u8 *data)
855{
856 s16 x = (s16) le16_to_cpup((__le16 *)data);
857
858 return x == -32768 ? -32767 : x;
859}
860
861/*
862 * The size for this message payload is 60.
863 * The known values are:
864 * (* values are not sent through wireless)
865 * (* accelerator/gyro is disabled by default)
866 * Offset| Type | Mapped to |Meaning
867 * -------+-------+-----------+--------------------------
868 * 4-7 | u32 | -- | sequence number
869 * 8-10 | 24bit | see below | buttons
870 * 11 | u8 | ABS_HAT2Y | left trigger
871 * 12 | u8 | ABS_HAT2X | right trigger
872 * 13-15 | -- | -- | always 0
873 * 16-17 | s16 | ABS_X/ABS_HAT0X | X value
874 * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value
875 * 20-21 | s16 | ABS_RX | right-pad X value
876 * 22-23 | s16 | ABS_RY | right-pad Y value
877 * 24-25 | s16 | -- | * left trigger
878 * 26-27 | s16 | -- | * right trigger
879 * 28-29 | s16 | -- | * accelerometer X value
880 * 30-31 | s16 | -- | * accelerometer Y value
881 * 32-33 | s16 | -- | * accelerometer Z value
882 * 34-35 | s16 | -- | gyro X value
883 * 36-36 | s16 | -- | gyro Y value
884 * 38-39 | s16 | -- | gyro Z value
885 * 40-41 | s16 | -- | quaternion W value
886 * 42-43 | s16 | -- | quaternion X value
887 * 44-45 | s16 | -- | quaternion Y value
888 * 46-47 | s16 | -- | quaternion Z value
889 * 48-49 | -- | -- | always 0
890 * 50-51 | s16 | -- | * left trigger (uncalibrated)
891 * 52-53 | s16 | -- | * right trigger (uncalibrated)
892 * 54-55 | s16 | -- | * joystick X value (uncalibrated)
893 * 56-57 | s16 | -- | * joystick Y value (uncalibrated)
894 * 58-59 | s16 | -- | * left-pad X value
895 * 60-61 | s16 | -- | * left-pad Y value
896 * 62-63 | u16 | -- | * battery voltage
897 *
898 * The buttons are:
899 * Bit | Mapped to | Description
900 * ------+------------+--------------------------------
901 * 8.0 | BTN_TR2 | right trigger fully pressed
902 * 8.1 | BTN_TL2 | left trigger fully pressed
903 * 8.2 | BTN_TR | right shoulder
904 * 8.3 | BTN_TL | left shoulder
905 * 8.4 | BTN_Y | button Y
906 * 8.5 | BTN_B | button B
907 * 8.6 | BTN_X | button X
908 * 8.7 | BTN_A | button A
909 * 9.0 | BTN_DPAD_UP | lef-pad up
910 * 9.1 | BTN_DPAD_RIGHT | lef-pad right
911 * 9.2 | BTN_DPAD_LEFT | lef-pad left
912 * 9.3 | BTN_DPAD_DOWN | lef-pad down
913 * 9.4 | BTN_SELECT | menu left
914 * 9.5 | BTN_MODE | steam logo
915 * 9.6 | BTN_START | menu right
916 * 9.7 | BTN_GEAR_DOWN | left back lever
917 * 10.0 | BTN_GEAR_UP | right back lever
918 * 10.1 | -- | left-pad clicked
919 * 10.2 | BTN_THUMBR | right-pad clicked
920 * 10.3 | BTN_THUMB | left-pad touched (but see explanation below)
921 * 10.4 | BTN_THUMB2 | right-pad touched
922 * 10.5 | -- | unknown
923 * 10.6 | BTN_THUMBL | joystick clicked
924 * 10.7 | -- | lpad_and_joy
925 */
926
927static void steam_do_input_event(struct steam_device *steam,
928 struct input_dev *input, u8 *data)
929{
930 /* 24 bits of buttons */
931 u8 b8, b9, b10;
932 s16 x, y;
933 bool lpad_touched, lpad_and_joy;
934
935 b8 = data[8];
936 b9 = data[9];
937 b10 = data[10];
938
939 input_report_abs(input, ABS_HAT2Y, data[11]);
940 input_report_abs(input, ABS_HAT2X, data[12]);
941
942 /*
943 * These two bits tells how to interpret the values X and Y.
944 * lpad_and_joy tells that the joystick and the lpad are used at the
945 * same time.
946 * lpad_touched tells whether X/Y are to be read as lpad coord or
947 * joystick values.
948 * (lpad_touched || lpad_and_joy) tells if the lpad is really touched.
949 */
950 lpad_touched = b10 & BIT(3);
951 lpad_and_joy = b10 & BIT(7);
952 x = steam_le16(data + 16);
953 y = -steam_le16(data + 18);
954
955 input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x);
956 input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y);
957 /* Check if joystick is centered */
958 if (lpad_touched && !lpad_and_joy) {
959 input_report_abs(input, ABS_X, 0);
960 input_report_abs(input, ABS_Y, 0);
961 }
962 /* Check if lpad is untouched */
963 if (!(lpad_touched || lpad_and_joy)) {
964 input_report_abs(input, ABS_HAT0X, 0);
965 input_report_abs(input, ABS_HAT0Y, 0);
966 }
967
968 input_report_abs(input, ABS_RX, steam_le16(data + 20));
969 input_report_abs(input, ABS_RY, -steam_le16(data + 22));
970
971 input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0)));
972 input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1)));
973 input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2)));
974 input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3)));
975 input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4)));
976 input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5)));
977 input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6)));
978 input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7)));
979 input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4)));
980 input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5)));
981 input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6)));
982 input_event(input, EV_KEY, BTN_GEAR_DOWN, !!(b9 & BIT(7)));
983 input_event(input, EV_KEY, BTN_GEAR_UP, !!(b10 & BIT(0)));
984 input_event(input, EV_KEY, BTN_THUMBR, !!(b10 & BIT(2)));
985 input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6)));
986 input_event(input, EV_KEY, BTN_THUMB, lpad_touched || lpad_and_joy);
987 input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(4)));
988 input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0)));
989 input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1)));
990 input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2)));
991 input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3)));
992
993 input_sync(input);
994}
995
996/*
997 * The size for this message payload is 11.
998 * The known values are:
999 * Offset| Type | Meaning
1000 * -------+-------+---------------------------
1001 * 4-7 | u32 | sequence number
1002 * 8-11 | -- | always 0
1003 * 12-13 | u16 | voltage (mV)
1004 * 14 | u8 | battery percent
1005 */
1006static void steam_do_battery_event(struct steam_device *steam,
1007 struct power_supply *battery, u8 *data)
1008{
1009 unsigned long flags;
1010
1011 s16 volts = steam_le16(data + 12);
1012 u8 batt = data[14];
1013
1014 /* Creating the battery may have failed */
1015 rcu_read_lock();
1016 battery = rcu_dereference(steam->battery);
1017 if (likely(battery)) {
1018 spin_lock_irqsave(&steam->lock, flags);
1019 steam->voltage = volts;
1020 steam->battery_charge = batt;
1021 spin_unlock_irqrestore(&steam->lock, flags);
1022 power_supply_changed(battery);
1023 }
1024 rcu_read_unlock();
1025}
1026
1027static int steam_raw_event(struct hid_device *hdev,
1028 struct hid_report *report, u8 *data,
1029 int size)
1030{
1031 struct steam_device *steam = hid_get_drvdata(hdev);
1032 struct input_dev *input;
1033 struct power_supply *battery;
1034
1035 if (!steam)
1036 return 0;
1037
1038 if (steam->client_opened)
1039 hid_input_report(steam->client_hdev, HID_FEATURE_REPORT,
1040 data, size, 0);
1041 /*
1042 * All messages are size=64, all values little-endian.
1043 * The format is:
1044 * Offset| Meaning
1045 * -------+--------------------------------------------
1046 * 0-1 | always 0x01, 0x00, maybe protocol version?
1047 * 2 | type of message
1048 * 3 | length of the real payload (not checked)
1049 * 4-n | payload data, depends on the type
1050 *
1051 * There are these known types of message:
1052 * 0x01: input data (60 bytes)
1053 * 0x03: wireless connect/disconnect (1 byte)
1054 * 0x04: battery status (11 bytes)
1055 */
1056
1057 if (size != 64 || data[0] != 1 || data[1] != 0)
1058 return 0;
1059
1060 switch (data[2]) {
1061 case STEAM_EV_INPUT_DATA:
1062 if (steam->client_opened)
1063 return 0;
1064 rcu_read_lock();
1065 input = rcu_dereference(steam->input);
1066 if (likely(input))
1067 steam_do_input_event(steam, input, data);
1068 rcu_read_unlock();
1069 break;
1070 case STEAM_EV_CONNECT:
1071 /*
1072 * The payload of this event is a single byte:
1073 * 0x01: disconnected.
1074 * 0x02: connected.
1075 */
1076 switch (data[4]) {
1077 case 0x01:
1078 steam_do_connect_event(steam, false);
1079 break;
1080 case 0x02:
1081 steam_do_connect_event(steam, true);
1082 break;
1083 }
1084 break;
1085 case STEAM_EV_BATTERY:
1086 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
1087 rcu_read_lock();
1088 battery = rcu_dereference(steam->battery);
1089 if (likely(battery)) {
1090 steam_do_battery_event(steam, battery, data);
1091 } else {
1092 dbg_hid(
1093 "%s: battery data without connect event\n",
1094 __func__);
1095 steam_do_connect_event(steam, true);
1096 }
1097 rcu_read_unlock();
1098 }
1099 break;
1100 }
1101 return 0;
1102}
1103
1104static int steam_param_set_lizard_mode(const char *val,
1105 const struct kernel_param *kp)
1106{
1107 struct steam_device *steam;
1108 int ret;
1109
1110 ret = param_set_bool(val, kp);
1111 if (ret)
1112 return ret;
1113
1114 mutex_lock(&steam_devices_lock);
1115 list_for_each_entry(steam, &steam_devices, list) {
1116 mutex_lock(&steam->mutex);
1117 if (!steam->client_opened)
1118 steam_set_lizard_mode(steam, lizard_mode);
1119 mutex_unlock(&steam->mutex);
1120 }
1121 mutex_unlock(&steam_devices_lock);
1122 return 0;
1123}
1124
1125static const struct kernel_param_ops steam_lizard_mode_ops = {
1126 .set = steam_param_set_lizard_mode,
1127 .get = param_get_bool,
1128};
1129
1130module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644);
1131MODULE_PARM_DESC(lizard_mode,
1132 "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use");
1133
1134static const struct hid_device_id steam_controllers[] = {
1135 { /* Wired Steam Controller */
1136 HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
1137 USB_DEVICE_ID_STEAM_CONTROLLER)
1138 },
1139 { /* Wireless Steam Controller */
1140 HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
1141 USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS),
1142 .driver_data = STEAM_QUIRK_WIRELESS
1143 },
1144 {}
1145};
1146
1147MODULE_DEVICE_TABLE(hid, steam_controllers);
1148
1149static struct hid_driver steam_controller_driver = {
1150 .name = "hid-steam",
1151 .id_table = steam_controllers,
1152 .probe = steam_probe,
1153 .remove = steam_remove,
1154 .raw_event = steam_raw_event,
1155};
1156
1157module_hid_driver(steam_controller_driver);