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

Pull USB / Thunderbolt fixes from Greg KH: "Here are some USB fixes for 6.4-rc3, as well as a driver core fix that resolves a memory leak that shows up in USB devices easier than other subsystems. Included in here are: - driver core memory leak as reported and tested by syzbot and developers - dwc3 driver fixes for reported problems - xhci driver fixes for reported problems - USB gadget driver reverts to resolve regressions - usbtmc driver fix for syzbot reported problem - thunderbolt driver fixes for reported issues - other small USB fixes All of these, except for the driver core fix, have been in linux-next with no reported problems. The driver core fix was tested and verified to solve the issue by syzbot and the original reporter" * tag 'usb-6.4-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: driver core: class: properly reference count class_dev_iter() xhci: Fix incorrect tracking of free space on transfer rings xhci-pci: Only run d3cold avoidance quirk for s2idle usb-storage: fix deadlock when a scsi command timeouts more than once usb: dwc3: fix a test for error in dwc3_core_init() usb: typec: tps6598x: Fix fault at module removal usb: gadget: u_ether: Fix host MAC address case usb: typec: altmodes/displayport: fix pin_assignment_show Revert "usb: gadget: udc: core: Invoke usb_gadget_connect only when started" Revert "usb: gadget: udc: core: Prevent redundant calls to pullup" usb: gadget: drop superfluous ':' in doc string usb: dwc3: debugfs: Resume dwc3 before accessing registers USB: UHCI: adjust zhaoxin UHCI controllers OverCurrent bit value usb: dwc3: fix gadget mode suspend interrupt handler issue usb: dwc3: gadget: Improve dwc3_gadget_suspend() and dwc3_gadget_resume() USB: usbtmc: Fix direction for 0-length ioctl control messages thunderbolt: Clear registers properly when auto clear isn't in use

Linus Torvalds committed 3 years ago

Commit 2dd0d982 parents 98be58a ddaf09819 files · +309 −163Browse files

Unified · Split

19 files

drivers/base/class.c +2 −0
drivers/thunderbolt/nhi.c +24 −5
drivers/thunderbolt/nhi_regs.h +2 −0
drivers/usb/class/usbtmc.c +2 −0
drivers/usb/dwc3/core.c +1 −1
drivers/usb/dwc3/core.h +2 −0
drivers/usb/dwc3/debugfs.c +109 −0
drivers/usb/dwc3/gadget.c +45 −34
drivers/usb/gadget/function/u_ether.c +3 −0
drivers/usb/gadget/udc/core.c +44 −107
drivers/usb/host/uhci-pci.c +6 −4
drivers/usb/host/xhci-pci.c +10 −2
drivers/usb/host/xhci-ring.c +28 −1
drivers/usb/host/xhci.h +1 −1
drivers/usb/storage/scsiglue.c +21 −7
drivers/usb/typec/altmodes/displayport.c +4 −0
drivers/usb/typec/tipd/core.c +3 −0
include/linux/device/class.h +1 −0
include/linux/usb/composite.h +1 −1

drivers/base/class.c+2−0

 		start_knode = &start->p->knode_class;
 	klist_iter_init_node(&sp->klist_devices, &iter->ki, start_knode);
 	iter->type = type;
+	iter->sp = sp;
 }
 EXPORT_SYMBOL_GPL(class_dev_iter_init);
 void class_dev_iter_exit(struct class_dev_iter *iter)
 {
 	klist_iter_exit(&iter->ki);
+	subsys_put(iter->sp);
 }
 EXPORT_SYMBOL_GPL(class_dev_iter_exit);

drivers/thunderbolt/nhi.c+24−5

@@ -54,6 +54,21 @@ static int ring_interrupt_index(const struct tb_ring *ring) · 53 unmodified lines
54	return bit;	54	return bit;
55	}	55	}
56		56
		57	static void nhi_mask_interrupt(struct tb_nhi *nhi, int mask, int ring)
		58	{
		59	if (nhi->quirks & QUIRK_AUTO_CLEAR_INT)
		60	return;
		61	iowrite32(mask, nhi->iobase + REG_RING_INTERRUPT_MASK_CLEAR_BASE + ring);
		62	}
		63
		64	static void nhi_clear_interrupt(struct tb_nhi *nhi, int ring)
		65	{
		66	if (nhi->quirks & QUIRK_AUTO_CLEAR_INT)
		67	ioread32(nhi->iobase + REG_RING_NOTIFY_BASE + ring);
		68	else
		69	iowrite32(~0, nhi->iobase + REG_RING_INT_CLEAR + ring);
		70	}
		71
