From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-eopbgr10049.outbound.protection.outlook.com ([40.107.1.49]:64432 "EHLO EUR02-HE1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726784AbeJVOAH (ORCPT ); Mon, 22 Oct 2018 10:00:07 -0400 From: Peter Chen Subject: [PATCH v2 2/4] usb: chipidea: imx: add HSIC support Date: Mon, 22 Oct 2018 05:43:01 +0000 Message-ID: <20181022054031.14027-3-peter.chen@nxp.com> References: <20181022054031.14027-1-peter.chen@nxp.com> In-Reply-To: <20181022054031.14027-1-peter.chen@nxp.com> Content-Language: en-US Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Sender: devicetree-owner@vger.kernel.org To: "linux-usb@vger.kernel.org" Cc: dl-linux-imx , "robh+dt@kernel.org" , "devicetree@vger.kernel.org" , "frieder.schrempf@exceet.de" , "festevam@gmail.com" , Peter Chen List-ID: To support imx HSIC, there are some special requirement: - The HSIC pad is 1.2v, it may need to supply from external - The data/strobe pin needs to be pulled down first, and after host mode is initialized, the strobe pin needs to be pulled up - During the USB suspend/resume, special setting is needed Signed-off-by: Peter Chen --- drivers/usb/chipidea/ci_hdrc_imx.c | 140 ++++++++++++++++++++++++++++++++-= ---- drivers/usb/chipidea/ci_hdrc_imx.h | 9 ++- drivers/usb/chipidea/usbmisc_imx.c | 130 +++++++++++++++++++++++++++++++++= + 3 files changed, 260 insertions(+), 19 deletions(-) diff --git a/drivers/usb/chipidea/ci_hdrc_imx.c b/drivers/usb/chipidea/ci_h= drc_imx.c index 09b37c0d075d..389c3261c4ee 100644 --- a/drivers/usb/chipidea/ci_hdrc_imx.c +++ b/drivers/usb/chipidea/ci_hdrc_imx.c @@ -14,6 +14,7 @@ #include #include #include +#include =20 #include "ci.h" #include "ci_hdrc_imx.h" @@ -85,6 +86,9 @@ struct ci_hdrc_imx_data { bool supports_runtime_pm; bool override_phy_control; bool in_lpm; + struct pinctrl *pinctrl; + struct pinctrl_state *pinctrl_hsic_active; + struct regulator *hsic_pad_regulator; /* SoC before i.mx6 (except imx23/imx28) needs three clks */ bool need_three_clks; struct clk *clk_ipg; @@ -245,19 +249,49 @@ static void imx_disable_unprepare_clks(struct device = *dev) } } =20 +static int ci_hdrc_imx_notify_event(struct ci_hdrc *ci, unsigned int event= ) +{ + struct device *dev =3D ci->dev->parent; + struct ci_hdrc_imx_data *data =3D dev_get_drvdata(dev); + int ret =3D 0; + + switch (event) { + case CI_HDRC_IMX_HSIC_ACTIVE_EVENT: + ret =3D pinctrl_select_state(data->pinctrl, + data->pinctrl_hsic_active); + if (ret) + dev_err(dev, "hsic_active select failed, err=3D%d\n", + ret); + break; + case CI_HDRC_IMX_HSIC_SUSPEND_EVENT: + ret =3D imx_usbmisc_hsic_set_connect(data->usbmisc_data); + if (ret) + dev_err(dev, + "hsic_set_connect failed, err=3D%d\n", ret); + break; + default: + break; + } + + return ret; +} + static int ci_hdrc_imx_probe(struct platform_device *pdev) { struct ci_hdrc_imx_data *data; struct ci_hdrc_platform_data pdata =3D { .name =3D dev_name(&pdev->dev), .capoffset =3D DEF_CAPOFFSET, + .notify_event =3D ci_hdrc_imx_notify_event, }; int ret; const struct of_device_id *of_id; const struct ci_hdrc_imx_platform_flag *imx_platform_flag; struct device_node *np =3D pdev->dev.of_node; + struct device *dev =3D &pdev->dev; + struct pinctrl_state *pinctrl_hsic_idle; =20 - of_id =3D of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev); + of_id =3D of_match_device(ci_hdrc_imx_dt_ids, dev); if (!of_id) return -ENODEV; =20 @@ -268,19 +302,73 @@ static int ci_hdrc_imx_probe(struct platform_device *= pdev) return -ENOMEM; =20 platform_set_drvdata(pdev, data); - data->usbmisc_data =3D usbmisc_get_init_data(&pdev->dev); + data->usbmisc_data =3D usbmisc_get_init_data(dev); if (IS_ERR(data->usbmisc_data)) return PTR_ERR(data->usbmisc_data); =20 - ret =3D imx_get_clks(&pdev->dev); + if (of_usb_get_phy_mode(dev->of_node) =3D=3D USBPHY_INTERFACE_MODE_HSIC) = { + pdata.flags |=3D CI_HDRC_IMX_IS_HSIC; + data->usbmisc_data->hsic =3D 1; + data->pinctrl =3D devm_pinctrl_get(dev); + if (IS_ERR(data->pinctrl)) { + dev_err(dev, "pinctrl get failed, err=3D%ld\n", + PTR_ERR(data->pinctrl)); + return PTR_ERR(data->pinctrl); + } + + pinctrl_hsic_idle =3D pinctrl_lookup_state(data->pinctrl, "idle"); + if (IS_ERR(pinctrl_hsic_idle)) { + dev_err(dev, + "pinctrl_hsic_idle lookup failed, err=3D%ld\n", + PTR_ERR(pinctrl_hsic_idle)); + return PTR_ERR(pinctrl_hsic_idle); + } + + ret =3D pinctrl_select_state(data->pinctrl, pinctrl_hsic_idle); + if (ret) { + dev_err(dev, "hsic_idle select failed, err=3D%d\n", ret); + return ret; + } + + data->pinctrl_hsic_active =3D pinctrl_lookup_state(data->pinctrl, + "active"); + if (IS_ERR(data->pinctrl_hsic_active)) { + dev_err(dev, + "pinctrl_hsic_active lookup failed, err=3D%ld\n", + PTR_ERR(data->pinctrl_hsic_active)); + return PTR_ERR(data->pinctrl_hsic_active); + } + + data->hsic_pad_regulator =3D devm_regulator_get(dev, "hsic"); + if (PTR_ERR(data->hsic_pad_regulator) =3D=3D -EPROBE_DEFER) { + return -EPROBE_DEFER; + } else if (PTR_ERR(data->hsic_pad_regulator) =3D=3D -ENODEV) { + /* no pad regualator is needed */ + data->hsic_pad_regulator =3D NULL; + } else if (IS_ERR(data->hsic_pad_regulator)) { + dev_err(dev, "Get HSIC pad regulator error: %ld\n", + PTR_ERR(data->hsic_pad_regulator)); + return PTR_ERR(data->hsic_pad_regulator); + } + + if (data->hsic_pad_regulator) { + ret =3D regulator_enable(data->hsic_pad_regulator); + if (ret) { + dev_err(dev, + "Fail to enable HSIC pad regulator\n"); + return ret; + } + } + } + ret =3D imx_get_clks(dev); if (ret) - return ret; + goto disable_hsic_regulator; =20 - ret =3D imx_prepare_enable_clks(&pdev->dev); + ret =3D imx_prepare_enable_clks(dev); if (ret) - return ret; + goto disable_hsic_regulator; =20 - data->phy =3D devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0); + data->phy =3D devm_usb_get_phy_by_phandle(dev, "fsl,usbphy", 0); if (IS_ERR(data->phy)) { ret =3D PTR_ERR(data->phy); /* Return -EINVAL if no usbphy is available */ @@ -305,40 +393,43 @@ static int ci_hdrc_imx_probe(struct platform_device *= pdev) =20 ret =3D imx_usbmisc_init(data->usbmisc_data); if (ret) { - dev_err(&pdev->dev, "usbmisc init failed, ret=3D%d\n", ret); + dev_err(dev, "usbmisc init failed, ret=3D%d\n", ret); goto err_clk; } =20 - data->ci_pdev =3D ci_hdrc_add_device(&pdev->dev, + data->ci_pdev =3D ci_hdrc_add_device(dev, pdev->resource, pdev->num_resources, &pdata); if (IS_ERR(data->ci_pdev)) { ret =3D PTR_ERR(data->ci_pdev); if (ret !=3D -EPROBE_DEFER) - dev_err(&pdev->dev, - "ci_hdrc_add_device failed, err=3D%d\n", ret); + dev_err(dev, "ci_hdrc_add_device failed, err=3D%d\n", + ret); goto err_clk; } =20 ret =3D imx_usbmisc_init_post(data->usbmisc_data); if (ret) { - dev_err(&pdev->dev, "usbmisc post failed, ret=3D%d\n", ret); + dev_err(dev, "usbmisc post failed, ret=3D%d\n", ret); goto disable_device; } =20 if (data->supports_runtime_pm) { - pm_runtime_set_active(&pdev->dev); - pm_runtime_enable(&pdev->dev); + pm_runtime_set_active(dev); + pm_runtime_enable(dev); } =20 - device_set_wakeup_capable(&pdev->dev, true); + device_set_wakeup_capable(dev, true); =20 return 0; =20 disable_device: ci_hdrc_remove_device(data->ci_pdev); err_clk: - imx_disable_unprepare_clks(&pdev->dev); + imx_disable_unprepare_clks(dev); +disable_hsic_regulator: + if (data->hsic_pad_regulator) + ret =3D regulator_disable(data->hsic_pad_regulator); return ret; } =20 @@ -355,6 +446,8 @@ static int ci_hdrc_imx_remove(struct platform_device *p= dev) if (data->override_phy_control) usb_phy_shutdown(data->phy); imx_disable_unprepare_clks(&pdev->dev); + if (data->hsic_pad_regulator) + regulator_disable(data->hsic_pad_regulator); =20 return 0; } @@ -367,9 +460,16 @@ static void ci_hdrc_imx_shutdown(struct platform_devic= e *pdev) static int __maybe_unused imx_controller_suspend(struct device *dev) { struct ci_hdrc_imx_data *data =3D dev_get_drvdata(dev); + int ret =3D 0; =20 dev_dbg(dev, "at %s\n", __func__); =20 + ret =3D imx_usbmisc_hsic_set_clk(data->usbmisc_data, false); + if (ret) { + dev_err(dev, "usbmisc hsic_set_clk failed, ret=3D%d\n", ret); + return ret; + } + imx_disable_unprepare_clks(dev); data->in_lpm =3D true; =20 @@ -400,8 +500,16 @@ static int __maybe_unused imx_controller_resume(struct= device *dev) goto clk_disable; } =20 + ret =3D imx_usbmisc_hsic_set_clk(data->usbmisc_data, true); + if (ret) { + dev_err(dev, "usbmisc hsic_set_clk failed, ret=3D%d\n", ret); + goto hsic_set_clk_fail; + } + return 0; =20 +hsic_set_clk_fail: + imx_usbmisc_set_wakeup(data->usbmisc_data, true); clk_disable: imx_disable_unprepare_clks(dev); return ret; diff --git a/drivers/usb/chipidea/ci_hdrc_imx.h b/drivers/usb/chipidea/ci_h= drc_imx.h index 204275f47573..fcecab478934 100644 --- a/drivers/usb/chipidea/ci_hdrc_imx.h +++ b/drivers/usb/chipidea/ci_hdrc_imx.h @@ -14,10 +14,13 @@ struct imx_usbmisc_data { unsigned int oc_polarity:1; /* over current polarity if oc enabled */ unsigned int evdo:1; /* set external vbus divider option */ unsigned int ulpi:1; /* connected to an ULPI phy */ + unsigned int hsic:1; /* HSIC controlller */ }; =20 -int imx_usbmisc_init(struct imx_usbmisc_data *); -int imx_usbmisc_init_post(struct imx_usbmisc_data *); -int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *, bool); +int imx_usbmisc_init(struct imx_usbmisc_data *data); +int imx_usbmisc_init_post(struct imx_usbmisc_data *data); +int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *data, bool enabled); +int imx_usbmisc_hsic_set_connect(struct imx_usbmisc_data *data); +int imx_usbmisc_hsic_set_clk(struct imx_usbmisc_data *data, bool on); =20 #endif /* __DRIVER_USB_CHIPIDEA_CI_HDRC_IMX_H */ diff --git a/drivers/usb/chipidea/usbmisc_imx.c b/drivers/usb/chipidea/usbm= isc_imx.c index def80ff547e4..df244be80b90 100644 --- a/drivers/usb/chipidea/usbmisc_imx.c +++ b/drivers/usb/chipidea/usbmisc_imx.c @@ -64,10 +64,22 @@ #define MX6_BM_OVER_CUR_DIS BIT(7) #define MX6_BM_OVER_CUR_POLARITY BIT(8) #define MX6_BM_WAKEUP_ENABLE BIT(10) +#define MX6_BM_UTMI_ON_CLOCK BIT(13) #define MX6_BM_ID_WAKEUP BIT(16) #define MX6_BM_VBUS_WAKEUP BIT(17) #define MX6SX_BM_DPDM_WAKEUP_EN BIT(29) #define MX6_BM_WAKEUP_INTR BIT(31) + +#define MX6_USB_HSIC_CTRL_OFFSET 0x10 +/* Send resume signal without 480Mhz PHY clock */ +#define MX6SX_BM_HSIC_AUTO_RESUME BIT(23) +/* set before portsc.suspendM =3D 1 */ +#define MX6_BM_HSIC_DEV_CONN BIT(21) +/* HSIC enable */ +#define MX6_BM_HSIC_EN BIT(12) +/* Force HSIC module 480M clock on, even when in Host is in suspend mode *= / +#define MX6_BM_HSIC_CLK_ON BIT(11) + #define MX6_USB_OTG1_PHY_CTRL 0x18 /* For imx6dql, it is host-only controller, for later imx6, it is otg's */ #define MX6_USB_OTG2_PHY_CTRL 0x1c @@ -94,6 +106,10 @@ struct usbmisc_ops { int (*post)(struct imx_usbmisc_data *data); /* It's called when we need to enable/disable usb wakeup */ int (*set_wakeup)(struct imx_usbmisc_data *data, bool enabled); + /* It's called before setting portsc.suspendM */ + int (*hsic_set_connect)(struct imx_usbmisc_data *data); + /* It's called during suspend/resume */ + int (*hsic_set_clk)(struct imx_usbmisc_data *data, bool enabled); }; =20 struct imx_usbmisc { @@ -353,6 +369,18 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data = *data) writel(reg | MX6_BM_NON_BURST_SETTING, usbmisc->base + data->index * 4); =20 + /* For HSIC controller */ + if (data->hsic) { + reg =3D readl(usbmisc->base + data->index * 4); + writel(reg | MX6_BM_UTMI_ON_CLOCK, + usbmisc->base + data->index * 4); + reg =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + + (data->index - 2) * 4); + reg |=3D MX6_BM_HSIC_EN | MX6_BM_HSIC_CLK_ON; + writel(reg, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + + (data->index - 2) * 4); + } + spin_unlock_irqrestore(&usbmisc->lock, flags); =20 usbmisc_imx6q_set_wakeup(data, false); @@ -360,6 +388,69 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data = *data) return 0; } =20 +static int usbmisc_imx6_hsic_set_connect(struct imx_usbmisc_data *data) +{ + unsigned long flags; + u32 val, offset; + struct imx_usbmisc *usbmisc =3D dev_get_drvdata(data->dev); + int ret =3D 0; + + spin_lock_irqsave(&usbmisc->lock, flags); + if (data->index =3D=3D 2 || data->index =3D=3D 3) { + offset =3D (data->index - 2) * 4; + } else if (data->index =3D=3D 0) { + /* + * For SoCs like i.MX7D and later, each USB controller has + * its own non-core register region. For SoCs before i.MX7D, + * the first USB controller is non-HSIC controller. + */ + offset =3D 0; + } else { + dev_err(data->dev, "index is error for usbmisc\n"); + offset =3D 0; + ret =3D -EINVAL; + } + + val =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + if (!(val & MX6_BM_HSIC_DEV_CONN)) + writel(val | MX6_BM_HSIC_DEV_CONN, + usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + spin_unlock_irqrestore(&usbmisc->lock, flags); + + return ret; +} + +static int usbmisc_imx6_hsic_set_clk(struct imx_usbmisc_data *data, bool o= n) +{ + unsigned long flags; + u32 val, offset; + struct imx_usbmisc *usbmisc =3D dev_get_drvdata(data->dev); + int ret =3D 0; + + spin_lock_irqsave(&usbmisc->lock, flags); + if (data->index =3D=3D 2 || data->index =3D=3D 3) { + offset =3D (data->index - 2) * 4; + } else if (data->index =3D=3D 0) { + offset =3D 0; + } else { + dev_err(data->dev, "index is error for usbmisc\n"); + offset =3D 0; + ret =3D -EINVAL; + } + + val =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + val |=3D MX6_BM_HSIC_EN | MX6_BM_HSIC_CLK_ON; + if (on) + val |=3D MX6_BM_HSIC_CLK_ON; + else + val &=3D ~MX6_BM_HSIC_CLK_ON; + writel(val, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + spin_unlock_irqrestore(&usbmisc->lock, flags); + + return 0; +} + + static int usbmisc_imx6sx_init(struct imx_usbmisc_data *data) { void __iomem *reg =3D NULL; @@ -385,6 +476,13 @@ static int usbmisc_imx6sx_init(struct imx_usbmisc_data= *data) spin_unlock_irqrestore(&usbmisc->lock, flags); } =20 + /* For HSIC controller */ + if (data->hsic) { + val =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET); + val |=3D MX6SX_BM_HSIC_AUTO_RESUME; + writel(val, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET); + } + return 0; } =20 @@ -454,6 +552,7 @@ static int usbmisc_imx7d_init(struct imx_usbmisc_data *= data) reg &=3D ~MX7D_USB_VBUS_WAKEUP_SOURCE_MASK; writel(reg | MX7D_USB_VBUS_WAKEUP_SOURCE_BVALID, usbmisc->base + MX7D_USBNC_USB_CTRL2); + spin_unlock_irqrestore(&usbmisc->lock, flags); =20 usbmisc_imx7d_set_wakeup(data, false); @@ -481,6 +580,8 @@ static const struct usbmisc_ops imx53_usbmisc_ops =3D { static const struct usbmisc_ops imx6q_usbmisc_ops =3D { .set_wakeup =3D usbmisc_imx6q_set_wakeup, .init =3D usbmisc_imx6q_init, + .hsic_set_connect =3D usbmisc_imx6_hsic_set_connect, + .hsic_set_clk =3D usbmisc_imx6_hsic_set_clk, }; =20 static const struct usbmisc_ops vf610_usbmisc_ops =3D { @@ -490,6 +591,8 @@ static const struct usbmisc_ops vf610_usbmisc_ops =3D { static const struct usbmisc_ops imx6sx_usbmisc_ops =3D { .set_wakeup =3D usbmisc_imx6q_set_wakeup, .init =3D usbmisc_imx6sx_init, + .hsic_set_connect =3D usbmisc_imx6_hsic_set_connect, + .hsic_set_clk =3D usbmisc_imx6_hsic_set_clk, }; =20 static const struct usbmisc_ops imx7d_usbmisc_ops =3D { @@ -546,6 +649,33 @@ int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *da= ta, bool enabled) } EXPORT_SYMBOL_GPL(imx_usbmisc_set_wakeup); =20 +int imx_usbmisc_hsic_set_connect(struct imx_usbmisc_data *data) +{ + struct imx_usbmisc *usbmisc; + + if (!data) + return 0; + + usbmisc =3D dev_get_drvdata(data->dev); + if (!usbmisc->ops->hsic_set_connect || !data->hsic) + return 0; + return usbmisc->ops->hsic_set_connect(data); +} +EXPORT_SYMBOL_GPL(imx_usbmisc_hsic_set_connect); + +int imx_usbmisc_hsic_set_clk(struct imx_usbmisc_data *data, bool on) +{ + struct imx_usbmisc *usbmisc; + + if (!data) + return 0; + + usbmisc =3D dev_get_drvdata(data->dev); + if (!usbmisc->ops->hsic_set_clk || !data->hsic) + return 0; + return usbmisc->ops->hsic_set_clk(data, on); +} +EXPORT_SYMBOL_GPL(imx_usbmisc_hsic_set_clk); static const struct of_device_id usbmisc_imx_dt_ids[] =3D { { .compatible =3D "fsl,imx25-usbmisc", --=20 2.14.1 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,2/4] usb: chipidea: imx: add HSIC support From: Peter Chen Message-Id: <20181022054031.14027-3-peter.chen@nxp.com> Date: Mon, 22 Oct 2018 05:43:01 +0000 To: "linux-usb@vger.kernel.org" Cc: dl-linux-imx , "robh+dt@kernel.org" , "devicetree@vger.kernel.org" , "frieder.schrempf@exceet.de" , "festevam@gmail.com" , Peter Chen List-ID: VG8gc3VwcG9ydCBpbXggSFNJQywgdGhlcmUgYXJlIHNvbWUgc3BlY2lhbCByZXF1aXJlbWVudDoK LSBUaGUgSFNJQyBwYWQgaXMgMS4ydiwgaXQgbWF5IG5lZWQgdG8gc3VwcGx5IGZyb20gZXh0ZXJu YWwKLSBUaGUgZGF0YS9zdHJvYmUgcGluIG5lZWRzIHRvIGJlIHB1bGxlZCBkb3duIGZpcnN0LCBh bmQgYWZ0ZXIKICBob3N0IG1vZGUgaXMgaW5pdGlhbGl6ZWQsIHRoZSBzdHJvYmUgcGluIG5lZWRz IHRvIGJlIHB1bGxlZCB1cAotIER1cmluZyB0aGUgVVNCIHN1c3BlbmQvcmVzdW1lLCBzcGVjaWFs IHNldHRpbmcgaXMgbmVlZGVkCgpTaWduZWQtb2ZmLWJ5OiBQZXRlciBDaGVuIDxwZXRlci5jaGVu QG54cC5jb20+Ci0tLQogZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguYyB8IDE0MCAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tCiBkcml2ZXJzL3VzYi9jaGlwaWRl YS9jaV9oZHJjX2lteC5oIHwgICA5ICsrLQogZHJpdmVycy91c2IvY2hpcGlkZWEvdXNibWlzY19p bXguYyB8IDEzMCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNo YW5nZWQsIDI2MCBpbnNlcnRpb25zKCspLCAxOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9k cml2ZXJzL3VzYi9jaGlwaWRlYS9jaV9oZHJjX2lteC5jIGIvZHJpdmVycy91c2IvY2hpcGlkZWEv Y2lfaGRyY19pbXguYwppbmRleCAwOWIzN2MwZDA3NWQuLjM4OWMzMjYxYzRlZSAxMDA2NDQKLS0t IGEvZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguYworKysgYi9kcml2ZXJzL3VzYi9j aGlwaWRlYS9jaV9oZHJjX2lteC5jCkBAIC0xNCw2ICsxNCw3IEBACiAjaW5jbHVkZSA8bGludXgv dXNiL2NoaXBpZGVhLmg+CiAjaW5jbHVkZSA8bGludXgvdXNiL29mLmg+CiAjaW5jbHVkZSA8bGlu dXgvY2xrLmg+CisjaW5jbHVkZSA8bGludXgvcGluY3RybC9jb25zdW1lci5oPgogCiAjaW5jbHVk ZSAiY2kuaCIKICNpbmNsdWRlICJjaV9oZHJjX2lteC5oIgpAQCAtODUsNiArODYsOSBAQCBzdHJ1 Y3QgY2lfaGRyY19pbXhfZGF0YSB7CiAJYm9vbCBzdXBwb3J0c19ydW50aW1lX3BtOwogCWJvb2wg b3ZlcnJpZGVfcGh5X2NvbnRyb2w7CiAJYm9vbCBpbl9scG07CisJc3RydWN0IHBpbmN0cmwgKnBp bmN0cmw7CisJc3RydWN0IHBpbmN0cmxfc3RhdGUgKnBpbmN0cmxfaHNpY19hY3RpdmU7CisJc3Ry dWN0IHJlZ3VsYXRvciAqaHNpY19wYWRfcmVndWxhdG9yOwogCS8qIFNvQyBiZWZvcmUgaS5teDYg KGV4Y2VwdCBpbXgyMy9pbXgyOCkgbmVlZHMgdGhyZWUgY2xrcyAqLwogCWJvb2wgbmVlZF90aHJl ZV9jbGtzOwogCXN0cnVjdCBjbGsgKmNsa19pcGc7CkBAIC0yNDUsMTkgKzI0OSw0OSBAQCBzdGF0 aWMgdm9pZCBpbXhfZGlzYWJsZV91bnByZXBhcmVfY2xrcyhzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJ fQogfQogCitzdGF0aWMgaW50IGNpX2hkcmNfaW14X25vdGlmeV9ldmVudChzdHJ1Y3QgY2lfaGRy YyAqY2ksIHVuc2lnbmVkIGludCBldmVudCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjaS0+ ZGV2LT5wYXJlbnQ7CisJc3RydWN0IGNpX2hkcmNfaW14X2RhdGEgKmRhdGEgPSBkZXZfZ2V0X2Ry dmRhdGEoZGV2KTsKKwlpbnQgcmV0ID0gMDsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIENJ X0hEUkNfSU1YX0hTSUNfQUNUSVZFX0VWRU5UOgorCQlyZXQgPSBwaW5jdHJsX3NlbGVjdF9zdGF0 ZShkYXRhLT5waW5jdHJsLAorCQkJCWRhdGEtPnBpbmN0cmxfaHNpY19hY3RpdmUpOworCQlpZiAo cmV0KQorCQkJZGV2X2VycihkZXYsICJoc2ljX2FjdGl2ZSBzZWxlY3QgZmFpbGVkLCBlcnI9JWRc biIsCisJCQkJcmV0KTsKKwkJYnJlYWs7CisJY2FzZSBDSV9IRFJDX0lNWF9IU0lDX1NVU1BFTkRf RVZFTlQ6CisJCXJldCA9IGlteF91c2JtaXNjX2hzaWNfc2V0X2Nvbm5lY3QoZGF0YS0+dXNibWlz Y19kYXRhKTsKKwkJaWYgKHJldCkKKwkJCWRldl9lcnIoZGV2LAorCQkJCSJoc2ljX3NldF9jb25u ZWN0IGZhaWxlZCwgZXJyPSVkXG4iLCByZXQpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVh azsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCiBzdGF0aWMgaW50IGNpX2hkcmNfaW14X3Byb2Jl KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IGNpX2hkcmNfaW14X2Rh dGEgKmRhdGE7CiAJc3RydWN0IGNpX2hkcmNfcGxhdGZvcm1fZGF0YSBwZGF0YSA9IHsKIAkJLm5h bWUJCT0gZGV2X25hbWUoJnBkZXYtPmRldiksCiAJCS5jYXBvZmZzZXQJPSBERUZfQ0FQT0ZGU0VU LAorCQkubm90aWZ5X2V2ZW50CT0gY2lfaGRyY19pbXhfbm90aWZ5X2V2ZW50LAogCX07CiAJaW50 IHJldDsKIAljb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICpvZl9pZDsKIAljb25zdCBzdHJ1Y3Qg Y2lfaGRyY19pbXhfcGxhdGZvcm1fZmxhZyAqaW14X3BsYXRmb3JtX2ZsYWc7CiAJc3RydWN0IGRl dmljZV9ub2RlICpucCA9IHBkZXYtPmRldi5vZl9ub2RlOworCXN0cnVjdCBkZXZpY2UgKmRldiA9 ICZwZGV2LT5kZXY7CisJc3RydWN0IHBpbmN0cmxfc3RhdGUgKnBpbmN0cmxfaHNpY19pZGxlOwog Ci0Jb2ZfaWQgPSBvZl9tYXRjaF9kZXZpY2UoY2lfaGRyY19pbXhfZHRfaWRzLCAmcGRldi0+ZGV2 KTsKKwlvZl9pZCA9IG9mX21hdGNoX2RldmljZShjaV9oZHJjX2lteF9kdF9pZHMsIGRldik7CiAJ aWYgKCFvZl9pZCkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKQEAgLTI2OCwxOSArMzAyLDczIEBAIHN0 YXRpYyBpbnQgY2lfaGRyY19pbXhfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK IAkJcmV0dXJuIC1FTk9NRU07CiAKIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkYXRhKTsK LQlkYXRhLT51c2JtaXNjX2RhdGEgPSB1c2JtaXNjX2dldF9pbml0X2RhdGEoJnBkZXYtPmRldik7 CisJZGF0YS0+dXNibWlzY19kYXRhID0gdXNibWlzY19nZXRfaW5pdF9kYXRhKGRldik7CiAJaWYg KElTX0VSUihkYXRhLT51c2JtaXNjX2RhdGEpKQogCQlyZXR1cm4gUFRSX0VSUihkYXRhLT51c2Jt aXNjX2RhdGEpOwogCi0JcmV0ID0gaW14X2dldF9jbGtzKCZwZGV2LT5kZXYpOworCWlmIChvZl91 c2JfZ2V0X3BoeV9tb2RlKGRldi0+b2Zfbm9kZSkgPT0gVVNCUEhZX0lOVEVSRkFDRV9NT0RFX0hT SUMpIHsKKwkJcGRhdGEuZmxhZ3MgfD0gQ0lfSERSQ19JTVhfSVNfSFNJQzsKKwkJZGF0YS0+dXNi bWlzY19kYXRhLT5oc2ljID0gMTsKKwkJZGF0YS0+cGluY3RybCA9IGRldm1fcGluY3RybF9nZXQo ZGV2KTsKKwkJaWYgKElTX0VSUihkYXRhLT5waW5jdHJsKSkgeworCQkJZGV2X2VycihkZXYsICJw aW5jdHJsIGdldCBmYWlsZWQsIGVycj0lbGRcbiIsCisJCQkJCVBUUl9FUlIoZGF0YS0+cGluY3Ry bCkpOworCQkJcmV0dXJuIFBUUl9FUlIoZGF0YS0+cGluY3RybCk7CisJCX0KKworCQlwaW5jdHJs X2hzaWNfaWRsZSA9IHBpbmN0cmxfbG9va3VwX3N0YXRlKGRhdGEtPnBpbmN0cmwsICJpZGxlIik7 CisJCWlmIChJU19FUlIocGluY3RybF9oc2ljX2lkbGUpKSB7CisJCQlkZXZfZXJyKGRldiwKKwkJ CQkicGluY3RybF9oc2ljX2lkbGUgbG9va3VwIGZhaWxlZCwgZXJyPSVsZFxuIiwKKwkJCQkJUFRS X0VSUihwaW5jdHJsX2hzaWNfaWRsZSkpOworCQkJcmV0dXJuIFBUUl9FUlIocGluY3RybF9oc2lj X2lkbGUpOworCQl9CisKKwkJcmV0ID0gcGluY3RybF9zZWxlY3Rfc3RhdGUoZGF0YS0+cGluY3Ry bCwgcGluY3RybF9oc2ljX2lkbGUpOworCQlpZiAocmV0KSB7CisJCQlkZXZfZXJyKGRldiwgImhz aWNfaWRsZSBzZWxlY3QgZmFpbGVkLCBlcnI9JWRcbiIsIHJldCk7CisJCQlyZXR1cm4gcmV0Owor CQl9CisKKwkJZGF0YS0+cGluY3RybF9oc2ljX2FjdGl2ZSA9IHBpbmN0cmxfbG9va3VwX3N0YXRl KGRhdGEtPnBpbmN0cmwsCisJCQkJCQkJCSJhY3RpdmUiKTsKKwkJaWYgKElTX0VSUihkYXRhLT5w aW5jdHJsX2hzaWNfYWN0aXZlKSkgeworCQkJZGV2X2VycihkZXYsCisJCQkJInBpbmN0cmxfaHNp Y19hY3RpdmUgbG9va3VwIGZhaWxlZCwgZXJyPSVsZFxuIiwKKwkJCQkJUFRSX0VSUihkYXRhLT5w aW5jdHJsX2hzaWNfYWN0aXZlKSk7CisJCQlyZXR1cm4gUFRSX0VSUihkYXRhLT5waW5jdHJsX2hz aWNfYWN0aXZlKTsKKwkJfQorCisJCWRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRvciA9IGRldm1fcmVn dWxhdG9yX2dldChkZXYsICJoc2ljIik7CisJCWlmIChQVFJfRVJSKGRhdGEtPmhzaWNfcGFkX3Jl Z3VsYXRvcikgPT0gLUVQUk9CRV9ERUZFUikgeworCQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7CisJ CX0gZWxzZSBpZiAoUFRSX0VSUihkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpID09IC1FTk9ERVYp IHsKKwkJCS8qIG5vIHBhZCByZWd1YWxhdG9yIGlzIG5lZWRlZCAqLworCQkJZGF0YS0+aHNpY19w YWRfcmVndWxhdG9yID0gTlVMTDsKKwkJfSBlbHNlIGlmIChJU19FUlIoZGF0YS0+aHNpY19wYWRf cmVndWxhdG9yKSkgeworCQkJZGV2X2VycihkZXYsICJHZXQgSFNJQyBwYWQgcmVndWxhdG9yIGVy cm9yOiAlbGRcbiIsCisJCQkJCVBUUl9FUlIoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKSk7CisJ CQlyZXR1cm4gUFRSX0VSUihkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpOworCQl9CisKKwkJaWYg KGRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRvcikgeworCQkJcmV0ID0gcmVndWxhdG9yX2VuYWJsZShk YXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpOworCQkJaWYgKHJldCkgeworCQkJCWRldl9lcnIoZGV2 LAorCQkJCQkiRmFpbCB0byBlbmFibGUgSFNJQyBwYWQgcmVndWxhdG9yXG4iKTsKKwkJCQlyZXR1 cm4gcmV0OworCQkJfQorCQl9CisJfQorCXJldCA9IGlteF9nZXRfY2xrcyhkZXYpOwogCWlmIChy ZXQpCi0JCXJldHVybiByZXQ7CisJCWdvdG8gZGlzYWJsZV9oc2ljX3JlZ3VsYXRvcjsKIAotCXJl dCA9IGlteF9wcmVwYXJlX2VuYWJsZV9jbGtzKCZwZGV2LT5kZXYpOworCXJldCA9IGlteF9wcmVw YXJlX2VuYWJsZV9jbGtzKGRldik7CiAJaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKKwkJZ290byBk aXNhYmxlX2hzaWNfcmVndWxhdG9yOwogCi0JZGF0YS0+cGh5ID0gZGV2bV91c2JfZ2V0X3BoeV9i eV9waGFuZGxlKCZwZGV2LT5kZXYsICJmc2wsdXNicGh5IiwgMCk7CisJZGF0YS0+cGh5ID0gZGV2 bV91c2JfZ2V0X3BoeV9ieV9waGFuZGxlKGRldiwgImZzbCx1c2JwaHkiLCAwKTsKIAlpZiAoSVNf RVJSKGRhdGEtPnBoeSkpIHsKIAkJcmV0ID0gUFRSX0VSUihkYXRhLT5waHkpOwogCQkvKiBSZXR1 cm4gLUVJTlZBTCBpZiBubyB1c2JwaHkgaXMgYXZhaWxhYmxlICovCkBAIC0zMDUsNDAgKzM5Myw0 MyBAQCBzdGF0aWMgaW50IGNpX2hkcmNfaW14X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KnBkZXYpCiAKIAlyZXQgPSBpbXhfdXNibWlzY19pbml0KGRhdGEtPnVzYm1pc2NfZGF0YSk7CiAJ aWYgKHJldCkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJ1c2JtaXNjIGluaXQgZmFpbGVkLCBy ZXQ9JWRcbiIsIHJldCk7CisJCWRldl9lcnIoZGV2LCAidXNibWlzYyBpbml0IGZhaWxlZCwgcmV0 PSVkXG4iLCByZXQpOwogCQlnb3RvIGVycl9jbGs7CiAJfQogCi0JZGF0YS0+Y2lfcGRldiA9IGNp X2hkcmNfYWRkX2RldmljZSgmcGRldi0+ZGV2LAorCWRhdGEtPmNpX3BkZXYgPSBjaV9oZHJjX2Fk ZF9kZXZpY2UoZGV2LAogCQkJCXBkZXYtPnJlc291cmNlLCBwZGV2LT5udW1fcmVzb3VyY2VzLAog CQkJCSZwZGF0YSk7CiAJaWYgKElTX0VSUihkYXRhLT5jaV9wZGV2KSkgewogCQlyZXQgPSBQVFJf RVJSKGRhdGEtPmNpX3BkZXYpOwogCQlpZiAocmV0ICE9IC1FUFJPQkVfREVGRVIpCi0JCQlkZXZf ZXJyKCZwZGV2LT5kZXYsCi0JCQkJImNpX2hkcmNfYWRkX2RldmljZSBmYWlsZWQsIGVycj0lZFxu IiwgcmV0KTsKKwkJCWRldl9lcnIoZGV2LCAiY2lfaGRyY19hZGRfZGV2aWNlIGZhaWxlZCwgZXJy PSVkXG4iLAorCQkJCQlyZXQpOwogCQlnb3RvIGVycl9jbGs7CiAJfQogCiAJcmV0ID0gaW14X3Vz Ym1pc2NfaW5pdF9wb3N0KGRhdGEtPnVzYm1pc2NfZGF0YSk7CiAJaWYgKHJldCkgewotCQlkZXZf ZXJyKCZwZGV2LT5kZXYsICJ1c2JtaXNjIHBvc3QgZmFpbGVkLCByZXQ9JWRcbiIsIHJldCk7CisJ CWRldl9lcnIoZGV2LCAidXNibWlzYyBwb3N0IGZhaWxlZCwgcmV0PSVkXG4iLCByZXQpOwogCQln b3RvIGRpc2FibGVfZGV2aWNlOwogCX0KIAogCWlmIChkYXRhLT5zdXBwb3J0c19ydW50aW1lX3Bt KSB7Ci0JCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZSgmcGRldi0+ZGV2KTsKLQkJcG1fcnVudGltZV9l bmFibGUoJnBkZXYtPmRldik7CisJCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZShkZXYpOworCQlwbV9y dW50aW1lX2VuYWJsZShkZXYpOwogCX0KIAotCWRldmljZV9zZXRfd2FrZXVwX2NhcGFibGUoJnBk ZXYtPmRldiwgdHJ1ZSk7CisJZGV2aWNlX3NldF93YWtldXBfY2FwYWJsZShkZXYsIHRydWUpOwog CiAJcmV0dXJuIDA7CiAKIGRpc2FibGVfZGV2aWNlOgogCWNpX2hkcmNfcmVtb3ZlX2RldmljZShk YXRhLT5jaV9wZGV2KTsKIGVycl9jbGs6Ci0JaW14X2Rpc2FibGVfdW5wcmVwYXJlX2Nsa3MoJnBk ZXYtPmRldik7CisJaW14X2Rpc2FibGVfdW5wcmVwYXJlX2Nsa3MoZGV2KTsKK2Rpc2FibGVfaHNp Y19yZWd1bGF0b3I6CisJaWYgKGRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRvcikKKwkJcmV0ID0gcmVn dWxhdG9yX2Rpc2FibGUoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKTsKIAlyZXR1cm4gcmV0Owog fQogCkBAIC0zNTUsNiArNDQ2LDggQEAgc3RhdGljIGludCBjaV9oZHJjX2lteF9yZW1vdmUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlpZiAoZGF0YS0+b3ZlcnJpZGVfcGh5X2NvbnRy b2wpCiAJCXVzYl9waHlfc2h1dGRvd24oZGF0YS0+cGh5KTsKIAlpbXhfZGlzYWJsZV91bnByZXBh cmVfY2xrcygmcGRldi0+ZGV2KTsKKwlpZiAoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKQorCQly ZWd1bGF0b3JfZGlzYWJsZShkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpOwogCiAJcmV0dXJuIDA7 CiB9CkBAIC0zNjcsOSArNDYwLDE2IEBAIHN0YXRpYyB2b2lkIGNpX2hkcmNfaW14X3NodXRkb3du KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiBzdGF0aWMgaW50IF9fbWF5YmVfdW51c2Vk IGlteF9jb250cm9sbGVyX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQogewogCXN0cnVjdCBj aV9oZHJjX2lteF9kYXRhICpkYXRhID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisJaW50IHJldCA9 IDA7CiAKIAlkZXZfZGJnKGRldiwgImF0ICVzXG4iLCBfX2Z1bmNfXyk7CiAKKwlyZXQgPSBpbXhf dXNibWlzY19oc2ljX3NldF9jbGsoZGF0YS0+dXNibWlzY19kYXRhLCBmYWxzZSk7CisJaWYgKHJl dCkgeworCQlkZXZfZXJyKGRldiwgInVzYm1pc2MgaHNpY19zZXRfY2xrIGZhaWxlZCwgcmV0PSVk XG4iLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKwogCWlteF9kaXNhYmxlX3VucHJlcGFyZV9j bGtzKGRldik7CiAJZGF0YS0+aW5fbHBtID0gdHJ1ZTsKIApAQCAtNDAwLDggKzUwMCwxNiBAQCBz dGF0aWMgaW50IF9fbWF5YmVfdW51c2VkIGlteF9jb250cm9sbGVyX3Jlc3VtZShzdHJ1Y3QgZGV2 aWNlICpkZXYpCiAJCWdvdG8gY2xrX2Rpc2FibGU7CiAJfQogCisJcmV0ID0gaW14X3VzYm1pc2Nf aHNpY19zZXRfY2xrKGRhdGEtPnVzYm1pc2NfZGF0YSwgdHJ1ZSk7CisJaWYgKHJldCkgeworCQlk ZXZfZXJyKGRldiwgInVzYm1pc2MgaHNpY19zZXRfY2xrIGZhaWxlZCwgcmV0PSVkXG4iLCByZXQp OworCQlnb3RvIGhzaWNfc2V0X2Nsa19mYWlsOworCX0KKwogCXJldHVybiAwOwogCitoc2ljX3Nl dF9jbGtfZmFpbDoKKwlpbXhfdXNibWlzY19zZXRfd2FrZXVwKGRhdGEtPnVzYm1pc2NfZGF0YSwg dHJ1ZSk7CiBjbGtfZGlzYWJsZToKIAlpbXhfZGlzYWJsZV91bnByZXBhcmVfY2xrcyhkZXYpOwog CXJldHVybiByZXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jaGlwaWRlYS9jaV9oZHJjX2lt eC5oIGIvZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguaAppbmRleCAyMDQyNzVmNDc1 NzMuLmZjZWNhYjQ3ODkzNCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRy Y19pbXguaAorKysgYi9kcml2ZXJzL3VzYi9jaGlwaWRlYS9jaV9oZHJjX2lteC5oCkBAIC0xNCwx MCArMTQsMTMgQEAgc3RydWN0IGlteF91c2JtaXNjX2RhdGEgewogCXVuc2lnbmVkIGludCBvY19w b2xhcml0eToxOyAvKiBvdmVyIGN1cnJlbnQgcG9sYXJpdHkgaWYgb2MgZW5hYmxlZCAqLwogCXVu c2lnbmVkIGludCBldmRvOjE7IC8qIHNldCBleHRlcm5hbCB2YnVzIGRpdmlkZXIgb3B0aW9uICov CiAJdW5zaWduZWQgaW50IHVscGk6MTsgLyogY29ubmVjdGVkIHRvIGFuIFVMUEkgcGh5ICovCisJ dW5zaWduZWQgaW50IGhzaWM6MTsgLyogSFNJQyBjb250cm9sbGxlciAqLwogfTsKIAotaW50IGlt eF91c2JtaXNjX2luaXQoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKik7Ci1pbnQgaW14X3VzYm1p c2NfaW5pdF9wb3N0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICopOwotaW50IGlteF91c2JtaXNj X3NldF93YWtldXAoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKiwgYm9vbCk7CitpbnQgaW14X3Vz Ym1pc2NfaW5pdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSk7CitpbnQgaW14X3VzYm1p c2NfaW5pdF9wb3N0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKTsKK2ludCBpbXhfdXNi bWlzY19zZXRfd2FrZXVwKHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhLCBib29sIGVuYWJs ZWQpOworaW50IGlteF91c2JtaXNjX2hzaWNfc2V0X2Nvbm5lY3Qoc3RydWN0IGlteF91c2JtaXNj X2RhdGEgKmRhdGEpOworaW50IGlteF91c2JtaXNjX2hzaWNfc2V0X2NsayhzdHJ1Y3QgaW14X3Vz Ym1pc2NfZGF0YSAqZGF0YSwgYm9vbCBvbik7CiAKICNlbmRpZiAvKiBfX0RSSVZFUl9VU0JfQ0hJ UElERUFfQ0lfSERSQ19JTVhfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2hpcGlkZWEv dXNibWlzY19pbXguYyBiL2RyaXZlcnMvdXNiL2NoaXBpZGVhL3VzYm1pc2NfaW14LmMKaW5kZXgg ZGVmODBmZjU0N2U0Li5kZjI0NGJlODBiOTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2NoaXBp ZGVhL3VzYm1pc2NfaW14LmMKKysrIGIvZHJpdmVycy91c2IvY2hpcGlkZWEvdXNibWlzY19pbXgu YwpAQCAtNjQsMTAgKzY0LDIyIEBACiAjZGVmaW5lIE1YNl9CTV9PVkVSX0NVUl9ESVMJCUJJVCg3 KQogI2RlZmluZSBNWDZfQk1fT1ZFUl9DVVJfUE9MQVJJVFkJQklUKDgpCiAjZGVmaW5lIE1YNl9C TV9XQUtFVVBfRU5BQkxFCQlCSVQoMTApCisjZGVmaW5lIE1YNl9CTV9VVE1JX09OX0NMT0NLCQlC SVQoMTMpCiAjZGVmaW5lIE1YNl9CTV9JRF9XQUtFVVAJCUJJVCgxNikKICNkZWZpbmUgTVg2X0JN X1ZCVVNfV0FLRVVQCQlCSVQoMTcpCiAjZGVmaW5lIE1YNlNYX0JNX0RQRE1fV0FLRVVQX0VOCQlC SVQoMjkpCiAjZGVmaW5lIE1YNl9CTV9XQUtFVVBfSU5UUgkJQklUKDMxKQorCisjZGVmaW5lIE1Y Nl9VU0JfSFNJQ19DVFJMX09GRlNFVAkweDEwCisvKiBTZW5kIHJlc3VtZSBzaWduYWwgd2l0aG91 dCA0ODBNaHogUEhZIGNsb2NrICovCisjZGVmaW5lIE1YNlNYX0JNX0hTSUNfQVVUT19SRVNVTUUJ QklUKDIzKQorLyogc2V0IGJlZm9yZSBwb3J0c2Muc3VzcGVuZE0gPSAxICovCisjZGVmaW5lIE1Y Nl9CTV9IU0lDX0RFVl9DT05OCQlCSVQoMjEpCisvKiBIU0lDIGVuYWJsZSAqLworI2RlZmluZSBN WDZfQk1fSFNJQ19FTgkJCUJJVCgxMikKKy8qIEZvcmNlIEhTSUMgbW9kdWxlIDQ4ME0gY2xvY2sg b24sIGV2ZW4gd2hlbiBpbiBIb3N0IGlzIGluIHN1c3BlbmQgbW9kZSAqLworI2RlZmluZSBNWDZf Qk1fSFNJQ19DTEtfT04JCUJJVCgxMSkKKwogI2RlZmluZSBNWDZfVVNCX09URzFfUEhZX0NUUkwJ CTB4MTgKIC8qIEZvciBpbXg2ZHFsLCBpdCBpcyBob3N0LW9ubHkgY29udHJvbGxlciwgZm9yIGxh dGVyIGlteDYsIGl0IGlzIG90ZydzICovCiAjZGVmaW5lIE1YNl9VU0JfT1RHMl9QSFlfQ1RSTAkJ MHgxYwpAQCAtOTQsNiArMTA2LDEwIEBAIHN0cnVjdCB1c2JtaXNjX29wcyB7CiAJaW50ICgqcG9z dCkoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpOwogCS8qIEl0J3MgY2FsbGVkIHdoZW4g d2UgbmVlZCB0byBlbmFibGUvZGlzYWJsZSB1c2Igd2FrZXVwICovCiAJaW50ICgqc2V0X3dha2V1 cCkoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wgZW5hYmxlZCk7CisJLyogSXQn cyBjYWxsZWQgYmVmb3JlIHNldHRpbmcgcG9ydHNjLnN1c3BlbmRNICovCisJaW50ICgqaHNpY19z ZXRfY29ubmVjdCkoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpOworCS8qIEl0J3MgY2Fs bGVkIGR1cmluZyBzdXNwZW5kL3Jlc3VtZSAqLworCWludCAoKmhzaWNfc2V0X2Nsaykoc3RydWN0 IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wgZW5hYmxlZCk7CiB9OwogCiBzdHJ1Y3QgaW14 X3VzYm1pc2MgewpAQCAtMzUzLDYgKzM2OSwxOCBAQCBzdGF0aWMgaW50IHVzYm1pc2NfaW14NnFf aW5pdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSkKIAl3cml0ZWwocmVnIHwgTVg2X0JN X05PTl9CVVJTVF9TRVRUSU5HLAogCQkJdXNibWlzYy0+YmFzZSArIGRhdGEtPmluZGV4ICogNCk7 CiAKKwkvKiBGb3IgSFNJQyBjb250cm9sbGVyICovCisJaWYgKGRhdGEtPmhzaWMpIHsKKwkJcmVn ID0gcmVhZGwodXNibWlzYy0+YmFzZSArIGRhdGEtPmluZGV4ICogNCk7CisJCXdyaXRlbChyZWcg fCBNWDZfQk1fVVRNSV9PTl9DTE9DSywKKwkJCXVzYm1pc2MtPmJhc2UgKyBkYXRhLT5pbmRleCAq IDQpOworCQlyZWcgPSByZWFkbCh1c2JtaXNjLT5iYXNlICsgTVg2X1VTQl9IU0lDX0NUUkxfT0ZG U0VUCisJCQkrIChkYXRhLT5pbmRleCAtIDIpICogNCk7CisJCXJlZyB8PSBNWDZfQk1fSFNJQ19F TiB8IE1YNl9CTV9IU0lDX0NMS19PTjsKKwkJd3JpdGVsKHJlZywgdXNibWlzYy0+YmFzZSArIE1Y Nl9VU0JfSFNJQ19DVFJMX09GRlNFVAorCQkJKyAoZGF0YS0+aW5kZXggLSAyKSAqIDQpOworCX0K KwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdzKTsKIAogCXVz Ym1pc2NfaW14NnFfc2V0X3dha2V1cChkYXRhLCBmYWxzZSk7CkBAIC0zNjAsNiArMzg4LDY5IEBA IHN0YXRpYyBpbnQgdXNibWlzY19pbXg2cV9pbml0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpk YXRhKQogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IHVzYm1pc2NfaW14Nl9oc2ljX3NldF9j b25uZWN0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQoreworCXVuc2lnbmVkIGxvbmcg ZmxhZ3M7CisJdTMyIHZhbCwgb2Zmc2V0OworCXN0cnVjdCBpbXhfdXNibWlzYyAqdXNibWlzYyA9 IGRldl9nZXRfZHJ2ZGF0YShkYXRhLT5kZXYpOworCWludCByZXQgPSAwOworCisJc3Bpbl9sb2Nr X2lycXNhdmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdzKTsKKwlpZiAoZGF0YS0+aW5kZXggPT0gMiB8 fCBkYXRhLT5pbmRleCA9PSAzKSB7CisJCW9mZnNldCA9IChkYXRhLT5pbmRleCAtIDIpICogNDsK Kwl9IGVsc2UgaWYgKGRhdGEtPmluZGV4ID09IDApIHsKKwkJLyoKKwkJICogRm9yIFNvQ3MgbGlr ZSBpLk1YN0QgYW5kIGxhdGVyLCBlYWNoIFVTQiBjb250cm9sbGVyIGhhcworCQkgKiBpdHMgb3du IG5vbi1jb3JlIHJlZ2lzdGVyIHJlZ2lvbi4gRm9yIFNvQ3MgYmVmb3JlIGkuTVg3RCwKKwkJICog dGhlIGZpcnN0IFVTQiBjb250cm9sbGVyIGlzIG5vbi1IU0lDIGNvbnRyb2xsZXIuCisJCSAqLwor CQlvZmZzZXQgPSAwOworCX0gZWxzZSB7CisJCWRldl9lcnIoZGF0YS0+ZGV2LCAiaW5kZXggaXMg ZXJyb3IgZm9yIHVzYm1pc2NcbiIpOworCQlvZmZzZXQgPSAwOworCQlyZXQgPSAtRUlOVkFMOwor CX0KKworCXZhbCA9IHJlYWRsKHVzYm1pc2MtPmJhc2UgKyBNWDZfVVNCX0hTSUNfQ1RSTF9PRkZT RVQgKyBvZmZzZXQpOworCWlmICghKHZhbCAmIE1YNl9CTV9IU0lDX0RFVl9DT05OKSkKKwkJd3Jp dGVsKHZhbCB8IE1YNl9CTV9IU0lDX0RFVl9DT05OLAorCQkJdXNibWlzYy0+YmFzZSArIE1YNl9V U0JfSFNJQ19DVFJMX09GRlNFVCArIG9mZnNldCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgm dXNibWlzYy0+bG9jaywgZmxhZ3MpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCB1 c2JtaXNjX2lteDZfaHNpY19zZXRfY2xrKHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhLCBi b29sIG9uKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdTMyIHZhbCwgb2Zmc2V0OworCXN0 cnVjdCBpbXhfdXNibWlzYyAqdXNibWlzYyA9IGRldl9nZXRfZHJ2ZGF0YShkYXRhLT5kZXYpOwor CWludCByZXQgPSAwOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdz KTsKKwlpZiAoZGF0YS0+aW5kZXggPT0gMiB8fCBkYXRhLT5pbmRleCA9PSAzKSB7CisJCW9mZnNl dCA9IChkYXRhLT5pbmRleCAtIDIpICogNDsKKwl9IGVsc2UgaWYgKGRhdGEtPmluZGV4ID09IDAp IHsKKwkJb2Zmc2V0ID0gMDsKKwl9IGVsc2UgeworCQlkZXZfZXJyKGRhdGEtPmRldiwgImluZGV4 IGlzIGVycm9yIGZvciB1c2JtaXNjXG4iKTsKKwkJb2Zmc2V0ID0gMDsKKwkJcmV0ID0gLUVJTlZB TDsKKwl9CisKKwl2YWwgPSByZWFkbCh1c2JtaXNjLT5iYXNlICsgTVg2X1VTQl9IU0lDX0NUUkxf T0ZGU0VUICsgb2Zmc2V0KTsKKwl2YWwgfD0gTVg2X0JNX0hTSUNfRU4gfCBNWDZfQk1fSFNJQ19D TEtfT047CisJaWYgKG9uKQorCQl2YWwgfD0gTVg2X0JNX0hTSUNfQ0xLX09OOworCWVsc2UKKwkJ dmFsICY9IH5NWDZfQk1fSFNJQ19DTEtfT047CisJd3JpdGVsKHZhbCwgdXNibWlzYy0+YmFzZSAr IE1YNl9VU0JfSFNJQ19DVFJMX09GRlNFVCArIG9mZnNldCk7CisJc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgmdXNibWlzYy0+bG9jaywgZmxhZ3MpOworCisJcmV0dXJuIDA7Cit9CisKKwogc3RhdGlj IGludCB1c2JtaXNjX2lteDZzeF9pbml0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQog ewogCXZvaWQgX19pb21lbSAqcmVnID0gTlVMTDsKQEAgLTM4NSw2ICs0NzYsMTMgQEAgc3RhdGlj IGludCB1c2JtaXNjX2lteDZzeF9pbml0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQog CQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ1c2JtaXNjLT5sb2NrLCBmbGFncyk7CiAJfQogCisJ LyogRm9yIEhTSUMgY29udHJvbGxlciAqLworCWlmIChkYXRhLT5oc2ljKSB7CisJCXZhbCA9IHJl YWRsKHVzYm1pc2MtPmJhc2UgKyBNWDZfVVNCX0hTSUNfQ1RSTF9PRkZTRVQpOworCQl2YWwgfD0g TVg2U1hfQk1fSFNJQ19BVVRPX1JFU1VNRTsKKwkJd3JpdGVsKHZhbCwgdXNibWlzYy0+YmFzZSAr IE1YNl9VU0JfSFNJQ19DVFJMX09GRlNFVCk7CisJfQorCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTQ1 NCw2ICs1NTIsNyBAQCBzdGF0aWMgaW50IHVzYm1pc2NfaW14N2RfaW5pdChzdHJ1Y3QgaW14X3Vz Ym1pc2NfZGF0YSAqZGF0YSkKIAlyZWcgJj0gfk1YN0RfVVNCX1ZCVVNfV0FLRVVQX1NPVVJDRV9N QVNLOwogCXdyaXRlbChyZWcgfCBNWDdEX1VTQl9WQlVTX1dBS0VVUF9TT1VSQ0VfQlZBTElELAog CQkgdXNibWlzYy0+YmFzZSArIE1YN0RfVVNCTkNfVVNCX0NUUkwyKTsKKwogCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdzKTsKIAogCXVzYm1pc2NfaW14N2Rfc2V0 X3dha2V1cChkYXRhLCBmYWxzZSk7CkBAIC00ODEsNiArNTgwLDggQEAgc3RhdGljIGNvbnN0IHN0 cnVjdCB1c2JtaXNjX29wcyBpbXg1M191c2JtaXNjX29wcyA9IHsKIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgdXNibWlzY19vcHMgaW14NnFfdXNibWlzY19vcHMgPSB7CiAJLnNldF93YWtldXAgPSB1c2Jt aXNjX2lteDZxX3NldF93YWtldXAsCiAJLmluaXQgPSB1c2JtaXNjX2lteDZxX2luaXQsCisJLmhz aWNfc2V0X2Nvbm5lY3QgPSB1c2JtaXNjX2lteDZfaHNpY19zZXRfY29ubmVjdCwKKwkuaHNpY19z ZXRfY2xrICAgPSB1c2JtaXNjX2lteDZfaHNpY19zZXRfY2xrLAogfTsKIAogc3RhdGljIGNvbnN0 IHN0cnVjdCB1c2JtaXNjX29wcyB2ZjYxMF91c2JtaXNjX29wcyA9IHsKQEAgLTQ5MCw2ICs1OTEs OCBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHVzYm1pc2Nfb3BzIHZmNjEwX3VzYm1pc2Nfb3BzID0g ewogc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JtaXNjX29wcyBpbXg2c3hfdXNibWlzY19vcHMgPSB7 CiAJLnNldF93YWtldXAgPSB1c2JtaXNjX2lteDZxX3NldF93YWtldXAsCiAJLmluaXQgPSB1c2Jt aXNjX2lteDZzeF9pbml0LAorCS5oc2ljX3NldF9jb25uZWN0ID0gdXNibWlzY19pbXg2X2hzaWNf c2V0X2Nvbm5lY3QsCisJLmhzaWNfc2V0X2NsayA9IHVzYm1pc2NfaW14Nl9oc2ljX3NldF9jbGss CiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHVzYm1pc2Nfb3BzIGlteDdkX3VzYm1pc2Nfb3Bz ID0gewpAQCAtNTQ2LDYgKzY0OSwzMyBAQCBpbnQgaW14X3VzYm1pc2Nfc2V0X3dha2V1cChzdHJ1 Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSwgYm9vbCBlbmFibGVkKQogfQogRVhQT1JUX1NZTUJP TF9HUEwoaW14X3VzYm1pc2Nfc2V0X3dha2V1cCk7CiAKK2ludCBpbXhfdXNibWlzY19oc2ljX3Nl dF9jb25uZWN0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQoreworCXN0cnVjdCBpbXhf dXNibWlzYyAqdXNibWlzYzsKKworCWlmICghZGF0YSkKKwkJcmV0dXJuIDA7CisKKwl1c2JtaXNj ID0gZGV2X2dldF9kcnZkYXRhKGRhdGEtPmRldik7CisJaWYgKCF1c2JtaXNjLT5vcHMtPmhzaWNf c2V0X2Nvbm5lY3QgfHwgIWRhdGEtPmhzaWMpCisJCXJldHVybiAwOworCXJldHVybiB1c2JtaXNj LT5vcHMtPmhzaWNfc2V0X2Nvbm5lY3QoZGF0YSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChpbXhf dXNibWlzY19oc2ljX3NldF9jb25uZWN0KTsKKworaW50IGlteF91c2JtaXNjX2hzaWNfc2V0X2Ns ayhzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSwgYm9vbCBvbikKK3sKKwlzdHJ1Y3QgaW14 X3VzYm1pc2MgKnVzYm1pc2M7CisKKwlpZiAoIWRhdGEpCisJCXJldHVybiAwOworCisJdXNibWlz YyA9IGRldl9nZXRfZHJ2ZGF0YShkYXRhLT5kZXYpOworCWlmICghdXNibWlzYy0+b3BzLT5oc2lj X3NldF9jbGsgfHwgIWRhdGEtPmhzaWMpCisJCXJldHVybiAwOworCXJldHVybiB1c2JtaXNjLT5v cHMtPmhzaWNfc2V0X2NsayhkYXRhLCBvbik7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChpbXhfdXNi bWlzY19oc2ljX3NldF9jbGspOwogc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgdXNi bWlzY19pbXhfZHRfaWRzW10gPSB7CiAJewogCQkuY29tcGF0aWJsZSA9ICJmc2wsaW14MjUtdXNi bWlzYyIsCg==