From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Sharma, Shashank" Subject: Re: [PATCH v2 4/4] drm/i915: Determine DP++ type 1 DVI adaptor presence based on VBT Date: Wed, 04 May 2016 15:54:41 +0530 Message-ID: <5729CDE9.9040800@intel.com> References: <1462216105-20881-1-git-send-email-ville.syrjala@linux.intel.com> <1462216105-20881-5-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: <1462216105-20881-5-git-send-email-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" 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 CgpPbiA1LzMvMjAxNiAxMjozOCBBTSwgdmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20gd3Jv dGU6Cj4gRnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNv bT4KPgo+IERQIGR1YWwgbW9kZSB0eXBlIDEgRFZJIGFkYXB0b3JzIGFyZW4ndCByZXF1aXJlZCB0 byBpbXBsZW1lbnQgYW55Cj4gcmVnaXN0ZXJzLCBzbyBpdCdzIGEgYml0IGhhcmQgdG8gZGV0ZWN0 IHRoZW0uIFRoZSBiZXN0IHdheSB3b3VsZAo+IGJlIHRvIGNoZWNrIHRoZSBzdGF0ZSBvZiB0aGUg Q09ORklHMSBwaW4sIGJ1dCB3ZSBoYXZlIG5vIHdheSB0bwo+IGRvIHRoYXQuIFNvIGFzIGEgbGFz dCByZXNvcnQsIGNoZWNrIHRoZSBWQlQgdG8gc2VlIGlmIHRoZSBIRE1JCj4gcG9ydCBpcyBpbiBm YWN0IGEgZHVhbCBtb2RlIGNhcGFibGUgRFAgcG9ydC4KPgo+IHYyOiBEZWFsIHdpdGggVkJUIGNv ZGUgcmVvcmdhbml6YXRpb24KPiAgICAgIERlYWwgd2l0aCBEUk1fRFBfRFVBTF9NT0RFX1VOS05P V04KPiAgICAgIFJlZHVjZSBERVZJQ0VfVFlQRV9EUF9EVUFMX01PREVfQklUUyBhIGJpdAo+ICAg ICAgQWNjZXB0IGJvdGggRFAgYW5kIEhETUkgZHZvX3BvcnQgaW4gVkJUIGFzIG15IEJTVwo+ICAg ICAgYXQgbGVhc3QgZGVjbGFyZSBpdHMgRFAgcG9ydCBhcyBIRE1JIDooCj4KPiBDYzogc3RhYmxl QHZnZXIua2VybmVsLm9yZwo+IENjOiBUb3JlIEFuZGVyc29uIDx0b3JlQGZ1ZC5ubz4KPiBSZXBv cnRlZC1ieTogVG9yZSBBbmRlcnNvbiA8dG9yZUBmdWQubm8+Cj4gRml4ZXM6IDdhMGJhYTYyMzQ0 NiAoIlJldmVydCAiZHJtL2k5MTU6IERpc2FibGUgMTJicGMgaGRtaSBmb3Igbm93IiIpCj4gQ2M6 IFBhdWxvIFphbm9uaSA8cGF1bG8uci56YW5vbmlAaW50ZWwuY29tPgo+IENjOiBTaGFzaGFuayBT aGFybWEgPHNoYXNoYW5rLnNoYXJtYUBpbnRlbC5jb20+Cj4gQ2M6IERhbmllbCBWZXR0ZXIgPGRh bmllbC52ZXR0ZXJAZmZ3bGwuY2g+Cj4gU2lnbmVkLW9mZi1ieTogVmlsbGUgU3lyasOkbMOkIDx2 aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiAtLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZHJ2LmggICAgICAgfCAgMSArCj4gICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9iaW9zLmMgICAgIHwgMzYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAg IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hkbWkuYyAgICAgfCAzMCArKysrKysrKysrKysr KysrKysrKysrKysrLS0tLQo+ICAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdmJ0X2RlZnMu aCB8IDEzICsrKysrKysrKysrKysKPiAgIDQgZmlsZXMgY2hhbmdlZCwgNzYgaW5zZXJ0aW9ucygr KSwgNCBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAo+IGluZGV4IGZmNmFh ZjBjNGUxZS4uYWJlNDM5MjJhMDhmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2k5MTVfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCj4gQEAg LTM0ODksNiArMzQ4OSw3IEBAIGJvb2wgaW50ZWxfYmlvc19pc192YWxpZF92YnQoY29uc3Qgdm9p ZCAqYnVmLCBzaXplX3Qgc2l6ZSk7Cj4gICBib29sIGludGVsX2Jpb3NfaXNfdHZfcHJlc2VudChz dHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpOwo+ICAgYm9vbCBpbnRlbF9iaW9zX2lz X2x2ZHNfcHJlc2VudChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIHU4ICppMmNf cGluKTsKPiAgIGJvb2wgaW50ZWxfYmlvc19pc19wb3J0X2VkcChzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYsIGVudW0gcG9ydCBwb3J0KTsKPiArYm9vbCBpbnRlbF9iaW9zX2lzX3Bv cnRfZHBfZHVhbF9tb2RlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgZW51bSBw b3J0IHBvcnQpOwo+ICAgYm9vbCBpbnRlbF9iaW9zX2lzX2RzaV9wcmVzZW50KHN0cnVjdCBkcm1f aTkxNV9wcml2YXRlICpkZXZfcHJpdiwgZW51bSBwb3J0ICpwb3J0KTsKPiAgIGJvb2wgaW50ZWxf Ymlvc19pc19wb3J0X2hwZF9pbnZlcnRlZChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYsCj4gICAJCQkJICAgICBlbnVtIHBvcnQgcG9ydCk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jp b3MuYwo+IGluZGV4IDgxNTE4MTE2ZTAwZC4uOGI2OGM0ODgyZmJhIDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2Jpb3MuYwo+IEBAIC0xNTk3LDYgKzE1OTcsNDIgQEAgYm9vbCBpbnRlbF9iaW9z X2lzX3BvcnRfZWRwKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgZW51bSBwb3J0 IHBvcnQpCj4gICAJcmV0dXJuIGZhbHNlOwo+ICAgfQo+Cj4gK2Jvb2wgaW50ZWxfYmlvc19pc19w b3J0X2RwX2R1YWxfbW9kZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIGVudW0g cG9ydCBwb3J0KQo+ICt7Cj4gKwlzdGF0aWMgY29uc3Qgc3RydWN0IHsKPiArCQl1MTYgZHAsIGhk bWk7Cj4gKwl9IHBvcnRfbWFwcGluZ1tdID0gewo+ICsJCS8qCj4gKwkJICogQnVnZ3kgVkJUcyBt YXkgZGVjbGFyZSBEUCBwb3J0cyBhcyBoYXZpbmcKPiArCQkgKiBIRE1JIHR5cGUgZHZvX3BvcnQg OiggU28gbGV0J3MgY2hlY2sgYm90aC4KPiArCQkgKi8KPiArCQlbUE9SVF9CXSA9IHsgRFZPX1BP UlRfRFBCLCBEVk9fUE9SVF9IRE1JQiwgfSwKPiArCQlbUE9SVF9DXSA9IHsgRFZPX1BPUlRfRFBD LCBEVk9fUE9SVF9IRE1JQywgfSwKPiArCQlbUE9SVF9EXSA9IHsgRFZPX1BPUlRfRFBELCBEVk9f UE9SVF9IRE1JRCwgfSwKPiArCQlbUE9SVF9FXSA9IHsgRFZPX1BPUlRfRFBFLCBEVk9fUE9SVF9I RE1JRSwgfSwKPiArCX07Cj4gKwlpbnQgaTsKPiArCj4gKwlpZiAocG9ydCA9PSBQT1JUX0EgfHwg cG9ydCA+PSBBUlJBWV9TSVpFKHBvcnRfbWFwcGluZykpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsK PiArCWlmICghZGV2X3ByaXYtPnZidC5jaGlsZF9kZXZfbnVtKQo+ICsJCXJldHVybiBmYWxzZTsK PiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgZGV2X3ByaXYtPnZidC5jaGlsZF9kZXZfbnVtOyBpKysp IHsKPiArCQljb25zdCB1bmlvbiBjaGlsZF9kZXZpY2VfY29uZmlnICpwX2NoaWxkID0KPiArCQkJ JmRldl9wcml2LT52YnQuY2hpbGRfZGV2W2ldOwo+ICsKPiArCQlpZiAoKHBfY2hpbGQtPmNvbW1v bi5kdm9fcG9ydCA9PSBwb3J0X21hcHBpbmdbcG9ydF0uZHAgfHwKPiArCQkgICAgIHBfY2hpbGQt PmNvbW1vbi5kdm9fcG9ydCA9PSBwb3J0X21hcHBpbmdbcG9ydF0uaGRtaSkgJiYKPiArCQkgICAg KHBfY2hpbGQtPmNvbW1vbi5kZXZpY2VfdHlwZSAmIERFVklDRV9UWVBFX0RQX0RVQUxfTU9ERV9C SVRTKSA9PQo+ICsJCSAgICAoREVWSUNFX1RZUEVfRFBfRFVBTF9NT0RFICYgREVWSUNFX1RZUEVf RFBfRFVBTF9NT0RFX0JJVFMpKQo+ICsJCQlyZXR1cm4gdHJ1ZTsKPiArCX0KPiArCj4gKwlyZXR1 cm4gZmFsc2U7Cj4gK30KPiArCj4gICAvKioKPiAgICAqIGludGVsX2Jpb3NfaXNfZHNpX3ByZXNl bnQgLSBpcyBEU0kgcHJlc2VudCBpbiBWQlQKPiAgICAqIEBkZXZfcHJpdjoJaTkxNSBkZXZpY2Ug aW5zdGFuY2UKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5j IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCj4gaW5kZXggYzRkOTNlNmI0YmVk Li42YjUyYzZhY2NmNmEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf aGRtaS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCj4gQEAgLTEz OTYsMTYgKzEzOTYsMzggQEAgaW50ZWxfaGRtaV91bnNldF9lZGlkKHN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uZWN0b3IpCj4gICB9Cj4KPiAgIHN0YXRpYyB2b2lkCj4gLWludGVsX2hkbWlfZHBf ZHVhbF9tb2RlX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICtpbnRl bF9oZG1pX2RwX2R1YWxfbW9kZV9kZXRlY3Qoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3Rv ciwgYm9vbCBoYXNfZWRpZCkKPiAgIHsKPiAgIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2 X3ByaXYgPSB0b19pOTE1KGNvbm5lY3Rvci0+ZGV2KTsKPiAgIAlzdHJ1Y3QgaW50ZWxfaGRtaSAq aGRtaSA9IGludGVsX2F0dGFjaGVkX2hkbWkoY29ubmVjdG9yKTsKPiArCWVudW0gcG9ydCBwb3J0 ID0gaGRtaV90b19kaWdfcG9ydChoZG1pKS0+cG9ydDsKPiAgIAlzdHJ1Y3QgaTJjX2FkYXB0ZXIg KmFkYXB0ZXIgPQo+ICAgCQlpbnRlbF9nbWJ1c19nZXRfYWRhcHRlcihkZXZfcHJpdiwgaGRtaS0+ ZGRjX2J1cyk7Cj4gICAJZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5cGUgdHlwZSA9IGRybV9kcF9k dWFsX21vZGVfZGV0ZWN0KGFkYXB0ZXIpOwo+Cj4gLQlpZiAodHlwZSA9PSBEUk1fRFBfRFVBTF9N T0RFX05PTkUgfHwKPiAtCSAgICB0eXBlID09IERSTV9EUF9EVUFMX01PREVfVU5LTk9XTikKPiAr CS8qCj4gKwkgKiBUeXBlIDEgRFZJIGFkYXB0b3JzIGFyZSBub3QgcmVxdWlyZWQgdG8gaW1wbGVt ZW50IGFueQo+ICsJICogcmVnaXN0ZXJzLCBzbyB3ZSBjYW4ndCBhbHdheXMgZGV0ZWN0IHRoZWly IHByZXNlbmNlLgo+ICsJICogSWRlYWxseSB3ZSBzaG91bGQgYmUgYWJsZSB0byBjaGVjayB0aGUg c3RhdGUgb2YgdGhlCj4gKwkgKiBDT05GSUcxIHBpbiwgYnV0IG5vIHN1Y2ggbHVjayBvbiBvdXIg aGFyZHdhcmUuCj4gKwkgKgo+ICsJICogVGhlIG9ubHkgbWV0aG9kIGxlZnQgdG8gdXMgaXMgdG8g Y2hlY2sgdGhlIFZCVCB0byBzZWUKPiArCSAqIGlmIHRoZSBwb3J0IGlzIGEgZHVhbCBtb2RlIGNh cGFibGUgRFAgcG9ydC4gQnV0IGxldCdzCj4gKwkgKiBvbmx5IGRvIHRoYXQgd2hlbiB3ZSBzdWNl c2Z1bGx5IHJlYWQgdGhlIEVESUQsIHRvIGF2b2lkCj4gKwkgKiBjb25mdXNpbmcgbG9nIG1lc3Nh Z2VzIGFib3V0IERQIGR1YWwgbW9kZSBhZGFwdG9ycyB3aGVuCj4gKwkgKiB0aGVyZSdzIG5vdGhp bmcgY29ubmVjdGVkIHRvIHRoZSBwb3J0Lgo+ICsJICovCj4gKwlpZiAodHlwZSA9PSBEUk1fRFBf RFVBTF9NT0RFX1VOS05PV04pIHsKPiArCQlpZiAoaGFzX2VkaWQgJiYKPiArCQkgICAgaW50ZWxf Ymlvc19pc19wb3J0X2RwX2R1YWxfbW9kZShkZXZfcHJpdiwgcG9ydCkpIHsKPiArCQkJRFJNX0RF QlVHX0tNUygiQXNzdW1pbmcgRFAgZHVhbCBtb2RlIGFkYXB0b3IgcHJlc2VuY2UgYmFzZWQgb24g VkJUXG4iKTsKPiArCQkJdHlwZSA9IERSTV9EUF9EVUFMX01PREVfVFlQRTFfRFZJOwo+ICsJCX0g ZWxzZSB7Cj4gKwkJCXR5cGUgPSBEUk1fRFBfRFVBTF9NT0RFX05PTkU7Cj4gKwkJfQo+ICsJfQo+ ICsKPiArCWlmICh0eXBlID09IERSTV9EUF9EVUFMX01PREVfTk9ORSkKPiAgIAkJcmV0dXJuOwo+ Cj4gICAJaGRtaS0+ZHBfZHVhbF9tb2RlLnR5cGUgPSB0eXBlOwo+IEBAIC0xNDMyLDcgKzE0NTQs NyBAQCBpbnRlbF9oZG1pX3NldF9lZGlkKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3Is IGJvb2wgZm9yY2UpCj4gICAJCQkJICAgIGludGVsX2dtYnVzX2dldF9hZGFwdGVyKGRldl9wcml2 LAo+ICAgCQkJCSAgICBpbnRlbF9oZG1pLT5kZGNfYnVzKSk7Cj4KPiAtCQlpbnRlbF9oZG1pX2Rw X2R1YWxfbW9kZV9kZXRlY3QoY29ubmVjdG9yKTsKPiArCQlpbnRlbF9oZG1pX2RwX2R1YWxfbW9k ZV9kZXRlY3QoY29ubmVjdG9yLCBlZGlkICE9IE5VTEwpOwo+Cj4gICAJCWludGVsX2Rpc3BsYXlf cG93ZXJfcHV0KGRldl9wcml2LCBQT1dFUl9ET01BSU5fR01CVVMpOwo+ICAgCX0KPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdmJ0X2RlZnMuaCBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX3ZidF9kZWZzLmgKPiBpbmRleCBhNGE0MmYyNTRjMzUuLmIxMDE5ZTAx ZTUxZCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF92YnRfZGVmcy5o Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdmJ0X2RlZnMuaAo+IEBAIC03NDYs NiArNzQ2LDcgQEAgc3RydWN0IGJkYl9wc3Igewo+ICAgI2RlZmluZQkgREVWSUNFX1RZUEVfSU5U X1RWCTB4MTAwOQo+ICAgI2RlZmluZQkgREVWSUNFX1RZUEVfSERNSQkweDYwRDIKPiAgICNkZWZp bmUJIERFVklDRV9UWVBFX0RQCQkweDY4QzYKPiArI2RlZmluZQkgREVWSUNFX1RZUEVfRFBfRFVB TF9NT0RFCTB4NjBENgo+ICAgI2RlZmluZQkgREVWSUNFX1RZUEVfZURQCTB4NzhDNgo+Cj4gICAj ZGVmaW5lICBERVZJQ0VfVFlQRV9DTEFTU19FWFRFTlNJT04JKDEgPDwgMTUpCj4gQEAgLTc4MCw2 ICs3ODEsMTggQEAgc3RydWN0IGJkYl9wc3Igewo+ICAgCSBERVZJQ0VfVFlQRV9ESVNQTEFZUE9S VF9PVVRQVVQgfCBcCj4gICAJIERFVklDRV9UWVBFX0FOQUxPR19PVVRQVVQpCj4KPiArI2RlZmlu ZSBERVZJQ0VfVFlQRV9EUF9EVUFMX01PREVfQklUUyBcCj4gKwkoREVWSUNFX1RZUEVfSU5URVJO QUxfQ09OTkVDVE9SIHwgXAo+ICsJIERFVklDRV9UWVBFX05PVF9IRE1JX09VVFBVVCB8IFwKV2h5 IGRvIHdlIG5lZWQgdGhpcyBvbmUgPyBTaG91bGRuJ3QgdGhlIG90aGVycyBjb3ZlciBhbGwgdGhl IGNhc2VzID8KSXMgdGhlcmUgYSBzcGVjaWFsIGNhc2UgaW4geW91ciBtaW5kID8KClJlZ2FyZHMK U2hhc2hhbmsKPiArCSBERVZJQ0VfVFlQRV9NSVBJX09VVFBVVCB8IFwKPiArCSBERVZJQ0VfVFlQ RV9DT01QT1NJVEVfT1VUUFVUIHwgXAo+ICsJIERFVklDRV9UWVBFX0xWRFNfU0lOR0FMSU5HIHwg XAo+ICsJIERFVklDRV9UWVBFX1RNRFNfRFZJX1NJR05BTElORyB8IFwKPiArCSBERVZJQ0VfVFlQ RV9WSURFT19TSUdOQUxJTkcgfCBcCj4gKwkgREVWSUNFX1RZUEVfRElTUExBWVBPUlRfT1VUUFVU IHwgXAo+ICsJIERFVklDRV9UWVBFX0RJR0lUQUxfT1VUUFVUIHwgXAo+ICsJIERFVklDRV9UWVBF X0FOQUxPR19PVVRQVVQpCj4gKwo+ICAgLyogZGVmaW5lIHRoZSBEVk8gcG9ydCBmb3IgSERNSSBv dXRwdXQgdHlwZSAqLwo+ICAgI2RlZmluZQkJRFZPX0IJCTEKPiAgICNkZWZpbmUJCURWT19DCQky Cj4KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRl dmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga09.intel.com ([134.134.136.24]:36029 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1757442AbcEDKYr (ORCPT ); Wed, 4 May 2016 06:24:47 -0400 Message-ID: <5729CDE9.9040800@intel.com> Date: Wed, 04 May 2016 15:54:41 +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 v2 4/4] drm/i915: Determine DP++ type 1 DVI adaptor presence based on VBT References: <1462216105-20881-1-git-send-email-ville.syrjala@linux.intel.com> <1462216105-20881-5-git-send-email-ville.syrjala@linux.intel.com> In-Reply-To: <1462216105-20881-5-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: On 5/3/2016 12:38 AM, 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 :( > > 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 | 13 +++++++++++++ > 4 files changed, 76 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..b1019e01e51d 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,18 @@ struct bdb_psr { > DEVICE_TYPE_DISPLAYPORT_OUTPUT | \ > DEVICE_TYPE_ANALOG_OUTPUT) > > +#define DEVICE_TYPE_DP_DUAL_MODE_BITS \ > + (DEVICE_TYPE_INTERNAL_CONNECTOR | \ > + DEVICE_TYPE_NOT_HDMI_OUTPUT | \ Why do we need this one ? Shouldn't the others cover all the cases ? Is there a special case in your mind ? Regards Shashank > + 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 >