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,URIBL_BLOCKED,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 5780FC46471 for ; Mon, 6 Aug 2018 12:09:33 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 15A3421A04 for ; Mon, 6 Aug 2018 12:09:33 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 15A3421A04 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 S1732066AbeHFOST (ORCPT ); Mon, 6 Aug 2018 10:18:19 -0400 Received: from mga11.intel.com ([192.55.52.93]:53493 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731180AbeHFOST (ORCPT ); Mon, 6 Aug 2018 10:18:19 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga102.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 06 Aug 2018 05:09:30 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.51,452,1526367600"; d="scan'208";a="77869419" Received: from espoo.fi.intel.com ([10.237.66.147]) by fmsmga004.fm.intel.com with ESMTP; 06 Aug 2018 05:09:27 -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: [v2] drm/i915: Add detection of changing of edid on between suspend and resume Date: Mon, 6 Aug 2018 15:09:27 +0300 Message-Id: <20180806120927.24719-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 | 83 +++++++++++++++++++++++++++- 1 file changed, 82 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/i915/intel_hotplug.c b/drivers/gpu/drm/i915/intel_hotplug.c index 648a13c6043c..0bd3e1c38167 100644 --- a/drivers/gpu/drm/i915/intel_hotplug.c +++ b/drivers/gpu/drm/i915/intel_hotplug.c @@ -507,6 +507,87 @@ 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 +633,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: [v2] drm/i915: Add detection of changing of edid on between suspend and resume Date: Mon, 6 Aug 2018 15:09:27 +0300 Message-ID: <20180806120927.24719-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 ZiBjb25uZWN0b3IsIGJ1dCBpdCBjYW4gbm90IGRldGVjdCBjaGFuZ2luZwpvZiBlZGlkLiBGb2xs b3dpbmcgc2NlbmFyaW8gcmVxdWlyZXMgZGV0ZWN0aW9uIG9mIGNoYW5naW5nIG9mIGVkaWQuCgog MSkgcGx1ZyBkaXNwbGF5IGRldmljZSB0byBhIGNvbm5lY3RvcgogMikgc3lzdGVtIHN1c3BlbmQK IDMpIHVucGx1ZyAxKSdzIGRpc3BsYXkgZGV2aWNlIGFuZCBwbHVnIHRoZSBvdGhlciBkaXNwbGF5 IGRldmljZSB0byBhIGNvbm5lY3RvcgogNCkgc3lzdGVtIHJlc3VtZQoKSXQgYWRkcyBlZGlkIGNo ZWNrIHJvdXRpbmUgd2hlbiBhIGNvbm5lY3RvciBzdGF0dXMgc3RpbGwgcmVtYWlucyBhcyAiY29u bmVjdG9yX3N0YXR1c19jb25uZWN0ZWQiLgoKdjI6IEFkZCBOVUxMIGNoZWNrIGJlZm9yZSBjb21w YXJpbmcgb2YgRURJRHMuCgpUZXN0Y2FzZTogaWd0L2ttc19jaGFtZWxpdW0vaGRtaS1lZGlkLWNo YW5nZS1kdXJpbmctaGliZXJuYXRlClRlc3RjYXNlOiBpZ3Qva21zX2NoYW1lbGl1bS9oZG1pLWVk aWQtY2hhbmdlLWR1cmluZy1zdXNwZW5kClRlc3RjYXNlOiBpZ3Qva21zX2NoYW1lbGl1bS9kcC1l ZGlkLWNoYW5nZS1kdXJpbmctaGliZXJuYXRlClRlc3RjYXNlOiBpZ3Qva21zX2NoYW1lbGl1bS9k cC1lZGlkLWNoYW5nZS1kdXJpbmctc3VzcGVuZAoKU2lnbmVkLW9mZi1ieTogR3dhbi1neWVvbmcg TXVuIDxnd2FuLWd5ZW9uZy5tdW5AaW50ZWwuY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2hvdHBsdWcuYyB8IDgzICsrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIDEgZmls ZSBjaGFuZ2VkLCA4MiBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaG90cGx1Zy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfaG90cGx1Zy5jCmluZGV4IDY0OGExM2M2MDQzYy4uMGJkM2UxYzM4MTY3IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9ob3RwbHVnLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfaG90cGx1Zy5jCkBAIC01MDcsNiArNTA3LDg3IEBAIHZvaWQg aW50ZWxfaHBkX2luaXQoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCX0KIH0K IAorLyoqCisgKiBpbnRlbF9ocGRfaXJxX2V2ZW50IC0gaG90cGx1ZyBwcm9jZXNzaW5nCisgKiBA ZGV2OiBkcm1fZGV2aWNlCisgKgorICogRHJpdmVycyBjYW4gdXNlIHRoaXMgZnVuY3Rpb24gdG8g cnVuIGEgZGV0ZWN0IGN5Y2xlIG9uIGFsbCBjb25uZWN0b3JzIHdoaWNoCisgKiBoYXZlIHRoZSBE Uk1fQ09OTkVDVE9SX1BPTExfSFBEIGZsYWcgc2V0IGluIHRoZWlyICZwb2xsZWQgbWVtYmVyLiBB bGwgb3RoZXIKKyAqIGNvbm5lY3RvcnMgYXJlIGlnbm9yZWQsIHdoaWNoIGlzIHVzZWZ1bCB0byBh dm9pZCByZXByb2JpbmcgZml4ZWQgcGFuZWxzLgorICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgdXNl ZnVsIGZvciBkcml2ZXJzIHdoaWNoIGNhbid0IG9yIGRvbid0IHRyYWNrIGhvdHBsdWcgaW50ZXJy dXB0cworICogZm9yIGVhY2ggY29ubmVjdG9yLiBUaGlzIGZ1bmN0aW9uIGlzIGJhc2VkIG9uIGRy bV9oZWxwZXJfaHBkX2lycV9ldmVudCgpIGhlbHBlcgorICogZnVuY3Rpb24gYW5kIGJlc2lkZXMg aXQgYWRkcyBlZGlkIGNoZWNrIHJvdXRpbmUgd2hlbiBhIGNvbm5lY3RvciBzdGF0dXMgc3RpbGwK KyAqIHJlbWFpbnMgYXMgImNvbm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVkIi4KKyAqCisgKiBGb2xs b3dpbmcgc2NlbmFyaW8gcmVxdWlyZXMgZGV0ZWN0aW9uIG9mIGNoYW5naW5nIG9mIGVkaWQuCisg KiAgMSkgcGx1ZyBkaXNwbGF5IGRldmljZSB0byBhIGNvbm5lY3RvcgorICogIDIpIHN5c3RlbSBz dXNwZW5kCisgKiAgMykgdW5wbHVnIDEpJ3MgZGlzcGxheSBkZXZpY2UgYW5kIHBsdWcgdGhlIG90 aGVyIGRpc3BsYXkgZGV2aWNlIHRvIGEgY29ubmVjdG9yCisgKiAgNCkgc3lzdGVtIHJlc3VtZQor CisgKiBUaGlzIGZ1bmN0aW9uIG11c3QgYmUgY2FsbGVkIGZyb20gcHJvY2VzcyBjb250ZXh0IHdp dGggbm8gbW9kZQorICogc2V0dGluZyBsb2NrcyBoZWxkLgorICoKKyAqIE5vdGUgdGhhdCBhIGNv bm5lY3RvciBjYW4gYmUgYm90aCBwb2xsZWQgYW5kIHByb2JlZCBmcm9tIHRoZSBob3RwbHVnIGhh bmRsZXIsCisgKiBpbiBjYXNlIHRoZSBob3RwbHVnIGludGVycnVwdCBpcyBrbm93biB0byBiZSB1 bnJlbGlhYmxlLgorICovCitzdGF0aWMgYm9vbCBpbnRlbF9ocGRfaXJxX2V2ZW50KHN0cnVjdCBk cm1fZGV2aWNlICpkZXYpCit7CisJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcjsKKwlz dHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9saXN0X2l0ZXIgY29ubl9pdGVyOworCWVudW0gZHJtX2Nvbm5l Y3Rvcl9zdGF0dXMgb2xkX3N0YXR1cywgY3VyX3N0YXR1czsKKwlzdHJ1Y3QgZWRpZCAqb2xkX2Vk aWQ7CisJYm9vbCBjaGFuZ2VkID0gZmFsc2U7CisKKwlpZiAoIWRldi0+bW9kZV9jb25maWcucG9s bF9lbmFibGVkKQorCQlyZXR1cm4gZmFsc2U7CisKKwltdXRleF9sb2NrKCZkZXYtPm1vZGVfY29u ZmlnLm11dGV4KTsKKwlkcm1fY29ubmVjdG9yX2xpc3RfaXRlcl9iZWdpbihkZXYsICZjb25uX2l0 ZXIpOworCWRybV9mb3JfZWFjaF9jb25uZWN0b3JfaXRlcihjb25uZWN0b3IsICZjb25uX2l0ZXIp IHsKKwkJLyogT25seSBoYW5kbGUgSFBEIGNhcGFibGUgY29ubmVjdG9ycy4gKi8KKwkJaWYgKCEo Y29ubmVjdG9yLT5wb2xsZWQgJiBEUk1fQ09OTkVDVE9SX1BPTExfSFBEKSkKKwkJCWNvbnRpbnVl OworCisJCW9sZF9zdGF0dXMgPSBjb25uZWN0b3ItPnN0YXR1czsKKwkJb2xkX2VkaWQgPSB0b19p bnRlbF9jb25uZWN0b3IoY29ubmVjdG9yKS0+ZGV0ZWN0X2VkaWQ7CisKKwkJY3VyX3N0YXR1cyA9 IGRybV9oZWxwZXJfcHJvYmVfZGV0ZWN0KGNvbm5lY3RvciwgTlVMTCwgZmFsc2UpOworCQlEUk1f REVCVUdfS01TKCJbQ09OTkVDVE9SOiVkOiVzXSBzdGF0dXMgdXBkYXRlZCBmcm9tICVzIHRvICVz XG4iLAorCQkJICAgICAgY29ubmVjdG9yLT5iYXNlLmlkLCBjb25uZWN0b3ItPm5hbWUsCisJCQkg ICAgICBkcm1fZ2V0X2Nvbm5lY3Rvcl9zdGF0dXNfbmFtZShvbGRfc3RhdHVzKSwKKwkJCSAgICAg IGRybV9nZXRfY29ubmVjdG9yX3N0YXR1c19uYW1lKGN1cl9zdGF0dXMpKTsKKworCQlpZiAob2xk X3N0YXR1cyAhPSBjdXJfc3RhdHVzKQorCQkJY2hhbmdlZCA9IHRydWU7CisKKwkJLyogQ2hlY2sg Y2hhbmdpbmcgb2YgZWRpZCB3aGVuIGEgY29ubmVjdG9yIHN0YXR1cyBzdGlsbCByZW1haW5zCisJ CSAqIGFzICJjb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZCIuCisJCSAqLworCQlpZiAob2xkX3N0 YXR1cyA9PSBjdXJfc3RhdHVzICYmCisJCSAgICBjdXJfc3RhdHVzID09IGNvbm5lY3Rvcl9zdGF0 dXNfY29ubmVjdGVkKSB7CisJCQlzdHJ1Y3QgZWRpZCAqY3VyX2VkaWQgPSB0b19pbnRlbF9jb25u ZWN0b3IoY29ubmVjdG9yKS0+ZGV0ZWN0X2VkaWQ7CisJCQlpZiAoIW9sZF9lZGlkIHx8ICFjdXJf ZWRpZCkKKwkJCQljb250aW51ZTsKKworCQkJaWYgKG1lbWNtcChvbGRfZWRpZCwgY3VyX2VkaWQs IHNpemVvZigqY3VyX2VkaWQpKSkgeworCQkJCWNoYW5nZWQgPSB0cnVlOworCQkJCURSTV9ERUJV R19LTVMoIltDT05ORUNUT1I6JWQ6JXNdIGVkaWQgdXBkYXRlZFxuIiwKKwkJCQkJICAgICAgY29u bmVjdG9yLT5iYXNlLmlkLAorCQkJCQkgICAgICBjb25uZWN0b3ItPm5hbWUpOworCQkJfQorCQl9 CisJfQorCWRybV9jb25uZWN0b3JfbGlzdF9pdGVyX2VuZCgmY29ubl9pdGVyKTsKKwltdXRleF91 bmxvY2soJmRldi0+bW9kZV9jb25maWcubXV0ZXgpOworCisJaWYgKGNoYW5nZWQpCisJCWRybV9r bXNfaGVscGVyX2hvdHBsdWdfZXZlbnQoZGV2KTsKKworCXJldHVybiBjaGFuZ2VkOworfQorCiBz dGF0aWMgdm9pZCBpOTE1X2hwZF9wb2xsX2luaXRfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndv cmspCiB7CiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0KQEAgLTU1Miw3ICs2 MzMsNyBAQCBzdGF0aWMgdm9pZCBpOTE1X2hwZF9wb2xsX2luaXRfd29yayhzdHJ1Y3Qgd29ya19z dHJ1Y3QgKndvcmspCiAJICogaW4gdGhlIG1pZGRsZSBvZiBkaXNhYmxpbmcgcG9sbGluZwogCSAq LwogCWlmICghZW5hYmxlZCkKLQkJZHJtX2hlbHBlcl9ocGRfaXJxX2V2ZW50KGRldik7CisJCWlu dGVsX2hwZF9pcnFfZXZlbnQoZGV2KTsKIH0KIAogLyoqCi0tIAoyLjE4LjAKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxp c3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNr dG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=