Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'usb-6.11-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB fixes from Greg KH:
"Here are a number of small USB driver fixes for reported issues for
6.11-rc3. Included in here are:
- usb serial driver MODULE_DESCRIPTION() updates
- usb serial driver fixes
- typec driver fixes
- usb-ip driver fix
- gadget driver fixes
- dt binding update
All of these have been in linux-next with no reported issues"
* tag 'usb-6.11-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb:
usb: typec: ucsi: Fix a deadlock in ucsi_send_command_common()
usb: typec: tcpm: avoid sink goto SNK_UNATTACHED state if not received source capability message
usb: gadget: f_fs: pull out f->disable() from ffs_func_set_alt()
usb: gadget: f_fs: restore ffs_func_disable() functionality
USB: serial: debug: do not echo input by default
usb: typec: tipd: Delete extra semi-colon
usb: typec: tipd: Fix dereferencing freeing memory in tps6598x_apply_patch()
usb: gadget: u_serial: Set start_delayed during suspend
usb: typec: tcpci: Fix error code in tcpci_check_std_output_cap()
usb: typec: fsa4480: Check if the chip is really there
usb: gadget: core: Check for unset descriptor
usb: vhci-hcd: Do not drop references before new references are gained
usb: gadget: u_audio: Check return codes from usb_ep_enable and config_ep_by_speed.
usb: gadget: midi2: Fix the response for FB info with block 0xff
dt-bindings: usb: microchip,usb2514: Add USB2517 compatible
USB: serial: garmin_gps: use struct_size() to allocate pkt
USB: serial: garmin_gps: annotate struct garmin_packet with __counted_by
USB: serial: add missing MODULE_DESCRIPTION() macros
USB: serial: spcp8x5: remove unused struct 'spcp8x5_usb_ctrl_arg'
+119
-59
+1
Documentation/devicetree/bindings/usb/microchip,usb2514.yaml
+1
Documentation/devicetree/bindings/usb/microchip,usb2514.yaml
+20
-12
drivers/usb/gadget/function/f_fs.c
+20
-12
drivers/usb/gadget/function/f_fs.c
···
3734
3734
if (alt > MAX_ALT_SETTINGS)
3735
3735
return -EINVAL;
3736
3736
3737
-
if (alt != (unsigned)-1) {
3738
-
intf = ffs_func_revmap_intf(func, interface);
3739
-
if (intf < 0)
3740
-
return intf;
3741
-
}
3737
+
intf = ffs_func_revmap_intf(func, interface);
3738
+
if (intf < 0)
3739
+
return intf;
3742
3740
3743
3741
if (ffs->func)
3744
3742
ffs_func_eps_disable(ffs->func);
···
3751
3753
if (ffs->state != FFS_ACTIVE)
3752
3754
return -ENODEV;
3753
3755
3754
-
if (alt == (unsigned)-1) {
3755
-
ffs->func = NULL;
3756
-
ffs_event_add(ffs, FUNCTIONFS_DISABLE);
3757
-
return 0;
3758
-
}
3759
-
3760
3756
ffs->func = func;
3761
3757
ret = ffs_func_eps_enable(func);
3762
3758
if (ret >= 0) {
···
3762
3770
3763
3771
static void ffs_func_disable(struct usb_function *f)
3764
3772
{
3765
-
ffs_func_set_alt(f, 0, (unsigned)-1);
3773
+
struct ffs_function *func = ffs_func_from_usb(f);
3774
+
struct ffs_data *ffs = func->ffs;
3775
+
3776
+
if (ffs->func)
3777
+
ffs_func_eps_disable(ffs->func);
3778
+
3779
+
if (ffs->state == FFS_DEACTIVATED) {
3780
+
ffs->state = FFS_CLOSING;
3781
+
INIT_WORK(&ffs->reset_work, ffs_reset_work);
3782
+
schedule_work(&ffs->reset_work);
3783
+
return;
3784
+
}
3785
+
3786
+
if (ffs->state == FFS_ACTIVE) {
3787
+
ffs->func = NULL;
3788
+
ffs_event_add(ffs, FUNCTIONFS_DISABLE);
3789
+
}
3766
3790
}
3767
3791
3768
3792
static int ffs_func_setup(struct usb_function *f,
+15
-6
drivers/usb/gadget/function/f_midi2.c
+15
-6
drivers/usb/gadget/function/f_midi2.c
···
642
642
if (format)
643
643
return; // invalid
644
644
blk = (*data >> 8) & 0xff;
645
-
if (blk >= ep->num_blks)
646
-
return;
647
-
if (*data & UMP_STREAM_MSG_REQUEST_FB_INFO)
648
-
reply_ump_stream_fb_info(ep, blk);
649
-
if (*data & UMP_STREAM_MSG_REQUEST_FB_NAME)
650
-
reply_ump_stream_fb_name(ep, blk);
645
+
if (blk == 0xff) {
646
+
/* inquiry for all blocks */
647
+
for (blk = 0; blk < ep->num_blks; blk++) {
648
+
if (*data & UMP_STREAM_MSG_REQUEST_FB_INFO)
649
+
reply_ump_stream_fb_info(ep, blk);
650
+
if (*data & UMP_STREAM_MSG_REQUEST_FB_NAME)
651
+
reply_ump_stream_fb_name(ep, blk);
652
+
}
653
+
} else if (blk < ep->num_blks) {
654
+
/* only the specified block */
655
+
if (*data & UMP_STREAM_MSG_REQUEST_FB_INFO)
656
+
reply_ump_stream_fb_info(ep, blk);
657
+
if (*data & UMP_STREAM_MSG_REQUEST_FB_NAME)
658
+
reply_ump_stream_fb_name(ep, blk);
659
+
}
651
660
return;
652
661
}
653
662
}
+34
-8
drivers/usb/gadget/function/u_audio.c
+34
-8
drivers/usb/gadget/function/u_audio.c
···
592
592
struct usb_ep *ep, *ep_fback;
593
593
struct uac_rtd_params *prm;
594
594
struct uac_params *params = &audio_dev->params;
595
-
int req_len, i;
595
+
int req_len, i, ret;
596
596
597
597
prm = &uac->c_prm;
598
598
dev_dbg(dev, "start capture with rate %d\n", prm->srate);
599
599
ep = audio_dev->out_ep;
600
-
config_ep_by_speed(gadget, &audio_dev->func, ep);
600
+
ret = config_ep_by_speed(gadget, &audio_dev->func, ep);
601
+
if (ret < 0) {
602
+
dev_err(dev, "config_ep_by_speed for out_ep failed (%d)\n", ret);
603
+
return ret;
604
+
}
605
+
601
606
req_len = ep->maxpacket;
602
607
603
608
prm->ep_enabled = true;
604
-
usb_ep_enable(ep);
609
+
ret = usb_ep_enable(ep);
610
+
if (ret < 0) {
611
+
dev_err(dev, "usb_ep_enable failed for out_ep (%d)\n", ret);
612
+
return ret;
613
+
}
605
614
606
615
for (i = 0; i < params->req_number; i++) {
607
616
if (!prm->reqs[i]) {
···
638
629
return 0;
639
630
640
631
/* Setup feedback endpoint */
641
-
config_ep_by_speed(gadget, &audio_dev->func, ep_fback);
632
+
ret = config_ep_by_speed(gadget, &audio_dev->func, ep_fback);
633
+
if (ret < 0) {
634
+
dev_err(dev, "config_ep_by_speed in_ep_fback failed (%d)\n", ret);
635
+
return ret; // TODO: Clean up out_ep
636
+
}
637
+
642
638
prm->fb_ep_enabled = true;
643
-
usb_ep_enable(ep_fback);
639
+
ret = usb_ep_enable(ep_fback);
640
+
if (ret < 0) {
641
+
dev_err(dev, "usb_ep_enable failed for in_ep_fback (%d)\n", ret);
642
+
return ret; // TODO: Clean up out_ep
643
+
}
644
644
req_len = ep_fback->maxpacket;
645
645
646
646
req_fback = usb_ep_alloc_request(ep_fback, GFP_ATOMIC);
···
705
687
struct uac_params *params = &audio_dev->params;
706
688
unsigned int factor;
707
689
const struct usb_endpoint_descriptor *ep_desc;
708
-
int req_len, i;
690
+
int req_len, i, ret;
709
691
unsigned int p_pktsize;
710
692
711
693
prm = &uac->p_prm;
712
694
dev_dbg(dev, "start playback with rate %d\n", prm->srate);
713
695
ep = audio_dev->in_ep;
714
-
config_ep_by_speed(gadget, &audio_dev->func, ep);
696
+
ret = config_ep_by_speed(gadget, &audio_dev->func, ep);
697
+
if (ret < 0) {
698
+
dev_err(dev, "config_ep_by_speed for in_ep failed (%d)\n", ret);
699
+
return ret;
700
+
}
715
701
716
702
ep_desc = ep->desc;
717
703
/*
···
742
720
uac->p_residue_mil = 0;
743
721
744
722
prm->ep_enabled = true;
745
-
usb_ep_enable(ep);
723
+
ret = usb_ep_enable(ep);
724
+
if (ret < 0) {
725
+
dev_err(dev, "usb_ep_enable failed for in_ep (%d)\n", ret);
726
+
return ret;
727
+
}
746
728
747
729
for (i = 0; i < params->req_number; i++) {
748
730
if (!prm->reqs[i]) {
+1
drivers/usb/gadget/function/u_serial.c
+1
drivers/usb/gadget/function/u_serial.c
+4
-6
drivers/usb/gadget/udc/core.c
+4
-6
drivers/usb/gadget/udc/core.c
···
118
118
goto out;
119
119
120
120
/* UDC drivers can't handle endpoints with maxpacket size 0 */
121
-
if (usb_endpoint_maxp(ep->desc) == 0) {
122
-
/*
123
-
* We should log an error message here, but we can't call
124
-
* dev_err() because there's no way to find the gadget
125
-
* given only ep.
126
-
*/
121
+
if (!ep->desc || usb_endpoint_maxp(ep->desc) == 0) {
122
+
WARN_ONCE(1, "%s: ep%d (%s) has %s\n", __func__, ep->address, ep->name,
123
+
(!ep->desc) ? "NULL descriptor" : "maxpacket 0");
124
+
127
125
ret = -EINVAL;
128
126
goto out;
129
127
}
+1
drivers/usb/serial/ch341.c
+1
drivers/usb/serial/ch341.c
+2
-3
drivers/usb/serial/garmin_gps.c
+2
-3
drivers/usb/serial/garmin_gps.c
···
104
104
int seq;
105
105
/* the real size of the data array, always > 0 */
106
106
int size;
107
-
__u8 data[];
107
+
__u8 data[] __counted_by(size);
108
108
};
109
109
110
110
/* structure used to keep the current state of the driver */
···
267
267
268
268
/* process only packets containing data ... */
269
269
if (data_length) {
270
-
pkt = kmalloc(sizeof(struct garmin_packet)+data_length,
271
-
GFP_ATOMIC);
270
+
pkt = kmalloc(struct_size(pkt, data, data_length), GFP_ATOMIC);
272
271
if (!pkt)
273
272
return 0;
274
273
+1
drivers/usb/serial/mxuport.c
+1
drivers/usb/serial/mxuport.c
+1
drivers/usb/serial/qcaux.c
+1
drivers/usb/serial/qcaux.c
-10
drivers/usb/serial/spcp8x5.c
-10
drivers/usb/serial/spcp8x5.c
···
49
49
};
50
50
MODULE_DEVICE_TABLE(usb, id_table);
51
51
52
-
struct spcp8x5_usb_ctrl_arg {
53
-
u8 type;
54
-
u8 cmd;
55
-
u8 cmd_type;
56
-
u16 value;
57
-
u16 index;
58
-
u16 length;
59
-
};
60
-
61
-
62
52
/* spcp8x5 spec register define */
63
53
#define MCR_CONTROL_LINE_RTS 0x02
64
54
#define MCR_CONTROL_LINE_DTR 0x01
+1
drivers/usb/serial/symbolserial.c
+1
drivers/usb/serial/symbolserial.c
+1
drivers/usb/serial/usb-serial-simple.c
+1
drivers/usb/serial/usb-serial-simple.c
+8
drivers/usb/serial/usb_debug.c
+8
drivers/usb/serial/usb_debug.c
···
76
76
usb_serial_generic_process_read_urb(urb);
77
77
}
78
78
79
+
static void usb_debug_init_termios(struct tty_struct *tty)
80
+
{
81
+
tty->termios.c_lflag &= ~(ECHO | ECHONL);
82
+
}
83
+
79
84
static struct usb_serial_driver debug_device = {
80
85
.driver = {
81
86
.owner = THIS_MODULE,
···
90
85
.num_ports = 1,
91
86
.bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE,
92
87
.break_ctl = usb_debug_break_ctl,
88
+
.init_termios = usb_debug_init_termios,
93
89
.process_read_urb = usb_debug_process_read_urb,
94
90
};
95
91
···
102
96
.id_table = dbc_id_table,
103
97
.num_ports = 1,
104
98
.break_ctl = usb_debug_break_ctl,
99
+
.init_termios = usb_debug_init_termios,
105
100
.process_read_urb = usb_debug_process_read_urb,
106
101
};
107
102
···
111
104
};
112
105
113
106
module_usb_serial_driver(serial_drivers, id_table_combined);
107
+
MODULE_DESCRIPTION("USB Debug cable driver");
114
108
MODULE_LICENSE("GPL v2");
+14
drivers/usb/typec/mux/fsa4480.c
+14
drivers/usb/typec/mux/fsa4480.c
···
13
13
#include <linux/usb/typec_dp.h>
14
14
#include <linux/usb/typec_mux.h>
15
15
16
+
#define FSA4480_DEVICE_ID 0x00
17
+
#define FSA4480_DEVICE_ID_VENDOR_ID GENMASK(7, 6)
18
+
#define FSA4480_DEVICE_ID_VERSION_ID GENMASK(5, 3)
19
+
#define FSA4480_DEVICE_ID_REV_ID GENMASK(2, 0)
16
20
#define FSA4480_SWITCH_ENABLE 0x04
17
21
#define FSA4480_SWITCH_SELECT 0x05
18
22
#define FSA4480_SWITCH_STATUS1 0x07
···
255
251
struct typec_switch_desc sw_desc = { };
256
252
struct typec_mux_desc mux_desc = { };
257
253
struct fsa4480 *fsa;
254
+
int val = 0;
258
255
int ret;
259
256
260
257
fsa = devm_kzalloc(dev, sizeof(*fsa), GFP_KERNEL);
···
272
267
fsa->regmap = devm_regmap_init_i2c(client, &fsa4480_regmap_config);
273
268
if (IS_ERR(fsa->regmap))
274
269
return dev_err_probe(dev, PTR_ERR(fsa->regmap), "failed to initialize regmap\n");
270
+
271
+
ret = regmap_read(fsa->regmap, FSA4480_DEVICE_ID, &val);
272
+
if (ret || !val)
273
+
return dev_err_probe(dev, -ENODEV, "FSA4480 not found\n");
274
+
275
+
dev_dbg(dev, "Found FSA4480 v%lu.%lu (Vendor ID = %lu)\n",
276
+
FIELD_GET(FSA4480_DEVICE_ID_VERSION_ID, val),
277
+
FIELD_GET(FSA4480_DEVICE_ID_REV_ID, val),
278
+
FIELD_GET(FSA4480_DEVICE_ID_VENDOR_ID, val));
275
279
276
280
/* Safe mode */
277
281
fsa->cur_enable = FSA4480_ENABLE_DEVICE | FSA4480_ENABLE_USB;
+1
-1
drivers/usb/typec/tcpm/tcpci.c
+1
-1
drivers/usb/typec/tcpm/tcpci.c
+1
-1
drivers/usb/typec/tcpm/tcpm.c
+1
-1
drivers/usb/typec/tcpm/tcpm.c
+2
-2
drivers/usb/typec/tipd/core.c
+2
-2
drivers/usb/typec/tipd/core.c
···
1191
1191
dev_info(tps->dev, "Firmware update succeeded\n");
1192
1192
1193
1193
release_fw:
1194
-
release_firmware(fw);
1195
1194
if (ret) {
1196
1195
dev_err(tps->dev, "Failed to write patch %s of %zu bytes\n",
1197
1196
firmware_name, fw->size);
1198
1197
}
1198
+
release_firmware(fw);
1199
1199
1200
1200
return ret;
1201
-
};
1201
+
}
1202
1202
1203
1203
static int cd321x_init(struct tps6598x *tps)
1204
1204
{
+4
-7
drivers/usb/typec/ucsi/ucsi.c
+4
-7
drivers/usb/typec/ucsi/ucsi.c
···
238
238
mutex_lock(&ucsi->ppm_lock);
239
239
240
240
ret = ucsi_run_command(ucsi, cmd, &cci, data, size, conn_ack);
241
-
if (cci & UCSI_CCI_BUSY) {
242
-
ret = ucsi_run_command(ucsi, UCSI_CANCEL, &cci, NULL, 0, false);
243
-
return ret ? ret : -EBUSY;
244
-
}
245
-
246
-
if (cci & UCSI_CCI_ERROR)
247
-
return ucsi_read_error(ucsi, connector_num);
241
+
if (cci & UCSI_CCI_BUSY)
242
+
ret = ucsi_run_command(ucsi, UCSI_CANCEL, &cci, NULL, 0, false) ?: -EBUSY;
243
+
else if (cci & UCSI_CCI_ERROR)
244
+
ret = ucsi_read_error(ucsi, connector_num);
248
245
249
246
mutex_unlock(&ucsi->ppm_lock);
250
247
return ret;
+6
-3
drivers/usb/usbip/vhci_hcd.c
+6
-3
drivers/usb/usbip/vhci_hcd.c
···
745
745
*
746
746
*/
747
747
if (usb_pipedevice(urb->pipe) == 0) {
748
+
struct usb_device *old;
748
749
__u8 type = usb_pipetype(urb->pipe);
749
750
struct usb_ctrlrequest *ctrlreq =
750
751
(struct usb_ctrlrequest *) urb->setup_packet;
···
756
755
goto no_need_xmit;
757
756
}
758
757
758
+
old = vdev->udev;
759
759
switch (ctrlreq->bRequest) {
760
760
case USB_REQ_SET_ADDRESS:
761
761
/* set_address may come when a device is reset */
762
762
dev_info(dev, "SetAddress Request (%d) to port %d\n",
763
763
ctrlreq->wValue, vdev->rhport);
764
764
765
-
usb_put_dev(vdev->udev);
766
765
vdev->udev = usb_get_dev(urb->dev);
766
+
usb_put_dev(old);
767
767
768
768
spin_lock(&vdev->ud.lock);
769
769
vdev->ud.status = VDEV_ST_USED;
···
783
781
usbip_dbg_vhci_hc(
784
782
"Not yet?:Get_Descriptor to device 0 (get max pipe size)\n");
785
783
786
-
usb_put_dev(vdev->udev);
787
784
vdev->udev = usb_get_dev(urb->dev);
785
+
usb_put_dev(old);
788
786
goto out;
789
787
790
788
default:
···
1069
1067
static void vhci_device_reset(struct usbip_device *ud)
1070
1068
{
1071
1069
struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
1070
+
struct usb_device *old = vdev->udev;
1072
1071
unsigned long flags;
1073
1072
1074
1073
spin_lock_irqsave(&ud->lock, flags);
···
1077
1074
vdev->speed = 0;
1078
1075
vdev->devid = 0;
1079
1076
1080
-
usb_put_dev(vdev->udev);
1081
1077
vdev->udev = NULL;
1078
+
usb_put_dev(old);
1082
1079
1083
1080
if (ud->tcp_socket) {
1084
1081
sockfd_put(ud->tcp_socket);