Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'usb-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6
* 'usb-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (30 commits)
USB: Serial: Add PID(0xF7C0) to FTDI SIO driver for a zeitcontrol-device
USB: Serial: Add device ID for Sierra Wireless MC8305
USB: Serial: Added device ID for Qualcomm Modem in Sagemcom's HiLo3G
usb/host/pci-quirks.c: correct annotation of `ehci_dmi_nohandoff_table'
USB: option driver: add PID for Vodafone-Huawei K4511
USB: option driver: add PID for Vodafone-Huawei K4510
USB: option driver: add PID for Vodafone-Huawei K3771
USB: option driver: add PID for Vodafone-Huawei K3770
usb: serial: ftdi_sio.c: For the FT232H FTDI_SIO_SET_BAUDRATE_REQUEST, index needs to be shifted too
usb/isp1760: Added missing call to usb_hcd_check_unlink_urb() during unlink
USB: EHCI: Fix test mode sequence
USB: ftdi_sio: fix minor typo in get_ftdi_divisor
USB: at91_udc: include linux/prefetch.h explicitly
USB: usb-storage: unusual_devs entry for ARM V2M motherboard.
usb/ehci-mxc: add missing inclusion of mach/hardware.h
USB: assign instead of equal in usbtmc.c
usb: renesas_usbhs: fixup usbhsg_for_each_uep 1st pos
usb: renesas_usbhs: fix DMA build by including dma-mapping.h
usb: gadget: net2272 - Correct includes
usb: musb: fix oops on musb_gadget_pullup
...
+113
-126
+1
-1
drivers/usb/class/usbtmc.c
+1
-1
drivers/usb/class/usbtmc.c
+6
-5
drivers/usb/core/config.c
+6
-5
drivers/usb/core/config.c
···
123
123
}
124
124
125
125
if (usb_endpoint_xfer_isoc(&ep->desc))
126
-
max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1) *
127
-
(desc->bmAttributes + 1);
126
+
max_tx = (desc->bMaxBurst + 1) * (desc->bmAttributes + 1) *
127
+
le16_to_cpu(ep->desc.wMaxPacketSize);
128
128
else if (usb_endpoint_xfer_int(&ep->desc))
129
-
max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1);
129
+
max_tx = le16_to_cpu(ep->desc.wMaxPacketSize) *
130
+
(desc->bMaxBurst + 1);
130
131
else
131
132
max_tx = 999999;
132
133
if (le16_to_cpu(desc->wBytesPerInterval) > max_tx) {
···
135
134
"config %d interface %d altsetting %d ep %d: "
136
135
"setting to %d\n",
137
136
usb_endpoint_xfer_isoc(&ep->desc) ? "Isoc" : "Int",
138
-
desc->wBytesPerInterval,
137
+
le16_to_cpu(desc->wBytesPerInterval),
139
138
cfgno, inum, asnum, ep->desc.bEndpointAddress,
140
139
max_tx);
141
-
ep->ss_ep_comp.wBytesPerInterval = max_tx;
140
+
ep->ss_ep_comp.wBytesPerInterval = cpu_to_le16(max_tx);
142
141
}
143
142
}
144
143
+1
-1
drivers/usb/gadget/Kconfig
+1
-1
drivers/usb/gadget/Kconfig
···
310
310
# musb builds in ../musb along with host support
311
311
config USB_GADGET_MUSB_HDRC
312
312
tristate "Inventra HDRC USB Peripheral (TI, ADI, ...)"
313
-
depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
313
+
depends on USB_MUSB_HDRC
314
314
select USB_GADGET_DUALSPEED
315
315
help
316
316
This OTG-capable silicon IP is used in dual designs including
+1
drivers/usb/gadget/at91_udc.c
+1
drivers/usb/gadget/at91_udc.c
+4
-2
drivers/usb/gadget/composite.c
+4
-2
drivers/usb/gadget/composite.c
···
1079
1079
cdev->desc.bMaxPacketSize0 =
1080
1080
cdev->gadget->ep0->maxpacket;
1081
1081
if (gadget_is_superspeed(gadget)) {
1082
-
if (gadget->speed >= USB_SPEED_SUPER)
1082
+
if (gadget->speed >= USB_SPEED_SUPER) {
1083
1083
cdev->desc.bcdUSB = cpu_to_le16(0x0300);
1084
-
else
1084
+
cdev->desc.bMaxPacketSize0 = 9;
1085
+
} else {
1085
1086
cdev->desc.bcdUSB = cpu_to_le16(0x0210);
1087
+
}
1086
1088
}
1087
1089
1088
1090
value = min(w_length, (u16) sizeof cdev->desc);
+7
drivers/usb/gadget/f_hid.c
+7
drivers/usb/gadget/f_hid.c
···
367
367
case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8
368
368
| USB_REQ_GET_DESCRIPTOR):
369
369
switch (value >> 8) {
370
+
case HID_DT_HID:
371
+
VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: HID\n");
372
+
length = min_t(unsigned short, length,
373
+
hidg_desc.bLength);
374
+
memcpy(req->buf, &hidg_desc, length);
375
+
goto respond;
376
+
break;
370
377
case HID_DT_REPORT:
371
378
VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");
372
379
length = min_t(unsigned short, length,
-101
drivers/usb/gadget/fusb300_udc.c
-101
drivers/usb/gadget/fusb300_udc.c
···
609
609
}
610
610
}
611
611
612
-
#if 0
613
-
static void fusb300_dbg_fifo(struct fusb300_ep *ep,
614
-
u8 entry, u16 length)
615
-
{
616
-
u32 reg;
617
-
u32 i = 0;
618
-
u32 j = 0;
619
-
620
-
reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
621
-
reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
622
-
FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
623
-
reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
624
-
FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
625
-
iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
626
-
627
-
for (i = 0; i < (length >> 2); i++) {
628
-
if (i * 4 == 1024)
629
-
break;
630
-
reg = ioread32(ep->fusb300->reg +
631
-
FUSB300_OFFSET_BUFDBG_START + i * 4);
632
-
printk(KERN_DEBUG" 0x%-8x", reg);
633
-
j++;
634
-
if ((j % 4) == 0)
635
-
printk(KERN_DEBUG "\n");
636
-
}
637
-
638
-
if (length % 4) {
639
-
reg = ioread32(ep->fusb300->reg +
640
-
FUSB300_OFFSET_BUFDBG_START + i * 4);
641
-
printk(KERN_DEBUG " 0x%x\n", reg);
642
-
}
643
-
644
-
if ((j % 4) != 0)
645
-
printk(KERN_DEBUG "\n");
646
-
647
-
fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
648
-
FUSB300_GTM_TST_FIFO_DEG);
649
-
}
650
-
651
-
static void fusb300_cmp_dbg_fifo(struct fusb300_ep *ep,
652
-
u8 entry, u16 length, u8 *golden)
653
-
{
654
-
u32 reg;
655
-
u32 i = 0;
656
-
u32 golden_value;
657
-
u8 *tmp;
658
-
659
-
tmp = golden;
660
-
661
-
printk(KERN_DEBUG "fusb300_cmp_dbg_fifo (entry %d) : start\n", entry);
662
-
663
-
reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
664
-
reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
665
-
FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
666
-
reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
667
-
FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
668
-
iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
669
-
670
-
for (i = 0; i < (length >> 2); i++) {
671
-
if (i * 4 == 1024)
672
-
break;
673
-
golden_value = *tmp | *(tmp + 1) << 8 |
674
-
*(tmp + 2) << 16 | *(tmp + 3) << 24;
675
-
676
-
reg = ioread32(ep->fusb300->reg +
677
-
FUSB300_OFFSET_BUFDBG_START + i*4);
678
-
679
-
if (reg != golden_value) {
680
-
printk(KERN_DEBUG "0x%x : ", (u32)(ep->fusb300->reg +
681
-
FUSB300_OFFSET_BUFDBG_START + i*4));
682
-
printk(KERN_DEBUG " golden = 0x%x, reg = 0x%x\n",
683
-
golden_value, reg);
684
-
}
685
-
tmp += 4;
686
-
}
687
-
688
-
switch (length % 4) {
689
-
case 1:
690
-
golden_value = *tmp;
691
-
case 2:
692
-
golden_value = *tmp | *(tmp + 1) << 8;
693
-
case 3:
694
-
golden_value = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16;
695
-
default:
696
-
break;
697
-
698
-
reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_BUFDBG_START + i*4);
699
-
if (reg != golden_value) {
700
-
printk(KERN_DEBUG "0x%x:", (u32)(ep->fusb300->reg +
701
-
FUSB300_OFFSET_BUFDBG_START + i*4));
702
-
printk(KERN_DEBUG " golden = 0x%x, reg = 0x%x\n",
703
-
golden_value, reg);
704
-
}
705
-
}
706
-
707
-
printk(KERN_DEBUG "fusb300_cmp_dbg_fifo : end\n");
708
-
fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
709
-
FUSB300_GTM_TST_FIFO_DEG);
710
-
}
711
-
#endif
712
-
713
612
static void fusb300_rdfifo(struct fusb300_ep *ep,
714
613
struct fusb300_request *req,
715
614
u32 length)
+1
-1
drivers/usb/gadget/net2272.c
+1
-1
drivers/usb/gadget/net2272.c
···
27
27
#include <linux/interrupt.h>
28
28
#include <linux/io.h>
29
29
#include <linux/ioport.h>
30
-
#include <linux/irq.h>
31
30
#include <linux/kernel.h>
32
31
#include <linux/list.h>
33
32
#include <linux/module.h>
34
33
#include <linux/moduleparam.h>
35
34
#include <linux/pci.h>
36
35
#include <linux/platform_device.h>
36
+
#include <linux/prefetch.h>
37
37
#include <linux/sched.h>
38
38
#include <linux/slab.h>
39
39
#include <linux/timer.h>
+1
drivers/usb/gadget/s3c2410_udc.c
+1
drivers/usb/gadget/s3c2410_udc.c
+12
drivers/usb/host/ehci-hub.c
+12
drivers/usb/host/ehci-hub.c
···
1046
1046
if (!selector || selector > 5)
1047
1047
goto error;
1048
1048
ehci_quiesce(ehci);
1049
+
1050
+
/* Put all enabled ports into suspend */
1051
+
while (ports--) {
1052
+
u32 __iomem *sreg =
1053
+
&ehci->regs->port_status[ports];
1054
+
1055
+
temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
1056
+
if (temp & PORT_PE)
1057
+
ehci_writel(ehci, temp | PORT_SUSPEND,
1058
+
sreg);
1059
+
}
1049
1060
ehci_halt(ehci);
1061
+
temp = ehci_readl(ehci, status_reg);
1050
1062
temp |= selector << 16;
1051
1063
ehci_writel(ehci, temp, status_reg);
1052
1064
break;
+1
drivers/usb/host/ehci-mxc.c
+1
drivers/usb/host/ehci-mxc.c
+16
drivers/usb/host/ehci-omap.c
+16
drivers/usb/host/ehci-omap.c
···
98
98
}
99
99
}
100
100
101
+
static void disable_put_regulator(
102
+
struct ehci_hcd_omap_platform_data *pdata)
103
+
{
104
+
int i;
105
+
106
+
for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
107
+
if (pdata->regulator[i]) {
108
+
regulator_disable(pdata->regulator[i]);
109
+
regulator_put(pdata->regulator[i]);
110
+
}
111
+
}
112
+
}
101
113
102
114
/* configure so an HC device and id are always provided */
103
115
/* always called with process context; sleeping is OK */
···
243
231
omap_usbhs_disable(dev);
244
232
245
233
err_enable:
234
+
disable_put_regulator(pdata);
246
235
usb_put_hcd(hcd);
247
236
248
237
err_io:
238
+
iounmap(regs);
249
239
return ret;
250
240
}
251
241
···
267
253
268
254
usb_remove_hcd(hcd);
269
255
omap_usbhs_disable(dev);
256
+
disable_put_regulator(dev->platform_data);
257
+
iounmap(hcd->regs);
270
258
usb_put_hcd(hcd);
271
259
return 0;
272
260
}
+3
drivers/usb/host/isp1760-hcd.c
+3
drivers/usb/host/isp1760-hcd.c
+2
-2
drivers/usb/host/pci-quirks.c
+2
-2
drivers/usb/host/pci-quirks.c
···
535
535
iounmap(base);
536
536
}
537
537
538
-
static const struct dmi_system_id __initconst ehci_dmi_nohandoff_table[] = {
538
+
static const struct dmi_system_id __devinitconst ehci_dmi_nohandoff_table[] = {
539
539
{
540
540
/* Pegatron Lucid (ExoPC) */
541
541
.matches = {
···
817
817
818
818
/* If the BIOS owns the HC, signal that the OS wants it, and wait */
819
819
if (val & XHCI_HC_BIOS_OWNED) {
820
-
writel(val & XHCI_HC_OS_OWNED, base + ext_cap_offset);
820
+
writel(val | XHCI_HC_OS_OWNED, base + ext_cap_offset);
821
821
822
822
/* Wait for 5 seconds with 10 microsecond polling interval */
823
823
timeout = handshake(base + ext_cap_offset, XHCI_HC_BIOS_OWNED,
+14
-5
drivers/usb/host/xhci.c
+14
-5
drivers/usb/host/xhci.c
···
345
345
spin_lock_irqsave(&xhci->lock, flags);
346
346
temp = xhci_readl(xhci, &xhci->op_regs->status);
347
347
xhci_dbg(xhci, "op reg status = 0x%x\n", temp);
348
-
if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
348
+
if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
349
+
(xhci->xhc_state & XHCI_STATE_HALTED)) {
349
350
xhci_dbg(xhci, "HW died, polling stopped.\n");
350
351
spin_unlock_irqrestore(&xhci->lock, flags);
351
352
return;
···
940
939
return 0;
941
940
}
942
941
942
+
xhci = hcd_to_xhci(hcd);
943
+
if (xhci->xhc_state & XHCI_STATE_HALTED)
944
+
return -ENODEV;
945
+
943
946
if (check_virt_dev) {
944
-
xhci = hcd_to_xhci(hcd);
945
947
if (!udev->slot_id || !xhci->devs
946
948
|| !xhci->devs[udev->slot_id]) {
947
949
printk(KERN_DEBUG "xHCI %s called with unaddressed "
···
1246
1242
xhci_urb_free_priv(xhci, urb_priv);
1247
1243
return ret;
1248
1244
}
1249
-
if (xhci->xhc_state & XHCI_STATE_DYING) {
1245
+
if ((xhci->xhc_state & XHCI_STATE_DYING) ||
1246
+
(xhci->xhc_state & XHCI_STATE_HALTED)) {
1250
1247
xhci_dbg(xhci, "Ep 0x%x: URB %p to be canceled on "
1251
1248
"non-responsive xHCI host.\n",
1252
1249
urb->ep->desc.bEndpointAddress, urb);
···
2670
2665
int i, ret;
2671
2666
2672
2667
ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
2673
-
if (ret <= 0)
2668
+
/* If the host is halted due to driver unload, we still need to free the
2669
+
* device.
2670
+
*/
2671
+
if (ret <= 0 && ret != -ENODEV)
2674
2672
return;
2675
2673
2676
2674
virt_dev = xhci->devs[udev->slot_id];
···
2687
2679
spin_lock_irqsave(&xhci->lock, flags);
2688
2680
/* Don't disable the slot if the host controller is dead. */
2689
2681
state = xhci_readl(xhci, &xhci->op_regs->status);
2690
-
if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
2682
+
if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
2683
+
(xhci->xhc_state & XHCI_STATE_HALTED)) {
2691
2684
xhci_free_virt_device(xhci, udev->slot_id);
2692
2685
spin_unlock_irqrestore(&xhci->lock, flags);
2693
2686
return;
-3
drivers/usb/musb/Kconfig
-3
drivers/usb/musb/Kconfig
···
3
3
# for silicon based on Mentor Graphics INVENTRA designs
4
4
#
5
5
6
-
comment "Enable Host or Gadget support to see Inventra options"
7
-
depends on !USB && USB_GADGET=n
8
-
9
6
# (M)HDRC = (Multipoint) Highspeed Dual-Role Controller
10
7
config USB_MUSB_HDRC
11
8
depends on USB && USB_GADGET
+5
drivers/usb/musb/musb_gadget.c
+5
drivers/usb/musb/musb_gadget.c
···
1698
1698
1699
1699
is_on = !!is_on;
1700
1700
1701
+
pm_runtime_get_sync(musb->controller);
1702
+
1701
1703
/* NOTE: this assumes we are sensing vbus; we'd rather
1702
1704
* not pullup unless the B-session is active.
1703
1705
*/
···
1709
1707
musb_pullup(musb, is_on);
1710
1708
}
1711
1709
spin_unlock_irqrestore(&musb->lock, flags);
1710
+
1711
+
pm_runtime_put(musb->controller);
1712
+
1712
1713
return 0;
1713
1714
}
1714
1715
+1
-1
drivers/usb/musb/tusb6010_omap.c
+1
-1
drivers/usb/musb/tusb6010_omap.c
+2
-1
drivers/usb/renesas_usbhs/mod_gadget.c
+2
-1
drivers/usb/renesas_usbhs/mod_gadget.c
···
14
14
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
15
15
*
16
16
*/
17
+
#include <linux/dma-mapping.h>
17
18
#include <linux/io.h>
18
19
#include <linux/module.h>
19
20
#include <linux/platform_device.h>
···
77
76
struct usbhsg_gpriv, mod)
78
77
79
78
#define __usbhsg_for_each_uep(start, pos, g, i) \
80
-
for (i = start, pos = (g)->uep; \
79
+
for (i = start, pos = (g)->uep + i; \
81
80
i < (g)->uep_size; \
82
81
i++, pos = (g)->uep + i)
83
82
+6
-2
drivers/usb/serial/ftdi_sio.c
+6
-2
drivers/usb/serial/ftdi_sio.c
···
151
151
* /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
152
152
*/
153
153
static struct usb_device_id id_table_combined [] = {
154
+
{ USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
154
155
{ USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
155
156
{ USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
156
157
{ USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
···
1172
1171
case FT2232H: /* FT2232H chip */
1173
1172
case FT4232H: /* FT4232H chip */
1174
1173
case FT232H: /* FT232H chip */
1175
-
if ((baud <= 12000000) & (baud >= 1200)) {
1174
+
if ((baud <= 12000000) && (baud >= 1200)) {
1176
1175
div_value = ftdi_2232h_baud_to_divisor(baud);
1177
1176
} else if (baud < 1200) {
1178
1177
div_value = ftdi_232bm_baud_to_divisor(baud);
···
1206
1205
urb_index_value = get_ftdi_divisor(tty, port);
1207
1206
urb_value = (__u16)urb_index_value;
1208
1207
urb_index = (__u16)(urb_index_value >> 16);
1209
-
if (priv->interface) { /* FT2232C */
1208
+
if ((priv->chip_type == FT2232C) || (priv->chip_type == FT2232H) ||
1209
+
(priv->chip_type == FT4232H) || (priv->chip_type == FT232H)) {
1210
+
/* Probably the BM type needs the MSB of the encoded fractional
1211
+
* divider also moved like for the chips above. Any infos? */
1210
1212
urb_index = (__u16)((urb_index << 8) | priv->interface);
1211
1213
}
1212
1214
+5
-1
drivers/usb/serial/ftdi_sio_ids.h
+5
-1
drivers/usb/serial/ftdi_sio_ids.h
+12
drivers/usb/serial/option.c
+12
drivers/usb/serial/option.c
···
148
148
#define HUAWEI_PRODUCT_K4505 0x1464
149
149
#define HUAWEI_PRODUCT_K3765 0x1465
150
150
#define HUAWEI_PRODUCT_E14AC 0x14AC
151
+
#define HUAWEI_PRODUCT_K3770 0x14C9
152
+
#define HUAWEI_PRODUCT_K3771 0x14CA
153
+
#define HUAWEI_PRODUCT_K4510 0x14CB
154
+
#define HUAWEI_PRODUCT_K4511 0x14CC
151
155
#define HUAWEI_PRODUCT_ETS1220 0x1803
152
156
#define HUAWEI_PRODUCT_E353 0x1506
153
157
···
551
547
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3765, 0xff, 0xff, 0xff) },
552
548
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_ETS1220, 0xff, 0xff, 0xff) },
553
549
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E14AC, 0xff, 0xff, 0xff) },
550
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x31) },
551
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x32) },
552
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3771, 0xff, 0x02, 0x31) },
553
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3771, 0xff, 0x02, 0x32) },
554
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4510, 0xff, 0x01, 0x31) },
555
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4510, 0xff, 0x01, 0x32) },
556
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4511, 0xff, 0x01, 0x31) },
557
+
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4511, 0xff, 0x01, 0x32) },
554
558
{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x01) },
555
559
{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
556
560
{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
+2
drivers/usb/serial/qcserial.c
+2
drivers/usb/serial/qcserial.c
···
45
45
{USB_DEVICE(0x05c6, 0x9203)}, /* Generic Gobi Modem device */
46
46
{USB_DEVICE(0x05c6, 0x9222)}, /* Generic Gobi Modem device */
47
47
{USB_DEVICE(0x05c6, 0x9008)}, /* Generic Gobi QDL device */
48
+
{USB_DEVICE(0x05c6, 0x9009)}, /* Generic Gobi Modem device */
48
49
{USB_DEVICE(0x05c6, 0x9201)}, /* Generic Gobi QDL device */
49
50
{USB_DEVICE(0x05c6, 0x9221)}, /* Generic Gobi QDL device */
50
51
{USB_DEVICE(0x05c6, 0x9231)}, /* Generic Gobi QDL device */
···
79
78
{USB_DEVICE(0x1199, 0x9008)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
80
79
{USB_DEVICE(0x1199, 0x9009)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
81
80
{USB_DEVICE(0x1199, 0x900a)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
81
+
{USB_DEVICE(0x1199, 0x9011)}, /* Sierra Wireless Gobi 2000 Modem device (MC8305) */
82
82
{USB_DEVICE(0x16d8, 0x8001)}, /* CMDTech Gobi 2000 QDL device (VU922) */
83
83
{USB_DEVICE(0x16d8, 0x8002)}, /* CMDTech Gobi 2000 Modem device (VU922) */
84
84
{USB_DEVICE(0x05c6, 0x9204)}, /* Gobi 2000 QDL device */
+10
drivers/usb/storage/unusual_devs.h
+10
drivers/usb/storage/unusual_devs.h
···
1988
1988
"Micro Mini 1GB",
1989
1989
USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
1990
1990
1991
+
/*
1992
+
* Nick Bowler <nbowler@elliptictech.com>
1993
+
* SCSI stack spams (otherwise harmless) error messages.
1994
+
*/
1995
+
UNUSUAL_DEV( 0xc251, 0x4003, 0x0100, 0x0100,
1996
+
"Keil Software, Inc.",
1997
+
"V2M MotherBoard",
1998
+
USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1999
+
US_FL_NOT_LOCKABLE),
2000
+
1991
2001
/* Reported by Andrew Simmons <andrew.simmons@gmail.com> */
1992
2002
UNUSUAL_DEV( 0xed06, 0x4500, 0x0001, 0x0001,
1993
2003
"DataStor",