Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'usb-3.5-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB fixes from Greg Kroah-Hartman:
"Here are a bunch of tiny fixes for the USB core and drivers for
3.5-rc3
A bunch of gadget fixes, and new device ids, as well as some fixes for
a number of different regressions that have been reported recently.
We also fixed some PCI host controllers to resolve a long-standing bug
with a whole class of host controllers that have been plaguing people
for a number of kernel releases, preventing their systems from
suspending properly.
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
* tag 'usb-3.5-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (41 commits)
USB: fix gathering of interface associations
usb: ehci-sh: fix illegal phy_init() running when platform_data is NULL
usb: cdc-acm: fix devices not unthrottled on open
Fix OMAP EHCI suspend/resume failure (i693)
USB: ohci-hub: Mark ohci_finish_controller_resume() as __maybe_unused
usb: use usb_serial_put in usb_serial_probe errors
USB: EHCI: Fix build warning in xilinx ehci driver
USB: fix PS3 EHCI systems
xHCI: Increase the timeout for controller save/restore state operation
xhci: Don't free endpoints in xhci_mem_cleanup()
xhci: Fix invalid loop check in xhci_free_tt_info()
xhci: Fix error path return value.
USB: Checking the wrong variable in usb_disable_lpm()
usb-storage: Add 090c:1000 to unusal-devs
USB: serial-generic: use a single set of device IDs
USB: serial: Enforce USB driver and USB serial driver match
USB: add NO_D3_DURING_SLEEP flag and revert 151b61284776be2
USB: option: add more YUGA device ids
USB: mos7840: Fix compilation of usb serial driver
USB: option: fix memory leak
...
+352
-168
+5
drivers/pci/pci.c
+5
drivers/pci/pci.c
···
1744
1744
if (target_state == PCI_POWER_ERROR)
1745
1745
return -EIO;
1746
1746
1747
+
/* Some devices mustn't be in D3 during system sleep */
1748
+
if (target_state == PCI_D3hot &&
1749
+
(dev->dev_flags & PCI_DEV_FLAGS_NO_D3_DURING_SLEEP))
1750
+
return 0;
1751
+
1747
1752
pci_enable_wake(dev, target_state, device_may_wakeup(&dev->dev));
1748
1753
1749
1754
error = pci_set_power_state(dev, target_state);
+26
drivers/pci/quirks.c
+26
drivers/pci/quirks.c
···
2929
2929
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0102, disable_igfx_irq);
2930
2930
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x010a, disable_igfx_irq);
2931
2931
2932
+
/*
2933
+
* The Intel 6 Series/C200 Series chipset's EHCI controllers on many
2934
+
* ASUS motherboards will cause memory corruption or a system crash
2935
+
* if they are in D3 while the system is put into S3 sleep.
2936
+
*/
2937
+
static void __devinit asus_ehci_no_d3(struct pci_dev *dev)
2938
+
{
2939
+
const char *sys_info;
2940
+
static const char good_Asus_board[] = "P8Z68-V";
2941
+
2942
+
if (dev->dev_flags & PCI_DEV_FLAGS_NO_D3_DURING_SLEEP)
2943
+
return;
2944
+
if (dev->subsystem_vendor != PCI_VENDOR_ID_ASUSTEK)
2945
+
return;
2946
+
sys_info = dmi_get_system_info(DMI_BOARD_NAME);
2947
+
if (sys_info && memcmp(sys_info, good_Asus_board,
2948
+
sizeof(good_Asus_board) - 1) == 0)
2949
+
return;
2950
+
2951
+
dev_info(&dev->dev, "broken D3 during system sleep on ASUS\n");
2952
+
dev->dev_flags |= PCI_DEV_FLAGS_NO_D3_DURING_SLEEP;
2953
+
device_set_wakeup_capable(&dev->dev, false);
2954
+
}
2955
+
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x1c26, asus_ehci_no_d3);
2956
+
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x1c2d, asus_ehci_no_d3);
2957
+
2932
2958
static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f,
2933
2959
struct pci_fixup *end)
2934
2960
{
+8
drivers/usb/class/cdc-acm.c
+8
drivers/usb/class/cdc-acm.c
···
567
567
568
568
usb_autopm_put_interface(acm->control);
569
569
570
+
/*
571
+
* Unthrottle device in case the TTY was closed while throttled.
572
+
*/
573
+
spin_lock_irq(&acm->read_lock);
574
+
acm->throttled = 0;
575
+
acm->throttle_req = 0;
576
+
spin_unlock_irq(&acm->read_lock);
577
+
570
578
if (acm_submit_read_urbs(acm, GFP_KERNEL))
571
579
goto error_submit_read_urbs;
572
580
+9
drivers/usb/class/cdc-wdm.c
+9
drivers/usb/class/cdc-wdm.c
···
55
55
.bInterfaceSubClass = 1,
56
56
.bInterfaceProtocol = 9, /* NOTE: CDC ECM control interface! */
57
57
},
58
+
{
59
+
/* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */
60
+
.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
61
+
USB_DEVICE_ID_MATCH_INT_INFO,
62
+
.idVendor = HUAWEI_VENDOR_ID,
63
+
.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
64
+
.bInterfaceSubClass = 1,
65
+
.bInterfaceProtocol = 57, /* NOTE: CDC ECM control interface! */
66
+
},
58
67
{ }
59
68
};
60
69
-9
drivers/usb/core/hcd-pci.c
-9
drivers/usb/core/hcd-pci.c
···
493
493
494
494
pci_save_state(pci_dev);
495
495
496
-
/*
497
-
* Some systems crash if an EHCI controller is in D3 during
498
-
* a sleep transition. We have to leave such controllers in D0.
499
-
*/
500
-
if (hcd->broken_pci_sleep) {
501
-
dev_dbg(dev, "Staying in PCI D0\n");
502
-
return retval;
503
-
}
504
-
505
496
/* If the root hub is dead rather than suspended, disallow remote
506
497
* wakeup. usb_hc_died() should ensure that both hosts are marked as
507
498
* dying, so we only need to check the primary roothub.
+1
-1
drivers/usb/core/hub.c
+1
-1
drivers/usb/core/hub.c
···
3379
3379
return 0;
3380
3380
3381
3381
udev->lpm_disable_count++;
3382
-
if ((udev->u1_params.timeout == 0 && udev->u1_params.timeout == 0))
3382
+
if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
3383
3383
return 0;
3384
3384
3385
3385
/* If LPM is enabled, attempt to disable it. */
+2
-1
drivers/usb/core/message.c
+2
-1
drivers/usb/core/message.c
···
1838
1838
intfc = cp->intf_cache[i];
1839
1839
intf->altsetting = intfc->altsetting;
1840
1840
intf->num_altsetting = intfc->num_altsetting;
1841
-
intf->intf_assoc = find_iad(dev, cp, i);
1842
1841
kref_get(&intfc->ref);
1843
1842
1844
1843
alt = usb_altnum_to_altsetting(intf, 0);
···
1850
1851
if (!alt)
1851
1852
alt = &intf->altsetting[0];
1852
1853
1854
+
intf->intf_assoc =
1855
+
find_iad(dev, cp, alt->desc.bInterfaceNumber);
1853
1856
intf->cur_altsetting = alt;
1854
1857
usb_enable_interface(dev, intf, true);
1855
1858
intf->dev.parent = &dev->dev;
-6
drivers/usb/gadget/atmel_usba_udc.c
-6
drivers/usb/gadget/atmel_usba_udc.c
···
599
599
600
600
spin_lock_irqsave(&ep->udc->lock, flags);
601
601
602
-
if (ep->ep.desc) {
603
-
spin_unlock_irqrestore(&ep->udc->lock, flags);
604
-
DBG(DBG_ERR, "ep%d already enabled\n", ep->index);
605
-
return -EBUSY;
606
-
}
607
-
608
602
ep->ep.desc = desc;
609
603
ep->ep.maxpacket = maxpacket;
610
604
+1
-1
drivers/usb/gadget/fsl_qe_udc.c
+1
-1
drivers/usb/gadget/fsl_qe_udc.c
···
1596
1596
ep = container_of(_ep, struct qe_ep, ep);
1597
1597
1598
1598
/* catch various bogus parameters */
1599
-
if (!_ep || !desc || ep->ep.desc || _ep->name == ep_name[0] ||
1599
+
if (!_ep || !desc || _ep->name == ep_name[0] ||
1600
1600
(desc->bDescriptorType != USB_DT_ENDPOINT))
1601
1601
return -EINVAL;
1602
1602
+2
-2
drivers/usb/gadget/fsl_udc_core.c
+2
-2
drivers/usb/gadget/fsl_udc_core.c
···
567
567
ep = container_of(_ep, struct fsl_ep, ep);
568
568
569
569
/* catch various bogus parameters */
570
-
if (!_ep || !desc || ep->ep.desc
570
+
if (!_ep || !desc
571
571
|| (desc->bDescriptorType != USB_DT_ENDPOINT))
572
572
return -EINVAL;
573
573
···
2575
2575
/* for ep0: the desc defined here;
2576
2576
* for other eps, gadget layer called ep_enable with defined desc
2577
2577
*/
2578
-
udc_controller->eps[0].desc = &fsl_ep0_desc;
2578
+
udc_controller->eps[0].ep.desc = &fsl_ep0_desc;
2579
2579
udc_controller->eps[0].ep.maxpacket = USB_MAX_CTRL_PAYLOAD;
2580
2580
2581
2581
/* setup the udc->eps[] for non-control endpoints and link
+2
-2
drivers/usb/gadget/fsl_usb2_udc.h
+2
-2
drivers/usb/gadget/fsl_usb2_udc.h
···
568
568
/*
569
569
* ### internal used help routines.
570
570
*/
571
-
#define ep_index(EP) ((EP)->desc->bEndpointAddress&0xF)
571
+
#define ep_index(EP) ((EP)->ep.desc->bEndpointAddress&0xF)
572
572
#define ep_maxpacket(EP) ((EP)->ep.maxpacket)
573
573
#define ep_is_in(EP) ( (ep_index(EP) == 0) ? (EP->udc->ep0_dir == \
574
-
USB_DIR_IN ):((EP)->desc->bEndpointAddress \
574
+
USB_DIR_IN) : ((EP)->ep.desc->bEndpointAddress \
575
575
& USB_DIR_IN)==USB_DIR_IN)
576
576
#define get_ep_by_pipe(udc, pipe) ((pipe == 1)? &udc->eps[0]: \
577
577
&udc->eps[pipe])
+1
-1
drivers/usb/gadget/goku_udc.c
+1
-1
drivers/usb/gadget/goku_udc.c
+1
-1
drivers/usb/gadget/mv_udc_core.c
+1
-1
drivers/usb/gadget/mv_udc_core.c
+1
-1
drivers/usb/gadget/omap_udc.c
+1
-1
drivers/usb/gadget/omap_udc.c
···
153
153
u16 maxp;
154
154
155
155
/* catch various bogus parameters */
156
-
if (!_ep || !desc || ep->ep.desc
156
+
if (!_ep || !desc
157
157
|| desc->bDescriptorType != USB_DT_ENDPOINT
158
158
|| ep->bEndpointAddress != desc->bEndpointAddress
159
159
|| ep->maxpacket < usb_endpoint_maxp(desc)) {
+1
-1
drivers/usb/gadget/pxa25x_udc.c
+1
-1
drivers/usb/gadget/pxa25x_udc.c
···
218
218
struct pxa25x_udc *dev;
219
219
220
220
ep = container_of (_ep, struct pxa25x_ep, ep);
221
-
if (!_ep || !desc || ep->ep.desc || _ep->name == ep0name
221
+
if (!_ep || !desc || _ep->name == ep0name
222
222
|| desc->bDescriptorType != USB_DT_ENDPOINT
223
223
|| ep->bEndpointAddress != desc->bEndpointAddress
224
224
|| ep->fifo_size < usb_endpoint_maxp (desc)) {
+1
-1
drivers/usb/gadget/s3c-hsudc.c
+1
-1
drivers/usb/gadget/s3c-hsudc.c
···
760
760
u32 ecr = 0;
761
761
762
762
hsep = our_ep(_ep);
763
-
if (!_ep || !desc || hsep->ep.desc || _ep->name == ep0name
763
+
if (!_ep || !desc || _ep->name == ep0name
764
764
|| desc->bDescriptorType != USB_DT_ENDPOINT
765
765
|| hsep->bEndpointAddress != desc->bEndpointAddress
766
766
|| ep_maxpacket(hsep) < usb_endpoint_maxp(desc))
+1
-1
drivers/usb/gadget/s3c2410_udc.c
+1
-1
drivers/usb/gadget/s3c2410_udc.c
+2
drivers/usb/host/ehci-hcd.c
+2
drivers/usb/host/ehci-hcd.c
···
671
671
hw = ehci->async->hw;
672
672
hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
673
673
hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
674
+
#if defined(CONFIG_PPC_PS3)
674
675
hw->hw_info1 |= cpu_to_hc32(ehci, (1 << 7)); /* I = 1 */
676
+
#endif
675
677
hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
676
678
hw->hw_qtd_next = EHCI_LIST_END(ehci);
677
679
ehci->async->qh_state = QH_STATE_LINKED;
+167
-1
drivers/usb/host/ehci-omap.c
+167
-1
drivers/usb/host/ehci-omap.c
···
43
43
#include <linux/regulator/consumer.h>
44
44
#include <linux/pm_runtime.h>
45
45
#include <linux/gpio.h>
46
+
#include <linux/clk.h>
46
47
47
48
/* EHCI Register Set */
48
49
#define EHCI_INSNREG04 (0xA0)
···
55
54
#define EHCI_INSNREG05_ULPI_REGADD_SHIFT 16
56
55
#define EHCI_INSNREG05_ULPI_EXTREGADD_SHIFT 8
57
56
#define EHCI_INSNREG05_ULPI_WRDATA_SHIFT 0
57
+
58
+
/* Errata i693 */
59
+
static struct clk *utmi_p1_fck;
60
+
static struct clk *utmi_p2_fck;
61
+
static struct clk *xclk60mhsp1_ck;
62
+
static struct clk *xclk60mhsp2_ck;
63
+
static struct clk *usbhost_p1_fck;
64
+
static struct clk *usbhost_p2_fck;
65
+
static struct clk *init_60m_fclk;
58
66
59
67
/*-------------------------------------------------------------------------*/
60
68
···
78
68
static inline u32 ehci_read(void __iomem *base, u32 reg)
79
69
{
80
70
return __raw_readl(base + reg);
71
+
}
72
+
73
+
/* Erratum i693 workaround sequence */
74
+
static void omap_ehci_erratum_i693(struct ehci_hcd *ehci)
75
+
{
76
+
int ret = 0;
77
+
78
+
/* Switch to the internal 60 MHz clock */
79
+
ret = clk_set_parent(utmi_p1_fck, init_60m_fclk);
80
+
if (ret != 0)
81
+
ehci_err(ehci, "init_60m_fclk set parent"
82
+
"failed error:%d\n", ret);
83
+
84
+
ret = clk_set_parent(utmi_p2_fck, init_60m_fclk);
85
+
if (ret != 0)
86
+
ehci_err(ehci, "init_60m_fclk set parent"
87
+
"failed error:%d\n", ret);
88
+
89
+
clk_enable(usbhost_p1_fck);
90
+
clk_enable(usbhost_p2_fck);
91
+
92
+
/* Wait 1ms and switch back to the external clock */
93
+
mdelay(1);
94
+
ret = clk_set_parent(utmi_p1_fck, xclk60mhsp1_ck);
95
+
if (ret != 0)
96
+
ehci_err(ehci, "xclk60mhsp1_ck set parent"
97
+
"failed error:%d\n", ret);
98
+
99
+
ret = clk_set_parent(utmi_p2_fck, xclk60mhsp2_ck);
100
+
if (ret != 0)
101
+
ehci_err(ehci, "xclk60mhsp2_ck set parent"
102
+
"failed error:%d\n", ret);
103
+
104
+
clk_disable(usbhost_p1_fck);
105
+
clk_disable(usbhost_p2_fck);
81
106
}
82
107
83
108
static void omap_ehci_soft_phy_reset(struct platform_device *pdev, u8 port)
···
143
98
break;
144
99
}
145
100
}
101
+
}
102
+
103
+
static int omap_ehci_hub_control(
104
+
struct usb_hcd *hcd,
105
+
u16 typeReq,
106
+
u16 wValue,
107
+
u16 wIndex,
108
+
char *buf,
109
+
u16 wLength
110
+
)
111
+
{
112
+
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
113
+
u32 __iomem *status_reg = &ehci->regs->port_status[
114
+
(wIndex & 0xff) - 1];
115
+
u32 temp;
116
+
unsigned long flags;
117
+
int retval = 0;
118
+
119
+
spin_lock_irqsave(&ehci->lock, flags);
120
+
121
+
if (typeReq == SetPortFeature && wValue == USB_PORT_FEAT_SUSPEND) {
122
+
temp = ehci_readl(ehci, status_reg);
123
+
if ((temp & PORT_PE) == 0 || (temp & PORT_RESET) != 0) {
124
+
retval = -EPIPE;
125
+
goto done;
126
+
}
127
+
128
+
temp &= ~PORT_WKCONN_E;
129
+
temp |= PORT_WKDISC_E | PORT_WKOC_E;
130
+
ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
131
+
132
+
omap_ehci_erratum_i693(ehci);
133
+
134
+
set_bit((wIndex & 0xff) - 1, &ehci->suspended_ports);
135
+
goto done;
136
+
}
137
+
138
+
spin_unlock_irqrestore(&ehci->lock, flags);
139
+
140
+
/* Handle the hub control events here */
141
+
return ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
142
+
done:
143
+
spin_unlock_irqrestore(&ehci->lock, flags);
144
+
return retval;
146
145
}
147
146
148
147
static void disable_put_regulator(
···
353
264
/* root ports should always stay powered */
354
265
ehci_port_power(omap_ehci, 1);
355
266
267
+
/* get clocks */
268
+
utmi_p1_fck = clk_get(dev, "utmi_p1_gfclk");
269
+
if (IS_ERR(utmi_p1_fck)) {
270
+
ret = PTR_ERR(utmi_p1_fck);
271
+
dev_err(dev, "utmi_p1_gfclk failed error:%d\n", ret);
272
+
goto err_add_hcd;
273
+
}
274
+
275
+
xclk60mhsp1_ck = clk_get(dev, "xclk60mhsp1_ck");
276
+
if (IS_ERR(xclk60mhsp1_ck)) {
277
+
ret = PTR_ERR(xclk60mhsp1_ck);
278
+
dev_err(dev, "xclk60mhsp1_ck failed error:%d\n", ret);
279
+
goto err_utmi_p1_fck;
280
+
}
281
+
282
+
utmi_p2_fck = clk_get(dev, "utmi_p2_gfclk");
283
+
if (IS_ERR(utmi_p2_fck)) {
284
+
ret = PTR_ERR(utmi_p2_fck);
285
+
dev_err(dev, "utmi_p2_gfclk failed error:%d\n", ret);
286
+
goto err_xclk60mhsp1_ck;
287
+
}
288
+
289
+
xclk60mhsp2_ck = clk_get(dev, "xclk60mhsp2_ck");
290
+
if (IS_ERR(xclk60mhsp2_ck)) {
291
+
ret = PTR_ERR(xclk60mhsp2_ck);
292
+
dev_err(dev, "xclk60mhsp2_ck failed error:%d\n", ret);
293
+
goto err_utmi_p2_fck;
294
+
}
295
+
296
+
usbhost_p1_fck = clk_get(dev, "usb_host_hs_utmi_p1_clk");
297
+
if (IS_ERR(usbhost_p1_fck)) {
298
+
ret = PTR_ERR(usbhost_p1_fck);
299
+
dev_err(dev, "usbhost_p1_fck failed error:%d\n", ret);
300
+
goto err_xclk60mhsp2_ck;
301
+
}
302
+
303
+
usbhost_p2_fck = clk_get(dev, "usb_host_hs_utmi_p2_clk");
304
+
if (IS_ERR(usbhost_p2_fck)) {
305
+
ret = PTR_ERR(usbhost_p2_fck);
306
+
dev_err(dev, "usbhost_p2_fck failed error:%d\n", ret);
307
+
goto err_usbhost_p1_fck;
308
+
}
309
+
310
+
init_60m_fclk = clk_get(dev, "init_60m_fclk");
311
+
if (IS_ERR(init_60m_fclk)) {
312
+
ret = PTR_ERR(init_60m_fclk);
313
+
dev_err(dev, "init_60m_fclk failed error:%d\n", ret);
314
+
goto err_usbhost_p2_fck;
315
+
}
316
+
356
317
return 0;
318
+
319
+
err_usbhost_p2_fck:
320
+
clk_put(usbhost_p2_fck);
321
+
322
+
err_usbhost_p1_fck:
323
+
clk_put(usbhost_p1_fck);
324
+
325
+
err_xclk60mhsp2_ck:
326
+
clk_put(xclk60mhsp2_ck);
327
+
328
+
err_utmi_p2_fck:
329
+
clk_put(utmi_p2_fck);
330
+
331
+
err_xclk60mhsp1_ck:
332
+
clk_put(xclk60mhsp1_ck);
333
+
334
+
err_utmi_p1_fck:
335
+
clk_put(utmi_p1_fck);
357
336
358
337
err_add_hcd:
359
338
disable_put_regulator(pdata);
···
451
294
disable_put_regulator(dev->platform_data);
452
295
iounmap(hcd->regs);
453
296
usb_put_hcd(hcd);
297
+
298
+
clk_put(utmi_p1_fck);
299
+
clk_put(utmi_p2_fck);
300
+
clk_put(xclk60mhsp1_ck);
301
+
clk_put(xclk60mhsp2_ck);
302
+
clk_put(usbhost_p1_fck);
303
+
clk_put(usbhost_p2_fck);
304
+
clk_put(init_60m_fclk);
305
+
454
306
pm_runtime_put_sync(dev);
455
307
pm_runtime_disable(dev);
456
308
···
530
364
* root hub support
531
365
*/
532
366
.hub_status_data = ehci_hub_status_data,
533
-
.hub_control = ehci_hub_control,
367
+
.hub_control = omap_ehci_hub_control,
534
368
.bus_suspend = ehci_bus_suspend,
535
369
.bus_resume = ehci_bus_resume,
536
370
-8
drivers/usb/host/ehci-pci.c
-8
drivers/usb/host/ehci-pci.c
···
144
144
hcd->has_tt = 1;
145
145
tdi_reset(ehci);
146
146
}
147
-
if (pdev->subsystem_vendor == PCI_VENDOR_ID_ASUSTEK) {
148
-
/* EHCI #1 or #2 on 6 Series/C200 Series chipset */
149
-
if (pdev->device == 0x1c26 || pdev->device == 0x1c2d) {
150
-
ehci_info(ehci, "broken D3 during system sleep on ASUS\n");
151
-
hcd->broken_pci_sleep = 1;
152
-
device_set_wakeup_capable(&pdev->dev, false);
153
-
}
154
-
}
155
147
break;
156
148
case PCI_VENDOR_ID_TDI:
157
149
if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
+1
-2
drivers/usb/host/ehci-sh.c
+1
-2
drivers/usb/host/ehci-sh.c
+1
-3
drivers/usb/host/ehci-xilinx-of.c
+1
-3
drivers/usb/host/ehci-xilinx-of.c
···
270
270
*
271
271
* Properly shutdown the hcd, call driver's shutdown routine.
272
272
*/
273
-
static int ehci_hcd_xilinx_of_shutdown(struct platform_device *op)
273
+
static void ehci_hcd_xilinx_of_shutdown(struct platform_device *op)
274
274
{
275
275
struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
276
276
277
277
if (hcd->driver->shutdown)
278
278
hcd->driver->shutdown(hcd);
279
-
280
-
return 0;
281
279
}
282
280
283
281
+1
-1
drivers/usb/host/ohci-hub.c
+1
-1
drivers/usb/host/ohci-hub.c
···
317
317
}
318
318
319
319
/* Carry out the final steps of resuming the controller device */
320
-
static void ohci_finish_controller_resume(struct usb_hcd *hcd)
320
+
static void __maybe_unused ohci_finish_controller_resume(struct usb_hcd *hcd)
321
321
{
322
322
struct ohci_hcd *ohci = hcd_to_ohci(hcd);
323
323
int port;
+24
-50
drivers/usb/host/xhci-mem.c
+24
-50
drivers/usb/host/xhci-mem.c
···
793
793
struct xhci_virt_device *virt_dev,
794
794
int slot_id)
795
795
{
796
-
struct list_head *tt;
797
796
struct list_head *tt_list_head;
798
-
struct list_head *tt_next;
799
-
struct xhci_tt_bw_info *tt_info;
797
+
struct xhci_tt_bw_info *tt_info, *next;
798
+
bool slot_found = false;
800
799
801
800
/* If the device never made it past the Set Address stage,
802
801
* it may not have the real_port set correctly.
···
807
808
}
808
809
809
810
tt_list_head = &(xhci->rh_bw[virt_dev->real_port - 1].tts);
810
-
if (list_empty(tt_list_head))
811
-
return;
812
-
813
-
list_for_each(tt, tt_list_head) {
814
-
tt_info = list_entry(tt, struct xhci_tt_bw_info, tt_list);
815
-
if (tt_info->slot_id == slot_id)
811
+
list_for_each_entry_safe(tt_info, next, tt_list_head, tt_list) {
812
+
/* Multi-TT hubs will have more than one entry */
813
+
if (tt_info->slot_id == slot_id) {
814
+
slot_found = true;
815
+
list_del(&tt_info->tt_list);
816
+
kfree(tt_info);
817
+
} else if (slot_found) {
816
818
break;
819
+
}
817
820
}
818
-
/* Cautionary measure in case the hub was disconnected before we
819
-
* stored the TT information.
820
-
*/
821
-
if (tt_info->slot_id != slot_id)
822
-
return;
823
-
824
-
tt_next = tt->next;
825
-
tt_info = list_entry(tt, struct xhci_tt_bw_info,
826
-
tt_list);
827
-
/* Multi-TT hubs will have more than one entry */
828
-
do {
829
-
list_del(tt);
830
-
kfree(tt_info);
831
-
tt = tt_next;
832
-
if (list_empty(tt_list_head))
833
-
break;
834
-
tt_next = tt->next;
835
-
tt_info = list_entry(tt, struct xhci_tt_bw_info,
836
-
tt_list);
837
-
} while (tt_info->slot_id == slot_id);
838
821
}
839
822
840
823
int xhci_alloc_tt_info(struct xhci_hcd *xhci,
···
1772
1791
{
1773
1792
struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
1774
1793
struct dev_info *dev_info, *next;
1775
-
struct list_head *tt_list_head;
1776
-
struct list_head *tt;
1777
-
struct list_head *endpoints;
1778
-
struct list_head *ep, *q;
1779
-
struct xhci_tt_bw_info *tt_info;
1780
-
struct xhci_interval_bw_table *bwt;
1781
-
struct xhci_virt_ep *virt_ep;
1782
-
1783
1794
unsigned long flags;
1784
1795
int size;
1785
-
int i;
1796
+
int i, j, num_ports;
1786
1797
1787
1798
/* Free the Event Ring Segment Table and the actual Event Ring */
1788
1799
size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
···
1833
1860
}
1834
1861
spin_unlock_irqrestore(&xhci->lock, flags);
1835
1862
1836
-
bwt = &xhci->rh_bw->bw_table;
1837
-
for (i = 0; i < XHCI_MAX_INTERVAL; i++) {
1838
-
endpoints = &bwt->interval_bw[i].endpoints;
1839
-
list_for_each_safe(ep, q, endpoints) {
1840
-
virt_ep = list_entry(ep, struct xhci_virt_ep, bw_endpoint_list);
1841
-
list_del(&virt_ep->bw_endpoint_list);
1842
-
kfree(virt_ep);
1863
+
num_ports = HCS_MAX_PORTS(xhci->hcs_params1);
1864
+
for (i = 0; i < num_ports; i++) {
1865
+
struct xhci_interval_bw_table *bwt = &xhci->rh_bw[i].bw_table;
1866
+
for (j = 0; j < XHCI_MAX_INTERVAL; j++) {
1867
+
struct list_head *ep = &bwt->interval_bw[j].endpoints;
1868
+
while (!list_empty(ep))
1869
+
list_del_init(ep->next);
1843
1870
}
1844
1871
}
1845
1872
1846
-
tt_list_head = &xhci->rh_bw->tts;
1847
-
list_for_each_safe(tt, q, tt_list_head) {
1848
-
tt_info = list_entry(tt, struct xhci_tt_bw_info, tt_list);
1849
-
list_del(tt);
1850
-
kfree(tt_info);
1873
+
for (i = 0; i < num_ports; i++) {
1874
+
struct xhci_tt_bw_info *tt, *n;
1875
+
list_for_each_entry_safe(tt, n, &xhci->rh_bw[i].tts, tt_list) {
1876
+
list_del(&tt->tt_list);
1877
+
kfree(tt);
1878
+
}
1851
1879
}
1852
1880
1853
1881
xhci->num_usb2_ports = 0;
+5
-5
drivers/usb/host/xhci.c
+5
-5
drivers/usb/host/xhci.c
···
795
795
command = xhci_readl(xhci, &xhci->op_regs->command);
796
796
command |= CMD_CSS;
797
797
xhci_writel(xhci, command, &xhci->op_regs->command);
798
-
if (handshake(xhci, &xhci->op_regs->status, STS_SAVE, 0, 10*100)) {
799
-
xhci_warn(xhci, "WARN: xHC CMD_CSS timeout\n");
798
+
if (handshake(xhci, &xhci->op_regs->status, STS_SAVE, 0, 10 * 1000)) {
799
+
xhci_warn(xhci, "WARN: xHC save state timeout\n");
800
800
spin_unlock_irq(&xhci->lock);
801
801
return -ETIMEDOUT;
802
802
}
···
848
848
command |= CMD_CRS;
849
849
xhci_writel(xhci, command, &xhci->op_regs->command);
850
850
if (handshake(xhci, &xhci->op_regs->status,
851
-
STS_RESTORE, 0, 10*100)) {
852
-
xhci_dbg(xhci, "WARN: xHC CMD_CSS timeout\n");
851
+
STS_RESTORE, 0, 10 * 1000)) {
852
+
xhci_warn(xhci, "WARN: xHC restore state timeout\n");
853
853
spin_unlock_irq(&xhci->lock);
854
854
return -ETIMEDOUT;
855
855
}
···
3906
3906
default:
3907
3907
dev_warn(&udev->dev, "%s: Can't get timeout for non-U1 or U2 state.\n",
3908
3908
__func__);
3909
-
return -EINVAL;
3909
+
return USB3_LPM_DISABLED;
3910
3910
}
3911
3911
3912
3912
if (sel <= max_sel_pel && pel <= max_sel_pel)
+1
drivers/usb/musb/davinci.c
+1
drivers/usb/musb/davinci.c
+2
-2
drivers/usb/musb/davinci.h
+2
-2
drivers/usb/musb/davinci.h
···
15
15
*/
16
16
17
17
/* Integrated highspeed/otg PHY */
18
-
#define USBPHY_CTL_PADDR (DAVINCI_SYSTEM_MODULE_BASE + 0x34)
18
+
#define USBPHY_CTL_PADDR 0x01c40034
19
19
#define USBPHY_DATAPOL BIT(11) /* (dm355) switch D+/D- */
20
20
#define USBPHY_PHYCLKGD BIT(8)
21
21
#define USBPHY_SESNDEN BIT(7) /* v(sess_end) comparator */
···
27
27
#define USBPHY_OTGPDWN BIT(1)
28
28
#define USBPHY_PHYPDWN BIT(0)
29
29
30
-
#define DM355_DEEPSLEEP_PADDR (DAVINCI_SYSTEM_MODULE_BASE + 0x48)
30
+
#define DM355_DEEPSLEEP_PADDR 0x01c40048
31
31
#define DRVVBUS_FORCE BIT(2)
32
32
#define DRVVBUS_OVERRIDE BIT(1)
33
33
+1
drivers/usb/musb/musb_gadget.c
+1
drivers/usb/musb/musb_gadget.c
+1
drivers/usb/serial/cp210x.c
+1
drivers/usb/serial/cp210x.c
···
82
82
{ USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
83
83
{ USB_DEVICE(0x10C4, 0x806F) }, /* IMS USB to RS422 Converter Cable */
84
84
{ USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
85
+
{ USB_DEVICE(0x10C4, 0x80C4) }, /* Cygnal Integrated Products, Inc., Optris infrared thermometer */
85
86
{ USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
86
87
{ USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */
87
88
{ USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
+1
drivers/usb/serial/ftdi_sio.c
+1
drivers/usb/serial/ftdi_sio.c
···
737
737
{ USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
738
738
{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_SERIAL_VX7_PID) },
739
739
{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_CT29B_PID) },
740
+
{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_RTS01_PID) },
740
741
{ USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
741
742
{ USB_DEVICE(FTDI_VID, FTDI_PHI_FISCO_PID) },
742
743
{ USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
+1
drivers/usb/serial/ftdi_sio_ids.h
+1
drivers/usb/serial/ftdi_sio_ids.h
···
784
784
#define RTSYSTEMS_VID 0x2100 /* Vendor ID */
785
785
#define RTSYSTEMS_SERIAL_VX7_PID 0x9e52 /* Serial converter for VX-7 Radios using FT232RL */
786
786
#define RTSYSTEMS_CT29B_PID 0x9e54 /* CT29B Radio Cable */
787
+
#define RTSYSTEMS_RTS01_PID 0x9e57 /* USB-RTS01 Radio Cable */
787
788
788
789
789
790
/*
+2
-8
drivers/usb/serial/generic.c
+2
-8
drivers/usb/serial/generic.c
···
39
39
40
40
static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
41
41
42
-
/* we want to look at all devices, as the vendor/product id can change
43
-
* depending on the command line argument */
44
-
static const struct usb_device_id generic_serial_ids[] = {
45
-
{.driver_info = 42},
46
-
{}
47
-
};
48
-
49
42
/* All of the device info needed for the Generic Serial Converter */
50
43
struct usb_serial_driver usb_serial_generic_device = {
51
44
.driver = {
···
72
79
USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
73
80
74
81
/* register our generic driver with ourselves */
75
-
retval = usb_serial_register_drivers(serial_drivers, "usbserial_generic", generic_serial_ids);
82
+
retval = usb_serial_register_drivers(serial_drivers,
83
+
"usbserial_generic", generic_device_ids);
76
84
#endif
77
85
return retval;
78
86
}
+8
-5
drivers/usb/serial/mct_u232.c
+8
-5
drivers/usb/serial/mct_u232.c
···
309
309
MCT_U232_SET_REQUEST_TYPE,
310
310
0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
311
311
WDR_TIMEOUT);
312
-
if (rc < 0)
313
-
dev_err(&serial->dev->dev,
314
-
"Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
312
+
kfree(buf);
313
+
315
314
dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
316
315
317
-
kfree(buf);
318
-
return rc;
316
+
if (rc < 0) {
317
+
dev_err(&serial->dev->dev,
318
+
"Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
319
+
return rc;
320
+
}
321
+
return 0;
319
322
} /* mct_u232_set_modem_ctrl */
320
323
321
324
static int mct_u232_get_modem_stat(struct usb_serial *serial,
+1
-1
drivers/usb/serial/mos7840.c
+1
-1
drivers/usb/serial/mos7840.c
···
190
190
191
191
static int device_type;
192
192
193
-
static const struct usb_device_id id_table[] __devinitconst = {
193
+
static const struct usb_device_id id_table[] = {
194
194
{USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)},
195
195
{USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)},
196
196
{USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7810)},
+45
-47
drivers/usb/serial/option.c
+45
-47
drivers/usb/serial/option.c
···
47
47
/* Function prototypes */
48
48
static int option_probe(struct usb_serial *serial,
49
49
const struct usb_device_id *id);
50
+
static void option_release(struct usb_serial *serial);
50
51
static int option_send_setup(struct usb_serial_port *port);
51
52
static void option_instat_callback(struct urb *urb);
52
53
···
151
150
#define HUAWEI_PRODUCT_E14AC 0x14AC
152
151
#define HUAWEI_PRODUCT_K3806 0x14AE
153
152
#define HUAWEI_PRODUCT_K4605 0x14C6
153
+
#define HUAWEI_PRODUCT_K5005 0x14C8
154
154
#define HUAWEI_PRODUCT_K3770 0x14C9
155
155
#define HUAWEI_PRODUCT_K3771 0x14CA
156
156
#define HUAWEI_PRODUCT_K4510 0x14CB
···
427
425
#define SAMSUNG_VENDOR_ID 0x04e8
428
426
#define SAMSUNG_PRODUCT_GT_B3730 0x6889
429
427
430
-
/* YUGA products www.yuga-info.com*/
428
+
/* YUGA products www.yuga-info.com gavin.kx@qq.com */
431
429
#define YUGA_VENDOR_ID 0x257A
432
430
#define YUGA_PRODUCT_CEM600 0x1601
433
431
#define YUGA_PRODUCT_CEM610 0x1602
···
444
442
#define YUGA_PRODUCT_CEU516 0x160C
445
443
#define YUGA_PRODUCT_CEU528 0x160D
446
444
#define YUGA_PRODUCT_CEU526 0x160F
445
+
#define YUGA_PRODUCT_CEU881 0x161F
446
+
#define YUGA_PRODUCT_CEU882 0x162F
447
447
448
448
#define YUGA_PRODUCT_CWM600 0x2601
449
449
#define YUGA_PRODUCT_CWM610 0x2602
···
461
457
#define YUGA_PRODUCT_CWU518 0x260B
462
458
#define YUGA_PRODUCT_CWU516 0x260C
463
459
#define YUGA_PRODUCT_CWU528 0x260D
460
+
#define YUGA_PRODUCT_CWU581 0x260E
464
461
#define YUGA_PRODUCT_CWU526 0x260F
462
+
#define YUGA_PRODUCT_CWU582 0x261F
463
+
#define YUGA_PRODUCT_CWU583 0x262F
465
464
466
-
#define YUGA_PRODUCT_CLM600 0x2601
467
-
#define YUGA_PRODUCT_CLM610 0x2602
468
-
#define YUGA_PRODUCT_CLM500 0x2603
469
-
#define YUGA_PRODUCT_CLM510 0x2604
470
-
#define YUGA_PRODUCT_CLM800 0x2605
471
-
#define YUGA_PRODUCT_CLM900 0x2606
465
+
#define YUGA_PRODUCT_CLM600 0x3601
466
+
#define YUGA_PRODUCT_CLM610 0x3602
467
+
#define YUGA_PRODUCT_CLM500 0x3603
468
+
#define YUGA_PRODUCT_CLM510 0x3604
469
+
#define YUGA_PRODUCT_CLM800 0x3605
470
+
#define YUGA_PRODUCT_CLM900 0x3606
472
471
473
-
#define YUGA_PRODUCT_CLU718 0x2607
474
-
#define YUGA_PRODUCT_CLU716 0x2608
475
-
#define YUGA_PRODUCT_CLU728 0x2609
476
-
#define YUGA_PRODUCT_CLU726 0x260A
477
-
#define YUGA_PRODUCT_CLU518 0x260B
478
-
#define YUGA_PRODUCT_CLU516 0x260C
479
-
#define YUGA_PRODUCT_CLU528 0x260D
480
-
#define YUGA_PRODUCT_CLU526 0x260F
472
+
#define YUGA_PRODUCT_CLU718 0x3607
473
+
#define YUGA_PRODUCT_CLU716 0x3608
474
+
#define YUGA_PRODUCT_CLU728 0x3609
475
+
#define YUGA_PRODUCT_CLU726 0x360A
476
+
#define YUGA_PRODUCT_CLU518 0x360B
477
+
#define YUGA_PRODUCT_CLU516 0x360C
478
+
#define YUGA_PRODUCT_CLU528 0x360D
479
+
#define YUGA_PRODUCT_CLU526 0x360F
481
480
482
481
/* Viettel products */
483
482
#define VIETTEL_VENDOR_ID 0x2262
···
673
666
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3806, 0xff, 0xff, 0xff) },
674
667
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4605, 0xff, 0xff, 0xff),
675
668
.driver_info = (kernel_ulong_t) &huawei_cdc12_blacklist },
669
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4605, 0xff, 0x01, 0x31) },
670
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4605, 0xff, 0x01, 0x32) },
671
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K5005, 0xff, 0x01, 0x31) },
672
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K5005, 0xff, 0x01, 0x32) },
673
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K5005, 0xff, 0x01, 0x33) },
676
674
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x31) },
677
675
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x32) },
678
676
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3771, 0xff, 0x02, 0x31) },
···
1221
1209
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU516) },
1222
1210
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU528) },
1223
1211
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU526) },
1212
+
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU881) },
1213
+
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU882) },
1214
+
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU581) },
1215
+
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU582) },
1216
+
{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU583) },
1224
1217
{ USB_DEVICE_AND_INTERFACE_INFO(VIETTEL_VENDOR_ID, VIETTEL_PRODUCT_VT1000, 0xff, 0xff, 0xff) },
1225
1218
{ USB_DEVICE_AND_INTERFACE_INFO(ZD_VENDOR_ID, ZD_PRODUCT_7000, 0xff, 0xff, 0xff) },
1226
1219
{ USB_DEVICE(LG_VENDOR_ID, LG_PRODUCT_L02C) }, /* docomo L-02C modem */
···
1262
1245
.ioctl = usb_wwan_ioctl,
1263
1246
.attach = usb_wwan_startup,
1264
1247
.disconnect = usb_wwan_disconnect,
1265
-
.release = usb_wwan_release,
1248
+
.release = option_release,
1266
1249
.read_int_callback = option_instat_callback,
1267
1250
#ifdef CONFIG_PM
1268
1251
.suspend = usb_wwan_suspend,
···
1275
1258
};
1276
1259
1277
1260
static bool debug;
1278
-
1279
-
/* per port private data */
1280
-
1281
-
#define N_IN_URB 4
1282
-
#define N_OUT_URB 4
1283
-
#define IN_BUFLEN 4096
1284
-
#define OUT_BUFLEN 4096
1285
-
1286
-
struct option_port_private {
1287
-
/* Input endpoints and buffer for this port */
1288
-
struct urb *in_urbs[N_IN_URB];
1289
-
u8 *in_buffer[N_IN_URB];
1290
-
/* Output endpoints and buffer for this port */
1291
-
struct urb *out_urbs[N_OUT_URB];
1292
-
u8 *out_buffer[N_OUT_URB];
1293
-
unsigned long out_busy; /* Bit vector of URBs in use */
1294
-
int opened;
1295
-
struct usb_anchor delayed;
1296
-
1297
-
/* Settings for the port */
1298
-
int rts_state; /* Handshaking pins (outputs) */
1299
-
int dtr_state;
1300
-
int cts_state; /* Handshaking pins (inputs) */
1301
-
int dsr_state;
1302
-
int dcd_state;
1303
-
int ri_state;
1304
-
1305
-
unsigned long tx_start_time[N_OUT_URB];
1306
-
};
1307
1261
1308
1262
module_usb_serial_driver(serial_drivers, option_ids);
1309
1263
···
1344
1356
return 0;
1345
1357
}
1346
1358
1359
+
static void option_release(struct usb_serial *serial)
1360
+
{
1361
+
struct usb_wwan_intf_private *priv = usb_get_serial_data(serial);
1362
+
1363
+
usb_wwan_release(serial);
1364
+
1365
+
kfree(priv);
1366
+
}
1367
+
1347
1368
static void option_instat_callback(struct urb *urb)
1348
1369
{
1349
1370
int err;
1350
1371
int status = urb->status;
1351
1372
struct usb_serial_port *port = urb->context;
1352
-
struct option_port_private *portdata = usb_get_serial_port_data(port);
1373
+
struct usb_wwan_port_private *portdata =
1374
+
usb_get_serial_port_data(port);
1353
1375
1354
1376
dbg("%s: urb %p port %p has data %p", __func__, urb, port, portdata);
1355
1377
···
1419
1421
struct usb_serial *serial = port->serial;
1420
1422
struct usb_wwan_intf_private *intfdata =
1421
1423
(struct usb_wwan_intf_private *) serial->private;
1422
-
struct option_port_private *portdata;
1424
+
struct usb_wwan_port_private *portdata;
1423
1425
int ifNum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
1424
1426
int val = 0;
1425
1427
+6
drivers/usb/serial/qcserial.c
+6
drivers/usb/serial/qcserial.c
···
105
105
{USB_DEVICE(0x1410, 0xa021)}, /* Novatel Gobi 3000 Composite */
106
106
{USB_DEVICE(0x413c, 0x8193)}, /* Dell Gobi 3000 QDL */
107
107
{USB_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */
108
+
{USB_DEVICE(0x1199, 0x9010)}, /* Sierra Wireless Gobi 3000 QDL */
109
+
{USB_DEVICE(0x1199, 0x9012)}, /* Sierra Wireless Gobi 3000 QDL */
108
110
{USB_DEVICE(0x1199, 0x9013)}, /* Sierra Wireless Gobi 3000 Modem device (MC8355) */
111
+
{USB_DEVICE(0x1199, 0x9014)}, /* Sierra Wireless Gobi 3000 QDL */
112
+
{USB_DEVICE(0x1199, 0x9015)}, /* Sierra Wireless Gobi 3000 Modem device */
113
+
{USB_DEVICE(0x1199, 0x9018)}, /* Sierra Wireless Gobi 3000 QDL */
114
+
{USB_DEVICE(0x1199, 0x9019)}, /* Sierra Wireless Gobi 3000 Modem device */
109
115
{USB_DEVICE(0x12D1, 0x14F0)}, /* Sony Gobi 3000 QDL */
110
116
{USB_DEVICE(0x12D1, 0x14F1)}, /* Sony Gobi 3000 Composite */
111
117
{ } /* Terminating entry */
+4
drivers/usb/serial/sierra.c
+4
drivers/usb/serial/sierra.c
···
294
294
{ USB_DEVICE(0x1199, 0x68A3), /* Sierra Wireless Direct IP modems */
295
295
.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
296
296
},
297
+
/* AT&T Direct IP LTE modems */
298
+
{ USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68AA, 0xFF, 0xFF, 0xFF),
299
+
.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
300
+
},
297
301
{ USB_DEVICE(0x0f3d, 0x68A3), /* Airprime/Sierra Wireless Direct IP modems */
298
302
.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
299
303
},
+7
-5
drivers/usb/serial/usb-serial.c
+7
-5
drivers/usb/serial/usb-serial.c
···
659
659
static struct usb_serial_driver *search_serial_device(
660
660
struct usb_interface *iface)
661
661
{
662
-
const struct usb_device_id *id;
662
+
const struct usb_device_id *id = NULL;
663
663
struct usb_serial_driver *drv;
664
+
struct usb_driver *driver = to_usb_driver(iface->dev.driver);
664
665
665
666
/* Check if the usb id matches a known device */
666
667
list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
667
-
id = get_iface_id(drv, iface);
668
+
if (drv->usb_driver == driver)
669
+
id = get_iface_id(drv, iface);
668
670
if (id)
669
671
return drv;
670
672
}
···
757
755
758
756
if (retval) {
759
757
dbg("sub driver rejected device");
760
-
kfree(serial);
758
+
usb_serial_put(serial);
761
759
module_put(type->driver.owner);
762
760
return retval;
763
761
}
···
829
827
*/
830
828
if (num_bulk_in == 0 || num_bulk_out == 0) {
831
829
dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
832
-
kfree(serial);
830
+
usb_serial_put(serial);
833
831
module_put(type->driver.owner);
834
832
return -ENODEV;
835
833
}
···
843
841
if (num_ports == 0) {
844
842
dev_err(&interface->dev,
845
843
"Generic device with no bulk out, not allowed.\n");
846
-
kfree(serial);
844
+
usb_serial_put(serial);
847
845
module_put(type->driver.owner);
848
846
return -EIO;
849
847
}
+7
drivers/usb/storage/unusual_devs.h
+7
drivers/usb/storage/unusual_devs.h
···
1107
1107
USB_SC_RBC, USB_PR_BULK, NULL,
1108
1108
0 ),
1109
1109
1110
+
/* Feiya QDI U2 DISK, reported by Hans de Goede <hdegoede@redhat.com> */
1111
+
UNUSUAL_DEV( 0x090c, 0x1000, 0x0000, 0xffff,
1112
+
"Feiya",
1113
+
"QDI U2 DISK",
1114
+
USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1115
+
US_FL_NO_READ_CAPACITY_16 ),
1116
+
1110
1117
/* aeb */
1111
1118
UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff,
1112
1119
"Feiya",
+2
include/linux/pci.h
+2
include/linux/pci.h
···
176
176
PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) 2,
177
177
/* Provide indication device is assigned by a Virtual Machine Manager */
178
178
PCI_DEV_FLAGS_ASSIGNED = (__force pci_dev_flags_t) 4,
179
+
/* Device causes system crash if in D3 during S3 sleep */
180
+
PCI_DEV_FLAGS_NO_D3_DURING_SLEEP = (__force pci_dev_flags_t) 8,
179
181
};
180
182
181
183
enum pci_irq_reroute_variant {
-2
include/linux/usb/hcd.h
-2
include/linux/usb/hcd.h
···
126
126
unsigned wireless:1; /* Wireless USB HCD */
127
127
unsigned authorized_default:1;
128
128
unsigned has_tt:1; /* Integrated TT in root hub */
129
-
unsigned broken_pci_sleep:1; /* Don't put the
130
-
controller in PCI-D3 for system sleep */
131
129
132
130
unsigned int irq; /* irq allocated */
133
131
void __iomem *regs; /* device memory/io */