lael-labs/linux

Documentation/devicetree/bindings/usb/amlogic,dwc3.txt+2−2

@@ -85,8 +85,8 @@ A child node must exist to represent the core DWC2 IP block. The name of · 84 unmodified lines
85	the node is not important. The content of the node is defined in dwc2.txt.	85	the node is not important. The content of the node is defined in dwc2.txt.
86		86
87	PHY documentation is provided in the following places:	87	PHY documentation is provided in the following places:
88	- Documentation/devicetree/bindings/phy/meson-g12a-usb2-phy.txt	88	- Documentation/devicetree/bindings/phy/amlogic,meson-g12a-usb2-phy.yaml
89	- Documentation/devicetree/bindings/phy/meson-g12a-usb3-pcie-phy.txt	89	- Documentation/devicetree/bindings/phy/amlogic,meson-g12a-usb3-pcie-phy.yaml
90		90
91	Example device nodes:	91	Example device nodes:
92	usb: usb@ffe09000 {	92	usb: usb@ffe09000 {

Documentation/devicetree/bindings/usb/generic-ehci.yaml+6−1

     description:
       Set this flag to force EHCI reset after resume.
-  phys: true
+  phys:
+    description: PHY specifier for the USB PHY
+  phy-names:
+    const: usb
 required:
   - compatible
         interrupts = <39>;
         clocks = <&ahb_gates 1>;
         phys = <&usbphy 1>;
+        phy-names = "usb";
     };
 ...

Documentation/devicetree/bindings/usb/generic-ohci.yaml+6−1

     description:
       Overrides the detected port count
-  phys: true
+  phys:
+    description: PHY specifier for the USB PHY
+  phy-names:
+    const: usb
 required:
   - compatible
           interrupts = <64>;
           clocks = <&usb_clk 6>, <&ahb_gates 2>;
           phys = <&usbphy 1>;
+          phy-names = "usb";
       };
 ...

Documentation/devicetree/bindings/usb/mediatek,mtk-xhci.txt+2−2

@@ -33,7 +33,7 @@ Required properties: · 32 unmodified lines
33	"dma_ck": dma_bus clock for data transfer by DMA,	33	"dma_ck": dma_bus clock for data transfer by DMA,
34	"xhci_ck": controller clock	34	"xhci_ck": controller clock
35		35
36	- phys : see usb-hcd.txt in the current directory	36	- phys : see usb-hcd.yaml in the current directory
37		37
38	Optional properties:	38	Optional properties:
39	- wakeup-source : enable USB remote wakeup;	39	- wakeup-source : enable USB remote wakeup;
@@ -53,7 +53,7 @@ Optional properties: · 13 unmodified lines
53	See: Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt	53	See: Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt
54	- imod-interval-ns: default interrupt moderation interval is 5000ns	54	- imod-interval-ns: default interrupt moderation interval is 5000ns
55		55
56	additionally the properties from usb-hcd.txt (in the current directory) are	56	additionally the properties from usb-hcd.yaml (in the current directory) are
57	supported.	57	supported.
58		58
59	Example:	59	Example:

Documentation/devicetree/bindings/usb/mediatek,mtu3.txt+2−2

@@ -17,7 +17,7 @@ Required properties: · 16 unmodified lines
17	- clock-names : must contain "sys_ck" for clock of controller,	17	- clock-names : must contain "sys_ck" for clock of controller,
18	the following clocks are optional:	18	the following clocks are optional:
19	"ref_ck", "mcu_ck" and "dma_ck";	19	"ref_ck", "mcu_ck" and "dma_ck";
20	- phys : see usb-hcd.txt in the current directory	20	- phys : see usb-hcd.yaml in the current directory
21	- dr_mode : should be one of "host", "peripheral" or "otg",	21	- dr_mode : should be one of "host", "peripheral" or "otg",
22	refer to usb/generic.txt	22	refer to usb/generic.txt
23		23
@@ -60,7 +60,7 @@ Optional properties: · 36 unmodified lines
60	- mediatek,u3p-dis-msk : mask to disable u3ports, bit0 for u3port0,	60	- mediatek,u3p-dis-msk : mask to disable u3ports, bit0 for u3port0,
61	bit1 for u3port1, ... etc;	61	bit1 for u3port1, ... etc;
62		62
63	additionally the properties from usb-hcd.txt (in the current directory) are	63	additionally the properties from usb-hcd.yaml (in the current directory) are
64	supported.	64	supported.
65		65
66	Sub-nodes:	66	Sub-nodes:

Documentation/devicetree/bindings/usb/usb-hcd.yaml+5−0

     description:
       List of all the USB PHYs on this HCD
+  phy-names:
+    description:
+      Name specifier for the USB PHY
 examples:
   - |
     usb {
         phys = <&usb2_phy1>, <&usb3_phy1>;
+        phy-names = "usb";
     };

Documentation/devicetree/bindings/usb/usb-uhci.txt+1−1

@@ -6,7 +6,7 @@ Required properties: · 5 unmodified lines
6	- reg : Should contain 1 register ranges(address and length)	6	- reg : Should contain 1 register ranges(address and length)
7	- interrupts : UHCI controller interrupt	7	- interrupts : UHCI controller interrupt
8		8
9	additionally the properties from usb-hcd.txt (in the current directory) are	9	additionally the properties from usb-hcd.yaml (in the current directory) are
10	supported.	10	supported.
11		11
12	Example:	12	Example:

Documentation/devicetree/bindings/usb/usb-xhci.txt+2−2

@@ -41,9 +41,9 @@ Optional properties: · 40 unmodified lines
41	- usb3-lpm-capable: determines if platform is USB3 LPM capable	41	- usb3-lpm-capable: determines if platform is USB3 LPM capable
42	- quirk-broken-port-ped: set if the controller has broken port disable mechanism	42	- quirk-broken-port-ped: set if the controller has broken port disable mechanism
43	- imod-interval-ns: default interrupt moderation interval is 5000ns	43	- imod-interval-ns: default interrupt moderation interval is 5000ns
44	- phys : see usb-hcd.txt in the current directory	44	- phys : see usb-hcd.yaml in the current directory
45		45
46	additionally the properties from usb-hcd.txt (in the current directory) are	46	additionally the properties from usb-hcd.yaml (in the current directory) are
47	supported.	47	supported.
48		48
49		49

Documentation/usb/rio.rst+0−109

@@ -1,109 +0,0 @@
1	============
2	Diamonds Rio
3	============
4
5	Copyright (C) 1999, 2000 Bruce Tenison
6
7	Portions Copyright (C) 1999, 2000 David Nelson
8
9	Thanks to David Nelson for guidance and the usage of the scanner.txt
10	and scanner.c files to model our driver and this informative file.
11
12	Mar. 2, 2000
13
14	Changes
15	=======
16
17	- Initial Revision
18
19
20	Overview
21	========
22
23	This README will address issues regarding how to configure the kernel
24	to access a RIO 500 mp3 player.
25	Before I explain how to use this to access the Rio500 please be warned:
26
27	.. warning::
28
29	Please note that this software is still under development. The authors
30	are in no way responsible for any damage that may occur, no matter how
31	inconsequential.
32
33	It seems that the Rio has a problem when sending .mp3 with low batteries.
34	I suggest when the batteries are low and you want to transfer stuff that you
35	replace it with a fresh one. In my case, what happened is I lost two 16kb
36	blocks (they are no longer usable to store information to it). But I don't
37	know if that's normal or not; it could simply be a problem with the flash
38	memory.
39
40	In an extreme case, I left my Rio playing overnight and the batteries wore
41	down to nothing and appear to have corrupted the flash memory. My RIO
42	needed to be replaced as a result. Diamond tech support is aware of the
43	problem. Do NOT allow your batteries to wear down to nothing before
44	changing them. It appears RIO 500 firmware does not handle low battery
45	power well at all.
46
47	On systems with OHCI controllers, the kernel OHCI code appears to have
48	power on problems with some chipsets. If you are having problems
49	connecting to your RIO 500, try turning it on first and then plugging it
50	into the USB cable.
51
52	Contact Information
53	-------------------
54
55	The main page for the project is hosted at sourceforge.net in the following
56	URL: <http://rio500.sourceforge.net>. You can also go to the project's
57	sourceforge home page at: <http://sourceforge.net/projects/rio500/>.
58	There is also a mailing list: rio500-users@lists.sourceforge.net
59
60	Authors
61	-------
62
63	Most of the code was written by Cesar Miquel <miquel@df.uba.ar>. Keith
64	Clayton <kclayton@jps.net> is incharge of the PPC port and making sure
65	things work there. Bruce Tenison <btenison@dibbs.net> is adding support
66	for .fon files and also does testing. The program will mostly sure be
67	re-written and Pete Ikusz along with the rest will re-design it. I would
68	also like to thank Tri Nguyen <tmn_3022000@hotmail.com> who provided use
69	with some important information regarding the communication with the Rio.
70
71	Additional Information and userspace tools
72
73	http://rio500.sourceforge.net/
74
75
76	Requirements
77	============
78
79	A host with a USB port running a Linux kernel with RIO 500 support enabled.
80
81	The driver is a module called rio500, which should be automatically loaded
82	as you plug in your device. If that fails you can manually load it with
83
84	modprobe rio500
85
86	Udev should automatically create a device node as soon as plug in your device.
87	If that fails, you can manually add a device for the USB rio500::
88
89	mknod /dev/usb/rio500 c 180 64
90
91	In that case, set appropriate permissions for /dev/usb/rio500 (don't forget
92	about group and world permissions). Both read and write permissions are
93	required for proper operation.
94
95	That's it. The Rio500 Utils at: http://rio500.sourceforge.net should
96	be able to access the rio500.
97
98	Limits
99	======
100
101	You can use only a single rio500 device at a time with your computer.
102
103	Bugs
104	====
105
106	If you encounter any problems feel free to drop me an email.
107
108	Bruce Tenison
109	btenison@dibbs.net

MAINTAINERS+0−7

@@ -16764,13 +16764,6 @@ W: http://www.linux-usb.org/usbnet · 16763 unmodified lines
16764	S: Maintained	16764	S: Maintained
16765	F: drivers/net/usb/dm9601.c	16765	F: drivers/net/usb/dm9601.c
16766		16766
16767	USB DIAMOND RIO500 DRIVER
16768	M: Cesar Miquel <miquel@df.uba.ar>
16769	L: rio500-users@lists.sourceforge.net
16770	W: http://rio500.sourceforge.net
16771	S: Maintained
16772	F: drivers/usb/misc/rio500*
16773
16774	USB EHCI DRIVER	16767	USB EHCI DRIVER
16775	M: Alan Stern <stern@rowland.harvard.edu>	16768	M: Alan Stern <stern@rowland.harvard.edu>
16776	L: linux-usb@vger.kernel.org	16769	L: linux-usb@vger.kernel.org

arch/arm/boot/dts/sun4i-a10.dtsi+4−0

 			interrupts = <39>;
 			clocks = <&ccu CLK_AHB_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <64>;
 			clocks = <&ccu CLK_USB_OHCI0>, <&ccu CLK_AHB_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <40>;
 			clocks = <&ccu CLK_AHB_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <65>;
 			clocks = <&ccu CLK_USB_OHCI1>, <&ccu CLK_AHB_OHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun5i.dtsi+2−0

 			interrupts = <39>;
 			clocks = <&ccu CLK_AHB_EHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <40>;
 			clocks = <&ccu CLK_USB_OHCI>, <&ccu CLK_AHB_OHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun6i-a31.dtsi+4−0

 			clocks = <&ccu CLK_AHB1_EHCI0>;
 			resets = <&ccu RST_AHB1_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_AHB1_OHCI0>, <&ccu CLK_USB_OHCI0>;
 			resets = <&ccu RST_AHB1_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_AHB1_EHCI1>;
 			resets = <&ccu RST_AHB1_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_AHB1_OHCI1>, <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_AHB1_OHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun7i-a20.dtsi+4−0

 			interrupts = <GIC_SPI 39 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_AHB_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <GIC_SPI 64 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_USB_OHCI0>, <&ccu CLK_AHB_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <GIC_SPI 40 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_AHB_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <GIC_SPI 65 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_USB_OHCI1>, <&ccu CLK_AHB_OHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun8i-a23-a33.dtsi+2−0

 			clocks = <&ccu CLK_BUS_EHCI>;
 			resets = <&ccu RST_BUS_EHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_OHCI>, <&ccu CLK_USB_OHCI>;
 			resets = <&ccu RST_BUS_OHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun8i-a83t.dtsi+3−0

 			clocks = <&ccu CLK_BUS_EHCI0>;
 			resets = <&ccu RST_BUS_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_OHCI0>, <&ccu CLK_USB_OHCI0>;
 			resets = <&ccu RST_BUS_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun8i-r40.dtsi+4−0

 			clocks = <&ccu CLK_BUS_EHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI2>;
 			resets = <&ccu RST_BUS_EHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI2>;
 			resets = <&ccu RST_BUS_OHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun9i-a80.dtsi+5−0

 			clocks = <&usb_clocks CLK_BUS_HCI0>;
 			resets = <&usb_clocks RST_USB0_HCI>;
 			phys = <&usbphy1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&usb_clocks CLK_USB_OHCI0>;
 			resets = <&usb_clocks RST_USB0_HCI>;
 			phys = <&usbphy1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&usb_clocks CLK_BUS_HCI1>;
 			resets = <&usb_clocks RST_USB1_HCI>;
 			phys = <&usbphy2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&usb_clocks CLK_BUS_HCI2>;
 			resets = <&usb_clocks RST_USB2_HCI>;
 			phys = <&usbphy3>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&usb_clocks CLK_USB_OHCI2>;
 			resets = <&usb_clocks RST_USB2_HCI>;
 			phys = <&usbphy3>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sunxi-h3-h5.dtsi+6−0

 			clocks = <&ccu CLK_BUS_EHCI1>, <&ccu CLK_BUS_OHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>, <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>, <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI2>, <&ccu CLK_BUS_OHCI2>;
 			resets = <&ccu RST_BUS_EHCI2>, <&ccu RST_BUS_OHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI2>;
 			resets = <&ccu RST_BUS_EHCI2>, <&ccu RST_BUS_OHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI3>, <&ccu CLK_BUS_OHCI3>;
 			resets = <&ccu RST_BUS_EHCI3>, <&ccu RST_BUS_OHCI3>;
 			phys = <&usbphy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI3>;
 			resets = <&ccu RST_BUS_EHCI3>, <&ccu RST_BUS_OHCI3>;
 			phys = <&usbphy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/configs/badge4_defconfig+0−1

@@ -91,7 +91,6 @@ CONFIG_USB_SERIAL_PL2303=m · 90 unmodified lines
91	CONFIG_USB_SERIAL_CYBERJACK=m	91	CONFIG_USB_SERIAL_CYBERJACK=m
92	CONFIG_USB_SERIAL_XIRCOM=m	92	CONFIG_USB_SERIAL_XIRCOM=m
93	CONFIG_USB_SERIAL_OMNINET=m	93	CONFIG_USB_SERIAL_OMNINET=m
94	CONFIG_USB_RIO500=m
95	CONFIG_EXT2_FS=m	94	CONFIG_EXT2_FS=m
96	CONFIG_EXT3_FS=m	95	CONFIG_EXT3_FS=m
97	CONFIG_MSDOS_FS=y	96	CONFIG_MSDOS_FS=y

arch/arm/configs/corgi_defconfig+0−1

