From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH 2/3] drm/i915: Use the correct crtc when sanitizing plane mapping Date: Tue, 2 Oct 2018 17:21:36 +0300 Message-ID: <20181002142136.GU9144@intel.com> References: <20181001142909.5567-1-ville.syrjala@linux.intel.com> <20181001143120.5777-1-ville.syrjala@linux.intel.com> <20181002121134.GN11082@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20181002121134.GN11082@phenom.ffwll.local> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Daniel Vetter Cc: stable@vger.kernel.org, intel-gfx@lists.freedesktop.org, Dennis , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBPY3QgMDIsIDIwMTggYXQgMDI6MTE6MzRQTSArMDIwMCwgRGFuaWVsIFZldHRlciB3 cm90ZToKPiBPbiBNb24sIE9jdCAwMSwgMjAxOCBhdCAwNTozMToyMFBNICswMzAwLCBWaWxsZSBT eXJqYWxhIHdyb3RlOgo+ID4gRnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxp bnV4LmludGVsLmNvbT4KPiA+IAo+ID4gV2hlbiB3ZSBkZWNpZGUgdGhhdCBhIHBsYW5lIGlzIGF0 dGFjaGVkIHRvIHRoZSB3cm9uZyBwaXBlIHdlIHRyeQo+ID4gdG8gdHVybiBvZmYgc2FpZCBwbGFu ZS4gSG93ZXZlciB3ZSBhcmUgcGFzc2luZyBhcm91bmQgdGhlIGNydGMgd2UKPiA+IHRoaW5rIHRo YXQgdGhlIHBsYW5lIGlzIHN1cHBvc2VkIHRvIGJlIHVzaW5nIHJhdGhlciB0aGFuIHRoZSBjcnRj Cj4gPiBpdCBpcyBjdXJyZW50bHkgdXNpbmcuIFRoYXQgZG9lc24ndCB3b3JrIGFsbCB0aGF0IHdl bGwgYmVjYXVzZQo+ID4gd2UgbWF5IGhhdmUgdG8gZG8gdmJsYW5rIHdhaXRzIGV0Yy4gYW5kIHRo ZSBvdGhlciBwaXBlIG1pZ2h0Cj4gPiBub3QgZXZlbiBiZSBlbmFibGVkIGhlcmUuIFNvIGxldCdz IHBhc3MgdGhlIHBsYW5lJ3MgY3VycmVudCBjcnRjIHRvCj4gPiBpbnRlbF9wbGFuZV9kaXNhYmxl X25vYXRvbWljKCkgc28gdGhhdCBpdCBjYW4gaXRzIGpvYiBjb3JyZWN0bHkuCj4gPiAKPiA+IFRv IGRvIHRoYXQgc2VtaS1jbGVhbmx5IHdlIGFsc28gaGF2ZSB0byBjaGFuZ2UgdGhlIHBsYW5lIHJl YWRvdXQKPiA+IHRvIHJlY29yZCB0aGUgcGxhbmUncyB2aXNpYmlsaXR5IGludG8gdGhlIGJpdG1h c2tzIG9mIHRoZSBjcnRjCj4gPiB3aGVyZSB0aGUgcGxhbmUgaXMgY3VycmVudGx5IGVuYWJsZWQg cmF0aGVyIHRoYW4gdG8gdGhlIGNydGMKPiA+IHdlIHdhbnQgdG8gdXNlIGZvciB0aGUgcGxhbmUu Cj4gPiAKPiA+IE9uZSBjYXZlYXQgaGVyZSBpcyB0aGF0IG91ciBhY3RpdmVfcGxhbmVzIGJpdG1h c2sgd2lsbCBnZXQgY29uZnVzZWQKPiA+IGlmIGJvdGggcGxhbmVzIGFyZSBlbmFibGVkIG9uIHRo ZSBzYW1lIHBpcGUuIEZvcnR1bmF0ZWx5IHdlIGNhbiB1c2UKPiA+IHBsYW5lX21hc2sgdG8gcmVj b25zdHJ1Y3QgYWN0aXZlX3BsYW5lcyBzdWZmaWNpZW50bHkgc2luY2UKPiA+IHBsYW5lX21hc2sg c3RpbGwgaGFzIHRoZSBzYW1lIG1lYW5pbmcgKGlzIHRoZSBwbGFuZSB2aXNpYmxlPykKPiA+IGR1 cmluZyByZWFkb3V0LiBXZSBhbHNvIGhhdmUgdG8gZG8gdGhlIHNhbWUgZHVyaW5nIHRoZSBpbml0 aWFsCj4gPiBwbGFuZSByZWFkb3V0IGFzIHRoZSBzZWNvbmQgcGxhbmUgY291bGQgY2xlYXIgdGhl IGFjdGl2ZV9wbGFuZXMKPiA+IGJpdCB0aGUgZmlyc3QgcGxhbmUgaGFkIGFscmVhZHkgc2V0Lgo+ IAo+IEhvdyBvZnRlbiBoYXZlIHdlIGJyb2tlbiB0aGlzIDotLwo+IAo+IFVuZm9ydHVuYXRlbHkg SSBzdGlsbCBkb24ndCBoYXZlIGEgZ29vZCBpZGVhIGhvdyB0byBiZXN0IENJIHRoaXMsIHNpbmNl IHdlCj4gc2h1dCBkb3duIGV2ZXJ5dGhpbmcgb24gbW9kdWxlIHVubG9hZC4gTWF5YmUgd2Ugc2hv dWxkIGhhdmUgYSBzcGVjaWFsIG1vZGUKPiBmb3IgbW9kdWxlIHVubG9hZCB0byBsZWF2ZSB0aGUg aHcgb24sIHNvIHRoYXQgd2UgY2FuIHN0YXJ0IHRlc3RpbmcgdmFyaW91cwo+IGZhc3Rib290IHNj ZW5hcmlvcyAuLi4KClllYWgsIHRoYXQgbWlnaHQgYmUgbmljZS4gVGhvdWdoIHdvdWxkbid0IGRp cmVjdGx5IGhlbHAgaGVyZSBzaW5jZQp3ZSdkIHN0aWxsIGhhdmUgdG8gbW92ZSB0aGUgcGxhbmUg dG8gdGhlIG90aGVyIHBpcGUuIEJ1dCB3ZSBjb3VsZApvZiBjb3Vyc2UgbWFrZSB0aGUgZHJpdmVy IHVubG9hZCBkbyB0aGF0IGZvciB1cyBhcyB3ZWxsLgoKT2ggYW5kIHRvIGhpdCB0aGlzIGJ1ZyB3 ZSdkIGFsc28gbmVlZCB0byBtYWtlIHN1cmUgY3hzciBpcyBlbmFibGVkCndoZW4gd2UgdW5sb2Fk IGFzIHRoYXQncyB3aGF0IGxlYWRzIHRvIHRoZSB2Ymxhbmsgd2FpdC4gVGhhdCdzIGFjdHVhbGx5 CnRoZSByZWFzb24gSSBkaWRuJ3QgY2F0Y2ggdGhpcyBidWcgb3JpZ2luYWxseS4gTm9uZSBvZiBt eSBtYWNoaW5lcwpoYXZlIGEgVkJJT1MgdGhhdCBlbmFibGVzIGN4c3IuCgo+IAo+IFNvbWUgcXVl c3Rpb25zIGJlbG93Lgo+IAo+ID4gQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcgIyBmY2JhODYy ZTg0MjggZHJtL2k5MTU6IEhhdmUgcGxhbmUtPmdldF9od19zdGF0ZSgpIHJldHVybiB0aGUgY3Vy cmVudCBwaXBlCj4gPiBDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZwo+ID4gQ2M6IERlbm5pcyA8 ZGVubmlzLm5lemljQHV0b3JvbnRvLmNhPgo+ID4gVGVzdGVkLWJ5OiBEZW5uaXMgPGRlbm5pcy5u ZXppY0B1dG9yb250by5jYT4KPiA+IEJ1Z3ppbGxhOiBodHRwczovL2J1Z3MuZnJlZWRlc2t0b3Au b3JnL3Nob3dfYnVnLmNnaT9pZD0xMDU2MzcKPiA+IEZpeGVzOiBiMWUwMTU5NWE2NmQgKCJkcm0v aTkxNTogUmVkbyBwbGFuZSBzYW5pdGF0aW9uIGR1cmluZyByZWFkb3V0IikKPiA+IFNpZ25lZC1v ZmYtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+Cj4g PiAtLS0KPiA+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgfCA2MyArKysr KysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0KPiA+ICAxIGZpbGUgY2hhbmdlZCwgNDcg aW5zZXJ0aW9ucygrKSwgMTYgZGVsZXRpb25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kaXNwbGF5LmMKPiA+IGluZGV4IGUwMThiMzdiZWQzOS4uYzcyYmU4Y2QxZjU0IDEwMDY0 NAo+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4gPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiA+IEBAIC0xNTQ3NSwxNSAr MTU0NzUsMTYgQEAgdm9pZCBpODMwX2Rpc2FibGVfcGlwZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0 ZSAqZGV2X3ByaXYsIGVudW0gcGlwZSBwaXBlKQo+ID4gIAlQT1NUSU5HX1JFQUQoRFBMTChwaXBl KSk7Cj4gPiAgfQo+ID4gIAo+ID4gLXN0YXRpYyBib29sIGludGVsX3BsYW5lX21hcHBpbmdfb2so c3RydWN0IGludGVsX2NydGMgKmNydGMsCj4gPiAtCQkJCSAgIHN0cnVjdCBpbnRlbF9wbGFuZSAq cGxhbmUpCj4gPiArc3RhdGljIHZvaWQgZml4dXBfYWN0aXZlX3BsYW5lcyhzdHJ1Y3QgaW50ZWxf Y3J0YyAqY3J0YykKPiA+ICB7Cj4gPiAtCWVudW0gcGlwZSBwaXBlOwo+ID4gLQo+ID4gLQlpZiAo IXBsYW5lLT5nZXRfaHdfc3RhdGUocGxhbmUsICZwaXBlKSkKPiA+IC0JCXJldHVybiB0cnVlOwo+ ID4gKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGNydGMtPmJh c2UuZGV2KTsKPiA+ICsJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUgPQo+ID4g KwkJdG9faW50ZWxfY3J0Y19zdGF0ZShjcnRjLT5iYXNlLnN0YXRlKTsKPiA+ICsJc3RydWN0IGRy bV9wbGFuZSAqcGxhbmU7Cj4gPiAgCj4gPiAtCXJldHVybiBwaXBlID09IGNydGMtPnBpcGU7Cj4g PiArCWRybV9mb3JfZWFjaF9wbGFuZV9tYXNrKHBsYW5lLCAmZGV2X3ByaXYtPmRybSwKPiA+ICsJ CQkJY3J0Y19zdGF0ZS0+YmFzZS5wbGFuZV9tYXNrKQo+ID4gKwkJY3J0Y19zdGF0ZS0+YWN0aXZl X3BsYW5lcyB8PSBCSVQodG9faW50ZWxfcGxhbmUocGxhbmUpLT5pZCk7Cj4gCj4gSSB0aGluayB3 ZSBuZWVkIHRvIGFsc28gdXBkYXRlIHBsYW5lX21hc2sgaGVyZS4KCnBsYW5lX21hc2sgd2lsbCBi ZSBjb3JyZWN0IHNpbmNlIGVhY2ggcGxhbmUgaGFzIGEgdW5pcXVlIGJpdCB0aGVyZS4KQW5kIGlu IGZhY3Qgd2UgdXNlIHBsYW5lX21hc2sgdG8gcmVjb25zdHJ1Y3QgYWN0aXZlX3BsYW5lcy4KCldo YXQgd2UgY291bGQgZG8gaXMgc2V0IGFjdGl2ZV9wbGFuZXM9MCBiZWZvcmUgdGhlIGxvb3AsIGFz IHRoZSBsb29wCndpbGwgcG9wdWxhdGUgaXQgZnVsbHkgYW55d2F5LgoKPiAKPiA+ICB9Cj4gPiAg Cj4gPiAgc3RhdGljIHZvaWQKPiA+IEBAIC0xNTQ5NywxMyArMTU0OTgsMjggQEAgaW50ZWxfc2Fu aXRpemVfcGxhbmVfbWFwcGluZyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCj4g PiAgCWZvcl9lYWNoX2ludGVsX2NydGMoJmRldl9wcml2LT5kcm0sIGNydGMpIHsKPiA+ICAJCXN0 cnVjdCBpbnRlbF9wbGFuZSAqcGxhbmUgPQo+ID4gIAkJCXRvX2ludGVsX3BsYW5lKGNydGMtPmJh c2UucHJpbWFyeSk7Cj4gPiArCQlzdHJ1Y3QgaW50ZWxfY3J0YyAqcGxhbmVfY3J0YzsKPiA+ICsJ CWVudW0gcGlwZSBwaXBlOwo+ID4gKwo+ID4gKwkJaWYgKCFwbGFuZS0+Z2V0X2h3X3N0YXRlKHBs YW5lLCAmcGlwZSkpCj4gPiArCQkJY29udGludWU7Cj4gPiAgCj4gPiAtCQlpZiAoaW50ZWxfcGxh bmVfbWFwcGluZ19vayhjcnRjLCBwbGFuZSkpCj4gPiArCQlpZiAocGlwZSA9PSBjcnRjLT5waXBl KQo+ID4gIAkJCWNvbnRpbnVlOwo+ID4gIAo+ID4gIAkJRFJNX0RFQlVHX0tNUygiJXMgYXR0YWNo ZWQgdG8gdGhlIHdyb25nIHBpcGUsIGRpc2FibGluZyBwbGFuZVxuIiwKPiA+ICAJCQkgICAgICBw bGFuZS0+YmFzZS5uYW1lKTsKPiA+IC0JCWludGVsX3BsYW5lX2Rpc2FibGVfbm9hdG9taWMoY3J0 YywgcGxhbmUpOwo+ID4gKwo+ID4gKwkJcGxhbmVfY3J0YyA9IGludGVsX2dldF9jcnRjX2Zvcl9w aXBlKGRldl9wcml2LCBwaXBlKTsKPiA+ICsJCWludGVsX3BsYW5lX2Rpc2FibGVfbm9hdG9taWMo cGxhbmVfY3J0YywgcGxhbmUpOwo+ID4gKwo+ID4gKwkJLyoKPiA+ICsJCSAqIE91ciBhY3RpdmVf cGxhbmVzIHRyYWNraW5nIHdpbGwgZ2V0IGNvbmZ1c2VkIGhlcmUKPiA+ICsJCSAqIGlmIGJvdGgg cGxhbmVzIEEgYW5kIEIgYXJlIGVuYWJsZWQgb24gdGhlIHNhbWUgcGlwZQo+ID4gKwkJICogKHNp bmNlIGJvdGggcGxhbmVzIG1hcCB0byBCSVQoUExBTkVfUFJJTUFSWSkpLgo+ID4gKwkJICogUmVj b25zdHJ1Y3QgYWN0aXZlX3BsYW5lcyBhZnRlciBkaXNhYmxpbmcgdGhlIHBsYW5lLgo+ID4gKwkJ ICovCj4gCj4gSG0sIHdvdWxkIGJlIG5lYXQgaWYgd2UgY291bGQgcmV0aXJlIGludGVsX2NydGNf c3RhdGUtPmFjdGl2ZV9wbGFuZXMgaW4KPiBmYXZvdXIgb2YgZHJtX2NydGNfc3RhdGUtPnBsYW5l X21hc2suIEV4Y2VwdCBmb3IgdGhhdCBlbnRpcmUgdmlzaWJsZSB5L24KPiB0aGluZyA6LS8KCkkn bSBhIGJpdCB0b3JuIGFib3V0IHRoaXMuIGFjdGl2ZV9wbGFuZXMgaXMgcmF0aGVyIGNvbnZlbmll bnQgZm9yCndhdGVybWFyayBzdHVmZiBhbmQgd2hhdG5vdCwgYnV0IG9uIHRoZSBvdGhlciBoYW5k IGl0IGRvZXNuJ3QgbWFwCndlbGwgdG8gcHJlLWc0eCBoYXJkd2FyZSwgc28gaW4gb3RoZXIgd2F5 cyBpdCdzIG5vdCBzbyBncmVhdC4KCj4gCj4gPiArCQlmaXh1cF9hY3RpdmVfcGxhbmVzKHBsYW5l X2NydGMpOwo+IAo+IEJpdCBhIGJpa2VzaGVkLCBidXQgd2hhdCBhYm91dCB0aHJvd2luZyB0aGUg cGxhbmUgc3RhdGUgYXdheSBhbmQganVzdAo+IHN0YXJ0aW5nIG92ZXIsIGluc3RlYWQgb2YgdHJ5 aW5nIHRvIGZpeCBpdCB1cD8KCllvdSBtZWFuIGp1c3QgemVyb2luZyB0aGUgcGxhbmUgbWFza3Mg aW4gdGhlIGNydGMgc3RhdGUgYW5kCmRvaW5nIHRoZSBwbGFuZV9yZWFkb3V0IGFnYWluPyBUaGF0 IHNob3VsZCBiZSBkb2FibGUuCgo+IFdlIGNvdWxkIHRoZW4gdXNlIHRoYXQgYXMgYQo+IGNvbnNp c3RlbmN5IGNoZWNrLCBpZiB0aGUgcGxhbmUgbWFwcGluZ3MgYXJlIHN0aWxsIHdyb25nIG91ciBj b2RlIGlzCj4gYnJva2VuIGFuZCB3ZSBzaG91bGQgYmFpbCBvdXQgd2l0aCBhIHZlcnkgbG91ZCB3 YXJuaW5nLgoKSW5kZWVkLiBUaGF0IHNlZW1zIGxpa2UgYSBoYWxmIGRlY2VudCBzYW5pdHkgY2hl Y2suCgo+IAo+IEJ1dCB0aGlzIGhlcmUgc2hvdWxkIHdvcmsgdG9vLCBhbGJlaXQgYSBiaXQgbW9y ZSBmcmFnaWxlIEkgdGhpbmsuCj4gCj4gQ2hlZXJzLCBEYW5pZWwKPiA+ICAJfQo+ID4gIH0KPiA+ ICAKPiA+IEBAIC0xNTY3MSwyMyArMTU2ODcsMzggQEAgdm9pZCBpOTE1X3JlZGlzYWJsZV92Z2Eo c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQo+ID4gIH0KPiA+ICAKPiA+ICAvKiBG SVhNRSByZWFkIG91dCBmdWxsIHBsYW5lIHN0YXRlIGZvciBhbGwgcGxhbmVzICovCj4gPiAtc3Rh dGljIHZvaWQgcmVhZG91dF9wbGFuZV9zdGF0ZShzdHJ1Y3QgaW50ZWxfY3J0YyAqY3J0YykKPiA+ ICtzdGF0aWMgdm9pZCByZWFkb3V0X3BsYW5lX3N0YXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdikKPiA+ICB7Cj4gPiAtCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp diA9IHRvX2k5MTUoY3J0Yy0+YmFzZS5kZXYpOwo+ID4gLQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0 ZSAqY3J0Y19zdGF0ZSA9Cj4gPiAtCQl0b19pbnRlbF9jcnRjX3N0YXRlKGNydGMtPmJhc2Uuc3Rh dGUpOwo+ID4gIAlzdHJ1Y3QgaW50ZWxfcGxhbmUgKnBsYW5lOwo+ID4gKwlzdHJ1Y3QgaW50ZWxf Y3J0YyAqY3J0YzsKPiA+ICAKPiA+IC0JZm9yX2VhY2hfaW50ZWxfcGxhbmVfb25fY3J0YygmZGV2 X3ByaXYtPmRybSwgY3J0YywgcGxhbmUpIHsKPiA+ICsJZm9yX2VhY2hfaW50ZWxfcGxhbmUoJmRl dl9wcml2LT5kcm0sIHBsYW5lKSB7Cj4gPiAgCQlzdHJ1Y3QgaW50ZWxfcGxhbmVfc3RhdGUgKnBs YW5lX3N0YXRlID0KPiA+ICAJCQl0b19pbnRlbF9wbGFuZV9zdGF0ZShwbGFuZS0+YmFzZS5zdGF0 ZSk7Cj4gPiArCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZTsKPiA+ICAJCWVu dW0gcGlwZSBwaXBlOwo+ID4gIAkJYm9vbCB2aXNpYmxlOwo+ID4gIAo+ID4gIAkJdmlzaWJsZSA9 IHBsYW5lLT5nZXRfaHdfc3RhdGUocGxhbmUsICZwaXBlKTsKPiA+ICAKPiA+ICsJCWNydGMgPSBp bnRlbF9nZXRfY3J0Y19mb3JfcGlwZShkZXZfcHJpdiwgcGlwZSk7Cj4gPiArCQljcnRjX3N0YXRl ID0gdG9faW50ZWxfY3J0Y19zdGF0ZShjcnRjLT5iYXNlLnN0YXRlKTsKPiA+ICsKPiA+ICAJCWlu dGVsX3NldF9wbGFuZV92aXNpYmxlKGNydGNfc3RhdGUsIHBsYW5lX3N0YXRlLCB2aXNpYmxlKTsK PiA+ICAJfQo+ID4gKwo+ID4gKwlmb3JfZWFjaF9pbnRlbF9jcnRjKCZkZXZfcHJpdi0+ZHJtLCBj cnRjKSB7Cj4gPiArCQkvKgo+ID4gKwkJICogT3VyIGFjdGl2ZV9wbGFuZXMgdHJhY2tpbmcgbWF5 IGdldCBjb25mdXNlZCBoZXJlCj4gPiArCQkgKiBvbiBnZW4yLzMgaWYgdGhlIGZpcnN0IHBsYW5l IGlzIGVuYWJsZWQgYnV0IHRoZQo+ID4gKwkJICogc2Vjb25kIG9uZSBpc24ndCBidXQgYm90aCBp bmRpY2F0ZSB0aGUgc2FtZSBwaXBlLgo+ID4gKwkJICogVGhlIHNlY29uZCBwbGFuZSB3b3VsZCBj bGVhciB0aGUgYWN0aXZlX3BsYW5lcwo+ID4gKwkJICogYml0IGZvciB0aGUgZmlyc3QgcGxhbmUg KHNpbmNlIGJvdGggbWFwIHRvCj4gPiArCQkgKiBCSVQoUExBTkVfUFJJTUFSWSkuIFJlY29uc3Ry dWN0IGFjdGl2ZV9wbGFuZXMKPiA+ICsJCSAqIGFmdGVyIHBsYW5lIHJlYWRvdXQgaXMgZG9uZS4K PiA+ICsJCSAqLwo+ID4gKwkJZml4dXBfYWN0aXZlX3BsYW5lcyhjcnRjKTsKPiA+ICsJfQo+ID4g IH0KPiA+ICAKPiA+ICBzdGF0aWMgdm9pZCBpbnRlbF9tb2Rlc2V0X3JlYWRvdXRfaHdfc3RhdGUo c3RydWN0IGRybV9kZXZpY2UgKmRldikKPiA+IEBAIC0xNTcxOSwxMyArMTU3NTAsMTMgQEAgc3Rh dGljIHZvaWQgaW50ZWxfbW9kZXNldF9yZWFkb3V0X2h3X3N0YXRlKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYpCj4gPiAgCQlpZiAoY3J0Y19zdGF0ZS0+YmFzZS5hY3RpdmUpCj4gPiAgCQkJZGV2X3By aXYtPmFjdGl2ZV9jcnRjcyB8PSAxIDw8IGNydGMtPnBpcGU7Cj4gPiAgCj4gPiAtCQlyZWFkb3V0 X3BsYW5lX3N0YXRlKGNydGMpOwo+ID4gLQo+ID4gIAkJRFJNX0RFQlVHX0tNUygiW0NSVEM6JWQ6 JXNdIGh3IHN0YXRlIHJlYWRvdXQ6ICVzXG4iLAo+ID4gIAkJCSAgICAgIGNydGMtPmJhc2UuYmFz ZS5pZCwgY3J0Yy0+YmFzZS5uYW1lLAo+ID4gIAkJCSAgICAgIGVuYWJsZWRkaXNhYmxlZChjcnRj X3N0YXRlLT5iYXNlLmFjdGl2ZSkpOwo+ID4gIAl9Cj4gPiAgCj4gPiArCXJlYWRvdXRfcGxhbmVf c3RhdGUoZGV2X3ByaXYpOwo+ID4gKwo+ID4gIAlmb3IgKGkgPSAwOyBpIDwgZGV2X3ByaXYtPm51 bV9zaGFyZWRfZHBsbDsgaSsrKSB7Cj4gPiAgCQlzdHJ1Y3QgaW50ZWxfc2hhcmVkX2RwbGwgKnBs bCA9ICZkZXZfcHJpdi0+c2hhcmVkX2RwbGxzW2ldOwo+ID4gIAo+ID4gLS0gCj4gPiAyLjE2LjQK PiA+IAo+ID4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K PiA+IEludGVsLWdmeCBtYWlsaW5nIGxpc3QKPiA+IEludGVsLWdmeEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKPiA+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v aW50ZWwtZ2Z4Cj4gCj4gLS0gCj4gRGFuaWVsIFZldHRlcgo+IFNvZnR3YXJlIEVuZ2luZWVyLCBJ bnRlbCBDb3Jwb3JhdGlvbgo+IGh0dHA6Ly9ibG9nLmZmd2xsLmNoCgotLSAKVmlsbGUgU3lyasOk bMOkCkludGVsCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga05.intel.com ([192.55.52.43]:12228 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726118AbeJBVFW (ORCPT ); Tue, 2 Oct 2018 17:05:22 -0400 Date: Tue, 2 Oct 2018 17:21:36 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Daniel Vetter Cc: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, Dennis , stable@vger.kernel.org Subject: Re: [Intel-gfx] [PATCH 2/3] drm/i915: Use the correct crtc when sanitizing plane mapping Message-ID: <20181002142136.GU9144@intel.com> References: <20181001142909.5567-1-ville.syrjala@linux.intel.com> <20181001143120.5777-1-ville.syrjala@linux.intel.com> <20181002121134.GN11082@phenom.ffwll.local> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20181002121134.GN11082@phenom.ffwll.local> Sender: stable-owner@vger.kernel.org List-ID: On Tue, Oct 02, 2018 at 02:11:34PM +0200, Daniel Vetter wrote: > On Mon, Oct 01, 2018 at 05:31:20PM +0300, Ville Syrjala wrote: > > From: Ville Syrj�l� > > > > When we decide that a plane is attached to the wrong pipe we try > > to turn off said plane. However we are passing around the crtc we > > think that the plane is supposed to be using rather than the crtc > > it is currently using. That doesn't work all that well because > > we may have to do vblank waits etc. and the other pipe might > > not even be enabled here. So let's pass the plane's current crtc to > > intel_plane_disable_noatomic() so that it can its job correctly. > > > > To do that semi-cleanly we also have to change the plane readout > > to record the plane's visibility into the bitmasks of the crtc > > where the plane is currently enabled rather than to the crtc > > we want to use for the plane. > > > > One caveat here is that our active_planes bitmask will get confused > > if both planes are enabled on the same pipe. Fortunately we can use > > plane_mask to reconstruct active_planes sufficiently since > > plane_mask still has the same meaning (is the plane visible?) > > during readout. We also have to do the same during the initial > > plane readout as the second plane could clear the active_planes > > bit the first plane had already set. > > How often have we broken this :-/ > > Unfortunately I still don't have a good idea how to best CI this, since we > shut down everything on module unload. Maybe we should have a special mode > for module unload to leave the hw on, so that we can start testing various > fastboot scenarios ... Yeah, that might be nice. Though wouldn't directly help here since we'd still have to move the plane to the other pipe. But we could of course make the driver unload do that for us as well. Oh and to hit this bug we'd also need to make sure cxsr is enabled when we unload as that's what leads to the vblank wait. That's actually the reason I didn't catch this bug originally. None of my machines have a VBIOS that enables cxsr. > > Some questions below. > > > Cc: stable@vger.kernel.org # fcba862e8428 drm/i915: Have plane->get_hw_state() return the current pipe > > Cc: stable@vger.kernel.org > > Cc: Dennis > > Tested-by: Dennis > > Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=105637 > > Fixes: b1e01595a66d ("drm/i915: Redo plane sanitation during readout") > > Signed-off-by: Ville Syrj�l� > > --- > > drivers/gpu/drm/i915/intel_display.c | 63 +++++++++++++++++++++++++++--------- > > 1 file changed, 47 insertions(+), 16 deletions(-) > > > > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > > index e018b37bed39..c72be8cd1f54 100644 > > --- a/drivers/gpu/drm/i915/intel_display.c > > +++ b/drivers/gpu/drm/i915/intel_display.c > > @@ -15475,15 +15475,16 @@ void i830_disable_pipe(struct drm_i915_private *dev_priv, enum pipe pipe) > > POSTING_READ(DPLL(pipe)); > > } > > > > -static bool intel_plane_mapping_ok(struct intel_crtc *crtc, > > - struct intel_plane *plane) > > +static void fixup_active_planes(struct intel_crtc *crtc) > > { > > - enum pipe pipe; > > - > > - if (!plane->get_hw_state(plane, &pipe)) > > - return true; > > + struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); > > + struct intel_crtc_state *crtc_state = > > + to_intel_crtc_state(crtc->base.state); > > + struct drm_plane *plane; > > > > - return pipe == crtc->pipe; > > + drm_for_each_plane_mask(plane, &dev_priv->drm, > > + crtc_state->base.plane_mask) > > + crtc_state->active_planes |= BIT(to_intel_plane(plane)->id); > > I think we need to also update plane_mask here. plane_mask will be correct since each plane has a unique bit there. And in fact we use plane_mask to reconstruct active_planes. What we could do is set active_planes=0 before the loop, as the loop will populate it fully anyway. > > > } > > > > static void > > @@ -15497,13 +15498,28 @@ intel_sanitize_plane_mapping(struct drm_i915_private *dev_priv) > > for_each_intel_crtc(&dev_priv->drm, crtc) { > > struct intel_plane *plane = > > to_intel_plane(crtc->base.primary); > > + struct intel_crtc *plane_crtc; > > + enum pipe pipe; > > + > > + if (!plane->get_hw_state(plane, &pipe)) > > + continue; > > > > - if (intel_plane_mapping_ok(crtc, plane)) > > + if (pipe == crtc->pipe) > > continue; > > > > DRM_DEBUG_KMS("%s attached to the wrong pipe, disabling plane\n", > > plane->base.name); > > - intel_plane_disable_noatomic(crtc, plane); > > + > > + plane_crtc = intel_get_crtc_for_pipe(dev_priv, pipe); > > + intel_plane_disable_noatomic(plane_crtc, plane); > > + > > + /* > > + * Our active_planes tracking will get confused here > > + * if both planes A and B are enabled on the same pipe > > + * (since both planes map to BIT(PLANE_PRIMARY)). > > + * Reconstruct active_planes after disabling the plane. > > + */ > > Hm, would be neat if we could retire intel_crtc_state->active_planes in > favour of drm_crtc_state->plane_mask. Except for that entire visible y/n > thing :-/ I'm a bit torn about this. active_planes is rather convenient for watermark stuff and whatnot, but on the other hand it doesn't map well to pre-g4x hardware, so in other ways it's not so great. > > > + fixup_active_planes(plane_crtc); > > Bit a bikeshed, but what about throwing the plane state away and just > starting over, instead of trying to fix it up? You mean just zeroing the plane masks in the crtc state and doing the plane_readout again? That should be doable. > We could then use that as a > consistency check, if the plane mappings are still wrong our code is > broken and we should bail out with a very loud warning. Indeed. That seems like a half decent sanity check. > > But this here should work too, albeit a bit more fragile I think. > > Cheers, Daniel > > } > > } > > > > @@ -15671,23 +15687,38 @@ void i915_redisable_vga(struct drm_i915_private *dev_priv) > > } > > > > /* FIXME read out full plane state for all planes */ > > -static void readout_plane_state(struct intel_crtc *crtc) > > +static void readout_plane_state(struct drm_i915_private *dev_priv) > > { > > - struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); > > - struct intel_crtc_state *crtc_state = > > - to_intel_crtc_state(crtc->base.state); > > struct intel_plane *plane; > > + struct intel_crtc *crtc; > > > > - for_each_intel_plane_on_crtc(&dev_priv->drm, crtc, plane) { > > + for_each_intel_plane(&dev_priv->drm, plane) { > > struct intel_plane_state *plane_state = > > to_intel_plane_state(plane->base.state); > > + struct intel_crtc_state *crtc_state; > > enum pipe pipe; > > bool visible; > > > > visible = plane->get_hw_state(plane, &pipe); > > > > + crtc = intel_get_crtc_for_pipe(dev_priv, pipe); > > + crtc_state = to_intel_crtc_state(crtc->base.state); > > + > > intel_set_plane_visible(crtc_state, plane_state, visible); > > } > > + > > + for_each_intel_crtc(&dev_priv->drm, crtc) { > > + /* > > + * Our active_planes tracking may get confused here > > + * on gen2/3 if the first plane is enabled but the > > + * second one isn't but both indicate the same pipe. > > + * The second plane would clear the active_planes > > + * bit for the first plane (since both map to > > + * BIT(PLANE_PRIMARY). Reconstruct active_planes > > + * after plane readout is done. > > + */ > > + fixup_active_planes(crtc); > > + } > > } > > > > static void intel_modeset_readout_hw_state(struct drm_device *dev) > > @@ -15719,13 +15750,13 @@ static void intel_modeset_readout_hw_state(struct drm_device *dev) > > if (crtc_state->base.active) > > dev_priv->active_crtcs |= 1 << crtc->pipe; > > > > - readout_plane_state(crtc); > > - > > DRM_DEBUG_KMS("[CRTC:%d:%s] hw state readout: %s\n", > > crtc->base.base.id, crtc->base.name, > > enableddisabled(crtc_state->base.active)); > > } > > > > + readout_plane_state(dev_priv); > > + > > for (i = 0; i < dev_priv->num_shared_dpll; i++) { > > struct intel_shared_dpll *pll = &dev_priv->shared_dplls[i]; > > > > -- > > 2.16.4 > > > > _______________________________________________ > > Intel-gfx mailing list > > Intel-gfx@lists.freedesktop.org > > https://lists.freedesktop.org/mailman/listinfo/intel-gfx > > -- > Daniel Vetter > Software Engineer, Intel Corporation > http://blog.ffwll.ch -- Ville Syrj�l� Intel