tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'usb-6.19-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB fixes from Greg KH:
"Here are some small USB fixes and new device ids for 6.19-rc6

Included in here are:

- new usb-serial device ids

- dwc3-apple driver fixes to get things working properly on that
hardware platform

- ohci/uhci platfrom driver module soft-deps with ehci to remove a
runtime warning that sometimes shows up on some platforms.

- quirk for broken devices that can not handle reading the BOS
descriptor from them without going crazy.

- usb-serial driver fixes

- xhci driver fixes

- usb gadget driver fixes

All of these except for the last xhci fix has been in linux-next for a
while. The xhci fix has been reported by others to solve the issue for
them, so should be ok"

* tag 'usb-6.19-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb:
xhci: sideband: don't dereference freed ring when removing sideband endpoint
usb: gadget: uvc: retry vb2_reqbufs() with vb_vmalloc_memops if use_sg fail
usb: gadget: uvc: return error from uvcg_queue_init()
usb: gadget: uvc: fix interval_duration calculation
usb: gadget: uvc: fix req_payload_size calculation
usb: dwc3: apple: Ignore USB role switches to the active role
usb: host: xhci-tegra: Use platform_get_irq_optional() for wake IRQs
USB: OHCI/UHCI: Add soft dependencies on ehci_platform
usb: dwc3: apple: Set USB2 PHY mode before dwc3 init
USB: serial: f81232: fix incomplete serial port generation
USB: serial: ftdi_sio: add support for PICAXE AXE027 cable
USB: serial: option: add Telit LE910 MBIM composition
usb: core: add USB_QUIRK_NO_BOS for devices that hang on BOS descriptor
dt-bindings: usb: qcom,dwc3: Correct MSM8994 interrupts
dt-bindings: usb: qcom,dwc3: Correct IPQ5018 interrupts
tcpm: allow looking for role_sw device in the main node
usb: dwc3: Check for USB4 IP_NAME

Linus Torvalds 27983960 5d1765a9

