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-5.13-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB / Thunderbolt fixes from Greg KH:
"Here are a number of tiny USB and Thunderbolt driver fixes for
5.13-rc4.

They consist of:

- thunderbolt fixes for some NVM bound issues

- xhci fixes for reported problems

- control-request fixups

- documentation build warning fixes

- new usb-serial driver device ids

- typec bugfixes for reported issues

- usbfs warning fixups (could be triggered from userspace)

- other tiny fixes for reported problems.

All of these have been in linux-next with no reported issues"

* tag 'usb-5.13-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (22 commits)
xhci: Fix 5.12 regression of missing xHC cache clearing command after a Stall
xhci: fix giving back URB with incorrect status regression in 5.12
usb: gadget: udc: renesas_usb3: Fix a race in usb3_start_pipen()
usb: typec: tcpm: Respond Not_Supported if no snk_vdo
usb: typec: tcpm: Properly interrupt VDM AMS
USB: trancevibrator: fix control-request direction
usb: Restore the usb_header label
usb: typec: tcpm: Use LE to CPU conversion when accessing msg->header
usb: typec: ucsi: Clear pending after acking connector change
usb: typec: mux: Fix matching with typec_altmode_desc
misc/uss720: fix memory leak in uss720_probe
usb: dwc3: gadget: Properly track pending and queued SG
USB: usbfs: Don't WARN about excessively large memory allocations
thunderbolt: usb4: Fix NVM read buffer bounds and offset issue
thunderbolt: dma_port: Fix NVM read buffer bounds and offset issue
usb: chipidea: udc: assign interrupt number to USB gadget structure
usb: cdnsp: Fix lack of removing request from pending list.
usb: cdns3: Fix runtime PM imbalance on error
USB: serial: pl2303: add device id for ADLINK ND-6530 GC
USB: serial: ti_usb_3410_5052: add startech.com device id
...

Linus Torvalds 523d0b1e 22447828

+112 -44
+2
Documentation/driver-api/usb/usb.rst
··· 123 123 In addition, some functions useful for creating debugging output are 124 124 defined in ``drivers/usb/common/debug.c``. 125 125 126 + .. _usb_header: 127 + 126 128 Host-Side Data Types and Macros 127 129 =============================== 128 130
+6 -5
drivers/thunderbolt/dma_port.c
··· 366 366 void *buf, size_t size) 367 367 { 368 368 unsigned int retries = DMA_PORT_RETRIES; 369 - unsigned int offset; 370 - 371 - offset = address & 3; 372 - address = address & ~3; 373 369 374 370 do { 375 - u32 nbytes = min_t(u32, size, MAIL_DATA_DWORDS * 4); 371 + unsigned int offset; 372 + size_t nbytes; 376 373 int ret; 374 + 375 + offset = address & 3; 376 + nbytes = min_t(size_t, size + offset, MAIL_DATA_DWORDS * 4); 377 377 378 378 ret = dma_port_flash_read_block(dma, address, dma->buf, 379 379 ALIGN(nbytes, 4)); ··· 386 386 return ret; 387 387 } 388 388 389 + nbytes -= offset; 389 390 memcpy(buf, dma->buf + offset, nbytes); 390 391 391 392 size -= nbytes;
+5 -4
drivers/thunderbolt/usb4.c
··· 68 68 unsigned int retries = USB4_DATA_RETRIES; 69 69 unsigned int offset; 70 70 71 - offset = address & 3; 72 - address = address & ~3; 73 - 74 71 do { 75 - size_t nbytes = min_t(size_t, size, USB4_DATA_DWORDS * 4); 76 72 unsigned int dwaddress, dwords; 77 73 u8 data[USB4_DATA_DWORDS * 4]; 74 + size_t nbytes; 78 75 int ret; 76 + 77 + offset = address & 3; 78 + nbytes = min_t(size_t, size + offset, USB4_DATA_DWORDS * 4); 79 79 80 80 dwaddress = address / 4; 81 81 dwords = ALIGN(nbytes, 4) / 4; ··· 87 87 return ret; 88 88 } 89 89 90 + nbytes -= offset; 90 91 memcpy(buf, data + offset, nbytes); 91 92 92 93 size -= nbytes;
+3 -1
drivers/usb/cdns3/cdns3-gadget.c
··· 3268 3268 pm_runtime_get_sync(cdns->dev); 3269 3269 3270 3270 ret = cdns3_gadget_start(cdns); 3271 - if (ret) 3271 + if (ret) { 3272 + pm_runtime_put_sync(cdns->dev); 3272 3273 return ret; 3274 + } 3273 3275 3274 3276 /* 3275 3277 * Because interrupt line can be shared with other components in
+7 -7
drivers/usb/cdns3/cdnsp-gadget.c
··· 422 422 int cdnsp_ep_dequeue(struct cdnsp_ep *pep, struct cdnsp_request *preq) 423 423 { 424 424 struct cdnsp_device *pdev = pep->pdev; 425 - int ret; 425 + int ret_stop = 0; 426 + int ret_rem; 426 427 427 428 trace_cdnsp_request_dequeue(preq); 428 429 429 - if (GET_EP_CTX_STATE(pep->out_ctx) == EP_STATE_RUNNING) { 430 - ret = cdnsp_cmd_stop_ep(pdev, pep); 431 - if (ret) 432 - return ret; 433 - } 430 + if (GET_EP_CTX_STATE(pep->out_ctx) == EP_STATE_RUNNING) 431 + ret_stop = cdnsp_cmd_stop_ep(pdev, pep); 434 432 435 - return cdnsp_remove_request(pdev, preq, pep); 433 + ret_rem = cdnsp_remove_request(pdev, preq, pep); 434 + 435 + return ret_rem ? ret_rem : ret_stop; 436 436 } 437 437 438 438 static void cdnsp_zero_in_ctx(struct cdnsp_device *pdev)
+1
drivers/usb/chipidea/udc.c
··· 2061 2061 ci->gadget.name = ci->platdata->name; 2062 2062 ci->gadget.otg_caps = otg_caps; 2063 2063 ci->gadget.sg_supported = 1; 2064 + ci->gadget.irq = ci->irq; 2064 2065 2065 2066 if (ci->platdata->flags & CI_HDRC_REQUIRES_ALIGNED_DMA) 2066 2067 ci->gadget.quirk_avoids_skb_reserve = 1;
+8 -3
drivers/usb/core/devio.c
··· 1218 1218 ret = usbfs_increase_memory_usage(len1 + sizeof(struct urb)); 1219 1219 if (ret) 1220 1220 return ret; 1221 - tbuf = kmalloc(len1, GFP_KERNEL); 1221 + 1222 + /* 1223 + * len1 can be almost arbitrarily large. Don't WARN if it's 1224 + * too big, just fail the request. 1225 + */ 1226 + tbuf = kmalloc(len1, GFP_KERNEL | __GFP_NOWARN); 1222 1227 if (!tbuf) { 1223 1228 ret = -ENOMEM; 1224 1229 goto done; ··· 1701 1696 if (num_sgs) { 1702 1697 as->urb->sg = kmalloc_array(num_sgs, 1703 1698 sizeof(struct scatterlist), 1704 - GFP_KERNEL); 1699 + GFP_KERNEL | __GFP_NOWARN); 1705 1700 if (!as->urb->sg) { 1706 1701 ret = -ENOMEM; 1707 1702 goto error; ··· 1736 1731 (uurb_start - as->usbm->vm_start); 1737 1732 } else { 1738 1733 as->urb->transfer_buffer = kmalloc(uurb->buffer_length, 1739 - GFP_KERNEL); 1734 + GFP_KERNEL | __GFP_NOWARN); 1740 1735 if (!as->urb->transfer_buffer) { 1741 1736 ret = -ENOMEM; 1742 1737 goto error;
+7 -6
drivers/usb/dwc3/gadget.c
··· 1244 1244 req->start_sg = sg_next(s); 1245 1245 1246 1246 req->num_queued_sgs++; 1247 + req->num_pending_sgs--; 1247 1248 1248 1249 /* 1249 1250 * The number of pending SG entries may not correspond to the ··· 1252 1251 * don't include unused SG entries. 1253 1252 */ 1254 1253 if (length == 0) { 1255 - req->num_pending_sgs -= req->request.num_mapped_sgs - req->num_queued_sgs; 1254 + req->num_pending_sgs = 0; 1256 1255 break; 1257 1256 } 1258 1257 ··· 2874 2873 struct dwc3_trb *trb = &dep->trb_pool[dep->trb_dequeue]; 2875 2874 struct scatterlist *sg = req->sg; 2876 2875 struct scatterlist *s; 2877 - unsigned int pending = req->num_pending_sgs; 2876 + unsigned int num_queued = req->num_queued_sgs; 2878 2877 unsigned int i; 2879 2878 int ret = 0; 2880 2879 2881 - for_each_sg(sg, s, pending, i) { 2880 + for_each_sg(sg, s, num_queued, i) { 2882 2881 trb = &dep->trb_pool[dep->trb_dequeue]; 2883 2882 2884 2883 req->sg = sg_next(s); 2885 - req->num_pending_sgs--; 2884 + req->num_queued_sgs--; 2886 2885 2887 2886 ret = dwc3_gadget_ep_reclaim_completed_trb(dep, req, 2888 2887 trb, event, status, true); ··· 2905 2904 2906 2905 static bool dwc3_gadget_ep_request_completed(struct dwc3_request *req) 2907 2906 { 2908 - return req->num_pending_sgs == 0; 2907 + return req->num_pending_sgs == 0 && req->num_queued_sgs == 0; 2909 2908 } 2910 2909 2911 2910 static int dwc3_gadget_ep_cleanup_completed_request(struct dwc3_ep *dep, ··· 2914 2913 { 2915 2914 int ret; 2916 2915 2917 - if (req->num_pending_sgs) 2916 + if (req->request.num_mapped_sgs) 2918 2917 ret = dwc3_gadget_ep_reclaim_trb_sg(dep, req, event, 2919 2918 status); 2920 2919 else
+3 -2
drivers/usb/gadget/udc/renesas_usb3.c
··· 1488 1488 struct renesas_usb3_request *usb3_req) 1489 1489 { 1490 1490 struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep); 1491 - struct renesas_usb3_request *usb3_req_first = usb3_get_request(usb3_ep); 1491 + struct renesas_usb3_request *usb3_req_first; 1492 1492 unsigned long flags; 1493 1493 int ret = -EAGAIN; 1494 1494 u32 enable_bits = 0; ··· 1496 1496 spin_lock_irqsave(&usb3->lock, flags); 1497 1497 if (usb3_ep->halt || usb3_ep->started) 1498 1498 goto out; 1499 - if (usb3_req != usb3_req_first) 1499 + usb3_req_first = __usb3_get_request(usb3_ep); 1500 + if (!usb3_req_first || usb3_req != usb3_req_first) 1500 1501 goto out; 1501 1502 1502 1503 if (usb3_pn_change(usb3, usb3_ep->num) < 0)
+7 -7
drivers/usb/host/xhci-ring.c
··· 828 828 list_for_each_entry_safe(td, tmp_td, &ep->cancelled_td_list, 829 829 cancelled_td_list) { 830 830 831 - /* 832 - * Doesn't matter what we pass for status, since the core will 833 - * just overwrite it (because the URB has been unlinked). 834 - */ 835 831 ring = xhci_urb_to_transfer_ring(ep->xhci, td->urb); 836 832 837 833 if (td->cancel_status == TD_CLEARED) 838 - xhci_td_cleanup(ep->xhci, td, ring, 0); 834 + xhci_td_cleanup(ep->xhci, td, ring, td->status); 839 835 840 836 if (ep->xhci->xhc_state & XHCI_STATE_DYING) 841 837 return; ··· 933 937 continue; 934 938 } 935 939 /* 936 - * If ring stopped on the TD we need to cancel, then we have to 940 + * If a ring stopped on the TD we need to cancel then we have to 937 941 * move the xHC endpoint ring dequeue pointer past this TD. 942 + * Rings halted due to STALL may show hw_deq is past the stalled 943 + * TD, but still require a set TR Deq command to flush xHC cache. 938 944 */ 939 945 hw_deq = xhci_get_hw_deq(xhci, ep->vdev, ep->ep_index, 940 946 td->urb->stream_id); 941 947 hw_deq &= ~0xf; 942 948 943 - if (trb_in_td(xhci, td->start_seg, td->first_trb, 949 + if (td->cancel_status == TD_HALTED) { 950 + cached_td = td; 951 + } else if (trb_in_td(xhci, td->start_seg, td->first_trb, 944 952 td->last_trb, hw_deq, false)) { 945 953 switch (td->cancel_status) { 946 954 case TD_CLEARED: /* TD is already no-op */
+2 -2
drivers/usb/misc/trancevibrator.c
··· 61 61 /* Set speed */ 62 62 retval = usb_control_msg(tv->udev, usb_sndctrlpipe(tv->udev, 0), 63 63 0x01, /* vendor request: set speed */ 64 - USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER, 64 + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 65 65 tv->speed, /* speed value */ 66 - 0, NULL, 0, USB_CTRL_GET_TIMEOUT); 66 + 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 67 67 if (retval) { 68 68 tv->speed = old; 69 69 dev_dbg(&tv->udev->dev, "retval = %d\n", retval);
+1
drivers/usb/misc/uss720.c
··· 736 736 parport_announce_port(pp); 737 737 738 738 usb_set_intfdata(intf, pp); 739 + usb_put_dev(usbdev); 739 740 return 0; 740 741 741 742 probe_abort:
+3
drivers/usb/serial/ftdi_sio.c
··· 1034 1034 /* Sienna devices */ 1035 1035 { USB_DEVICE(FTDI_VID, FTDI_SIENNA_PID) }, 1036 1036 { USB_DEVICE(ECHELON_VID, ECHELON_U20_PID) }, 1037 + /* IDS GmbH devices */ 1038 + { USB_DEVICE(IDS_VID, IDS_SI31A_PID) }, 1039 + { USB_DEVICE(IDS_VID, IDS_CM31A_PID) }, 1037 1040 /* U-Blox devices */ 1038 1041 { USB_DEVICE(UBLOX_VID, UBLOX_C099F9P_ZED_PID) }, 1039 1042 { USB_DEVICE(UBLOX_VID, UBLOX_C099F9P_ODIN_PID) },
+7
drivers/usb/serial/ftdi_sio_ids.h
··· 1568 1568 #define UNJO_ISODEBUG_V1_PID 0x150D 1569 1569 1570 1570 /* 1571 + * IDS GmbH 1572 + */ 1573 + #define IDS_VID 0x2CAF 1574 + #define IDS_SI31A_PID 0x13A2 1575 + #define IDS_CM31A_PID 0x13A3 1576 + 1577 + /* 1571 1578 * U-Blox products (http://www.u-blox.com). 1572 1579 */ 1573 1580 #define UBLOX_VID 0x1546
+4
drivers/usb/serial/option.c
··· 1240 1240 .driver_info = NCTRL(0) | RSVD(1) }, 1241 1241 { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1901, 0xff), /* Telit LN940 (MBIM) */ 1242 1242 .driver_info = NCTRL(0) }, 1243 + { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x7010, 0xff), /* Telit LE910-S1 (RNDIS) */ 1244 + .driver_info = NCTRL(2) }, 1245 + { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x7011, 0xff), /* Telit LE910-S1 (ECM) */ 1246 + .driver_info = NCTRL(2) }, 1243 1247 { USB_DEVICE(TELIT_VENDOR_ID, 0x9010), /* Telit SBL FN980 flashing device */ 1244 1248 .driver_info = NCTRL(0) | ZLP }, 1245 1249 { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */
+1
drivers/usb/serial/pl2303.c
··· 113 113 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) }, 114 114 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) }, 115 115 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) }, 116 + { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) }, 116 117 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) }, 117 118 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) }, 118 119 { } /* Terminating entry */
+1
drivers/usb/serial/pl2303.h
··· 158 158 /* ADLINK ND-6530 RS232,RS485 and RS422 adapter */ 159 159 #define ADLINK_VENDOR_ID 0x0b63 160 160 #define ADLINK_ND6530_PRODUCT_ID 0x6530 161 + #define ADLINK_ND6530GC_PRODUCT_ID 0x653a 161 162 162 163 /* SMART USB Serial Adapter */ 163 164 #define SMART_VENDOR_ID 0x0b8c
+3
drivers/usb/serial/ti_usb_3410_5052.c
··· 37 37 /* Vendor and product ids */ 38 38 #define TI_VENDOR_ID 0x0451 39 39 #define IBM_VENDOR_ID 0x04b3 40 + #define STARTECH_VENDOR_ID 0x14b0 40 41 #define TI_3410_PRODUCT_ID 0x3410 41 42 #define IBM_4543_PRODUCT_ID 0x4543 42 43 #define IBM_454B_PRODUCT_ID 0x454b ··· 371 370 { USB_DEVICE(MXU1_VENDOR_ID, MXU1_1131_PRODUCT_ID) }, 372 371 { USB_DEVICE(MXU1_VENDOR_ID, MXU1_1150_PRODUCT_ID) }, 373 372 { USB_DEVICE(MXU1_VENDOR_ID, MXU1_1151_PRODUCT_ID) }, 373 + { USB_DEVICE(STARTECH_VENDOR_ID, TI_3410_PRODUCT_ID) }, 374 374 { } /* terminator */ 375 375 }; 376 376 ··· 410 408 { USB_DEVICE(MXU1_VENDOR_ID, MXU1_1131_PRODUCT_ID) }, 411 409 { USB_DEVICE(MXU1_VENDOR_ID, MXU1_1150_PRODUCT_ID) }, 412 410 { USB_DEVICE(MXU1_VENDOR_ID, MXU1_1151_PRODUCT_ID) }, 411 + { USB_DEVICE(STARTECH_VENDOR_ID, TI_3410_PRODUCT_ID) }, 413 412 { } /* terminator */ 414 413 }; 415 414
+4 -3
drivers/usb/typec/mux.c
··· 191 191 bool match; 192 192 int nval; 193 193 u16 *val; 194 + int ret; 194 195 int i; 195 196 196 197 /* ··· 219 218 if (!val) 220 219 return ERR_PTR(-ENOMEM); 221 220 222 - nval = fwnode_property_read_u16_array(fwnode, "svid", val, nval); 223 - if (nval < 0) { 221 + ret = fwnode_property_read_u16_array(fwnode, "svid", val, nval); 222 + if (ret < 0) { 224 223 kfree(val); 225 - return ERR_PTR(nval); 224 + return ERR_PTR(ret); 226 225 } 227 226 228 227 for (i = 0; i < nval; i++) {
+36 -3
drivers/usb/typec/tcpm/tcpm.c
··· 1550 1550 if (PD_VDO_SVDM_VER(p[0]) < svdm_version) 1551 1551 typec_partner_set_svdm_version(port->partner, 1552 1552 PD_VDO_SVDM_VER(p[0])); 1553 + 1554 + tcpm_ams_start(port, DISCOVER_IDENTITY); 1553 1555 /* 6.4.4.3.1: Only respond as UFP (device) */ 1554 1556 if (port->data_role == TYPEC_DEVICE && 1555 1557 port->nr_snk_vdo) { ··· 1570 1568 } 1571 1569 break; 1572 1570 case CMD_DISCOVER_SVID: 1571 + tcpm_ams_start(port, DISCOVER_SVIDS); 1573 1572 break; 1574 1573 case CMD_DISCOVER_MODES: 1574 + tcpm_ams_start(port, DISCOVER_MODES); 1575 1575 break; 1576 1576 case CMD_ENTER_MODE: 1577 + tcpm_ams_start(port, DFP_TO_UFP_ENTER_MODE); 1577 1578 break; 1578 1579 case CMD_EXIT_MODE: 1580 + tcpm_ams_start(port, DFP_TO_UFP_EXIT_MODE); 1579 1581 break; 1580 1582 case CMD_ATTENTION: 1583 + tcpm_ams_start(port, ATTENTION); 1581 1584 /* Attention command does not have response */ 1582 1585 *adev_action = ADEV_ATTENTION; 1583 1586 return 0; ··· 2294 2287 bool frs_enable; 2295 2288 int ret; 2296 2289 2290 + if (tcpm_vdm_ams(port) && type != PD_DATA_VENDOR_DEF) { 2291 + port->vdm_state = VDM_STATE_ERR_BUSY; 2292 + tcpm_ams_finish(port); 2293 + mod_vdm_delayed_work(port, 0); 2294 + } 2295 + 2297 2296 switch (type) { 2298 2297 case PD_DATA_SOURCE_CAP: 2299 2298 for (i = 0; i < cnt; i++) ··· 2430 2417 NONE_AMS); 2431 2418 break; 2432 2419 case PD_DATA_VENDOR_DEF: 2433 - tcpm_handle_vdm_request(port, msg->payload, cnt); 2420 + if (tcpm_vdm_ams(port) || port->nr_snk_vdo) 2421 + tcpm_handle_vdm_request(port, msg->payload, cnt); 2422 + else if (port->negotiated_rev > PD_REV20) 2423 + tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 2434 2424 break; 2435 2425 case PD_DATA_BIST: 2436 2426 port->bist_request = le32_to_cpu(msg->payload[0]); ··· 2474 2458 { 2475 2459 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header); 2476 2460 enum tcpm_state next_state; 2461 + 2462 + /* 2463 + * Stop VDM state machine if interrupted by other Messages while NOT_SUPP is allowed in 2464 + * VDM AMS if waiting for VDM responses and will be handled later. 2465 + */ 2466 + if (tcpm_vdm_ams(port) && type != PD_CTRL_NOT_SUPP && type != PD_CTRL_GOOD_CRC) { 2467 + port->vdm_state = VDM_STATE_ERR_BUSY; 2468 + tcpm_ams_finish(port); 2469 + mod_vdm_delayed_work(port, 0); 2470 + } 2477 2471 2478 2472 switch (type) { 2479 2473 case PD_CTRL_GOOD_CRC: ··· 2743 2717 enum pd_ext_msg_type type = pd_header_type_le(msg->header); 2744 2718 unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header); 2745 2719 2746 - if (!(msg->ext_msg.header & PD_EXT_HDR_CHUNKED)) { 2720 + /* stopping VDM state machine if interrupted by other Messages */ 2721 + if (tcpm_vdm_ams(port)) { 2722 + port->vdm_state = VDM_STATE_ERR_BUSY; 2723 + tcpm_ams_finish(port); 2724 + mod_vdm_delayed_work(port, 0); 2725 + } 2726 + 2727 + if (!(le16_to_cpu(msg->ext_msg.header) & PD_EXT_HDR_CHUNKED)) { 2747 2728 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 2748 2729 tcpm_log(port, "Unchunked extended messages unsupported"); 2749 2730 return; ··· 2844 2811 "Data role mismatch, initiating error recovery"); 2845 2812 tcpm_set_state(port, ERROR_RECOVERY, 0); 2846 2813 } else { 2847 - if (msg->header & PD_HEADER_EXT_HDR) 2814 + if (le16_to_cpu(msg->header) & PD_HEADER_EXT_HDR) 2848 2815 tcpm_pd_ext_msg_request(port, msg); 2849 2816 else if (cnt) 2850 2817 tcpm_pd_data_request(port, msg);
+1 -1
drivers/usb/typec/ucsi/ucsi.c
··· 717 717 ucsi_send_command(con->ucsi, command, NULL, 0); 718 718 719 719 /* 3. ACK connector change */ 720 - clear_bit(EVENT_PENDING, &ucsi->flags); 721 720 ret = ucsi_acknowledge_connector_change(ucsi); 721 + clear_bit(EVENT_PENDING, &ucsi->flags); 722 722 if (ret) { 723 723 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret); 724 724 goto out_unlock;