HID: steelseries: split out Arctis driver and add Nova 7 Gen2 support
v5 cover HID: steelseries: split out Arctis driver and add Nova 7 Gen2 support
This series moves the SteelSeries Arctis headset support out of hid-steelseries.c into its own module, reworks it around a per-model device_info table, hardens the battery power-supply lifetime, adds an asynchronous status interface, and finally adds support for the Arctis Nova 7 Gen2 family. After the split, hid-steelseries.c is left handling only the SRW-S1 racing wheel.
Changes since v4:
- Refactor: send the Arctis 1 and Arctis 9 status requests as output reports again. v4 regressed these to feature reports during the refactor, which can stall the endpoint and break battery polling. The now-unused feature-report helper is removed.
- Refactor: the Arctis 1 parser validates the report length and the 0x06 0x12 header before consuming a report as battery status, instead of parsing every incoming report.
- Refactor: the Arctis 9 parser only reads capacity/charging from a 0xaa 0x01 status frame and treats every other frame (including the 0x55 "no status" and the 0x03 "stale" replies) as disconnected.
- Refcounting: register the power supply into a local variable and publish sd->battery only on success, so a concurrent raw_event can never observe an error pointer.
- Async: publish the sync interface's drvdata only once the device is fully initialised, so the async sibling never attaches to a half-initialised or failed instance; the probe error path is simplified accordingly.
- Async: the sibling lookup verifies the sibling is bound to this driver and takes a reference before using its data, guarding against type confusion and use-after-free.
- Dropped the standalone "Fix whitespace in srws1 report descriptor" patch from v4; it was unrelated churn and the descriptor is left untouched from upstream.
- Rebased on the 7.2 merge window.
Sriman Achanta (9):
HID: steelseries: Fix ARCTIS_1_X device mislabeling
HID: steelseries: Split Arctis headset driver into separate module
HID: steelseries: Inline and simplify SRWS1 wheel driver
HID: steelseries: Refactor Arctis driver to use device_info framework
HID: steelseries: Report POWER_SUPPLY_STATUS_FULL when full
HID: steelseries: Correct Arctis 9 battery calibration range
HID: steelseries: Manage battery lifetime with refcounting
HID: steelseries: Add async status interface support
HID: steelseries: Add support for Arctis Nova 7 Gen2 family
drivers/hid/Makefile | 2 +- drivers/hid/hid-ids.h | 12 +- drivers/hid/hid-quirks.c | 10 +- drivers/hid/hid-steelseries-arctis.c | 643 +++++++++++++++++++++++++++ drivers/hid/hid-steelseries.c | 406 +---------------- 5 files changed, 672 insertions(+), 401 deletions(-) create mode 100644 drivers/hid/hid-steelseries-arctis.c
base-commit: 840ef6c78e6a2f694b578ecb9063241c992aaa9e
Signature · 1 line
2.54.0
PATCH v5 1/9 HID: steelseries: Fix ARCTIS_1_X device mislabeling
The SteelSeries Arctis 1 Wireless for Xbox (0x12b6) was labelled as the plain Arctis 1 Wireless. Rename USB_DEVICE_ID_STEELSERIES_ARCTIS_1 to USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X, along with the matching quirk flag and device table entry. The device ID value is unchanged.
--- drivers/hid/hid-ids.h | 4 ++-- drivers/hid/hid-quirks.c | 2 +- drivers/hid/hid-steelseries.c | 10 +++++----- 3 files changed, 8 insertions(+), 8 deletions(-)
drivers/hid/hid-ids.h +2 -2
@@ -1377,8 +1377,8 @@#define USB_VENDOR_ID_STEELSERIES 0x1038#define USB_DEVICE_ID_STEELSERIES_SRWS1 0x1410 -#define USB_DEVICE_ID_STEELSERIES_ARCTIS_1 0x12b6 -#define USB_DEVICE_ID_STEELSERIES_ARCTIS_9 0x12c2 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X 0x12b6 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_9 0x12c2#define USB_VENDOR_ID_SUN 0x0430#define USB_DEVICE_ID_RARITAN_KVM_DONGLE 0xcdab
drivers/hid/hid-quirks.c +1 -1
@@ -747,7 +747,7 @@ static const struct hid_device_id hid_have_special_driver[] = {#endif #if IS_ENABLED(CONFIG_HID_STEELSERIES) { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) }, - { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_1) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_9) }, #endif #if IS_ENABLED(CONFIG_HID_SUNPLUS)
drivers/hid/hid-steelseries.c +5 -5
@@ -18,7 +18,7 @@#include "hid-ids.h" #define STEELSERIES_SRWS1 BIT(0) -#define STEELSERIES_ARCTIS_1 BIT(1) +#define STEELSERIES_ARCTIS_1_X BIT(1)#define STEELSERIES_ARCTIS_9 BIT(2)struct steelseries_device {
@@ -374,7 +374,7 @@ static void steelseries_headset_fetch_battery(struct hid_device *hdev) {int ret =0 ; -if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_1 ) +if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X ) ret =steelseries_headset_request_battery (hdev, arctis_1_battery_request,sizeof (arctis_1_battery_request));else if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_9 )
@@ -638,7 +638,7 @@ static int steelseries_headset_raw_event(struct hid_device *hdev,if (hdev->product ==USB_DEVICE_ID_STEELSERIES_SRWS1 )return 0 ; -if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_1 ) { +if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X ) {hid_dbg (sd->hdev,"Parsing raw event for Arctis 1 headset (%*ph)\n" , size, read_buf); if (size < ARCTIS_1_BATTERY_RESPONSE_LEN ||
@@ -725,8 +725,8 @@ static const struct hid_device_id steelseries_devices[] = { .driver_data = STEELSERIES_SRWS1 }, {/* SteelSeries Arctis 1 Wireless for XBox */ - HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_1), - .driver_data = STEELSERIES_ARCTIS_1 }, + HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X), + .driver_data = STEELSERIES_ARCTIS_1_X }, { /* SteelSeries Arctis 9 Wireless for XBox */ HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_9),
Signature · 1 line
2.54.0
PATCH v5 2/9 HID: steelseries: Split Arctis headset driver into separate module
In reply to Sriman AchantaMove all Arctis headset code (battery monitoring, wireless status, power supply registration, raw event handling) from hid-steelseries.c into the new hid-steelseries-arctis.c driver module.
hid-steelseries.c now handles only the SRWS1 racing wheel, while hid-steelseries-arctis.c handles the Arctis 1 (Xbox) and Arctis 9 wireless headsets with their own device table, probe, remove, and raw_event implementations.
--- drivers/hid/Makefile | 2 +- drivers/hid/hid-steelseries-arctis.c | 404 +++++++++++++++++++++++++++ drivers/hid/hid-steelseries.c | 382 +------------------------ 3 files changed, 408 insertions(+), 380 deletions(-) create mode 100644 drivers/hid/hid-steelseries-arctis.c
drivers/hid/Makefile +1 -1
@@ -134,7 +134,7 @@ obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o obj-$(CONFIG_HID_SONY) += hid-sony.o obj-$(CONFIG_HID_SPEEDLINK) += hid-speedlink.o obj-$(CONFIG_HID_STEAM) += hid-steam.o -obj-$(CONFIG_HID_STEELSERIES) += hid-steelseries.o +obj-$(CONFIG_HID_STEELSERIES) += hid-steelseries.o hid-steelseries-arctis.o obj-$(CONFIG_HID_SUNPLUS) += hid-sunplus.o obj-$(CONFIG_HID_GREENASIA) += hid-gaff.o obj-$(CONFIG_HID_THRUSTMASTER) += hid-tmff.o hid-thrustmaster.o
drivers/hid/hid-steelseries-arctis.c new file +404 -0
404 lines not on this page · raw message
drivers/hid/hid-steelseries.c +3 -379
437 lines not on this page · raw message
Signature · 1 line
2.54.0
PATCH v5 3/9 HID: steelseries: Inline and simplify SRWS1 wheel driver
In reply to Sriman AchantaArctis headsets have their own driver now, so hid-steelseries.c only handles the SRWS1 racing wheel. Remove the dispatch layer:
- Inline steelseries_srws1_probe() as steelseries_probe()
- Add a steelseries_remove() that calls hid_hw_stop()
- Drop the STEELSERIES_SRWS1 quirk bit, no longer needed
- Remove the vendor/product check in steelseries_srws1_report_fixup(), since this driver only binds the SRWS1
--- drivers/hid/hid-steelseries.c | 30 +++++++++--------------------- 1 file changed, 9 insertions(+), 21 deletions(-)
drivers/hid/hid-steelseries.c +9 -21
@@ -15,8 +15,6 @@#include "hid-ids.h" -#define STEELSERIES_SRWS1 BIT(0) -#if IS_BUILTIN (CONFIG_LEDS_CLASS ) || \ (IS_MODULE (CONFIG_LEDS_CLASS ) &&IS_MODULE (CONFIG_HID_STEELSERIES ))#define SRWS1_NUMBER_LEDS 15
@@ -225,7 +223,7 @@ static enum led_brightness steelseries_srws1_led_get_brightness(struct led_classreturn value ?LED_FULL :LED_OFF ; } -static int steelseries_srws1_probe (struct hid_device *hdev, +static int steelseries_probe (struct hid_device *hdev,const struct hid_device_id *id) {int ret, i;
@@ -319,33 +317,24 @@ static int steelseries_srws1_probe(struct hid_device *hdev, err: return ret; } -#endif -static int steelseries_probe (struct hid_device *hdev,const struct hid_device_id *id) +static void steelseries_remove (struct hid_device *hdev) { -#if IS_BUILTIN (CONFIG_LEDS_CLASS ) || \ - (IS_MODULE (CONFIG_LEDS_CLASS ) &&IS_MODULE (CONFIG_HID_STEELSERIES )) -return steelseries_srws1_probe (hdev, id); +hid_hw_stop (hdev); +}#else +static int steelseries_probe (struct hid_device *hdev, +const struct hid_device_id *id) +{return -ENODEV ; -#endif } -static void steelseries_remove (struct hid_device *hdev) -{ -#if IS_BUILTIN (CONFIG_LEDS_CLASS ) || \ - (IS_MODULE (CONFIG_LEDS_CLASS ) &&IS_MODULE (CONFIG_HID_STEELSERIES )) -hid_hw_stop (hdev); +static void steelseries_remove (struct hid_device *hdev) {}#endif -}static const __u8 *steelseries_srws1_report_fixup (struct hid_device *hdev,__u8 *rdesc,unsigned int *rsize) { -if (hdev->vendor !=USB_VENDOR_ID_STEELSERIES || - hdev->product !=USB_DEVICE_ID_STEELSERIES_SRWS1 ) -return rdesc; -if (*rsize >=115 && rdesc[11 ] ==0x02 && rdesc[13 ] ==0xc8 && rdesc[29 ] ==0xbb && rdesc[40 ] ==0xc5 ) {hid_info (hdev,"Fixing up Steelseries SRW-S1 report descriptor\n" );
@@ -356,8 +345,7 @@ static const __u8 *steelseries_srws1_report_fixup(struct hid_device *hdev, }static const struct hid_device_id steelseries_devices[] = { - {HID_USB_DEVICE (USB_VENDOR_ID_STEELSERIES ,USB_DEVICE_ID_STEELSERIES_SRWS1 ), - .driver_data =STEELSERIES_SRWS1 }, + {HID_USB_DEVICE (USB_VENDOR_ID_STEELSERIES ,USB_DEVICE_ID_STEELSERIES_SRWS1 ) }, { } };
Signature · 1 line
2.54.0
PATCH v5 4/9 HID: steelseries: Refactor Arctis driver to use device_info framework
In reply to Sriman AchantaReplace the per-product if/else quirk bitmap with a steelseries_device_info struct. Each model provides its capabilities, sync_interface, and request_status/parse_status callbacks. Report sending is folded into steelseries_send_report() and the feature and output wrappers, and the battery identifiers lose their per-model names.
This is mostly a refactor, but it changes two things:
- Battery status is polled from a periodic delayed work (status_work) instead of being requested from raw_event(). The interval stays at 3s.
- Arctis 1 no longer clamps the reported capacity to 100% while disconnected. The connection state already controls how this is shown to userspace.
ARCTIS_1_X and ARCTIS_9 keep working. No new devices are added.
--- drivers/hid/hid-steelseries-arctis.c | 468 +++++++++++++++------------ 1 file changed, 267 insertions(+), 201 deletions(-)
drivers/hid/hid-steelseries-arctis.c +267 -201
@@ -3,6 +3,7 @@* HID driver for Steelseries arctis headsets * * Copyright (c) 2023 Bastien Nocera +* Copyright (c) 2026 Sriman Achanta */ #include <linux/device.h>
@@ -15,70 +16,89 @@#include "hid-ids.h" -#define STEELSERIES_ARCTIS_1_X BIT(0) -#define STEELSERIES_ARCTIS_9 BIT(1) +#define SS_CAP_BATTERY BIT(0) + +struct steelseries_device ; + +struct steelseries_device_info { +unsigned long capabilities; + +u8 sync_interface; + +int (*request_status)(struct hid_device *hdev); +void (*parse_status)(struct steelseries_device *sd,u8 *data,int size); +};struct steelseries_device {struct hid_device *hdev; -unsigned long quirks; +const struct steelseries_device_info *info; -struct delayed_work battery_work; -spinlock_t lock; -bool removed; +struct delayed_work status_work;struct power_supply_desc battery_desc;struct power_supply *battery; -uint8_t battery_capacity;bool headset_connected; +u8 battery_capacity;bool battery_charging; -}; -#define STEELSERIES_HEADSET_BATTERY_TIMEOUT_MS 3000 +spinlock_t lock; +bool removed; +}; -#define ARCTIS_1_BATTERY_RESPONSE_LEN 8 -#define ARCTIS_9_BATTERY_RESPONSE_LEN 64 -static const char arctis_1_battery_request[] = {0x06 ,0x12 }; -static const char arctis_9_battery_request[] = {0x00 ,0x20 }; +/* +* Headset report helpers +*/ -static int steelseries_headset_request_battery (struct hid_device *hdev, -const char *request,size_t len) +static int steelseries_send_report (struct hid_device *hdev,const u8 *data, +int len,enum hid_report_type type) { -u8 *write_buf; +u8 *buf;int ret; -/* Request battery information */ - write_buf =kmemdup (request, len,GFP_KERNEL ); -if (!write_buf) + buf =kmemdup (data, len,GFP_KERNEL ); +if (!buf)return -ENOMEM ; -hid_dbg (hdev,"Sending battery request report" ); - ret =hid_hw_raw_request (hdev, request[0 ], write_buf, len, -HID_OUTPUT_REPORT ,HID_REQ_SET_REPORT ); -if (ret < (int )len) { -hid_err (hdev,"hid_hw_raw_request() failed with %d\n" , ret); - ret = -ENODATA ; - } + ret =hid_hw_raw_request (hdev, data[0 ], buf, len, type, +HID_REQ_SET_REPORT ); +kfree (buf); -kfree (write_buf); -return ret; +if (ret <0 ) +return ret; +if (ret < len) +return -EIO ; + +return 0 ; } -static void steelseries_headset_fetch_battery (struct hid_device *hdev) +static inline int steelseries_send_output_report (struct hid_device *hdev, +const u8 *data,int len) { -int ret =0 ; +return steelseries_send_report (hdev, data, len,HID_OUTPUT_REPORT ); +} + +/* +* Headset status request functions +*/ -if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X ) - ret =steelseries_headset_request_battery (hdev, - arctis_1_battery_request,sizeof (arctis_1_battery_request)); -else if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_9 ) - ret =steelseries_headset_request_battery (hdev, - arctis_9_battery_request,sizeof (arctis_9_battery_request)); +static int steelseries_arctis_1_request_status (struct hid_device *hdev) +{ +const u8 data[] = {0x06 ,0x12 }; -if (ret <0 ) -hid_dbg (hdev, -"Battery query failed (err: %d)\n" , ret); +return steelseries_send_output_report (hdev, data,sizeof (data)); } +static int steelseries_arctis_9_request_status (struct hid_device *hdev) +{ +const u8 data[] = {0x00 ,0x20 }; + +return steelseries_send_output_report (hdev, data,sizeof (data)); +} + +/* +* Headset battery helpers +*/ +static int battery_capacity_to_level (int capacity) {if (capacity >=50 )
@@ -88,30 +108,101 @@ static int battery_capacity_to_level(int capacity)return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL ; } -static void steelseries_headset_battery_timer_tick (struct work_struct *work) +static u8 steelseries_map_capacity (u8 capacity,u8 min_in,u8 max_in) { -struct steelseries_device *sd =container_of (work, - struct steelseries_device, battery_work.work); -struct hid_device *hdev = sd->hdev; +if (capacity >= max_in) +return 100 ; +if (capacity <= min_in) +return 0 ; +return (capacity - min_in) *100 / (max_in - min_in); +} -steelseries_headset_fetch_battery (hdev); +/* +* Headset status parse functions +*/ + +static void steelseries_arctis_1_parse_status (struct steelseries_device *sd, +u8 *data,int size) +{ +/* Only the battery status report echoes the request header. */ +if (size <8 || data[0 ] !=0x06 || data[1 ] !=0x12 ) +return ; + + sd->headset_connected = (data[2 ] !=0x01 ); + sd->battery_capacity = data[3 ]; +} + +static void steelseries_arctis_9_parse_status (struct steelseries_device *sd, +u8 *data,int size) +{ +if (size <5 ) +return ; + +if (data[0 ] ==0xaa && data[1 ] ==0x01 ) { + sd->headset_connected = true; + sd->battery_charging = (data[4 ] ==0x01 ); + sd->battery_capacity =steelseries_map_capacity (data[3 ],0x68 ,0x9d ); + }else { +/* Device off: 0x55 (no status) or 0x03 (stale status). */ + sd->headset_connected = false; + sd->battery_charging = false; + } +} + +/* +* Device info definitions +*/ + +static const struct steelseries_device_info arctis_1_info = { + .sync_interface =3 , + .capabilities =SS_CAP_BATTERY , + .request_status = steelseries_arctis_1_request_status, + .parse_status = steelseries_arctis_1_parse_status, +}; + +static const struct steelseries_device_info arctis_9_info = { + .sync_interface =0 , + .capabilities =SS_CAP_BATTERY , + .request_status = steelseries_arctis_9_request_status, + .parse_status = steelseries_arctis_9_parse_status, +}; + +/* +* Headset wireless status and battery infrastructure +*/ + +#define STEELSERIES_HEADSET_STATUS_TIMEOUT_MS 3000 + +static void +steelseries_headset_set_wireless_status (struct hid_device *hdev, +bool connected) +{ +struct usb_interface *intf; + +if (!hid_is_usb (hdev)) +return ; + + intf =to_usb_interface (hdev->dev.parent); +usb_set_wireless_status (intf, connected ? +USB_WIRELESS_STATUS_CONNECTED : +USB_WIRELESS_STATUS_DISCONNECTED ); }#define STEELSERIES_PREFIX "SteelSeries " -#define STEELSERIES_PREFIX_LEN strlen(STEELSERIES_PREFIX) -static int steelseries_headset_battery_get_property (struct power_supply *psy, +static int steelseries_battery_get_property (struct power_supply *psy,enum power_supply_property psp,union power_supply_propval *val) {struct steelseries_device *sd =power_supply_get_drvdata (psy); +size_t prefix_len;int ret =0 ;switch (psp) {case POWER_SUPPLY_PROP_MODEL_NAME : val->strval = sd->hdev->name; -while (!strncmp (val->strval,STEELSERIES_PREFIX ,STEELSERIES_PREFIX_LEN )) - val->strval +=STEELSERIES_PREFIX_LEN ; +while ((prefix_len =str_has_prefix (val->strval,STEELSERIES_PREFIX ))) + val->strval += prefix_len;break ;case POWER_SUPPLY_PROP_MANUFACTURER : val->strval ="SteelSeries" ;
@@ -120,12 +211,12 @@ static int steelseries_headset_battery_get_property(struct power_supply *psy, val->intval =1 ;break ;case POWER_SUPPLY_PROP_STATUS : -if (sd->headset_connected) { - val->intval = sd->battery_charging ? -POWER_SUPPLY_STATUS_CHARGING : -POWER_SUPPLY_STATUS_DISCHARGING ; - }else +if (!sd->headset_connected) val->intval =POWER_SUPPLY_STATUS_UNKNOWN ; +else if (sd->battery_charging) + val->intval =POWER_SUPPLY_STATUS_CHARGING ; +else + val->intval =POWER_SUPPLY_STATUS_DISCHARGING ;break ;case POWER_SUPPLY_PROP_SCOPE : val->intval =POWER_SUPPLY_SCOPE_DEVICE ;
@@ -143,22 +234,7 @@ static int steelseries_headset_battery_get_property(struct power_supply *psy,return ret; } -static void -steelseries_headset_set_wireless_status (struct hid_device *hdev, -bool connected) -{ -struct usb_interface *intf; - -if (!hid_is_usb (hdev)) -return ; - - intf =to_usb_interface (hdev->dev.parent); -usb_set_wireless_status (intf, connected ? -USB_WIRELESS_STATUS_CONNECTED : -USB_WIRELESS_STATUS_DISCONNECTED ); -} - -static enum power_supply_property steelseries_headset_battery_props[] = { +static enum power_supply_property steelseries_battery_props[] = {POWER_SUPPLY_PROP_MODEL_NAME ,POWER_SUPPLY_PROP_MANUFACTURER ,POWER_SUPPLY_PROP_PRESENT ,
@@ -168,7 +244,26 @@ static enum power_supply_property steelseries_headset_battery_props[] = { POWER_SUPPLY_PROP_CAPACITY_LEVEL, }; -static int steelseries_headset_battery_register (struct steelseries_device *sd) +/* +* Delayed work handlers for status polling +*/ + +static void steelseries_status_timer_work_handler (struct work_struct *work) +{ +struct steelseries_device *sd =container_of ( + work, struct steelseries_device, status_work.work); +unsigned long flags; + + sd->info->request_status (sd->hdev); + +spin_lock_irqsave (&sd->lock, flags); +if (!sd->removed) +schedule_delayed_work (&sd->status_work, +msecs_to_jiffies (STEELSERIES_HEADSET_STATUS_TIMEOUT_MS )); +spin_unlock_irqrestore (&sd->lock, flags); +} + +static int steelseries_battery_register (struct steelseries_device *sd) {static atomic_t battery_no =ATOMIC_INIT (0 );struct power_supply_config battery_cfg = { .drv_data = sd, };
@@ -176,25 +271,27 @@ static int steelseries_headset_battery_register(struct steelseries_device *sd)int ret; sd->battery_desc.type =POWER_SUPPLY_TYPE_BATTERY ; - sd->battery_desc.properties = steelseries_headset_battery_props; - sd->battery_desc.num_properties =ARRAY_SIZE (steelseries_headset_battery_props); - sd->battery_desc.get_property = steelseries_headset_battery_get_property; + sd->battery_desc.properties = steelseries_battery_props; + sd->battery_desc.num_properties =ARRAY_SIZE (steelseries_battery_props); + sd->battery_desc.get_property = steelseries_battery_get_property; sd->battery_desc.use_for_apm =0 ; n =atomic_inc_return (&battery_no) -1 ; sd->battery_desc.name =devm_kasprintf (&sd->hdev->dev,GFP_KERNEL , -"steelseries_headset_battery_%ld" , n); +"steelseries_headset_battery_%ld" , n);if (!sd->battery_desc.name)return -ENOMEM ;/* avoid the warning of 0% battery while waiting for the first info */ -steelseries_headset_set_wireless_status (sd->hdev, false); sd->battery_capacity =100 ; sd->battery_charging = false; + sd->headset_connected = false; +steelseries_headset_set_wireless_status (sd->hdev, false); sd->battery =devm_power_supply_register (&sd->hdev->dev, &sd->battery_desc, &battery_cfg);if (IS_ERR (sd->battery)) { ret =PTR_ERR (sd->battery); + sd->battery =NULL ;hid_err (sd->hdev,"%s:power_supply_register failed with error %d\n" , __func__, ret);
@@ -202,59 +299,65 @@ static int steelseries_headset_battery_register(struct steelseries_device *sd) }power_supply_powers (sd->battery, &sd->hdev->dev); -INIT_DELAYED_WORK (&sd->battery_work, steelseries_headset_battery_timer_tick); -steelseries_headset_fetch_battery (sd->hdev); - -if (sd->quirks &STEELSERIES_ARCTIS_9 ) { -/* The first fetch_battery request can remain unanswered in some cases */ -schedule_delayed_work (&sd->battery_work, -msecs_to_jiffies (STEELSERIES_HEADSET_BATTERY_TIMEOUT_MS )); - } -return 0 ; } -static bool steelseries_is_vendor_usage_page (struct hid_device *hdev,uint8_t usage_page) -{ -return hdev->rdesc[0 ] ==0x06 && - hdev->rdesc[1 ] == usage_page && - hdev->rdesc[2 ] ==0xff ; -} - -static int steelseries_arctis_probe (struct hid_device *hdev,const struct hid_device_id *id) +static int steelseries_arctis_probe (struct hid_device *hdev, +const struct hid_device_id *id) { +const struct steelseries_device_info *info = + (const struct steelseries_device_info *)id->driver_data;struct steelseries_device *sd; +struct usb_interface *intf; +u8 interface_num;int ret; - sd =devm_kzalloc (&hdev->dev,sizeof (*sd),GFP_KERNEL ); -if (!sd) -return -ENOMEM ; -hid_set_drvdata (hdev, sd); - sd->hdev = hdev; - sd->quirks = id->driver_data; +if (hid_is_usb (hdev)) { + intf =to_usb_interface (hdev->dev.parent); + interface_num = intf->cur_altsetting->desc.bInterfaceNumber; + }else { +return -ENODEV ; + } ret =hid_parse (hdev);if (ret)return ret; -if (sd->quirks &STEELSERIES_ARCTIS_9 && - !steelseries_is_vendor_usage_page (hdev,0xc0 )) -return -ENODEV ; +/* Let hid-generic handle non-sync interfaces */ +if (interface_num != info->sync_interface) +return hid_hw_start (hdev,HID_CONNECT_DEFAULT ); + + sd =devm_kzalloc (&hdev->dev,sizeof (*sd),GFP_KERNEL ); +if (!sd) +return -ENOMEM ; + sd->hdev = hdev; + sd->info = info;spin_lock_init (&sd->lock); +hid_set_drvdata (hdev, sd); + ret =hid_hw_start (hdev,HID_CONNECT_DEFAULT );if (ret)return ret; ret =hid_hw_open (hdev);if (ret) -return ret; + goto err_stop; -if (steelseries_headset_battery_register (sd) <0 ) -hid_err (sd->hdev, -"Failed to register battery for headset\n" ); +if (info->capabilities &SS_CAP_BATTERY ) { + ret =steelseries_battery_register (sd); +if (ret <0 ) +hid_warn (hdev,"Failed to register battery: %d\n" , ret); + } + +INIT_DELAYED_WORK (&sd->status_work, steelseries_status_timer_work_handler); +schedule_delayed_work (&sd->status_work,msecs_to_jiffies (100 )); +return 0 ; + +err_stop: +hid_hw_stop (hdev);return ret; }
@@ -262,130 +365,92 @@ static void steelseries_arctis_remove(struct hid_device *hdev) {struct steelseries_device *sd;unsigned long flags; +struct usb_interface *intf; +u8 interface_num; + +if (hid_is_usb (hdev)) { + intf =to_usb_interface (hdev->dev.parent); + interface_num = intf->cur_altsetting->desc.bInterfaceNumber; + }else { +return ; + } sd =hid_get_drvdata (hdev); -spin_lock_irqsave (&sd->lock, flags); - sd->removed = true; -spin_unlock_irqrestore (&sd->lock, flags); +if (!sd) { +hid_hw_stop (hdev); +return ; + } -cancel_delayed_work_sync (&sd->battery_work); +if (interface_num == sd->info->sync_interface) { +spin_lock_irqsave (&sd->lock, flags); + sd->removed = true; +spin_unlock_irqrestore (&sd->lock, flags); + +cancel_delayed_work_sync (&sd->status_work); + }hid_hw_close (hdev);hid_hw_stop (hdev); } -static uint8_t steelseries_headset_map_capacity (uint8_t capacity,uint8_t min_in,uint8_t max_in) -{ -if (capacity >= max_in) -return 100 ; -if (capacity <= min_in) -return 0 ; -return (capacity - min_in) *100 / (max_in - min_in); -} -static int steelseries_arctis_raw_event (struct hid_device *hdev, -struct hid_report *report,u8 *read_buf, -int size) +struct hid_report *report,u8 *data,int size) {struct steelseries_device *sd =hid_get_drvdata (hdev); -int capacity = sd->battery_capacity; -bool connected = sd->headset_connected; -bool charging = sd->battery_charging; -unsigned long flags; +u8 old_capacity; +bool old_connected; +bool old_charging; -if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X ) { -hid_dbg (sd->hdev, -"Parsing raw event for Arctis 1 headset (%*ph)\n" , size, read_buf); -if (size <ARCTIS_1_BATTERY_RESPONSE_LEN || -memcmp (read_buf, arctis_1_battery_request,sizeof (arctis_1_battery_request))) { -if (!delayed_work_pending (&sd->battery_work)) - goto request_battery; -return 0 ; - } -if (read_buf[2 ] ==0x01 ) { - connected = false; - capacity =100 ; - }else { - connected = true; - capacity = read_buf[3 ]; - } - } +if (!sd) +return 0 ; -if (hdev->product ==USB_DEVICE_ID_STEELSERIES_ARCTIS_9 ) { -hid_dbg (sd->hdev, -"Parsing raw event for Arctis 9 headset (%*ph)\n" , size, read_buf); -if (size <ARCTIS_9_BATTERY_RESPONSE_LEN ) { -if (!delayed_work_pending (&sd->battery_work)) - goto request_battery; -return 0 ; - } + old_capacity = sd->battery_capacity; + old_connected = sd->headset_connected; + old_charging = sd->battery_charging; -if (read_buf[0 ] ==0xaa && read_buf[1 ] ==0x01 ) { - connected = true; - charging = read_buf[4 ] ==0x01 ; - -/* -* Found no official documentation about min and max. -* Values defined by testing. -*/ - capacity =steelseries_headset_map_capacity (read_buf[3 ],0x68 ,0x9d ); - }else { -/* -* Device is off and sends the last known status read_buf[1] == 0x03 or -* there is no known status of the device read_buf[0] == 0x55 -*/ - connected = false; - charging = false; - } - } + sd->info->parse_status (sd, data, size); -if (connected != sd->headset_connected) { -hid_dbg (sd->hdev, +if (sd->headset_connected != old_connected) { +hid_dbg (hdev,"Connected status changed from %sconnected to %sconnected\n" , - sd->headset_connected ?"" :"not " , - connected ?"" :"not " ); - sd->headset_connected = connected; -steelseries_headset_set_wireless_status (hdev, connected); + old_connected ?"" :"not " , + sd->headset_connected ?"" :"not " ); + +if (sd->battery) { +steelseries_headset_set_wireless_status (sd->hdev, + sd->headset_connected); +power_supply_changed (sd->battery); + } } -if (capacity != sd->battery_capacity) { -hid_dbg (sd->hdev, -"Battery capacity changed from %d%% to %d%%\n" , - sd->battery_capacity, capacity); - sd->battery_capacity = capacity; -power_supply_changed (sd->battery); +if (sd->battery_capacity != old_capacity) { +hid_dbg (hdev,"Battery capacity changed from %d%% to %d%%\n" , + old_capacity, sd->battery_capacity); +if (sd->battery) +power_supply_changed (sd->battery); } -if (charging != sd->battery_charging) { -hid_dbg (sd->hdev, +if (sd->battery_charging != old_charging) { +hid_dbg (hdev,"Battery charging status changed from %scharging to %scharging\n" , - sd->battery_charging ?"" :"not " , - charging ?"" :"not " ); - sd->battery_charging = charging; -power_supply_changed (sd->battery); + old_charging ?"" :"not " , + sd->battery_charging ?"" :"not " ); +if (sd->battery) +power_supply_changed (sd->battery); } -request_battery: -spin_lock_irqsave (&sd->lock, flags); -if (!sd->removed) -schedule_delayed_work (&sd->battery_work, -msecs_to_jiffies (STEELSERIES_HEADSET_BATTERY_TIMEOUT_MS )); -spin_unlock_irqrestore (&sd->lock, flags); -return 0 ; }static const struct hid_device_id steelseries_arctis_devices[] = { - {/* SteelSeries Arctis 1 Wireless for XBox */ -HID_USB_DEVICE (USB_VENDOR_ID_STEELSERIES ,USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X ), - .driver_data =STEELSERIES_ARCTIS_1_X }, - - {/* SteelSeries Arctis 9 Wireless for XBox */ -HID_USB_DEVICE (USB_VENDOR_ID_STEELSERIES ,USB_DEVICE_ID_STEELSERIES_ARCTIS_9 ), - .driver_data =STEELSERIES_ARCTIS_9 }, - - { } + {HID_USB_DEVICE (USB_VENDOR_ID_STEELSERIES , +USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X ), + .driver_data = (unsigned long )&arctis_1_info }, + {HID_USB_DEVICE (USB_VENDOR_ID_STEELSERIES , +USB_DEVICE_ID_STEELSERIES_ARCTIS_9 ), + .driver_data = (unsigned long )&arctis_9_info }, + {} };MODULE_DEVICE_TABLE (hid, steelseries_arctis_devices);
@@ -402,3 +467,4 @@ MODULE_DESCRIPTION("HID driver for Steelseries arctis headsets");MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Christian Mayer <[email protected]>" );MODULE_AUTHOR ("Bastien Nocera <[email protected]>" ); +MODULE_AUTHOR ("Sriman Achanta <[email protected]>" );
Signature · 1 line
2.54.0
PATCH v5 5/9 HID: steelseries: Report POWER_SUPPLY_STATUS_FULL when full
In reply to Sriman AchantaReport POWER_SUPPLY_STATUS_FULL when the headset is connected, not charging, and at 100% capacity. It reported DISCHARGING in that case before.
--- drivers/hid/hid-steelseries-arctis.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/hid/hid-steelseries-arctis.c +2 -0
@@ -215,6 +215,8 @@ static int steelseries_battery_get_property(struct power_supply *psy, val->intval =POWER_SUPPLY_STATUS_UNKNOWN ; else if (sd->battery_charging) val->intval = POWER_SUPPLY_STATUS_CHARGING; + else if (sd->battery_capacity >= 100) + val->intval = POWER_SUPPLY_STATUS_FULL; else val->intval = POWER_SUPPLY_STATUS_DISCHARGING;break ;
Signature · 1 line
2.54.0
PATCH v5 7/9 HID: steelseries: Manage battery lifetime with refcounting
In reply to Sriman AchantaThe next change shares one steelseries_device between two HID interfaces, so the state can outlive either interface. Stop using devm for it. Reference count the struct with a kref and free it from steelseries_device_release(). Register and unregister the power supply explicitly, and clear sd->battery under sd->lock in remove() so it is not touched after it is unregistered.
Drop the global atomic battery counter and name the power supply after the device (hdev->uniq, or dev_name() when empty), as hid-input and the other HID battery drivers do.
No functional change for the current single-interface devices.
--- drivers/hid/hid-steelseries-arctis.c | 47 +++++++++++++++++++++------- 1 file changed, 36 insertions(+), 11 deletions(-)
drivers/hid/hid-steelseries-arctis.c +36 -11
@@ -8,6 +8,8 @@#include <linux/device.h> #include <linux/hid.h> +#include <linux/kref.h> +#include <linux/slab.h> #include <linux/module.h> #include <linux/power_supply.h> #include <linux/spinlock.h>
@@ -30,6 +32,8 @@ struct steelseries_device_info { };struct steelseries_device { +struct kref refcnt; +struct hid_device *hdev;const struct steelseries_device_info *info;
@@ -45,6 +49,14 @@ struct steelseries_device {bool removed; }; +static void steelseries_device_release (struct kref *ref) +{ +struct steelseries_device *sd = + container_of(ref, struct steelseries_device, refcnt); + +kfree (sd); +} +/* * Headset report helpers */
@@ -267,9 +279,8 @@ static void steelseries_status_timer_work_handler(struct work_struct *work)static int steelseries_battery_register (struct steelseries_device *sd) { -static atomic_t battery_no =ATOMIC_INIT (0 );struct power_supply_config battery_cfg = { .drv_data = sd, }; -unsigned long n; +struct power_supply *battery;int ret; sd->battery_desc.type =POWER_SUPPLY_TYPE_BATTERY ;
@@ -277,9 +288,10 @@ static int steelseries_battery_register(struct steelseries_device *sd) sd->battery_desc.num_properties =ARRAY_SIZE (steelseries_battery_props); sd->battery_desc.get_property = steelseries_battery_get_property; sd->battery_desc.use_for_apm =0 ; - n =atomic_inc_return (&battery_no) -1 ; sd->battery_desc.name =devm_kasprintf (&sd->hdev->dev,GFP_KERNEL , -"steelseries_headset_battery_%ld" , n); +"steelseries_headset_battery_%s" , + sd->hdev->uniq[0 ] ? sd->hdev->uniq : +dev_name (&sd->hdev->dev));if (!sd->battery_desc.name)return -ENOMEM ;
@@ -289,17 +301,19 @@ static int steelseries_battery_register(struct steelseries_device *sd) sd->headset_connected = false;steelseries_headset_set_wireless_status (sd->hdev, false); - sd->battery =devm_power_supply_register (&sd->hdev->dev, + battery =power_supply_register (&sd->hdev->dev, &sd->battery_desc, &battery_cfg); -if (IS_ERR (sd->battery)) { - ret =PTR_ERR (sd->battery); - sd->battery =NULL ; +if (IS_ERR (battery)) { + ret =PTR_ERR (battery);hid_err (sd->hdev,"%s:power_supply_register failed with error %d\n" , __func__, ret);return ret; } -power_supply_powers (sd->battery, &sd->hdev->dev); +power_supply_powers (battery, &sd->hdev->dev); + +/* Assign on success only, so a concurrent raw_event never sees an ERR_PTR. */ + sd->battery = battery;return 0 ; }
@@ -329,10 +343,11 @@ static int steelseries_arctis_probe(struct hid_device *hdev,if (interface_num != info->sync_interface)return hid_hw_start (hdev,HID_CONNECT_DEFAULT ); - sd =devm_kzalloc (&hdev->dev,sizeof (*sd),GFP_KERNEL ); + sd =kzalloc_obj (*sd,GFP_KERNEL );if (!sd)return -ENOMEM ; +kref_init (&sd->refcnt); sd->hdev = hdev; sd->info = info;spin_lock_init (&sd->lock);
@@ -341,7 +356,7 @@ static int steelseries_arctis_probe(struct hid_device *hdev, ret =hid_hw_start (hdev,HID_CONNECT_DEFAULT );if (ret) -return ret; + goto err_put; ret =hid_hw_open (hdev);if (ret)
@@ -360,12 +375,15 @@ static int steelseries_arctis_probe(struct hid_device *hdev, err_stop:hid_hw_stop (hdev); +err_put: +kref_put (&sd->refcnt, steelseries_device_release);return ret; }static void steelseries_arctis_remove (struct hid_device *hdev) {struct steelseries_device *sd; +struct power_supply *battery;unsigned long flags;struct usb_interface *intf;u8 interface_num;
@@ -387,13 +405,20 @@ static void steelseries_arctis_remove(struct hid_device *hdev)if (interface_num == sd->info->sync_interface) {spin_lock_irqsave (&sd->lock, flags); sd->removed = true; + battery = sd->battery; + sd->battery =NULL ;spin_unlock_irqrestore (&sd->lock, flags);cancel_delayed_work_sync (&sd->status_work); + +if (battery) +power_supply_unregister (battery); }hid_hw_close (hdev);hid_hw_stop (hdev); + +kref_put (&sd->refcnt, steelseries_device_release); } static int steelseries_arctis_raw_event(struct hid_device *hdev,
Signature · 1 line
2.54.0
PATCH v5 8/9 HID: steelseries: Add async status interface support
In reply to Sriman AchantaSome headsets expose a second HID interface that sends battery and connection updates on its own. Watching that interface lets the driver stop polling the sync interface. Add a steelseries_device_info::async_interface field and the code to handle it:
- The driver binds both the sync and async interfaces. The async interface shares the steelseries_device created by the sync interface. It finds the sibling with usb_ifnum_to_if(), takes a reference, and returns -EPROBE_DEFER until the sync interface has probed. If the sync interface never binds, the async interface defers forever, which is fine here.
- raw_event() now holds sd->lock and re-checks sd->removed so events on either interface are serialised against removal.
- status_work runs once for async devices instead of rearming. A single status request is sent when the headset connects to get the initial battery level.
No device sets async_interface yet. This is the infrastructure for the next commit.
--- drivers/hid/hid-steelseries-arctis.c | 137 +++++++++++++++++++++------ 1 file changed, 110 insertions(+), 27 deletions(-)
drivers/hid/hid-steelseries-arctis.c +110 -27
@@ -26,6 +26,7 @@ struct steelseries_device_info {unsigned long capabilities;u8 sync_interface; +u8 async_interface;int (*request_status)(struct hid_device *hdev);void (*parse_status)(struct steelseries_device *sd,u8 *data,int size);
@@ -271,7 +272,8 @@ static void steelseries_status_timer_work_handler(struct work_struct *work) sd->info->request_status (sd->hdev);spin_lock_irqsave (&sd->lock, flags); -if (!sd->removed) +/* Async devices push status events themselves; only poll once. */ +if (!sd->removed && !sd->info->async_interface)schedule_delayed_work (&sd->status_work,msecs_to_jiffies (STEELSERIES_HEADSET_STATUS_TIMEOUT_MS ));spin_unlock_irqrestore (&sd->lock, flags);
@@ -318,6 +320,32 @@ static int steelseries_battery_register(struct steelseries_device *sd)return 0 ; } +static struct hid_driver steelseries_arctis_driver; + +static struct steelseries_device * +steelseries_get_sibling_sd (struct hid_device *hdev,int interface_num) +{ +struct usb_interface *intf =to_usb_interface (hdev->dev.parent); +struct usb_device *usb_dev =interface_to_usbdev (intf); +struct usb_interface *sibling_intf; +struct hid_device *sibling_hdev; +struct steelseries_device *sd; + + sibling_intf =usb_ifnum_to_if (usb_dev, interface_num); +if (!sibling_intf) +return NULL ; + + sibling_hdev =usb_get_intfdata (sibling_intf); +if (!sibling_hdev || sibling_hdev->driver != &steelseries_arctis_driver) +return NULL ; + + sd =hid_get_drvdata (sibling_hdev); +if (sd) +kref_get (&sd->refcnt); + +return sd; +} +static int steelseries_arctis_probe (struct hid_device *hdev,const struct hid_device_id *id) {
@@ -339,43 +367,81 @@ static int steelseries_arctis_probe(struct hid_device *hdev,if (ret)return ret; -/* Let hid-generic handle non-sync interfaces */ -if (interface_num != info->sync_interface) +/* Let hid-generic handle non-vendor or unknown interfaces */ +if (interface_num != info->sync_interface && + (!info->async_interface || interface_num != info->async_interface))return hid_hw_start (hdev,HID_CONNECT_DEFAULT ); - sd =kzalloc_obj (*sd,GFP_KERNEL ); -if (!sd) -return -ENOMEM ; - -kref_init (&sd->refcnt); - sd->hdev = hdev; - sd->info = info; -spin_lock_init (&sd->lock); +if (interface_num == info->sync_interface) { + sd =kzalloc_obj (*sd,GFP_KERNEL ); +if (!sd) +return -ENOMEM ; + +kref_init (&sd->refcnt); + sd->hdev = hdev; + sd->info = info; +spin_lock_init (&sd->lock); +INIT_DELAYED_WORK (&sd->status_work, steelseries_status_timer_work_handler); + + ret =hid_hw_start (hdev,HID_CONNECT_DEFAULT ); +if (ret) + goto err_free; + + ret =hid_hw_open (hdev); +if (ret) + goto err_stop; + +if (info->capabilities &SS_CAP_BATTERY ) { + ret =steelseries_battery_register (sd); +if (ret <0 ) +hid_warn (hdev,"Failed to register battery: %d\n" , ret); + } -hid_set_drvdata (hdev, sd); +/* +* Publish drvdata only once fully initialised: the async sibling +* attaches by reading it, so it must never observe a half-built or +* failed instance. A failed probe never gets here, so the error +* path below has nothing to unpublish. +*/ +hid_set_drvdata (hdev, sd); +schedule_delayed_work (&sd->status_work,msecs_to_jiffies (100 )); - ret =hid_hw_start (hdev,HID_CONNECT_DEFAULT ); -if (ret) - goto err_put; +return 0 ; + } - ret =hid_hw_open (hdev); -if (ret) - goto err_stop; +/* +* The async interface shares the steelseries_device created by the +* sync interface. Defer until the sync interface has probed and +* published its drvdata. +*/ +if (info->async_interface && interface_num == info->async_interface) { + sd =steelseries_get_sibling_sd (hdev, info->sync_interface); +if (!sd) +return -EPROBE_DEFER ; + +hid_set_drvdata (hdev, sd); + + ret =hid_hw_start (hdev,HID_CONNECT_DEFAULT ); +if (ret) { +kref_put (&sd->refcnt, steelseries_device_release); +return ret; + } -if (info->capabilities &SS_CAP_BATTERY ) { - ret =steelseries_battery_register (sd); -if (ret <0 ) -hid_warn (hdev,"Failed to register battery: %d\n" , ret); + ret =hid_hw_open (hdev); +if (ret) { +hid_hw_stop (hdev); +kref_put (&sd->refcnt, steelseries_device_release); +return ret; + } +return 0 ; } -INIT_DELAYED_WORK (&sd->status_work, steelseries_status_timer_work_handler); -schedule_delayed_work (&sd->status_work,msecs_to_jiffies (100 )); - -return 0 ; +return -ENODEV ; err_stop:hid_hw_stop (hdev); -err_put: +err_free: +/* drvdata is unpublished until full success, so no sibling can hold sd. */ kref_put (&sd->refcnt, steelseries_device_release);return ret; }
@@ -428,10 +494,21 @@ static int steelseries_arctis_raw_event(struct hid_device *hdev,u8 old_capacity;bool old_connected;bool old_charging; +bool is_async_interface; +unsigned long flags;if (!sd)return 0 ; + is_async_interface = (hdev != sd->hdev); + +spin_lock_irqsave (&sd->lock, flags); + +if (sd->removed) { +spin_unlock_irqrestore (&sd->lock, flags); +return 0 ; + } + old_capacity = sd->battery_capacity; old_connected = sd->headset_connected; old_charging = sd->battery_charging;
@@ -444,6 +521,10 @@ static int steelseries_arctis_raw_event(struct hid_device *hdev, old_connected ?"" :"not " , sd->headset_connected ? "" : "not "); +if (sd->headset_connected && !old_connected && + sd->info->async_interface && is_async_interface) +schedule_delayed_work (&sd->status_work,0 ); +if (sd->battery) {steelseries_headset_set_wireless_status (sd->hdev, sd->headset_connected);
@@ -467,6 +548,8 @@ static int steelseries_arctis_raw_event(struct hid_device *hdev,power_supply_changed (sd->battery); } +spin_unlock_irqrestore (&sd->lock, flags); +return 0 ; }
Signature · 1 line
2.54.0
PATCH v5 9/9 HID: steelseries: Add support for Arctis Nova 7 Gen2 family
In reply to Sriman AchantaThe Arctis Nova 7 Gen2 headsets answer status polls, but they also send unsolicited battery and connection updates on a second HID interface (interface 5). Use that interface through async_interface so the driver does not have to poll. Add request and parse helpers for the Gen2 status format (0xb0/0xb7/0xb9/0xbb opcodes).
Add the eight USB product IDs that share this protocol:
0x22a1 Arctis Nova 7 2026 0x22a7 Arctis Nova 7P 2026 0x22a5 Arctis Nova 7X 2026 0x22a9 Arctis Nova 7 Diablo 2026 0x227e Arctis Nova 7 Gen 2 0x2258 Arctis Nova 7X Gen 2 0x229e Arctis Nova 7X Gen 2 (alternate PID) 0x22ad Arctis Nova 7X Gen 2 (alternate PID)
--- drivers/hid/hid-ids.h | 8 ++++ drivers/hid/hid-quirks.c | 8 ++++ drivers/hid/hid-steelseries-arctis.c | 63 ++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+)
drivers/hid/hid-ids.h +8 -0
@@ -1379,6 +1379,14 @@#define USB_DEVICE_ID_STEELSERIES_SRWS1 0x1410#define USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X 0x12b6#define USB_DEVICE_ID_STEELSERIES_ARCTIS_9 0x12c2 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_2026 0x22a1 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_P_2026 0x22a7 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_2026 0x22a5 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_DIABLO_2026 0x22a9 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_GEN2 0x227e +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_GEN2 0x2258 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_GEN2_2 0x229e +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_GEN2_3 0x22ad#define USB_VENDOR_ID_SUN 0x0430#define USB_DEVICE_ID_RARITAN_KVM_DONGLE 0xcdab
drivers/hid/hid-quirks.c +8 -0
@@ -749,6 +749,14 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_9) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_2026) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_P_2026) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_2026) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_DIABLO_2026) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_GEN2) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_GEN2) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_GEN2_2) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_GEN2_3) }, #endif #if IS_ENABLED(CONFIG_HID_SUNPLUS) { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
drivers/hid/hid-steelseries-arctis.c +63 -0
87 lines not on this page · raw message
Signature · 1 line
2.54.0
PATCH v5 6/9 HID: steelseries: Correct Arctis 9 battery calibration range
In reply to Sriman AchantaMap the Arctis 9 raw battery value over 0x64 (empty) to 0x9a (full) instead of 0x68 to 0x9d. These values match the HeadsetControl project
[1] and fit the calibration points from an independent reverse engineering of the battery tray (about 25% at raw 112, 50% at raw 125) [2].
I do not have this headset. The values come from those references and were not measured directly.
[1] https://github.com/Sapd/HeadsetControl/blob/master/lib/devices/steelseries_arctis_9.hpp
[2] https://magnier.io/reverse-engineering-arctis-9-battery-tray/
--- drivers/hid/hid-steelseries-arctis.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/hid/hid-steelseries-arctis.c +1 -1
@@ -141,7 +141,7 @@ static void steelseries_arctis_9_parse_status(struct steelseries_device *sd,if (data[0 ] ==0xaa && data[1 ] ==0x01 ) { sd->headset_connected = true; sd->battery_charging = (data[4 ] ==0x01 ); - sd->battery_capacity =steelseries_map_capacity (data[3 ],0x68 ,0x9d ); + sd->battery_capacity =steelseries_map_capacity (data[3 ],0x64 ,0x9a ); }else {/* Device off: 0x55 (no status) or 0x03 (stale status). */ sd->headset_connected = false;
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v5 8/9] HID: steelseries: Add async status interface support
In reply to Sriman AchantaThank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] Unsynchronized access to the sibling interface's HID device and driver data in…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] Unsynchronized access to the sibling interface's HID device and driver data in steelseries_get_sibling_sd() leads to Use-After-Free vulnerabilities during concurrent unbinding.
- [High] Unsafe retrieval of intfdata from a sibling USB interface without verifying the bound USB driver leads to type confusion.
--
commit 184e416637c40dbd71e035542907c5105f99d55d
Author: Sriman Achanta <[email protected]>
HID: steelseries: Add async status interface support
This patch adds support for an async status interface on some Steelseries headsets. The driver binds both sync and async interfaces, using the async interface to push status events and delay its probe until the sync interface is fully initialized.
Quoted 3 lines
drivers/hid/hid-steelseries-arctis.c +0
-0
[ ... ]
Quoted 5 lines
drivers/hid/hid-steelseries-arctis.c +5
-0+static struct steelseries_device * +steelseries_get_sibling_sd (struct hid_device *hdev,int interface_num) +{ +struct usb_interface *intf =to_usb_interface (hdev->dev.parent); +struct usb_device *usb_dev =interface_to_usbdev (intf);
drivers/hid/hid-steelseries-arctis.c static int steelseries_battery_register(struct steelseries_device *sd) · line 339
Quoted 10 lines
drivers/hid/hid-steelseries-arctis.c +10
-0+struct usb_interface *sibling_intf; +struct hid_device *sibling_hdev; +struct steelseries_device *sd; + + sibling_intf =usb_ifnum_to_if (usb_dev, interface_num); +if (!sibling_intf) +return NULL ; + + sibling_hdev =usb_get_intfdata (sibling_intf); +if (!sibling_hdev || sibling_hdev->driver != &steelseries_arctis_driver)
[Severity: High]
Can a malicious USB device trigger an out-of-bounds read here?
If the device advertises the sync interface as a non-HID class (like Mass Storage) but the async interface as HID, the USB core might bind a different driver to the sync interface. In that case, usb_get_intfdata() would return a driver-specific structure (like struct us_data) rather than a struct hid_device.
Would it be safer to verify the bound USB driver on the sibling interface before casting the intfdata and dereferencing sibling_hdev->driver?
drivers/hid/hid-steelseries-arctis.c static int steelseries_battery_register(struct steelseries_device *sd) · line 344
Quoted 5 lines
drivers/hid/hid-steelseries-arctis.c +5
-0+return NULL ; + + sd =hid_get_drvdata (sibling_hdev); +if (sd) +kref_get (&sd->refcnt);
[Severity: High]
Is there a race condition with concurrent unbinding here?
If the sync interface is concurrently unbound (e.g., via sysfs or physical disconnection) while the async interface is probing, usb_get_intfdata() and hid_get_drvdata() are called without holding device_lock() for the sibling interface's device.
Could this allow the hid_device to be freed before checking sibling_hdev->driver, or allow the steelseries_device (sd) to be freed before kref_get() is called?
Quoted 3 lines
drivers/hid/hid-steelseries-arctis.c +3
-0+ +return sd; +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
[email protected]
AI reviewRe: [PATCH v5 5/9] HID: steelseries: Report POWER_SUPPLY_STATUS_FULL when full
In reply to Sriman AchantaThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The patch incorrectly reports POWER_SUPPLY_STATUS_FULL for an unplugged, actively discharging…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The patch incorrectly reports POWER_SUPPLY_STATUS_FULL for an unplugged, actively discharging wireless headset solely because its capacity is 100%. --
commit 7a846a17b1f3241f94405b831860eba9d3123648
Author: Sriman Achanta <[email protected]>
HID: steelseries: Report POWER_SUPPLY_STATUS_FULL when full
This commit updates the battery status reporting for SteelSeries headsets. It now returns POWER_SUPPLY_STATUS_FULL when the headset is connected, not charging, and at 100% capacity instead of returning DISCHARGING.
drivers/hid/hid-steelseries-arctis.c static int steelseries_battery_get_property(struct power_supply *psy, · line 219
Quoted 9 lines
drivers/hid/hid-steelseries-arctis.c +2
-0@@ -215,6 +215,8 @@ static int steelseries_battery_get_property(struct power_supply *psy, val->intval =POWER_SUPPLY_STATUS_UNKNOWN ; else if (sd->battery_charging) val->intval = POWER_SUPPLY_STATUS_CHARGING; + else if (sd->battery_capacity >= 100) + val->intval = POWER_SUPPLY_STATUS_FULL;
[Severity: Medium]
Will this incorrectly report POWER_SUPPLY_STATUS_FULL for an unplugged, actively discharging wireless headset just because its capacity is at 100%?
When the headset is unplugged from external power but still fully charged, sd->battery_charging is false and sd->battery_capacity is 100. It appears this logic will now return POWER_SUPPLY_STATUS_FULL instead of POWER_SUPPLY_STATUS_DISCHARGING, because there is no explicit check to verify if the device is currently receiving external power.
Is there a way to ensure the headset is actually plugged in before returning FULL, so that userspace tools don't incorrectly hide the discharge state until the capacity drops below 100%?
Quoted 3 lines
drivers/hid/hid-steelseries-arctis.c +0
-0else val->intval =POWER_SUPPLY_STATUS_DISCHARGING ;break ;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
[email protected]
AI reviewRe: [PATCH v5 9/9] HID: steelseries: Add support for Arctis Nova 7 Gen2 family
In reply to Sriman AchantaThank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
New issues:
- [Medium] The global bounds check if (size < 4) incorrectly drops valid, shorter unsolicited status reports.
Pre-existing issues:
- [High] Concurrent sysfs unbind leads to Use-After-Free of sibling hid_device and steelseries_device.
- [High] Type confusion when retrieving the sibling HID device can lead to an out-of-bounds memory read. --
commit 70087cd16ba3bb84894fac86ae371e8ee1265c7a
Author: Sriman Achanta <[email protected]>
HID: steelseries: Add support for Arctis Nova 7 Gen2 family
This patch adds support for the Arctis Nova 7 Gen2 headsets. It introduces a new parser for unsolicited battery and connection updates on a second HID interface, and adds eight new USB product IDs to the supported devices list.
Quoted 4 lines
drivers/hid/hid-steelseries-arctis.c +0
-0
[ ... ]
drivers/hid/hid-steelseries-arctis.c static void steelseries_arctis_9_parse_status(struct steelseries_device *sd, · line 176
Quoted 9 lines
drivers/hid/hid-steelseries-arctis.c +5
-0@@ -162,6 +169,30 @@ static void steelseries_arctis_9_parse_status(struct steelseries_device *sd, } } +static void steelseries_arctis_nova_7_gen2_parse_status (struct steelseries_device *sd, +u8 *data,int size) +{ +if (size <4 ) +return ;
[Severity: Medium]
Could this global bounds check prematurely discard valid unsolicited battery and connection updates?
The new opcodes 0xb7, 0xb9, and 0xbb only require up to data[1] to be valid. If the headset firmware sends these unsolicited updates as 2-byte short USB HID packets reflecting their actual content size, this check will drop them.
[ ... ]
drivers/hid/hid-steelseries-arctis.c static const struct steelseries_device_info arctis_9_info = { · line 216
Quoted 7 lines
drivers/hid/hid-steelseries-arctis.c +3
-0@@ -180,6 +211,14 @@ static const struct steelseries_device_info arctis_9_info = { .parse_status = steelseries_arctis_9_parse_status, }; +static const struct steelseries_device_info arctis_nova_7_gen2_info = { + .sync_interface =3 , + .async_interface =5 ,
[Severity: High]
This is a pre-existing issue, but the addition of these new devices using the async/sync interface mechanism heavily exercises it. Is it possible for a concurrent sysfs unbind to cause a use-after-free?
During the async interface probe, steelseries_get_sibling_sd() calls usb_get_intfdata(sibling_intf) without holding the device lock for the sibling interface. If a user concurrently unbinds the sibling interface (e.g., via sysfs), usbhid destroys the hid_device. This causes the probe path to locklessly dereference the freed sibling_hdev->driver:
sibling_hdev = usb_get_intfdata(sibling_intf); if (!sibling_hdev || sibling_hdev->driver != &steelseries_arctis_driver) return NULL; sd = hid_get_drvdata(sibling_hdev); if (sd) kref_get(&sd->refcnt);
It then calls kref_get(&sd->refcnt) on the associated private data, modifying freed memory.
[Severity: High]
This isn't a bug introduced by this patch, but adding these devices expands the exposure to a pre-existing type confusion issue. Could this lead to an out-of-bounds memory read?
In steelseries_get_sibling_sd(), the driver extracts the private data via usb_get_intfdata() and assumes it is a struct hid_device *:
sibling_intf = usb_ifnum_to_if(usb_dev, interface_num); if (!sibling_intf) return NULL; sibling_hdev = usb_get_intfdata(sibling_intf); if (!sibling_hdev || sibling_hdev->driver != &steelseries_arctis_driver) return NULL;
If a crafted USB device is plugged in where the sibling interface (e.g., interface 0 or 3) is a non-HID class like USB Audio, a different driver will bind and store its own private structure in intfdata.
The driver field sits hundreds of bytes deep into struct hid_device. Reading it from a smaller structure belonging to another driver will read out-of-bounds of the allocated SLUB object.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
I can help test two other SteelSeries Arctis devices, the Nova 7 (0x2202) and Nova 7X (0x2206). I know support was dropped between v3 and v4.
Link:
https://lore.kernel.org/lkml/[email protected]/#t
Quoted 1 line · Sriman Achanta
Changes since v3:
...
Quoted 2 lines
- Limit new device support to the Arctis Nova 7 Gen2 family, the only hardware I can test.
I patched back in Nova 7X (0x2206) support locally (Archlinux 6.18.37-1- lts) and it reports battery status with no obvious issues. I only tested basic audio out and report of battery status via dongle. I'm not sure what a complete test matrix would look like. I did not test Nova 7 (0x2202).
Here is my patch on top of v5 in case it is relevant, but this is mostly from what was dropped in v3. Not meant to be a clean submission, happy to send a proper formatted patch if useful.
--- drivers/hid/hid-ids.h | 1 + drivers/hid/hid-quirks.c | 1 + drivers/hid/hid-steelseries-arctis.c | 21 +++++++++++++++++++++ 3 files changed, 23 insertions(+)
drivers/hid/hid-ids.h +1 -0
@@ -1320,6 +1320,7 @@#define USB_DEVICE_ID_STEELSERIES_SRWS1 0x1410#define USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X 0x12b6#define USB_DEVICE_ID_STEELSERIES_ARCTIS_9 0x12c2 +#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X 0x2206#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_2026 0x22a1#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_P_2026 0x22a7#define USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_2026 0x22a5
drivers/hid/hid-quirks.c +1 -0
@@ -716,6 +716,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_1_X) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_9) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_2026) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_P_2026) }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X_2026) },
drivers/hid/hid-steelseries-arctis.c +21 -0
@@ -168,6 +168,16 @@ static void steelseries_arctis_9_parse_status(struct steelseries_device *sd, sd->battery_charging = false; } } +static void steelseries_arctis_nova_7_parse_status (struct steelseries_device *sd,u8 *data,int size) +{ +if (size <4 ) +return ; +if (data[0 ] ==0xb0 ) { + sd->headset_connected = (data[1 ] ==0x03 ); + sd->battery_capacity =steelseries_map_capacity (data[2 ],0x00 ,0x04 ); + sd->battery_charging = (data[3 ] ==0x01 ); + } +}static void steelseries_arctis_nova_7_gen2_parse_status (struct steelseries_device *sd,u8 *data,int size)
@@ -219,6 +229,13 @@ static const struct steelseries_device_info arctis_nova_7_gen2_info = { .parse_status = steelseries_arctis_nova_7_gen2_parse_status, }; +static const struct steelseries_device_info arctis_nova_7_info = { + .sync_interface =3 , + .capabilities =SS_CAP_BATTERY , + .request_status = steelseries_arctis_nova_request_status, + .parse_status = steelseries_arctis_nova_7_parse_status, +}; +/* * Headset wireless status and battery infrastructure */
@@ -599,6 +616,10 @@ static const struct hid_device_id steelseries_arctis_devices[] = { {HID_USB_DEVICE (USB_VENDOR_ID_STEELSERIES , USB_DEVICE_ID_STEELSERIES_ARCTIS_9), .driver_data = (unsigned long)&arctis_9_info }, + { /* SteelSeries Arctis Nova 7X (0x2206) */ + HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, + USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_X), + .driver_data = (unsigned long)&arctis_nova_7_info }, { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_ARCTIS_NOVA_7_2026), .driver_data = (unsigned long)&arctis_nova_7_gen2_info },