tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * HID driver for Steelseries devices
4 *
5 * Copyright (c) 2013 Simon Wood
6 * Copyright (c) 2023 Bastien Nocera
7 */
8
9/*
10 */
11
12#include <linux/device.h>
13#include <linux/hid.h>
14#include <linux/module.h>
15#include <linux/usb.h>
16#include <linux/leds.h>
17
18#include "hid-ids.h"
19
20#define STEELSERIES_SRWS1 BIT(0)
21#define STEELSERIES_ARCTIS_1 BIT(1)
22#define STEELSERIES_ARCTIS_9 BIT(2)
23
24struct steelseries_device {
25 struct hid_device *hdev;
26 unsigned long quirks;
27
28 struct delayed_work battery_work;
29 spinlock_t lock;
30 bool removed;
31
32 struct power_supply_desc battery_desc;
33 struct power_supply *battery;
34 uint8_t battery_capacity;
35 bool headset_connected;
36 bool battery_charging;
37};
38
39#if IS_BUILTIN(CONFIG_LEDS_CLASS) || \
40 (IS_MODULE(CONFIG_LEDS_CLASS) && IS_MODULE(CONFIG_HID_STEELSERIES))
41#define SRWS1_NUMBER_LEDS 15
42struct steelseries_srws1_data {
43 __u16 led_state;
44 /* the last element is used for setting all leds simultaneously */
45 struct led_classdev *led[SRWS1_NUMBER_LEDS + 1];
46};
47#endif
48
49/* Fixed report descriptor for Steelseries SRW-S1 wheel controller
50 *
51 * The original descriptor hides the sensitivity and assists dials
52 * a custom vendor usage page. This inserts a patch to make them
53 * appear in the 'Generic Desktop' usage.
54 */
55
56static const __u8 steelseries_srws1_rdesc_fixed[] = {
570x05, 0x01, /* Usage Page (Desktop) */
580x09, 0x08, /* Usage (MultiAxis), Changed */
590xA1, 0x01, /* Collection (Application), */
600xA1, 0x02, /* Collection (Logical), */
610x95, 0x01, /* Report Count (1), */
620x05, 0x01, /* Changed Usage Page (Desktop), */
630x09, 0x30, /* Changed Usage (X), */
640x16, 0xF8, 0xF8, /* Logical Minimum (-1800), */
650x26, 0x08, 0x07, /* Logical Maximum (1800), */
660x65, 0x14, /* Unit (Degrees), */
670x55, 0x0F, /* Unit Exponent (15), */
680x75, 0x10, /* Report Size (16), */
690x81, 0x02, /* Input (Variable), */
700x09, 0x31, /* Changed Usage (Y), */
710x15, 0x00, /* Logical Minimum (0), */
720x26, 0xFF, 0x03, /* Logical Maximum (1023), */
730x75, 0x0C, /* Report Size (12), */
740x81, 0x02, /* Input (Variable), */
750x09, 0x32, /* Changed Usage (Z), */
760x15, 0x00, /* Logical Minimum (0), */
770x26, 0xFF, 0x03, /* Logical Maximum (1023), */
780x75, 0x0C, /* Report Size (12), */
790x81, 0x02, /* Input (Variable), */
800x05, 0x01, /* Usage Page (Desktop), */
810x09, 0x39, /* Usage (Hat Switch), */
820x25, 0x07, /* Logical Maximum (7), */
830x35, 0x00, /* Physical Minimum (0), */
840x46, 0x3B, 0x01, /* Physical Maximum (315), */
850x65, 0x14, /* Unit (Degrees), */
860x75, 0x04, /* Report Size (4), */
870x95, 0x01, /* Report Count (1), */
880x81, 0x02, /* Input (Variable), */
890x25, 0x01, /* Logical Maximum (1), */
900x45, 0x01, /* Physical Maximum (1), */
910x65, 0x00, /* Unit, */
920x75, 0x01, /* Report Size (1), */
930x95, 0x03, /* Report Count (3), */
940x81, 0x01, /* Input (Constant), */
950x05, 0x09, /* Usage Page (Button), */
960x19, 0x01, /* Usage Minimum (01h), */
970x29, 0x11, /* Usage Maximum (11h), */
980x95, 0x11, /* Report Count (17), */
990x81, 0x02, /* Input (Variable), */
100 /* ---- Dial patch starts here ---- */
1010x05, 0x01, /* Usage Page (Desktop), */
1020x09, 0x33, /* Usage (RX), */
1030x75, 0x04, /* Report Size (4), */
1040x95, 0x02, /* Report Count (2), */
1050x15, 0x00, /* Logical Minimum (0), */
1060x25, 0x0b, /* Logical Maximum (b), */
1070x81, 0x02, /* Input (Variable), */
1080x09, 0x35, /* Usage (RZ), */
1090x75, 0x04, /* Report Size (4), */
1100x95, 0x01, /* Report Count (1), */
1110x25, 0x03, /* Logical Maximum (3), */
1120x81, 0x02, /* Input (Variable), */
113 /* ---- Dial patch ends here ---- */
1140x06, 0x00, 0xFF, /* Usage Page (FF00h), */
1150x09, 0x01, /* Usage (01h), */
1160x75, 0x04, /* Changed Report Size (4), */
1170x95, 0x0D, /* Changed Report Count (13), */
1180x81, 0x02, /* Input (Variable), */
1190xC0, /* End Collection, */
1200xA1, 0x02, /* Collection (Logical), */
1210x09, 0x02, /* Usage (02h), */
1220x75, 0x08, /* Report Size (8), */
1230x95, 0x10, /* Report Count (16), */
1240x91, 0x02, /* Output (Variable), */
1250xC0, /* End Collection, */
1260xC0 /* End Collection */
127};
128
129#if IS_BUILTIN(CONFIG_LEDS_CLASS) || \
130 (IS_MODULE(CONFIG_LEDS_CLASS) && IS_MODULE(CONFIG_HID_STEELSERIES))
131static void steelseries_srws1_set_leds(struct hid_device *hdev, __u16 leds)
132{
133 struct list_head *report_list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
134 struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
135 __s32 *value = report->field[0]->value;
136
137 value[0] = 0x40;
138 value[1] = leds & 0xFF;
139 value[2] = leds >> 8;
140 value[3] = 0x00;
141 value[4] = 0x00;
142 value[5] = 0x00;
143 value[6] = 0x00;
144 value[7] = 0x00;
145 value[8] = 0x00;
146 value[9] = 0x00;
147 value[10] = 0x00;
148 value[11] = 0x00;
149 value[12] = 0x00;
150 value[13] = 0x00;
151 value[14] = 0x00;
152 value[15] = 0x00;
153
154 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
155
156 /* Note: LED change does not show on device until the device is read/polled */
157}
158
159static void steelseries_srws1_led_all_set_brightness(struct led_classdev *led_cdev,
160 enum led_brightness value)
161{
162 struct device *dev = led_cdev->dev->parent;
163 struct hid_device *hid = to_hid_device(dev);
164 struct steelseries_srws1_data *drv_data = hid_get_drvdata(hid);
165
166 if (!drv_data) {
167 hid_err(hid, "Device data not found.");
168 return;
169 }
170
171 if (value == LED_OFF)
172 drv_data->led_state = 0;
173 else
174 drv_data->led_state = (1 << (SRWS1_NUMBER_LEDS + 1)) - 1;
175
176 steelseries_srws1_set_leds(hid, drv_data->led_state);
177}
178
179static enum led_brightness steelseries_srws1_led_all_get_brightness(struct led_classdev *led_cdev)
180{
181 struct device *dev = led_cdev->dev->parent;
182 struct hid_device *hid = to_hid_device(dev);
183 struct steelseries_srws1_data *drv_data;
184
185 drv_data = hid_get_drvdata(hid);
186
187 if (!drv_data) {
188 hid_err(hid, "Device data not found.");
189 return LED_OFF;
190 }
191
192 return (drv_data->led_state >> SRWS1_NUMBER_LEDS) ? LED_FULL : LED_OFF;
193}
194
195static void steelseries_srws1_led_set_brightness(struct led_classdev *led_cdev,
196 enum led_brightness value)
197{
198 struct device *dev = led_cdev->dev->parent;
199 struct hid_device *hid = to_hid_device(dev);
200 struct steelseries_srws1_data *drv_data = hid_get_drvdata(hid);
201 int i, state = 0;
202
203 if (!drv_data) {
204 hid_err(hid, "Device data not found.");
205 return;
206 }
207
208 for (i = 0; i < SRWS1_NUMBER_LEDS; i++) {
209 if (led_cdev != drv_data->led[i])
210 continue;
211
212 state = (drv_data->led_state >> i) & 1;
213 if (value == LED_OFF && state) {
214 drv_data->led_state &= ~(1 << i);
215 steelseries_srws1_set_leds(hid, drv_data->led_state);
216 } else if (value != LED_OFF && !state) {
217 drv_data->led_state |= 1 << i;
218 steelseries_srws1_set_leds(hid, drv_data->led_state);
219 }
220 break;
221 }
222}
223
224static enum led_brightness steelseries_srws1_led_get_brightness(struct led_classdev *led_cdev)
225{
226 struct device *dev = led_cdev->dev->parent;
227 struct hid_device *hid = to_hid_device(dev);
228 struct steelseries_srws1_data *drv_data;
229 int i, value = 0;
230
231 drv_data = hid_get_drvdata(hid);
232
233 if (!drv_data) {
234 hid_err(hid, "Device data not found.");
235 return LED_OFF;
236 }
237
238 for (i = 0; i < SRWS1_NUMBER_LEDS; i++)
239 if (led_cdev == drv_data->led[i]) {
240 value = (drv_data->led_state >> i) & 1;
241 break;
242 }
243
244 return value ? LED_FULL : LED_OFF;
245}
246
247static int steelseries_srws1_probe(struct hid_device *hdev,
248 const struct hid_device_id *id)
249{
250 int ret, i;
251 struct led_classdev *led;
252 struct steelseries_srws1_data *drv_data;
253 size_t name_sz;
254 char *name;
255
256 drv_data = devm_kzalloc(&hdev->dev, sizeof(*drv_data), GFP_KERNEL);
257 if (drv_data == NULL) {
258 hid_err(hdev, "can't alloc SRW-S1 memory\n");
259 return -ENOMEM;
260 }
261
262 hid_set_drvdata(hdev, drv_data);
263
264 ret = hid_parse(hdev);
265 if (ret) {
266 hid_err(hdev, "parse failed\n");
267 goto err;
268 }
269
270 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 16)) {
271 ret = -ENODEV;
272 goto err;
273 }
274
275 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
276 if (ret) {
277 hid_err(hdev, "hw start failed\n");
278 goto err;
279 }
280
281 /* register led subsystem */
282 drv_data->led_state = 0;
283 for (i = 0; i < SRWS1_NUMBER_LEDS + 1; i++)
284 drv_data->led[i] = NULL;
285
286 steelseries_srws1_set_leds(hdev, 0);
287
288 name_sz = strlen(hdev->uniq) + 16;
289
290 /* 'ALL', for setting all LEDs simultaneously */
291 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev)+name_sz, GFP_KERNEL);
292 if (!led) {
293 hid_err(hdev, "can't allocate memory for LED ALL\n");
294 goto out;
295 }
296
297 name = (void *)(&led[1]);
298 snprintf(name, name_sz, "SRWS1::%s::RPMALL", hdev->uniq);
299 led->name = name;
300 led->brightness = 0;
301 led->max_brightness = 1;
302 led->brightness_get = steelseries_srws1_led_all_get_brightness;
303 led->brightness_set = steelseries_srws1_led_all_set_brightness;
304
305 drv_data->led[SRWS1_NUMBER_LEDS] = led;
306 ret = devm_led_classdev_register(&hdev->dev, led);
307 if (ret) {
308 hid_err(hdev, "failed to register LED %d. Aborting.\n", SRWS1_NUMBER_LEDS);
309 goto out; /* let the driver continue without LEDs */
310 }
311
312 /* Each individual LED */
313 for (i = 0; i < SRWS1_NUMBER_LEDS; i++) {
314 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev)+name_sz, GFP_KERNEL);
315 if (!led) {
316 hid_err(hdev, "can't allocate memory for LED %d\n", i);
317 break;
318 }
319
320 name = (void *)(&led[1]);
321 snprintf(name, name_sz, "SRWS1::%s::RPM%d", hdev->uniq, i+1);
322 led->name = name;
323 led->brightness = 0;
324 led->max_brightness = 1;
325 led->brightness_get = steelseries_srws1_led_get_brightness;
326 led->brightness_set = steelseries_srws1_led_set_brightness;
327
328 drv_data->led[i] = led;
329 ret = devm_led_classdev_register(&hdev->dev, led);
330
331 if (ret) {
332 hid_err(hdev, "failed to register LED %d. Aborting.\n", i);
333 break; /* but let the driver continue without LEDs */
334 }
335 }
336out:
337 return 0;
338err:
339 return ret;
340}
341#endif
342
343#define STEELSERIES_HEADSET_BATTERY_TIMEOUT_MS 3000
344
345#define ARCTIS_1_BATTERY_RESPONSE_LEN 8
346#define ARCTIS_9_BATTERY_RESPONSE_LEN 64
347static const char arctis_1_battery_request[] = { 0x06, 0x12 };
348static const char arctis_9_battery_request[] = { 0x00, 0x20 };
349
350static int steelseries_headset_request_battery(struct hid_device *hdev,
351 const char *request, size_t len)
352{
353 u8 *write_buf;
354 int ret;
355
356 /* Request battery information */
357 write_buf = kmemdup(request, len, GFP_KERNEL);
358 if (!write_buf)
359 return -ENOMEM;
360
361 hid_dbg(hdev, "Sending battery request report");
362 ret = hid_hw_raw_request(hdev, request[0], write_buf, len,
363 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
364 if (ret < (int)len) {
365 hid_err(hdev, "hid_hw_raw_request() failed with %d\n", ret);
366 ret = -ENODATA;
367 }
368
369 kfree(write_buf);
370 return ret;
371}
372
373static void steelseries_headset_fetch_battery(struct hid_device *hdev)
374{
375 int ret = 0;
376
377 if (hdev->product == USB_DEVICE_ID_STEELSERIES_ARCTIS_1)
378 ret = steelseries_headset_request_battery(hdev,
379 arctis_1_battery_request, sizeof(arctis_1_battery_request));
380 else if (hdev->product == USB_DEVICE_ID_STEELSERIES_ARCTIS_9)
381 ret = steelseries_headset_request_battery(hdev,
382 arctis_9_battery_request, sizeof(arctis_9_battery_request));
383
384 if (ret < 0)
385 hid_dbg(hdev,
386 "Battery query failed (err: %d)\n", ret);
387}
388
389static int battery_capacity_to_level(int capacity)
390{
391 if (capacity >= 50)
392 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
393 if (capacity >= 20)
394 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
395 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
396}
397
398static void steelseries_headset_battery_timer_tick(struct work_struct *work)
399{
400 struct steelseries_device *sd = container_of(work,
401 struct steelseries_device, battery_work.work);
402 struct hid_device *hdev = sd->hdev;
403
404 steelseries_headset_fetch_battery(hdev);
405}
406
407#define STEELSERIES_PREFIX "SteelSeries "
408#define STEELSERIES_PREFIX_LEN strlen(STEELSERIES_PREFIX)
409
410static int steelseries_headset_battery_get_property(struct power_supply *psy,
411 enum power_supply_property psp,
412 union power_supply_propval *val)
413{
414 struct steelseries_device *sd = power_supply_get_drvdata(psy);
415 int ret = 0;
416
417 switch (psp) {
418 case POWER_SUPPLY_PROP_MODEL_NAME:
419 val->strval = sd->hdev->name;
420 while (!strncmp(val->strval, STEELSERIES_PREFIX, STEELSERIES_PREFIX_LEN))
421 val->strval += STEELSERIES_PREFIX_LEN;
422 break;
423 case POWER_SUPPLY_PROP_MANUFACTURER:
424 val->strval = "SteelSeries";
425 break;
426 case POWER_SUPPLY_PROP_PRESENT:
427 val->intval = 1;
428 break;
429 case POWER_SUPPLY_PROP_STATUS:
430 if (sd->headset_connected) {
431 val->intval = sd->battery_charging ?
432 POWER_SUPPLY_STATUS_CHARGING :
433 POWER_SUPPLY_STATUS_DISCHARGING;
434 } else
435 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
436 break;
437 case POWER_SUPPLY_PROP_SCOPE:
438 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
439 break;
440 case POWER_SUPPLY_PROP_CAPACITY:
441 val->intval = sd->battery_capacity;
442 break;
443 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
444 val->intval = battery_capacity_to_level(sd->battery_capacity);
445 break;
446 default:
447 ret = -EINVAL;
448 break;
449 }
450 return ret;
451}
452
453static void
454steelseries_headset_set_wireless_status(struct hid_device *hdev,
455 bool connected)
456{
457 struct usb_interface *intf;
458
459 if (!hid_is_usb(hdev))
460 return;
461
462 intf = to_usb_interface(hdev->dev.parent);
463 usb_set_wireless_status(intf, connected ?
464 USB_WIRELESS_STATUS_CONNECTED :
465 USB_WIRELESS_STATUS_DISCONNECTED);
466}
467
468static enum power_supply_property steelseries_headset_battery_props[] = {
469 POWER_SUPPLY_PROP_MODEL_NAME,
470 POWER_SUPPLY_PROP_MANUFACTURER,
471 POWER_SUPPLY_PROP_PRESENT,
472 POWER_SUPPLY_PROP_STATUS,
473 POWER_SUPPLY_PROP_SCOPE,
474 POWER_SUPPLY_PROP_CAPACITY,
475 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
476};
477
478static int steelseries_headset_battery_register(struct steelseries_device *sd)
479{
480 static atomic_t battery_no = ATOMIC_INIT(0);
481 struct power_supply_config battery_cfg = { .drv_data = sd, };
482 unsigned long n;
483 int ret;
484
485 sd->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
486 sd->battery_desc.properties = steelseries_headset_battery_props;
487 sd->battery_desc.num_properties = ARRAY_SIZE(steelseries_headset_battery_props);
488 sd->battery_desc.get_property = steelseries_headset_battery_get_property;
489 sd->battery_desc.use_for_apm = 0;
490 n = atomic_inc_return(&battery_no) - 1;
491 sd->battery_desc.name = devm_kasprintf(&sd->hdev->dev, GFP_KERNEL,
492 "steelseries_headset_battery_%ld", n);
493 if (!sd->battery_desc.name)
494 return -ENOMEM;
495
496 /* avoid the warning of 0% battery while waiting for the first info */
497 steelseries_headset_set_wireless_status(sd->hdev, false);
498 sd->battery_capacity = 100;
499 sd->battery_charging = false;
500
501 sd->battery = devm_power_supply_register(&sd->hdev->dev,
502 &sd->battery_desc, &battery_cfg);
503 if (IS_ERR(sd->battery)) {
504 ret = PTR_ERR(sd->battery);
505 hid_err(sd->hdev,
506 "%s:power_supply_register failed with error %d\n",
507 __func__, ret);
508 return ret;
509 }
510 power_supply_powers(sd->battery, &sd->hdev->dev);
511
512 INIT_DELAYED_WORK(&sd->battery_work, steelseries_headset_battery_timer_tick);
513 steelseries_headset_fetch_battery(sd->hdev);
514
515 if (sd->quirks & STEELSERIES_ARCTIS_9) {
516 /* The first fetch_battery request can remain unanswered in some cases */
517 schedule_delayed_work(&sd->battery_work,
518 msecs_to_jiffies(STEELSERIES_HEADSET_BATTERY_TIMEOUT_MS));
519 }
520
521 return 0;
522}
523
524static bool steelseries_is_vendor_usage_page(struct hid_device *hdev, uint8_t usage_page)
525{
526 return hdev->rdesc[0] == 0x06 &&
527 hdev->rdesc[1] == usage_page &&
528 hdev->rdesc[2] == 0xff;
529}
530
531static int steelseries_probe(struct hid_device *hdev, const struct hid_device_id *id)
532{
533 struct steelseries_device *sd;
534 int ret;
535
536 if (hdev->product == USB_DEVICE_ID_STEELSERIES_SRWS1) {
537#if IS_BUILTIN(CONFIG_LEDS_CLASS) || \
538 (IS_MODULE(CONFIG_LEDS_CLASS) && IS_MODULE(CONFIG_HID_STEELSERIES))
539 return steelseries_srws1_probe(hdev, id);
540#else
541 return -ENODEV;
542#endif
543 }
544
545 sd = devm_kzalloc(&hdev->dev, sizeof(*sd), GFP_KERNEL);
546 if (!sd)
547 return -ENOMEM;
548 hid_set_drvdata(hdev, sd);
549 sd->hdev = hdev;
550 sd->quirks = id->driver_data;
551
552 ret = hid_parse(hdev);
553 if (ret)
554 return ret;
555
556 if (sd->quirks & STEELSERIES_ARCTIS_9 &&
557 !steelseries_is_vendor_usage_page(hdev, 0xc0))
558 return -ENODEV;
559
560 spin_lock_init(&sd->lock);
561
562 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
563 if (ret)
564 return ret;
565
566 ret = hid_hw_open(hdev);
567 if (ret)
568 return ret;
569
570 if (steelseries_headset_battery_register(sd) < 0)
571 hid_err(sd->hdev,
572 "Failed to register battery for headset\n");
573
574 return ret;
575}
576
577static void steelseries_remove(struct hid_device *hdev)
578{
579 struct steelseries_device *sd;
580 unsigned long flags;
581
582 if (hdev->product == USB_DEVICE_ID_STEELSERIES_SRWS1) {
583#if IS_BUILTIN(CONFIG_LEDS_CLASS) || \
584 (IS_MODULE(CONFIG_LEDS_CLASS) && IS_MODULE(CONFIG_HID_STEELSERIES))
585 hid_hw_stop(hdev);
586#endif
587 return;
588 }
589
590 sd = hid_get_drvdata(hdev);
591
592 spin_lock_irqsave(&sd->lock, flags);
593 sd->removed = true;
594 spin_unlock_irqrestore(&sd->lock, flags);
595
596 cancel_delayed_work_sync(&sd->battery_work);
597
598 hid_hw_close(hdev);
599 hid_hw_stop(hdev);
600}
601
602static const __u8 *steelseries_srws1_report_fixup(struct hid_device *hdev,
603 __u8 *rdesc, unsigned int *rsize)
604{
605 if (hdev->vendor != USB_VENDOR_ID_STEELSERIES ||
606 hdev->product != USB_DEVICE_ID_STEELSERIES_SRWS1)
607 return rdesc;
608
609 if (*rsize >= 115 && rdesc[11] == 0x02 && rdesc[13] == 0xc8
610 && rdesc[29] == 0xbb && rdesc[40] == 0xc5) {
611 hid_info(hdev, "Fixing up Steelseries SRW-S1 report descriptor\n");
612 *rsize = sizeof(steelseries_srws1_rdesc_fixed);
613 return steelseries_srws1_rdesc_fixed;
614 }
615 return rdesc;
616}
617
618static uint8_t steelseries_headset_map_capacity(uint8_t capacity, uint8_t min_in, uint8_t max_in)
619{
620 if (capacity >= max_in)
621 return 100;
622 if (capacity <= min_in)
623 return 0;
624 return (capacity - min_in) * 100 / (max_in - min_in);
625}
626
627static int steelseries_headset_raw_event(struct hid_device *hdev,
628 struct hid_report *report, u8 *read_buf,
629 int size)
630{
631 struct steelseries_device *sd = hid_get_drvdata(hdev);
632 int capacity = sd->battery_capacity;
633 bool connected = sd->headset_connected;
634 bool charging = sd->battery_charging;
635 unsigned long flags;
636
637 /* Not a headset */
638 if (hdev->product == USB_DEVICE_ID_STEELSERIES_SRWS1)
639 return 0;
640
641 if (hdev->product == USB_DEVICE_ID_STEELSERIES_ARCTIS_1) {
642 hid_dbg(sd->hdev,
643 "Parsing raw event for Arctis 1 headset (%*ph)\n", size, read_buf);
644 if (size < ARCTIS_1_BATTERY_RESPONSE_LEN ||
645 memcmp(read_buf, arctis_1_battery_request, sizeof(arctis_1_battery_request))) {
646 if (!delayed_work_pending(&sd->battery_work))
647 goto request_battery;
648 return 0;
649 }
650 if (read_buf[2] == 0x01) {
651 connected = false;
652 capacity = 100;
653 } else {
654 connected = true;
655 capacity = read_buf[3];
656 }
657 }
658
659 if (hdev->product == USB_DEVICE_ID_STEELSERIES_ARCTIS_9) {
660 hid_dbg(sd->hdev,
661 "Parsing raw event for Arctis 9 headset (%*ph)\n", size, read_buf);
662 if (size < ARCTIS_9_BATTERY_RESPONSE_LEN) {
663 if (!delayed_work_pending(&sd->battery_work))
664 goto request_battery;
665 return 0;
666 }
667
668 if (read_buf[0] == 0xaa && read_buf[1] == 0x01) {
669 connected = true;
670 charging = read_buf[4] == 0x01;
671
672 /*
673 * Found no official documentation about min and max.
674 * Values defined by testing.
675 */
676 capacity = steelseries_headset_map_capacity(read_buf[3], 0x68, 0x9d);
677 } else {
678 /*
679 * Device is off and sends the last known status read_buf[1] == 0x03 or
680 * there is no known status of the device read_buf[0] == 0x55
681 */
682 connected = false;
683 charging = false;
684 }
685 }
686
687 if (connected != sd->headset_connected) {
688 hid_dbg(sd->hdev,
689 "Connected status changed from %sconnected to %sconnected\n",
690 sd->headset_connected ? "" : "not ",
691 connected ? "" : "not ");
692 sd->headset_connected = connected;
693 steelseries_headset_set_wireless_status(hdev, connected);
694 }
695
696 if (capacity != sd->battery_capacity) {
697 hid_dbg(sd->hdev,
698 "Battery capacity changed from %d%% to %d%%\n",
699 sd->battery_capacity, capacity);
700 sd->battery_capacity = capacity;
701 power_supply_changed(sd->battery);
702 }
703
704 if (charging != sd->battery_charging) {
705 hid_dbg(sd->hdev,
706 "Battery charging status changed from %scharging to %scharging\n",
707 sd->battery_charging ? "" : "not ",
708 charging ? "" : "not ");
709 sd->battery_charging = charging;
710 power_supply_changed(sd->battery);
711 }
712
713request_battery:
714 spin_lock_irqsave(&sd->lock, flags);
715 if (!sd->removed)
716 schedule_delayed_work(&sd->battery_work,
717 msecs_to_jiffies(STEELSERIES_HEADSET_BATTERY_TIMEOUT_MS));
718 spin_unlock_irqrestore(&sd->lock, flags);
719
720 return 0;
721}
722
723static const struct hid_device_id steelseries_devices[] = {
724 { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1),
725 .driver_data = STEELSERIES_SRWS1 },
726
727 { /* SteelSeries Arctis 1 Wireless for XBox */
728 HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_1),
729 .driver_data = STEELSERIES_ARCTIS_1 },
730
731 { /* SteelSeries Arctis 9 Wireless for XBox */
732 HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_9),
733 .driver_data = STEELSERIES_ARCTIS_9 },
734
735 { }
736};
737MODULE_DEVICE_TABLE(hid, steelseries_devices);
738
739static struct hid_driver steelseries_driver = {
740 .name = "steelseries",
741 .id_table = steelseries_devices,
742 .probe = steelseries_probe,
743 .remove = steelseries_remove,
744 .report_fixup = steelseries_srws1_report_fixup,
745 .raw_event = steelseries_headset_raw_event,
746};
747
748module_hid_driver(steelseries_driver);
749MODULE_DESCRIPTION("HID driver for Steelseries devices");
750MODULE_LICENSE("GPL");
751MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
752MODULE_AUTHOR("Simon Wood <simon@mungewell.org>");
753MODULE_AUTHOR("Christian Mayer <git@mayer-bgk.de>");