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