Merge branch 'for-6.15/plantronics' into for-linus (74ed6b5b) · Commits · git / linux-net

drivers/hid/hid-plantronics.c

+67 −77

Original line number	Diff line number	Diff line
		@@ -6,9 +6,6 @@
		* Copyright (c) 2015-2018 Terry Junge <terry.junge@plantronics.com>
		*/

		/*
		*/

		#include "hid-ids.h"

		#include <linux/hid.h>
		@@ -23,30 +20,28 @@

		#define PLT_VOL_UP 0x00b1
		#define PLT_VOL_DOWN 0x00b2
		#define PLT_MIC_MUTE 0x00b5

		#define PLT1_VOL_UP (PLT_HID_1_0_PAGE \| PLT_VOL_UP)
		#define PLT1_VOL_DOWN (PLT_HID_1_0_PAGE \| PLT_VOL_DOWN)
		#define PLT1_MIC_MUTE (PLT_HID_1_0_PAGE \| PLT_MIC_MUTE)
		#define PLT2_VOL_UP (PLT_HID_2_0_PAGE \| PLT_VOL_UP)
		#define PLT2_VOL_DOWN (PLT_HID_2_0_PAGE \| PLT_VOL_DOWN)
		#define PLT2_MIC_MUTE (PLT_HID_2_0_PAGE \| PLT_MIC_MUTE)
		#define HID_TELEPHONY_MUTE (HID_UP_TELEPHONY \| 0x2f)
		#define HID_CONSUMER_MUTE (HID_UP_CONSUMER \| 0xe2)

		#define PLT_DA60 0xda60
		#define PLT_BT300_MIN 0x0413
		#define PLT_BT300_MAX 0x0418


		#define PLT_ALLOW_CONSUMER (field->application == HID_CP_CONSUMERCONTROL && \
		(usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)

		#define PLT_QUIRK_DOUBLE_VOLUME_KEYS BIT(0)
		#define PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS BIT(1)

		#define PLT_DOUBLE_KEY_TIMEOUT 5 /* ms */
		#define PLT_FOLLOWED_OPPOSITE_KEY_TIMEOUT 220 /* ms */

		struct plt_drv_data {
		unsigned long device_type;
		unsigned long last_volume_key_ts;
		u32 quirks;
		unsigned long last_key_ts;
		unsigned long double_key_to;
		__u16 last_key;
		};

		static int plantronics_input_mapping(struct hid_device *hdev,
		@@ -58,34 +53,43 @@ static int plantronics_input_mapping(struct hid_device *hdev,
		unsigned short mapped_key;
		struct plt_drv_data *drv_data = hid_get_drvdata(hdev);
		unsigned long plt_type = drv_data->device_type;
		int allow_mute = usage->hid == HID_TELEPHONY_MUTE;
		int allow_consumer = field->application == HID_CP_CONSUMERCONTROL &&
		(usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER &&
		usage->hid != HID_CONSUMER_MUTE;

		/* special case for PTT products */
		if (field->application == HID_GD_JOYSTICK)
		goto defaulted;

		/* handle volume up/down mapping */
		/* non-standard types or multi-HID interfaces - plt_type is PID */
		if (!(plt_type & HID_USAGE_PAGE)) {
		switch (plt_type) {
		case PLT_DA60:
		if (PLT_ALLOW_CONSUMER)
		if (allow_consumer)
		goto defaulted;
		goto ignored;
		if (usage->hid == HID_CONSUMER_MUTE) {
		mapped_key = KEY_MICMUTE;
		goto mapped;
		}
		break;
		default:
		if (PLT_ALLOW_CONSUMER)
		if (allow_consumer \|\| allow_mute)
		goto defaulted;
		}
		goto ignored;
		}
		/* handle standard types - plt_type is 0xffa0uuuu or 0xffa2uuuu */
		/* 'basic telephony compliant' - allow default consumer page map */
		else if ((plt_type & HID_USAGE) >= PLT_BASIC_TELEPHONY &&
		(plt_type & HID_USAGE) != PLT_BASIC_EXCEPTION) {
		if (PLT_ALLOW_CONSUMER)

		/* handle standard consumer control mapping */
		/* and standard telephony mic mute mapping */
		if (allow_consumer \|\| allow_mute)
		goto defaulted;
		}
		/* not 'basic telephony' - apply legacy mapping */
		/* only map if the field is in the device's primary vendor page */
		else if (!((field->application ^ plt_type) & HID_USAGE_PAGE)) {

		/* handle vendor unique types - plt_type is 0xffa0uuuu or 0xffa2uuuu */
		/* if not 'basic telephony compliant' - map vendor unique controls */
		if (!((plt_type & HID_USAGE) >= PLT_BASIC_TELEPHONY &&
		(plt_type & HID_USAGE) != PLT_BASIC_EXCEPTION) &&
		!((field->application ^ plt_type) & HID_USAGE_PAGE))
		switch (usage->hid) {
		case PLT1_VOL_UP:
		case PLT2_VOL_UP:
		@@ -95,7 +99,10 @@ static int plantronics_input_mapping(struct hid_device *hdev,
		case PLT2_VOL_DOWN:
		mapped_key = KEY_VOLUMEDOWN;
		goto mapped;
		}
		case PLT1_MIC_MUTE:
		case PLT2_MIC_MUTE:
		mapped_key = KEY_MICMUTE;
		goto mapped;
		}

		/*
		@@ -105,6 +112,8 @@ static int plantronics_input_mapping(struct hid_device *hdev,
		*/

		ignored:
		hid_dbg(hdev, "usage: %08x (appl: %08x) - ignored\n",
		usage->hid, field->application);
		return -1;

		defaulted:
		@@ -123,38 +132,26 @@ static int plantronics_event(struct hid_device hdev, struct hid_field field,
		struct hid_usage *usage, __s32 value)
		{
		struct plt_drv_data *drv_data = hid_get_drvdata(hdev);

		if (drv_data->quirks & PLT_QUIRK_DOUBLE_VOLUME_KEYS) {
		unsigned long prev_ts, cur_ts;
		unsigned long prev_tsto, cur_ts;
		__u16 prev_key, cur_key;

		/* Usages are filtered in plantronics_usages. */

		if (!value) /* Handle key presses only. */
		/* HZ too low for ms resolution - double key detection disabled */
		/* or it is a key release - handle key presses only. */
		if (!drv_data->double_key_to \|\| !value)
		return 0;

		prev_ts = drv_data->last_volume_key_ts;
		cur_ts = jiffies;
		if (jiffies_to_msecs(cur_ts - prev_ts) <= PLT_DOUBLE_KEY_TIMEOUT)
		return 1; /* Ignore the repeated key. */

		drv_data->last_volume_key_ts = cur_ts;
		}
		if (drv_data->quirks & PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS) {
		unsigned long prev_ts, cur_ts;

		/* Usages are filtered in plantronics_usages. */
		prev_tsto = drv_data->last_key_ts + drv_data->double_key_to;
		cur_ts = drv_data->last_key_ts = jiffies;
		prev_key = drv_data->last_key;
		cur_key = drv_data->last_key = usage->code;

		if (!value) /* Handle key presses only. */
		return 0;

		prev_ts = drv_data->last_volume_key_ts;
		cur_ts = jiffies;
		if (jiffies_to_msecs(cur_ts - prev_ts) <= PLT_FOLLOWED_OPPOSITE_KEY_TIMEOUT)
		return 1; /* Ignore the followed opposite volume key. */

		drv_data->last_volume_key_ts = cur_ts;
		/* If the same key occurs in <= double_key_to -- ignore it */
		if (prev_key == cur_key && time_before_eq(cur_ts, prev_tsto)) {
		hid_dbg(hdev, "double key %d ignored\n", cur_key);
		return 1; /* Ignore the repeated key. */
		}

		return 0;
		}

		@@ -196,12 +193,16 @@ static int plantronics_probe(struct hid_device *hdev,
		ret = hid_parse(hdev);
		if (ret) {
		hid_err(hdev, "parse failed\n");
		goto err;
		return ret;
		}

		drv_data->device_type = plantronics_device_type(hdev);
		drv_data->quirks = id->driver_data;
		drv_data->last_volume_key_ts = jiffies - msecs_to_jiffies(PLT_DOUBLE_KEY_TIMEOUT);
		drv_data->double_key_to = msecs_to_jiffies(PLT_DOUBLE_KEY_TIMEOUT);
		drv_data->last_key_ts = jiffies - drv_data->double_key_to;

		/* if HZ does not allow ms resolution - disable double key detection */
		if (drv_data->double_key_to < PLT_DOUBLE_KEY_TIMEOUT)
		drv_data->double_key_to = 0;

		hid_set_drvdata(hdev, drv_data);

		@@ -210,29 +211,10 @@ static int plantronics_probe(struct hid_device *hdev,
		if (ret)
		hid_err(hdev, "hw start failed\n");

		err:
		return ret;
		}

		static const struct hid_device_id plantronics_devices[] = {
		{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
		USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3210_SERIES),
		.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
		{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
		USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3220_SERIES),
		.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
		{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
		USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3215_SERIES),
		.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
		{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
		USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3225_SERIES),
		.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
		{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
		USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3325_SERIES),
		.driver_data = PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS },
		{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
		USB_DEVICE_ID_PLANTRONICS_ENCOREPRO_500_SERIES),
		.driver_data = PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS },
		{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },
		{ }
		};
		@@ -241,6 +223,14 @@ MODULE_DEVICE_TABLE(hid, plantronics_devices);
		static const struct hid_usage_id plantronics_usages[] = {
		{ HID_CP_VOLUMEUP, EV_KEY, HID_ANY_ID },
		{ HID_CP_VOLUMEDOWN, EV_KEY, HID_ANY_ID },
		{ HID_TELEPHONY_MUTE, EV_KEY, HID_ANY_ID },
		{ HID_CONSUMER_MUTE, EV_KEY, HID_ANY_ID },
		{ PLT2_VOL_UP, EV_KEY, HID_ANY_ID },
		{ PLT2_VOL_DOWN, EV_KEY, HID_ANY_ID },
		{ PLT2_MIC_MUTE, EV_KEY, HID_ANY_ID },
		{ PLT1_VOL_UP, EV_KEY, HID_ANY_ID },
		{ PLT1_VOL_DOWN, EV_KEY, HID_ANY_ID },
		{ PLT1_MIC_MUTE, EV_KEY, HID_ANY_ID },
		{ HID_TERMINATOR, HID_TERMINATOR, HID_TERMINATOR }
		};

sound/usb/mixer_quirks.c

+51 −0

Original line number	Diff line number	Diff line
		@@ -4223,6 +4223,52 @@ static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
		}
		}

		/*
		* Some Plantronics headsets have control names that don't meet ALSA naming
		* standards. This function fixes nonstandard source names. By the time
		* this function is called the control name should look like one of these:
		* "source names Playback Volume"
		* "source names Playback Switch"
		* "source names Capture Volume"
		* "source names Capture Switch"
		* If any of the trigger words are found in the name then the name will
		* be changed to:
		* "Headset Playback Volume"
		* "Headset Playback Switch"
		* "Headset Capture Volume"
		* "Headset Capture Switch"
		* depending on the current suffix.
		*/
		static void snd_fix_plt_name(struct snd_usb_audio *chip,
		struct snd_ctl_elem_id *id)
		{
		/* no variant of "Sidetone" should be added to this list */
		static const char * const trigger[] = {
		"Earphone", "Microphone", "Receive", "Transmit"
		};
		static const char * const suffix[] = {
		" Playback Volume", " Playback Switch",
		" Capture Volume", " Capture Switch"
		};
		int i;

		for (i = 0; i < ARRAY_SIZE(trigger); i++)
		if (strstr(id->name, trigger[i]))
		goto triggered;
		usb_audio_dbg(chip, "no change in %s\n", id->name);
		return;

		triggered:
		for (i = 0; i < ARRAY_SIZE(suffix); i++)
		if (strstr(id->name, suffix[i])) {
		usb_audio_dbg(chip, "fixing kctl name %s\n", id->name);
		snprintf(id->name, sizeof(id->name), "Headset%s",
		suffix[i]);
		return;
		}
		usb_audio_dbg(chip, "something wrong in kctl name %s\n", id->name);
		}

		void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
		struct usb_mixer_elem_info *cval, int unitid,
		struct snd_kcontrol *kctl)
		@@ -4240,5 +4286,10 @@ void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
		cval->min_mute = 1;
		break;
		}

		/* ALSA-ify some Plantronics headset control names */
		if (USB_ID_VENDOR(mixer->chip->usb_id) == 0x047f &&
		(cval->control == UAC_FU_MUTE \|\| cval->control == UAC_FU_VOLUME))
		snd_fix_plt_name(mixer->chip, &kctl->id);
		}