Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'usb-3.18-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB fixes from Greg KH:
"Here are a bunch of USB fixes for 3.18-rc3.
Mostly usb-serial device ids and gadget fixes for issues that have
been reported. Full details are in the shortlog.
All of these have been in linux-next for a while"
* tag 'usb-3.18-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (42 commits)
usb: chipidea: Fix oops when removing the ci_hdrc module
usb: gadget: function: Fixed the return value on error path
usb: dwc2: gadget: disable phy before turning off power regulators
usb: gadget: function: Remove redundant usb_free_all_descriptors
usb: dwc3: gadget: Properly initialize LINK TRB
usb: dwc2: gadget: fix gadget unregistration in udc_stop() function
usb: dwc2: Bits in bitfield should add up to 32
usb: dwc2: gadget: sparse warning of context imbalance
usb: gadget: udc: core: fix kernel oops with soft-connect
usb: musb: musb_dsps: fix NULL pointer in suspend
usb: musb: dsps: start OTG timer on resume again
usb: gadget: loopback: don't queue requests to bogus endpoints
usb: ffs: fix regression when quirk_ep_out_aligned_size flag is set
usb: gadget: f_fs: remove redundant ffs_data_get()
usb: gadget: udc: USB_GADGET_XILINX should depend on HAS_DMA
Revert "usb: dwc3: dwc3-omap: Disable/Enable only wrapper interrupts in prepare/complete"
usb: gadget: composite: enable BESL support
usb: musb: cppi41: restart hrtimer only if not yet done
usb: dwc3: ep0: fix Data Phase for transfer sizes aligned to wMaxPacketSize
usb: serial: ftdi_sio: add "bricked" FTDI device PID
...
+320
-174
-1
drivers/usb/chipidea/core.c
-1
drivers/usb/chipidea/core.c
+1
-1
drivers/usb/dwc2/core.h
+1
-1
drivers/usb/dwc2/core.h
+7
-7
drivers/usb/dwc2/gadget.c
+7
-7
drivers/usb/dwc2/gadget.c
···
2561
2561
hs_ep->fifo_size = val;
2562
2562
break;
2563
2563
}
2564
-
if (i == 8)
2565
-
return -ENOMEM;
2564
+
if (i == 8) {
2565
+
ret = -ENOMEM;
2566
+
goto error;
2567
+
}
2566
2568
}
2567
2569
2568
2570
/* for non control endpoints, set PID to D0 */
···
2581
2579
/* enable the endpoint interrupt */
2582
2580
s3c_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
2583
2581
2582
+
error:
2584
2583
spin_unlock_irqrestore(&hsotg->lock, flags);
2585
2584
return ret;
2586
2585
}
···
2937
2934
2938
2935
spin_lock_irqsave(&hsotg->lock, flags);
2939
2936
2940
-
if (!driver)
2941
-
hsotg->driver = NULL;
2942
-
2937
+
hsotg->driver = NULL;
2943
2938
hsotg->gadget.speed = USB_SPEED_UNKNOWN;
2944
2939
2945
2940
spin_unlock_irqrestore(&hsotg->lock, flags);
···
3568
3567
s3c_hsotg_initep(hsotg, &hsotg->eps[epnum], epnum);
3569
3568
3570
3569
/* disable power and clock */
3570
+
s3c_hsotg_phy_disable(hsotg);
3571
3571
3572
3572
ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
3573
3573
hsotg->supplies);
···
3576
3574
dev_err(hsotg->dev, "failed to disable supplies: %d\n", ret);
3577
3575
goto err_ep_mem;
3578
3576
}
3579
-
3580
-
s3c_hsotg_phy_disable(hsotg);
3581
3577
3582
3578
ret = usb_add_gadget_udc(&pdev->dev, &hsotg->gadget);
3583
3579
if (ret)
+2
-13
drivers/usb/dwc3/dwc3-omap.c
+2
-13
drivers/usb/dwc3/dwc3-omap.c
···
597
597
{
598
598
struct dwc3_omap *omap = dev_get_drvdata(dev);
599
599
600
-
dwc3_omap_write_irqmisc_set(omap, 0x00);
600
+
dwc3_omap_disable_irqs(omap);
601
601
602
602
return 0;
603
603
}
···
605
605
static void dwc3_omap_complete(struct device *dev)
606
606
{
607
607
struct dwc3_omap *omap = dev_get_drvdata(dev);
608
-
u32 reg;
609
608
610
-
reg = (USBOTGSS_IRQMISC_OEVT |
611
-
USBOTGSS_IRQMISC_DRVVBUS_RISE |
612
-
USBOTGSS_IRQMISC_CHRGVBUS_RISE |
613
-
USBOTGSS_IRQMISC_DISCHRGVBUS_RISE |
614
-
USBOTGSS_IRQMISC_IDPULLUP_RISE |
615
-
USBOTGSS_IRQMISC_DRVVBUS_FALL |
616
-
USBOTGSS_IRQMISC_CHRGVBUS_FALL |
617
-
USBOTGSS_IRQMISC_DISCHRGVBUS_FALL |
618
-
USBOTGSS_IRQMISC_IDPULLUP_FALL);
619
-
620
-
dwc3_omap_write_irqmisc_set(omap, reg);
609
+
dwc3_omap_enable_irqs(omap);
621
610
}
622
611
623
612
static int dwc3_omap_suspend(struct device *dev)
+2
drivers/usb/dwc3/dwc3-pci.c
+2
drivers/usb/dwc3/dwc3-pci.c
···
30
30
#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 0xabcd
31
31
#define PCI_DEVICE_ID_INTEL_BYT 0x0f37
32
32
#define PCI_DEVICE_ID_INTEL_MRFLD 0x119e
33
+
#define PCI_DEVICE_ID_INTEL_BSW 0x22B7
33
34
34
35
struct dwc3_pci {
35
36
struct device *dev;
···
182
181
PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
183
182
PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
184
183
},
184
+
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BSW), },
185
185
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT), },
186
186
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_MRFLD), },
187
187
{ } /* Terminating Entry */
+36
-12
drivers/usb/dwc3/ep0.c
+36
-12
drivers/usb/dwc3/ep0.c
···
256
256
257
257
/* stall is always issued on EP0 */
258
258
dep = dwc->eps[0];
259
-
__dwc3_gadget_ep_set_halt(dep, 1);
259
+
__dwc3_gadget_ep_set_halt(dep, 1, false);
260
260
dep->flags = DWC3_EP_ENABLED;
261
261
dwc->delayed_status = false;
262
262
···
271
271
dwc3_ep0_out_start(dwc);
272
272
}
273
273
274
-
int dwc3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
274
+
int __dwc3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
275
275
{
276
276
struct dwc3_ep *dep = to_dwc3_ep(ep);
277
277
struct dwc3 *dwc = dep->dwc;
···
279
279
dwc3_ep0_stall_and_restart(dwc);
280
280
281
281
return 0;
282
+
}
283
+
284
+
int dwc3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
285
+
{
286
+
struct dwc3_ep *dep = to_dwc3_ep(ep);
287
+
struct dwc3 *dwc = dep->dwc;
288
+
unsigned long flags;
289
+
int ret;
290
+
291
+
spin_lock_irqsave(&dwc->lock, flags);
292
+
ret = __dwc3_gadget_ep0_set_halt(ep, value);
293
+
spin_unlock_irqrestore(&dwc->lock, flags);
294
+
295
+
return ret;
282
296
}
283
297
284
298
void dwc3_ep0_out_start(struct dwc3 *dwc)
···
480
466
return -EINVAL;
481
467
if (set == 0 && (dep->flags & DWC3_EP_WEDGE))
482
468
break;
483
-
ret = __dwc3_gadget_ep_set_halt(dep, set);
469
+
ret = __dwc3_gadget_ep_set_halt(dep, set, true);
484
470
if (ret)
485
471
return -EINVAL;
486
472
break;
···
789
775
790
776
dwc->ep0_next_event = DWC3_EP0_NRDY_STATUS;
791
777
792
-
r = next_request(&ep0->request_list);
793
-
ur = &r->request;
794
-
795
778
trb = dwc->ep0_trb;
796
779
797
780
status = DWC3_TRB_SIZE_TRBSTS(trb->size);
···
800
789
801
790
return;
802
791
}
792
+
793
+
r = next_request(&ep0->request_list);
794
+
if (!r)
795
+
return;
796
+
797
+
ur = &r->request;
803
798
804
799
length = trb->size & DWC3_TRB_SIZE_MASK;
805
800
···
828
811
829
812
dwc3_ep0_stall_and_restart(dwc);
830
813
} else {
831
-
/*
832
-
* handle the case where we have to send a zero packet. This
833
-
* seems to be case when req.length > maxpacket. Could it be?
834
-
*/
835
-
if (r)
836
-
dwc3_gadget_giveback(ep0, r, 0);
814
+
dwc3_gadget_giveback(ep0, r, 0);
815
+
816
+
if (IS_ALIGNED(ur->length, ep0->endpoint.maxpacket) &&
817
+
ur->length && ur->zero) {
818
+
int ret;
819
+
820
+
dwc->ep0_next_event = DWC3_EP0_COMPLETE;
821
+
822
+
ret = dwc3_ep0_start_trans(dwc, epnum,
823
+
dwc->ctrl_req_addr, 0,
824
+
DWC3_TRBCTL_CONTROL_DATA);
825
+
WARN_ON(ret < 0);
826
+
}
837
827
}
838
828
}
839
829
+23
-16
drivers/usb/dwc3/gadget.c
+23
-16
drivers/usb/dwc3/gadget.c
···
525
525
if (!usb_endpoint_xfer_isoc(desc))
526
526
return 0;
527
527
528
-
memset(&trb_link, 0, sizeof(trb_link));
529
-
530
528
/* Link TRB for ISOC. The HWO bit is never reset */
531
529
trb_st_hw = &dep->trb_pool[0];
532
530
533
531
trb_link = &dep->trb_pool[DWC3_TRB_NUM - 1];
532
+
memset(trb_link, 0, sizeof(*trb_link));
534
533
535
534
trb_link->bpl = lower_32_bits(dwc3_trb_dma_offset(dep, trb_st_hw));
536
535
trb_link->bph = upper_32_bits(dwc3_trb_dma_offset(dep, trb_st_hw));
···
580
581
581
582
/* make sure HW endpoint isn't stalled */
582
583
if (dep->flags & DWC3_EP_STALL)
583
-
__dwc3_gadget_ep_set_halt(dep, 0);
584
+
__dwc3_gadget_ep_set_halt(dep, 0, false);
584
585
585
586
reg = dwc3_readl(dwc->regs, DWC3_DALEPENA);
586
587
reg &= ~DWC3_DALEPENA_EP(dep->number);
···
1201
1202
return ret;
1202
1203
}
1203
1204
1204
-
int __dwc3_gadget_ep_set_halt(struct dwc3_ep *dep, int value)
1205
+
int __dwc3_gadget_ep_set_halt(struct dwc3_ep *dep, int value, int protocol)
1205
1206
{
1206
1207
struct dwc3_gadget_ep_cmd_params params;
1207
1208
struct dwc3 *dwc = dep->dwc;
1208
1209
int ret;
1209
1210
1211
+
if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
1212
+
dev_err(dwc->dev, "%s is of Isochronous type\n", dep->name);
1213
+
return -EINVAL;
1214
+
}
1215
+
1210
1216
memset(¶ms, 0x00, sizeof(params));
1211
1217
1212
1218
if (value) {
1219
+
if (!protocol && ((dep->direction && dep->flags & DWC3_EP_BUSY) ||
1220
+
(!list_empty(&dep->req_queued) ||
1221
+
!list_empty(&dep->request_list)))) {
1222
+
dev_dbg(dwc->dev, "%s: pending request, cannot halt\n",
1223
+
dep->name);
1224
+
return -EAGAIN;
1225
+
}
1226
+
1213
1227
ret = dwc3_send_gadget_ep_cmd(dwc, dep->number,
1214
1228
DWC3_DEPCMD_SETSTALL, ¶ms);
1215
1229
if (ret)
···
1253
1241
int ret;
1254
1242
1255
1243
spin_lock_irqsave(&dwc->lock, flags);
1256
-
1257
-
if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
1258
-
dev_err(dwc->dev, "%s is of Isochronous type\n", dep->name);
1259
-
ret = -EINVAL;
1260
-
goto out;
1261
-
}
1262
-
1263
-
ret = __dwc3_gadget_ep_set_halt(dep, value);
1264
-
out:
1244
+
ret = __dwc3_gadget_ep_set_halt(dep, value, false);
1265
1245
spin_unlock_irqrestore(&dwc->lock, flags);
1266
1246
1267
1247
return ret;
···
1264
1260
struct dwc3_ep *dep = to_dwc3_ep(ep);
1265
1261
struct dwc3 *dwc = dep->dwc;
1266
1262
unsigned long flags;
1263
+
int ret;
1267
1264
1268
1265
spin_lock_irqsave(&dwc->lock, flags);
1269
1266
dep->flags |= DWC3_EP_WEDGE;
1270
-
spin_unlock_irqrestore(&dwc->lock, flags);
1271
1267
1272
1268
if (dep->number == 0 || dep->number == 1)
1273
-
return dwc3_gadget_ep0_set_halt(ep, 1);
1269
+
ret = __dwc3_gadget_ep0_set_halt(ep, 1);
1274
1270
else
1275
-
return dwc3_gadget_ep_set_halt(ep, 1);
1271
+
ret = __dwc3_gadget_ep_set_halt(dep, 1, false);
1272
+
spin_unlock_irqrestore(&dwc->lock, flags);
1273
+
1274
+
return ret;
1276
1275
}
1277
1276
1278
1277
/* -------------------------------------------------------------------------- */
+2
-1
drivers/usb/dwc3/gadget.h
+2
-1
drivers/usb/dwc3/gadget.h
···
82
82
void dwc3_ep0_interrupt(struct dwc3 *dwc,
83
83
const struct dwc3_event_depevt *event);
84
84
void dwc3_ep0_out_start(struct dwc3 *dwc);
85
+
int __dwc3_gadget_ep0_set_halt(struct usb_ep *ep, int value);
85
86
int dwc3_gadget_ep0_set_halt(struct usb_ep *ep, int value);
86
87
int dwc3_gadget_ep0_queue(struct usb_ep *ep, struct usb_request *request,
87
88
gfp_t gfp_flags);
88
-
int __dwc3_gadget_ep_set_halt(struct dwc3_ep *dep, int value);
89
+
int __dwc3_gadget_ep_set_halt(struct dwc3_ep *dep, int value, int protocol);
89
90
90
91
/**
91
92
* dwc3_gadget_ep_get_transfer_index - Gets transfer index from HW
+38
-15
drivers/usb/dwc3/trace.h
+38
-15
drivers/usb/dwc3/trace.h
···
73
73
TP_PROTO(struct usb_ctrlrequest *ctrl),
74
74
TP_ARGS(ctrl),
75
75
TP_STRUCT__entry(
76
-
__field(struct usb_ctrlrequest *, ctrl)
76
+
__field(__u8, bRequestType)
77
+
__field(__u8, bRequest)
78
+
__field(__le16, wValue)
79
+
__field(__le16, wIndex)
80
+
__field(__le16, wLength)
77
81
),
78
82
TP_fast_assign(
79
-
__entry->ctrl = ctrl;
83
+
__entry->bRequestType = ctrl->bRequestType;
84
+
__entry->bRequest = ctrl->bRequest;
85
+
__entry->wValue = ctrl->wValue;
86
+
__entry->wIndex = ctrl->wIndex;
87
+
__entry->wLength = ctrl->wLength;
80
88
),
81
89
TP_printk("bRequestType %02x bRequest %02x wValue %04x wIndex %04x wLength %d",
82
-
__entry->ctrl->bRequestType, __entry->ctrl->bRequest,
83
-
le16_to_cpu(__entry->ctrl->wValue), le16_to_cpu(__entry->ctrl->wIndex),
84
-
le16_to_cpu(__entry->ctrl->wLength)
90
+
__entry->bRequestType, __entry->bRequest,
91
+
le16_to_cpu(__entry->wValue), le16_to_cpu(__entry->wIndex),
92
+
le16_to_cpu(__entry->wLength)
85
93
)
86
94
);
87
95
···
102
94
TP_PROTO(struct dwc3_request *req),
103
95
TP_ARGS(req),
104
96
TP_STRUCT__entry(
97
+
__dynamic_array(char, name, DWC3_MSG_MAX)
105
98
__field(struct dwc3_request *, req)
99
+
__field(unsigned, actual)
100
+
__field(unsigned, length)
101
+
__field(int, status)
106
102
),
107
103
TP_fast_assign(
104
+
snprintf(__get_str(name), DWC3_MSG_MAX, "%s", req->dep->name);
108
105
__entry->req = req;
106
+
__entry->actual = req->request.actual;
107
+
__entry->length = req->request.length;
108
+
__entry->status = req->request.status;
109
109
),
110
110
TP_printk("%s: req %p length %u/%u ==> %d",
111
-
__entry->req->dep->name, __entry->req,
112
-
__entry->req->request.actual, __entry->req->request.length,
113
-
__entry->req->request.status
111
+
__get_str(name), __entry->req, __entry->actual, __entry->length,
112
+
__entry->status
114
113
)
115
114
);
116
115
···
173
158
struct dwc3_gadget_ep_cmd_params *params),
174
159
TP_ARGS(dep, cmd, params),
175
160
TP_STRUCT__entry(
176
-
__field(struct dwc3_ep *, dep)
161
+
__dynamic_array(char, name, DWC3_MSG_MAX)
177
162
__field(unsigned int, cmd)
178
163
__field(struct dwc3_gadget_ep_cmd_params *, params)
179
164
),
180
165
TP_fast_assign(
181
-
__entry->dep = dep;
166
+
snprintf(__get_str(name), DWC3_MSG_MAX, "%s", dep->name);
182
167
__entry->cmd = cmd;
183
168
__entry->params = params;
184
169
),
185
170
TP_printk("%s: cmd '%s' [%d] params %08x %08x %08x\n",
186
-
__entry->dep->name, dwc3_gadget_ep_cmd_string(__entry->cmd),
171
+
__get_str(name), dwc3_gadget_ep_cmd_string(__entry->cmd),
187
172
__entry->cmd, __entry->params->param0,
188
173
__entry->params->param1, __entry->params->param2
189
174
)
···
199
184
TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
200
185
TP_ARGS(dep, trb),
201
186
TP_STRUCT__entry(
202
-
__field(struct dwc3_ep *, dep)
187
+
__dynamic_array(char, name, DWC3_MSG_MAX)
203
188
__field(struct dwc3_trb *, trb)
189
+
__field(u32, bpl)
190
+
__field(u32, bph)
191
+
__field(u32, size)
192
+
__field(u32, ctrl)
204
193
),
205
194
TP_fast_assign(
206
-
__entry->dep = dep;
195
+
snprintf(__get_str(name), DWC3_MSG_MAX, "%s", dep->name);
207
196
__entry->trb = trb;
197
+
__entry->bpl = trb->bpl;
198
+
__entry->bph = trb->bph;
199
+
__entry->size = trb->size;
200
+
__entry->ctrl = trb->ctrl;
208
201
),
209
202
TP_printk("%s: trb %p bph %08x bpl %08x size %08x ctrl %08x\n",
210
-
__entry->dep->name, __entry->trb, __entry->trb->bph,
211
-
__entry->trb->bpl, __entry->trb->size, __entry->trb->ctrl
203
+
__get_str(name), __entry->trb, __entry->bph, __entry->bpl,
204
+
__entry->size, __entry->ctrl
212
205
)
213
206
);
214
207
+1
-1
drivers/usb/gadget/composite.c
+1
-1
drivers/usb/gadget/composite.c
···
560
560
usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE;
561
561
usb_ext->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
562
562
usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT;
563
-
usb_ext->bmAttributes = cpu_to_le32(USB_LPM_SUPPORT);
563
+
usb_ext->bmAttributes = cpu_to_le32(USB_LPM_SUPPORT | USB_BESL_SUPPORT);
564
564
565
565
/*
566
566
* The Superspeed USB Capability descriptor shall be implemented by all
+4
-4
drivers/usb/gadget/function/f_acm.c
+4
-4
drivers/usb/gadget/function/f_acm.c
···
433
433
dev_vdbg(&cdev->gadget->dev,
434
434
"reset acm control interface %d\n", intf);
435
435
usb_ep_disable(acm->notify);
436
-
} else {
437
-
dev_vdbg(&cdev->gadget->dev,
438
-
"init acm ctrl interface %d\n", intf);
436
+
}
437
+
438
+
if (!acm->notify->desc)
439
439
if (config_ep_by_speed(cdev->gadget, f, acm->notify))
440
440
return -EINVAL;
441
-
}
441
+
442
442
usb_ep_enable(acm->notify);
443
443
acm->notify->driver_data = acm;
444
444
-1
drivers/usb/gadget/function/f_eem.c
-1
drivers/usb/gadget/function/f_eem.c
+34
-8
drivers/usb/gadget/function/f_fs.c
+34
-8
drivers/usb/gadget/function/f_fs.c
···
647
647
if (io_data->read && ret > 0) {
648
648
int i;
649
649
size_t pos = 0;
650
+
651
+
/*
652
+
* Since req->length may be bigger than io_data->len (after
653
+
* being rounded up to maxpacketsize), we may end up with more
654
+
* data then user space has space for.
655
+
*/
656
+
ret = min_t(int, ret, io_data->len);
657
+
650
658
use_mm(io_data->mm);
651
659
for (i = 0; i < io_data->nr_segs; i++) {
660
+
size_t len = min_t(size_t, ret - pos,
661
+
io_data->iovec[i].iov_len);
662
+
if (!len)
663
+
break;
652
664
if (unlikely(copy_to_user(io_data->iovec[i].iov_base,
653
-
&io_data->buf[pos],
654
-
io_data->iovec[i].iov_len))) {
665
+
&io_data->buf[pos], len))) {
655
666
ret = -EFAULT;
656
667
break;
657
668
}
658
-
pos += io_data->iovec[i].iov_len;
669
+
pos += len;
659
670
}
660
671
unuse_mm(io_data->mm);
661
672
}
···
698
687
struct ffs_epfile *epfile = file->private_data;
699
688
struct ffs_ep *ep;
700
689
char *data = NULL;
701
-
ssize_t ret, data_len;
690
+
ssize_t ret, data_len = -EINVAL;
702
691
int halt;
703
692
704
693
/* Are we still active? */
···
798
787
/* Fire the request */
799
788
struct usb_request *req;
800
789
790
+
/*
791
+
* Sanity Check: even though data_len can't be used
792
+
* uninitialized at the time I write this comment, some
793
+
* compilers complain about this situation.
794
+
* In order to keep the code clean from warnings, data_len is
795
+
* being initialized to -EINVAL during its declaration, which
796
+
* means we can't rely on compiler anymore to warn no future
797
+
* changes won't result in data_len being used uninitialized.
798
+
* For such reason, we're adding this redundant sanity check
799
+
* here.
800
+
*/
801
+
if (unlikely(data_len == -EINVAL)) {
802
+
WARN(1, "%s: data_len == -EINVAL\n", __func__);
803
+
ret = -EINVAL;
804
+
goto error_lock;
805
+
}
806
+
801
807
if (io_data->aio) {
802
808
req = usb_ep_alloc_request(ep->ep, GFP_KERNEL);
803
809
if (unlikely(!req))
804
810
goto error_lock;
805
811
806
812
req->buf = data;
807
-
req->length = io_data->len;
813
+
req->length = data_len;
808
814
809
815
io_data->buf = data;
810
816
io_data->ep = ep->ep;
···
843
815
844
816
req = ep->req;
845
817
req->buf = data;
846
-
req->length = io_data->len;
818
+
req->length = data_len;
847
819
848
820
req->context = &done;
849
821
req->complete = ffs_epfile_io_complete;
···
2690
2662
2691
2663
func->conf = c;
2692
2664
func->gadget = c->cdev->gadget;
2693
-
2694
-
ffs_data_get(func->ffs);
2695
2665
2696
2666
/*
2697
2667
* in drivers/usb/gadget/configfs.c:configfs_composite_bind()
+3
-2
drivers/usb/gadget/function/f_hid.c
+3
-2
drivers/usb/gadget/function/f_hid.c
···
621
621
dev = MKDEV(major, hidg->minor);
622
622
status = cdev_add(&hidg->cdev, dev, 1);
623
623
if (status)
624
-
goto fail;
624
+
goto fail_free_descs;
625
625
626
626
device_create(hidg_class, NULL, dev, NULL, "%s%d", "hidg", hidg->minor);
627
627
628
628
return 0;
629
629
630
+
fail_free_descs:
631
+
usb_free_all_descriptors(f);
630
632
fail:
631
633
ERROR(f->config->cdev, "hidg_bind FAILED\n");
632
634
if (hidg->req != NULL) {
···
637
635
usb_ep_free_request(hidg->in_ep, hidg->req);
638
636
}
639
637
640
-
usb_free_all_descriptors(f);
641
638
return status;
642
639
}
643
640
+43
-46
drivers/usb/gadget/function/f_loopback.c
+43
-46
drivers/usb/gadget/function/f_loopback.c
···
253
253
254
254
case 0: /* normal completion? */
255
255
if (ep == loop->out_ep) {
256
-
/* loop this OUT packet back IN to the host */
257
256
req->zero = (req->actual < req->length);
258
257
req->length = req->actual;
259
-
status = usb_ep_queue(loop->in_ep, req, GFP_ATOMIC);
260
-
if (status == 0)
261
-
return;
262
-
263
-
/* "should never get here" */
264
-
ERROR(cdev, "can't loop %s to %s: %d\n",
265
-
ep->name, loop->in_ep->name,
266
-
status);
267
258
}
268
259
269
260
/* queue the buffer for some later OUT packet */
270
261
req->length = buflen;
271
-
status = usb_ep_queue(loop->out_ep, req, GFP_ATOMIC);
262
+
status = usb_ep_queue(ep, req, GFP_ATOMIC);
272
263
if (status == 0)
273
264
return;
274
265
···
299
308
return alloc_ep_req(ep, len, buflen);
300
309
}
301
310
302
-
static int
303
-
enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
311
+
static int enable_endpoint(struct usb_composite_dev *cdev, struct f_loopback *loop,
312
+
struct usb_ep *ep)
304
313
{
305
-
int result = 0;
306
-
struct usb_ep *ep;
307
314
struct usb_request *req;
308
315
unsigned i;
316
+
int result;
309
317
310
-
/* one endpoint writes data back IN to the host */
311
-
ep = loop->in_ep;
312
-
result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
313
-
if (result)
314
-
return result;
315
-
result = usb_ep_enable(ep);
316
-
if (result < 0)
317
-
return result;
318
-
ep->driver_data = loop;
319
-
320
-
/* one endpoint just reads OUT packets */
321
-
ep = loop->out_ep;
318
+
/*
319
+
* one endpoint writes data back IN to the host while another endpoint
320
+
* just reads OUT packets
321
+
*/
322
322
result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
323
323
if (result)
324
324
goto fail0;
325
-
326
325
result = usb_ep_enable(ep);
327
-
if (result < 0) {
328
-
fail0:
329
-
ep = loop->in_ep;
330
-
usb_ep_disable(ep);
331
-
ep->driver_data = NULL;
332
-
return result;
333
-
}
326
+
if (result < 0)
327
+
goto fail0;
334
328
ep->driver_data = loop;
335
329
336
-
/* allocate a bunch of read buffers and queue them all at once.
330
+
/*
331
+
* allocate a bunch of read buffers and queue them all at once.
337
332
* we buffer at most 'qlen' transfers; fewer if any need more
338
333
* than 'buflen' bytes each.
339
334
*/
340
335
for (i = 0; i < qlen && result == 0; i++) {
341
336
req = lb_alloc_ep_req(ep, 0);
342
-
if (req) {
343
-
req->complete = loopback_complete;
344
-
result = usb_ep_queue(ep, req, GFP_ATOMIC);
345
-
if (result)
346
-
ERROR(cdev, "%s queue req --> %d\n",
347
-
ep->name, result);
348
-
} else {
349
-
usb_ep_disable(ep);
350
-
ep->driver_data = NULL;
351
-
result = -ENOMEM;
352
-
goto fail0;
337
+
if (!req)
338
+
goto fail1;
339
+
340
+
req->complete = loopback_complete;
341
+
result = usb_ep_queue(ep, req, GFP_ATOMIC);
342
+
if (result) {
343
+
ERROR(cdev, "%s queue req --> %d\n",
344
+
ep->name, result);
345
+
goto fail1;
353
346
}
354
347
}
348
+
349
+
return 0;
350
+
351
+
fail1:
352
+
usb_ep_disable(ep);
353
+
354
+
fail0:
355
+
return result;
356
+
}
357
+
358
+
static int
359
+
enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
360
+
{
361
+
int result = 0;
362
+
363
+
result = enable_endpoint(cdev, loop, loop->in_ep);
364
+
if (result)
365
+
return result;
366
+
367
+
result = enable_endpoint(cdev, loop, loop->out_ep);
368
+
if (result)
369
+
return result;
355
370
356
371
DBG(cdev, "%s enabled\n", loop->function.name);
357
372
return result;
-1
drivers/usb/gadget/function/f_ncm.c
-1
drivers/usb/gadget/function/f_ncm.c
+4
-5
drivers/usb/gadget/function/f_obex.c
+4
-5
drivers/usb/gadget/function/f_obex.c
···
35
35
struct gserial port;
36
36
u8 ctrl_id;
37
37
u8 data_id;
38
+
u8 cur_alt;
38
39
u8 port_num;
39
40
u8 can_activate;
40
41
};
···
236
235
} else
237
236
goto fail;
238
237
238
+
obex->cur_alt = alt;
239
+
239
240
return 0;
240
241
241
242
fail:
···
248
245
{
249
246
struct f_obex *obex = func_to_obex(f);
250
247
251
-
if (intf == obex->ctrl_id)
252
-
return 0;
253
-
254
-
return obex->port.in->driver_data ? 1 : 0;
248
+
return obex->cur_alt;
255
249
}
256
250
257
251
static void obex_disable(struct usb_function *f)
···
397
397
return 0;
398
398
399
399
fail:
400
-
usb_free_all_descriptors(f);
401
400
/* we might as well release our claims on endpoints */
402
401
if (obex->port.out)
403
402
obex->port.out->driver_data = NULL;
+1
-1
drivers/usb/gadget/function/f_phonet.c
+1
-1
drivers/usb/gadget/function/f_phonet.c
+6
-3
drivers/usb/gadget/function/f_rndis.c
+6
-3
drivers/usb/gadget/function/f_rndis.c
···
802
802
803
803
if (rndis->manufacturer && rndis->vendorID &&
804
804
rndis_set_param_vendor(rndis->config, rndis->vendorID,
805
-
rndis->manufacturer))
806
-
goto fail;
805
+
rndis->manufacturer)) {
806
+
status = -EINVAL;
807
+
goto fail_free_descs;
808
+
}
807
809
808
810
/* NOTE: all that is done without knowing or caring about
809
811
* the network link ... which is unavailable to this code
···
819
817
rndis->notify->name);
820
818
return 0;
821
819
820
+
fail_free_descs:
821
+
usb_free_all_descriptors(f);
822
822
fail:
823
823
kfree(f->os_desc_table);
824
824
f->os_desc_n = 0;
825
-
usb_free_all_descriptors(f);
826
825
827
826
if (rndis->notify_req) {
828
827
kfree(rndis->notify_req->buf);
-1
drivers/usb/gadget/function/f_subset.c
-1
drivers/usb/gadget/function/f_subset.c
+19
-4
drivers/usb/gadget/function/f_uac2.c
+19
-4
drivers/usb/gadget/function/f_uac2.c
···
512
512
return 0;
513
513
}
514
514
515
+
static void snd_uac2_release(struct device *dev)
516
+
{
517
+
dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
518
+
}
519
+
515
520
static int alsa_uac2_init(struct audio_dev *agdev)
516
521
{
517
522
struct snd_uac2_chip *uac2 = &agdev->uac2;
···
528
523
529
524
uac2->pdev.id = 0;
530
525
uac2->pdev.name = uac2_name;
526
+
uac2->pdev.dev.release = snd_uac2_release;
531
527
532
528
/* Register snd_uac2 driver */
533
529
err = platform_driver_register(&uac2->pdrv);
···
778
772
779
773
.bEndpointAddress = USB_DIR_OUT,
780
774
.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
775
+
.wMaxPacketSize = cpu_to_le16(1023),
781
776
.bInterval = 1,
782
777
};
783
778
···
787
780
.bDescriptorType = USB_DT_ENDPOINT,
788
781
789
782
.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
783
+
.wMaxPacketSize = cpu_to_le16(1024),
790
784
.bInterval = 4,
791
785
};
792
786
···
855
847
856
848
.bEndpointAddress = USB_DIR_IN,
857
849
.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
850
+
.wMaxPacketSize = cpu_to_le16(1023),
858
851
.bInterval = 1,
859
852
};
860
853
···
864
855
.bDescriptorType = USB_DT_ENDPOINT,
865
856
866
857
.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
858
+
.wMaxPacketSize = cpu_to_le16(1024),
867
859
.bInterval = 4,
868
860
};
869
861
···
956
946
{
957
947
struct snd_uac2_chip *uac2 = prm->uac2;
958
948
int i;
949
+
950
+
if (!prm->ep_enabled)
951
+
return;
959
952
960
953
prm->ep_enabled = false;
961
954
···
1084
1071
prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
1085
1072
if (!prm->rbuf) {
1086
1073
prm->max_psize = 0;
1087
-
goto err;
1074
+
goto err_free_descs;
1088
1075
}
1089
1076
1090
1077
prm = &agdev->uac2.p_prm;
···
1092
1079
prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
1093
1080
if (!prm->rbuf) {
1094
1081
prm->max_psize = 0;
1095
-
goto err;
1082
+
goto err_free_descs;
1096
1083
}
1097
1084
1098
1085
ret = alsa_uac2_init(agdev);
1099
1086
if (ret)
1100
-
goto err;
1087
+
goto err_free_descs;
1101
1088
return 0;
1089
+
1090
+
err_free_descs:
1091
+
usb_free_all_descriptors(fn);
1102
1092
err:
1103
1093
kfree(agdev->uac2.p_prm.rbuf);
1104
1094
kfree(agdev->uac2.c_prm.rbuf);
1105
-
usb_free_all_descriptors(fn);
1106
1095
if (agdev->in_ep)
1107
1096
agdev->in_ep->driver_data = NULL;
1108
1097
if (agdev->out_ep)
+44
-10
drivers/usb/gadget/function/f_uvc.c
+44
-10
drivers/usb/gadget/function/f_uvc.c
···
279
279
else if (interface != uvc->streaming_intf)
280
280
return -EINVAL;
281
281
else
282
-
return uvc->state == UVC_STATE_STREAMING ? 1 : 0;
282
+
return uvc->video.ep->driver_data ? 1 : 0;
283
283
}
284
284
285
285
static int
286
286
uvc_function_set_alt(struct usb_function *f, unsigned interface, unsigned alt)
287
287
{
288
288
struct uvc_device *uvc = to_uvc(f);
289
+
struct usb_composite_dev *cdev = f->config->cdev;
289
290
struct v4l2_event v4l2_event;
290
291
struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
291
292
int ret;
292
293
293
-
INFO(f->config->cdev, "uvc_function_set_alt(%u, %u)\n", interface, alt);
294
+
INFO(cdev, "uvc_function_set_alt(%u, %u)\n", interface, alt);
294
295
295
296
if (interface == uvc->control_intf) {
296
297
if (alt)
297
298
return -EINVAL;
298
299
300
+
if (uvc->control_ep->driver_data) {
301
+
INFO(cdev, "reset UVC Control\n");
302
+
usb_ep_disable(uvc->control_ep);
303
+
uvc->control_ep->driver_data = NULL;
304
+
}
305
+
306
+
if (!uvc->control_ep->desc)
307
+
if (config_ep_by_speed(cdev->gadget, f, uvc->control_ep))
308
+
return -EINVAL;
309
+
310
+
usb_ep_enable(uvc->control_ep);
311
+
uvc->control_ep->driver_data = uvc;
312
+
299
313
if (uvc->state == UVC_STATE_DISCONNECTED) {
300
314
memset(&v4l2_event, 0, sizeof(v4l2_event));
301
315
v4l2_event.type = UVC_EVENT_CONNECT;
302
-
uvc_event->speed = f->config->cdev->gadget->speed;
316
+
uvc_event->speed = cdev->gadget->speed;
303
317
v4l2_event_queue(uvc->vdev, &v4l2_event);
304
318
305
319
uvc->state = UVC_STATE_CONNECTED;
···
335
321
if (uvc->state != UVC_STATE_STREAMING)
336
322
return 0;
337
323
338
-
if (uvc->video.ep)
324
+
if (uvc->video.ep) {
339
325
usb_ep_disable(uvc->video.ep);
326
+
uvc->video.ep->driver_data = NULL;
327
+
}
340
328
341
329
memset(&v4l2_event, 0, sizeof(v4l2_event));
342
330
v4l2_event.type = UVC_EVENT_STREAMOFF;
···
351
335
if (uvc->state != UVC_STATE_CONNECTED)
352
336
return 0;
353
337
354
-
if (uvc->video.ep) {
355
-
ret = config_ep_by_speed(f->config->cdev->gadget,
356
-
&(uvc->func), uvc->video.ep);
357
-
if (ret)
358
-
return ret;
359
-
usb_ep_enable(uvc->video.ep);
338
+
if (!uvc->video.ep)
339
+
return -EINVAL;
340
+
341
+
if (uvc->video.ep->driver_data) {
342
+
INFO(cdev, "reset UVC\n");
343
+
usb_ep_disable(uvc->video.ep);
344
+
uvc->video.ep->driver_data = NULL;
360
345
}
346
+
347
+
ret = config_ep_by_speed(f->config->cdev->gadget,
348
+
&(uvc->func), uvc->video.ep);
349
+
if (ret)
350
+
return ret;
351
+
usb_ep_enable(uvc->video.ep);
352
+
uvc->video.ep->driver_data = uvc;
361
353
362
354
memset(&v4l2_event, 0, sizeof(v4l2_event));
363
355
v4l2_event.type = UVC_EVENT_STREAMON;
···
390
366
v4l2_event_queue(uvc->vdev, &v4l2_event);
391
367
392
368
uvc->state = UVC_STATE_DISCONNECTED;
369
+
370
+
if (uvc->video.ep->driver_data) {
371
+
usb_ep_disable(uvc->video.ep);
372
+
uvc->video.ep->driver_data = NULL;
373
+
}
374
+
375
+
if (uvc->control_ep->driver_data) {
376
+
usb_ep_disable(uvc->control_ep);
377
+
uvc->control_ep->driver_data = NULL;
378
+
}
393
379
}
394
380
395
381
/* --------------------------------------------------------------------------
+2
-1
drivers/usb/gadget/function/uvc_video.c
+2
-1
drivers/usb/gadget/function/uvc_video.c
+1
drivers/usb/gadget/udc/Kconfig
+1
drivers/usb/gadget/udc/Kconfig
+5
drivers/usb/gadget/udc/udc-core.c
+5
drivers/usb/gadget/udc/udc-core.c
···
507
507
{
508
508
struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
509
509
510
+
if (!udc->driver) {
511
+
dev_err(dev, "soft-connect without a gadget driver\n");
512
+
return -EOPNOTSUPP;
513
+
}
514
+
510
515
if (sysfs_streq(buf, "connect")) {
511
516
usb_gadget_udc_start(udc->gadget, udc->driver);
512
517
usb_gadget_connect(udc->gadget);
+2
-1
drivers/usb/musb/musb_cppi41.c
+2
-1
drivers/usb/musb/musb_cppi41.c
···
209
209
}
210
210
}
211
211
212
-
if (!list_empty(&controller->early_tx_list)) {
212
+
if (!list_empty(&controller->early_tx_list) &&
213
+
!hrtimer_is_queued(&controller->early_tx)) {
213
214
ret = HRTIMER_RESTART;
214
215
hrtimer_forward_now(&controller->early_tx,
215
216
ktime_set(0, 20 * NSEC_PER_USEC));
+15
-3
drivers/usb/musb/musb_dsps.c
+15
-3
drivers/usb/musb/musb_dsps.c
···
868
868
struct dsps_glue *glue = dev_get_drvdata(dev);
869
869
const struct dsps_musb_wrapper *wrp = glue->wrp;
870
870
struct musb *musb = platform_get_drvdata(glue->musb);
871
-
void __iomem *mbase = musb->ctrl_base;
871
+
void __iomem *mbase;
872
872
873
873
del_timer_sync(&glue->timer);
874
+
875
+
if (!musb)
876
+
/* This can happen if the musb device is in -EPROBE_DEFER */
877
+
return 0;
878
+
879
+
mbase = musb->ctrl_base;
874
880
glue->context.control = dsps_readl(mbase, wrp->control);
875
881
glue->context.epintr = dsps_readl(mbase, wrp->epintr_set);
876
882
glue->context.coreintr = dsps_readl(mbase, wrp->coreintr_set);
···
893
887
struct dsps_glue *glue = dev_get_drvdata(dev);
894
888
const struct dsps_musb_wrapper *wrp = glue->wrp;
895
889
struct musb *musb = platform_get_drvdata(glue->musb);
896
-
void __iomem *mbase = musb->ctrl_base;
890
+
void __iomem *mbase;
897
891
892
+
if (!musb)
893
+
return 0;
894
+
895
+
mbase = musb->ctrl_base;
898
896
dsps_writel(mbase, wrp->control, glue->context.control);
899
897
dsps_writel(mbase, wrp->epintr_set, glue->context.epintr);
900
898
dsps_writel(mbase, wrp->coreintr_set, glue->context.coreintr);
···
906
896
dsps_writel(mbase, wrp->mode, glue->context.mode);
907
897
dsps_writel(mbase, wrp->tx_mode, glue->context.tx_mode);
908
898
dsps_writel(mbase, wrp->rx_mode, glue->context.rx_mode);
909
-
setup_timer(&glue->timer, otg_timer, (unsigned long) musb);
899
+
if (musb->xceiv->state == OTG_STATE_B_IDLE &&
900
+
musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE)
901
+
mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
910
902
911
903
return 0;
912
904
}
+1
drivers/usb/serial/cp210x.c
+1
drivers/usb/serial/cp210x.c
···
155
155
{ USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
156
156
{ USB_DEVICE(0x1ADB, 0x0001) }, /* Schweitzer Engineering C662 Cable */
157
157
{ USB_DEVICE(0x1B1C, 0x1C00) }, /* Corsair USB Dongle */
158
+
{ USB_DEVICE(0x1BA4, 0x0002) }, /* Silicon Labs 358x factory default */
158
159
{ USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
159
160
{ USB_DEVICE(0x1D6F, 0x0010) }, /* Seluxit ApS RF Dongle */
160
161
{ USB_DEVICE(0x1E29, 0x0102) }, /* Festo CPX-USB */
+3
drivers/usb/serial/ftdi_sio.c
+3
drivers/usb/serial/ftdi_sio.c
···
140
140
* /sys/bus/usb-serial/drivers/ftdi_sio/new_id and send a patch or report.
141
141
*/
142
142
static const struct usb_device_id id_table_combined[] = {
143
+
{ USB_DEVICE(FTDI_VID, FTDI_BRICK_PID) },
143
144
{ USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
144
145
{ USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
145
146
{ USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
···
662
661
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
663
662
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
664
663
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
664
+
{ USB_DEVICE(XSENS_VID, XSENS_AWINDA_DONGLE_PID) },
665
+
{ USB_DEVICE(XSENS_VID, XSENS_AWINDA_STATION_PID) },
665
666
{ USB_DEVICE(XSENS_VID, XSENS_CONVERTER_PID) },
666
667
{ USB_DEVICE(XSENS_VID, XSENS_MTW_PID) },
667
668
{ USB_DEVICE(FTDI_VID, FTDI_OMNI1509) },
+11
-1
drivers/usb/serial/ftdi_sio_ids.h
+11
-1
drivers/usb/serial/ftdi_sio_ids.h
···
30
30
31
31
/*** third-party PIDs (using FTDI_VID) ***/
32
32
33
+
/*
34
+
* Certain versions of the official Windows FTDI driver reprogrammed
35
+
* counterfeit FTDI devices to PID 0. Support these devices anyway.
36
+
*/
37
+
#define FTDI_BRICK_PID 0x0000
38
+
33
39
#define FTDI_LUMEL_PD12_PID 0x6002
34
40
35
41
/*
···
149
143
* Xsens Technologies BV products (http://www.xsens.com).
150
144
*/
151
145
#define XSENS_VID 0x2639
152
-
#define XSENS_CONVERTER_PID 0xD00D /* Xsens USB-serial converter */
146
+
#define XSENS_AWINDA_STATION_PID 0x0101
147
+
#define XSENS_AWINDA_DONGLE_PID 0x0102
153
148
#define XSENS_MTW_PID 0x0200 /* Xsens MTw */
149
+
#define XSENS_CONVERTER_PID 0xD00D /* Xsens USB-serial converter */
150
+
151
+
/* Xsens devices using FTDI VID */
154
152
#define XSENS_CONVERTER_0_PID 0xD388 /* Xsens USB converter */
155
153
#define XSENS_CONVERTER_1_PID 0xD389 /* Xsens Wireless Receiver */
156
154
#define XSENS_CONVERTER_2_PID 0xD38A
-15
drivers/usb/serial/kobil_sct.c
-15
drivers/usb/serial/kobil_sct.c
···
414
414
int result;
415
415
int dtr = 0;
416
416
int rts = 0;
417
-
unsigned char *transfer_buffer;
418
-
int transfer_buffer_length = 8;
419
417
420
418
/* FIXME: locking ? */
421
419
priv = usb_get_serial_port_data(port);
···
422
424
/* This device doesn't support ioctl calls */
423
425
return -EINVAL;
424
426
}
425
-
426
-
/* allocate memory for transfer buffer */
427
-
transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
428
-
if (!transfer_buffer)
429
-
return -ENOMEM;
430
427
431
428
if (set & TIOCM_RTS)
432
429
rts = 1;
···
462
469
KOBIL_TIMEOUT);
463
470
}
464
471
dev_dbg(dev, "%s - Send set_status_line URB returns: %i\n", __func__, result);
465
-
kfree(transfer_buffer);
466
472
return (result < 0) ? result : 0;
467
473
}
468
474
···
522
530
{
523
531
struct usb_serial_port *port = tty->driver_data;
524
532
struct kobil_private *priv = usb_get_serial_port_data(port);
525
-
unsigned char *transfer_buffer;
526
-
int transfer_buffer_length = 8;
527
533
int result;
528
534
529
535
if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
···
531
541
532
542
switch (cmd) {
533
543
case TCFLSH:
534
-
transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL);
535
-
if (!transfer_buffer)
536
-
return -ENOBUFS;
537
-
538
544
result = usb_control_msg(port->serial->dev,
539
545
usb_sndctrlpipe(port->serial->dev, 0),
540
546
SUSBCRequest_Misc,
···
545
559
dev_dbg(&port->dev,
546
560
"%s - Send reset_all_queues (FLUSH) URB returns: %i\n",
547
561
__func__, result);
548
-
kfree(transfer_buffer);
549
562
return (result < 0) ? -EIO: 0;
550
563
default:
551
564
return -ENOIOCTLCMD;
+10
drivers/usb/serial/option.c
+10
drivers/usb/serial/option.c
···
269
269
#define TELIT_PRODUCT_DE910_DUAL 0x1010
270
270
#define TELIT_PRODUCT_UE910_V2 0x1012
271
271
#define TELIT_PRODUCT_LE920 0x1200
272
+
#define TELIT_PRODUCT_LE910 0x1201
272
273
273
274
/* ZTE PRODUCTS */
274
275
#define ZTE_VENDOR_ID 0x19d2
···
363
362
364
363
/* Haier products */
365
364
#define HAIER_VENDOR_ID 0x201e
365
+
#define HAIER_PRODUCT_CE81B 0x10f8
366
366
#define HAIER_PRODUCT_CE100 0x2009
367
367
368
368
/* Cinterion (formerly Siemens) products */
···
589
587
590
588
static const struct option_blacklist_info zte_1255_blacklist = {
591
589
.reserved = BIT(3) | BIT(4),
590
+
};
591
+
592
+
static const struct option_blacklist_info telit_le910_blacklist = {
593
+
.sendsetup = BIT(0),
594
+
.reserved = BIT(1) | BIT(2),
592
595
};
593
596
594
597
static const struct option_blacklist_info telit_le920_blacklist = {
···
1145
1138
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_CC864_SINGLE) },
1146
1139
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_DE910_DUAL) },
1147
1140
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UE910_V2) },
1141
+
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910),
1142
+
.driver_info = (kernel_ulong_t)&telit_le910_blacklist },
1148
1143
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE920),
1149
1144
.driver_info = (kernel_ulong_t)&telit_le920_blacklist },
1150
1145
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */
···
1630
1621
{ USB_DEVICE(LONGCHEER_VENDOR_ID, ZOOM_PRODUCT_4597) },
1631
1622
{ USB_DEVICE(LONGCHEER_VENDOR_ID, IBALL_3_5G_CONNECT) },
1632
1623
{ USB_DEVICE(HAIER_VENDOR_ID, HAIER_PRODUCT_CE100) },
1624
+
{ USB_DEVICE_AND_INTERFACE_INFO(HAIER_VENDOR_ID, HAIER_PRODUCT_CE81B, 0xff, 0xff, 0xff) },
1633
1625
/* Pirelli */
1634
1626
{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_1, 0xff) },
1635
1627
{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_2, 0xff) },