From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v2] drm/i915: Prevent PPS stealing from a normal DP port on VLV/CHV Date: Mon, 19 Dec 2016 15:01:57 +0200 Message-ID: <20161219130157.GV31595@intel.com> References: <1481552505-13828-1-git-send-email-ville.syrjala@linux.intel.com> <1481738423-29738-1-git-send-email-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by gabe.freedesktop.org (Postfix) with ESMTPS id 67C516E039 for ; Mon, 19 Dec 2016 13:02:01 +0000 (UTC) Content-Disposition: inline In-Reply-To: <1481738423-29738-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: intel-gfx@lists.freedesktop.org Cc: stable@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org T24gV2VkLCBEZWMgMTQsIDIwMTYgYXQgMDg6MDA6MjNQTSArMDIwMCwgdmlsbGUuc3lyamFsYUBs aW51eC5pbnRlbC5jb20gd3JvdGU6Cj4gRnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJq YWxhQGxpbnV4LmludGVsLmNvbT4KPiAKPiBWTFYgYXBwYXJlbnRseSBnZXRzIHVwc2V0IGlmIHRo ZSBQUFMgZm9yIGEgcGlwZSBjdXJyZW50bHkgZHJpdmluZyBhbgo+IGV4dGVybmFsIERQIHBvcnQg Z2V0cyB1c2VkIGZvciBWREQgc3R1ZmYgb24gYW5vdGhlciBlRFAgcG9ydC4gVGhlIERQCj4gcG9y dCBmYWxscyBvdmVyIGFuZCBmYWlscyB0byByZXRyYWluIHdoZW4gdGhpcyBoYXBwZW5zLCBsZWF2 aW5nIHRoZQo+IHVzZXIgc3RhcmluZyBhdCBhIGJsYWNrIHNjcmVlbi4KPiAKPiBMZXQncyBmaXgg aXQgYnkgYWxzbyB0cmFja2luZyB3aGljaCBwaXBlIGlzIGRyaXZpbmcgd2hpY2ggRFAvZURQIHBv cnQuCj4gV2UnbGwgdHJhY2sgdGhpcyB1bmRlciBpbnRlbF9kcCBzbyB0aGF0IHdlJ2xsIHNoYXJl IHRoZSBwcm90ZWN0aW9uCj4gb2YgdGhlIHBwc19tdXRleCBhbG9uZ3NpZGUgdGhlIHBwc19waXBl IHRyYWNraW5nLCBzaW5jZSB0aGUgdHdvCj4gdGhpbmdzIGFyZSBpbnRpbWF0ZWx5IHJlbGF0ZWQu Cj4gCj4gSSBoYWQgcGxhbnMgdG8gcmVkdWNlIHRoZSBwcm90ZWN0aW9uIG9mIHBwc19tdXRleCB0 byBjb3ZlciBvbmx5IGVEUAo+IHBvcnRzLCBidXQgd2l0aCB0aGlzIHdlIGNhbid0IGRvIHRoYXQu IFdlbGwsIGZvciBmb3IgVkxWL0NIViBhdCBsZWFzdC4KPiBGb3Igb3RoZXIgcGxhdGZvcm1zIGl0 IHNob3VsZCBzdGlsbCBiZSBwb3NzaWJsZSwgd2hpY2ggd291bGQgYWxsb3cKPiBBVVggY29tbXVu aWNhdGlvbiB0byBvY2N1ciBpbiBwYXJhbGxlbCBmb3IgbXVsdGlwbGUgRFAgcG9ydHMuCj4gCj4g djI6IERyb3Agc3RyYXkgY3JhcCBmcm9tIGEgY29tbWVudCAoSW1yZSkKPiAgICAgR3JhYiBwcHNf bXV0ZXggd2hlbiBjbGVhcmluZyBhY3RpdmVfcGlwZQo+ICAgICBGaXggYSB0eXBvIGluIHRoZSBj b21taXQgbWVzc2FnZQo+IAo+IENjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCj4gU2lnbmVkLW9m Zi1ieTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiBS ZXZpZXdlZC1ieTogSW1yZSBEZWFrIDxpbXJlLmRlYWtAaW50ZWwuY29tPgoKUHVzaGVkIHRvIGRp bnEuIFRoYW5rcyBmb3IgdGhlIHJldmlldy4KCkkgZGlkIG5vdGljZSB0aGF0IEkgaGFkIG5lZ2xl Y3RlZCB0byBtYWtlIHZsdl9hY3RpdmVfcGlwZSgpIHN0YXRpYywKYnV0IEkganVzdCBmaXhlZCB0 aGF0IHVwIHdoaWxlIGFwcGx5aW5nIHRoZSBwYXRjaC4KCj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2RwLmMgIHwgMTUyICsrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0t LS0tLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCB8ICAgNiArKwo+ICAy IGZpbGVzIGNoYW5nZWQsIDExMSBpbnNlcnRpb25zKCspLCA0NyBkZWxldGlvbnMoLSkKPiAKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2RwLmMKPiBpbmRleCBkYjc1YmI5MjRlNDguLmZlODMwZTM3MzZjZiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYwo+IEBAIC00NTQsMTQgKzQ1NCw1MCBAQCB2bHZf cG93ZXJfc2VxdWVuY2VyX2tpY2soc3RydWN0IGludGVsX2RwICppbnRlbF9kcCkKPiAgCX0KPiAg fQo+ICAKPiArc3RhdGljIGVudW0gcGlwZSB2bHZfZmluZF9mcmVlX3BwcyhzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCj4gK3sKPiArCXN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNv ZGVyOwo+ICsJdW5zaWduZWQgaW50IHBpcGVzID0gKDEgPDwgUElQRV9BKSB8ICgxIDw8IFBJUEVf Qik7Cj4gKwo+ICsJLyoKPiArCSAqIFdlIGRvbid0IGhhdmUgcG93ZXIgc2VxdWVuY2VyIGN1cnJl bnRseS4KPiArCSAqIFBpY2sgb25lIHRoYXQncyBub3QgdXNlZCBieSBvdGhlciBwb3J0cy4KPiAr CSAqLwo+ICsJZm9yX2VhY2hfaW50ZWxfZW5jb2RlcigmZGV2X3ByaXYtPmRybSwgZW5jb2Rlcikg ewo+ICsJCXN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHA7Cj4gKwo+ICsJCWlmIChlbmNvZGVyLT50 eXBlICE9IElOVEVMX09VVFBVVF9EUCAmJgo+ICsJCSAgICBlbmNvZGVyLT50eXBlICE9IElOVEVM X09VVFBVVF9FRFApCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiArCQlpbnRlbF9kcCA9IGVuY190b19p bnRlbF9kcCgmZW5jb2Rlci0+YmFzZSk7Cj4gKwo+ICsJCWlmIChlbmNvZGVyLT50eXBlID09IElO VEVMX09VVFBVVF9FRFApIHsKPiArCQkJV0FSTl9PTihpbnRlbF9kcC0+YWN0aXZlX3BpcGUgIT0g SU5WQUxJRF9QSVBFICYmCj4gKwkJCQlpbnRlbF9kcC0+YWN0aXZlX3BpcGUgIT0gaW50ZWxfZHAt PnBwc19waXBlKTsKPiArCj4gKwkJCWlmIChpbnRlbF9kcC0+cHBzX3BpcGUgIT0gSU5WQUxJRF9Q SVBFKQo+ICsJCQkJcGlwZXMgJj0gfigxIDw8IGludGVsX2RwLT5wcHNfcGlwZSk7Cj4gKwkJfSBl bHNlIHsKPiArCQkJV0FSTl9PTihpbnRlbF9kcC0+cHBzX3BpcGUgIT0gSU5WQUxJRF9QSVBFKTsK PiArCj4gKwkJCWlmIChpbnRlbF9kcC0+YWN0aXZlX3BpcGUgIT0gSU5WQUxJRF9QSVBFKQo+ICsJ CQkJcGlwZXMgJj0gfigxIDw8IGludGVsX2RwLT5hY3RpdmVfcGlwZSk7Cj4gKwkJfQo+ICsJfQo+ ICsKPiArCWlmIChwaXBlcyA9PSAwKQo+ICsJCXJldHVybiBJTlZBTElEX1BJUEU7Cj4gKwo+ICsJ cmV0dXJuIGZmcyhwaXBlcykgLSAxOwo+ICt9Cj4gKwo+ICBzdGF0aWMgZW51bSBwaXBlCj4gIHZs dl9wb3dlcl9zZXF1ZW5jZXJfcGlwZShzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKQo+ICB7Cj4g IAlzdHJ1Y3QgaW50ZWxfZGlnaXRhbF9wb3J0ICppbnRlbF9kaWdfcG9ydCA9IGRwX3RvX2RpZ19w b3J0KGludGVsX2RwKTsKPiAgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBpbnRlbF9kaWdfcG9y dC0+YmFzZS5iYXNlLmRldjsKPiAgCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9 IHRvX2k5MTUoZGV2KTsKPiAtCXN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyOwo+IC0JdW5z aWduZWQgaW50IHBpcGVzID0gKDEgPDwgUElQRV9BKSB8ICgxIDw8IFBJUEVfQik7Cj4gIAllbnVt IHBpcGUgcGlwZTsKPiAgCj4gIAlsb2NrZGVwX2Fzc2VydF9oZWxkKCZkZXZfcHJpdi0+cHBzX211 dGV4KTsKPiBAQCAtNDY5LDMzICs1MDUsMjAgQEAgdmx2X3Bvd2VyX3NlcXVlbmNlcl9waXBlKHN0 cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHApCj4gIAkvKiBXZSBzaG91bGQgbmV2ZXIgbGFuZCBoZXJl IHdpdGggcmVndWxhciBEUCBwb3J0cyAqLwo+ICAJV0FSTl9PTighaXNfZWRwKGludGVsX2RwKSk7 Cj4gIAo+ICsJV0FSTl9PTihpbnRlbF9kcC0+YWN0aXZlX3BpcGUgIT0gSU5WQUxJRF9QSVBFICYm Cj4gKwkJaW50ZWxfZHAtPmFjdGl2ZV9waXBlICE9IGludGVsX2RwLT5wcHNfcGlwZSk7Cj4gKwo+ ICAJaWYgKGludGVsX2RwLT5wcHNfcGlwZSAhPSBJTlZBTElEX1BJUEUpCj4gIAkJcmV0dXJuIGlu dGVsX2RwLT5wcHNfcGlwZTsKPiAgCj4gLQkvKgo+IC0JICogV2UgZG9uJ3QgaGF2ZSBwb3dlciBz ZXF1ZW5jZXIgY3VycmVudGx5Lgo+IC0JICogUGljayBvbmUgdGhhdCdzIG5vdCB1c2VkIGJ5IG90 aGVyIHBvcnRzLgo+IC0JICovCj4gLQlmb3JfZWFjaF9pbnRlbF9lbmNvZGVyKGRldiwgZW5jb2Rl cikgewo+IC0JCXN0cnVjdCBpbnRlbF9kcCAqdG1wOwo+IC0KPiAtCQlpZiAoZW5jb2Rlci0+dHlw ZSAhPSBJTlRFTF9PVVRQVVRfRURQKQo+IC0JCQljb250aW51ZTsKPiAtCj4gLQkJdG1wID0gZW5j X3RvX2ludGVsX2RwKCZlbmNvZGVyLT5iYXNlKTsKPiAtCj4gLQkJaWYgKHRtcC0+cHBzX3BpcGUg IT0gSU5WQUxJRF9QSVBFKQo+IC0JCQlwaXBlcyAmPSB+KDEgPDwgdG1wLT5wcHNfcGlwZSk7Cj4g LQl9Cj4gKwlwaXBlID0gdmx2X2ZpbmRfZnJlZV9wcHMoZGV2X3ByaXYpOwo+ICAKPiAgCS8qCj4g IAkgKiBEaWRuJ3QgZmluZCBvbmUuIFRoaXMgc2hvdWxkIG5vdCBoYXBwZW4gc2luY2UgdGhlcmUK PiAgCSAqIGFyZSB0d28gcG93ZXIgc2VxdWVuY2VycyBhbmQgdXAgdG8gdHdvIGVEUCBwb3J0cy4K PiAgCSAqLwo+IC0JaWYgKFdBUk5fT04ocGlwZXMgPT0gMCkpCj4gKwlpZiAoV0FSTl9PTihwaXBl ID09IElOVkFMSURfUElQRSkpCj4gIAkJcGlwZSA9IFBJUEVfQTsKPiAtCWVsc2UKPiAtCQlwaXBl ID0gZmZzKHBpcGVzKSAtIDE7Cj4gIAo+ICAJdmx2X3N0ZWFsX3Bvd2VyX3NlcXVlbmNlcihkZXYs IHBpcGUpOwo+ICAJaW50ZWxfZHAtPnBwc19waXBlID0gcGlwZTsKPiBAQCAtNjUxLDEwICs2NzQs MTcgQEAgdm9pZCBpbnRlbF9wb3dlcl9zZXF1ZW5jZXJfcmVzZXQoc3RydWN0IGRybV9pOTE1X3By aXZhdGUgKmRldl9wcml2KQo+ICAJZm9yX2VhY2hfaW50ZWxfZW5jb2RlcihkZXYsIGVuY29kZXIp IHsKPiAgCQlzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwOwo+ICAKPiAtCQlpZiAoZW5jb2Rlci0+ dHlwZSAhPSBJTlRFTF9PVVRQVVRfRURQKQo+ICsJCWlmIChlbmNvZGVyLT50eXBlICE9IElOVEVM X09VVFBVVF9EUCAmJgo+ICsJCSAgICBlbmNvZGVyLT50eXBlICE9IElOVEVMX09VVFBVVF9FRFAp Cj4gIAkJCWNvbnRpbnVlOwo+ICAKPiAgCQlpbnRlbF9kcCA9IGVuY190b19pbnRlbF9kcCgmZW5j b2Rlci0+YmFzZSk7Cj4gKwo+ICsJCVdBUk5fT04oaW50ZWxfZHAtPmFjdGl2ZV9waXBlICE9IElO VkFMSURfUElQRSk7Cj4gKwo+ICsJCWlmIChlbmNvZGVyLT50eXBlICE9IElOVEVMX09VVFBVVF9F RFApCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiAgCQlpZiAoSVNfR0VOOV9MUChkZXZfcHJpdikpCj4g IAkJCWludGVsX2RwLT5wcHNfcmVzZXQgPSB0cnVlOwo+ICAJCWVsc2UKPiBAQCAtMjgxNCw2ICsy ODQ0LDggQEAgc3RhdGljIHZvaWQgdmx2X2RldGFjaF9wb3dlcl9zZXF1ZW5jZXIoc3RydWN0IGlu dGVsX2RwICppbnRlbF9kcCkKPiAgCWVudW0gcGlwZSBwaXBlID0gaW50ZWxfZHAtPnBwc19waXBl Owo+ICAJaTkxNV9yZWdfdCBwcF9vbl9yZWcgPSBQUF9PTl9ERUxBWVMocGlwZSk7Cj4gIAo+ICsJ V0FSTl9PTihpbnRlbF9kcC0+YWN0aXZlX3BpcGUgIT0gSU5WQUxJRF9QSVBFKTsKPiArCj4gIAll ZHBfcGFuZWxfdmRkX29mZl9zeW5jKGludGVsX2RwKTsKPiAgCj4gIAkvKgo+IEBAIC0yODQ4LDIy ICsyODgwLDIzIEBAIHN0YXRpYyB2b2lkIHZsdl9zdGVhbF9wb3dlcl9zZXF1ZW5jZXIoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwKPiAgCQlzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwOwo+ICAJCWVu dW0gcG9ydCBwb3J0Owo+ICAKPiAtCQlpZiAoZW5jb2Rlci0+dHlwZSAhPSBJTlRFTF9PVVRQVVRf RURQKQo+ICsJCWlmIChlbmNvZGVyLT50eXBlICE9IElOVEVMX09VVFBVVF9EUCAmJgo+ICsJCSAg ICBlbmNvZGVyLT50eXBlICE9IElOVEVMX09VVFBVVF9FRFApCj4gIAkJCWNvbnRpbnVlOwo+ICAK PiAgCQlpbnRlbF9kcCA9IGVuY190b19pbnRlbF9kcCgmZW5jb2Rlci0+YmFzZSk7Cj4gIAkJcG9y dCA9IGRwX3RvX2RpZ19wb3J0KGludGVsX2RwKS0+cG9ydDsKPiAgCj4gKwkJV0FSTihpbnRlbF9k cC0+YWN0aXZlX3BpcGUgPT0gcGlwZSwKPiArCQkgICAgICJzdGVhbGluZyBwaXBlICVjIHBvd2Vy IHNlcXVlbmNlciBmcm9tIGFjdGl2ZSAoZSlEUCBwb3J0ICVjXG4iLAo+ICsJCSAgICAgcGlwZV9u YW1lKHBpcGUpLCBwb3J0X25hbWUocG9ydCkpOwo+ICsKPiAgCQlpZiAoaW50ZWxfZHAtPnBwc19w aXBlICE9IHBpcGUpCj4gIAkJCWNvbnRpbnVlOwo+ICAKPiAgCQlEUk1fREVCVUdfS01TKCJzdGVh bGluZyBwaXBlICVjIHBvd2VyIHNlcXVlbmNlciBmcm9tIHBvcnQgJWNcbiIsCj4gIAkJCSAgICAg IHBpcGVfbmFtZShwaXBlKSwgcG9ydF9uYW1lKHBvcnQpKTsKPiAgCj4gLQkJV0FSTihlbmNvZGVy LT5iYXNlLmNydGMsCj4gLQkJICAgICAic3RlYWxpbmcgcGlwZSAlYyBwb3dlciBzZXF1ZW5jZXIg ZnJvbSBhY3RpdmUgZURQIHBvcnQgJWNcbiIsCj4gLQkJICAgICBwaXBlX25hbWUocGlwZSksIHBv cnRfbmFtZShwb3J0KSk7Cj4gLQo+ICAJCS8qIG1ha2Ugc3VyZSB2ZGQgaXMgb2ZmIGJlZm9yZSB3 ZSBzdGVhbCBpdCAqLwo+ICAJCXZsdl9kZXRhY2hfcG93ZXJfc2VxdWVuY2VyKGludGVsX2RwKTsK PiAgCX0KPiBAQCAtMjg3OSwxOSArMjkxMiwxNyBAQCBzdGF0aWMgdm9pZCB2bHZfaW5pdF9wYW5l bF9wb3dlcl9zZXF1ZW5jZXIoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCkKPiAgCj4gIAlsb2Nr ZGVwX2Fzc2VydF9oZWxkKCZkZXZfcHJpdi0+cHBzX211dGV4KTsKPiAgCj4gLQlpZiAoIWlzX2Vk cChpbnRlbF9kcCkpCj4gLQkJcmV0dXJuOwo+ICsJV0FSTl9PTihpbnRlbF9kcC0+YWN0aXZlX3Bp cGUgIT0gSU5WQUxJRF9QSVBFKTsKPiAgCj4gLQlpZiAoaW50ZWxfZHAtPnBwc19waXBlID09IGNy dGMtPnBpcGUpCj4gLQkJcmV0dXJuOwo+IC0KPiAtCS8qCj4gLQkgKiBJZiBhbm90aGVyIHBvd2Vy IHNlcXVlbmNlciB3YXMgYmVpbmcgdXNlZCBvbiB0aGlzCj4gLQkgKiBwb3J0IHByZXZpb3VzbHkg bWFrZSBzdXJlIHRvIHR1cm4gb2ZmIHZkZCB0aGVyZSB3aGlsZQo+IC0JICogd2Ugc3RpbGwgaGF2 ZSBjb250cm9sIG9mIGl0Lgo+IC0JICovCj4gLQlpZiAoaW50ZWxfZHAtPnBwc19waXBlICE9IElO VkFMSURfUElQRSkKPiArCWlmIChpbnRlbF9kcC0+cHBzX3BpcGUgIT0gSU5WQUxJRF9QSVBFICYm Cj4gKwkgICAgaW50ZWxfZHAtPnBwc19waXBlICE9IGNydGMtPnBpcGUpIHsKPiArCQkvKgo+ICsJ CSAqIElmIGFub3RoZXIgcG93ZXIgc2VxdWVuY2VyIHdhcyBiZWluZyB1c2VkIG9uIHRoaXMKPiAr CQkgKiBwb3J0IHByZXZpb3VzbHkgbWFrZSBzdXJlIHRvIHR1cm4gb2ZmIHZkZCB0aGVyZSB3aGls ZQo+ICsJCSAqIHdlIHN0aWxsIGhhdmUgY29udHJvbCBvZiBpdC4KPiArCQkgKi8KPiAgCQl2bHZf ZGV0YWNoX3Bvd2VyX3NlcXVlbmNlcihpbnRlbF9kcCk7Cj4gKwl9Cj4gIAo+ICAJLyoKPiAgCSAq IFdlIG1heSBiZSBzdGVhbGluZyB0aGUgcG93ZXIKPiBAQCAtMjg5OSw2ICsyOTMwLDExIEBAIHN0 YXRpYyB2b2lkIHZsdl9pbml0X3BhbmVsX3Bvd2VyX3NlcXVlbmNlcihzdHJ1Y3QgaW50ZWxfZHAg KmludGVsX2RwKQo+ICAJICovCj4gIAl2bHZfc3RlYWxfcG93ZXJfc2VxdWVuY2VyKGRldiwgY3J0 Yy0+cGlwZSk7Cj4gIAo+ICsJaW50ZWxfZHAtPmFjdGl2ZV9waXBlID0gY3J0Yy0+cGlwZTsKPiAr Cj4gKwlpZiAoIWlzX2VkcChpbnRlbF9kcCkpCj4gKwkJcmV0dXJuOwo+ICsKPiAgCS8qIG5vdyBp dCdzIGFsbCBvdXJzICovCj4gIAlpbnRlbF9kcC0+cHBzX3BpcGUgPSBjcnRjLT5waXBlOwo+ICAK PiBAQCAtMzQ4NSw2ICszNTIxLDEyIEBAIGludGVsX2RwX2xpbmtfZG93bihzdHJ1Y3QgaW50ZWxf ZHAgKmludGVsX2RwKQo+ICAJbXNsZWVwKGludGVsX2RwLT5wYW5lbF9wb3dlcl9kb3duX2RlbGF5 KTsKPiAgCj4gIAlpbnRlbF9kcC0+RFAgPSBEUDsKPiArCj4gKwlpZiAoSVNfVkFMTEVZVklFVyhk ZXZfcHJpdikgfHwgSVNfQ0hFUlJZVklFVyhkZXZfcHJpdikpIHsKPiArCQlwcHNfbG9jayhpbnRl bF9kcCk7Cj4gKwkJaW50ZWxfZHAtPmFjdGl2ZV9waXBlID0gSU5WQUxJRF9QSVBFOwo+ICsJCXBw c191bmxvY2soaW50ZWxfZHApOwo+ICsJfQo+ICB9Cj4gIAo+ICBib29sCj4gQEAgLTQ3NTAsNiAr NDc5MiwxOSBAQCBzdGF0aWMgdm9pZCBpbnRlbF9lZHBfcGFuZWxfdmRkX3Nhbml0aXplKHN0cnVj dCBpbnRlbF9kcCAqaW50ZWxfZHApCj4gIAllZHBfcGFuZWxfdmRkX3NjaGVkdWxlX29mZihpbnRl bF9kcCk7Cj4gIH0KPiAgCj4gK2VudW0gcGlwZSB2bHZfYWN0aXZlX3BpcGUoc3RydWN0IGludGVs X2RwICppbnRlbF9kcCkKPiArewo+ICsJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2 ID0gdG9faTkxNShpbnRlbF9kcF90b19kZXYoaW50ZWxfZHApKTsKPiArCj4gKwlpZiAoKGludGVs X2RwLT5EUCAmIERQX1BPUlRfRU4pID09IDApCj4gKwkJcmV0dXJuIElOVkFMSURfUElQRTsKPiAr Cj4gKwlpZiAoSVNfQ0hFUlJZVklFVyhkZXZfcHJpdikpCj4gKwkJcmV0dXJuIERQX1BPUlRfVE9f UElQRV9DSFYoaW50ZWxfZHAtPkRQKTsKPiArCWVsc2UKPiArCQlyZXR1cm4gUE9SVF9UT19QSVBF KGludGVsX2RwLT5EUCk7Cj4gK30KPiArCj4gIHZvaWQgaW50ZWxfZHBfZW5jb2Rlcl9yZXNldChz dHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpCj4gIHsKPiAgCXN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZW5jb2Rlci0+ZGV2KTsKPiBAQCAtNDc2MiwxNCArNDgx NywxNiBAQCB2b2lkIGludGVsX2RwX2VuY29kZXJfcmVzZXQoc3RydWN0IGRybV9lbmNvZGVyICpl bmNvZGVyKQo+ICAJaWYgKGxzcGNvbi0+YWN0aXZlKQo+ICAJCWxzcGNvbl9yZXN1bWUobHNwY29u KTsKPiAgCj4gLQlpZiAodG9faW50ZWxfZW5jb2RlcihlbmNvZGVyKS0+dHlwZSAhPSBJTlRFTF9P VVRQVVRfRURQKQo+IC0JCXJldHVybjsKPiAtCj4gIAlwcHNfbG9jayhpbnRlbF9kcCk7Cj4gIAo+ IC0JLyogUmVpbml0IHRoZSBwb3dlciBzZXF1ZW5jZXIsIGluIGNhc2UgQklPUyBkaWQgc29tZXRo aW5nIHdpdGggaXQuICovCj4gLQlpbnRlbF9kcF9wcHNfaW5pdChlbmNvZGVyLT5kZXYsIGludGVs X2RwKTsKPiAtCWludGVsX2VkcF9wYW5lbF92ZGRfc2FuaXRpemUoaW50ZWxfZHApOwo+ICsJaWYg KElTX1ZBTExFWVZJRVcoZGV2X3ByaXYpIHx8IElTX0NIRVJSWVZJRVcoZGV2X3ByaXYpKQo+ICsJ CWludGVsX2RwLT5hY3RpdmVfcGlwZSA9IHZsdl9hY3RpdmVfcGlwZShpbnRlbF9kcCk7Cj4gKwo+ ICsJaWYgKGlzX2VkcChpbnRlbF9kcCkpIHsKPiArCQkvKiBSZWluaXQgdGhlIHBvd2VyIHNlcXVl bmNlciwgaW4gY2FzZSBCSU9TIGRpZCBzb21ldGhpbmcgd2l0aCBpdC4gKi8KPiArCQlpbnRlbF9k cF9wcHNfaW5pdChlbmNvZGVyLT5kZXYsIGludGVsX2RwKTsKPiArCQlpbnRlbF9lZHBfcGFuZWxf dmRkX3Nhbml0aXplKGludGVsX2RwKTsKPiArCX0KPiAgCj4gIAlwcHNfdW5sb2NrKGludGVsX2Rw KTsKPiAgfQo+IEBAIC01NTk2LDEwICs1NjUzLDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfZWRwX2lu aXRfY29ubmVjdG9yKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsCj4gIAkJICogSWYgdGhlIGN1 cnJlbnQgcGlwZSBpc24ndCB2YWxpZCwgdHJ5IHRoZSBQUFMgcGlwZSwgYW5kIGlmIHRoYXQKPiAg CQkgKiBmYWlscyBqdXN0IGFzc3VtZSBwaXBlIEEuCj4gIAkJICovCj4gLQkJaWYgKElTX0NIRVJS WVZJRVcoZGV2X3ByaXYpKQo+IC0JCQlwaXBlID0gRFBfUE9SVF9UT19QSVBFX0NIVihpbnRlbF9k cC0+RFApOwo+IC0JCWVsc2UKPiAtCQkJcGlwZSA9IFBPUlRfVE9fUElQRShpbnRlbF9kcC0+RFAp Owo+ICsJCXBpcGUgPSB2bHZfYWN0aXZlX3BpcGUoaW50ZWxfZHApOwo+ICAKPiAgCQlpZiAocGlw ZSAhPSBQSVBFX0EgJiYgcGlwZSAhPSBQSVBFX0IpCj4gIAkJCXBpcGUgPSBpbnRlbF9kcC0+cHBz X3BpcGU7Cj4gQEAgLTU2NDgsNiArNTcwMiw3IEBAIGludGVsX2RwX2luaXRfY29ubmVjdG9yKHN0 cnVjdCBpbnRlbF9kaWdpdGFsX3BvcnQgKmludGVsX2RpZ19wb3J0LAo+ICAJCXJldHVybiBmYWxz ZTsKPiAgCj4gIAlpbnRlbF9kcC0+cHBzX3BpcGUgPSBJTlZBTElEX1BJUEU7Cj4gKwlpbnRlbF9k cC0+YWN0aXZlX3BpcGUgPSBJTlZBTElEX1BJUEU7Cj4gIAo+ICAJLyogaW50ZWxfZHAgdmZ1bmNz ICovCj4gIAlpZiAoSU5URUxfR0VOKGRldl9wcml2KSA+PSA5KQo+IEBAIC01Njc2LDYgKzU3MzEs OSBAQCBpbnRlbF9kcF9pbml0X2Nvbm5lY3RvcihzdHJ1Y3QgaW50ZWxfZGlnaXRhbF9wb3J0ICpp bnRlbF9kaWdfcG9ydCwKPiAgCWVsc2UKPiAgCQl0eXBlID0gRFJNX01PREVfQ09OTkVDVE9SX0Rp c3BsYXlQb3J0Owo+ICAKPiArCWlmIChJU19WQUxMRVlWSUVXKGRldl9wcml2KSB8fCBJU19DSEVS UllWSUVXKGRldl9wcml2KSkKPiArCQlpbnRlbF9kcC0+YWN0aXZlX3BpcGUgPSB2bHZfYWN0aXZl X3BpcGUoaW50ZWxfZHApOwo+ICsKPiAgCS8qCj4gIAkgKiBGb3IgZURQIHdlIGFsd2F5cyBzZXQg dGhlIGVuY29kZXIgdHlwZSB0byBJTlRFTF9PVVRQVVRfRURQLCBidXQKPiAgCSAqIGZvciBEUCB0 aGUgZW5jb2RlciB0eXBlIGNhbiBiZSBzZXQgYnkgdGhlIGNhbGxlciB0bwo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2Rydi5oCj4gaW5kZXggOGY0ZGRjYTBmNTIxLi44NWIzOWQzYTZkZmYgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IEBAIC05MjksNiArOTI5LDEyIEBAIHN0cnVjdCBpbnRl bF9kcCB7Cj4gIAkgKi8KPiAgCWVudW0gcGlwZSBwcHNfcGlwZTsKPiAgCS8qCj4gKwkgKiBQaXBl IGN1cnJlbnRseSBkcml2aW5nIHRoZSBwb3J0LiBVc2VkIGZvciBwcmV2ZW50aW5nCj4gKwkgKiB0 aGUgdXNlIG9mIHRoZSBQUFMgZm9yIGFueSBwaXBlIGN1cnJlbnRybHkgZHJpdmluZwo+ICsJICog ZXh0ZXJuYWwgRFAgYXMgdGhhdCB3aWxsIG1lc3MgdGhpbmdzIHVwIG9uIFZMVi4KPiArCSAqLwo+ ICsJZW51bSBwaXBlIGFjdGl2ZV9waXBlOwo+ICsJLyoKPiAgCSAqIFNldCBpZiB0aGUgc2VxdWVu Y2VyIG1heSBiZSByZXNldCBkdWUgdG8gYSBwb3dlciB0cmFuc2l0aW9uLAo+ICAJICogcmVxdWly aW5nIGEgcmVpbml0aWFsaXphdGlvbi4gT25seSByZWxldmFudCBvbiBCWFQuCj4gIAkgKi8KPiAt LSAKPiAyLjcuNAoKLS0gClZpbGxlIFN5cmrDpGzDpApJbnRlbCBPVEMKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJ bnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com ([134.134.136.65]:56185 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754633AbcLSNCN (ORCPT ); Mon, 19 Dec 2016 08:02:13 -0500 Date: Mon, 19 Dec 2016 15:01:57 +0200 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: intel-gfx@lists.freedesktop.org Cc: stable@vger.kernel.org Subject: Re: [PATCH v2] drm/i915: Prevent PPS stealing from a normal DP port on VLV/CHV Message-ID: <20161219130157.GV31595@intel.com> References: <1481552505-13828-1-git-send-email-ville.syrjala@linux.intel.com> <1481738423-29738-1-git-send-email-ville.syrjala@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1481738423-29738-1-git-send-email-ville.syrjala@linux.intel.com> Sender: stable-owner@vger.kernel.org List-ID: On Wed, Dec 14, 2016 at 08:00:23PM +0200, ville.syrjala@linux.intel.com wrote: > From: Ville Syrj�l� > > VLV apparently gets upset if the PPS for a pipe currently driving an > external DP port gets used for VDD stuff on another eDP port. The DP > port falls over and fails to retrain when this happens, leaving the > user staring at a black screen. > > Let's fix it by also tracking which pipe is driving which DP/eDP port. > We'll track this under intel_dp so that we'll share the protection > of the pps_mutex alongside the pps_pipe tracking, since the two > things are intimately related. > > I had plans to reduce the protection of pps_mutex to cover only eDP > ports, but with this we can't do that. Well, for for VLV/CHV at least. > For other platforms it should still be possible, which would allow > AUX communication to occur in parallel for multiple DP ports. > > v2: Drop stray crap from a comment (Imre) > Grab pps_mutex when clearing active_pipe > Fix a typo in the commit message > > Cc: stable@vger.kernel.org > Signed-off-by: Ville Syrj�l� > Reviewed-by: Imre Deak Pushed to dinq. Thanks for the review. I did notice that I had neglected to make vlv_active_pipe() static, but I just fixed that up while applying the patch. > --- > drivers/gpu/drm/i915/intel_dp.c | 152 +++++++++++++++++++++++++++------------ > drivers/gpu/drm/i915/intel_drv.h | 6 ++ > 2 files changed, 111 insertions(+), 47 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c > index db75bb924e48..fe830e3736cf 100644 > --- a/drivers/gpu/drm/i915/intel_dp.c > +++ b/drivers/gpu/drm/i915/intel_dp.c > @@ -454,14 +454,50 @@ vlv_power_sequencer_kick(struct intel_dp *intel_dp) > } > } > > +static enum pipe vlv_find_free_pps(struct drm_i915_private *dev_priv) > +{ > + struct intel_encoder *encoder; > + unsigned int pipes = (1 << PIPE_A) | (1 << PIPE_B); > + > + /* > + * We don't have power sequencer currently. > + * Pick one that's not used by other ports. > + */ > + for_each_intel_encoder(&dev_priv->drm, encoder) { > + struct intel_dp *intel_dp; > + > + if (encoder->type != INTEL_OUTPUT_DP && > + encoder->type != INTEL_OUTPUT_EDP) > + continue; > + > + intel_dp = enc_to_intel_dp(&encoder->base); > + > + if (encoder->type == INTEL_OUTPUT_EDP) { > + WARN_ON(intel_dp->active_pipe != INVALID_PIPE && > + intel_dp->active_pipe != intel_dp->pps_pipe); > + > + if (intel_dp->pps_pipe != INVALID_PIPE) > + pipes &= ~(1 << intel_dp->pps_pipe); > + } else { > + WARN_ON(intel_dp->pps_pipe != INVALID_PIPE); > + > + if (intel_dp->active_pipe != INVALID_PIPE) > + pipes &= ~(1 << intel_dp->active_pipe); > + } > + } > + > + if (pipes == 0) > + return INVALID_PIPE; > + > + return ffs(pipes) - 1; > +} > + > static enum pipe > vlv_power_sequencer_pipe(struct intel_dp *intel_dp) > { > struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); > struct drm_device *dev = intel_dig_port->base.base.dev; > struct drm_i915_private *dev_priv = to_i915(dev); > - struct intel_encoder *encoder; > - unsigned int pipes = (1 << PIPE_A) | (1 << PIPE_B); > enum pipe pipe; > > lockdep_assert_held(&dev_priv->pps_mutex); > @@ -469,33 +505,20 @@ vlv_power_sequencer_pipe(struct intel_dp *intel_dp) > /* We should never land here with regular DP ports */ > WARN_ON(!is_edp(intel_dp)); > > + WARN_ON(intel_dp->active_pipe != INVALID_PIPE && > + intel_dp->active_pipe != intel_dp->pps_pipe); > + > if (intel_dp->pps_pipe != INVALID_PIPE) > return intel_dp->pps_pipe; > > - /* > - * We don't have power sequencer currently. > - * Pick one that's not used by other ports. > - */ > - for_each_intel_encoder(dev, encoder) { > - struct intel_dp *tmp; > - > - if (encoder->type != INTEL_OUTPUT_EDP) > - continue; > - > - tmp = enc_to_intel_dp(&encoder->base); > - > - if (tmp->pps_pipe != INVALID_PIPE) > - pipes &= ~(1 << tmp->pps_pipe); > - } > + pipe = vlv_find_free_pps(dev_priv); > > /* > * Didn't find one. This should not happen since there > * are two power sequencers and up to two eDP ports. > */ > - if (WARN_ON(pipes == 0)) > + if (WARN_ON(pipe == INVALID_PIPE)) > pipe = PIPE_A; > - else > - pipe = ffs(pipes) - 1; > > vlv_steal_power_sequencer(dev, pipe); > intel_dp->pps_pipe = pipe; > @@ -651,10 +674,17 @@ void intel_power_sequencer_reset(struct drm_i915_private *dev_priv) > for_each_intel_encoder(dev, encoder) { > struct intel_dp *intel_dp; > > - if (encoder->type != INTEL_OUTPUT_EDP) > + if (encoder->type != INTEL_OUTPUT_DP && > + encoder->type != INTEL_OUTPUT_EDP) > continue; > > intel_dp = enc_to_intel_dp(&encoder->base); > + > + WARN_ON(intel_dp->active_pipe != INVALID_PIPE); > + > + if (encoder->type != INTEL_OUTPUT_EDP) > + continue; > + > if (IS_GEN9_LP(dev_priv)) > intel_dp->pps_reset = true; > else > @@ -2814,6 +2844,8 @@ static void vlv_detach_power_sequencer(struct intel_dp *intel_dp) > enum pipe pipe = intel_dp->pps_pipe; > i915_reg_t pp_on_reg = PP_ON_DELAYS(pipe); > > + WARN_ON(intel_dp->active_pipe != INVALID_PIPE); > + > edp_panel_vdd_off_sync(intel_dp); > > /* > @@ -2848,22 +2880,23 @@ static void vlv_steal_power_sequencer(struct drm_device *dev, > struct intel_dp *intel_dp; > enum port port; > > - if (encoder->type != INTEL_OUTPUT_EDP) > + if (encoder->type != INTEL_OUTPUT_DP && > + encoder->type != INTEL_OUTPUT_EDP) > continue; > > intel_dp = enc_to_intel_dp(&encoder->base); > port = dp_to_dig_port(intel_dp)->port; > > + WARN(intel_dp->active_pipe == pipe, > + "stealing pipe %c power sequencer from active (e)DP port %c\n", > + pipe_name(pipe), port_name(port)); > + > if (intel_dp->pps_pipe != pipe) > continue; > > DRM_DEBUG_KMS("stealing pipe %c power sequencer from port %c\n", > pipe_name(pipe), port_name(port)); > > - WARN(encoder->base.crtc, > - "stealing pipe %c power sequencer from active eDP port %c\n", > - pipe_name(pipe), port_name(port)); > - > /* make sure vdd is off before we steal it */ > vlv_detach_power_sequencer(intel_dp); > } > @@ -2879,19 +2912,17 @@ static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp) > > lockdep_assert_held(&dev_priv->pps_mutex); > > - if (!is_edp(intel_dp)) > - return; > + WARN_ON(intel_dp->active_pipe != INVALID_PIPE); > > - if (intel_dp->pps_pipe == crtc->pipe) > - return; > - > - /* > - * If another power sequencer was being used on this > - * port previously make sure to turn off vdd there while > - * we still have control of it. > - */ > - if (intel_dp->pps_pipe != INVALID_PIPE) > + if (intel_dp->pps_pipe != INVALID_PIPE && > + intel_dp->pps_pipe != crtc->pipe) { > + /* > + * If another power sequencer was being used on this > + * port previously make sure to turn off vdd there while > + * we still have control of it. > + */ > vlv_detach_power_sequencer(intel_dp); > + } > > /* > * We may be stealing the power > @@ -2899,6 +2930,11 @@ static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp) > */ > vlv_steal_power_sequencer(dev, crtc->pipe); > > + intel_dp->active_pipe = crtc->pipe; > + > + if (!is_edp(intel_dp)) > + return; > + > /* now it's all ours */ > intel_dp->pps_pipe = crtc->pipe; > > @@ -3485,6 +3521,12 @@ intel_dp_link_down(struct intel_dp *intel_dp) > msleep(intel_dp->panel_power_down_delay); > > intel_dp->DP = DP; > + > + if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) { > + pps_lock(intel_dp); > + intel_dp->active_pipe = INVALID_PIPE; > + pps_unlock(intel_dp); > + } > } > > bool > @@ -4750,6 +4792,19 @@ static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp) > edp_panel_vdd_schedule_off(intel_dp); > } > > +enum pipe vlv_active_pipe(struct intel_dp *intel_dp) > +{ > + struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp)); > + > + if ((intel_dp->DP & DP_PORT_EN) == 0) > + return INVALID_PIPE; > + > + if (IS_CHERRYVIEW(dev_priv)) > + return DP_PORT_TO_PIPE_CHV(intel_dp->DP); > + else > + return PORT_TO_PIPE(intel_dp->DP); > +} > + > void intel_dp_encoder_reset(struct drm_encoder *encoder) > { > struct drm_i915_private *dev_priv = to_i915(encoder->dev); > @@ -4762,14 +4817,16 @@ void intel_dp_encoder_reset(struct drm_encoder *encoder) > if (lspcon->active) > lspcon_resume(lspcon); > > - if (to_intel_encoder(encoder)->type != INTEL_OUTPUT_EDP) > - return; > - > pps_lock(intel_dp); > > - /* Reinit the power sequencer, in case BIOS did something with it. */ > - intel_dp_pps_init(encoder->dev, intel_dp); > - intel_edp_panel_vdd_sanitize(intel_dp); > + if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) > + intel_dp->active_pipe = vlv_active_pipe(intel_dp); > + > + if (is_edp(intel_dp)) { > + /* Reinit the power sequencer, in case BIOS did something with it. */ > + intel_dp_pps_init(encoder->dev, intel_dp); > + intel_edp_panel_vdd_sanitize(intel_dp); > + } > > pps_unlock(intel_dp); > } > @@ -5596,10 +5653,7 @@ static bool intel_edp_init_connector(struct intel_dp *intel_dp, > * If the current pipe isn't valid, try the PPS pipe, and if that > * fails just assume pipe A. > */ > - if (IS_CHERRYVIEW(dev_priv)) > - pipe = DP_PORT_TO_PIPE_CHV(intel_dp->DP); > - else > - pipe = PORT_TO_PIPE(intel_dp->DP); > + pipe = vlv_active_pipe(intel_dp); > > if (pipe != PIPE_A && pipe != PIPE_B) > pipe = intel_dp->pps_pipe; > @@ -5648,6 +5702,7 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port, > return false; > > intel_dp->pps_pipe = INVALID_PIPE; > + intel_dp->active_pipe = INVALID_PIPE; > > /* intel_dp vfuncs */ > if (INTEL_GEN(dev_priv) >= 9) > @@ -5676,6 +5731,9 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port, > else > type = DRM_MODE_CONNECTOR_DisplayPort; > > + if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) > + intel_dp->active_pipe = vlv_active_pipe(intel_dp); > + > /* > * For eDP we always set the encoder type to INTEL_OUTPUT_EDP, but > * for DP the encoder type can be set by the caller to > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 8f4ddca0f521..85b39d3a6dff 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -929,6 +929,12 @@ struct intel_dp { > */ > enum pipe pps_pipe; > /* > + * Pipe currently driving the port. Used for preventing > + * the use of the PPS for any pipe currentrly driving > + * external DP as that will mess things up on VLV. > + */ > + enum pipe active_pipe; > + /* > * Set if the sequencer may be reset due to a power transition, > * requiring a reinitialization. Only relevant on BXT. > */ > -- > 2.7.4 -- Ville Syrj�l� Intel OTC