@@ -195,7 +195,6 @@ CONFIG_USB_SERIAL_XIRCOM=m · 194 unmodified lines
195	CONFIG_USB_SERIAL_OMNINET=m	195	CONFIG_USB_SERIAL_OMNINET=m
196	CONFIG_USB_EMI62=m	196	CONFIG_USB_EMI62=m
197	CONFIG_USB_EMI26=m	197	CONFIG_USB_EMI26=m
198	CONFIG_USB_RIO500=m
199	CONFIG_USB_LEGOTOWER=m	198	CONFIG_USB_LEGOTOWER=m
200	CONFIG_USB_LCD=m	199	CONFIG_USB_LCD=m
201	CONFIG_USB_CYTHERM=m	200	CONFIG_USB_CYTHERM=m

arch/arm/configs/pxa_defconfig+0−1

@@ -581,7 +581,6 @@ CONFIG_USB_SERIAL_XIRCOM=m · 580 unmodified lines
581	CONFIG_USB_SERIAL_OMNINET=m	581	CONFIG_USB_SERIAL_OMNINET=m
582	CONFIG_USB_EMI62=m	582	CONFIG_USB_EMI62=m
583	CONFIG_USB_EMI26=m	583	CONFIG_USB_EMI26=m
584	CONFIG_USB_RIO500=m
585	CONFIG_USB_LEGOTOWER=m	584	CONFIG_USB_LEGOTOWER=m
586	CONFIG_USB_LCD=m	585	CONFIG_USB_LCD=m
587	CONFIG_USB_CYTHERM=m	586	CONFIG_USB_CYTHERM=m

arch/arm/configs/s3c2410_defconfig+0−1

@@ -327,7 +327,6 @@ CONFIG_USB_EMI62=m · 326 unmodified lines
327	CONFIG_USB_EMI26=m	327	CONFIG_USB_EMI26=m
328	CONFIG_USB_ADUTUX=m	328	CONFIG_USB_ADUTUX=m
329	CONFIG_USB_SEVSEG=m	329	CONFIG_USB_SEVSEG=m
330	CONFIG_USB_RIO500=m
331	CONFIG_USB_LEGOTOWER=m	330	CONFIG_USB_LEGOTOWER=m
332	CONFIG_USB_LCD=m	331	CONFIG_USB_LCD=m
333	CONFIG_USB_CYPRESS_CY7C63=m	332	CONFIG_USB_CYPRESS_CY7C63=m

arch/arm/configs/spitz_defconfig+0−1

@@ -189,7 +189,6 @@ CONFIG_USB_SERIAL_XIRCOM=m · 188 unmodified lines
189	CONFIG_USB_SERIAL_OMNINET=m	189	CONFIG_USB_SERIAL_OMNINET=m
190	CONFIG_USB_EMI62=m	190	CONFIG_USB_EMI62=m
191	CONFIG_USB_EMI26=m	191	CONFIG_USB_EMI26=m
192	CONFIG_USB_RIO500=m
193	CONFIG_USB_LEGOTOWER=m	192	CONFIG_USB_LEGOTOWER=m
194	CONFIG_USB_LCD=m	193	CONFIG_USB_LCD=m
195	CONFIG_USB_CYTHERM=m	194	CONFIG_USB_CYTHERM=m

arch/arm64/boot/dts/allwinner/sun50i-a64-pinebook.dts+2−0

 &ehci0 {
 	phys = <&usbphy 0>;
+	phy-names = "usb";
 	status = "okay";
 };
 &ohci0 {
 	phys = <&usbphy 0>;
+	phy-names = "usb";
 	status = "okay";
 };

arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi+2−0

 			resets = <&ccu RST_BUS_OHCI1>,
 				 <&ccu RST_BUS_EHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm64/boot/dts/allwinner/sun50i-h6.dtsi+2−0

 			resets = <&ccu RST_BUS_OHCI3>,
 				 <&ccu RST_BUS_EHCI3>;
 			phys = <&usb2phy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI3>;
 			resets = <&ccu RST_BUS_OHCI3>;
 			phys = <&usb2phy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/mips/configs/mtx1_defconfig+0−1

@@ -571,7 +571,6 @@ CONFIG_USB_SERIAL_OMNINET=m · 570 unmodified lines
571	CONFIG_USB_EMI62=m	571	CONFIG_USB_EMI62=m
572	CONFIG_USB_EMI26=m	572	CONFIG_USB_EMI26=m
573	CONFIG_USB_ADUTUX=m	573	CONFIG_USB_ADUTUX=m
574	CONFIG_USB_RIO500=m
575	CONFIG_USB_LEGOTOWER=m	574	CONFIG_USB_LEGOTOWER=m
576	CONFIG_USB_LCD=m	575	CONFIG_USB_LCD=m
577	CONFIG_USB_CYPRESS_CY7C63=m	576	CONFIG_USB_CYPRESS_CY7C63=m

arch/mips/configs/rm200_defconfig+0−1

@@ -314,7 +314,6 @@ CONFIG_USB_SERIAL_SAFE_PADDED=y · 313 unmodified lines
314	CONFIG_USB_SERIAL_CYBERJACK=m	314	CONFIG_USB_SERIAL_CYBERJACK=m
315	CONFIG_USB_SERIAL_XIRCOM=m	315	CONFIG_USB_SERIAL_XIRCOM=m
316	CONFIG_USB_SERIAL_OMNINET=m	316	CONFIG_USB_SERIAL_OMNINET=m
317	CONFIG_USB_RIO500=m
318	CONFIG_USB_LEGOTOWER=m	317	CONFIG_USB_LEGOTOWER=m
319	CONFIG_USB_LCD=m	318	CONFIG_USB_LCD=m
320	CONFIG_USB_CYTHERM=m	319	CONFIG_USB_CYTHERM=m

drivers/base/platform.c+39−7

@@ -241,12 +241,8 @@ struct resource platform_get_resource_byname(struct platform_device dev, · 240 unmodified lines
241	}	241	}
242	EXPORT_SYMBOL_GPL(platform_get_resource_byname);	242	EXPORT_SYMBOL_GPL(platform_get_resource_byname);
243		243
244	/**	244	static int __platform_get_irq_byname(struct platform_device *dev,
245	* platform_get_irq_byname - get an IRQ for a device by name	245	const char *name)
246	* @dev: platform device
247	* @name: IRQ name
248	*/
249	int platform_get_irq_byname(struct platform_device dev, const char name)
250	{	246	{
251	struct resource *r;	247	struct resource *r;
252		248
@@ -262,11 +258,47 @@ int platform_get_irq_byname(struct platform_device dev, const char name) · 9 unmodified lines
262	if (r)	258	if (r)
263	return r->start;	259	return r->start;
264		260
265	dev_err(&dev->dev, "IRQ %s not found\n", name);
266	return -ENXIO;	261	return -ENXIO;
267	}	262	}
		263
		264	/**
		265	* platform_get_irq_byname - get an IRQ for a device by name
		266	* @dev: platform device
		267	* @name: IRQ name
		268	*
		269	* Get an IRQ like platform_get_irq(), but then by name rather then by index.
		270	*
		271	* Return: IRQ number on success, negative error number on failure.
		272	*/
		273	int platform_get_irq_byname(struct platform_device dev, const char name)
		274	{
		275	int ret;
		276
		277	ret = __platform_get_irq_byname(dev, name);
		278	if (ret < 0 && ret != -EPROBE_DEFER)
		279	dev_err(&dev->dev, "IRQ %s not found\n", name);
		280
		281	return ret;
		282	}
268	EXPORT_SYMBOL_GPL(platform_get_irq_byname);	283	EXPORT_SYMBOL_GPL(platform_get_irq_byname);
269		284
		285	/**
		286	* platform_get_irq_byname_optional - get an optional IRQ for a device by name
		287	* @dev: platform device
		288	* @name: IRQ name
		289	*
		290	* Get an optional IRQ by name like platform_get_irq_byname(). Except that it
		291	* does not print an error message if an IRQ can not be obtained.
		292	*
		293	* Return: IRQ number on success, negative error number on failure.
		294	*/
		295	int platform_get_irq_byname_optional(struct platform_device *dev,
		296	const char *name)
		297	{
		298	return __platform_get_irq_byname(dev, name);
		299	}
		300	EXPORT_SYMBOL_GPL(platform_get_irq_byname_optional);
		301
270	/**	302	/**
271	* platform_add_devices - add a numbers of platform devices	303	* platform_add_devices - add a numbers of platform devices
272	* @devs: array of platform devices to add	304	* @devs: array of platform devices to add

drivers/media/usb/stkwebcam/stk-webcam.c+1−2

@@ -643,8 +643,7 @@ static int v4l_stk_release(struct file *fp) · 642 unmodified lines
643	dev->owner = NULL;	643	dev->owner = NULL;
644	}	644	}
645		645
646	if (is_present(dev))	646	usb_autopm_put_interface(dev->interface);
647	usb_autopm_put_interface(dev->interface);
648	mutex_unlock(&dev->lock);	647	mutex_unlock(&dev->lock);
649	return v4l2_fh_release(fp);	648	return v4l2_fh_release(fp);
650	}	649	}

drivers/usb/cdns3/cdns3-pci-wrap.c+2−1

 		wrap->plat_dev = platform_device_register_full(&plat_info);
 		if (IS_ERR(wrap->plat_dev)) {
 			pci_disable_device(pdev);
+			err = PTR_ERR(wrap->plat_dev);
 			kfree(wrap);
-			return PTR_ERR(wrap->plat_dev);
+			return err;
 		}
 	}

drivers/usb/cdns3/core.c+19−1

@@ -160,10 +160,28 @@ static int cdns3_core_init_role(struct cdns3 *cdns) · 159 unmodified lines
160	if (ret)	160	if (ret)
161	goto err;	161	goto err;
162		162
163	if (cdns->dr_mode != USB_DR_MODE_OTG) {	163	/* Initialize idle role to start with */
		164	ret = cdns3_role_start(cdns, USB_ROLE_NONE);
		165	if (ret)
		166	goto err;
		167
		168	switch (cdns->dr_mode) {
		169	case USB_DR_MODE_UNKNOWN:
		170	case USB_DR_MODE_OTG:
164	ret = cdns3_hw_role_switch(cdns);	171	ret = cdns3_hw_role_switch(cdns);
165	if (ret)	172	if (ret)
166	goto err;	173	goto err;
		174	break;
		175	case USB_DR_MODE_PERIPHERAL:
		176	ret = cdns3_role_start(cdns, USB_ROLE_DEVICE);
		177	if (ret)
		178	goto err;
		179	break;
		180	case USB_DR_MODE_HOST:
		181	ret = cdns3_role_start(cdns, USB_ROLE_HOST);
		182	if (ret)
		183	goto err;
		184	break;
167	}	185	}
168		186
169	return ret;	187	return ret;

drivers/usb/cdns3/ep0.c+9−3

 static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
 				    struct usb_ctrlrequest *ctrl)
 {
+	struct cdns3_endpoint *priv_ep;
 	__le16 *response_pkt;
 	u16 usb_status = 0;
 	u32 recip;
+	u8 index;
 	recip = ctrl->bRequestType & USB_RECIP_MASK;
 	case USB_RECIP_INTERFACE:
 		return cdns3_ep0_delegate_req(priv_dev, ctrl);
 	case USB_RECIP_ENDPOINT:
-		/* check if endpoint is stalled */
+		index = cdns3_ep_addr_to_index(ctrl->wIndex);
+		priv_ep = priv_dev->eps[index];
+		/* check if endpoint is stalled or stall is pending */
 		cdns3_select_ep(priv_dev, ctrl->wIndex);
-		if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)))
+		if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)) ||
+		    (priv_ep->flags & EP_STALL_PENDING))
 			usb_status =  BIT(USB_ENDPOINT_HALT);
 		break;
 	default:
 			 * for sending status stage.
 			 * This time should be less then 3ms.
 			 */
-			usleep_range(1000, 2000);
+			mdelay(1);
 			cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
 					       USB_CMD_STMODE |
 					       USB_STS_TMODE_SEL(tmode - 1));

drivers/usb/cdns3/gadget.c+8−0

 	switch (max_speed) {
 	case USB_SPEED_FULL:
 		writel(USB_CONF_SFORCE_FS, &priv_dev->regs->usb_conf);
+		writel(USB_CONF_USB3DIS, &priv_dev->regs->usb_conf);
 		break;
 	case USB_SPEED_HIGH:
 		writel(USB_CONF_USB3DIS, &priv_dev->regs->usb_conf);
 {
 	int ret = 0;
+	/* Ensure 32-bit DMA Mask in case we switched back from Host mode */
+	ret = dma_set_mask_and_coherent(cdns->dev, DMA_BIT_MASK(32));
+	if (ret) {
+		dev_err(cdns->dev, "Failed to set dma mask: %d\n", ret);
+		return ret;
+	}
 	cdns3_drd_switch_gadget(cdns, 1);
 	pm_runtime_get_sync(cdns->dev);

drivers/usb/class/usblp.c+5−3

@@ -461,10 +461,12 @@ static int usblp_release(struct inode inode, struct file file) · 460 unmodified lines
461		461
462	mutex_lock(&usblp_mutex);	462	mutex_lock(&usblp_mutex);
463	usblp->used = 0;	463	usblp->used = 0;
464	if (usblp->present) {	464	if (usblp->present)
465	usblp_unlink_urbs(usblp);	465	usblp_unlink_urbs(usblp);
466	usb_autopm_put_interface(usblp->intf);	466
467	} else /* finish cleanup from disconnect */	467	usb_autopm_put_interface(usblp->intf);
		468
		469	if (!usblp->present) /* finish cleanup from disconnect */
468	usblp_cleanup(usblp);	470	usblp_cleanup(usblp);
469	mutex_unlock(&usblp_mutex);	471	mutex_unlock(&usblp_mutex);
470	return 0;	472	return 0;

drivers/usb/dwc3/drd.c+2−5

 	struct platform_device *dwc3_pdev = to_platform_device(dwc->dev);
 	int irq;
-	irq = platform_get_irq_byname(dwc3_pdev, "otg");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "otg");
 	if (irq > 0)
 		goto out;
 	if (irq == -EPROBE_DEFER)
 		goto out;
-	irq = platform_get_irq_byname(dwc3_pdev, "dwc_usb3");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "dwc_usb3");
 	if (irq > 0)
 		goto out;
 	if (irq > 0)
 		goto out;
-	if (irq != -EPROBE_DEFER)
-		dev_err(dwc->dev, "missing OTG IRQ\n");
 	if (!irq)
 		irq = -EINVAL;

drivers/usb/dwc3/gadget.c+2−5

 	struct platform_device *dwc3_pdev = to_platform_device(dwc->dev);
 	int irq;
-	irq = platform_get_irq_byname(dwc3_pdev, "peripheral");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "peripheral");
 	if (irq > 0)
 		goto out;
 	if (irq == -EPROBE_DEFER)
 		goto out;
-	irq = platform_get_irq_byname(dwc3_pdev, "dwc_usb3");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "dwc_usb3");
 	if (irq > 0)
 		goto out;
 	if (irq > 0)
 		goto out;
-	if (irq != -EPROBE_DEFER)
-		dev_err(dwc->dev, "missing peripheral IRQ\n");
 	if (!irq)
 		irq = -EINVAL;

drivers/usb/dwc3/host.c+2−5

 	struct platform_device	*dwc3_pdev = to_platform_device(dwc->dev);
 	int irq;
