linux-sg2042

History

Greg Kroah-Hartman 95713fb8aa Revert "usb: core: Add "quirks" parameter for usbcore" This reverts commit `b27560e4d9` as it breaks the build for some arches :( Reported-by: kbuild test robot <fengguang.wu@intel.com> Cc: Kai-Heng Feng <kai.heng.feng@canonical.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index 1d1d53f85ddd..70a7398c20e2 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -4368,6 +4368,61 @@ usbcore.nousb [USB] Disable the USB subsystem + usbcore.quirks= + [USB] A list of quirks entries to supplement or + override the built-in usb core quirk list. List + entries are separated by commas. Each entry has + the form VID:PID:Flags where VID and PID are Vendor + and Product ID values (4-digit hex numbers) and + Flags is a set of characters, each corresponding + to a common usb core quirk flag as follows: + a = USB_QUIRK_STRING_FETCH_255 (string + descriptors must not be fetched using + a 255-byte read); + b = USB_QUIRK_RESET_RESUME (device can't resume + correctly so reset it instead); + c = USB_QUIRK_NO_SET_INTF (device can't handle + Set-Interface requests); + d = USB_QUIRK_CONFIG_INTF_STRINGS (device can't + handle its Configuration or Interface + strings); + e = USB_QUIRK_RESET (device can't be reset + (e.g morph devices), don't use reset); + f = USB_QUIRK_HONOR_BNUMINTERFACES (device has + more interface descriptions than the + bNumInterfaces count, and can't handle + talking to these interfaces); + g = USB_QUIRK_DELAY_INIT (device needs a pause + during initialization, after we read + the device descriptor); + h = USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL (For + high speed and super speed interrupt + endpoints, the USB 2.0 and USB 3.0 spec + require the interval in microframes (1 + microframe = 125 microseconds) to be + calculated as interval = 2 ^ + (bInterval-1). + Devices with this quirk report their + bInterval as the result of this + calculation instead of the exponent + variable used in the calculation); + i = USB_QUIRK_DEVICE_QUALIFIER (device can't + handle device_qualifier descriptor + requests); + j = USB_QUIRK_IGNORE_REMOTE_WAKEUP (device + generates spurious wakeup, ignore + remote wakeup capability); + k = USB_QUIRK_NO_LPM (device can't handle Link + Power Management); + l = USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL + (Device reports its bInterval as linear + frames instead of the USB 2.0 + calculation); + m = USB_QUIRK_DISCONNECT_SUSPEND (Device needs + to be disconnected before suspend to + prevent spurious wakeup) + Example: quirks=0781:5580:bk,0a5c:5834:gij + usbhid.mousepoll= [USBHID] The interval which mice are to be polled at. diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c index f4a548471f0f..42faaeead81b 100644 --- a/drivers/usb/core/quirks.c +++ b/drivers/usb/core/quirks.c @@ -11,6 +11,143 @@ #include <linux/usb/hcd.h> #include "usb.h" +struct quirk_entry { + u16 vid; + u16 pid; + u32 flags; +}; + +static DEFINE_MUTEX(quirk_mutex); + +static struct quirk_entry quirk_list; +static unsigned int quirk_count; + +static char quirks_param[128]; + +static int quirks_param_set(const char val, const struct kernel_param kp) +{ + char p, field; + u16 vid, pid; + u32 flags; + size_t i; + + mutex_lock(&quirk_mutex); + + if (!val \|\| !val) { + quirk_count = 0; + kfree(quirk_list); + quirk_list = NULL; + goto unlock; + } + + for (quirk_count = 1, i = 0; val[i]; i++) + if (val[i] == ',') + quirk_count++; + + if (quirk_list) { + kfree(quirk_list); + quirk_list = NULL; + } + + quirk_list = kcalloc(quirk_count, sizeof(struct quirk_entry), + GFP_KERNEL); + if (!quirk_list) { + mutex_unlock(&quirk_mutex); + return -ENOMEM; + } + + for (i = 0, p = (char )val; p && p;) { + /* Each entry consists of VID:PID:flags / + field = strsep(&p, ":"); + if (!field) + break; + + if (kstrtou16(field, 16, &vid)) + break; + + field = strsep(&p, ":"); + if (!field) + break; + + if (kstrtou16(field, 16, &pid)) + break; + + field = strsep(&p, ","); + if (!field \|\| !field) + break; + + /* Collect the flags / + for (flags = 0; field; field++) { + switch (field) { + case 'a': + flags \|= USB_QUIRK_STRING_FETCH_255; + break; + case 'b': + flags \|= USB_QUIRK_RESET_RESUME; + break; + case 'c': + flags \|= USB_QUIRK_NO_SET_INTF; + break; + case 'd': + flags \|= USB_QUIRK_CONFIG_INTF_STRINGS; + break; + case 'e': + flags \|= USB_QUIRK_RESET; + break; + case 'f': + flags \|= USB_QUIRK_HONOR_BNUMINTERFACES; + break; + case 'g': + flags \|= USB_QUIRK_DELAY_INIT; + break; + case 'h': + flags \|= USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL; + break; + case 'i': + flags \|= USB_QUIRK_DEVICE_QUALIFIER; + break; + case 'j': + flags \|= USB_QUIRK_IGNORE_REMOTE_WAKEUP; + break; + case 'k': + flags \|= USB_QUIRK_NO_LPM; + break; + case 'l': + flags \|= USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL; + break; + case 'm': + flags \|= USB_QUIRK_DISCONNECT_SUSPEND; + break; + / Ignore unrecognized flag characters / + } + } + + quirk_list[i++] = (struct quirk_entry) + { .vid = vid, .pid = pid, .flags = flags }; + } + + if (i < quirk_count) + quirk_count = i; + +unlock: + mutex_unlock(&quirk_mutex); + + return param_set_copystring(val, kp); +} + +static const struct kernel_param_ops quirks_param_ops = { + .set = quirks_param_set, + .get = param_get_string, +}; + +static struct kparam_string quirks_param_string = { + .maxlen = sizeof(quirks_param), + .string = quirks_param, +}; + +module_param_cb(quirks, &quirks_param_ops, &quirks_param_string, 0644); +MODULE_PARM_DESC(quirks, "Add/modify USB quirks by specifying quirks=vendorID:productID:quirks"); + / Lists of quirky USB devices, split in device quirks and interface quirks. * Device quirks are applied at the very beginning of the enumeration process, * right after reading the device descriptor. They can thus only match on device @@ -320,8 +457,8 @@ static int usb_amd_resume_quirk(struct usb_device udev) return 0; } -static u32 __usb_detect_quirks(struct usb_device udev, - const struct usb_device_id id) +static u32 usb_detect_static_quirks(struct usb_device udev, + const struct usb_device_id id) { u32 quirks = 0; @@ -339,21 +476,43 @@ static u32 __usb_detect_quirks(struct usb_device udev, return quirks; } +static u32 usb_detect_dynamic_quirks(struct usb_device udev) +{ + u16 vid = le16_to_cpu(udev->descriptor.idVendor); + u16 pid = le16_to_cpu(udev->descriptor.idProduct); + int i, flags = 0; + + mutex_lock(&quirk_mutex); + + for (i = 0; i < quirk_count; i++) { + if (vid == quirk_list[i].vid && pid == quirk_list[i].pid) { + flags = quirk_list[i].flags; + break; + } + } + + mutex_unlock(&quirk_mutex); + + return flags; +} + / * Detect any quirks the device has, and do any housekeeping for it if needed. / void usb_detect_quirks(struct usb_device udev) { - udev->quirks = __usb_detect_quirks(udev, usb_quirk_list); + udev->quirks = usb_detect_static_quirks(udev, usb_quirk_list); /* * Pixart-based mice would trigger remote wakeup issue on AMD * Yangtze chipset, so set them as RESET_RESUME flag. / if (usb_amd_resume_quirk(udev)) - udev->quirks \|= __usb_detect_quirks(udev, + udev->quirks \|= usb_detect_static_quirks(udev, usb_amd_resume_quirk_list); + udev->quirks ^= usb_detect_dynamic_quirks(udev); + if (udev->quirks) dev_dbg(&udev->dev, "USB quirks for this device: %x\n", udev->quirks); @@ -372,7 +531,7 @@ void usb_detect_interface_quirks(struct usb_device udev) { u32 quirks; - quirks = __usb_detect_quirks(udev, usb_interface_quirk_list); + quirks = usb_detect_static_quirks(udev, usb_interface_quirk_list); if (quirks == 0) return; @@ -380,3 +539,11 @@ void usb_detect_interface_quirks(struct usb_device udev) quirks); udev->quirks \|= quirks; } + +void usb_release_quirk_list(void) +{ + mutex_lock(&quirk_mutex); + kfree(quirk_list); + quirk_list = NULL; + mutex_unlock(&quirk_mutex); +} diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c index 2f5fbc56a9dd..0adb6345ff2e 100644 --- a/drivers/usb/core/usb.c +++ b/drivers/usb/core/usb.c @@ -1259,6 +1259,7 @@ static void __exit usb_exit(void) if (usb_disabled()) return; + usb_release_quirk_list(); usb_deregister_device_driver(&usb_generic_driver); usb_major_cleanup(); usb_deregister(&usbfs_driver); diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h index 149cc7480971..546a2219454b 100644 --- a/drivers/usb/core/usb.h +++ b/drivers/usb/core/usb.h @@ -36,6 +36,7 @@ extern void usb_deauthorize_interface(struct usb_interface ); extern void usb_authorize_interface(struct usb_interface ); extern void usb_detect_quirks(struct usb_device udev); extern void usb_detect_interface_quirks(struct usb_device udev); +extern void usb_release_quirk_list(void); extern int usb_remove_device(struct usb_device udev); extern int usb_get_device_descriptor(struct usb_device *dev,		2018-03-12 16:30:40 +01:00
..
atm	USB: atm: fix up some remaining DEVICE_ATTR() usage	2018-01-24 08:49:52 +01:00
c67x00	USB: add SPDX identifiers to all remaining Makefiles	2017-11-07 15:53:48 +01:00
chipidea	usb: add a flag to skip PHY initialization to struct usb_hcd	2018-03-09 09:43:52 -08:00
class	usb: cdc_acm: prevent race at write to acm while system resumes	2018-02-16 07:52:55 +01:00
common	USB: ulpi: fix bus-node lookup	2017-11-28 15:17:48 +01:00
core	Revert "usb: core: Add "quirks" parameter for usbcore"	2018-03-12 16:30:40 +01:00
dwc2	USB: dwc2: Re-use DEFINE_SHOW_ATTRIBUTE() macro	2018-03-09 09:27:55 -08:00
dwc3	usb: dwc3: core: Fix ULPI PHYs and prevent phy_get/ulpi_init during suspend/resume	2018-02-15 15:28:35 +02:00
early	usb: early: Correct the endpoint type value for bulk in endpoint	2017-12-07 16:03:15 +01:00
gadget	USB: gadget: pxa27x: Re-use DEFINE_SHOW_ATTRIBUTE() macro	2018-03-09 09:31:25 -08:00
host	usb: host: ohci-platform: remove custom USB PHY handling	2018-03-09 09:43:53 -08:00
image	USB/PHY patches for 4.15-rc1	2017-11-13 21:14:07 -08:00
isp1760	usb: isp1760: Use kasprintf	2018-03-09 09:40:21 -08:00
misc	USB: adutux: Add waiting in transfer abortion	2018-03-09 09:37:10 -08:00
mon	vfs: do bulk POLL* -> EPOLL* replacement	2018-02-11 14:34:03 -08:00
mtu3	usb: mtu3: fix semicolon.cocci warnings	2018-01-16 10:01:01 +01:00
musb	USB: musb: Re-use DEFINE_SHOW_ATTRIBUTE() macro	2018-03-09 09:27:55 -08:00
phy	usb: phy: mxs: Fix NULL pointer dereference on i.MX23/28	2018-02-12 10:51:37 +02:00
renesas_usbhs	usb: renesas_usbhs: missed the "running" flag in usb_dmac with rx path	2018-02-15 18:43:57 +01:00
serial	USB: serial: option: Add support for Quectel EP06	2018-02-15 18:36:19 +01:00
storage	USB: move many drivers to use DEVICE_ATTR_RO	2018-01-24 08:49:52 +01:00
typec	usb: typec: Start using ERR_PTR	2018-03-09 09:46:18 -08:00
usbip	usbip: Correct maximum value of CONFIG_USBIP_VHCI_HC_PORTS	2018-03-09 09:16:18 -08:00
wusbcore	USB: wusbcore: remove redundant re-assignment to pointer 'dev'	2018-03-09 09:16:19 -08:00
Kconfig	sparc,leon: Select USB_UHCI_BIG_ENDIAN_{MMIO,DESC}	2018-02-15 21:45:16 +00:00
Makefile	License cleanup: add SPDX GPL-2.0 license identifier to files with no license	2017-11-02 11:10:55 +01:00
README	…
usb-skeleton.c	usb: usb-skeleton: make MODULE_LICENSE and SPDX tag match	2018-03-06 09:42:07 -08:00

README

To understand all the Linux-USB framework, you'll use these resources:

    * This source code.  This is necessarily an evolving work, and
      includes kerneldoc that should help you get a current overview.
      ("make pdfdocs", and then look at "usb.pdf" for host side and
      "gadget.pdf" for peripheral side.)  Also, Documentation/usb has
      more information.

    * The USB 2.0 specification (from www.usb.org), with supplements
      such as those for USB OTG and the various device classes.
      The USB specification has a good overview chapter, and USB
      peripherals conform to the widely known "Chapter 9".

    * Chip specifications for USB controllers.  Examples include
      host controllers (on PCs, servers, and more); peripheral
      controllers (in devices with Linux firmware, like printers or
      cell phones); and hard-wired peripherals like Ethernet adapters.

    * Specifications for other protocols implemented by USB peripheral
      functions.  Some are vendor-specific; others are vendor-neutral
      but just standardized outside of the www.usb.org team.

Here is a list of what each subdirectory here is, and what is contained in
them.

core/		- This is for the core USB host code, including the
		  usbfs files and the hub class driver ("hub_wq").

host/		- This is for USB host controller drivers.  This
		  includes UHCI, OHCI, EHCI, and others that might
		  be used with more specialized "embedded" systems.

gadget/		- This is for USB peripheral controller drivers and
		  the various gadget drivers which talk to them.


Individual USB driver directories.  A new driver should be added to the
first subdirectory in the list below that it fits into.

image/		- This is for still image drivers, like scanners or
		  digital cameras.
../input/	- This is for any driver that uses the input subsystem,
		  like keyboard, mice, touchscreens, tablets, etc.
../media/	- This is for multimedia drivers, like video cameras,
		  radios, and any other drivers that talk to the v4l
		  subsystem.
../net/		- This is for network drivers.
serial/		- This is for USB to serial drivers.
storage/	- This is for USB mass-storage drivers.
class/		- This is for all USB device drivers that do not fit
		  into any of the above categories, and work for a range
		  of USB Class specified devices. 
misc/		- This is for all USB device drivers that do not fit
		  into any of the above categories.