tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'usb-4.12-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB fixes from Greg KH:
"Here are some small gadget and xhci USB fixes for 4.12-rc6.

Nothing major, but one of the gadget patches does fix a reported oops,
and the xhci ones resolve reported problems. All have been in
linux-next with no reported issues"

* tag 'usb-4.12-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb:
USB: gadgetfs, dummy-hcd, net2280: fix locking for callbacks
usb: xhci: ASMedia ASM1042A chipset need shorts TX quirk
usb: xhci: Fix USB 3.1 supported protocol parsing
USB: gadget: fix GPF in gadgetfs
usb: gadget: composite: make sure to reactivate function on unbind

Linus Torvalds 19ea9d66 1be627df

+24 -28
+5 -6
drivers/usb/gadget/composite.c
··· 315 315 list_del(&f->list); 316 316 if (f->unbind) 317 317 f->unbind(c, f); 318 + 319 + if (f->bind_deactivated) 320 + usb_function_activate(f); 318 321 } 319 322 EXPORT_SYMBOL_GPL(usb_remove_function); 320 323 ··· 959 956 960 957 f = list_first_entry(&config->functions, 961 958 struct usb_function, list); 962 - list_del(&f->list); 963 - if (f->unbind) { 964 - DBG(cdev, "unbind function '%s'/%p\n", f->name, f); 965 - f->unbind(config, f); 966 - /* may free memory for "f" */ 967 - } 959 + 960 + usb_remove_function(config, f); 968 961 } 969 962 list_del(&config->list); 970 963 if (config->unbind) {
+6 -3
drivers/usb/gadget/legacy/inode.c
··· 1183 1183 1184 1184 /* closing ep0 === shutdown all */ 1185 1185 1186 - if (dev->gadget_registered) 1186 + if (dev->gadget_registered) { 1187 1187 usb_gadget_unregister_driver (&gadgetfs_driver); 1188 + dev->gadget_registered = false; 1189 + } 1188 1190 1189 1191 /* at this point "good" hardware has disconnected the 1190 1192 * device from USB; the host won't see it any more. ··· 1679 1677 gadgetfs_suspend (struct usb_gadget *gadget) 1680 1678 { 1681 1679 struct dev_data *dev = get_gadget_data (gadget); 1680 + unsigned long flags; 1682 1681 1683 1682 INFO (dev, "suspended from state %d\n", dev->state); 1684 - spin_lock (&dev->lock); 1683 + spin_lock_irqsave(&dev->lock, flags); 1685 1684 switch (dev->state) { 1686 1685 case STATE_DEV_SETUP: // VERY odd... host died?? 1687 1686 case STATE_DEV_CONNECTED: ··· 1693 1690 default: 1694 1691 break; 1695 1692 } 1696 - spin_unlock (&dev->lock); 1693 + spin_unlock_irqrestore(&dev->lock, flags); 1697 1694 } 1698 1695 1699 1696 static struct usb_gadget_driver gadgetfs_driver = {
+4 -9
drivers/usb/gadget/udc/dummy_hcd.c
··· 442 442 /* Report reset and disconnect events to the driver */ 443 443 if (dum->driver && (disconnect || reset)) { 444 444 stop_activity(dum); 445 - spin_unlock(&dum->lock); 446 445 if (reset) 447 446 usb_gadget_udc_reset(&dum->gadget, dum->driver); 448 447 else 449 448 dum->driver->disconnect(&dum->gadget); 450 - spin_lock(&dum->lock); 451 449 } 452 450 } else if (dum_hcd->active != dum_hcd->old_active) { 453 - if (dum_hcd->old_active && dum->driver->suspend) { 454 - spin_unlock(&dum->lock); 451 + if (dum_hcd->old_active && dum->driver->suspend) 455 452 dum->driver->suspend(&dum->gadget); 456 - spin_lock(&dum->lock); 457 - } else if (!dum_hcd->old_active && dum->driver->resume) { 458 - spin_unlock(&dum->lock); 453 + else if (!dum_hcd->old_active && dum->driver->resume) 459 454 dum->driver->resume(&dum->gadget); 460 - spin_lock(&dum->lock); 461 - } 462 455 } 463 456 464 457 dum_hcd->old_status = dum_hcd->port_status; ··· 976 983 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g); 977 984 struct dummy *dum = dum_hcd->dum; 978 985 986 + spin_lock_irq(&dum->lock); 979 987 dum->driver = NULL; 988 + spin_unlock_irq(&dum->lock); 980 989 981 990 return 0; 982 991 }
+1 -8
drivers/usb/gadget/udc/net2280.c
··· 2470 2470 nuke(&dev->ep[i]); 2471 2471 2472 2472 /* report disconnect; the driver is already quiesced */ 2473 - if (driver) { 2474 - spin_unlock(&dev->lock); 2473 + if (driver) 2475 2474 driver->disconnect(&dev->gadget); 2476 - spin_lock(&dev->lock); 2477 - } 2478 2475 2479 2476 usb_reinit(dev); 2480 2477 } ··· 3345 3348 BIT(PCI_RETRY_ABORT_INTERRUPT)) 3346 3349 3347 3350 static void handle_stat1_irqs(struct net2280 *dev, u32 stat) 3348 - __releases(dev->lock) 3349 - __acquires(dev->lock) 3350 3351 { 3351 3352 struct net2280_ep *ep; 3352 3353 u32 tmp, num, mask, scratch; ··· 3385 3390 if (disconnect || reset) { 3386 3391 stop_activity(dev, dev->driver); 3387 3392 ep0_start(dev); 3388 - spin_unlock(&dev->lock); 3389 3393 if (reset) 3390 3394 usb_gadget_udc_reset 3391 3395 (&dev->gadget, dev->driver); 3392 3396 else 3393 3397 (dev->driver->disconnect) 3394 3398 (&dev->gadget); 3395 - spin_lock(&dev->lock); 3396 3399 return; 3397 3400 } 3398 3401 }
+5 -2
drivers/usb/host/xhci-mem.c
··· 2119 2119 { 2120 2120 u32 temp, port_offset, port_count; 2121 2121 int i; 2122 - u8 major_revision; 2122 + u8 major_revision, minor_revision; 2123 2123 struct xhci_hub *rhub; 2124 2124 2125 2125 temp = readl(addr); 2126 2126 major_revision = XHCI_EXT_PORT_MAJOR(temp); 2127 + minor_revision = XHCI_EXT_PORT_MINOR(temp); 2127 2128 2128 2129 if (major_revision == 0x03) { 2129 2130 rhub = &xhci->usb3_rhub; ··· 2138 2137 return; 2139 2138 } 2140 2139 rhub->maj_rev = XHCI_EXT_PORT_MAJOR(temp); 2141 - rhub->min_rev = XHCI_EXT_PORT_MINOR(temp); 2140 + 2141 + if (rhub->min_rev < minor_revision) 2142 + rhub->min_rev = minor_revision; 2142 2143 2143 2144 /* Port offset and count in the third dword, see section 7.2 */ 2144 2145 temp = readl(addr + 2);
+3
drivers/usb/host/xhci-pci.c
··· 201 201 if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA && 202 202 pdev->device == 0x1042) 203 203 xhci->quirks |= XHCI_BROKEN_STREAMS; 204 + if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA && 205 + pdev->device == 0x1142) 206 + xhci->quirks |= XHCI_TRUST_TX_LENGTH; 204 207 205 208 if (pdev->vendor == PCI_VENDOR_ID_TI && pdev->device == 0x8241) 206 209 xhci->quirks |= XHCI_LIMIT_ENDPOINT_INTERVAL_7;