From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sivakumar Thulasimani Subject: Re: [PATCH 3/3] drm/i915: Support DDI lane reversal for DP Date: Thu, 30 Jul 2015 09:43:37 +0530 Message-ID: <55B9A471.2070107@intel.com> References: <1438099409-25456-1-git-send-email-benjamin.tissoires@redhat.com> <1438099409-25456-4-git-send-email-benjamin.tissoires@redhat.com> <55B88E25.6000006@intel.com> <20150729152240.GD2743@mail.corp.redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by gabe.freedesktop.org (Postfix) with ESMTP id 207D46E242 for ; Wed, 29 Jul 2015 21:13:41 -0700 (PDT) In-Reply-To: <20150729152240.GD2743@mail.corp.redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Benjamin Tissoires Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, Todd Broch , linux-kernel@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org CgpPbiA3LzI5LzIwMTUgODo1MiBQTSwgQmVuamFtaW4gVGlzc29pcmVzIHdyb3RlOgo+IE9uIEp1 bCAyOSAyMDE1IG9yIHRoZXJlYWJvdXRzLCBTaXZha3VtYXIgVGh1bGFzaW1hbmkgd3JvdGU6Cj4+ IHdoeSBub3QgZGV0ZWN0IHJldmVyc2UgaW4gaW50ZWxfZHBfZGV0ZWN0L2ludGVsX2hwZF9wdWxz ZSA/IHRoYXQgd2F5IHlvdSBjYW4KPj4gaWRlbnRpZnkgYm90aCBsYW5lIGNvdW50IGFuZCByZXZl cnNhbCBzdGF0ZSB3aXRob3V0IHRvdWNoaW5nIGFueXRoaW5nIGluIHRoZQo+PiBsaW5rIHRyYWlu aW5nIGNvZGUuIGkgYW0geWV0IHRvIHVwc3RyZWFtIG15IGNoYW5nZXMgZm9yIENIVCB0aGF0IGkg Y2FuIHNoYXJlCj4+IGlmIHJlcXVpcmVkIHRoYXQgZG9lcyB0aGUgc2FtZSBpbiBpbnRlbF9kcF9k ZXRlY3Qgd2l0aG91dCB0b3VjaGluZyBhbnkgbGluZQo+PiBpbiBsaW5rIHRyYWluaW5nIHBhdGgu Cj4gV2l0aCBteSBjdXJyZW50IGxpbWl0ZWQga25vd2xlZGdlIG9mIHRoZSBkcCBob3RwbHVnIChh bmQgaTkxNSBkcml2ZXIpIEkKPiBhbSBub3Qgc3VyZSB3ZSBjb3VsZCBkZXRlY3QgdGhlIHJldmVy c2VkIHN0YXRlIHdpdGhvdXQgdHJ5aW5nIHRvIHRyYWluIDEKPiBsYW5lIG9ubHkuIEknZCBiZSBn bGFkIHRvIGxvb2sgYXQgeW91ciBjaGFuZ2VzIGFuZCB0ZXN0IHRoZW0gb24gbXkKPiBzeXN0ZW0g aWYgeW91IHRoaW5rIHRoYXQgY291bGQgaGVscCBoYXZpbmcgYSBjbGVhbmVyIHNvbHV0aW9uLgo+ Cj4gQ2hlZXJzLAo+IEJlbmphbWluCk5vLCB3aGF0IGkgcmVjb21tZW5kZWQgd2FzIHRvIGRvIGxp bmsgdHJhaW5pbmcgYnV0IGluIGludGVsX2RwX2RldGVjdC4gClNpbmNlIFVTQiBUeXBlIEMgY2Fi bGUKYWxzbyBoYXMgaXRzIG93biBsYW5lIGNvdW50IHJlc3RyaWN0aW9uIChpdCBjYW4gaGF2ZSBk aWZmZXJlbnQgbGFuZSAKY291bnQgdGhhbiB0aGUgb25lIHN1cHBvcnRlZApieSBwYW5lbCkgeW91 IG1pZ2h0IGhhdmUgdG8gZmlndXJlIHRoYXQgb3V0IGFzIHdlbGwuIHNvIGJvdGggcmV2ZXJzYWwg CmFuZCBsYW5lIGNvdW50IGRldGVjdGlvbgpjYW4gYmUgZG9uZSBvdXRzaWRlIHRoZSBtb2Rlc2V0 IHBhdGggYW5kIGtlZXAgdGhlIGNvZGUgZnJlZSBvZiB0eXBlIEMgCmNoYW5nZXMgb3V0c2lkZQpk ZXRlY3Rpb24gcGF0aC4KClBsZWFzZSBmaW5kIGJlbG93IHRoZSBjb2RlIHRvIGRvIHRoZSBzYW1l LiBEbyBub3Qgd2FzdGUgdGltZSB0cnlpbmcgdG8gCmFwcGx5IHRoaXMgZGlyZWN0bHkgb24Kbmln aHRseSBzaW5jZSB0aGlzIGlzIGJhc2VkIG9uIGEgbG9jYWwgdHJlZSBhbmQgYmVjYXVzZSB0aGlz IGlzIHByZS0gCmF0b21pYyBjaGFuZ2VzIGNvZGUsIHNvIHlvdQptaWdodCBoYXZlIHRvIG1vZGlm eSBjaHZfdXBmcm9udF9saW5rX3RyYWluIHRvIHdvcmsgb24gdG9wIG9mIHRoZSBsYXRlc3QgCm5p Z2h0bHkgY29kZS4gd2UKYXJlIHN1cHBvc2VkIHRvIHVwc3RyZWFtIHRoaXMgYW5kIGlzIGluIG15 IHRvZG8gbGlzdC4KCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKQXV0aG9yOiBEdXJnYWRvc3MgUiA8ZHVyZ2Fkb3NzLnJA aW50ZWwuY29tPgpEYXRlOiAgIEZyaSBNYXkgMjIgMTQ6MzA6MDcgMjAxNSArMDUzMAoKICAgIGRy bS9pOTE1OiBFbmFibGUgVXBmcm9udCBsaW5rIHRyYWluaW5nIGZvciB0eXBlLUMgRFAgc3VwcG9y dAoKICAgICBUbyBzdXBwb3J0IFVTQiB0eXBlIEMgYWx0ZXJuYXRlIERQIG1vZGUsIHRoZSBkaXNw bGF5IGRyaXZlciBuZWVkcyAKdG8ga25vdyB0aGUKICAgICBudW1iZXIgb2YgbGFuZXMgcmVxdWly ZWQgYnkgRFAgcGFuZWwgYXMgd2VsbCBhcyBudW1iZXIgb2YgbGFuZXMgCnRoYXQgY2FuIGJlCiAg ICAgc3VwcG9ydGVkIGJ5IHRoZSB0eXBlLUMgY2FibGUuIFNvbWV0aW1lcywgdGhlIHR5cGUtQyBj YWJsZSBtYXkgCmxpbWl0IHRoZQogICAgIGJhbmR3aWR0aCBldmVuIGlmIFBhbmVsIGNhbiBzdXBw b3J0IG1vcmUgbGFuZXMuIFRvIGFkZHJlc3MgdGhlc2UgCnNjZW5hcmlvcywKICAgICB0aGUgZGlz cGxheSBkcml2ZXIgd2lsbCBzdGFydCBsaW5rIHRyYWluaW5nIHdpdGggbWF4IGxhbmVzLCBhbmQg aWYgCnRoZSBsaW5rCiAgICAgdHJhaW5pbmcgZmFpbHMsIHRoZSBkcml2ZXIgdGhlbiBmYWxscyBi YWNrIHRvIHgyIGxhbmVzLgoKICAgICAqIFNpbmNlIGxpbmsgdHJhaW5pbmcgaXMgZG9uZSBiZWZv cmUgbW9kZXNldCwgcGxhbmVzIGFyZSBub3QgCmVuYWJsZWQuIE9ubHkKICAgICAgIGVuY29kZXIg YW5kIHRoZSBpdHMgYXNzb2NpYXRlZCBQTExzIGFyZSBlbmFibGVkLgogICAgICogT25jZSBsaW5r IHRyYWluaW5nIGlzIGRvbmUsIHRoZSBlbmNvZGVyIGFuZCBpdHMgUExMcyBhcmUgCmRpc2FibGVk OyBzbyB0aGF0CiAgICAgICB0aGUgc3Vic2VxdWVudCBtb2Rlc2V0IGlzIG5vdCBhd2FyZSBvZiB0 aGVzZSBjaGFuZ2VzLgogICAgICogQXMgb2Ygbm93LCB0aGlzIGlzIHRlc3RlZCBvbmx5IG9uIENI Vi4KCiAgICAgU2lnbmVkLW9mZi1ieTogRHVyZ2Fkb3NzIFIgPGR1cmdhZG9zcy5yQGludGVsLmNv bT4KCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgCmIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCmluZGV4IDBjOGFlMmEuLmM3MmRj YWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYworKysg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKQEAgLTE0NzkzLDMgKzE0Nzkz LDEyMSBAQCBpbnRlbF9kaXNwbGF5X3ByaW50X2Vycm9yX3N0YXRlKHN0cnVjdCAKZHJtX2k5MTVf ZXJyb3Jfc3RhdGVfYnVmICptLAogICAgICAgICAgZXJyX3ByaW50ZihtLCAiICBWU1lOQzogJTA4 eFxuIiwgZXJyb3ItPnRyYW5zY29kZXJbaV0udnN5bmMpOwogICAgICB9CiAgfQorCitib29sIGNo dl91cGZyb250X2xpbmtfdHJhaW4oc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKyAgICAgICAgc3Ry dWN0IGludGVsX2RwICppbnRlbF9kcCwgc3RydWN0IGludGVsX2NydGMgKmNydGMpCit7CisgICAg c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKKyAg ICBzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IgPSBpbnRlbF9kcC0+YXR0YWNoZWRf Y29ubmVjdG9yOworICAgIHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyID0gY29ubmVjdG9y LT5lbmNvZGVyOworICAgIGJvb2wgZm91bmQgPSBmYWxzZTsKKyAgICBib29sIHZhbGlkX2NydGMg PSBmYWxzZTsKKworICAgIGlmICghY29ubmVjdG9yIHx8ICFlbmNvZGVyKSB7CisgICAgICAgIERS TV9ERUJVR19LTVMoImRwIGNvbm5lY3Rvci9lbmNvZGVyIGlzIE5VTExcbiIpOworICAgICAgICBy ZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgLyogSWYgd2UgYWxyZWFkeSBoYXZlIGEgY3J0Yywg c3RhcnQgbGluayB0cmFpbmluZyBkaXJlY3RseSAqLworICAgIGlmIChjcnRjKSB7CisgICAgICAg IHZhbGlkX2NydGMgPSB0cnVlOworICAgICAgICBnb3RvIHN0YXJ0X2xpbmtfdHJhaW47CisgICAg fQorCisgICAgLyogRmluZCBhbiB1bnVzZWQgY3J0YyBhbmQgdXNlIGl0IGZvciBsaW5rIHRyYWlu aW5nICovCisgICAgZm9yX2VhY2hfaW50ZWxfY3J0YyhkZXYsIGNydGMpIHsKKyAgICAgICAgaWYg KGludGVsX2NydGNfYWN0aXZlKCZjcnRjLT5iYXNlKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOwor CisgICAgICAgIGNvbm5lY3Rvci0+bmV3X2VuY29kZXIgPSBlbmNvZGVyOworICAgICAgICBlbmNv ZGVyLT5uZXdfY3J0YyA9IGNydGM7CisgICAgICAgIGVuY29kZXItPmJhc2UuY3J0YyA9ICZjcnRj LT5iYXNlOworCisgICAgICAgIC8qIE1ha2Ugc3VyZSB0aGUgbmV3IGNydGMgd2lsbCB3b3JrIHdp dGggdGhlIGVuY29kZXIgKi8KKyAgICAgICAgaWYgKGRybV9lbmNvZGVyX2NydGNfb2soJmVuY29k ZXItPmJhc2UsCisgICAgICAgICAgICAgICAgICAgICAmY3J0Yy0+YmFzZSkpIHsKKyAgICAgICAg ICAgIGZvdW5kID0gdHJ1ZTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQor CisgICAgaWYgKCFmb3VuZCkgeworICAgICAgICBEUk1fRVJST1IoIkNvdWxkIG5vdCBmaW5kIGNy dGMgZm9yIHVwZnJvbnQgbGluayB0cmFpbmluZ1xuIik7CisgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICB9CisKK3N0YXJ0X2xpbmtfdHJhaW46CisKKyAgICBEUk1fREVCVUdfS01TKCJ1cGZyb250 IGxpbmsgdHJhaW5pbmcgb24gcGlwZTolY1xuIiwKKyAgICAgICAgICAgICAgICAgICAgcGlwZV9u YW1lKGNydGMtPnBpcGUpKTsKKyAgICBmb3VuZCA9IGZhbHNlOworCisgICAgLyogSW5pdGlhbGl6 ZSB3aXRoIE1heCBMaW5rIHJhdGUgJiBsYW5lIGNvdW50IHN1cHBvcnRlZCBieSBwYW5lbCAqLwor ICAgIGludGVsX2RwLT5saW5rX2J3ID0gIGludGVsX2RwLT5kcGNkW0RQX01BWF9MSU5LX1JBVEVd OworICAgIGludGVsX2RwLT5sYW5lX2NvdW50ID0gaW50ZWxfZHAtPmRwY2RbRFBfTUFYX0xBTkVf Q09VTlRdICYKKyAgICAgICAgICAgICAgICAgICAgRFBfTUFYX0xBTkVfQ09VTlRfTUFTSzsKKwor ICAgIGRvIHsKKyAgICAgICAgLyogRmluZCBwb3J0IGNsb2NrIGZyb20gbGlua19idyAqLworICAg ICAgICBjcnRjLT5jb25maWcucG9ydF9jbG9jayA9CisgICAgICAgICAgICAgICAgZHJtX2RwX2J3 X2NvZGVfdG9fbGlua19yYXRlKGludGVsX2RwLT5saW5rX2J3KTsKKworICAgICAgICAvKiBFbmFi bGUgUExMIGZvbGxvd2VkIGJ5IHBvcnQgKi8KKyAgICAgICAgaW50ZWxfZHBfc2V0X2Nsb2NrKGVu Y29kZXIsICZjcnRjLT5jb25maWcsIGludGVsX2RwLT5saW5rX2J3KTsKKyAgICAgICAgY2h2X3Vw ZGF0ZV9wbGwoY3J0Yyk7CisgICAgICAgIGVuY29kZXItPnByZV9wbGxfZW5hYmxlKGVuY29kZXIp OworICAgICAgICBjaHZfZW5hYmxlX3BsbChjcnRjKTsKKyAgICAgICAgZW5jb2Rlci0+cHJlX2Vu YWJsZShlbmNvZGVyKTsKKworICAgICAgICAvKiBDaGVjayBpZiBsaW5rIHRyYWluaW5nIHBhc3Nl ZDsgaWYgc28gdXBkYXRlIGxhbmUgY291bnQgKi8KKyAgICAgICAgaWYgKGludGVsX2RwLT50cmFp bl9zZXRfdmFsaWQpIHsKKyAgICAgICAgICAgIGludGVsX2RwLT5kcGNkW0RQX01BWF9MQU5FX0NP VU5UXSAmPQorICAgICAgICAgICAgICAgICAgICAgICAgfkRQX01BWF9MQU5FX0NPVU5UX01BU0s7 CisgICAgICAgICAgICBpbnRlbF9kcC0+ZHBjZFtEUF9NQVhfTEFORV9DT1VOVF0gfD0KKyAgICAg ICAgICAgICAgICBpbnRlbF9kcC0+bGFuZV9jb3VudCAmIERQX01BWF9MQU5FX0NPVU5UX01BU0s7 CisKKyAgICAgICAgICAgIGZvdW5kID0gdHJ1ZTsKKyAgICAgICAgfQorCisgICAgICAgIC8qIFJl c2V0IGVuY29kZXIgZm9yIG5leHQgcmV0cnkgb3IgZm9yIGNsZWFuIHVwICovCisgICAgICAgIGVu Y29kZXItPmRpc2FibGUoZW5jb2Rlcik7CisgICAgICAgIGVuY29kZXItPnBvc3RfZGlzYWJsZShl bmNvZGVyKTsKKyAgICAgICAgY2h2X2Rpc2FibGVfcGxsKGRldl9wcml2LCBjcnRjLT5waXBlKTsK KworICAgICAgICBpZiAoZm91bmQpCisgICAgICAgICAgICBnb3RvIGV4aXQ7CisKKyAgICAgICAg RFJNX0RFQlVHX0tNUygidXBmcm9udCBsaW5rIHRyYWluaW5nIGZhaWxlZC4gbGFuZXM6JWQgYnc6 JWRcbiIsCisgICAgICAgICAgICAgICAgaW50ZWxfZHAtPmxhbmVfY291bnQsIGludGVsX2RwLT5s aW5rX2J3KTsKKworICAgICAgICAvKiBHbyBkb3duIHRvIHRoZSBuZXh0IGxldmVsIGFuZCByZXRy eSBsaW5rIHRyYWluaW5nICovCisgICAgICAgIGlmIChpbnRlbF9kcC0+bGFuZV9jb3VudCA9PSA0 KSB7CisgICAgICAgICAgICBpbnRlbF9kcC0+bGFuZV9jb3VudCA9IDI7CisgICAgICAgIH0gZWxz ZSBpZiAoaW50ZWxfZHAtPmxhbmVfY291bnQgPT0gMikgeworICAgICAgICAgICAgaW50ZWxfZHAt PmxhbmVfY291bnQgPSAxOworICAgICAgICB9IGVsc2UgaWYgKGludGVsX2RwLT5saW5rX2J3ID09 IERQX0xJTktfQldfNV80KSB7CisgICAgICAgICAgICBpbnRlbF9kcC0+bGlua19idyA9IERQX0xJ TktfQldfMl83OworICAgICAgICAgICAgaW50ZWxfZHAtPmxhbmVfY291bnQgPSA0OworICAgICAg ICB9IGVsc2UgaWYgKGludGVsX2RwLT5saW5rX2J3ID09IERQX0xJTktfQldfMl83KSB7CisgICAg ICAgICAgICBpbnRlbF9kcC0+bGlua19idyA9IERQX0xJTktfQldfMV82MjsKKyAgICAgICAgICAg IGludGVsX2RwLT5sYW5lX2NvdW50ID0gNDsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAg IC8qIFRyaWVkIGFsbCBjb21iaW5hdGlvbnMsIHNvIGV4aXQgKi8KKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICB9CisKKyAgICB9IHdoaWxlICgxKTsKKworZXhpdDoKKyAgICAvKiBDbGVhciBs b2NhbCBhc3NvY2lhdGlvbnMgbWFkZSAqLworICAgIGlmICghdmFsaWRfY3J0YykgeworICAgICAg ICBjb25uZWN0b3ItPm5ld19lbmNvZGVyID0gTlVMTDsKKyAgICAgICAgZW5jb2Rlci0+bmV3X2Ny dGMgPSBOVUxMOworICAgICAgICBlbmNvZGVyLT5iYXNlLmNydGMgPSBOVUxMOworICAgIH0KKwor ICAgIGlmIChmb3VuZCkKKyAgICAgICAgRFJNX0RFQlVHX0tNUygidXBmcm9udCBsaW5rIHRyYWlu aW5nIHBhc3NlZC4gbGFuZXM6JWQgYnc6JWRcbiIsCisgICAgICAgICAgICAgICAgaW50ZWxfZHAt PmxhbmVfY291bnQsIGludGVsX2RwLT5saW5rX2J3KTsKKyAgICByZXR1cm4gZm91bmQ7Cit9CmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jIApiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2RwLmMKaW5kZXggOTdmMDNiZi4uMzk0YTdhNSAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9kcC5jCkBAIC04NzgsNyArODc4LDcgQEAgaW50ZWxfZHBfY29ubmVjdG9yX3VucmVn aXN0ZXIoc3RydWN0IGludGVsX2Nvbm5lY3RvciAKKmludGVsX2Nvbm5lY3RvcikKICAgICAgaW50 ZWxfY29ubmVjdG9yX3VucmVnaXN0ZXIoaW50ZWxfY29ubmVjdG9yKTsKICB9Cgotc3RhdGljIHZv aWQKK3ZvaWQKICBpbnRlbF9kcF9zZXRfY2xvY2soc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29k ZXIsCiAgICAgICAgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19jb25maWcgKnBpcGVfY29uZmlnLCBp bnQgbGlua19idykKICB7CkBAIC0xMDEwLDcgKzEwMTAsNiBAQCBpbnRlbF9kcF9jb21wdXRlX2Nv bmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKICAgICAgICAgICAgICAgICAgbGlu a19jbG9jayA9IGRybV9kcF9id19jb2RlX3RvX2xpbmtfcmF0ZShid3NbY2xvY2tdKTsKICAgICAg ICAgICAgICAgICAgbGlua19hdmFpbCA9IGludGVsX2RwX21heF9kYXRhX3JhdGUobGlua19jbG9j aywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsYW5lX2NvdW50KTsKLQog ICAgICAgICAgICAgICAgICBpZiAobW9kZV9yYXRlIDw9IGxpbmtfYXZhaWwpIHsKICAgICAgICAg ICAgICAgICAgICAgIGdvdG8gZm91bmQ7CiAgICAgICAgICAgICAgICAgIH0KQEAgLTQ1MjIsNiAr NDUyMSwxMSBAQCBnNHhfZHBfZGV0ZWN0KHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHApCiAgICAg IGlmICgoSTkxNV9SRUFEKFBPUlRfSE9UUExVR19TVEFUKSAmIGJpdCkgPT0gMCkKICAgICAgICAg IHJldHVybiBjb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKCisgICAgLyogQXZvaWQgRFBD RCBvcGVydGF0aW9ucyBpZiBzdGF0dXMgaXMgc2FtZSAqLworICAgIGlmIChpbnRlbF9kcC0+YXR0 YWNoZWRfY29ubmVjdG9yLT5iYXNlLnN0YXR1cyA9PQorICAgICAgICAgICAgICAgIGNvbm5lY3Rv cl9zdGF0dXNfY29ubmVjdGVkKQorICAgICAgICByZXR1cm4gY29ubmVjdG9yX3N0YXR1c19jb25u ZWN0ZWQ7CisKICAgICAgcmV0dXJuIGludGVsX2RwX2RldGVjdF9kcGNkKGludGVsX2RwKTsKICB9 CgpAQCAtNDU2NiwxMSArNDU3MCwxMyBAQCBpbnRlbF9kcF9kZXRlY3Qoc3RydWN0IGRybV9jb25u ZWN0b3IgKmNvbm5lY3RvciwgCmJvb2wgZm9yY2UpCiAgICAgIHN0cnVjdCBpbnRlbF9kcCAqaW50 ZWxfZHAgPSBpbnRlbF9hdHRhY2hlZF9kcChjb25uZWN0b3IpOwogICAgICBzdHJ1Y3QgaW50ZWxf ZGlnaXRhbF9wb3J0ICppbnRlbF9kaWdfcG9ydCA9IGRwX3RvX2RpZ19wb3J0KGludGVsX2RwKTsK ICAgICAgc3RydWN0IGludGVsX2VuY29kZXIgKmludGVsX2VuY29kZXIgPSAmaW50ZWxfZGlnX3Bv cnQtPmJhc2U7CisgICAgc3RydWN0IGRybV9jcnRjICpjcnRjID0gaW50ZWxfZGlnX3BvcnQtPmJh c2UuYmFzZS5jcnRjOwogICAgICBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY29ubmVjdG9yLT5k ZXY7CiAgICAgIHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3By aXZhdGU7CiAgICAgIGVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMgc3RhdHVzOwogICAgICBlbnVt IGludGVsX2Rpc3BsYXlfcG93ZXJfZG9tYWluIHBvd2VyX2RvbWFpbjsKICAgICAgc3RydWN0IGVk aWQgKmVkaWQgPSBOVUxMOworICAgIHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjID0gTlVM TDsKCiAgICAgIGludGVsX3J1bnRpbWVfcG1fZ2V0KGRldl9wcml2KTsKCkBAIC00NTkwLDYgKzQ1 OTYsMTEgQEAgaW50ZWxfZHBfZGV0ZWN0KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3Is IApib29sIGZvcmNlKQogICAgICBpZiAoc3RhdHVzICE9IGNvbm5lY3Rvcl9zdGF0dXNfY29ubmVj dGVkKQogICAgICAgICAgZ290byBvdXQ7CgorICAgIGlmIChjb25uZWN0b3ItPnN0YXR1cyA9PSBj b25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZCkgeworICAgICAgICBEUk1fREVCVUdfS01TKCJDb25u ZWN0b3Igc3RhdHVzIGlzIGFscmVhZHkgY29ubmVjdGVkXG4iKTsKKyAgICAgICAgZ290byBvdXQ7 CisgICAgfQorCiAgICAgIGludGVsX2RwX3Byb2JlX291aShpbnRlbF9kcCk7CgogICAgICBpZiAo aW50ZWxfZHAtPmZvcmNlX2F1ZGlvICE9IEhETUlfQVVESU9fQVVUTykgewpAQCAtNDYwNCw2ICs0 NjE1LDIyIEBAIGludGVsX2RwX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y LCAKYm9vbCBmb3JjZSkKCiAgICAgIGlmIChpbnRlbF9lbmNvZGVyLT50eXBlICE9IElOVEVMX09V VFBVVF9FRFApCiAgICAgICAgICBpbnRlbF9lbmNvZGVyLT50eXBlID0gSU5URUxfT1VUUFVUX0RJ U1BMQVlQT1JUOworCisgICAgaWYgKElTX0NIRVJSWVZJRVcoZGV2KSAmJgorICAgICAgICAgICAg aW50ZWxfZW5jb2Rlci0+dHlwZSA9PSBJTlRFTF9PVVRQVVRfRElTUExBWVBPUlQpIHsKKyAgICAg ICAgLyogSGFuZGxlIGNvbm5lY3RlZCBib290IHNjZW5hcmlvIHdoZXJlIHBhbmVsIGlzIGVuYWJs ZWQKKyAgICAgICAgICogYnkgR09QL1ZCSU9TLgorICAgICAgICAgKi8KKyAgICAgICAgaWYgKGlu dGVsX2VuY29kZXItPmNvbm5lY3RvcnNfYWN0aXZlICYmCisgICAgICAgICAgICAgICAgICAgICAg ICBjcnRjICYmIGNydGMtPmVuYWJsZWQpIHsKKyAgICAgICAgICAgIGludGVsX2NydGMgPSB0b19p bnRlbF9jcnRjKGNydGMpOworICAgICAgICAgICAgRFJNX0RFQlVHX0tNUygiRGlzYWJsaW5nIGNy dGMgJWMgZm9yIHVwZnJvbnQgbGluayB0cmFpbmluZ1xuIiwKKyAgICAgICAgICAgICAgICAgICAg cGlwZV9uYW1lKGludGVsX2NydGMtPnBpcGUpKTsKKyAgICAgICAgICAgIGludGVsX2NydGNfY29u dHJvbChjcnRjLCBmYWxzZSk7CisgICAgICAgIH0KKyAgICAgICAgY2h2X3VwZnJvbnRfbGlua190 cmFpbihkZXYsIGludGVsX2RwLCBpbnRlbF9jcnRjKTsKKyAgICB9CisKICAgICAgc3RhdHVzID0g Y29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQ7CgogIG91dDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2Rydi5oIApiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Ry di5oCmluZGV4IGZjMjY2ZGEuLjE1ZWVmOTRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaApA QCAtOTkxLDYgKzk5MSwxMCBAQCB2b2lkIGludGVsX2RwX3N0YXJ0X2xpbmtfdHJhaW4oc3RydWN0 IGludGVsX2RwIAoqaW50ZWxfZHApOwogIHZvaWQgaW50ZWxfZHBfY29tcGxldGVfbGlua190cmFp bihzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKTsKICB2b2lkIGludGVsX2RwX3N0b3BfbGlua190 cmFpbihzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKTsKICBib29sIGludGVsX2RwX2Zhc3RfbGlu a190cmFpbihzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKTsKK2Jvb2wgY2h2X3VwZnJvbnRfbGlu a190cmFpbihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorICAgICAgICAgICAgc3RydWN0IGludGVs X2RwICppbnRlbF9kcCwgc3RydWN0IGludGVsX2NydGMgKmNydGMpOwordm9pZCBpbnRlbF9kcF9z ZXRfY2xvY2soc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCisgICAgICAgICAgICBzdHJ1 Y3QgaW50ZWxfY3J0Y19jb25maWcgKnBpcGVfY29uZmlnLCBpbnQgbGlua19idyk7CiAgdm9pZCBp bnRlbF9kcF9zaW5rX2RwbXMoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwgaW50IG1vZGUpOwog IHZvaWQgaW50ZWxfZHBfc2V0X20yX24yKHN0cnVjdCBpbnRlbF9jcnRjICpjcnRjLCBzdHJ1Y3Qg aW50ZWxfbGlua19tX24gCiptX24pOwogIHZvaWQgaW50ZWxfZHBfZW5jb2Rlcl9kZXN0cm95KHN0 cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlcik7CgotLSAKcmVnYXJkcywKU2l2YWt1bWFyCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFp bGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cDovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1750935AbbG3ENm (ORCPT ); Thu, 30 Jul 2015 00:13:42 -0400 Received: from mga14.intel.com ([192.55.52.115]:23296 "EHLO mga14.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750732AbbG3ENl (ORCPT ); Thu, 30 Jul 2015 00:13:41 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.15,575,1432623600"; d="scan'208";a="532792411" Message-ID: <55B9A471.2070107@intel.com> Date: Thu, 30 Jul 2015 09:43:37 +0530 From: Sivakumar Thulasimani User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64; rv:31.0) Gecko/20100101 Thunderbird/31.7.0 MIME-Version: 1.0 To: Benjamin Tissoires CC: Daniel Vetter , intel-gfx@lists.freedesktop.org, Todd Broch , linux-kernel@vger.kernel.org Subject: Re: [Intel-gfx] [PATCH 3/3] drm/i915: Support DDI lane reversal for DP References: <1438099409-25456-1-git-send-email-benjamin.tissoires@redhat.com> <1438099409-25456-4-git-send-email-benjamin.tissoires@redhat.com> <55B88E25.6000006@intel.com> <20150729152240.GD2743@mail.corp.redhat.com> In-Reply-To: <20150729152240.GD2743@mail.corp.redhat.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 7/29/2015 8:52 PM, Benjamin Tissoires wrote: > On Jul 29 2015 or thereabouts, Sivakumar Thulasimani wrote: >> why not detect reverse in intel_dp_detect/intel_hpd_pulse ? that way you can >> identify both lane count and reversal state without touching anything in the >> link training code. i am yet to upstream my changes for CHT that i can share >> if required that does the same in intel_dp_detect without touching any line >> in link training path. > With my current limited knowledge of the dp hotplug (and i915 driver) I > am not sure we could detect the reversed state without trying to train 1 > lane only. I'd be glad to look at your changes and test them on my > system if you think that could help having a cleaner solution. > > Cheers, > Benjamin No, what i recommended was to do link training but in intel_dp_detect. Since USB Type C cable also has its own lane count restriction (it can have different lane count than the one supported by panel) you might have to figure that out as well. so both reversal and lane count detection can be done outside the modeset path and keep the code free of type C changes outside detection path. Please find below the code to do the same. Do not waste time trying to apply this directly on nightly since this is based on a local tree and because this is pre- atomic changes code, so you might have to modify chv_upfront_link_train to work on top of the latest nightly code. we are supposed to upstream this and is in my todo list. --------------------------------------------------------------------------------------------------------------------------- Author: Durgadoss R Date: Fri May 22 14:30:07 2015 +0530 drm/i915: Enable Upfront link training for type-C DP support To support USB type C alternate DP mode, the display driver needs to know the number of lanes required by DP panel as well as number of lanes that can be supported by the type-C cable. Sometimes, the type-C cable may limit the bandwidth even if Panel can support more lanes. To address these scenarios, the display driver will start link training with max lanes, and if the link training fails, the driver then falls back to x2 lanes. * Since link training is done before modeset, planes are not enabled. Only encoder and the its associated PLLs are enabled. * Once link training is done, the encoder and its PLLs are disabled; so that the subsequent modeset is not aware of these changes. * As of now, this is tested only on CHV. Signed-off-by: Durgadoss R diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 0c8ae2a..c72dcaa 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -14793,3 +14793,121 @@ intel_display_print_error_state(struct drm_i915_error_state_buf *m, err_printf(m, " VSYNC: %08x\n", error->transcoder[i].vsync); } } + +bool chv_upfront_link_train(struct drm_device *dev, + struct intel_dp *intel_dp, struct intel_crtc *crtc) +{ + struct drm_i915_private *dev_priv = dev->dev_private; + struct intel_connector *connector = intel_dp->attached_connector; + struct intel_encoder *encoder = connector->encoder; + bool found = false; + bool valid_crtc = false; + + if (!connector || !encoder) { + DRM_DEBUG_KMS("dp connector/encoder is NULL\n"); + return false; + } + + /* If we already have a crtc, start link training directly */ + if (crtc) { + valid_crtc = true; + goto start_link_train; + } + + /* Find an unused crtc and use it for link training */ + for_each_intel_crtc(dev, crtc) { + if (intel_crtc_active(&crtc->base)) + continue; + + connector->new_encoder = encoder; + encoder->new_crtc = crtc; + encoder->base.crtc = &crtc->base; + + /* Make sure the new crtc will work with the encoder */ + if (drm_encoder_crtc_ok(&encoder->base, + &crtc->base)) { + found = true; + break; + } + } + + if (!found) { + DRM_ERROR("Could not find crtc for upfront link training\n"); + return false; + } + +start_link_train: + + DRM_DEBUG_KMS("upfront link training on pipe:%c\n", + pipe_name(crtc->pipe)); + found = false; + + /* Initialize with Max Link rate & lane count supported by panel */ + intel_dp->link_bw = intel_dp->dpcd[DP_MAX_LINK_RATE]; + intel_dp->lane_count = intel_dp->dpcd[DP_MAX_LANE_COUNT] & + DP_MAX_LANE_COUNT_MASK; + + do { + /* Find port clock from link_bw */ + crtc->config.port_clock = + drm_dp_bw_code_to_link_rate(intel_dp->link_bw); + + /* Enable PLL followed by port */ + intel_dp_set_clock(encoder, &crtc->config, intel_dp->link_bw); + chv_update_pll(crtc); + encoder->pre_pll_enable(encoder); + chv_enable_pll(crtc); + encoder->pre_enable(encoder); + + /* Check if link training passed; if so update lane count */ + if (intel_dp->train_set_valid) { + intel_dp->dpcd[DP_MAX_LANE_COUNT] &= + ~DP_MAX_LANE_COUNT_MASK; + intel_dp->dpcd[DP_MAX_LANE_COUNT] |= + intel_dp->lane_count & DP_MAX_LANE_COUNT_MASK; + + found = true; + } + + /* Reset encoder for next retry or for clean up */ + encoder->disable(encoder); + encoder->post_disable(encoder); + chv_disable_pll(dev_priv, crtc->pipe); + + if (found) + goto exit; + + DRM_DEBUG_KMS("upfront link training failed. lanes:%d bw:%d\n", + intel_dp->lane_count, intel_dp->link_bw); + + /* Go down to the next level and retry link training */ + if (intel_dp->lane_count == 4) { + intel_dp->lane_count = 2; + } else if (intel_dp->lane_count == 2) { + intel_dp->lane_count = 1; + } else if (intel_dp->link_bw == DP_LINK_BW_5_4) { + intel_dp->link_bw = DP_LINK_BW_2_7; + intel_dp->lane_count = 4; + } else if (intel_dp->link_bw == DP_LINK_BW_2_7) { + intel_dp->link_bw = DP_LINK_BW_1_62; + intel_dp->lane_count = 4; + } else { + /* Tried all combinations, so exit */ + break; + } + + } while (1); + +exit: + /* Clear local associations made */ + if (!valid_crtc) { + connector->new_encoder = NULL; + encoder->new_crtc = NULL; + encoder->base.crtc = NULL; + } + + if (found) + DRM_DEBUG_KMS("upfront link training passed. lanes:%d bw:%d\n", + intel_dp->lane_count, intel_dp->link_bw); + return found; +} diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c index 97f03bf..394a7a5 100644 --- a/drivers/gpu/drm/i915/intel_dp.c +++ b/drivers/gpu/drm/i915/intel_dp.c @@ -878,7 +878,7 @@ intel_dp_connector_unregister(struct intel_connector *intel_connector) intel_connector_unregister(intel_connector); } -static void +void intel_dp_set_clock(struct intel_encoder *encoder, struct intel_crtc_config *pipe_config, int link_bw) { @@ -1010,7 +1010,6 @@ intel_dp_compute_config(struct intel_encoder *encoder, link_clock = drm_dp_bw_code_to_link_rate(bws[clock]); link_avail = intel_dp_max_data_rate(link_clock, lane_count); - if (mode_rate <= link_avail) { goto found; } @@ -4522,6 +4521,11 @@ g4x_dp_detect(struct intel_dp *intel_dp) if ((I915_READ(PORT_HOTPLUG_STAT) & bit) == 0) return connector_status_disconnected; + /* Avoid DPCD opertations if status is same */ + if (intel_dp->attached_connector->base.status == + connector_status_connected) + return connector_status_connected; + return intel_dp_detect_dpcd(intel_dp); } @@ -4566,11 +4570,13 @@ intel_dp_detect(struct drm_connector *connector, bool force) struct intel_dp *intel_dp = intel_attached_dp(connector); struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); struct intel_encoder *intel_encoder = &intel_dig_port->base; + struct drm_crtc *crtc = intel_dig_port->base.base.crtc; struct drm_device *dev = connector->dev; struct drm_i915_private *dev_priv = dev->dev_private; enum drm_connector_status status; enum intel_display_power_domain power_domain; struct edid *edid = NULL; + struct intel_crtc *intel_crtc = NULL; intel_runtime_pm_get(dev_priv); @@ -4590,6 +4596,11 @@ intel_dp_detect(struct drm_connector *connector, bool force) if (status != connector_status_connected) goto out; + if (connector->status == connector_status_connected) { + DRM_DEBUG_KMS("Connector status is already connected\n"); + goto out; + } + intel_dp_probe_oui(intel_dp); if (intel_dp->force_audio != HDMI_AUDIO_AUTO) { @@ -4604,6 +4615,22 @@ intel_dp_detect(struct drm_connector *connector, bool force) if (intel_encoder->type != INTEL_OUTPUT_EDP) intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT; + + if (IS_CHERRYVIEW(dev) && + intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT) { + /* Handle connected boot scenario where panel is enabled + * by GOP/VBIOS. + */ + if (intel_encoder->connectors_active && + crtc && crtc->enabled) { + intel_crtc = to_intel_crtc(crtc); + DRM_DEBUG_KMS("Disabling crtc %c for upfront link training\n", + pipe_name(intel_crtc->pipe)); + intel_crtc_control(crtc, false); + } + chv_upfront_link_train(dev, intel_dp, intel_crtc); + } + status = connector_status_connected; out: diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index fc266da..15eef94d 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -991,6 +991,10 @@ void intel_dp_start_link_train(struct intel_dp *intel_dp); void intel_dp_complete_link_train(struct intel_dp *intel_dp); void intel_dp_stop_link_train(struct intel_dp *intel_dp); bool intel_dp_fast_link_train(struct intel_dp *intel_dp); +bool chv_upfront_link_train(struct drm_device *dev, + struct intel_dp *intel_dp, struct intel_crtc *crtc); +void intel_dp_set_clock(struct intel_encoder *encoder, + struct intel_crtc_config *pipe_config, int link_bw); void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode); void intel_dp_set_m2_n2(struct intel_crtc *crtc, struct intel_link_m_n *m_n); void intel_dp_encoder_destroy(struct drm_encoder *encoder); -- regards, Sivakumar