-	irq = platform_get_irq_byname(dwc3_pdev, "host");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "host");
 	if (irq > 0)
 		goto out;
 	if (irq == -EPROBE_DEFER)
 		goto out;
-	irq = platform_get_irq_byname(dwc3_pdev, "dwc_usb3");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "dwc_usb3");
 	if (irq > 0)
 		goto out;
 	if (irq > 0)
 		goto out;
-	if (irq != -EPROBE_DEFER)
-		dev_err(dwc->dev, "missing host IRQ\n");
 	if (!irq)
 		irq = -EINVAL;

drivers/usb/gadget/udc/Kconfig+1−1

@@ -45,7 +45,7 @@ config USB_AT91 · 44 unmodified lines
45		45
46	config USB_LPC32XX	46	config USB_LPC32XX
47	tristate "LPC32XX USB Peripheral Controller"	47	tristate "LPC32XX USB Peripheral Controller"
48	depends on ARCH_LPC32XX	48	depends on ARCH_LPC32XX \|\| COMPILE_TEST
49	depends on I2C	49	depends on I2C
50	select USB_ISP1301	50	select USB_ISP1301
51	help	51	help

drivers/usb/gadget/udc/dummy_hcd.c+2−1

 #define DRIVER_VERSION	"02 May 2005"
 #define POWER_BUDGET	500	/* in mA; use 8 for low-power port testing */
+#define POWER_BUDGET_3	900	/* in mA */
 static const char	driver_name[] = "dummy_hcd";
 static const char	driver_desc[] = "USB Host+Gadget Emulator";
 	dum_hcd->rh_state = DUMMY_RH_RUNNING;
 	dum_hcd->stream_en_ep = 0;
 	INIT_LIST_HEAD(&dum_hcd->urbp_list);
-	dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET;
+	dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET_3;
 	dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
 	dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
 #ifdef CONFIG_USB_OTG

drivers/usb/gadget/udc/lpc32xx_udc.c+2−2

