From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: Re: [PATCH v2 3/3] drm/i915: Enable polling when we don't have hpd Date: Mon, 20 Jun 2016 16:59:14 -0400 Message-ID: <1466456354.2198.1.camel@redhat.com> References: <1466456253-30493-1-git-send-email-cpaul@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1466456253-30493-1-git-send-email-cpaul@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, Daniel Vetter , Ville =?ISO-8859-1?Q?Syrj=E4l=E4?= Cc: David Airlie , Daniel Vetter , "open list:INTEL DRM DRIVERS (excluding Poulsbo, Moorestow...), linux-kernel@vger.kernel.org (open list)" , stable@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org QXMgYSBmb3Jld2FybmluZzogSSBoYXZlIGNvbmZpcm1lZCB0aGUgQ1JUIGhwZCBsb29wcyBWc3ly amFsYSBoYXMgbWVudGlvbmVkLCBhbmQKdGhleSBhcmUgdHJpZ2dlcmVkIGJ5IHRoaXMgcGF0Y2gu IEknbSB3b3JraW5nIG9uIGEgcGF0Y2ggZm9yIHRoaXMgYXRtLgoKT24gTW9uLCAyMDE2LTA2LTIw IGF0IDE2OjU3IC0wNDAwLCBMeXVkZSB3cm90ZToKPiBVbmZvcnR1bmF0ZWx5LCB0aGVyZSdzIHR3 byBzaXR1YXRpb25zIHdoZXJlIHdlIGxvc2UgaHBkIHJpZ2h0IG5vdzoKPiAtIFJ1bnRpbWUgc3Vz cGVuZAo+IC0gV2hlbiB3ZSd2ZSBzaHV0IG9mZiBhbGwgb2YgdGhlIHBvd2VyIHdlbGxzIG9uIFZh bGxleXZpZXcvQ2hlcnJ5dmlldwo+IAo+IFdoaWxlIGl0IHdvdWxkIGJlIG5pY2UgaWYgdGhpcyBk aWRuJ3QgY2F1c2UgaXNzdWVzLCB0aGlzIGhhcyB0aGUKPiBhYmlsaXR5IHRvIGdldCB1cyBpbiBz b21lIGF3a3dhcmQgc3RhdGVzIHdoZXJlIGEgdXNlciB3b24ndCBiZSBhYmxlIHRvCj4gZ2V0IHRo ZWlyIGRpc3BsYXkgdG8gdHVybiBvbi4gRm9yIGluc3RhbmNlOyBpZiB3ZSBib290IGEgVmFsbGV5 dmlldwo+IHN5c3RlbSB3aXRob3V0IGFueSBtb25pdG9ycyBjb25uZWN0ZWQsIGl0IHdvbid0IG5l ZWQgYW55IG9mIGl0J3MgcG93ZXIKPiB3ZWxscyBhbmQgdGh1cyBzaHV0IHRoZW0gb2ZmLiBTaW5j ZSB0aGlzIGNhdXNlcyB1cyB0byBsb3NlIEhQRCwgdGhpcwo+IG1lYW5zIHRoYXQgdW5sZXNzIHRo ZSB1c2VyIGtub3dzIGhvdyB0byBzc2ggaW50byB0aGVpciBtYWNoaW5lIGFuZCBkbyBhCj4gbWFu dWFsIHJlcHJvYmUgZm9yIG1vbml0b3JzLCBub25lIG9mIHRoZSBtb25pdG9ycyB0aGV5IGNvbm5l Y3QgYWZ0ZXIKPiBib290aW5nIHdpbGwgYWN0dWFsbHkgd29yay4KPiAKPiBFdmVudHVhbGx5IHdl IHNob3VsZCBjb21lIHVwIHdpdGggYSBiZXR0ZXIgZml4IHRoZW4gaGF2aW5nIHRvIGVuYWJsZQo+ IHBvbGxpbmcgZm9yIHRoaXMsIHNpbmNlIHRoaXMgbWFrZXMgcnBtIGEgbG90IGxlc3MgdXNlZnVs LCBidXQgZm9yIG5vdwo+IHRoZSBpbmZyYXN0cnVjdHVyZSBpbiBpOTE1IGp1c3QgaXNuJ3QgdGhl cmUgeWV0IHRvIGdldCBocGQgaW4gdGhlc2UKPiBzaXR1YXRpb25zLgo+IAo+IENoYW5nZXMgc2lu Y2UgdjE6Cj4gwqAtIEFkZCBjb21tZW50IGV4cGxhaW5pbmcgdGhlIGFkZGl0aW9uIG9mIHRoZSBp Zgo+IMKgwqDCoCghbW9kZV9jb25maWctPnBvbGxfcnVubmluZykgaW4gaW50ZWxfaHBkX2luaXQo KQo+IMKgLSBSZW1vdmUgdW5uZWVkZWQgaWYgKCFkZXYtPm1vZGVfY29uZmlnLnBvbGxfZW5hYmxl ZCkgaW4KPiDCoMKgwqBpOTE1X2hwZF9wb2xsX2luaXRfd29yaygpCj4gwqAtIENhbGwgdG8gZHJt X2hlbHBlcl9ocGRfaXJxX2V2ZW50KCkgYWZ0ZXIgd2UgZGlzYWJsZSBwb2xsaW5nCj4gwqAtIEFk ZCBjYW5jZWxfd29ya19zeW5jKCkgY2FsbCB0byBpbnRlbF9ocGRfY2FuY2VsX3dvcmsoKQo+IAo+ IENjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCj4gQ2M6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUu c3lyamFsYUBsaW51eC5pbnRlbC5jb20+Cj4gQWNrZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmll bC52ZXR0ZXJAZmZ3bGwuY2g+Cj4gU2lnbmVkLW9mZi1ieTogTHl1ZGUgPGNwYXVsQHJlZGhhdC5j b20+Cj4gLS0tCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jwqDCoMKgwqDCoMKg wqDCoMKgfMKgwqA3ICsrLQo+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaMKgwqDC oMKgwqDCoMKgwqDCoHzCoMKgMyArKwo+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2 LmjCoMKgwqDCoMKgwqDCoMKgfMKgwqAyICsKPiDCoGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2hvdHBsdWcuY8KgwqDCoMKgfCA4MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLQo+ IC0KPiDCoGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3J1bnRpbWVfcG0uYyB8wqDCoDMgKysK PiDCoDUgZmlsZXMgY2hhbmdlZCwgODYgaW5zZXJ0aW9ucygrKSwgMTEgZGVsZXRpb25zKC0pCj4g Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCj4gaW5kZXggM2ViNDdmYi4uNTM4MWQ5ZSAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCj4gKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9kcnYuYwo+IEBAIC0xNjEyLDYgKzE2MTIsOSBAQCBzdGF0aWMgaW50 IGludGVsX3J1bnRpbWVfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXZpY2UpCj4gwqAKPiDCoAlh c3NlcnRfZm9yY2V3YWtlc19pbmFjdGl2ZShkZXZfcHJpdik7Cj4gwqAKPiArCWlmICghSVNfVkFM TEVZVklFVyhkZXZfcHJpdikgfHwgIUlTX0NIRVJSWVZJRVcoZGV2X3ByaXYpKQo+ICsJCWludGVs X2hwZF9wb2xsX2VuYWJsZShkZXZfcHJpdiwgdHJ1ZSk7Cj4gKwo+IMKgCURSTV9ERUJVR19LTVMo IkRldmljZSBzdXNwZW5kZWRcbiIpOwo+IMKgCXJldHVybiAwOwo+IMKgfQo+IEBAIC0xNjY3LDgg KzE2NzAsMTAgQEAgc3RhdGljIGludCBpbnRlbF9ydW50aW1lX3Jlc3VtZShzdHJ1Y3QgZGV2aWNl ICpkZXZpY2UpCj4gwqAJwqAqIHBvd2VyIHdlbGwsIHNvIGhwZCBpcyByZWluaXRpYWxpemVkIGZy b20gdGhlcmUuIEZvcgo+IMKgCcKgKiBldmVyeW9uZSBlbHNlIGRvIGl0IGhlcmUuCj4gwqAJwqAq Lwo+IC0JaWYgKCFJU19WQUxMRVlWSUVXKGRldl9wcml2KSAmJiAhSVNfQ0hFUlJZVklFVyhkZXZf cHJpdikpCj4gKwlpZiAoIUlTX1ZBTExFWVZJRVcoZGV2X3ByaXYpICYmICFJU19DSEVSUllWSUVX KGRldl9wcml2KSkgewo+IMKgCQlpbnRlbF9ocGRfaW5pdChkZXZfcHJpdik7Cj4gKwkJaW50ZWxf aHBkX3BvbGxfZW5hYmxlKGRldl9wcml2LCBmYWxzZSk7Cj4gKwl9Cj4gwqAKPiDCoAlpbnRlbF9l bmFibGVfZ3RfcG93ZXJzYXZlKGRldl9wcml2KTsKPiDCoAo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYu aAo+IGluZGV4IDFlZWY1ZWYuLjZmNzA3NWQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV9kcnYuaAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgK PiBAQCAtMjgzLDYgKzI4Myw5IEBAIHN0cnVjdCBpOTE1X2hvdHBsdWcgewo+IMKgCXUzMiBzaG9y dF9wb3J0X21hc2s7Cj4gwqAJc3RydWN0IHdvcmtfc3RydWN0IGRpZ19wb3J0X3dvcms7Cj4gwqAK PiArCXN0cnVjdCB3b3JrX3N0cnVjdCBwb2xsX2VuYWJsZV93b3JrOwo+ICsJYm9vbCBwb2xsX2Vu YWJsZWQ7Cj4gKwo+IMKgCS8qCj4gwqAJwqAqIGlmIHdlIGdldCBhIEhQRCBpcnEgZnJvbSBEUCBh bmQgYSBIUEQgaXJxIGZyb20gbm9uLURQCj4gwqAJwqAqIHRoZSBub24tRFAgSFBEIGNvdWxkIGJs b2NrIHRoZSB3b3JrcXVldWUgb24gYSBtb2RlIGNvbmZpZwo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf ZHJ2LmgKPiBpbmRleCBjZDE0NzUxLi44N2M1MTQzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf ZHJ2LmgKPiBAQCAtMTM4NCw2ICsxMzg0LDggQEAgaW50IGludGVsX2RzaV9kY3NfaW5pdF9iYWNr bGlnaHRfZnVuY3Moc3RydWN0Cj4gaW50ZWxfY29ubmVjdG9yICppbnRlbF9jb25uZWN0b3IpOwo+ IMKgCj4gwqAvKiBpbnRlbF9kdm8uYyAqLwo+IMKgdm9pZCBpbnRlbF9kdm9faW5pdChzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2KTsKPiArLyogaW50ZWxfaG90cGx1Zy5jICovCj4gK3ZvaWQgaW50ZWxf aHBkX3BvbGxfZW5hYmxlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgYm9vbCBl bmFibGVkKTsKPiDCoAo+IMKgCj4gwqAvKiBsZWdhY3kgZmJkZXYgZW11bGF0aW9uIGluIGludGVs X2ZiZGV2LmMgKi8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaG90 cGx1Zy5jCj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9ob3RwbHVnLmMKPiBpbmRleCBl YzMyODVmLi4zZWY1MDk2IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2hvdHBsdWcuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYwo+ IEBAIC00NjQsMjAgKzQ2NCwzNCBAQCB2b2lkIGludGVsX2hwZF9pbml0KHN0cnVjdCBkcm1faTkx NV9wcml2YXRlICpkZXZfcHJpdikKPiDCoAkJZGV2X3ByaXYtPmhvdHBsdWcuc3RhdHNbaV0uY291 bnQgPSAwOwo+IMKgCQlkZXZfcHJpdi0+aG90cGx1Zy5zdGF0c1tpXS5zdGF0ZSA9IEhQRF9FTkFC TEVEOwo+IMKgCX0KPiAtCWxpc3RfZm9yX2VhY2hfZW50cnkoY29ubmVjdG9yLCAmbW9kZV9jb25m aWctPmNvbm5lY3Rvcl9saXN0LCBoZWFkKSB7Cj4gLQkJc3RydWN0IGludGVsX2Nvbm5lY3RvciAq aW50ZWxfY29ubmVjdG9yID0KPiB0b19pbnRlbF9jb25uZWN0b3IoY29ubmVjdG9yKTsKPiAtCQlj b25uZWN0b3ItPnBvbGxlZCA9IGludGVsX2Nvbm5lY3Rvci0+cG9sbGVkOwo+IMKgCj4gLQkJLyog TVNUIGhhcyBhIGR5bmFtaWMgaW50ZWxfY29ubmVjdG9yLT5lbmNvZGVyIGFuZCBpdCdzCj4gcmVw cm9iaW5nCj4gLQkJwqAqIGlzIGFsbCBoYW5kbGVkIGJ5IHRoZSBNU1QgaGVscGVycy4gKi8KPiAt CQlpZiAoaW50ZWxfY29ubmVjdG9yLT5tc3RfcG9ydCkKPiAtCQkJY29udGludWU7Cj4gKwkvKgo+ ICsJwqAqIFdoZW4gd2UncmUgaW4gdGhlIG1pZHN0IG9mIGRvaW5nIGNvbm5lY3RvciBwb2xsaW5n IGluIHNpdHVhdGlvbnMKPiArCcKgKiB3aGVyZSB3ZSBkb24ndCBoYXZlIHdvcmtpbmcgaHBkLCB3 ZSBuZWVkIHRvIG1ha2Ugc3VyZSB3ZSBkb24ndCB0cnkKPiArCcKgKiBjaGFuZ2luZyB0aGUgcG9s bGluZyBzZXR0aW5ncyBvZiBhbnkgY29ubmVjdG9ycywgc2luY2UgdGhpcyBjYW4KPiBsZWFkCj4g KwnCoCogdG8gdXMgc2V0dGluZyBjb25uZWN0b3ItPnBvbGxlZCB0byBEUk1fQ09OTkVDVE9SX1BP TExfSFBELAo+IHJlc3VsdGluZwo+ICsJwqAqIGluIERSTSdzIHBvbGxpbmcgaGVscGVycyBhdXRv bWF0aWNhbGx5IHNraXBwaW5nIHRoZSByZXN0IG9mIHRoZQo+ICsJwqAqIGNvbm5lY3RvcnMgdGhh dCBzdGlsbCBuZWVkIHBvbGxpbmcKPiArCcKgKi8KPiArCWlmICghbW9kZV9jb25maWctPnBvbGxf cnVubmluZykgewo+ICsJCWxpc3RfZm9yX2VhY2hfZW50cnkoY29ubmVjdG9yLCAmbW9kZV9jb25m aWctPmNvbm5lY3Rvcl9saXN0LAo+IGhlYWQpIHsKPiArCQkJc3RydWN0IGludGVsX2Nvbm5lY3Rv ciAqaW50ZWxfY29ubmVjdG9yID0KPiArCQkJCXRvX2ludGVsX2Nvbm5lY3Rvcihjb25uZWN0b3Ip Owo+ICsJCQljb25uZWN0b3ItPnBvbGxlZCA9IGludGVsX2Nvbm5lY3Rvci0+cG9sbGVkOwo+IMKg Cj4gLQkJaWYgKCFjb25uZWN0b3ItPnBvbGxlZCAmJiBJOTE1X0hBU19IT1RQTFVHKGRldikgJiYK PiAtCQnCoMKgwqDCoGludGVsX2Nvbm5lY3Rvci0+ZW5jb2Rlci0+aHBkX3BpbiA+IEhQRF9OT05F KQo+IC0JCQljb25uZWN0b3ItPnBvbGxlZCA9IERSTV9DT05ORUNUT1JfUE9MTF9IUEQ7Cj4gKwkJ CS8qIE1TVCBoYXMgYSBkeW5hbWljIGludGVsX2Nvbm5lY3Rvci0+ZW5jb2RlciBhbmQKPiBpdCdz Cj4gKwkJCcKgKiByZXByb2JpbmcgaXMgYWxsIGhhbmRsZWQgYnkgdGhlIE1TVCBoZWxwZXJzLiAq Lwo+ICsJCQlpZiAoaW50ZWxfY29ubmVjdG9yLT5tc3RfcG9ydCkKPiArCQkJCWNvbnRpbnVlOwo+ ICsKPiArCQkJaWYgKCFjb25uZWN0b3ItPnBvbGxlZCAmJiBJOTE1X0hBU19IT1RQTFVHKGRldikg JiYKPiArCQkJwqDCoMKgwqBpbnRlbF9jb25uZWN0b3ItPmVuY29kZXItPmhwZF9waW4gPiBIUERf Tk9ORSkKPiArCQkJCWNvbm5lY3Rvci0+cG9sbGVkID0gRFJNX0NPTk5FQ1RPUl9QT0xMX0hQRDsK PiArCQl9Cj4gwqAJfQo+IMKgCj4gKwlpbnRlbF9ocGRfcG9sbF9lbmFibGUoZGV2X3ByaXYsIGZh bHNlKTsKPiArCj4gwqAJLyoKPiDCoAnCoCogSW50ZXJydXB0IHNldHVwIGlzIGFscmVhZHkgZ3Vh cmFudGVlZCB0byBiZSBzaW5nbGUtdGhyZWFkZWQsIHRoaXMKPiBpcwo+IMKgCcKgKiBqdXN0IHRv IG1ha2UgdGhlIGFzc2VydF9zcGluX2xvY2tlZCBjaGVja3MgaGFwcHkuCj4gQEAgLTQ4OCwxMCAr NTAyLDU3IEBAIHZvaWQgaW50ZWxfaHBkX2luaXQoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRl dl9wcml2KQo+IMKgCXNwaW5fdW5sb2NrX2lycSgmZGV2X3ByaXYtPmlycV9sb2NrKTsKPiDCoH0K PiDCoAo+ICt2b2lkIGk5MTVfaHBkX3BvbGxfaW5pdF93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAq d29yaykgewo+ICsJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0KPiArCQljb250 YWluZXJfb2Yod29yaywgc3RydWN0IGRybV9pOTE1X3ByaXZhdGUsCj4gKwkJCcKgwqDCoMKgwqBo b3RwbHVnLnBvbGxfZW5hYmxlX3dvcmspOwo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGRl dl9wcml2LT5kZXY7Cj4gKwlzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICppbnRlbF9jb25uZWN0b3I7 Cj4gKwo+ICsJbXV0ZXhfbG9jaygmZGV2LT5tb2RlX2NvbmZpZy5tdXRleCk7Cj4gKwo+ICsJZm9y X2VhY2hfaW50ZWxfY29ubmVjdG9yKGRldiwgaW50ZWxfY29ubmVjdG9yKSB7Cj4gKwkJc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciA9ICZpbnRlbF9jb25uZWN0b3ItPmJhc2U7Cj4gKwo+ ICsJCWlmIChkZXZfcHJpdi0+aG90cGx1Zy5wb2xsX2VuYWJsZWQpIHsKPiArCQkJY29ubmVjdG9y LT5wb2xsZWQgPSBEUk1fQ09OTkVDVE9SX1BPTExfQ09OTkVDVCB8Cj4gKwkJCQlEUk1fQ09OTkVD VE9SX1BPTExfRElTQ09OTkVDVDsKPiArCj4gKwkJfSBlbHNlIGlmICghaW50ZWxfY29ubmVjdG9y LT5wb2xsZWQgJiYgSTkxNV9IQVNfSE9UUExVRyhkZXYpCj4gJiYKPiArCQkJwqDCoMKgaW50ZWxf Y29ubmVjdG9yLT5lbmNvZGVyLT5ocGRfcGluID4gSFBEX05PTkUpIHsKPiArCQkJY29ubmVjdG9y LT5wb2xsZWQgPSBEUk1fQ09OTkVDVE9SX1BPTExfSFBEOwo+ICsJCX0KPiArCX0KPiArCj4gKwlp ZiAoZGV2X3ByaXYtPmhvdHBsdWcucG9sbF9lbmFibGVkKQo+ICsJCWRybV9rbXNfaGVscGVyX3Bv bGxfZW5hYmxlX2xvY2tlZChkZXYpOwo+ICsKPiArCW11dGV4X3VubG9jaygmZGV2LT5tb2RlX2Nv bmZpZy5tdXRleCk7Cj4gKwo+ICsJLyoKPiArCcKgKiBXZSBtaWdodCBoYXZlIG1pc3NlZCBhbnkg aG90cGx1Z3MgdGhhdCBoYXBwZW5lZCB3aGlsZSB3ZSB3ZXJlCj4gKwnCoCogaW4gdGhlIG1pZGRs ZSBvZiBkaXNhYmxpbmcgcG9sbGluZwo+ICsJwqAqLwo+ICsJaWYgKCFkZXZfcHJpdi0+aG90cGx1 Zy5wb2xsX2VuYWJsZWQpCj4gKwkJZHJtX2hlbHBlcl9ocGRfaXJxX2V2ZW50KGRldik7Cj4gK30K PiArCj4gK3ZvaWQgaW50ZWxfaHBkX3BvbGxfZW5hYmxlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdiwgYm9vbCBlbmFibGVkKQo+ICt7Cj4gKwlkZXZfcHJpdi0+aG90cGx1Zy5wb2xs X2VuYWJsZWQgPSBlbmFibGVkOwo+ICsKPiArCS8qCj4gKwnCoCogV2UgbWlnaHQgYWxyZWFkeSBi ZSBob2xkaW5nIGRldi0+bW9kZV9jb25maWcubXV0ZXgsIHNvIGRvIHRoaXMgaW4KPiBhCj4gKwnC oCogc2VwZXJhdGUgd29ya2VyCj4gKwnCoCovCj4gKwlzY2hlZHVsZV93b3JrKCZkZXZfcHJpdi0+ aG90cGx1Zy5wb2xsX2VuYWJsZV93b3JrKTsKPiArfQo+ICsKPiDCoHZvaWQgaW50ZWxfaHBkX2lu aXRfd29yayhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCj4gwqB7Cj4gwqAJSU5J VF9XT1JLKCZkZXZfcHJpdi0+aG90cGx1Zy5ob3RwbHVnX3dvcmssIGk5MTVfaG90cGx1Z193b3Jr X2Z1bmMpOwo+IMKgCUlOSVRfV09SSygmZGV2X3ByaXYtPmhvdHBsdWcuZGlnX3BvcnRfd29yaywg aTkxNV9kaWdwb3J0X3dvcmtfZnVuYyk7Cj4gKwlJTklUX1dPUksoJmRldl9wcml2LT5ob3RwbHVn LnBvbGxfZW5hYmxlX3dvcmssCj4gaTkxNV9ocGRfcG9sbF9pbml0X3dvcmspOwo+IMKgCUlOSVRf REVMQVlFRF9XT1JLKCZkZXZfcHJpdi0+aG90cGx1Zy5yZWVuYWJsZV93b3JrLAo+IMKgCQkJwqDC oGludGVsX2hwZF9pcnFfc3Rvcm1fcmVlbmFibGVfd29yayk7Cj4gwqB9Cj4gQEAgLTUwOCw2ICs1 NjksNyBAQCB2b2lkIGludGVsX2hwZF9jYW5jZWxfd29yayhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0 ZQo+ICpkZXZfcHJpdikKPiDCoAo+IMKgCWNhbmNlbF93b3JrX3N5bmMoJmRldl9wcml2LT5ob3Rw bHVnLmRpZ19wb3J0X3dvcmspOwo+IMKgCWNhbmNlbF93b3JrX3N5bmMoJmRldl9wcml2LT5ob3Rw bHVnLmhvdHBsdWdfd29yayk7Cj4gKwljYW5jZWxfd29ya19zeW5jKCZkZXZfcHJpdi0+aG90cGx1 Zy5wb2xsX2VuYWJsZV93b3JrKTsKPiDCoAljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmRldl9w cml2LT5ob3RwbHVnLnJlZW5hYmxlX3dvcmspOwo+IMKgfQo+IMKgCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3J1bnRpbWVfcG0uYwo+IGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfcnVudGltZV9wbS5jCj4gaW5kZXggNmYzZDAxOS4uNTkyY2I3ZCAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9ydW50aW1lX3BtLmMKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9ydW50aW1lX3BtLmMKPiBAQCAtMTA5OSw2ICsxMDk5 LDcgQEAgc3RhdGljIHZvaWQgdmx2X2Rpc3BsYXlfcG93ZXJfd2VsbF9pbml0KHN0cnVjdAo+IGRy bV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQo+IMKgCWlmIChkZXZfcHJpdi0+cG93ZXJfZG9tYWlu cy5pbml0aWFsaXppbmcpCj4gwqAJCXJldHVybjsKPiDCoAo+ICsJaW50ZWxfaHBkX3BvbGxfZW5h YmxlKGRldl9wcml2LCBmYWxzZSk7Cj4gwqAJaW50ZWxfaHBkX2luaXQoZGV2X3ByaXYpOwo+IMKg Cj4gwqAJLyogUmUtZW5hYmxlIHRoZSBBRFBBLCBpZiB3ZSBoYXZlIG9uZSAqLwo+IEBAIC0xMTIw LDYgKzExMjEsOCBAQCBzdGF0aWMgdm9pZCB2bHZfZGlzcGxheV9wb3dlcl93ZWxsX2RlaW5pdChz dHJ1Y3QKPiBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKPiDCoAlzeW5jaHJvbml6ZV9pcnEo ZGV2X3ByaXYtPmRldi0+aXJxKTsKPiDCoAo+IMKgCXZsdl9wb3dlcl9zZXF1ZW5jZXJfcmVzZXQo ZGV2X3ByaXYpOwo+ICsKPiArCWludGVsX2hwZF9wb2xsX2VuYWJsZShkZXZfcHJpdiwgdHJ1ZSk7 Cj4gwqB9Cj4gwqAKPiDCoHN0YXRpYyB2b2lkIHZsdl9kaXNwbGF5X3Bvd2VyX3dlbGxfZW5hYmxl KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKLS0gCkNoZWVycywKCUx5dWRlCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZngg bWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0 cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx1.redhat.com ([209.132.183.28]:44482 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754870AbcFTVAC (ORCPT ); Mon, 20 Jun 2016 17:00:02 -0400 Message-ID: <1466456354.2198.1.camel@redhat.com> Subject: Re: [PATCH v2 3/3] drm/i915: Enable polling when we don't have hpd From: Lyude Paul To: intel-gfx@lists.freedesktop.org, Daniel Vetter , Ville =?ISO-8859-1?Q?Syrj=E4l=E4?= Cc: stable@vger.kernel.org, Daniel Vetter , Jani Nikula , David Airlie , "open list:INTEL DRM DRIVERS (excluding Poulsbo, Moorestow...), " "linux-kernel@vger.kernel.org (open list)" Date: Mon, 20 Jun 2016 16:59:14 -0400 In-Reply-To: <1466456253-30493-1-git-send-email-cpaul@redhat.com> References: <1466456253-30493-1-git-send-email-cpaul@redhat.com> Content-Type: text/plain; charset="UTF-8" Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: stable-owner@vger.kernel.org List-ID: As a forewarning: I have confirmed the CRT hpd loops Vsyrjala has mentioned, and they are triggered by this patch. I'm working on a patch for this atm. On Mon, 2016-06-20 at 16:57 -0400, Lyude wrote: > Unfortunately, there's two situations where we lose hpd right now: > - Runtime suspend > - When we've shut off all of the power wells on Valleyview/Cherryview > > While it would be nice if this didn't cause issues, this has the > ability to get us in some awkward states where a user won't be able to > get their display to turn on. For instance; if we boot a Valleyview > system without any monitors connected, it won't need any of it's power > wells and thus shut them off. Since this causes us to lose HPD, this > means that unless the user knows how to ssh into their machine and do a > manual reprobe for monitors, none of the monitors they connect after > booting will actually work. > > Eventually we should come up with a better fix then having to enable > polling for this, since this makes rpm a lot less useful, but for now > the infrastructure in i915 just isn't there yet to get hpd in these > situations. > > Changes since v1: >  - Add comment explaining the addition of the if >    (!mode_config->poll_running) in intel_hpd_init() >  - Remove unneeded if (!dev->mode_config.poll_enabled) in >    i915_hpd_poll_init_work() >  - Call to drm_helper_hpd_irq_event() after we disable polling >  - Add cancel_work_sync() call to intel_hpd_cancel_work() > > Cc: stable@vger.kernel.org > Cc: Ville Syrjälä > Acked-by: Daniel Vetter > Signed-off-by: Lyude > --- >  drivers/gpu/drm/i915/i915_drv.c         |  7 ++- >  drivers/gpu/drm/i915/i915_drv.h         |  3 ++ >  drivers/gpu/drm/i915/intel_drv.h        |  2 + >  drivers/gpu/drm/i915/intel_hotplug.c    | 82 +++++++++++++++++++++++++++++--- > - >  drivers/gpu/drm/i915/intel_runtime_pm.c |  3 ++ >  5 files changed, 86 insertions(+), 11 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c > index 3eb47fb..5381d9e 100644 > --- a/drivers/gpu/drm/i915/i915_drv.c > +++ b/drivers/gpu/drm/i915/i915_drv.c > @@ -1612,6 +1612,9 @@ static int intel_runtime_suspend(struct device *device) >   >   assert_forcewakes_inactive(dev_priv); >   > + if (!IS_VALLEYVIEW(dev_priv) || !IS_CHERRYVIEW(dev_priv)) > + intel_hpd_poll_enable(dev_priv, true); > + >   DRM_DEBUG_KMS("Device suspended\n"); >   return 0; >  } > @@ -1667,8 +1670,10 @@ static int intel_runtime_resume(struct device *device) >    * power well, so hpd is reinitialized from there. For >    * everyone else do it here. >    */ > - if (!IS_VALLEYVIEW(dev_priv) && !IS_CHERRYVIEW(dev_priv)) > + if (!IS_VALLEYVIEW(dev_priv) && !IS_CHERRYVIEW(dev_priv)) { >   intel_hpd_init(dev_priv); > + intel_hpd_poll_enable(dev_priv, false); > + } >   >   intel_enable_gt_powersave(dev_priv); >   > diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h > index 1eef5ef..6f7075d 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -283,6 +283,9 @@ struct i915_hotplug { >   u32 short_port_mask; >   struct work_struct dig_port_work; >   > + struct work_struct poll_enable_work; > + bool poll_enabled; > + >   /* >    * if we get a HPD irq from DP and a HPD irq from non-DP >    * the non-DP HPD could block the workqueue on a mode config > diff --git a/drivers/gpu/drm/i915/intel_drv.h > b/drivers/gpu/drm/i915/intel_drv.h > index cd14751..87c5143 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -1384,6 +1384,8 @@ int intel_dsi_dcs_init_backlight_funcs(struct > intel_connector *intel_connector); >   >  /* intel_dvo.c */ >  void intel_dvo_init(struct drm_device *dev); > +/* intel_hotplug.c */ > +void intel_hpd_poll_enable(struct drm_i915_private *dev_priv, bool enabled); >   >   >  /* legacy fbdev emulation in intel_fbdev.c */ > diff --git a/drivers/gpu/drm/i915/intel_hotplug.c > b/drivers/gpu/drm/i915/intel_hotplug.c > index ec3285f..3ef5096 100644 > --- a/drivers/gpu/drm/i915/intel_hotplug.c > +++ b/drivers/gpu/drm/i915/intel_hotplug.c > @@ -464,20 +464,34 @@ void intel_hpd_init(struct drm_i915_private *dev_priv) >   dev_priv->hotplug.stats[i].count = 0; >   dev_priv->hotplug.stats[i].state = HPD_ENABLED; >   } > - list_for_each_entry(connector, &mode_config->connector_list, head) { > - struct intel_connector *intel_connector = > to_intel_connector(connector); > - connector->polled = intel_connector->polled; >   > - /* MST has a dynamic intel_connector->encoder and it's > reprobing > -  * is all handled by the MST helpers. */ > - if (intel_connector->mst_port) > - continue; > + /* > +  * When we're in the midst of doing connector polling in situations > +  * where we don't have working hpd, we need to make sure we don't try > +  * changing the polling settings of any connectors, since this can > lead > +  * to us setting connector->polled to DRM_CONNECTOR_POLL_HPD, > resulting > +  * in DRM's polling helpers automatically skipping the rest of the > +  * connectors that still need polling > +  */ > + if (!mode_config->poll_running) { > + list_for_each_entry(connector, &mode_config->connector_list, > head) { > + struct intel_connector *intel_connector = > + to_intel_connector(connector); > + connector->polled = intel_connector->polled; >   > - if (!connector->polled && I915_HAS_HOTPLUG(dev) && > -     intel_connector->encoder->hpd_pin > HPD_NONE) > - connector->polled = DRM_CONNECTOR_POLL_HPD; > + /* MST has a dynamic intel_connector->encoder and > it's > +  * reprobing is all handled by the MST helpers. */ > + if (intel_connector->mst_port) > + continue; > + > + if (!connector->polled && I915_HAS_HOTPLUG(dev) && > +     intel_connector->encoder->hpd_pin > HPD_NONE) > + connector->polled = DRM_CONNECTOR_POLL_HPD; > + } >   } >   > + intel_hpd_poll_enable(dev_priv, false); > + >   /* >    * Interrupt setup is already guaranteed to be single-threaded, this > is >    * just to make the assert_spin_locked checks happy. > @@ -488,10 +502,57 @@ void intel_hpd_init(struct drm_i915_private *dev_priv) >   spin_unlock_irq(&dev_priv->irq_lock); >  } >   > +void i915_hpd_poll_init_work(struct work_struct *work) { > + struct drm_i915_private *dev_priv = > + container_of(work, struct drm_i915_private, > +      hotplug.poll_enable_work); > + struct drm_device *dev = dev_priv->dev; > + struct intel_connector *intel_connector; > + > + mutex_lock(&dev->mode_config.mutex); > + > + for_each_intel_connector(dev, intel_connector) { > + struct drm_connector *connector = &intel_connector->base; > + > + if (dev_priv->hotplug.poll_enabled) { > + connector->polled = DRM_CONNECTOR_POLL_CONNECT | > + DRM_CONNECTOR_POLL_DISCONNECT; > + > + } else if (!intel_connector->polled && I915_HAS_HOTPLUG(dev) > && > +    intel_connector->encoder->hpd_pin > HPD_NONE) { > + connector->polled = DRM_CONNECTOR_POLL_HPD; > + } > + } > + > + if (dev_priv->hotplug.poll_enabled) > + drm_kms_helper_poll_enable_locked(dev); > + > + mutex_unlock(&dev->mode_config.mutex); > + > + /* > +  * We might have missed any hotplugs that happened while we were > +  * in the middle of disabling polling > +  */ > + if (!dev_priv->hotplug.poll_enabled) > + drm_helper_hpd_irq_event(dev); > +} > + > +void intel_hpd_poll_enable(struct drm_i915_private *dev_priv, bool enabled) > +{ > + dev_priv->hotplug.poll_enabled = enabled; > + > + /* > +  * We might already be holding dev->mode_config.mutex, so do this in > a > +  * seperate worker > +  */ > + schedule_work(&dev_priv->hotplug.poll_enable_work); > +} > + >  void intel_hpd_init_work(struct drm_i915_private *dev_priv) >  { >   INIT_WORK(&dev_priv->hotplug.hotplug_work, i915_hotplug_work_func); >   INIT_WORK(&dev_priv->hotplug.dig_port_work, i915_digport_work_func); > + INIT_WORK(&dev_priv->hotplug.poll_enable_work, > i915_hpd_poll_init_work); >   INIT_DELAYED_WORK(&dev_priv->hotplug.reenable_work, >     intel_hpd_irq_storm_reenable_work); >  } > @@ -508,6 +569,7 @@ void intel_hpd_cancel_work(struct drm_i915_private > *dev_priv) >   >   cancel_work_sync(&dev_priv->hotplug.dig_port_work); >   cancel_work_sync(&dev_priv->hotplug.hotplug_work); > + cancel_work_sync(&dev_priv->hotplug.poll_enable_work); >   cancel_delayed_work_sync(&dev_priv->hotplug.reenable_work); >  } >   > diff --git a/drivers/gpu/drm/i915/intel_runtime_pm.c > b/drivers/gpu/drm/i915/intel_runtime_pm.c > index 6f3d019..592cb7d 100644 > --- a/drivers/gpu/drm/i915/intel_runtime_pm.c > +++ b/drivers/gpu/drm/i915/intel_runtime_pm.c > @@ -1099,6 +1099,7 @@ static void vlv_display_power_well_init(struct > drm_i915_private *dev_priv) >   if (dev_priv->power_domains.initializing) >   return; >   > + intel_hpd_poll_enable(dev_priv, false); >   intel_hpd_init(dev_priv); >   >   /* Re-enable the ADPA, if we have one */ > @@ -1120,6 +1121,8 @@ static void vlv_display_power_well_deinit(struct > drm_i915_private *dev_priv) >   synchronize_irq(dev_priv->dev->irq); >   >   vlv_power_sequencer_reset(dev_priv); > + > + intel_hpd_poll_enable(dev_priv, true); >  } >   >  static void vlv_display_power_well_enable(struct drm_i915_private *dev_priv, -- Cheers, Lyude