From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:59796 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752425AbdCEXom (ORCPT ); Sun, 5 Mar 2017 18:44:42 -0500 From: Laurent Pinchart To: dri-devel@lists.freedesktop.org Cc: Archit Taneja , Fabio Estevam , Jose Abreu , Neil Armstrong , Kieran Bingham , linux-renesas-soc@vger.kernel.org, Nickey Yang , Russell King , Andy Yan , Vladimir Zapolskiy Subject: [PATCH v5.1 06/10] drm: bridge: dw-hdmi: Create PHY operations Date: Mon, 6 Mar 2017 01:36:15 +0200 Message-Id: <20170305233615.11993-1-laurent.pinchart+renesas@ideasonboard.com> In-Reply-To: <20170303172007.26541-7-laurent.pinchart+renesas@ideasonboard.com> References: <20170303172007.26541-7-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 | 95 ++++++++++++++++++++++++++++------------ include/drm/bridge/dw_hdmi.h | 18 +++++++- 2 files changed, 82 insertions(+), 31 deletions(-) Changes since v5: - Undo changes from v5.1 04/10 and 05/10 diff --git a/drivers/gpu/drm/bridge/dw-hdmi.c b/drivers/gpu/drm/bridge/dw-hdmi.c index c25eac8ba47b..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) { @@ -917,7 +925,7 @@ static void dw_hdmi_phy_sel_interface_control(struct dw_hdmi *hdmi, u8 enable) static void dw_hdmi_phy_power_off(struct dw_hdmi *hdmi) { - const struct dw_hdmi_phy_data *phy = hdmi->phy; + const struct dw_hdmi_phy_data *phy = hdmi->phy.data; unsigned int i; u16 val; @@ -951,7 +959,7 @@ static void dw_hdmi_phy_power_off(struct dw_hdmi *hdmi) static int dw_hdmi_phy_power_on(struct dw_hdmi *hdmi) { - const struct dw_hdmi_phy_data *phy = hdmi->phy; + const struct dw_hdmi_phy_data *phy = hdmi->phy.data; unsigned int i; u8 val; @@ -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.1 06/10] drm: bridge: dw-hdmi: Create PHY operations Date: Mon, 6 Mar 2017 01:36:15 +0200 Message-ID: <20170305233615.11993-1-laurent.pinchart+renesas@ideasonboard.com> References: <20170303172007.26541-7-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 5CC266E313 for ; Sun, 5 Mar 2017 23:35:45 +0000 (UTC) In-Reply-To: <20170303172007.26541-7-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 , Andy Yan , Russell King , Vladimir Zapolskiy List-Id: dri-devel@lists.freedesktop.org VGhlIEhETUkgVFggY29udHJvbGxlciBzdXBwb3J0IGRpZmZlcmVudCBQSFlzIHdob3NlIHByb2dy YW1taW5nCmludGVyZmFjZSBjYW4gdmFyeSBzaWduaWZpY2FudGx5LCBlc3BlY2lhbGx5IHdpdGgg dmVuZG9yIFBIWXMgdGhhdCBhcmUKbm90IHByb3ZpZGVkIGJ5IFN5bm9wc3lzLiBUbyBzdXBwb3J0 IHRoZW0sIGNyZWF0ZSBhIFBIWSBvcGVyYXRpb24Kc3RydWN0dXJlIHRoYXQgY2FuIGJlIHByb3Zp ZGVkIGJ5IHRoZSBwbGF0Zm9ybSBnbHVlIGxheWVyLiBUaGUgZXhpc3RpbmcKUEhZIGhhbmRsaW5n IGNvZGUgKGxpbWl0ZWQgdG8gU3lub3BzeXMgUEhZIHN1cHBvcnQpIGlzIHJlZmFjdG9yZWQgaW50 byBhCnNldCBvZiBkZWZhdWx0IFBIWSBvcGVyYXRpb25zIHRoYXQgYXJlIHVzZWQgYXV0b21hdGlj YWxseSB3aGVuIHRoZQpwbGF0Zm9ybSBnbHVlIGRvZXNuJ3QgcHJvdmlkZSBpdHMgb3duIG9wZXJh dGlvbnMuCgpTaWduZWQtb2ZmLWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0 K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KVGVzdGVkLWJ5OiBOZWlsIEFybXN0cm9uZyA8bmFy bXN0cm9uZ0BiYXlsaWJyZS5jb20+ClJldmlld2VkLWJ5OiBKb3NlIEFicmV1IDxqb2FicmV1QHN5 bm9wc3lzLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2R3LWhkbWkuYyB8IDk1ICsr KysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0KIGluY2x1ZGUvZHJtL2JyaWRn ZS9kd19oZG1pLmggICAgIHwgMTggKysrKysrKy0KIDIgZmlsZXMgY2hhbmdlZCwgODIgaW5zZXJ0 aW9ucygrKSwgMzEgZGVsZXRpb25zKC0pCgpDaGFuZ2VzIHNpbmNlIHY1OgoKLSBVbmRvIGNoYW5n ZXMgZnJvbSB2NS4xIDA0LzEwIGFuZCAwNS8xMAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9icmlkZ2UvZHctaGRtaS5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9kdy1oZG1pLmMKaW5k ZXggYzI1ZWFjOGJhNDdiLi5jYjI3MDM4NjJiZTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9icmlkZ2UvZHctaGRtaS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvZHctaGRtaS5j CkBAIC0xNDEsOCArMTQxLDEyIEBAIHN0cnVjdCBkd19oZG1pIHsKIAl1OCBlZGlkW0hETUlfRURJ RF9MRU5dOwogCWJvb2wgY2FibGVfcGx1Z2luOwogCi0JY29uc3Qgc3RydWN0IGR3X2hkbWlfcGh5 X2RhdGEgKnBoeTsKLQlib29sIHBoeV9lbmFibGVkOworCXN0cnVjdCB7CisJCWNvbnN0IHN0cnVj dCBkd19oZG1pX3BoeV9vcHMgKm9wczsKKwkJY29uc3QgY2hhciAqbmFtZTsKKwkJdm9pZCAqZGF0 YTsKKwkJYm9vbCBlbmFibGVkOworCX0gcGh5OwogCiAJc3RydWN0IGRybV9kaXNwbGF5X21vZGUg cHJldmlvdXNfbW9kZTsKIApAQCAtODMxLDYgKzgzNSwxMCBAQCBzdGF0aWMgdm9pZCBoZG1pX3Zp ZGVvX3BhY2tldGl6ZShzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkKIAkJICBIRE1JX1ZQX0NPTkYpOwog fQogCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICogU3lub3BzeXMgUEhZIEhhbmRsaW5nCisg Ki8KKwogc3RhdGljIGlubGluZSB2b2lkIGhkbWlfcGh5X3Rlc3RfY2xlYXIoc3RydWN0IGR3X2hk bWkgKmhkbWksCiAJCQkJICAgICAgIHVuc2lnbmVkIGNoYXIgYml0KQogewpAQCAtOTE3LDcgKzky NSw3IEBAIHN0YXRpYyB2b2lkIGR3X2hkbWlfcGh5X3NlbF9pbnRlcmZhY2VfY29udHJvbChzdHJ1 Y3QgZHdfaGRtaSAqaGRtaSwgdTggZW5hYmxlKQogCiBzdGF0aWMgdm9pZCBkd19oZG1pX3BoeV9w b3dlcl9vZmYoc3RydWN0IGR3X2hkbWkgKmhkbWkpCiB7Ci0JY29uc3Qgc3RydWN0IGR3X2hkbWlf cGh5X2RhdGEgKnBoeSA9IGhkbWktPnBoeTsKKwljb25zdCBzdHJ1Y3QgZHdfaGRtaV9waHlfZGF0 YSAqcGh5ID0gaGRtaS0+cGh5LmRhdGE7CiAJdW5zaWduZWQgaW50IGk7CiAJdTE2IHZhbDsKIApA QCAtOTUxLDcgKzk1OSw3IEBAIHN0YXRpYyB2b2lkIGR3X2hkbWlfcGh5X3Bvd2VyX29mZihzdHJ1 Y3QgZHdfaGRtaSAqaGRtaSkKIAogc3RhdGljIGludCBkd19oZG1pX3BoeV9wb3dlcl9vbihzdHJ1 Y3QgZHdfaGRtaSAqaGRtaSkKIHsKLQljb25zdCBzdHJ1Y3QgZHdfaGRtaV9waHlfZGF0YSAqcGh5 ID0gaGRtaS0+cGh5OworCWNvbnN0IHN0cnVjdCBkd19oZG1pX3BoeV9kYXRhICpwaHkgPSBoZG1p LT5waHkuZGF0YTsKIAl1bnNpZ25lZCBpbnQgaTsKIAl1OCB2YWw7CiAKQEAgLTk4Nyw2ICs5OTUs NyBAQCBzdGF0aWMgaW50IGR3X2hkbWlfcGh5X3Bvd2VyX29uKHN0cnVjdCBkd19oZG1pICpoZG1p KQogCiBzdGF0aWMgaW50IGhkbWlfcGh5X2NvbmZpZ3VyZShzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkK IHsKKwljb25zdCBzdHJ1Y3QgZHdfaGRtaV9waHlfZGF0YSAqcGh5ID0gaGRtaS0+cGh5LmRhdGE7 CiAJY29uc3Qgc3RydWN0IGR3X2hkbWlfcGxhdF9kYXRhICpwZGF0YSA9IGhkbWktPnBsYXRfZGF0 YTsKIAljb25zdCBzdHJ1Y3QgZHdfaGRtaV9tcGxsX2NvbmZpZyAqbXBsbF9jb25maWcgPSBwZGF0 YS0+bXBsbF9jZmc7CiAJY29uc3Qgc3RydWN0IGR3X2hkbWlfY3Vycl9jdHJsICpjdXJyX2N0cmwg PSBwZGF0YS0+Y3VyX2N0cjsKQEAgLTEwMTksNyArMTAyOCw3IEBAIHN0YXRpYyBpbnQgaGRtaV9w aHlfY29uZmlndXJlKHN0cnVjdCBkd19oZG1pICpoZG1pKQogCWR3X2hkbWlfcGh5X3Bvd2VyX29m ZihoZG1pKTsKIAogCS8qIExlYXZlIGxvdyBwb3dlciBjb25zdW1wdGlvbiBtb2RlIGJ5IGFzc2Vy dGluZyBTVlNSRVQuICovCi0JaWYgKGhkbWktPnBoeS0+aGFzX3N2c3JldCkKKwlpZiAocGh5LT5o YXNfc3ZzcmV0KQogCQlkd19oZG1pX3BoeV9lbmFibGVfc3ZzcmV0KGhkbWksIDEpOwogCiAJLyog UEhZIHJlc2V0LiBUaGUgcmVzZXQgc2lnbmFsIGlzIGFjdGl2ZSBoaWdoIG9uIEdlbjIgUEhZcy4g Ki8KQEAgLTEwNTcsNyArMTA2Niw4IEBAIHN0YXRpYyBpbnQgaGRtaV9waHlfY29uZmlndXJlKHN0 cnVjdCBkd19oZG1pICpoZG1pKQogCXJldHVybiBkd19oZG1pX3BoeV9wb3dlcl9vbihoZG1pKTsK IH0KIAotc3RhdGljIGludCBkd19oZG1pX3BoeV9pbml0KHN0cnVjdCBkd19oZG1pICpoZG1pKQor c3RhdGljIGludCBkd19oZG1pX3BoeV9pbml0KHN0cnVjdCBkd19oZG1pICpoZG1pLCB2b2lkICpk YXRhLAorCQkJICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKQogewogCWludCBpLCBy ZXQ7CiAKQEAgLTEwNzEsMTAgKzEwODEsMzEgQEAgc3RhdGljIGludCBkd19oZG1pX3BoeV9pbml0 KHN0cnVjdCBkd19oZG1pICpoZG1pKQogCQkJcmV0dXJuIHJldDsKIAl9CiAKLQloZG1pLT5waHlf ZW5hYmxlZCA9IHRydWU7CiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGR3X2hkbWlfcGh5 X2Rpc2FibGUoc3RydWN0IGR3X2hkbWkgKmhkbWksIHZvaWQgKmRhdGEpCit7CisJZHdfaGRtaV9w aHlfcG93ZXJfb2ZmKGhkbWkpOworfQorCitzdGF0aWMgZW51bSBkcm1fY29ubmVjdG9yX3N0YXR1 cyBkd19oZG1pX3BoeV9yZWFkX2hwZChzdHJ1Y3QgZHdfaGRtaSAqaGRtaSwKKwkJCQkJCSAgICAg IHZvaWQgKmRhdGEpCit7CisJcmV0dXJuIGhkbWlfcmVhZGIoaGRtaSwgSERNSV9QSFlfU1RBVDAp ICYgSERNSV9QSFlfSFBEID8KKwkJY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQgOiBjb25uZWN0 b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkd19oZG1p X3BoeV9vcHMgZHdfaGRtaV9zeW5vcHN5c19waHlfb3BzID0geworCS5pbml0ID0gZHdfaGRtaV9w aHlfaW5pdCwKKwkuZGlzYWJsZSA9IGR3X2hkbWlfcGh5X2Rpc2FibGUsCisJLnJlYWRfaHBkID0g ZHdfaGRtaV9waHlfcmVhZF9ocGQsCit9OworCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICog SERNSSBUWCBTZXR1cAorICovCisKIHN0YXRpYyB2b2lkIGhkbWlfdHhfaGRjcF9jb25maWcoc3Ry dWN0IGR3X2hkbWkgKmhkbWkpCiB7CiAJdTggZGU7CkBAIC0xMjg5LDE2ICsxMzIwLDYgQEAgc3Rh dGljIHZvaWQgaGRtaV9hdl9jb21wb3NlcihzdHJ1Y3QgZHdfaGRtaSAqaGRtaSwKIAloZG1pX3dy aXRlYihoZG1pLCB2c3luY19sZW4sIEhETUlfRkNfVlNZTkNJTldJRFRIKTsKIH0KIAotc3RhdGlj IHZvaWQgZHdfaGRtaV9waHlfZGlzYWJsZShzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkKLXsKLQlpZiAo IWhkbWktPnBoeV9lbmFibGVkKQotCQlyZXR1cm47Ci0KLQlkd19oZG1pX3BoeV9wb3dlcl9vZmYo aGRtaSk7Ci0KLQloZG1pLT5waHlfZW5hYmxlZCA9IGZhbHNlOwotfQotCiAvKiBIRE1JIEluaXRp YWxpemF0aW9uIFN0ZXAgQi40ICovCiBzdGF0aWMgdm9pZCBkd19oZG1pX2VuYWJsZV92aWRlb19w YXRoKHN0cnVjdCBkd19oZG1pICpoZG1pKQogewpAQCAtMTQzMSw5ICsxNDUyLDEwIEBAIHN0YXRp YyBpbnQgZHdfaGRtaV9zZXR1cChzdHJ1Y3QgZHdfaGRtaSAqaGRtaSwgc3RydWN0IGRybV9kaXNw bGF5X21vZGUgKm1vZGUpCiAJaGRtaV9hdl9jb21wb3NlcihoZG1pLCBtb2RlKTsKIAogCS8qIEhE TUkgSW5pdGlhbGl6YXRlaW9uIFN0ZXAgQi4yICovCi0JcmV0ID0gZHdfaGRtaV9waHlfaW5pdCho ZG1pKTsKKwlyZXQgPSBoZG1pLT5waHkub3BzLT5pbml0KGhkbWksIGhkbWktPnBoeS5kYXRhLCAm aGRtaS0+cHJldmlvdXNfbW9kZSk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKKwloZG1pLT5w aHkuZW5hYmxlZCA9IHRydWU7CiAKIAkvKiBIRE1JIEluaXRpYWxpemF0aW9uIFN0ZXAgQi4zICov CiAJZHdfaGRtaV9lbmFibGVfdmlkZW9fcGF0aChoZG1pKTsKQEAgLTE1NDgsNyArMTU3MCwxMSBA QCBzdGF0aWMgdm9pZCBkd19oZG1pX3Bvd2Vyb24oc3RydWN0IGR3X2hkbWkgKmhkbWkpCiAKIHN0 YXRpYyB2b2lkIGR3X2hkbWlfcG93ZXJvZmYoc3RydWN0IGR3X2hkbWkgKmhkbWkpCiB7Ci0JZHdf aGRtaV9waHlfZGlzYWJsZShoZG1pKTsKKwlpZiAoaGRtaS0+cGh5LmVuYWJsZWQpIHsKKwkJaGRt aS0+cGh5Lm9wcy0+ZGlzYWJsZShoZG1pLCBoZG1pLT5waHkuZGF0YSk7CisJCWhkbWktPnBoeS5l bmFibGVkID0gZmFsc2U7CisJfQorCiAJaGRtaS0+YnJpZGdlX2lzX29uID0gZmFsc2U7CiB9CiAK QEAgLTE2MTEsOCArMTYzNyw3IEBAIGR3X2hkbWlfY29ubmVjdG9yX2RldGVjdChzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubmVjdG9yLCBib29sIGZvcmNlKQogCWR3X2hkbWlfdXBkYXRlX3BoeV9t YXNrKGhkbWkpOwogCW11dGV4X3VubG9jaygmaGRtaS0+bXV0ZXgpOwogCi0JcmV0dXJuIGhkbWlf cmVhZGIoaGRtaSwgSERNSV9QSFlfU1RBVDApICYgSERNSV9QSFlfSFBEID8KLQkJY29ubmVjdG9y X3N0YXR1c19jb25uZWN0ZWQgOiBjb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKKwlyZXR1 cm4gaGRtaS0+cGh5Lm9wcy0+cmVhZF9ocGQoaGRtaSwgaGRtaS0+cGh5LmRhdGEpOwogfQogCiBz dGF0aWMgaW50IGR3X2hkbWlfY29ubmVjdG9yX2dldF9tb2RlcyhzdHJ1Y3QgZHJtX2Nvbm5lY3Rv ciAqY29ubmVjdG9yKQpAQCAtMTg5OCwxOSArMTkyMywzMSBAQCBzdGF0aWMgaW50IGR3X2hkbWlf ZGV0ZWN0X3BoeShzdHJ1Y3QgZHdfaGRtaSAqaGRtaSkKIAogCXBoeV90eXBlID0gaGRtaV9yZWFk YihoZG1pLCBIRE1JX0NPTkZJRzJfSUQpOwogCisJaWYgKHBoeV90eXBlID09IERXX0hETUlfUEhZ X1ZFTkRPUl9QSFkpIHsKKwkJLyogVmVuZG9yIFBIWXMgcmVxdWlyZSBzdXBwb3J0IGZyb20gdGhl IGdsdWUgbGF5ZXIuICovCisJCWlmICghaGRtaS0+cGxhdF9kYXRhLT5waHlfb3BzIHx8ICFoZG1p LT5wbGF0X2RhdGEtPnBoeV9uYW1lKSB7CisJCQlkZXZfZXJyKGhkbWktPmRldiwKKwkJCQkiVmVu ZG9yIEhETUkgUEhZIG5vdCBzdXBwb3J0ZWQgYnkgZ2x1ZSBsYXllclxuIik7CisJCQlyZXR1cm4g LUVOT0RFVjsKKwkJfQorCisJCWhkbWktPnBoeS5vcHMgPSBoZG1pLT5wbGF0X2RhdGEtPnBoeV9v cHM7CisJCWhkbWktPnBoeS5kYXRhID0gaGRtaS0+cGxhdF9kYXRhLT5waHlfZGF0YTsKKwkJaGRt aS0+cGh5Lm5hbWUgPSBoZG1pLT5wbGF0X2RhdGEtPnBoeV9uYW1lOworCQlyZXR1cm4gMDsKKwl9 CisKKwkvKiBTeW5vcHN5cyBQSFlzIGFyZSBoYW5kbGVkIGludGVybmFsbHkuICovCiAJZm9yIChp ID0gMDsgaSA8IEFSUkFZX1NJWkUoZHdfaGRtaV9waHlzKTsgKytpKSB7CiAJCWlmIChkd19oZG1p X3BoeXNbaV0udHlwZSA9PSBwaHlfdHlwZSkgewotCQkJaGRtaS0+cGh5ID0gJmR3X2hkbWlfcGh5 c1tpXTsKKwkJCWhkbWktPnBoeS5vcHMgPSAmZHdfaGRtaV9zeW5vcHN5c19waHlfb3BzOworCQkJ aGRtaS0+cGh5Lm5hbWUgPSBkd19oZG1pX3BoeXNbaV0ubmFtZTsKKwkJCWhkbWktPnBoeS5kYXRh ID0gKHZvaWQgKikmZHdfaGRtaV9waHlzW2ldOwogCQkJcmV0dXJuIDA7CiAJCX0KIAl9CiAKLQlp ZiAocGh5X3R5cGUgPT0gRFdfSERNSV9QSFlfVkVORE9SX1BIWSkKLQkJZGV2X2VycihoZG1pLT5k ZXYsICJVbnN1cHBvcnRlZCB2ZW5kb3IgSERNSSBQSFlcbiIpOwotCWVsc2UKLQkJZGV2X2Vyciho ZG1pLT5kZXYsICJVbnN1cHBvcnRlZCBIRE1JIFBIWSB0eXBlICglMDJ4KVxuIiwKLQkJCXBoeV90 eXBlKTsKLQorCWRldl9lcnIoaGRtaS0+ZGV2LCAiVW5zdXBwb3J0ZWQgSERNSSBQSFkgdHlwZSAo JTAyeClcbiIsIHBoeV90eXBlKTsKIAlyZXR1cm4gLUVOT0RFVjsKIH0KIApAQCAtMjAzMSw3ICsy MDY4LDcgQEAgX19kd19oZG1pX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCiAJ ZGV2X2luZm8oZGV2LCAiRGV0ZWN0ZWQgSERNSSBUWCBjb250cm9sbGVyIHYleC4lMDN4ICVzIEhE Q1AgKCVzKVxuIiwKIAkJIGhkbWktPnZlcnNpb24gPj4gMTIsIGhkbWktPnZlcnNpb24gJiAweGZm ZiwKIAkJIHByb2RfaWQxICYgSERNSV9QUk9EVUNUX0lEMV9IRENQID8gIndpdGgiIDogIndpdGhv dXQiLAotCQkgaGRtaS0+cGh5LT5uYW1lKTsKKwkJIGhkbWktPnBoeS5uYW1lKTsKIAogCWluaXRp YWxpemVfaGRtaV9paF9tdXRlcyhoZG1pKTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vYnJp ZGdlL2R3X2hkbWkuaCBiL2luY2x1ZGUvZHJtL2JyaWRnZS9kd19oZG1pLmgKaW5kZXggYjA4MGEx NzFhMjNmLi4wZjU4M2NhN2U2NmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2JyaWRnZS9kd19o ZG1pLmgKKysrIGIvaW5jbHVkZS9kcm0vYnJpZGdlL2R3X2hkbWkuaApAQCAtNTcsMTMgKzU3LDI3 IEBAIHN0cnVjdCBkd19oZG1pX3BoeV9jb25maWcgewogCXUxNiB2bGV2X2N0cjsgICAvKiB2b2x0 YWdlIGxldmVsIGNvbnRyb2wgKi8KIH07CiAKK3N0cnVjdCBkd19oZG1pX3BoeV9vcHMgeworCWlu dCAoKmluaXQpKHN0cnVjdCBkd19oZG1pICpoZG1pLCB2b2lkICpkYXRhLAorCQkgICAgc3RydWN0 IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpOworCXZvaWQgKCpkaXNhYmxlKShzdHJ1Y3QgZHdfaGRt aSAqaGRtaSwgdm9pZCAqZGF0YSk7CisJZW51bSBkcm1fY29ubmVjdG9yX3N0YXR1cyAoKnJlYWRf aHBkKShzdHJ1Y3QgZHdfaGRtaSAqaGRtaSwgdm9pZCAqZGF0YSk7Cit9OworCiBzdHJ1Y3QgZHdf aGRtaV9wbGF0X2RhdGEgewogCWVudW0gZHdfaGRtaV9kZXZ0eXBlIGRldl90eXBlOworCWVudW0g ZHJtX21vZGVfc3RhdHVzICgqbW9kZV92YWxpZCkoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5l Y3RvciwKKwkJCQkJICAgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpOworCisJLyogVmVu ZG9yIFBIWSBzdXBwb3J0ICovCisJY29uc3Qgc3RydWN0IGR3X2hkbWlfcGh5X29wcyAqcGh5X29w czsKKwljb25zdCBjaGFyICpwaHlfbmFtZTsKKwl2b2lkICpwaHlfZGF0YTsKKworCS8qIFN5bm9w c3lzIFBIWSBzdXBwb3J0ICovCiAJY29uc3Qgc3RydWN0IGR3X2hkbWlfbXBsbF9jb25maWcgKm1w bGxfY2ZnOwogCWNvbnN0IHN0cnVjdCBkd19oZG1pX2N1cnJfY3RybCAqY3VyX2N0cjsKIAljb25z dCBzdHJ1Y3QgZHdfaGRtaV9waHlfY29uZmlnICpwaHlfY29uZmlnOwotCWVudW0gZHJtX21vZGVf c3RhdHVzICgqbW9kZV92YWxpZCkoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKLQkJ CQkJICAgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpOwogfTsKIAogaW50IGR3X2hkbWlf cHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKLS0gClJlZ2FyZHMsCgpMYXVyZW50 IFBpbmNoYXJ0CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK