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 C97C4C46460 for ; Thu, 9 Aug 2018 11:13:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 8A7982154C for ; Thu, 9 Aug 2018 11:13:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8A7982154C 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 S1730883AbeHINiD (ORCPT ); Thu, 9 Aug 2018 09:38:03 -0400 Received: from mga07.intel.com ([134.134.136.100]:9712 "EHLO mga07.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730334AbeHINiC (ORCPT ); Thu, 9 Aug 2018 09:38:02 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga105.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 09 Aug 2018 04:13:39 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.53,214,1531810800"; d="scan'208";a="61850463" Received: from espoo.fi.intel.com ([10.237.66.147]) by fmsmga008.fm.intel.com with ESMTP; 09 Aug 2018 04:13:31 -0700 From: Gwan-gyeong Mun To: Jani Nikula Cc: Joonas Lahtinen , Rodrigo Vivi , David Airlie , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [v3] drm/i915: Add detection of changing of edid on between suspend and resume Date: Thu, 9 Aug 2018 14:13:30 +0300 Message-Id: <20180809111330.5113-1-gwan-gyeong.mun@intel.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20180803163453.7760-1-gwan-gyeong.mun@intel.com> References: <20180803163453.7760-1-gwan-gyeong.mun@intel.com> 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". v2: Add NULL check before comparing of EDIDs. 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 | 84 +++++++++++++++++++++++++++- 1 file changed, 83 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/i915/intel_hotplug.c b/drivers/gpu/drm/i915/intel_hotplug.c index 648a13c6043c..965f2d771fc0 100644 --- a/drivers/gpu/drm/i915/intel_hotplug.c +++ b/drivers/gpu/drm/i915/intel_hotplug.c @@ -507,6 +507,88 @@ 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 (!old_edid || !cur_edid) + continue; + + if (memcmp(old_edid, cur_edid, sizeof(*cur_edid))) { + 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 +634,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: [v3] drm/i915: Add detection of changing of edid on between suspend and resume Date: Thu, 9 Aug 2018 14:13:30 +0300 Message-ID: <20180809111330.5113-1-gwan-gyeong.mun@intel.com> References: <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: In-Reply-To: <20180803163453.7760-1-gwan-gyeong.mun@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Jani Nikula Cc: David Airlie , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Rodrigo Vivi List-Id: dri-devel@lists.freedesktop.org VGhlIGhvdHBsdWcgZGV0ZWN0aW9uIHJvdXRpbmUgb2YgaTkxNSB1c2VzIGRybV9oZWxwZXJfaHBk X2lycV9ldmVudCgpLiBUaGlzCmhlbHBlciBjYW4gZGV0ZWN0IGNoYW5naW5nIG9mIHN0YXR1cyBv ZiBjb25uZWN0b3IsIGJ1dCBpdCBjYW4gbm90IGRldGVjdApjaGFuZ2luZyBvZiBlZGlkLgoKRm9s bG93aW5nIHNjZW5hcmlvIHJlcXVpcmVzIGRldGVjdGlvbiBvZiBjaGFuZ2luZyBvZiBlZGlkLgoK IDEpIHBsdWcgZGlzcGxheSBkZXZpY2UgdG8gYSBjb25uZWN0b3IKIDIpIHN5c3RlbSBzdXNwZW5k CiAzKSB1bnBsdWcgMSkncyBkaXNwbGF5IGRldmljZSBhbmQgcGx1ZyB0aGUgb3RoZXIgZGlzcGxh eSBkZXZpY2UgdG8gYSBjb25uZWN0b3IKIDQpIHN5c3RlbSByZXN1bWUKCkl0IGFkZHMgZWRpZCBj aGVjayByb3V0aW5lIHdoZW4gYSBjb25uZWN0b3Igc3RhdHVzIHN0aWxsIHJlbWFpbnMgYXMgImNv bm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVkIi4KCnYyOiBBZGQgTlVMTCBjaGVjayBiZWZvcmUgY29t cGFyaW5nIG9mIEVESURzLgoKVGVzdGNhc2U6IGlndC9rbXNfY2hhbWVsaXVtL2hkbWktZWRpZC1j aGFuZ2UtZHVyaW5nLWhpYmVybmF0ZQpUZXN0Y2FzZTogaWd0L2ttc19jaGFtZWxpdW0vaGRtaS1l ZGlkLWNoYW5nZS1kdXJpbmctc3VzcGVuZApUZXN0Y2FzZTogaWd0L2ttc19jaGFtZWxpdW0vZHAt ZWRpZC1jaGFuZ2UtZHVyaW5nLWhpYmVybmF0ZQpUZXN0Y2FzZTogaWd0L2ttc19jaGFtZWxpdW0v ZHAtZWRpZC1jaGFuZ2UtZHVyaW5nLXN1c3BlbmQKClNpZ25lZC1vZmYtYnk6IEd3YW4tZ3llb25n IE11biA8Z3dhbi1neWVvbmcubXVuQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9ob3RwbHVnLmMgfCA4NCArKysrKysrKysrKysrKysrKysrKysrKysrKystCiAxIGZp bGUgY2hhbmdlZCwgODMgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2hvdHBsdWcuYwppbmRleCA2NDhhMTNjNjA0M2MuLjk2NWYyZDc3MWZjMCAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaG90cGx1Zy5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYwpAQCAtNTA3LDYgKzUwNyw4OCBAQCB2b2lk IGludGVsX2hwZF9pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKIAl9CiB9 CiAKKy8qKgorICogaW50ZWxfaHBkX2lycV9ldmVudCAtIGhvdHBsdWcgcHJvY2Vzc2luZworICog QGRldjogZHJtX2RldmljZQorICoKKyAqIERyaXZlcnMgY2FuIHVzZSB0aGlzIGZ1bmN0aW9uIHRv IHJ1biBhIGRldGVjdCBjeWNsZSBvbiBhbGwgY29ubmVjdG9ycyB3aGljaAorICogaGF2ZSB0aGUg RFJNX0NPTk5FQ1RPUl9QT0xMX0hQRCBmbGFnIHNldCBpbiB0aGVpciAmcG9sbGVkIG1lbWJlci4g QWxsIG90aGVyCisgKiBjb25uZWN0b3JzIGFyZSBpZ25vcmVkLCB3aGljaCBpcyB1c2VmdWwgdG8g YXZvaWQgcmVwcm9iaW5nIGZpeGVkIHBhbmVscy4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGlzIHVz ZWZ1bCBmb3IgZHJpdmVycyB3aGljaCBjYW4ndCBvciBkb24ndCB0cmFjayBob3RwbHVnIGludGVy cnVwdHMKKyAqIGZvciBlYWNoIGNvbm5lY3Rvci4gVGhpcyBmdW5jdGlvbiBpcyBiYXNlZCBvbiBk cm1faGVscGVyX2hwZF9pcnFfZXZlbnQoKSBoZWxwZXIKKyAqIGZ1bmN0aW9uIGFuZCBiZXNpZGVz IGl0IGFkZHMgZWRpZCBjaGVjayByb3V0aW5lIHdoZW4gYSBjb25uZWN0b3Igc3RhdHVzIHN0aWxs CisgKiByZW1haW5zIGFzICJjb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZCIuCisgKgorICogRm9s bG93aW5nIHNjZW5hcmlvIHJlcXVpcmVzIGRldGVjdGlvbiBvZiBjaGFuZ2luZyBvZiBlZGlkLgor ICogIDEpIHBsdWcgZGlzcGxheSBkZXZpY2UgdG8gYSBjb25uZWN0b3IKKyAqICAyKSBzeXN0ZW0g c3VzcGVuZAorICogIDMpIHVucGx1ZyAxKSdzIGRpc3BsYXkgZGV2aWNlIGFuZCBwbHVnIHRoZSBv dGhlciBkaXNwbGF5IGRldmljZSB0byBhIGNvbm5lY3RvcgorICogIDQpIHN5c3RlbSByZXN1bWUK KworICogVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZCBmcm9tIHByb2Nlc3MgY29udGV4dCB3 aXRoIG5vIG1vZGUKKyAqIHNldHRpbmcgbG9ja3MgaGVsZC4KKyAqCisgKiBOb3RlIHRoYXQgYSBj b25uZWN0b3IgY2FuIGJlIGJvdGggcG9sbGVkIGFuZCBwcm9iZWQgZnJvbSB0aGUgaG90cGx1ZyBo YW5kbGVyLAorICogaW4gY2FzZSB0aGUgaG90cGx1ZyBpbnRlcnJ1cHQgaXMga25vd24gdG8gYmUg dW5yZWxpYWJsZS4KKyAqLworc3RhdGljIGJvb2wgaW50ZWxfaHBkX2lycV9ldmVudChzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3I7CisJ c3RydWN0IGRybV9jb25uZWN0b3JfbGlzdF9pdGVyIGNvbm5faXRlcjsKKwllbnVtIGRybV9jb25u ZWN0b3Jfc3RhdHVzIG9sZF9zdGF0dXMsIGN1cl9zdGF0dXM7CisJc3RydWN0IGVkaWQgKm9sZF9l ZGlkOworCWJvb2wgY2hhbmdlZCA9IGZhbHNlOworCisJaWYgKCFkZXYtPm1vZGVfY29uZmlnLnBv bGxfZW5hYmxlZCkKKwkJcmV0dXJuIGZhbHNlOworCisJbXV0ZXhfbG9jaygmZGV2LT5tb2RlX2Nv bmZpZy5tdXRleCk7CisJZHJtX2Nvbm5lY3Rvcl9saXN0X2l0ZXJfYmVnaW4oZGV2LCAmY29ubl9p dGVyKTsKKwlkcm1fZm9yX2VhY2hfY29ubmVjdG9yX2l0ZXIoY29ubmVjdG9yLCAmY29ubl9pdGVy KSB7CisJCS8qIE9ubHkgaGFuZGxlIEhQRCBjYXBhYmxlIGNvbm5lY3RvcnMuICovCisJCWlmICgh KGNvbm5lY3Rvci0+cG9sbGVkICYgRFJNX0NPTk5FQ1RPUl9QT0xMX0hQRCkpCisJCQljb250aW51 ZTsKKworCQlvbGRfc3RhdHVzID0gY29ubmVjdG9yLT5zdGF0dXM7CisJCW9sZF9lZGlkID0gdG9f aW50ZWxfY29ubmVjdG9yKGNvbm5lY3RvciktPmRldGVjdF9lZGlkOworCisJCWN1cl9zdGF0dXMg PSBkcm1faGVscGVyX3Byb2JlX2RldGVjdChjb25uZWN0b3IsIE5VTEwsIGZhbHNlKTsKKwkJRFJN X0RFQlVHX0tNUygiW0NPTk5FQ1RPUjolZDolc10gc3RhdHVzIHVwZGF0ZWQgZnJvbSAlcyB0byAl c1xuIiwKKwkJCSAgICAgIGNvbm5lY3Rvci0+YmFzZS5pZCwgY29ubmVjdG9yLT5uYW1lLAorCQkJ ICAgICAgZHJtX2dldF9jb25uZWN0b3Jfc3RhdHVzX25hbWUob2xkX3N0YXR1cyksCisJCQkgICAg ICBkcm1fZ2V0X2Nvbm5lY3Rvcl9zdGF0dXNfbmFtZShjdXJfc3RhdHVzKSk7CisKKwkJaWYgKG9s ZF9zdGF0dXMgIT0gY3VyX3N0YXR1cykKKwkJCWNoYW5nZWQgPSB0cnVlOworCisJCS8qIENoZWNr IGNoYW5naW5nIG9mIGVkaWQgd2hlbiBhIGNvbm5lY3RvciBzdGF0dXMgc3RpbGwgcmVtYWlucwor CQkgKiBhcyAiY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQiLgorCQkgKi8KKwkJaWYgKG9sZF9z dGF0dXMgPT0gY3VyX3N0YXR1cyAmJgorCQkgICAgY3VyX3N0YXR1cyA9PSBjb25uZWN0b3Jfc3Rh dHVzX2Nvbm5lY3RlZCkgeworCQkJc3RydWN0IGVkaWQgKmN1cl9lZGlkID0gdG9faW50ZWxfY29u bmVjdG9yKGNvbm5lY3RvciktPmRldGVjdF9lZGlkOworCisJCQlpZiAoIW9sZF9lZGlkIHx8ICFj dXJfZWRpZCkKKwkJCQljb250aW51ZTsKKworCQkJaWYgKG1lbWNtcChvbGRfZWRpZCwgY3VyX2Vk aWQsIHNpemVvZigqY3VyX2VkaWQpKSkgeworCQkJCWNoYW5nZWQgPSB0cnVlOworCQkJCURSTV9E RUJVR19LTVMoIltDT05ORUNUT1I6JWQ6JXNdIGVkaWQgdXBkYXRlZFxuIiwKKwkJCQkJICAgICAg Y29ubmVjdG9yLT5iYXNlLmlkLAorCQkJCQkgICAgICBjb25uZWN0b3ItPm5hbWUpOworCQkJfQor CQl9CisJfQorCWRybV9jb25uZWN0b3JfbGlzdF9pdGVyX2VuZCgmY29ubl9pdGVyKTsKKwltdXRl eF91bmxvY2soJmRldi0+bW9kZV9jb25maWcubXV0ZXgpOworCisJaWYgKGNoYW5nZWQpCisJCWRy bV9rbXNfaGVscGVyX2hvdHBsdWdfZXZlbnQoZGV2KTsKKworCXJldHVybiBjaGFuZ2VkOworfQor CiBzdGF0aWMgdm9pZCBpOTE1X2hwZF9wb2xsX2luaXRfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3Qg KndvcmspCiB7CiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0KQEAgLTU1Miw3 ICs2MzQsNyBAQCBzdGF0aWMgdm9pZCBpOTE1X2hwZF9wb2xsX2luaXRfd29yayhzdHJ1Y3Qgd29y a19zdHJ1Y3QgKndvcmspCiAJICogaW4gdGhlIG1pZGRsZSBvZiBkaXNhYmxpbmcgcG9sbGluZwog CSAqLwogCWlmICghZW5hYmxlZCkKLQkJZHJtX2hlbHBlcl9ocGRfaXJxX2V2ZW50KGRldik7CisJ CWludGVsX2hwZF9pcnFfZXZlbnQoZGV2KTsKIH0KIAogLyoqCi0tIAoyLjE4LjAKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5n IGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVk ZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=