From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [PATCH v2 1/3] drm/i915: Block fbdev HPD processing during suspend Date: Mon, 28 Jan 2019 15:56:01 -0500 Message-ID: <20190128205603.16372-2-lyude@redhat.com> References: <20190128205603.16372-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190128205603.16372-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 U1QgdG9wb2xvZ2llcyBjb25uZWN0ZWQgb24gdGhpcyBtYWNoaW5lLgoKU2lnbmVkLW9mZi1ieTog THl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4KRml4ZXM6IDBlMzJiMzljZWVkNiAoImRybS9p OTE1OiBhZGQgRFAgMS4yIE1TVCBzdXBwb3J0ICh2MC43KSIpCkNjOiBUb2RkIFByZXZpdGUgPHRw cmV2aXRlQGdtYWlsLmNvbT4KQ2M6IERhdmUgQWlybGllIDxhaXJsaWVkQHJlZGhhdC5jb20+CkNj OiBKYW5pIE5pa3VsYSA8amFuaS5uaWt1bGFAbGludXguaW50ZWwuY29tPgpDYzogSm9vbmFzIExh aHRpbmVuIDxqb29uYXMubGFodGluZW5AbGludXguaW50ZWwuY29tPgpDYzogUm9kcmlnbyBWaXZp IDxyb2RyaWdvLnZpdmlAaW50ZWwuY29tPgpDYzogSW1yZSBEZWFrIDxpbXJlLmRlYWtAaW50ZWwu Y29tPgpDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpDYzogPHN0YWJsZUB2Z2Vy Lmtlcm5lbC5vcmc+ICMgdjMuMTcrCi0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2 LmggICB8IDEwICsrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiZGV2LmMg fCAzMCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIDIgZmlsZXMgY2hhbmdlZCwgMzkg aW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKaW5k ZXggODViOTEzZWE2ZTgwLi5jODU0OTU4OGIyY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5o CkBAIC0yMTMsNiArMjEzLDE2IEBAIHN0cnVjdCBpbnRlbF9mYmRldiB7CiAJdW5zaWduZWQgbG9u ZyB2bWFfZmxhZ3M7CiAJYXN5bmNfY29va2llX3QgY29va2llOwogCWludCBwcmVmZXJyZWRfYnBw OworCisJLyogV2hldGhlciBvciBub3QgZmJkZXYgaHBkIHByb2Nlc3NpbmcgaXMgdGVtcG9yYXJp bHkgc3VzcGVuZGVkICovCisJYm9vbCBocGRfc3VzcGVuZGVkIDogMTsKKwkvKiBTZXQgd2hlbiBh IGhvdHBsdWcgd2FzIHJlY2VpdmVkIHdoaWxlIEhQRCBwcm9jZXNzaW5nIHdhcworCSAqIHN1c3Bl bmRlZAorCSAqLworCWJvb2wgaHBkX3dhaXRpbmcgOiAxOworCisJLyogUHJvdGVjdHMgaHBkX3N1 c3BlbmRlZCAqLworCXN0cnVjdCBtdXRleCBocGRfbG9jazsKIH07CiAKIHN0cnVjdCBpbnRlbF9l bmNvZGVyIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiZGV2LmMg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYmRldi5jCmluZGV4IDhjZjNlZmU4OGYwMi4u M2E2YzBiZWJhYWY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYmRl di5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiZGV2LmMKQEAgLTY4MSw2ICs2 ODEsNyBAQCBpbnQgaW50ZWxfZmJkZXZfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCWlm IChpZmJkZXYgPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9NRU07CiAKKwltdXRleF9pbml0KCZpZmJk ZXYtPmhwZF9sb2NrKTsKIAlkcm1fZmJfaGVscGVyX3ByZXBhcmUoZGV2LCAmaWZiZGV2LT5oZWxw ZXIsICZpbnRlbF9mYl9oZWxwZXJfZnVuY3MpOwogCiAJaWYgKCFpbnRlbF9mYmRldl9pbml0X2Jp b3MoZGV2LCBpZmJkZXYpKQpAQCAtNzU0LDYgKzc1NSwyMyBAQCB2b2lkIGludGVsX2ZiZGV2X2Zp bmkoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCWludGVsX2ZiZGV2X2Rlc3Ry b3koaWZiZGV2KTsKIH0KIAorLyogU3VzcGVuZHMvcmVzdW1lcyBmYmRldiBwcm9jZXNzaW5nIG9m IGluY29taW5nIEhQRCBldmVudHMuIFdoZW4gcmVzdW1pbmcgSFBECisgKiBwcm9jZXNzaW5nLCBm YmRldiB3aWxsIHBlcmZvcm0gYSBmdWxsIGNvbm5lY3RvciByZXByb2JlIGlmIGEgaG90cGx1ZyBl dmVudAorICogd2FzIHJlY2VpdmVkIHdoaWxlIEhQRCB3YXMgc3VzcGVuZGVkLgorICovCitzdGF0 aWMgdm9pZCBpbnRlbF9mYmRldl9ocGRfc2V0X3N1c3BlbmQoc3RydWN0IGludGVsX2ZiZGV2ICpp ZmJkZXYsIGludCBzdGF0ZSkKK3sKKwltdXRleF9sb2NrKCZpZmJkZXYtPmhwZF9sb2NrKTsKKwlp ZmJkZXYtPmhwZF9zdXNwZW5kZWQgPSBzdGF0ZSA9PSBGQklORk9fU1RBVEVfU1VTUEVOREVEOwor CWlmIChpZmJkZXYtPmhwZF93YWl0aW5nKSB7CisJCWlmYmRldi0+aHBkX3dhaXRpbmcgPSBmYWxz ZTsKKworCQlEUk1fREVCVUdfS01TKCJIYW5kbGluZyBkZWxheWVkIGZiY29uIEhQRCBldmVudFxu Iik7CisJCWRybV9mYl9oZWxwZXJfaG90cGx1Z19ldmVudCgmaWZiZGV2LT5oZWxwZXIpOworCX0K KwltdXRleF91bmxvY2soJmlmYmRldi0+aHBkX2xvY2spOworfQorCiB2b2lkIGludGVsX2ZiZGV2 X3NldF9zdXNwZW5kKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBzdGF0ZSwgYm9vbCBzeW5j aHJvbm91cykKIHsKIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1 KGRldik7CkBAIC03NzUsNiArNzkzLDcgQEAgdm9pZCBpbnRlbF9mYmRldl9zZXRfc3VzcGVuZChz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgc3RhdGUsIGJvb2wgc3luY2hyb25vdXMKIAkJICov CiAJCWlmIChzdGF0ZSAhPSBGQklORk9fU1RBVEVfUlVOTklORykKIAkJCWZsdXNoX3dvcmsoJmRl dl9wcml2LT5mYmRldl9zdXNwZW5kX3dvcmspOworCiAJCWNvbnNvbGVfbG9jaygpOwogCX0gZWxz ZSB7CiAJCS8qCkBAIC04MDIsNiArODIxLDggQEAgdm9pZCBpbnRlbF9mYmRldl9zZXRfc3VzcGVu ZChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgc3RhdGUsIGJvb2wgc3luY2hyb25vdXMKIAog CWRybV9mYl9oZWxwZXJfc2V0X3N1c3BlbmQoJmlmYmRldi0+aGVscGVyLCBzdGF0ZSk7CiAJY29u c29sZV91bmxvY2soKTsKKworCWludGVsX2ZiZGV2X2hwZF9zZXRfc3VzcGVuZChpZmJkZXYsIHN0 YXRlKTsKIH0KIAogdm9pZCBpbnRlbF9mYmRldl9vdXRwdXRfcG9sbF9jaGFuZ2VkKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYpCkBAIC04MTIsOCArODMzLDE1IEBAIHZvaWQgaW50ZWxfZmJkZXZfb3V0 cHV0X3BvbGxfY2hhbmdlZChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCQlyZXR1cm47CiAKIAlp bnRlbF9mYmRldl9zeW5jKGlmYmRldik7Ci0JaWYgKGlmYmRldi0+dm1hIHx8IGlmYmRldi0+aGVs cGVyLmRlZmVycmVkX3NldHVwKQorCisJbXV0ZXhfbG9jaygmaWZiZGV2LT5ocGRfbG9jayk7CisJ aWYgKGlmYmRldi0+aHBkX3N1c3BlbmRlZCkgeworCQlEUk1fREVCVUdfS01TKCJmYmRldiBIUEQg ZXZlbnQgZGVmZXJyZWQgdW50aWwgcmVzdW1lXG4iKTsKKwkJaWZiZGV2LT5ocGRfd2FpdGluZyA9 IHRydWU7CisJfSBlbHNlIGlmIChpZmJkZXYtPnZtYSB8fCBpZmJkZXYtPmhlbHBlci5kZWZlcnJl ZF9zZXR1cCkgewogCQlkcm1fZmJfaGVscGVyX2hvdHBsdWdfZXZlbnQoJmlmYmRldi0+aGVscGVy KTsKKwl9CisJbXV0ZXhfdW5sb2NrKCZpZmJkZXYtPmhwZF9sb2NrKTsKIH0KIAogdm9pZCBpbnRl bF9mYmRldl9yZXN0b3JlX21vZGUoc3RydWN0IGRybV9kZXZpY2UgKmRldikKLS0gCjIuMjAuMQoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4 IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== 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 53A11C282C8 for ; Mon, 28 Jan 2019 20:56:31 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 2168F2175B for ; Mon, 28 Jan 2019 20:56:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728387AbfA1U4U (ORCPT ); Mon, 28 Jan 2019 15:56:20 -0500 Received: from mx1.redhat.com ([209.132.183.28]:58994 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726765AbfA1U4S (ORCPT ); Mon, 28 Jan 2019 15:56:18 -0500 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id EF21980F7D; Mon, 28 Jan 2019 20:56:17 +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 A21B55D73F; Mon, 28 Jan 2019 20:56:16 +0000 (UTC) From: Lyude Paul To: intel-gfx@lists.freedesktop.org Cc: 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 v2 1/3] drm/i915: Block fbdev HPD processing during suspend Date: Mon, 28 Jan 2019 15:56:01 -0500 Message-Id: <20190128205603.16372-2-lyude@redhat.com> In-Reply-To: <20190128205603.16372-1-lyude@redhat.com> References: <20190128205603.16372-1-lyude@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.27]); Mon, 28 Jan 2019 20:56:18 +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. 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 | 30 +++++++++++++++++++++++++++++- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 85b913ea6e80..c8549588b2ce 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..3a6c0bebaaf9 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,23 @@ 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) +{ + mutex_lock(&ifbdev->hpd_lock); + ifbdev->hpd_suspended = state == FBINFO_STATE_SUSPENDED; + if (ifbdev->hpd_waiting) { + ifbdev->hpd_waiting = false; + + DRM_DEBUG_KMS("Handling delayed fbcon HPD event\n"); + drm_fb_helper_hotplug_event(&ifbdev->helper); + } + mutex_unlock(&ifbdev->hpd_lock); +} + void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous) { struct drm_i915_private *dev_priv = to_i915(dev); @@ -775,6 +793,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,6 +821,8 @@ 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) @@ -812,8 +833,15 @@ void intel_fbdev_output_poll_changed(struct drm_device *dev) return; intel_fbdev_sync(ifbdev); - if (ifbdev->vma || ifbdev->helper.deferred_setup) + + mutex_lock(&ifbdev->hpd_lock); + if (ifbdev->hpd_suspended) { + DRM_DEBUG_KMS("fbdev HPD event deferred until resume\n"); + ifbdev->hpd_waiting = true; + } else if (ifbdev->vma || ifbdev->helper.deferred_setup) { drm_fb_helper_hotplug_event(&ifbdev->helper); + } + mutex_unlock(&ifbdev->hpd_lock); } void intel_fbdev_restore_mode(struct drm_device *dev) -- 2.20.1