Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'usb-5.18-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB fixes from Greg KH:
"Here are some small fixes for reported issues with some USB drivers.
They include:
- xhci fixes for xhci-mtk platform driver
- typec driver fixes for reported problems.
- cdc-wdm read-stuck fix
- gadget driver fix for reported race condition
- new usb-serial driver ids
All of these have been in linux-next with no reported problems"
* tag 'usb-5.18-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb:
usb: xhci-mtk: remove bandwidth budget table
usb: xhci-mtk: fix fs isoc's transfer error
usb: gadget: fix race when gadget driver register via ioctl
usb: typec: tcpci_mt6360: Update for BMC PHY setting
usb: gadget: uvc: allow for application to cleanly shutdown
usb: typec: tcpci: Don't skip cleanup in .remove() on error
usb: cdc-wdm: fix reading stuck on device close
USB: serial: qcserial: add support for Sierra Wireless EM7590
USB: serial: option: add Fibocom MA510 modem
USB: serial: option: add Fibocom L610 modem
USB: serial: pl2303: add device id for HP LM930 Display
+86
-75
+1
drivers/usb/class/cdc-wdm.c
+1
drivers/usb/class/cdc-wdm.c
+25
drivers/usb/gadget/function/f_uvc.c
+25
drivers/usb/gadget/function/f_uvc.c
···
890
890
{
891
891
struct usb_composite_dev *cdev = c->cdev;
892
892
struct uvc_device *uvc = to_uvc(f);
893
+
long wait_ret = 1;
893
894
894
895
uvcg_info(f, "%s()\n", __func__);
896
+
897
+
/* If we know we're connected via v4l2, then there should be a cleanup
898
+
* of the device from userspace either via UVC_EVENT_DISCONNECT or
899
+
* though the video device removal uevent. Allow some time for the
900
+
* application to close out before things get deleted.
901
+
*/
902
+
if (uvc->func_connected) {
903
+
uvcg_dbg(f, "waiting for clean disconnect\n");
904
+
wait_ret = wait_event_interruptible_timeout(uvc->func_connected_queue,
905
+
uvc->func_connected == false, msecs_to_jiffies(500));
906
+
uvcg_dbg(f, "done waiting with ret: %ld\n", wait_ret);
907
+
}
895
908
896
909
device_remove_file(&uvc->vdev.dev, &dev_attr_function_name);
897
910
video_unregister_device(&uvc->vdev);
898
911
v4l2_device_unregister(&uvc->v4l2_dev);
912
+
913
+
if (uvc->func_connected) {
914
+
/* Wait for the release to occur to ensure there are no longer any
915
+
* pending operations that may cause panics when resources are cleaned
916
+
* up.
917
+
*/
918
+
uvcg_warn(f, "%s no clean disconnect, wait for release\n", __func__);
919
+
wait_ret = wait_event_interruptible_timeout(uvc->func_connected_queue,
920
+
uvc->func_connected == false, msecs_to_jiffies(1000));
921
+
uvcg_dbg(f, "done waiting for release with ret: %ld\n", wait_ret);
922
+
}
899
923
900
924
usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
901
925
kfree(uvc->control_buf);
···
939
915
940
916
mutex_init(&uvc->video.mutex);
941
917
uvc->state = UVC_STATE_DISCONNECTED;
918
+
init_waitqueue_head(&uvc->func_connected_queue);
942
919
opts = fi_to_f_uvc_opts(fi);
943
920
944
921
mutex_lock(&opts->lock);
+2
drivers/usb/gadget/function/uvc.h
+2
drivers/usb/gadget/function/uvc.h
···
14
14
#include <linux/spinlock.h>
15
15
#include <linux/usb/composite.h>
16
16
#include <linux/videodev2.h>
17
+
#include <linux/wait.h>
17
18
18
19
#include <media/v4l2-device.h>
19
20
#include <media/v4l2-dev.h>
···
130
129
struct usb_function func;
131
130
struct uvc_video video;
132
131
bool func_connected;
132
+
wait_queue_head_t func_connected_queue;
133
133
134
134
/* Descriptors */
135
135
struct {
+2
-1
drivers/usb/gadget/function/uvc_v4l2.c
+2
-1
drivers/usb/gadget/function/uvc_v4l2.c
···
253
253
254
254
static void uvc_v4l2_disable(struct uvc_device *uvc)
255
255
{
256
-
uvc->func_connected = false;
257
256
uvc_function_disconnect(uvc);
258
257
uvcg_video_enable(&uvc->video, 0);
259
258
uvcg_free_buffers(&uvc->video.queue);
259
+
uvc->func_connected = false;
260
+
wake_up_interruptible(&uvc->func_connected_queue);
260
261
}
261
262
262
263
static int
+2
drivers/usb/gadget/legacy/raw_gadget.c
+2
drivers/usb/gadget/legacy/raw_gadget.c
···
145
145
STATE_DEV_INVALID = 0,
146
146
STATE_DEV_OPENED,
147
147
STATE_DEV_INITIALIZED,
148
+
STATE_DEV_REGISTERING,
148
149
STATE_DEV_RUNNING,
149
150
STATE_DEV_CLOSED,
150
151
STATE_DEV_FAILED
···
509
508
ret = -EINVAL;
510
509
goto out_unlock;
511
510
}
511
+
dev->state = STATE_DEV_REGISTERING;
512
512
spin_unlock_irqrestore(&dev->lock, flags);
513
513
514
514
ret = usb_gadget_probe_driver(&dev->driver);
+19
-71
drivers/usb/host/xhci-mtk-sch.c
+19
-71
drivers/usb/host/xhci-mtk-sch.c
···
19
19
#define HS_BW_BOUNDARY 6144
20
20
/* usb2 spec section11.18.1: at most 188 FS bytes per microframe */
21
21
#define FS_PAYLOAD_MAX 188
22
-
/*
23
-
* max number of microframes for split transfer,
24
-
* for fs isoc in : 1 ss + 1 idle + 7 cs
25
-
*/
26
-
#define TT_MICROFRAMES_MAX 9
27
22
28
23
#define DBG_BUF_EN 64
29
24
···
237
242
238
243
static struct mu3h_sch_ep_info *
239
244
create_sch_ep(struct xhci_hcd_mtk *mtk, struct usb_device *udev,
240
-
struct usb_host_endpoint *ep, struct xhci_ep_ctx *ep_ctx)
245
+
struct usb_host_endpoint *ep)
241
246
{
242
247
struct mu3h_sch_ep_info *sch_ep;
243
248
struct mu3h_sch_bw_info *bw_info;
244
249
struct mu3h_sch_tt *tt = NULL;
245
-
u32 len_bw_budget_table;
246
250
247
251
bw_info = get_bw_info(mtk, udev, ep);
248
252
if (!bw_info)
249
253
return ERR_PTR(-ENODEV);
250
254
251
-
if (is_fs_or_ls(udev->speed))
252
-
len_bw_budget_table = TT_MICROFRAMES_MAX;
253
-
else if ((udev->speed >= USB_SPEED_SUPER)
254
-
&& usb_endpoint_xfer_isoc(&ep->desc))
255
-
len_bw_budget_table = get_esit(ep_ctx);
256
-
else
257
-
len_bw_budget_table = 1;
258
-
259
-
sch_ep = kzalloc(struct_size(sch_ep, bw_budget_table,
260
-
len_bw_budget_table),
261
-
GFP_KERNEL);
255
+
sch_ep = kzalloc(sizeof(*sch_ep), GFP_KERNEL);
262
256
if (!sch_ep)
263
257
return ERR_PTR(-ENOMEM);
264
258
···
279
295
u32 mult;
280
296
u32 esit_pkts;
281
297
u32 max_esit_payload;
282
-
u32 *bwb_table = sch_ep->bw_budget_table;
283
-
int i;
284
298
285
299
ep_type = CTX_TO_EP_TYPE(le32_to_cpu(ep_ctx->ep_info2));
286
300
maxpkt = MAX_PACKET_DECODED(le32_to_cpu(ep_ctx->ep_info2));
···
314
332
*/
315
333
sch_ep->pkts = max_burst + 1;
316
334
sch_ep->bw_cost_per_microframe = maxpkt * sch_ep->pkts;
317
-
bwb_table[0] = sch_ep->bw_cost_per_microframe;
318
335
} else if (sch_ep->speed >= USB_SPEED_SUPER) {
319
336
/* usb3_r1 spec section4.4.7 & 4.4.8 */
320
337
sch_ep->cs_count = 0;
···
330
349
if (ep_type == INT_IN_EP || ep_type == INT_OUT_EP) {
331
350
sch_ep->pkts = esit_pkts;
332
351
sch_ep->num_budget_microframes = 1;
333
-
bwb_table[0] = maxpkt * sch_ep->pkts;
334
352
}
335
353
336
354
if (ep_type == ISOC_IN_EP || ep_type == ISOC_OUT_EP) {
···
346
366
DIV_ROUND_UP(esit_pkts, sch_ep->pkts);
347
367
348
368
sch_ep->repeat = !!(sch_ep->num_budget_microframes > 1);
349
-
sch_ep->bw_cost_per_microframe = maxpkt * sch_ep->pkts;
350
-
351
-
for (i = 0; i < sch_ep->num_budget_microframes - 1; i++)
352
-
bwb_table[i] = sch_ep->bw_cost_per_microframe;
353
-
354
-
/* last one <= bw_cost_per_microframe */
355
-
bwb_table[i] = maxpkt * esit_pkts
356
-
- i * sch_ep->bw_cost_per_microframe;
357
369
}
370
+
sch_ep->bw_cost_per_microframe = maxpkt * sch_ep->pkts;
358
371
} else if (is_fs_or_ls(sch_ep->speed)) {
359
372
sch_ep->pkts = 1; /* at most one packet for each microframe */
360
373
···
357
384
*/
358
385
sch_ep->cs_count = DIV_ROUND_UP(maxpkt, FS_PAYLOAD_MAX);
359
386
sch_ep->num_budget_microframes = sch_ep->cs_count;
360
-
sch_ep->bw_cost_per_microframe =
361
-
(maxpkt < FS_PAYLOAD_MAX) ? maxpkt : FS_PAYLOAD_MAX;
362
-
363
-
/* init budget table */
364
-
if (ep_type == ISOC_OUT_EP) {
365
-
for (i = 0; i < sch_ep->num_budget_microframes; i++)
366
-
bwb_table[i] = sch_ep->bw_cost_per_microframe;
367
-
} else if (ep_type == INT_OUT_EP) {
368
-
/* only first one consumes bandwidth, others as zero */
369
-
bwb_table[0] = sch_ep->bw_cost_per_microframe;
370
-
} else { /* INT_IN_EP or ISOC_IN_EP */
371
-
bwb_table[0] = 0; /* start split */
372
-
bwb_table[1] = 0; /* idle */
373
-
/*
374
-
* due to cs_count will be updated according to cs
375
-
* position, assign all remainder budget array
376
-
* elements as @bw_cost_per_microframe, but only first
377
-
* @num_budget_microframes elements will be used later
378
-
*/
379
-
for (i = 2; i < TT_MICROFRAMES_MAX; i++)
380
-
bwb_table[i] = sch_ep->bw_cost_per_microframe;
381
-
}
387
+
sch_ep->bw_cost_per_microframe = min_t(u32, maxpkt, FS_PAYLOAD_MAX);
382
388
}
383
389
}
384
390
···
374
422
375
423
for (j = 0; j < sch_ep->num_budget_microframes; j++) {
376
424
k = XHCI_MTK_BW_INDEX(base + j);
377
-
bw = sch_bw->bus_bw[k] + sch_ep->bw_budget_table[j];
425
+
bw = sch_bw->bus_bw[k] + sch_ep->bw_cost_per_microframe;
378
426
if (bw > max_bw)
379
427
max_bw = bw;
380
428
}
···
385
433
static void update_bus_bw(struct mu3h_sch_bw_info *sch_bw,
386
434
struct mu3h_sch_ep_info *sch_ep, bool used)
387
435
{
436
+
int bw_updated;
388
437
u32 base;
389
-
int i, j, k;
438
+
int i, j;
439
+
440
+
bw_updated = sch_ep->bw_cost_per_microframe * (used ? 1 : -1);
390
441
391
442
for (i = 0; i < sch_ep->num_esit; i++) {
392
443
base = sch_ep->offset + i * sch_ep->esit;
393
-
for (j = 0; j < sch_ep->num_budget_microframes; j++) {
394
-
k = XHCI_MTK_BW_INDEX(base + j);
395
-
if (used)
396
-
sch_bw->bus_bw[k] += sch_ep->bw_budget_table[j];
397
-
else
398
-
sch_bw->bus_bw[k] -= sch_ep->bw_budget_table[j];
399
-
}
444
+
for (j = 0; j < sch_ep->num_budget_microframes; j++)
445
+
sch_bw->bus_bw[XHCI_MTK_BW_INDEX(base + j)] += bw_updated;
400
446
}
401
447
}
402
448
···
414
464
*/
415
465
for (j = 0; j < sch_ep->num_budget_microframes; j++) {
416
466
k = XHCI_MTK_BW_INDEX(base + j);
417
-
tmp = tt->fs_bus_bw[k] + sch_ep->bw_budget_table[j];
467
+
tmp = tt->fs_bus_bw[k] + sch_ep->bw_cost_per_microframe;
418
468
if (tmp > FS_PAYLOAD_MAX)
419
469
return -ESCH_BW_OVERFLOW;
420
470
}
···
488
538
static void update_sch_tt(struct mu3h_sch_ep_info *sch_ep, bool used)
489
539
{
490
540
struct mu3h_sch_tt *tt = sch_ep->sch_tt;
541
+
int bw_updated;
491
542
u32 base;
492
-
int i, j, k;
543
+
int i, j;
544
+
545
+
bw_updated = sch_ep->bw_cost_per_microframe * (used ? 1 : -1);
493
546
494
547
for (i = 0; i < sch_ep->num_esit; i++) {
495
548
base = sch_ep->offset + i * sch_ep->esit;
496
549
497
-
for (j = 0; j < sch_ep->num_budget_microframes; j++) {
498
-
k = XHCI_MTK_BW_INDEX(base + j);
499
-
if (used)
500
-
tt->fs_bus_bw[k] += sch_ep->bw_budget_table[j];
501
-
else
502
-
tt->fs_bus_bw[k] -= sch_ep->bw_budget_table[j];
503
-
}
550
+
for (j = 0; j < sch_ep->num_budget_microframes; j++)
551
+
tt->fs_bus_bw[XHCI_MTK_BW_INDEX(base + j)] += bw_updated;
504
552
}
505
553
506
554
if (used)
···
658
710
659
711
xhci_dbg(xhci, "%s %s\n", __func__, decode_ep(ep, udev->speed));
660
712
661
-
sch_ep = create_sch_ep(mtk, udev, ep, ep_ctx);
713
+
sch_ep = create_sch_ep(mtk, udev, ep);
662
714
if (IS_ERR_OR_NULL(sch_ep))
663
715
return -ENOMEM;
664
716
-2
drivers/usb/host/xhci-mtk.h
-2
drivers/usb/host/xhci-mtk.h
···
83
83
* times; 1: distribute the (bMaxBurst+1)*(Mult+1) packets
84
84
* according to @pkts and @repeat. normal mode is used by
85
85
* default
86
-
* @bw_budget_table: table to record bandwidth budget per microframe
87
86
*/
88
87
struct mu3h_sch_ep_info {
89
88
u32 esit;
···
108
109
u32 pkts;
109
110
u32 cs_count;
110
111
u32 burst_mode;
111
-
u32 bw_budget_table[];
112
112
};
113
113
114
114
#define MU3C_U3_PORT_MAX 4
+4
drivers/usb/serial/option.c
+4
drivers/usb/serial/option.c
···
2123
2123
.driver_info = RSVD(3) },
2124
2124
{ USB_DEVICE(0x1508, 0x1001), /* Fibocom NL668 (IOT version) */
2125
2125
.driver_info = RSVD(4) | RSVD(5) | RSVD(6) },
2126
+
{ USB_DEVICE(0x1782, 0x4d10) }, /* Fibocom L610 (AT mode) */
2127
+
{ USB_DEVICE_INTERFACE_CLASS(0x1782, 0x4d11, 0xff) }, /* Fibocom L610 (ECM/RNDIS mode) */
2126
2128
{ USB_DEVICE(0x2cb7, 0x0104), /* Fibocom NL678 series */
2127
2129
.driver_info = RSVD(4) | RSVD(5) },
2128
2130
{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x0105, 0xff), /* Fibocom NL678 series */
2129
2131
.driver_info = RSVD(6) },
2132
+
{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x0106, 0xff) }, /* Fibocom MA510 (ECM mode w/ diag intf.) */
2133
+
{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x010a, 0xff) }, /* Fibocom MA510 (ECM mode) */
2130
2134
{ USB_DEVICE_AND_INTERFACE_INFO(0x2cb7, 0x010b, 0xff, 0xff, 0x30) }, /* Fibocom FG150 Diag */
2131
2135
{ USB_DEVICE_AND_INTERFACE_INFO(0x2cb7, 0x010b, 0xff, 0, 0) }, /* Fibocom FG150 AT */
2132
2136
{ USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a0, 0xff) }, /* Fibocom NL668-AM/NL652-EU (laptop MBIM) */
+1
drivers/usb/serial/pl2303.c
+1
drivers/usb/serial/pl2303.c
···
106
106
{ USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
107
107
{ USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
108
108
{ USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
109
+
{ USB_DEVICE(HP_VENDOR_ID, HP_LM930_PRODUCT_ID) },
109
110
{ USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
110
111
{ USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
111
112
{ USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
+1
drivers/usb/serial/pl2303.h
+1
drivers/usb/serial/pl2303.h
···
135
135
#define HP_TD620_PRODUCT_ID 0x0956
136
136
#define HP_LD960_PRODUCT_ID 0x0b39
137
137
#define HP_LD381_PRODUCT_ID 0x0f7f
138
+
#define HP_LM930_PRODUCT_ID 0x0f9b
138
139
#define HP_LCM220_PRODUCT_ID 0x3139
139
140
#define HP_LCM960_PRODUCT_ID 0x3239
140
141
#define HP_LD220_PRODUCT_ID 0x3524
+2
drivers/usb/serial/qcserial.c
+2
drivers/usb/serial/qcserial.c
···
166
166
{DEVICE_SWI(0x1199, 0x9090)}, /* Sierra Wireless EM7565 QDL */
167
167
{DEVICE_SWI(0x1199, 0x9091)}, /* Sierra Wireless EM7565 */
168
168
{DEVICE_SWI(0x1199, 0x90d2)}, /* Sierra Wireless EM9191 QDL */
169
+
{DEVICE_SWI(0x1199, 0xc080)}, /* Sierra Wireless EM7590 QDL */
170
+
{DEVICE_SWI(0x1199, 0xc081)}, /* Sierra Wireless EM7590 */
169
171
{DEVICE_SWI(0x413c, 0x81a2)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */
170
172
{DEVICE_SWI(0x413c, 0x81a3)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */
171
173
{DEVICE_SWI(0x413c, 0x81a4)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */
+1
-1
drivers/usb/typec/tcpm/tcpci.c
+1
-1
drivers/usb/typec/tcpm/tcpci.c
···
877
877
/* Disable chip interrupts before unregistering port */
878
878
err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, 0);
879
879
if (err < 0)
880
-
return err;
880
+
dev_warn(&client->dev, "Failed to disable irqs (%pe)\n", ERR_PTR(err));
881
881
882
882
tcpci_unregister_port(chip->tcpci);
883
883
+26
drivers/usb/typec/tcpm/tcpci_mt6360.c
+26
drivers/usb/typec/tcpm/tcpci_mt6360.c
···
15
15
16
16
#include "tcpci.h"
17
17
18
+
#define MT6360_REG_PHYCTRL1 0x80
19
+
#define MT6360_REG_PHYCTRL3 0x82
20
+
#define MT6360_REG_PHYCTRL7 0x86
18
21
#define MT6360_REG_VCONNCTRL1 0x8C
19
22
#define MT6360_REG_MODECTRL2 0x8F
20
23
#define MT6360_REG_SWRESET 0xA0
···
25
22
#define MT6360_REG_DRPCTRL1 0xA2
26
23
#define MT6360_REG_DRPCTRL2 0xA3
27
24
#define MT6360_REG_I2CTORST 0xBF
25
+
#define MT6360_REG_PHYCTRL11 0xCA
26
+
#define MT6360_REG_RXCTRL1 0xCE
28
27
#define MT6360_REG_RXCTRL2 0xCF
29
28
#define MT6360_REG_CTDCTRL2 0xEC
30
29
···
108
103
/* Enable Rpdet oneshot detection */
109
104
ret = regmap_update_bits(regmap, MT6360_REG_CTDCTRL2, MT6360_RPONESHOT_ENABLE,
110
105
MT6360_RPONESHOT_ENABLE);
106
+
if (ret)
107
+
return ret;
108
+
109
+
/* BMC PHY */
110
+
ret = mt6360_tcpc_write16(regmap, MT6360_REG_PHYCTRL1, 0x3A70);
111
+
if (ret)
112
+
return ret;
113
+
114
+
ret = regmap_write(regmap, MT6360_REG_PHYCTRL3, 0x82);
115
+
if (ret)
116
+
return ret;
117
+
118
+
ret = regmap_write(regmap, MT6360_REG_PHYCTRL7, 0x36);
119
+
if (ret)
120
+
return ret;
121
+
122
+
ret = mt6360_tcpc_write16(regmap, MT6360_REG_PHYCTRL11, 0x3C60);
123
+
if (ret)
124
+
return ret;
125
+
126
+
ret = regmap_write(regmap, MT6360_REG_RXCTRL1, 0xE8);
111
127
if (ret)
112
128
return ret;
113
129