+166 -67
+2 -2
Documentation/devicetree/bindings/usb/qcom,dwc3.yaml
··· 406 406 compatible: 407 407 contains: 408 408 enum: 409 - - qcom,ipq5018-dwc3 410 409 - qcom,ipq6018-dwc3 411 410 - qcom,ipq8074-dwc3 412 411 - qcom,msm8953-dwc3 ··· 427 428 compatible: 428 429 contains: 429 430 enum: 431 + - qcom,msm8994-dwc3 430 432 - qcom,msm8996-dwc3 431 433 - qcom,qcs404-dwc3 432 434 - qcom,sdm660-dwc3 ··· 451 451 compatible: 452 452 contains: 453 453 enum: 454 + - qcom,ipq5018-dwc3 454 455 - qcom,ipq5332-dwc3 455 456 then: 456 457 properties: ··· 489 488 enum: 490 489 - qcom,ipq4019-dwc3 491 490 - qcom,ipq8064-dwc3 492 - - qcom,msm8994-dwc3 493 491 - qcom,qcs615-dwc3 494 492 - qcom,qcs8300-dwc3 495 493 - qcom,qdu1000-dwc3
+2 -2
Documentation/devicetree/bindings/usb/qcom,snps-dwc3.yaml
··· 420 420 compatible: 421 421 contains: 422 422 enum: 423 - - qcom,ipq5018-dwc3 424 423 - qcom,ipq6018-dwc3 425 424 - qcom,ipq8074-dwc3 426 425 - qcom,msm8953-dwc3 ··· 442 443 compatible: 443 444 contains: 444 445 enum: 446 + - qcom,msm8994-dwc3 445 447 - qcom,msm8996-dwc3 446 448 - qcom,qcs404-dwc3 447 449 - qcom,sdm660-dwc3 ··· 467 467 compatible: 468 468 contains: 469 469 enum: 470 + - qcom,ipq5018-dwc3 470 471 - qcom,ipq5332-dwc3 471 472 then: 472 473 properties: ··· 510 509 - qcom,ipq4019-dwc3 511 510 - qcom,ipq8064-dwc3 512 511 - qcom,kaanapali-dwc3 513 - - qcom,msm8994-dwc3 514 512 - qcom,qcs615-dwc3 515 513 - qcom,qcs8300-dwc3 516 514 - qcom,qdu1000-dwc3
+5
drivers/usb/core/config.c
··· 1040 1040 __u8 cap_type; 1041 1041 int ret; 1042 1042 1043 + if (dev->quirks & USB_QUIRK_NO_BOS) { 1044 + dev_dbg(ddev, "skipping BOS descriptor\n"); 1045 + return -ENOMSG; 1046 + } 1047 + 1043 1048 bos = kzalloc(sizeof(*bos), GFP_KERNEL); 1044 1049 if (!bos) 1045 1050 return -ENOMEM;
+3
drivers/usb/core/quirks.c
··· 450 450 { USB_DEVICE(0x0c45, 0x7056), .driver_info = 451 451 USB_QUIRK_IGNORE_REMOTE_WAKEUP }, 452 452 453 + /* Elgato 4K X - BOS descriptor fetch hangs at SuperSpeed Plus */ 454 + { USB_DEVICE(0x0fd9, 0x009b), .driver_info = USB_QUIRK_NO_BOS }, 455 + 453 456 /* Sony Xperia XZ1 Compact (lilac) smartphone in fastboot mode */ 454 457 { USB_DEVICE(0x0fce, 0x0dde), .driver_info = USB_QUIRK_NO_LPM }, 455 458
+2
drivers/usb/dwc3/core.c
··· 993 993 994 994 reg = dwc3_readl(dwc->regs, DWC3_GSNPSID); 995 995 dwc->ip = DWC3_GSNPS_ID(reg); 996 + if (dwc->ip == DWC4_IP) 997 + dwc->ip = DWC32_IP; 996 998 997 999 /* This should read as U3 followed by revision number */ 998 1000 if (DWC3_IP_IS(DWC3)) {
+1
drivers/usb/dwc3/core.h
··· 1265 1265 #define DWC3_IP 0x5533 1266 1266 #define DWC31_IP 0x3331 1267 1267 #define DWC32_IP 0x3332 1268 + #define DWC4_IP 0x3430 1268 1269 1269 1270 u32 revision; 1270 1271
+49 -15
drivers/usb/dwc3/dwc3-apple.c
··· 218 218 return ret; 219 219 } 220 220 221 - static void dwc3_apple_phy_set_mode(struct dwc3_apple *appledwc, enum phy_mode mode) 222 - { 223 - lockdep_assert_held(&appledwc->lock); 224 - 225 - /* 226 - * This platform requires SUSPHY to be enabled here already in order to properly configure 227 - * the PHY and switch dwc3's PIPE interface to USB3 PHY. 228 - */ 229 - dwc3_enable_susphy(&appledwc->dwc, true); 230 - phy_set_mode(appledwc->dwc.usb2_generic_phy[0], mode); 231 - phy_set_mode(appledwc->dwc.usb3_generic_phy[0], mode); 232 - } 233 - 234 221 static int dwc3_apple_init(struct dwc3_apple *appledwc, enum dwc3_apple_state state) 235 222 { 236 223 int ret, ret_reset; 237 224 238 225 lockdep_assert_held(&appledwc->lock); 226 + 227 + /* 228 + * The USB2 PHY on this platform must be configured for host or device mode while it is 229 + * still powered off and before dwc3 tries to access it. Otherwise, the new configuration 230 + * will sometimes only take affect after the *next* time dwc3 is brought up which causes 231 + * the connected device to just not work. 232 + * The USB3 PHY must be configured later after dwc3 has already been initialized. 233 + */ 234 + switch (state) { 235 + case DWC3_APPLE_HOST: 236 + phy_set_mode(appledwc->dwc.usb2_generic_phy[0], PHY_MODE_USB_HOST); 237 + break; 238 + case DWC3_APPLE_DEVICE: 239 + phy_set_mode(appledwc->dwc.usb2_generic_phy[0], PHY_MODE_USB_DEVICE); 240 + break; 241 + default: 242 + /* Unreachable unless there's a bug in this driver */ 243 + return -EINVAL; 244 + } 239 245 240 246 ret = reset_control_deassert(appledwc->reset); 241 247 if (ret) { ··· 263 257 case DWC3_APPLE_HOST: 264 258 appledwc->dwc.dr_mode = USB_DR_MODE_HOST; 265 259 dwc3_apple_set_ptrcap(appledwc, DWC3_GCTL_PRTCAP_HOST); 266 - dwc3_apple_phy_set_mode(appledwc, PHY_MODE_USB_HOST); 260 + /* 261 + * This platform requires SUSPHY to be enabled here already in order to properly 262 + * configure the PHY and switch dwc3's PIPE interface to USB3 PHY. The USB2 PHY 263 + * has already been configured to the correct mode earlier. 264 + */ 265 + dwc3_enable_susphy(&appledwc->dwc, true); 266 + phy_set_mode(appledwc->dwc.usb3_generic_phy[0], PHY_MODE_USB_HOST); 267 267 ret = dwc3_host_init(&appledwc->dwc); 268 268 if (ret) { 269 269 dev_err(appledwc->dev, "Failed to initialize host, ret=%d\n", ret); ··· 280 268 case DWC3_APPLE_DEVICE: 281 269 appledwc->dwc.dr_mode = USB_DR_MODE_PERIPHERAL; 282 270 dwc3_apple_set_ptrcap(appledwc, DWC3_GCTL_PRTCAP_DEVICE); 283 - dwc3_apple_phy_set_mode(appledwc, PHY_MODE_USB_DEVICE); 271 + /* 272 + * This platform requires SUSPHY to be enabled here already in order to properly 273 + * configure the PHY and switch dwc3's PIPE interface to USB3 PHY. The USB2 PHY 274 + * has already been configured to the correct mode earlier. 275 + */ 276 + dwc3_enable_susphy(&appledwc->dwc, true); 277 + phy_set_mode(appledwc->dwc.usb3_generic_phy[0], PHY_MODE_USB_DEVICE); 284 278 ret = dwc3_gadget_init(&appledwc->dwc); 285 279 if (ret) { 286 280 dev_err(appledwc->dev, "Failed to initialize gadget, ret=%d\n", ret); ··· 356 338 int ret; 357 339 358 340 guard(mutex)(&appledwc->lock); 341 + 342 + /* 343 + * Skip role switches if appledwc is already in the desired state. The 344 + * USB-C port controller on M2 and M1/M2 Pro/Max/Ultra devices issues 345 + * additional interrupts which results in usb_role_switch_set_role() 346 + * calls with the current role. 347 + * Ignore those calls here to ensure the USB-C port controller and 348 + * appledwc are in a consistent state. 349 + * This matches the behaviour in __dwc3_set_mode(). 350 + * Do no handle USB_ROLE_NONE for DWC3_APPLE_NO_CABLE and 351 + * DWC3_APPLE_PROBE_PENDING since that is no-op anyway. 352 + */ 353 + if (appledwc->state == DWC3_APPLE_HOST && role == USB_ROLE_HOST) 354 + return 0; 355 + if (appledwc->state == DWC3_APPLE_DEVICE && role == USB_ROLE_DEVICE) 356 + return 0; 359 357 360 358 /* 361 359 * We need to tear all of dwc3 down and re-initialize it every time a cable is
+4
drivers/usb/gadget/function/f_uvc.c
··· 362 362 return ret; 363 363 usb_ep_enable(uvc->video.ep); 364 364 365 + uvc->video.max_req_size = uvc->video.ep->maxpacket 366 + * max_t(unsigned int, uvc->video.ep->maxburst, 1) 367 + * (uvc->video.ep->mult); 368 + 365 369 memset(&v4l2_event, 0, sizeof(v4l2_event)); 366 370 v4l2_event.type = UVC_EVENT_STREAMON; 367 371 v4l2_event_queue(&uvc->vdev, &v4l2_event);
+2 -1
drivers/usb/gadget/function/uvc.h
··· 107 107 unsigned int width; 108 108 unsigned int height; 109 109 unsigned int imagesize; 110 - unsigned int interval; 110 + unsigned int interval; /* in 100ns units */ 111 111 struct mutex mutex; /* protects frame parameters */ 112 112 113 113 unsigned int uvc_num_requests; ··· 117 117 /* Requests */ 118 118 bool is_enabled; /* tracks whether video stream is enabled */ 119 119 unsigned int req_size; 120 + unsigned int max_req_size; 120 121 struct list_head ureqs; /* all uvc_requests allocated by uvc_video */ 121 122 122 123 /* USB requests that the video pump thread can encode into */
+19 -4
drivers/usb/gadget/function/uvc_queue.c
··· 86 86 buf->bytesused = 0; 87 87 } else { 88 88 buf->bytesused = vb2_get_plane_payload(vb, 0); 89 - buf->req_payload_size = 90 - DIV_ROUND_UP(buf->bytesused + 91 - (video->reqs_per_frame * UVCG_REQUEST_HEADER_LEN), 92 - video->reqs_per_frame); 89 + 90 + if (video->reqs_per_frame != 0) { 91 + buf->req_payload_size = 92 + DIV_ROUND_UP(buf->bytesused + 93 + (video->reqs_per_frame * UVCG_REQUEST_HEADER_LEN), 94 + video->reqs_per_frame); 95 + if (buf->req_payload_size > video->req_size) 96 + buf->req_payload_size = video->req_size; 97 + } else { 98 + buf->req_payload_size = video->max_req_size; 99 + } 93 100 } 94 101 95 102 return 0; ··· 182 175 { 183 176 int ret; 184 177 178 + retry: 185 179 ret = vb2_reqbufs(&queue->queue, rb); 180 + if (ret < 0 && queue->use_sg) { 181 + uvc_trace(UVC_TRACE_IOCTL, 182 + "failed to alloc buffer with sg enabled, try non-sg mode\n"); 183 + queue->use_sg = 0; 184 + queue->queue.mem_ops = &vb2_vmalloc_memops; 185 + goto retry; 186 + } 186 187 187 188 return ret ? ret : rb->count; 188 189 }
+7 -7
drivers/usb/gadget/function/uvc_video.c
··· 499 499 { 500 500 struct uvc_device *uvc = container_of(video, struct uvc_device, video); 501 501 struct usb_composite_dev *cdev = uvc->func.config->cdev; 502 - unsigned int interval_duration = video->ep->desc->bInterval * 1250; 502 + unsigned int interval_duration; 503 503 unsigned int max_req_size, req_size, header_size; 504 504 unsigned int nreq; 505 505 506 - max_req_size = video->ep->maxpacket 507 - * max_t(unsigned int, video->ep->maxburst, 1) 508 - * (video->ep->mult); 506 + max_req_size = video->max_req_size; 509 507 510 508 if (!usb_endpoint_xfer_isoc(video->ep->desc)) { 511 509 video->req_size = max_req_size; ··· 513 515 return; 514 516 } 515 517 518 + interval_duration = 2 << (video->ep->desc->bInterval - 1); 516 519 if (cdev->gadget->speed < USB_SPEED_HIGH) 517 - interval_duration = video->ep->desc->bInterval * 10000; 520 + interval_duration *= 10000; 521 + else 522 + interval_duration *= 1250; 518 523 519 524 nreq = DIV_ROUND_UP(video->interval, interval_duration); 520 525 ··· 838 837 video->interval = 666666; 839 838 840 839 /* Initialize the video buffers queue. */ 841 - uvcg_queue_init(&video->queue, uvc->v4l2_dev.dev->parent, 840 + return uvcg_queue_init(&video->queue, uvc->v4l2_dev.dev->parent, 842 841 V4L2_BUF_TYPE_VIDEO_OUTPUT, &video->mutex); 843 - return 0; 844 842 }
+1
drivers/usb/host/ohci-platform.c
··· 392 392 MODULE_AUTHOR("Hauke Mehrtens"); 393 393 MODULE_AUTHOR("Alan Stern"); 394 394 MODULE_LICENSE("GPL"); 395 + MODULE_SOFTDEP("pre: ehci_platform");
+1
drivers/usb/host/uhci-platform.c
··· 211 211 .of_match_table = platform_uhci_ids, 212 212 }, 213 213 }; 214 + MODULE_SOFTDEP("pre: ehci_platform");
-1
drivers/usb/host/xhci-sideband.c
··· 210 210 return -ENODEV; 211 211 212 212 __xhci_sideband_remove_endpoint(sb, ep); 213 - xhci_initialize_ring_info(ep->ring); 214 213 215 214 return 0; 216 215 }
+1 -1
drivers/usb/host/xhci-tegra.c
··· 1563 1563 for (i = 0; i < tegra->soc->max_num_wakes; i++) { 1564 1564 struct irq_data *data; 1565 1565 1566 - tegra->wake_irqs[i] = platform_get_irq(pdev, i + WAKE_IRQ_START_INDEX); 1566 + tegra->wake_irqs[i] = platform_get_irq_optional(pdev, i + WAKE_IRQ_START_INDEX); 1567 1567 if (tegra->wake_irqs[i] < 0) 1568 1568 break; 1569 1569
+12 -3
drivers/usb/host/xhci.c
··· 2898 2898 gfp_t gfp_flags) 2899 2899 { 2900 2900 struct xhci_command *command; 2901 + struct xhci_ep_ctx *ep_ctx; 2901 2902 unsigned long flags; 2902 - int ret; 2903 + int ret = -ENODEV; 2903 2904 2904 2905 command = xhci_alloc_command(xhci, true, gfp_flags); 2905 2906 if (!command) 2906 2907 return -ENOMEM; 2907 2908 2908 2909 spin_lock_irqsave(&xhci->lock, flags); 2909 - ret = xhci_queue_stop_endpoint(xhci, command, ep->vdev->slot_id, 2910 - ep->ep_index, suspend); 2910 + 2911 + /* make sure endpoint exists and is running before stopping it */ 2912 + if (ep->ring) { 2913 + ep_ctx = xhci_get_ep_ctx(xhci, ep->vdev->out_ctx, ep->ep_index); 2914 + if (GET_EP_CTX_STATE(ep_ctx) == EP_STATE_RUNNING) 2915 + ret = xhci_queue_stop_endpoint(xhci, command, 2916 + ep->vdev->slot_id, 2917 + ep->ep_index, suspend); 2918 + } 2919 + 2911 2920 if (ret < 0) { 2912 2921 spin_unlock_irqrestore(&xhci->lock, flags); 2913 2922 goto out;
+47 -30
drivers/usb/serial/f81232.c
··· 70 70 #define F81232_REGISTER_REQUEST 0xa0 71 71 #define F81232_GET_REGISTER 0xc0 72 72 #define F81232_SET_REGISTER 0x40 73 - #define F81534A_ACCESS_REG_RETRY 2 74 73 75 74 #define SERIAL_BASE_ADDRESS 0x0120 76 75 #define RECEIVE_BUFFER_REGISTER (0x00 + SERIAL_BASE_ADDRESS) ··· 823 824 static int f81534a_ctrl_set_register(struct usb_interface *intf, u16 reg, 824 825 u16 size, void *val) 825 826 { 826 - struct usb_device *dev = interface_to_usbdev(intf); 827 - int retry = F81534A_ACCESS_REG_RETRY; 828 - int status; 827 + return usb_control_msg_send(interface_to_usbdev(intf), 828 + 0, 829 + F81232_REGISTER_REQUEST, 830 + F81232_SET_REGISTER, 831 + reg, 832 + 0, 833 + val, 834 + size, 835 + USB_CTRL_SET_TIMEOUT, 836 + GFP_KERNEL); 837 + } 829 838 830 - while (retry--) { 831 - status = usb_control_msg_send(dev, 832 - 0, 833 - F81232_REGISTER_REQUEST, 834 - F81232_SET_REGISTER, 835 - reg, 836 - 0, 837 - val, 838 - size, 839 - USB_CTRL_SET_TIMEOUT, 840 - GFP_KERNEL); 841 - if (status) { 842 - status = usb_translate_errors(status); 843 - if (status == -EIO) 844 - continue; 845 - } 846 - 847 - break; 848 - } 849 - 850 - if (status) { 851 - dev_err(&intf->dev, "failed to set register 0x%x: %d\n", 852 - reg, status); 853 - } 854 - 855 - return status; 839 + static int f81534a_ctrl_get_register(struct usb_interface *intf, u16 reg, 840 + u16 size, void *val) 841 + { 842 + return usb_control_msg_recv(interface_to_usbdev(intf), 843 + 0, 844 + F81232_REGISTER_REQUEST, 845 + F81232_GET_REGISTER, 846 + reg, 847 + 0, 848 + val, 849 + size, 850 + USB_CTRL_GET_TIMEOUT, 851 + GFP_KERNEL); 856 852 } 857 853 858 854 static int f81534a_ctrl_enable_all_ports(struct usb_interface *intf, bool en) ··· 863 869 * bit 0~11 : Serial port enable bit. 864 870 */ 865 871 if (en) { 872 + /* 873 + * The Fintek F81532A/534A/535/536 family relies on the 874 + * F81534A_CTRL_CMD_ENABLE_PORT (116h) register during 875 + * initialization to both determine serial port status and 876 + * control port creation. 877 + * 878 + * If the driver experiences fast load/unload cycles, the 879 + * device state may becomes unstable, resulting in the 880 + * incomplete generation of serial ports. 881 + * 882 + * Performing a dummy read operation on the register prior 883 + * to the initial write command resolves the issue. 884 + * 885 + * This clears the device's stale internal state. Subsequent 886 + * write operations will correctly generate all serial ports. 887 + */ 888 + status = f81534a_ctrl_get_register(intf, 889 + F81534A_CTRL_CMD_ENABLE_PORT, 890 + sizeof(enable), 891 + enable); 892 + if (status) 893 + return status; 894 + 866 895 enable[0] = 0xff; 867 896 enable[1] = 0x8f; 868 897 }
+1
drivers/usb/serial/ftdi_sio.c
··· 848 848 { USB_DEVICE_INTERFACE_NUMBER(FTDI_VID, LMI_LM3S_DEVEL_BOARD_PID, 1) }, 849 849 { USB_DEVICE_INTERFACE_NUMBER(FTDI_VID, LMI_LM3S_EVAL_BOARD_PID, 1) }, 850 850 { USB_DEVICE_INTERFACE_NUMBER(FTDI_VID, LMI_LM3S_ICDI_BOARD_PID, 1) }, 851 + { USB_DEVICE(FTDI_VID, FTDI_AXE027_PID) }, 851 852 { USB_DEVICE_INTERFACE_NUMBER(FTDI_VID, FTDI_TURTELIZER_PID, 1) }, 852 853 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) }, 853 854 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_SCU18) },
+2
drivers/usb/serial/ftdi_sio_ids.h
··· 96 96 #define LMI_LM3S_EVAL_BOARD_PID 0xbcd9 97 97 #define LMI_LM3S_ICDI_BOARD_PID 0xbcda 98 98 99 + #define FTDI_AXE027_PID 0xBD90 /* PICAXE AXE027 USB download cable */ 100 + 99 101 #define FTDI_TURTELIZER_PID 0xBDC8 /* JTAG/RS-232 adapter by egnite GmbH */ 100 102 101 103 /* OpenDCC (www.opendcc.de) product id */
+1
drivers/usb/serial/option.c
··· 1505 1505 { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1231, 0xff), /* Telit LE910Cx (RNDIS) */ 1506 1506 .driver_info = NCTRL(2) | RSVD(3) }, 1507 1507 { USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x1250, 0xff, 0x00, 0x00) }, /* Telit LE910Cx (rmnet) */ 1508 + { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1252, 0xff) }, /* Telit LE910Cx (MBIM) */ 1508 1509 { USB_DEVICE(TELIT_VENDOR_ID, 0x1260), 1509 1510 .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) }, 1510 1511 { USB_DEVICE(TELIT_VENDOR_ID, 0x1261),
+1 -1
drivers/usb/typec/tcpm/tcpm.c
··· 7890 7890 port->partner_desc.identity = &port->partner_ident; 7891 7891 7892 7892 port->role_sw = fwnode_usb_role_switch_get(tcpc->fwnode); 7893 - if (!port->role_sw) 7893 + if (IS_ERR_OR_NULL(port->role_sw)) 7894 7894 port->role_sw = usb_role_switch_get(port->dev); 7895 7895 if (IS_ERR(port->role_sw)) { 7896 7896 err = PTR_ERR(port->role_sw);
+3
include/linux/usb/quirks.h
··· 75 75 /* short SET_ADDRESS request timeout */ 76 76 #define USB_QUIRK_SHORT_SET_ADDRESS_REQ_TIMEOUT BIT(16) 77 77 78 + /* skip BOS descriptor request */ 79 + #define USB_QUIRK_NO_BOS BIT(17) 80 + 78 81 #endif /* __LINUX_USB_QUIRKS_H */