@@ -1151,7 +1151,7 @@ static void udc_pop_fifo(struct lpc32xx_udc udc, u8 data, u32 bytes) · 1150 unmodified lines
1151	u32 *p32, tmp, cbytes;	1151	u32 *p32, tmp, cbytes;
1152		1152
1153	/* Use optimal data transfer method based on source address and size */	1153	/* Use optimal data transfer method based on source address and size */
1154	switch (((u32) data) & 0x3) {	1154	switch (((uintptr_t) data) & 0x3) {
1155	case 0: /* 32-bit aligned */	1155	case 0: /* 32-bit aligned */
1156	p32 = (u32 *) data;	1156	p32 = (u32 *) data;
1157	cbytes = (bytes & ~0x3);	1157	cbytes = (bytes & ~0x3);
@@ -1252,7 +1252,7 @@ static void udc_stuff_fifo(struct lpc32xx_udc udc, u8 data, u32 bytes) · 94 unmodified lines
1252	u32 *p32, tmp, cbytes;	1252	u32 *p32, tmp, cbytes;
1253		1253
1254	/* Use optimal data transfer method based on source address and size */	1254	/* Use optimal data transfer method based on source address and size */
1255	switch (((u32) data) & 0x3) {	1255	switch (((uintptr_t) data) & 0x3) {
1256	case 0: /* 32-bit aligned */	1256	case 0: /* 32-bit aligned */
1257	p32 = (u32 *) data;	1257	p32 = (u32 *) data;
1258	cbytes = (bytes & ~0x3);	1258	cbytes = (bytes & ~0x3);

drivers/usb/host/xhci-ext-caps.c+1−0

@@ -57,6 +57,7 @@ static int xhci_create_intel_xhci_sw_pdev(struct xhci_hcd *xhci, u32 cap_offset) · 56 unmodified lines
57	ret = platform_device_add_properties(pdev, role_switch_props);	57	ret = platform_device_add_properties(pdev, role_switch_props);
58	if (ret) {	58	if (ret) {
59	dev_err(dev, "failed to register device properties\n");	59	dev_err(dev, "failed to register device properties\n");
		60	platform_device_put(pdev);
60	return ret;	61	return ret;
61	}	62	}
62	}	63	}

drivers/usb/host/xhci-ring.c+2−2

@@ -3202,10 +3202,10 @@ static int xhci_align_td(struct xhci_hcd xhci, struct urb urb, u32 enqd_len, · 3201 unmodified lines
3202	if (usb_urb_dir_out(urb)) {	3202	if (usb_urb_dir_out(urb)) {
3203	len = sg_pcopy_to_buffer(urb->sg, urb->num_sgs,	3203	len = sg_pcopy_to_buffer(urb->sg, urb->num_sgs,
3204	seg->bounce_buf, new_buff_len, enqd_len);	3204	seg->bounce_buf, new_buff_len, enqd_len);
3205	if (len != seg->bounce_len)	3205	if (len != new_buff_len)
3206	xhci_warn(xhci,	3206	xhci_warn(xhci,
3207	"WARN Wrong bounce buffer write length: %zu != %d\n",	3207	"WARN Wrong bounce buffer write length: %zu != %d\n",
3208	len, seg->bounce_len);	3208	len, new_buff_len);
3209	seg->bounce_dma = dma_map_single(dev, seg->bounce_buf,	3209	seg->bounce_dma = dma_map_single(dev, seg->bounce_buf,
3210	max_pkt, DMA_TO_DEVICE);	3210	max_pkt, DMA_TO_DEVICE);
3211	} else {	3211	} else {

drivers/usb/host/xhci.c+63−15

@@ -1032,7 +1032,7 @@ int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup) · 1031 unmodified lines
1032	writel(command, &xhci->op_regs->command);	1032	writel(command, &xhci->op_regs->command);
1033	xhci->broken_suspend = 0;	1033	xhci->broken_suspend = 0;
1034	if (xhci_handshake(&xhci->op_regs->status,	1034	if (xhci_handshake(&xhci->op_regs->status,
1035	STS_SAVE, 0, 10 * 1000)) {	1035	STS_SAVE, 0, 20 * 1000)) {
1036	/*	1036	/*
1037	* AMD SNPS xHC 3.0 occasionally does not clear the	1037	* AMD SNPS xHC 3.0 occasionally does not clear the
1038	* SSS bit of USBSTS and when driver tries to poll	1038	* SSS bit of USBSTS and when driver tries to poll
@@ -1108,6 +1108,18 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) · 69 unmodified lines
1108	hibernated = true;	1108	hibernated = true;
1109		1109
1110	if (!hibernated) {	1110	if (!hibernated) {
		1111	/*
		1112	* Some controllers might lose power during suspend, so wait
		1113	* for controller not ready bit to clear, just as in xHC init.
		1114	*/
		1115	retval = xhci_handshake(&xhci->op_regs->status,
		1116	STS_CNR, 0, 10 * 1000 * 1000);
		1117	if (retval) {
		1118	xhci_warn(xhci, "Controller not ready at resume %d\n",
		1119	retval);
		1120	spin_unlock_irq(&xhci->lock);
		1121	return retval;
		1122	}
1111	/* step 1: restore register */	1123	/* step 1: restore register */
1112	xhci_restore_registers(xhci);	1124	xhci_restore_registers(xhci);
1113	/* step 2: initialize command ring buffer */	1125	/* step 2: initialize command ring buffer */
@@ -3083,6 +3095,7 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, · 1969 unmodified lines
3083	unsigned int ep_index;	3095	unsigned int ep_index;
3084	unsigned long flags;	3096	unsigned long flags;
3085	u32 ep_flag;	3097	u32 ep_flag;
		3098	int err;
3086		3099
3087	xhci = hcd_to_xhci(hcd);	3100	xhci = hcd_to_xhci(hcd);
3088	if (!host_ep->hcpriv)	3101	if (!host_ep->hcpriv)
@@ -3142,7 +3155,17 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, · 53 unmodified lines
3142	xhci_free_command(xhci, cfg_cmd);	3155	xhci_free_command(xhci, cfg_cmd);
3143	goto cleanup;	3156	goto cleanup;
3144	}	3157	}
3145	xhci_queue_stop_endpoint(xhci, stop_cmd, udev->slot_id, ep_index, 0);	3158
		3159	err = xhci_queue_stop_endpoint(xhci, stop_cmd, udev->slot_id,
		3160	ep_index, 0);
		3161	if (err < 0) {
		3162	spin_unlock_irqrestore(&xhci->lock, flags);
		3163	xhci_free_command(xhci, cfg_cmd);
		3164	xhci_dbg(xhci, "%s: Failed to queue stop ep command, %d ",
		3165	__func__, err);
		3166	goto cleanup;
		3167	}
		3168
3146	xhci_ring_cmd_db(xhci);	3169	xhci_ring_cmd_db(xhci);
3147	spin_unlock_irqrestore(&xhci->lock, flags);	3170	spin_unlock_irqrestore(&xhci->lock, flags);
3148		3171
@@ -3156,8 +3179,16 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, · 7 unmodified lines
3156	ctrl_ctx, ep_flag, ep_flag);	3179	ctrl_ctx, ep_flag, ep_flag);
3157	xhci_endpoint_copy(xhci, cfg_cmd->in_ctx, vdev->out_ctx, ep_index);	3180	xhci_endpoint_copy(xhci, cfg_cmd->in_ctx, vdev->out_ctx, ep_index);
3158		3181
3159	xhci_queue_configure_endpoint(xhci, cfg_cmd, cfg_cmd->in_ctx->dma,	3182	err = xhci_queue_configure_endpoint(xhci, cfg_cmd, cfg_cmd->in_ctx->dma,
3160	udev->slot_id, false);	3183	udev->slot_id, false);
		3184	if (err < 0) {
		3185	spin_unlock_irqrestore(&xhci->lock, flags);
		3186	xhci_free_command(xhci, cfg_cmd);
		3187	xhci_dbg(xhci, "%s: Failed to queue config ep command, %d ",
		3188	__func__, err);
		3189	goto cleanup;
		3190	}
		3191
3161	xhci_ring_cmd_db(xhci);	3192	xhci_ring_cmd_db(xhci);
3162	spin_unlock_irqrestore(&xhci->lock, flags);	3193	spin_unlock_irqrestore(&xhci->lock, flags);
3163		3194
@@ -4674,12 +4705,12 @@ static int xhci_update_timeout_for_endpoint(struct xhci_hcd *xhci, · 1510 unmodified lines
4674	alt_timeout = xhci_call_host_update_timeout_for_endpoint(xhci, udev,	4705	alt_timeout = xhci_call_host_update_timeout_for_endpoint(xhci, udev,
4675	desc, state, timeout);	4706	desc, state, timeout);
4676		4707
4677	/* If we found we can't enable hub-initiated LPM, or	4708	/* If we found we can't enable hub-initiated LPM, and
4678	* the U1 or U2 exit latency was too high to allow	4709	* the U1 or U2 exit latency was too high to allow
4679	* device-initiated LPM as well, just stop searching.	4710	* device-initiated LPM as well, then we will disable LPM
		4711	* for this device, so stop searching any further.
4680	*/	4712	*/
4681	if (alt_timeout == USB3_LPM_DISABLED \|\|	4713	if (alt_timeout == USB3_LPM_DISABLED) {
4682	alt_timeout == USB3_LPM_DEVICE_INITIATED) {
4683	*timeout = alt_timeout;	4714	*timeout = alt_timeout;
4684	return -E2BIG;	4715	return -E2BIG;
4685	}	4716	}
@@ -4790,10 +4821,12 @@ static u16 xhci_calculate_lpm_timeout(struct usb_hcd *hcd, · 104 unmodified lines
4790	if (intf->dev.driver) {	4821	if (intf->dev.driver) {
4791	driver = to_usb_driver(intf->dev.driver);	4822	driver = to_usb_driver(intf->dev.driver);
4792	if (driver && driver->disable_hub_initiated_lpm) {	4823	if (driver && driver->disable_hub_initiated_lpm) {
4793	dev_dbg(&udev->dev, "Hub-initiated %s disabled "	4824	dev_dbg(&udev->dev, "Hub-initiated %s disabled at request of driver %s\n",
4794	"at request of driver %s\n",	4825	state_name, driver->name);
4795	state_name, driver->name);	4826	timeout = xhci_get_timeout_no_hub_lpm(udev,
4796	return xhci_get_timeout_no_hub_lpm(udev, state);	4827	state);
		4828	if (timeout == USB3_LPM_DISABLED)
		4829	return timeout;
4797	}	4830	}
4798	}	4831	}
4799		4832
@@ -5077,11 +5110,18 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks) · 277 unmodified lines
5077	hcd->has_tt = 1;	5110	hcd->has_tt = 1;
5078	} else {	5111	} else {
5079	/*	5112	/*
5080	* Some 3.1 hosts return sbrn 0x30, use xhci supported protocol	5113	* Early xHCI 1.1 spec did not mention USB 3.1 capable hosts
5081	* minor revision instead of sbrn. Minor revision is a two digit	5114	* should return 0x31 for sbrn, or that the minor revision
5082	* BCD containing minor and sub-minor numbers, only show minor.	5115	* is a two digit BCD containig minor and sub-minor numbers.
		5116	* This was later clarified in xHCI 1.2.
		5117	*
		5118	* Some USB 3.1 capable hosts therefore have sbrn 0x30, and
		5119	* minor revision set to 0x1 instead of 0x10.
5083	*/	5120	*/
5084	minor_rev = xhci->usb3_rhub.min_rev / 0x10;	5121	if (xhci->usb3_rhub.min_rev == 0x1)
		5122	minor_rev = 1;
		5123	else
		5124	minor_rev = xhci->usb3_rhub.min_rev / 0x10;
5085		5125
5086	switch (minor_rev) {	5126	switch (minor_rev) {
5087	case 2:	5127	case 2:
@@ -5198,8 +5238,16 @@ static void xhci_clear_tt_buffer_complete(struct usb_hcd *hcd, · 110 unmodified lines
5198	unsigned int ep_index;	5238	unsigned int ep_index;
5199	unsigned long flags;	5239	unsigned long flags;
5200		5240
		5241	/*
		5242	* udev might be NULL if tt buffer is cleared during a failed device
		5243	* enumeration due to a halted control endpoint. Usb core might
		5244	* have allocated a new udev for the next enumeration attempt.
		5245	*/
		5246
5201	xhci = hcd_to_xhci(hcd);	5247	xhci = hcd_to_xhci(hcd);
5202	udev = (struct usb_device *)ep->hcpriv;	5248	udev = (struct usb_device *)ep->hcpriv;
		5249	if (!udev)
		5250	return;
5203	slot_id = udev->slot_id;	5251	slot_id = udev->slot_id;
5204	ep_index = xhci_get_endpoint_index(&ep->desc);	5252	ep_index = xhci_get_endpoint_index(&ep->desc);
5205		5253

drivers/usb/image/microtek.c+4−0

@@ -716,6 +716,10 @@ static int mts_usb_probe(struct usb_interface *intf, · 715 unmodified lines
716		716
717	}	717	}
718		718
		719	if (ep_in_current != &ep_in_set[2]) {
		720	MTS_WARNING("couldn't find two input bulk endpoints. Bailing out.\n");
		721	return -ENODEV;
		722	}
719		723
720	if ( ep_out == -1 ) {	724	if ( ep_out == -1 ) {
721	MTS_WARNING( "couldn't find an output bulk endpoint. Bailing out.\n" );	725	MTS_WARNING( "couldn't find an output bulk endpoint. Bailing out.\n" );

drivers/usb/misc/Kconfig+0−10

@@ -47,16 +47,6 @@ config USB_SEVSEG · 46 unmodified lines
47	To compile this driver as a module, choose M here: the	47	To compile this driver as a module, choose M here: the
48	module will be called usbsevseg.	48	module will be called usbsevseg.
49		49
50	config USB_RIO500
51	tristate "USB Diamond Rio500 support"
52	help
53	Say Y here if you want to connect a USB Rio500 mp3 player to your
54	computer's USB port. Please read <file:Documentation/usb/rio.rst>
55	for more information.
56
57	To compile this driver as a module, choose M here: the
58	module will be called rio500.
59
60	config USB_LEGOTOWER	50	config USB_LEGOTOWER
61	tristate "USB Lego Infrared Tower support"	51	tristate "USB Lego Infrared Tower support"
62	help	52	help

drivers/usb/misc/Makefile+0−1

@@ -17,7 +17,6 @@ obj-$(CONFIG_USB_ISIGHTFW) += isight_firmware.o · 16 unmodified lines
17	obj-$(CONFIG_USB_LCD) += usblcd.o	17	obj-$(CONFIG_USB_LCD) += usblcd.o
18	obj-$(CONFIG_USB_LD) += ldusb.o	18	obj-$(CONFIG_USB_LD) += ldusb.o
19	obj-$(CONFIG_USB_LEGOTOWER) += legousbtower.o	19	obj-$(CONFIG_USB_LEGOTOWER) += legousbtower.o
20	obj-$(CONFIG_USB_RIO500) += rio500.o
21	obj-$(CONFIG_USB_TEST) += usbtest.o	20	obj-$(CONFIG_USB_TEST) += usbtest.o
22	obj-$(CONFIG_USB_EHSET_TEST_FIXTURE) += ehset.o	21	obj-$(CONFIG_USB_EHSET_TEST_FIXTURE) += ehset.o
23	obj-$(CONFIG_USB_TRANCEVIBRATOR) += trancevibrator.o	22	obj-$(CONFIG_USB_TRANCEVIBRATOR) += trancevibrator.o

drivers/usb/misc/adutux.c+15−9

@@ -75,6 +75,7 @@ struct adu_device { · 74 unmodified lines
75	char serial_number[8];	75	char serial_number[8];
76		76
77	int open_count; /* number of times this port has been opened */	77	int open_count; /* number of times this port has been opened */
		78	unsigned long disconnected:1;
78		79
79	char *read_buffer_primary;	80	char *read_buffer_primary;
80	int read_buffer_length;	81	int read_buffer_length;
@@ -116,7 +117,7 @@ static void adu_abort_transfers(struct adu_device *dev) · 35 unmodified lines
116	{	117	{
117	unsigned long flags;	118	unsigned long flags;
118		119
119	if (dev->udev == NULL)	120	if (dev->disconnected)
120	return;	121	return;
121		122
122	/* shutdown transfer */	123	/* shutdown transfer */
@@ -148,6 +149,7 @@ static void adu_delete(struct adu_device *dev) · 25 unmodified lines
148	kfree(dev->read_buffer_secondary);	149	kfree(dev->read_buffer_secondary);
149	kfree(dev->interrupt_in_buffer);	150	kfree(dev->interrupt_in_buffer);
150	kfree(dev->interrupt_out_buffer);	151	kfree(dev->interrupt_out_buffer);
		152	usb_put_dev(dev->udev);
151	kfree(dev);	153	kfree(dev);
152	}	154	}
153		155
@@ -243,7 +245,7 @@ static int adu_open(struct inode inode, struct file file) · 89 unmodified lines
243	}	245	}
244		246
245	dev = usb_get_intfdata(interface);	247	dev = usb_get_intfdata(interface);
246	if (!dev \|\| !dev->udev) {	248	if (!dev) {
247	retval = -ENODEV;	249	retval = -ENODEV;
248	goto exit_no_device;	250	goto exit_no_device;
249	}	251	}
@@ -326,7 +328,7 @@ static int adu_release(struct inode inode, struct file file) · 76 unmodified lines
326	}	328	}
327		329
328	adu_release_internal(dev);	330	adu_release_internal(dev);
329	if (dev->udev == NULL) {	331	if (dev->disconnected) {
330	/* the device was unplugged before the file was released */	332	/* the device was unplugged before the file was released */
331	if (!dev->open_count) /* ... and we're the last user */	333	if (!dev->open_count) /* ... and we're the last user */
332	adu_delete(dev);	334	adu_delete(dev);
@@ -354,7 +356,7 @@ static ssize_t adu_read(struct file file, __user char buffer, size_t count, · 21 unmodified lines
354	return -ERESTARTSYS;	356	return -ERESTARTSYS;
355		357
356	/* verify that the device wasn't unplugged */	358	/* verify that the device wasn't unplugged */
357	if (dev->udev == NULL) {	359	if (dev->disconnected) {
358	retval = -ENODEV;	360	retval = -ENODEV;
359	pr_err("No device or device unplugged %d\n", retval);	361	pr_err("No device or device unplugged %d\n", retval);
360	goto exit;	362	goto exit;
@@ -518,7 +520,7 @@ static ssize_t adu_write(struct file file, const __user char buffer, · 157 unmodified lines
518	goto exit_nolock;	520	goto exit_nolock;
519		521
520	/* verify that the device wasn't unplugged */	522	/* verify that the device wasn't unplugged */
521	if (dev->udev == NULL) {	523	if (dev->disconnected) {
522	retval = -ENODEV;	524	retval = -ENODEV;
523	pr_err("No device or device unplugged %d\n", retval);	525	pr_err("No device or device unplugged %d\n", retval);
524	goto exit;	526	goto exit;
@@ -663,7 +665,7 @@ static int adu_probe(struct usb_interface *interface, · 138 unmodified lines
663		665
664	mutex_init(&dev->mtx);	666	mutex_init(&dev->mtx);
665	spin_lock_init(&dev->buflock);	667	spin_lock_init(&dev->buflock);
666	dev->udev = udev;	668	dev->udev = usb_get_dev(udev);
667	init_waitqueue_head(&dev->read_wait);	669	init_waitqueue_head(&dev->read_wait);
668	init_waitqueue_head(&dev->write_wait);	670	init_waitqueue_head(&dev->write_wait);
669		671
@@ -762,14 +764,18 @@ static void adu_disconnect(struct usb_interface *interface) · 92 unmodified lines
762		764
763	dev = usb_get_intfdata(interface);	765	dev = usb_get_intfdata(interface);
764		766
765	mutex_lock(&dev->mtx); /* not interruptible */
766	dev->udev = NULL; /* poison */
767	usb_deregister_dev(interface, &adu_class);	767	usb_deregister_dev(interface, &adu_class);
768	mutex_unlock(&dev->mtx);	768
		769	usb_poison_urb(dev->interrupt_in_urb);
		770	usb_poison_urb(dev->interrupt_out_urb);
769		771
770	mutex_lock(&adutux_mutex);	772	mutex_lock(&adutux_mutex);
771	usb_set_intfdata(interface, NULL);	773	usb_set_intfdata(interface, NULL);
772		774
		775	mutex_lock(&dev->mtx); /* not interruptible */
		776	dev->disconnected = 1;
		777	mutex_unlock(&dev->mtx);
		778
773	/* if the device is not opened, then we clean up right now */	779	/* if the device is not opened, then we clean up right now */
774	if (!dev->open_count)	780	if (!dev->open_count)
775	adu_delete(dev);	781	adu_delete(dev);

drivers/usb/misc/chaoskey.c+3−2

 		usb_free_urb(dev->urb);
 		kfree(dev->name);
 		kfree(dev->buf);
+		usb_put_intf(dev->interface);
 		kfree(dev);
 	}
 }
 	if (dev == NULL)
 		goto out;
+	dev->interface = usb_get_intf(interface);
 	dev->buf = kmalloc(size, GFP_KERNEL);
 	if (dev->buf == NULL)
 			goto out;
 	}
-	dev->interface = interface;
 	dev->in_ep = in_ep;
 	if (le16_to_cpu(udev->descriptor.idVendor) != ALEA_VENDOR_ID)

drivers/usb/misc/iowarrior.c+15−33

@@ -54,11 +54,7 @@ MODULE_AUTHOR(DRIVER_AUTHOR); · 53 unmodified lines
54	MODULE_DESCRIPTION(DRIVER_DESC);	54	MODULE_DESCRIPTION(DRIVER_DESC);
55	MODULE_LICENSE("GPL");	55	MODULE_LICENSE("GPL");
56		56
57	/* Module parameters */
58	static DEFINE_MUTEX(iowarrior_mutex);
59
60	static struct usb_driver iowarrior_driver;	57	static struct usb_driver iowarrior_driver;
61	static DEFINE_MUTEX(iowarrior_open_disc_lock);
62		58
63	/--------------/	59	/--------------/
64	/* data */	60	/* data */
@@ -87,6 +83,7 @@ struct iowarrior { · 22 unmodified lines
87	char chip_serial[9]; /* the serial number string of the chip connected */	83	char chip_serial[9]; /* the serial number string of the chip connected */
88	int report_size; /* number of bytes in a report */	84	int report_size; /* number of bytes in a report */
89	u16 product_id;	85	u16 product_id;
		86	struct usb_anchor submitted;
90	};	87	};
91		88
92	/--------------/	89	/--------------/
@@ -243,6 +240,7 @@ static inline void iowarrior_delete(struct iowarrior *dev) · 150 unmodified lines
243	kfree(dev->int_in_buffer);	240	kfree(dev->int_in_buffer);
244	usb_free_urb(dev->int_in_urb);	241	usb_free_urb(dev->int_in_urb);
245	kfree(dev->read_queue);	242	kfree(dev->read_queue);
		243	usb_put_intf(dev->interface);
246	kfree(dev);	244	kfree(dev);
247	}	245	}
248		246
@@ -424,11 +422,13 @@ static ssize_t iowarrior_write(struct file *file, · 175 unmodified lines
424	retval = -EFAULT;	422	retval = -EFAULT;
425	goto error;	423	goto error;
426	}	424	}
		425	usb_anchor_urb(int_out_urb, &dev->submitted);
427	retval = usb_submit_urb(int_out_urb, GFP_KERNEL);	426	retval = usb_submit_urb(int_out_urb, GFP_KERNEL);
428	if (retval) {	427	if (retval) {
429	dev_dbg(&dev->interface->dev,	428	dev_dbg(&dev->interface->dev,
430	"submit error %d for urb nr.%d\n",	429	"submit error %d for urb nr.%d\n",
431	retval, atomic_read(&dev->write_busy));	430	retval, atomic_read(&dev->write_busy));
		431	usb_unanchor_urb(int_out_urb);
432	goto error;	432	goto error;
433	}	433	}
434	/* submit was ok */	434	/* submit was ok */
@@ -477,8 +477,6 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd, · 42 unmodified lines
477	if (!buffer)	477	if (!buffer)
478	return -ENOMEM;	478	return -ENOMEM;
479		479
480	/* lock this object */
481	mutex_lock(&iowarrior_mutex);
482	mutex_lock(&dev->mutex);	480	mutex_lock(&dev->mutex);
483		481
484	/* verify that the device wasn't unplugged */	482	/* verify that the device wasn't unplugged */
@@ -571,7 +569,6 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd, · 86 unmodified lines
571	error_out:	569	error_out:
572	/* unlock the device */	570	/* unlock the device */
573	mutex_unlock(&dev->mutex);	571	mutex_unlock(&dev->mutex);
574	mutex_unlock(&iowarrior_mutex);
575	kfree(buffer);	572	kfree(buffer);
576	return retval;	573	return retval;
577	}	574	}
@@ -586,27 +583,20 @@ static int iowarrior_open(struct inode inode, struct file file) · 8 unmodified lines
586	int subminor;	583	int subminor;
587	int retval = 0;	584	int retval = 0;
588		585
589	mutex_lock(&iowarrior_mutex);
590	subminor = iminor(inode);	586	subminor = iminor(inode);
591		587
592	interface = usb_find_interface(&iowarrior_driver, subminor);	588	interface = usb_find_interface(&iowarrior_driver, subminor);
593	if (!interface) {	589	if (!interface) {
594	mutex_unlock(&iowarrior_mutex);	590	pr_err("%s - error, can't find device for minor %d\n",
595	printk(KERN_ERR "%s - error, can't find device for minor %d\n",
596	__func__, subminor);	591	__func__, subminor);
597	return -ENODEV;	592	return -ENODEV;
598	}	593	}
599		594
600	mutex_lock(&iowarrior_open_disc_lock);
601	dev = usb_get_intfdata(interface);	595	dev = usb_get_intfdata(interface);
602	if (!dev) {	596	if (!dev)
603	mutex_unlock(&iowarrior_open_disc_lock);
604	mutex_unlock(&iowarrior_mutex);
605	return -ENODEV;	597	return -ENODEV;
606	}
607		598
608	mutex_lock(&dev->mutex);	599	mutex_lock(&dev->mutex);
609	mutex_unlock(&iowarrior_open_disc_lock);
610		600
611	/* Only one process can open each device, no sharing. */	601	/* Only one process can open each device, no sharing. */
612	if (dev->opened) {	602	if (dev->opened) {
@@ -628,7 +618,6 @@ static int iowarrior_open(struct inode inode, struct file file) · 15 unmodified lines
628		618
629	out:	619	out:
630	mutex_unlock(&dev->mutex);	620	mutex_unlock(&dev->mutex);
631	mutex_unlock(&iowarrior_mutex);
632	return retval;	621	return retval;
633	}	622	}
634		623
@@ -764,11 +753,13 @@ static int iowarrior_probe(struct usb_interface *interface, · 129 unmodified lines
764	init_waitqueue_head(&dev->write_wait);	753	init_waitqueue_head(&dev->write_wait);
765		754
766	dev->udev = udev;	755	dev->udev = udev;
767	dev->interface = interface;	756	dev->interface = usb_get_intf(interface);
768		757
769	iface_desc = interface->cur_altsetting;	758	iface_desc = interface->cur_altsetting;
770	dev->product_id = le16_to_cpu(udev->descriptor.idProduct);	759	dev->product_id = le16_to_cpu(udev->descriptor.idProduct);
771		760
		761	init_usb_anchor(&dev->submitted);
		762
772	res = usb_find_last_int_in_endpoint(iface_desc, &dev->int_in_endpoint);	763	res = usb_find_last_int_in_endpoint(iface_desc, &dev->int_in_endpoint);
773	if (res) {	764	if (res) {
774	dev_err(&interface->dev, "no interrupt-in endpoint found\n");	765	dev_err(&interface->dev, "no interrupt-in endpoint found\n");
@@ -836,7 +827,6 @@ static int iowarrior_probe(struct usb_interface *interface, · 61 unmodified lines
836	if (retval) {	827	if (retval) {
837	/* something prevented us from registering this driver */	828	/* something prevented us from registering this driver */
838	dev_err(&interface->dev, "Not able to get a minor for this device.\n");	829	dev_err(&interface->dev, "Not able to get a minor for this device.\n");
839	usb_set_intfdata(interface, NULL);
840	goto error;	830	goto error;
841	}	831	}
842		832
@@ -860,26 +850,15 @@ error: · 17 unmodified lines
860	*/	850	*/
861	static void iowarrior_disconnect(struct usb_interface *interface)	851	static void iowarrior_disconnect(struct usb_interface *interface)
862	{	852	{
863	struct iowarrior *dev;	853	struct iowarrior *dev = usb_get_intfdata(interface);
864	int minor;	854	int minor = dev->minor;
865
866	dev = usb_get_intfdata(interface);
867	mutex_lock(&iowarrior_open_disc_lock);
868	usb_set_intfdata(interface, NULL);
869	/* prevent device read, write and ioctl */
870	dev->present = 0;
871
872	minor = dev->minor;
873	mutex_unlock(&iowarrior_open_disc_lock);
874	/* give back our minor - this will call close() locks need to be dropped at this point*/
875		855
876	usb_deregister_dev(interface, &iowarrior_class);	856	usb_deregister_dev(interface, &iowarrior_class);
877		857
878	mutex_lock(&dev->mutex);	858	mutex_lock(&dev->mutex);
879		859
880	/* prevent device read, write and ioctl */	860	/* prevent device read, write and ioctl */
881		861	dev->present = 0;
882	mutex_unlock(&dev->mutex);
883		862
884	if (dev->opened) {	863	if (dev->opened) {
885	/* There is a process that holds a filedescriptor to the device ,	864	/* There is a process that holds a filedescriptor to the device ,
@@ -887,10 +866,13 @@ static void iowarrior_disconnect(struct usb_interface *interface) · 1 unmodified line
887	Deleting the device is postponed until close() was called.	866	Deleting the device is postponed until close() was called.
888	*/	867	*/
889	usb_kill_urb(dev->int_in_urb);	868	usb_kill_urb(dev->int_in_urb);
		869	usb_kill_anchored_urbs(&dev->submitted);
890	wake_up_interruptible(&dev->read_wait);	870	wake_up_interruptible(&dev->read_wait);
891	wake_up_interruptible(&dev->write_wait);	871	wake_up_interruptible(&dev->write_wait);
		872	mutex_unlock(&dev->mutex);
892	} else {	873	} else {
893	/* no process is using the device, cleanup now */	874	/* no process is using the device, cleanup now */
		875	mutex_unlock(&dev->mutex);
894	iowarrior_delete(dev);	876	iowarrior_delete(dev);
895	}	877	}
896		878

drivers/usb/misc/ldusb.c+12−12

 struct ld_usb {
 	struct mutex		mutex;		/* locks this structure */
 	struct usb_interface	*intf;		/* save off the usb interface pointer */
+	unsigned long		disconnected:1;
 	int			open_count;	/* number of times this port has been opened */
 	/* shutdown transfer */
 	if (dev->interrupt_in_running) {
 		dev->interrupt_in_running = 0;
-		if (dev->intf)
+		usb_kill_urb(dev->interrupt_in_urb);
-			usb_kill_urb(dev->interrupt_in_urb);
 	}
 	if (dev->interrupt_out_busy)
-		if (dev->intf)
+		usb_kill_urb(dev->interrupt_out_urb);
-			usb_kill_urb(dev->interrupt_out_urb);
 }
 /**
  */
 static void ld_usb_delete(struct ld_usb *dev)
 {
-	ld_usb_abort_transfers(dev);
 	/* free data structures */
 	usb_free_urb(dev->interrupt_in_urb);
 	usb_free_urb(dev->interrupt_out_urb);
 resubmit:
 	/* resubmit if we're still running */
-	if (dev->interrupt_in_running && !dev->buffer_overflow && dev->intf) {
+	if (dev->interrupt_in_running && !dev->buffer_overflow) {
 		retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
 		if (retval) {
 			dev_err(&dev->intf->dev,
 		retval = -ENODEV;
 		goto unlock_exit;
 	}
-	if (dev->intf == NULL) {
+	if (dev->disconnected) {
 		/* the device was unplugged before the file was released */
 		mutex_unlock(&dev->mutex);
 		/* unlock here as ld_usb_delete frees dev */
 	dev = file->private_data;
-	if (!dev->intf)
+	if (dev->disconnected)
 		return EPOLLERR | EPOLLHUP;
 	poll_wait(file, &dev->read_wait, wait);
 	}
 	/* verify that the device wasn't unplugged */
-	if (dev->intf == NULL) {
+	if (dev->disconnected) {
 		retval = -ENODEV;
 		printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
 		goto unlock_exit;
 	}
 	/* verify that the device wasn't unplugged */
-	if (dev->intf == NULL) {
+	if (dev->disconnected) {
 		retval = -ENODEV;
 		printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
 		goto unlock_exit;
 	/* give back our minor */
 	usb_deregister_dev(intf, &ld_usb_class);
+	usb_poison_urb(dev->interrupt_in_urb);
+	usb_poison_urb(dev->interrupt_out_urb);
 	mutex_lock(&dev->mutex);
 	/* if the device is not opened, then we clean up right now */
 		mutex_unlock(&dev->mutex);
 		ld_usb_delete(dev);
 	} else {
-		dev->intf = NULL;
+		dev->disconnected = 1;
 		/* wake up pollers */
 		wake_up_interruptible_all(&dev->read_wait);
 		wake_up_interruptible_all(&dev->write_wait);

drivers/usb/misc/legousbtower.c+25−33

@@ -179,7 +179,6 @@ static const struct usb_device_id tower_table[] = { · 178 unmodified lines
179	};	179	};
180		180
181	MODULE_DEVICE_TABLE (usb, tower_table);	181	MODULE_DEVICE_TABLE (usb, tower_table);
182	static DEFINE_MUTEX(open_disc_mutex);
183		182
184	#define LEGO_USB_TOWER_MINOR_BASE 160	183	#define LEGO_USB_TOWER_MINOR_BASE 160
185		184
@@ -191,6 +190,7 @@ struct lego_usb_tower { · 5 unmodified lines
191	unsigned char minor; /* the starting minor number for this device */	190	unsigned char minor; /* the starting minor number for this device */
192		191
193	int open_count; /* number of times this port has been opened */	192	int open_count; /* number of times this port has been opened */
		193	unsigned long disconnected:1;
194		194
195	char* read_buffer;	195	char* read_buffer;
196	size_t read_buffer_length; /* this much came in */	196	size_t read_buffer_length; /* this much came in */
@@ -290,14 +290,13 @@ static inline void lego_usb_tower_debug_data(struct device *dev, · 93 unmodified lines
290	*/	290	*/
291	static inline void tower_delete (struct lego_usb_tower *dev)	291	static inline void tower_delete (struct lego_usb_tower *dev)
292	{	292	{
293	tower_abort_transfers (dev);
294
295	/* free data structures */	293	/* free data structures */
296	usb_free_urb(dev->interrupt_in_urb);	294	usb_free_urb(dev->interrupt_in_urb);
297	usb_free_urb(dev->interrupt_out_urb);	295	usb_free_urb(dev->interrupt_out_urb);
298	kfree (dev->read_buffer);	296	kfree (dev->read_buffer);
299	kfree (dev->interrupt_in_buffer);	297	kfree (dev->interrupt_in_buffer);
300	kfree (dev->interrupt_out_buffer);	298	kfree (dev->interrupt_out_buffer);
		299	usb_put_dev(dev->udev);
301	kfree (dev);	300	kfree (dev);
302	}	301	}
303		302
@@ -332,18 +331,14 @@ static int tower_open (struct inode inode, struct file file) · 28 unmodified lines
332	goto exit;	331	goto exit;
333	}	332	}
334		333
335	mutex_lock(&open_disc_mutex);
336	dev = usb_get_intfdata(interface);	334	dev = usb_get_intfdata(interface);
337
338	if (!dev) {	335	if (!dev) {
339	mutex_unlock(&open_disc_mutex);
340	retval = -ENODEV;	336	retval = -ENODEV;
341	goto exit;	337	goto exit;
342	}	338	}
343		339
344	/* lock this device */	340	/* lock this device */
345	if (mutex_lock_interruptible(&dev->lock)) {	341	if (mutex_lock_interruptible(&dev->lock)) {
346	mutex_unlock(&open_disc_mutex);
347	retval = -ERESTARTSYS;	342	retval = -ERESTARTSYS;
348	goto exit;	343	goto exit;
349	}	344	}
@@ -351,12 +346,9 @@ static int tower_open (struct inode inode, struct file file) · 1 unmodified line
351		346
352	/* allow opening only once */	347	/* allow opening only once */
353	if (dev->open_count) {	348	if (dev->open_count) {
354	mutex_unlock(&open_disc_mutex);
355	retval = -EBUSY;	349	retval = -EBUSY;
356	goto unlock_exit;	350	goto unlock_exit;
357	}	351	}
358	dev->open_count = 1;
359	mutex_unlock(&open_disc_mutex);
360		352
361	/* reset the tower */	353	/* reset the tower */
362	result = usb_control_msg (dev->udev,	354	result = usb_control_msg (dev->udev,
@@ -396,13 +388,14 @@ static int tower_open (struct inode inode, struct file file) · 33 unmodified lines
396	dev_err(&dev->udev->dev,	388	dev_err(&dev->udev->dev,
397	"Couldn't submit interrupt_in_urb %d\n", retval);	389	"Couldn't submit interrupt_in_urb %d\n", retval);
398	dev->interrupt_in_running = 0;	390	dev->interrupt_in_running = 0;
399	dev->open_count = 0;
400	goto unlock_exit;	391	goto unlock_exit;
401	}	392	}
402		393
403	/* save device in the file's private structure */	394	/* save device in the file's private structure */
404	file->private_data = dev;	395	file->private_data = dev;
405		396
		397	dev->open_count = 1;
		398
406	unlock_exit:	399	unlock_exit:
407	mutex_unlock(&dev->lock);	400	mutex_unlock(&dev->lock);
408		401
@@ -423,10 +416,9 @@ static int tower_release (struct inode inode, struct file file) · 14 unmodified lines
423		416
424	if (dev == NULL) {	417	if (dev == NULL) {
425	retval = -ENODEV;	418	retval = -ENODEV;
426	goto exit_nolock;	419	goto exit;
427	}	420	}
428		421
429	mutex_lock(&open_disc_mutex);
430	if (mutex_lock_interruptible(&dev->lock)) {	422	if (mutex_lock_interruptible(&dev->lock)) {
431	retval = -ERESTARTSYS;	423	retval = -ERESTARTSYS;
432	goto exit;	424	goto exit;
@@ -438,7 +430,8 @@ static int tower_release (struct inode inode, struct file file) · 5 unmodified lines
438	retval = -ENODEV;	430	retval = -ENODEV;
439	goto unlock_exit;	431	goto unlock_exit;
440	}	432	}
441	if (dev->udev == NULL) {	433
		434	if (dev->disconnected) {
442	/* the device was unplugged before the file was released */	435	/* the device was unplugged before the file was released */
443		436
444	/* unlock here as tower_delete frees dev */	437	/* unlock here as tower_delete frees dev */
@@ -456,10 +449,7 @@ static int tower_release (struct inode inode, struct file file) · 11 unmodified lines
456		449
457	unlock_exit:	450	unlock_exit:
458	mutex_unlock(&dev->lock);	451	mutex_unlock(&dev->lock);
459
460	exit:	452	exit:
461	mutex_unlock(&open_disc_mutex);
462	exit_nolock:
463	return retval;	453	return retval;
464	}	454	}
465		455
@@ -477,10 +467,9 @@ static void tower_abort_transfers (struct lego_usb_tower *dev) · 11 unmodified lines
477	if (dev->interrupt_in_running) {	467	if (dev->interrupt_in_running) {
478	dev->interrupt_in_running = 0;	468	dev->interrupt_in_running = 0;
479	mb();	469	mb();
480	if (dev->udev)	470	usb_kill_urb(dev->interrupt_in_urb);
481	usb_kill_urb (dev->interrupt_in_urb);
482	}	471	}
483	if (dev->interrupt_out_busy && dev->udev)	472	if (dev->interrupt_out_busy)
484	usb_kill_urb(dev->interrupt_out_urb);	473	usb_kill_urb(dev->interrupt_out_urb);
485	}	474	}
486		475
@@ -516,7 +505,7 @@ static __poll_t tower_poll (struct file file, poll_table wait) · 29 unmodified lines
516		505
517	dev = file->private_data;	506	dev = file->private_data;
518		507
519	if (!dev->udev)	508	if (dev->disconnected)
520	return EPOLLERR \| EPOLLHUP;	509	return EPOLLERR \| EPOLLHUP;
521		510
522	poll_wait(file, &dev->read_wait, wait);	511	poll_wait(file, &dev->read_wait, wait);
@@ -563,7 +552,7 @@ static ssize_t tower_read (struct file file, char __user buffer, size_t count, · 40 unmodified lines
563	}	552	}
564		553
565	/* verify that the device wasn't unplugged */	554	/* verify that the device wasn't unplugged */
566	if (dev->udev == NULL) {	555	if (dev->disconnected) {
567	retval = -ENODEV;	556	retval = -ENODEV;
568	pr_err("No device or device unplugged %d\n", retval);	557	pr_err("No device or device unplugged %d\n", retval);
569	goto unlock_exit;	558	goto unlock_exit;
@@ -649,7 +638,7 @@ static ssize_t tower_write (struct file file, const char __user buffer, size_t · 79 unmodified lines
649	}	638	}
650		639
651	/* verify that the device wasn't unplugged */	640	/* verify that the device wasn't unplugged */
652	if (dev->udev == NULL) {	641	if (dev->disconnected) {
653	retval = -ENODEV;	642	retval = -ENODEV;
654	pr_err("No device or device unplugged %d\n", retval);	643	pr_err("No device or device unplugged %d\n", retval);
655	goto unlock_exit;	644	goto unlock_exit;
@@ -759,7 +748,7 @@ static void tower_interrupt_in_callback (struct urb *urb) · 103 unmodified lines
759		748
760	resubmit:	749	resubmit:
761	/* resubmit if we're still running */	750	/* resubmit if we're still running */
762	if (dev->interrupt_in_running && dev->udev) {	751	if (dev->interrupt_in_running) {
763	retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);	752	retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
764	if (retval)	753	if (retval)
765	dev_err(&dev->udev->dev,	754	dev_err(&dev->udev->dev,
@@ -822,8 +811,9 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device · 56 unmodified lines
822		811
823	mutex_init(&dev->lock);	812	mutex_init(&dev->lock);
824		813
825	dev->udev = udev;	814	dev->udev = usb_get_dev(udev);
826	dev->open_count = 0;	815	dev->open_count = 0;
		816	dev->disconnected = 0;
827		817
828	dev->read_buffer = NULL;	818	dev->read_buffer = NULL;
829	dev->read_buffer_length = 0;	819	dev->read_buffer_length = 0;
@@ -891,8 +881,10 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device · 61 unmodified lines
891	get_version_reply,	881	get_version_reply,
892	sizeof(*get_version_reply),	882	sizeof(*get_version_reply),
893	1000);	883	1000);
894	if (result < 0) {	884	if (result < sizeof(*get_version_reply)) {
895	dev_err(idev, "LEGO USB Tower get version control request failed\n");	885	if (result >= 0)
		886	result = -EIO;
		887	dev_err(idev, "get version request failed: %d\n", result);
896	retval = result;	888	retval = result;
897	goto error;	889	goto error;
898	}	890	}
@@ -910,7 +902,6 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device · 11 unmodified lines
910	if (retval) {	902	if (retval) {
911	/* something prevented us from registering this driver */	903	/* something prevented us from registering this driver */
912	dev_err(idev, "Not able to get a minor for this device.\n");	904	dev_err(idev, "Not able to get a minor for this device.\n");
913	usb_set_intfdata (interface, NULL);
914	goto error;	905	goto error;
915	}	906	}
916	dev->minor = interface->minor;	907	dev->minor = interface->minor;
@@ -942,23 +933,24 @@ static void tower_disconnect (struct usb_interface *interface) · 25 unmodified lines
942	int minor;	933	int minor;
943		934
944	dev = usb_get_intfdata (interface);	935	dev = usb_get_intfdata (interface);
945	mutex_lock(&open_disc_mutex);
946	usb_set_intfdata (interface, NULL);
947		936
948	minor = dev->minor;	937	minor = dev->minor;
949		938
950	/* give back our minor */	939	/* give back our minor and prevent further open() */
951	usb_deregister_dev (interface, &tower_class);	940	usb_deregister_dev (interface, &tower_class);
952		941
		942	/* stop I/O */
		943	usb_poison_urb(dev->interrupt_in_urb);
		944	usb_poison_urb(dev->interrupt_out_urb);
		945
953	mutex_lock(&dev->lock);	946	mutex_lock(&dev->lock);
954	mutex_unlock(&open_disc_mutex);
955		947
956	/* if the device is not opened, then we clean up right now */	948	/* if the device is not opened, then we clean up right now */
957	if (!dev->open_count) {	949	if (!dev->open_count) {
958	mutex_unlock(&dev->lock);	950	mutex_unlock(&dev->lock);
959	tower_delete (dev);	951	tower_delete (dev);
960	} else {	952	} else {
961	dev->udev = NULL;	953	dev->disconnected = 1;
962	/* wake up pollers */	954	/* wake up pollers */
963	wake_up_interruptible_all(&dev->read_wait);	955	wake_up_interruptible_all(&dev->read_wait);
964	wake_up_interruptible_all(&dev->write_wait);	956	wake_up_interruptible_all(&dev->write_wait);

drivers/usb/misc/rio500.c+0−554

@@ -1,554 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	/* -- linux-c -- */
3
4	/*
5	* Driver for USB Rio 500
6	*
7	* Cesar Miquel (miquel@df.uba.ar)
8	*
9	* based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
10	*
11	* Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
12	*
13	* Changelog:
14	* 30/05/2003 replaced lock/unlock kernel with up/down
15	* Daniele Bellucci bellucda@tiscali.it
16	* */
17
18	#include <linux/module.h>
19	#include <linux/kernel.h>
20	#include <linux/signal.h>
21	#include <linux/sched/signal.h>
22	#include <linux/mutex.h>
23	#include <linux/errno.h>
24	#include <linux/random.h>
25	#include <linux/poll.h>
26	#include <linux/slab.h>
27	#include <linux/spinlock.h>
28	#include <linux/usb.h>
29	#include <linux/wait.h>
30
31	#include "rio500_usb.h"
32
33	#define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
34	#define DRIVER_DESC "USB Rio 500 driver"
35
36	#define RIO_MINOR 64
37
38	/* stall/wait timeout for rio */
39	#define NAK_TIMEOUT (HZ)
40
41	#define IBUF_SIZE 0x1000
42
43	/* Size of the rio buffer */
44	#define OBUF_SIZE 0x10000
45
46	struct rio_usb_data {
47	struct usb_device rio_dev; / init: probe_rio */
48	unsigned int ifnum; /* Interface number of the USB device */
49	int isopen; /* nz if open */
50	int present; /* Device is present on the bus */
51	char obuf, ibuf; /* transfer buffers */
52	char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */
53	wait_queue_head_t wait_q; /* for timeouts */
54	};
55
56	static DEFINE_MUTEX(rio500_mutex);
57	static struct rio_usb_data rio_instance;
58
59	static int open_rio(struct inode inode, struct file file)
60	{
61	struct rio_usb_data *rio = &rio_instance;
62
63	/* against disconnect() */
64	mutex_lock(&rio500_mutex);
65
66	if (rio->isopen \|\| !rio->present) {
67	mutex_unlock(&rio500_mutex);
68	return -EBUSY;
69	}
70	rio->isopen = 1;
71
72	init_waitqueue_head(&rio->wait_q);
73
74
75	dev_info(&rio->rio_dev->dev, "Rio opened.\n");
76	mutex_unlock(&rio500_mutex);
77
78	return 0;
79	}
80
81	static int close_rio(struct inode inode, struct file file)
82	{
83	struct rio_usb_data *rio = &rio_instance;
84
85	/* against disconnect() */
86	mutex_lock(&rio500_mutex);
87
88	rio->isopen = 0;
89	if (!rio->present) {
90	/* cleanup has been delayed */
91	kfree(rio->ibuf);
92	kfree(rio->obuf);
93	rio->ibuf = NULL;
94	rio->obuf = NULL;
95	} else {
96	dev_info(&rio->rio_dev->dev, "Rio closed.\n");
97	}
98	mutex_unlock(&rio500_mutex);
99	return 0;
100	}
101
102	static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
103	{
104	struct RioCommand rio_cmd;
105	struct rio_usb_data *rio = &rio_instance;
106	void __user *data;
107	unsigned char *buffer;
108	int result, requesttype;
109	int retries;
110	int retval=0;
111
112	mutex_lock(&rio500_mutex);
113	/* Sanity check to make sure rio is connected, powered, etc */
114	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
115	retval = -ENODEV;
116	goto err_out;
117	}
118
119	switch (cmd) {
120	case RIO_RECV_COMMAND:
121	data = (void __user *) arg;
122	if (data == NULL)
123	break;
124	if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
125	retval = -EFAULT;
126	goto err_out;
127	}
128	if (rio_cmd.length < 0 \|\| rio_cmd.length > PAGE_SIZE) {
129	retval = -EINVAL;
130	goto err_out;
131	}
132	buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
133	if (buffer == NULL) {
134	retval = -ENOMEM;
135	goto err_out;
136	}
137	if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
138	retval = -EFAULT;
139	free_page((unsigned long) buffer);
140	goto err_out;
141	}
142
143	requesttype = rio_cmd.requesttype \| USB_DIR_IN \|
144	USB_TYPE_VENDOR \| USB_RECIP_DEVICE;
145	dev_dbg(&rio->rio_dev->dev,
146	"sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
147	requesttype, rio_cmd.request, rio_cmd.value,
148	rio_cmd.index, rio_cmd.length);
149	/* Send rio control message */
150	retries = 3;
151	while (retries) {
152	result = usb_control_msg(rio->rio_dev,
153	usb_rcvctrlpipe(rio-> rio_dev, 0),
154	rio_cmd.request,
155	requesttype,
156	rio_cmd.value,
157	rio_cmd.index, buffer,
158	rio_cmd.length,
159	jiffies_to_msecs(rio_cmd.timeout));
160	if (result == -ETIMEDOUT)
161	retries--;
162	else if (result < 0) {
163	dev_err(&rio->rio_dev->dev,
164	"Error executing ioctrl. code = %d\n",
165	result);
166	retries = 0;
167	} else {
168	dev_dbg(&rio->rio_dev->dev,
169	"Executed ioctl. Result = %d (data=%02x)\n",
170	result, buffer[0]);
171	if (copy_to_user(rio_cmd.buffer, buffer,
172	rio_cmd.length)) {
173	free_page((unsigned long) buffer);
174	retval = -EFAULT;
175	goto err_out;
176	}
177	retries = 0;
178	}
179
180	/* rio_cmd.buffer contains a raw stream of single byte
181	data which has been returned from rio. Data is
182	interpreted at application level. For data that
183	will be cast to data types longer than 1 byte, data
184	will be little_endian and will potentially need to
185	be swapped at the app level */
186
187	}
188	free_page((unsigned long) buffer);
189	break;
190
191	case RIO_SEND_COMMAND:
192	data = (void __user *) arg;
193	if (data == NULL)
194	break;
195	if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
196	retval = -EFAULT;
197	goto err_out;
198	}
199	if (rio_cmd.length < 0 \|\| rio_cmd.length > PAGE_SIZE) {
200	retval = -EINVAL;
201	goto err_out;
202	}
203	buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
204	if (buffer == NULL) {
205	retval = -ENOMEM;
206	goto err_out;
207	}
208	if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
209	free_page((unsigned long)buffer);
210	retval = -EFAULT;
211	goto err_out;
212	}
213
214	requesttype = rio_cmd.requesttype \| USB_DIR_OUT \|
215	USB_TYPE_VENDOR \| USB_RECIP_DEVICE;
216	dev_dbg(&rio->rio_dev->dev,
217	"sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
218	requesttype, rio_cmd.request, rio_cmd.value,
219	rio_cmd.index, rio_cmd.length);
220	/* Send rio control message */
221	retries = 3;
222	while (retries) {
223	result = usb_control_msg(rio->rio_dev,
224	usb_sndctrlpipe(rio-> rio_dev, 0),
225	rio_cmd.request,
226	requesttype,
227	rio_cmd.value,
228	rio_cmd.index, buffer,
229	rio_cmd.length,
230	jiffies_to_msecs(rio_cmd.timeout));
231	if (result == -ETIMEDOUT)
232	retries--;
233	else if (result < 0) {
234	dev_err(&rio->rio_dev->dev,
235	"Error executing ioctrl. code = %d\n",
236	result);
237	retries = 0;
238	} else {
239	dev_dbg(&rio->rio_dev->dev,
240	"Executed ioctl. Result = %d\n", result);
241	retries = 0;
242
243	}
244
245	}
246	free_page((unsigned long) buffer);
247	break;
248
249	default:
250	retval = -ENOTTY;
251	break;
252	}
253
254
255	err_out:
256	mutex_unlock(&rio500_mutex);
257	return retval;
258	}
259
260	static ssize_t
261	write_rio(struct file file, const char __user buffer,
262	size_t count, loff_t * ppos)
263	{
264	DEFINE_WAIT(wait);
265	struct rio_usb_data *rio = &rio_instance;
266
267	unsigned long copy_size;
268	unsigned long bytes_written = 0;
269	unsigned int partial;
270
271	int result = 0;
272	int maxretry;
273	int errn = 0;
274	int intr;
275
276	intr = mutex_lock_interruptible(&rio500_mutex);
277	if (intr)
278	return -EINTR;
279	/* Sanity check to make sure rio is connected, powered, etc */
280	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
281	mutex_unlock(&rio500_mutex);
282	return -ENODEV;
283	}
284
285
286
287	do {
288	unsigned long thistime;
289	char *obuf = rio->obuf;
290
291	thistime = copy_size =
292	(count >= OBUF_SIZE) ? OBUF_SIZE : count;
293	if (copy_from_user(rio->obuf, buffer, copy_size)) {
294	errn = -EFAULT;
295	goto error;
296	}
297	maxretry = 5;
298	while (thistime) {
299	if (!rio->rio_dev) {
300	errn = -ENODEV;
301	goto error;
302	}
303	if (signal_pending(current)) {
304	mutex_unlock(&rio500_mutex);
305	return bytes_written ? bytes_written : -EINTR;
306	}
307
308	result = usb_bulk_msg(rio->rio_dev,
309	usb_sndbulkpipe(rio->rio_dev, 2),
310	obuf, thistime, &partial, 5000);
311
312	dev_dbg(&rio->rio_dev->dev,
313	"write stats: result:%d thistime:%lu partial:%u\n",
314	result, thistime, partial);
315
316	if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
317	if (!maxretry--) {
318	errn = -ETIME;
319	goto error;
320	}
321	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
322	schedule_timeout(NAK_TIMEOUT);
323	finish_wait(&rio->wait_q, &wait);
324	continue;
325	} else if (!result && partial) {
326	obuf += partial;
327	thistime -= partial;
328	} else
329	break;
330	}
331	if (result) {
332	dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
333	result);
334	errn = -EIO;
335	goto error;
336	}
337	bytes_written += copy_size;
338	count -= copy_size;
339	buffer += copy_size;
340	} while (count > 0);
341
342	mutex_unlock(&rio500_mutex);
343
344	return bytes_written ? bytes_written : -EIO;
345
346	error:
347	mutex_unlock(&rio500_mutex);
348	return errn;
349	}
350
351	static ssize_t
352	read_rio(struct file file, char __user buffer, size_t count, loff_t * ppos)
353	{
354	DEFINE_WAIT(wait);
355	struct rio_usb_data *rio = &rio_instance;
356	ssize_t read_count;
357	unsigned int partial;
358	int this_read;
359	int result;
360	int maxretry = 10;
361	char *ibuf;
362	int intr;
363
364	intr = mutex_lock_interruptible(&rio500_mutex);
365	if (intr)
366	return -EINTR;
367	/* Sanity check to make sure rio is connected, powered, etc */
368	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
369	mutex_unlock(&rio500_mutex);
370	return -ENODEV;
371	}
372
373	ibuf = rio->ibuf;
374
375	read_count = 0;
376
377
378	while (count > 0) {
379	if (signal_pending(current)) {
380	mutex_unlock(&rio500_mutex);
381	return read_count ? read_count : -EINTR;
382	}
383	if (!rio->rio_dev) {
384	mutex_unlock(&rio500_mutex);
385	return -ENODEV;
386	}
387	this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
388
389	result = usb_bulk_msg(rio->rio_dev,
390	usb_rcvbulkpipe(rio->rio_dev, 1),
391	ibuf, this_read, &partial,
392	8000);
393
394	dev_dbg(&rio->rio_dev->dev,
395	"read stats: result:%d this_read:%u partial:%u\n",
396	result, this_read, partial);
397
398	if (partial) {
399	count = this_read = partial;
400	} else if (result == -ETIMEDOUT \|\| result == 15) { /* FIXME: 15 ??? */
401	if (!maxretry--) {
402	mutex_unlock(&rio500_mutex);
403	dev_err(&rio->rio_dev->dev,
404	"read_rio: maxretry timeout\n");
405	return -ETIME;
406	}
407	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
408	schedule_timeout(NAK_TIMEOUT);
409	finish_wait(&rio->wait_q, &wait);
410	continue;
411	} else if (result != -EREMOTEIO) {
412	mutex_unlock(&rio500_mutex);
413	dev_err(&rio->rio_dev->dev,
414	"Read Whoops - result:%d partial:%u this_read:%u\n",
415	result, partial, this_read);
416	return -EIO;
417	} else {
418	mutex_unlock(&rio500_mutex);
419	return (0);
420	}
421
422	if (this_read) {
423	if (copy_to_user(buffer, ibuf, this_read)) {
424	mutex_unlock(&rio500_mutex);
425	return -EFAULT;
426	}
427	count -= this_read;
428	read_count += this_read;
429	buffer += this_read;
430	}
431	}
432	mutex_unlock(&rio500_mutex);
433	return read_count;
434	}
435
436	static const struct file_operations usb_rio_fops = {
437	.owner = THIS_MODULE,
438	.read = read_rio,
439	.write = write_rio,
440	.unlocked_ioctl = ioctl_rio,
441	.open = open_rio,
442	.release = close_rio,
443	.llseek = noop_llseek,
444	};
445
446	static struct usb_class_driver usb_rio_class = {
447	.name = "rio500%d",
448	.fops = &usb_rio_fops,
449	.minor_base = RIO_MINOR,
450	};
451
452	static int probe_rio(struct usb_interface *intf,
453	const struct usb_device_id *id)
454	{
455	struct usb_device *dev = interface_to_usbdev(intf);
456	struct rio_usb_data *rio = &rio_instance;
457	int retval = -ENOMEM;
458	char ibuf, obuf;
459
460	if (rio->present) {
461	dev_info(&intf->dev, "Second USB Rio at address %d refused\n", dev->devnum);
462	return -EBUSY;
463	}
464	dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
465
466	obuf = kmalloc(OBUF_SIZE, GFP_KERNEL);
467	if (!obuf) {
468	dev_err(&dev->dev,
469	"probe_rio: Not enough memory for the output buffer\n");
470	goto err_obuf;
471	}
472	dev_dbg(&intf->dev, "obuf address: %p\n", obuf);
473
474	ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL);
475	if (!ibuf) {
476	dev_err(&dev->dev,
477	"probe_rio: Not enough memory for the input buffer\n");
478	goto err_ibuf;
479	}
480	dev_dbg(&intf->dev, "ibuf address: %p\n", ibuf);
481
482	mutex_lock(&rio500_mutex);
483	rio->rio_dev = dev;
484	rio->ibuf = ibuf;
485	rio->obuf = obuf;
486	rio->present = 1;
487	mutex_unlock(&rio500_mutex);
488
489	retval = usb_register_dev(intf, &usb_rio_class);
490	if (retval) {
491	dev_err(&dev->dev,
492	"Not able to get a minor for this device.\n");
493	goto err_register;
494	}
495
496	usb_set_intfdata(intf, rio);
497	return retval;
498
499	err_register:
500	mutex_lock(&rio500_mutex);
501	rio->present = 0;
502	mutex_unlock(&rio500_mutex);
503	err_ibuf:
504	kfree(obuf);
505	err_obuf:
506	return retval;
507	}
508
509	static void disconnect_rio(struct usb_interface *intf)
510	{
511	struct rio_usb_data *rio = usb_get_intfdata (intf);
512
513	usb_set_intfdata (intf, NULL);
514	if (rio) {
515	usb_deregister_dev(intf, &usb_rio_class);
516
517	mutex_lock(&rio500_mutex);
518	if (rio->isopen) {
519	rio->isopen = 0;
520	/* better let it finish - the release will do whats needed */
521	rio->rio_dev = NULL;
522	mutex_unlock(&rio500_mutex);
523	return;
524	}
525	kfree(rio->ibuf);
526	kfree(rio->obuf);
527
528	dev_info(&intf->dev, "USB Rio disconnected.\n");
529
530	rio->present = 0;
531	mutex_unlock(&rio500_mutex);
532	}
533	}
534
535	static const struct usb_device_id rio_table[] = {
536	{ USB_DEVICE(0x0841, 1) }, /* Rio 500 */
537	{ } /* Terminating entry */
538	};
539
540	MODULE_DEVICE_TABLE (usb, rio_table);
541
542	static struct usb_driver rio_driver = {
543	.name = "rio500",
544	.probe = probe_rio,
545	.disconnect = disconnect_rio,
546	.id_table = rio_table,
547	};
548
549	module_usb_driver(rio_driver);
550
551	MODULE_AUTHOR( DRIVER_AUTHOR );
552	MODULE_DESCRIPTION( DRIVER_DESC );
553	MODULE_LICENSE("GPL");
554

drivers/usb/misc/rio500_usb.h+0−20

@@ -1,20 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	/* ----------------------------------------------------------------------
3	Copyright (C) 2000 Cesar Miquel (miquel@df.uba.ar)
4	---------------------------------------------------------------------- */
5
6	#define RIO_SEND_COMMAND 0x1
7	#define RIO_RECV_COMMAND 0x2
8
9	#define RIO_DIR_OUT 0x0
10	#define RIO_DIR_IN 0x1
11
12	struct RioCommand {
13	short length;
14	int request;
15	int requesttype;
16	int value;
17	int index;
18	void __user *buffer;
19	int timeout;
20	};

drivers/usb/misc/usblcd.c+33−27

 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/mutex.h>
+#include <linux/rwsem.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #define IOCTL_GET_DRV_VERSION	2
-static DEFINE_MUTEX(lcd_mutex);
 static const struct usb_device_id id_table[] = {
 	{ .idVendor = 0x10D2, .match_flags = USB_DEVICE_ID_MATCH_VENDOR, },
 	{ },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
-static DEFINE_MUTEX(open_disc_mutex);
 struct usb_lcd {
 	struct usb_device	*udev;			/* init: probe_lcd */
 	struct usb_interface	*interface;		/* the interface for
 							   using up all RAM */
 	struct usb_anchor	submitted;		/* URBs to wait for
 							   before suspend */
+	struct rw_semaphore	io_rwsem;
+	unsigned long		disconnected:1;
 };
 #define to_lcd_dev(d) container_of(d, struct usb_lcd, kref)
 	struct usb_interface *interface;
 	int subminor, r;
-	mutex_lock(&lcd_mutex);
 	subminor = iminor(inode);
 	interface = usb_find_interface(&lcd_driver, subminor);
 	if (!interface) {
-		mutex_unlock(&lcd_mutex);
+		pr_err("USBLCD: %s - error, can't find device for minor %d\n",
-		printk(KERN_ERR "USBLCD: %s - error, can't find device for minor %d\n",
 		       __func__, subminor);
 		return -ENODEV;
 	}
-	mutex_lock(&open_disc_mutex);
 	dev = usb_get_intfdata(interface);
-	if (!dev) {
-		mutex_unlock(&open_disc_mutex);
-		mutex_unlock(&lcd_mutex);
-		return -ENODEV;
-	}
 	/* increment our usage count for the device */
 	kref_get(&dev->kref);
-	mutex_unlock(&open_disc_mutex);
 	/* grab a power reference */
 	r = usb_autopm_get_interface(interface);
 	if (r < 0) {
 		kref_put(&dev->kref, lcd_delete);
-		mutex_unlock(&lcd_mutex);
 		return r;
 	}
 	/* save our object in the file's private structure */
 	file->private_data = dev;
-	mutex_unlock(&lcd_mutex);
 	return 0;
 }
 	dev = file->private_data;
+	down_read(&dev->io_rwsem);
+	if (dev->disconnected) {
+		retval = -ENODEV;
+		goto out_up_io;
+	}
 	/* do a blocking bulk read to get data from the device */
 	retval = usb_bulk_msg(dev->udev,
 			      usb_rcvbulkpipe(dev->udev,
 			retval = bytes_read;
 	}
+out_up_io:
+	up_read(&dev->io_rwsem);
 	return retval;
 }
 	switch (cmd) {
 	case IOCTL_GET_HARD_VERSION:
-		mutex_lock(&lcd_mutex);
 		bcdDevice = le16_to_cpu((dev->udev)->descriptor.bcdDevice);
 		sprintf(buf, "%1d%1d.%1d%1d",
 			(bcdDevice & 0xF000)>>12,
 			(bcdDevice & 0xF00)>>8,
 			(bcdDevice & 0xF0)>>4,
 			(bcdDevice & 0xF));
-		mutex_unlock(&lcd_mutex);
 		if (copy_to_user((void __user *)arg, buf, strlen(buf)) != 0)
 			return -EFAULT;
 		break;
 	if (r < 0)
 		return -EINTR;
+	down_read(&dev->io_rwsem);
+	if (dev->disconnected) {
+		retval = -ENODEV;
+		goto err_up_io;
+	}
 	/* create a urb, and a buffer for it, and copy the data to the urb */
 	urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!urb) {
 		retval = -ENOMEM;
-		goto err_no_buf;
+		goto err_up_io;
 	}
 	buf = usb_alloc_coherent(dev->udev, count, GFP_KERNEL,
 	   the USB core will eventually free it entirely */
 	usb_free_urb(urb);
+	up_read(&dev->io_rwsem);
 exit:
 	return count;
 error_unanchor:
 error:
 	usb_free_coherent(dev->udev, count, buf, urb->transfer_dma);
 	usb_free_urb(urb);
-err_no_buf:
+err_up_io:
+	up_read(&dev->io_rwsem);
 	up(&dev->limit_sem);
 	return retval;
 }
 	kref_init(&dev->kref);
 	sema_init(&dev->limit_sem, USB_LCD_CONCURRENT_WRITES);
+	init_rwsem(&dev->io_rwsem);
 	init_usb_anchor(&dev->submitted);
 	dev->udev = usb_get_dev(interface_to_usbdev(interface));
 		/* something prevented us from registering this driver */
 		dev_err(&interface->dev,
 			"Not able to get a minor for this device.\n");
-		usb_set_intfdata(interface, NULL);
 		goto error;
 	}
 static void lcd_disconnect(struct usb_interface *interface)
 {
-	struct usb_lcd *dev;
+	struct usb_lcd *dev = usb_get_intfdata(interface);
 	int minor = interface->minor;
-	mutex_lock(&open_disc_mutex);
-	dev = usb_get_intfdata(interface);
-	usb_set_intfdata(interface, NULL);
-	mutex_unlock(&open_disc_mutex);
 	/* give back our minor */
 	usb_deregister_dev(interface, &lcd_class);
+	down_write(&dev->io_rwsem);
+	dev->disconnected = 1;
+	up_write(&dev->io_rwsem);
+	usb_kill_anchored_urbs(&dev->submitted);
 	/* decrement our usage count */
 	kref_put(&dev->kref, lcd_delete);

drivers/usb/misc/yurex.c+11−7

 	struct kref		kref;
 	struct mutex		io_mutex;
+	unsigned long		disconnected:1;
 	struct fasync_struct	*async_queue;
 	wait_queue_head_t	waitq;
 				dev->int_buffer, dev->urb->transfer_dma);
 		usb_free_urb(dev->urb);
 	}
+	usb_put_intf(dev->interface);
 	usb_put_dev(dev->udev);
 	kfree(dev);
 }
 	switch (status) {
 	case 0: /*success*/
 		break;
+	/* The device is terminated or messed up, give up */
 	case -EOVERFLOW:
 		dev_err(&dev->interface->dev,
 			"%s - overflow with length %d, actual length is %d\n",
 	case -ENOENT:
 	case -ESHUTDOWN:
 	case -EILSEQ:
-		/* The device is terminated, clean up */
+	case -EPROTO:
+	case -ETIME:
 		return;
 	default:
 		dev_err(&dev->interface->dev,
 			"%s - unknown status received: %d\n", __func__, status);
-		goto exit;
+		return;
 	}
 	/* handle received message */
 		break;
 	}
-exit:
 	retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 	if (retval) {
 		dev_err(&dev->interface->dev, "%s - usb_submit_urb failed: %d\n",
 	init_waitqueue_head(&dev->waitq);
 	dev->udev = usb_get_dev(interface_to_usbdev(interface));
-	dev->interface = interface;
+	dev->interface = usb_get_intf(interface);
 	/* set up the endpoint information */
 	iface_desc = interface->cur_altsetting;
 	/* prevent more I/O from starting */
 	usb_poison_urb(dev->urb);
+	usb_poison_urb(dev->cntl_urb);
 	mutex_lock(&dev->io_mutex);
-	dev->interface = NULL;
+	dev->disconnected = 1;
 	mutex_unlock(&dev->io_mutex);
 	/* wakeup waiters */
 	dev = file->private_data;
 	mutex_lock(&dev->io_mutex);
-	if (!dev->interface) {		/* already disconnected */
+	if (dev->disconnected) {		/* already disconnected */
 		mutex_unlock(&dev->io_mutex);
 		return -ENODEV;
 	}
 		goto error;
 	mutex_lock(&dev->io_mutex);
-	if (!dev->interface) {		/* already disconnected */
+	if (dev->disconnected) {		/* already disconnected */
 		mutex_unlock(&dev->io_mutex);
 		retval = -ENODEV;
 		goto error;

drivers/usb/renesas_usbhs/common.h+1−0

@@ -211,6 +211,7 @@ struct usbhs_priv; · 210 unmodified lines
211	/* DCPCTR */	211	/* DCPCTR */
212	#define BSTS (1 << 15) /* Buffer Status */	212	#define BSTS (1 << 15) /* Buffer Status */
213	#define SUREQ (1 << 14) /* Sending SETUP Token */	213	#define SUREQ (1 << 14) /* Sending SETUP Token */
		214	#define INBUFM (1 << 14) /* (PIPEnCTR) Transfer Buffer Monitor */
214	#define CSSTS (1 << 12) /* CSSTS Status */	215	#define CSSTS (1 << 12) /* CSSTS Status */
215	#define ACLRM (1 << 9) /* Buffer Auto-Clear Mode */	216	#define ACLRM (1 << 9) /* Buffer Auto-Clear Mode */
216	#define SQCLR (1 << 8) /* Toggle Bit Clear */	217	#define SQCLR (1 << 8) /* Toggle Bit Clear */

drivers/usb/renesas_usbhs/fifo.c+1−1

@@ -89,7 +89,7 @@ static void __usbhsf_pkt_del(struct usbhs_pkt *pkt) · 88 unmodified lines
89	list_del_init(&pkt->node);	89	list_del_init(&pkt->node);
90	}	90	}
91		91
92	static struct usbhs_pkt __usbhsf_pkt_get(struct usbhs_pipe pipe)	92	struct usbhs_pkt __usbhsf_pkt_get(struct usbhs_pipe pipe)
93	{	93	{
94	return list_first_entry_or_null(&pipe->list, struct usbhs_pkt, node);	94	return list_first_entry_or_null(&pipe->list, struct usbhs_pkt, node);
95	}	95	}

drivers/usb/renesas_usbhs/fifo.h+1−0

@@ -97,5 +97,6 @@ void usbhs_pkt_push(struct usbhs_pipe pipe, struct usbhs_pkt pkt, · 96 unmodified lines
97	void *buf, int len, int zero, int sequence);	97	void *buf, int len, int zero, int sequence);
98	struct usbhs_pkt usbhs_pkt_pop(struct usbhs_pipe pipe, struct usbhs_pkt *pkt);	98	struct usbhs_pkt usbhs_pkt_pop(struct usbhs_pipe pipe, struct usbhs_pkt *pkt);
99	void usbhs_pkt_start(struct usbhs_pipe *pipe);	99	void usbhs_pkt_start(struct usbhs_pipe *pipe);
		100	struct usbhs_pkt __usbhsf_pkt_get(struct usbhs_pipe pipe);
100		101
101	#endif /* RENESAS_USB_FIFO_H */	102	#endif /* RENESAS_USB_FIFO_H */

drivers/usb/renesas_usbhs/mod_gadget.c+15−3

@@ -722,8 +722,7 @@ static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge) · 721 unmodified lines
722	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);	722	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
723	struct device *dev = usbhsg_gpriv_to_dev(gpriv);	723	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
724	unsigned long flags;	724	unsigned long flags;
725		725	int ret = 0;
726	usbhsg_pipe_disable(uep);
727		726
728	dev_dbg(dev, "set halt %d (pipe %d)\n",	727	dev_dbg(dev, "set halt %d (pipe %d)\n",
729	halt, usbhs_pipe_number(pipe));	728	halt, usbhs_pipe_number(pipe));
@@ -731,6 +730,18 @@ static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge) · 1 unmodified line
731	/****************** spin lock ******************/	730	/****************** spin lock ******************/
732	usbhs_lock(priv, flags);	731	usbhs_lock(priv, flags);
733		732
		733	/*
		734	* According to usb_ep_set_halt()'s description, this function should
		735	* return -EAGAIN if the IN endpoint has any queue or data. Note
		736	* that the usbhs_pipe_is_dir_in() returns false if the pipe is an
		737	* IN endpoint in the gadget mode.
		738	*/
		739	if (!usbhs_pipe_is_dir_in(pipe) && (__usbhsf_pkt_get(pipe) \|\|
		740	usbhs_pipe_contains_transmittable_data(pipe))) {
		741	ret = -EAGAIN;
		742	goto out;
		743	}
		744
734	if (halt)	745	if (halt)
735	usbhs_pipe_stall(pipe);	746	usbhs_pipe_stall(pipe);
736	else	747	else
@@ -741,10 +752,11 @@ static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge) · 4 unmodified lines
741	else	752	else
742	usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);	753	usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);
743		754
		755	out:
744	usbhs_unlock(priv, flags);	756	usbhs_unlock(priv, flags);
745	/****************** spin unlock ****************/	757	/****************** spin unlock ****************/
746		758
747	return 0;	759	return ret;
748	}	760	}
749		761
750	static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)	762	static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)

