From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:40906 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751754AbdCCRXF (ORCPT ); Fri, 3 Mar 2017 12:23:05 -0500 From: Laurent Pinchart To: dri-devel@lists.freedesktop.org Cc: Andy Yan , Archit Taneja , Fabio Estevam , Jose Abreu , Kieran Bingham , Neil Armstrong , Nickey Yang , Russell King , Vladimir Zapolskiy , linux-renesas-soc@vger.kernel.org Subject: [PATCH v5 06/10] drm: bridge: dw-hdmi: Create PHY operations Date: Fri, 3 Mar 2017 19:20:03 +0200 Message-Id: <20170303172007.26541-7-laurent.pinchart+renesas@ideasonboard.com> In-Reply-To: <20170303172007.26541-1-laurent.pinchart+renesas@ideasonboard.com> References: <20170303172007.26541-1-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: The HDMI TX controller support different PHYs whose programming interface can vary significantly, especially with vendor PHYs that are not provided by Synopsys. To support them, create a PHY operation structure that can be provided by the platform glue layer. The existing PHY handling code (limited to Synopsys PHY support) is refactored into a set of default PHY operations that are used automatically when the platform glue doesn't provide its own operations. Signed-off-by: Laurent Pinchart Tested-by: Neil Armstrong Reviewed-by: Jose Abreu --- drivers/gpu/drm/bridge/dw-hdmi.c | 91 ++++++++++++++++++++++++++++------------ include/drm/bridge/dw_hdmi.h | 18 +++++++- 2 files changed, 80 insertions(+), 29 deletions(-) diff --git a/drivers/gpu/drm/bridge/dw-hdmi.c b/drivers/gpu/drm/bridge/dw-hdmi.c index 0aa3ad404f77..cb2703862be2 100644 --- a/drivers/gpu/drm/bridge/dw-hdmi.c +++ b/drivers/gpu/drm/bridge/dw-hdmi.c @@ -141,8 +141,12 @@ struct dw_hdmi { u8 edid[HDMI_EDID_LEN]; bool cable_plugin; - const struct dw_hdmi_phy_data *phy; - bool phy_enabled; + struct { + const struct dw_hdmi_phy_ops *ops; + const char *name; + void *data; + bool enabled; + } phy; struct drm_display_mode previous_mode; @@ -831,6 +835,10 @@ static void hdmi_video_packetize(struct dw_hdmi *hdmi) HDMI_VP_CONF); } +/* ----------------------------------------------------------------------------- + * Synopsys PHY Handling + */ + static inline void hdmi_phy_test_clear(struct dw_hdmi *hdmi, unsigned char bit) { @@ -987,6 +995,7 @@ static int dw_hdmi_phy_power_on(struct dw_hdmi *hdmi) static int hdmi_phy_configure(struct dw_hdmi *hdmi) { + const struct dw_hdmi_phy_data *phy = hdmi->phy.data; const struct dw_hdmi_plat_data *pdata = hdmi->plat_data; const struct dw_hdmi_mpll_config *mpll_config = pdata->mpll_cfg; const struct dw_hdmi_curr_ctrl *curr_ctrl = pdata->cur_ctr; @@ -1019,7 +1028,7 @@ static int hdmi_phy_configure(struct dw_hdmi *hdmi) dw_hdmi_phy_power_off(hdmi); /* Leave low power consumption mode by asserting SVSRET. */ - if (hdmi->phy->has_svsret) + if (phy->has_svsret) dw_hdmi_phy_enable_svsret(hdmi, 1); /* PHY reset. The reset signal is active high on Gen2 PHYs. */ @@ -1057,7 +1066,8 @@ static int hdmi_phy_configure(struct dw_hdmi *hdmi) return dw_hdmi_phy_power_on(hdmi); } -static int dw_hdmi_phy_init(struct dw_hdmi *hdmi) +static int dw_hdmi_phy_init(struct dw_hdmi *hdmi, void *data, + struct drm_display_mode *mode) { int i, ret; @@ -1071,10 +1081,31 @@ static int dw_hdmi_phy_init(struct dw_hdmi *hdmi) return ret; } - hdmi->phy_enabled = true; return 0; } +static void dw_hdmi_phy_disable(struct dw_hdmi *hdmi, void *data) +{ + dw_hdmi_phy_power_off(hdmi); +} + +static enum drm_connector_status dw_hdmi_phy_read_hpd(struct dw_hdmi *hdmi, + void *data) +{ + return hdmi_readb(hdmi, HDMI_PHY_STAT0) & HDMI_PHY_HPD ? + connector_status_connected : connector_status_disconnected; +} + +static const struct dw_hdmi_phy_ops dw_hdmi_synopsys_phy_ops = { + .init = dw_hdmi_phy_init, + .disable = dw_hdmi_phy_disable, + .read_hpd = dw_hdmi_phy_read_hpd, +}; + +/* ----------------------------------------------------------------------------- + * HDMI TX Setup + */ + static void hdmi_tx_hdcp_config(struct dw_hdmi *hdmi) { u8 de; @@ -1289,16 +1320,6 @@ static void hdmi_av_composer(struct dw_hdmi *hdmi, hdmi_writeb(hdmi, vsync_len, HDMI_FC_VSYNCINWIDTH); } -static void dw_hdmi_phy_disable(struct dw_hdmi *hdmi) -{ - if (!hdmi->phy_enabled) - return; - - dw_hdmi_phy_power_off(hdmi); - - hdmi->phy_enabled = false; -} - /* HDMI Initialization Step B.4 */ static void dw_hdmi_enable_video_path(struct dw_hdmi *hdmi) { @@ -1431,9 +1452,10 @@ static int dw_hdmi_setup(struct dw_hdmi *hdmi, struct drm_display_mode *mode) hdmi_av_composer(hdmi, mode); /* HDMI Initializateion Step B.2 */ - ret = dw_hdmi_phy_init(hdmi); + ret = hdmi->phy.ops->init(hdmi, hdmi->phy.data, &hdmi->previous_mode); if (ret) return ret; + hdmi->phy.enabled = true; /* HDMI Initialization Step B.3 */ dw_hdmi_enable_video_path(hdmi); @@ -1548,7 +1570,11 @@ static void dw_hdmi_poweron(struct dw_hdmi *hdmi) static void dw_hdmi_poweroff(struct dw_hdmi *hdmi) { - dw_hdmi_phy_disable(hdmi); + if (hdmi->phy.enabled) { + hdmi->phy.ops->disable(hdmi, hdmi->phy.data); + hdmi->phy.enabled = false; + } + hdmi->bridge_is_on = false; } @@ -1611,8 +1637,7 @@ dw_hdmi_connector_detect(struct drm_connector *connector, bool force) dw_hdmi_update_phy_mask(hdmi); mutex_unlock(&hdmi->mutex); - return hdmi_readb(hdmi, HDMI_PHY_STAT0) & HDMI_PHY_HPD ? - connector_status_connected : connector_status_disconnected; + return hdmi->phy.ops->read_hpd(hdmi, hdmi->phy.data); } static int dw_hdmi_connector_get_modes(struct drm_connector *connector) @@ -1898,19 +1923,31 @@ static int dw_hdmi_detect_phy(struct dw_hdmi *hdmi) phy_type = hdmi_readb(hdmi, HDMI_CONFIG2_ID); + if (phy_type == DW_HDMI_PHY_VENDOR_PHY) { + /* Vendor PHYs require support from the glue layer. */ + if (!hdmi->plat_data->phy_ops || !hdmi->plat_data->phy_name) { + dev_err(hdmi->dev, + "Vendor HDMI PHY not supported by glue layer\n"); + return -ENODEV; + } + + hdmi->phy.ops = hdmi->plat_data->phy_ops; + hdmi->phy.data = hdmi->plat_data->phy_data; + hdmi->phy.name = hdmi->plat_data->phy_name; + return 0; + } + + /* Synopsys PHYs are handled internally. */ for (i = 0; i < ARRAY_SIZE(dw_hdmi_phys); ++i) { if (dw_hdmi_phys[i].type == phy_type) { - hdmi->phy = &dw_hdmi_phys[i]; + hdmi->phy.ops = &dw_hdmi_synopsys_phy_ops; + hdmi->phy.name = dw_hdmi_phys[i].name; + hdmi->phy.data = (void *)&dw_hdmi_phys[i]; return 0; } } - if (phy_type == DW_HDMI_PHY_VENDOR_PHY) - dev_err(hdmi->dev, "Unsupported vendor HDMI PHY\n"); - else - dev_err(hdmi->dev, "Unsupported HDMI PHY type (%02x)\n", - phy_type); - + dev_err(hdmi->dev, "Unsupported HDMI PHY type (%02x)\n", phy_type); return -ENODEV; } @@ -2031,7 +2068,7 @@ __dw_hdmi_probe(struct platform_device *pdev, dev_info(dev, "Detected HDMI TX controller v%x.%03x %s HDCP (%s)\n", hdmi->version >> 12, hdmi->version & 0xfff, prod_id1 & HDMI_PRODUCT_ID1_HDCP ? "with" : "without", - hdmi->phy->name); + hdmi->phy.name); initialize_hdmi_ih_mutes(hdmi); diff --git a/include/drm/bridge/dw_hdmi.h b/include/drm/bridge/dw_hdmi.h index b080a171a23f..0f583ca7e66e 100644 --- a/include/drm/bridge/dw_hdmi.h +++ b/include/drm/bridge/dw_hdmi.h @@ -57,13 +57,27 @@ struct dw_hdmi_phy_config { u16 vlev_ctr; /* voltage level control */ }; +struct dw_hdmi_phy_ops { + int (*init)(struct dw_hdmi *hdmi, void *data, + struct drm_display_mode *mode); + void (*disable)(struct dw_hdmi *hdmi, void *data); + enum drm_connector_status (*read_hpd)(struct dw_hdmi *hdmi, void *data); +}; + struct dw_hdmi_plat_data { enum dw_hdmi_devtype dev_type; + enum drm_mode_status (*mode_valid)(struct drm_connector *connector, + struct drm_display_mode *mode); + + /* Vendor PHY support */ + const struct dw_hdmi_phy_ops *phy_ops; + const char *phy_name; + void *phy_data; + + /* Synopsys PHY support */ const struct dw_hdmi_mpll_config *mpll_cfg; const struct dw_hdmi_curr_ctrl *cur_ctr; const struct dw_hdmi_phy_config *phy_config; - enum drm_mode_status (*mode_valid)(struct drm_connector *connector, - struct drm_display_mode *mode); }; int dw_hdmi_probe(struct platform_device *pdev, -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: [PATCH v5 06/10] drm: bridge: dw-hdmi: Create PHY operations Date: Fri, 3 Mar 2017 19:20:03 +0200 Message-ID: <20170303172007.26541-7-laurent.pinchart+renesas@ideasonboard.com> References: <20170303172007.26541-1-laurent.pinchart+renesas@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from galahad.ideasonboard.com (galahad.ideasonboard.com [185.26.127.97]) by gabe.freedesktop.org (Postfix) with ESMTPS id 592066EDAA for ; Fri, 3 Mar 2017 17:19:42 +0000 (UTC) In-Reply-To: <20170303172007.26541-1-laurent.pinchart+renesas@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: Fabio Estevam , Jose Abreu , Neil Armstrong , Kieran Bingham , linux-renesas-soc@vger.kernel.org, Nickey Yang , Russell King , Andy Yan , Vladimir Zapolskiy List-Id: dri-devel@lists.freedesktop.org VGhlIEhETUkgVFggY29udHJvbGxlciBzdXBwb3J0IGRpZmZlcmVudCBQSFlzIHdob3NlIHByb2dy YW1taW5nCmludGVyZmFjZSBjYW4gdmFyeSBzaWduaWZpY2FudGx5LCBlc3BlY2lhbGx5IHdpdGgg dmVuZG9yIFBIWXMgdGhhdCBhcmUKbm90IHByb3ZpZGVkIGJ5IFN5bm9wc3lzLiBUbyBzdXBwb3J0 IHRoZW0sIGNyZWF0ZSBhIFBIWSBvcGVyYXRpb24Kc3RydWN0dXJlIHRoYXQgY2FuIGJlIHByb3Zp ZGVkIGJ5IHRoZSBwbGF0Zm9ybSBnbHVlIGxheWVyLiBUaGUgZXhpc3RpbmcKUEhZIGhhbmRsaW5n IGNvZGUgKGxpbWl0ZWQgdG8gU3lub3BzeXMgUEhZIHN1cHBvcnQpIGlzIHJlZmFjdG9yZWQgaW50 byBhCnNldCBvZiBkZWZhdWx0IFBIWSBvcGVyYXRpb25zIHRoYXQgYXJlIHVzZWQgYXV0b21hdGlj YWxseSB3aGVuIHRoZQpwbGF0Zm9ybSBnbHVlIGRvZXNuJ3QgcHJvdmlkZSBpdHMgb3duIG9wZXJh dGlvbnMuCgpTaWduZWQtb2ZmLWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0 K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KVGVzdGVkLWJ5OiBOZWlsIEFybXN0cm9uZyA8bmFy bXN0cm9uZ0BiYXlsaWJyZS5jb20+ClJldmlld2VkLWJ5OiBKb3NlIEFicmV1IDxqb2FicmV1QHN5 bm9wc3lzLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2R3LWhkbWkuYyB8IDkxICsr KysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0KIGluY2x1ZGUvZHJtL2JyaWRn ZS9kd19oZG1pLmggICAgIHwgMTggKysrKysrKy0KIDIgZmlsZXMgY2hhbmdlZCwgODAgaW5zZXJ0 aW9ucygrKSwgMjkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2Jy aWRnZS9kdy1oZG1pLmMgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2R3LWhkbWkuYwppbmRleCAw YWEzYWQ0MDRmNzcuLmNiMjcwMzg2MmJlMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2Jy aWRnZS9kdy1oZG1pLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9kdy1oZG1pLmMKQEAg LTE0MSw4ICsxNDEsMTIgQEAgc3RydWN0IGR3X2hkbWkgewogCXU4IGVkaWRbSERNSV9FRElEX0xF Tl07CiAJYm9vbCBjYWJsZV9wbHVnaW47CiAKLQljb25zdCBzdHJ1Y3QgZHdfaGRtaV9waHlfZGF0 YSAqcGh5OwotCWJvb2wgcGh5X2VuYWJsZWQ7CisJc3RydWN0IHsKKwkJY29uc3Qgc3RydWN0IGR3 X2hkbWlfcGh5X29wcyAqb3BzOworCQljb25zdCBjaGFyICpuYW1lOworCQl2b2lkICpkYXRhOwor CQlib29sIGVuYWJsZWQ7CisJfSBwaHk7CiAKIAlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSBwcmV2 aW91c19tb2RlOwogCkBAIC04MzEsNiArODM1LDEwIEBAIHN0YXRpYyB2b2lkIGhkbWlfdmlkZW9f cGFja2V0aXplKHN0cnVjdCBkd19oZG1pICpoZG1pKQogCQkgIEhETUlfVlBfQ09ORik7CiB9CiAK Ky8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKiBTeW5vcHN5cyBQSFkgSGFuZGxpbmcKKyAqLwor CiBzdGF0aWMgaW5saW5lIHZvaWQgaGRtaV9waHlfdGVzdF9jbGVhcihzdHJ1Y3QgZHdfaGRtaSAq aGRtaSwKIAkJCQkgICAgICAgdW5zaWduZWQgY2hhciBiaXQpCiB7CkBAIC05ODcsNiArOTk1LDcg QEAgc3RhdGljIGludCBkd19oZG1pX3BoeV9wb3dlcl9vbihzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkK IAogc3RhdGljIGludCBoZG1pX3BoeV9jb25maWd1cmUoc3RydWN0IGR3X2hkbWkgKmhkbWkpCiB7 CisJY29uc3Qgc3RydWN0IGR3X2hkbWlfcGh5X2RhdGEgKnBoeSA9IGhkbWktPnBoeS5kYXRhOwog CWNvbnN0IHN0cnVjdCBkd19oZG1pX3BsYXRfZGF0YSAqcGRhdGEgPSBoZG1pLT5wbGF0X2RhdGE7 CiAJY29uc3Qgc3RydWN0IGR3X2hkbWlfbXBsbF9jb25maWcgKm1wbGxfY29uZmlnID0gcGRhdGEt Pm1wbGxfY2ZnOwogCWNvbnN0IHN0cnVjdCBkd19oZG1pX2N1cnJfY3RybCAqY3Vycl9jdHJsID0g cGRhdGEtPmN1cl9jdHI7CkBAIC0xMDE5LDcgKzEwMjgsNyBAQCBzdGF0aWMgaW50IGhkbWlfcGh5 X2NvbmZpZ3VyZShzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkKIAlkd19oZG1pX3BoeV9wb3dlcl9vZmYo aGRtaSk7CiAKIAkvKiBMZWF2ZSBsb3cgcG93ZXIgY29uc3VtcHRpb24gbW9kZSBieSBhc3NlcnRp bmcgU1ZTUkVULiAqLwotCWlmIChoZG1pLT5waHktPmhhc19zdnNyZXQpCisJaWYgKHBoeS0+aGFz X3N2c3JldCkKIAkJZHdfaGRtaV9waHlfZW5hYmxlX3N2c3JldChoZG1pLCAxKTsKIAogCS8qIFBI WSByZXNldC4gVGhlIHJlc2V0IHNpZ25hbCBpcyBhY3RpdmUgaGlnaCBvbiBHZW4yIFBIWXMuICov CkBAIC0xMDU3LDcgKzEwNjYsOCBAQCBzdGF0aWMgaW50IGhkbWlfcGh5X2NvbmZpZ3VyZShzdHJ1 Y3QgZHdfaGRtaSAqaGRtaSkKIAlyZXR1cm4gZHdfaGRtaV9waHlfcG93ZXJfb24oaGRtaSk7CiB9 CiAKLXN0YXRpYyBpbnQgZHdfaGRtaV9waHlfaW5pdChzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkKK3N0 YXRpYyBpbnQgZHdfaGRtaV9waHlfaW5pdChzdHJ1Y3QgZHdfaGRtaSAqaGRtaSwgdm9pZCAqZGF0 YSwKKwkJCSAgICBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSkKIHsKIAlpbnQgaSwgcmV0 OwogCkBAIC0xMDcxLDEwICsxMDgxLDMxIEBAIHN0YXRpYyBpbnQgZHdfaGRtaV9waHlfaW5pdChz dHJ1Y3QgZHdfaGRtaSAqaGRtaSkKIAkJCXJldHVybiByZXQ7CiAJfQogCi0JaGRtaS0+cGh5X2Vu YWJsZWQgPSB0cnVlOwogCXJldHVybiAwOwogfQogCitzdGF0aWMgdm9pZCBkd19oZG1pX3BoeV9k aXNhYmxlKHN0cnVjdCBkd19oZG1pICpoZG1pLCB2b2lkICpkYXRhKQoreworCWR3X2hkbWlfcGh5 X3Bvd2VyX29mZihoZG1pKTsKK30KKworc3RhdGljIGVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMg ZHdfaGRtaV9waHlfcmVhZF9ocGQoc3RydWN0IGR3X2hkbWkgKmhkbWksCisJCQkJCQkgICAgICB2 b2lkICpkYXRhKQoreworCXJldHVybiBoZG1pX3JlYWRiKGhkbWksIEhETUlfUEhZX1NUQVQwKSAm IEhETUlfUEhZX0hQRCA/CisJCWNvbm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVkIDogY29ubmVjdG9y X3N0YXR1c19kaXNjb25uZWN0ZWQ7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHdfaGRtaV9w aHlfb3BzIGR3X2hkbWlfc3lub3BzeXNfcGh5X29wcyA9IHsKKwkuaW5pdCA9IGR3X2hkbWlfcGh5 X2luaXQsCisJLmRpc2FibGUgPSBkd19oZG1pX3BoeV9kaXNhYmxlLAorCS5yZWFkX2hwZCA9IGR3 X2hkbWlfcGh5X3JlYWRfaHBkLAorfTsKKworLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqIEhE TUkgVFggU2V0dXAKKyAqLworCiBzdGF0aWMgdm9pZCBoZG1pX3R4X2hkY3BfY29uZmlnKHN0cnVj dCBkd19oZG1pICpoZG1pKQogewogCXU4IGRlOwpAQCAtMTI4OSwxNiArMTMyMCw2IEBAIHN0YXRp YyB2b2lkIGhkbWlfYXZfY29tcG9zZXIoc3RydWN0IGR3X2hkbWkgKmhkbWksCiAJaGRtaV93cml0 ZWIoaGRtaSwgdnN5bmNfbGVuLCBIRE1JX0ZDX1ZTWU5DSU5XSURUSCk7CiB9CiAKLXN0YXRpYyB2 b2lkIGR3X2hkbWlfcGh5X2Rpc2FibGUoc3RydWN0IGR3X2hkbWkgKmhkbWkpCi17Ci0JaWYgKCFo ZG1pLT5waHlfZW5hYmxlZCkKLQkJcmV0dXJuOwotCi0JZHdfaGRtaV9waHlfcG93ZXJfb2ZmKGhk bWkpOwotCi0JaGRtaS0+cGh5X2VuYWJsZWQgPSBmYWxzZTsKLX0KLQogLyogSERNSSBJbml0aWFs aXphdGlvbiBTdGVwIEIuNCAqLwogc3RhdGljIHZvaWQgZHdfaGRtaV9lbmFibGVfdmlkZW9fcGF0 aChzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkKIHsKQEAgLTE0MzEsOSArMTQ1MiwxMCBAQCBzdGF0aWMg aW50IGR3X2hkbWlfc2V0dXAoc3RydWN0IGR3X2hkbWkgKmhkbWksIHN0cnVjdCBkcm1fZGlzcGxh eV9tb2RlICptb2RlKQogCWhkbWlfYXZfY29tcG9zZXIoaGRtaSwgbW9kZSk7CiAKIAkvKiBIRE1J IEluaXRpYWxpemF0ZWlvbiBTdGVwIEIuMiAqLwotCXJldCA9IGR3X2hkbWlfcGh5X2luaXQoaGRt aSk7CisJcmV0ID0gaGRtaS0+cGh5Lm9wcy0+aW5pdChoZG1pLCBoZG1pLT5waHkuZGF0YSwgJmhk bWktPnByZXZpb3VzX21vZGUpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CisJaGRtaS0+cGh5 LmVuYWJsZWQgPSB0cnVlOwogCiAJLyogSERNSSBJbml0aWFsaXphdGlvbiBTdGVwIEIuMyAqLwog CWR3X2hkbWlfZW5hYmxlX3ZpZGVvX3BhdGgoaGRtaSk7CkBAIC0xNTQ4LDcgKzE1NzAsMTEgQEAg c3RhdGljIHZvaWQgZHdfaGRtaV9wb3dlcm9uKHN0cnVjdCBkd19oZG1pICpoZG1pKQogCiBzdGF0 aWMgdm9pZCBkd19oZG1pX3Bvd2Vyb2ZmKHN0cnVjdCBkd19oZG1pICpoZG1pKQogewotCWR3X2hk bWlfcGh5X2Rpc2FibGUoaGRtaSk7CisJaWYgKGhkbWktPnBoeS5lbmFibGVkKSB7CisJCWhkbWkt PnBoeS5vcHMtPmRpc2FibGUoaGRtaSwgaGRtaS0+cGh5LmRhdGEpOworCQloZG1pLT5waHkuZW5h YmxlZCA9IGZhbHNlOworCX0KKwogCWhkbWktPmJyaWRnZV9pc19vbiA9IGZhbHNlOwogfQogCkBA IC0xNjExLDggKzE2MzcsNyBAQCBkd19oZG1pX2Nvbm5lY3Rvcl9kZXRlY3Qoc3RydWN0IGRybV9j b25uZWN0b3IgKmNvbm5lY3RvciwgYm9vbCBmb3JjZSkKIAlkd19oZG1pX3VwZGF0ZV9waHlfbWFz ayhoZG1pKTsKIAltdXRleF91bmxvY2soJmhkbWktPm11dGV4KTsKIAotCXJldHVybiBoZG1pX3Jl YWRiKGhkbWksIEhETUlfUEhZX1NUQVQwKSAmIEhETUlfUEhZX0hQRCA/Ci0JCWNvbm5lY3Rvcl9z dGF0dXNfY29ubmVjdGVkIDogY29ubmVjdG9yX3N0YXR1c19kaXNjb25uZWN0ZWQ7CisJcmV0dXJu IGhkbWktPnBoeS5vcHMtPnJlYWRfaHBkKGhkbWksIGhkbWktPnBoeS5kYXRhKTsKIH0KIAogc3Rh dGljIGludCBkd19oZG1pX2Nvbm5lY3Rvcl9nZXRfbW9kZXMoc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3RvcikKQEAgLTE4OTgsMTkgKzE5MjMsMzEgQEAgc3RhdGljIGludCBkd19oZG1pX2Rl dGVjdF9waHkoc3RydWN0IGR3X2hkbWkgKmhkbWkpCiAKIAlwaHlfdHlwZSA9IGhkbWlfcmVhZGIo aGRtaSwgSERNSV9DT05GSUcyX0lEKTsKIAorCWlmIChwaHlfdHlwZSA9PSBEV19IRE1JX1BIWV9W RU5ET1JfUEhZKSB7CisJCS8qIFZlbmRvciBQSFlzIHJlcXVpcmUgc3VwcG9ydCBmcm9tIHRoZSBn bHVlIGxheWVyLiAqLworCQlpZiAoIWhkbWktPnBsYXRfZGF0YS0+cGh5X29wcyB8fCAhaGRtaS0+ cGxhdF9kYXRhLT5waHlfbmFtZSkgeworCQkJZGV2X2VycihoZG1pLT5kZXYsCisJCQkJIlZlbmRv ciBIRE1JIFBIWSBub3Qgc3VwcG9ydGVkIGJ5IGdsdWUgbGF5ZXJcbiIpOworCQkJcmV0dXJuIC1F Tk9ERVY7CisJCX0KKworCQloZG1pLT5waHkub3BzID0gaGRtaS0+cGxhdF9kYXRhLT5waHlfb3Bz OworCQloZG1pLT5waHkuZGF0YSA9IGhkbWktPnBsYXRfZGF0YS0+cGh5X2RhdGE7CisJCWhkbWkt PnBoeS5uYW1lID0gaGRtaS0+cGxhdF9kYXRhLT5waHlfbmFtZTsKKwkJcmV0dXJuIDA7CisJfQor CisJLyogU3lub3BzeXMgUEhZcyBhcmUgaGFuZGxlZCBpbnRlcm5hbGx5LiAqLwogCWZvciAoaSA9 IDA7IGkgPCBBUlJBWV9TSVpFKGR3X2hkbWlfcGh5cyk7ICsraSkgewogCQlpZiAoZHdfaGRtaV9w aHlzW2ldLnR5cGUgPT0gcGh5X3R5cGUpIHsKLQkJCWhkbWktPnBoeSA9ICZkd19oZG1pX3BoeXNb aV07CisJCQloZG1pLT5waHkub3BzID0gJmR3X2hkbWlfc3lub3BzeXNfcGh5X29wczsKKwkJCWhk bWktPnBoeS5uYW1lID0gZHdfaGRtaV9waHlzW2ldLm5hbWU7CisJCQloZG1pLT5waHkuZGF0YSA9 ICh2b2lkICopJmR3X2hkbWlfcGh5c1tpXTsKIAkJCXJldHVybiAwOwogCQl9CiAJfQogCi0JaWYg KHBoeV90eXBlID09IERXX0hETUlfUEhZX1ZFTkRPUl9QSFkpCi0JCWRldl9lcnIoaGRtaS0+ZGV2 LCAiVW5zdXBwb3J0ZWQgdmVuZG9yIEhETUkgUEhZXG4iKTsKLQllbHNlCi0JCWRldl9lcnIoaGRt aS0+ZGV2LCAiVW5zdXBwb3J0ZWQgSERNSSBQSFkgdHlwZSAoJTAyeClcbiIsCi0JCQlwaHlfdHlw ZSk7Ci0KKwlkZXZfZXJyKGhkbWktPmRldiwgIlVuc3VwcG9ydGVkIEhETUkgUEhZIHR5cGUgKCUw MngpXG4iLCBwaHlfdHlwZSk7CiAJcmV0dXJuIC1FTk9ERVY7CiB9CiAKQEAgLTIwMzEsNyArMjA2 OCw3IEBAIF9fZHdfaGRtaV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAogCWRl dl9pbmZvKGRldiwgIkRldGVjdGVkIEhETUkgVFggY29udHJvbGxlciB2JXguJTAzeCAlcyBIRENQ ICglcylcbiIsCiAJCSBoZG1pLT52ZXJzaW9uID4+IDEyLCBoZG1pLT52ZXJzaW9uICYgMHhmZmYs CiAJCSBwcm9kX2lkMSAmIEhETUlfUFJPRFVDVF9JRDFfSERDUCA/ICJ3aXRoIiA6ICJ3aXRob3V0 IiwKLQkJIGhkbWktPnBoeS0+bmFtZSk7CisJCSBoZG1pLT5waHkubmFtZSk7CiAKIAlpbml0aWFs aXplX2hkbWlfaWhfbXV0ZXMoaGRtaSk7CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2JyaWRn ZS9kd19oZG1pLmggYi9pbmNsdWRlL2RybS9icmlkZ2UvZHdfaGRtaS5oCmluZGV4IGIwODBhMTcx YTIzZi4uMGY1ODNjYTdlNjZlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9icmlkZ2UvZHdfaGRt aS5oCisrKyBiL2luY2x1ZGUvZHJtL2JyaWRnZS9kd19oZG1pLmgKQEAgLTU3LDEzICs1NywyNyBA QCBzdHJ1Y3QgZHdfaGRtaV9waHlfY29uZmlnIHsKIAl1MTYgdmxldl9jdHI7ICAgLyogdm9sdGFn ZSBsZXZlbCBjb250cm9sICovCiB9OwogCitzdHJ1Y3QgZHdfaGRtaV9waHlfb3BzIHsKKwlpbnQg KCppbml0KShzdHJ1Y3QgZHdfaGRtaSAqaGRtaSwgdm9pZCAqZGF0YSwKKwkJICAgIHN0cnVjdCBk cm1fZGlzcGxheV9tb2RlICptb2RlKTsKKwl2b2lkICgqZGlzYWJsZSkoc3RydWN0IGR3X2hkbWkg KmhkbWksIHZvaWQgKmRhdGEpOworCWVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMgKCpyZWFkX2hw ZCkoc3RydWN0IGR3X2hkbWkgKmhkbWksIHZvaWQgKmRhdGEpOworfTsKKwogc3RydWN0IGR3X2hk bWlfcGxhdF9kYXRhIHsKIAllbnVtIGR3X2hkbWlfZGV2dHlwZSBkZXZfdHlwZTsKKwllbnVtIGRy bV9tb2RlX3N0YXR1cyAoKm1vZGVfdmFsaWQpKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0 b3IsCisJCQkJCSAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKTsKKworCS8qIFZlbmRv ciBQSFkgc3VwcG9ydCAqLworCWNvbnN0IHN0cnVjdCBkd19oZG1pX3BoeV9vcHMgKnBoeV9vcHM7 CisJY29uc3QgY2hhciAqcGh5X25hbWU7CisJdm9pZCAqcGh5X2RhdGE7CisKKwkvKiBTeW5vcHN5 cyBQSFkgc3VwcG9ydCAqLwogCWNvbnN0IHN0cnVjdCBkd19oZG1pX21wbGxfY29uZmlnICptcGxs X2NmZzsKIAljb25zdCBzdHJ1Y3QgZHdfaGRtaV9jdXJyX2N0cmwgKmN1cl9jdHI7CiAJY29uc3Qg c3RydWN0IGR3X2hkbWlfcGh5X2NvbmZpZyAqcGh5X2NvbmZpZzsKLQllbnVtIGRybV9tb2RlX3N0 YXR1cyAoKm1vZGVfdmFsaWQpKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCi0JCQkJ CSAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKTsKIH07CiAKIGludCBkd19oZG1pX3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQ aW5jaGFydAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K ZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==