From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:59795 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752442AbdCEXok (ORCPT ); Sun, 5 Mar 2017 18:44:40 -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 04/10] drm: bridge: dw-hdmi: Fix the PHY power down sequence Date: Mon, 6 Mar 2017 01:35:39 +0200 Message-Id: <20170305233539.11898-1-laurent.pinchart+renesas@ideasonboard.com> In-Reply-To: <20170303172007.26541-5-laurent.pinchart+renesas@ideasonboard.com> References: <20170303172007.26541-5-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: The PHY requires us to wait for the PHY to switch to low power mode after deasserting TXPWRON and before asserting PDDQ in the power down sequence, otherwise power down will fail. The PHY power down can be monitored though the TX_READY bit, available through I2C in the PHY registers, or the TX_PHY_LOCK bit, available through the HDMI TX registers. As the two are equivalent, let's pick the easier solution of polling the TX_PHY_LOCK bit. The power down code is currently duplicated in multiple places. To avoid spreading multiple calls to a TX_PHY_LOCK poll function, we have to refactor the power down code and group it all in a single function. Tests showed that one poll iteration was enough for TX_PHY_LOCK to become low, without requiring any additional delay. Retrying the read five times with a 1ms to 2ms delay between each attempt should thus be more than enough. Signed-off-by: Laurent Pinchart Tested-by: Neil Armstrong Reviewed-by: Jose Abreu --- drivers/gpu/drm/bridge/dw-hdmi.c | 52 +++++++++++++++++++++++++++++++++------- 1 file changed, 43 insertions(+), 9 deletions(-) Changes since v5: - Fix compilation breakage due to reordering of the patches compared to v4 diff --git a/drivers/gpu/drm/bridge/dw-hdmi.c b/drivers/gpu/drm/bridge/dw-hdmi.c index d863b3393aee..3a1cd4c7ac64 100644 --- a/drivers/gpu/drm/bridge/dw-hdmi.c +++ b/drivers/gpu/drm/bridge/dw-hdmi.c @@ -116,6 +116,7 @@ struct dw_hdmi_i2c { struct dw_hdmi_phy_data { enum dw_hdmi_phy_type type; const char *name; + unsigned int gen; bool has_svsret; }; @@ -914,6 +915,40 @@ static void dw_hdmi_phy_sel_interface_control(struct dw_hdmi *hdmi, u8 enable) HDMI_PHY_CONF0_SELDIPIF_MASK); } +static void dw_hdmi_phy_power_off(struct dw_hdmi *hdmi) +{ + const struct dw_hdmi_phy_data *phy = hdmi->phy; + unsigned int i; + u16 val; + + if (phy->gen == 1) { + dw_hdmi_phy_enable_tmds(hdmi, 0); + dw_hdmi_phy_enable_powerdown(hdmi, true); + return; + } + + dw_hdmi_phy_gen2_txpwron(hdmi, 0); + + /* + * Wait for TX_PHY_LOCK to be deasserted to indicate that the PHY went + * to low power mode. + */ + for (i = 0; i < 5; ++i) { + val = hdmi_readb(hdmi, HDMI_PHY_STAT0); + if (!(val & HDMI_PHY_TX_PHY_LOCK)) + break; + + usleep_range(1000, 2000); + } + + if (val & HDMI_PHY_TX_PHY_LOCK) + dev_warn(hdmi->dev, "PHY failed to power down\n"); + else + dev_dbg(hdmi->dev, "PHY powered down in %u iterations\n", i); + + dw_hdmi_phy_gen2_pddq(hdmi, 1); +} + static int hdmi_phy_configure(struct dw_hdmi *hdmi) { u8 val, msec; @@ -946,11 +981,7 @@ static int hdmi_phy_configure(struct dw_hdmi *hdmi) return -EINVAL; } - /* gen2 tx power off */ - dw_hdmi_phy_gen2_txpwron(hdmi, 0); - - /* gen2 pddq */ - dw_hdmi_phy_gen2_pddq(hdmi, 1); + dw_hdmi_phy_power_off(hdmi); /* Leave low power consumption mode by asserting SVSRET. */ if (hdmi->phy->has_svsret) @@ -1025,8 +1056,6 @@ static int dw_hdmi_phy_init(struct dw_hdmi *hdmi) for (i = 0; i < 2; i++) { dw_hdmi_phy_sel_data_en_pol(hdmi, 1); dw_hdmi_phy_sel_interface_control(hdmi, 0); - dw_hdmi_phy_enable_tmds(hdmi, 0); - dw_hdmi_phy_enable_powerdown(hdmi, true); ret = hdmi_phy_configure(hdmi); if (ret) @@ -1256,8 +1285,7 @@ static void dw_hdmi_phy_disable(struct dw_hdmi *hdmi) if (!hdmi->phy_enabled) return; - dw_hdmi_phy_enable_tmds(hdmi, 0); - dw_hdmi_phy_enable_powerdown(hdmi, true); + dw_hdmi_phy_power_off(hdmi); hdmi->phy_enabled = false; } @@ -1827,23 +1855,29 @@ static const struct dw_hdmi_phy_data dw_hdmi_phys[] = { { .type = DW_HDMI_PHY_DWC_HDMI_TX_PHY, .name = "DWC HDMI TX PHY", + .gen = 1, }, { .type = DW_HDMI_PHY_DWC_MHL_PHY_HEAC, .name = "DWC MHL PHY + HEAC PHY", + .gen = 2, .has_svsret = true, }, { .type = DW_HDMI_PHY_DWC_MHL_PHY, .name = "DWC MHL PHY", + .gen = 2, .has_svsret = true, }, { .type = DW_HDMI_PHY_DWC_HDMI_3D_TX_PHY_HEAC, .name = "DWC HDMI 3D TX PHY + HEAC PHY", + .gen = 2, }, { .type = DW_HDMI_PHY_DWC_HDMI_3D_TX_PHY, .name = "DWC HDMI 3D TX PHY", + .gen = 2, }, { .type = DW_HDMI_PHY_DWC_HDMI20_TX_PHY, .name = "DWC HDMI 2.0 TX PHY", + .gen = 2, .has_svsret = true, } }; -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: [PATCH v5.1 04/10] drm: bridge: dw-hdmi: Fix the PHY power down sequence Date: Mon, 6 Mar 2017 01:35:39 +0200 Message-ID: <20170305233539.11898-1-laurent.pinchart+renesas@ideasonboard.com> References: <20170303172007.26541-5-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 21EA26E30E for ; Sun, 5 Mar 2017 23:35:08 +0000 (UTC) In-Reply-To: <20170303172007.26541-5-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 VGhlIFBIWSByZXF1aXJlcyB1cyB0byB3YWl0IGZvciB0aGUgUEhZIHRvIHN3aXRjaCB0byBsb3cg cG93ZXIgbW9kZQphZnRlciBkZWFzc2VydGluZyBUWFBXUk9OIGFuZCBiZWZvcmUgYXNzZXJ0aW5n IFBERFEgaW4gdGhlIHBvd2VyIGRvd24Kc2VxdWVuY2UsIG90aGVyd2lzZSBwb3dlciBkb3duIHdp bGwgZmFpbC4KClRoZSBQSFkgcG93ZXIgZG93biBjYW4gYmUgbW9uaXRvcmVkIHRob3VnaCB0aGUg VFhfUkVBRFkgYml0LCBhdmFpbGFibGUKdGhyb3VnaCBJMkMgaW4gdGhlIFBIWSByZWdpc3RlcnMs IG9yIHRoZSBUWF9QSFlfTE9DSyBiaXQsIGF2YWlsYWJsZQp0aHJvdWdoIHRoZSBIRE1JIFRYIHJl Z2lzdGVycy4gQXMgdGhlIHR3byBhcmUgZXF1aXZhbGVudCwgbGV0J3MgcGljayB0aGUKZWFzaWVy IHNvbHV0aW9uIG9mIHBvbGxpbmcgdGhlIFRYX1BIWV9MT0NLIGJpdC4KClRoZSBwb3dlciBkb3du IGNvZGUgaXMgY3VycmVudGx5IGR1cGxpY2F0ZWQgaW4gbXVsdGlwbGUgcGxhY2VzLiBUbyBhdm9p ZApzcHJlYWRpbmcgbXVsdGlwbGUgY2FsbHMgdG8gYSBUWF9QSFlfTE9DSyBwb2xsIGZ1bmN0aW9u LCB3ZSBoYXZlIHRvCnJlZmFjdG9yIHRoZSBwb3dlciBkb3duIGNvZGUgYW5kIGdyb3VwIGl0IGFs bCBpbiBhIHNpbmdsZSBmdW5jdGlvbi4KClRlc3RzIHNob3dlZCB0aGF0IG9uZSBwb2xsIGl0ZXJh dGlvbiB3YXMgZW5vdWdoIGZvciBUWF9QSFlfTE9DSyB0bwpiZWNvbWUgbG93LCB3aXRob3V0IHJl cXVpcmluZyBhbnkgYWRkaXRpb25hbCBkZWxheS4gUmV0cnlpbmcgdGhlIHJlYWQKZml2ZSB0aW1l cyB3aXRoIGEgMW1zIHRvIDJtcyBkZWxheSBiZXR3ZWVuIGVhY2ggYXR0ZW1wdCBzaG91bGQgdGh1 cyBiZQptb3JlIHRoYW4gZW5vdWdoLgoKU2lnbmVkLW9mZi1ieTogTGF1cmVudCBQaW5jaGFydCA8 bGF1cmVudC5waW5jaGFydCtyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+ClRlc3RlZC1ieTogTmVp bCBBcm1zdHJvbmcgPG5hcm1zdHJvbmdAYmF5bGlicmUuY29tPgpSZXZpZXdlZC1ieTogSm9zZSBB YnJldSA8am9hYnJldUBzeW5vcHN5cy5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9k dy1oZG1pLmMgfCA1MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tCiAx IGZpbGUgY2hhbmdlZCwgNDMgaW5zZXJ0aW9ucygrKSwgOSBkZWxldGlvbnMoLSkKCkNoYW5nZXMg c2luY2UgdjU6CgotIEZpeCBjb21waWxhdGlvbiBicmVha2FnZSBkdWUgdG8gcmVvcmRlcmluZyBv ZiB0aGUgcGF0Y2hlcyBjb21wYXJlZCB0byB2NAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9icmlkZ2UvZHctaGRtaS5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9kdy1oZG1pLmMKaW5k ZXggZDg2M2IzMzkzYWVlLi4zYTFjZDRjN2FjNjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9icmlkZ2UvZHctaGRtaS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvZHctaGRtaS5j CkBAIC0xMTYsNiArMTE2LDcgQEAgc3RydWN0IGR3X2hkbWlfaTJjIHsKIHN0cnVjdCBkd19oZG1p X3BoeV9kYXRhIHsKIAllbnVtIGR3X2hkbWlfcGh5X3R5cGUgdHlwZTsKIAljb25zdCBjaGFyICpu YW1lOworCXVuc2lnbmVkIGludCBnZW47CiAJYm9vbCBoYXNfc3ZzcmV0OwogfTsKIApAQCAtOTE0 LDYgKzkxNSw0MCBAQCBzdGF0aWMgdm9pZCBkd19oZG1pX3BoeV9zZWxfaW50ZXJmYWNlX2NvbnRy b2woc3RydWN0IGR3X2hkbWkgKmhkbWksIHU4IGVuYWJsZSkKIAkJCSBIRE1JX1BIWV9DT05GMF9T RUxESVBJRl9NQVNLKTsKIH0KIAorc3RhdGljIHZvaWQgZHdfaGRtaV9waHlfcG93ZXJfb2ZmKHN0 cnVjdCBkd19oZG1pICpoZG1pKQoreworCWNvbnN0IHN0cnVjdCBkd19oZG1pX3BoeV9kYXRhICpw aHkgPSBoZG1pLT5waHk7CisJdW5zaWduZWQgaW50IGk7CisJdTE2IHZhbDsKKworCWlmIChwaHkt PmdlbiA9PSAxKSB7CisJCWR3X2hkbWlfcGh5X2VuYWJsZV90bWRzKGhkbWksIDApOworCQlkd19o ZG1pX3BoeV9lbmFibGVfcG93ZXJkb3duKGhkbWksIHRydWUpOworCQlyZXR1cm47CisJfQorCisJ ZHdfaGRtaV9waHlfZ2VuMl90eHB3cm9uKGhkbWksIDApOworCisJLyoKKwkgKiBXYWl0IGZvciBU WF9QSFlfTE9DSyB0byBiZSBkZWFzc2VydGVkIHRvIGluZGljYXRlIHRoYXQgdGhlIFBIWSB3ZW50 CisJICogdG8gbG93IHBvd2VyIG1vZGUuCisJICovCisJZm9yIChpID0gMDsgaSA8IDU7ICsraSkg eworCQl2YWwgPSBoZG1pX3JlYWRiKGhkbWksIEhETUlfUEhZX1NUQVQwKTsKKwkJaWYgKCEodmFs ICYgSERNSV9QSFlfVFhfUEhZX0xPQ0spKQorCQkJYnJlYWs7CisKKwkJdXNsZWVwX3JhbmdlKDEw MDAsIDIwMDApOworCX0KKworCWlmICh2YWwgJiBIRE1JX1BIWV9UWF9QSFlfTE9DSykKKwkJZGV2 X3dhcm4oaGRtaS0+ZGV2LCAiUEhZIGZhaWxlZCB0byBwb3dlciBkb3duXG4iKTsKKwllbHNlCisJ CWRldl9kYmcoaGRtaS0+ZGV2LCAiUEhZIHBvd2VyZWQgZG93biBpbiAldSBpdGVyYXRpb25zXG4i LCBpKTsKKworCWR3X2hkbWlfcGh5X2dlbjJfcGRkcShoZG1pLCAxKTsKK30KKwogc3RhdGljIGlu dCBoZG1pX3BoeV9jb25maWd1cmUoc3RydWN0IGR3X2hkbWkgKmhkbWkpCiB7CiAJdTggdmFsLCBt c2VjOwpAQCAtOTQ2LDExICs5ODEsNyBAQCBzdGF0aWMgaW50IGhkbWlfcGh5X2NvbmZpZ3VyZShz dHJ1Y3QgZHdfaGRtaSAqaGRtaSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCi0JLyogZ2VuMiB0 eCBwb3dlciBvZmYgKi8KLQlkd19oZG1pX3BoeV9nZW4yX3R4cHdyb24oaGRtaSwgMCk7Ci0KLQkv KiBnZW4yIHBkZHEgKi8KLQlkd19oZG1pX3BoeV9nZW4yX3BkZHEoaGRtaSwgMSk7CisJZHdfaGRt aV9waHlfcG93ZXJfb2ZmKGhkbWkpOwogCiAJLyogTGVhdmUgbG93IHBvd2VyIGNvbnN1bXB0aW9u IG1vZGUgYnkgYXNzZXJ0aW5nIFNWU1JFVC4gKi8KIAlpZiAoaGRtaS0+cGh5LT5oYXNfc3ZzcmV0 KQpAQCAtMTAyNSw4ICsxMDU2LDYgQEAgc3RhdGljIGludCBkd19oZG1pX3BoeV9pbml0KHN0cnVj dCBkd19oZG1pICpoZG1pKQogCWZvciAoaSA9IDA7IGkgPCAyOyBpKyspIHsKIAkJZHdfaGRtaV9w aHlfc2VsX2RhdGFfZW5fcG9sKGhkbWksIDEpOwogCQlkd19oZG1pX3BoeV9zZWxfaW50ZXJmYWNl X2NvbnRyb2woaGRtaSwgMCk7Ci0JCWR3X2hkbWlfcGh5X2VuYWJsZV90bWRzKGhkbWksIDApOwot CQlkd19oZG1pX3BoeV9lbmFibGVfcG93ZXJkb3duKGhkbWksIHRydWUpOwogCiAJCXJldCA9IGhk bWlfcGh5X2NvbmZpZ3VyZShoZG1pKTsKIAkJaWYgKHJldCkKQEAgLTEyNTYsOCArMTI4NSw3IEBA IHN0YXRpYyB2b2lkIGR3X2hkbWlfcGh5X2Rpc2FibGUoc3RydWN0IGR3X2hkbWkgKmhkbWkpCiAJ aWYgKCFoZG1pLT5waHlfZW5hYmxlZCkKIAkJcmV0dXJuOwogCi0JZHdfaGRtaV9waHlfZW5hYmxl X3RtZHMoaGRtaSwgMCk7Ci0JZHdfaGRtaV9waHlfZW5hYmxlX3Bvd2VyZG93bihoZG1pLCB0cnVl KTsKKwlkd19oZG1pX3BoeV9wb3dlcl9vZmYoaGRtaSk7CiAKIAloZG1pLT5waHlfZW5hYmxlZCA9 IGZhbHNlOwogfQpAQCAtMTgyNywyMyArMTg1NSwyOSBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGR3 X2hkbWlfcGh5X2RhdGEgZHdfaGRtaV9waHlzW10gPSB7CiAJewogCQkudHlwZSA9IERXX0hETUlf UEhZX0RXQ19IRE1JX1RYX1BIWSwKIAkJLm5hbWUgPSAiRFdDIEhETUkgVFggUEhZIiwKKwkJLmdl biA9IDEsCiAJfSwgewogCQkudHlwZSA9IERXX0hETUlfUEhZX0RXQ19NSExfUEhZX0hFQUMsCiAJ CS5uYW1lID0gIkRXQyBNSEwgUEhZICsgSEVBQyBQSFkiLAorCQkuZ2VuID0gMiwKIAkJLmhhc19z dnNyZXQgPSB0cnVlLAogCX0sIHsKIAkJLnR5cGUgPSBEV19IRE1JX1BIWV9EV0NfTUhMX1BIWSwK IAkJLm5hbWUgPSAiRFdDIE1ITCBQSFkiLAorCQkuZ2VuID0gMiwKIAkJLmhhc19zdnNyZXQgPSB0 cnVlLAogCX0sIHsKIAkJLnR5cGUgPSBEV19IRE1JX1BIWV9EV0NfSERNSV8zRF9UWF9QSFlfSEVB QywKIAkJLm5hbWUgPSAiRFdDIEhETUkgM0QgVFggUEhZICsgSEVBQyBQSFkiLAorCQkuZ2VuID0g MiwKIAl9LCB7CiAJCS50eXBlID0gRFdfSERNSV9QSFlfRFdDX0hETUlfM0RfVFhfUEhZLAogCQku bmFtZSA9ICJEV0MgSERNSSAzRCBUWCBQSFkiLAorCQkuZ2VuID0gMiwKIAl9LCB7CiAJCS50eXBl ID0gRFdfSERNSV9QSFlfRFdDX0hETUkyMF9UWF9QSFksCiAJCS5uYW1lID0gIkRXQyBIRE1JIDIu MCBUWCBQSFkiLAorCQkuZ2VuID0gMiwKIAkJLmhhc19zdnNyZXQgPSB0cnVlLAogCX0KIH07Ci0t IApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vZHJpLWRldmVsCg==