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-3.16-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB bugfixes from Greg KH:
"Here's a round of USB bugfixes, quirk additions, and new device ids
for 3.16-rc4. Nothing major in here at all, just a bunch of tiny
changes. All have been in linux-next with no reported issues"

* tag 'usb-3.16-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (33 commits)
usb: chipidea: udc: delete td from req's td list at ep_dequeue
usb: Kconfig: make EHCI_MSM selectable for QCOM SOCs
usb-storage/SCSI: Add broken_fua blacklist flag
usb: musb: dsps: fix the base address for accessing the mode register
tools: ffs-test: fix header values endianess
usb: phy: msm: Do not do runtime pm if the phy is not idle
usb: musb: Ensure that cppi41 timer gets armed on premature DMA TX irq
usb: gadget: gr_udc: Fix check for invalid number of microframes
usb: musb: Fix panic upon musb_am335x module removal
usb: gadget: f_fs: resurect usb_functionfs_descs_head structure
Revert "tools: ffs-test: convert to new descriptor format fixing compilation error"
xhci: Fix runtime suspended xhci from blocking system suspend.
xhci: clear root port wake on bits if controller isn't wake-up capable
xhci: correct burst count field for isoc transfers on 1.0 xhci hosts
xhci: Use correct SLOT ID when handling a reset device command
MAINTAINERS: update e-mail address
usb: option: add/modify Olivetti Olicard modems
USB: ftdi_sio: fix null deref at port probe
MAINTAINERS: drop two usb-serial subdriver entries
USB: option: add device ID for SpeedUp SU9800 usb 3g modem
...

Linus Torvalds 034a0f6b 9911f2e1

