Commit e24e31ea authored by Jiri Kosina's avatar Jiri Kosina
Browse files

Merge branch 'for-6.14/steelseries' into for-linus 

- SteelSeries Arctis 9 support (Christian Mayer)
parents 068815ef ad8ef3df

drivers/hid/hid-steelseries.c

+110 −10
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 


#define STEELSERIES_SRWS1		BIT(0)

#define STEELSERIES_ARCTIS_1		BIT(1)

#define STEELSERIES_ARCTIS_9		BIT(2)



struct steelseries_device {

	struct hid_device *hdev;
@@ -32,6 +33,7 @@ struct steelseries_device { 
	struct power_supply *battery;

	uint8_t battery_capacity;

	bool headset_connected;

	bool battery_charging;

};



#if IS_BUILTIN(CONFIG_LEDS_CLASS) || \
@@ -368,32 +370,35 @@ static void steelseries_srws1_remove(struct hid_device *hdev) 


	hid_hw_stop(hdev);

	kfree(drv_data);

	return;

}

#endif



#define STEELSERIES_HEADSET_BATTERY_TIMEOUT_MS	3000



#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 };



static int steelseries_headset_arctis_1_fetch_battery(struct hid_device *hdev)

static int steelseries_headset_request_battery(struct hid_device *hdev,

	const char *request, size_t len)

{

	u8 *write_buf;

	int ret;



	/* Request battery information */

	write_buf = kmemdup(arctis_1_battery_request, sizeof(arctis_1_battery_request), GFP_KERNEL);

	write_buf = kmemdup(request, len, GFP_KERNEL);

	if (!write_buf)

		return -ENOMEM;



	ret = hid_hw_raw_request(hdev, arctis_1_battery_request[0],

				 write_buf, sizeof(arctis_1_battery_request),

	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)sizeof(arctis_1_battery_request)) {

	if (ret < (int)len) {

		hid_err(hdev, "hid_hw_raw_request() failed with %d\n", ret);

		ret = -ENODATA;

	}



	kfree(write_buf);

	return ret;

}
@@ -404,7 +409,11 @@ static void steelseries_headset_fetch_battery(struct hid_device *hdev) 
	int ret = 0;



	if (sd->quirks & STEELSERIES_ARCTIS_1)

		ret = steelseries_headset_arctis_1_fetch_battery(hdev);

		ret = steelseries_headset_request_battery(hdev,

			arctis_1_battery_request, sizeof(arctis_1_battery_request));

	else if (sd->quirks & STEELSERIES_ARCTIS_9)

		ret = steelseries_headset_request_battery(hdev,

			arctis_9_battery_request, sizeof(arctis_9_battery_request));



	if (ret < 0)

		hid_dbg(hdev,
@@ -429,6 +438,9 @@ static void steelseries_headset_battery_timer_tick(struct work_struct *work) 
	steelseries_headset_fetch_battery(hdev);

}



#define STEELSERIES_PREFIX "SteelSeries "

#define STEELSERIES_PREFIX_LEN strlen(STEELSERIES_PREFIX)



static int steelseries_headset_battery_get_property(struct power_supply *psy,

				enum power_supply_property psp,

				union power_supply_propval *val)
