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=-8.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,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 2E86EC46475 for ; Wed, 24 Oct 2018 02:49:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id F017020651 for ; Wed, 24 Oct 2018 02:49:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F017020651 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 S1726992AbeJXLPl (ORCPT ); Wed, 24 Oct 2018 07:15:41 -0400 Received: from mga11.intel.com ([192.55.52.93]:41763 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725826AbeJXLPl (ORCPT ); Wed, 24 Oct 2018 07:15:41 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga102.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 23 Oct 2018 19:22:28 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.54,418,1534834800"; d="scan'208";a="102098586" Received: from jhli-desk1.jf.intel.com ([10.7.198.167]) by orsmga001.jf.intel.com with ESMTP; 23 Oct 2018 19:22:28 -0700 From: Juston Li To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Cc: lyude@redhat.com, clinton.a.taylor@intel.com, nathan.d.ciobanu@intel.com, mario.limonciello@dell.com, jared_dominguez@dell.com, linux-kernel@vger.kernel.org, Lyude , stable@vger.kernel.org, Juston Li Subject: [RESEND PATCH v2 1/2] drm/dp/mst: Reprobe EDID for MST ports on resume Date: Tue, 23 Oct 2018 19:19:24 -0700 Message-Id: <20181024021925.27026-2-juston.li@intel.com> X-Mailer: git-send-email 2.17.2 In-Reply-To: <20181024021925.27026-1-juston.li@intel.com> References: <20181024021925.27026-1-juston.li@intel.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Lyude As observed with the latest ThinkPad docks, we unfortunately can't rely on docks keeping us updated with hotplug events that happened while we were suspended. On top of that, even if the number of connectors remains the same between suspend and resume it's still not safe to assume that there were no hotplugs, since a different monitor might have been plugged into a port another monitor previously occupied. As such, we need to go through all of the MST ports and check whether or not their EDIDs have changed. In addition to that, we also now return -EINVAL from drm_dp_mst_topology_mgr_resume to indicate to callers that they need to reset the MST connection, and that they can't rely on any other method of reprobing. Cc: stable@vger.kernel.org Signed-off-by: Lyude Signed-off-by: Juston Li --- drivers/gpu/drm/drm_dp_mst_topology.c | 94 ++++++++++++++++++++++++++- 1 file changed, 93 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c index 5ff1d79b86c4..88abebe52021 100644 --- a/drivers/gpu/drm/drm_dp_mst_topology.c +++ b/drivers/gpu/drm/drm_dp_mst_topology.c @@ -29,6 +29,7 @@ #include #include #include +#include #include #include @@ -2201,6 +2202,64 @@ void drm_dp_mst_topology_mgr_suspend(struct drm_dp_mst_topology_mgr *mgr) } EXPORT_SYMBOL(drm_dp_mst_topology_mgr_suspend); +static bool drm_dp_mst_edids_changed(struct drm_dp_mst_topology_mgr *mgr, + struct drm_dp_mst_port *port) +{ + struct drm_device *dev; + struct drm_connector *connector; + struct drm_dp_mst_port *dport; + struct drm_dp_mst_branch *mstb; + struct edid *current_edid, *cached_edid; + bool ret = false; + + port = drm_dp_get_validated_port_ref(mgr, port); + if (!port) + return false; + + mstb = drm_dp_get_validated_mstb_ref(mgr, port->mstb); + if (mstb) { + list_for_each_entry(dport, &port->mstb->ports, next) { + ret = drm_dp_mst_edids_changed(mgr, dport); + if (ret) + break; + } + + drm_dp_put_mst_branch_device(mstb); + if (ret) + goto out; + } + + connector = port->connector; + if (!connector || !port->aux.ddc.algo) + goto out; + + dev = connector->dev; + mutex_lock(&dev->mode_config.mutex); + + current_edid = drm_get_edid(connector, &port->aux.ddc); + if (connector->edid_blob_ptr) + cached_edid = (void *)connector->edid_blob_ptr->data; + else + return false; + + if ((current_edid && cached_edid && memcmp(current_edid, cached_edid, + sizeof(struct edid)) != 0) || + (!current_edid && cached_edid) || (current_edid && !cached_edid)) { + ret = true; + DRM_DEBUG_KMS("EDID on %s changed, reprobing connectors\n", + connector->name); + } + + mutex_unlock(&dev->mode_config.mutex); + + kfree(current_edid); + +out: + drm_dp_put_port(port); + + return ret; +} + /** * drm_dp_mst_topology_mgr_resume() - resume the MST manager * @mgr: manager to resume @@ -2210,9 +2269,15 @@ EXPORT_SYMBOL(drm_dp_mst_topology_mgr_suspend); * * if the device fails this returns -1, and the driver should do * a full MST reprobe, in case we were undocked. + * + * if the device can no longer be trusted, this returns -EINVAL + * and the driver should unconditionally disconnect and reconnect + * the dock. */ int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr) { + struct drm_dp_mst_branch *mstb; + struct drm_dp_mst_port *port; int ret = 0; mutex_lock(&mgr->lock); @@ -2246,8 +2311,35 @@ int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr) drm_dp_check_mstb_guid(mgr->mst_primary, guid); ret = 0; - } else + + /* + * Some hubs also forget to notify us of hotplugs that happened + * while we were in suspend, so we need to verify that the edid + * hasn't changed for any of the connectors. If it has been, + * we unfortunately can't rely on the dock updating us with + * hotplug events, so indicate we need a full reconnect. + */ + + /* MST's I2C helpers can't be used while holding this lock */ + mutex_unlock(&mgr->lock); + + mstb = drm_dp_get_validated_mstb_ref(mgr, mgr->mst_primary); + if (mstb) { + list_for_each_entry(port, &mstb->ports, next) { + if (drm_dp_mst_edids_changed(mgr, port)) { + ret = -EINVAL; + break; + } + } + + drm_dp_put_mst_branch_device(mstb); + } + } else { ret = -1; + mutex_unlock(&mgr->lock); + } + + return ret; out_unlock: mutex_unlock(&mgr->lock); -- 2.17.2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Juston Li Subject: [RESEND PATCH v2 1/2] drm/dp/mst: Reprobe EDID for MST ports on resume Date: Tue, 23 Oct 2018 19:19:24 -0700 Message-ID: <20181024021925.27026-2-juston.li@intel.com> References: <20181024021925.27026-1-juston.li@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20181024021925.27026-1-juston.li@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Cc: mario.limonciello@dell.com, linux-kernel@vger.kernel.org, nathan.d.ciobanu@intel.com, jared_dominguez@dell.com, stable@vger.kernel.org, Lyude , Juston Li List-Id: dri-devel@lists.freedesktop.org RnJvbTogTHl1ZGUgPGNwYXVsQHJlZGhhdC5jb20+CgpBcyBvYnNlcnZlZCB3aXRoIHRoZSBsYXRl c3QgVGhpbmtQYWQgZG9ja3MsIHdlIHVuZm9ydHVuYXRlbHkgY2FuJ3QgcmVseQpvbiBkb2NrcyBr ZWVwaW5nIHVzIHVwZGF0ZWQgd2l0aCBob3RwbHVnIGV2ZW50cyB0aGF0IGhhcHBlbmVkIHdoaWxl IHdlCndlcmUgc3VzcGVuZGVkLiBPbiB0b3Agb2YgdGhhdCwgZXZlbiBpZiB0aGUgbnVtYmVyIG9m IGNvbm5lY3RvcnMgcmVtYWlucwp0aGUgc2FtZSBiZXR3ZWVuIHN1c3BlbmQgYW5kIHJlc3VtZSBp dCdzIHN0aWxsIG5vdCBzYWZlIHRvIGFzc3VtZSB0aGF0CnRoZXJlIHdlcmUgbm8gaG90cGx1Z3Ms IHNpbmNlIGEgZGlmZmVyZW50IG1vbml0b3IgbWlnaHQgaGF2ZSBiZWVuCnBsdWdnZWQgaW50byBh IHBvcnQgYW5vdGhlciBtb25pdG9yIHByZXZpb3VzbHkgb2NjdXBpZWQuIEFzIHN1Y2gsIHdlCm5l ZWQgdG8gZ28gdGhyb3VnaCBhbGwgb2YgdGhlIE1TVCBwb3J0cyBhbmQgY2hlY2sgd2hldGhlciBv ciBub3QgdGhlaXIKRURJRHMgaGF2ZSBjaGFuZ2VkLgoKSW4gYWRkaXRpb24gdG8gdGhhdCwgd2Ug YWxzbyBub3cgcmV0dXJuIC1FSU5WQUwgZnJvbQpkcm1fZHBfbXN0X3RvcG9sb2d5X21ncl9yZXN1 bWUgdG8gaW5kaWNhdGUgdG8gY2FsbGVycyB0aGF0IHRoZXkgbmVlZCB0bwpyZXNldCB0aGUgTVNU IGNvbm5lY3Rpb24sIGFuZCB0aGF0IHRoZXkgY2FuJ3QgcmVseSBvbiBhbnkgb3RoZXIgbWV0aG9k Cm9mIHJlcHJvYmluZy4KCkNjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnClNpZ25lZC1vZmYtYnk6 IEx5dWRlIDxjcGF1bEByZWRoYXQuY29tPgpTaWduZWQtb2ZmLWJ5OiBKdXN0b24gTGkgPGp1c3Rv bi5saUBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL2RybV9kcF9tc3RfdG9wb2xvZ3ku YyB8IDk0ICsrKysrKysrKysrKysrKysrKysrKysrKysrLQogMSBmaWxlIGNoYW5nZWQsIDkzIGlu c2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v ZHJtX2RwX21zdF90b3BvbG9neS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9kcF9tc3RfdG9wb2xv Z3kuYwppbmRleCA1ZmYxZDc5Yjg2YzQuLjg4YWJlYmU1MjAyMSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2RybV9kcF9tc3RfdG9wb2xvZ3kuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJt X2RwX21zdF90b3BvbG9neS5jCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSA8bGludXgvaTJj Lmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9kcF9tc3RfaGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2Ry bVAuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2VkaWQuaD4KIAogI2luY2x1ZGUgPGRybS9kcm1fZml4 ZWQuaD4KICNpbmNsdWRlIDxkcm0vZHJtX2F0b21pYy5oPgpAQCAtMjIwMSw2ICsyMjAyLDY0IEBA IHZvaWQgZHJtX2RwX21zdF90b3BvbG9neV9tZ3Jfc3VzcGVuZChzdHJ1Y3QgZHJtX2RwX21zdF90 b3BvbG9neV9tZ3IgKm1ncikKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2RwX21zdF90b3BvbG9neV9t Z3Jfc3VzcGVuZCk7CiAKK3N0YXRpYyBib29sIGRybV9kcF9tc3RfZWRpZHNfY2hhbmdlZChzdHJ1 Y3QgZHJtX2RwX21zdF90b3BvbG9neV9tZ3IgKm1nciwKKwkJCQkgICAgIHN0cnVjdCBkcm1fZHBf bXN0X3BvcnQgKnBvcnQpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubmVjdG9yOworCXN0cnVjdCBkcm1fZHBfbXN0X3BvcnQgKmRwb3J0Owor CXN0cnVjdCBkcm1fZHBfbXN0X2JyYW5jaCAqbXN0YjsKKwlzdHJ1Y3QgZWRpZCAqY3VycmVudF9l ZGlkLCAqY2FjaGVkX2VkaWQ7CisJYm9vbCByZXQgPSBmYWxzZTsKKworCXBvcnQgPSBkcm1fZHBf Z2V0X3ZhbGlkYXRlZF9wb3J0X3JlZihtZ3IsIHBvcnQpOworCWlmICghcG9ydCkKKwkJcmV0dXJu IGZhbHNlOworCisJbXN0YiA9IGRybV9kcF9nZXRfdmFsaWRhdGVkX21zdGJfcmVmKG1nciwgcG9y dC0+bXN0Yik7CisJaWYgKG1zdGIpIHsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeShkcG9ydCwgJnBv cnQtPm1zdGItPnBvcnRzLCBuZXh0KSB7CisJCQlyZXQgPSBkcm1fZHBfbXN0X2VkaWRzX2NoYW5n ZWQobWdyLCBkcG9ydCk7CisJCQlpZiAocmV0KQorCQkJCWJyZWFrOworCQl9CisKKwkJZHJtX2Rw X3B1dF9tc3RfYnJhbmNoX2RldmljZShtc3RiKTsKKwkJaWYgKHJldCkKKwkJCWdvdG8gb3V0Owor CX0KKworCWNvbm5lY3RvciA9IHBvcnQtPmNvbm5lY3RvcjsKKwlpZiAoIWNvbm5lY3RvciB8fCAh cG9ydC0+YXV4LmRkYy5hbGdvKQorCQlnb3RvIG91dDsKKworCWRldiA9IGNvbm5lY3Rvci0+ZGV2 OworCW11dGV4X2xvY2soJmRldi0+bW9kZV9jb25maWcubXV0ZXgpOworCisJY3VycmVudF9lZGlk ID0gZHJtX2dldF9lZGlkKGNvbm5lY3RvciwgJnBvcnQtPmF1eC5kZGMpOworCWlmIChjb25uZWN0 b3ItPmVkaWRfYmxvYl9wdHIpCisJCWNhY2hlZF9lZGlkID0gKHZvaWQgKiljb25uZWN0b3ItPmVk aWRfYmxvYl9wdHItPmRhdGE7CisJZWxzZQorCQlyZXR1cm4gZmFsc2U7CisKKwlpZiAoKGN1cnJl bnRfZWRpZCAmJiBjYWNoZWRfZWRpZCAmJiBtZW1jbXAoY3VycmVudF9lZGlkLCBjYWNoZWRfZWRp ZCwKKwkJCQkJCSAgIHNpemVvZihzdHJ1Y3QgZWRpZCkpICE9IDApIHx8CisJICAgICghY3VycmVu dF9lZGlkICYmIGNhY2hlZF9lZGlkKSB8fCAoY3VycmVudF9lZGlkICYmICFjYWNoZWRfZWRpZCkp IHsKKwkJcmV0ID0gdHJ1ZTsKKwkJRFJNX0RFQlVHX0tNUygiRURJRCBvbiAlcyBjaGFuZ2VkLCBy ZXByb2JpbmcgY29ubmVjdG9yc1xuIiwKKwkJCSAgICAgIGNvbm5lY3Rvci0+bmFtZSk7CisJfQor CisJbXV0ZXhfdW5sb2NrKCZkZXYtPm1vZGVfY29uZmlnLm11dGV4KTsKKworCWtmcmVlKGN1cnJl bnRfZWRpZCk7CisKK291dDoKKwlkcm1fZHBfcHV0X3BvcnQocG9ydCk7CisKKwlyZXR1cm4gcmV0 OworfQorCiAvKioKICAqIGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyX3Jlc3VtZSgpIC0gcmVzdW1l IHRoZSBNU1QgbWFuYWdlcgogICogQG1ncjogbWFuYWdlciB0byByZXN1bWUKQEAgLTIyMTAsOSAr MjI2OSwxNSBAQCBFWFBPUlRfU1lNQk9MKGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyX3N1c3BlbmQp OwogICoKICAqIGlmIHRoZSBkZXZpY2UgZmFpbHMgdGhpcyByZXR1cm5zIC0xLCBhbmQgdGhlIGRy aXZlciBzaG91bGQgZG8KICAqIGEgZnVsbCBNU1QgcmVwcm9iZSwgaW4gY2FzZSB3ZSB3ZXJlIHVu ZG9ja2VkLgorICoKKyAqIGlmIHRoZSBkZXZpY2UgY2FuIG5vIGxvbmdlciBiZSB0cnVzdGVkLCB0 aGlzIHJldHVybnMgLUVJTlZBTAorICogYW5kIHRoZSBkcml2ZXIgc2hvdWxkIHVuY29uZGl0aW9u YWxseSBkaXNjb25uZWN0IGFuZCByZWNvbm5lY3QKKyAqIHRoZSBkb2NrLgogICovCiBpbnQgZHJt X2RwX21zdF90b3BvbG9neV9tZ3JfcmVzdW1lKHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21n ciAqbWdyKQogeworCXN0cnVjdCBkcm1fZHBfbXN0X2JyYW5jaCAqbXN0YjsKKwlzdHJ1Y3QgZHJt X2RwX21zdF9wb3J0ICpwb3J0OwogCWludCByZXQgPSAwOwogCiAJbXV0ZXhfbG9jaygmbWdyLT5s b2NrKTsKQEAgLTIyNDYsOCArMjMxMSwzNSBAQCBpbnQgZHJtX2RwX21zdF90b3BvbG9neV9tZ3Jf cmVzdW1lKHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbWdyKQogCQlkcm1fZHBfY2hl Y2tfbXN0Yl9ndWlkKG1nci0+bXN0X3ByaW1hcnksIGd1aWQpOwogCiAJCXJldCA9IDA7Ci0JfSBl bHNlCisKKwkJLyoKKwkJICogU29tZSBodWJzIGFsc28gZm9yZ2V0IHRvIG5vdGlmeSB1cyBvZiBo b3RwbHVncyB0aGF0IGhhcHBlbmVkCisJCSAqIHdoaWxlIHdlIHdlcmUgaW4gc3VzcGVuZCwgc28g d2UgbmVlZCB0byB2ZXJpZnkgdGhhdCB0aGUgZWRpZAorCQkgKiBoYXNuJ3QgY2hhbmdlZCBmb3Ig YW55IG9mIHRoZSBjb25uZWN0b3JzLiBJZiBpdCBoYXMgYmVlbiwKKwkJICogd2UgdW5mb3J0dW5h dGVseSBjYW4ndCByZWx5IG9uIHRoZSBkb2NrIHVwZGF0aW5nIHVzIHdpdGgKKwkJICogaG90cGx1 ZyBldmVudHMsIHNvIGluZGljYXRlIHdlIG5lZWQgYSBmdWxsIHJlY29ubmVjdC4KKwkJICovCisK KwkJLyogTVNUJ3MgSTJDIGhlbHBlcnMgY2FuJ3QgYmUgdXNlZCB3aGlsZSBob2xkaW5nIHRoaXMg bG9jayAqLworCQltdXRleF91bmxvY2soJm1nci0+bG9jayk7CisKKwkJbXN0YiA9IGRybV9kcF9n ZXRfdmFsaWRhdGVkX21zdGJfcmVmKG1nciwgbWdyLT5tc3RfcHJpbWFyeSk7CisJCWlmIChtc3Ri KSB7CisJCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcnQsICZtc3RiLT5wb3J0cywgbmV4dCkgewor CQkJCWlmIChkcm1fZHBfbXN0X2VkaWRzX2NoYW5nZWQobWdyLCBwb3J0KSkgeworCQkJCQlyZXQg PSAtRUlOVkFMOworCQkJCQlicmVhazsKKwkJCQl9CisJCQl9CisKKwkJCWRybV9kcF9wdXRfbXN0 X2JyYW5jaF9kZXZpY2UobXN0Yik7CisJCX0KKwl9IGVsc2UgewogCQlyZXQgPSAtMTsKKwkJbXV0 ZXhfdW5sb2NrKCZtZ3ItPmxvY2spOworCX0KKworCXJldHVybiByZXQ7CiAKIG91dF91bmxvY2s6 CiAJbXV0ZXhfdW5sb2NrKCZtZ3ItPmxvY2spOwotLSAKMi4xNy4yCgpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK