From: Greg Kroah-Hartman Date: Tue, 1 Dec 2020 08:34:56 +0000 (+0100) Subject: 4.9-stable patches X-Git-Tag: v4.4.247~8 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=9c655381fef983d0b661c1e1f347cfe70024274c;p=thirdparty%2Fkernel%2Fstable-queue.git 4.9-stable patches added patches: regulator-avoid-resolve_supply-infinite-recursion.patch regulator-workaround-self-referent-regulators.patch usb-core-add-endpoint-blacklist-quirk.patch usb-core-fix-regression-in-hercules-audio-card.patch --- diff --git a/queue-4.9/regulator-avoid-resolve_supply-infinite-recursion.patch b/queue-4.9/regulator-avoid-resolve_supply-infinite-recursion.patch new file mode 100644 index 00000000000..914ac666469 --- /dev/null +++ b/queue-4.9/regulator-avoid-resolve_supply-infinite-recursion.patch @@ -0,0 +1,43 @@ +From foo@baz Tue Dec 1 09:28:38 AM CET 2020 +From: "Michał Mirosław" +Date: Fri, 13 Nov 2020 01:20:28 +0100 +Subject: regulator: avoid resolve_supply() infinite recursion + +From: "Michał Mirosław" + +commit 4b639e254d3d4f15ee4ff2b890a447204cfbeea9 upstream + +When a regulator's name equals its supply's name the +regulator_resolve_supply() recurses indefinitely. Add a check +so that debugging the problem is easier. The "fixed" commit +just exposed the problem. + +Fixes: aea6cb99703e ("regulator: resolve supply after creating regulator") +Cc: stable@vger.kernel.org +Reported-by: Ahmad Fatoum +Signed-off-by: Michał Mirosław +Tested-by: Ahmad Fatoum # stpmic1 +Link: https://lore.kernel.org/r/c6171057cfc0896f950c4d8cb82df0f9f1b89ad9.1605226675.git.mirq-linux@rere.qmqm.pl +Signed-off-by: Mark Brown +[sudip: adjust context] +Signed-off-by: Sudip Mukherjee +Signed-off-by: Greg Kroah-Hartman +--- + drivers/regulator/core.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +--- a/drivers/regulator/core.c ++++ b/drivers/regulator/core.c +@@ -1550,6 +1550,12 @@ static int regulator_resolve_supply(stru + } + } + ++ if (r == rdev) { ++ dev_err(dev, "Supply for %s (%s) resolved to itself\n", ++ rdev->desc->name, rdev->supply_name); ++ return -EINVAL; ++ } ++ + /* Recursively resolve the supply of the supply */ + ret = regulator_resolve_supply(r); + if (ret < 0) { diff --git a/queue-4.9/regulator-workaround-self-referent-regulators.patch b/queue-4.9/regulator-workaround-self-referent-regulators.patch new file mode 100644 index 00000000000..69ba3e71bcf --- /dev/null +++ b/queue-4.9/regulator-workaround-self-referent-regulators.patch @@ -0,0 +1,42 @@ +From foo@baz Tue Dec 1 09:29:11 AM CET 2020 +From: "Michał Mirosław" +Date: Fri, 13 Nov 2020 01:20:28 +0100 +Subject: regulator: workaround self-referent regulators + +From: "Michał Mirosław" + +commit f5c042b23f7429e5c2ac987b01a31c69059a978b upstream + +Workaround regulators whose supply name happens to be the same as its +own name. This fixes boards that used to work before the early supply +resolving was removed. The error message is left in place so that +offending drivers can be detected. + +Fixes: aea6cb99703e ("regulator: resolve supply after creating regulator") +Cc: stable@vger.kernel.org +Reported-by: Ahmad Fatoum +Signed-off-by: Michał Mirosław +Tested-by: Ahmad Fatoum # stpmic1 +Link: https://lore.kernel.org/r/d703acde2a93100c3c7a81059d716c50ad1b1f52.1605226675.git.mirq-linux@rere.qmqm.pl +Signed-off-by: Mark Brown +[sudip: adjust context] +Signed-off-by: Sudip Mukherjee +Signed-off-by: Greg Kroah-Hartman +--- + drivers/regulator/core.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +--- a/drivers/regulator/core.c ++++ b/drivers/regulator/core.c +@@ -1553,7 +1553,10 @@ static int regulator_resolve_supply(stru + if (r == rdev) { + dev_err(dev, "Supply for %s (%s) resolved to itself\n", + rdev->desc->name, rdev->supply_name); +- return -EINVAL; ++ if (!have_full_constraints()) ++ return -EINVAL; ++ r = dummy_regulator_rdev; ++ get_device(&r->dev); + } + + /* Recursively resolve the supply of the supply */ diff --git a/queue-4.9/series b/queue-4.9/series index 5afb6a598ea..fbc1126609b 100644 --- a/queue-4.9/series +++ b/queue-4.9/series @@ -37,3 +37,7 @@ usb-core-change-pk-for-__user-pointers-to-px.patch usb-gadget-f_midi-fix-memleak-in-f_midi_alloc.patch usb-gadget-fix-memleak-in-gadgetfs_fill_super.patch x86-speculation-fix-prctl-when-spectre_v2_user-seccomp-prctl-ibpb.patch +regulator-avoid-resolve_supply-infinite-recursion.patch +regulator-workaround-self-referent-regulators.patch +usb-core-add-endpoint-blacklist-quirk.patch +usb-core-fix-regression-in-hercules-audio-card.patch diff --git a/queue-4.9/usb-core-add-endpoint-blacklist-quirk.patch b/queue-4.9/usb-core-add-endpoint-blacklist-quirk.patch new file mode 100644 index 00000000000..e544a9eeda6 --- /dev/null +++ b/queue-4.9/usb-core-add-endpoint-blacklist-quirk.patch @@ -0,0 +1,124 @@ +From foo@baz Tue Dec 1 09:30:52 AM CET 2020 +From: Johan Hovold +Date: Mon, 3 Feb 2020 16:38:28 +0100 +Subject: USB: core: add endpoint-blacklist quirk + +From: Johan Hovold + +commit 73f8bda9b5dc1c69df2bc55c0cbb24461a6391a9 upstream + +Add a new device quirk that can be used to blacklist endpoints. + +Since commit 3e4f8e21c4f2 ("USB: core: fix check for duplicate +endpoints") USB core ignores any duplicate endpoints found during +descriptor parsing. + +In order to handle devices where the first interfaces with duplicate +endpoints are the ones that should have their endpoints ignored, we need +to add a blacklist. + +Tested-by: edes +Cc: stable +Signed-off-by: Johan Hovold +Link: https://lore.kernel.org/r/20200203153830.26394-2-johan@kernel.org +Signed-off-by: Greg Kroah-Hartman +[sudip: adjust context] +Signed-off-by: Sudip Mukherjee +Signed-off-by: Greg Kroah-Hartman +--- + drivers/usb/core/config.c | 11 +++++++++++ + drivers/usb/core/quirks.c | 32 ++++++++++++++++++++++++++++++++ + drivers/usb/core/usb.h | 3 +++ + include/linux/usb/quirks.h | 3 +++ + 4 files changed, 49 insertions(+) + +--- a/drivers/usb/core/config.c ++++ b/drivers/usb/core/config.c +@@ -251,6 +251,7 @@ static int usb_parse_endpoint(struct dev + struct usb_host_interface *ifp, int num_ep, + unsigned char *buffer, int size) + { ++ struct usb_device *udev = to_usb_device(ddev); + unsigned char *buffer0 = buffer; + struct usb_endpoint_descriptor *d; + struct usb_host_endpoint *endpoint; +@@ -292,6 +293,16 @@ static int usb_parse_endpoint(struct dev + goto skip_to_next_endpoint_or_interface_descriptor; + } + ++ /* Ignore blacklisted endpoints */ ++ if (udev->quirks & USB_QUIRK_ENDPOINT_BLACKLIST) { ++ if (usb_endpoint_is_blacklisted(udev, ifp, d)) { ++ dev_warn(ddev, "config %d interface %d altsetting %d has a blacklisted endpoint with address 0x%X, skipping\n", ++ cfgno, inum, asnum, ++ d->bEndpointAddress); ++ goto skip_to_next_endpoint_or_interface_descriptor; ++ } ++ } ++ + endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints]; + ++ifp->desc.bNumEndpoints; + +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -344,6 +344,38 @@ static const struct usb_device_id usb_am + { } /* terminating entry must be last */ + }; + ++/* ++ * Entries for blacklisted endpoints that should be ignored when parsing ++ * configuration descriptors. ++ * ++ * Matched for devices with USB_QUIRK_ENDPOINT_BLACKLIST. ++ */ ++static const struct usb_device_id usb_endpoint_blacklist[] = { ++ { } ++}; ++ ++bool usb_endpoint_is_blacklisted(struct usb_device *udev, ++ struct usb_host_interface *intf, ++ struct usb_endpoint_descriptor *epd) ++{ ++ const struct usb_device_id *id; ++ unsigned int address; ++ ++ for (id = usb_endpoint_blacklist; id->match_flags; ++id) { ++ if (!usb_match_device(udev, id)) ++ continue; ++ ++ if (!usb_match_one_id_intf(udev, intf, id)) ++ continue; ++ ++ address = id->driver_info; ++ if (address == epd->bEndpointAddress) ++ return true; ++ } ++ ++ return false; ++} ++ + static bool usb_match_any_interface(struct usb_device *udev, + const struct usb_device_id *id) + { +--- a/drivers/usb/core/usb.h ++++ b/drivers/usb/core/usb.h +@@ -31,6 +31,9 @@ extern void usb_deauthorize_interface(st + extern void usb_authorize_interface(struct usb_interface *); + extern void usb_detect_quirks(struct usb_device *udev); + extern void usb_detect_interface_quirks(struct usb_device *udev); ++extern bool usb_endpoint_is_blacklisted(struct usb_device *udev, ++ struct usb_host_interface *intf, ++ struct usb_endpoint_descriptor *epd); + extern int usb_remove_device(struct usb_device *udev); + + extern int usb_get_device_descriptor(struct usb_device *dev, +--- a/include/linux/usb/quirks.h ++++ b/include/linux/usb/quirks.h +@@ -59,4 +59,7 @@ + /* Device needs a pause after every control message. */ + #define USB_QUIRK_DELAY_CTRL_MSG BIT(13) + ++/* device has blacklisted endpoints */ ++#define USB_QUIRK_ENDPOINT_BLACKLIST BIT(15) ++ + #endif /* __LINUX_USB_QUIRKS_H */ diff --git a/queue-4.9/usb-core-fix-regression-in-hercules-audio-card.patch b/queue-4.9/usb-core-fix-regression-in-hercules-audio-card.patch new file mode 100644 index 00000000000..480730586b8 --- /dev/null +++ b/queue-4.9/usb-core-fix-regression-in-hercules-audio-card.patch @@ -0,0 +1,57 @@ +From foo@baz Tue Dec 1 09:30:52 AM CET 2020 +From: Alan Stern +Date: Thu, 19 Nov 2020 12:00:40 -0500 +Subject: USB: core: Fix regression in Hercules audio card + +From: Alan Stern + +commit 184eead057cc7e803558269babc1f2cfb9113ad1 upstream + +Commit 3e4f8e21c4f2 ("USB: core: fix check for duplicate endpoints") +aimed to make the USB stack more reliable by detecting and skipping +over endpoints that are duplicated between interfaces. This caused a +regression for a Hercules audio card (reported as Bugzilla #208357), +which contains such non-compliant duplications. Although the +duplications are harmless, skipping the valid endpoints prevented the +device from working. + +This patch fixes the regression by adding ENDPOINT_IGNORE quirks for +the Hercules card, telling the kernel to ignore the invalid duplicate +endpoints and thereby allowing the valid endpoints to be used as +intended. + +Fixes: 3e4f8e21c4f2 ("USB: core: fix check for duplicate endpoints") +CC: +Reported-by: Alexander Chalikiopoulos +Signed-off-by: Alan Stern +Link: https://lore.kernel.org/r/20201119170040.GA576844@rowland.harvard.edu +Signed-off-by: Greg Kroah-Hartman +[sudip: use usb_endpoint_blacklist and USB_QUIRK_ENDPOINT_BLACKLIST] +Signed-off-by: Sudip Mukherjee +Signed-off-by: Greg Kroah-Hartman +--- + drivers/usb/core/quirks.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -195,6 +195,10 @@ static const struct usb_device_id usb_qu + /* Guillemot Webcam Hercules Dualpix Exchange*/ + { USB_DEVICE(0x06f8, 0x3005), .driver_info = USB_QUIRK_RESET_RESUME }, + ++ /* Guillemot Hercules DJ Console audio card (BZ 208357) */ ++ { USB_DEVICE(0x06f8, 0xb000), .driver_info = ++ USB_QUIRK_ENDPOINT_BLACKLIST }, ++ + /* Midiman M-Audio Keystation 88es */ + { USB_DEVICE(0x0763, 0x0192), .driver_info = USB_QUIRK_RESET_RESUME }, + +@@ -351,6 +355,8 @@ static const struct usb_device_id usb_am + * Matched for devices with USB_QUIRK_ENDPOINT_BLACKLIST. + */ + static const struct usb_device_id usb_endpoint_blacklist[] = { ++ { USB_DEVICE_INTERFACE_NUMBER(0x06f8, 0xb000, 5), .driver_info = 0x01 }, ++ { USB_DEVICE_INTERFACE_NUMBER(0x06f8, 0xb000, 5), .driver_info = 0x81 }, + { } + }; +