From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Sharma, Shashank" Subject: Re: [PATCH v3 4/4] drm/i915: Determine DP++ type 1 DVI adaptor presence based on VBT Date: Wed, 04 May 2016 19:20:58 +0530 Message-ID: <5729FE42.3070804@intel.com> References: <1462216105-20881-5-git-send-email-ville.syrjala@linux.intel.com> <1462362322-31278-1-git-send-email-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1462362322-31278-1-git-send-email-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: ville.syrjala@linux.intel.com, dri-devel@lists.freedesktop.org Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, Tore Anderson , Paulo Zanoni , stable@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org UmV2aWV3ZWQtYnk6IFNoYXNoYW5rIFNoYXJtYSA8c2hhc2hhbmsuc2hhcm1hQGludGVsLmNvbT4K ClJlZ2FyZHMKU2hhc2hhbmsKT24gNS80LzIwMTYgNToxNSBQTSwgdmlsbGUuc3lyamFsYUBsaW51 eC5pbnRlbC5jb20gd3JvdGU6Cj4gRnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxh QGxpbnV4LmludGVsLmNvbT4KPgo+IERQIGR1YWwgbW9kZSB0eXBlIDEgRFZJIGFkYXB0b3JzIGFy ZW4ndCByZXF1aXJlZCB0byBpbXBsZW1lbnQgYW55Cj4gcmVnaXN0ZXJzLCBzbyBpdCdzIGEgYml0 IGhhcmQgdG8gZGV0ZWN0IHRoZW0uIFRoZSBiZXN0IHdheSB3b3VsZAo+IGJlIHRvIGNoZWNrIHRo ZSBzdGF0ZSBvZiB0aGUgQ09ORklHMSBwaW4sIGJ1dCB3ZSBoYXZlIG5vIHdheSB0bwo+IGRvIHRo YXQuIFNvIGFzIGEgbGFzdCByZXNvcnQsIGNoZWNrIHRoZSBWQlQgdG8gc2VlIGlmIHRoZSBIRE1J Cj4gcG9ydCBpcyBpbiBmYWN0IGEgZHVhbCBtb2RlIGNhcGFibGUgRFAgcG9ydC4KPgo+IHYyOiBE ZWFsIHdpdGggVkJUIGNvZGUgcmVvcmdhbml6YXRpb24KPiAgICAgIERlYWwgd2l0aCBEUk1fRFBf RFVBTF9NT0RFX1VOS05PV04KPiAgICAgIFJlZHVjZSBERVZJQ0VfVFlQRV9EUF9EVUFMX01PREVf QklUUyBhIGJpdAo+ICAgICAgQWNjZXB0IGJvdGggRFAgYW5kIEhETUkgZHZvX3BvcnQgaW4gVkJU IGFzIG15IEJTVwo+ICAgICAgYXQgbGVhc3QgZGVjbGFyZSBpdHMgRFAgcG9ydCBhcyBIRE1JIDoo Cj4gdjM6IElnbm9yZSBERVZJQ0VfVFlQRV9OT1RfSERNSV9PVVRQVVQgKFNoYXNoYW5sKQo+Cj4g Q2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcKPiBDYzogVG9yZSBBbmRlcnNvbiA8dG9yZUBmdWQu bm8+Cj4gUmVwb3J0ZWQtYnk6IFRvcmUgQW5kZXJzb24gPHRvcmVAZnVkLm5vPgo+IEZpeGVzOiA3 YTBiYWE2MjM0NDYgKCJSZXZlcnQgImRybS9pOTE1OiBEaXNhYmxlIDEyYnBjIGhkbWkgZm9yIG5v dyIiKQo+IENjOiBQYXVsbyBaYW5vbmkgPHBhdWxvLnIuemFub25pQGludGVsLmNvbT4KPiBDYzog U2hhc2hhbmsgU2hhcm1hIDxzaGFzaGFuay5zaGFybWFAaW50ZWwuY29tPgo+IENjOiBEYW5pZWwg VmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPgo+IFNpZ25lZC1vZmYtYnk6IFZpbGxlIFN5 cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+Cj4gLS0tCj4gICBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgIHwgIDEgKwo+ICAgZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfYmlvcy5jICAgICB8IDM2ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrCj4gICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9oZG1pLmMgICAgIHwgMzAgKysr KysrKysrKysrKysrKysrKysrKysrKy0tLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X3ZidF9kZWZzLmggfCAxMiArKysrKysrKysrKysKPiAgIDQgZmlsZXMgY2hhbmdlZCwgNzUgaW5z ZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAo+IGlu ZGV4IGZmNmFhZjBjNGUxZS4uYWJlNDM5MjJhMDhmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Ry di5oCj4gQEAgLTM0ODksNiArMzQ4OSw3IEBAIGJvb2wgaW50ZWxfYmlvc19pc192YWxpZF92YnQo Y29uc3Qgdm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7Cj4gICBib29sIGludGVsX2Jpb3NfaXNfdHZf cHJlc2VudChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpOwo+ICAgYm9vbCBpbnRl bF9iaW9zX2lzX2x2ZHNfcHJlc2VudChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYs IHU4ICppMmNfcGluKTsKPiAgIGJvb2wgaW50ZWxfYmlvc19pc19wb3J0X2VkcChzdHJ1Y3QgZHJt X2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIGVudW0gcG9ydCBwb3J0KTsKPiArYm9vbCBpbnRlbF9i aW9zX2lzX3BvcnRfZHBfZHVhbF9tb2RlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp diwgZW51bSBwb3J0IHBvcnQpOwo+ICAgYm9vbCBpbnRlbF9iaW9zX2lzX2RzaV9wcmVzZW50KHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgZW51bSBwb3J0ICpwb3J0KTsKPiAgIGJv b2wgaW50ZWxfYmlvc19pc19wb3J0X2hwZF9pbnZlcnRlZChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0 ZSAqZGV2X3ByaXYsCj4gICAJCQkJICAgICBlbnVtIHBvcnQgcG9ydCk7Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2Jpb3MuYwo+IGluZGV4IDgxNTE4MTE2ZTAwZC4uOGI2OGM0ODgyZmJhIDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYwo+ICsrKyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYwo+IEBAIC0xNTk3LDYgKzE1OTcsNDIgQEAgYm9vbCBp bnRlbF9iaW9zX2lzX3BvcnRfZWRwKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwg ZW51bSBwb3J0IHBvcnQpCj4gICAJcmV0dXJuIGZhbHNlOwo+ICAgfQo+Cj4gK2Jvb2wgaW50ZWxf Ymlvc19pc19wb3J0X2RwX2R1YWxfbW9kZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYsIGVudW0gcG9ydCBwb3J0KQo+ICt7Cj4gKwlzdGF0aWMgY29uc3Qgc3RydWN0IHsKPiArCQl1 MTYgZHAsIGhkbWk7Cj4gKwl9IHBvcnRfbWFwcGluZ1tdID0gewo+ICsJCS8qCj4gKwkJICogQnVn Z3kgVkJUcyBtYXkgZGVjbGFyZSBEUCBwb3J0cyBhcyBoYXZpbmcKPiArCQkgKiBIRE1JIHR5cGUg ZHZvX3BvcnQgOiggU28gbGV0J3MgY2hlY2sgYm90aC4KPiArCQkgKi8KPiArCQlbUE9SVF9CXSA9 IHsgRFZPX1BPUlRfRFBCLCBEVk9fUE9SVF9IRE1JQiwgfSwKPiArCQlbUE9SVF9DXSA9IHsgRFZP X1BPUlRfRFBDLCBEVk9fUE9SVF9IRE1JQywgfSwKPiArCQlbUE9SVF9EXSA9IHsgRFZPX1BPUlRf RFBELCBEVk9fUE9SVF9IRE1JRCwgfSwKPiArCQlbUE9SVF9FXSA9IHsgRFZPX1BPUlRfRFBFLCBE Vk9fUE9SVF9IRE1JRSwgfSwKPiArCX07Cj4gKwlpbnQgaTsKPiArCj4gKwlpZiAocG9ydCA9PSBQ T1JUX0EgfHwgcG9ydCA+PSBBUlJBWV9TSVpFKHBvcnRfbWFwcGluZykpCj4gKwkJcmV0dXJuIGZh bHNlOwo+ICsKPiArCWlmICghZGV2X3ByaXYtPnZidC5jaGlsZF9kZXZfbnVtKQo+ICsJCXJldHVy biBmYWxzZTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgZGV2X3ByaXYtPnZidC5jaGlsZF9kZXZf bnVtOyBpKyspIHsKPiArCQljb25zdCB1bmlvbiBjaGlsZF9kZXZpY2VfY29uZmlnICpwX2NoaWxk ID0KPiArCQkJJmRldl9wcml2LT52YnQuY2hpbGRfZGV2W2ldOwo+ICsKPiArCQlpZiAoKHBfY2hp bGQtPmNvbW1vbi5kdm9fcG9ydCA9PSBwb3J0X21hcHBpbmdbcG9ydF0uZHAgfHwKPiArCQkgICAg IHBfY2hpbGQtPmNvbW1vbi5kdm9fcG9ydCA9PSBwb3J0X21hcHBpbmdbcG9ydF0uaGRtaSkgJiYK PiArCQkgICAgKHBfY2hpbGQtPmNvbW1vbi5kZXZpY2VfdHlwZSAmIERFVklDRV9UWVBFX0RQX0RV QUxfTU9ERV9CSVRTKSA9PQo+ICsJCSAgICAoREVWSUNFX1RZUEVfRFBfRFVBTF9NT0RFICYgREVW SUNFX1RZUEVfRFBfRFVBTF9NT0RFX0JJVFMpKQo+ICsJCQlyZXR1cm4gdHJ1ZTsKPiArCX0KPiAr Cj4gKwlyZXR1cm4gZmFsc2U7Cj4gK30KPiArCj4gICAvKioKPiAgICAqIGludGVsX2Jpb3NfaXNf ZHNpX3ByZXNlbnQgLSBpcyBEU0kgcHJlc2VudCBpbiBWQlQKPiAgICAqIEBkZXZfcHJpdjoJaTkx NSBkZXZpY2UgaW5zdGFuY2UKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfaGRtaS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCj4gaW5kZXggYzRk OTNlNmI0YmVkLi42YjUyYzZhY2NmNmEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfaGRtaS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5j Cj4gQEAgLTEzOTYsMTYgKzEzOTYsMzggQEAgaW50ZWxfaGRtaV91bnNldF9lZGlkKHN0cnVjdCBk cm1fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gICB9Cj4KPiAgIHN0YXRpYyB2b2lkCj4gLWludGVs X2hkbWlfZHBfZHVhbF9tb2RlX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y KQo+ICtpbnRlbF9oZG1pX2RwX2R1YWxfbW9kZV9kZXRlY3Qoc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3RvciwgYm9vbCBoYXNfZWRpZCkKPiAgIHsKPiAgIAlzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGNvbm5lY3Rvci0+ZGV2KTsKPiAgIAlzdHJ1Y3QgaW50 ZWxfaGRtaSAqaGRtaSA9IGludGVsX2F0dGFjaGVkX2hkbWkoY29ubmVjdG9yKTsKPiArCWVudW0g cG9ydCBwb3J0ID0gaGRtaV90b19kaWdfcG9ydChoZG1pKS0+cG9ydDsKPiAgIAlzdHJ1Y3QgaTJj X2FkYXB0ZXIgKmFkYXB0ZXIgPQo+ICAgCQlpbnRlbF9nbWJ1c19nZXRfYWRhcHRlcihkZXZfcHJp diwgaGRtaS0+ZGRjX2J1cyk7Cj4gICAJZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5cGUgdHlwZSA9 IGRybV9kcF9kdWFsX21vZGVfZGV0ZWN0KGFkYXB0ZXIpOwo+Cj4gLQlpZiAodHlwZSA9PSBEUk1f RFBfRFVBTF9NT0RFX05PTkUgfHwKPiAtCSAgICB0eXBlID09IERSTV9EUF9EVUFMX01PREVfVU5L Tk9XTikKPiArCS8qCj4gKwkgKiBUeXBlIDEgRFZJIGFkYXB0b3JzIGFyZSBub3QgcmVxdWlyZWQg dG8gaW1wbGVtZW50IGFueQo+ICsJICogcmVnaXN0ZXJzLCBzbyB3ZSBjYW4ndCBhbHdheXMgZGV0 ZWN0IHRoZWlyIHByZXNlbmNlLgo+ICsJICogSWRlYWxseSB3ZSBzaG91bGQgYmUgYWJsZSB0byBj aGVjayB0aGUgc3RhdGUgb2YgdGhlCj4gKwkgKiBDT05GSUcxIHBpbiwgYnV0IG5vIHN1Y2ggbHVj ayBvbiBvdXIgaGFyZHdhcmUuCj4gKwkgKgo+ICsJICogVGhlIG9ubHkgbWV0aG9kIGxlZnQgdG8g dXMgaXMgdG8gY2hlY2sgdGhlIFZCVCB0byBzZWUKPiArCSAqIGlmIHRoZSBwb3J0IGlzIGEgZHVh bCBtb2RlIGNhcGFibGUgRFAgcG9ydC4gQnV0IGxldCdzCj4gKwkgKiBvbmx5IGRvIHRoYXQgd2hl biB3ZSBzdWNlc2Z1bGx5IHJlYWQgdGhlIEVESUQsIHRvIGF2b2lkCj4gKwkgKiBjb25mdXNpbmcg bG9nIG1lc3NhZ2VzIGFib3V0IERQIGR1YWwgbW9kZSBhZGFwdG9ycyB3aGVuCj4gKwkgKiB0aGVy ZSdzIG5vdGhpbmcgY29ubmVjdGVkIHRvIHRoZSBwb3J0Lgo+ICsJICovCj4gKwlpZiAodHlwZSA9 PSBEUk1fRFBfRFVBTF9NT0RFX1VOS05PV04pIHsKPiArCQlpZiAoaGFzX2VkaWQgJiYKPiArCQkg ICAgaW50ZWxfYmlvc19pc19wb3J0X2RwX2R1YWxfbW9kZShkZXZfcHJpdiwgcG9ydCkpIHsKPiAr CQkJRFJNX0RFQlVHX0tNUygiQXNzdW1pbmcgRFAgZHVhbCBtb2RlIGFkYXB0b3IgcHJlc2VuY2Ug YmFzZWQgb24gVkJUXG4iKTsKPiArCQkJdHlwZSA9IERSTV9EUF9EVUFMX01PREVfVFlQRTFfRFZJ Owo+ICsJCX0gZWxzZSB7Cj4gKwkJCXR5cGUgPSBEUk1fRFBfRFVBTF9NT0RFX05PTkU7Cj4gKwkJ fQo+ICsJfQo+ICsKPiArCWlmICh0eXBlID09IERSTV9EUF9EVUFMX01PREVfTk9ORSkKPiAgIAkJ cmV0dXJuOwo+Cj4gICAJaGRtaS0+ZHBfZHVhbF9tb2RlLnR5cGUgPSB0eXBlOwo+IEBAIC0xNDMy LDcgKzE0NTQsNyBAQCBpbnRlbF9oZG1pX3NldF9lZGlkKHN0cnVjdCBkcm1fY29ubmVjdG9yICpj b25uZWN0b3IsIGJvb2wgZm9yY2UpCj4gICAJCQkJICAgIGludGVsX2dtYnVzX2dldF9hZGFwdGVy KGRldl9wcml2LAo+ICAgCQkJCSAgICBpbnRlbF9oZG1pLT5kZGNfYnVzKSk7Cj4KPiAtCQlpbnRl bF9oZG1pX2RwX2R1YWxfbW9kZV9kZXRlY3QoY29ubmVjdG9yKTsKPiArCQlpbnRlbF9oZG1pX2Rw X2R1YWxfbW9kZV9kZXRlY3QoY29ubmVjdG9yLCBlZGlkICE9IE5VTEwpOwo+Cj4gICAJCWludGVs X2Rpc3BsYXlfcG93ZXJfcHV0KGRldl9wcml2LCBQT1dFUl9ET01BSU5fR01CVVMpOwo+ICAgCX0K PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdmJ0X2RlZnMuaCBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3ZidF9kZWZzLmgKPiBpbmRleCBhNGE0MmYyNTRjMzUu LjRmOTc5OWYwMjVhOSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF92 YnRfZGVmcy5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdmJ0X2RlZnMuaAo+ IEBAIC03NDYsNiArNzQ2LDcgQEAgc3RydWN0IGJkYl9wc3Igewo+ICAgI2RlZmluZQkgREVWSUNF X1RZUEVfSU5UX1RWCTB4MTAwOQo+ICAgI2RlZmluZQkgREVWSUNFX1RZUEVfSERNSQkweDYwRDIK PiAgICNkZWZpbmUJIERFVklDRV9UWVBFX0RQCQkweDY4QzYKPiArI2RlZmluZQkgREVWSUNFX1RZ UEVfRFBfRFVBTF9NT0RFCTB4NjBENgo+ICAgI2RlZmluZQkgREVWSUNFX1RZUEVfZURQCTB4NzhD Ngo+Cj4gICAjZGVmaW5lICBERVZJQ0VfVFlQRV9DTEFTU19FWFRFTlNJT04JKDEgPDwgMTUpCj4g QEAgLTc4MCw2ICs3ODEsMTcgQEAgc3RydWN0IGJkYl9wc3Igewo+ICAgCSBERVZJQ0VfVFlQRV9E SVNQTEFZUE9SVF9PVVRQVVQgfCBcCj4gICAJIERFVklDRV9UWVBFX0FOQUxPR19PVVRQVVQpCj4K PiArI2RlZmluZSBERVZJQ0VfVFlQRV9EUF9EVUFMX01PREVfQklUUyBcCj4gKwkoREVWSUNFX1RZ UEVfSU5URVJOQUxfQ09OTkVDVE9SIHwgXAo+ICsJIERFVklDRV9UWVBFX01JUElfT1VUUFVUIHwg XAo+ICsJIERFVklDRV9UWVBFX0NPTVBPU0lURV9PVVRQVVQgfCBcCj4gKwkgREVWSUNFX1RZUEVf TFZEU19TSU5HQUxJTkcgfCBcCj4gKwkgREVWSUNFX1RZUEVfVE1EU19EVklfU0lHTkFMSU5HIHwg XAo+ICsJIERFVklDRV9UWVBFX1ZJREVPX1NJR05BTElORyB8IFwKPiArCSBERVZJQ0VfVFlQRV9E SVNQTEFZUE9SVF9PVVRQVVQgfCBcCj4gKwkgREVWSUNFX1RZUEVfRElHSVRBTF9PVVRQVVQgfCBc Cj4gKwkgREVWSUNFX1RZUEVfQU5BTE9HX09VVFBVVCkKPiArCj4gICAvKiBkZWZpbmUgdGhlIERW TyBwb3J0IGZvciBIRE1JIG91dHB1dCB0eXBlICovCj4gICAjZGVmaW5lCQlEVk9fQgkJMQo+ICAg I2RlZmluZQkJRFZPX0MJCTIKPgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVz a3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9p bnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com ([134.134.136.65]:15869 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750735AbcEDNvD (ORCPT ); Wed, 4 May 2016 09:51:03 -0400 Message-ID: <5729FE42.3070804@intel.com> Date: Wed, 04 May 2016 19:20:58 +0530 From: "Sharma, Shashank" MIME-Version: 1.0 To: ville.syrjala@linux.intel.com, dri-devel@lists.freedesktop.org CC: intel-gfx@lists.freedesktop.org, stable@vger.kernel.org, Tore Anderson , Paulo Zanoni , Daniel Vetter Subject: Re: [PATCH v3 4/4] drm/i915: Determine DP++ type 1 DVI adaptor presence based on VBT References: <1462216105-20881-5-git-send-email-ville.syrjala@linux.intel.com> <1462362322-31278-1-git-send-email-ville.syrjala@linux.intel.com> In-Reply-To: <1462362322-31278-1-git-send-email-ville.syrjala@linux.intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Sender: stable-owner@vger.kernel.org List-ID: Reviewed-by: Shashank Sharma Regards Shashank On 5/4/2016 5:15 PM, ville.syrjala@linux.intel.com wrote: > From: Ville Syrjälä > > DP dual mode type 1 DVI adaptors aren't required to implement any > registers, so it's a bit hard to detect them. The best way would > be to check the state of the CONFIG1 pin, but we have no way to > do that. So as a last resort, check the VBT to see if the HDMI > port is in fact a dual mode capable DP port. > > v2: Deal with VBT code reorganization > Deal with DRM_DP_DUAL_MODE_UNKNOWN > Reduce DEVICE_TYPE_DP_DUAL_MODE_BITS a bit > Accept both DP and HDMI dvo_port in VBT as my BSW > at least declare its DP port as HDMI :( > v3: Ignore DEVICE_TYPE_NOT_HDMI_OUTPUT (Shashanl) > > Cc: stable@vger.kernel.org > Cc: Tore Anderson > Reported-by: Tore Anderson > Fixes: 7a0baa623446 ("Revert "drm/i915: Disable 12bpc hdmi for now"") > Cc: Paulo Zanoni > Cc: Shashank Sharma > Cc: Daniel Vetter > Signed-off-by: Ville Syrjälä > --- > drivers/gpu/drm/i915/i915_drv.h | 1 + > drivers/gpu/drm/i915/intel_bios.c | 36 +++++++++++++++++++++++++++++++++++ > drivers/gpu/drm/i915/intel_hdmi.c | 30 +++++++++++++++++++++++++---- > drivers/gpu/drm/i915/intel_vbt_defs.h | 12 ++++++++++++ > 4 files changed, 75 insertions(+), 4 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h > index ff6aaf0c4e1e..abe43922a08f 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -3489,6 +3489,7 @@ bool intel_bios_is_valid_vbt(const void *buf, size_t size); > bool intel_bios_is_tv_present(struct drm_i915_private *dev_priv); > bool intel_bios_is_lvds_present(struct drm_i915_private *dev_priv, u8 *i2c_pin); > bool intel_bios_is_port_edp(struct drm_i915_private *dev_priv, enum port port); > +bool intel_bios_is_port_dp_dual_mode(struct drm_i915_private *dev_priv, enum port port); > bool intel_bios_is_dsi_present(struct drm_i915_private *dev_priv, enum port *port); > bool intel_bios_is_port_hpd_inverted(struct drm_i915_private *dev_priv, > enum port port); > diff --git a/drivers/gpu/drm/i915/intel_bios.c b/drivers/gpu/drm/i915/intel_bios.c > index 81518116e00d..8b68c4882fba 100644 > --- a/drivers/gpu/drm/i915/intel_bios.c > +++ b/drivers/gpu/drm/i915/intel_bios.c > @@ -1597,6 +1597,42 @@ bool intel_bios_is_port_edp(struct drm_i915_private *dev_priv, enum port port) > return false; > } > > +bool intel_bios_is_port_dp_dual_mode(struct drm_i915_private *dev_priv, enum port port) > +{ > + static const struct { > + u16 dp, hdmi; > + } port_mapping[] = { > + /* > + * Buggy VBTs may declare DP ports as having > + * HDMI type dvo_port :( So let's check both. > + */ > + [PORT_B] = { DVO_PORT_DPB, DVO_PORT_HDMIB, }, > + [PORT_C] = { DVO_PORT_DPC, DVO_PORT_HDMIC, }, > + [PORT_D] = { DVO_PORT_DPD, DVO_PORT_HDMID, }, > + [PORT_E] = { DVO_PORT_DPE, DVO_PORT_HDMIE, }, > + }; > + int i; > + > + if (port == PORT_A || port >= ARRAY_SIZE(port_mapping)) > + return false; > + > + if (!dev_priv->vbt.child_dev_num) > + return false; > + > + for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { > + const union child_device_config *p_child = > + &dev_priv->vbt.child_dev[i]; > + > + if ((p_child->common.dvo_port == port_mapping[port].dp || > + p_child->common.dvo_port == port_mapping[port].hdmi) && > + (p_child->common.device_type & DEVICE_TYPE_DP_DUAL_MODE_BITS) == > + (DEVICE_TYPE_DP_DUAL_MODE & DEVICE_TYPE_DP_DUAL_MODE_BITS)) > + return true; > + } > + > + return false; > +} > + > /** > * intel_bios_is_dsi_present - is DSI present in VBT > * @dev_priv: i915 device instance > diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c > index c4d93e6b4bed..6b52c6accf6a 100644 > --- a/drivers/gpu/drm/i915/intel_hdmi.c > +++ b/drivers/gpu/drm/i915/intel_hdmi.c > @@ -1396,16 +1396,38 @@ intel_hdmi_unset_edid(struct drm_connector *connector) > } > > static void > -intel_hdmi_dp_dual_mode_detect(struct drm_connector *connector) > +intel_hdmi_dp_dual_mode_detect(struct drm_connector *connector, bool has_edid) > { > struct drm_i915_private *dev_priv = to_i915(connector->dev); > struct intel_hdmi *hdmi = intel_attached_hdmi(connector); > + enum port port = hdmi_to_dig_port(hdmi)->port; > struct i2c_adapter *adapter = > intel_gmbus_get_adapter(dev_priv, hdmi->ddc_bus); > enum drm_dp_dual_mode_type type = drm_dp_dual_mode_detect(adapter); > > - if (type == DRM_DP_DUAL_MODE_NONE || > - type == DRM_DP_DUAL_MODE_UNKNOWN) > + /* > + * Type 1 DVI adaptors are not required to implement any > + * registers, so we can't always detect their presence. > + * Ideally we should be able to check the state of the > + * CONFIG1 pin, but no such luck on our hardware. > + * > + * The only method left to us is to check the VBT to see > + * if the port is a dual mode capable DP port. But let's > + * only do that when we sucesfully read the EDID, to avoid > + * confusing log messages about DP dual mode adaptors when > + * there's nothing connected to the port. > + */ > + if (type == DRM_DP_DUAL_MODE_UNKNOWN) { > + if (has_edid && > + intel_bios_is_port_dp_dual_mode(dev_priv, port)) { > + DRM_DEBUG_KMS("Assuming DP dual mode adaptor presence based on VBT\n"); > + type = DRM_DP_DUAL_MODE_TYPE1_DVI; > + } else { > + type = DRM_DP_DUAL_MODE_NONE; > + } > + } > + > + if (type == DRM_DP_DUAL_MODE_NONE) > return; > > hdmi->dp_dual_mode.type = type; > @@ -1432,7 +1454,7 @@ intel_hdmi_set_edid(struct drm_connector *connector, bool force) > intel_gmbus_get_adapter(dev_priv, > intel_hdmi->ddc_bus)); > > - intel_hdmi_dp_dual_mode_detect(connector); > + intel_hdmi_dp_dual_mode_detect(connector, edid != NULL); > > intel_display_power_put(dev_priv, POWER_DOMAIN_GMBUS); > } > diff --git a/drivers/gpu/drm/i915/intel_vbt_defs.h b/drivers/gpu/drm/i915/intel_vbt_defs.h > index a4a42f254c35..4f9799f025a9 100644 > --- a/drivers/gpu/drm/i915/intel_vbt_defs.h > +++ b/drivers/gpu/drm/i915/intel_vbt_defs.h > @@ -746,6 +746,7 @@ struct bdb_psr { > #define DEVICE_TYPE_INT_TV 0x1009 > #define DEVICE_TYPE_HDMI 0x60D2 > #define DEVICE_TYPE_DP 0x68C6 > +#define DEVICE_TYPE_DP_DUAL_MODE 0x60D6 > #define DEVICE_TYPE_eDP 0x78C6 > > #define DEVICE_TYPE_CLASS_EXTENSION (1 << 15) > @@ -780,6 +781,17 @@ struct bdb_psr { > DEVICE_TYPE_DISPLAYPORT_OUTPUT | \ > DEVICE_TYPE_ANALOG_OUTPUT) > > +#define DEVICE_TYPE_DP_DUAL_MODE_BITS \ > + (DEVICE_TYPE_INTERNAL_CONNECTOR | \ > + DEVICE_TYPE_MIPI_OUTPUT | \ > + DEVICE_TYPE_COMPOSITE_OUTPUT | \ > + DEVICE_TYPE_LVDS_SINGALING | \ > + DEVICE_TYPE_TMDS_DVI_SIGNALING | \ > + DEVICE_TYPE_VIDEO_SIGNALING | \ > + DEVICE_TYPE_DISPLAYPORT_OUTPUT | \ > + DEVICE_TYPE_DIGITAL_OUTPUT | \ > + DEVICE_TYPE_ANALOG_OUTPUT) > + > /* define the DVO port for HDMI output type */ > #define DVO_B 1 > #define DVO_C 2 >