From mboxrd@z Thu Jan 1 00:00:00 1970 From: Greg Kroah-Hartman Subject: [PATCH 4.19 83/85] drm/i915: Block fbdev HPD processing during suspend Date: Mon, 18 Feb 2019 14:43:49 +0100 Message-ID: <20190218133507.978524940@linuxfoundation.org> References: <20190218133459.758004711@linuxfoundation.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by gabe.freedesktop.org (Postfix) with ESMTPS id 0CC5F8918F for ; Mon, 18 Feb 2019 13:54:05 +0000 (UTC) In-Reply-To: <20190218133459.758004711@linuxfoundation.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: linux-kernel@vger.kernel.org Cc: Todd Previte , Jani Nikula , Greg Kroah-Hartman , stable@vger.kernel.org, Dave Airlie , intel-gfx@lists.freedesktop.org List-Id: intel-gfx@lists.freedesktop.org NC4xOS1zdGFibGUgcmV2aWV3IHBhdGNoLiAgSWYgYW55b25lIGhhcyBhbnkgb2JqZWN0aW9ucywg cGxlYXNlIGxldCBtZSBrbm93LgoKLS0tLS0tLS0tLS0tLS0tLS0tCgpGcm9tOiBMeXVkZSBQYXVs IDxseXVkZUByZWRoYXQuY29tPgoKY29tbWl0IGU4YThmZWRkNTdmZGNlYmYwZTRmMjRlZjBmYzdl MjkzMjNkZjhlNjYgdXBzdHJlYW0uCgpXaGVuIHJlc3VtaW5nLCB3ZSBjaGVjayB3aGV0aGVyIG9y IG5vdCBhbnkgcHJldmlvdXNseSBjb25uZWN0ZWQKTVNUIHRvcG9sb2dpZXMgYXJlIHN0aWxsIHBy ZXNlbnQgYW5kIGlmIHNvLCBhdHRlbXB0IHRvIHJlc3VtZSB0aGVtLiBJZgp0aGlzIGZhaWxzLCB3 ZSBkaXNhYmxlIHNhaWQgTVNUIHRvcG9sb2dpZXMgYW5kIGZpcmUgb2ZmIGEgaG90cGx1ZyBldmVu dApzbyB0aGF0IHVzZXJzcGFjZSBrbm93cyB0byByZXByb2JlLgoKSG93ZXZlciwgc2VuZGluZyBh IGhvdHBsdWcgZXZlbnQgaW52b2x2ZXMgY2FsbGluZwpkcm1fZmJfaGVscGVyX2hvdHBsdWdfZXZl bnQoKSwgd2hpY2ggaW4gdHVybiByZXN1bHRzIGluIGZiY29uIGRvaW5nIGEKY29ubmVjdG9yIHJl cHJvYmUgaW4gdGhlIGNhbGxlcidzIHRocmVhZCAtIHNvbWV0aGluZyB3ZSBjYW4ndCBkbyBhdCB0 aGUKcG9pbnQgaW4gd2hpY2ggaTkxNSBjYWxscyBkcm1fZHBfbXN0X3RvcG9sb2d5X21ncl9yZXN1 bWUoKSBzaW5jZQpob3RwbHVnZ2luZyBoYXNuJ3QgYmVlbiBmdWxseSBpbml0aWFsaXplZCB5ZXQu CgpUaGlzIGN1cnJlbnRseSBjYXVzZXMgc29tZSByYXRoZXIgc3VidGxlIGJ1dCBmYXRhbCBpc3N1 ZXMuIEZvciBleGFtcGxlLApvbiBteSBUNDgwcyB0aGUgbGFwdG9wIGRvY2sgY29ubmVjdGVkIHRv IGl0IHVzdWFsbHkgZGlzYXBwZWFycyBkdXJpbmcgYQpzdXNwZW5kIGN5Y2xlLCBhbmQgY29tZXMg YmFjayB1cCBhIHNob3J0IHdoaWxlIGFmdGVyIHRoZSBzeXN0ZW0gaGFzIGJlZW4KcmVzdW1lZC4g VGhpcyBndWFyYW50ZWVzIHByZXR0eSBtdWNoIGV2ZXJ5IHN1c3BlbmQgYW5kIHJlc3VtZSBjeWNs ZSwKZHJtX2RwX21zdF90b3BvbG9neV9tZ3Jfc2V0X21zdChtZ3IsIGZhbHNlKTsgd2lsbCBiZSBj YXVzZWQgYW5kIGluIHR1cm4sCmEgY29ubmVjdG9yIGhvdHBsdWcgd2lsbCBvY2N1ci4gTm93IGl0 J3MgUnV0ZSBHb2xkYmVyZyB0aW1lOiB3aGVuIHRoZQpjb25uZWN0b3IgaG90cGx1ZyBvY2N1cnMs IGk5MTUgcmVwcm9iZXMgL2FsbC8gb2YgdGhlIGNvbm5lY3RvcnMsCmluY2x1ZGluZyBlRFAuIEhv d2V2ZXIsIGVEUCBwcm9iaW5nIHJlcXVpcmVzIHRoYXQgd2UgcG93ZXIgb24gdGhlIHBhbmVsClZE RCB3aGljaCBpbiB0dXJuLCBncmFicyBhIHdha2VyZWYgdG8gdGhlIGFwcHJvcHJpYXRlIHBvd2Vy IGRvbWFpbiBvbgp0aGUgR1BVIChvbiBteSBUNDgwcywgdGhpcyBpcyB0aGUgUE9SVF9ERElfQV9J TyBkb21haW4pLiBUaGlzIGlzIHdoZXJlCnRoaW5ncyBzdGFydCBicmVha2luZywgc2luY2UgdGhp cyBhbGwgaGFwcGVucyBiZWZvcmUKaW50ZWxfcG93ZXJfZG9tYWluc19lbmFibGUoKSBpcyBjYWxs ZWQgd2UgZW5kIHVwIGxlYWtpbmcgdGhlIHdha2VyZWYKdGhhdCB3YXMgYWNxdWlyZWQgYW5kIG5l dmVyIHJlbGVhc2luZyBpdCBsYXRlci4gQ29tZSBuZXh0IHN1c3BlbmQvcmVzdW1lCmN5Y2xlLCB0 aGlzIGNhdXNlcyB1cyB0byBmYWlsIHRvIHNodXQgZG93biB0aGUgR1BVIHByb3Blcmx5LCB3aGlj aApjYXVzZXMgaXQgbm90IHRvIHJlc3VtZSBwcm9wZXJseSBhbmQgZGllIGEgaG9ycmlibGUgY29t cGxpY2F0ZWQgZGVhdGguCgooYXMgYSBub3RlOiB0aGlzIG9ubHkgaGFwcGVucyB3aGVuIHRoZXJl J3MgYm90aCBhbiBlRFAgcGFuZWwgYW5kIE1TVAp0b3BvbG9neSBjb25uZWN0ZWQgd2hpY2ggaXMg cmVtb3ZlZCBtaWQtc3VzcGVuZC4gT25lIG9yIHRoZSBvdGhlciBzZWVtcwp0byBhbHdheXMgYmUg T0spLgoKV2UgY291bGQgdHJ5IHRvIGZpeCB0aGUgVkREIHdha2VyZWYgbGVhaywgYnV0IHRoaXMg ZG9lc24ndCBzZWVtIGxpa2UKaXQncyB3b3J0aCBpdCBhdCBhbGwgc2luY2Ugd2UgYXJlbid0IGFi bGUgdG8gaGFuZGxlIGhvdHBsdWcgZGV0ZWN0aW9uCndoaWxlIHJlc3VtaW5nIGFueXdheS4gU28s IGxldCdzIGdvIHdpdGggYSBtb3JlIHJvYnVzdCBzb2x1dGlvbiBpbnNwaXJlZApieSBub3V2ZWF1 OiBibG9jayBmYmRldiBmcm9tIGhhbmRsaW5nIGhvdHBsdWcgZXZlbnRzIHVudGlsIHdlIHJlc3Vt ZQpmYmRldi4gVGhpcyBhbGxvd3MgdXMgdG8gc3RpbGwgc2VuZCBzeXNmcyBob3RwbHVnIGV2ZW50 cyB0byBiZSBoYW5kbGVkCmxhdGVyIGJ5IHVzZXIgc3BhY2Ugd2hpbGUgd2UncmUgcmVzdW1pbmcs IHdoaWxlIGFsc28gcHJldmVudGluZyB1cyBmcm9tCmFjdHVhbGx5IHByb2Nlc3NpbmcgYW55IGhv dHBsdWcgZXZlbnRzIHdlIHJlY2VpdmUgdW50aWwgaXQncyBzYWZlLgoKVGhpcyBmaXhlcyB0aGUg d2FrZXJlZiBsZWFrIG9ic2VydmVkIG9uIHRoZSBUNDgwcyBhbmQgYXMgc3VjaCwgYWxzbwpmaXhl cyBzdXNwZW5kL3Jlc3VtZSB3aXRoIE1TVCB0b3BvbG9naWVzIGNvbm5lY3RlZCBvbiB0aGlzIG1h Y2hpbmUuCgpDaGFuZ2VzIHNpbmNlIHYyOgoqIERvbid0IGNhbGwgZHJtX2ZiX2hlbHBlcl9ob3Rw bHVnX2V2ZW50KCkgdW5kZXIgbG9jaywgZG8gaXQgYWZ0ZXIgbG9jawogIChDaHJpcyBXaWxzb24p CiogRG9uJ3QgY2FsbCBkcm1fZmJfaGVscGVyX2hvdHBsdWdfZXZlbnQoKSBpbgogIGludGVsX2Zi ZGV2X291dHB1dF9wb2xsX2NoYW5nZWQoKSB1bmRlciBsb2NrIChDaHJpcyBXaWxzb24pCiogQWx3 YXlzIHNldCBpZmJkZXYtPmhwZF93YWl0aW5nIChDaHJpcyBXaWxzb24pCgpTaWduZWQtb2ZmLWJ5 OiBMeXVkZSBQYXVsIDxseXVkZUByZWRoYXQuY29tPgpGaXhlczogMGUzMmIzOWNlZWQ2ICgiZHJt L2k5MTU6IGFkZCBEUCAxLjIgTVNUIHN1cHBvcnQgKHYwLjcpIikKQ2M6IFRvZGQgUHJldml0ZSA8 dHByZXZpdGVAZ21haWwuY29tPgpDYzogRGF2ZSBBaXJsaWUgPGFpcmxpZWRAcmVkaGF0LmNvbT4K Q2M6IEphbmkgTmlrdWxhIDxqYW5pLm5pa3VsYUBsaW51eC5pbnRlbC5jb20+CkNjOiBKb29uYXMg TGFodGluZW4gPGpvb25hcy5sYWh0aW5lbkBsaW51eC5pbnRlbC5jb20+CkNjOiBSb2RyaWdvIFZp dmkgPHJvZHJpZ28udml2aUBpbnRlbC5jb20+CkNjOiBJbXJlIERlYWsgPGltcmUuZGVha0BpbnRl bC5jb20+CkNjOiBpbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCkNjOiA8c3RhYmxlQHZn ZXIua2VybmVsLm9yZz4gIyB2My4xNysKUmV2aWV3ZWQtYnk6IENocmlzIFdpbHNvbiA8Y2hyaXNA Y2hyaXMtd2lsc29uLmNvLnVrPgpMaW5rOiBodHRwczovL3BhdGNod29yay5mcmVlZGVza3RvcC5v cmcvcGF0Y2gvbXNnaWQvMjAxOTAxMjkxOTEwMDEuNDQyLTItbHl1ZGVAcmVkaGF0LmNvbQooY2hl cnJ5IHBpY2tlZCBmcm9tIGNvbW1pdCBmZTVlYzY1NjY4Y2RhYTQzNDg2MzFkOGNlMTc2NmVlZDQz YjMzYzEwKQpTaWduZWQtb2ZmLWJ5OiBKYW5pIE5pa3VsYSA8amFuaS5uaWt1bGFAaW50ZWwuY29t PgpTaWduZWQtb2ZmLWJ5OiBHcmVnIEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRp b24ub3JnPgoKLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCAgIHwgICAxMCAr KysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYmRldi5jIHwgICAzMyArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIDIgZmlsZXMgY2hhbmdlZCwgNDIgaW5zZXJ0 aW9ucygrKSwgMSBkZWxldGlvbigtKQoKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf ZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKQEAgLTIwOSw2ICsy MDksMTYgQEAgc3RydWN0IGludGVsX2ZiZGV2IHsKIAl1bnNpZ25lZCBsb25nIHZtYV9mbGFnczsK IAlhc3luY19jb29raWVfdCBjb29raWU7CiAJaW50IHByZWZlcnJlZF9icHA7CisKKwkvKiBXaGV0 aGVyIG9yIG5vdCBmYmRldiBocGQgcHJvY2Vzc2luZyBpcyB0ZW1wb3JhcmlseSBzdXNwZW5kZWQg Ki8KKwlib29sIGhwZF9zdXNwZW5kZWQgOiAxOworCS8qIFNldCB3aGVuIGEgaG90cGx1ZyB3YXMg cmVjZWl2ZWQgd2hpbGUgSFBEIHByb2Nlc3Npbmcgd2FzCisJICogc3VzcGVuZGVkCisJICovCisJ Ym9vbCBocGRfd2FpdGluZyA6IDE7CisKKwkvKiBQcm90ZWN0cyBocGRfc3VzcGVuZGVkICovCisJ c3RydWN0IG11dGV4IGhwZF9sb2NrOwogfTsKIAogc3RydWN0IGludGVsX2VuY29kZXIgewotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYmRldi5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2ZiZGV2LmMKQEAgLTY3Nyw2ICs2NzcsNyBAQCBpbnQgaW50ZWxfZmJkZXZf aW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqCiAJaWYgKGlmYmRldiA9PSBOVUxMKQogCQlyZXR1cm4g LUVOT01FTTsKIAorCW11dGV4X2luaXQoJmlmYmRldi0+aHBkX2xvY2spOwogCWRybV9mYl9oZWxw ZXJfcHJlcGFyZShkZXYsICZpZmJkZXYtPmhlbHBlciwgJmludGVsX2ZiX2hlbHBlcl9mdW5jcyk7 CiAKIAlpZiAoIWludGVsX2ZiZGV2X2luaXRfYmlvcyhkZXYsIGlmYmRldikpCkBAIC03NTAsNiAr NzUxLDI2IEBAIHZvaWQgaW50ZWxfZmJkZXZfZmluaShzdHJ1Y3QgZHJtX2k5MTVfcHIKIAlpbnRl bF9mYmRldl9kZXN0cm95KGlmYmRldik7CiB9CiAKKy8qIFN1c3BlbmRzL3Jlc3VtZXMgZmJkZXYg cHJvY2Vzc2luZyBvZiBpbmNvbWluZyBIUEQgZXZlbnRzLiBXaGVuIHJlc3VtaW5nIEhQRAorICog cHJvY2Vzc2luZywgZmJkZXYgd2lsbCBwZXJmb3JtIGEgZnVsbCBjb25uZWN0b3IgcmVwcm9iZSBp ZiBhIGhvdHBsdWcgZXZlbnQKKyAqIHdhcyByZWNlaXZlZCB3aGlsZSBIUEQgd2FzIHN1c3BlbmRl ZC4KKyAqLworc3RhdGljIHZvaWQgaW50ZWxfZmJkZXZfaHBkX3NldF9zdXNwZW5kKHN0cnVjdCBp bnRlbF9mYmRldiAqaWZiZGV2LCBpbnQgc3RhdGUpCit7CisJYm9vbCBzZW5kX2hwZCA9IGZhbHNl OworCisJbXV0ZXhfbG9jaygmaWZiZGV2LT5ocGRfbG9jayk7CisJaWZiZGV2LT5ocGRfc3VzcGVu ZGVkID0gc3RhdGUgPT0gRkJJTkZPX1NUQVRFX1NVU1BFTkRFRDsKKwlzZW5kX2hwZCA9ICFpZmJk ZXYtPmhwZF9zdXNwZW5kZWQgJiYgaWZiZGV2LT5ocGRfd2FpdGluZzsKKwlpZmJkZXYtPmhwZF93 YWl0aW5nID0gZmFsc2U7CisJbXV0ZXhfdW5sb2NrKCZpZmJkZXYtPmhwZF9sb2NrKTsKKworCWlm IChzZW5kX2hwZCkgeworCQlEUk1fREVCVUdfS01TKCJIYW5kbGluZyBkZWxheWVkIGZiY29uIEhQ RCBldmVudFxuIik7CisJCWRybV9mYl9oZWxwZXJfaG90cGx1Z19ldmVudCgmaWZiZGV2LT5oZWxw ZXIpOworCX0KK30KKwogdm9pZCBpbnRlbF9mYmRldl9zZXRfc3VzcGVuZChzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LCBpbnQgc3RhdGUsIGJvb2wgc3luY2hyb25vdXMpCiB7CiAJc3RydWN0IGRybV9p OTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShkZXYpOwpAQCAtNzcxLDYgKzc5Miw3IEBA IHZvaWQgaW50ZWxfZmJkZXZfc2V0X3N1c3BlbmQoc3RydWN0IGRybV8KIAkJICovCiAJCWlmIChz dGF0ZSAhPSBGQklORk9fU1RBVEVfUlVOTklORykKIAkJCWZsdXNoX3dvcmsoJmRldl9wcml2LT5m YmRldl9zdXNwZW5kX3dvcmspOworCiAJCWNvbnNvbGVfbG9jaygpOwogCX0gZWxzZSB7CiAJCS8q CkBAIC03OTgsMTcgKzgyMCwyNiBAQCB2b2lkIGludGVsX2ZiZGV2X3NldF9zdXNwZW5kKHN0cnVj dCBkcm1fCiAKIAlkcm1fZmJfaGVscGVyX3NldF9zdXNwZW5kKCZpZmJkZXYtPmhlbHBlciwgc3Rh dGUpOwogCWNvbnNvbGVfdW5sb2NrKCk7CisKKwlpbnRlbF9mYmRldl9ocGRfc2V0X3N1c3BlbmQo aWZiZGV2LCBzdGF0ZSk7CiB9CiAKIHZvaWQgaW50ZWxfZmJkZXZfb3V0cHV0X3BvbGxfY2hhbmdl ZChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogewogCXN0cnVjdCBpbnRlbF9mYmRldiAqaWZiZGV2 ID0gdG9faTkxNShkZXYpLT5mYmRldjsKKwlib29sIHNlbmRfaHBkOwogCiAJaWYgKCFpZmJkZXYp CiAJCXJldHVybjsKIAogCWludGVsX2ZiZGV2X3N5bmMoaWZiZGV2KTsKLQlpZiAoaWZiZGV2LT52 bWEgfHwgaWZiZGV2LT5oZWxwZXIuZGVmZXJyZWRfc2V0dXApCisKKwltdXRleF9sb2NrKCZpZmJk ZXYtPmhwZF9sb2NrKTsKKwlzZW5kX2hwZCA9ICFpZmJkZXYtPmhwZF9zdXNwZW5kZWQ7CisJaWZi ZGV2LT5ocGRfd2FpdGluZyA9IHRydWU7CisJbXV0ZXhfdW5sb2NrKCZpZmJkZXYtPmhwZF9sb2Nr KTsKKworCWlmIChzZW5kX2hwZCAmJiAoaWZiZGV2LT52bWEgfHwgaWZiZGV2LT5oZWxwZXIuZGVm ZXJyZWRfc2V0dXApKQogCQlkcm1fZmJfaGVscGVyX2hvdHBsdWdfZXZlbnQoJmlmYmRldi0+aGVs cGVyKTsKIH0KIAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdm eA== 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=-6.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,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 E583CC43381 for ; Mon, 18 Feb 2019 14:38:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id ABBA121736 for ; Mon, 18 Feb 2019 14:38:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1550500722; bh=zocM1cHJfFUYoJZswMYq0A23vrhfouBPCinwcXXdNbM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=Y2og7b61T4gyFt3xfi9KrQ3tfqigF26DoXspjW5Pu2IgHDRG+Xd+yj3OzT+MhGIO1 /F/3eqXrfr8IZktlRBQPg2KJ6fCDIfOTbgCFVYWl7BXphcBJZdaKqCEUWWfPPX1iY6 VWoTX+hA1qduLYNq6ZSCIL3y5OHNm5tUT0f9ayyA= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387517AbfBROil (ORCPT ); Mon, 18 Feb 2019 09:38:41 -0500 Received: from mail.kernel.org ([198.145.29.99]:33946 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1733103AbfBRNyG (ORCPT ); Mon, 18 Feb 2019 08:54:06 -0500 Received: from localhost (5356596B.cm-6-7b.dynamic.ziggo.nl [83.86.89.107]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 655BF2077B; Mon, 18 Feb 2019 13:54:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1550498044; bh=zocM1cHJfFUYoJZswMYq0A23vrhfouBPCinwcXXdNbM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=SfVXZu8J1EenjzDAIbHw6v7Ju4q0gen7tvH9X+e0k2UETX9xz0DvQf/Z7DfXgNQQB BV8VwNZBGupOce2LBUum5anNsmS7SgZmZaoD6VXktrpe7MI2djx/En3LL+g9t1osbq iHhD34yH1XjEWrNp6w/h7XFC6Gj09qGw+scW4Q1A= From: Greg Kroah-Hartman To: linux-kernel@vger.kernel.org Cc: Greg Kroah-Hartman , stable@vger.kernel.org, Lyude Paul , Todd Previte , Dave Airlie , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , Imre Deak , intel-gfx@lists.freedesktop.org, Chris Wilson , Jani Nikula Subject: [PATCH 4.19 83/85] drm/i915: Block fbdev HPD processing during suspend Date: Mon, 18 Feb 2019 14:43:49 +0100 Message-Id: <20190218133507.978524940@linuxfoundation.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190218133459.758004711@linuxfoundation.org> References: <20190218133459.758004711@linuxfoundation.org> User-Agent: quilt/0.65 X-stable: review X-Patchwork-Hint: ignore MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 4.19-stable review patch. If anyone has any objections, please let me know. ------------------ From: Lyude Paul commit e8a8fedd57fdcebf0e4f24ef0fc7e29323df8e66 upstream. 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+ Reviewed-by: Chris Wilson Link: https://patchwork.freedesktop.org/patch/msgid/20190129191001.442-2-lyude@redhat.com (cherry picked from commit fe5ec65668cdaa4348631d8ce1766eed43b33c10) Signed-off-by: Jani Nikula Signed-off-by: Greg Kroah-Hartman --- drivers/gpu/drm/i915/intel_drv.h | 10 ++++++++++ drivers/gpu/drm/i915/intel_fbdev.c | 33 ++++++++++++++++++++++++++++++++- 2 files changed, 42 insertions(+), 1 deletion(-) --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -209,6 +209,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 { --- a/drivers/gpu/drm/i915/intel_fbdev.c +++ b/drivers/gpu/drm/i915/intel_fbdev.c @@ -677,6 +677,7 @@ int intel_fbdev_init(struct drm_device * 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)) @@ -750,6 +751,26 @@ void intel_fbdev_fini(struct drm_i915_pr 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); @@ -771,6 +792,7 @@ void intel_fbdev_set_suspend(struct drm_ */ if (state != FBINFO_STATE_RUNNING) flush_work(&dev_priv->fbdev_suspend_work); + console_lock(); } else { /* @@ -798,17 +820,26 @@ void intel_fbdev_set_suspend(struct drm_ 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); }