From mboxrd@z Thu Jan 1 00:00:00 1970 From: Manu Gautam Subject: [PATCH v5 7/7] phy: qcom-qusb2: Add QUSB2 PHYs support for sdm845 Date: Thu, 3 May 2018 02:36:14 +0530 Message-ID: <1525295174-15995-8-git-send-email-mgautam@codeaurora.org> References: <1525295174-15995-1-git-send-email-mgautam@codeaurora.org> Return-path: In-Reply-To: <1525295174-15995-1-git-send-email-mgautam@codeaurora.org> Sender: linux-kernel-owner@vger.kernel.org To: Kishon Vijay Abraham I , robh@kernel.org, sboyd@kernel.org Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, dianders@chromium.org, evgreen@chromium.org, Vivek Gautam , linux-arm-msm@vger.kernel.org, linux-usb@vger.kernel.org, Manu Gautam List-Id: linux-arm-msm@vger.kernel.org There are two QUSB2 PHYs present on sdm845. In order to improve eye diagram for both the PHYs some parameters need to be changed. Provide device tree properties to override these from board specific device tree files. Signed-off-by: Manu Gautam --- drivers/phy/qualcomm/phy-qcom-qusb2.c | 126 +++++++++++++++++++++++++++++++--- 1 file changed, 118 insertions(+), 8 deletions(-) diff --git a/drivers/phy/qualcomm/phy-qcom-qusb2.c b/drivers/phy/qualcomm/phy-qcom-qusb2.c index 40fdef8..e70e425 100644 --- a/drivers/phy/qualcomm/phy-qcom-qusb2.c +++ b/drivers/phy/qualcomm/phy-qcom-qusb2.c @@ -20,6 +20,8 @@ #include #include +#include + #define QUSB2PHY_PLL_TEST 0x04 #define CLK_REF_SEL BIT(7) @@ -60,6 +62,17 @@ #define CORE_RESET BIT(5) #define CORE_RESET_MUX BIT(6) +/* QUSB2PHY_IMP_CTRL1 register bits */ +#define IMP_RES_OFFSET_MASK GENMASK(5, 0) +#define IMP_RES_OFFSET_SHIFT 0x0 + +/* QUSB2PHY_PORT_TUNE1 register bits */ +#define HSTX_TRIM_MASK GENMASK(7, 4) +#define HSTX_TRIM_SHIFT 0x4 +#define PREEMPH_WIDTH_HALF_BIT BIT(2) +#define PREEMPHASIS_EN_MASK GENMASK(1, 0) +#define PREEMPHASIS_EN_SHIFT 0x0 + #define QUSB2PHY_PLL_ANALOG_CONTROLS_TWO 0x04 #define QUSB2PHY_PLL_CLOCK_INVERTERS 0x18c #define QUSB2PHY_PLL_CMODE 0x2c @@ -139,7 +152,7 @@ enum qusb2phy_reg_layout { QUSB2_PHY_INIT_CFG(QUSB2PHY_PLL_PWR_CTRL, 0x00), }; -static const unsigned int qusb2_v2_regs_layout[] = { +static const unsigned int sdm845_regs_layout[] = { [QUSB2PHY_PLL_CORE_INPUT_OVERRIDE] = 0xa8, [QUSB2PHY_PLL_STATUS] = 0x1a0, [QUSB2PHY_PORT_TUNE1] = 0x240, @@ -153,7 +166,7 @@ enum qusb2phy_reg_layout { [QUSB2PHY_INTR_CTRL] = 0x230, }; -static const struct qusb2_phy_init_tbl qusb2_v2_init_tbl[] = { +static const struct qusb2_phy_init_tbl sdm845_init_tbl[] = { QUSB2_PHY_INIT_CFG(QUSB2PHY_PLL_ANALOG_CONTROLS_TWO, 0x03), QUSB2_PHY_INIT_CFG(QUSB2PHY_PLL_CLOCK_INVERTERS, 0x7c), QUSB2_PHY_INIT_CFG(QUSB2PHY_PLL_CMODE, 0x80), @@ -208,10 +221,10 @@ struct qusb2_phy_cfg { .autoresume_en = BIT(3), }; -static const struct qusb2_phy_cfg qusb2_v2_phy_cfg = { - .tbl = qusb2_v2_init_tbl, - .tbl_num = ARRAY_SIZE(qusb2_v2_init_tbl), - .regs = qusb2_v2_regs_layout, +static const struct qusb2_phy_cfg sdm845_phy_cfg = { + .tbl = sdm845_init_tbl, + .tbl_num = ARRAY_SIZE(sdm845_init_tbl), + .regs = sdm845_regs_layout, .disable_ctrl = (PWR_CTRL1_VREF_SUPPLY_TRIM | PWR_CTRL1_CLAMP_N_EN | POWER_DOWN), @@ -241,6 +254,15 @@ struct qusb2_phy_cfg { * @tcsr: TCSR syscon register map * @cell: nvmem cell containing phy tuning value * + * @override_imp_res_offset: PHY should use different rescode offset + * @imp_res_offset_value: rescode offset to be updated in IMP_CTRL1 register + * @override_hstx_trim: PHY should use different HSTX o/p current value + * @hstx_trim_value: HSTX_TRIM value to be updated in TUNE1 register + * @override_preemphasis: PHY should use different pre-amphasis amplitude + * @preemphasis_level: Amplitude Pre-Emphasis to be updated in TUNE1 register + * @override_preemphasis_width: PHY should use different pre-emphasis duration + * @preemphasis_width: half/full-width Pre-Emphasis updated via TUNE1 + * * @cfg: phy config data * @has_se_clk_scheme: indicate if PHY has single-ended ref clock scheme * @phy_initialized: indicate if PHY has been initialized @@ -259,12 +281,35 @@ struct qusb2_phy { struct regmap *tcsr; struct nvmem_cell *cell; + bool override_imp_res_offset; + u8 imp_res_offset_value; + bool override_hstx_trim; + u8 hstx_trim_value; + bool override_preemphasis; + u8 preemphasis_level; + bool override_preemphasis_width; + u8 preemphasis_width; + const struct qusb2_phy_cfg *cfg; bool has_se_clk_scheme; bool phy_initialized; enum phy_mode mode; }; +static inline void qusb2_write_mask(void __iomem *base, u32 offset, + u32 val, u32 mask) +{ + u32 reg; + + reg = readl(base + offset); + reg &= ~mask; + reg |= val & mask; + writel(reg, base + offset); + + /* Ensure above write is completed */ + readl(base + offset); +} + static inline void qusb2_setbits(void __iomem *base, u32 offset, u32 val) { u32 reg; @@ -305,6 +350,42 @@ void qcom_qusb2_phy_configure(void __iomem *base, } /* + * Update board specific PHY tuning override values if specified from + * device tree. + */ +static void qusb2_phy_override_phy_params(struct qusb2_phy *qphy) +{ + const struct qusb2_phy_cfg *cfg = qphy->cfg; + + if (qphy->override_imp_res_offset) + qusb2_write_mask(qphy->base, QUSB2PHY_IMP_CTRL1, + qphy->imp_res_offset_value << IMP_RES_OFFSET_SHIFT, + IMP_RES_OFFSET_MASK); + + if (qphy->override_hstx_trim) + qusb2_write_mask(qphy->base, cfg->regs[QUSB2PHY_PORT_TUNE1], + qphy->hstx_trim_value << HSTX_TRIM_SHIFT, + HSTX_TRIM_MASK); + + if (qphy->override_preemphasis) + qusb2_write_mask(qphy->base, cfg->regs[QUSB2PHY_PORT_TUNE1], + qphy->preemphasis_level << PREEMPHASIS_EN_SHIFT, + PREEMPHASIS_EN_MASK); + + if (qphy->override_preemphasis_width) { + if (qphy->preemphasis_width == + QUSB2_V2_PREEMPHASIS_WIDTH_HALF_BIT) + qusb2_setbits(qphy->base, + cfg->regs[QUSB2PHY_PORT_TUNE1], + PREEMPH_WIDTH_HALF_BIT); + else + qusb2_clrbits(qphy->base, + cfg->regs[QUSB2PHY_PORT_TUNE1], + PREEMPH_WIDTH_HALF_BIT); + } +} + +/* * Fetches HS Tx tuning value from nvmem and sets the * QUSB2PHY_PORT_TUNE1/2 register. * For error case, skip setting the value and use the default value. @@ -525,6 +606,9 @@ static int qusb2_phy_init(struct phy *phy) qcom_qusb2_phy_configure(qphy->base, cfg->regs, cfg->tbl, cfg->tbl_num); + /* Override board specific PHY tuning values */ + qusb2_phy_override_phy_params(qphy); + /* Set efuse value for tuning the PHY */ qusb2_phy_set_tune2_param(qphy); @@ -647,8 +731,8 @@ static int qusb2_phy_exit(struct phy *phy) .compatible = "qcom,msm8996-qusb2-phy", .data = &msm8996_phy_cfg, }, { - .compatible = "qcom,qusb2-v2-phy", - .data = &qusb2_v2_phy_cfg, + .compatible = "qcom,sdm845-qusb2-phy", + .data = &sdm845_phy_cfg, }, { }, }; @@ -668,6 +752,7 @@ static int qusb2_phy_probe(struct platform_device *pdev) struct resource *res; int ret, i; int num; + u32 value; qphy = devm_kzalloc(dev, sizeof(*qphy), GFP_KERNEL); if (!qphy) @@ -736,6 +821,31 @@ static int qusb2_phy_probe(struct platform_device *pdev) qphy->cell = NULL; dev_dbg(dev, "failed to lookup tune2 hstx trim value\n"); } + + if (!of_property_read_u32(dev->of_node, "qcom,imp-res-offset-value", + &value)) { + qphy->imp_res_offset_value = (u8)value; + qphy->override_imp_res_offset = true; + } + + if (!of_property_read_u32(dev->of_node, "qcom,hstx-trim-value", + &value)) { + qphy->hstx_trim_value = (u8)value; + qphy->override_hstx_trim = true; + } + + if (!of_property_read_u32(dev->of_node, "qcom,preemphasis-level", + &value)) { + qphy->preemphasis_level = (u8)value; + qphy->override_preemphasis = true; + } + + if (!of_property_read_u32(dev->of_node, "qcom,preemphasis-width", + &value)) { + qphy->preemphasis_width = (u8)value; + qphy->override_preemphasis_width = true; + } + pm_runtime_set_active(dev); pm_runtime_enable(dev); /* -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v5,7/7] phy: qcom-qusb2: Add QUSB2 PHYs support for sdm845 From: Manu Gautam Message-Id: <1525295174-15995-8-git-send-email-mgautam@codeaurora.org> Date: Thu, 3 May 2018 02:36:14 +0530 To: Kishon Vijay Abraham I , robh@kernel.org, sboyd@kernel.org Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, dianders@chromium.org, evgreen@chromium.org, Vivek Gautam , linux-arm-msm@vger.kernel.org, linux-usb@vger.kernel.org, Manu Gautam List-ID: VGhlcmUgYXJlIHR3byBRVVNCMiBQSFlzIHByZXNlbnQgb24gc2RtODQ1LiBJbiBvcmRlcgp0byBp bXByb3ZlIGV5ZSBkaWFncmFtIGZvciBib3RoIHRoZSBQSFlzIHNvbWUgcGFyYW1ldGVycwpuZWVk IHRvIGJlIGNoYW5nZWQuIFByb3ZpZGUgZGV2aWNlIHRyZWUgcHJvcGVydGllcyB0bwpvdmVycmlk ZSB0aGVzZSBmcm9tIGJvYXJkIHNwZWNpZmljIGRldmljZSB0cmVlIGZpbGVzLgoKU2lnbmVkLW9m Zi1ieTogTWFudSBHYXV0YW0gPG1nYXV0YW1AY29kZWF1cm9yYS5vcmc+Ci0tLQogZHJpdmVycy9w aHkvcXVhbGNvbW0vcGh5LXFjb20tcXVzYjIuYyB8IDEyNiArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrLS0tCiAxIGZpbGUgY2hhbmdlZCwgMTE4IGluc2VydGlvbnMoKyksIDggZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waHkvcXVhbGNvbW0vcGh5LXFjb20tcXVzYjIu YyBiL2RyaXZlcnMvcGh5L3F1YWxjb21tL3BoeS1xY29tLXF1c2IyLmMKaW5kZXggNDBmZGVmOC4u ZTcwZTQyNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9waHkvcXVhbGNvbW0vcGh5LXFjb20tcXVzYjIu YworKysgYi9kcml2ZXJzL3BoeS9xdWFsY29tbS9waHktcWNvbS1xdXNiMi5jCkBAIC0yMCw2ICsy MCw4IEBACiAjaW5jbHVkZSA8bGludXgvcmVzZXQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+ CiAKKyNpbmNsdWRlIDxkdC1iaW5kaW5ncy9waHkvcGh5LXFjb20tcXVzYjIuaD4KKwogI2RlZmlu ZSBRVVNCMlBIWV9QTExfVEVTVAkJMHgwNAogI2RlZmluZSBDTEtfUkVGX1NFTAkJCUJJVCg3KQog CkBAIC02MCw2ICs2MiwxNyBAQAogI2RlZmluZSBDT1JFX1JFU0VUCQkJCUJJVCg1KQogI2RlZmlu ZSBDT1JFX1JFU0VUX01VWAkJCQlCSVQoNikKIAorLyogUVVTQjJQSFlfSU1QX0NUUkwxIHJlZ2lz dGVyIGJpdHMgKi8KKyNkZWZpbmUgSU1QX1JFU19PRkZTRVRfTUFTSwkJCUdFTk1BU0soNSwgMCkK KyNkZWZpbmUgSU1QX1JFU19PRkZTRVRfU0hJRlQJCQkweDAKKworLyogUVVTQjJQSFlfUE9SVF9U VU5FMSByZWdpc3RlciBiaXRzICovCisjZGVmaW5lIEhTVFhfVFJJTV9NQVNLCQkJCUdFTk1BU0so NywgNCkKKyNkZWZpbmUgSFNUWF9UUklNX1NISUZUCQkJCTB4NAorI2RlZmluZSBQUkVFTVBIX1dJ RFRIX0hBTEZfQklUCQkJQklUKDIpCisjZGVmaW5lIFBSRUVNUEhBU0lTX0VOX01BU0sJCQlHRU5N QVNLKDEsIDApCisjZGVmaW5lIFBSRUVNUEhBU0lTX0VOX1NISUZUCQkJMHgwCisKICNkZWZpbmUg UVVTQjJQSFlfUExMX0FOQUxPR19DT05UUk9MU19UV08JMHgwNAogI2RlZmluZSBRVVNCMlBIWV9Q TExfQ0xPQ0tfSU5WRVJURVJTCQkweDE4YwogI2RlZmluZSBRVVNCMlBIWV9QTExfQ01PREUJCQkw eDJjCkBAIC0xMzksNyArMTUyLDcgQEAgZW51bSBxdXNiMnBoeV9yZWdfbGF5b3V0IHsKIAlRVVNC Ml9QSFlfSU5JVF9DRkcoUVVTQjJQSFlfUExMX1BXUl9DVFJMLCAweDAwKSwKIH07CiAKLXN0YXRp YyBjb25zdCB1bnNpZ25lZCBpbnQgcXVzYjJfdjJfcmVnc19sYXlvdXRbXSA9IHsKK3N0YXRpYyBj b25zdCB1bnNpZ25lZCBpbnQgc2RtODQ1X3JlZ3NfbGF5b3V0W10gPSB7CiAJW1FVU0IyUEhZX1BM TF9DT1JFX0lOUFVUX09WRVJSSURFXSA9IDB4YTgsCiAJW1FVU0IyUEhZX1BMTF9TVEFUVVNdCQk9 IDB4MWEwLAogCVtRVVNCMlBIWV9QT1JUX1RVTkUxXQkJPSAweDI0MCwKQEAgLTE1Myw3ICsxNjYs NyBAQCBlbnVtIHF1c2IycGh5X3JlZ19sYXlvdXQgewogCVtRVVNCMlBIWV9JTlRSX0NUUkxdCQk9 IDB4MjMwLAogfTsKIAotc3RhdGljIGNvbnN0IHN0cnVjdCBxdXNiMl9waHlfaW5pdF90YmwgcXVz YjJfdjJfaW5pdF90YmxbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcXVzYjJfcGh5X2luaXRf dGJsIHNkbTg0NV9pbml0X3RibFtdID0gewogCVFVU0IyX1BIWV9JTklUX0NGRyhRVVNCMlBIWV9Q TExfQU5BTE9HX0NPTlRST0xTX1RXTywgMHgwMyksCiAJUVVTQjJfUEhZX0lOSVRfQ0ZHKFFVU0Iy UEhZX1BMTF9DTE9DS19JTlZFUlRFUlMsIDB4N2MpLAogCVFVU0IyX1BIWV9JTklUX0NGRyhRVVNC MlBIWV9QTExfQ01PREUsIDB4ODApLApAQCAtMjA4LDEwICsyMjEsMTAgQEAgc3RydWN0IHF1c2Iy X3BoeV9jZmcgewogCS5hdXRvcmVzdW1lX2VuCSA9IEJJVCgzKSwKIH07CiAKLXN0YXRpYyBjb25z dCBzdHJ1Y3QgcXVzYjJfcGh5X2NmZyBxdXNiMl92Ml9waHlfY2ZnID0gewotCS50YmwJCT0gcXVz YjJfdjJfaW5pdF90YmwsCi0JLnRibF9udW0JPSBBUlJBWV9TSVpFKHF1c2IyX3YyX2luaXRfdGJs KSwKLQkucmVncwkJPSBxdXNiMl92Ml9yZWdzX2xheW91dCwKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg cXVzYjJfcGh5X2NmZyBzZG04NDVfcGh5X2NmZyA9IHsKKwkudGJsCQk9IHNkbTg0NV9pbml0X3Ri bCwKKwkudGJsX251bQk9IEFSUkFZX1NJWkUoc2RtODQ1X2luaXRfdGJsKSwKKwkucmVncwkJPSBz ZG04NDVfcmVnc19sYXlvdXQsCiAKIAkuZGlzYWJsZV9jdHJsCT0gKFBXUl9DVFJMMV9WUkVGX1NV UFBMWV9UUklNIHwgUFdSX0NUUkwxX0NMQU1QX05fRU4gfAogCQkJICAgUE9XRVJfRE9XTiksCkBA IC0yNDEsNiArMjU0LDE1IEBAIHN0cnVjdCBxdXNiMl9waHlfY2ZnIHsKICAqIEB0Y3NyOiBUQ1NS IHN5c2NvbiByZWdpc3RlciBtYXAKICAqIEBjZWxsOiBudm1lbSBjZWxsIGNvbnRhaW5pbmcgcGh5 IHR1bmluZyB2YWx1ZQogICoKKyAqIEBvdmVycmlkZV9pbXBfcmVzX29mZnNldDogUEhZIHNob3Vs ZCB1c2UgZGlmZmVyZW50IHJlc2NvZGUgb2Zmc2V0CisgKiBAaW1wX3Jlc19vZmZzZXRfdmFsdWU6 IHJlc2NvZGUgb2Zmc2V0IHRvIGJlIHVwZGF0ZWQgaW4gSU1QX0NUUkwxIHJlZ2lzdGVyCisgKiBA b3ZlcnJpZGVfaHN0eF90cmltOiBQSFkgc2hvdWxkIHVzZSBkaWZmZXJlbnQgSFNUWCBvL3AgY3Vy cmVudCB2YWx1ZQorICogQGhzdHhfdHJpbV92YWx1ZTogSFNUWF9UUklNIHZhbHVlIHRvIGJlIHVw ZGF0ZWQgaW4gVFVORTEgcmVnaXN0ZXIKKyAqIEBvdmVycmlkZV9wcmVlbXBoYXNpczogUEhZIHNo b3VsZCB1c2UgZGlmZmVyZW50IHByZS1hbXBoYXNpcyBhbXBsaXR1ZGUKKyAqIEBwcmVlbXBoYXNp c19sZXZlbDogQW1wbGl0dWRlIFByZS1FbXBoYXNpcyB0byBiZSB1cGRhdGVkIGluIFRVTkUxIHJl Z2lzdGVyCisgKiBAb3ZlcnJpZGVfcHJlZW1waGFzaXNfd2lkdGg6IFBIWSBzaG91bGQgdXNlIGRp ZmZlcmVudCBwcmUtZW1waGFzaXMgZHVyYXRpb24KKyAqIEBwcmVlbXBoYXNpc193aWR0aDogaGFs Zi9mdWxsLXdpZHRoIFByZS1FbXBoYXNpcyB1cGRhdGVkIHZpYSBUVU5FMQorICoKICAqIEBjZmc6 IHBoeSBjb25maWcgZGF0YQogICogQGhhc19zZV9jbGtfc2NoZW1lOiBpbmRpY2F0ZSBpZiBQSFkg aGFzIHNpbmdsZS1lbmRlZCByZWYgY2xvY2sgc2NoZW1lCiAgKiBAcGh5X2luaXRpYWxpemVkOiBp bmRpY2F0ZSBpZiBQSFkgaGFzIGJlZW4gaW5pdGlhbGl6ZWQKQEAgLTI1OSwxMiArMjgxLDM1IEBA IHN0cnVjdCBxdXNiMl9waHkgewogCXN0cnVjdCByZWdtYXAgKnRjc3I7CiAJc3RydWN0IG52bWVt X2NlbGwgKmNlbGw7CiAKKwlib29sIG92ZXJyaWRlX2ltcF9yZXNfb2Zmc2V0OworCXU4IGltcF9y ZXNfb2Zmc2V0X3ZhbHVlOworCWJvb2wgb3ZlcnJpZGVfaHN0eF90cmltOworCXU4IGhzdHhfdHJp bV92YWx1ZTsKKwlib29sIG92ZXJyaWRlX3ByZWVtcGhhc2lzOworCXU4IHByZWVtcGhhc2lzX2xl dmVsOworCWJvb2wgb3ZlcnJpZGVfcHJlZW1waGFzaXNfd2lkdGg7CisJdTggcHJlZW1waGFzaXNf d2lkdGg7CisKIAljb25zdCBzdHJ1Y3QgcXVzYjJfcGh5X2NmZyAqY2ZnOwogCWJvb2wgaGFzX3Nl X2Nsa19zY2hlbWU7CiAJYm9vbCBwaHlfaW5pdGlhbGl6ZWQ7CiAJZW51bSBwaHlfbW9kZSBtb2Rl OwogfTsKIAorc3RhdGljIGlubGluZSB2b2lkIHF1c2IyX3dyaXRlX21hc2sodm9pZCBfX2lvbWVt ICpiYXNlLCB1MzIgb2Zmc2V0LAorCQkJCSAgICB1MzIgdmFsLCB1MzIgbWFzaykKK3sKKwl1MzIg cmVnOworCisJcmVnID0gcmVhZGwoYmFzZSArIG9mZnNldCk7CisJcmVnICY9IH5tYXNrOworCXJl ZyB8PSB2YWwgJiBtYXNrOworCXdyaXRlbChyZWcsIGJhc2UgKyBvZmZzZXQpOworCisJLyogRW5z dXJlIGFib3ZlIHdyaXRlIGlzIGNvbXBsZXRlZCAqLworCXJlYWRsKGJhc2UgKyBvZmZzZXQpOwor fQorCiBzdGF0aWMgaW5saW5lIHZvaWQgcXVzYjJfc2V0Yml0cyh2b2lkIF9faW9tZW0gKmJhc2Us IHUzMiBvZmZzZXQsIHUzMiB2YWwpCiB7CiAJdTMyIHJlZzsKQEAgLTMwNSw2ICszNTAsNDIgQEAg dm9pZCBxY29tX3F1c2IyX3BoeV9jb25maWd1cmUodm9pZCBfX2lvbWVtICpiYXNlLAogfQogCiAv KgorICogVXBkYXRlIGJvYXJkIHNwZWNpZmljIFBIWSB0dW5pbmcgb3ZlcnJpZGUgdmFsdWVzIGlm IHNwZWNpZmllZCBmcm9tCisgKiBkZXZpY2UgdHJlZS4KKyAqLworc3RhdGljIHZvaWQgcXVzYjJf cGh5X292ZXJyaWRlX3BoeV9wYXJhbXMoc3RydWN0IHF1c2IyX3BoeSAqcXBoeSkKK3sKKwljb25z dCBzdHJ1Y3QgcXVzYjJfcGh5X2NmZyAqY2ZnID0gcXBoeS0+Y2ZnOworCisJaWYgKHFwaHktPm92 ZXJyaWRlX2ltcF9yZXNfb2Zmc2V0KQorCQlxdXNiMl93cml0ZV9tYXNrKHFwaHktPmJhc2UsIFFV U0IyUEhZX0lNUF9DVFJMMSwKKwkJCSAgICAgcXBoeS0+aW1wX3Jlc19vZmZzZXRfdmFsdWUgPDwg SU1QX1JFU19PRkZTRVRfU0hJRlQsCisJCQkgICAgIElNUF9SRVNfT0ZGU0VUX01BU0spOworCisJ aWYgKHFwaHktPm92ZXJyaWRlX2hzdHhfdHJpbSkKKwkJcXVzYjJfd3JpdGVfbWFzayhxcGh5LT5i YXNlLCBjZmctPnJlZ3NbUVVTQjJQSFlfUE9SVF9UVU5FMV0sCisJCQkJIHFwaHktPmhzdHhfdHJp bV92YWx1ZSA8PCBIU1RYX1RSSU1fU0hJRlQsCisJCQkJIEhTVFhfVFJJTV9NQVNLKTsKKworCWlm IChxcGh5LT5vdmVycmlkZV9wcmVlbXBoYXNpcykKKwkJcXVzYjJfd3JpdGVfbWFzayhxcGh5LT5i YXNlLCBjZmctPnJlZ3NbUVVTQjJQSFlfUE9SVF9UVU5FMV0sCisJCQkJcXBoeS0+cHJlZW1waGFz aXNfbGV2ZWwgPDwgUFJFRU1QSEFTSVNfRU5fU0hJRlQsCisJCQkJUFJFRU1QSEFTSVNfRU5fTUFT Syk7CisKKwlpZiAocXBoeS0+b3ZlcnJpZGVfcHJlZW1waGFzaXNfd2lkdGgpIHsKKwkJaWYgKHFw aHktPnByZWVtcGhhc2lzX3dpZHRoID09CisJCSAgICBRVVNCMl9WMl9QUkVFTVBIQVNJU19XSURU SF9IQUxGX0JJVCkKKwkJCXF1c2IyX3NldGJpdHMocXBoeS0+YmFzZSwKKwkJCQkgICAgICBjZmct PnJlZ3NbUVVTQjJQSFlfUE9SVF9UVU5FMV0sCisJCQkJICAgICAgUFJFRU1QSF9XSURUSF9IQUxG X0JJVCk7CisJCWVsc2UKKwkJCXF1c2IyX2NscmJpdHMocXBoeS0+YmFzZSwKKwkJCQkgICAgICBj ZmctPnJlZ3NbUVVTQjJQSFlfUE9SVF9UVU5FMV0sCisJCQkJICAgICAgUFJFRU1QSF9XSURUSF9I QUxGX0JJVCk7CisJfQorfQorCisvKgogICogRmV0Y2hlcyBIUyBUeCB0dW5pbmcgdmFsdWUgZnJv bSBudm1lbSBhbmQgc2V0cyB0aGUKICAqIFFVU0IyUEhZX1BPUlRfVFVORTEvMiByZWdpc3Rlci4K ICAqIEZvciBlcnJvciBjYXNlLCBza2lwIHNldHRpbmcgdGhlIHZhbHVlIGFuZCB1c2UgdGhlIGRl ZmF1bHQgdmFsdWUuCkBAIC01MjUsNiArNjA2LDkgQEAgc3RhdGljIGludCBxdXNiMl9waHlfaW5p dChzdHJ1Y3QgcGh5ICpwaHkpCiAJcWNvbV9xdXNiMl9waHlfY29uZmlndXJlKHFwaHktPmJhc2Us IGNmZy0+cmVncywgY2ZnLT50YmwsCiAJCQkJIGNmZy0+dGJsX251bSk7CiAKKwkvKiBPdmVycmlk ZSBib2FyZCBzcGVjaWZpYyBQSFkgdHVuaW5nIHZhbHVlcyAqLworCXF1c2IyX3BoeV9vdmVycmlk ZV9waHlfcGFyYW1zKHFwaHkpOworCiAJLyogU2V0IGVmdXNlIHZhbHVlIGZvciB0dW5pbmcgdGhl IFBIWSAqLwogCXF1c2IyX3BoeV9zZXRfdHVuZTJfcGFyYW0ocXBoeSk7CiAKQEAgLTY0Nyw4ICs3 MzEsOCBAQCBzdGF0aWMgaW50IHF1c2IyX3BoeV9leGl0KHN0cnVjdCBwaHkgKnBoeSkKIAkJLmNv bXBhdGlibGUJPSAicWNvbSxtc204OTk2LXF1c2IyLXBoeSIsCiAJCS5kYXRhCQk9ICZtc204OTk2 X3BoeV9jZmcsCiAJfSwgewotCQkuY29tcGF0aWJsZQk9ICJxY29tLHF1c2IyLXYyLXBoeSIsCi0J CS5kYXRhCQk9ICZxdXNiMl92Ml9waHlfY2ZnLAorCQkuY29tcGF0aWJsZQk9ICJxY29tLHNkbTg0 NS1xdXNiMi1waHkiLAorCQkuZGF0YQkJPSAmc2RtODQ1X3BoeV9jZmcsCiAJfSwKIAl7IH0sCiB9 OwpAQCAtNjY4LDYgKzc1Miw3IEBAIHN0YXRpYyBpbnQgcXVzYjJfcGh5X3Byb2JlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJc3RydWN0IHJlc291cmNlICpyZXM7CiAJaW50IHJldCwg aTsKIAlpbnQgbnVtOworCXUzMiB2YWx1ZTsKIAogCXFwaHkgPSBkZXZtX2t6YWxsb2MoZGV2LCBz aXplb2YoKnFwaHkpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIXFwaHkpCkBAIC03MzYsNiArODIxLDMx IEBAIHN0YXRpYyBpbnQgcXVzYjJfcGh5X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk ZXYpCiAJCXFwaHktPmNlbGwgPSBOVUxMOwogCQlkZXZfZGJnKGRldiwgImZhaWxlZCB0byBsb29r dXAgdHVuZTIgaHN0eCB0cmltIHZhbHVlXG4iKTsKIAl9CisKKwlpZiAoIW9mX3Byb3BlcnR5X3Jl YWRfdTMyKGRldi0+b2Zfbm9kZSwgInFjb20saW1wLXJlcy1vZmZzZXQtdmFsdWUiLAorCQkJCSAg JnZhbHVlKSkgeworCQlxcGh5LT5pbXBfcmVzX29mZnNldF92YWx1ZSA9ICh1OCl2YWx1ZTsKKwkJ cXBoeS0+b3ZlcnJpZGVfaW1wX3Jlc19vZmZzZXQgPSB0cnVlOworCX0KKworCWlmICghb2ZfcHJv cGVydHlfcmVhZF91MzIoZGV2LT5vZl9ub2RlLCAicWNvbSxoc3R4LXRyaW0tdmFsdWUiLAorCQkJ CSAgJnZhbHVlKSkgeworCQlxcGh5LT5oc3R4X3RyaW1fdmFsdWUgPSAodTgpdmFsdWU7CisJCXFw aHktPm92ZXJyaWRlX2hzdHhfdHJpbSA9IHRydWU7CisJfQorCisJaWYgKCFvZl9wcm9wZXJ0eV9y ZWFkX3UzMihkZXYtPm9mX25vZGUsICJxY29tLHByZWVtcGhhc2lzLWxldmVsIiwKKwkJCQkgICAg ICZ2YWx1ZSkpIHsKKwkJcXBoeS0+cHJlZW1waGFzaXNfbGV2ZWwgPSAodTgpdmFsdWU7CisJCXFw aHktPm92ZXJyaWRlX3ByZWVtcGhhc2lzID0gdHJ1ZTsKKwl9CisKKwlpZiAoIW9mX3Byb3BlcnR5 X3JlYWRfdTMyKGRldi0+b2Zfbm9kZSwgInFjb20scHJlZW1waGFzaXMtd2lkdGgiLAorCQkJCSAg ICAgJnZhbHVlKSkgeworCQlxcGh5LT5wcmVlbXBoYXNpc193aWR0aCA9ICh1OCl2YWx1ZTsKKwkJ cXBoeS0+b3ZlcnJpZGVfcHJlZW1waGFzaXNfd2lkdGggPSB0cnVlOworCX0KKwogCXBtX3J1bnRp bWVfc2V0X2FjdGl2ZShkZXYpOwogCXBtX3J1bnRpbWVfZW5hYmxlKGRldik7CiAJLyoK