From mboxrd@z Thu Jan 1 00:00:00 1970 From: Benjamin Tissoires Subject: Re: [PATCH 3/3] drm/i915: Support DDI lane reversal for DP Date: Wed, 5 Aug 2015 15:34:27 -0400 Message-ID: <20150805193427.GA6097@mail.corp.redhat.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> <55B9A471.2070107@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by gabe.freedesktop.org (Postfix) with ESMTPS id 6C29B6E978 for ; Wed, 5 Aug 2015 12:34:31 -0700 (PDT) Content-Disposition: inline In-Reply-To: <55B9A471.2070107@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Sivakumar Thulasimani Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, Todd Broch , linux-kernel@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org T24gSnVsIDMwIDIwMTUgb3IgdGhlcmVhYm91dHMsIFNpdmFrdW1hciBUaHVsYXNpbWFuaSB3cm90 ZToKPiAKPiAKPiBPbiA3LzI5LzIwMTUgODo1MiBQTSwgQmVuamFtaW4gVGlzc29pcmVzIHdyb3Rl Ogo+ID5PbiBKdWwgMjkgMjAxNSBvciB0aGVyZWFib3V0cywgU2l2YWt1bWFyIFRodWxhc2ltYW5p IHdyb3RlOgo+ID4+d2h5IG5vdCBkZXRlY3QgcmV2ZXJzZSBpbiBpbnRlbF9kcF9kZXRlY3QvaW50 ZWxfaHBkX3B1bHNlID8gdGhhdCB3YXkgeW91IGNhbgo+ID4+aWRlbnRpZnkgYm90aCBsYW5lIGNv dW50IGFuZCByZXZlcnNhbCBzdGF0ZSB3aXRob3V0IHRvdWNoaW5nIGFueXRoaW5nIGluIHRoZQo+ ID4+bGluayB0cmFpbmluZyBjb2RlLiBpIGFtIHlldCB0byB1cHN0cmVhbSBteSBjaGFuZ2VzIGZv ciBDSFQgdGhhdCBpIGNhbiBzaGFyZQo+ID4+aWYgcmVxdWlyZWQgdGhhdCBkb2VzIHRoZSBzYW1l IGluIGludGVsX2RwX2RldGVjdCB3aXRob3V0IHRvdWNoaW5nIGFueSBsaW5lCj4gPj5pbiBsaW5r IHRyYWluaW5nIHBhdGguCj4gPldpdGggbXkgY3VycmVudCBsaW1pdGVkIGtub3dsZWRnZSBvZiB0 aGUgZHAgaG90cGx1ZyAoYW5kIGk5MTUgZHJpdmVyKSBJCj4gPmFtIG5vdCBzdXJlIHdlIGNvdWxk IGRldGVjdCB0aGUgcmV2ZXJzZWQgc3RhdGUgd2l0aG91dCB0cnlpbmcgdG8gdHJhaW4gMQo+ID5s YW5lIG9ubHkuIEknZCBiZSBnbGFkIHRvIGxvb2sgYXQgeW91ciBjaGFuZ2VzIGFuZCB0ZXN0IHRo ZW0gb24gbXkKPiA+c3lzdGVtIGlmIHlvdSB0aGluayB0aGF0IGNvdWxkIGhlbHAgaGF2aW5nIGEg Y2xlYW5lciBzb2x1dGlvbi4KPiA+Cj4gPkNoZWVycywKPiA+QmVuamFtaW4KPiBObywgd2hhdCBp IHJlY29tbWVuZGVkIHdhcyB0byBkbyBsaW5rIHRyYWluaW5nIGJ1dCBpbiBpbnRlbF9kcF9kZXRl Y3QuIFNpbmNlCj4gVVNCIFR5cGUgQyBjYWJsZQo+IGFsc28gaGFzIGl0cyBvd24gbGFuZSBjb3Vu dCByZXN0cmljdGlvbiAoaXQgY2FuIGhhdmUgZGlmZmVyZW50IGxhbmUgY291bnQKPiB0aGFuIHRo ZSBvbmUgc3VwcG9ydGVkCj4gYnkgcGFuZWwpIHlvdSBtaWdodCBoYXZlIHRvIGZpZ3VyZSB0aGF0 IG91dCBhcyB3ZWxsLiBzbyBib3RoIHJldmVyc2FsIGFuZAo+IGxhbmUgY291bnQgZGV0ZWN0aW9u Cj4gY2FuIGJlIGRvbmUgb3V0c2lkZSB0aGUgbW9kZXNldCBwYXRoIGFuZCBrZWVwIHRoZSBjb2Rl IGZyZWUgb2YgdHlwZSBDCj4gY2hhbmdlcyBvdXRzaWRlCj4gZGV0ZWN0aW9uIHBhdGguCj4gCj4g UGxlYXNlIGZpbmQgYmVsb3cgdGhlIGNvZGUgdG8gZG8gdGhlIHNhbWUuIERvIG5vdCB3YXN0ZSB0 aW1lIHRyeWluZyB0byBhcHBseQo+IHRoaXMgZGlyZWN0bHkgb24KPiBuaWdodGx5IHNpbmNlIHRo aXMgaXMgYmFzZWQgb24gYSBsb2NhbCB0cmVlIGFuZCBiZWNhdXNlIHRoaXMgaXMgcHJlLSBhdG9t aWMKPiBjaGFuZ2VzIGNvZGUsIHNvIHlvdQo+IG1pZ2h0IGhhdmUgdG8gbW9kaWZ5IGNodl91cGZy b250X2xpbmtfdHJhaW4gdG8gd29yayBvbiB0b3Agb2YgdGhlIGxhdGVzdAo+IG5pZ2h0bHkgY29k ZS4gd2UKPiBhcmUgc3VwcG9zZWQgdG8gdXBzdHJlYW0gdGhpcyBhbmQgaXMgaW4gbXkgdG9kbyBs aXN0Lgo+IAoKW29yaWdpbmFsIHBhdGNoIHNuaXBwZWQuLi5dCgpIaSBTaXZha3VtYXIsCgpTbyBJ IG1hbmFnZWQgdG8gbWFudWFsbHkgcmUtYXBwbHkgeW91ciBwYXRjaCBvbiB0b3Agb2YKZHJtLWlu dGVsLW5pZ2h0bHksIGFuZCB0cmllZCB0byBwb3J0IGl0IHRvIG1ha2UgQnJvYWR3ZWxsIHdvcmtp bmcgdG9vLgpJdCB3b3JrcyBPSyBpZiB0aGUgc3lzdGVtIGlzIGFscmVhZHkgYm9vdCB3aXRob3V0 IGFueSBleHRlcm5hbCBEUCB1c2VkLgpJbiB0aGlzIGNhc2UsIHRoZSBkZXRlY3Rpb24gd29ya3Mg YW5kIEkgY2FuIHNlZSBteSBleHRlcm5hbCBtb25pdG9yCndvcmtpbmcgcHJvcGVybHkuCgpIb3dl dmVyLCBpZiB0aGUgbW9uaXRvciBpcyBjb2xkIHBsdWdnZWQsIHRoZSBjcHUvR1BVIGhhbmdzIGFu ZCBJIGNhbiBub3QKdW5kZXJzdGFuZCB3aHkuIEkgdGhpbmsgSSBlbmFibGVkIGFsbCB0aGF0IGlz IG1lbnRpb25lZCBpbiB0aGUgUFJNIHRvIGJlCmFibGUgdG8gdHJhaW4gdGhlIERQIGxpbmssIGJ1 dCBJIGFtIG9idmlvdXNseSBtaXNzaW5nIHNvbWV0aGluZyBlbHNlLgpDYW4geW91IGhhdmUgYSBs b29rPwoKTXkgcGF0Y2ggaXMgbm93OgoKRnJvbSAxMWU5YzQyZjU1YWUyN2JkNmU3YjAxNjhiZjI0 ZDE1MDgyYzdkNTE3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEdXJnYWRvc3MgUiA8 ZHVyZ2Fkb3NzLnJAaW50ZWwuY29tPgpEYXRlOiBNb24sIDMgQXVnIDIwMTUgMTE6NTE6MTYgLTA0 MDAKU3ViamVjdDogW1BBVENIXSBkcm0vaTkxNTogRW5hYmxlIFVwZnJvbnQgbGluayB0cmFpbmlu ZyBmb3IgdHlwZS1DIERQIHN1cHBvcnQKClRvIHN1cHBvcnQgVVNCIHR5cGUgQyBhbHRlcm5hdGUg RFAgbW9kZSwgdGhlIGRpc3BsYXkgZHJpdmVyIG5lZWRzIHRvIGtub3cgdGhlCm51bWJlciBvZiBs YW5lcyByZXF1aXJlZCBieSBEUCBwYW5lbCBhcyB3ZWxsIGFzIG51bWJlciBvZiBsYW5lcyB0aGF0 IGNhbiBiZQpzdXBwb3J0ZWQgYnkgdGhlIHR5cGUtQyBjYWJsZS4gU29tZXRpbWVzLCB0aGUgdHlw ZS1DIGNhYmxlIG1heSBsaW1pdCB0aGUKYmFuZHdpZHRoIGV2ZW4gaWYgUGFuZWwgY2FuIHN1cHBv cnQgbW9yZSBsYW5lcy4gVG8gYWRkcmVzcyB0aGVzZSBzY2VuYXJpb3MsCnRoZSBkaXNwbGF5IGRy aXZlciB3aWxsIHN0YXJ0IGxpbmsgdHJhaW5pbmcgd2l0aCBtYXggbGFuZXMsIGFuZCBpZiB0aGUg bGluawp0cmFpbmluZyBmYWlscywgdGhlIGRyaXZlciB0aGVuIGZhbGxzIGJhY2sgdG8geDIgbGFu ZXMuCgoqIFNpbmNlIGxpbmsgdHJhaW5pbmcgaXMgZG9uZSBiZWZvcmUgbW9kZXNldCwgcGxhbmVz IGFyZSBub3QgZW5hYmxlZC4gT25seQogIGVuY29kZXIgYW5kIHRoZSBpdHMgYXNzb2NpYXRlZCBQ TExzIGFyZSBlbmFibGVkLgoqIE9uY2UgbGluayB0cmFpbmluZyBpcyBkb25lLCB0aGUgZW5jb2Rl ciBhbmQgaXRzIFBMTHMgYXJlIGRpc2FibGVkOyBzbyB0aGF0CiAgdGhlIHN1YnNlcXVlbnQgbW9k ZXNldCBpcyBub3QgYXdhcmUgb2YgdGhlc2UgY2hhbmdlcy4KKiBBcyBvZiBub3csIHRoaXMgaXMg dGVzdGVkIG9ubHkgb24gQ0hWLgoKU2lnbmVkLW9mZi1ieTogRHVyZ2Fkb3NzIFIgPGR1cmdhZG9z cy5yQGludGVsLmNvbT4KW0JUOiBhZGQgYnJvYWR3ZWxsIHN1cHBvcnQgYW5kIFVTQi1DIHJldmVy dGVkIHN0YXRlIGRldGVjdGlvbl0KU2lnbmVkLW9mZi1ieTogQmVuamFtaW4gVGlzc29pcmVzIDxi ZW5qYW1pbi50aXNzb2lyZXNAcmVkaGF0LmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kaXNwbGF5LmMgfCAxNjMgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwLmMgICAgICB8ICAyMiArKysrLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICAgIHwgICA3ICsrCiAzIGZpbGVzIGNoYW5nZWQs IDE5MCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2Rpc3BsYXkuYwppbmRleCA4MThmM2EzLi5lOGRkYmEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZGlzcGxheS5jCkBAIC0xNTc5OSwzICsxNTc5OSwxNjYgQEAgdm9pZCBpbnRlbF9tb2Rlc2V0 X3ByZWNsb3NlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fZmlsZSAqZmlsZSkK IAkJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPmV2ZW50X2xvY2spOwogCX0KIH0KKworc3RhdGljIGJv b2wKK2ludGVsX3VwZnJvbnRfbGlua190cmFpbl9jb25maWcoc3RydWN0IGRybV9kZXZpY2UgKmRl diwKKwkJCQlzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAorCQkJCXN0cnVjdCBpbnRlbF9jcnRj ICpjcnRjLAorCQkJCXVpbnQ4X3QgbGlua19idywKKwkJCQl1aW50OF90IGxhbmVfY291bnQpCit7 CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsK KwlzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IgPSBpbnRlbF9kcC0+YXR0YWNoZWRf Y29ubmVjdG9yOworCXN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyID0gY29ubmVjdG9yLT5l bmNvZGVyOworCWJvb2wgc3VjY2VzczsKKworCWludGVsX2RwLT5saW5rX2J3ID0gbGlua19idzsK KwlpbnRlbF9kcC0+bGFuZV9jb3VudCA9IGxhbmVfY291bnQ7CisKKwkvKiBGaW5kIHBvcnQgY2xv Y2sgZnJvbSBsaW5rX2J3ICovCisJY3J0Yy0+Y29uZmlnLT5wb3J0X2Nsb2NrID0gZHJtX2RwX2J3 X2NvZGVfdG9fbGlua19yYXRlKGludGVsX2RwLT5saW5rX2J3KTsKKworCS8qIEVuYWJsZSBQTEwg Zm9sbG93ZWQgYnkgcG9ydCAqLworCWlmIChJU19CUk9BRFdFTEwoZGV2KSkgeworCQloc3dfZHBf c2V0X2RkaV9wbGxfc2VsKGNydGMtPmNvbmZpZywgaW50ZWxfZHAtPmxpbmtfYncpOworCQlpZiAo aW50ZWxfY3J0Y190b19zaGFyZWRfZHBsbChjcnRjKSkKKwkJCWludGVsX2VuYWJsZV9zaGFyZWRf ZHBsbChjcnRjKTsKKworCQlpbnRlbF9zZXRfY3B1X2ZpZm9fdW5kZXJydW5fcmVwb3J0aW5nKGRl dl9wcml2LCBjcnRjLT5waXBlLCB0cnVlKTsKKworCX0gZWxzZSBpZiAoSVNfQ0hFUlJZVklFVyhk ZXYpKSB7CisJCWludGVsX2RwX3NldF9jbG9jayhlbmNvZGVyLCBjcnRjLT5jb25maWcsIGludGVs X2RwLT5saW5rX2J3KTsKKwkJaWYgKGVuY29kZXItPnByZV9wbGxfZW5hYmxlKQorCQkJZW5jb2Rl ci0+cHJlX3BsbF9lbmFibGUoZW5jb2Rlcik7CisJCWlmICghaW50ZWxfcGlwZV9oYXNfdHlwZShj cnRjLCBJTlRFTF9PVVRQVVRfRFNJKSkKKwkJCWNodl9lbmFibGVfcGxsKGNydGMsIGNydGMtPmNv bmZpZyk7CisJfQorCWlmIChlbmNvZGVyLT5wcmVfZW5hYmxlKQorCQllbmNvZGVyLT5wcmVfZW5h YmxlKGVuY29kZXIpOworCisJc3VjY2VzcyA9IGludGVsX2RwLT50cmFpbl9zZXRfdmFsaWQ7CisK KwkvKiBSZXNldCBlbmNvZGVyIGZvciBuZXh0IHJldHJ5IG9yIGZvciBjbGVhbiB1cCAqLworCWlm IChlbmNvZGVyLT5wb3N0X2Rpc2FibGUpCisJCWVuY29kZXItPnBvc3RfZGlzYWJsZShlbmNvZGVy KTsKKwlpZiAoSVNfQ0hFUlJZVklFVyhkZXYpKSB7CisJCWlmICghaW50ZWxfcGlwZV9oYXNfdHlw ZShjcnRjLCBJTlRFTF9PVVRQVVRfRFNJKSkKKwkJCWNodl9kaXNhYmxlX3BsbChkZXZfcHJpdiwg Y3J0Yy0+cGlwZSk7CisJfSBlbHNlIGlmIChJU19CUk9BRFdFTEwoZGV2KSkgeworCQlpbnRlbF9z ZXRfY3B1X2ZpZm9fdW5kZXJydW5fcmVwb3J0aW5nKGRldl9wcml2LCBjcnRjLT5waXBlLCBmYWxz ZSk7CisJCWlmIChpbnRlbF9jcnRjX3RvX3NoYXJlZF9kcGxsKGNydGMpKQorCQkJaW50ZWxfZGlz YWJsZV9zaGFyZWRfZHBsbChjcnRjKTsKKwl9CisKKwlpbnRlbF9kcC0+dHJhaW5fc2V0X3ZhbGlk ID0gZmFsc2U7CisKKwlyZXR1cm4gc3VjY2VzczsKK30KKworYm9vbAoraW50ZWxfdXBmcm9udF9s aW5rX3RyYWluKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCQkgc3RydWN0IGludGVsX2RwICpp bnRlbF9kcCwKKwkJCSBzdHJ1Y3QgaW50ZWxfY3J0YyAqY3J0YykKK3sKKwlzdHJ1Y3QgaW50ZWxf Y29ubmVjdG9yICpjb25uZWN0b3IgPSBpbnRlbF9kcC0+YXR0YWNoZWRfY29ubmVjdG9yOworCXN0 cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyID0gY29ubmVjdG9yLT5lbmNvZGVyOworCXN0cnVj dCBpbnRlbF9kaWdpdGFsX3BvcnQgKmludGVsX2RpZ19wb3J0ID0gZW5jX3RvX2RpZ19wb3J0KCZl bmNvZGVyLT5iYXNlKTsKKwl1aW50OF90IGxpbmtfYncsIGxhbmVfY291bnQ7CisJYm9vbCBmb3Vu ZCA9IGZhbHNlOworCWJvb2wgdmFsaWRfY3J0YyA9ICEhY3J0YzsKKworCWlmICghY29ubmVjdG9y IHx8ICFlbmNvZGVyKSB7CisJCURSTV9ERUJVR19LTVMoImRwIGNvbm5lY3Rvci9lbmNvZGVyIGlz IE5VTExcbiIpOworCQlyZXR1cm4gZmFsc2U7CisJfQorCisJLyogRmluZCBhbiB1bnVzZWQgY3J0 YyBhbmQgdXNlIGl0IGZvciBsaW5rIHRyYWluaW5nIGlmIG5vIGNydGMgaXMgZ2l2ZW4gKi8KKwlp ZiAoIWNydGMpIHsKKwkJZm9yX2VhY2hfaW50ZWxfY3J0YyhkZXYsIGNydGMpIHsKKwkJCWlmIChp bnRlbF9jcnRjX2FjdGl2ZSgmY3J0Yy0+YmFzZSkpCisJCQkJY29udGludWU7CisKKwkJCS8qIE1h a2Ugc3VyZSB0aGUgbmV3IGNydGMgd2lsbCB3b3JrIHdpdGggdGhlIGVuY29kZXIgKi8KKwkJCWlm ICghZHJtX2VuY29kZXJfY3J0Y19vaygmZW5jb2Rlci0+YmFzZSwgJmNydGMtPmJhc2UpKQorCQkJ CWNvbnRpbnVlOworCisJCQllbmNvZGVyLT5iYXNlLmNydGMgPSAmY3J0Yy0+YmFzZTsKKworCQkJ Zm91bmQgPSB0cnVlOworCQkJYnJlYWs7CisJCX0KKworCQlpZiAoIWZvdW5kKSB7CisJCQlEUk1f RVJST1IoIkNvdWxkIG5vdCBmaW5kIGNydGMgZm9yIHVwZnJvbnQgbGluayB0cmFpbmluZ1xuIik7 CisJCQlnb3RvIGV4aXQ7CisJCX0KKwl9CisKKwlEUk1fREVCVUdfS01TKCJ1cGZyb250IGxpbmsg dHJhaW5pbmcgb24gcGlwZTolY1xuIiwKKwkJICAgICAgcGlwZV9uYW1lKGNydGMtPnBpcGUpKTsK KworCS8qIGNoZWNrIHRoZSByZXZlcnNlZCBzdGF0ZSBvZiB0aGUgYWRhcHRlciBmaXJzdCAqLwor CisJLyogdW5zZXQgdGhlIHJldmVyc2FsIGJpdCAqLworCWludGVsX2RpZ19wb3J0LT5zYXZlZF9w b3J0X2JpdHMgJj0gfkRESV9CVUZfUE9SVF9SRVZFUlNBTDsKKworCS8qIEluaXRpYWxpemUgd2l0 aCBNYXggTGluayByYXRlIHN1cHBvcnRlZCBieSBwYW5lbCAmIG9uZSBsYW5lICovCisJaW50ZWxf ZHAtPmxpbmtfYncgPSBpbnRlbF9kcC0+ZHBjZFtEUF9NQVhfTElOS19SQVRFXTsKKwlpbnRlbF9k cC0+bGFuZV9jb3VudCA9IDE7CisKKwkvKiBDaGVjayBpZiBsaW5rIHRyYWluaW5nIHBhc3NlZDsg aWYgbm90LCB1cGRhdGUgdGhlIHJldmVyc2VkIHN0YXRlICovCisJaWYgKCFpbnRlbF91cGZyb250 X2xpbmtfdHJhaW5fY29uZmlnKGRldiwgaW50ZWxfZHAsIGNydGMsCisJCQkJCWludGVsX2RwLT5k cGNkW0RQX01BWF9MSU5LX1JBVEVdLCAxKSkKKwkJaW50ZWxfZGlnX3BvcnQtPnNhdmVkX3BvcnRf Yml0cyB8PSBERElfQlVGX1BPUlRfUkVWRVJTQUw7CisKKwlmb3VuZCA9IGZhbHNlOworCisJLyog SW5pdGlhbGl6ZSB3aXRoIE1heCBMaW5rIHJhdGUgJiBsYW5lIGNvdW50IHN1cHBvcnRlZCBieSBw YW5lbCAqLworCWxpbmtfYncgPSAgaW50ZWxfZHAtPmRwY2RbRFBfTUFYX0xJTktfUkFURV07CisJ bGFuZV9jb3VudCA9IGludGVsX2RwLT5kcGNkW0RQX01BWF9MQU5FX0NPVU5UXSAmIERQX01BWF9M QU5FX0NPVU5UX01BU0s7CisKKwlkbyB7CisJCS8qIENoZWNrIGlmIGxpbmsgdHJhaW5pbmcgcGFz c2VkOyBpZiBzbyB1cGRhdGUgbGFuZSBjb3VudCAqLworCQlpZiAoaW50ZWxfdXBmcm9udF9saW5r X3RyYWluX2NvbmZpZyhkZXYsIGludGVsX2RwLCBjcnRjLAorCQkJCQlsaW5rX2J3LCBsYW5lX2Nv dW50KSkgeworCQkJaW50ZWxfZHAtPmRwY2RbRFBfTUFYX0xBTkVfQ09VTlRdICY9CisJCQkJCQl+ RFBfTUFYX0xBTkVfQ09VTlRfTUFTSzsKKwkJCWludGVsX2RwLT5kcGNkW0RQX01BWF9MQU5FX0NP VU5UXSB8PQorCQkJCWludGVsX2RwLT5sYW5lX2NvdW50ICYgRFBfTUFYX0xBTkVfQ09VTlRfTUFT SzsKKworCQkJZm91bmQgPSB0cnVlOworCQkJZ290byBleGl0OworCQl9CisKKwkJRFJNX0RFQlVH X0tNUygidXBmcm9udCBsaW5rIHRyYWluaW5nIGZhaWxlZC4gbGFuZXM6JWQgYnc6JWRcbiIsCisJ CQkJaW50ZWxfZHAtPmxhbmVfY291bnQsIGludGVsX2RwLT5saW5rX2J3KTsKKworCQkvKiBHbyBk b3duIHRvIHRoZSBuZXh0IGxldmVsIGFuZCByZXRyeSBsaW5rIHRyYWluaW5nICovCisJCWlmIChs YW5lX2NvdW50ID09IDQpIHsKKwkJCWxhbmVfY291bnQgPSAyOworCQl9IGVsc2UgaWYgKGxhbmVf Y291bnQgPT0gMikgeworCQkJbGFuZV9jb3VudCA9IDE7CisJCX0gZWxzZSBpZiAobGlua19idyA9 PSBEUF9MSU5LX0JXXzVfNCkgeworCQkJbGlua19idyA9IERQX0xJTktfQldfMl83OworCQkJbGFu ZV9jb3VudCA9IDQ7CisJCX0gZWxzZSBpZiAobGlua19idyA9PSBEUF9MSU5LX0JXXzJfNykgewor CQkJbGlua19idyA9IERQX0xJTktfQldfMV82MjsKKwkJCWxhbmVfY291bnQgPSA0OworCQl9IGVs c2UgeworCQkJLyogVHJpZWQgYWxsIGNvbWJpbmF0aW9ucywgc28gZXhpdCAqLworCQkJYnJlYWs7 CisJCX0KKworCX0gd2hpbGUgKDEpOworCitleGl0OgorCS8qIENsZWFyIGxvY2FsIGFzc29jaWF0 aW9ucyBtYWRlICovCisJaWYgKCF2YWxpZF9jcnRjKQorCQllbmNvZGVyLT5iYXNlLmNydGMgPSBO VUxMOworCisJaWYgKGZvdW5kKQorCQlEUk1fREVCVUdfS01TKCJ1cGZyb250IGxpbmsgdHJhaW5p bmcgcGFzc2VkLiBsYW5lczolZCBidzolZFxuIiwKKwkJCQlpbnRlbF9kcC0+bGFuZV9jb3VudCwg aW50ZWxfZHAtPmxpbmtfYncpOworCisJcmV0dXJuIGZvdW5kOworfQpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2RwLmMKaW5kZXggNDRmOGEzMi4uMTg3ODAwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfZHAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jCkBA IC0xMTQ0LDcgKzExNDQsNyBAQCBza2xfZWRwX3NldF9wbGxfY29uZmlnKHN0cnVjdCBpbnRlbF9j cnRjX3N0YXRlICpwaXBlX2NvbmZpZywgaW50IGxpbmtfY2xvY2spCiAJcGlwZV9jb25maWctPmRw bGxfaHdfc3RhdGUuY3RybDEgPSBjdHJsMTsKIH0KIAotc3RhdGljIHZvaWQKK3ZvaWQKIGhzd19k cF9zZXRfZGRpX3BsbF9zZWwoc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLCBp bnQgbGlua19idykKIHsKIAltZW1zZXQoJnBpcGVfY29uZmlnLT5kcGxsX2h3X3N0YXRlLCAwLApA QCAtMTIwMiw3ICsxMjAyLDcgQEAgaW50ZWxfZHBfc291cmNlX3JhdGVzKHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYsIGNvbnN0IGludCAqKnNvdXJjZV9yYXRlcykKIAkJcmV0dXJuIChEUF9MSU5LX0JX XzJfNyA+PiAzKSArIDE7CiB9CiAKLXN0YXRpYyB2b2lkCit2b2lkCiBpbnRlbF9kcF9zZXRfY2xv Y2soc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCiAJCSAgIHN0cnVjdCBpbnRlbF9jcnRj X3N0YXRlICpwaXBlX2NvbmZpZywgaW50IGxpbmtfYncpCiB7CkBAIC00NDIzLDYgKzQ0MjMsMTAg QEAgZzR4X2RwX2RldGVjdChzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKQogCWVsc2UgaWYgKHJl dCA9PSAwKQogCQlyZXR1cm4gY29ubmVjdG9yX3N0YXR1c19kaXNjb25uZWN0ZWQ7CiAKKwkvKiBB dm9pZCBEUENEIG9wZXJ0YXRpb25zIGlmIHN0YXR1cyBpcyBzYW1lICovCisJaWYgKGludGVsX2Rw LT5hdHRhY2hlZF9jb25uZWN0b3ItPmJhc2Uuc3RhdHVzID09IGNvbm5lY3Rvcl9zdGF0dXNfY29u bmVjdGVkKQorCQlyZXR1cm4gY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQ7CisKIAlyZXR1cm4g aW50ZWxfZHBfZGV0ZWN0X2RwY2QoaW50ZWxfZHApOwogfQogCkBAIC00NDk1LDcgKzQ0OTksOSBA QCBpbnRlbF9kcF9kZXRlY3Qoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwgYm9vbCBm b3JjZSkKIAlzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwID0gaW50ZWxfYXR0YWNoZWRfZHAoY29u bmVjdG9yKTsKIAlzdHJ1Y3QgaW50ZWxfZGlnaXRhbF9wb3J0ICppbnRlbF9kaWdfcG9ydCA9IGRw X3RvX2RpZ19wb3J0KGludGVsX2RwKTsKIAlzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqaW50ZWxfZW5j b2RlciA9ICZpbnRlbF9kaWdfcG9ydC0+YmFzZTsKKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSBp bnRlbF9kaWdfcG9ydC0+YmFzZS5iYXNlLmNydGM7CiAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9 IGNvbm5lY3Rvci0+ZGV2OworCXN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjOwogCWVudW0g ZHJtX2Nvbm5lY3Rvcl9zdGF0dXMgc3RhdHVzOwogCWVudW0gaW50ZWxfZGlzcGxheV9wb3dlcl9k b21haW4gcG93ZXJfZG9tYWluOwogCWJvb2wgcmV0OwpAQCAtNDU0MCw2ICs0NTQ2LDE4IEBAIGlu dGVsX2RwX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLCBib29sIGZvcmNl KQogCiAJaWYgKGludGVsX2VuY29kZXItPnR5cGUgIT0gSU5URUxfT1VUUFVUX0VEUCkKIAkJaW50 ZWxfZW5jb2Rlci0+dHlwZSA9IElOVEVMX09VVFBVVF9ESVNQTEFZUE9SVDsKKworCWlmIChpbnRl bF9lbmNvZGVyLT50eXBlID09IElOVEVMX09VVFBVVF9ESVNQTEFZUE9SVCAmJgorCSAgICAoSVNf QlJPQURXRUxMKGRldikgfHwgSVNfQ0hFUlJZVklFVyhkZXYpKSkgeworCQkvKiBEbyBub3QgaGFu ZGxlIGNvbm5lY3RlZCBib290IHNjZW5hcmlvIHdoZXJlIHBhbmVsIGlzIGVuYWJsZWQKKwkJICog YnkgR09QL1ZCSU9TLgorCQkgKi8KKwkJaWYgKChjb25uZWN0b3ItPnN0YXR1cyAhPSBjb25uZWN0 b3Jfc3RhdHVzX2Nvbm5lY3RlZCkgJiYKKwkJICAgICEoaW50ZWxfZW5jb2Rlci0+Y29ubmVjdG9y c19hY3RpdmUgJiYKKwkJICAgICAgY3J0YyAmJiBjcnRjLT5lbmFibGVkKSkKKwkJCWludGVsX3Vw ZnJvbnRfbGlua190cmFpbihkZXYsIGludGVsX2RwLCBOVUxMKTsKKwl9CisKIAlzdGF0dXMgPSBj b25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZDsKIAogCS8qIFRyeSB0byByZWFkIHRoZSBzb3VyY2Ug b2YgdGhlIGludGVycnVwdCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAppbmRleCAzMjBjOWU2 Li5mY2M5NWQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaApAQCAtMTE2Myw2ICsxMTYzLDEz IEBAIGJvb2wgaW50ZWxfZHBfaW5pdF9jb25uZWN0b3Ioc3RydWN0IGludGVsX2RpZ2l0YWxfcG9y dCAqaW50ZWxfZGlnX3BvcnQsCiB2b2lkIGludGVsX2RwX3N0YXJ0X2xpbmtfdHJhaW4oc3RydWN0 IGludGVsX2RwICppbnRlbF9kcCk7CiB2b2lkIGludGVsX2RwX2NvbXBsZXRlX2xpbmtfdHJhaW4o c3RydWN0IGludGVsX2RwICppbnRlbF9kcCk7CiB2b2lkIGludGVsX2RwX3N0b3BfbGlua190cmFp bihzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKTsKK2Jvb2wgaW50ZWxfdXBmcm9udF9saW5rX3Ry YWluKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCQkgICAgICBzdHJ1Y3QgaW50ZWxfZHAgKmlu dGVsX2RwLAorCQkJICAgICAgc3RydWN0IGludGVsX2NydGMgKmNydGMpOwordm9pZCBoc3dfZHBf c2V0X2RkaV9wbGxfc2VsKHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywgaW50 IGxpbmtfYncpOwordm9pZCBpbnRlbF9kcF9zZXRfY2xvY2soc3RydWN0IGludGVsX2VuY29kZXIg KmVuY29kZXIsCisJCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsIGludCBs aW5rX2J3KTsKKwogdm9pZCBpbnRlbF9kcF9zaW5rX2RwbXMoc3RydWN0IGludGVsX2RwICppbnRl bF9kcCwgaW50IG1vZGUpOwogdm9pZCBpbnRlbF9kcF9lbmNvZGVyX2Rlc3Ryb3koc3RydWN0IGRy bV9lbmNvZGVyICplbmNvZGVyKTsKIGludCBpbnRlbF9kcF9zaW5rX2NyYyhzdHJ1Y3QgaW50ZWxf ZHAgKmludGVsX2RwLCB1OCAqY3JjKTsKLS0gCjIuNC4zCgoKQ2hlZXJzLApCZW5qYW1pbiAKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1h aWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752914AbbHETec (ORCPT ); Wed, 5 Aug 2015 15:34:32 -0400 Received: from mx1.redhat.com ([209.132.183.28]:51753 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751161AbbHETeb (ORCPT ); Wed, 5 Aug 2015 15:34:31 -0400 Date: Wed, 5 Aug 2015 15:34:27 -0400 From: Benjamin Tissoires To: Sivakumar Thulasimani 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 Message-ID: <20150805193427.GA6097@mail.corp.redhat.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> <55B9A471.2070107@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <55B9A471.2070107@intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Jul 30 2015 or thereabouts, Sivakumar Thulasimani wrote: > > > 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. > [original patch snipped...] Hi Sivakumar, So I managed to manually re-apply your patch on top of drm-intel-nightly, and tried to port it to make Broadwell working too. It works OK if the system is already boot without any external DP used. In this case, the detection works and I can see my external monitor working properly. However, if the monitor is cold plugged, the cpu/GPU hangs and I can not understand why. I think I enabled all that is mentioned in the PRM to be able to train the DP link, but I am obviously missing something else. Can you have a look? My patch is now: >>From 11e9c42f55ae27bd6e7b0168bf24d15082c7d517 Mon Sep 17 00:00:00 2001 From: Durgadoss R Date: Mon, 3 Aug 2015 11:51:16 -0400 Subject: [PATCH] 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 [BT: add broadwell support and USB-C reverted state detection] Signed-off-by: Benjamin Tissoires --- drivers/gpu/drm/i915/intel_display.c | 163 +++++++++++++++++++++++++++++++++++ drivers/gpu/drm/i915/intel_dp.c | 22 ++++- drivers/gpu/drm/i915/intel_drv.h | 7 ++ 3 files changed, 190 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 818f3a3..e8ddba0 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -15799,3 +15799,166 @@ void intel_modeset_preclose(struct drm_device *dev, struct drm_file *file) spin_unlock_irq(&dev->event_lock); } } + +static bool +intel_upfront_link_train_config(struct drm_device *dev, + struct intel_dp *intel_dp, + struct intel_crtc *crtc, + uint8_t link_bw, + uint8_t lane_count) +{ + struct drm_i915_private *dev_priv = dev->dev_private; + struct intel_connector *connector = intel_dp->attached_connector; + struct intel_encoder *encoder = connector->encoder; + bool success; + + intel_dp->link_bw = link_bw; + intel_dp->lane_count = lane_count; + + /* 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 */ + if (IS_BROADWELL(dev)) { + hsw_dp_set_ddi_pll_sel(crtc->config, intel_dp->link_bw); + if (intel_crtc_to_shared_dpll(crtc)) + intel_enable_shared_dpll(crtc); + + intel_set_cpu_fifo_underrun_reporting(dev_priv, crtc->pipe, true); + + } else if (IS_CHERRYVIEW(dev)) { + intel_dp_set_clock(encoder, crtc->config, intel_dp->link_bw); + if (encoder->pre_pll_enable) + encoder->pre_pll_enable(encoder); + if (!intel_pipe_has_type(crtc, INTEL_OUTPUT_DSI)) + chv_enable_pll(crtc, crtc->config); + } + if (encoder->pre_enable) + encoder->pre_enable(encoder); + + success = intel_dp->train_set_valid; + + /* Reset encoder for next retry or for clean up */ + if (encoder->post_disable) + encoder->post_disable(encoder); + if (IS_CHERRYVIEW(dev)) { + if (!intel_pipe_has_type(crtc, INTEL_OUTPUT_DSI)) + chv_disable_pll(dev_priv, crtc->pipe); + } else if (IS_BROADWELL(dev)) { + intel_set_cpu_fifo_underrun_reporting(dev_priv, crtc->pipe, false); + if (intel_crtc_to_shared_dpll(crtc)) + intel_disable_shared_dpll(crtc); + } + + intel_dp->train_set_valid = false; + + return success; +} + +bool +intel_upfront_link_train(struct drm_device *dev, + struct intel_dp *intel_dp, + struct intel_crtc *crtc) +{ + struct intel_connector *connector = intel_dp->attached_connector; + struct intel_encoder *encoder = connector->encoder; + struct intel_digital_port *intel_dig_port = enc_to_dig_port(&encoder->base); + uint8_t link_bw, lane_count; + bool found = false; + bool valid_crtc = !!crtc; + + if (!connector || !encoder) { + DRM_DEBUG_KMS("dp connector/encoder is NULL\n"); + return false; + } + + /* Find an unused crtc and use it for link training if no crtc is given */ + if (!crtc) { + for_each_intel_crtc(dev, crtc) { + if (intel_crtc_active(&crtc->base)) + continue; + + /* Make sure the new crtc will work with the encoder */ + if (!drm_encoder_crtc_ok(&encoder->base, &crtc->base)) + continue; + + encoder->base.crtc = &crtc->base; + + found = true; + break; + } + + if (!found) { + DRM_ERROR("Could not find crtc for upfront link training\n"); + goto exit; + } + } + + DRM_DEBUG_KMS("upfront link training on pipe:%c\n", + pipe_name(crtc->pipe)); + + /* check the reversed state of the adapter first */ + + /* unset the reversal bit */ + intel_dig_port->saved_port_bits &= ~DDI_BUF_PORT_REVERSAL; + + /* Initialize with Max Link rate supported by panel & one lane */ + intel_dp->link_bw = intel_dp->dpcd[DP_MAX_LINK_RATE]; + intel_dp->lane_count = 1; + + /* Check if link training passed; if not, update the reversed state */ + if (!intel_upfront_link_train_config(dev, intel_dp, crtc, + intel_dp->dpcd[DP_MAX_LINK_RATE], 1)) + intel_dig_port->saved_port_bits |= DDI_BUF_PORT_REVERSAL; + + found = false; + + /* Initialize with Max Link rate & lane count supported by panel */ + link_bw = intel_dp->dpcd[DP_MAX_LINK_RATE]; + lane_count = intel_dp->dpcd[DP_MAX_LANE_COUNT] & DP_MAX_LANE_COUNT_MASK; + + do { + /* Check if link training passed; if so update lane count */ + if (intel_upfront_link_train_config(dev, intel_dp, crtc, + link_bw, lane_count)) { + 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; + 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 (lane_count == 4) { + lane_count = 2; + } else if (lane_count == 2) { + lane_count = 1; + } else if (link_bw == DP_LINK_BW_5_4) { + link_bw = DP_LINK_BW_2_7; + lane_count = 4; + } else if (link_bw == DP_LINK_BW_2_7) { + link_bw = DP_LINK_BW_1_62; + lane_count = 4; + } else { + /* Tried all combinations, so exit */ + break; + } + + } while (1); + +exit: + /* Clear local associations made */ + if (!valid_crtc) + 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 44f8a32..187800b 100644 --- a/drivers/gpu/drm/i915/intel_dp.c +++ b/drivers/gpu/drm/i915/intel_dp.c @@ -1144,7 +1144,7 @@ skl_edp_set_pll_config(struct intel_crtc_state *pipe_config, int link_clock) pipe_config->dpll_hw_state.ctrl1 = ctrl1; } -static void +void hsw_dp_set_ddi_pll_sel(struct intel_crtc_state *pipe_config, int link_bw) { memset(&pipe_config->dpll_hw_state, 0, @@ -1202,7 +1202,7 @@ intel_dp_source_rates(struct drm_device *dev, const int **source_rates) return (DP_LINK_BW_2_7 >> 3) + 1; } -static void +void intel_dp_set_clock(struct intel_encoder *encoder, struct intel_crtc_state *pipe_config, int link_bw) { @@ -4423,6 +4423,10 @@ g4x_dp_detect(struct intel_dp *intel_dp) else if (ret == 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); } @@ -4495,7 +4499,9 @@ 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 intel_crtc *intel_crtc; enum drm_connector_status status; enum intel_display_power_domain power_domain; bool ret; @@ -4540,6 +4546,18 @@ intel_dp_detect(struct drm_connector *connector, bool force) if (intel_encoder->type != INTEL_OUTPUT_EDP) intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT; + + if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT && + (IS_BROADWELL(dev) || IS_CHERRYVIEW(dev))) { + /* Do not handle connected boot scenario where panel is enabled + * by GOP/VBIOS. + */ + if ((connector->status != connector_status_connected) && + !(intel_encoder->connectors_active && + crtc && crtc->enabled)) + intel_upfront_link_train(dev, intel_dp, NULL); + } + status = connector_status_connected; /* Try to read the source of the interrupt */ diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 320c9e6..fcc95d5 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1163,6 +1163,13 @@ bool intel_dp_init_connector(struct intel_digital_port *intel_dig_port, 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_upfront_link_train(struct drm_device *dev, + struct intel_dp *intel_dp, + struct intel_crtc *crtc); +void hsw_dp_set_ddi_pll_sel(struct intel_crtc_state *pipe_config, int link_bw); +void intel_dp_set_clock(struct intel_encoder *encoder, + struct intel_crtc_state *pipe_config, int link_bw); + void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode); void intel_dp_encoder_destroy(struct drm_encoder *encoder); int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc); -- 2.4.3 Cheers, Benjamin