@@ -437,13 +449,24 @@ static int steelseries_headset_battery_get_property(struct power_supply *psy, 
	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;

		break;

	case POWER_SUPPLY_PROP_MANUFACTURER:

		val->strval = "SteelSeries";

		break;

	case POWER_SUPPLY_PROP_PRESENT:

		val->intval = 1;

		break;

	case POWER_SUPPLY_PROP_STATUS:

		val->intval = sd->headset_connected ?

			POWER_SUPPLY_STATUS_DISCHARGING :

			POWER_SUPPLY_STATUS_UNKNOWN;

		if (sd->headset_connected) {

			val->intval = sd->battery_charging ?

				POWER_SUPPLY_STATUS_CHARGING :

				POWER_SUPPLY_STATUS_DISCHARGING;

		} else

			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;

		break;

	case POWER_SUPPLY_PROP_SCOPE:

		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
@@ -477,6 +500,8 @@ steelseries_headset_set_wireless_status(struct hid_device *hdev, 
}



static enum power_supply_property steelseries_headset_battery_props[] = {

	POWER_SUPPLY_PROP_MODEL_NAME,

	POWER_SUPPLY_PROP_MANUFACTURER,

	POWER_SUPPLY_PROP_PRESENT,

	POWER_SUPPLY_PROP_STATUS,

	POWER_SUPPLY_PROP_SCOPE,
@@ -505,6 +530,7 @@ static int steelseries_headset_battery_register(struct steelseries_device *sd) 
	/* 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->battery = devm_power_supply_register(&sd->hdev->dev,

			&sd->battery_desc, &battery_cfg);
@@ -520,9 +546,22 @@ static int steelseries_headset_battery_register(struct steelseries_device *sd) 
	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_probe(struct hid_device *hdev, const struct hid_device_id *id)

{

	struct steelseries_device *sd;
@@ -548,12 +587,20 @@ static int steelseries_probe(struct hid_device *hdev, const struct hid_device_id 
	if (ret)

		return ret;



	if (sd->quirks & STEELSERIES_ARCTIS_9 &&

			!steelseries_is_vendor_usage_page(hdev, 0xc0))

		return -ENODEV;



	spin_lock_init(&sd->lock);



	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);

	if (ret)

		return ret;



	ret = hid_hw_open(hdev);

	if (ret)

		return ret;



	if (steelseries_headset_battery_register(sd) < 0)

		hid_err(sd->hdev,

			"Failed to register battery for headset\n");
@@ -580,6 +627,7 @@ static void steelseries_remove(struct hid_device *hdev) 


	cancel_delayed_work_sync(&sd->battery_work);



	hid_hw_close(hdev);

	hid_hw_stop(hdev);

}
@@ -599,6 +647,15 @@ static const __u8 *steelseries_srws1_report_fixup(struct hid_device *hdev, 
	return rdesc;

}



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_headset_raw_event(struct hid_device *hdev,

					struct hid_report *report, u8 *read_buf,

					int size)
@@ -606,6 +663,7 @@ static int steelseries_headset_raw_event(struct hid_device *hdev, 
	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;



	/* Not a headset */
@@ -630,6 +688,34 @@ static int steelseries_headset_raw_event(struct hid_device *hdev, 
		}

	}



	if (sd->quirks & 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;

		}



		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;

		}

	}



	if (connected != sd->headset_connected) {

		hid_dbg(sd->hdev,

			"Connected status changed from %sconnected to %sconnected\n",
@@ -647,6 +733,15 @@ static int steelseries_headset_raw_event(struct hid_device *hdev, 
		power_supply_changed(sd->battery);

	}



	if (charging != sd->battery_charging) {

		hid_dbg(sd->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);

	}



request_battery:

	spin_lock_irqsave(&sd->lock, flags);

	if (!sd->removed)
@@ -665,6 +760,10 @@ static const struct hid_device_id steelseries_devices[] = { 
	  HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, 0x12b6),

	.driver_data = STEELSERIES_ARCTIS_1 },



	{ /* SteelSeries Arctis 9 Wireless for XBox */

	  HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, 0x12c2),

	  .driver_data = STEELSERIES_ARCTIS_9 },



	{ }

};

MODULE_DEVICE_TABLE(hid, steelseries_devices);
@@ -683,3 +782,4 @@ MODULE_DESCRIPTION("HID driver for Steelseries devices"); 
MODULE_LICENSE("GPL");

MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");

MODULE_AUTHOR("Simon Wood <simon@mungewell.org>");

MODULE_AUTHOR("Christian Mayer <git@mayer-bgk.de>");