+164 -94
+1 -13
MAINTAINERS
··· 9406 9406 F: drivers/usb/host/isp116x* 9407 9407 F: include/linux/usb/isp116x.h 9408 9408 9409 - USB KAWASAKI LSI DRIVER 9410 - M: Oliver Neukum <oliver@neukum.org> 9411 - L: linux-usb@vger.kernel.org 9412 - S: Maintained 9413 - F: drivers/usb/serial/kl5kusb105.* 9414 - 9415 9409 USB MASS STORAGE DRIVER 9416 9410 M: Matthew Dharm <mdharm-usb@one-eyed-alien.net> 9417 9411 L: linux-usb@vger.kernel.org ··· 9432 9438 S: Maintained 9433 9439 F: Documentation/usb/ohci.txt 9434 9440 F: drivers/usb/host/ohci* 9435 - 9436 - USB OPTION-CARD DRIVER 9437 - M: Matthias Urlichs <smurf@smurf.noris.de> 9438 - L: linux-usb@vger.kernel.org 9439 - S: Maintained 9440 - F: drivers/usb/serial/option.c 9441 9441 9442 9442 USB PEGASUS DRIVER 9443 9443 M: Petko Manolov <petkan@nucleusys.com> ··· 9465 9477 F: drivers/net/usb/rtl8150.c 9466 9478 9467 9479 USB SERIAL SUBSYSTEM 9468 - M: Johan Hovold <jhovold@gmail.com> 9480 + M: Johan Hovold <johan@kernel.org> 9469 9481 L: linux-usb@vger.kernel.org 9470 9482 S: Maintained 9471 9483 F: Documentation/usb/usb-serial.txt
+4 -1
drivers/scsi/sd.c
··· 2441 2441 } 2442 2442 2443 2443 sdkp->DPOFUA = (data.device_specific & 0x10) != 0; 2444 - if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) { 2444 + if (sdp->broken_fua) { 2445 + sd_first_printk(KERN_NOTICE, sdkp, "Disabling FUA\n"); 2446 + sdkp->DPOFUA = 0; 2447 + } else if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) { 2445 2448 sd_first_printk(KERN_NOTICE, sdkp, 2446 2449 "Uses READ/WRITE(6), disabling FUA\n"); 2447 2450 sdkp->DPOFUA = 0;
+7
drivers/usb/chipidea/udc.c
··· 1321 1321 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep); 1322 1322 struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req); 1323 1323 unsigned long flags; 1324 + struct td_node *node, *tmpnode; 1324 1325 1325 1326 if (ep == NULL || req == NULL || hwreq->req.status != -EALREADY || 1326 1327 hwep->ep.desc == NULL || list_empty(&hwreq->queue) || ··· 1331 1330 spin_lock_irqsave(hwep->lock, flags); 1332 1331 1333 1332 hw_ep_flush(hwep->ci, hwep->num, hwep->dir); 1333 + 1334 + list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) { 1335 + dma_pool_free(hwep->td_pool, node->ptr, node->dma); 1336 + list_del(&node->td); 1337 + kfree(node); 1338 + } 1334 1339 1335 1340 /* pop request */ 1336 1341 list_del_init(&hwreq->queue);
+1
drivers/usb/dwc3/Kconfig
··· 45 45 config USB_DWC3_OMAP 46 46 tristate "Texas Instruments OMAP5 and similar Platforms" 47 47 depends on EXTCON && (ARCH_OMAP2PLUS || COMPILE_TEST) 48 + depends on OF 48 49 default USB_DWC3 49 50 help 50 51 Some platforms from Texas Instruments like OMAP5, DRA7xxx and
+14 -3
drivers/usb/dwc3/dwc3-omap.c
··· 322 322 { 323 323 struct platform_device *pdev = to_platform_device(dev); 324 324 325 - platform_device_unregister(pdev); 325 + of_device_unregister(pdev); 326 326 327 327 return 0; 328 328 } ··· 599 599 { 600 600 struct dwc3_omap *omap = dev_get_drvdata(dev); 601 601 602 - dwc3_omap_disable_irqs(omap); 602 + dwc3_omap_write_irqmisc_set(omap, 0x00); 603 603 604 604 return 0; 605 605 } ··· 607 607 static void dwc3_omap_complete(struct device *dev) 608 608 { 609 609 struct dwc3_omap *omap = dev_get_drvdata(dev); 610 + u32 reg; 610 611 611 - dwc3_omap_enable_irqs(omap); 612 + reg = (USBOTGSS_IRQMISC_OEVT | 613 + USBOTGSS_IRQMISC_DRVVBUS_RISE | 614 + USBOTGSS_IRQMISC_CHRGVBUS_RISE | 615 + USBOTGSS_IRQMISC_DISCHRGVBUS_RISE | 616 + USBOTGSS_IRQMISC_IDPULLUP_RISE | 617 + USBOTGSS_IRQMISC_DRVVBUS_FALL | 618 + USBOTGSS_IRQMISC_CHRGVBUS_FALL | 619 + USBOTGSS_IRQMISC_DISCHRGVBUS_FALL | 620 + USBOTGSS_IRQMISC_IDPULLUP_FALL); 621 + 622 + dwc3_omap_write_irqmisc_set(omap, reg); 612 623 } 613 624 614 625 static int dwc3_omap_suspend(struct device *dev)
+4 -4
drivers/usb/dwc3/gadget.c
··· 828 828 length, last ? " last" : "", 829 829 chain ? " chain" : ""); 830 830 831 - /* Skip the LINK-TRB on ISOC */ 832 - if (((dep->free_slot & DWC3_TRB_MASK) == DWC3_TRB_NUM - 1) && 833 - usb_endpoint_xfer_isoc(dep->endpoint.desc)) 834 - dep->free_slot++; 835 831 836 832 trb = &dep->trb_pool[dep->free_slot & DWC3_TRB_MASK]; 837 833 ··· 839 843 } 840 844 841 845 dep->free_slot++; 846 + /* Skip the LINK-TRB on ISOC */ 847 + if (((dep->free_slot & DWC3_TRB_MASK) == DWC3_TRB_NUM - 1) && 848 + usb_endpoint_xfer_isoc(dep->endpoint.desc)) 849 + dep->free_slot++; 842 850 843 851 trb->size = DWC3_TRB_SIZE_LENGTH(length); 844 852 trb->bpl = lower_32_bits(dma);
+19 -18
drivers/usb/gadget/configfs.c
··· 1145 1145 .store_attribute = usb_os_desc_attr_store, 1146 1146 }; 1147 1147 1148 - static ssize_t rndis_grp_compatible_id_show(struct usb_os_desc *desc, 1149 - char *page) 1148 + static ssize_t interf_grp_compatible_id_show(struct usb_os_desc *desc, 1149 + char *page) 1150 1150 { 1151 1151 memcpy(page, desc->ext_compat_id, 8); 1152 1152 return 8; 1153 1153 } 1154 1154 1155 - static ssize_t rndis_grp_compatible_id_store(struct usb_os_desc *desc, 1156 - const char *page, size_t len) 1155 + static ssize_t interf_grp_compatible_id_store(struct usb_os_desc *desc, 1156 + const char *page, size_t len) 1157 1157 { 1158 1158 int l; 1159 1159 ··· 1171 1171 return len; 1172 1172 } 1173 1173 1174 - static struct usb_os_desc_attribute rndis_grp_attr_compatible_id = 1174 + static struct usb_os_desc_attribute interf_grp_attr_compatible_id = 1175 1175 __CONFIGFS_ATTR(compatible_id, S_IRUGO | S_IWUSR, 1176 - rndis_grp_compatible_id_show, 1177 - rndis_grp_compatible_id_store); 1176 + interf_grp_compatible_id_show, 1177 + interf_grp_compatible_id_store); 1178 1178 1179 - static ssize_t rndis_grp_sub_compatible_id_show(struct usb_os_desc *desc, 1180 - char *page) 1179 + static ssize_t interf_grp_sub_compatible_id_show(struct usb_os_desc *desc, 1180 + char *page) 1181 1181 { 1182 1182 memcpy(page, desc->ext_compat_id + 8, 8); 1183 1183 return 8; 1184 1184 } 1185 1185 1186 - static ssize_t rndis_grp_sub_compatible_id_store(struct usb_os_desc *desc, 1187 - const char *page, size_t len) 1186 + static ssize_t interf_grp_sub_compatible_id_store(struct usb_os_desc *desc, 1187 + const char *page, size_t len) 1188 1188 { 1189 1189 int l; 1190 1190 ··· 1202 1202 return len; 1203 1203 } 1204 1204 1205 - static struct usb_os_desc_attribute rndis_grp_attr_sub_compatible_id = 1205 + static struct usb_os_desc_attribute interf_grp_attr_sub_compatible_id = 1206 1206 __CONFIGFS_ATTR(sub_compatible_id, S_IRUGO | S_IWUSR, 1207 - rndis_grp_sub_compatible_id_show, 1208 - rndis_grp_sub_compatible_id_store); 1207 + interf_grp_sub_compatible_id_show, 1208 + interf_grp_sub_compatible_id_store); 1209 1209 1210 1210 static struct configfs_attribute *interf_grp_attrs[] = { 1211 - &rndis_grp_attr_compatible_id.attr, 1212 - &rndis_grp_attr_sub_compatible_id.attr, 1211 + &interf_grp_attr_compatible_id.attr, 1212 + &interf_grp_attr_sub_compatible_id.attr, 1213 1213 NULL 1214 1214 }; 1215 1215 1216 1216 int usb_os_desc_prepare_interf_dir(struct config_group *parent, 1217 1217 int n_interf, 1218 1218 struct usb_os_desc **desc, 1219 + char **names, 1219 1220 struct module *owner) 1220 1221 { 1221 1222 struct config_group **f_default_groups, *os_desc_group, ··· 1258 1257 d = desc[n_interf]; 1259 1258 d->owner = owner; 1260 1259 config_group_init_type_name(&d->group, "", interface_type); 1261 - config_item_set_name(&d->group.cg_item, "interface.%d", 1262 - n_interf); 1260 + config_item_set_name(&d->group.cg_item, "interface.%s", 1261 + names[n_interf]); 1263 1262 interface_groups[n_interf] = &d->group; 1264 1263 } 1265 1264
+1
drivers/usb/gadget/configfs.h
··· 8 8 int usb_os_desc_prepare_interf_dir(struct config_group *parent, 9 9 int n_interf, 10 10 struct usb_os_desc **desc, 11 + char **names, 11 12 struct module *owner); 12 13 13 14 static inline struct usb_os_desc *to_usb_os_desc(struct config_item *item)
+7 -5
drivers/usb/gadget/f_fs.c
··· 1483 1483 ffs->ep0req->context = ffs; 1484 1484 1485 1485 lang = ffs->stringtabs; 1486 - for (lang = ffs->stringtabs; *lang; ++lang) { 1487 - struct usb_string *str = (*lang)->strings; 1488 - int id = first_id; 1489 - for (; str->s; ++id, ++str) 1490 - str->id = id; 1486 + if (lang) { 1487 + for (; *lang; ++lang) { 1488 + struct usb_string *str = (*lang)->strings; 1489 + int id = first_id; 1490 + for (; str->s; ++id, ++str) 1491 + str->id = id; 1492 + } 1491 1493 } 1492 1494 1493 1495 ffs->gadget = cdev->gadget;
+4 -2
drivers/usb/gadget/f_rndis.c
··· 687 687 f->os_desc_table = kzalloc(sizeof(*f->os_desc_table), 688 688 GFP_KERNEL); 689 689 if (!f->os_desc_table) 690 - return PTR_ERR(f->os_desc_table); 690 + return -ENOMEM; 691 691 f->os_desc_n = 1; 692 692 f->os_desc_table[0].os_desc = &rndis_opts->rndis_os_desc; 693 693 } ··· 905 905 { 906 906 struct f_rndis_opts *opts; 907 907 struct usb_os_desc *descs[1]; 908 + char *names[1]; 908 909 909 910 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 910 911 if (!opts) ··· 923 922 INIT_LIST_HEAD(&opts->rndis_os_desc.ext_prop); 924 923 925 924 descs[0] = &opts->rndis_os_desc; 925 + names[0] = "rndis"; 926 926 usb_os_desc_prepare_interf_dir(&opts->func_inst.group, 1, descs, 927 - THIS_MODULE); 927 + names, THIS_MODULE); 928 928 config_group_init_type_name(&opts->func_inst.group, "", 929 929 &rndis_func_type); 930 930
+3 -2
drivers/usb/gadget/gr_udc.c
··· 1532 1532 "%s mode: multiple trans./microframe not valid\n", 1533 1533 (mode == 2 ? "Bulk" : "Control")); 1534 1534 return -EINVAL; 1535 - } else if (nt == 0x11) { 1536 - dev_err(dev->dev, "Invalid value for trans./microframe\n"); 1535 + } else if (nt == 0x3) { 1536 + dev_err(dev->dev, 1537 + "Invalid value 0x3 for additional trans./microframe\n"); 1537 1538 return -EINVAL; 1538 1539 } else if ((nt + 1) * max > buffer_size) { 1539 1540 dev_err(dev->dev, "Hw buffer size %d < max payload %d * %d\n",
+6 -1
drivers/usb/gadget/inode.c
··· 1264 1264 1265 1265 kfree (dev->buf); 1266 1266 dev->buf = NULL; 1267 - put_dev (dev); 1268 1267 1268 + /* other endpoints were all decoupled from this device */ 1269 + spin_lock_irq(&dev->lock); 1270 + dev->state = STATE_DEV_DISABLED; 1271 + spin_unlock_irq(&dev->lock); 1272 + 1273 + put_dev (dev); 1269 1274 return 0; 1270 1275 } 1271 1276
+3
drivers/usb/gadget/u_ether.c
··· 1120 1120 1121 1121 DBG(dev, "%s\n", __func__); 1122 1122 1123 + netif_tx_lock(dev->net); 1123 1124 netif_stop_queue(dev->net); 1125 + netif_tx_unlock(dev->net); 1126 + 1124 1127 netif_carrier_off(dev->net); 1125 1128 1126 1129 /* disable endpoints, forcing (synchronous) completion
+1 -1
drivers/usb/host/Kconfig
··· 176 176 177 177 config USB_EHCI_MSM 178 178 tristate "Support for Qualcomm QSD/MSM on-chip EHCI USB controller" 179 - depends on ARCH_MSM 179 + depends on ARCH_MSM || ARCH_QCOM 180 180 select USB_EHCI_ROOT_HUB_TT 181 181 ---help--- 182 182 Enables support for the USB Host controller present on the
+4 -1
drivers/usb/host/xhci-hub.c
··· 22 22 23 23 24 24 #include <linux/slab.h> 25 + #include <linux/device.h> 25 26 #include <asm/unaligned.h> 26 27 27 28 #include "xhci.h" ··· 1140 1139 * including the USB 3.0 roothub, but only if CONFIG_PM_RUNTIME 1141 1140 * is enabled, so also enable remote wake here. 1142 1141 */ 1143 - if (hcd->self.root_hub->do_remote_wakeup) { 1142 + if (hcd->self.root_hub->do_remote_wakeup 1143 + && device_may_wakeup(hcd->self.controller)) { 1144 + 1144 1145 if (t1 & PORT_CONNECT) { 1145 1146 t2 |= PORT_WKOC_E | PORT_WKDISC_E; 1146 1147 t2 &= ~PORT_WKCONN_E;
+6 -3
drivers/usb/host/xhci-ring.c
··· 1433 1433 xhci_handle_cmd_reset_ep(xhci, slot_id, cmd_trb, cmd_comp_code); 1434 1434 break; 1435 1435 case TRB_RESET_DEV: 1436 - WARN_ON(slot_id != TRB_TO_SLOT_ID( 1437 - le32_to_cpu(cmd_trb->generic.field[3]))); 1436 + /* SLOT_ID field in reset device cmd completion event TRB is 0. 1437 + * Use the SLOT_ID from the command TRB instead (xhci 4.6.11) 1438 + */ 1439 + slot_id = TRB_TO_SLOT_ID( 1440 + le32_to_cpu(cmd_trb->generic.field[3])); 1438 1441 xhci_handle_cmd_reset_dev(xhci, slot_id, event); 1439 1442 break; 1440 1443 case TRB_NEC_GET_FW: ··· 3537 3534 return 0; 3538 3535 3539 3536 max_burst = urb->ep->ss_ep_comp.bMaxBurst; 3540 - return roundup(total_packet_count, max_burst + 1) - 1; 3537 + return DIV_ROUND_UP(total_packet_count, max_burst + 1) - 1; 3541 3538 } 3542 3539 3543 3540 /*
+7 -3
drivers/usb/host/xhci.c
··· 936 936 */ 937 937 int xhci_resume(struct xhci_hcd *xhci, bool hibernated) 938 938 { 939 - u32 command, temp = 0; 939 + u32 command, temp = 0, status; 940 940 struct usb_hcd *hcd = xhci_to_hcd(xhci); 941 941 struct usb_hcd *secondary_hcd; 942 942 int retval = 0; ··· 1054 1054 1055 1055 done: 1056 1056 if (retval == 0) { 1057 - usb_hcd_resume_root_hub(hcd); 1058 - usb_hcd_resume_root_hub(xhci->shared_hcd); 1057 + /* Resume root hubs only when have pending events. */ 1058 + status = readl(&xhci->op_regs->status); 1059 + if (status & STS_EINT) { 1060 + usb_hcd_resume_root_hub(hcd); 1061 + usb_hcd_resume_root_hub(xhci->shared_hcd); 1062 + } 1059 1063 } 1060 1064 1061 1065 /*
+6 -17
drivers/usb/musb/musb_am335x.c
··· 19 19 return ret; 20 20 } 21 21 22 - static int of_remove_populated_child(struct device *dev, void *d) 23 - { 24 - struct platform_device *pdev = to_platform_device(dev); 25 - 26 - of_device_unregister(pdev); 27 - return 0; 28 - } 29 - 30 - static int am335x_child_remove(struct platform_device *pdev) 31 - { 32 - device_for_each_child(&pdev->dev, NULL, of_remove_populated_child); 33 - pm_runtime_disable(&pdev->dev); 34 - return 0; 35 - } 36 - 37 22 static const struct of_device_id am335x_child_of_match[] = { 38 23 { .compatible = "ti,am33xx-usb" }, 39 24 { }, ··· 27 42 28 43 static struct platform_driver am335x_child_driver = { 29 44 .probe = am335x_child_probe, 30 - .remove = am335x_child_remove, 31 45 .driver = { 32 46 .name = "am335x-usb-childs", 33 47 .of_match_table = am335x_child_of_match, 34 48 }, 35 49 }; 36 50 37 - module_platform_driver(am335x_child_driver); 51 + static int __init am335x_child_init(void) 52 + { 53 + return platform_driver_register(&am335x_child_driver); 54 + } 55 + module_init(am335x_child_init); 56 + 38 57 MODULE_DESCRIPTION("AM33xx child devices"); 39 58 MODULE_LICENSE("GPL v2");
+1 -1
drivers/usb/musb/musb_core.c
··· 849 849 } 850 850 851 851 /* handle babble condition */ 852 - if (int_usb & MUSB_INTR_BABBLE) 852 + if (int_usb & MUSB_INTR_BABBLE && is_host_active(musb)) 853 853 schedule_work(&musb->recover_work); 854 854 855 855 #if 0
+1 -1
drivers/usb/musb/musb_cppi41.c
··· 318 318 } 319 319 list_add_tail(&cppi41_channel->tx_check, 320 320 &controller->early_tx_list); 321 - if (!hrtimer_active(&controller->early_tx)) { 321 + if (!hrtimer_is_queued(&controller->early_tx)) { 322 322 hrtimer_start_range_ns(&controller->early_tx, 323 323 ktime_set(0, 140 * NSEC_PER_USEC), 324 324 40 * NSEC_PER_USEC,
+4 -5
drivers/usb/musb/musb_dsps.c
··· 494 494 struct dsps_glue *glue = dev_get_drvdata(dev->parent); 495 495 const struct dsps_musb_wrapper *wrp = glue->wrp; 496 496 void __iomem *ctrl_base = musb->ctrl_base; 497 - void __iomem *base = musb->mregs; 498 497 u32 reg; 499 498 500 - reg = dsps_readl(base, wrp->mode); 499 + reg = dsps_readl(ctrl_base, wrp->mode); 501 500 502 501 switch (mode) { 503 502 case MUSB_HOST: ··· 509 510 */ 510 511 reg |= (1 << wrp->iddig_mux); 511 512 512 - dsps_writel(base, wrp->mode, reg); 513 + dsps_writel(ctrl_base, wrp->mode, reg); 513 514 dsps_writel(ctrl_base, wrp->phy_utmi, 0x02); 514 515 break; 515 516 case MUSB_PERIPHERAL: ··· 522 523 */ 523 524 reg |= (1 << wrp->iddig_mux); 524 525 525 - dsps_writel(base, wrp->mode, reg); 526 + dsps_writel(ctrl_base, wrp->mode, reg); 526 527 break; 527 528 case MUSB_OTG: 528 - dsps_writel(base, wrp->phy_utmi, 0x02); 529 + dsps_writel(ctrl_base, wrp->phy_utmi, 0x02); 529 530 break; 530 531 default: 531 532 dev_err(glue->dev, "unsupported mode %d\n", mode);
-1
drivers/usb/musb/ux500.c
··· 274 274 musb->dev.parent = &pdev->dev; 275 275 musb->dev.dma_mask = &pdev->dev.coherent_dma_mask; 276 276 musb->dev.coherent_dma_mask = pdev->dev.coherent_dma_mask; 277 - musb->dev.of_node = pdev->dev.of_node; 278 277 279 278 glue->dev = &pdev->dev; 280 279 glue->musb = musb;
+3 -1
drivers/usb/phy/phy-msm-usb.c
··· 1229 1229 motg->chg_state = USB_CHG_STATE_UNDEFINED; 1230 1230 motg->chg_type = USB_INVALID_CHARGER; 1231 1231 } 1232 - pm_runtime_put_sync(otg->phy->dev); 1232 + 1233 + if (otg->phy->state == OTG_STATE_B_IDLE) 1234 + pm_runtime_put_sync(otg->phy->dev); 1233 1235 break; 1234 1236 case OTG_STATE_B_PERIPHERAL: 1235 1237 dev_dbg(otg->phy->dev, "OTG_STATE_B_PERIPHERAL state\n");
+8
drivers/usb/renesas_usbhs/fifo.c
··· 681 681 usbhs_pipe_number(pipe), 682 682 pkt->length, pkt->actual, *is_done, pkt->zero); 683 683 684 + /* 685 + * Transmission end 686 + */ 687 + if (*is_done) { 688 + if (usbhs_pipe_is_dcp(pipe)) 689 + usbhs_dcp_control_transfer_done(pipe); 690 + } 691 + 684 692 usbhs_fifo_read_busy: 685 693 usbhsf_fifo_unselect(pipe, fifo); 686 694
+5 -2
drivers/usb/serial/ftdi_sio.c
··· 1566 1566 struct usb_device *udev = serial->dev; 1567 1567 1568 1568 struct usb_interface *interface = serial->interface; 1569 - struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc; 1569 + struct usb_endpoint_descriptor *ep_desc; 1570 1570 1571 1571 unsigned num_endpoints; 1572 - int i; 1572 + unsigned i; 1573 1573 1574 1574 num_endpoints = interface->cur_altsetting->desc.bNumEndpoints; 1575 1575 dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints); 1576 + 1577 + if (!num_endpoints) 1578 + return; 1576 1579 1577 1580 /* NOTE: some customers have programmed FT232R/FT245R devices 1578 1581 * with an endpoint size of 0 - not good. In this case, we
+20 -6
drivers/usb/serial/option.c
··· 352 352 /* Zoom */ 353 353 #define ZOOM_PRODUCT_4597 0x9607 354 354 355 + /* SpeedUp SU9800 usb 3g modem */ 356 + #define SPEEDUP_PRODUCT_SU9800 0x9800 357 + 355 358 /* Haier products */ 356 359 #define HAIER_VENDOR_ID 0x201e 357 360 #define HAIER_PRODUCT_CE100 0x2009 ··· 375 372 /* Olivetti products */ 376 373 #define OLIVETTI_VENDOR_ID 0x0b3c 377 374 #define OLIVETTI_PRODUCT_OLICARD100 0xc000 375 + #define OLIVETTI_PRODUCT_OLICARD120 0xc001 376 + #define OLIVETTI_PRODUCT_OLICARD140 0xc002 378 377 #define OLIVETTI_PRODUCT_OLICARD145 0xc003 378 + #define OLIVETTI_PRODUCT_OLICARD155 0xc004 379 379 #define OLIVETTI_PRODUCT_OLICARD200 0xc005 380 + #define OLIVETTI_PRODUCT_OLICARD160 0xc00a 380 381 #define OLIVETTI_PRODUCT_OLICARD500 0xc00b 381 382 382 383 /* Celot products */ ··· 1584 1577 { USB_DEVICE(LONGCHEER_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14), 1585 1578 .driver_info = (kernel_ulong_t)&four_g_w14_blacklist 1586 1579 }, 1580 + { USB_DEVICE_INTERFACE_CLASS(LONGCHEER_VENDOR_ID, SPEEDUP_PRODUCT_SU9800, 0xff) }, 1587 1581 { USB_DEVICE(LONGCHEER_VENDOR_ID, ZOOM_PRODUCT_4597) }, 1588 1582 { USB_DEVICE(LONGCHEER_VENDOR_ID, IBALL_3_5G_CONNECT) }, 1589 1583 { USB_DEVICE(HAIER_VENDOR_ID, HAIER_PRODUCT_CE100) }, ··· 1619 1611 { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDMNET) }, 1620 1612 { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, /* HC28 enumerates with Siemens or Cinterion VID depending on FW revision */ 1621 1613 { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) }, 1622 - 1623 - { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD100) }, 1614 + { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD100), 1615 + .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, 1616 + { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD120), 1617 + .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, 1618 + { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD140), 1619 + .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, 1624 1620 { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD145) }, 1621 + { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD155), 1622 + .driver_info = (kernel_ulong_t)&net_intf6_blacklist }, 1625 1623 { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD200), 1626 - .driver_info = (kernel_ulong_t)&net_intf6_blacklist 1627 - }, 1624 + .driver_info = (kernel_ulong_t)&net_intf6_blacklist }, 1625 + { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD160), 1626 + .driver_info = (kernel_ulong_t)&net_intf6_blacklist }, 1628 1627 { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD500), 1629 - .driver_info = (kernel_ulong_t)&net_intf4_blacklist 1630 - }, 1628 + .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, 1631 1629 { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */ 1632 1630 { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/ 1633 1631 { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM600) },
+4
drivers/usb/storage/scsiglue.c
··· 256 256 if (us->fflags & US_FL_WRITE_CACHE) 257 257 sdev->wce_default_on = 1; 258 258 259 + /* A few buggy USB-ATA bridges don't understand FUA */ 260 + if (us->fflags & US_FL_BROKEN_FUA) 261 + sdev->broken_fua = 1; 262 + 259 263 } else { 260 264 261 265 /* Non-disk-type devices don't need to blacklist any pages
+7
drivers/usb/storage/unusual_devs.h
··· 1936 1936 USB_SC_DEVICE, USB_PR_DEVICE, NULL, 1937 1937 US_FL_IGNORE_RESIDUE ), 1938 1938 1939 + /* Reported by Michael Büsch <m@bues.ch> */ 1940 + UNUSUAL_DEV( 0x152d, 0x0567, 0x0114, 0x0114, 1941 + "JMicron", 1942 + "USB to ATA/ATAPI Bridge", 1943 + USB_SC_DEVICE, USB_PR_DEVICE, NULL, 1944 + US_FL_BROKEN_FUA ), 1945 + 1939 1946 /* Reported by Alexandre Oliva <oliva@lsd.ic.unicamp.br> 1940 1947 * JMicron responds to USN and several other SCSI ioctls with a 1941 1948 * residue that causes subsequent I/O requests to fail. */
+3 -1
include/linux/usb_usual.h
··· 70 70 US_FLAG(NEEDS_CAP16, 0x00400000) \ 71 71 /* cannot handle READ_CAPACITY_10 */ \ 72 72 US_FLAG(IGNORE_UAS, 0x00800000) \ 73 - /* Device advertises UAS but it is broken */ 73 + /* Device advertises UAS but it is broken */ \ 74 + US_FLAG(BROKEN_FUA, 0x01000000) \ 75 + /* Cannot handle FUA in WRITE or READ CDBs */ \ 74 76 75 77 #define US_FLAG(name, value) US_FL_##name = value , 76 78 enum { US_DO_ALL_FLAGS };
+1
include/scsi/scsi_device.h
··· 173 173 unsigned is_visible:1; /* is the device visible in sysfs */ 174 174 unsigned wce_default_on:1; /* Cache is ON by default */ 175 175 unsigned no_dif:1; /* T10 PI (DIF) should be disabled */ 176 + unsigned broken_fua:1; /* Don't set FUA bit */ 176 177 177 178 atomic_t disk_events_disable_depth; /* disable depth for disk events */ 178 179
+7
include/uapi/linux/usb/functionfs.h
··· 33 33 __u8 bInterval; 34 34 } __attribute__((packed)); 35 35 36 + /* Legacy format, deprecated as of 3.14. */ 37 + struct usb_functionfs_descs_head { 38 + __le32 magic; 39 + __le32 length; 40 + __le32 fs_count; 41 + __le32 hs_count; 42 + } __attribute__((packed, deprecated)); 36 43 37 44 /* 38 45 * Descriptors format:
+2 -2
tools/usb/ffs-test.c
··· 116 116 .header = { 117 117 .magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC), 118 118 .length = cpu_to_le32(sizeof descriptors), 119 - .fs_count = 3, 120 - .hs_count = 3, 119 + .fs_count = cpu_to_le32(3), 120 + .hs_count = cpu_to_le32(3), 121 121 }, 122 122 .fs_descs = { 123 123 .intf = {