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=-3.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_PASS,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 BED15C28CF6 for ; Fri, 3 Aug 2018 16:35:33 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 7494821777 for ; Fri, 3 Aug 2018 16:35:33 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7494821777 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728470AbeHCScd (ORCPT ); Fri, 3 Aug 2018 14:32:33 -0400 Received: from mga14.intel.com ([192.55.52.115]:11987 "EHLO mga14.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727171AbeHCScc (ORCPT ); Fri, 3 Aug 2018 14:32:32 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga103.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 03 Aug 2018 09:35:30 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.51,439,1526367600"; d="scan'208";a="80296287" Received: from espoo.fi.intel.com ([10.237.66.147]) by orsmga002.jf.intel.com with ESMTP; 03 Aug 2018 09:34:54 -0700 From: Gwan-gyeong Mun To: linux-kernel@vger.kernel.org Cc: Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , David Airlie , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH] drm/i915: Add detection of changing of edid on between suspend and resume Date: Fri, 3 Aug 2018 19:34:53 +0300 Message-Id: <20180803163453.7760-1-gwan-gyeong.mun@intel.com> X-Mailer: git-send-email 2.18.0 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The hotplug detection routine of i915 uses drm_helper_hpd_irq_event(). This helper can detect changing of status of connector, but it can not detect changing of edid. Following scenario requires detection of changing of edid. 1) plug display device to a connector 2) system suspend 3) unplug 1)'s display device and plug the other display device to a connector 4) system resume It adds edid check routine when a connector status still remains as "connector_status_connected". Testcase: igt/kms_chamelium/hdmi-edid-change-during-hibernate Testcase: igt/kms_chamelium/hdmi-edid-change-during-suspend Testcase: igt/kms_chamelium/dp-edid-change-during-hibernate Testcase: igt/kms_chamelium/dp-edid-change-during-suspend Signed-off-by: Gwan-gyeong Mun --- drivers/gpu/drm/i915/intel_hotplug.c | 80 +++++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/i915/intel_hotplug.c b/drivers/gpu/drm/i915/intel_hotplug.c index 648a13c6043c..b92b83d46ccc 100644 --- a/drivers/gpu/drm/i915/intel_hotplug.c +++ b/drivers/gpu/drm/i915/intel_hotplug.c @@ -507,6 +507,84 @@ void intel_hpd_init(struct drm_i915_private *dev_priv) } } +/** + * intel_hpd_irq_event - hotplug processing + * @dev: drm_device + * + * Drivers can use this function to run a detect cycle on all connectors which + * have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All other + * connectors are ignored, which is useful to avoid reprobing fixed panels. + * + * This function is useful for drivers which can't or don't track hotplug interrupts + * for each connector. This function is based on drm_helper_hpd_irq_event() helper + * function and besides it adds edid check routine when a connector status still + * remains as "connector_status_connected". + * + * Following scenario requires detection of changing of edid. + * 1) plug display device to a connector + * 2) system suspend + * 3) unplug 1)'s display device and plug the other display device to a connector + * 4) system resume + + * This function must be called from process context with no mode + * setting locks held. + * + * Note that a connector can be both polled and probed from the hotplug handler, + * in case the hotplug interrupt is known to be unreliable. + */ +static bool intel_hpd_irq_event(struct drm_device *dev) +{ + struct drm_connector *connector; + struct drm_connector_list_iter conn_iter; + enum drm_connector_status old_status, cur_status; + struct edid *old_edid; + bool changed = false; + + if (!dev->mode_config.poll_enabled) + return false; + + mutex_lock(&dev->mode_config.mutex); + drm_connector_list_iter_begin(dev, &conn_iter); + drm_for_each_connector_iter(connector, &conn_iter) { + /* Only handle HPD capable connectors. */ + if (!(connector->polled & DRM_CONNECTOR_POLL_HPD)) + continue; + + old_status = connector->status; + old_edid = to_intel_connector(connector)->detect_edid; + + cur_status = drm_helper_probe_detect(connector, NULL, false); + DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n", + connector->base.id, connector->name, + drm_get_connector_status_name(old_status), + drm_get_connector_status_name(cur_status)); + + if (old_status != cur_status) + changed = true; + + /* Check changing of edid when a connector status still remains + * as "connector_status_connected". */ + if (old_status == cur_status && + cur_status == connector_status_connected) { + struct edid *cur_edid = to_intel_connector(connector)->detect_edid; + + if (memcmp(old_edid, cur_edid, sizeof(*cur_edid)) != 0) { + changed = true; + DRM_DEBUG_KMS("[CONNECTOR:%d:%s] edid updated\n", + connector->base.id, + connector->name); + } + } + } + drm_connector_list_iter_end(&conn_iter); + mutex_unlock(&dev->mode_config.mutex); + + if (changed) + drm_kms_helper_hotplug_event(dev); + + return changed; +} + static void i915_hpd_poll_init_work(struct work_struct *work) { struct drm_i915_private *dev_priv = @@ -552,7 +630,7 @@ static void i915_hpd_poll_init_work(struct work_struct *work) * in the middle of disabling polling */ if (!enabled) - drm_helper_hpd_irq_event(dev); + intel_hpd_irq_event(dev); } /** -- 2.18.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gwan-gyeong Mun Subject: [PATCH] drm/i915: Add detection of changing of edid on between suspend and resume Date: Fri, 3 Aug 2018 19:34:53 +0300 Message-ID: <20180803163453.7760-1-gwan-gyeong.mun@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-kernel@vger.kernel.org Cc: David Airlie , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Rodrigo Vivi List-Id: dri-devel@lists.freedesktop.org VGhlIGhvdHBsdWcgZGV0ZWN0aW9uIHJvdXRpbmUgb2YgaTkxNSB1c2VzIGRybV9oZWxwZXJfaHBk X2lycV9ldmVudCgpLiBUaGlzIGhlbHBlcgpjYW4gZGV0ZWN0IGNoYW5naW5nIG9mIHN0YXR1cyBv ZiBjb25uZWN0b3IsIGJ1dCBpdCBjYW4gbm90IGRldGVjdCBjaGFuZ2luZyBvZgplZGlkLiBGb2xs b3dpbmcgc2NlbmFyaW8gcmVxdWlyZXMgZGV0ZWN0aW9uIG9mIGNoYW5naW5nIG9mIGVkaWQuCgog MSkgcGx1ZyBkaXNwbGF5IGRldmljZSB0byBhIGNvbm5lY3RvcgogMikgc3lzdGVtIHN1c3BlbmQK IDMpIHVucGx1ZyAxKSdzIGRpc3BsYXkgZGV2aWNlIGFuZCBwbHVnIHRoZSBvdGhlciBkaXNwbGF5 IGRldmljZSB0byBhIGNvbm5lY3RvcgogNCkgc3lzdGVtIHJlc3VtZQoKSXQgYWRkcyBlZGlkIGNo ZWNrIHJvdXRpbmUgd2hlbiBhIGNvbm5lY3RvciBzdGF0dXMgc3RpbGwgcmVtYWlucyBhcyAiY29u bmVjdG9yX3N0YXR1c19jb25uZWN0ZWQiLgoKVGVzdGNhc2U6IGlndC9rbXNfY2hhbWVsaXVtL2hk bWktZWRpZC1jaGFuZ2UtZHVyaW5nLWhpYmVybmF0ZQpUZXN0Y2FzZTogaWd0L2ttc19jaGFtZWxp dW0vaGRtaS1lZGlkLWNoYW5nZS1kdXJpbmctc3VzcGVuZApUZXN0Y2FzZTogaWd0L2ttc19jaGFt ZWxpdW0vZHAtZWRpZC1jaGFuZ2UtZHVyaW5nLWhpYmVybmF0ZQpUZXN0Y2FzZTogaWd0L2ttc19j aGFtZWxpdW0vZHAtZWRpZC1jaGFuZ2UtZHVyaW5nLXN1c3BlbmQKClNpZ25lZC1vZmYtYnk6IEd3 YW4tZ3llb25nIE11biA8Z3dhbi1neWVvbmcubXVuQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9ob3RwbHVnLmMgfCA4MCArKysrKysrKysrKysrKysrKysrKysrKysr KystCiAxIGZpbGUgY2hhbmdlZCwgNzkgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYwppbmRleCA2NDhhMTNjNjA0M2MuLmI5MmI4M2Q0 NmNjYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaG90cGx1Zy5jCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYwpAQCAtNTA3LDYgKzUwNyw4 NCBAQCB2b2lkIGludGVsX2hwZF9pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp dikKIAl9CiB9CiAKKy8qKgorICogaW50ZWxfaHBkX2lycV9ldmVudCAtIGhvdHBsdWcgcHJvY2Vz c2luZworICogQGRldjogZHJtX2RldmljZQorICoKKyAqIERyaXZlcnMgY2FuIHVzZSB0aGlzIGZ1 bmN0aW9uIHRvIHJ1biBhIGRldGVjdCBjeWNsZSBvbiBhbGwgY29ubmVjdG9ycyB3aGljaAorICog aGF2ZSB0aGUgRFJNX0NPTk5FQ1RPUl9QT0xMX0hQRCBmbGFnIHNldCBpbiB0aGVpciAmcG9sbGVk IG1lbWJlci4gQWxsIG90aGVyCisgKiBjb25uZWN0b3JzIGFyZSBpZ25vcmVkLCB3aGljaCBpcyB1 c2VmdWwgdG8gYXZvaWQgcmVwcm9iaW5nIGZpeGVkIHBhbmVscy4KKyAqCisgKiBUaGlzIGZ1bmN0 aW9uIGlzIHVzZWZ1bCBmb3IgZHJpdmVycyB3aGljaCBjYW4ndCBvciBkb24ndCB0cmFjayBob3Rw bHVnIGludGVycnVwdHMKKyAqIGZvciBlYWNoIGNvbm5lY3Rvci4gVGhpcyBmdW5jdGlvbiBpcyBi YXNlZCBvbiBkcm1faGVscGVyX2hwZF9pcnFfZXZlbnQoKSBoZWxwZXIKKyAqIGZ1bmN0aW9uIGFu ZCBiZXNpZGVzIGl0IGFkZHMgZWRpZCBjaGVjayByb3V0aW5lIHdoZW4gYSBjb25uZWN0b3Igc3Rh dHVzIHN0aWxsCisgKiByZW1haW5zIGFzICJjb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZCIuCisg KgorICogRm9sbG93aW5nIHNjZW5hcmlvIHJlcXVpcmVzIGRldGVjdGlvbiBvZiBjaGFuZ2luZyBv ZiBlZGlkLgorICogIDEpIHBsdWcgZGlzcGxheSBkZXZpY2UgdG8gYSBjb25uZWN0b3IKKyAqICAy KSBzeXN0ZW0gc3VzcGVuZAorICogIDMpIHVucGx1ZyAxKSdzIGRpc3BsYXkgZGV2aWNlIGFuZCBw bHVnIHRoZSBvdGhlciBkaXNwbGF5IGRldmljZSB0byBhIGNvbm5lY3RvcgorICogIDQpIHN5c3Rl bSByZXN1bWUKKworICogVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZCBmcm9tIHByb2Nlc3Mg Y29udGV4dCB3aXRoIG5vIG1vZGUKKyAqIHNldHRpbmcgbG9ja3MgaGVsZC4KKyAqCisgKiBOb3Rl IHRoYXQgYSBjb25uZWN0b3IgY2FuIGJlIGJvdGggcG9sbGVkIGFuZCBwcm9iZWQgZnJvbSB0aGUg aG90cGx1ZyBoYW5kbGVyLAorICogaW4gY2FzZSB0aGUgaG90cGx1ZyBpbnRlcnJ1cHQgaXMga25v d24gdG8gYmUgdW5yZWxpYWJsZS4KKyAqLworc3RhdGljIGJvb2wgaW50ZWxfaHBkX2lycV9ldmVu dChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25u ZWN0b3I7CisJc3RydWN0IGRybV9jb25uZWN0b3JfbGlzdF9pdGVyIGNvbm5faXRlcjsKKwllbnVt IGRybV9jb25uZWN0b3Jfc3RhdHVzIG9sZF9zdGF0dXMsIGN1cl9zdGF0dXM7CisJc3RydWN0IGVk aWQgKm9sZF9lZGlkOworCWJvb2wgY2hhbmdlZCA9IGZhbHNlOworCisJaWYgKCFkZXYtPm1vZGVf Y29uZmlnLnBvbGxfZW5hYmxlZCkKKwkJcmV0dXJuIGZhbHNlOworCisJbXV0ZXhfbG9jaygmZGV2 LT5tb2RlX2NvbmZpZy5tdXRleCk7CisJZHJtX2Nvbm5lY3Rvcl9saXN0X2l0ZXJfYmVnaW4oZGV2 LCAmY29ubl9pdGVyKTsKKwlkcm1fZm9yX2VhY2hfY29ubmVjdG9yX2l0ZXIoY29ubmVjdG9yLCAm Y29ubl9pdGVyKSB7CisJCS8qIE9ubHkgaGFuZGxlIEhQRCBjYXBhYmxlIGNvbm5lY3RvcnMuICov CisJCWlmICghKGNvbm5lY3Rvci0+cG9sbGVkICYgRFJNX0NPTk5FQ1RPUl9QT0xMX0hQRCkpCisJ CQljb250aW51ZTsKKworCQlvbGRfc3RhdHVzID0gY29ubmVjdG9yLT5zdGF0dXM7CisJCW9sZF9l ZGlkID0gdG9faW50ZWxfY29ubmVjdG9yKGNvbm5lY3RvciktPmRldGVjdF9lZGlkOworCisJCWN1 cl9zdGF0dXMgPSBkcm1faGVscGVyX3Byb2JlX2RldGVjdChjb25uZWN0b3IsIE5VTEwsIGZhbHNl KTsKKwkJRFJNX0RFQlVHX0tNUygiW0NPTk5FQ1RPUjolZDolc10gc3RhdHVzIHVwZGF0ZWQgZnJv bSAlcyB0byAlc1xuIiwKKwkJCSAgICAgIGNvbm5lY3Rvci0+YmFzZS5pZCwgY29ubmVjdG9yLT5u YW1lLAorCQkJICAgICAgZHJtX2dldF9jb25uZWN0b3Jfc3RhdHVzX25hbWUob2xkX3N0YXR1cyks CisJCQkgICAgICBkcm1fZ2V0X2Nvbm5lY3Rvcl9zdGF0dXNfbmFtZShjdXJfc3RhdHVzKSk7CisK KwkJaWYgKG9sZF9zdGF0dXMgIT0gY3VyX3N0YXR1cykKKwkJCWNoYW5nZWQgPSB0cnVlOworCisJ CS8qIENoZWNrIGNoYW5naW5nIG9mIGVkaWQgd2hlbiBhIGNvbm5lY3RvciBzdGF0dXMgc3RpbGwg cmVtYWlucworCQkgKiBhcyAiY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQiLiAqLworCQlpZiAo b2xkX3N0YXR1cyA9PSBjdXJfc3RhdHVzICYmCisJCSAgICBjdXJfc3RhdHVzID09IGNvbm5lY3Rv cl9zdGF0dXNfY29ubmVjdGVkKSB7CisJCQlzdHJ1Y3QgZWRpZCAqY3VyX2VkaWQgPSB0b19pbnRl bF9jb25uZWN0b3IoY29ubmVjdG9yKS0+ZGV0ZWN0X2VkaWQ7CisKKwkJCWlmIChtZW1jbXAob2xk X2VkaWQsIGN1cl9lZGlkLCBzaXplb2YoKmN1cl9lZGlkKSkgIT0gMCkgeworCQkJCWNoYW5nZWQg PSB0cnVlOworCQkJCURSTV9ERUJVR19LTVMoIltDT05ORUNUT1I6JWQ6JXNdIGVkaWQgdXBkYXRl ZFxuIiwKKwkJCQkJICAgICAgY29ubmVjdG9yLT5iYXNlLmlkLAorCQkJCQkgICAgICBjb25uZWN0 b3ItPm5hbWUpOworCQkJfQorCQl9CisJfQorCWRybV9jb25uZWN0b3JfbGlzdF9pdGVyX2VuZCgm Y29ubl9pdGVyKTsKKwltdXRleF91bmxvY2soJmRldi0+bW9kZV9jb25maWcubXV0ZXgpOworCisJ aWYgKGNoYW5nZWQpCisJCWRybV9rbXNfaGVscGVyX2hvdHBsdWdfZXZlbnQoZGV2KTsKKworCXJl dHVybiBjaGFuZ2VkOworfQorCiBzdGF0aWMgdm9pZCBpOTE1X2hwZF9wb2xsX2luaXRfd29yayhz dHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiB7CiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRl dl9wcml2ID0KQEAgLTU1Miw3ICs2MzAsNyBAQCBzdGF0aWMgdm9pZCBpOTE1X2hwZF9wb2xsX2lu aXRfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJICogaW4gdGhlIG1pZGRsZSBvZiBk aXNhYmxpbmcgcG9sbGluZwogCSAqLwogCWlmICghZW5hYmxlZCkKLQkJZHJtX2hlbHBlcl9ocGRf aXJxX2V2ZW50KGRldik7CisJCWludGVsX2hwZF9pcnFfZXZlbnQoZGV2KTsKIH0KIAogLyoqCi0t IAoyLjE4LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=