From: Greg Kroah-Hartman Date: Tue, 1 Apr 2025 09:19:51 +0000 (+0100) Subject: 6.6-stable patches X-Git-Tag: v6.1.133~42 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=cae59e72cb1199ea19b27227a50056e11f9a59e2;p=thirdparty%2Fkernel%2Fstable-queue.git 6.6-stable patches added patches: alsa-usb-audio-add-quirk-for-plantronics-headsets-to-fix-control-names.patch arm-9350-1-fault-implement-copy_from_kernel_nofault_allowed.patch arm-9351-1-fault-add-cut-here-line-for-prefetch-aborts.patch arm-remove-address-checking-for-mmuless-devices.patch atm-fix-null-pointer-dereference.patch hid-hid-plantronics-add-mic-mute-mapping-and-generalize-quirks.patch series --- diff --git a/queue-6.6/alsa-usb-audio-add-quirk-for-plantronics-headsets-to-fix-control-names.patch b/queue-6.6/alsa-usb-audio-add-quirk-for-plantronics-headsets-to-fix-control-names.patch new file mode 100644 index 0000000000..b1b43e12a7 --- /dev/null +++ b/queue-6.6/alsa-usb-audio-add-quirk-for-plantronics-headsets-to-fix-control-names.patch @@ -0,0 +1,100 @@ +From 486f6205c233da1baa309bde5f634eb1f8319a33 Mon Sep 17 00:00:00 2001 +From: Terry Junge +Date: Fri, 17 Jan 2025 16:58:39 -0800 +Subject: ALSA: usb-audio: Add quirk for Plantronics headsets to fix control names + +From: Terry Junge + +commit 486f6205c233da1baa309bde5f634eb1f8319a33 upstream. + +Many Poly/Plantronics headset families name the feature, input, +and/or output units in a such a way to produce control names +that are not recognized by user space. As such, the volume and +mute events do not get routed to the headset's audio controls. + +As an example from a product family: + +The microphone mute control is named +Headset Microphone Capture Switch +and the headset volume control is named +Headset Earphone Playback Volume + +The quirk fixes these to become +Headset Capture Switch +Headset Playback Volume + +Signed-off-by: Terry Junge +Reviewed-by: Takashi Iwai +Cc: stable@vger.kernel.org +Signed-off-by: Jiri Kosina +Signed-off-by: Greg Kroah-Hartman +--- + sound/usb/mixer_quirks.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 51 insertions(+) + +--- a/sound/usb/mixer_quirks.c ++++ b/sound/usb/mixer_quirks.c +@@ -3575,6 +3575,52 @@ static void snd_dragonfly_quirk_db_scale + } + } + ++/* ++ * 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) +@@ -3592,5 +3638,10 @@ void snd_usb_mixer_fu_apply_quirk(struct + 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); + } + diff --git a/queue-6.6/arm-9350-1-fault-implement-copy_from_kernel_nofault_allowed.patch b/queue-6.6/arm-9350-1-fault-implement-copy_from_kernel_nofault_allowed.patch new file mode 100644 index 0000000000..35926e334f --- /dev/null +++ b/queue-6.6/arm-9350-1-fault-implement-copy_from_kernel_nofault_allowed.patch @@ -0,0 +1,49 @@ +From 169f9102f9198b04afffa6164372a4ba4070f412 Mon Sep 17 00:00:00 2001 +From: Kees Cook +Date: Thu, 1 Feb 2024 18:32:58 +0100 +Subject: ARM: 9350/1: fault: Implement copy_from_kernel_nofault_allowed() + +From: Kees Cook + +commit 169f9102f9198b04afffa6164372a4ba4070f412 upstream. + +Under PAN emulation when dumping backtraces from things like the +LKDTM EXEC_USERSPACE test[1], a double fault (which would hang a CPU) +would happen because of dump_instr() attempting to read a userspace +address. Make sure copy_from_kernel_nofault() does not attempt this +any more. + +Closes: https://lava.sirena.org.uk/scheduler/job/497571 +Link: https://lore.kernel.org/all/202401181125.D48DCB4C@keescook/ [1] + +Reported-by: Mark Brown +Suggested-by: Russell King (Oracle) +Reviewed-by: Ard Biesheuvel +Tested-by: Mark Brown +Cc: Wang Kefeng +Cc: Andrew Morton +Cc: Ben Hutchings +Cc: linux-arm-kernel@lists.infradead.org +Signed-off-by: Kees Cook +Signed-off-by: Russell King (Oracle) +Signed-off-by: Greg Kroah-Hartman +--- + arch/arm/mm/fault.c | 7 +++++++ + 1 file changed, 7 insertions(+) + +--- a/arch/arm/mm/fault.c ++++ b/arch/arm/mm/fault.c +@@ -25,6 +25,13 @@ + + #include "fault.h" + ++bool copy_from_kernel_nofault_allowed(const void *unsafe_src, size_t size) ++{ ++ unsigned long addr = (unsigned long)unsafe_src; ++ ++ return addr >= TASK_SIZE && ULONG_MAX - addr >= size; ++} ++ + #ifdef CONFIG_MMU + + /* diff --git a/queue-6.6/arm-9351-1-fault-add-cut-here-line-for-prefetch-aborts.patch b/queue-6.6/arm-9351-1-fault-add-cut-here-line-for-prefetch-aborts.patch new file mode 100644 index 0000000000..af1275d687 --- /dev/null +++ b/queue-6.6/arm-9351-1-fault-add-cut-here-line-for-prefetch-aborts.patch @@ -0,0 +1,33 @@ +From 8f09b8b4fa58e99cbfd9a650b31d65cdbd8e4276 Mon Sep 17 00:00:00 2001 +From: Kees Cook +Date: Thu, 1 Feb 2024 18:32:23 +0100 +Subject: ARM: 9351/1: fault: Add "cut here" line for prefetch aborts + +From: Kees Cook + +commit 8f09b8b4fa58e99cbfd9a650b31d65cdbd8e4276 upstream. + +The common pattern in arm is to emit a "8<--- cut here ---" line for +faults, but it was missing for do_PrefetchAbort(). Add it. + +Cc: Wang Kefeng +Cc: Ben Hutchings +Cc: linux-arm-kernel@lists.infradead.org +Acked-by: Ard Biesheuvel +Signed-off-by: Kees Cook +Signed-off-by: Russell King (Oracle) +Signed-off-by: Greg Kroah-Hartman +--- + arch/arm/mm/fault.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/arch/arm/mm/fault.c ++++ b/arch/arm/mm/fault.c +@@ -563,6 +563,7 @@ do_PrefetchAbort(unsigned long addr, uns + if (!inf->fn(addr, ifsr | FSR_LNX_PF, regs)) + return; + ++ pr_alert("8<--- cut here ---\n"); + pr_alert("Unhandled prefetch abort: %s (0x%03x) at 0x%08lx\n", + inf->name, ifsr, addr); + diff --git a/queue-6.6/arm-remove-address-checking-for-mmuless-devices.patch b/queue-6.6/arm-remove-address-checking-for-mmuless-devices.patch new file mode 100644 index 0000000000..c724c40ccb --- /dev/null +++ b/queue-6.6/arm-remove-address-checking-for-mmuless-devices.patch @@ -0,0 +1,46 @@ +From 3ccea4784fddd96fbd6c4497eb28b45dab638c2a Mon Sep 17 00:00:00 2001 +From: Yanjun Yang +Date: Tue, 11 Jun 2024 18:09:47 +0800 +Subject: ARM: Remove address checking for MMUless devices + +From: Yanjun Yang + +commit 3ccea4784fddd96fbd6c4497eb28b45dab638c2a upstream. + +Commit 169f9102f9198b ("ARM: 9350/1: fault: Implement +copy_from_kernel_nofault_allowed()") added the function to check address +before use. However, for devices without MMU, addr > TASK_SIZE will +always fail. This patch move this function after the #ifdef CONFIG_MMU +statement. + +Signed-off-by: Yanjun Yang +Acked-by: Ard Biesheuvel +Closes: https://bugzilla.kernel.org/show_bug.cgi?id=218953 +Fixes: 169f9102f9198b ("ARM: 9350/1: fault: Implement copy_from_kernel_nofault_allowed()") +Link: https://lore.kernel.org/r/20240611100947.32241-1-yangyj.ee@gmail.com +Signed-off-by: Kees Cook +Signed-off-by: Greg Kroah-Hartman +--- + arch/arm/mm/fault.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/arch/arm/mm/fault.c ++++ b/arch/arm/mm/fault.c +@@ -25,6 +25,8 @@ + + #include "fault.h" + ++#ifdef CONFIG_MMU ++ + bool copy_from_kernel_nofault_allowed(const void *unsafe_src, size_t size) + { + unsigned long addr = (unsigned long)unsafe_src; +@@ -32,8 +34,6 @@ bool copy_from_kernel_nofault_allowed(co + return addr >= TASK_SIZE && ULONG_MAX - addr >= size; + } + +-#ifdef CONFIG_MMU +- + /* + * This is useful to dump out the page tables associated with + * 'addr' in mm 'mm'. diff --git a/queue-6.6/atm-fix-null-pointer-dereference.patch b/queue-6.6/atm-fix-null-pointer-dereference.patch new file mode 100644 index 0000000000..18e70c0392 --- /dev/null +++ b/queue-6.6/atm-fix-null-pointer-dereference.patch @@ -0,0 +1,125 @@ +From bf2986fcf82a449441f9ee4335df19be19e83970 Mon Sep 17 00:00:00 2001 +From: Minjoong Kim +Date: Sat, 22 Mar 2025 10:52:00 +0000 +Subject: atm: Fix NULL pointer dereference + +From: Minjoong Kim + +commit bf2986fcf82a449441f9ee4335df19be19e83970 upstream. + +When MPOA_cache_impos_rcvd() receives the msg, it can trigger +Null Pointer Dereference Vulnerability if both entry and +holding_time are NULL. Because there is only for the situation +where entry is NULL and holding_time exists, it can be passed +when both entry and holding_time are NULL. If these are NULL, +the entry will be passd to eg_cache_put() as parameter and +it is referenced by entry->use code in it. + +kasan log: + +[ 3.316691] Oops: general protection fault, probably for non-canonical address 0xdffffc0000000006:I +[ 3.317568] KASAN: null-ptr-deref in range [0x0000000000000030-0x0000000000000037] +[ 3.318188] CPU: 3 UID: 0 PID: 79 Comm: ex Not tainted 6.14.0-rc2 #102 +[ 3.318601] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.15.0-1 04/01/2014 +[ 3.319298] RIP: 0010:eg_cache_remove_entry+0xa5/0x470 +[ 3.319677] Code: c1 f7 6e fd 48 c7 c7 00 7e 38 b2 e8 95 64 54 fd 48 c7 c7 40 7e 38 b2 48 89 ee e80 +[ 3.321220] RSP: 0018:ffff88800583f8a8 EFLAGS: 00010006 +[ 3.321596] RAX: 0000000000000006 RBX: ffff888005989000 RCX: ffffffffaecc2d8e +[ 3.322112] RDX: 0000000000000000 RSI: 0000000000000004 RDI: 0000000000000030 +[ 3.322643] RBP: 0000000000000000 R08: 0000000000000000 R09: fffffbfff6558b88 +[ 3.323181] R10: 0000000000000003 R11: 203a207972746e65 R12: 1ffff11000b07f15 +[ 3.323707] R13: dffffc0000000000 R14: ffff888005989000 R15: ffff888005989068 +[ 3.324185] FS: 000000001b6313c0(0000) GS:ffff88806d380000(0000) knlGS:0000000000000000 +[ 3.325042] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +[ 3.325545] CR2: 00000000004b4b40 CR3: 000000000248e000 CR4: 00000000000006f0 +[ 3.326430] Call Trace: +[ 3.326725] +[ 3.326927] ? die_addr+0x3c/0xa0 +[ 3.327330] ? exc_general_protection+0x161/0x2a0 +[ 3.327662] ? asm_exc_general_protection+0x26/0x30 +[ 3.328214] ? vprintk_emit+0x15e/0x420 +[ 3.328543] ? eg_cache_remove_entry+0xa5/0x470 +[ 3.328910] ? eg_cache_remove_entry+0x9a/0x470 +[ 3.329294] ? __pfx_eg_cache_remove_entry+0x10/0x10 +[ 3.329664] ? console_unlock+0x107/0x1d0 +[ 3.329946] ? __pfx_console_unlock+0x10/0x10 +[ 3.330283] ? do_syscall_64+0xa6/0x1a0 +[ 3.330584] ? entry_SYSCALL_64_after_hwframe+0x47/0x7f +[ 3.331090] ? __pfx_prb_read_valid+0x10/0x10 +[ 3.331395] ? down_trylock+0x52/0x80 +[ 3.331703] ? vprintk_emit+0x15e/0x420 +[ 3.331986] ? __pfx_vprintk_emit+0x10/0x10 +[ 3.332279] ? down_trylock+0x52/0x80 +[ 3.332527] ? _printk+0xbf/0x100 +[ 3.332762] ? __pfx__printk+0x10/0x10 +[ 3.333007] ? _raw_write_lock_irq+0x81/0xe0 +[ 3.333284] ? __pfx__raw_write_lock_irq+0x10/0x10 +[ 3.333614] msg_from_mpoad+0x1185/0x2750 +[ 3.333893] ? __build_skb_around+0x27b/0x3a0 +[ 3.334183] ? __pfx_msg_from_mpoad+0x10/0x10 +[ 3.334501] ? __alloc_skb+0x1c0/0x310 +[ 3.334809] ? __pfx___alloc_skb+0x10/0x10 +[ 3.335283] ? _raw_spin_lock+0xe0/0xe0 +[ 3.335632] ? finish_wait+0x8d/0x1e0 +[ 3.335975] vcc_sendmsg+0x684/0xba0 +[ 3.336250] ? __pfx_vcc_sendmsg+0x10/0x10 +[ 3.336587] ? __pfx_autoremove_wake_function+0x10/0x10 +[ 3.337056] ? fdget+0x176/0x3e0 +[ 3.337348] __sys_sendto+0x4a2/0x510 +[ 3.337663] ? __pfx___sys_sendto+0x10/0x10 +[ 3.337969] ? ioctl_has_perm.constprop.0.isra.0+0x284/0x400 +[ 3.338364] ? sock_ioctl+0x1bb/0x5a0 +[ 3.338653] ? __rseq_handle_notify_resume+0x825/0xd20 +[ 3.339017] ? __pfx_sock_ioctl+0x10/0x10 +[ 3.339316] ? __pfx___rseq_handle_notify_resume+0x10/0x10 +[ 3.339727] ? selinux_file_ioctl+0xa4/0x260 +[ 3.340166] __x64_sys_sendto+0xe0/0x1c0 +[ 3.340526] ? syscall_exit_to_user_mode+0x123/0x140 +[ 3.340898] do_syscall_64+0xa6/0x1a0 +[ 3.341170] entry_SYSCALL_64_after_hwframe+0x77/0x7f +[ 3.341533] RIP: 0033:0x44a380 +[ 3.341757] Code: 0f 1f 84 00 00 00 00 00 66 90 f3 0f 1e fa 41 89 ca 64 8b 04 25 18 00 00 00 85 c00 +[ 3.343078] RSP: 002b:00007ffc1d404098 EFLAGS: 00000246 ORIG_RAX: 000000000000002c +[ 3.343631] RAX: ffffffffffffffda RBX: 00007ffc1d404458 RCX: 000000000044a380 +[ 3.344306] RDX: 000000000000019c RSI: 00007ffc1d4040b0 RDI: 0000000000000003 +[ 3.344833] RBP: 00007ffc1d404260 R08: 0000000000000000 R09: 0000000000000000 +[ 3.345381] R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000001 +[ 3.346015] R13: 00007ffc1d404448 R14: 00000000004c17d0 R15: 0000000000000001 +[ 3.346503] +[ 3.346679] Modules linked in: +[ 3.346956] ---[ end trace 0000000000000000 ]--- +[ 3.347315] RIP: 0010:eg_cache_remove_entry+0xa5/0x470 +[ 3.347737] Code: c1 f7 6e fd 48 c7 c7 00 7e 38 b2 e8 95 64 54 fd 48 c7 c7 40 7e 38 b2 48 89 ee e80 +[ 3.349157] RSP: 0018:ffff88800583f8a8 EFLAGS: 00010006 +[ 3.349517] RAX: 0000000000000006 RBX: ffff888005989000 RCX: ffffffffaecc2d8e +[ 3.350103] RDX: 0000000000000000 RSI: 0000000000000004 RDI: 0000000000000030 +[ 3.350610] RBP: 0000000000000000 R08: 0000000000000000 R09: fffffbfff6558b88 +[ 3.351246] R10: 0000000000000003 R11: 203a207972746e65 R12: 1ffff11000b07f15 +[ 3.351785] R13: dffffc0000000000 R14: ffff888005989000 R15: ffff888005989068 +[ 3.352404] FS: 000000001b6313c0(0000) GS:ffff88806d380000(0000) knlGS:0000000000000000 +[ 3.353099] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +[ 3.353544] CR2: 00000000004b4b40 CR3: 000000000248e000 CR4: 00000000000006f0 +[ 3.354072] note: ex[79] exited with irqs disabled +[ 3.354458] note: ex[79] exited with preempt_count 1 + +Signed-off-by: Minjoong Kim +Fixes: 1da177e4c3f4 ("Linux-2.6.12-rc2") +Reviewed-by: Simon Horman +Link: https://patch.msgid.link/20250322105200.14981-1-pwn9uin@gmail.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Greg Kroah-Hartman +--- + net/atm/mpc.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/net/atm/mpc.c ++++ b/net/atm/mpc.c +@@ -1314,6 +1314,8 @@ static void MPOA_cache_impos_rcvd(struct + holding_time = msg->content.eg_info.holding_time; + dprintk("(%s) entry = %p, holding_time = %u\n", + mpc->dev->name, entry, holding_time); ++ if (entry == NULL && !holding_time) ++ return; + if (entry == NULL && holding_time) { + entry = mpc->eg_ops->add_entry(msg, mpc); + mpc->eg_ops->put(entry); diff --git a/queue-6.6/hid-hid-plantronics-add-mic-mute-mapping-and-generalize-quirks.patch b/queue-6.6/hid-hid-plantronics-add-mic-mute-mapping-and-generalize-quirks.patch new file mode 100644 index 0000000000..d577af5c2e --- /dev/null +++ b/queue-6.6/hid-hid-plantronics-add-mic-mute-mapping-and-generalize-quirks.patch @@ -0,0 +1,281 @@ +From 9821709af892be9fbf4ee9a50b2f3e0604295ce0 Mon Sep 17 00:00:00 2001 +From: Terry Junge +Date: Fri, 17 Jan 2025 16:58:38 -0800 +Subject: HID: hid-plantronics: Add mic mute mapping and generalize quirks + +From: Terry Junge + +commit 9821709af892be9fbf4ee9a50b2f3e0604295ce0 upstream. + +Add mapping for headset mute key events. + +Remove PLT_QUIRK_DOUBLE_VOLUME_KEYS quirk and made it generic. +The quirk logic did not keep track of the actual previous key +so any key event occurring in less than or equal to 5ms was ignored. + +Remove PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS quirk. +It had the same logic issue as the double key quirk and was actually +masking the as designed behavior of most of the headsets. +It's occurrence should be minimized with the ALSA control naming +quirk that is part of the patch set. + +Signed-off-by: Terry Junge +Cc: stable@vger.kernel.org +Signed-off-by: Jiri Kosina +Signed-off-by: Greg Kroah-Hartman +--- + drivers/hid/hid-plantronics.c | 148 +++++++++++++++++++----------------------- + 1 file changed, 69 insertions(+), 79 deletions(-) + +--- a/drivers/hid/hid-plantronics.c ++++ b/drivers/hid/hid-plantronics.c +@@ -6,9 +6,6 @@ + * Copyright (c) 2015-2018 Terry Junge + */ + +-/* +- */ +- + #include "hid-ids.h" + + #include +@@ -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(str + 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) +- 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 standard consumer control mapping */ ++ /* and standard telephony mic mute mapping */ ++ if (allow_consumer || allow_mute) ++ goto defaulted; ++ ++ /* 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,8 +99,11 @@ static int plantronics_input_mapping(str + case PLT2_VOL_DOWN: + mapped_key = KEY_VOLUMEDOWN; + goto mapped; ++ case PLT1_MIC_MUTE: ++ case PLT2_MIC_MUTE: ++ mapped_key = KEY_MICMUTE; ++ goto mapped; + } +- } + + /* + * Future mapping of call control or other usages, +@@ -105,6 +112,8 @@ static int plantronics_input_mapping(str + */ + + 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_ + struct hid_usage *usage, __s32 value) + { + struct plt_drv_data *drv_data = hid_get_drvdata(hdev); ++ unsigned long prev_tsto, cur_ts; ++ __u16 prev_key, cur_key; + +- if (drv_data->quirks & PLT_QUIRK_DOUBLE_VOLUME_KEYS) { +- unsigned long prev_ts, cur_ts; +- +- /* Usages are filtered in plantronics_usages. */ +- +- 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_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. */ +- +- if (!value) /* Handle key presses only. */ +- return 0; ++ /* Usages are filtered in plantronics_usages. */ + +- 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; ++ /* 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_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 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_ + 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_ + 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_dev + 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 } + }; + diff --git a/queue-6.6/series b/queue-6.6/series new file mode 100644 index 0000000000..8760f0ac6d --- /dev/null +++ b/queue-6.6/series @@ -0,0 +1,6 @@ +alsa-usb-audio-add-quirk-for-plantronics-headsets-to-fix-control-names.patch +hid-hid-plantronics-add-mic-mute-mapping-and-generalize-quirks.patch +atm-fix-null-pointer-dereference.patch +arm-9350-1-fault-implement-copy_from_kernel_nofault_allowed.patch +arm-9351-1-fault-add-cut-here-line-for-prefetch-aborts.patch +arm-remove-address-checking-for-mmuless-devices.patch