usb: core: Add quirk for 255-bytes initial config read

Certain third-party USB game controllers exposing (or spoofing) an Xbox
360-compatible interface (VID:PID 045e:028e) fail to enumerate under Linux.
The device disconnects from the bus without responding to the initial
GET_DESCRIPTOR(CONFIGURATION) request, and the kernel logs 'unable to read
config index 0 descriptor/start: -71'.

The device then falls back to a secondary Android HID mode (with a
different VID:PID), losing XInput functionality including rumble support.
The failure reproduces across multiple machines, host controller types, and
kernel versions including current mainline and LTS. The device enumerates
correctly and remains in XInput mode under Windows. Notably, the device
enumerates correctly in Android mode when the same 9-byte request
is issued for that mode's configuration descriptor, confirming the firmware
bug is specific to the XInput mode.

usbmon traces from Linux and Wireshark/USBPcap traces from Windows are
identical up to the point of failure, with no visible protocol-level
difference explaining the divergence. The root cause was identified when
Michal Pecio discovered via a QEMU bus-level capture that Windows does not
use wLength=9 for the initial config descriptor request; it uses
wLength=255. Alan Stern subsequently confirmed this with a bus
analyzer on a different USB 2.0 device, and Michal verified the behavior
goes back to Windows 95 OSR2.1.

So, add a new quirk flag USB_QUIRK_WINDOWS_CONFIG_REQ_SIZE which causes
usb_get_configuration() to issue a 255 byte sized configuration request
instead of USB_DT_CONFIG_SIZE (9) for the initial
GET_DESCRIPTOR(CONFIGURATION) request, mimicking long-standing Windows
behavior.

This patch intentionally does not add any new VID:PID entries using this
quirk. Some affected Xbox 360-compatible controllers spoof Microsoft's
VID:PID, while genuine Microsoft controllers already enumerate correctly
and do not require this quirk. Other affected clone devices use their own
VID:PID pairs and can be added individually as they are identified.

Suggested-by: Alan Stern <stern@rowland.harvard.edu>
Suggested-by: Michal Pecio <michal.pecio@gmail.com>
Closes: https://lore.kernel.org/linux-usb/CAFgddh+JWdT4LLwMc5qjM8q_pBu-fRo2qADR5ovAKoGHWMQrRw@mail.gmail.com/
Fixes: 1da177e4c3f4 ("Linux-2.6.12-rc2")
Cc: stable <stable@kernel.org>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Nikhil Solanke <nikhilsolanke5@gmail.com>
Link: https://patch.msgid.link/20260728195158.65162-2-nikhilsolanke5@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index b5493a7f8f22812833308b22f2cc35b0a42e55b2..3d35270dddefc519541727bf088df513d444b212 100644 (file)
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -8169,6 +8169,11 @@ Kernel parameters
                                q = USB_QUIRK_FORCE_ONE_CONFIG (Device
                                        claims zero configurations,
                                        forcing to 1);
