From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752162AbdLFOJ6 (ORCPT ); Wed, 6 Dec 2017 09:09:58 -0500 Received: from mail.linuxfoundation.org ([140.211.169.12]:56914 "EHLO mail.linuxfoundation.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751633AbdLFOJy (ORCPT ); Wed, 6 Dec 2017 09:09:54 -0500 Date: Wed, 6 Dec 2017 15:10:00 +0100 From: Greg KH To: Kai-Heng Feng Cc: corbet@lwn.net, linux-usb@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v2] usb: core: Add "quirks" parameter for usbcore Message-ID: <20171206141000.GA11339@kroah.com> References: <20171206102621.14192-1-kai.heng.feng@canonical.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20171206102621.14192-1-kai.heng.feng@canonical.com> User-Agent: Mutt/1.9.1 (2017-09-22) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Dec 06, 2017 at 06:26:21PM +0800, Kai-Heng Feng wrote: > Trying quirks in usbcore needs to rebuild the driver or the entire > kernel if it's builtin. It can save a lot of time if usbcore has similar > ability like "usbhid.quirks=" and "usb-storage.quirks=". > > Rename the original quirk detection function to "static" as we introduce > this new "dynamic" function. > > Now users can use "usbcore.quirks=" as short term workaround before the > next kernel release. > > This is inspired by usbhid and usb-storage. > > Signed-off-by: Kai-Heng Feng > --- > v2: use in-kernel tolower() function. > > Documentation/admin-guide/kernel-parameters.txt | 55 +++++++++++++ > drivers/usb/core/quirks.c | 100 ++++++++++++++++++++++-- > include/linux/usb/quirks.h | 2 + > 3 files changed, 151 insertions(+), 6 deletions(-) > > diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt > index 6571fbfdb2a1..d42fb278320b 100644 > --- a/Documentation/admin-guide/kernel-parameters.txt > +++ b/Documentation/admin-guide/kernel-parameters.txt > @@ -4302,6 +4302,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 f1dbab6f798f..5471765765be 100644 > --- a/drivers/usb/core/quirks.c > +++ b/drivers/usb/core/quirks.c > @@ -11,6 +11,12 @@ > #include > #include "usb.h" > > +/* Quirks specified at module load time */ > +static char *quirks_param[MAX_USB_BOOT_QUIRKS]; > +module_param_array_named(quirks, quirks_param, charp, NULL, 0444); So you can't modify this at runtime? Why not? > +MODULE_PARM_DESC(quirks, "Add/modify USB quirks by specifying" > + "quirks=vendorID:productID:quirks"); Don't break strings over multiple lines. > + > /* 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 > @@ -310,8 +316,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; > > @@ -329,23 +335,105 @@ static u32 __usb_detect_quirks(struct usb_device *udev, > return quirks; > } > > +static u32 usb_detect_dynamic_quirks(struct usb_device *udev) > +{ > + u16 dev_vid = le16_to_cpu(udev->descriptor.idVendor); > + u16 dev_pid = le16_to_cpu(udev->descriptor.idProduct); > + u16 quirk_vid, quirk_pid; > + char quirks[32]; > + char *p; > + u32 flags = 0; > + int n, m; > + > + for (n = 0; n < MAX_USB_BOOT_QUIRKS && quirks_param[n]; n++) { > + m = sscanf(quirks_param[n], "%hx:%hx:%s", > + &quirk_vid, &quirk_pid, quirks); > + if (m != 3) > + pr_warn("Could not parse USB quirk module param %s\n", > + quirks_param[n]); dev_warn(). Also, you are going to complain about the inability to parse the quirks for _EVERY_ USB device in the system? That feels really wrong. Parse it once, and then use the parsed table when matching things up. Don't parse the string each and every time a device is added, that's a horrible waste of time (not like USB enumeration is fast, but really, let's not make it worse for no reason.) > + > + if (quirk_vid == dev_vid && quirk_pid == dev_pid) > + break; > + } > + if (n == MAX_USB_BOOT_QUIRKS || !quirks_param[n]) > + return 0; > + > + p = quirks; > + > + /* Collect the flags */ > + for (; *p; p++) { > + switch (tolower(*p)) { > + 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 */ > + } > + } > + > + 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_dynamic_quirks(udev); > + > + if (udev->quirks) { > + dev_dbg(&udev->dev, "Dynamic USB quirks for this device: %x\n", > + udev->quirks); > + return; > + } > + > + udev->quirks = usb_detect_static_quirks(udev, usb_quirk_list); Did you just overwrite the dynamic with the static ones? It feels like you just did :( > --- a/include/linux/usb/quirks.h > +++ b/include/linux/usb/quirks.h > @@ -8,6 +8,8 @@ > #ifndef __LINUX_USB_QUIRKS_H > #define __LINUX_USB_QUIRKS_H > > +#define MAX_USB_BOOT_QUIRKS 4 Why 4? And why in this .h file? Also, Oliver's request is good, xor is a nice way to do things if at all possible. thanks, greg k-h From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v2] usb: core: Add "quirks" parameter for usbcore From: Greg Kroah-Hartman Message-Id: <20171206141000.GA11339@kroah.com> Date: Wed, 6 Dec 2017 15:10:00 +0100 To: Kai-Heng Feng Cc: corbet@lwn.net, linux-usb@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org List-ID: T24gV2VkLCBEZWMgMDYsIDIwMTcgYXQgMDY6MjY6MjFQTSArMDgwMCwgS2FpLUhlbmcgRmVuZyB3 cm90ZToKPiBUcnlpbmcgcXVpcmtzIGluIHVzYmNvcmUgbmVlZHMgdG8gcmVidWlsZCB0aGUgZHJp dmVyIG9yIHRoZSBlbnRpcmUKPiBrZXJuZWwgaWYgaXQncyBidWlsdGluLiBJdCBjYW4gc2F2ZSBh IGxvdCBvZiB0aW1lIGlmIHVzYmNvcmUgaGFzIHNpbWlsYXIKPiBhYmlsaXR5IGxpa2UgInVzYmhp ZC5xdWlya3M9IiBhbmQgInVzYi1zdG9yYWdlLnF1aXJrcz0iLgo+IAo+IFJlbmFtZSB0aGUgb3Jp Z2luYWwgcXVpcmsgZGV0ZWN0aW9uIGZ1bmN0aW9uIHRvICJzdGF0aWMiIGFzIHdlIGludHJvZHVj ZQo+IHRoaXMgbmV3ICJkeW5hbWljIiBmdW5jdGlvbi4KPiAKPiBOb3cgdXNlcnMgY2FuIHVzZSAi dXNiY29yZS5xdWlya3M9IiBhcyBzaG9ydCB0ZXJtIHdvcmthcm91bmQgYmVmb3JlIHRoZQo+IG5l eHQga2VybmVsIHJlbGVhc2UuCj4gCj4gVGhpcyBpcyBpbnNwaXJlZCBieSB1c2JoaWQgYW5kIHVz Yi1zdG9yYWdlLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEthaS1IZW5nIEZlbmcgPGthaS5oZW5nLmZl bmdAY2Fub25pY2FsLmNvbT4KPiAtLS0KPiB2MjogdXNlIGluLWtlcm5lbCB0b2xvd2VyKCkgZnVu Y3Rpb24uCj4gCj4gIERvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMu dHh0IHwgIDU1ICsrKysrKysrKysrKysKPiAgZHJpdmVycy91c2IvY29yZS9xdWlya3MuYyAgICAg ICAgICAgICAgICAgICAgICAgfCAxMDAgKysrKysrKysrKysrKysrKysrKysrKy0tCj4gIGluY2x1 ZGUvbGludXgvdXNiL3F1aXJrcy5oICAgICAgICAgICAgICAgICAgICAgIHwgICAyICsKPiAgMyBm aWxlcyBjaGFuZ2VkLCAxNTEgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKPiAKPiBkaWZm IC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQg Yi9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dAo+IGluZGV4 IDY1NzFmYmZkYjJhMS4uZDQyZmIyNzgzMjBiIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24v YWRtaW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMudHh0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9h ZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKPiBAQCAtNDMwMiw2ICs0MzAyLDYxIEBA Cj4gIAo+ICAJdXNiY29yZS5ub3VzYglbVVNCXSBEaXNhYmxlIHRoZSBVU0Igc3Vic3lzdGVtCj4g IAo+ICsJdXNiY29yZS5xdWlya3M9Cj4gKwkJCVtVU0JdIEEgbGlzdCBvZiBxdWlya3MgZW50cmll cyB0byBzdXBwbGVtZW50IG9yCj4gKwkJCW92ZXJyaWRlIHRoZSBidWlsdC1pbiB1c2IgY29yZSBx dWlyayBsaXN0LiAgTGlzdAo+ICsJCQllbnRyaWVzIGFyZSBzZXBhcmF0ZWQgYnkgY29tbWFzLiAg RWFjaCBlbnRyeSBoYXMKPiArCQkJdGhlIGZvcm0gVklEOlBJRDpGbGFncyB3aGVyZSBWSUQgYW5k IFBJRCBhcmUgVmVuZG9yCj4gKwkJCWFuZCBQcm9kdWN0IElEIHZhbHVlcyAoNC1kaWdpdCBoZXgg bnVtYmVycykgYW5kCj4gKwkJCUZsYWdzIGlzIGEgc2V0IG9mIGNoYXJhY3RlcnMsIGVhY2ggY29y cmVzcG9uZGluZwo+ICsJCQl0byBhIGNvbW1vbiB1c2IgY29yZSBxdWlyayBmbGFnIGFzIGZvbGxv d3M6Cj4gKwkJCQlhID0gVVNCX1FVSVJLX1NUUklOR19GRVRDSF8yNTUgKHN0cmluZwo+ICsJCQkJ CWRlc2NyaXB0b3JzIG11c3Qgbm90IGJlIGZldGNoZWQgdXNpbmcKPiArCQkJCQlhIDI1NS1ieXRl IHJlYWQpOwo+ICsJCQkJYiA9IFVTQl9RVUlSS19SRVNFVF9SRVNVTUUgKGRldmljZSBjYW4ndCBy ZXN1bWUKPiArCQkJCQljb3JyZWN0bHkgc28gcmVzZXQgaXQgaW5zdGVhZCk7Cj4gKwkJCQljID0g VVNCX1FVSVJLX05PX1NFVF9JTlRGIChkZXZpY2UgY2FuJ3QgaGFuZGxlCj4gKwkJCQkJU2V0LUlu dGVyZmFjZSByZXF1ZXN0cyk7Cj4gKwkJCQlkID0gVVNCX1FVSVJLX0NPTkZJR19JTlRGX1NUUklO R1MgKGRldmljZSBjYW4ndAo+ICsJCQkJCWhhbmRsZSBpdHMgQ29uZmlndXJhdGlvbiBvciBJbnRl cmZhY2UKPiArCQkJCQlzdHJpbmdzKTsKPiArCQkJCWUgPSBVU0JfUVVJUktfUkVTRVQgKGRldmlj ZSBjYW4ndCBiZSByZXNldAo+ICsJCQkJCShlLmcgbW9ycGggZGV2aWNlcyksIGRvbid0IHVzZSBy ZXNldCk7Cj4gKwkJCQlmID0gVVNCX1FVSVJLX0hPTk9SX0JOVU1JTlRFUkZBQ0VTIChkZXZpY2Ug aGFzCj4gKwkJCQkJbW9yZSBpbnRlcmZhY2UgZGVzY3JpcHRpb25zIHRoYW4gdGhlCj4gKwkJCQkJ Yk51bUludGVyZmFjZXMgY291bnQsIGFuZCBjYW4ndCBoYW5kbGUKPiArCQkJCQl0YWxraW5nIHRv IHRoZXNlIGludGVyZmFjZXMpOwo+ICsJCQkJZyA9IFVTQl9RVUlSS19ERUxBWV9JTklUIChkZXZp Y2UgbmVlZHMgYSBwYXVzZQo+ICsJCQkJCWR1cmluZyBpbml0aWFsaXphdGlvbiwgYWZ0ZXIgd2Ug cmVhZAo+ICsJCQkJCXRoZSBkZXZpY2UgZGVzY3JpcHRvcik7Cj4gKwkJCQloID0gVVNCX1FVSVJL X0xJTkVBUl9VRlJBTUVfSU5UUl9CSU5URVJWQUwgKEZvcgo+ICsJCQkJCWhpZ2ggc3BlZWQgYW5k IHN1cGVyIHNwZWVkIGludGVycnVwdAo+ICsJCQkJCWVuZHBvaW50cywgdGhlIFVTQiAyLjAgYW5k IFVTQiAzLjAgc3BlYwo+ICsJCQkJCXJlcXVpcmUgdGhlIGludGVydmFsIGluIG1pY3JvZnJhbWVz ICgxCj4gKwkJCQkJbWljcm9mcmFtZSA9IDEyNSBtaWNyb3NlY29uZHMpIHRvIGJlCj4gKwkJCQkJ Y2FsY3VsYXRlZCBhcyBpbnRlcnZhbCA9IDIgXgo+ICsJCQkJCShiSW50ZXJ2YWwtMSkuCj4gKwkJ CQkJRGV2aWNlcyB3aXRoIHRoaXMgcXVpcmsgcmVwb3J0IHRoZWlyCj4gKwkJCQkJYkludGVydmFs IGFzIHRoZSByZXN1bHQgb2YgdGhpcwo+ICsJCQkJCWNhbGN1bGF0aW9uIGluc3RlYWQgb2YgdGhl IGV4cG9uZW50Cj4gKwkJCQkJdmFyaWFibGUgdXNlZCBpbiB0aGUgY2FsY3VsYXRpb24pOwo+ICsJ CQkJaSA9IFVTQl9RVUlSS19ERVZJQ0VfUVVBTElGSUVSIChkZXZpY2UgY2FuJ3QKPiArCQkJCQlo YW5kbGUgZGV2aWNlX3F1YWxpZmllciBkZXNjcmlwdG9yCj4gKwkJCQkJcmVxdWVzdHMpOwo+ICsJ CQkJaiA9IFVTQl9RVUlSS19JR05PUkVfUkVNT1RFX1dBS0VVUCAoZGV2aWNlCj4gKwkJCQkJZ2Vu ZXJhdGVzIHNwdXJpb3VzIHdha2V1cCwgaWdub3JlCj4gKwkJCQkJcmVtb3RlIHdha2V1cCBjYXBh YmlsaXR5KTsKPiArCQkJCWsgPSBVU0JfUVVJUktfTk9fTFBNIChkZXZpY2UgY2FuJ3QgaGFuZGxl IExpbmsKPiArCQkJCQlQb3dlciBNYW5hZ2VtZW50KTsKPiArCQkJCWwgPSBVU0JfUVVJUktfTElO RUFSX0ZSQU1FX0lOVFJfQklOVEVSVkFMCj4gKwkJCQkJKERldmljZSByZXBvcnRzIGl0cyBiSW50 ZXJ2YWwgYXMgbGluZWFyCj4gKwkJCQkJZnJhbWVzIGluc3RlYWQgb2YgdGhlIFVTQiAyLjAKPiAr CQkJCQljYWxjdWxhdGlvbik7Cj4gKwkJCQltID0gVVNCX1FVSVJLX0RJU0NPTk5FQ1RfU1VTUEVO RCAoRGV2aWNlIG5lZWRzCj4gKwkJCQkJdG8gYmUgZGlzY29ubmVjdGVkIGJlZm9yZSBzdXNwZW5k IHRvCj4gKwkJCQkJcHJldmVudCBzcHVyaW91cyB3YWtldXApCj4gKwkJCUV4YW1wbGU6IHF1aXJr cz0wNzgxOjU1ODA6YmssMGE1Yzo1ODM0Omdpago+ICsKPiAgCXVzYmhpZC5tb3VzZXBvbGw9Cj4g IAkJCVtVU0JISURdIFRoZSBpbnRlcnZhbCB3aGljaCBtaWNlIGFyZSB0byBiZSBwb2xsZWQgYXQu Cj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jb3JlL3F1aXJrcy5jIGIvZHJpdmVycy91 c2IvY29yZS9xdWlya3MuYwo+IGluZGV4IGYxZGJhYjZmNzk4Zi4uNTQ3MTc2NTc2NWJlIDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvcXVpcmtzLmMKPiArKysgYi9kcml2ZXJzL3VzYi9j b3JlL3F1aXJrcy5jCj4gQEAgLTExLDYgKzExLDEyIEBACj4gICNpbmNsdWRlIDxsaW51eC91c2Iv aGNkLmg+Cj4gICNpbmNsdWRlICJ1c2IuaCIKPiAgCj4gKy8qIFF1aXJrcyBzcGVjaWZpZWQgYXQg bW9kdWxlIGxvYWQgdGltZSAqLwo+ICtzdGF0aWMgY2hhciAqcXVpcmtzX3BhcmFtW01BWF9VU0Jf Qk9PVF9RVUlSS1NdOwo+ICttb2R1bGVfcGFyYW1fYXJyYXlfbmFtZWQocXVpcmtzLCBxdWlya3Nf cGFyYW0sIGNoYXJwLCBOVUxMLCAwNDQ0KTsKClNvIHlvdSBjYW4ndCBtb2RpZnkgdGhpcyBhdCBy dW50aW1lPyAgV2h5IG5vdD8KCj4gK01PRFVMRV9QQVJNX0RFU0MocXVpcmtzLCAiQWRkL21vZGlm eSBVU0IgcXVpcmtzIGJ5IHNwZWNpZnlpbmciCj4gKwkJCSAicXVpcmtzPXZlbmRvcklEOnByb2R1 Y3RJRDpxdWlya3MiKTsKCkRvbid0IGJyZWFrIHN0cmluZ3Mgb3ZlciBtdWx0aXBsZSBsaW5lcy4K Cj4gKwo+ICAvKiBMaXN0cyBvZiBxdWlya3kgVVNCIGRldmljZXMsIHNwbGl0IGluIGRldmljZSBx dWlya3MgYW5kIGludGVyZmFjZSBxdWlya3MuCj4gICAqIERldmljZSBxdWlya3MgYXJlIGFwcGxp ZWQgYXQgdGhlIHZlcnkgYmVnaW5uaW5nIG9mIHRoZSBlbnVtZXJhdGlvbiBwcm9jZXNzLAo+ICAg KiByaWdodCBhZnRlciByZWFkaW5nIHRoZSBkZXZpY2UgZGVzY3JpcHRvci4gVGhleSBjYW4gdGh1 cyBvbmx5IG1hdGNoIG9uIGRldmljZQo+IEBAIC0zMTAsOCArMzE2LDggQEAgc3RhdGljIGludCB1 c2JfYW1kX3Jlc3VtZV9xdWlyayhzdHJ1Y3QgdXNiX2RldmljZSAqdWRldikKPiAgCXJldHVybiAw Owo+ICB9Cj4gIAo+IC1zdGF0aWMgdTMyIF9fdXNiX2RldGVjdF9xdWlya3Moc3RydWN0IHVzYl9k ZXZpY2UgKnVkZXYsCj4gLQkJCSAgICAgICBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCAqaWQp Cj4gK3N0YXRpYyB1MzIgdXNiX2RldGVjdF9zdGF0aWNfcXVpcmtzKHN0cnVjdCB1c2JfZGV2aWNl ICp1ZGV2LAo+ICsJCQkJICAgIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCkKPiAgewo+ ICAJdTMyIHF1aXJrcyA9IDA7Cj4gIAo+IEBAIC0zMjksMjMgKzMzNSwxMDUgQEAgc3RhdGljIHUz MiBfX3VzYl9kZXRlY3RfcXVpcmtzKHN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2LAo+ICAJcmV0dXJu IHF1aXJrczsKPiAgfQo+ICAKPiArc3RhdGljIHUzMiB1c2JfZGV0ZWN0X2R5bmFtaWNfcXVpcmtz KHN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2KQo+ICt7Cj4gKwl1MTYgZGV2X3ZpZCA9IGxlMTZfdG9f Y3B1KHVkZXYtPmRlc2NyaXB0b3IuaWRWZW5kb3IpOwo+ICsJdTE2IGRldl9waWQgPSBsZTE2X3Rv X2NwdSh1ZGV2LT5kZXNjcmlwdG9yLmlkUHJvZHVjdCk7Cj4gKwl1MTYgcXVpcmtfdmlkLCBxdWly a19waWQ7Cj4gKwljaGFyIHF1aXJrc1szMl07Cj4gKwljaGFyICpwOwo+ICsJdTMyIGZsYWdzID0g MDsKPiArCWludCBuLCBtOwo+ICsKPiArCWZvciAobiA9IDA7IG4gPCBNQVhfVVNCX0JPT1RfUVVJ UktTICYmIHF1aXJrc19wYXJhbVtuXTsgbisrKSB7Cj4gKwkJbSA9IHNzY2FuZihxdWlya3NfcGFy YW1bbl0sICIlaHg6JWh4OiVzIiwKPiArCQkJICAgJnF1aXJrX3ZpZCwgJnF1aXJrX3BpZCwgcXVp cmtzKTsKPiArCQlpZiAobSAhPSAzKQo+ICsJCQlwcl93YXJuKCJDb3VsZCBub3QgcGFyc2UgVVNC IHF1aXJrIG1vZHVsZSBwYXJhbSAlc1xuIiwKPiArCQkJCXF1aXJrc19wYXJhbVtuXSk7CgpkZXZf d2FybigpLgoKQWxzbywgeW91IGFyZSBnb2luZyB0byBjb21wbGFpbiBhYm91dCB0aGUgaW5hYmls aXR5IHRvIHBhcnNlIHRoZSBxdWlya3MKZm9yIF9FVkVSWV8gVVNCIGRldmljZSBpbiB0aGUgc3lz dGVtPyAgVGhhdCBmZWVscyByZWFsbHkgd3JvbmcuICBQYXJzZQppdCBvbmNlLCBhbmQgdGhlbiB1 c2UgdGhlIHBhcnNlZCB0YWJsZSB3aGVuIG1hdGNoaW5nIHRoaW5ncyB1cC4gIERvbid0CnBhcnNl IHRoZSBzdHJpbmcgZWFjaCBhbmQgZXZlcnkgdGltZSBhIGRldmljZSBpcyBhZGRlZCwgdGhhdCdz IGEKaG9ycmlibGUgd2FzdGUgb2YgdGltZSAobm90IGxpa2UgVVNCIGVudW1lcmF0aW9uIGlzIGZh c3QsIGJ1dCByZWFsbHksCmxldCdzIG5vdCBtYWtlIGl0IHdvcnNlIGZvciBubyByZWFzb24uKQoK PiArCj4gKwkJaWYgKHF1aXJrX3ZpZCA9PSBkZXZfdmlkICYmIHF1aXJrX3BpZCA9PSBkZXZfcGlk KQo+ICsJCQlicmVhazsKPiArCX0KPiArCWlmIChuID09IE1BWF9VU0JfQk9PVF9RVUlSS1MgfHwg IXF1aXJrc19wYXJhbVtuXSkKPiArCQlyZXR1cm4gMDsKPiArCj4gKwlwID0gcXVpcmtzOwo+ICsK PiArCS8qIENvbGxlY3QgdGhlIGZsYWdzICovCj4gKwlmb3IgKDsgKnA7IHArKykgewo+ICsJCXN3 aXRjaCAodG9sb3dlcigqcCkpIHsKPiArCQljYXNlICdhJzoKPiArCQkJZmxhZ3MgfD0gVVNCX1FV SVJLX1NUUklOR19GRVRDSF8yNTU7Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgJ2InOgo+ICsJCQlm bGFncyB8PSBVU0JfUVVJUktfUkVTRVRfUkVTVU1FOwo+ICsJCQlicmVhazsKPiArCQljYXNlICdj JzoKPiArCQkJZmxhZ3MgfD0gVVNCX1FVSVJLX05PX1NFVF9JTlRGOwo+ICsJCQlicmVhazsKPiAr CQljYXNlICdkJzoKPiArCQkJZmxhZ3MgfD0gVVNCX1FVSVJLX0NPTkZJR19JTlRGX1NUUklOR1M7 Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgJ2UnOgo+ICsJCQlmbGFncyB8PSBVU0JfUVVJUktfUkVT RVQ7Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgJ2YnOgo+ICsJCQlmbGFncyB8PSBVU0JfUVVJUktf SE9OT1JfQk5VTUlOVEVSRkFDRVM7Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgJ2cnOgo+ICsJCQlm bGFncyB8PSBVU0JfUVVJUktfREVMQVlfSU5JVDsKPiArCQkJYnJlYWs7Cj4gKwkJY2FzZSAnaCc6 Cj4gKwkJCWZsYWdzIHw9IFVTQl9RVUlSS19MSU5FQVJfVUZSQU1FX0lOVFJfQklOVEVSVkFMOwo+ ICsJCQlicmVhazsKPiArCQljYXNlICdpJzoKPiArCQkJZmxhZ3MgfD0gVVNCX1FVSVJLX0RFVklD RV9RVUFMSUZJRVI7Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgJ2onOgo+ICsJCQlmbGFncyB8PSBV U0JfUVVJUktfSUdOT1JFX1JFTU9URV9XQUtFVVA7Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgJ2sn Ogo+ICsJCQlmbGFncyB8PSBVU0JfUVVJUktfTk9fTFBNOwo+ICsJCQlicmVhazsKPiArCQljYXNl ICdsJzoKPiArCQkJZmxhZ3MgfD0gVVNCX1FVSVJLX0xJTkVBUl9GUkFNRV9JTlRSX0JJTlRFUlZB TDsKPiArCQkJYnJlYWs7Cj4gKwkJY2FzZSAnbSc6Cj4gKwkJCWZsYWdzIHw9IFVTQl9RVUlSS19E SVNDT05ORUNUX1NVU1BFTkQ7Cj4gKwkJCWJyZWFrOwo+ICsJCS8qIElnbm9yZSB1bnJlY29nbml6 ZWQgZmxhZyBjaGFyYWN0ZXJzICovCj4gKwkJfQo+ICsJfQo+ICsKPiArCXJldHVybiBmbGFnczsK PiArfQo+ICsKPiAgLyoKPiAgICogRGV0ZWN0IGFueSBxdWlya3MgdGhlIGRldmljZSBoYXMsIGFu ZCBkbyBhbnkgaG91c2VrZWVwaW5nIGZvciBpdCBpZiBuZWVkZWQuCj4gICAqLwo+ICB2b2lkIHVz Yl9kZXRlY3RfcXVpcmtzKHN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2KQo+ICB7Cj4gLQl1ZGV2LT5x dWlya3MgPSBfX3VzYl9kZXRlY3RfcXVpcmtzKHVkZXYsIHVzYl9xdWlya19saXN0KTsKPiArCXVk ZXYtPnF1aXJrcyA9IHVzYl9kZXRlY3RfZHluYW1pY19xdWlya3ModWRldik7Cj4gKwo+ICsJaWYg KHVkZXYtPnF1aXJrcykgewo+ICsJCWRldl9kYmcoJnVkZXYtPmRldiwgIkR5bmFtaWMgVVNCIHF1 aXJrcyBmb3IgdGhpcyBkZXZpY2U6ICV4XG4iLAo+ICsJCQl1ZGV2LT5xdWlya3MpOwo+ICsJCXJl dHVybjsKPiArCX0KPiArCj4gKwl1ZGV2LT5xdWlya3MgPSB1c2JfZGV0ZWN0X3N0YXRpY19xdWly a3ModWRldiwgdXNiX3F1aXJrX2xpc3QpOwoKRGlkIHlvdSBqdXN0IG92ZXJ3cml0ZSB0aGUgZHlu YW1pYyB3aXRoIHRoZSBzdGF0aWMgb25lcz8gIEl0IGZlZWxzIGxpa2UKeW91IGp1c3QgZGlkIDoo Cgo+IC0tLSBhL2luY2x1ZGUvbGludXgvdXNiL3F1aXJrcy5oCj4gKysrIGIvaW5jbHVkZS9saW51 eC91c2IvcXVpcmtzLmgKPiBAQCAtOCw2ICs4LDggQEAKPiAgI2lmbmRlZiBfX0xJTlVYX1VTQl9R VUlSS1NfSAo+ICAjZGVmaW5lIF9fTElOVVhfVVNCX1FVSVJLU19ICj4gIAo+ICsjZGVmaW5lIE1B WF9VU0JfQk9PVF9RVUlSS1MgNAoKV2h5IDQ/ICBBbmQgd2h5IGluIHRoaXMgLmggZmlsZT8KCkFs c28sIE9saXZlcidzIHJlcXVlc3QgaXMgZ29vZCwgeG9yIGlzIGEgbmljZSB3YXkgdG8gZG8gdGhp bmdzIGlmIGF0IGFsbApwb3NzaWJsZS4KCnRoYW5rcywKCmdyZWcgay1oCi0tLQpUbyB1bnN1YnNj cmliZSBmcm9tIHRoaXMgbGlzdDogc2VuZCB0aGUgbGluZSAidW5zdWJzY3JpYmUgbGludXgtdXNi IiBpbgp0aGUgYm9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZwpN b3JlIG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9tby1p bmZvLmh0bWwK