From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville Syrjala Subject: [PATCH v2 2/3] drm/i915: Use the correct crtc when sanitizing plane mapping Date: Wed, 3 Oct 2018 17:50:17 +0300 Message-ID: <20181003145017.4527-1-ville.syrjala@linux.intel.com> References: <20181001143120.5777-1-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20181001143120.5777-1-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: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Dennis , stable@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org RnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KCldo ZW4gd2UgZGVjaWRlIHRoYXQgYSBwbGFuZSBpcyBhdHRhY2hlZCB0byB0aGUgd3JvbmcgcGlwZSB3 ZSB0cnkKdG8gdHVybiBvZmYgc2FpZCBwbGFuZS4gSG93ZXZlciB3ZSBhcmUgcGFzc2luZyBhcm91 bmQgdGhlIGNydGMgd2UKdGhpbmsgdGhhdCB0aGUgcGxhbmUgaXMgc3VwcG9zZWQgdG8gYmUgdXNp bmcgcmF0aGVyIHRoYW4gdGhlIGNydGMKaXQgaXMgY3VycmVudGx5IHVzaW5nLiBUaGF0IGRvZXNu J3Qgd29yayBhbGwgdGhhdCB3ZWxsIGJlY2F1c2UKd2UgbWF5IGhhdmUgdG8gZG8gdmJsYW5rIHdh aXRzIGV0Yy4gYW5kIHRoZSBvdGhlciBwaXBlIG1pZ2h0Cm5vdCBldmVuIGJlIGVuYWJsZWQgaGVy ZS4gU28gbGV0J3MgcGFzcyB0aGUgcGxhbmUncyBjdXJyZW50IGNydGMgdG8KaW50ZWxfcGxhbmVf ZGlzYWJsZV9ub2F0b21pYygpIHNvIHRoYXQgaXQgY2FuIGl0cyBqb2IgY29ycmVjdGx5LgoKVG8g ZG8gdGhhdCBzZW1pLWNsZWFubHkgd2UgYWxzbyBoYXZlIHRvIGNoYW5nZSB0aGUgcGxhbmUgcmVh ZG91dAp0byByZWNvcmQgdGhlIHBsYW5lJ3MgdmlzaWJpbGl0eSBpbnRvIHRoZSBiaXRtYXNrcyBv ZiB0aGUgY3J0Ywp3aGVyZSB0aGUgcGxhbmUgaXMgY3VycmVudGx5IGVuYWJsZWQgcmF0aGVyIHRo YW4gdG8gdGhlIGNydGMKd2Ugd2FudCB0byB1c2UgZm9yIHRoZSBwbGFuZS4KCk9uZSBjYXZlYXQg aGVyZSBpcyB0aGF0IG91ciBhY3RpdmVfcGxhbmVzIGJpdG1hc2sgd2lsbCBnZXQgY29uZnVzZWQK aWYgYm90aCBwbGFuZXMgYXJlIGVuYWJsZWQgb24gdGhlIHNhbWUgcGlwZS4gRm9ydHVuYXRlbHkg d2UgY2FuIHVzZQpwbGFuZV9tYXNrIHRvIHJlY29uc3RydWN0IGFjdGl2ZV9wbGFuZXMgc3VmZmlj aWVudGx5IHNpbmNlCnBsYW5lX21hc2sgc3RpbGwgaGFzIHRoZSBzYW1lIG1lYW5pbmcgKGlzIHRo ZSBwbGFuZSB2aXNpYmxlPykKZHVyaW5nIHJlYWRvdXQuIFdlIGFsc28gaGF2ZSB0byBkbyB0aGUg c2FtZSBkdXJpbmcgdGhlIGluaXRpYWwKcGxhbmUgcmVhZG91dCBhcyB0aGUgc2Vjb25kIHBsYW5l IGNvdWxkIGNsZWFyIHRoZSBhY3RpdmVfcGxhbmVzCmJpdCB0aGUgZmlyc3QgcGxhbmUgaGFkIGFs cmVhZHkgc2V0LgoKdjI6IFJlbHkgb24gZml4dXBfYWN0aXZlX3BsYW5lcygpIHRvIHBvcHVsYXRl IGFjdGl2ZV9wbGFuZXMgZnVsbHkgKERhbmllbCkKICAgIEFkZCBEYW5pZWwncyBwcm9wb3NlZCBj b21tZW50IHRvIGJldHRlciBkb2N1bWVudCB3aHkgd2UgZG8gdGhpcwogICAgRHJvcCB0aGUgcmVk dW5kYW50IGludGVsX3NldF9wbGFuZV92aXNpYmxlKCkgY2FsbAoKQ2M6IHN0YWJsZUB2Z2VyLmtl cm5lbC5vcmcgIyBmY2JhODYyZTg0MjggZHJtL2k5MTU6IEhhdmUgcGxhbmUtPmdldF9od19zdGF0 ZSgpIHJldHVybiB0aGUgY3VycmVudCBwaXBlCkNjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCkNj OiBEZW5uaXMgPGRlbm5pcy5uZXppY0B1dG9yb250by5jYT4KQ2M6IERhbmllbCBWZXR0ZXIgPGRh bmllbEBmZndsbC5jaD4KVGVzdGVkLWJ5OiBEZW5uaXMgPGRlbm5pcy5uZXppY0B1dG9yb250by5j YT4KQnVnemlsbGE6IGh0dHBzOi8vYnVncy5mcmVlZGVza3RvcC5vcmcvc2hvd19idWcuY2dpP2lk PTEwNTYzNwpGaXhlczogYjFlMDE1OTVhNjZkICgiZHJtL2k5MTU6IFJlZG8gcGxhbmUgc2FuaXRh dGlvbiBkdXJpbmcgcmVhZG91dCIpClNpZ25lZC1vZmYtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmls bGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZGlzcGxheS5jIHwgNzggKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tCiAx IGZpbGUgY2hhbmdlZCwgNDYgaW5zZXJ0aW9ucygrKSwgMzIgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCmluZGV4IGQyODI4MTU5ZjZjOC4uZjBkMDA0NjQxYjBk IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCkBAIC0yNzY0LDIwICsyNzY0LDMz IEBAIGludGVsX3NldF9wbGFuZV92aXNpYmxlKHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRj X3N0YXRlLAogCiAJcGxhbmVfc3RhdGUtPmJhc2UudmlzaWJsZSA9IHZpc2libGU7CiAKLQkvKiBG SVhNRSBwcmUtZzR4IGRvbid0IHdvcmsgbGlrZSB0aGlzICovCi0JaWYgKHZpc2libGUpIHsKKwlp ZiAodmlzaWJsZSkKIAkJY3J0Y19zdGF0ZS0+YmFzZS5wbGFuZV9tYXNrIHw9IGRybV9wbGFuZV9t YXNrKCZwbGFuZS0+YmFzZSk7Ci0JCWNydGNfc3RhdGUtPmFjdGl2ZV9wbGFuZXMgfD0gQklUKHBs YW5lLT5pZCk7Ci0JfSBlbHNlIHsKKwllbHNlCiAJCWNydGNfc3RhdGUtPmJhc2UucGxhbmVfbWFz ayAmPSB+ZHJtX3BsYW5lX21hc2soJnBsYW5lLT5iYXNlKTsKLQkJY3J0Y19zdGF0ZS0+YWN0aXZl X3BsYW5lcyAmPSB+QklUKHBsYW5lLT5pZCk7Ci0JfQogCiAJRFJNX0RFQlVHX0tNUygiJXMgYWN0 aXZlIHBsYW5lcyAweCV4XG4iLAogCQkgICAgICBjcnRjX3N0YXRlLT5iYXNlLmNydGMtPm5hbWUs CiAJCSAgICAgIGNydGNfc3RhdGUtPmFjdGl2ZV9wbGFuZXMpOwogfQogCitzdGF0aWMgdm9pZCBm aXh1cF9hY3RpdmVfcGxhbmVzKHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlKQor eworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoY3J0Y19zdGF0 ZS0+YmFzZS5jcnRjLT5kZXYpOworCXN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lOworCisJLyoKKwkg KiBBY3RpdmVfcGxhbmVzIGFsaWFzZXMgaWYgbXVsdGlwbGUgInByaW1hcnkiIG9yIGN1cnNvciBw bGFuZXMKKwkgKiBoYXZlIGJlZW4gdXNlZCBvbiB0aGUgc2FtZSAob3Igd3JvbmcpIHBpcGUuIHBs YW5lX21hc2sgdXNlcworCSAqIHVuaXF1ZSBpZHMsIGhlbmNlIHdlIGNhbiB1c2UgdGhhdCB0byBy ZWNvbnN0cnVjdCBhY3RpdmVfcGxhbmVzLgorCSAqLworCWNydGNfc3RhdGUtPmFjdGl2ZV9wbGFu ZXMgPSAwOworCisJZHJtX2Zvcl9lYWNoX3BsYW5lX21hc2socGxhbmUsICZkZXZfcHJpdi0+ZHJt LAorCQkJCWNydGNfc3RhdGUtPmJhc2UucGxhbmVfbWFzaykKKwkJY3J0Y19zdGF0ZS0+YWN0aXZl X3BsYW5lcyB8PSBCSVQodG9faW50ZWxfcGxhbmUocGxhbmUpLT5pZCk7Cit9CisKIHN0YXRpYyB2 b2lkIGludGVsX3BsYW5lX2Rpc2FibGVfbm9hdG9taWMoc3RydWN0IGludGVsX2NydGMgKmNydGMs CiAJCQkJCSBzdHJ1Y3QgaW50ZWxfcGxhbmUgKnBsYW5lKQogewpAQCAtMjc4Nyw2ICsyODAwLDcg QEAgc3RhdGljIHZvaWQgaW50ZWxfcGxhbmVfZGlzYWJsZV9ub2F0b21pYyhzdHJ1Y3QgaW50ZWxf Y3J0YyAqY3J0YywKIAkJdG9faW50ZWxfcGxhbmVfc3RhdGUocGxhbmUtPmJhc2Uuc3RhdGUpOwog CiAJaW50ZWxfc2V0X3BsYW5lX3Zpc2libGUoY3J0Y19zdGF0ZSwgcGxhbmVfc3RhdGUsIGZhbHNl KTsKKwlmaXh1cF9hY3RpdmVfcGxhbmVzKGNydGNfc3RhdGUpOwogCiAJaWYgKHBsYW5lLT5pZCA9 PSBQTEFORV9QUklNQVJZKQogCQlpbnRlbF9wcmVfZGlzYWJsZV9wcmltYXJ5X25vYXRvbWljKCZj cnRjLT5iYXNlKTsKQEAgLTI4MDUsNyArMjgxOSw2IEBAIGludGVsX2ZpbmRfaW5pdGlhbF9wbGFu ZV9vYmooc3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGMsCiAJc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iajsKIAlzdHJ1Y3QgZHJtX3BsYW5lICpwcmltYXJ5ID0gaW50ZWxfY3J0Yy0+ YmFzZS5wcmltYXJ5OwogCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRlID0gcHJp bWFyeS0+c3RhdGU7Ci0Jc3RydWN0IGRybV9jcnRjX3N0YXRlICpjcnRjX3N0YXRlID0gaW50ZWxf Y3J0Yy0+YmFzZS5zdGF0ZTsKIAlzdHJ1Y3QgaW50ZWxfcGxhbmUgKmludGVsX3BsYW5lID0gdG9f aW50ZWxfcGxhbmUocHJpbWFyeSk7CiAJc3RydWN0IGludGVsX3BsYW5lX3N0YXRlICppbnRlbF9z dGF0ZSA9CiAJCXRvX2ludGVsX3BsYW5lX3N0YXRlKHBsYW5lX3N0YXRlKTsKQEAgLTI5MDAsMTAg KzI5MTMsNiBAQCBpbnRlbF9maW5kX2luaXRpYWxfcGxhbmVfb2JqKHN0cnVjdCBpbnRlbF9jcnRj ICppbnRlbF9jcnRjLAogCXBsYW5lX3N0YXRlLT5mYiA9IGZiOwogCXBsYW5lX3N0YXRlLT5jcnRj ID0gJmludGVsX2NydGMtPmJhc2U7CiAKLQlpbnRlbF9zZXRfcGxhbmVfdmlzaWJsZSh0b19pbnRl bF9jcnRjX3N0YXRlKGNydGNfc3RhdGUpLAotCQkJCXRvX2ludGVsX3BsYW5lX3N0YXRlKHBsYW5l X3N0YXRlKSwKLQkJCQl0cnVlKTsKLQogCWF0b21pY19vcih0b19pbnRlbF9wbGFuZShwcmltYXJ5 KS0+ZnJvbnRidWZmZXJfYml0LAogCQkgICZvYmotPmZyb250YnVmZmVyX2JpdHMpOwogfQpAQCAt MTU0OTQsMTcgKzE1NTAzLDYgQEAgdm9pZCBpODMwX2Rpc2FibGVfcGlwZShzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIGVudW0gcGlwZSBwaXBlKQogCVBPU1RJTkdfUkVBRChEUExM KHBpcGUpKTsKIH0KIAotc3RhdGljIGJvb2wgaW50ZWxfcGxhbmVfbWFwcGluZ19vayhzdHJ1Y3Qg aW50ZWxfY3J0YyAqY3J0YywKLQkJCQkgICBzdHJ1Y3QgaW50ZWxfcGxhbmUgKnBsYW5lKQotewot CWVudW0gcGlwZSBwaXBlOwotCi0JaWYgKCFwbGFuZS0+Z2V0X2h3X3N0YXRlKHBsYW5lLCAmcGlw ZSkpCi0JCXJldHVybiB0cnVlOwotCi0JcmV0dXJuIHBpcGUgPT0gY3J0Yy0+cGlwZTsKLX0KLQog c3RhdGljIHZvaWQKIGludGVsX3Nhbml0aXplX3BsYW5lX21hcHBpbmcoc3RydWN0IGRybV9pOTE1 X3ByaXZhdGUgKmRldl9wcml2KQogewpAQCAtMTU1MTYsMTMgKzE1NTE0LDIwIEBAIGludGVsX3Nh bml0aXplX3BsYW5lX21hcHBpbmcoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQog CWZvcl9lYWNoX2ludGVsX2NydGMoJmRldl9wcml2LT5kcm0sIGNydGMpIHsKIAkJc3RydWN0IGlu dGVsX3BsYW5lICpwbGFuZSA9CiAJCQl0b19pbnRlbF9wbGFuZShjcnRjLT5iYXNlLnByaW1hcnkp OworCQlzdHJ1Y3QgaW50ZWxfY3J0YyAqcGxhbmVfY3J0YzsKKwkJZW51bSBwaXBlIHBpcGU7CiAK LQkJaWYgKGludGVsX3BsYW5lX21hcHBpbmdfb2soY3J0YywgcGxhbmUpKQorCQlpZiAoIXBsYW5l LT5nZXRfaHdfc3RhdGUocGxhbmUsICZwaXBlKSkKKwkJCWNvbnRpbnVlOworCisJCWlmIChwaXBl ID09IGNydGMtPnBpcGUpCiAJCQljb250aW51ZTsKIAogCQlEUk1fREVCVUdfS01TKCIlcyBhdHRh Y2hlZCB0byB0aGUgd3JvbmcgcGlwZSwgZGlzYWJsaW5nIHBsYW5lXG4iLAogCQkJICAgICAgcGxh bmUtPmJhc2UubmFtZSk7Ci0JCWludGVsX3BsYW5lX2Rpc2FibGVfbm9hdG9taWMoY3J0YywgcGxh bmUpOworCisJCXBsYW5lX2NydGMgPSBpbnRlbF9nZXRfY3J0Y19mb3JfcGlwZShkZXZfcHJpdiwg cGlwZSk7CisJCWludGVsX3BsYW5lX2Rpc2FibGVfbm9hdG9taWMocGxhbmVfY3J0YywgcGxhbmUp OwogCX0KIH0KIApAQCAtMTU2OTAsMjMgKzE1Njk1LDMyIEBAIHZvaWQgaTkxNV9yZWRpc2FibGVf dmdhKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKIH0KIAogLyogRklYTUUgcmVh ZCBvdXQgZnVsbCBwbGFuZSBzdGF0ZSBmb3IgYWxsIHBsYW5lcyAqLwotc3RhdGljIHZvaWQgcmVh ZG91dF9wbGFuZV9zdGF0ZShzdHJ1Y3QgaW50ZWxfY3J0YyAqY3J0YykKK3N0YXRpYyB2b2lkIHJl YWRvdXRfcGxhbmVfc3RhdGUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogewot CXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoY3J0Yy0+YmFzZS5k ZXYpOwotCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlID0KLQkJdG9faW50ZWxf Y3J0Y19zdGF0ZShjcnRjLT5iYXNlLnN0YXRlKTsKIAlzdHJ1Y3QgaW50ZWxfcGxhbmUgKnBsYW5l OworCXN0cnVjdCBpbnRlbF9jcnRjICpjcnRjOwogCi0JZm9yX2VhY2hfaW50ZWxfcGxhbmVfb25f Y3J0YygmZGV2X3ByaXYtPmRybSwgY3J0YywgcGxhbmUpIHsKKwlmb3JfZWFjaF9pbnRlbF9wbGFu ZSgmZGV2X3ByaXYtPmRybSwgcGxhbmUpIHsKIAkJc3RydWN0IGludGVsX3BsYW5lX3N0YXRlICpw bGFuZV9zdGF0ZSA9CiAJCQl0b19pbnRlbF9wbGFuZV9zdGF0ZShwbGFuZS0+YmFzZS5zdGF0ZSk7 Ci0JCWVudW0gcGlwZSBwaXBlOworCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3J0Y19zdGF0 ZTsKKwkJZW51bSBwaXBlIHBpcGUgPSBQSVBFX0E7CiAJCWJvb2wgdmlzaWJsZTsKIAogCQl2aXNp YmxlID0gcGxhbmUtPmdldF9od19zdGF0ZShwbGFuZSwgJnBpcGUpOwogCisJCWNydGMgPSBpbnRl bF9nZXRfY3J0Y19mb3JfcGlwZShkZXZfcHJpdiwgcGlwZSk7CisJCWNydGNfc3RhdGUgPSB0b19p bnRlbF9jcnRjX3N0YXRlKGNydGMtPmJhc2Uuc3RhdGUpOworCiAJCWludGVsX3NldF9wbGFuZV92 aXNpYmxlKGNydGNfc3RhdGUsIHBsYW5lX3N0YXRlLCB2aXNpYmxlKTsKIAl9CisKKwlmb3JfZWFj aF9pbnRlbF9jcnRjKCZkZXZfcHJpdi0+ZHJtLCBjcnRjKSB7CisJCXN0cnVjdCBpbnRlbF9jcnRj X3N0YXRlICpjcnRjX3N0YXRlID0KKwkJCXRvX2ludGVsX2NydGNfc3RhdGUoY3J0Yy0+YmFzZS5z dGF0ZSk7CisKKwkJZml4dXBfYWN0aXZlX3BsYW5lcyhjcnRjX3N0YXRlKTsKKwl9CiB9CiAKIHN0 YXRpYyB2b2lkIGludGVsX21vZGVzZXRfcmVhZG91dF9od19zdGF0ZShzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2KQpAQCAtMTU3MzgsMTMgKzE1NzUyLDEzIEBAIHN0YXRpYyB2b2lkIGludGVsX21vZGVz ZXRfcmVhZG91dF9od19zdGF0ZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCQlpZiAoY3J0Y19z dGF0ZS0+YmFzZS5hY3RpdmUpCiAJCQlkZXZfcHJpdi0+YWN0aXZlX2NydGNzIHw9IDEgPDwgY3J0 Yy0+cGlwZTsKIAotCQlyZWFkb3V0X3BsYW5lX3N0YXRlKGNydGMpOwotCiAJCURSTV9ERUJVR19L TVMoIltDUlRDOiVkOiVzXSBodyBzdGF0ZSByZWFkb3V0OiAlc1xuIiwKIAkJCSAgICAgIGNydGMt PmJhc2UuYmFzZS5pZCwgY3J0Yy0+YmFzZS5uYW1lLAogCQkJICAgICAgZW5hYmxlZGRpc2FibGVk KGNydGNfc3RhdGUtPmJhc2UuYWN0aXZlKSk7CiAJfQogCisJcmVhZG91dF9wbGFuZV9zdGF0ZShk ZXZfcHJpdik7CisKIAlmb3IgKGkgPSAwOyBpIDwgZGV2X3ByaXYtPm51bV9zaGFyZWRfZHBsbDsg aSsrKSB7CiAJCXN0cnVjdCBpbnRlbF9zaGFyZWRfZHBsbCAqcGxsID0gJmRldl9wcml2LT5zaGFy ZWRfZHBsbHNbaV07CiAKLS0gCjIuMTYuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga06.intel.com ([134.134.136.31]:10113 "EHLO mga06.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726748AbeJCVjM (ORCPT ); Wed, 3 Oct 2018 17:39:12 -0400 From: Ville Syrjala To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, stable@vger.kernel.org, Dennis , Daniel Vetter Subject: [PATCH v2 2/3] drm/i915: Use the correct crtc when sanitizing plane mapping Date: Wed, 3 Oct 2018 17:50:17 +0300 Message-Id: <20181003145017.4527-1-ville.syrjala@linux.intel.com> In-Reply-To: <20181001143120.5777-1-ville.syrjala@linux.intel.com> References: <20181001143120.5777-1-ville.syrjala@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: stable-owner@vger.kernel.org List-ID: 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. v2: Rely on fixup_active_planes() to populate active_planes fully (Daniel) Add Daniel's proposed comment to better document why we do this Drop the redundant intel_set_plane_visible() call Cc: stable@vger.kernel.org # fcba862e8428 drm/i915: Have plane->get_hw_state() return the current pipe Cc: stable@vger.kernel.org Cc: Dennis Cc: Daniel Vetter 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 | 78 +++++++++++++++++++++--------------- 1 file changed, 46 insertions(+), 32 deletions(-) diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index d2828159f6c8..f0d004641b0d 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -2764,20 +2764,33 @@ intel_set_plane_visible(struct intel_crtc_state *crtc_state, plane_state->base.visible = visible; - /* FIXME pre-g4x don't work like this */ - if (visible) { + if (visible) crtc_state->base.plane_mask |= drm_plane_mask(&plane->base); - crtc_state->active_planes |= BIT(plane->id); - } else { + else crtc_state->base.plane_mask &= ~drm_plane_mask(&plane->base); - crtc_state->active_planes &= ~BIT(plane->id); - } DRM_DEBUG_KMS("%s active planes 0x%x\n", crtc_state->base.crtc->name, crtc_state->active_planes); } +static void fixup_active_planes(struct intel_crtc_state *crtc_state) +{ + struct drm_i915_private *dev_priv = to_i915(crtc_state->base.crtc->dev); + struct drm_plane *plane; + + /* + * Active_planes aliases if multiple "primary" or cursor planes + * have been used on the same (or wrong) pipe. plane_mask uses + * unique ids, hence we can use that to reconstruct active_planes. + */ + crtc_state->active_planes = 0; + + drm_for_each_plane_mask(plane, &dev_priv->drm, + crtc_state->base.plane_mask) + crtc_state->active_planes |= BIT(to_intel_plane(plane)->id); +} + static void intel_plane_disable_noatomic(struct intel_crtc *crtc, struct intel_plane *plane) { @@ -2787,6 +2800,7 @@ static void intel_plane_disable_noatomic(struct intel_crtc *crtc, to_intel_plane_state(plane->base.state); intel_set_plane_visible(crtc_state, plane_state, false); + fixup_active_planes(crtc_state); if (plane->id == PLANE_PRIMARY) intel_pre_disable_primary_noatomic(&crtc->base); @@ -2805,7 +2819,6 @@ intel_find_initial_plane_obj(struct intel_crtc *intel_crtc, struct drm_i915_gem_object *obj; struct drm_plane *primary = intel_crtc->base.primary; struct drm_plane_state *plane_state = primary->state; - struct drm_crtc_state *crtc_state = intel_crtc->base.state; struct intel_plane *intel_plane = to_intel_plane(primary); struct intel_plane_state *intel_state = to_intel_plane_state(plane_state); @@ -2900,10 +2913,6 @@ intel_find_initial_plane_obj(struct intel_crtc *intel_crtc, plane_state->fb = fb; plane_state->crtc = &intel_crtc->base; - intel_set_plane_visible(to_intel_crtc_state(crtc_state), - to_intel_plane_state(plane_state), - true); - atomic_or(to_intel_plane(primary)->frontbuffer_bit, &obj->frontbuffer_bits); } @@ -15494,17 +15503,6 @@ 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) -{ - enum pipe pipe; - - if (!plane->get_hw_state(plane, &pipe)) - return true; - - return pipe == crtc->pipe; -} - static void intel_sanitize_plane_mapping(struct drm_i915_private *dev_priv) { @@ -15516,13 +15514,20 @@ 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 (intel_plane_mapping_ok(crtc, plane)) + if (!plane->get_hw_state(plane, &pipe)) + continue; + + 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); } } @@ -15690,23 +15695,32 @@ 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); - enum pipe pipe; + struct intel_crtc_state *crtc_state; + enum pipe pipe = PIPE_A; 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) { + struct intel_crtc_state *crtc_state = + to_intel_crtc_state(crtc->base.state); + + fixup_active_planes(crtc_state); + } } static void intel_modeset_readout_hw_state(struct drm_device *dev) @@ -15738,13 +15752,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