57	/*	72	/*
58	* ring_interrupt_active() - activate/deactivate interrupts for a single ring	73	* ring_interrupt_active() - activate/deactivate interrupts for a single ring
59	*	74	*
@@ -61,8 +76,8 @@ static int ring_interrupt_index(const struct tb_ring *ring) · 1 unmodified line
61	*/	76	*/
62	static void ring_interrupt_active(struct tb_ring *ring, bool active)	77	static void ring_interrupt_active(struct tb_ring *ring, bool active)
63	{	78	{
64	int reg = REG_RING_INTERRUPT_BASE +	79	int index = ring_interrupt_index(ring) / 32 * 4;
65	ring_interrupt_index(ring) / 32 * 4;	80	int reg = REG_RING_INTERRUPT_BASE + index;
66	int interrupt_bit = ring_interrupt_index(ring) & 31;	81	int interrupt_bit = ring_interrupt_index(ring) & 31;
67	int mask = 1 << interrupt_bit;	82	int mask = 1 << interrupt_bit;
68	u32 old, new;	83	u32 old, new;
@@ -123,7 +138,11 @@ static void ring_interrupt_active(struct tb_ring *ring, bool active) · 54 unmodified lines
123	"interrupt for %s %d is already %s\n",	138	"interrupt for %s %d is already %s\n",
124	RING_TYPE(ring), ring->hop,	139	RING_TYPE(ring), ring->hop,
125	active ? "enabled" : "disabled");	140	active ? "enabled" : "disabled");
126	iowrite32(new, ring->nhi->iobase + reg);	141
		142	if (active)
		143	iowrite32(new, ring->nhi->iobase + reg);
		144	else
		145	nhi_mask_interrupt(ring->nhi, mask, index);
127	}	146	}
128		147
129	/*	148	/*
@@ -136,11 +155,11 @@ static void nhi_disable_interrupts(struct tb_nhi *nhi) · 6 unmodified lines
136	int i = 0;	155	int i = 0;
137	/* disable interrupts */	156	/* disable interrupts */
138	for (i = 0; i < RING_INTERRUPT_REG_COUNT(nhi); i++)	157	for (i = 0; i < RING_INTERRUPT_REG_COUNT(nhi); i++)
139	iowrite32(0, nhi->iobase + REG_RING_INTERRUPT_BASE + 4 * i);	158	nhi_mask_interrupt(nhi, ~0, 4 * i);
140		159
141	/* clear interrupt status bits */	160	/* clear interrupt status bits */
142	for (i = 0; i < RING_NOTIFY_REG_COUNT(nhi); i++)	161	for (i = 0; i < RING_NOTIFY_REG_COUNT(nhi); i++)
143	ioread32(nhi->iobase + REG_RING_NOTIFY_BASE + 4 * i);	162	nhi_clear_interrupt(nhi, 4 * i);
144	}	163	}
145		164
146	/* ring helper methods */	165	/* ring helper methods */

drivers/thunderbolt/nhi_regs.h+2−0

@@ -93,6 +93,8 @@ struct ring_desc { · 92 unmodified lines
93	#define REG_RING_INTERRUPT_BASE 0x38200	93	#define REG_RING_INTERRUPT_BASE 0x38200
94	#define RING_INTERRUPT_REG_COUNT(nhi) ((31 + 2 * nhi->hop_count) / 32)	94	#define RING_INTERRUPT_REG_COUNT(nhi) ((31 + 2 * nhi->hop_count) / 32)
95		95
		96	#define REG_RING_INTERRUPT_MASK_CLEAR_BASE 0x38208
		97
96	#define REG_INT_THROTTLING_RATE 0x38c00	98	#define REG_INT_THROTTLING_RATE 0x38c00
97		99
98	/* Interrupt Vector Allocation */	100	/* Interrupt Vector Allocation */

drivers/usb/class/usbtmc.c+2−0

@@ -1928,6 +1928,8 @@ static int usbtmc_ioctl_request(struct usbtmc_device_data *data, · 1927 unmodified lines
1928		1928
1929	if (request.req.wLength > USBTMC_BUFSIZE)	1929	if (request.req.wLength > USBTMC_BUFSIZE)
1930	return -EMSGSIZE;	1930	return -EMSGSIZE;
		1931	if (request.req.wLength == 0) /* Length-0 requests are never IN */
		1932	request.req.bRequestType &= ~USB_DIR_IN;
1931		1933
1932	is_in = request.req.bRequestType & USB_DIR_IN;	1934	is_in = request.req.bRequestType & USB_DIR_IN;
1933		1935

drivers/usb/dwc3/core.c+1−1

@@ -1137,7 +1137,7 @@ static int dwc3_core_init(struct dwc3 *dwc) · 1136 unmodified lines
1137		1137
1138	dwc3_set_incr_burst_type(dwc);	1138	dwc3_set_incr_burst_type(dwc);
1139		1139
1140	dwc3_phy_power_on(dwc);	1140	ret = dwc3_phy_power_on(dwc);
1141	if (ret)	1141	if (ret)
1142	goto err_exit_phy;	1142	goto err_exit_phy;
1143		1143

drivers/usb/dwc3/core.h+2−0

  * @dis_metastability_quirk: set to disable metastability quirk.
  * @dis_split_quirk: set to disable split boundary.
  * @wakeup_configured: set if the device is configured for remote wakeup.
+ * @suspended: set to track suspend event due to U3/L2.
  * @imod_interval: set the interrupt moderation interval in 250ns
  *			increments or 0 to disable.
  * @max_cfg_eps: current max number of IN eps used across all USB configs.
 	unsigned		dis_split_quirk:1;
 	unsigned		async_callbacks:1;
 	unsigned		wakeup_configured:1;
+	unsigned		suspended:1;
 	u16			imod_interval;

drivers/usb/dwc3/debugfs.c+109−0

 	unsigned int		current_mode;
 	unsigned long		flags;
 	u32			reg;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	reg = dwc3_readl(dwc->regs, DWC3_GSTS);
 	}
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = s->private;
 	unsigned long		flags;
 	u32			reg;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	reg = dwc3_readl(dwc->regs, DWC3_GCTL);
 		seq_printf(s, "UNKNOWN %08x\n", DWC3_GCTL_PRTCAP(reg));
 	}
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = s->private;
 	unsigned long		flags;
 	u32			reg;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	reg = dwc3_readl(dwc->regs, DWC3_DCTL);
 		seq_printf(s, "UNKNOWN %d\n", reg);
 	}
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	unsigned long		flags;
 	u32			testmode = 0;
 	char			buf[32];