drivers/usb/renesas_usbhs/pipe.c+15−0

@@ -277,6 +277,21 @@ int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe) · 276 unmodified lines
277	return -EBUSY;	277	return -EBUSY;
278	}	278	}
279		279
		280	bool usbhs_pipe_contains_transmittable_data(struct usbhs_pipe *pipe)
		281	{
		282	u16 val;
		283
		284	/* Do not support for DCP pipe */
		285	if (usbhs_pipe_is_dcp(pipe))
		286	return false;
		287
		288	val = usbhsp_pipectrl_get(pipe);
		289	if (val & INBUFM)
		290	return true;
		291
		292	return false;
		293	}
		294
280	/*	295	/*
281	* PID ctrl	296	* PID ctrl
282	*/	297	*/

drivers/usb/renesas_usbhs/pipe.h+1−0

@@ -83,6 +83,7 @@ void usbhs_pipe_clear(struct usbhs_pipe *pipe); · 82 unmodified lines
83	void usbhs_pipe_clear_without_sequence(struct usbhs_pipe *pipe,	83	void usbhs_pipe_clear_without_sequence(struct usbhs_pipe *pipe,
84	int needs_bfre, int bfre_enable);	84	int needs_bfre, int bfre_enable);
85	int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe);	85	int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe);
		86	bool usbhs_pipe_contains_transmittable_data(struct usbhs_pipe *pipe);
