From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-14.6 required=3.0 tests=DKIMWL_WL_MED,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D06A7C282C5 for ; Thu, 24 Jan 2019 20:06:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 84FE921855 for ; Thu, 24 Jan 2019 20:06:19 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="qm9Oxp+Y" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731209AbfAXUGR (ORCPT ); Thu, 24 Jan 2019 15:06:17 -0500 Received: from mail-lf1-f67.google.com ([209.85.167.67]:46307 "EHLO mail-lf1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729034AbfAXUGP (ORCPT ); Thu, 24 Jan 2019 15:06:15 -0500 Received: by mail-lf1-f67.google.com with SMTP id f5so5225217lfc.13 for ; Thu, 24 Jan 2019 12:06:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=I44R5by7utG/5Cuuk2f4UjloCvOrI5Cx4uHif7F31LM=; b=qm9Oxp+YgeCHc1SPFddkkVXbLPcQA58VtGcIQX69gDDtCze6TffAljuOoLBpIWn39m L+vDe15nPgYpyUBDmzofGFpEfHWmhIfjvi/N+qzmFEbcwWkXPtOC2AKKrviBu6TIRxhs 8kikYHtFba+h+efHg1qZHwQR1qEOYEDxnI1QrqEoLv4Fyx7wgi9ENX9QcoY1+XXPAoNc fakQo59z59q6hNznEDPQvlFSn7iB7KIhQlYEezhQ9LV4m7ozdXXe27w6WhHq7tpi3KJK zU9Wwrt7jWH+v1q9uvH3pT7XGqVMSpzh4uor0Aqp43z7PYFGIJ2SWxF2pYC18dgaciCi c+wQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=I44R5by7utG/5Cuuk2f4UjloCvOrI5Cx4uHif7F31LM=; b=ChNgeCADJqrhOBTe2U4RxHOp2vJGdYa2DcUQ1Dztcc2OaAdzKaZmYpZawAialG0QVV r4ppecL6QMp+mz+Z+wCKeD3/7OoGHTbXbObPqcckKKfyFNXoc/ecahCZov3Y8kmw35xq 8Z9VVsx7l7BL6myBTI5lUF1fEXg1h8sYhHsF5MdpTBEMcJIbJ0wV8O/umSBrn0/EvXz8 7x8fM6oZplJck/RbHQpUe2xZ0WdJ4iH/RjXZo9oFfcKfStl0I3JbZ05lyaMwfjXvL2lm a8926l5q9eREn7BIOOjHNWiXZ7EMUSKVcbQ6PJRUwZx4Nf0DlC7nXwYreNfmKSaE1vmP dOtg== X-Gm-Message-State: AJcUukc7+0Wuo8m0CbWOCL+sKQB8WSHuXikywCf4AojM15aqF7TcUL5s bTvtF2HH0W1PsPZ5JUjcOjw25BfeuzIM1IsKsU3V0Q== X-Google-Smtp-Source: ALg8bN79xzF84mpqT9PowT9KxU6sSIHpBORgXfYF2wq0WumkJp46k8uDupCVefo8QOvu1yfsK2Ca0BciK0uEtWYLY3Q= X-Received: by 2002:a19:2906:: with SMTP id p6mr6259390lfp.17.1548360372533; Thu, 24 Jan 2019 12:06:12 -0800 (PST) MIME-Version: 1.0 References: <20181117010748.24347-1-rajatja@google.com> <20190123205725.239661-1-rajatja@google.com> <20190123205725.239661-4-rajatja@google.com> <7A112914-5B41-4D26-807B-021B7AC907C6@holtmann.org> In-Reply-To: <7A112914-5B41-4D26-807B-021B7AC907C6@holtmann.org> From: Rajat Jain Date: Thu, 24 Jan 2019 12:05:35 -0800 Message-ID: Subject: Re: [PATCH v5 4/4] Bluetooth: btusb: Use the cmd_timeout method to reset the Intel BT chip To: Marcel Holtmann Cc: Johan Hedberg , Greg Kroah-Hartman , "David S. Miller" , Dmitry Torokhov , Alex Hung , Bluez mailing list , Linux Kernel Mailing List , linux-usb@vger.kernel.org, netdev , Rajat Jain , Dmitry Torokhov , Raghuram Hegde , chethan.tumkur.narayan@intel.com, "Ghorai, Sukumar" Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, Jan 24, 2019 at 1:46 AM Marcel Holtmann wrote= : > > Hi Rajat, > > > If the platform provides it, use the reset gpio to reset the Intel BT > > chip, as part of cmd_timeout handling. This has been found helpful on > > Intel bluetooth controllers where the firmware gets stuck and the only > > way out is a hard reset pin provided by the platform. > > > > Signed-off-by: Rajat Jain > > --- > > v5: Rename the hook to cmd_timeout, and wait for 5 timeouts before > > resetting the device. > > v4: Use data->flags instead of clearing the quirk in btusb_hw_reset() > > v3: Better error handling for gpiod_get_optional() > > v2: Handle the EPROBE_DEFER case. > > > > drivers/bluetooth/btusb.c | 54 +++++++++++++++++++++++++++++++++++++++ > > 1 file changed, 54 insertions(+) > > > > diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c > > index 4761499db9ee..8949ea30a1bc 100644 > > --- a/drivers/bluetooth/btusb.c > > +++ b/drivers/bluetooth/btusb.c > > @@ -29,6 +29,7 @@ > > #include > > #include > > #include > > +#include > > #include > > > > #include > > @@ -439,6 +440,7 @@ static const struct dmi_system_id btusb_needs_reset= _resume_table[] =3D { > > #define BTUSB_BOOTING 9 > > #define BTUSB_DIAG_RUNNING 10 > > #define BTUSB_OOB_WAKE_ENABLED 11 > > +#define BTUSB_HW_RESET_ACTIVE 12 > > > > struct btusb_data { > > struct hci_dev *hdev; > > @@ -476,6 +478,8 @@ struct btusb_data { > > struct usb_endpoint_descriptor *diag_tx_ep; > > struct usb_endpoint_descriptor *diag_rx_ep; > > > > + struct gpio_desc *reset_gpio; > > + > > __u8 cmdreq_type; > > __u8 cmdreq; > > > > @@ -489,8 +493,39 @@ struct btusb_data { > > int (*setup_on_usb)(struct hci_dev *hdev); > > > > int oob_wake_irq; /* irq for out-of-band wake-on-bt */ > > + unsigned num_cmd_timeout; > > Make this cmd_timeout_count or cmd_timeout_cnt. Sure, will do. > > > }; > > > > + > > +static void btusb_intel_cmd_timeout(struct hci_dev *hdev, > > + struct hci_command_hdr *cmd) > > +{ > > + struct btusb_data *data =3D hci_get_drvdata(hdev); > > + struct gpio_desc *reset_gpio =3D data->reset_gpio; > > + > > + bt_dev_err(hdev, "btusb num_cmd_timeout =3D %u", ++data->num_cmd_= timeout); > > I would prefer if you don=E2=80=99t do the increase in the bt_dev_err(). = And you can also scrap the =E2=80=9Cbtusb =E2=80=9C prefix here since that = is all present via bt_dev_err if really needed at some point. Actually I qu= estion the whole bt_dev_err here in the first place since the core will put= our the error. You are just repeating it here. will do. > > > + > > + if (data->num_cmd_timeout < 5) > > + return; > > So I would propose to do just this: > > if (++data->cmd_timeout_count < 5) > return; will do. > > > + > > + /* > > + * Toggle the hard reset line if the platform provides one. The r= eset > > + * is going to yank the device off the USB and then replug. So do= ing > > + * once is enough. The cleanup is handled correctly on the way ou= t > > + * (standard USB disconnect), and the new device is detected clea= nly > > + * and bound to the driver again like it should be. > > + */ > > + if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) { > > + bt_dev_err(hdev, "last reset failed? Not resetting again"= ); > > + return; > > + } > > + > > + bt_dev_err(hdev, "Initiating HW reset via gpio"); > > + gpiod_set_value(reset_gpio, 1); > > + mdelay(100); > > + gpiod_set_value(reset_gpio, 0); > > +} > > + > > static inline void btusb_free_frags(struct btusb_data *data) > > { > > unsigned long flags; > > @@ -2915,6 +2950,7 @@ static int btusb_probe(struct usb_interface *intf= , > > const struct usb_device_id *id) > > { > > struct usb_endpoint_descriptor *ep_desc; > > + struct gpio_desc *reset_gpio; > > struct btusb_data *data; > > struct hci_dev *hdev; > > unsigned ifnum_base; > > @@ -3028,6 +3064,15 @@ static int btusb_probe(struct usb_interface *int= f, > > > > SET_HCIDEV_DEV(hdev, &intf->dev); > > > > + reset_gpio =3D gpiod_get_optional(&data->udev->dev, "reset", > > + GPIOD_OUT_LOW); > > Any reason to not use the devm_gpiod_get_optional() version here? Yes, we're using the &data->udev->dev device (parent of the USB interface) to fetch the gpio, so if we use the devm_* variant, the gpio resource will not be freed immediately if the btusb_probe fails. I'll add a comment in the code to make this more clear. > > > + if (IS_ERR(reset_gpio)) { > > + err =3D PTR_ERR(reset_gpio); > > + goto out_free_dev; > > + } else if (reset_gpio) { > > + data->reset_gpio =3D reset_gpio; > > + } > > + > > hdev->open =3D btusb_open; > > hdev->close =3D btusb_close; > > hdev->flush =3D btusb_flush; > > @@ -3085,6 +3130,8 @@ static int btusb_probe(struct usb_interface *intf= , > > set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks)= ; > > set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks); > > set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks); > > + if (data->reset_gpio) > > + hdev->cmd_timeout =3D btusb_intel_cmd_timeout; > > } > > Always assign hdev->cmd_timeout =3D btusb_intel_cmd_timeout and put it af= ter btintel_set_bdaddr and before the quirks. will do. > > Move the if (data->reset_gpio) check into btusb_intel_cmd_timeout() funct= ion and print a warning that no reset GPIO is present. There'll be Intel platforms already out there which will obviously not have the reset pin described in the ACPI as of today. So I'm not sure if it is right for all of them to start complaining about a missing "reset gpio" in case of timeout post this change. Thus I would prefer to assign hdev->cmd_timeout only if ACPI does provide a gpio i.e. newer platforms that want to support this feature. Thoughts? Thanks, Rajat > > > > > if (id->driver_info & BTUSB_INTEL_NEW) { > > @@ -3097,6 +3144,8 @@ static int btusb_probe(struct usb_interface *intf= , > > set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks)= ; > > set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks); > > set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks); > > + if (data->reset_gpio) > > + hdev->cmd_timeout =3D btusb_intel_cmd_timeout; > > } > > > > if (id->driver_info & BTUSB_MARVELL) > > @@ -3226,6 +3275,8 @@ static int btusb_probe(struct usb_interface *intf= , > > return 0; > > > > out_free_dev: > > + if (data->reset_gpio) > > + gpiod_put(data->reset_gpio); > > hci_free_dev(hdev); > > return err; > > } > > @@ -3269,6 +3320,9 @@ static void btusb_disconnect(struct usb_interface= *intf) > > if (data->oob_wake_irq) > > device_init_wakeup(&data->udev->dev, false); > > > > + if (data->reset_gpio) > > + gpiod_put(data->reset_gpio); > > + > > hci_free_dev(hdev); > > } > > Regards > > Marcel > 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: [v5,4/4] Bluetooth: btusb: Use the cmd_timeout method to reset the Intel BT chip From: Rajat Jain Message-Id: Date: Thu, 24 Jan 2019 12:05:35 -0800 To: Marcel Holtmann Cc: Johan Hedberg , Greg Kroah-Hartman , "David S. Miller" , Dmitry Torokhov , Alex Hung , Bluez mailing list , Linux Kernel Mailing List , linux-usb@vger.kernel.org, netdev , Rajat Jain , Dmitry Torokhov , Raghuram Hegde , chethan.tumkur.narayan@intel.com, "Ghorai, Sukumar" List-ID: T24gVGh1LCBKYW4gMjQsIDIwMTkgYXQgMTo0NiBBTSBNYXJjZWwgSG9sdG1hbm4gPG1hcmNlbEBo b2x0bWFubi5vcmc+IHdyb3RlOgo+Cj4gSGkgUmFqYXQsCj4KPiA+IElmIHRoZSBwbGF0Zm9ybSBw cm92aWRlcyBpdCwgdXNlIHRoZSByZXNldCBncGlvIHRvIHJlc2V0IHRoZSBJbnRlbCBCVAo+ID4g Y2hpcCwgYXMgcGFydCBvZiBjbWRfdGltZW91dCBoYW5kbGluZy4gVGhpcyBoYXMgYmVlbiBmb3Vu ZCBoZWxwZnVsIG9uCj4gPiBJbnRlbCBibHVldG9vdGggY29udHJvbGxlcnMgd2hlcmUgdGhlIGZp cm13YXJlIGdldHMgc3R1Y2sgYW5kIHRoZSBvbmx5Cj4gPiB3YXkgb3V0IGlzIGEgaGFyZCByZXNl dCBwaW4gcHJvdmlkZWQgYnkgdGhlIHBsYXRmb3JtLgo+ID4KPiA+IFNpZ25lZC1vZmYtYnk6IFJh amF0IEphaW4gPHJhamF0amFAZ29vZ2xlLmNvbT4KPiA+IC0tLQo+ID4gdjU6IFJlbmFtZSB0aGUg aG9vayB0byBjbWRfdGltZW91dCwgYW5kIHdhaXQgZm9yIDUgdGltZW91dHMgYmVmb3JlCj4gPiAg ICByZXNldHRpbmcgdGhlIGRldmljZS4KPiA+IHY0OiBVc2UgZGF0YS0+ZmxhZ3MgaW5zdGVhZCBv ZiBjbGVhcmluZyB0aGUgcXVpcmsgaW4gYnR1c2JfaHdfcmVzZXQoKQo+ID4gdjM6IEJldHRlciBl cnJvciBoYW5kbGluZyBmb3IgZ3Bpb2RfZ2V0X29wdGlvbmFsKCkKPiA+IHYyOiBIYW5kbGUgdGhl IEVQUk9CRV9ERUZFUiBjYXNlLgo+ID4KPiA+IGRyaXZlcnMvYmx1ZXRvb3RoL2J0dXNiLmMgfCA1 NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiA+IDEgZmlsZSBjaGFu Z2VkLCA1NCBpbnNlcnRpb25zKCspCj4gPgo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmx1ZXRv b3RoL2J0dXNiLmMgYi9kcml2ZXJzL2JsdWV0b290aC9idHVzYi5jCj4gPiBpbmRleCA0NzYxNDk5 ZGI5ZWUuLjg5NDllYTMwYTFiYyAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvYmx1ZXRvb3RoL2J0 dXNiLmMKPiA+ICsrKyBiL2RyaXZlcnMvYmx1ZXRvb3RoL2J0dXNiLmMKPiA+IEBAIC0yOSw2ICsy OSw3IEBACj4gPiAjaW5jbHVkZSA8bGludXgvb2ZfZGV2aWNlLmg+Cj4gPiAjaW5jbHVkZSA8bGlu dXgvb2ZfaXJxLmg+Cj4gPiAjaW5jbHVkZSA8bGludXgvc3VzcGVuZC5oPgo+ID4gKyNpbmNsdWRl IDxsaW51eC9ncGlvL2NvbnN1bWVyLmg+Cj4gPiAjaW5jbHVkZSA8YXNtL3VuYWxpZ25lZC5oPgo+ ID4KPiA+ICNpbmNsdWRlIDxuZXQvYmx1ZXRvb3RoL2JsdWV0b290aC5oPgo+ID4gQEAgLTQzOSw2 ICs0NDAsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRtaV9zeXN0ZW1faWQgYnR1c2JfbmVlZHNf cmVzZXRfcmVzdW1lX3RhYmxlW10gPSB7Cj4gPiAjZGVmaW5lIEJUVVNCX0JPT1RJTkcgICAgICAg ICA5Cj4gPiAjZGVmaW5lIEJUVVNCX0RJQUdfUlVOTklORyAgICAxMAo+ID4gI2RlZmluZSBCVFVT Ql9PT0JfV0FLRV9FTkFCTEVEICAgICAgICAxMQo+ID4gKyNkZWZpbmUgQlRVU0JfSFdfUkVTRVRf QUNUSVZFICAgICAgICAxMgo+ID4KPiA+IHN0cnVjdCBidHVzYl9kYXRhIHsKPiA+ICAgICAgIHN0 cnVjdCBoY2lfZGV2ICAgICAgICpoZGV2Owo+ID4gQEAgLTQ3Niw2ICs0NzgsOCBAQCBzdHJ1Y3Qg YnR1c2JfZGF0YSB7Cj4gPiAgICAgICBzdHJ1Y3QgdXNiX2VuZHBvaW50X2Rlc2NyaXB0b3IgKmRp YWdfdHhfZXA7Cj4gPiAgICAgICBzdHJ1Y3QgdXNiX2VuZHBvaW50X2Rlc2NyaXB0b3IgKmRpYWdf cnhfZXA7Cj4gPgo+ID4gKyAgICAgc3RydWN0IGdwaW9fZGVzYyAqcmVzZXRfZ3BpbzsKPiA+ICsK PiA+ICAgICAgIF9fdTggY21kcmVxX3R5cGU7Cj4gPiAgICAgICBfX3U4IGNtZHJlcTsKPiA+Cj4g PiBAQCAtNDg5LDggKzQ5MywzOSBAQCBzdHJ1Y3QgYnR1c2JfZGF0YSB7Cj4gPiAgICAgICBpbnQg KCpzZXR1cF9vbl91c2IpKHN0cnVjdCBoY2lfZGV2ICpoZGV2KTsKPiA+Cj4gPiAgICAgICBpbnQg b29iX3dha2VfaXJxOyAgIC8qIGlycSBmb3Igb3V0LW9mLWJhbmQgd2FrZS1vbi1idCAqLwo+ID4g KyAgICAgdW5zaWduZWQgbnVtX2NtZF90aW1lb3V0Owo+Cj4gTWFrZSB0aGlzIGNtZF90aW1lb3V0 X2NvdW50IG9yIGNtZF90aW1lb3V0X2NudC4KClN1cmUsIHdpbGwgZG8uCgo+Cj4gPiB9Owo+ID4K PiA+ICsKPiA+ICtzdGF0aWMgdm9pZCBidHVzYl9pbnRlbF9jbWRfdGltZW91dChzdHJ1Y3QgaGNp X2RldiAqaGRldiwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qg aGNpX2NvbW1hbmRfaGRyICpjbWQpCj4gPiArewo+ID4gKyAgICAgc3RydWN0IGJ0dXNiX2RhdGEg KmRhdGEgPSBoY2lfZ2V0X2RydmRhdGEoaGRldik7Cj4gPiArICAgICBzdHJ1Y3QgZ3Bpb19kZXNj ICpyZXNldF9ncGlvID0gZGF0YS0+cmVzZXRfZ3BpbzsKPiA+ICsKPiA+ICsgICAgIGJ0X2Rldl9l cnIoaGRldiwgImJ0dXNiIG51bV9jbWRfdGltZW91dCA9ICV1IiwgKytkYXRhLT5udW1fY21kX3Rp bWVvdXQpOwo+Cj4gSSB3b3VsZCBwcmVmZXIgaWYgeW91IGRvbuKAmXQgZG8gdGhlIGluY3JlYXNl IGluIHRoZSBidF9kZXZfZXJyKCkuIEFuZCB5b3UgY2FuIGFsc28gc2NyYXAgdGhlIOKAnGJ0dXNi IOKAnCBwcmVmaXggaGVyZSBzaW5jZSB0aGF0IGlzIGFsbCBwcmVzZW50IHZpYSBidF9kZXZfZXJy IGlmIHJlYWxseSBuZWVkZWQgYXQgc29tZSBwb2ludC4gQWN0dWFsbHkgSSBxdWVzdGlvbiB0aGUg d2hvbGUgYnRfZGV2X2VyciBoZXJlIGluIHRoZSBmaXJzdCBwbGFjZSBzaW5jZSB0aGUgY29yZSB3 aWxsIHB1dCBvdXIgdGhlIGVycm9yLiBZb3UgYXJlIGp1c3QgcmVwZWF0aW5nIGl0IGhlcmUuCgp3 aWxsIGRvLgoKPgo+ID4gKwo+ID4gKyAgICAgaWYgKGRhdGEtPm51bV9jbWRfdGltZW91dCA8IDUp Cj4gPiArICAgICAgICAgICAgIHJldHVybjsKPgo+IFNvIEkgd291bGQgcHJvcG9zZSB0byBkbyBq dXN0IHRoaXM6Cj4KPiAgICAgICAgIGlmICgrK2RhdGEtPmNtZF90aW1lb3V0X2NvdW50IDwgNSkK PiAgICAgICAgICAgICAgICAgcmV0dXJuOwoKd2lsbCBkby4KCgo+Cj4gPiArCj4gPiArICAgICAv Kgo+ID4gKyAgICAgICogVG9nZ2xlIHRoZSBoYXJkIHJlc2V0IGxpbmUgaWYgdGhlIHBsYXRmb3Jt IHByb3ZpZGVzIG9uZS4gVGhlIHJlc2V0Cj4gPiArICAgICAgKiBpcyBnb2luZyB0byB5YW5rIHRo ZSBkZXZpY2Ugb2ZmIHRoZSBVU0IgYW5kIHRoZW4gcmVwbHVnLiBTbyBkb2luZwo+ID4gKyAgICAg ICogb25jZSBpcyBlbm91Z2guIFRoZSBjbGVhbnVwIGlzIGhhbmRsZWQgY29ycmVjdGx5IG9uIHRo ZSB3YXkgb3V0Cj4gPiArICAgICAgKiAoc3RhbmRhcmQgVVNCIGRpc2Nvbm5lY3QpLCBhbmQgdGhl IG5ldyBkZXZpY2UgaXMgZGV0ZWN0ZWQgY2xlYW5seQo+ID4gKyAgICAgICogYW5kIGJvdW5kIHRv IHRoZSBkcml2ZXIgYWdhaW4gbGlrZSBpdCBzaG91bGQgYmUuCj4gPiArICAgICAgKi8KPiA+ICsg ICAgIGlmICh0ZXN0X2FuZF9zZXRfYml0KEJUVVNCX0hXX1JFU0VUX0FDVElWRSwgJmRhdGEtPmZs YWdzKSkgewo+ID4gKyAgICAgICAgICAgICBidF9kZXZfZXJyKGhkZXYsICJsYXN0IHJlc2V0IGZh aWxlZD8gTm90IHJlc2V0dGluZyBhZ2FpbiIpOwo+ID4gKyAgICAgICAgICAgICByZXR1cm47Cj4g PiArICAgICB9Cj4gPiArCj4gPiArICAgICBidF9kZXZfZXJyKGhkZXYsICJJbml0aWF0aW5nIEhX IHJlc2V0IHZpYSBncGlvIik7Cj4gPiArICAgICBncGlvZF9zZXRfdmFsdWUocmVzZXRfZ3Bpbywg MSk7Cj4gPiArICAgICBtZGVsYXkoMTAwKTsKPiA+ICsgICAgIGdwaW9kX3NldF92YWx1ZShyZXNl dF9ncGlvLCAwKTsKPiA+ICt9Cj4gPiArCj4gPiBzdGF0aWMgaW5saW5lIHZvaWQgYnR1c2JfZnJl ZV9mcmFncyhzdHJ1Y3QgYnR1c2JfZGF0YSAqZGF0YSkKPiA+IHsKPiA+ICAgICAgIHVuc2lnbmVk IGxvbmcgZmxhZ3M7Cj4gPiBAQCAtMjkxNSw2ICsyOTUwLDcgQEAgc3RhdGljIGludCBidHVzYl9w cm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZiwKPiA+ICAgICAgICAgICAgICAgICAgICAg IGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCkKPiA+IHsKPiA+ICAgICAgIHN0cnVjdCB1 c2JfZW5kcG9pbnRfZGVzY3JpcHRvciAqZXBfZGVzYzsKPiA+ICsgICAgIHN0cnVjdCBncGlvX2Rl c2MgKnJlc2V0X2dwaW87Cj4gPiAgICAgICBzdHJ1Y3QgYnR1c2JfZGF0YSAqZGF0YTsKPiA+ICAg ICAgIHN0cnVjdCBoY2lfZGV2ICpoZGV2Owo+ID4gICAgICAgdW5zaWduZWQgaWZudW1fYmFzZTsK PiA+IEBAIC0zMDI4LDYgKzMwNjQsMTUgQEAgc3RhdGljIGludCBidHVzYl9wcm9iZShzdHJ1Y3Qg dXNiX2ludGVyZmFjZSAqaW50ZiwKPiA+Cj4gPiAgICAgICBTRVRfSENJREVWX0RFVihoZGV2LCAm aW50Zi0+ZGV2KTsKPiA+Cj4gPiArICAgICByZXNldF9ncGlvID0gZ3Bpb2RfZ2V0X29wdGlvbmFs KCZkYXRhLT51ZGV2LT5kZXYsICJyZXNldCIsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIEdQSU9EX09VVF9MT1cpOwo+Cj4gQW55IHJlYXNvbiB0byBub3QgdXNlIHRo ZSBkZXZtX2dwaW9kX2dldF9vcHRpb25hbCgpIHZlcnNpb24gaGVyZT8KClllcywgd2UncmUgdXNp bmcgdGhlICZkYXRhLT51ZGV2LT5kZXYgZGV2aWNlIChwYXJlbnQgb2YgdGhlIFVTQgppbnRlcmZh Y2UpIHRvIGZldGNoIHRoZSBncGlvLCBzbyBpZiB3ZSB1c2UgdGhlIGRldm1fKiB2YXJpYW50LCB0 aGUKZ3BpbyByZXNvdXJjZSB3aWxsIG5vdCBiZSBmcmVlZCBpbW1lZGlhdGVseSBpZiB0aGUgYnR1 c2JfcHJvYmUgZmFpbHMuCkknbGwgYWRkIGEgY29tbWVudCBpbiB0aGUgY29kZSB0byBtYWtlIHRo aXMgbW9yZSBjbGVhci4KCj4KPiA+ICsgICAgIGlmIChJU19FUlIocmVzZXRfZ3BpbykpIHsKPiA+ ICsgICAgICAgICAgICAgZXJyID0gUFRSX0VSUihyZXNldF9ncGlvKTsKPiA+ICsgICAgICAgICAg ICAgZ290byBvdXRfZnJlZV9kZXY7Cj4gPiArICAgICB9IGVsc2UgaWYgKHJlc2V0X2dwaW8pIHsK PiA+ICsgICAgICAgICAgICAgZGF0YS0+cmVzZXRfZ3BpbyA9IHJlc2V0X2dwaW87Cj4gPiArICAg ICB9Cj4gPiArCj4gPiAgICAgICBoZGV2LT5vcGVuICAgPSBidHVzYl9vcGVuOwo+ID4gICAgICAg aGRldi0+Y2xvc2UgID0gYnR1c2JfY2xvc2U7Cj4gPiAgICAgICBoZGV2LT5mbHVzaCAgPSBidHVz Yl9mbHVzaDsKPiA+IEBAIC0zMDg1LDYgKzMxMzAsOCBAQCBzdGF0aWMgaW50IGJ0dXNiX3Byb2Jl KHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmLAo+ID4gICAgICAgICAgICAgICBzZXRfYml0KEhD SV9RVUlSS19TVFJJQ1RfRFVQTElDQVRFX0ZJTFRFUiwgJmhkZXYtPnF1aXJrcyk7Cj4gPiAgICAg ICAgICAgICAgIHNldF9iaXQoSENJX1FVSVJLX1NJTVVMVEFORU9VU19ESVNDT1ZFUlksICZoZGV2 LT5xdWlya3MpOwo+ID4gICAgICAgICAgICAgICBzZXRfYml0KEhDSV9RVUlSS19OT05fUEVSU0lT VEVOVF9ESUFHLCAmaGRldi0+cXVpcmtzKTsKPiA+ICsgICAgICAgICAgICAgaWYgKGRhdGEtPnJl c2V0X2dwaW8pCj4gPiArICAgICAgICAgICAgICAgICAgICAgaGRldi0+Y21kX3RpbWVvdXQgPSBi dHVzYl9pbnRlbF9jbWRfdGltZW91dDsKPiA+ICAgICAgIH0KPgo+IEFsd2F5cyBhc3NpZ24gaGRl di0+Y21kX3RpbWVvdXQgPSBidHVzYl9pbnRlbF9jbWRfdGltZW91dCBhbmQgcHV0IGl0IGFmdGVy IGJ0aW50ZWxfc2V0X2JkYWRkciBhbmQgYmVmb3JlIHRoZSBxdWlya3MuCgp3aWxsIGRvLgoKPgo+ IE1vdmUgdGhlIGlmIChkYXRhLT5yZXNldF9ncGlvKSBjaGVjayBpbnRvIGJ0dXNiX2ludGVsX2Nt ZF90aW1lb3V0KCkgZnVuY3Rpb24gYW5kIHByaW50IGEgd2FybmluZyB0aGF0IG5vIHJlc2V0IEdQ SU8gaXMgcHJlc2VudC4KClRoZXJlJ2xsIGJlIEludGVsIHBsYXRmb3JtcyBhbHJlYWR5IG91dCB0 aGVyZSB3aGljaCB3aWxsIG9idmlvdXNseSBub3QKaGF2ZSB0aGUgcmVzZXQgcGluIGRlc2NyaWJl ZCBpbiB0aGUgQUNQSSBhcyBvZiB0b2RheS4gU28gSSdtIG5vdCBzdXJlCmlmIGl0IGlzIHJpZ2h0 IGZvciBhbGwgb2YgdGhlbSB0byBzdGFydCBjb21wbGFpbmluZyBhYm91dCBhIG1pc3NpbmcKInJl c2V0IGdwaW8iIGluIGNhc2Ugb2YgdGltZW91dCBwb3N0IHRoaXMgY2hhbmdlLiBUaHVzIEkgd291 bGQgcHJlZmVyCnRvIGFzc2lnbiBoZGV2LT5jbWRfdGltZW91dCBvbmx5IGlmIEFDUEkgZG9lcyBw cm92aWRlIGEgZ3BpbyBpLmUuCm5ld2VyIHBsYXRmb3JtcyB0aGF0IHdhbnQgdG8gc3VwcG9ydCB0 aGlzIGZlYXR1cmUuIFRob3VnaHRzPwoKVGhhbmtzLAoKUmFqYXQKCj4KPiA+Cj4gPiAgICAgICBp ZiAoaWQtPmRyaXZlcl9pbmZvICYgQlRVU0JfSU5URUxfTkVXKSB7Cj4gPiBAQCAtMzA5Nyw2ICsz MTQ0LDggQEAgc3RhdGljIGludCBidHVzYl9wcm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50 ZiwKPiA+ICAgICAgICAgICAgICAgc2V0X2JpdChIQ0lfUVVJUktfU1RSSUNUX0RVUExJQ0FURV9G SUxURVIsICZoZGV2LT5xdWlya3MpOwo+ID4gICAgICAgICAgICAgICBzZXRfYml0KEhDSV9RVUlS S19TSU1VTFRBTkVPVVNfRElTQ09WRVJZLCAmaGRldi0+cXVpcmtzKTsKPiA+ICAgICAgICAgICAg ICAgc2V0X2JpdChIQ0lfUVVJUktfTk9OX1BFUlNJU1RFTlRfRElBRywgJmhkZXYtPnF1aXJrcyk7 Cj4gPiArICAgICAgICAgICAgIGlmIChkYXRhLT5yZXNldF9ncGlvKQo+ID4gKyAgICAgICAgICAg ICAgICAgICAgIGhkZXYtPmNtZF90aW1lb3V0ID0gYnR1c2JfaW50ZWxfY21kX3RpbWVvdXQ7Cj4g PiAgICAgICB9Cj4gPgo+ID4gICAgICAgaWYgKGlkLT5kcml2ZXJfaW5mbyAmIEJUVVNCX01BUlZF TEwpCj4gPiBAQCAtMzIyNiw2ICszMjc1LDggQEAgc3RhdGljIGludCBidHVzYl9wcm9iZShzdHJ1 Y3QgdXNiX2ludGVyZmFjZSAqaW50ZiwKPiA+ICAgICAgIHJldHVybiAwOwo+ID4KPiA+IG91dF9m cmVlX2RldjoKPiA+ICsgICAgIGlmIChkYXRhLT5yZXNldF9ncGlvKQo+ID4gKyAgICAgICAgICAg ICBncGlvZF9wdXQoZGF0YS0+cmVzZXRfZ3Bpbyk7Cj4gPiAgICAgICBoY2lfZnJlZV9kZXYoaGRl dik7Cj4gPiAgICAgICByZXR1cm4gZXJyOwo+ID4gfQo+ID4gQEAgLTMyNjksNiArMzMyMCw5IEBA IHN0YXRpYyB2b2lkIGJ0dXNiX2Rpc2Nvbm5lY3Qoc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGYp Cj4gPiAgICAgICBpZiAoZGF0YS0+b29iX3dha2VfaXJxKQo+ID4gICAgICAgICAgICAgICBkZXZp Y2VfaW5pdF93YWtldXAoJmRhdGEtPnVkZXYtPmRldiwgZmFsc2UpOwo+ID4KPiA+ICsgICAgIGlm IChkYXRhLT5yZXNldF9ncGlvKQo+ID4gKyAgICAgICAgICAgICBncGlvZF9wdXQoZGF0YS0+cmVz ZXRfZ3Bpbyk7Cj4gPiArCj4gPiAgICAgICBoY2lfZnJlZV9kZXYoaGRldik7Cj4gPiB9Cj4KPiBS ZWdhcmRzCj4KPiBNYXJjZWwKPgo=