+	int			ret;
 	if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
 		return -EFAULT;
 	else
 		testmode = 0;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	dwc3_gadget_set_test_mode(dwc, testmode);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return count;
 }
 	enum dwc3_link_state	state;
 	u32			reg;
 	u8			speed;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	reg = dwc3_readl(dwc->regs, DWC3_GSTS);
 	if (DWC3_GSTS_CURMOD(reg) != DWC3_GSTS_CURMOD_DEVICE) {
 		seq_puts(s, "Not available\n");
 		spin_unlock_irqrestore(&dwc->lock, flags);
+		pm_runtime_put_sync(dwc->dev);
 		return 0;
 	}
 		   dwc3_gadget_hs_link_string(state));
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	char			buf[32];
 	u32			reg;
 	u8			speed;
+	int			ret;
 	if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
 		return -EFAULT;
 	else
 		return -EINVAL;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	reg = dwc3_readl(dwc->regs, DWC3_GSTS);
 	if (DWC3_GSTS_CURMOD(reg) != DWC3_GSTS_CURMOD_DEVICE) {
 		spin_unlock_irqrestore(&dwc->lock, flags);
+		pm_runtime_put_sync(dwc->dev);
 		return -EINVAL;
 	}
 	if (speed < DWC3_DSTS_SUPERSPEED &&
 	    state != DWC3_LINK_STATE_RECOV) {
 		spin_unlock_irqrestore(&dwc->lock, flags);
+		pm_runtime_put_sync(dwc->dev);
 		return -EINVAL;
 	}
 	dwc3_gadget_set_link_state(dwc, state);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return count;
 }
 	unsigned long		flags;
 	u32			mdwidth;
 	u32			val;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	val = dwc3_core_fifo_space(dep, DWC3_TXFIFO);
 	seq_printf(s, "%u\n", val);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	unsigned long		flags;
 	u32			mdwidth;
 	u32			val;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	val = dwc3_core_fifo_space(dep, DWC3_RXFIFO);
 	seq_printf(s, "%u\n", val);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = dep->dwc;
 	unsigned long		flags;
 	u32			val;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	val = dwc3_core_fifo_space(dep, DWC3_TXREQQ);
 	seq_printf(s, "%u\n", val);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = dep->dwc;
 	unsigned long		flags;
 	u32			val;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	val = dwc3_core_fifo_space(dep, DWC3_RXREQQ);
 	seq_printf(s, "%u\n", val);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = dep->dwc;
 	unsigned long		flags;
 	u32			val;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	val = dwc3_core_fifo_space(dep, DWC3_RXINFOQ);
 	seq_printf(s, "%u\n", val);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = dep->dwc;
 	unsigned long		flags;
 	u32			val;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	val = dwc3_core_fifo_space(dep, DWC3_DESCFETCHQ);
 	seq_printf(s, "%u\n", val);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = dep->dwc;
 	unsigned long		flags;
 	u32			val;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	val = dwc3_core_fifo_space(dep, DWC3_EVENTQ);
 	seq_printf(s, "%u\n", val);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	struct dwc3		*dwc = dep->dwc;
 	unsigned long		flags;
 	int			i;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	if (dep->number <= 1) {
 out:
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	u32			lower_32_bits;
 	u32			upper_32_bits;
 	u32			reg;
+	int			ret;
+	ret = pm_runtime_resume_and_get(dwc->dev);
+	if (ret < 0)
+		return ret;
 	spin_lock_irqsave(&dwc->lock, flags);
 	reg = DWC3_GDBGLSPMUX_EPSELECT(dep->number);
 	seq_printf(s, "0x%016llx\n", ep_info);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	pm_runtime_put_sync(dwc->dev);
 	return 0;
 }
 	dwc->regset->regs = dwc3_regs;
 	dwc->regset->nregs = ARRAY_SIZE(dwc3_regs);
 	dwc->regset->base = dwc->regs - DWC3_GLOBALS_REGS_START;
+	dwc->regset->dev = dwc->dev;
 	root = debugfs_create_dir(dev_name(dwc->dev), usb_debug_root);
 	dwc->debug_root = root;

drivers/usb/dwc3/gadget.c+45−34

 			return -EINVAL;
 		}
 		dwc3_resume_gadget(dwc);
+		dwc->suspended = false;
 		dwc->link_state = DWC3_LINK_STATE_U0;
 	}
 	return ret;
 }