86	void usbhs_pipe_enable(struct usbhs_pipe *pipe);	87	void usbhs_pipe_enable(struct usbhs_pipe *pipe);
87	void usbhs_pipe_disable(struct usbhs_pipe *pipe);	88	void usbhs_pipe_disable(struct usbhs_pipe *pipe);
88	void usbhs_pipe_stall(struct usbhs_pipe *pipe);	89	void usbhs_pipe_stall(struct usbhs_pipe *pipe);

drivers/usb/serial/ftdi_sio.c+3−0

 	/* EZPrototypes devices */
 	{ USB_DEVICE(EZPROTOTYPES_VID, HJELMSLUND_USB485_ISO_PID) },
 	{ USB_DEVICE_INTERFACE_NUMBER(UNJO_VID, UNJO_ISODEBUG_V1_PID, 1) },
+	/* Sienna devices */
+	{ USB_DEVICE(FTDI_VID, FTDI_SIENNA_PID) },
+	{ USB_DEVICE(ECHELON_VID, ECHELON_U20_PID) },
 	{ }					/* Terminating entry */
 };

drivers/usb/serial/ftdi_sio_ids.h+9−0

 #define FTDI_LUMEL_PD12_PID	0x6002
+/* Sienna Serial Interface by Secyourit GmbH */
+#define FTDI_SIENNA_PID		0x8348
 /* Cyber Cortex AV by Fabulous Silicon (http://fabuloussilicon.com) */
 #define CYBER_CORTEX_AV_PID	0x8698
 #define BANDB_TTL3USB9M_PID	0xAC50
 #define BANDB_ZZ_PROG1_USB_PID	0xBA02
