From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga17.intel.com ([192.55.52.151]:32012 "EHLO mga17.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933405AbeFKOJO (ORCPT ); Mon, 11 Jun 2018 10:09:14 -0400 Date: Mon, 11 Jun 2018 17:09:10 +0300 From: Heikki Krogerus To: Yoshihiro Shimoda Cc: balbi@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com, gregkh@linuxfoundation.org, hdegoede@redhat.com, andy.shevchenko@gmail.com, linux-usb@vger.kernel.org, linux-renesas-soc@vger.kernel.org, devicetree@vger.kernel.org Subject: Re: [PATCH v6] usb: gadget: udc: renesas_usb3: Add register of usb role switch Message-ID: <20180611140910.GS17155@kuha.fi.intel.com> References: <1527747093-1674-1-git-send-email-yoshihiro.shimoda.uh@renesas.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1527747093-1674-1-git-send-email-yoshihiro.shimoda.uh@renesas.com> Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: On Thu, May 31, 2018 at 03:11:33PM +0900, Yoshihiro Shimoda wrote: > This patch adds role switch support for R-Car SoCs into the USB 3.0 > peripheral driver. Some R-Car SoCs (e.g. R-Car H3) have USB 3.0 > dual-role device controller which has the USB 3.0 xHCI host and > Renesas USB 3.0 peripheral. > > Unfortunately, the mode change register (DRD_CON) contains > the USB 3.0 peripheral controller side only. So, this renesas_usb3 > driver manages the DRD_CON now. However, in peripheral mode, the host > should stop. Also the host hardware needs to reinitialize its own > registers when the mode changes from peripheral to host mode. > Otherwise, the host cannot work correctly (e.g. detect a device > as high-speed). > > To achieve this reinitialization by a driver, this driver also > registers a role switch driver to manage the DRD_CON and get > a device pointer of usb 3.0 host from "companion" property of OF. > Then, when the usb role is changed, renesas_usb3_role_switch_set() > will attach/release the xhci-plat driver to reinitialize the host > hardware. > > Signed-off-by: Yoshihiro Shimoda Reviewed-by: Heikki Krogerus > --- > This patch set is based on Felipe's usb.git / testing/next branch > (commit id = 47265c067c0d129f3a0e94bc221293a780af9d78). > > Changes from v5 (https://patchwork.kernel.org/patch/10426483/): > - Add a new function "usb3_set_mode_by_role_sw()" instead of reusing > usb3_set_mode() and add _usb3_set_mode(). > - Change a coding style of container_of. > - Revise an error message in renesas_usb3_role_switch_set(). > - Add "const" for "renesas_usb3_role_switch_desc". > - Simplify a condition check of usb_of_get_companion_dev(). > > Changes from RFC v4 (https://patchwork.kernel.org/patch/10418265/): > - Use "companion" device tree property simply instead of device_connection > APIs with OF graph. > - Merge patch 2 and 3 to one. > - Revise the commit log (I should had revised this on RFC v4 though). > > Changes from RFC v3: > - Rebase latest usb.git / testing/next branch. > - Add graph parse into device_connection_find_match(). > - Use workqueue to call _usb3_set_mode() in patch 3. > (I realized renesas_usb3_role_switch_set() cannot run on atomic because > device_attach() might sleep.) > > Changes from RFC v2: > - Add registering usb role switch into drivers/usb/gadget/udc/renesas_usb3 > because hardware resource (a register) is shared and remove individual > usb role switch driver/dt-bindings for R-Car. > - Remove "usb_role_switch_get_by_graph" API because the renesas_usb3 driver > doesn't need such API now. > > Changes from RFC: > - Remove "device-connection-id" and "usb role switch driver" dt-bingings. > - Remove drivers/of code. > - Add a new API for find the connection by using graph on devcon.c and roles.c. > - Use each new API on the rcar usb role switch and renesas_usb3 drivers. > - Update the dtsi file for r8a7795. > > > drivers/usb/gadget/udc/Kconfig | 1 + > drivers/usb/gadget/udc/renesas_usb3.c | 84 ++++++++++++++++++++++++++++++++++- > 2 files changed, 84 insertions(+), 1 deletion(-) > > diff --git a/drivers/usb/gadget/udc/Kconfig b/drivers/usb/gadget/udc/Kconfig > index b838cae..78823cd 100644 > --- a/drivers/usb/gadget/udc/Kconfig > +++ b/drivers/usb/gadget/udc/Kconfig > @@ -193,6 +193,7 @@ config USB_RENESAS_USB3 > tristate 'Renesas USB3.0 Peripheral controller' > depends on ARCH_RENESAS || COMPILE_TEST > depends on EXTCON && HAS_DMA > + select USB_ROLE_SWITCH > help > Renesas USB3.0 Peripheral controller is a USB peripheral controller > that supports super, high, and full speed USB 3.0 data transfers. > diff --git a/drivers/usb/gadget/udc/renesas_usb3.c b/drivers/usb/gadget/udc/renesas_usb3.c > index 5caf78b..f44a4b1 100644 > --- a/drivers/usb/gadget/udc/renesas_usb3.c > +++ b/drivers/usb/gadget/udc/renesas_usb3.c > @@ -23,6 +23,8 @@ > #include > #include > #include > +#include > +#include > > /* register definitions */ > #define USB3_AXI_INT_STA 0x008 > @@ -335,6 +337,11 @@ struct renesas_usb3 { > struct phy *phy; > struct dentry *dentry; > > + struct usb_role_switch *role_sw; > + struct device *host_dev; > + struct work_struct role_work; > + enum usb_role role; > + > struct renesas_usb3_ep *usb3_ep; > int num_usb3_eps; > > @@ -651,6 +658,14 @@ static void usb3_check_vbus(struct renesas_usb3 *usb3) > } > } > > +static void renesas_usb3_role_work(struct work_struct *work) > +{ > + struct renesas_usb3 *usb3 = > + container_of(work, struct renesas_usb3, role_work); > + > + usb_role_switch_set_role(usb3->role_sw, usb3->role); > +} > + > static void usb3_set_mode(struct renesas_usb3 *usb3, bool host) > { > if (host) > @@ -659,6 +674,16 @@ static void usb3_set_mode(struct renesas_usb3 *usb3, bool host) > usb3_set_bit(usb3, DRD_CON_PERI_CON, USB3_DRD_CON); > } > > +static void usb3_set_mode_by_role_sw(struct renesas_usb3 *usb3, bool host) > +{ > + if (usb3->role_sw) { > + usb3->role = host ? USB_ROLE_HOST : USB_ROLE_DEVICE; > + schedule_work(&usb3->role_work); > + } else { > + usb3_set_mode(usb3, host); > + } > +} > + > static void usb3_vbus_out(struct renesas_usb3 *usb3, bool enable) > { > if (enable) > @@ -672,7 +697,7 @@ static void usb3_mode_config(struct renesas_usb3 *usb3, bool host, bool a_dev) > unsigned long flags; > > spin_lock_irqsave(&usb3->lock, flags); > - usb3_set_mode(usb3, host); > + usb3_set_mode_by_role_sw(usb3, host); > usb3_vbus_out(usb3, a_dev); > /* for A-Peripheral or forced B-device mode */ > if ((!host && a_dev) || > @@ -2302,6 +2327,41 @@ static int renesas_usb3_set_selfpowered(struct usb_gadget *gadget, int is_self) > .set_selfpowered = renesas_usb3_set_selfpowered, > }; > > +static enum usb_role renesas_usb3_role_switch_get(struct device *dev) > +{ > + struct renesas_usb3 *usb3 = dev_get_drvdata(dev); > + enum usb_role cur_role; > + > + pm_runtime_get_sync(dev); > + cur_role = usb3_is_host(usb3) ? USB_ROLE_HOST : USB_ROLE_DEVICE; > + pm_runtime_put(dev); > + > + return cur_role; > +} > + > +static int renesas_usb3_role_switch_set(struct device *dev, > + enum usb_role role) > +{ > + struct renesas_usb3 *usb3 = dev_get_drvdata(dev); > + struct device *host = usb3->host_dev; > + enum usb_role cur_role = renesas_usb3_role_switch_get(dev); > + > + pm_runtime_get_sync(dev); > + if (cur_role == USB_ROLE_HOST && role == USB_ROLE_DEVICE) { > + device_release_driver(host); > + usb3_set_mode(usb3, false); > + } else if (cur_role == USB_ROLE_DEVICE && role == USB_ROLE_HOST) { > + /* Must set the mode before device_attach of the host */ > + usb3_set_mode(usb3, true); > + /* This device_attach() might sleep */ > + if (device_attach(host) < 0) > + dev_err(dev, "device_attach(host) failed\n"); > + } > + pm_runtime_put(dev); > + > + return 0; > +} > + > static ssize_t role_store(struct device *dev, struct device_attribute *attr, > const char *buf, size_t count) > { > @@ -2417,6 +2477,8 @@ static int renesas_usb3_remove(struct platform_device *pdev) > debugfs_remove_recursive(usb3->dentry); > device_remove_file(&pdev->dev, &dev_attr_role); > > + usb_role_switch_unregister(usb3->role_sw); > + > usb_del_gadget_udc(&usb3->gadget); > renesas_usb3_dma_free_prd(usb3, &pdev->dev); > > @@ -2573,6 +2635,12 @@ static void renesas_usb3_init_ram(struct renesas_usb3 *usb3, struct device *dev, > EXTCON_NONE, > }; > > +static const struct usb_role_switch_desc renesas_usb3_role_switch_desc = { > + .set = renesas_usb3_role_switch_set, > + .get = renesas_usb3_role_switch_get, > + .allow_userspace_control = true, > +}; > + > static int renesas_usb3_probe(struct platform_device *pdev) > { > struct renesas_usb3 *usb3; > @@ -2658,6 +2726,20 @@ static int renesas_usb3_probe(struct platform_device *pdev) > if (ret < 0) > goto err_dev_create; > > + INIT_WORK(&usb3->role_work, renesas_usb3_role_work); > + usb3->role_sw = usb_role_switch_register(&pdev->dev, > + &renesas_usb3_role_switch_desc); > + if (!IS_ERR(usb3->role_sw)) { > + usb3->host_dev = usb_of_get_companion_dev(&pdev->dev); > + if (!usb3->host_dev) { > + /* If not found, this driver will not use a role sw */ > + usb_role_switch_unregister(usb3->role_sw); > + usb3->role_sw = NULL; > + } > + } else { > + usb3->role_sw = NULL; > + } > + > usb3->workaround_for_vbus = priv->workaround_for_vbus; > > renesas_usb3_debugfs_init(usb3, &pdev->dev); -- heikki 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: [v6] usb: gadget: udc: renesas_usb3: Add register of usb role switch From: Heikki Krogerus Message-Id: <20180611140910.GS17155@kuha.fi.intel.com> Date: Mon, 11 Jun 2018 17:09:10 +0300 To: Yoshihiro Shimoda Cc: balbi@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com, gregkh@linuxfoundation.org, hdegoede@redhat.com, andy.shevchenko@gmail.com, linux-usb@vger.kernel.org, linux-renesas-soc@vger.kernel.org, devicetree@vger.kernel.org List-ID: T24gVGh1LCBNYXkgMzEsIDIwMTggYXQgMDM6MTE6MzNQTSArMDkwMCwgWW9zaGloaXJvIFNoaW1v ZGEgd3JvdGU6Cj4gVGhpcyBwYXRjaCBhZGRzIHJvbGUgc3dpdGNoIHN1cHBvcnQgZm9yIFItQ2Fy IFNvQ3MgaW50byB0aGUgVVNCIDMuMAo+IHBlcmlwaGVyYWwgZHJpdmVyLiBTb21lIFItQ2FyIFNv Q3MgKGUuZy4gUi1DYXIgSDMpIGhhdmUgVVNCIDMuMAo+IGR1YWwtcm9sZSBkZXZpY2UgY29udHJv bGxlciB3aGljaCBoYXMgdGhlIFVTQiAzLjAgeEhDSSBob3N0IGFuZAo+IFJlbmVzYXMgVVNCIDMu MCBwZXJpcGhlcmFsLgo+IAo+IFVuZm9ydHVuYXRlbHksIHRoZSBtb2RlIGNoYW5nZSByZWdpc3Rl ciAoRFJEX0NPTikgY29udGFpbnMKPiB0aGUgVVNCIDMuMCBwZXJpcGhlcmFsIGNvbnRyb2xsZXIg c2lkZSBvbmx5LiBTbywgdGhpcyByZW5lc2FzX3VzYjMKPiBkcml2ZXIgbWFuYWdlcyB0aGUgRFJE X0NPTiBub3cuIEhvd2V2ZXIsIGluIHBlcmlwaGVyYWwgbW9kZSwgdGhlIGhvc3QKPiBzaG91bGQg c3RvcC4gQWxzbyB0aGUgaG9zdCBoYXJkd2FyZSBuZWVkcyB0byByZWluaXRpYWxpemUgaXRzIG93 bgo+IHJlZ2lzdGVycyB3aGVuIHRoZSBtb2RlIGNoYW5nZXMgZnJvbSBwZXJpcGhlcmFsIHRvIGhv c3QgbW9kZS4KPiBPdGhlcndpc2UsIHRoZSBob3N0IGNhbm5vdCB3b3JrIGNvcnJlY3RseSAoZS5n LiBkZXRlY3QgYSBkZXZpY2UKPiBhcyBoaWdoLXNwZWVkKS4KPiAKPiBUbyBhY2hpZXZlIHRoaXMg cmVpbml0aWFsaXphdGlvbiBieSBhIGRyaXZlciwgdGhpcyBkcml2ZXIgYWxzbwo+IHJlZ2lzdGVy cyBhIHJvbGUgc3dpdGNoIGRyaXZlciB0byBtYW5hZ2UgdGhlIERSRF9DT04gYW5kIGdldAo+IGEg ZGV2aWNlIHBvaW50ZXIgb2YgdXNiIDMuMCBob3N0IGZyb20gImNvbXBhbmlvbiIgcHJvcGVydHkg b2YgT0YuCj4gVGhlbiwgd2hlbiB0aGUgdXNiIHJvbGUgaXMgY2hhbmdlZCwgcmVuZXNhc191c2Iz X3JvbGVfc3dpdGNoX3NldCgpCj4gd2lsbCBhdHRhY2gvcmVsZWFzZSB0aGUgeGhjaS1wbGF0IGRy aXZlciB0byByZWluaXRpYWxpemUgdGhlIGhvc3QKPiBoYXJkd2FyZS4KPiAKPiBTaWduZWQtb2Zm LWJ5OiBZb3NoaWhpcm8gU2hpbW9kYSA8eW9zaGloaXJvLnNoaW1vZGEudWhAcmVuZXNhcy5jb20+ CgpSZXZpZXdlZC1ieTogSGVpa2tpIEtyb2dlcnVzIDxoZWlra2kua3JvZ2VydXNAbGludXguaW50 ZWwuY29tPgoKPiAtLS0KPiBUaGlzIHBhdGNoIHNldCBpcyBiYXNlZCBvbiBGZWxpcGUncyB1c2Iu Z2l0IC8gdGVzdGluZy9uZXh0IGJyYW5jaAo+IChjb21taXQgaWQgPSA0NzI2NWMwNjdjMGQxMjlm M2EwZTk0YmMyMjEyOTNhNzgwYWY5ZDc4KS4KPiAKPiBDaGFuZ2VzIGZyb20gdjUgKGh0dHBzOi8v cGF0Y2h3b3JrLmtlcm5lbC5vcmcvcGF0Y2gvMTA0MjY0ODMvKToKPiAgLSBBZGQgYSBuZXcgZnVu Y3Rpb24gInVzYjNfc2V0X21vZGVfYnlfcm9sZV9zdygpIiBpbnN0ZWFkIG9mIHJldXNpbmcKPiAg ICB1c2IzX3NldF9tb2RlKCkgYW5kIGFkZCBfdXNiM19zZXRfbW9kZSgpLgo+ICAtIENoYW5nZSBh IGNvZGluZyBzdHlsZSBvZiBjb250YWluZXJfb2YuCj4gIC0gUmV2aXNlIGFuIGVycm9yIG1lc3Nh Z2UgaW4gcmVuZXNhc191c2IzX3JvbGVfc3dpdGNoX3NldCgpLgo+ICAtIEFkZCAiY29uc3QiIGZv ciAicmVuZXNhc191c2IzX3JvbGVfc3dpdGNoX2Rlc2MiLgo+ICAtIFNpbXBsaWZ5IGEgY29uZGl0 aW9uIGNoZWNrIG9mIHVzYl9vZl9nZXRfY29tcGFuaW9uX2RldigpLgo+IAo+IENoYW5nZXMgZnJv bSBSRkMgdjQgKGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcGF0Y2gvMTA0MTgyNjUvKToK PiAgLSBVc2UgImNvbXBhbmlvbiIgZGV2aWNlIHRyZWUgcHJvcGVydHkgc2ltcGx5IGluc3RlYWQg b2YgZGV2aWNlX2Nvbm5lY3Rpb24KPiAgICBBUElzIHdpdGggT0YgZ3JhcGguCj4gIC0gTWVyZ2Ug cGF0Y2ggMiBhbmQgMyB0byBvbmUuCj4gIC0gUmV2aXNlIHRoZSBjb21taXQgbG9nIChJIHNob3Vs ZCBoYWQgcmV2aXNlZCB0aGlzIG9uIFJGQyB2NCB0aG91Z2gpLgo+IAo+IENoYW5nZXMgZnJvbSBS RkMgdjM6Cj4gIC0gUmViYXNlIGxhdGVzdCB1c2IuZ2l0IC8gdGVzdGluZy9uZXh0IGJyYW5jaC4K PiAgLSBBZGQgZ3JhcGggcGFyc2UgaW50byBkZXZpY2VfY29ubmVjdGlvbl9maW5kX21hdGNoKCku Cj4gIC0gVXNlIHdvcmtxdWV1ZSB0byBjYWxsIF91c2IzX3NldF9tb2RlKCkgaW4gcGF0Y2ggMy4K PiAgICAoSSByZWFsaXplZCByZW5lc2FzX3VzYjNfcm9sZV9zd2l0Y2hfc2V0KCkgY2Fubm90IHJ1 biBvbiBhdG9taWMgYmVjYXVzZQo+ICAgICBkZXZpY2VfYXR0YWNoKCkgbWlnaHQgc2xlZXAuKQo+ IAo+IENoYW5nZXMgZnJvbSBSRkMgdjI6Cj4gIC0gQWRkIHJlZ2lzdGVyaW5nIHVzYiByb2xlIHN3 aXRjaCBpbnRvIGRyaXZlcnMvdXNiL2dhZGdldC91ZGMvcmVuZXNhc191c2IzCj4gICAgYmVjYXVz ZSBoYXJkd2FyZSByZXNvdXJjZSAoYSByZWdpc3RlcikgaXMgc2hhcmVkIGFuZCByZW1vdmUgaW5k aXZpZHVhbAo+ICAgIHVzYiByb2xlIHN3aXRjaCBkcml2ZXIvZHQtYmluZGluZ3MgZm9yIFItQ2Fy Lgo+ICAtIFJlbW92ZSAidXNiX3JvbGVfc3dpdGNoX2dldF9ieV9ncmFwaCIgQVBJIGJlY2F1c2Ug dGhlIHJlbmVzYXNfdXNiMyBkcml2ZXIKPiAgICBkb2Vzbid0IG5lZWQgc3VjaCBBUEkgbm93Lgo+ IAo+IENoYW5nZXMgZnJvbSBSRkM6Cj4gIC0gUmVtb3ZlICJkZXZpY2UtY29ubmVjdGlvbi1pZCIg YW5kICJ1c2Igcm9sZSBzd2l0Y2ggZHJpdmVyIiBkdC1iaW5naW5ncy4KPiAgLSBSZW1vdmUgZHJp dmVycy9vZiBjb2RlLgo+ICAtIEFkZCBhIG5ldyBBUEkgZm9yIGZpbmQgdGhlIGNvbm5lY3Rpb24g YnkgdXNpbmcgZ3JhcGggb24gZGV2Y29uLmMgYW5kIHJvbGVzLmMuCj4gIC0gVXNlIGVhY2ggbmV3 IEFQSSBvbiB0aGUgcmNhciB1c2Igcm9sZSBzd2l0Y2ggYW5kIHJlbmVzYXNfdXNiMyBkcml2ZXJz Lgo+ICAtIFVwZGF0ZSB0aGUgZHRzaSBmaWxlIGZvciByOGE3Nzk1Lgo+IAo+IAo+ICBkcml2ZXJz L3VzYi9nYWRnZXQvdWRjL0tjb25maWcgICAgICAgIHwgIDEgKwo+ICBkcml2ZXJzL3VzYi9nYWRn ZXQvdWRjL3JlbmVzYXNfdXNiMy5jIHwgODQgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKy0KPiAgMiBmaWxlcyBjaGFuZ2VkLCA4NCBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0p Cj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC91ZGMvS2NvbmZpZyBiL2RyaXZl cnMvdXNiL2dhZGdldC91ZGMvS2NvbmZpZwo+IGluZGV4IGI4MzhjYWUuLjc4ODIzY2QgMTAwNjQ0 Cj4gLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L3VkYy9LY29uZmlnCj4gKysrIGIvZHJpdmVycy91 c2IvZ2FkZ2V0L3VkYy9LY29uZmlnCj4gQEAgLTE5Myw2ICsxOTMsNyBAQCBjb25maWcgVVNCX1JF TkVTQVNfVVNCMwo+ICAJdHJpc3RhdGUgJ1JlbmVzYXMgVVNCMy4wIFBlcmlwaGVyYWwgY29udHJv bGxlcicKPiAgCWRlcGVuZHMgb24gQVJDSF9SRU5FU0FTIHx8IENPTVBJTEVfVEVTVAo+ICAJZGVw ZW5kcyBvbiBFWFRDT04gJiYgSEFTX0RNQQo+ICsJc2VsZWN0IFVTQl9ST0xFX1NXSVRDSAo+ICAJ aGVscAo+ICAJICAgUmVuZXNhcyBVU0IzLjAgUGVyaXBoZXJhbCBjb250cm9sbGVyIGlzIGEgVVNC IHBlcmlwaGVyYWwgY29udHJvbGxlcgo+ICAJICAgdGhhdCBzdXBwb3J0cyBzdXBlciwgaGlnaCwg YW5kIGZ1bGwgc3BlZWQgVVNCIDMuMCBkYXRhIHRyYW5zZmVycy4KPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy91c2IvZ2FkZ2V0L3VkYy9yZW5lc2FzX3VzYjMuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC91 ZGMvcmVuZXNhc191c2IzLmMKPiBpbmRleCA1Y2FmNzhiLi5mNDRhNGIxIDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvdXNiL2dhZGdldC91ZGMvcmVuZXNhc191c2IzLmMKPiArKysgYi9kcml2ZXJzL3Vz Yi9nYWRnZXQvdWRjL3JlbmVzYXNfdXNiMy5jCj4gQEAgLTIzLDYgKzIzLDggQEAKPiAgI2luY2x1 ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3VzYi9jaDkuaD4KPiAgI2lu Y2x1ZGUgPGxpbnV4L3VzYi9nYWRnZXQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3VzYi9vZi5oPgo+ ICsjaW5jbHVkZSA8bGludXgvdXNiL3JvbGUuaD4KPiAgCj4gIC8qIHJlZ2lzdGVyIGRlZmluaXRp b25zICovCj4gICNkZWZpbmUgVVNCM19BWElfSU5UX1NUQQkweDAwOAo+IEBAIC0zMzUsNiArMzM3 LDExIEBAIHN0cnVjdCByZW5lc2FzX3VzYjMgewo+ICAJc3RydWN0IHBoeSAqcGh5Owo+ICAJc3Ry dWN0IGRlbnRyeSAqZGVudHJ5Owo+ICAKPiArCXN0cnVjdCB1c2Jfcm9sZV9zd2l0Y2ggKnJvbGVf c3c7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpob3N0X2RldjsKPiArCXN0cnVjdCB3b3JrX3N0cnVjdCBy b2xlX3dvcms7Cj4gKwllbnVtIHVzYl9yb2xlIHJvbGU7Cj4gKwo+ICAJc3RydWN0IHJlbmVzYXNf dXNiM19lcCAqdXNiM19lcDsKPiAgCWludCBudW1fdXNiM19lcHM7Cj4gIAo+IEBAIC02NTEsNiAr NjU4LDE0IEBAIHN0YXRpYyB2b2lkIHVzYjNfY2hlY2tfdmJ1cyhzdHJ1Y3QgcmVuZXNhc191c2Iz ICp1c2IzKQo+ICAJfQo+ICB9Cj4gIAo+ICtzdGF0aWMgdm9pZCByZW5lc2FzX3VzYjNfcm9sZV93 b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKPiArewo+ICsJc3RydWN0IHJlbmVzYXNfdXNi MyAqdXNiMyA9Cj4gKwkJCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgcmVuZXNhc191c2IzLCBy b2xlX3dvcmspOwo+ICsKPiArCXVzYl9yb2xlX3N3aXRjaF9zZXRfcm9sZSh1c2IzLT5yb2xlX3N3 LCB1c2IzLT5yb2xlKTsKPiArfQo+ICsKPiAgc3RhdGljIHZvaWQgdXNiM19zZXRfbW9kZShzdHJ1 Y3QgcmVuZXNhc191c2IzICp1c2IzLCBib29sIGhvc3QpCj4gIHsKPiAgCWlmIChob3N0KQo+IEBA IC02NTksNiArNjc0LDE2IEBAIHN0YXRpYyB2b2lkIHVzYjNfc2V0X21vZGUoc3RydWN0IHJlbmVz YXNfdXNiMyAqdXNiMywgYm9vbCBob3N0KQo+ICAJCXVzYjNfc2V0X2JpdCh1c2IzLCBEUkRfQ09O X1BFUklfQ09OLCBVU0IzX0RSRF9DT04pOwo+ICB9Cj4gIAo+ICtzdGF0aWMgdm9pZCB1c2IzX3Nl dF9tb2RlX2J5X3JvbGVfc3coc3RydWN0IHJlbmVzYXNfdXNiMyAqdXNiMywgYm9vbCBob3N0KQo+ ICt7Cj4gKwlpZiAodXNiMy0+cm9sZV9zdykgewo+ICsJCXVzYjMtPnJvbGUgPSBob3N0ID8gVVNC X1JPTEVfSE9TVCA6IFVTQl9ST0xFX0RFVklDRTsKPiArCQlzY2hlZHVsZV93b3JrKCZ1c2IzLT5y b2xlX3dvcmspOwo+ICsJfSBlbHNlIHsKPiArCQl1c2IzX3NldF9tb2RlKHVzYjMsIGhvc3QpOwo+ ICsJfQo+ICt9Cj4gKwo+ICBzdGF0aWMgdm9pZCB1c2IzX3ZidXNfb3V0KHN0cnVjdCByZW5lc2Fz X3VzYjMgKnVzYjMsIGJvb2wgZW5hYmxlKQo+ICB7Cj4gIAlpZiAoZW5hYmxlKQo+IEBAIC02NzIs NyArNjk3LDcgQEAgc3RhdGljIHZvaWQgdXNiM19tb2RlX2NvbmZpZyhzdHJ1Y3QgcmVuZXNhc191 c2IzICp1c2IzLCBib29sIGhvc3QsIGJvb2wgYV9kZXYpCj4gIAl1bnNpZ25lZCBsb25nIGZsYWdz Owo+ICAKPiAgCXNwaW5fbG9ja19pcnFzYXZlKCZ1c2IzLT5sb2NrLCBmbGFncyk7Cj4gLQl1c2Iz X3NldF9tb2RlKHVzYjMsIGhvc3QpOwo+ICsJdXNiM19zZXRfbW9kZV9ieV9yb2xlX3N3KHVzYjMs IGhvc3QpOwo+ICAJdXNiM192YnVzX291dCh1c2IzLCBhX2Rldik7Cj4gIAkvKiBmb3IgQS1QZXJp cGhlcmFsIG9yIGZvcmNlZCBCLWRldmljZSBtb2RlICovCj4gIAlpZiAoKCFob3N0ICYmIGFfZGV2 KSB8fAo+IEBAIC0yMzAyLDYgKzIzMjcsNDEgQEAgc3RhdGljIGludCByZW5lc2FzX3VzYjNfc2V0 X3NlbGZwb3dlcmVkKHN0cnVjdCB1c2JfZ2FkZ2V0ICpnYWRnZXQsIGludCBpc19zZWxmKQo+ICAJ LnNldF9zZWxmcG93ZXJlZAk9IHJlbmVzYXNfdXNiM19zZXRfc2VsZnBvd2VyZWQsCj4gIH07Cj4g IAo+ICtzdGF0aWMgZW51bSB1c2Jfcm9sZSByZW5lc2FzX3VzYjNfcm9sZV9zd2l0Y2hfZ2V0KHN0 cnVjdCBkZXZpY2UgKmRldikKPiArewo+ICsJc3RydWN0IHJlbmVzYXNfdXNiMyAqdXNiMyA9IGRl dl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJZW51bSB1c2Jfcm9sZSBjdXJfcm9sZTsKPiArCj4gKwlw bV9ydW50aW1lX2dldF9zeW5jKGRldik7Cj4gKwljdXJfcm9sZSA9IHVzYjNfaXNfaG9zdCh1c2Iz KSA/IFVTQl9ST0xFX0hPU1QgOiBVU0JfUk9MRV9ERVZJQ0U7Cj4gKwlwbV9ydW50aW1lX3B1dChk ZXYpOwo+ICsKPiArCXJldHVybiBjdXJfcm9sZTsKPiArfQo+ICsKPiArc3RhdGljIGludCByZW5l c2FzX3VzYjNfcm9sZV9zd2l0Y2hfc2V0KHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCQllbnVt IHVzYl9yb2xlIHJvbGUpCj4gK3sKPiArCXN0cnVjdCByZW5lc2FzX3VzYjMgKnVzYjMgPSBkZXZf Z2V0X2RydmRhdGEoZGV2KTsKPiArCXN0cnVjdCBkZXZpY2UgKmhvc3QgPSB1c2IzLT5ob3N0X2Rl djsKPiArCWVudW0gdXNiX3JvbGUgY3VyX3JvbGUgPSByZW5lc2FzX3VzYjNfcm9sZV9zd2l0Y2hf Z2V0KGRldik7Cj4gKwo+ICsJcG1fcnVudGltZV9nZXRfc3luYyhkZXYpOwo+ICsJaWYgKGN1cl9y b2xlID09IFVTQl9ST0xFX0hPU1QgJiYgcm9sZSA9PSBVU0JfUk9MRV9ERVZJQ0UpIHsKPiArCQlk ZXZpY2VfcmVsZWFzZV9kcml2ZXIoaG9zdCk7Cj4gKwkJdXNiM19zZXRfbW9kZSh1c2IzLCBmYWxz ZSk7Cj4gKwl9IGVsc2UgaWYgKGN1cl9yb2xlID09IFVTQl9ST0xFX0RFVklDRSAmJiByb2xlID09 IFVTQl9ST0xFX0hPU1QpIHsKPiArCQkvKiBNdXN0IHNldCB0aGUgbW9kZSBiZWZvcmUgZGV2aWNl X2F0dGFjaCBvZiB0aGUgaG9zdCAqLwo+ICsJCXVzYjNfc2V0X21vZGUodXNiMywgdHJ1ZSk7Cj4g KwkJLyogVGhpcyBkZXZpY2VfYXR0YWNoKCkgbWlnaHQgc2xlZXAgKi8KPiArCQlpZiAoZGV2aWNl X2F0dGFjaChob3N0KSA8IDApCj4gKwkJCWRldl9lcnIoZGV2LCAiZGV2aWNlX2F0dGFjaChob3N0 KSBmYWlsZWRcbiIpOwo+ICsJfQo+ICsJcG1fcnVudGltZV9wdXQoZGV2KTsKPiArCj4gKwlyZXR1 cm4gMDsKPiArfQo+ICsKPiAgc3RhdGljIHNzaXplX3Qgcm9sZV9zdG9yZShzdHJ1Y3QgZGV2aWNl ICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+ICAJCQkgIGNvbnN0IGNoYXIg KmJ1Ziwgc2l6ZV90IGNvdW50KQo+ICB7Cj4gQEAgLTI0MTcsNiArMjQ3Nyw4IEBAIHN0YXRpYyBp bnQgcmVuZXNhc191c2IzX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICAJ ZGVidWdmc19yZW1vdmVfcmVjdXJzaXZlKHVzYjMtPmRlbnRyeSk7Cj4gIAlkZXZpY2VfcmVtb3Zl X2ZpbGUoJnBkZXYtPmRldiwgJmRldl9hdHRyX3JvbGUpOwo+ICAKPiArCXVzYl9yb2xlX3N3aXRj aF91bnJlZ2lzdGVyKHVzYjMtPnJvbGVfc3cpOwo+ICsKPiAgCXVzYl9kZWxfZ2FkZ2V0X3VkYygm dXNiMy0+Z2FkZ2V0KTsKPiAgCXJlbmVzYXNfdXNiM19kbWFfZnJlZV9wcmQodXNiMywgJnBkZXYt PmRldik7Cj4gIAo+IEBAIC0yNTczLDYgKzI2MzUsMTIgQEAgc3RhdGljIHZvaWQgcmVuZXNhc191 c2IzX2luaXRfcmFtKHN0cnVjdCByZW5lc2FzX3VzYjMgKnVzYjMsIHN0cnVjdCBkZXZpY2UgKmRl diwKPiAgCUVYVENPTl9OT05FLAo+ICB9Owo+ICAKPiArc3RhdGljIGNvbnN0IHN0cnVjdCB1c2Jf cm9sZV9zd2l0Y2hfZGVzYyByZW5lc2FzX3VzYjNfcm9sZV9zd2l0Y2hfZGVzYyA9IHsKPiArCS5z ZXQgPSByZW5lc2FzX3VzYjNfcm9sZV9zd2l0Y2hfc2V0LAo+ICsJLmdldCA9IHJlbmVzYXNfdXNi M19yb2xlX3N3aXRjaF9nZXQsCj4gKwkuYWxsb3dfdXNlcnNwYWNlX2NvbnRyb2wgPSB0cnVlLAo+ ICt9Owo+ICsKPiAgc3RhdGljIGludCByZW5lc2FzX3VzYjNfcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldikKPiAgewo+ICAJc3RydWN0IHJlbmVzYXNfdXNiMyAqdXNiMzsKPiBAQCAt MjY1OCw2ICsyNzI2LDIwIEBAIHN0YXRpYyBpbnQgcmVuZXNhc191c2IzX3Byb2JlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gIAlpZiAocmV0IDwgMCkKPiAgCQlnb3RvIGVycl9kZXZf Y3JlYXRlOwo+ICAKPiArCUlOSVRfV09SSygmdXNiMy0+cm9sZV93b3JrLCByZW5lc2FzX3VzYjNf cm9sZV93b3JrKTsKPiArCXVzYjMtPnJvbGVfc3cgPSB1c2Jfcm9sZV9zd2l0Y2hfcmVnaXN0ZXIo JnBkZXYtPmRldiwKPiArCQkJCQkmcmVuZXNhc191c2IzX3JvbGVfc3dpdGNoX2Rlc2MpOwo+ICsJ aWYgKCFJU19FUlIodXNiMy0+cm9sZV9zdykpIHsKPiArCQl1c2IzLT5ob3N0X2RldiA9IHVzYl9v Zl9nZXRfY29tcGFuaW9uX2RldigmcGRldi0+ZGV2KTsKPiArCQlpZiAoIXVzYjMtPmhvc3RfZGV2 KSB7Cj4gKwkJCS8qIElmIG5vdCBmb3VuZCwgdGhpcyBkcml2ZXIgd2lsbCBub3QgdXNlIGEgcm9s ZSBzdyAqLwo+ICsJCQl1c2Jfcm9sZV9zd2l0Y2hfdW5yZWdpc3Rlcih1c2IzLT5yb2xlX3N3KTsK PiArCQkJdXNiMy0+cm9sZV9zdyA9IE5VTEw7Cj4gKwkJfQo+ICsJfSBlbHNlIHsKPiArCQl1c2Iz LT5yb2xlX3N3ID0gTlVMTDsKPiArCX0KPiArCj4gIAl1c2IzLT53b3JrYXJvdW5kX2Zvcl92YnVz ID0gcHJpdi0+d29ya2Fyb3VuZF9mb3JfdmJ1czsKPiAgCj4gIAlyZW5lc2FzX3VzYjNfZGVidWdm c19pbml0KHVzYjMsICZwZGV2LT5kZXYpOwo=