From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [PATCH v3 1/3] drm/i915: Block fbdev HPD processing during suspend Date: Tue, 29 Jan 2019 14:09:59 -0500 Message-ID: <20190129191001.442-2-lyude@redhat.com> References: <20190129191001.442-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190129191001.442-1-lyude@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: intel-gfx@lists.freedesktop.org Cc: Todd Previte , dri-devel@lists.freedesktop.org, David Airlie , linux-kernel@vger.kernel.org, stable@vger.kernel.org, Dave Airlie List-Id: dri-devel@lists.freedesktop.org V2hlbiByZXN1bWluZywgd2UgY2hlY2sgd2hldGhlciBvciBub3QgYW55IHByZXZpb3VzbHkgY29u bmVjdGVkCk1TVCB0b3BvbG9naWVzIGFyZSBzdGlsbCBwcmVzZW50IGFuZCBpZiBzbywgYXR0ZW1w dCB0byByZXN1bWUgdGhlbS4gSWYKdGhpcyBmYWlscywgd2UgZGlzYWJsZSBzYWlkIE1TVCB0b3Bv bG9naWVzIGFuZCBmaXJlIG9mZiBhIGhvdHBsdWcgZXZlbnQKc28gdGhhdCB1c2Vyc3BhY2Uga25v d3MgdG8gcmVwcm9iZS4KCkhvd2V2ZXIsIHNlbmRpbmcgYSBob3RwbHVnIGV2ZW50IGludm9sdmVz IGNhbGxpbmcKZHJtX2ZiX2hlbHBlcl9ob3RwbHVnX2V2ZW50KCksIHdoaWNoIGluIHR1cm4gcmVz dWx0cyBpbiBmYmNvbiBkb2luZyBhCmNvbm5lY3RvciByZXByb2JlIGluIHRoZSBjYWxsZXIncyB0 aHJlYWQgLSBzb21ldGhpbmcgd2UgY2FuJ3QgZG8gYXQgdGhlCnBvaW50IGluIHdoaWNoIGk5MTUg Y2FsbHMgZHJtX2RwX21zdF90b3BvbG9neV9tZ3JfcmVzdW1lKCkgc2luY2UKaG90cGx1Z2dpbmcg aGFzbid0IGJlZW4gZnVsbHkgaW5pdGlhbGl6ZWQgeWV0LgoKVGhpcyBjdXJyZW50bHkgY2F1c2Vz IHNvbWUgcmF0aGVyIHN1YnRsZSBidXQgZmF0YWwgaXNzdWVzLiBGb3IgZXhhbXBsZSwKb24gbXkg VDQ4MHMgdGhlIGxhcHRvcCBkb2NrIGNvbm5lY3RlZCB0byBpdCB1c3VhbGx5IGRpc2FwcGVhcnMg ZHVyaW5nIGEKc3VzcGVuZCBjeWNsZSwgYW5kIGNvbWVzIGJhY2sgdXAgYSBzaG9ydCB3aGlsZSBh ZnRlciB0aGUgc3lzdGVtIGhhcyBiZWVuCnJlc3VtZWQuIFRoaXMgZ3VhcmFudGVlcyBwcmV0dHkg bXVjaCBldmVyeSBzdXNwZW5kIGFuZCByZXN1bWUgY3ljbGUsCmRybV9kcF9tc3RfdG9wb2xvZ3lf bWdyX3NldF9tc3QobWdyLCBmYWxzZSk7IHdpbGwgYmUgY2F1c2VkIGFuZCBpbiB0dXJuLAphIGNv bm5lY3RvciBob3RwbHVnIHdpbGwgb2NjdXIuIE5vdyBpdCdzIFJ1dGUgR29sZGJlcmcgdGltZTog d2hlbiB0aGUKY29ubmVjdG9yIGhvdHBsdWcgb2NjdXJzLCBpOTE1IHJlcHJvYmVzIC9hbGwvIG9m IHRoZSBjb25uZWN0b3JzLAppbmNsdWRpbmcgZURQLiBIb3dldmVyLCBlRFAgcHJvYmluZyByZXF1 aXJlcyB0aGF0IHdlIHBvd2VyIG9uIHRoZSBwYW5lbApWREQgd2hpY2ggaW4gdHVybiwgZ3JhYnMg YSB3YWtlcmVmIHRvIHRoZSBhcHByb3ByaWF0ZSBwb3dlciBkb21haW4gb24KdGhlIEdQVSAob24g bXkgVDQ4MHMsIHRoaXMgaXMgdGhlIFBPUlRfRERJX0FfSU8gZG9tYWluKS4gVGhpcyBpcyB3aGVy ZQp0aGluZ3Mgc3RhcnQgYnJlYWtpbmcsIHNpbmNlIHRoaXMgYWxsIGhhcHBlbnMgYmVmb3JlCmlu dGVsX3Bvd2VyX2RvbWFpbnNfZW5hYmxlKCkgaXMgY2FsbGVkIHdlIGVuZCB1cCBsZWFraW5nIHRo ZSB3YWtlcmVmCnRoYXQgd2FzIGFjcXVpcmVkIGFuZCBuZXZlciByZWxlYXNpbmcgaXQgbGF0ZXIu IENvbWUgbmV4dCBzdXNwZW5kL3Jlc3VtZQpjeWNsZSwgdGhpcyBjYXVzZXMgdXMgdG8gZmFpbCB0 byBzaHV0IGRvd24gdGhlIEdQVSBwcm9wZXJseSwgd2hpY2gKY2F1c2VzIGl0IG5vdCB0byByZXN1 bWUgcHJvcGVybHkgYW5kIGRpZSBhIGhvcnJpYmxlIGNvbXBsaWNhdGVkIGRlYXRoLgoKKGFzIGEg bm90ZTogdGhpcyBvbmx5IGhhcHBlbnMgd2hlbiB0aGVyZSdzIGJvdGggYW4gZURQIHBhbmVsIGFu ZCBNU1QKdG9wb2xvZ3kgY29ubmVjdGVkIHdoaWNoIGlzIHJlbW92ZWQgbWlkLXN1c3BlbmQuIE9u ZSBvciB0aGUgb3RoZXIgc2VlbXMKdG8gYWx3YXlzIGJlIE9LKS4KCldlIGNvdWxkIHRyeSB0byBm aXggdGhlIFZERCB3YWtlcmVmIGxlYWssIGJ1dCB0aGlzIGRvZXNuJ3Qgc2VlbSBsaWtlCml0J3Mg d29ydGggaXQgYXQgYWxsIHNpbmNlIHdlIGFyZW4ndCBhYmxlIHRvIGhhbmRsZSBob3RwbHVnIGRl dGVjdGlvbgp3aGlsZSByZXN1bWluZyBhbnl3YXkuIFNvLCBsZXQncyBnbyB3aXRoIGEgbW9yZSBy b2J1c3Qgc29sdXRpb24gaW5zcGlyZWQKYnkgbm91dmVhdTogYmxvY2sgZmJkZXYgZnJvbSBoYW5k bGluZyBob3RwbHVnIGV2ZW50cyB1bnRpbCB3ZSByZXN1bWUKZmJkZXYuIFRoaXMgYWxsb3dzIHVz IHRvIHN0aWxsIHNlbmQgc3lzZnMgaG90cGx1ZyBldmVudHMgdG8gYmUgaGFuZGxlZApsYXRlciBi eSB1c2VyIHNwYWNlIHdoaWxlIHdlJ3JlIHJlc3VtaW5nLCB3aGlsZSBhbHNvIHByZXZlbnRpbmcg dXMgZnJvbQphY3R1YWxseSBwcm9jZXNzaW5nIGFueSBob3RwbHVnIGV2ZW50cyB3ZSByZWNlaXZl IHVudGlsIGl0J3Mgc2FmZS4KClRoaXMgZml4ZXMgdGhlIHdha2VyZWYgbGVhayBvYnNlcnZlZCBv biB0aGUgVDQ4MHMgYW5kIGFzIHN1Y2gsIGFsc28KZml4ZXMgc3VzcGVuZC9yZXN1bWUgd2l0aCBN U1QgdG9wb2xvZ2llcyBjb25uZWN0ZWQgb24gdGhpcyBtYWNoaW5lLgoKQ2hhbmdlcyBzaW5jZSB2 MjoKKiBEb24ndCBjYWxsIGRybV9mYl9oZWxwZXJfaG90cGx1Z19ldmVudCgpIHVuZGVyIGxvY2ss IGRvIGl0IGFmdGVyIGxvY2sKICAoQ2hyaXMgV2lsc29uKQoqIERvbid0IGNhbGwgZHJtX2ZiX2hl bHBlcl9ob3RwbHVnX2V2ZW50KCkgaW4KICBpbnRlbF9mYmRldl9vdXRwdXRfcG9sbF9jaGFuZ2Vk KCkgdW5kZXIgbG9jayAoQ2hyaXMgV2lsc29uKQoqIEFsd2F5cyBzZXQgaWZiZGV2LT5ocGRfd2Fp dGluZyAoQ2hyaXMgV2lsc29uKQoKU2lnbmVkLW9mZi1ieTogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVk aGF0LmNvbT4KRml4ZXM6IDBlMzJiMzljZWVkNiAoImRybS9pOTE1OiBhZGQgRFAgMS4yIE1TVCBz dXBwb3J0ICh2MC43KSIpCkNjOiBUb2RkIFByZXZpdGUgPHRwcmV2aXRlQGdtYWlsLmNvbT4KQ2M6 IERhdmUgQWlybGllIDxhaXJsaWVkQHJlZGhhdC5jb20+CkNjOiBKYW5pIE5pa3VsYSA8amFuaS5u aWt1bGFAbGludXguaW50ZWwuY29tPgpDYzogSm9vbmFzIExhaHRpbmVuIDxqb29uYXMubGFodGlu ZW5AbGludXguaW50ZWwuY29tPgpDYzogUm9kcmlnbyBWaXZpIDxyb2RyaWdvLnZpdmlAaW50ZWwu Y29tPgpDYzogSW1yZSBEZWFrIDxpbXJlLmRlYWtAaW50ZWwuY29tPgpDYzogaW50ZWwtZ2Z4QGxp c3RzLmZyZWVkZXNrdG9wLm9yZwpDYzogPHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmc+ICMgdjMuMTcr Ci0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICB8IDEwICsrKysrKysrKwog ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZmJkZXYuYyB8IDMzICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrLQogMiBmaWxlcyBjaGFuZ2VkLCA0MiBpbnNlcnRpb25zKCspLCAxIGRlbGV0 aW9uKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAppbmRleCA5MGJhNTQzNjM3MGUuLjllYzNk MDBmYmQxOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKKysr IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKQEAgLTIxMyw2ICsyMTMsMTYgQEAg c3RydWN0IGludGVsX2ZiZGV2IHsKIAl1bnNpZ25lZCBsb25nIHZtYV9mbGFnczsKIAlhc3luY19j b29raWVfdCBjb29raWU7CiAJaW50IHByZWZlcnJlZF9icHA7CisKKwkvKiBXaGV0aGVyIG9yIG5v dCBmYmRldiBocGQgcHJvY2Vzc2luZyBpcyB0ZW1wb3JhcmlseSBzdXNwZW5kZWQgKi8KKwlib29s IGhwZF9zdXNwZW5kZWQgOiAxOworCS8qIFNldCB3aGVuIGEgaG90cGx1ZyB3YXMgcmVjZWl2ZWQg d2hpbGUgSFBEIHByb2Nlc3Npbmcgd2FzCisJICogc3VzcGVuZGVkCisJICovCisJYm9vbCBocGRf d2FpdGluZyA6IDE7CisKKwkvKiBQcm90ZWN0cyBocGRfc3VzcGVuZGVkICovCisJc3RydWN0IG11 dGV4IGhwZF9sb2NrOwogfTsKIAogc3RydWN0IGludGVsX2VuY29kZXIgewpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZmJkZXYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2ZiZGV2LmMKaW5kZXggOGNmM2VmZTg4ZjAyLi4zNzZmZmU4NDJlMjYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiZGV2LmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZmJkZXYuYwpAQCAtNjgxLDYgKzY4MSw3IEBAIGludCBpbnRlbF9mYmRl dl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJaWYgKGlmYmRldiA9PSBOVUxMKQogCQly ZXR1cm4gLUVOT01FTTsKIAorCW11dGV4X2luaXQoJmlmYmRldi0+aHBkX2xvY2spOwogCWRybV9m Yl9oZWxwZXJfcHJlcGFyZShkZXYsICZpZmJkZXYtPmhlbHBlciwgJmludGVsX2ZiX2hlbHBlcl9m dW5jcyk7CiAKIAlpZiAoIWludGVsX2ZiZGV2X2luaXRfYmlvcyhkZXYsIGlmYmRldikpCkBAIC03 NTQsNiArNzU1LDI2IEBAIHZvaWQgaW50ZWxfZmJkZXZfZmluaShzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYpCiAJaW50ZWxfZmJkZXZfZGVzdHJveShpZmJkZXYpOwogfQogCisvKiBT dXNwZW5kcy9yZXN1bWVzIGZiZGV2IHByb2Nlc3Npbmcgb2YgaW5jb21pbmcgSFBEIGV2ZW50cy4g V2hlbiByZXN1bWluZyBIUEQKKyAqIHByb2Nlc3NpbmcsIGZiZGV2IHdpbGwgcGVyZm9ybSBhIGZ1 bGwgY29ubmVjdG9yIHJlcHJvYmUgaWYgYSBob3RwbHVnIGV2ZW50CisgKiB3YXMgcmVjZWl2ZWQg d2hpbGUgSFBEIHdhcyBzdXNwZW5kZWQuCisgKi8KK3N0YXRpYyB2b2lkIGludGVsX2ZiZGV2X2hw ZF9zZXRfc3VzcGVuZChzdHJ1Y3QgaW50ZWxfZmJkZXYgKmlmYmRldiwgaW50IHN0YXRlKQorewor CWJvb2wgc2VuZF9ocGQgPSBmYWxzZTsKKworCW11dGV4X2xvY2soJmlmYmRldi0+aHBkX2xvY2sp OworCWlmYmRldi0+aHBkX3N1c3BlbmRlZCA9IHN0YXRlID09IEZCSU5GT19TVEFURV9TVVNQRU5E RUQ7CisJc2VuZF9ocGQgPSAhaWZiZGV2LT5ocGRfc3VzcGVuZGVkICYmIGlmYmRldi0+aHBkX3dh aXRpbmc7CisJaWZiZGV2LT5ocGRfd2FpdGluZyA9IGZhbHNlOworCW11dGV4X3VubG9jaygmaWZi ZGV2LT5ocGRfbG9jayk7CisKKwlpZiAoc2VuZF9ocGQpIHsKKwkJRFJNX0RFQlVHX0tNUygiSGFu ZGxpbmcgZGVsYXllZCBmYmNvbiBIUEQgZXZlbnRcbiIpOworCQlkcm1fZmJfaGVscGVyX2hvdHBs dWdfZXZlbnQoJmlmYmRldi0+aGVscGVyKTsKKwl9Cit9CisKIHZvaWQgaW50ZWxfZmJkZXZfc2V0 X3N1c3BlbmQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgaW50IHN0YXRlLCBib29sIHN5bmNocm9u b3VzKQogewogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZGV2 KTsKQEAgLTc3NSw2ICs3OTYsNyBAQCB2b2lkIGludGVsX2ZiZGV2X3NldF9zdXNwZW5kKHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsIGludCBzdGF0ZSwgYm9vbCBzeW5jaHJvbm91cwogCQkgKi8KIAkJ aWYgKHN0YXRlICE9IEZCSU5GT19TVEFURV9SVU5OSU5HKQogCQkJZmx1c2hfd29yaygmZGV2X3By aXYtPmZiZGV2X3N1c3BlbmRfd29yayk7CisKIAkJY29uc29sZV9sb2NrKCk7CiAJfSBlbHNlIHsK IAkJLyoKQEAgLTgwMiwxNyArODI0LDI2IEBAIHZvaWQgaW50ZWxfZmJkZXZfc2V0X3N1c3BlbmQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgaW50IHN0YXRlLCBib29sIHN5bmNocm9ub3VzCiAKIAlk cm1fZmJfaGVscGVyX3NldF9zdXNwZW5kKCZpZmJkZXYtPmhlbHBlciwgc3RhdGUpOwogCWNvbnNv bGVfdW5sb2NrKCk7CisKKwlpbnRlbF9mYmRldl9ocGRfc2V0X3N1c3BlbmQoaWZiZGV2LCBzdGF0 ZSk7CiB9CiAKIHZvaWQgaW50ZWxfZmJkZXZfb3V0cHV0X3BvbGxfY2hhbmdlZChzdHJ1Y3QgZHJt X2RldmljZSAqZGV2KQogewogCXN0cnVjdCBpbnRlbF9mYmRldiAqaWZiZGV2ID0gdG9faTkxNShk ZXYpLT5mYmRldjsKKwlib29sIHNlbmRfaHBkOwogCiAJaWYgKCFpZmJkZXYpCiAJCXJldHVybjsK IAogCWludGVsX2ZiZGV2X3N5bmMoaWZiZGV2KTsKLQlpZiAoaWZiZGV2LT52bWEgfHwgaWZiZGV2 LT5oZWxwZXIuZGVmZXJyZWRfc2V0dXApCisKKwltdXRleF9sb2NrKCZpZmJkZXYtPmhwZF9sb2Nr KTsKKwlzZW5kX2hwZCA9ICFpZmJkZXYtPmhwZF9zdXNwZW5kZWQ7CisJaWZiZGV2LT5ocGRfd2Fp dGluZyA9IHRydWU7CisJbXV0ZXhfdW5sb2NrKCZpZmJkZXYtPmhwZF9sb2NrKTsKKworCWlmIChz ZW5kX2hwZCAmJiAoaWZiZGV2LT52bWEgfHwgaWZiZGV2LT5oZWxwZXIuZGVmZXJyZWRfc2V0dXAp KQogCQlkcm1fZmJfaGVscGVyX2hvdHBsdWdfZXZlbnQoJmlmYmRldi0+aGVscGVyKTsKIH0KIAot LSAKMi4yMC4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK 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=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED 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 A01F7C282C7 for ; Tue, 29 Jan 2019 19:10:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 728C62184D for ; Tue, 29 Jan 2019 19:10:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729374AbfA2TKZ (ORCPT ); Tue, 29 Jan 2019 14:10:25 -0500 Received: from mx1.redhat.com ([209.132.183.28]:33998 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727056AbfA2TKX (ORCPT ); Tue, 29 Jan 2019 14:10:23 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 73D94A7FC9; Tue, 29 Jan 2019 19:10:22 +0000 (UTC) Received: from malachite.bss.redhat.com (dhcp-10-20-1-11.bss.redhat.com [10.20.1.11]) by smtp.corp.redhat.com (Postfix) with ESMTP id 11E4F5C57C; Tue, 29 Jan 2019 19:10:20 +0000 (UTC) From: Lyude Paul To: intel-gfx@lists.freedesktop.org Cc: Chris Wilson , Todd Previte , Dave Airlie , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , Imre Deak , stable@vger.kernel.org, David Airlie , Daniel Vetter , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 1/3] drm/i915: Block fbdev HPD processing during suspend Date: Tue, 29 Jan 2019 14:09:59 -0500 Message-Id: <20190129191001.442-2-lyude@redhat.com> In-Reply-To: <20190129191001.442-1-lyude@redhat.com> References: <20190129191001.442-1-lyude@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.28]); Tue, 29 Jan 2019 19:10:22 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org When resuming, we check whether or not any previously connected MST topologies are still present and if so, attempt to resume them. If this fails, we disable said MST topologies and fire off a hotplug event so that userspace knows to reprobe. However, sending a hotplug event involves calling drm_fb_helper_hotplug_event(), which in turn results in fbcon doing a connector reprobe in the caller's thread - something we can't do at the point in which i915 calls drm_dp_mst_topology_mgr_resume() since hotplugging hasn't been fully initialized yet. This currently causes some rather subtle but fatal issues. For example, on my T480s the laptop dock connected to it usually disappears during a suspend cycle, and comes back up a short while after the system has been resumed. This guarantees pretty much every suspend and resume cycle, drm_dp_mst_topology_mgr_set_mst(mgr, false); will be caused and in turn, a connector hotplug will occur. Now it's Rute Goldberg time: when the connector hotplug occurs, i915 reprobes /all/ of the connectors, including eDP. However, eDP probing requires that we power on the panel VDD which in turn, grabs a wakeref to the appropriate power domain on the GPU (on my T480s, this is the PORT_DDI_A_IO domain). This is where things start breaking, since this all happens before intel_power_domains_enable() is called we end up leaking the wakeref that was acquired and never releasing it later. Come next suspend/resume cycle, this causes us to fail to shut down the GPU properly, which causes it not to resume properly and die a horrible complicated death. (as a note: this only happens when there's both an eDP panel and MST topology connected which is removed mid-suspend. One or the other seems to always be OK). We could try to fix the VDD wakeref leak, but this doesn't seem like it's worth it at all since we aren't able to handle hotplug detection while resuming anyway. So, let's go with a more robust solution inspired by nouveau: block fbdev from handling hotplug events until we resume fbdev. This allows us to still send sysfs hotplug events to be handled later by user space while we're resuming, while also preventing us from actually processing any hotplug events we receive until it's safe. This fixes the wakeref leak observed on the T480s and as such, also fixes suspend/resume with MST topologies connected on this machine. Changes since v2: * Don't call drm_fb_helper_hotplug_event() under lock, do it after lock (Chris Wilson) * Don't call drm_fb_helper_hotplug_event() in intel_fbdev_output_poll_changed() under lock (Chris Wilson) * Always set ifbdev->hpd_waiting (Chris Wilson) Signed-off-by: Lyude Paul Fixes: 0e32b39ceed6 ("drm/i915: add DP 1.2 MST support (v0.7)") Cc: Todd Previte Cc: Dave Airlie Cc: Jani Nikula Cc: Joonas Lahtinen Cc: Rodrigo Vivi Cc: Imre Deak Cc: intel-gfx@lists.freedesktop.org Cc: # v3.17+ --- drivers/gpu/drm/i915/intel_drv.h | 10 +++++++++ drivers/gpu/drm/i915/intel_fbdev.c | 33 +++++++++++++++++++++++++++++- 2 files changed, 42 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 90ba5436370e..9ec3d00fbd19 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -213,6 +213,16 @@ struct intel_fbdev { unsigned long vma_flags; async_cookie_t cookie; int preferred_bpp; + + /* Whether or not fbdev hpd processing is temporarily suspended */ + bool hpd_suspended : 1; + /* Set when a hotplug was received while HPD processing was + * suspended + */ + bool hpd_waiting : 1; + + /* Protects hpd_suspended */ + struct mutex hpd_lock; }; struct intel_encoder { diff --git a/drivers/gpu/drm/i915/intel_fbdev.c b/drivers/gpu/drm/i915/intel_fbdev.c index 8cf3efe88f02..376ffe842e26 100644 --- a/drivers/gpu/drm/i915/intel_fbdev.c +++ b/drivers/gpu/drm/i915/intel_fbdev.c @@ -681,6 +681,7 @@ int intel_fbdev_init(struct drm_device *dev) if (ifbdev == NULL) return -ENOMEM; + mutex_init(&ifbdev->hpd_lock); drm_fb_helper_prepare(dev, &ifbdev->helper, &intel_fb_helper_funcs); if (!intel_fbdev_init_bios(dev, ifbdev)) @@ -754,6 +755,26 @@ void intel_fbdev_fini(struct drm_i915_private *dev_priv) intel_fbdev_destroy(ifbdev); } +/* Suspends/resumes fbdev processing of incoming HPD events. When resuming HPD + * processing, fbdev will perform a full connector reprobe if a hotplug event + * was received while HPD was suspended. + */ +static void intel_fbdev_hpd_set_suspend(struct intel_fbdev *ifbdev, int state) +{ + bool send_hpd = false; + + mutex_lock(&ifbdev->hpd_lock); + ifbdev->hpd_suspended = state == FBINFO_STATE_SUSPENDED; + send_hpd = !ifbdev->hpd_suspended && ifbdev->hpd_waiting; + ifbdev->hpd_waiting = false; + mutex_unlock(&ifbdev->hpd_lock); + + if (send_hpd) { + DRM_DEBUG_KMS("Handling delayed fbcon HPD event\n"); + drm_fb_helper_hotplug_event(&ifbdev->helper); + } +} + void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous) { struct drm_i915_private *dev_priv = to_i915(dev); @@ -775,6 +796,7 @@ void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous */ if (state != FBINFO_STATE_RUNNING) flush_work(&dev_priv->fbdev_suspend_work); + console_lock(); } else { /* @@ -802,17 +824,26 @@ void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous drm_fb_helper_set_suspend(&ifbdev->helper, state); console_unlock(); + + intel_fbdev_hpd_set_suspend(ifbdev, state); } void intel_fbdev_output_poll_changed(struct drm_device *dev) { struct intel_fbdev *ifbdev = to_i915(dev)->fbdev; + bool send_hpd; if (!ifbdev) return; intel_fbdev_sync(ifbdev); - if (ifbdev->vma || ifbdev->helper.deferred_setup) + + mutex_lock(&ifbdev->hpd_lock); + send_hpd = !ifbdev->hpd_suspended; + ifbdev->hpd_waiting = true; + mutex_unlock(&ifbdev->hpd_lock); + + if (send_hpd && (ifbdev->vma || ifbdev->helper.deferred_setup)) drm_fb_helper_hotplug_event(&ifbdev->helper); } -- 2.20.1