+static int dwc3_gadget_soft_connect(struct dwc3 *dwc)
+{
+	/*
+	 * In the Synopsys DWC_usb31 1.90a programming guide section
+	 * 4.1.9, it specifies that for a reconnect after a
+	 * device-initiated disconnect requires a core soft reset
+	 * (DCTL.CSftRst) before enabling the run/stop bit.
+	 */
+	dwc3_core_soft_reset(dwc);
+	dwc3_event_buffers_setup(dwc);
+	__dwc3_gadget_start(dwc);
+	return dwc3_gadget_run_stop(dwc, true);
+}
 static int dwc3_gadget_pullup(struct usb_gadget *g, int is_on)
 {
 	struct dwc3		*dwc = gadget_to_dwc(g);
 	synchronize_irq(dwc->irq_gadget);
-	if (!is_on) {
+	if (!is_on)
 		ret = dwc3_gadget_soft_disconnect(dwc);
-	} else {
+	else
-		/*
+		ret = dwc3_gadget_soft_connect(dwc);
-		 * In the Synopsys DWC_usb31 1.90a programming guide section
-		 * 4.1.9, it specifies that for a reconnect after a
-		 * device-initiated disconnect requires a core soft reset
-		 * (DCTL.CSftRst) before enabling the run/stop bit.
-		 */
-		dwc3_core_soft_reset(dwc);
-		dwc3_event_buffers_setup(dwc);
-		__dwc3_gadget_start(dwc);
-		ret = dwc3_gadget_run_stop(dwc, true);
-	}
 	pm_runtime_put(dwc->dev);
 {
 	int			reg;
+	dwc->suspended = false;
 	dwc3_gadget_set_link_state(dwc, DWC3_LINK_STATE_RX_DET);
 	reg = dwc3_readl(dwc->regs, DWC3_DCTL);
 {
 	u32			reg;
+	dwc->suspended = false;
 	/*
 	 * Ideally, dwc3_reset_gadget() would trigger the function
 	 * drivers to stop any active transfers through ep disable.
 static void dwc3_gadget_wakeup_interrupt(struct dwc3 *dwc, unsigned int evtinfo)
 {
+	dwc->suspended = false;
 	/*
 	 * TODO take core out of low power mode when that's
 	 * implemented.
 		if (dwc->gadget->wakeup_armed) {
 			dwc3_gadget_enable_linksts_evts(dwc, false);
 			dwc3_resume_gadget(dwc);
+			dwc->suspended = false;
 		}
 		break;
 	case DWC3_LINK_STATE_U1:
 {
 	enum dwc3_link_state next = evtinfo & DWC3_LINK_STATE_MASK;
-	if (dwc->link_state != next && next == DWC3_LINK_STATE_U3)
+	if (!dwc->suspended && next == DWC3_LINK_STATE_U3) {
+		dwc->suspended = true;
 		dwc3_suspend_gadget(dwc);
+	}
 	dwc->link_state = next;
 }
 int dwc3_gadget_suspend(struct dwc3 *dwc)
 {
 	unsigned long flags;
+	int ret;
 	if (!dwc->gadget_driver)
 		return 0;
-	dwc3_gadget_run_stop(dwc, false);
+	ret = dwc3_gadget_soft_disconnect(dwc);
+	if (ret)
+		goto err;
 	spin_lock_irqsave(&dwc->lock, flags);
 	dwc3_disconnect_gadget(dwc);
-	__dwc3_gadget_stop(dwc);
 	spin_unlock_irqrestore(&dwc->lock, flags);
 	return 0;
+err:
+	/*
+	 * Attempt to reset the controller's state. Likely no
+	 * communication can be established until the host
+	 * performs a port reset.
+	 */
+	if (dwc->softconnect)
+		dwc3_gadget_soft_connect(dwc);
+	return ret;
 }
 int dwc3_gadget_resume(struct dwc3 *dwc)
 {
-	int			ret;
 	if (!dwc->gadget_driver || !dwc->softconnect)
 		return 0;
-	ret = __dwc3_gadget_start(dwc);
+	return dwc3_gadget_soft_connect(dwc);
-	if (ret < 0)
-		goto err0;
-	ret = dwc3_gadget_run_stop(dwc, true);
-	if (ret < 0)
-		goto err1;
-	return 0;
-err1:
-	__dwc3_gadget_stop(dwc);
-err0:
-	return ret;
 }
 void dwc3_gadget_process_pending_events(struct dwc3 *dwc)

drivers/usb/gadget/function/u_ether.c+3−0

 #include <linux/etherdevice.h>
 #include <linux/ethtool.h>
 #include <linux/if_vlan.h>
+#include <linux/string_helpers.h>
 #include <linux/usb/composite.h>
 #include "u_ether.h"
 	dev = netdev_priv(net);
 	snprintf(host_addr, len, "%pm", dev->host_mac);
+	string_upper(host_addr, host_addr);
 	return strlen(host_addr);
 }
 EXPORT_SYMBOL_GPL(gether_get_host_addr_cdc);

drivers/usb/gadget/udc/core.c+44−107

  * @vbus: for udcs who care about vbus status, this value is real vbus status;
  * for udcs who do not care about vbus status, this value is always true
  * @started: the UDC's started state. True if the UDC had started.
- * @connect_lock: protects udc->vbus, udc->started, gadget->connect, gadget->deactivate related
- * functions. usb_gadget_connect_locked, usb_gadget_disconnect_locked,
- * usb_udc_connect_control_locked, usb_gadget_udc_start_locked, usb_gadget_udc_stop_locked are
- * called with this lock held.
  *
  * This represents the internal data structure which is used by the UDC-class
  * to hold information about udc driver and gadget together.
 	struct list_head		list;
 	bool				vbus;
 	bool				started;
-	struct mutex			connect_lock;
 };
 static struct class *udc_class;
 }
 EXPORT_SYMBOL_GPL(usb_gadget_vbus_disconnect);
