From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paulo Zanoni Subject: Re: [PATCH 5/6] drm/i915/gen9: Get rid of redundant watermark values Date: Wed, 05 Oct 2016 18:44:04 -0300 Message-ID: <1475703844.2381.74.camel@intel.com> References: <1475681598-12081-1-git-send-email-cpaul@redhat.com> <1475681598-12081-6-git-send-email-cpaul@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1475681598-12081-6-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Lyude , intel-gfx@lists.freedesktop.org Cc: David Airlie , Daniel Vetter , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org RW0gUXVhLCAyMDE2LTEwLTA1IMOgcyAxMTozMyAtMDQwMCwgTHl1ZGUgZXNjcmV2ZXU6Cj4gTm93 IHRoYXQgd2UndmUgbWFrZSBza2xfd21fbGV2ZWxzIG1ha2UgYSBsaXR0bGUgbW9yZSBzZW5zZSwg d2UgY2FuCj4gcmVtb3ZlIGFsbCBvZiB0aGUgcmVkdW5kYW50IHdtIGluZm9ybWF0aW9uLiBVcCB1 bnRpbCBub3cgd2UnZCBiZWVuCj4gc3RvcmluZyB0d28gY29waWVzIG9mIGFsbCBvZiB0aGUgc2ts IHdhdGVybWFya3M6IG9uZSBiZWluZyB0aGUKPiBza2xfcGlwZV93bSBzdHJ1Y3RzLCB0aGUgb3Ro ZXIgYmVpbmcgdGhlIGdsb2JhbCB3bSBzdHJ1Y3QgaW4KPiBkcm1faTkxNV9wcml2YXRlIGNvbnRh aW5pbmcgdGhlIHJhdyByZWdpc3RlciB2YWx1ZXMuIFRoaXMgaXMKPiBjb25mdXNpbmcKPiBhbmQg cHJvYmxlbWF0aWMsIHNpbmNlIGl0IG1lYW5zIHdlJ3JlIHByb25lIHRvIGFjY2lkZW50YWxseSBs ZXR0aW5nCj4gdGhlCj4gdHdvIGNvcGllcyBnbyBvdXQgb2Ygc3luYy4gU28sIGdldCByaWQgb2Yg YWxsIG9mIHRoZSBmdW5jdGlvbnMKPiByZXNwb25zaWJsZSBmb3IgY29tcHV0aW5nIHRoZSByZWdp c3RlciB2YWx1ZXMgYW5kIGp1c3QgdXNlIGEgc2luZ2xlCj4gaGVscGVyLCBza2xfd3JpdGVfd21f bGV2ZWwoKSwgdG8gY29udmVydCBhbmQgd3JpdGUgdGhlIG5ldyB3YXRlcm1hcmtzCj4gb24KPiB0 aGUgZmx5LgoKSSBsaWtlIHRoZSBkaXJlY3Rpb24gb2YgdGhpcyBwYXRjaCB0b28sIGJ1dCB0aGVy ZSBhcmUgc29tZSBzbWFsbApwb3NzaWJsZSBwcm9ibGVtcy4gU2VlIGJlbG93LgoKCj4gCj4gU2ln bmVkLW9mZi1ieTogTHl1ZGUgPGNwYXVsQHJlZGhhdC5jb20+Cj4gQ2M6IE1hYXJ0ZW4gTGFua2hv cnN0IDxtYWFydGVuLmxhbmtob3JzdEBsaW51eC5pbnRlbC5jb20+Cj4gQ2M6IFZpbGxlIFN5cmrD pGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+Cj4gQ2M6IE1hdHQgUm9wZXIgPG1h dHRoZXcuZC5yb3BlckBpbnRlbC5jb20+Cj4gLS0tCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2Rydi5owqDCoMKgwqDCoMKgfMKgwqDCoDIgLQo+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZGlzcGxheS5jIHzCoMKgMTQgKystCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9kcnYuaMKgwqDCoMKgwqB8wqDCoMKgNiArLQo+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfcG0uY8KgwqDCoMKgwqDCoHwgMjAzICsrKysrKysrKysrKy0tLS0tLS0tLS0tLS0KPiAtLS0t LS0tLS0tCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zcHJpdGUuY8KgwqB8wqDCoMKg OCArLQo+IMKgNSBmaWxlcyBjaGFuZ2VkLCA4OCBpbnNlcnRpb25zKCspLCAxNDUgZGVsZXRpb25z KC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiBpbmRleCAwZjk3ZDQzLi42MzUxOWFj IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCj4gQEAgLTE2NDMsOCArMTY0Myw2IEBAIHN0 cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gewo+IMKgc3RydWN0IHNrbF93bV92YWx1ZXMgewo+IMKg CXVuc2lnbmVkIGRpcnR5X3BpcGVzOwo+IMKgCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gZGRi Owo+IC0JdWludDMyX3QgcGxhbmVbSTkxNV9NQVhfUElQRVNdW0k5MTVfTUFYX1BMQU5FU11bOF07 Cj4gLQl1aW50MzJfdCBwbGFuZV90cmFuc1tJOTE1X01BWF9QSVBFU11bSTkxNV9NQVhfUExBTkVT XTsKPiDCoH07Cj4gwqAKPiDCoHN0cnVjdCBza2xfd21fbGV2ZWwgewo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2Rpc3BsYXkuYwo+IGluZGV4IGRkMTVhZTIuLmM1ODBkM2QgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4gKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4gQEAgLTMzNzgsNiArMzM3OCw4IEBAIHN0YXRp YyB2b2lkIHNreWxha2VfdXBkYXRlX3ByaW1hcnlfcGxhbmUoc3RydWN0Cj4gZHJtX3BsYW5lICpw bGFuZSwKPiDCoAlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YyA9IHRvX2ludGVsX2NydGMo Y3J0Y19zdGF0ZS0KPiA+YmFzZS5jcnRjKTsKPiDCoAlzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpm YiA9IHBsYW5lX3N0YXRlLT5iYXNlLmZiOwo+IMKgCWNvbnN0IHN0cnVjdCBza2xfd21fdmFsdWVz ICp3bSA9ICZkZXZfcHJpdi0+d20uc2tsX3Jlc3VsdHM7Cj4gKwljb25zdCBzdHJ1Y3Qgc2tsX3Bs YW5lX3dtICpwX3dtID0KPiArCQkmY3J0Y19zdGF0ZS0+d20uc2tsLm9wdGltYWwucGxhbmVzWzBd OwoKSSB3aXNoIHNvbWVvbmUgd291bGQgZG8gYSBwYXRjaCB0byBjb252ZXJ0IGFsbCB0aGVzZSBo YXJkY29kZWQgdmFsdWVzCnRvIFBMQU5FX1gsIGFuZCBjb252ZXJ0ICJpbnQicyDCoHRvICJlbnVt IHBsYW5lInMgZXZlcnl3aGVyZS4KCgo+IMKgCWludCBwaXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsK PiDCoAl1MzIgcGxhbmVfY3RsOwo+IMKgCXVuc2lnbmVkIGludCByb3RhdGlvbiA9IHBsYW5lX3N0 YXRlLT5iYXNlLnJvdGF0aW9uOwo+IEBAIC0zNDE0LDcgKzM0MTYsNyBAQCBzdGF0aWMgdm9pZCBz a3lsYWtlX3VwZGF0ZV9wcmltYXJ5X3BsYW5lKHN0cnVjdAo+IGRybV9wbGFuZSAqcGxhbmUsCj4g wqAJaW50ZWxfY3J0Yy0+YWRqdXN0ZWRfeSA9IHNyY195Owo+IMKgCj4gwqAJaWYgKHdtLT5kaXJ0 eV9waXBlcyAmIGRybV9jcnRjX21hc2soJmludGVsX2NydGMtPmJhc2UpKQo+IC0JCXNrbF93cml0 ZV9wbGFuZV93bShpbnRlbF9jcnRjLCB3bSwgMCk7Cj4gKwkJc2tsX3dyaXRlX3BsYW5lX3dtKGlu dGVsX2NydGMsIHBfd20sICZ3bS0+ZGRiLCAwKTsKPiDCoAo+IMKgCUk5MTVfV1JJVEUoUExBTkVf Q1RMKHBpcGUsIDApLCBwbGFuZV9jdGwpOwo+IMKgCUk5MTVfV1JJVEUoUExBTkVfT0ZGU0VUKHBp cGUsIDApLCAoc3JjX3kgPDwgMTYpIHwgc3JjX3gpOwo+IEBAIC0zNDQ4LDYgKzM0NTAsOCBAQCBz dGF0aWMgdm9pZAo+IHNreWxha2VfZGlzYWJsZV9wcmltYXJ5X3BsYW5lKHN0cnVjdCBkcm1fcGxh bmUgKnByaW1hcnksCj4gwqAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNydGMtPmRldjsKPiDC oAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGRldik7Cj4gwqAJ c3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGMgPSB0b19pbnRlbF9jcnRjKGNydGMpOwo+ICsJ c3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZSA9IHRvX2ludGVsX2NydGNfc3RhdGUoY3J0 Yy0KPiA+c3RhdGUpOwo+ICsJY29uc3Qgc3RydWN0IHNrbF9wbGFuZV93bSAqcF93bSA9ICZjc3Rh dGUtCj4gPndtLnNrbC5vcHRpbWFsLnBsYW5lc1swXTsKPiDCoAlpbnQgcGlwZSA9IGludGVsX2Ny dGMtPnBpcGU7Cj4gwqAKPiDCoAkvKgo+IEBAIC0zNDU1LDcgKzM0NTksOCBAQCBzdGF0aWMgdm9p ZAo+IHNreWxha2VfZGlzYWJsZV9wcmltYXJ5X3BsYW5lKHN0cnVjdCBkcm1fcGxhbmUgKnByaW1h cnksCj4gwqAJwqAqIHBsYW5lJ3MgdmlzaWJsaXR5IGlzbid0IGFjdHVhbGx5IGNoYW5naW5nIG5l aXRoZXIgaXMgaXRzCj4gd2F0ZXJtYXJrcy4KPiDCoAnCoCovCj4gwqAJaWYgKCFjcnRjLT5wcmlt YXJ5LT5zdGF0ZS0+dmlzaWJsZSkKPiAtCQlza2xfd3JpdGVfcGxhbmVfd20oaW50ZWxfY3J0Yywg JmRldl9wcml2LQo+ID53bS5za2xfcmVzdWx0cywgMCk7Cj4gKwkJc2tsX3dyaXRlX3BsYW5lX3dt KGludGVsX2NydGMsIHBfd20sCj4gKwkJCQnCoMKgwqAmZGV2X3ByaXYtPndtLnNrbF9yZXN1bHRz LmRkYiwKPiAwKTsKPiDCoAo+IMKgCUk5MTVfV1JJVEUoUExBTkVfQ1RMKHBpcGUsIDApLCAwKTsK PiDCoAlJOTE1X1dSSVRFKFBMQU5FX1NVUkYocGlwZSwgMCksIDApOwo+IEBAIC0xMDgxOSwxMiAr MTA4MjQsMTUgQEAgc3RhdGljIHZvaWQgaTl4eF91cGRhdGVfY3Vyc29yKHN0cnVjdAo+IGRybV9j cnRjICpjcnRjLCB1MzIgYmFzZSwKPiDCoAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ ZGV2Owo+IMKgCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZGV2 KTsKPiDCoAlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YyA9IHRvX2ludGVsX2NydGMoY3J0 Yyk7Cj4gKwlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3N0YXRlID0gdG9faW50ZWxfY3J0Y19z dGF0ZShjcnRjLQo+ID5zdGF0ZSk7Cj4gwqAJY29uc3Qgc3RydWN0IHNrbF93bV92YWx1ZXMgKndt ID0gJmRldl9wcml2LT53bS5za2xfcmVzdWx0czsKPiArCWNvbnN0IHN0cnVjdCBza2xfcGxhbmVf d20gKnBfd20gPQo+ICsJCSZjc3RhdGUtPndtLnNrbC5vcHRpbWFsLnBsYW5lc1tQTEFORV9DVVJT T1JdOwo+IMKgCWludCBwaXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsKPiDCoAl1aW50MzJfdCBjbnRs ID0gMDsKPiDCoAo+IMKgCWlmIChJTlRFTF9HRU4oZGV2X3ByaXYpID49IDkgJiYgd20tPmRpcnR5 X3BpcGVzICYKPiBkcm1fY3J0Y19tYXNrKGNydGMpKQo+IC0JCXNrbF93cml0ZV9jdXJzb3Jfd20o aW50ZWxfY3J0Yywgd20pOwo+ICsJCXNrbF93cml0ZV9jdXJzb3Jfd20oaW50ZWxfY3J0YywgcF93 bSwgJndtLT5kZGIpOwo+IMKgCj4gwqAJaWYgKHBsYW5lX3N0YXRlICYmIHBsYW5lX3N0YXRlLT5i YXNlLnZpc2libGUpIHsKPiDCoAkJY250bCA9IE1DVVJTT1JfR0FNTUFfRU5BQkxFOwo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiBpbmRleCBkNjg0ZjRmLi45NThkYzcyIDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiBAQCAtMTc2NSw5ICsxNzY1LDExIEBAIGJvb2wgc2tsX2Rk Yl9hbGxvY2F0aW9uX2VxdWFscyhjb25zdCBzdHJ1Y3QKPiBza2xfZGRiX2FsbG9jYXRpb24gKm9s ZCwKPiDCoGJvb2wgc2tsX2RkYl9hbGxvY2F0aW9uX292ZXJsYXBzKHN0cnVjdCBkcm1fYXRvbWlj X3N0YXRlICpzdGF0ZSwKPiDCoAkJCQnCoHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjKTsK PiDCoHZvaWQgc2tsX3dyaXRlX2N1cnNvcl93bShzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0 YywKPiAtCQkJwqBjb25zdCBzdHJ1Y3Qgc2tsX3dtX3ZhbHVlcyAqd20pOwo+ICsJCQnCoGNvbnN0 IHN0cnVjdCBza2xfcGxhbmVfd20gKndtLAo+ICsJCQnCoGNvbnN0IHN0cnVjdCBza2xfZGRiX2Fs bG9jYXRpb24gKmRkYik7Cj4gwqB2b2lkIHNrbF93cml0ZV9wbGFuZV93bShzdHJ1Y3QgaW50ZWxf Y3J0YyAqaW50ZWxfY3J0YywKPiAtCQkJY29uc3Qgc3RydWN0IHNrbF93bV92YWx1ZXMgKndtLAo+ ICsJCQljb25zdCBzdHJ1Y3Qgc2tsX3BsYW5lX3dtICp3bSwKPiArCQkJY29uc3Qgc3RydWN0IHNr bF9kZGJfYWxsb2NhdGlvbiAqZGRiLAo+IMKgCQkJaW50IHBsYW5lKTsKPiDCoHVpbnQzMl90IGls a19waXBlX3BpeGVsX3JhdGUoY29uc3Qgc3RydWN0IGludGVsX2NydGNfc3RhdGUKPiAqcGlwZV9j b25maWcpOwo+IMKgYm9vbCBpbGtfZGlzYWJsZV9scF93bShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 KTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+IGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+IGluZGV4IDI1MGYxMmQuLjc3MDg2NDYgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKPiBAQCAtMzAwMCw2ICszMDAwLDggQEAgYm9vbCBp bnRlbF9jYW5fZW5hYmxlX3NhZ3Yoc3RydWN0Cj4gZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCj4g wqAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShkZXYpOwo+IMKg CXN0cnVjdCBpbnRlbF9hdG9taWNfc3RhdGUgKmludGVsX3N0YXRlID0KPiB0b19pbnRlbF9hdG9t aWNfc3RhdGUoc3RhdGUpOwo+IMKgCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKPiArCXN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlICpjc3RhdGU7Cj4gKwlzdHJ1Y3Qgc2tsX3BsYW5lX3dtICp3bTsKPiDC oAllbnVtIHBpcGUgcGlwZTsKPiDCoAlpbnQgbGV2ZWwsIHBsYW5lOwo+IMKgCj4gQEAgLTMwMjAs MTggKzMwMjIsMjEgQEAgYm9vbCBpbnRlbF9jYW5fZW5hYmxlX3NhZ3Yoc3RydWN0Cj4gZHJtX2F0 b21pY19zdGF0ZSAqc3RhdGUpCj4gwqAJLyogU2luY2Ugd2UncmUgbm93IGd1YXJhbnRlZWQgdG8g b25seSBoYXZlIG9uZSBhY3RpdmUKPiBDUlRDLi4uICovCj4gwqAJcGlwZSA9IGZmcyhpbnRlbF9z dGF0ZS0+YWN0aXZlX2NydGNzKSAtIDE7Cj4gwqAJY3J0YyA9IGRldl9wcml2LT5waXBlX3RvX2Ny dGNfbWFwcGluZ1twaXBlXTsKPiArCWNzdGF0ZSA9IGludGVsX2F0b21pY19nZXRfY3J0Y19zdGF0 ZShzdGF0ZSwKPiB0b19pbnRlbF9jcnRjKGNydGMpKTsKPiDCoAo+IMKgCWlmIChjcnRjLT5zdGF0 ZS0+bW9kZS5mbGFncyAmIERSTV9NT0RFX0ZMQUdfSU5URVJMQUNFKQo+IMKgCQlyZXR1cm4gZmFs c2U7Cj4gwqAKPiDCoAlmb3JfZWFjaF9wbGFuZShkZXZfcHJpdiwgcGlwZSwgcGxhbmUpIHsKPiAr CQl3bSA9ICZjc3RhdGUtPndtLnNrbC5vcHRpbWFsLnBsYW5lc1twbGFuZV07Cj4gKwo+IMKgCQkv KiBTa2lwIHRoaXMgcGxhbmUgaWYgaXQncyBub3QgZW5hYmxlZCAqLwo+IC0JCWlmIChpbnRlbF9z dGF0ZS0+d21fcmVzdWx0cy5wbGFuZVtwaXBlXVtwbGFuZV1bMF0gPT0KPiAwKQo+ICsJCWlmICgh d20tPndtWzBdLnBsYW5lX2VuKQo+IMKgCQkJY29udGludWU7Cj4gwqAKPiDCoAkJLyogRmluZCB0 aGUgaGlnaGVzdCBlbmFibGVkIHdtIGxldmVsIGZvciB0aGlzIHBsYW5lCj4gKi8KPiAtCQlmb3Ig KGxldmVsID0gaWxrX3dtX21heF9sZXZlbChkZXYpOwo+IC0JCcKgwqDCoMKgwqBpbnRlbF9zdGF0 ZS0KPiA+d21fcmVzdWx0cy5wbGFuZVtwaXBlXVtwbGFuZV1bbGV2ZWxdID09IDA7IC0tbGV2ZWwp Cj4gKwkJZm9yIChsZXZlbCA9IGlsa193bV9tYXhfbGV2ZWwoZGV2KTsgIXdtLQo+ID53bVtsZXZl bF0ucGxhbmVfZW47Cj4gKwkJwqDCoMKgwqDCoC0tbGV2ZWwpCj4gwqAJCcKgwqDCoMKgwqB7IH0K PiDCoAo+IMKgCQkvKgo+IEBAIC0zNzc3LDY3ICszNzgyLDYgQEAgc3RhdGljIGludCBza2xfYnVp bGRfcGlwZV93bShzdHJ1Y3QKPiBpbnRlbF9jcnRjX3N0YXRlICpjc3RhdGUsCj4gwqAJcmV0dXJu IDA7Cj4gwqB9Cj4gwqAKPiAtc3RhdGljIHZvaWQgc2tsX2NvbXB1dGVfd21fcmVzdWx0cyhzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2LAo+IC0JCQkJwqDCoMKgc3RydWN0IHNrbF9waXBlX3dtICpwX3dt LAo+IC0JCQkJwqDCoMKgc3RydWN0IHNrbF93bV92YWx1ZXMgKnIsCj4gLQkJCQnCoMKgwqBzdHJ1 Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YykKPiAtewo+IC0JaW50IGxldmVsLCBtYXhfbGV2ZWwg PSBpbGtfd21fbWF4X2xldmVsKGRldik7Cj4gLQlzdHJ1Y3Qgc2tsX3BsYW5lX3dtICpwbGFuZV93 bTsKPiAtCWVudW0gcGlwZSBwaXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsKPiAtCXVpbnQzMl90IHRl bXA7Cj4gLQlpbnQgaTsKPiAtCj4gLQlmb3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3BsYW5lcyhp bnRlbF9jcnRjKTsgaSsrKSB7Cj4gLQkJcGxhbmVfd20gPSAmcF93bS0+cGxhbmVzW2ldOwo+IC0K PiAtCQlmb3IgKGxldmVsID0gMDsgbGV2ZWwgPD0gbWF4X2xldmVsOyBsZXZlbCsrKSB7Cj4gLQkJ CXRlbXAgPSAwOwo+IC0KPiAtCQkJdGVtcCB8PSBwbGFuZV93bS0+d21bbGV2ZWxdLnBsYW5lX3Jl c19sIDw8Cj4gLQkJCQkJUExBTkVfV01fTElORVNfU0hJRlQ7Cj4gLQkJCXRlbXAgfD0gcGxhbmVf d20tPndtW2xldmVsXS5wbGFuZV9yZXNfYjsKPiAtCQkJaWYgKHBsYW5lX3dtLT53bVtsZXZlbF0u cGxhbmVfZW4pCj4gLQkJCQl0ZW1wIHw9IFBMQU5FX1dNX0VOOwo+IC0KPiAtCQkJci0+cGxhbmVb cGlwZV1baV1bbGV2ZWxdID0gdGVtcDsKPiAtCQl9Cj4gLQo+IC0JfQo+IC0KPiAtCWZvciAobGV2 ZWwgPSAwOyBsZXZlbCA8PSBtYXhfbGV2ZWw7IGxldmVsKyspIHsKPiAtCQlwbGFuZV93bSA9ICZw X3dtLT5wbGFuZXNbUExBTkVfQ1VSU09SXTsKPiAtCQl0ZW1wID0gMDsKPiAtCQl0ZW1wIHw9IHBs YW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2wgPDwKPiBQTEFORV9XTV9MSU5FU19TSElGVDsK PiAtCQl0ZW1wIHw9IHBsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2I7Cj4gLQkJaWYgKHBs YW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfZW4pCj4gLQkJCXRlbXAgfD0gUExBTkVfV01fRU47Cj4g LQo+IC0JCXItPnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl1bbGV2ZWxdID0gdGVtcDsKPiAtCX0K PiAtCj4gLQkvKiB0cmFuc2l0aW9uIFdNcyAqLwo+IC0JZm9yIChpID0gMDsgaSA8IGludGVsX251 bV9wbGFuZXMoaW50ZWxfY3J0Yyk7IGkrKykgewo+IC0JCXBsYW5lX3dtID0gJnBfd20tPnBsYW5l c1tpXTsKPiAtCQl0ZW1wID0gMDsKPiAtCQl0ZW1wIHw9IHBsYW5lX3dtLT50cmFuc193bS5wbGFu ZV9yZXNfbCA8PAo+IFBMQU5FX1dNX0xJTkVTX1NISUZUOwo+IC0JCXRlbXAgfD0gcGxhbmVfd20t PnRyYW5zX3dtLnBsYW5lX3Jlc19iOwo+IC0JCWlmIChwbGFuZV93bS0+dHJhbnNfd20ucGxhbmVf ZW4pCj4gLQkJCXRlbXAgfD0gUExBTkVfV01fRU47Cj4gLQo+IC0JCXItPnBsYW5lX3RyYW5zW3Bp cGVdW2ldID0gdGVtcDsKPiAtCX0KPiAtCj4gLQlwbGFuZV93bSA9ICZwX3dtLT5wbGFuZXNbUExB TkVfQ1VSU09SXTsKPiAtCXRlbXAgPSAwOwo+IC0JdGVtcCB8PSBwbGFuZV93bS0+dHJhbnNfd20u cGxhbmVfcmVzX2wgPDwKPiBQTEFORV9XTV9MSU5FU19TSElGVDsKPiAtCXRlbXAgfD0gcGxhbmVf d20tPnRyYW5zX3dtLnBsYW5lX3Jlc19iOwo+IC0JaWYgKHBsYW5lX3dtLT50cmFuc193bS5wbGFu ZV9lbikKPiAtCQl0ZW1wIHw9IFBMQU5FX1dNX0VOOwo+IC0KPiAtCXItPnBsYW5lX3RyYW5zW3Bp cGVdW1BMQU5FX0NVUlNPUl0gPSB0ZW1wOwo+IC19Cj4gLQo+IMKgc3RhdGljIHZvaWQgc2tsX2Rk Yl9lbnRyeV93cml0ZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCj4gwqAJCQkJ aTkxNV9yZWdfdCByZWcsCj4gwqAJCQkJY29uc3Qgc3RydWN0IHNrbF9kZGJfZW50cnkgKmVudHJ5 KQo+IEBAIC0zODQ4LDggKzM3OTIsMjIgQEAgc3RhdGljIHZvaWQgc2tsX2RkYl9lbnRyeV93cml0 ZShzdHJ1Y3QKPiBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKPiDCoAkJSTkxNV9XUklURShy ZWcsIDApOwo+IMKgfQo+IMKgCj4gK3N0YXRpYyB2b2lkIHNrbF93cml0ZV93bV9sZXZlbChzdHJ1 Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCj4gKwkJCcKgwqDCoMKgwqDCoMKgaTkxNV9y ZWdfdCByZWcsCj4gKwkJCcKgwqDCoMKgwqDCoMKgY29uc3Qgc3RydWN0IHNrbF93bV9sZXZlbCAq bGV2ZWwpCj4gK3sKPiArCXVpbnQzMl90IHZhbCA9IDA7Cj4gKwo+ICsJdmFsIHw9IGxldmVsLT5w bGFuZV9yZXNfYjsKPiArCXZhbCB8PSBsZXZlbC0+cGxhbmVfcmVzX2wgPDwgUExBTkVfV01fTElO RVNfU0hJRlQ7Cj4gKwl2YWwgfD0gbGV2ZWwtPnBsYW5lX2VuOwoKVGhlIGxpbmUgYWJvdmUgc2Vl bXMgd3JvbmcsIHlvdSBzaG91bGQgY2hlY2sgZm9yIHBsYW5lX2VuIGFuZCB0aGVuIHNldApQTEFO RV9XTV9FTi4KCklNSE8gaXQgd291bGQgZXZlbiBiZXR0ZXIgaWYgd2UgY29tcGxldGVseSB6ZXJv ZWQgdGhlIHJlZ2lzdGVyIGluIGNhc2UKcGxhbmVfZW4gaXMgZmFsc2UsIHNvIHdlIGNvdWxkIGhh dmU6Cgp1aW50MzJfdCB2YWwgPSAwOwoKaWYgKGxldmVsLT5wbGFuZV9lbikgewoJdmFsIHw9IFBM QU5FX1dNX0VOOwoJdmFsIHw9IGxldmVsLT5wbGFuZV9yZXNfYjsKCXZhbCB8PSBsZXZlbC0+cGxh bmVfcmVzX2wgPDwgUExBTkVfV01fTElORVNfU0hJRlQ7Cn0KCgo+ICsKPiArCUk5MTVfV1JJVEUo cmVnLCB2YWwpOwo+ICt9Cj4gKwo+IMKgdm9pZCBza2xfd3JpdGVfcGxhbmVfd20oc3RydWN0IGlu dGVsX2NydGMgKmludGVsX2NydGMsCj4gLQkJCWNvbnN0IHN0cnVjdCBza2xfd21fdmFsdWVzICp3 bSwKPiArCQkJY29uc3Qgc3RydWN0IHNrbF9wbGFuZV93bSAqd20sCj4gKwkJCWNvbnN0IHN0cnVj dCBza2xfZGRiX2FsbG9jYXRpb24gKmRkYiwKPiDCoAkJCWludCBwbGFuZSkKPiDCoHsKPiDCoAlz dHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmaW50ZWxfY3J0Yy0+YmFzZTsKPiBAQCAtMzg1OSwxOSAr MzgxNywyMSBAQCB2b2lkIHNrbF93cml0ZV9wbGFuZV93bShzdHJ1Y3QgaW50ZWxfY3J0Ywo+ICpp bnRlbF9jcnRjLAo+IMKgCWVudW0gcGlwZSBwaXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsKPiDCoAo+ IMKgCWZvciAobGV2ZWwgPSAwOyBsZXZlbCA8PSBtYXhfbGV2ZWw7IGxldmVsKyspIHsKPiAtCQlJ OTE1X1dSSVRFKFBMQU5FX1dNKHBpcGUsIHBsYW5lLCBsZXZlbCksCj4gLQkJCcKgwqDCoHdtLT5w bGFuZVtwaXBlXVtwbGFuZV1bbGV2ZWxdKTsKPiArCQlza2xfd3JpdGVfd21fbGV2ZWwoZGV2X3By aXYsIFBMQU5FX1dNKHBpcGUsIHBsYW5lLAo+IGxldmVsKSwKPiArCQkJCcKgwqDCoCZ3bS0+d21b bGV2ZWxdKTsKPiDCoAl9Cj4gLQlJOTE1X1dSSVRFKFBMQU5FX1dNX1RSQU5TKHBpcGUsIHBsYW5l KSwgd20tCj4gPnBsYW5lX3RyYW5zW3BpcGVdW3BsYW5lXSk7Cj4gKwlza2xfd3JpdGVfd21fbGV2 ZWwoZGV2X3ByaXYsIFBMQU5FX1dNX1RSQU5TKHBpcGUsIHBsYW5lKSwKPiArCQkJwqDCoMKgJndt LT50cmFuc193bSk7Cj4gwqAKPiDCoAlza2xfZGRiX2VudHJ5X3dyaXRlKGRldl9wcml2LCBQTEFO RV9CVUZfQ0ZHKHBpcGUsIHBsYW5lKSwKPiAtCQkJwqDCoMKgwqAmd20tPmRkYi5wbGFuZVtwaXBl XVtwbGFuZV0pOwo+ICsJCQnCoMKgwqDCoCZkZGItPnBsYW5lW3BpcGVdW3BsYW5lXSk7Cj4gwqAJ c2tsX2RkYl9lbnRyeV93cml0ZShkZXZfcHJpdiwgUExBTkVfTlYxMl9CVUZfQ0ZHKHBpcGUsCj4g cGxhbmUpLAo+IC0JCQnCoMKgwqDCoCZ3bS0+ZGRiLnlfcGxhbmVbcGlwZV1bcGxhbmVdKTsKPiAr CQkJwqDCoMKgwqAmZGRiLT55X3BsYW5lW3BpcGVdW3BsYW5lXSk7Cj4gwqB9Cj4gwqAKPiDCoHZv aWQgc2tsX3dyaXRlX2N1cnNvcl93bShzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YywKPiAt CQkJwqBjb25zdCBzdHJ1Y3Qgc2tsX3dtX3ZhbHVlcyAqd20pCj4gKwkJCcKgY29uc3Qgc3RydWN0 IHNrbF9wbGFuZV93bSAqd20sCj4gKwkJCcKgY29uc3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlv biAqZGRiKQo+IMKgewo+IMKgCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9ICZpbnRlbF9jcnRjLT5i YXNlOwo+IMKgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjcnRjLT5kZXY7Cj4gQEAgLTM4ODAs MTMgKzM4NDAsMTMgQEAgdm9pZCBza2xfd3JpdGVfY3Vyc29yX3dtKHN0cnVjdCBpbnRlbF9jcnRj Cj4gKmludGVsX2NydGMsCj4gwqAJZW51bSBwaXBlIHBpcGUgPSBpbnRlbF9jcnRjLT5waXBlOwo+ IMKgCj4gwqAJZm9yIChsZXZlbCA9IDA7IGxldmVsIDw9IG1heF9sZXZlbDsgbGV2ZWwrKykgewo+ IC0JCUk5MTVfV1JJVEUoQ1VSX1dNKHBpcGUsIGxldmVsKSwKPiAtCQkJwqDCoMKgd20tPnBsYW5l W3BpcGVdW1BMQU5FX0NVUlNPUl1bbGV2ZWxdKTsKPiArCQlza2xfd3JpdGVfd21fbGV2ZWwoZGV2 X3ByaXYsIENVUl9XTShwaXBlLCBsZXZlbCksCj4gKwkJCQnCoMKgwqAmd20tPndtW2xldmVsXSk7 Cj4gwqAJfQo+IC0JSTkxNV9XUklURShDVVJfV01fVFJBTlMocGlwZSksIHdtLQo+ID5wbGFuZV90 cmFuc1twaXBlXVtQTEFORV9DVVJTT1JdKTsKPiArCXNrbF93cml0ZV93bV9sZXZlbChkZXZfcHJp diwgQ1VSX1dNX1RSQU5TKHBpcGUpLCAmd20tCj4gPnRyYW5zX3dtKTsKPiDCoAo+IMKgCXNrbF9k ZGJfZW50cnlfd3JpdGUoZGV2X3ByaXYsIENVUl9CVUZfQ0ZHKHBpcGUpLAo+IC0JCQnCoMKgwqDC oCZ3bS0+ZGRiLnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl0pOwo+ICsJCQnCoMKgwqDCoCZkZGIt PnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl0pOwo+IMKgfQo+IMKgCj4gwqBzdGF0aWMgaW5saW5l IGJvb2wgc2tsX2RkYl9lbnRyaWVzX292ZXJsYXAoY29uc3Qgc3RydWN0Cj4gc2tsX2RkYl9lbnRy eSAqYSwKPiBAQCAtNDA2NCwxMSArNDAyNCw2IEBAIHNrbF9jb3B5X3dtX2Zvcl9waXBlKHN0cnVj dCBza2xfd21fdmFsdWVzCj4gKmRzdCwKPiDCoAkJwqDCoMKgwqDCoHN0cnVjdCBza2xfd21fdmFs dWVzICpzcmMsCj4gwqAJCcKgwqDCoMKgwqBlbnVtIHBpcGUgcGlwZSkKPiDCoHsKPiAtCW1lbWNw eShkc3QtPnBsYW5lW3BpcGVdLCBzcmMtPnBsYW5lW3BpcGVdLAo+IC0JwqDCoMKgwqDCoMKgwqBz aXplb2YoZHN0LT5wbGFuZVtwaXBlXSkpOwo+IC0JbWVtY3B5KGRzdC0+cGxhbmVfdHJhbnNbcGlw ZV0sIHNyYy0+cGxhbmVfdHJhbnNbcGlwZV0sCj4gLQnCoMKgwqDCoMKgwqDCoHNpemVvZihkc3Qt PnBsYW5lX3RyYW5zW3BpcGVdKSk7Cj4gLQo+IMKgCW1lbWNweShkc3QtPmRkYi55X3BsYW5lW3Bp cGVdLCBzcmMtPmRkYi55X3BsYW5lW3BpcGVdLAo+IMKgCcKgwqDCoMKgwqDCoMKgc2l6ZW9mKGRz dC0+ZGRiLnlfcGxhbmVbcGlwZV0pKTsKPiDCoAltZW1jcHkoZHN0LT5kZGIucGxhbmVbcGlwZV0s IHNyYy0+ZGRiLnBsYW5lW3BpcGVdLAo+IEBAIC00MTE3LDcgKzQwNzIsNiBAQCBza2xfY29tcHV0 ZV93bShzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gwqAJwqAqIG5vIHN1aXRhYmxl IHdhdGVybWFyayB2YWx1ZXMgY2FuIGJlIGZvdW5kLgo+IMKgCcKgKi8KPiDCoAlmb3JfZWFjaF9j cnRjX2luX3N0YXRlKHN0YXRlLCBjcnRjLCBjc3RhdGUsIGkpIHsKPiAtCQlzdHJ1Y3QgaW50ZWxf Y3J0YyAqaW50ZWxfY3J0YyA9IHRvX2ludGVsX2NydGMoY3J0Yyk7Cj4gwqAJCXN0cnVjdCBpbnRl bF9jcnRjX3N0YXRlICppbnRlbF9jc3RhdGUgPQo+IMKgCQkJdG9faW50ZWxfY3J0Y19zdGF0ZShj c3RhdGUpOwo+IMKgCj4gQEAgLTQxMzUsNyArNDA4OSw2IEBAIHNrbF9jb21wdXRlX3dtKHN0cnVj dCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKPiDCoAkJCWNvbnRpbnVlOwo+IMKgCj4gwqAJCWlu dGVsX2NzdGF0ZS0+dXBkYXRlX3dtX3ByZSA9IHRydWU7Cj4gLQkJc2tsX2NvbXB1dGVfd21fcmVz dWx0cyhjcnRjLT5kZXYsIHBpcGVfd20sIHJlc3VsdHMsCj4gaW50ZWxfY3J0Yyk7Cj4gwqAJfQo+ IMKgCj4gwqAJcmV0dXJuIDA7Cj4gQEAgLTQxNjksOSArNDEyMiwxMSBAQCBzdGF0aWMgdm9pZCBz a2xfdXBkYXRlX3dtKHN0cnVjdCBkcm1fY3J0Ywo+ICpjcnRjKQo+IMKgCQlpbnQgcGxhbmU7Cj4g wqAKPiDCoAkJZm9yIChwbGFuZSA9IDA7IHBsYW5lIDwKPiBpbnRlbF9udW1fcGxhbmVzKGludGVs X2NydGMpOyBwbGFuZSsrKQo+IC0JCQlza2xfd3JpdGVfcGxhbmVfd20oaW50ZWxfY3J0YywgcmVz dWx0cywKPiBwbGFuZSk7Cj4gKwkJCXNrbF93cml0ZV9wbGFuZV93bShpbnRlbF9jcnRjLCAmcGlw ZV93bS0KPiA+cGxhbmVzW3BsYW5lXSwKPiArCQkJCQnCoMKgwqAmcmVzdWx0cy0+ZGRiLCBwbGFu ZSk7Cj4gwqAKPiAtCQlza2xfd3JpdGVfY3Vyc29yX3dtKGludGVsX2NydGMsIHJlc3VsdHMpOwo+ ICsJCXNrbF93cml0ZV9jdXJzb3Jfd20oaW50ZWxfY3J0YywgJnBpcGVfd20tCj4gPnBsYW5lc1tQ TEFORV9DVVJTT1JdLAo+ICsJCQkJwqDCoMKgwqAmcmVzdWx0cy0+ZGRiKTsKPiDCoAl9Cj4gwqAK PiDCoAlza2xfY29weV93bV9mb3JfcGlwZShod192YWxzLCByZXN1bHRzLCBwaXBlKTsKPiBAQCAt NDI1NiwyOCArNDIxMSwxMyBAQCBzdGF0aWMgdm9pZCBpbGtfb3B0aW1pemVfd2F0ZXJtYXJrcyhz dHJ1Y3QKPiBpbnRlbF9jcnRjX3N0YXRlICpjc3RhdGUpCj4gwqAJbXV0ZXhfdW5sb2NrKCZkZXZf cHJpdi0+d20ud21fbXV0ZXgpOwo+IMKgfQo+IMKgCj4gLXN0YXRpYyB2b2lkIHNrbF9waXBlX3dt X2FjdGl2ZV9zdGF0ZSh1aW50MzJfdCB2YWwsCj4gLQkJCQnCoMKgwqDCoMKgc3RydWN0IHNrbF9w aXBlX3dtICphY3RpdmUsCj4gLQkJCQnCoMKgwqDCoMKgYm9vbCBpc190cmFuc3dtLAo+IC0JCQkJ wqDCoMKgwqDCoGludCBpLAo+IC0JCQkJwqDCoMKgwqDCoGludCBsZXZlbCkKPiArc3RhdGljIGlu bGluZSB2b2lkIHNrbF93bV9sZXZlbF9mcm9tX3JlZ192YWwodWludDMyX3QgdmFsLAo+ICsJCQkJ CcKgwqDCoMKgwqBzdHJ1Y3Qgc2tsX3dtX2xldmVsCj4gKmxldmVsKQo+IMKgewo+IC0Jc3RydWN0 IHNrbF9wbGFuZV93bSAqcGxhbmVfd20gPSAmYWN0aXZlLT5wbGFuZXNbaV07Cj4gLQlib29sIGlz X2VuYWJsZWQgPSAodmFsICYgUExBTkVfV01fRU4pICE9IDA7Cj4gLQo+IC0JaWYgKCFpc190cmFu c3dtKSB7Cj4gLQkJcGxhbmVfd20tPndtW2xldmVsXS5wbGFuZV9lbiA9IGlzX2VuYWJsZWQ7Cj4g LQkJcGxhbmVfd20tPndtW2xldmVsXS5wbGFuZV9yZXNfYiA9IHZhbCAmCj4gUExBTkVfV01fQkxP Q0tTX01BU0s7Cj4gLQkJcGxhbmVfd20tPndtW2xldmVsXS5wbGFuZV9yZXNfbCA9Cj4gLQkJCSh2 YWwgPj4gUExBTkVfV01fTElORVNfU0hJRlQpICYKPiAtCQkJUExBTkVfV01fTElORVNfTUFTSzsK PiAtCX0gZWxzZSB7Cj4gLQkJcGxhbmVfd20tPnRyYW5zX3dtLnBsYW5lX2VuID0gaXNfZW5hYmxl ZDsKPiAtCQlwbGFuZV93bS0+dHJhbnNfd20ucGxhbmVfcmVzX2IgPSB2YWwgJgo+IFBMQU5FX1dN X0JMT0NLU19NQVNLOwo+IC0JCXBsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfbCA9Cj4gLQkJ CSh2YWwgPj4gUExBTkVfV01fTElORVNfU0hJRlQpICYKPiAtCQkJUExBTkVfV01fTElORVNfTUFT SzsKPiAtCX0KPiArCWxldmVsLT5wbGFuZV9lbiA9IHZhbCAmIFBMQU5FX1dNX0VOOwo+ICsJbGV2 ZWwtPnBsYW5lX3Jlc19iID0gdmFsICYgUExBTkVfV01fQkxPQ0tTX01BU0s7Cj4gKwlsZXZlbC0+ cGxhbmVfcmVzX2wgPSAodmFsICYgUExBTkVfV01fTElORVNfTUFTSykgPj4KPiArCQlQTEFORV9X TV9MSU5FU19TSElGVDsKClRoaXMgYWxzbyBsb29rcyB3cm9uZywgc2luY2UgUExBTkVfV01fTElO RVNfTUFTSyBpcyAweDFmLiBXZSBzaG91bGQgZG8KbGlrZSB0aGUgb3JpZ2luYWwgY29kZSBkaWQ6 IHNoaWZ0aW5nIGJlZm9yZSBtYXNraW5nLgoKCj4gwqB9Cj4gwqAKPiDCoHN0YXRpYyB2b2lkIHNr bF9waXBlX3dtX2dldF9od19zdGF0ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCj4gQEAgLTQyODcs MjMgKzQyMjcsMzMgQEAgc3RhdGljIHZvaWQgc2tsX3BpcGVfd21fZ2V0X2h3X3N0YXRlKHN0cnVj dAo+IGRybV9jcnRjICpjcnRjKQo+IMKgCXN0cnVjdCBza2xfd21fdmFsdWVzICpodyA9ICZkZXZf cHJpdi0+d20uc2tsX2h3Owo+IMKgCXN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjID0gdG9f aW50ZWxfY3J0YyhjcnRjKTsKPiDCoAlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3N0YXRlID0g dG9faW50ZWxfY3J0Y19zdGF0ZShjcnRjLQo+ID5zdGF0ZSk7Cj4gKwlzdHJ1Y3QgaW50ZWxfcGxh bmUgKmludGVsX3BsYW5lOwo+IMKgCXN0cnVjdCBza2xfcGlwZV93bSAqYWN0aXZlID0gJmNzdGF0 ZS0+d20uc2tsLm9wdGltYWw7Cj4gKwlzdHJ1Y3Qgc2tsX3BsYW5lX3dtICp3bTsKPiDCoAllbnVt IHBpcGUgcGlwZSA9IGludGVsX2NydGMtPnBpcGU7Cj4gLQlpbnQgbGV2ZWwsIGksIG1heF9sZXZl bDsKPiAtCXVpbnQzMl90IHRlbXA7Cj4gKwlpbnQgbGV2ZWwsIGlkLCBtYXhfbGV2ZWwgPSBpbGtf d21fbWF4X2xldmVsKGRldik7Cj4gKwl1aW50MzJfdCB2YWw7Cj4gwqAKPiAtCW1heF9sZXZlbCA9 IGlsa193bV9tYXhfbGV2ZWwoZGV2KTsKPiArCWZvcl9lYWNoX2ludGVsX3BsYW5lX29uX2NydGMo ZGV2LCBpbnRlbF9jcnRjLCBpbnRlbF9wbGFuZSkgewo+ICsJCWlkID0gc2tsX3dtX3BsYW5lX2lk KGludGVsX3BsYW5lKTsKPiArCQl3bSA9ICZjc3RhdGUtPndtLnNrbC5vcHRpbWFsLnBsYW5lc1tp ZF07Cj4gwqAKPiAtCWZvciAobGV2ZWwgPSAwOyBsZXZlbCA8PSBtYXhfbGV2ZWw7IGxldmVsKysp IHsKPiAtCQlmb3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3BsYW5lcyhpbnRlbF9jcnRjKTsgaSsr KQo+IC0JCQlody0+cGxhbmVbcGlwZV1baV1bbGV2ZWxdID0KPiAtCQkJCQlJOTE1X1JFQUQoUExB TkVfV00ocGlwZSwgaSwKPiBsZXZlbCkpOwo+IC0JCWh3LT5wbGFuZVtwaXBlXVtQTEFORV9DVVJT T1JdW2xldmVsXSA9Cj4gSTkxNV9SRUFEKENVUl9XTShwaXBlLCBsZXZlbCkpOwo+IC0JfQo+ICsJ CWZvciAobGV2ZWwgPSAwOyBsZXZlbCA8PSBtYXhfbGV2ZWw7IGxldmVsKyspIHsKPiArCQkJaWYg KGlkICE9IFBMQU5FX0NVUlNPUikKPiArCQkJCXZhbCA9IEk5MTVfUkVBRChQTEFORV9XTShwaXBl LCBpZCwKPiBsZXZlbCkpOwo+ICsJCQllbHNlCj4gKwkJCQl2YWwgPSBJOTE1X1JFQUQoQ1VSX1dN KHBpcGUsCj4gbGV2ZWwpKTsKPiArCj4gKwkJCXNrbF93bV9sZXZlbF9mcm9tX3JlZ192YWwodmFs LCAmd20tCj4gPndtW2xldmVsXSk7Cj4gKwkJfQo+IMKgCj4gLQlmb3IgKGkgPSAwOyBpIDwgaW50 ZWxfbnVtX3BsYW5lcyhpbnRlbF9jcnRjKTsgaSsrKQo+IC0JCWh3LT5wbGFuZV90cmFuc1twaXBl XVtpXSA9Cj4gSTkxNV9SRUFEKFBMQU5FX1dNX1RSQU5TKHBpcGUsIGkpKTsKPiAtCWh3LT5wbGFu ZV90cmFuc1twaXBlXVtQTEFORV9DVVJTT1JdID0KPiBJOTE1X1JFQUQoQ1VSX1dNX1RSQU5TKHBp cGUpKTsKPiArCQlpZiAoaWQgIT0gUExBTkVfQ1VSU09SKQo+ICsJCQl2YWwgPSBJOTE1X1JFQUQo UExBTkVfV01fVFJBTlMocGlwZSwgaWQpKTsKPiArCQllbHNlCj4gKwkJCXZhbCA9IEk5MTVfUkVB RChDVVJfV01fVFJBTlMocGlwZSkpOwo+ICsKPiArCQlza2xfd21fbGV2ZWxfZnJvbV9yZWdfdmFs KHZhbCwgJndtLT50cmFuc193bSk7Cj4gKwl9Cj4gwqAKPiDCoAlpZiAoIWludGVsX2NydGMtPmFj dGl2ZSkKPiDCoAkJcmV0dXJuOwo+IEBAIC00MzExLDI1ICs0MjYxLDYgQEAgc3RhdGljIHZvaWQg c2tsX3BpcGVfd21fZ2V0X2h3X3N0YXRlKHN0cnVjdAo+IGRybV9jcnRjICpjcnRjKQo+IMKgCWh3 LT5kaXJ0eV9waXBlcyB8PSBkcm1fY3J0Y19tYXNrKGNydGMpOwo+IMKgCj4gwqAJYWN0aXZlLT5s aW5ldGltZSA9IEk5MTVfUkVBRChQSVBFX1dNX0xJTkVUSU1FKHBpcGUpKTsKPiAtCj4gLQlmb3Ig KGxldmVsID0gMDsgbGV2ZWwgPD0gbWF4X2xldmVsOyBsZXZlbCsrKSB7Cj4gLQkJZm9yIChpID0g MDsgaSA8IGludGVsX251bV9wbGFuZXMoaW50ZWxfY3J0Yyk7IGkrKykgewo+IC0JCQl0ZW1wID0g aHctPnBsYW5lW3BpcGVdW2ldW2xldmVsXTsKPiAtCQkJc2tsX3BpcGVfd21fYWN0aXZlX3N0YXRl KHRlbXAsIGFjdGl2ZSwKPiBmYWxzZSwgaSwgbGV2ZWwpOwo+IC0JCX0KPiAtCQl0ZW1wID0gaHct PnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl1bbGV2ZWxdOwo+IC0JCXNrbF9waXBlX3dtX2FjdGl2 ZV9zdGF0ZSh0ZW1wLCBhY3RpdmUsIGZhbHNlLCBpLAo+IGxldmVsKTsKPiAtCX0KPiAtCj4gLQlm b3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3BsYW5lcyhpbnRlbF9jcnRjKTsgaSsrKSB7Cj4gLQkJ dGVtcCA9IGh3LT5wbGFuZV90cmFuc1twaXBlXVtpXTsKPiAtCQlza2xfcGlwZV93bV9hY3RpdmVf c3RhdGUodGVtcCwgYWN0aXZlLCB0cnVlLCBpLCAwKTsKPiAtCX0KPiAtCj4gLQl0ZW1wID0gaHct PnBsYW5lX3RyYW5zW3BpcGVdW1BMQU5FX0NVUlNPUl07Cj4gLQlza2xfcGlwZV93bV9hY3RpdmVf c3RhdGUodGVtcCwgYWN0aXZlLCB0cnVlLCBpLCAwKTsKPiAtCj4gLQlpbnRlbF9jcnRjLT53bS5h Y3RpdmUuc2tsID0gKmFjdGl2ZTsKCkFzIGZhciBhcyBJIHVuZGVyc3Rvb2QsIHdlIHNob3VsZCBz dGlsbCBiZSBzZXR0aW5nIGludGVsX2NydGMtCj53bS5hY3RpdmUuc2tsLiBTaG91bGRuJ3Qgd2U/ IElmIG5vdCwgd2h5PwoKCk5vdywgZHVlIHRvIHRoZSBwcm9ibGVtcyBhYm92ZSwgd2VyZW4ndCB5 b3UgZ2V0dGluZyBzb21lIFdBUk5zIGFib3V0CnRoZSBodyBzdGF0ZSBub3QgbWF0Y2hpbmcgd2hh dCBpdCBzaG91bGQ/IEluIGNhc2Ugbm90LCBtYXliZSB5b3UgY291bGQKaW52ZXN0aWdhdGUgd2h5 LgoKCj4gwqB9Cj4gwqAKPiDCoHZvaWQgc2tsX3dtX2dldF9od19zdGF0ZShzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2KQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zcHJp dGUuYwo+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfc3ByaXRlLmMKPiBpbmRleCA3M2E1 MjFmLi4wZmI3NzViIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nw cml0ZS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfc3ByaXRlLmMKPiBAQCAt MjA4LDYgKzIwOCw4IEBAIHNrbF91cGRhdGVfcGxhbmUoc3RydWN0IGRybV9wbGFuZSAqZHJtX3Bs YW5lLAo+IMKgCXN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjID0gdG9faW50ZWxfY3J0Yyhj cnRjKTsKPiDCoAljb25zdCBpbnQgcGlwZSA9IGludGVsX3BsYW5lLT5waXBlOwo+IMKgCWNvbnN0 IGludCBwbGFuZSA9IGludGVsX3BsYW5lLT5wbGFuZSArIDE7Cj4gKwljb25zdCBzdHJ1Y3Qgc2ts X3BsYW5lX3dtICpwX3dtID0KPiArCQkmY3J0Y19zdGF0ZS0+d20uc2tsLm9wdGltYWwucGxhbmVz W3BsYW5lXTsKPiDCoAl1MzIgcGxhbmVfY3RsOwo+IMKgCWNvbnN0IHN0cnVjdCBkcm1faW50ZWxf c3ByaXRlX2NvbG9ya2V5ICprZXkgPSAmcGxhbmVfc3RhdGUtCj4gPmNrZXk7Cj4gwqAJdTMyIHN1 cmZfYWRkciA9IHBsYW5lX3N0YXRlLT5tYWluLm9mZnNldDsKPiBAQCAtMjMyLDcgKzIzNCw3IEBA IHNrbF91cGRhdGVfcGxhbmUoc3RydWN0IGRybV9wbGFuZSAqZHJtX3BsYW5lLAo+IMKgCXBsYW5l X2N0bCB8PSBza2xfcGxhbmVfY3RsX3JvdGF0aW9uKHJvdGF0aW9uKTsKPiDCoAo+IMKgCWlmICh3 bS0+ZGlydHlfcGlwZXMgJiBkcm1fY3J0Y19tYXNrKGNydGMpKQo+IC0JCXNrbF93cml0ZV9wbGFu ZV93bShpbnRlbF9jcnRjLCB3bSwgcGxhbmUpOwo+ICsJCXNrbF93cml0ZV9wbGFuZV93bShpbnRl bF9jcnRjLCBwX3dtLCAmd20tPmRkYiwKPiBwbGFuZSk7Cj4gwqAKPiDCoAlpZiAoa2V5LT5mbGFn cykgewo+IMKgCQlJOTE1X1dSSVRFKFBMQU5FX0tFWVZBTChwaXBlLCBwbGFuZSksIGtleS0KPiA+ bWluX3ZhbHVlKTsKPiBAQCAtMjg5LDYgKzI5MSw3IEBAIHNrbF9kaXNhYmxlX3BsYW5lKHN0cnVj dCBkcm1fcGxhbmUgKmRwbGFuZSwKPiBzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCj4gwqAJc3RydWN0 IGRybV9kZXZpY2UgKmRldiA9IGRwbGFuZS0+ZGV2Owo+IMKgCXN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZGV2KTsKPiDCoAlzdHJ1Y3QgaW50ZWxfcGxhbmUgKmlu dGVsX3BsYW5lID0gdG9faW50ZWxfcGxhbmUoZHBsYW5lKTsKPiArCXN0cnVjdCBpbnRlbF9jcnRj X3N0YXRlICpjc3RhdGUgPSB0b19pbnRlbF9jcnRjX3N0YXRlKGNydGMtCj4gPnN0YXRlKTsKPiDC oAljb25zdCBpbnQgcGlwZSA9IGludGVsX3BsYW5lLT5waXBlOwo+IMKgCWNvbnN0IGludCBwbGFu ZSA9IGludGVsX3BsYW5lLT5wbGFuZSArIDE7Cj4gwqAKPiBAQCAtMjk4LDcgKzMwMSw4IEBAIHNr bF9kaXNhYmxlX3BsYW5lKHN0cnVjdCBkcm1fcGxhbmUgKmRwbGFuZSwKPiBzdHJ1Y3QgZHJtX2Ny dGMgKmNydGMpCj4gwqAJwqAqLwo+IMKgCWlmICghZHBsYW5lLT5zdGF0ZS0+dmlzaWJsZSkKPiDC oAkJc2tsX3dyaXRlX3BsYW5lX3dtKHRvX2ludGVsX2NydGMoY3J0YyksCj4gLQkJCQnCoMKgwqAm ZGV2X3ByaXYtPndtLnNrbF9yZXN1bHRzLAo+IHBsYW5lKTsKPiArCQkJCcKgwqDCoCZjc3RhdGUt Cj4gPndtLnNrbC5vcHRpbWFsLnBsYW5lc1twbGFuZV0sCj4gKwkJCQnCoMKgwqAmZGV2X3ByaXYt PndtLnNrbF9yZXN1bHRzLmRkYiwKPiBwbGFuZSk7Cj4gwqAKPiDCoAlJOTE1X1dSSVRFKFBMQU5F X0NUTChwaXBlLCBwbGFuZSksIDApOwo+IMKgCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755088AbcJEVoM (ORCPT ); Wed, 5 Oct 2016 17:44:12 -0400 Received: from mga04.intel.com ([192.55.52.120]:61179 "EHLO mga04.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754225AbcJEVoK (ORCPT ); Wed, 5 Oct 2016 17:44:10 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.31,451,1473145200"; d="scan'208";a="16598256" Message-ID: <1475703844.2381.74.camel@intel.com> Subject: Re: [Intel-gfx] [PATCH 5/6] drm/i915/gen9: Get rid of redundant watermark values From: Paulo Zanoni To: Lyude , intel-gfx@lists.freedesktop.org Cc: David Airlie , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Daniel Vetter Date: Wed, 05 Oct 2016 18:44:04 -0300 In-Reply-To: <1475681598-12081-6-git-send-email-cpaul@redhat.com> References: <1475681598-12081-1-git-send-email-cpaul@redhat.com> <1475681598-12081-6-git-send-email-cpaul@redhat.com> Content-Type: text/plain; charset="UTF-8" X-Mailer: Evolution 3.20.5 (3.20.5-1.fc24) Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Em Qua, 2016-10-05 às 11:33 -0400, Lyude escreveu: > Now that we've make skl_wm_levels make a little more sense, we can > remove all of the redundant wm information. Up until now we'd been > storing two copies of all of the skl watermarks: one being the > skl_pipe_wm structs, the other being the global wm struct in > drm_i915_private containing the raw register values. This is > confusing > and problematic, since it means we're prone to accidentally letting > the > two copies go out of sync. So, get rid of all of the functions > responsible for computing the register values and just use a single > helper, skl_write_wm_level(), to convert and write the new watermarks > on > the fly. I like the direction of this patch too, but there are some small possible problems. See below. > > Signed-off-by: Lyude > Cc: Maarten Lankhorst > Cc: Ville Syrjälä > Cc: Matt Roper > --- >  drivers/gpu/drm/i915/i915_drv.h      |   2 - >  drivers/gpu/drm/i915/intel_display.c |  14 ++- >  drivers/gpu/drm/i915/intel_drv.h     |   6 +- >  drivers/gpu/drm/i915/intel_pm.c      | 203 ++++++++++++------------- > ---------- >  drivers/gpu/drm/i915/intel_sprite.c  |   8 +- >  5 files changed, 88 insertions(+), 145 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.h > b/drivers/gpu/drm/i915/i915_drv.h > index 0f97d43..63519ac 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -1643,8 +1643,6 @@ struct skl_ddb_allocation { >  struct skl_wm_values { >   unsigned dirty_pipes; >   struct skl_ddb_allocation ddb; > - uint32_t plane[I915_MAX_PIPES][I915_MAX_PLANES][8]; > - uint32_t plane_trans[I915_MAX_PIPES][I915_MAX_PLANES]; >  }; >   >  struct skl_wm_level { > diff --git a/drivers/gpu/drm/i915/intel_display.c > b/drivers/gpu/drm/i915/intel_display.c > index dd15ae2..c580d3d 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -3378,6 +3378,8 @@ static void skylake_update_primary_plane(struct > drm_plane *plane, >   struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state- > >base.crtc); >   struct drm_framebuffer *fb = plane_state->base.fb; >   const struct skl_wm_values *wm = &dev_priv->wm.skl_results; > + const struct skl_plane_wm *p_wm = > + &crtc_state->wm.skl.optimal.planes[0]; I wish someone would do a patch to convert all these hardcoded values to PLANE_X, and convert "int"s  to "enum plane"s everywhere. >   int pipe = intel_crtc->pipe; >   u32 plane_ctl; >   unsigned int rotation = plane_state->base.rotation; > @@ -3414,7 +3416,7 @@ static void skylake_update_primary_plane(struct > drm_plane *plane, >   intel_crtc->adjusted_y = src_y; >   >   if (wm->dirty_pipes & drm_crtc_mask(&intel_crtc->base)) > - skl_write_plane_wm(intel_crtc, wm, 0); > + skl_write_plane_wm(intel_crtc, p_wm, &wm->ddb, 0); >   >   I915_WRITE(PLANE_CTL(pipe, 0), plane_ctl); >   I915_WRITE(PLANE_OFFSET(pipe, 0), (src_y << 16) | src_x); > @@ -3448,6 +3450,8 @@ static void > skylake_disable_primary_plane(struct drm_plane *primary, >   struct drm_device *dev = crtc->dev; >   struct drm_i915_private *dev_priv = to_i915(dev); >   struct intel_crtc *intel_crtc = to_intel_crtc(crtc); > + struct intel_crtc_state *cstate = to_intel_crtc_state(crtc- > >state); > + const struct skl_plane_wm *p_wm = &cstate- > >wm.skl.optimal.planes[0]; >   int pipe = intel_crtc->pipe; >   >   /* > @@ -3455,7 +3459,8 @@ static void > skylake_disable_primary_plane(struct drm_plane *primary, >    * plane's visiblity isn't actually changing neither is its > watermarks. >    */ >   if (!crtc->primary->state->visible) > - skl_write_plane_wm(intel_crtc, &dev_priv- > >wm.skl_results, 0); > + skl_write_plane_wm(intel_crtc, p_wm, > +    &dev_priv->wm.skl_results.ddb, > 0); >   >   I915_WRITE(PLANE_CTL(pipe, 0), 0); >   I915_WRITE(PLANE_SURF(pipe, 0), 0); > @@ -10819,12 +10824,15 @@ static void i9xx_update_cursor(struct > drm_crtc *crtc, u32 base, >   struct drm_device *dev = crtc->dev; >   struct drm_i915_private *dev_priv = to_i915(dev); >   struct intel_crtc *intel_crtc = to_intel_crtc(crtc); > + struct intel_crtc_state *cstate = to_intel_crtc_state(crtc- > >state); >   const struct skl_wm_values *wm = &dev_priv->wm.skl_results; > + const struct skl_plane_wm *p_wm = > + &cstate->wm.skl.optimal.planes[PLANE_CURSOR]; >   int pipe = intel_crtc->pipe; >   uint32_t cntl = 0; >   >   if (INTEL_GEN(dev_priv) >= 9 && wm->dirty_pipes & > drm_crtc_mask(crtc)) > - skl_write_cursor_wm(intel_crtc, wm); > + skl_write_cursor_wm(intel_crtc, p_wm, &wm->ddb); >   >   if (plane_state && plane_state->base.visible) { >   cntl = MCURSOR_GAMMA_ENABLE; > diff --git a/drivers/gpu/drm/i915/intel_drv.h > b/drivers/gpu/drm/i915/intel_drv.h > index d684f4f..958dc72 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -1765,9 +1765,11 @@ bool skl_ddb_allocation_equals(const struct > skl_ddb_allocation *old, >  bool skl_ddb_allocation_overlaps(struct drm_atomic_state *state, >    struct intel_crtc *intel_crtc); >  void skl_write_cursor_wm(struct intel_crtc *intel_crtc, > -  const struct skl_wm_values *wm); > +  const struct skl_plane_wm *wm, > +  const struct skl_ddb_allocation *ddb); >  void skl_write_plane_wm(struct intel_crtc *intel_crtc, > - const struct skl_wm_values *wm, > + const struct skl_plane_wm *wm, > + const struct skl_ddb_allocation *ddb, >   int plane); >  uint32_t ilk_pipe_pixel_rate(const struct intel_crtc_state > *pipe_config); >  bool ilk_disable_lp_wm(struct drm_device *dev); > diff --git a/drivers/gpu/drm/i915/intel_pm.c > b/drivers/gpu/drm/i915/intel_pm.c > index 250f12d..7708646 100644 > --- a/drivers/gpu/drm/i915/intel_pm.c > +++ b/drivers/gpu/drm/i915/intel_pm.c > @@ -3000,6 +3000,8 @@ bool intel_can_enable_sagv(struct > drm_atomic_state *state) >   struct drm_i915_private *dev_priv = to_i915(dev); >   struct intel_atomic_state *intel_state = > to_intel_atomic_state(state); >   struct drm_crtc *crtc; > + struct intel_crtc_state *cstate; > + struct skl_plane_wm *wm; >   enum pipe pipe; >   int level, plane; >   > @@ -3020,18 +3022,21 @@ bool intel_can_enable_sagv(struct > drm_atomic_state *state) >   /* Since we're now guaranteed to only have one active > CRTC... */ >   pipe = ffs(intel_state->active_crtcs) - 1; >   crtc = dev_priv->pipe_to_crtc_mapping[pipe]; > + cstate = intel_atomic_get_crtc_state(state, > to_intel_crtc(crtc)); >   >   if (crtc->state->mode.flags & DRM_MODE_FLAG_INTERLACE) >   return false; >   >   for_each_plane(dev_priv, pipe, plane) { > + wm = &cstate->wm.skl.optimal.planes[plane]; > + >   /* Skip this plane if it's not enabled */ > - if (intel_state->wm_results.plane[pipe][plane][0] == > 0) > + if (!wm->wm[0].plane_en) >   continue; >   >   /* Find the highest enabled wm level for this plane > */ > - for (level = ilk_wm_max_level(dev); > -      intel_state- > >wm_results.plane[pipe][plane][level] == 0; --level) > + for (level = ilk_wm_max_level(dev); !wm- > >wm[level].plane_en; > +      --level) >        { } >   >   /* > @@ -3777,67 +3782,6 @@ static int skl_build_pipe_wm(struct > intel_crtc_state *cstate, >   return 0; >  } >   > -static void skl_compute_wm_results(struct drm_device *dev, > -    struct skl_pipe_wm *p_wm, > -    struct skl_wm_values *r, > -    struct intel_crtc *intel_crtc) > -{ > - int level, max_level = ilk_wm_max_level(dev); > - struct skl_plane_wm *plane_wm; > - enum pipe pipe = intel_crtc->pipe; > - uint32_t temp; > - int i; > - > - for (i = 0; i < intel_num_planes(intel_crtc); i++) { > - plane_wm = &p_wm->planes[i]; > - > - for (level = 0; level <= max_level; level++) { > - temp = 0; > - > - temp |= plane_wm->wm[level].plane_res_l << > - PLANE_WM_LINES_SHIFT; > - temp |= plane_wm->wm[level].plane_res_b; > - if (plane_wm->wm[level].plane_en) > - temp |= PLANE_WM_EN; > - > - r->plane[pipe][i][level] = temp; > - } > - > - } > - > - for (level = 0; level <= max_level; level++) { > - plane_wm = &p_wm->planes[PLANE_CURSOR]; > - temp = 0; > - temp |= plane_wm->wm[level].plane_res_l << > PLANE_WM_LINES_SHIFT; > - temp |= plane_wm->wm[level].plane_res_b; > - if (plane_wm->wm[level].plane_en) > - temp |= PLANE_WM_EN; > - > - r->plane[pipe][PLANE_CURSOR][level] = temp; > - } > - > - /* transition WMs */ > - for (i = 0; i < intel_num_planes(intel_crtc); i++) { > - plane_wm = &p_wm->planes[i]; > - temp = 0; > - temp |= plane_wm->trans_wm.plane_res_l << > PLANE_WM_LINES_SHIFT; > - temp |= plane_wm->trans_wm.plane_res_b; > - if (plane_wm->trans_wm.plane_en) > - temp |= PLANE_WM_EN; > - > - r->plane_trans[pipe][i] = temp; > - } > - > - plane_wm = &p_wm->planes[PLANE_CURSOR]; > - temp = 0; > - temp |= plane_wm->trans_wm.plane_res_l << > PLANE_WM_LINES_SHIFT; > - temp |= plane_wm->trans_wm.plane_res_b; > - if (plane_wm->trans_wm.plane_en) > - temp |= PLANE_WM_EN; > - > - r->plane_trans[pipe][PLANE_CURSOR] = temp; > -} > - >  static void skl_ddb_entry_write(struct drm_i915_private *dev_priv, >   i915_reg_t reg, >   const struct skl_ddb_entry *entry) > @@ -3848,8 +3792,22 @@ static void skl_ddb_entry_write(struct > drm_i915_private *dev_priv, >   I915_WRITE(reg, 0); >  } >   > +static void skl_write_wm_level(struct drm_i915_private *dev_priv, > +        i915_reg_t reg, > +        const struct skl_wm_level *level) > +{ > + uint32_t val = 0; > + > + val |= level->plane_res_b; > + val |= level->plane_res_l << PLANE_WM_LINES_SHIFT; > + val |= level->plane_en; The line above seems wrong, you should check for plane_en and then set PLANE_WM_EN. IMHO it would even better if we completely zeroed the register in case plane_en is false, so we could have: uint32_t val = 0; if (level->plane_en) { val |= PLANE_WM_EN; val |= level->plane_res_b; val |= level->plane_res_l << PLANE_WM_LINES_SHIFT; } > + > + I915_WRITE(reg, val); > +} > + >  void skl_write_plane_wm(struct intel_crtc *intel_crtc, > - const struct skl_wm_values *wm, > + const struct skl_plane_wm *wm, > + const struct skl_ddb_allocation *ddb, >   int plane) >  { >   struct drm_crtc *crtc = &intel_crtc->base; > @@ -3859,19 +3817,21 @@ void skl_write_plane_wm(struct intel_crtc > *intel_crtc, >   enum pipe pipe = intel_crtc->pipe; >   >   for (level = 0; level <= max_level; level++) { > - I915_WRITE(PLANE_WM(pipe, plane, level), > -    wm->plane[pipe][plane][level]); > + skl_write_wm_level(dev_priv, PLANE_WM(pipe, plane, > level), > +    &wm->wm[level]); >   } > - I915_WRITE(PLANE_WM_TRANS(pipe, plane), wm- > >plane_trans[pipe][plane]); > + skl_write_wm_level(dev_priv, PLANE_WM_TRANS(pipe, plane), > +    &wm->trans_wm); >   >   skl_ddb_entry_write(dev_priv, PLANE_BUF_CFG(pipe, plane), > -     &wm->ddb.plane[pipe][plane]); > +     &ddb->plane[pipe][plane]); >   skl_ddb_entry_write(dev_priv, PLANE_NV12_BUF_CFG(pipe, > plane), > -     &wm->ddb.y_plane[pipe][plane]); > +     &ddb->y_plane[pipe][plane]); >  } >   >  void skl_write_cursor_wm(struct intel_crtc *intel_crtc, > -  const struct skl_wm_values *wm) > +  const struct skl_plane_wm *wm, > +  const struct skl_ddb_allocation *ddb) >  { >   struct drm_crtc *crtc = &intel_crtc->base; >   struct drm_device *dev = crtc->dev; > @@ -3880,13 +3840,13 @@ void skl_write_cursor_wm(struct intel_crtc > *intel_crtc, >   enum pipe pipe = intel_crtc->pipe; >   >   for (level = 0; level <= max_level; level++) { > - I915_WRITE(CUR_WM(pipe, level), > -    wm->plane[pipe][PLANE_CURSOR][level]); > + skl_write_wm_level(dev_priv, CUR_WM(pipe, level), > +    &wm->wm[level]); >   } > - I915_WRITE(CUR_WM_TRANS(pipe), wm- > >plane_trans[pipe][PLANE_CURSOR]); > + skl_write_wm_level(dev_priv, CUR_WM_TRANS(pipe), &wm- > >trans_wm); >   >   skl_ddb_entry_write(dev_priv, CUR_BUF_CFG(pipe), > -     &wm->ddb.plane[pipe][PLANE_CURSOR]); > +     &ddb->plane[pipe][PLANE_CURSOR]); >  } >   >  static inline bool skl_ddb_entries_overlap(const struct > skl_ddb_entry *a, > @@ -4064,11 +4024,6 @@ skl_copy_wm_for_pipe(struct skl_wm_values > *dst, >        struct skl_wm_values *src, >        enum pipe pipe) >  { > - memcpy(dst->plane[pipe], src->plane[pipe], > -        sizeof(dst->plane[pipe])); > - memcpy(dst->plane_trans[pipe], src->plane_trans[pipe], > -        sizeof(dst->plane_trans[pipe])); > - >   memcpy(dst->ddb.y_plane[pipe], src->ddb.y_plane[pipe], >          sizeof(dst->ddb.y_plane[pipe])); >   memcpy(dst->ddb.plane[pipe], src->ddb.plane[pipe], > @@ -4117,7 +4072,6 @@ skl_compute_wm(struct drm_atomic_state *state) >    * no suitable watermark values can be found. >    */ >   for_each_crtc_in_state(state, crtc, cstate, i) { > - struct intel_crtc *intel_crtc = to_intel_crtc(crtc); >   struct intel_crtc_state *intel_cstate = >   to_intel_crtc_state(cstate); >   > @@ -4135,7 +4089,6 @@ skl_compute_wm(struct drm_atomic_state *state) >   continue; >   >   intel_cstate->update_wm_pre = true; > - skl_compute_wm_results(crtc->dev, pipe_wm, results, > intel_crtc); >   } >   >   return 0; > @@ -4169,9 +4122,11 @@ static void skl_update_wm(struct drm_crtc > *crtc) >   int plane; >   >   for (plane = 0; plane < > intel_num_planes(intel_crtc); plane++) > - skl_write_plane_wm(intel_crtc, results, > plane); > + skl_write_plane_wm(intel_crtc, &pipe_wm- > >planes[plane], > +    &results->ddb, plane); >   > - skl_write_cursor_wm(intel_crtc, results); > + skl_write_cursor_wm(intel_crtc, &pipe_wm- > >planes[PLANE_CURSOR], > +     &results->ddb); >   } >   >   skl_copy_wm_for_pipe(hw_vals, results, pipe); > @@ -4256,28 +4211,13 @@ static void ilk_optimize_watermarks(struct > intel_crtc_state *cstate) >   mutex_unlock(&dev_priv->wm.wm_mutex); >  } >   > -static void skl_pipe_wm_active_state(uint32_t val, > -      struct skl_pipe_wm *active, > -      bool is_transwm, > -      int i, > -      int level) > +static inline void skl_wm_level_from_reg_val(uint32_t val, > +      struct skl_wm_level > *level) >  { > - struct skl_plane_wm *plane_wm = &active->planes[i]; > - bool is_enabled = (val & PLANE_WM_EN) != 0; > - > - if (!is_transwm) { > - plane_wm->wm[level].plane_en = is_enabled; > - plane_wm->wm[level].plane_res_b = val & > PLANE_WM_BLOCKS_MASK; > - plane_wm->wm[level].plane_res_l = > - (val >> PLANE_WM_LINES_SHIFT) & > - PLANE_WM_LINES_MASK; > - } else { > - plane_wm->trans_wm.plane_en = is_enabled; > - plane_wm->trans_wm.plane_res_b = val & > PLANE_WM_BLOCKS_MASK; > - plane_wm->trans_wm.plane_res_l = > - (val >> PLANE_WM_LINES_SHIFT) & > - PLANE_WM_LINES_MASK; > - } > + level->plane_en = val & PLANE_WM_EN; > + level->plane_res_b = val & PLANE_WM_BLOCKS_MASK; > + level->plane_res_l = (val & PLANE_WM_LINES_MASK) >> > + PLANE_WM_LINES_SHIFT; This also looks wrong, since PLANE_WM_LINES_MASK is 0x1f. We should do like the original code did: shifting before masking. >  } >   >  static void skl_pipe_wm_get_hw_state(struct drm_crtc *crtc) > @@ -4287,23 +4227,33 @@ static void skl_pipe_wm_get_hw_state(struct > drm_crtc *crtc) >   struct skl_wm_values *hw = &dev_priv->wm.skl_hw; >   struct intel_crtc *intel_crtc = to_intel_crtc(crtc); >   struct intel_crtc_state *cstate = to_intel_crtc_state(crtc- > >state); > + struct intel_plane *intel_plane; >   struct skl_pipe_wm *active = &cstate->wm.skl.optimal; > + struct skl_plane_wm *wm; >   enum pipe pipe = intel_crtc->pipe; > - int level, i, max_level; > - uint32_t temp; > + int level, id, max_level = ilk_wm_max_level(dev); > + uint32_t val; >   > - max_level = ilk_wm_max_level(dev); > + for_each_intel_plane_on_crtc(dev, intel_crtc, intel_plane) { > + id = skl_wm_plane_id(intel_plane); > + wm = &cstate->wm.skl.optimal.planes[id]; >   > - for (level = 0; level <= max_level; level++) { > - for (i = 0; i < intel_num_planes(intel_crtc); i++) > - hw->plane[pipe][i][level] = > - I915_READ(PLANE_WM(pipe, i, > level)); > - hw->plane[pipe][PLANE_CURSOR][level] = > I915_READ(CUR_WM(pipe, level)); > - } > + for (level = 0; level <= max_level; level++) { > + if (id != PLANE_CURSOR) > + val = I915_READ(PLANE_WM(pipe, id, > level)); > + else > + val = I915_READ(CUR_WM(pipe, > level)); > + > + skl_wm_level_from_reg_val(val, &wm- > >wm[level]); > + } >   > - for (i = 0; i < intel_num_planes(intel_crtc); i++) > - hw->plane_trans[pipe][i] = > I915_READ(PLANE_WM_TRANS(pipe, i)); > - hw->plane_trans[pipe][PLANE_CURSOR] = > I915_READ(CUR_WM_TRANS(pipe)); > + if (id != PLANE_CURSOR) > + val = I915_READ(PLANE_WM_TRANS(pipe, id)); > + else > + val = I915_READ(CUR_WM_TRANS(pipe)); > + > + skl_wm_level_from_reg_val(val, &wm->trans_wm); > + } >   >   if (!intel_crtc->active) >   return; > @@ -4311,25 +4261,6 @@ static void skl_pipe_wm_get_hw_state(struct > drm_crtc *crtc) >   hw->dirty_pipes |= drm_crtc_mask(crtc); >   >   active->linetime = I915_READ(PIPE_WM_LINETIME(pipe)); > - > - for (level = 0; level <= max_level; level++) { > - for (i = 0; i < intel_num_planes(intel_crtc); i++) { > - temp = hw->plane[pipe][i][level]; > - skl_pipe_wm_active_state(temp, active, > false, i, level); > - } > - temp = hw->plane[pipe][PLANE_CURSOR][level]; > - skl_pipe_wm_active_state(temp, active, false, i, > level); > - } > - > - for (i = 0; i < intel_num_planes(intel_crtc); i++) { > - temp = hw->plane_trans[pipe][i]; > - skl_pipe_wm_active_state(temp, active, true, i, 0); > - } > - > - temp = hw->plane_trans[pipe][PLANE_CURSOR]; > - skl_pipe_wm_active_state(temp, active, true, i, 0); > - > - intel_crtc->wm.active.skl = *active; As far as I understood, we should still be setting intel_crtc- >wm.active.skl. Shouldn't we? If not, why? Now, due to the problems above, weren't you getting some WARNs about the hw state not matching what it should? In case not, maybe you could investigate why. >  } >   >  void skl_wm_get_hw_state(struct drm_device *dev) > diff --git a/drivers/gpu/drm/i915/intel_sprite.c > b/drivers/gpu/drm/i915/intel_sprite.c > index 73a521f..0fb775b 100644 > --- a/drivers/gpu/drm/i915/intel_sprite.c > +++ b/drivers/gpu/drm/i915/intel_sprite.c > @@ -208,6 +208,8 @@ skl_update_plane(struct drm_plane *drm_plane, >   struct intel_crtc *intel_crtc = to_intel_crtc(crtc); >   const int pipe = intel_plane->pipe; >   const int plane = intel_plane->plane + 1; > + const struct skl_plane_wm *p_wm = > + &crtc_state->wm.skl.optimal.planes[plane]; >   u32 plane_ctl; >   const struct drm_intel_sprite_colorkey *key = &plane_state- > >ckey; >   u32 surf_addr = plane_state->main.offset; > @@ -232,7 +234,7 @@ skl_update_plane(struct drm_plane *drm_plane, >   plane_ctl |= skl_plane_ctl_rotation(rotation); >   >   if (wm->dirty_pipes & drm_crtc_mask(crtc)) > - skl_write_plane_wm(intel_crtc, wm, plane); > + skl_write_plane_wm(intel_crtc, p_wm, &wm->ddb, > plane); >   >   if (key->flags) { >   I915_WRITE(PLANE_KEYVAL(pipe, plane), key- > >min_value); > @@ -289,6 +291,7 @@ skl_disable_plane(struct drm_plane *dplane, > struct drm_crtc *crtc) >   struct drm_device *dev = dplane->dev; >   struct drm_i915_private *dev_priv = to_i915(dev); >   struct intel_plane *intel_plane = to_intel_plane(dplane); > + struct intel_crtc_state *cstate = to_intel_crtc_state(crtc- > >state); >   const int pipe = intel_plane->pipe; >   const int plane = intel_plane->plane + 1; >   > @@ -298,7 +301,8 @@ skl_disable_plane(struct drm_plane *dplane, > struct drm_crtc *crtc) >    */ >   if (!dplane->state->visible) >   skl_write_plane_wm(to_intel_crtc(crtc), > -    &dev_priv->wm.skl_results, > plane); > +    &cstate- > >wm.skl.optimal.planes[plane], > +    &dev_priv->wm.skl_results.ddb, > plane); >   >   I915_WRITE(PLANE_CTL(pipe, plane), 0); >