+                               r = USB_QUIRK_WINDOWS_CONFIG_REQ_SIZE (Device
+                                       fails during initialization when asked for
+                                       9-bytes configuration descriptor request.
+                                       Ask for 255-bytes request instead to mirror
+                                       Windows' behavior);
                        Example: quirks=0781:5580:bk,0a5c:5834:gij
 
        usbhid.mousepoll=

diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 45e20c6d76c04c6ecd9eb366b3f4326d2d777e85..346a2faa9bb862eeb869a9d1026156cb1a8617db 100644 (file)
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -912,6 +912,18 @@ int usb_get_configuration(struct usb_device *dev)
        unsigned char *bigbuffer;
        struct usb_config_descriptor *desc;
        int result;
+       size_t usb_config_req_size;
+
+       /*
+        * We usually start by grabbing the first 9-bytes descriptor so we know
+        * how long the whole configuration is. Some devices with quirky
+        * firmware will fail enumeration, so if the quirk is set, use 255 instead,
+        * mirroring the behavior of Windows.
+        */
+       if (dev->quirks & USB_QUIRK_WINDOWS_CONFIG_REQ_SIZE)
+               usb_config_req_size = 255;
+       else
+               usb_config_req_size = USB_DT_CONFIG_SIZE;
 
        if (ncfg > USB_MAXCONFIG) {
                dev_notice(ddev, "too many configurations: %d, "
@@ -938,15 +950,13 @@ int usb_get_configuration(struct usb_device *dev)
        if (!dev->rawdescriptors)
                return -ENOMEM;
 
-       desc = kmalloc(USB_DT_CONFIG_SIZE, GFP_KERNEL);
+       desc = kmalloc(usb_config_req_size, GFP_KERNEL);
        if (!desc)
                return -ENOMEM;
 
        for (cfgno = 0; cfgno < ncfg; cfgno++) {
-               /* We grab just the first descriptor so we know how long
-                * the whole configuration is */
                result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
-                   desc, USB_DT_CONFIG_SIZE);
+                   desc, usb_config_req_size);
                if (result < 0) {
                        dev_err(ddev, "unable to read config index %d "
                            "descriptor/%s: %d\n", cfgno, "start", result);
@@ -956,16 +966,14 @@ int usb_get_configuration(struct usb_device *dev)
                        dev->descriptor.bNumConfigurations = cfgno;
                        break;
                } else if (result < 4) {
-                       dev_err(ddev, "config index %d descriptor too short "
-                           "(expected %i, got %i)\n", cfgno,
-                           USB_DT_CONFIG_SIZE, result);
+                       dev_err(ddev, "config index %d descriptor too short (asked for %zu, got %i)\n",
+                           cfgno, usb_config_req_size, result);
                        result = -EINVAL;
                        goto err;
                }
                length = max_t(int, le16_to_cpu(desc->wTotalLength),
                    USB_DT_CONFIG_SIZE);
 
-               /* Now that we know the length, get the whole thing */
                bigbuffer = kmalloc(length, GFP_KERNEL);
                if (!bigbuffer) {
                        result = -ENOMEM;
@@ -975,6 +983,13 @@ int usb_get_configuration(struct usb_device *dev)
                if (dev->quirks & USB_QUIRK_DELAY_INIT)
                        msleep(200);
 
+               /* Skip the second read if we already got everything */
+               if (result >= length) {
+                       memcpy(bigbuffer, desc, length);
+                       goto store_and_parse;
+               }
+
+               /* Get the whole thing */
                result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
                    bigbuffer, length);
                if (result < 0) {
@@ -989,6 +1004,7 @@ int usb_get_configuration(struct usb_device *dev)
                        length = result;
                }
 
+store_and_parse:
                dev->rawdescriptors[cfgno] = bigbuffer;
 
                result = usb_parse_configuration(dev, cfgno,

diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 87ee2d938bc0386ce444e1ed9f43898f96330b5b..f5a60ccf21d3d45a22bf638f93a99e4035f09440 100644 (file)
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -142,6 +142,10 @@ static int quirks_param_set(const char *value, const struct kernel_param *kp)
                                break;
                        case 'q':
                                flags |= USB_QUIRK_FORCE_ONE_CONFIG;
+                               break;
+                       case 'r':
+                               flags |= USB_QUIRK_WINDOWS_CONFIG_REQ_SIZE;
+                               break;
                        /* Ignore unrecognized flag characters */
                        }
                }

diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h
index b3cc7beab4a3ceb695d8e404ff2e646545d2c230..a4043b33c2c2a5e80c40f5fa63c78380e9b608d3 100644 (file)
--- a/include/linux/usb/quirks.h
+++ b/include/linux/usb/quirks.h
@@ -81,4 +81,7 @@
 /* Device claims zero configurations, forcing to 1 */
 #define USB_QUIRK_FORCE_ONE_CONFIG             BIT(18)
 
+/* Use a 255 bytes config descriptor request mirroring windows behavior */
+#define USB_QUIRK_WINDOWS_CONFIG_REQ_SIZE      BIT(19)
+
 #endif /* __LINUX_USB_QUIRKS_H */