From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,T_DKIMWL_WL_HIGH,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9E867C43219 for ; Thu, 2 May 2019 22:54:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 525AF2081C for ; Thu, 2 May 2019 22:54:35 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="RwI3FCTd" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726401AbfEBWyd (ORCPT ); Thu, 2 May 2019 18:54:33 -0400 Received: from mail-pf1-f196.google.com ([209.85.210.196]:39347 "EHLO mail-pf1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726022AbfEBWy0 (ORCPT ); Thu, 2 May 2019 18:54:26 -0400 Received: by mail-pf1-f196.google.com with SMTP id z26so1854426pfg.6 for ; Thu, 02 May 2019 15:54:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=l64/bY1LxWfLDdKRyx3HvfnrnrE3pPmc5ecC8BHS8F8=; b=RwI3FCTdhPlmT+vMtbOwvhHezJhcz6S3wikgsAnwkzLmQ+9lRGGWZfnNLQ7JOD3f3V O618Ee2olbH1vL5uLwrwyxrNnp/TRnW88UEo6BeI7bB6wvtvXpGkZYd/9QPsiyrQWmTc S0/rHacmhEwblVNjhViOt5F8O/gOx/K3I45VM= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=l64/bY1LxWfLDdKRyx3HvfnrnrE3pPmc5ecC8BHS8F8=; b=GvH5ADHIn0GJk2H2gtNtE6URfK8U3wzuG+ok9vGR/z1pHze4IjUzGocDTpr/ijMjrr ZqH91o6gquSkhEkz+4Ksj6nudmgCxAaiwp791f43RlWwWa5ykKXFG5Oqr0DbdIqfyJfJ 43T0L/FMJN1JMsKS8ERw0nj1f6FUmQRPHDLfjarIJOx7ZAcZ/NQdLrc4qIuhZi2lXDq+ eMZS+478J1LiXM/JGSXvdpVJDWTBZPAg84yWZONvXWx/M+yjFPz5CQ3EIuQzJdR2RtCt TQ4YtScAXS48jTMLRV3hCKPzideRPcUiEhgws5ck3oa2hKY4JiSxzx9I2ScnxvV79b8I 9VeQ== X-Gm-Message-State: APjAAAXaD5M4VQi73QXwG+VsKeVY/8RBhou199jxxW7j0kYhoTfyZrBL 7izFHrz8KnRVsIeUehtF7NFsBQ== X-Google-Smtp-Source: APXvYqw76PWYSXX61eOhftbcTudFyvpDPm4S/i4gNcHsWTvjZHUKRbeYb0d9ibyOWF51AFQB+grXKg== X-Received: by 2002:a63:f707:: with SMTP id x7mr6521431pgh.343.1556837665388; Thu, 02 May 2019 15:54:25 -0700 (PDT) Received: from tictac2.mtv.corp.google.com ([2620:15c:202:1:24fa:e766:52c9:e3b2]) by smtp.gmail.com with ESMTPSA id v15sm264736pff.105.2019.05.02.15.54.24 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 02 May 2019 15:54:24 -0700 (PDT) From: Douglas Anderson To: Heiko Stuebner , Sandy Huang , Andrzej Hajda , Laurent Pinchart , Rob Herring Cc: linux-rockchip@lists.infradead.org, Neil Armstrong , Mark Rutland , mka@chromium.org, Sean Paul , Douglas Anderson , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, David Airlie , Jernej Skrabec , Daniel Vetter Subject: [PATCH 2/5] drm/bridge/synopsys: dw-hdmi: Add "unwedge" for ddc bus Date: Thu, 2 May 2019 15:53:33 -0700 Message-Id: <20190502225336.206885-2-dianders@chromium.org> X-Mailer: git-send-email 2.21.0.1020.gf2820cf01a-goog In-Reply-To: <20190502225336.206885-1-dianders@chromium.org> References: <20190502225336.206885-1-dianders@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org See the PhD thesis in the comments in this patch for details, but to summarize this adds a hacky "unwedge" feature to the dw_hdmi i2c bus to workaround what appears to be a hardware errata. This relies on a pinctrl entry to help change around muxing to perform the unwedge. NOTE that the specific TV this was tested on was the "Samsung UN40HU6950FXZA" and the specific port was the "STB" port. Signed-off-by: Douglas Anderson --- drivers/gpu/drm/bridge/synopsys/dw-hdmi.c | 116 +++++++++++++++++++--- 1 file changed, 100 insertions(+), 16 deletions(-) diff --git a/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c b/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c index db761329a1e3..c66587e33813 100644 --- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c +++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -169,6 +170,10 @@ struct dw_hdmi { bool sink_is_hdmi; bool sink_has_audio; + struct pinctrl *pinctrl; + struct pinctrl_state *default_state; + struct pinctrl_state *unwedge_state; + struct mutex mutex; /* for state below and previous_mode */ enum drm_connector_force force; /* mutex-protected force state */ bool disabled; /* DRM has disabled our bridge */ @@ -247,11 +252,82 @@ static void dw_hdmi_i2c_init(struct dw_hdmi *hdmi) HDMI_IH_MUTE_I2CM_STAT0); } +static bool dw_hdmi_i2c_unwedge(struct dw_hdmi *hdmi) +{ + /* If no unwedge state then give up */ + if (IS_ERR(hdmi->unwedge_state)) + return false; + + dev_info(hdmi->dev, "Attempting to unwedge stuck i2c bus\n"); + + /* + * This is a huge hack to workaround a problem where the dw_hdmi i2c + * bus could sometimes get wedged. Once wedged there doesn't appear + * to be any way to unwedge it (including the HDMI_I2CM_SOFTRSTZ) + * other than pulsing the SDA line. + * + * We appear to be able to pulse the SDA line (in the eyes of dw_hdmi) + * by: + * 1. Remux the pin as a GPIO output, driven low. + * 2. Wait a little while. 1 ms seems to work, but we'll do 10. + * 3. Immediately jump to remux the pin as dw_hdmi i2c again. + * + * At the moment of remuxing, the line will still be low due to its + * recent stint as an output, but then it will be pulled high by the + * (presumed) external pullup. dw_hdmi seems to see this as a rising + * edge and that seems to get it out of its jam. + * + * This wedging was only ever seen on one TV, and only on one of + * its HDMI ports. It happened when the TV was powered on while the + * device was plugged in. A scope trace shows the TV bringing both SDA + * and SCL low, then bringing them both back up at roughly the same + * time. Presumably this confuses dw_hdmi because it saw activity but + * no real STOP (maybe it thinks there's another master on the bus?). + * Giving it a clean rising edge of SDA while SCL is already high + * presumably makes dw_hdmi see a STOP which seems to bring dw_hdmi out + * of its stupor. + * + * Note that after coming back alive, transfers seem to immediately + * resume, so if we unwedge due to a timeout we should wait a little + * longer for our transfer to finish, since it might have just started + * now. + */ + pinctrl_select_state(hdmi->pinctrl, hdmi->unwedge_state); + msleep(10); + pinctrl_select_state(hdmi->pinctrl, hdmi->default_state); + + return true; +} + +static int dw_hdmi_i2c_wait(struct dw_hdmi *hdmi) +{ + struct dw_hdmi_i2c *i2c = hdmi->i2c; + int stat; + + stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10); + if (!stat) { + /* If we can't unwedge, return timeout */ + if (!dw_hdmi_i2c_unwedge(hdmi)) + return -EAGAIN; + + /* We tried to unwedge; give it another chance */ + stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10); + if (!stat) + return -EAGAIN; + } + + /* Check for error condition on the bus */ + if (i2c->stat & HDMI_IH_I2CM_STAT0_ERROR) + return -EIO; + + return 0; +} + static int dw_hdmi_i2c_read(struct dw_hdmi *hdmi, unsigned char *buf, unsigned int length) { struct dw_hdmi_i2c *i2c = hdmi->i2c; - int stat; + int ret; if (!i2c->is_regaddr) { dev_dbg(hdmi->dev, "set read register address to 0\n"); @@ -270,13 +346,9 @@ static int dw_hdmi_i2c_read(struct dw_hdmi *hdmi, hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_READ, HDMI_I2CM_OPERATION); - stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10); - if (!stat) - return -EAGAIN; - - /* Check for error condition on the bus */ - if (i2c->stat & HDMI_IH_I2CM_STAT0_ERROR) - return -EIO; + ret = dw_hdmi_i2c_wait(hdmi); + if (ret) + return ret; *buf++ = hdmi_readb(hdmi, HDMI_I2CM_DATAI); } @@ -289,7 +361,7 @@ static int dw_hdmi_i2c_write(struct dw_hdmi *hdmi, unsigned char *buf, unsigned int length) { struct dw_hdmi_i2c *i2c = hdmi->i2c; - int stat; + int ret; if (!i2c->is_regaddr) { /* Use the first write byte as register address */ @@ -307,13 +379,9 @@ static int dw_hdmi_i2c_write(struct dw_hdmi *hdmi, hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_WRITE, HDMI_I2CM_OPERATION); - stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10); - if (!stat) - return -EAGAIN; - - /* Check for error condition on the bus */ - if (i2c->stat & HDMI_IH_I2CM_STAT0_ERROR) - return -EIO; + ret = dw_hdmi_i2c_wait(hdmi); + if (ret) + return ret; } return 0; @@ -2606,6 +2674,22 @@ __dw_hdmi_probe(struct platform_device *pdev, /* If DDC bus is not specified, try to register HDMI I2C bus */ if (!hdmi->ddc) { + /* Look for (optional) stuff related to unwedging */ + hdmi->pinctrl = devm_pinctrl_get(dev); + if (!IS_ERR(hdmi->pinctrl)) { + hdmi->unwedge_state = + pinctrl_lookup_state(hdmi->pinctrl, "unwedge"); + hdmi->default_state = + pinctrl_lookup_state(hdmi->pinctrl, "default"); + + if (IS_ERR(hdmi->default_state) && + !IS_ERR(hdmi->unwedge_state)) { + dev_warn(dev, + "Unwedge requires default pinctrl\n"); + hdmi->unwedge_state = ERR_PTR(-ENODEV); + } + } + hdmi->ddc = dw_hdmi_i2c_adapter(hdmi); if (IS_ERR(hdmi->ddc)) hdmi->ddc = NULL; -- 2.21.0.1020.gf2820cf01a-goog From mboxrd@z Thu Jan 1 00:00:00 1970 From: Douglas Anderson Subject: [PATCH 2/5] drm/bridge/synopsys: dw-hdmi: Add "unwedge" for ddc bus Date: Thu, 2 May 2019 15:53:33 -0700 Message-ID: <20190502225336.206885-2-dianders@chromium.org> References: <20190502225336.206885-1-dianders@chromium.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190502225336.206885-1-dianders@chromium.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Heiko Stuebner , Sandy Huang , Andrzej Hajda , Laurent Pinchart , Rob Herring Cc: Mark Rutland , Jernej Skrabec , Neil Armstrong , David Airlie , Douglas Anderson , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-rockchip@lists.infradead.org, mka@chromium.org, Sean Paul List-Id: linux-rockchip.vger.kernel.org U2VlIHRoZSBQaEQgdGhlc2lzIGluIHRoZSBjb21tZW50cyBpbiB0aGlzIHBhdGNoIGZvciBkZXRh aWxzLCBidXQgdG8Kc3VtbWFyaXplIHRoaXMgYWRkcyBhIGhhY2t5ICJ1bndlZGdlIiBmZWF0dXJl IHRvIHRoZSBkd19oZG1pIGkyYyBidXMgdG8Kd29ya2Fyb3VuZCB3aGF0IGFwcGVhcnMgdG8gYmUg YSBoYXJkd2FyZSBlcnJhdGEuICBUaGlzIHJlbGllcyBvbiBhCnBpbmN0cmwgZW50cnkgdG8gaGVs cCBjaGFuZ2UgYXJvdW5kIG11eGluZyB0byBwZXJmb3JtIHRoZSB1bndlZGdlLgoKTk9URSB0aGF0 IHRoZSBzcGVjaWZpYyBUViB0aGlzIHdhcyB0ZXN0ZWQgb24gd2FzIHRoZSAiU2Ftc3VuZwpVTjQw SFU2OTUwRlhaQSIgYW5kIHRoZSBzcGVjaWZpYyBwb3J0IHdhcyB0aGUgIlNUQiIgcG9ydC4KClNp Z25lZC1vZmYtYnk6IERvdWdsYXMgQW5kZXJzb24gPGRpYW5kZXJzQGNocm9taXVtLm9yZz4KLS0t CgogZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9zeW5vcHN5cy9kdy1oZG1pLmMgfCAxMTYgKysrKysr KysrKysrKysrKysrKy0tLQogMSBmaWxlIGNoYW5nZWQsIDEwMCBpbnNlcnRpb25zKCspLCAxNiBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL3N5bm9wc3lz L2R3LWhkbWkuYyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2Uvc3lub3BzeXMvZHctaGRtaS5jCmlu ZGV4IGRiNzYxMzI5YTFlMy4uYzY2NTg3ZTMzODEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vYnJpZGdlL3N5bm9wc3lzL2R3LWhkbWkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdl L3N5bm9wc3lzL2R3LWhkbWkuYwpAQCAtMTksNiArMTksNyBAQAogI2luY2x1ZGUgPGxpbnV4L2hk bWkuaD4KICNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgogI2luY2x1ZGUgPGxpbnV4L29mX2Rldmlj ZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvY29uc3VtZXIuaD4KICNpbmNsdWRlIDxsaW51 eC9yZWdtYXAuaD4KICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgogCkBAIC0xNjksNiArMTcw LDEwIEBAIHN0cnVjdCBkd19oZG1pIHsKIAlib29sIHNpbmtfaXNfaGRtaTsKIAlib29sIHNpbmtf aGFzX2F1ZGlvOwogCisJc3RydWN0IHBpbmN0cmwgKnBpbmN0cmw7CisJc3RydWN0IHBpbmN0cmxf c3RhdGUgKmRlZmF1bHRfc3RhdGU7CisJc3RydWN0IHBpbmN0cmxfc3RhdGUgKnVud2VkZ2Vfc3Rh dGU7CisKIAlzdHJ1Y3QgbXV0ZXggbXV0ZXg7CQkvKiBmb3Igc3RhdGUgYmVsb3cgYW5kIHByZXZp b3VzX21vZGUgKi8KIAllbnVtIGRybV9jb25uZWN0b3JfZm9yY2UgZm9yY2U7CS8qIG11dGV4LXBy b3RlY3RlZCBmb3JjZSBzdGF0ZSAqLwogCWJvb2wgZGlzYWJsZWQ7CQkJLyogRFJNIGhhcyBkaXNh YmxlZCBvdXIgYnJpZGdlICovCkBAIC0yNDcsMTEgKzI1Miw4MiBAQCBzdGF0aWMgdm9pZCBkd19o ZG1pX2kyY19pbml0KHN0cnVjdCBkd19oZG1pICpoZG1pKQogCQkgICAgSERNSV9JSF9NVVRFX0ky Q01fU1RBVDApOwogfQogCitzdGF0aWMgYm9vbCBkd19oZG1pX2kyY191bndlZGdlKHN0cnVjdCBk d19oZG1pICpoZG1pKQoreworCS8qIElmIG5vIHVud2VkZ2Ugc3RhdGUgdGhlbiBnaXZlIHVwICov CisJaWYgKElTX0VSUihoZG1pLT51bndlZGdlX3N0YXRlKSkKKwkJcmV0dXJuIGZhbHNlOworCisJ ZGV2X2luZm8oaGRtaS0+ZGV2LCAiQXR0ZW1wdGluZyB0byB1bndlZGdlIHN0dWNrIGkyYyBidXNc biIpOworCisJLyoKKwkgKiBUaGlzIGlzIGEgaHVnZSBoYWNrIHRvIHdvcmthcm91bmQgYSBwcm9i bGVtIHdoZXJlIHRoZSBkd19oZG1pIGkyYworCSAqIGJ1cyBjb3VsZCBzb21ldGltZXMgZ2V0IHdl ZGdlZC4gIE9uY2Ugd2VkZ2VkIHRoZXJlIGRvZXNuJ3QgYXBwZWFyCisJICogdG8gYmUgYW55IHdh eSB0byB1bndlZGdlIGl0IChpbmNsdWRpbmcgdGhlIEhETUlfSTJDTV9TT0ZUUlNUWikKKwkgKiBv dGhlciB0aGFuIHB1bHNpbmcgdGhlIFNEQSBsaW5lLgorCSAqCisJICogV2UgYXBwZWFyIHRvIGJl IGFibGUgdG8gcHVsc2UgdGhlIFNEQSBsaW5lIChpbiB0aGUgZXllcyBvZiBkd19oZG1pKQorCSAq IGJ5OgorCSAqIDEuIFJlbXV4IHRoZSBwaW4gYXMgYSBHUElPIG91dHB1dCwgZHJpdmVuIGxvdy4K KwkgKiAyLiBXYWl0IGEgbGl0dGxlIHdoaWxlLiAgMSBtcyBzZWVtcyB0byB3b3JrLCBidXQgd2Un bGwgZG8gMTAuCisJICogMy4gSW1tZWRpYXRlbHkganVtcCB0byByZW11eCB0aGUgcGluIGFzIGR3 X2hkbWkgaTJjIGFnYWluLgorCSAqCisJICogQXQgdGhlIG1vbWVudCBvZiByZW11eGluZywgdGhl IGxpbmUgd2lsbCBzdGlsbCBiZSBsb3cgZHVlIHRvIGl0cworCSAqIHJlY2VudCBzdGludCBhcyBh biBvdXRwdXQsIGJ1dCB0aGVuIGl0IHdpbGwgYmUgcHVsbGVkIGhpZ2ggYnkgdGhlCisJICogKHBy ZXN1bWVkKSBleHRlcm5hbCBwdWxsdXAuICBkd19oZG1pIHNlZW1zIHRvIHNlZSB0aGlzIGFzIGEg cmlzaW5nCisJICogZWRnZSBhbmQgdGhhdCBzZWVtcyB0byBnZXQgaXQgb3V0IG9mIGl0cyBqYW0u CisJICoKKwkgKiBUaGlzIHdlZGdpbmcgd2FzIG9ubHkgZXZlciBzZWVuIG9uIG9uZSBUViwgYW5k IG9ubHkgb24gb25lIG9mCisJICogaXRzIEhETUkgcG9ydHMuICBJdCBoYXBwZW5lZCB3aGVuIHRo ZSBUViB3YXMgcG93ZXJlZCBvbiB3aGlsZSB0aGUKKwkgKiBkZXZpY2Ugd2FzIHBsdWdnZWQgaW4u ICBBIHNjb3BlIHRyYWNlIHNob3dzIHRoZSBUViBicmluZ2luZyBib3RoIFNEQQorCSAqIGFuZCBT Q0wgbG93LCB0aGVuIGJyaW5naW5nIHRoZW0gYm90aCBiYWNrIHVwIGF0IHJvdWdobHkgdGhlIHNh bWUKKwkgKiB0aW1lLiAgUHJlc3VtYWJseSB0aGlzIGNvbmZ1c2VzIGR3X2hkbWkgYmVjYXVzZSBp dCBzYXcgYWN0aXZpdHkgYnV0CisJICogbm8gcmVhbCBTVE9QIChtYXliZSBpdCB0aGlua3MgdGhl cmUncyBhbm90aGVyIG1hc3RlciBvbiB0aGUgYnVzPykuCisJICogR2l2aW5nIGl0IGEgY2xlYW4g cmlzaW5nIGVkZ2Ugb2YgU0RBIHdoaWxlIFNDTCBpcyBhbHJlYWR5IGhpZ2gKKwkgKiBwcmVzdW1h Ymx5IG1ha2VzIGR3X2hkbWkgc2VlIGEgU1RPUCB3aGljaCBzZWVtcyB0byBicmluZyBkd19oZG1p IG91dAorCSAqIG9mIGl0cyBzdHVwb3IuCisJICoKKwkgKiBOb3RlIHRoYXQgYWZ0ZXIgY29taW5n IGJhY2sgYWxpdmUsIHRyYW5zZmVycyBzZWVtIHRvIGltbWVkaWF0ZWx5CisJICogcmVzdW1lLCBz byBpZiB3ZSB1bndlZGdlIGR1ZSB0byBhIHRpbWVvdXQgd2Ugc2hvdWxkIHdhaXQgYSBsaXR0bGUK KwkgKiBsb25nZXIgZm9yIG91ciB0cmFuc2ZlciB0byBmaW5pc2gsIHNpbmNlIGl0IG1pZ2h0IGhh dmUganVzdCBzdGFydGVkCisJICogbm93LgorCSAqLworCXBpbmN0cmxfc2VsZWN0X3N0YXRlKGhk bWktPnBpbmN0cmwsIGhkbWktPnVud2VkZ2Vfc3RhdGUpOworCW1zbGVlcCgxMCk7CisJcGluY3Ry bF9zZWxlY3Rfc3RhdGUoaGRtaS0+cGluY3RybCwgaGRtaS0+ZGVmYXVsdF9zdGF0ZSk7CisKKwly ZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIGludCBkd19oZG1pX2kyY193YWl0KHN0cnVjdCBkd19o ZG1pICpoZG1pKQoreworCXN0cnVjdCBkd19oZG1pX2kyYyAqaTJjID0gaGRtaS0+aTJjOworCWlu dCBzdGF0OworCisJc3RhdCA9IHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmaTJjLT5jbXAs IEhaIC8gMTApOworCWlmICghc3RhdCkgeworCQkvKiBJZiB3ZSBjYW4ndCB1bndlZGdlLCByZXR1 cm4gdGltZW91dCAqLworCQlpZiAoIWR3X2hkbWlfaTJjX3Vud2VkZ2UoaGRtaSkpCisJCQlyZXR1 cm4gLUVBR0FJTjsKKworCQkvKiBXZSB0cmllZCB0byB1bndlZGdlOyBnaXZlIGl0IGFub3RoZXIg Y2hhbmNlICovCisJCXN0YXQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmkyYy0+Y21w LCBIWiAvIDEwKTsKKwkJaWYgKCFzdGF0KQorCQkJcmV0dXJuIC1FQUdBSU47CisJfQorCisJLyog Q2hlY2sgZm9yIGVycm9yIGNvbmRpdGlvbiBvbiB0aGUgYnVzICovCisJaWYgKGkyYy0+c3RhdCAm IEhETUlfSUhfSTJDTV9TVEFUMF9FUlJPUikKKwkJcmV0dXJuIC1FSU87CisKKwlyZXR1cm4gMDsK K30KKwogc3RhdGljIGludCBkd19oZG1pX2kyY19yZWFkKHN0cnVjdCBkd19oZG1pICpoZG1pLAog CQkJICAgIHVuc2lnbmVkIGNoYXIgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbmd0aCkKIHsKIAlzdHJ1 Y3QgZHdfaGRtaV9pMmMgKmkyYyA9IGhkbWktPmkyYzsKLQlpbnQgc3RhdDsKKwlpbnQgcmV0Owog CiAJaWYgKCFpMmMtPmlzX3JlZ2FkZHIpIHsKIAkJZGV2X2RiZyhoZG1pLT5kZXYsICJzZXQgcmVh ZCByZWdpc3RlciBhZGRyZXNzIHRvIDBcbiIpOwpAQCAtMjcwLDEzICszNDYsOSBAQCBzdGF0aWMg aW50IGR3X2hkbWlfaTJjX3JlYWQoc3RydWN0IGR3X2hkbWkgKmhkbWksCiAJCQloZG1pX3dyaXRl YihoZG1pLCBIRE1JX0kyQ01fT1BFUkFUSU9OX1JFQUQsCiAJCQkJICAgIEhETUlfSTJDTV9PUEVS QVRJT04pOwogCi0JCXN0YXQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmkyYy0+Y21w LCBIWiAvIDEwKTsKLQkJaWYgKCFzdGF0KQotCQkJcmV0dXJuIC1FQUdBSU47Ci0KLQkJLyogQ2hl Y2sgZm9yIGVycm9yIGNvbmRpdGlvbiBvbiB0aGUgYnVzICovCi0JCWlmIChpMmMtPnN0YXQgJiBI RE1JX0lIX0kyQ01fU1RBVDBfRVJST1IpCi0JCQlyZXR1cm4gLUVJTzsKKwkJcmV0ID0gZHdfaGRt aV9pMmNfd2FpdChoZG1pKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CiAKIAkJKmJ1Zisr ID0gaGRtaV9yZWFkYihoZG1pLCBIRE1JX0kyQ01fREFUQUkpOwogCX0KQEAgLTI4OSw3ICszNjEs NyBAQCBzdGF0aWMgaW50IGR3X2hkbWlfaTJjX3dyaXRlKHN0cnVjdCBkd19oZG1pICpoZG1pLAog CQkJICAgICB1bnNpZ25lZCBjaGFyICpidWYsIHVuc2lnbmVkIGludCBsZW5ndGgpCiB7CiAJc3Ry dWN0IGR3X2hkbWlfaTJjICppMmMgPSBoZG1pLT5pMmM7Ci0JaW50IHN0YXQ7CisJaW50IHJldDsK IAogCWlmICghaTJjLT5pc19yZWdhZGRyKSB7CiAJCS8qIFVzZSB0aGUgZmlyc3Qgd3JpdGUgYnl0 ZSBhcyByZWdpc3RlciBhZGRyZXNzICovCkBAIC0zMDcsMTMgKzM3OSw5IEBAIHN0YXRpYyBpbnQg ZHdfaGRtaV9pMmNfd3JpdGUoc3RydWN0IGR3X2hkbWkgKmhkbWksCiAJCWhkbWlfd3JpdGViKGhk bWksIEhETUlfSTJDTV9PUEVSQVRJT05fV1JJVEUsCiAJCQkgICAgSERNSV9JMkNNX09QRVJBVElP Tik7CiAKLQkJc3RhdCA9IHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmaTJjLT5jbXAsIEha IC8gMTApOwotCQlpZiAoIXN0YXQpCi0JCQlyZXR1cm4gLUVBR0FJTjsKLQotCQkvKiBDaGVjayBm b3IgZXJyb3IgY29uZGl0aW9uIG9uIHRoZSBidXMgKi8KLQkJaWYgKGkyYy0+c3RhdCAmIEhETUlf SUhfSTJDTV9TVEFUMF9FUlJPUikKLQkJCXJldHVybiAtRUlPOworCQlyZXQgPSBkd19oZG1pX2ky Y193YWl0KGhkbWkpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKIAl9CiAKIAlyZXR1cm4g MDsKQEAgLTI2MDYsNiArMjY3NCwyMiBAQCBfX2R3X2hkbWlfcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldiwKIAogCS8qIElmIEREQyBidXMgaXMgbm90IHNwZWNpZmllZCwgdHJ5IHRv IHJlZ2lzdGVyIEhETUkgSTJDIGJ1cyAqLwogCWlmICghaGRtaS0+ZGRjKSB7CisJCS8qIExvb2sg Zm9yIChvcHRpb25hbCkgc3R1ZmYgcmVsYXRlZCB0byB1bndlZGdpbmcgKi8KKwkJaGRtaS0+cGlu Y3RybCA9IGRldm1fcGluY3RybF9nZXQoZGV2KTsKKwkJaWYgKCFJU19FUlIoaGRtaS0+cGluY3Ry bCkpIHsKKwkJCWhkbWktPnVud2VkZ2Vfc3RhdGUgPQorCQkJCXBpbmN0cmxfbG9va3VwX3N0YXRl KGhkbWktPnBpbmN0cmwsICJ1bndlZGdlIik7CisJCQloZG1pLT5kZWZhdWx0X3N0YXRlID0KKwkJ CQlwaW5jdHJsX2xvb2t1cF9zdGF0ZShoZG1pLT5waW5jdHJsLCAiZGVmYXVsdCIpOworCisJCQlp ZiAoSVNfRVJSKGhkbWktPmRlZmF1bHRfc3RhdGUpICYmCisJCQkgICAgIUlTX0VSUihoZG1pLT51 bndlZGdlX3N0YXRlKSkgeworCQkJCWRldl93YXJuKGRldiwKKwkJCQkJICJVbndlZGdlIHJlcXVp cmVzIGRlZmF1bHQgcGluY3RybFxuIik7CisJCQkJaGRtaS0+dW53ZWRnZV9zdGF0ZSA9IEVSUl9Q VFIoLUVOT0RFVik7CisJCQl9CisJCX0KKwogCQloZG1pLT5kZGMgPSBkd19oZG1pX2kyY19hZGFw dGVyKGhkbWkpOwogCQlpZiAoSVNfRVJSKGhkbWktPmRkYykpCiAJCQloZG1pLT5kZGMgPSBOVUxM OwotLSAKMi4yMS4wLjEwMjAuZ2YyODIwY2YwMWEtZ29vZwoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2 ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vZHJpLWRldmVs