-/* Internal version of usb_gadget_connect needs to be called with connect_lock held. */
+/**
-static int usb_gadget_connect_locked(struct usb_gadget *gadget)
+ * usb_gadget_connect - software-controlled connect to USB host
-	__must_hold(&gadget->udc->connect_lock)
+ * @gadget:the peripheral being connected
+ *
+ * Enables the D+ (or potentially D-) pullup.  The host will start
+ * enumerating this gadget when the pullup is active and a VBUS session
+ * is active (the link is powered).
+ *
+ * Returns zero on success, else negative errno.
+ */
+int usb_gadget_connect(struct usb_gadget *gadget)
 {
 	int ret = 0;
 		goto out;
 	}
-	if (gadget->connected)
+	if (gadget->deactivated) {
-		goto out;
-	if (gadget->deactivated || !gadget->udc->started) {
 		/*
 		 * If gadget is deactivated we only save new state.
 		 * Gadget will be connected automatically after activation.
-		 *
-		 * udc first needs to be started before gadget can be pulled up.
 		 */
 		gadget->connected = true;
 		goto out;
 	return ret;
 }
+EXPORT_SYMBOL_GPL(usb_gadget_connect);
 /**
- * usb_gadget_connect - software-controlled connect to USB host
+ * usb_gadget_disconnect - software-controlled disconnect from USB host
- * @gadget:the peripheral being connected
+ * @gadget:the peripheral being disconnected
  *
- * Enables the D+ (or potentially D-) pullup.  The host will start
+ * Disables the D+ (or potentially D-) pullup, which the host may see
- * enumerating this gadget when the pullup is active and a VBUS session
+ * as a disconnect (when a VBUS session is active).  Not all systems
- * is active (the link is powered).
+ * support software pullup controls.
+ *
+ * Following a successful disconnect, invoke the ->disconnect() callback
+ * for the current gadget driver so that UDC drivers don't need to.
  *
  * Returns zero on success, else negative errno.
  */
-int usb_gadget_connect(struct usb_gadget *gadget)
+int usb_gadget_disconnect(struct usb_gadget *gadget)
-{
-	int ret;
-	mutex_lock(&gadget->udc->connect_lock);
-	ret = usb_gadget_connect_locked(gadget);
-	mutex_unlock(&gadget->udc->connect_lock);
-	return ret;
-}
-EXPORT_SYMBOL_GPL(usb_gadget_connect);
-/* Internal version of usb_gadget_disconnect needs to be called with connect_lock held. */
-static int usb_gadget_disconnect_locked(struct usb_gadget *gadget)
-	__must_hold(&gadget->udc->connect_lock)
 {
 	int ret = 0;
 	if (!gadget->connected)
 		goto out;
-	if (gadget->deactivated || !gadget->udc->started) {
+	if (gadget->deactivated) {
 		/*
 		 * If gadget is deactivated we only save new state.
 		 * Gadget will stay disconnected after activation.
-		 *
-		 * udc should have been started before gadget being pulled down.
 		 */
 		gadget->connected = false;
 		goto out;
 	return ret;
 }
-/**
- * usb_gadget_disconnect - software-controlled disconnect from USB host
- * @gadget:the peripheral being disconnected
- *
- * Disables the D+ (or potentially D-) pullup, which the host may see
- * as a disconnect (when a VBUS session is active).  Not all systems
- * support software pullup controls.
- *
- * Following a successful disconnect, invoke the ->disconnect() callback
- * for the current gadget driver so that UDC drivers don't need to.
- *
- * Returns zero on success, else negative errno.
- */
-int usb_gadget_disconnect(struct usb_gadget *gadget)
-{
-	int ret;
-	mutex_lock(&gadget->udc->connect_lock);
-	ret = usb_gadget_disconnect_locked(gadget);
-	mutex_unlock(&gadget->udc->connect_lock);
-	return ret;
-}
 EXPORT_SYMBOL_GPL(usb_gadget_disconnect);
 /**
 	if (gadget->deactivated)
 		goto out;
-	mutex_lock(&gadget->udc->connect_lock);
 	if (gadget->connected) {
-		ret = usb_gadget_disconnect_locked(gadget);
+		ret = usb_gadget_disconnect(gadget);
 		if (ret)
-			goto unlock;
+			goto out;
 		/*
 		 * If gadget was being connected before deactivation, we want
 	}
 	gadget->deactivated = true;
-unlock:
-	mutex_unlock(&gadget->udc->connect_lock);
 out:
 	trace_usb_gadget_deactivate(gadget, ret);
 	if (!gadget->deactivated)
 		goto out;
-	mutex_lock(&gadget->udc->connect_lock);
 	gadget->deactivated = false;
 	/*
 	 * while it was being deactivated, we call usb_gadget_connect().
 	 */
 	if (gadget->connected)
-		ret = usb_gadget_connect_locked(gadget);
+		ret = usb_gadget_connect(gadget);
-	mutex_unlock(&gadget->udc->connect_lock);
 out:
 	trace_usb_gadget_activate(gadget, ret);
 /* ------------------------------------------------------------------------- */
-/* Acquire connect_lock before calling this function. */
+static void usb_udc_connect_control(struct usb_udc *udc)
-static void usb_udc_connect_control_locked(struct usb_udc *udc) __must_hold(&udc->connect_lock)
 {
-	if (udc->vbus && udc->started)
+	if (udc->vbus)
-		usb_gadget_connect_locked(udc->gadget);
+		usb_gadget_connect(udc->gadget);
 	else
-		usb_gadget_disconnect_locked(udc->gadget);
+		usb_gadget_disconnect(udc->gadget);
 }
 /**
 {
 	struct usb_udc *udc = gadget->udc;
-	mutex_lock(&udc->connect_lock);
 	if (udc) {
 		udc->vbus = status;
-		usb_udc_connect_control_locked(udc);
+		usb_udc_connect_control(udc);
 	}
-	mutex_unlock(&udc->connect_lock);
 }
 EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
 EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
 /**
- * usb_gadget_udc_start_locked - tells usb device controller to start up
+ * usb_gadget_udc_start - tells usb device controller to start up
  * @udc: The UDC to be started
  *
  * This call is issued by the UDC Class driver when it's about
  * necessary to have it powered on.
  *
  * Returns zero on success, else negative errno.
- *
- * Caller should acquire connect_lock before invoking this function.
  */
-static inline int usb_gadget_udc_start_locked(struct usb_udc *udc)
+static inline int usb_gadget_udc_start(struct usb_udc *udc)
-	__must_hold(&udc->connect_lock)
 {
 	int ret;
 }
 /**
- * usb_gadget_udc_stop_locked - tells usb device controller we don't need it anymore
+ * usb_gadget_udc_stop - tells usb device controller we don't need it anymore
  * @udc: The UDC to be stopped
  *
  * This call is issued by the UDC Class driver after calling
  * The details are implementation specific, but it can go as
  * far as powering off UDC completely and disable its data
  * line pullups.
- *
- * Caller should acquire connect lock before invoking this function.
  */
-static inline void usb_gadget_udc_stop_locked(struct usb_udc *udc)
+static inline void usb_gadget_udc_stop(struct usb_udc *udc)
-	__must_hold(&udc->connect_lock)
 {
 	if (!udc->started) {
 		dev_err(&udc->dev, "UDC had already stopped\n");
 	udc->gadget = gadget;
 	gadget->udc = udc;
-	mutex_init(&udc->connect_lock);
 	udc->started = false;
 	if (ret)
 		goto err_bind;
-	mutex_lock(&udc->connect_lock);
+	ret = usb_gadget_udc_start(udc);
-	ret = usb_gadget_udc_start_locked(udc);
+	if (ret)
-	if (ret) {
-		mutex_unlock(&udc->connect_lock);
 		goto err_start;
-	}
 	usb_gadget_enable_async_callbacks(udc);
-	usb_udc_connect_control_locked(udc);
+	usb_udc_connect_control(udc);
-	mutex_unlock(&udc->connect_lock);
 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
 	return 0;
 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
-	mutex_lock(&udc->connect_lock);
+	usb_gadget_disconnect(gadget);
-	usb_gadget_disconnect_locked(gadget);
 	usb_gadget_disable_async_callbacks(udc);
 	if (gadget->irq)
 		synchronize_irq(gadget->irq);
 	udc->driver->unbind(gadget);
-	usb_gadget_udc_stop_locked(udc);
+	usb_gadget_udc_stop(udc);
-	mutex_unlock(&udc->connect_lock);
 	mutex_lock(&udc_lock);
 	driver->is_bound = false;
 	}
 	if (sysfs_streq(buf, "connect")) {
-		mutex_lock(&udc->connect_lock);
+		usb_gadget_udc_start(udc);
-		usb_gadget_udc_start_locked(udc);
+		usb_gadget_connect(udc->gadget);
-		usb_gadget_connect_locked(udc->gadget);
-		mutex_unlock(&udc->connect_lock);
 	} else if (sysfs_streq(buf, "disconnect")) {
-		mutex_lock(&udc->connect_lock);
+		usb_gadget_disconnect(udc->gadget);
-		usb_gadget_disconnect_locked(udc->gadget);
+		usb_gadget_udc_stop(udc);
-		usb_gadget_udc_stop_locked(udc);
-		mutex_unlock(&udc->connect_lock);
 	} else {
 		dev_err(dev, "unsupported command '%s'\n", buf);
 		ret = -EINVAL;

drivers/usb/host/uhci-pci.c+6−4

 	uhci->rh_numports = uhci_count_ports(hcd);
-	/* Intel controllers report the OverCurrent bit active on.
+	/*
-	 * VIA controllers report it active off, so we'll adjust the
+	 * Intel controllers report the OverCurrent bit active on.  VIA
-	 * bit value.  (It's not standardized in the UHCI spec.)
+	 * and ZHAOXIN controllers report it active off, so we'll adjust
+	 * the bit value.  (It's not standardized in the UHCI spec.)
 	 */
-	if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_VIA)
+	if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_VIA ||
+			to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_ZHAOXIN)
 		uhci->oc_low = 1;
 	/* HP's server management chip requires a longer port reset delay. */

drivers/usb/host/xhci-pci.c+10−2

 #include <linux/module.h>
 #include <linux/acpi.h>
 #include <linux/reset.h>
+#include <linux/suspend.h>
 #include "xhci.h"
 #include "xhci-trace.h"
 	if (pdev->vendor == PCI_VENDOR_ID_AMD &&
 		pdev->device == PCI_DEVICE_ID_AMD_RENOIR_XHCI)
-		xhci->quirks |= XHCI_BROKEN_D3COLD;
+		xhci->quirks |= XHCI_BROKEN_D3COLD_S2I;
 	if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
 		xhci->quirks |= XHCI_LPM_SUPPORT;
 	 * Systems with the TI redriver that loses port status change events
 	 * need to have the registers polled during D3, so avoid D3cold.
 	 */
-	if (xhci->quirks & (XHCI_COMP_MODE_QUIRK | XHCI_BROKEN_D3COLD))
+	if (xhci->quirks & XHCI_COMP_MODE_QUIRK)
 		pci_d3cold_disable(pdev);
+#ifdef CONFIG_SUSPEND
+	/* d3cold is broken, but only when s2idle is used */
+	if (pm_suspend_target_state == PM_SUSPEND_TO_IDLE &&
+	    xhci->quirks & (XHCI_BROKEN_D3COLD_S2I))
+		pci_d3cold_disable(pdev);
+#endif
 	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
 		xhci_pme_quirk(hcd);

drivers/usb/host/xhci-ring.c+28−1

@@ -276,6 +276,26 @@ static void inc_enq(struct xhci_hcd xhci, struct xhci_ring ring, · 275 unmodified lines
276	trace_xhci_inc_enq(ring);	276	trace_xhci_inc_enq(ring);
277	}	277	}
278		278
		279	static int xhci_num_trbs_to(struct xhci_segment start_seg, union xhci_trb start,
		280	struct xhci_segment end_seg, union xhci_trb end,
		281	unsigned int num_segs)
		282	{
		283	union xhci_trb *last_on_seg;
		284	int num = 0;
		285	int i = 0;
		286
		287	do {
		288	if (start_seg == end_seg && end >= start)
		289	return num + (end - start);
		290	last_on_seg = &start_seg->trbs[TRBS_PER_SEGMENT - 1];
		291	num += last_on_seg - start;
		292	start_seg = start_seg->next;
		293	start = start_seg->trbs;
		294	} while (i++ <= num_segs);
		295
		296	return -EINVAL;
		297	}
		298
279	/*	299	/*
280	* Check to see if there's room to enqueue num_trbs on the ring and make sure	300	* Check to see if there's room to enqueue num_trbs on the ring and make sure
281	* enqueue pointer will not advance into dequeue segment. See rules above.	301	* enqueue pointer will not advance into dequeue segment. See rules above.
@@ -2140,6 +2160,7 @@ static int finish_td(struct xhci_hcd xhci, struct xhci_virt_ep ep, · 1858 unmodified lines
2140	u32 trb_comp_code)	2160	u32 trb_comp_code)
2141	{	2161	{
2142	struct xhci_ep_ctx *ep_ctx;	2162	struct xhci_ep_ctx *ep_ctx;
		2163	int trbs_freed;
2143		2164
2144	ep_ctx = xhci_get_ep_ctx(xhci, ep->vdev->out_ctx, ep->ep_index);	2165	ep_ctx = xhci_get_ep_ctx(xhci, ep->vdev->out_ctx, ep->ep_index);
2145		2166
@@ -2209,9 +2230,15 @@ static int finish_td(struct xhci_hcd xhci, struct xhci_virt_ep ep, · 63 unmodified lines
2209	}	2230	}
2210		2231
2211	/* Update ring dequeue pointer */	2232	/* Update ring dequeue pointer */
		2233	trbs_freed = xhci_num_trbs_to(ep_ring->deq_seg, ep_ring->dequeue,
		2234	td->last_trb_seg, td->last_trb,
		2235	ep_ring->num_segs);
		2236	if (trbs_freed < 0)
		2237	xhci_dbg(xhci, "Failed to count freed trbs at TD finish\n");
		2238	else
		2239	ep_ring->num_trbs_free += trbs_freed;
2212	ep_ring->dequeue = td->last_trb;	2240	ep_ring->dequeue = td->last_trb;
2213	ep_ring->deq_seg = td->last_trb_seg;	2241	ep_ring->deq_seg = td->last_trb_seg;
2214	ep_ring->num_trbs_free += td->num_trbs - 1;
2215	inc_deq(xhci, ep_ring);	2242	inc_deq(xhci, ep_ring);
2216		2243
2217	return xhci_td_cleanup(xhci, td, ep_ring, td->status);	2244	return xhci_td_cleanup(xhci, td, ep_ring, td->status);

drivers/usb/host/xhci.h+1−1

@@ -1901,7 +1901,7 @@ struct xhci_hcd { · 1900 unmodified lines
1901	#define XHCI_DISABLE_SPARSE BIT_ULL(38)	1901	#define XHCI_DISABLE_SPARSE BIT_ULL(38)
1902	#define XHCI_SG_TRB_CACHE_SIZE_QUIRK BIT_ULL(39)	1902	#define XHCI_SG_TRB_CACHE_SIZE_QUIRK BIT_ULL(39)
1903	#define XHCI_NO_SOFT_RETRY BIT_ULL(40)	1903	#define XHCI_NO_SOFT_RETRY BIT_ULL(40)
1904	#define XHCI_BROKEN_D3COLD BIT_ULL(41)	1904	#define XHCI_BROKEN_D3COLD_S2I BIT_ULL(41)
1905	#define XHCI_EP_CTX_BROKEN_DCS BIT_ULL(42)	1905	#define XHCI_EP_CTX_BROKEN_DCS BIT_ULL(42)
1906	#define XHCI_SUSPEND_RESUME_CLKS BIT_ULL(43)	1906	#define XHCI_SUSPEND_RESUME_CLKS BIT_ULL(43)
1907	#define XHCI_RESET_TO_DEFAULT BIT_ULL(44)	1907	#define XHCI_RESET_TO_DEFAULT BIT_ULL(44)

drivers/usb/storage/scsiglue.c+21−7

  ***********************************************************************/
 /* Command timeout and abort */
-static int command_abort(struct scsi_cmnd *srb)
+static int command_abort_matching(struct us_data *us, struct scsi_cmnd *srb_match)
 {
-	struct us_data *us = host_to_us(srb->device->host);
-	usb_stor_dbg(us, "%s called\n", __func__);
 	/*
 	 * us->srb together with the TIMED_OUT, RESETTING, and ABORTING
 	 * bits are protected by the host lock.
 	 */
 	scsi_lock(us_to_host(us));
-	/* Is this command still active? */
+	/* is there any active pending command to abort ? */
-	if (us->srb != srb) {
+	if (!us->srb) {
 		scsi_unlock(us_to_host(us));
 		usb_stor_dbg(us, "-- nothing to abort\n");
+		return SUCCESS;
+	}
+	/* Does the command match the passed srb if any ? */
+	if (srb_match && us->srb != srb_match) {
+		scsi_unlock(us_to_host(us));
+		usb_stor_dbg(us, "-- pending command mismatch\n");
 		return FAILED;
 	}
 	return SUCCESS;
 }
+static int command_abort(struct scsi_cmnd *srb)
+{
+	struct us_data *us = host_to_us(srb->device->host);
+	usb_stor_dbg(us, "%s called\n", __func__);
+	return command_abort_matching(us, srb);
+}
 /*
  * This invokes the transport reset mechanism to reset the state of the
  * device
 	usb_stor_dbg(us, "%s called\n", __func__);
+	/* abort any pending command before reset */
+	command_abort_matching(us, NULL);
 	/* lock the device pointers and do the reset */
 	mutex_lock(&(us->dev_mutex));
 	result = us->transport_reset(us);

drivers/usb/typec/altmodes/displayport.c+4−0

@@ -516,6 +516,10 @@ static ssize_t pin_assignment_show(struct device *dev, · 515 unmodified lines
516		516
517	mutex_unlock(&dp->lock);	517	mutex_unlock(&dp->lock);
518		518
		519	/* get_current_pin_assignments can return 0 when no matching pin assignments are found */
		520	if (len == 0)
		521	len++;
		522
519	buf[len - 1] = '\n';	523	buf[len - 1] = '\n';
520	return len;	524	return len;
521	}	525	}

drivers/usb/typec/tipd/core.c+3−0

@@ -886,6 +886,9 @@ static void tps6598x_remove(struct i2c_client *client) · 885 unmodified lines
886	{	886	{
887	struct tps6598x *tps = i2c_get_clientdata(client);	887	struct tps6598x *tps = i2c_get_clientdata(client);
888		888
		889	if (!client->irq)
		890	cancel_delayed_work_sync(&tps->wq_poll);
		891
889	tps6598x_disconnect(tps, 0);	892	tps6598x_disconnect(tps, 0);
890	typec_unregister_port(tps->port);	893	typec_unregister_port(tps->port);
891	usb_role_switch_put(tps->role_sw);	894	usb_role_switch_put(tps->role_sw);

include/linux/device/class.h+1−0

@@ -74,6 +74,7 @@ struct class { · 73 unmodified lines
74	struct class_dev_iter {	74	struct class_dev_iter {
75	struct klist_iter ki;	75	struct klist_iter ki;
76	const struct device_type *type;	76	const struct device_type *type;
		77	struct subsys_private *sp;
77	};	78	};
78		79
79	int __must_check class_register(const struct class *class);	80	int __must_check class_register(const struct class *class);

include/linux/usb/composite.h+1−1

@@ -443,7 +443,7 @@ static inline struct usb_composite_driver *to_cdriver( · 442 unmodified lines
443	* @bcd_webusb_version: 0x0100 by default, WebUSB specification version	443	* @bcd_webusb_version: 0x0100 by default, WebUSB specification version
444	* @b_webusb_vendor_code: 0x0 by default, vendor code for WebUSB	444	* @b_webusb_vendor_code: 0x0 by default, vendor code for WebUSB
445	* @landing_page: empty by default, landing page to announce in WebUSB	445	* @landing_page: empty by default, landing page to announce in WebUSB
446	* @use_webusb:: false by default, interested gadgets set it	446	* @use_webusb: false by default, interested gadgets set it
447	* @os_desc_config: the configuration to be used with OS descriptors	447	* @os_desc_config: the configuration to be used with OS descriptors
448	* @setup_pending: true when setup request is queued but not completed	448	* @setup_pending: true when setup request is queued but not completed
449	* @os_desc_pending: true when os_desc request is queued but not completed	449	* @os_desc_pending: true when os_desc request is queued but not completed