+/*
+ * Echelon USB Serial Interface
+ */
+#define ECHELON_VID		0x0920
+#define ECHELON_U20_PID		0x7500
 /*
  * Intrepid Control Systems (http://www.intrepidcs.com/) ValueCAN and NeoVI
  */

drivers/usb/serial/keyspan.c+2−2

@@ -1741,8 +1741,8 @@ static struct urb keyspan_setup_urb(struct usb_serial serial, int endpoint, · 1740 unmodified lines
1741		1741
1742	ep_desc = find_ep(serial, endpoint);	1742	ep_desc = find_ep(serial, endpoint);
1743	if (!ep_desc) {	1743	if (!ep_desc) {
1744	/* leak the urb, something's wrong and the callers don't care */	1744	usb_free_urb(urb);
1745	return urb;	1745	return NULL;
1746	}	1746	}
1747	if (usb_endpoint_xfer_int(ep_desc)) {	1747	if (usb_endpoint_xfer_int(ep_desc)) {
1748	ep_type_name = "INT";	1748	ep_type_name = "INT";

drivers/usb/serial/option.c+11−0

 #define CINTERION_PRODUCT_PH8_AUDIO		0x0083
 #define CINTERION_PRODUCT_AHXX_2RMNET		0x0084
 #define CINTERION_PRODUCT_AHXX_AUDIO		0x0085
+#define CINTERION_PRODUCT_CLS8			0x00b0
 /* Olivetti products */
 #define OLIVETTI_VENDOR_ID			0x0b3c
 	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) | RSVD(3) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, TELIT_PRODUCT_LE922_USBCFG5, 0xff),
 	  .driver_info = RSVD(0) | RSVD(1) | NCTRL(2) | RSVD(3) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1050, 0xff),	/* Telit FN980 (rmnet) */
+	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1051, 0xff),	/* Telit FN980 (MBIM) */
+	  .driver_info = NCTRL(0) | RSVD(1) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1052, 0xff),	/* Telit FN980 (RNDIS) */
+	  .driver_info = NCTRL(2) | RSVD(3) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1053, 0xff),	/* Telit FN980 (ECM) */
+	  .driver_info = NCTRL(0) | RSVD(1) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910),
 	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(3) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910_DUAL_MODEM),
 	  .driver_info = RSVD(4) },
 	{ USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX_2RMNET, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX_AUDIO, 0xff) },
+	{ USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_CLS8, 0xff),
+	  .driver_info = RSVD(0) | RSVD(4) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) },
 	{ USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDM) },

drivers/usb/serial/usb-serial.c+1−4

 	serial = port->serial;
 	owner = serial->type->driver.owner;
-	mutex_lock(&serial->disc_mutex);
+	usb_autopm_put_interface(serial->interface);
-	if (!serial->disconnected)
-		usb_autopm_put_interface(serial->interface);
-	mutex_unlock(&serial->disc_mutex);
 	usb_serial_put(serial);
 	module_put(owner);

drivers/usb/typec/tcpm/tcpm.c+8−6

 	/* USB data support is optional */
 	ret = fwnode_property_read_string(fwnode, "data-role", &cap_str);
 	if (ret == 0) {
-		port->typec_caps.data = typec_find_port_data_role(cap_str);
+		ret = typec_find_port_data_role(cap_str);
-		if (port->typec_caps.data < 0)
+		if (ret < 0)
-			return -EINVAL;
+			return ret;
+		port->typec_caps.data = ret;
 	}
 	ret = fwnode_property_read_string(fwnode, "power-role", &cap_str);
 	if (ret < 0)
 		return ret;
-	port->typec_caps.type = typec_find_port_power_role(cap_str);
+	ret = typec_find_port_power_role(cap_str);
-	if (port->typec_caps.type < 0)
+	if (ret < 0)
-		return -EINVAL;
+		return ret;
+	port->typec_caps.type = ret;
 	port->port_type = port->typec_caps.type;
 	if (port->port_type == TYPEC_PORT_SNK)

drivers/usb/typec/ucsi/displayport.c+2−0

@@ -75,6 +75,8 @@ static int ucsi_displayport_enter(struct typec_altmode *alt) · 74 unmodified lines
75		75
76	if (cur != 0xff) {	76	if (cur != 0xff) {
77	mutex_unlock(&dp->con->lock);	77	mutex_unlock(&dp->con->lock);
		78	if (dp->con->port_altmode[cur] == alt)
		79	return 0;
78	return -EBUSY;	80	return -EBUSY;
79	}	81	}
80		82

drivers/usb/typec/ucsi/ucsi_ccg.c+4−38

 	/* fw build with vendor information */
 	u16 fw_build;
-	bool run_isr; /* flag to call ISR routine during resume */
 	struct work_struct pm_work;
 };
 	if (quirks && quirks->max_read_len)
 		max_read_len = quirks->max_read_len;
-	if (uc->fw_build == CCG_FW_BUILD_NVIDIA &&
-	    uc->fw_version <= CCG_OLD_FW_VERSION) {
-		mutex_lock(&uc->lock);
-		/*
-		 * Do not schedule pm_work to run ISR in
-		 * ucsi_ccg_runtime_resume() after pm_runtime_get_sync()
-		 * since we are already in ISR path.
-		 */
-		uc->run_isr = false;
-		mutex_unlock(&uc->lock);
-	}
 	pm_runtime_get_sync(uc->dev);
 	while (rem_len > 0) {
 		msgs[1].buf = &data[len - rem_len];
 	msgs[0].len = len + sizeof(rab);
 	msgs[0].buf = buf;
-	if (uc->fw_build == CCG_FW_BUILD_NVIDIA &&
-	    uc->fw_version <= CCG_OLD_FW_VERSION) {
-		mutex_lock(&uc->lock);
-		/*
-		 * Do not schedule pm_work to run ISR in
-		 * ucsi_ccg_runtime_resume() after pm_runtime_get_sync()
-		 * since we are already in ISR path.
-		 */
-		uc->run_isr = false;
-		mutex_unlock(&uc->lock);
-	}
 	pm_runtime_get_sync(uc->dev);
 	status = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 	if (status < 0) {
 	uc->ppm.sync = ucsi_ccg_sync;
 	uc->dev = dev;
 	uc->client = client;
-	uc->run_isr = true;
 	mutex_init(&uc->lock);
 	INIT_WORK(&uc->work, ccg_update_firmware);
 	INIT_WORK(&uc->pm_work, ccg_pm_workaround_work);
 	pm_runtime_set_active(uc->dev);
 	pm_runtime_enable(uc->dev);
+	pm_runtime_use_autosuspend(uc->dev);
+	pm_runtime_set_autosuspend_delay(uc->dev, 5000);
 	pm_runtime_idle(uc->dev);
 	return 0;
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct ucsi_ccg *uc = i2c_get_clientdata(client);
-	bool schedule = true;
 	/*
 	 * Firmware version 3.1.10 or earlier, built for NVIDIA has known issue
 	 * Schedule a work to call ISR as a workaround.
 	 */
 	if (uc->fw_build == CCG_FW_BUILD_NVIDIA &&
-	    uc->fw_version <= CCG_OLD_FW_VERSION) {
+	    uc->fw_version <= CCG_OLD_FW_VERSION)
-		mutex_lock(&uc->lock);
+		schedule_work(&uc->pm_work);
-		if (!uc->run_isr) {
-			uc->run_isr = true;
-			schedule = false;
-		}
-		mutex_unlock(&uc->lock);
-		if (schedule)
-			schedule_work(&uc->pm_work);
-	}
 	return 0;
 }

drivers/usb/usb-skeleton.c+9−10

 	spinlock_t		err_lock;		/* lock for errors */
 	struct kref		kref;
 	struct mutex		io_mutex;		/* synchronize I/O with disconnect */
+	unsigned long		disconnected:1;
 	wait_queue_head_t	bulk_in_wait;		/* to wait for an ongoing read */
 };
 #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
 	struct usb_skel *dev = to_skel_dev(kref);
 	usb_free_urb(dev->bulk_in_urb);
+	usb_put_intf(dev->interface);
 	usb_put_dev(dev->udev);
 	kfree(dev->bulk_in_buffer);
 	kfree(dev);
 		return -ENODEV;
 	/* allow the device to be autosuspended */
-	mutex_lock(&dev->io_mutex);
+	usb_autopm_put_interface(dev->interface);
-	if (dev->interface)
-		usb_autopm_put_interface(dev->interface);
-	mutex_unlock(&dev->io_mutex);
 	/* decrement the count on our device */
 	kref_put(&dev->kref, skel_delete);
 	dev = file->private_data;
-	/* if we cannot read at all, return EOF */
+	if (!count)
-	if (!dev->bulk_in_urb || !count)
 		return 0;
 	/* no concurrent readers */
 	if (rv < 0)
 		return rv;
-	if (!dev->interface) {		/* disconnect() was called */
+	if (dev->disconnected) {		/* disconnect() was called */
 		rv = -ENODEV;
 		goto exit;
 	}
 	/* this lock makes sure we don't submit URBs to gone devices */
 	mutex_lock(&dev->io_mutex);
-	if (!dev->interface) {		/* disconnect() was called */
+	if (dev->disconnected) {		/* disconnect() was called */
 		mutex_unlock(&dev->io_mutex);
 		retval = -ENODEV;
 		goto error;
 	init_waitqueue_head(&dev->bulk_in_wait);
 	dev->udev = usb_get_dev(interface_to_usbdev(interface));
-	dev->interface = interface;
+	dev->interface = usb_get_intf(interface);
 	/* set up the endpoint information */
 	/* use only the first bulk-in and bulk-out endpoints */
 	/* prevent more I/O from starting */
 	mutex_lock(&dev->io_mutex);
-	dev->interface = NULL;
+	dev->disconnected = 1;
 	mutex_unlock(&dev->io_mutex);
+	usb_kill_urb(dev->bulk_in_urb);
 	usb_kill_anchored_urbs(&dev->submitted);
 	/* decrement our usage count */

drivers/usb/usbip/vhci_hcd.c+2−2

@@ -1195,12 +1195,12 @@ static int vhci_start(struct usb_hcd *hcd) · 1194 unmodified lines
1195	if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {	1195	if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {
1196	err = vhci_init_attr_group();	1196	err = vhci_init_attr_group();
1197	if (err) {	1197	if (err) {
1198	pr_err("init attr group\n");	1198	dev_err(hcd_dev(hcd), "init attr group failed, err = %d\n", err);
1199	return err;	1199	return err;
1200	}	1200	}
1201	err = sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);	1201	err = sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);
1202	if (err) {	1202	if (err) {
1203	pr_err("create sysfs files\n");	1203	dev_err(hcd_dev(hcd), "create sysfs files failed, err = %d\n", err);
1204	vhci_finish_attr_group();	1204	vhci_finish_attr_group();
1205	return err;	1205	return err;
1206	}	1206	}

include/linux/platform_device.h+2−0

@@ -64,6 +64,8 @@ extern struct resource platform_get_resource_byname(struct platform_device , · 63 unmodified lines
64	unsigned int,	64	unsigned int,
65	const char *);	65	const char *);
66	extern int platform_get_irq_byname(struct platform_device , const char );	66	extern int platform_get_irq_byname(struct platform_device , const char );
		67	extern int platform_get_irq_byname_optional(struct platform_device *dev,
		68	const char *name);
67	extern int platform_add_devices(struct platform_device **, int);	69	extern int platform_add_devices(struct platform_device **, int);
68		70
69	struct platform_device_info {	71	struct platform_device_info {