From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paulo Zanoni Subject: Re: [PATCH v2 03/10] drm/i915/gen9: Make skl_wm_level per-plane Date: Tue, 11 Oct 2016 16:36:56 -0300 Message-ID: <1476214616.2460.15.camel@intel.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> <1475885497-6094-4-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: <1475885497-6094-4-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 , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Daniel Vetter List-Id: dri-devel@lists.freedesktop.org RW0gU2V4LCAyMDE2LTEwLTA3IMOgcyAyMDoxMSAtMDQwMCwgTHl1ZGUgZXNjcmV2ZXU6Cj4gSGF2 aW5nIHNrbF93bV9sZXZlbCBjb250YWluIGFsbCBvZiB0aGUgd2F0ZXJtYXJrcyBmb3IgZWFjaCBw bGFuZSBpcwo+IGFubm95aW5nIHNpbmNlIGl0IHByZXZlbnRzIHVzIGZyb20gaGF2aW5nIGFueSBz b3J0IG9mIG9iamVjdCB0bwo+IHJlcHJlc2VudCBhIHNpbmdsZSB3YXRlcm1hcmsgbGV2ZWwsIHNv bWV0aGluZyB3ZSB0YWtlIGFkdmFudGFnZSBvZiBpbgo+IHRoZSBuZXh0IGNvbW1pdCB0byBjdXQg ZG93biBvbiBhbGwgb2YgdGhlIGNvcHkgcGFzdGUgY29kZSBpbiBoZXJlLgo+IAo+IENoYW5nZXMg c2luY2UgdjE6Cj4gLSBTdHlsZSBuaXRwaWNrcwo+IC0gRml4IGFjY2lkZW50YWwgdXNhZ2Ugb2Yg aSB2cy4gUExBTkVfQ1VSU09SCj4gLSBTcGxpdCBvdXQgc2tsX3BpcGVfd21fYWN0aXZlX3N0YXRl IHNpbXBsaWZpY2F0aW9uIGludG8gc2VwYXJhdGUKPiBwYXRjaAo+IAo+IFNpZ25lZC1vZmYtYnk6 IEx5dWRlIDxjcGF1bEByZWRoYXQuY29tPgoKUmV2aWV3ZWQtYnk6IFBhdWxvIFphbm9uaSA8cGF1 bG8uci56YW5vbmlAaW50ZWwuY29tPgoKPiBSZXZpZXdlZC1ieTogTWFhcnRlbiBMYW5raG9yc3Qg PG1hYXJ0ZW4ubGFua2hvcnN0QGxpbnV4LmludGVsLmNvbT4KPiBDYzogVmlsbGUgU3lyasOkbMOk IDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiBDYzogUGF1bG8gWmFub25pIDxwYXVs by5yLnphbm9uaUBpbnRlbC5jb20+Cj4gLS0tCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X2Rydi5owqDCoHzCoMKgwqA2ICstCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYu aCB8wqDCoMKgNiArLQo+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uY8KgwqB8IDIw NyArKysrKysrKysrKysrKysrKysrLS0tLS0tLS0KPiAtLS0tLS0tLS0tLS0KPiDCoDMgZmlsZXMg Y2hhbmdlZCwgMTExIGluc2VydGlvbnMoKyksIDEwOCBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAo+IGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV9kcnYuaAo+IGluZGV4IGU5ZDAzNWVhLi4wMjg3YzkzIDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2Rydi5oCj4gQEAgLTE2NDksOSArMTY0OSw5IEBAIHN0cnVjdCBza2xfd21fdmFs dWVzIHsKPiDCoH07Cj4gwqAKPiDCoHN0cnVjdCBza2xfd21fbGV2ZWwgewo+IC0JYm9vbCBwbGFu ZV9lbltJOTE1X01BWF9QTEFORVNdOwo+IC0JdWludDE2X3QgcGxhbmVfcmVzX2JbSTkxNV9NQVhf UExBTkVTXTsKPiAtCXVpbnQ4X3QgcGxhbmVfcmVzX2xbSTkxNV9NQVhfUExBTkVTXTsKPiArCWJv b2wgcGxhbmVfZW47Cj4gKwl1aW50MTZfdCBwbGFuZV9yZXNfYjsKPiArCXVpbnQ4X3QgcGxhbmVf cmVzX2w7Cj4gwqB9Owo+IMKgCj4gwqAvKgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcnYuaAo+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiBp bmRleCAzNWJhMjgyLi5kNjg0ZjRmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiBA QCAtNDY4LDkgKzQ2OCwxMyBAQCBzdHJ1Y3QgaW50ZWxfcGlwZV93bSB7Cj4gwqAJYm9vbCBzcHJp dGVzX3NjYWxlZDsKPiDCoH07Cj4gwqAKPiAtc3RydWN0IHNrbF9waXBlX3dtIHsKPiArc3RydWN0 IHNrbF9wbGFuZV93bSB7Cj4gwqAJc3RydWN0IHNrbF93bV9sZXZlbCB3bVs4XTsKPiDCoAlzdHJ1 Y3Qgc2tsX3dtX2xldmVsIHRyYW5zX3dtOwo+ICt9Owo+ICsKPiArc3RydWN0IHNrbF9waXBlX3dt IHsKPiArCXN0cnVjdCBza2xfcGxhbmVfd20gcGxhbmVzW0k5MTVfTUFYX1BMQU5FU107Cj4gwqAJ dWludDMyX3QgbGluZXRpbWU7Cj4gwqB9Owo+IMKgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX3BtLmMKPiBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMK PiBpbmRleCBjYzVkNWU5Li40YzJlYmNkIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX3BtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCj4g QEAgLTM2NzAsNjcgKzM2NzAsNTIgQEAgc3RhdGljIGludAo+IMKgc2tsX2NvbXB1dGVfd21fbGV2 ZWwoY29uc3Qgc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAo+IMKgCQnCoMKgwqDC oMKgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqZGRiLAo+IMKgCQnCoMKgwqDCoMKgc3RydWN0 IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZSwKPiArCQnCoMKgwqDCoMKgc3RydWN0IGludGVsX3Bs YW5lICppbnRlbF9wbGFuZSwKPiDCoAkJwqDCoMKgwqDCoGludCBsZXZlbCwKPiDCoAkJwqDCoMKg wqDCoHN0cnVjdCBza2xfd21fbGV2ZWwgKnJlc3VsdCkKPiDCoHsKPiDCoAlzdHJ1Y3QgZHJtX2F0 b21pY19zdGF0ZSAqc3RhdGUgPSBjc3RhdGUtPmJhc2Uuc3RhdGU7Cj4gwqAJc3RydWN0IGludGVs X2NydGMgKmludGVsX2NydGMgPSB0b19pbnRlbF9jcnRjKGNzdGF0ZS0KPiA+YmFzZS5jcnRjKTsK PiAtCXN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lOwo+IC0Jc3RydWN0IGludGVsX3BsYW5lICppbnRl bF9wbGFuZTsKPiAtCXN0cnVjdCBpbnRlbF9wbGFuZV9zdGF0ZSAqaW50ZWxfcHN0YXRlOwo+ICsJ c3RydWN0IGRybV9wbGFuZSAqcGxhbmUgPSAmaW50ZWxfcGxhbmUtPmJhc2U7Cj4gKwlzdHJ1Y3Qg aW50ZWxfcGxhbmVfc3RhdGUgKmludGVsX3BzdGF0ZSA9IE5VTEw7Cj4gwqAJdWludDE2X3QgZGRi X2Jsb2NrczsKPiDCoAllbnVtIHBpcGUgcGlwZSA9IGludGVsX2NydGMtPnBpcGU7Cj4gwqAJaW50 IHJldDsKPiArCWludCBpID0gc2tsX3dtX3BsYW5lX2lkKGludGVsX3BsYW5lKTsKPiArCj4gKwlp ZiAoc3RhdGUpCj4gKwkJaW50ZWxfcHN0YXRlID0KPiArCQkJaW50ZWxfYXRvbWljX2dldF9leGlz dGluZ19wbGFuZV9zdGF0ZShzdGF0ZSwKPiArCQkJCQkJCcKgwqDCoMKgwqDCoGludGVsXwo+IHBs YW5lKTsKPiDCoAo+IMKgCS8qCj4gLQnCoCogV2UnbGwgb25seSBjYWxjdWxhdGUgd2F0ZXJtYXJr cyBmb3IgcGxhbmVzIHRoYXQgYXJlCj4gYWN0dWFsbHkKPiAtCcKgKiBlbmFibGVkLCBzbyBtYWtl IHN1cmUgYWxsIG90aGVyIHBsYW5lcyBhcmUgc2V0IGFzCj4gZGlzYWJsZWQuCj4gKwnCoCogTm90 ZTogSWYgd2Ugc3RhcnQgc3VwcG9ydGluZyBtdWx0aXBsZSBwZW5kaW5nIGF0b21pYwo+IGNvbW1p dHMgYWdhaW5zdAo+ICsJwqAqIHRoZSBzYW1lIHBsYW5lcy9DUlRDJ3MgaW4gdGhlIGZ1dHVyZSwg cGxhbmUtPnN0YXRlIHdpbGwKPiBubyBsb25nZXIgYmUKPiArCcKgKiB0aGUgY29ycmVjdCBwcmUt c3RhdGUgdG8gdXNlIGZvciB0aGUgY2FsY3VsYXRpb25zIGhlcmUKPiBhbmQgd2UnbGwKPiArCcKg KiBuZWVkIHRvIGNoYW5nZSB3aGVyZSB3ZSBnZXQgdGhlICd1bmNoYW5nZWQnIHBsYW5lIGRhdGEK PiBmcm9tLgo+ICsJwqAqCj4gKwnCoCogRm9yIG5vdyB0aGlzIGlzIGZpbmUgYmVjYXVzZSB3ZSBv bmx5IGFsbG93IG9uZSBxdWV1ZWQKPiBjb21taXQgYWdhaW5zdAo+ICsJwqAqIGEgQ1JUQy7CoMKg RXZlbiBpZiB0aGUgcGxhbmUgaXNuJ3QgbW9kaWZpZWQgYnkgdGhpcwo+IHRyYW5zYWN0aW9uIGFu ZCB3ZQo+ICsJwqAqIGRvbid0IGhhdmUgYSBwbGFuZSBsb2NrLCB3ZSBzdGlsbCBoYXZlIHRoZSBD UlRDJ3MgbG9jaywKPiBzbyB3ZSBrbm93Cj4gKwnCoCogdGhhdCBubyBvdGhlciB0cmFuc2FjdGlv bnMgYXJlIHJhY2luZyB3aXRoIHVzIHRvIHVwZGF0ZQo+IGl0Lgo+IMKgCcKgKi8KPiAtCW1lbXNl dChyZXN1bHQsIDAsIHNpemVvZigqcmVzdWx0KSk7Cj4gKwlpZiAoIWludGVsX3BzdGF0ZSkKPiAr CQlpbnRlbF9wc3RhdGUgPSB0b19pbnRlbF9wbGFuZV9zdGF0ZShwbGFuZS0+c3RhdGUpOwo+IMKg Cj4gLQlmb3JfZWFjaF9pbnRlbF9wbGFuZV9tYXNrKCZkZXZfcHJpdi0+ZHJtLAo+IC0JCQkJwqDC oGludGVsX3BsYW5lLAo+IC0JCQkJwqDCoGNzdGF0ZS0+YmFzZS5wbGFuZV9tYXNrKSB7Cj4gLQkJ aW50IGkgPSBza2xfd21fcGxhbmVfaWQoaW50ZWxfcGxhbmUpOwo+IC0KPiAtCQlwbGFuZSA9ICZp bnRlbF9wbGFuZS0+YmFzZTsKPiAtCQlpbnRlbF9wc3RhdGUgPSBOVUxMOwo+IC0JCWlmIChzdGF0 ZSkKPiAtCQkJaW50ZWxfcHN0YXRlID0KPiAtCQkJCWludGVsX2F0b21pY19nZXRfZXhpc3Rpbmdf cGxhbmVfc3RhdAo+IGUoc3RhdGUsCj4gLQkJCQkJCQkJwqDCoMKgwqAKPiDCoMKgaW50ZWxfcGxh bmUpOwo+ICsJV0FSTl9PTighaW50ZWxfcHN0YXRlLT5iYXNlLmZiKTsKPiDCoAo+IC0JCS8qCj4g LQkJwqAqIE5vdGU6IElmIHdlIHN0YXJ0IHN1cHBvcnRpbmcgbXVsdGlwbGUgcGVuZGluZwo+IGF0 b21pYyBjb21taXRzCj4gLQkJwqAqIGFnYWluc3QgdGhlIHNhbWUgcGxhbmVzL0NSVEMncyBpbiB0 aGUgZnV0dXJlLAo+IHBsYW5lLT5zdGF0ZQo+IC0JCcKgKiB3aWxsIG5vIGxvbmdlciBiZSB0aGUg Y29ycmVjdCBwcmUtc3RhdGUgdG8gdXNlCj4gZm9yIHRoZQo+IC0JCcKgKiBjYWxjdWxhdGlvbnMg aGVyZSBhbmQgd2UnbGwgbmVlZCB0byBjaGFuZ2Ugd2hlcmUKPiB3ZSBnZXQgdGhlCj4gLQkJwqAq ICd1bmNoYW5nZWQnIHBsYW5lIGRhdGEgZnJvbS4KPiAtCQnCoCoKPiAtCQnCoCogRm9yIG5vdyB0 aGlzIGlzIGZpbmUgYmVjYXVzZSB3ZSBvbmx5IGFsbG93IG9uZQo+IHF1ZXVlZCBjb21taXQKPiAt CQnCoCogYWdhaW5zdCBhIENSVEMuwqDCoEV2ZW4gaWYgdGhlIHBsYW5lIGlzbid0IG1vZGlmaWVk Cj4gYnkgdGhpcwo+IC0JCcKgKiB0cmFuc2FjdGlvbiBhbmQgd2UgZG9uJ3QgaGF2ZSBhIHBsYW5l IGxvY2ssIHdlCj4gc3RpbGwgaGF2ZQo+IC0JCcKgKiB0aGUgQ1JUQydzIGxvY2ssIHNvIHdlIGtu b3cgdGhhdCBubyBvdGhlcgo+IHRyYW5zYWN0aW9ucyBhcmUKPiAtCQnCoCogcmFjaW5nIHdpdGgg dXMgdG8gdXBkYXRlIGl0Lgo+IC0JCcKgKi8KPiAtCQlpZiAoIWludGVsX3BzdGF0ZSkKPiAtCQkJ aW50ZWxfcHN0YXRlID0gdG9faW50ZWxfcGxhbmVfc3RhdGUocGxhbmUtCj4gPnN0YXRlKTsKPiAr CWRkYl9ibG9ja3MgPSBza2xfZGRiX2VudHJ5X3NpemUoJmRkYi0+cGxhbmVbcGlwZV1baV0pOwo+ IMKgCj4gLQkJV0FSTl9PTighaW50ZWxfcHN0YXRlLT5iYXNlLmZiKTsKPiAtCj4gLQkJZGRiX2Js b2NrcyA9IHNrbF9kZGJfZW50cnlfc2l6ZSgmZGRiLQo+ID5wbGFuZVtwaXBlXVtpXSk7Cj4gLQo+ IC0JCXJldCA9IHNrbF9jb21wdXRlX3BsYW5lX3dtKGRldl9wcml2LAo+IC0JCQkJCcKgwqDCoGNz dGF0ZSwKPiAtCQkJCQnCoMKgwqBpbnRlbF9wc3RhdGUsCj4gLQkJCQkJwqDCoMKgZGRiX2Jsb2Nr cywKPiAtCQkJCQnCoMKgwqBsZXZlbCwKPiAtCQkJCQnCoMKgwqAmcmVzdWx0LT5wbGFuZV9yZXNf YltpXSwKPiAtCQkJCQnCoMKgwqAmcmVzdWx0LT5wbGFuZV9yZXNfbFtpXSwKPiAtCQkJCQnCoMKg wqAmcmVzdWx0LT5wbGFuZV9lbltpXSk7Cj4gLQkJaWYgKHJldCkKPiAtCQkJcmV0dXJuIHJldDsK PiAtCX0KPiArCXJldCA9IHNrbF9jb21wdXRlX3BsYW5lX3dtKGRldl9wcml2LAo+ICsJCQkJwqDC oMKgY3N0YXRlLAo+ICsJCQkJwqDCoMKgaW50ZWxfcHN0YXRlLAo+ICsJCQkJwqDCoMKgZGRiX2Js b2NrcywKPiArCQkJCcKgwqDCoGxldmVsLAo+ICsJCQkJwqDCoMKgJnJlc3VsdC0+cGxhbmVfcmVz X2IsCj4gKwkJCQnCoMKgwqAmcmVzdWx0LT5wbGFuZV9yZXNfbCwKPiArCQkJCcKgwqDCoCZyZXN1 bHQtPnBsYW5lX2VuKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiDCoAo+IMKgCXJl dHVybiAwOwo+IMKgfQo+IEBAIC0zNzUxLDE5ICszNzM2LDExIEBAIHNrbF9jb21wdXRlX2xpbmV0 aW1lX3dtKHN0cnVjdAo+IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZSkKPiDCoHN0YXRpYyB2b2lk IHNrbF9jb21wdXRlX3RyYW5zaXRpb25fd20oc3RydWN0IGludGVsX2NydGNfc3RhdGUKPiAqY3N0 YXRlLAo+IMKgCQkJCcKgwqDCoMKgwqDCoHN0cnVjdCBza2xfd21fbGV2ZWwgKnRyYW5zX3dtCj4g Lyogb3V0ICovKQo+IMKgewo+IC0Jc3RydWN0IGRybV9jcnRjICpjcnRjID0gY3N0YXRlLT5iYXNl LmNydGM7Cj4gLQlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YyA9IHRvX2ludGVsX2NydGMo Y3J0Yyk7Cj4gLQlzdHJ1Y3QgaW50ZWxfcGxhbmUgKmludGVsX3BsYW5lOwo+IC0KPiDCoAlpZiAo IWNzdGF0ZS0+YmFzZS5hY3RpdmUpCj4gwqAJCXJldHVybjsKPiDCoAo+IMKgCS8qIFVudGlsIHdl IGtub3cgbW9yZSwganVzdCBkaXNhYmxlIHRyYW5zaXRpb24gV01zICovCj4gLQlmb3JfZWFjaF9p bnRlbF9wbGFuZV9vbl9jcnRjKGNydGMtPmRldiwgaW50ZWxfY3J0YywKPiBpbnRlbF9wbGFuZSkg ewo+IC0JCWludCBpID0gc2tsX3dtX3BsYW5lX2lkKGludGVsX3BsYW5lKTsKPiAtCj4gLQkJdHJh bnNfd20tPnBsYW5lX2VuW2ldID0gZmFsc2U7Cj4gLQl9Cj4gKwl0cmFuc193bS0+cGxhbmVfZW4g PSBmYWxzZTsKPiDCoH0KPiDCoAo+IMKgc3RhdGljIGludCBza2xfYnVpbGRfcGlwZV93bShzdHJ1 Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3N0YXRlLAo+IEBAIC0zNzcyLDE5ICszNzQ5LDMzIEBAIHN0 YXRpYyBpbnQgc2tsX2J1aWxkX3BpcGVfd20oc3RydWN0Cj4gaW50ZWxfY3J0Y19zdGF0ZSAqY3N0 YXRlLAo+IMKgewo+IMKgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjc3RhdGUtPmJhc2UuY3J0 Yy0+ZGV2Owo+IMKgCWNvbnN0IHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRv X2k5MTUoZGV2KTsKPiArCXN0cnVjdCBpbnRlbF9wbGFuZSAqaW50ZWxfcGxhbmU7Cj4gKwlzdHJ1 Y3Qgc2tsX3BsYW5lX3dtICp3bTsKPiDCoAlpbnQgbGV2ZWwsIG1heF9sZXZlbCA9IGlsa193bV9t YXhfbGV2ZWwoZGV2KTsKPiDCoAlpbnQgcmV0Owo+IMKgCj4gLQlmb3IgKGxldmVsID0gMDsgbGV2 ZWwgPD0gbWF4X2xldmVsOyBsZXZlbCsrKSB7Cj4gLQkJcmV0ID0gc2tsX2NvbXB1dGVfd21fbGV2 ZWwoZGV2X3ByaXYsIGRkYiwgY3N0YXRlLAo+IC0JCQkJCcKgwqDCoGxldmVsLCAmcGlwZV93bS0K PiA+d21bbGV2ZWxdKTsKPiAtCQlpZiAocmV0KQo+IC0JCQlyZXR1cm4gcmV0Owo+ICsJLyoKPiAr CcKgKiBXZSdsbCBvbmx5IGNhbGN1bGF0ZSB3YXRlcm1hcmtzIGZvciBwbGFuZXMgdGhhdCBhcmUK PiBhY3R1YWxseQo+ICsJwqAqIGVuYWJsZWQsIHNvIG1ha2Ugc3VyZSBhbGwgb3RoZXIgcGxhbmVz IGFyZSBzZXQgYXMKPiBkaXNhYmxlZC4KPiArCcKgKi8KPiArCW1lbXNldChwaXBlX3dtLT5wbGFu ZXMsIDAsIHNpemVvZihwaXBlX3dtLT5wbGFuZXMpKTsKPiArCj4gKwlmb3JfZWFjaF9pbnRlbF9w bGFuZV9tYXNrKCZkZXZfcHJpdi0+ZHJtLAo+ICsJCQkJwqDCoGludGVsX3BsYW5lLAo+ICsJCQkJ wqDCoGNzdGF0ZS0+YmFzZS5wbGFuZV9tYXNrKSB7Cj4gKwkJd20gPSAmcGlwZV93bS0+cGxhbmVz W3NrbF93bV9wbGFuZV9pZChpbnRlbF9wbGFuZSldOwo+ICsKPiArCQlmb3IgKGxldmVsID0gMDsg bGV2ZWwgPD0gbWF4X2xldmVsOyBsZXZlbCsrKSB7Cj4gKwkJCXJldCA9IHNrbF9jb21wdXRlX3dt X2xldmVsKGRldl9wcml2LCBkZGIsCj4gY3N0YXRlLAo+ICsJCQkJCQnCoMKgwqBpbnRlbF9wbGFu ZSwKPiBsZXZlbCwKPiArCQkJCQkJwqDCoMKgJndtLT53bVtsZXZlbF0pOwo+ICsJCQlpZiAocmV0 KQo+ICsJCQkJcmV0dXJuIHJldDsKPiArCQl9Cj4gKwkJc2tsX2NvbXB1dGVfdHJhbnNpdGlvbl93 bShjc3RhdGUsICZ3bS0+dHJhbnNfd20pOwo+IMKgCX0KPiDCoAlwaXBlX3dtLT5saW5ldGltZSA9 IHNrbF9jb21wdXRlX2xpbmV0aW1lX3dtKGNzdGF0ZSk7Cj4gwqAKPiAtCXNrbF9jb21wdXRlX3Ry YW5zaXRpb25fd20oY3N0YXRlLCAmcGlwZV93bS0+dHJhbnNfd20pOwo+IC0KPiDCoAlyZXR1cm4g MDsKPiDCoH0KPiDCoAo+IEBAIC0zNzk0LDUwICszNzg1LDU2IEBAIHN0YXRpYyB2b2lkIHNrbF9j b21wdXRlX3dtX3Jlc3VsdHMoc3RydWN0Cj4gZHJtX2RldmljZSAqZGV2LAo+IMKgCQkJCcKgwqDC oHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjKQo+IMKgewo+IMKgCWludCBsZXZlbCwgbWF4 X2xldmVsID0gaWxrX3dtX21heF9sZXZlbChkZXYpOwo+ICsJc3RydWN0IHNrbF9wbGFuZV93bSAq cGxhbmVfd207Cj4gwqAJZW51bSBwaXBlIHBpcGUgPSBpbnRlbF9jcnRjLT5waXBlOwo+IMKgCXVp bnQzMl90IHRlbXA7Cj4gwqAJaW50IGk7Cj4gwqAKPiAtCWZvciAobGV2ZWwgPSAwOyBsZXZlbCA8 PSBtYXhfbGV2ZWw7IGxldmVsKyspIHsKPiAtCQlmb3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3Bs YW5lcyhpbnRlbF9jcnRjKTsgaSsrKSB7Cj4gKwlmb3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3Bs YW5lcyhpbnRlbF9jcnRjKTsgaSsrKSB7Cj4gKwkJcGxhbmVfd20gPSAmcF93bS0+cGxhbmVzW2ld Owo+ICsKPiArCQlmb3IgKGxldmVsID0gMDsgbGV2ZWwgPD0gbWF4X2xldmVsOyBsZXZlbCsrKSB7 Cj4gwqAJCQl0ZW1wID0gMDsKPiDCoAo+IC0JCQl0ZW1wIHw9IHBfd20tPndtW2xldmVsXS5wbGFu ZV9yZXNfbFtpXSA8PAo+ICsJCQl0ZW1wIHw9IHBsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVz X2wgPDwKPiDCoAkJCQkJUExBTkVfV01fTElORVNfU0hJRlQ7Cj4gLQkJCXRlbXAgfD0gcF93bS0+ d21bbGV2ZWxdLnBsYW5lX3Jlc19iW2ldOwo+IC0JCQlpZiAocF93bS0+d21bbGV2ZWxdLnBsYW5l X2VuW2ldKQo+ICsJCQl0ZW1wIHw9IHBsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2I7Cj4g KwkJCWlmIChwbGFuZV93bS0+d21bbGV2ZWxdLnBsYW5lX2VuKQo+IMKgCQkJCXRlbXAgfD0gUExB TkVfV01fRU47Cj4gwqAKPiDCoAkJCXItPnBsYW5lW3BpcGVdW2ldW2xldmVsXSA9IHRlbXA7Cj4g wqAJCX0KPiDCoAo+IC0JCXRlbXAgPSAwOwo+IC0KPiAtCQl0ZW1wIHw9IHBfd20tPndtW2xldmVs XS5wbGFuZV9yZXNfbFtQTEFORV9DVVJTT1JdIDw8Cj4gUExBTkVfV01fTElORVNfU0hJRlQ7Cj4g LQkJdGVtcCB8PSBwX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2JbUExBTkVfQ1VSU09SXTsKPiAr CX0KPiDCoAo+IC0JCWlmIChwX3dtLT53bVtsZXZlbF0ucGxhbmVfZW5bUExBTkVfQ1VSU09SXSkK PiArCWZvciAobGV2ZWwgPSAwOyBsZXZlbCA8PSBtYXhfbGV2ZWw7IGxldmVsKyspIHsKPiArCQlw bGFuZV93bSA9ICZwX3dtLT5wbGFuZXNbUExBTkVfQ1VSU09SXTsKPiArCQl0ZW1wID0gMDsKPiAr CQl0ZW1wIHw9IHBsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2wgPDwKPiBQTEFORV9XTV9M SU5FU19TSElGVDsKPiArCQl0ZW1wIHw9IHBsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2I7 Cj4gKwkJaWYgKHBsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfZW4pCj4gwqAJCQl0ZW1wIHw9IFBM QU5FX1dNX0VOOwo+IMKgCj4gwqAJCXItPnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl1bbGV2ZWxd ID0gdGVtcDsKPiAtCj4gwqAJfQo+IMKgCj4gwqAJLyogdHJhbnNpdGlvbiBXTXMgKi8KPiDCoAlm b3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3BsYW5lcyhpbnRlbF9jcnRjKTsgaSsrKSB7Cj4gKwkJ cGxhbmVfd20gPSAmcF93bS0+cGxhbmVzW2ldOwo+IMKgCQl0ZW1wID0gMDsKPiAtCQl0ZW1wIHw9 IHBfd20tPnRyYW5zX3dtLnBsYW5lX3Jlc19sW2ldIDw8Cj4gUExBTkVfV01fTElORVNfU0hJRlQ7 Cj4gLQkJdGVtcCB8PSBwX3dtLT50cmFuc193bS5wbGFuZV9yZXNfYltpXTsKPiAtCQlpZiAocF93 bS0+dHJhbnNfd20ucGxhbmVfZW5baV0pCj4gKwkJdGVtcCB8PSBwbGFuZV93bS0+dHJhbnNfd20u cGxhbmVfcmVzX2wgPDwKPiBQTEFORV9XTV9MSU5FU19TSElGVDsKPiArCQl0ZW1wIHw9IHBsYW5l X3dtLT50cmFuc193bS5wbGFuZV9yZXNfYjsKPiArCQlpZiAocGxhbmVfd20tPnRyYW5zX3dtLnBs YW5lX2VuKQo+IMKgCQkJdGVtcCB8PSBQTEFORV9XTV9FTjsKPiDCoAo+IMKgCQlyLT5wbGFuZV90 cmFuc1twaXBlXVtpXSA9IHRlbXA7Cj4gwqAJfQo+IMKgCj4gKwlwbGFuZV93bSA9ICZwX3dtLT5w bGFuZXNbUExBTkVfQ1VSU09SXTsKPiDCoAl0ZW1wID0gMDsKPiAtCXRlbXAgfD0gcF93bS0+dHJh bnNfd20ucGxhbmVfcmVzX2xbUExBTkVfQ1VSU09SXSA8PAo+IFBMQU5FX1dNX0xJTkVTX1NISUZU Owo+IC0JdGVtcCB8PSBwX3dtLT50cmFuc193bS5wbGFuZV9yZXNfYltQTEFORV9DVVJTT1JdOwo+ IC0JaWYgKHBfd20tPnRyYW5zX3dtLnBsYW5lX2VuW1BMQU5FX0NVUlNPUl0pCj4gKwl0ZW1wIHw9 IHBsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfbCA8PAo+IFBMQU5FX1dNX0xJTkVTX1NISUZU Owo+ICsJdGVtcCB8PSBwbGFuZV93bS0+dHJhbnNfd20ucGxhbmVfcmVzX2I7Cj4gKwlpZiAocGxh bmVfd20tPnRyYW5zX3dtLnBsYW5lX2VuKQo+IMKgCQl0ZW1wIHw9IFBMQU5FX1dNX0VOOwo+IMKg Cj4gwqAJci0+cGxhbmVfdHJhbnNbcGlwZV1bUExBTkVfQ1VSU09SXSA9IHRlbXA7Cj4gQEAgLTQy NzgsMzUgKzQyNzUsMzcgQEAgc3RhdGljIHZvaWQgc2tsX3BpcGVfd21fYWN0aXZlX3N0YXRlKHVp bnQzMl90Cj4gdmFsLAo+IMKgCj4gwqAJaWYgKCFpc190cmFuc3dtKSB7Cj4gwqAJCWlmICghaXNf Y3Vyc29yKSB7Cj4gLQkJCWFjdGl2ZS0+d21bbGV2ZWxdLnBsYW5lX2VuW2ldID0gaXNfZW5hYmxl ZDsKPiAtCQkJYWN0aXZlLT53bVtsZXZlbF0ucGxhbmVfcmVzX2JbaV0gPQo+IC0JCQkJCXZhbCAm IFBMQU5FX1dNX0JMT0NLU19NQVNLOwo+IC0JCQlhY3RpdmUtPndtW2xldmVsXS5wbGFuZV9yZXNf bFtpXSA9Cj4gLQkJCQkJKHZhbCA+Pgo+IFBMQU5FX1dNX0xJTkVTX1NISUZUKSAmCj4gLQkJCQkJ CVBMQU5FX1dNX0xJTkVTX01BU0s7Cj4gKwkJCWFjdGl2ZS0+cGxhbmVzW2ldLndtW2xldmVsXS5w bGFuZV9lbiA9Cj4gaXNfZW5hYmxlZDsKPiArCQkJYWN0aXZlLT5wbGFuZXNbaV0ud21bbGV2ZWxd LnBsYW5lX3Jlc19iID0KPiArCQkJCXZhbCAmIFBMQU5FX1dNX0JMT0NLU19NQVNLOwo+ICsJCQlh Y3RpdmUtPnBsYW5lc1tpXS53bVtsZXZlbF0ucGxhbmVfcmVzX2wgPQo+ICsJCQkJKHZhbCA+PiBQ TEFORV9XTV9MSU5FU19TSElGVCkgJgo+ICsJCQkJUExBTkVfV01fTElORVNfTUFTSzsKPiDCoAkJ fSBlbHNlIHsKPiAtCQkJYWN0aXZlLT53bVtsZXZlbF0ucGxhbmVfZW5bUExBTkVfQ1VSU09SXSA9 Cj4gaXNfZW5hYmxlZDsKPiAtCQkJYWN0aXZlLT53bVtsZXZlbF0ucGxhbmVfcmVzX2JbUExBTkVf Q1VSU09SXQo+ID0KPiAtCQkJCQl2YWwgJiBQTEFORV9XTV9CTE9DS1NfTUFTSzsKPiAtCQkJYWN0 aXZlLT53bVtsZXZlbF0ucGxhbmVfcmVzX2xbUExBTkVfQ1VSU09SXQo+ID0KPiAtCQkJCQkodmFs ID4+Cj4gUExBTkVfV01fTElORVNfU0hJRlQpICYKPiAtCQkJCQkJUExBTkVfV01fTElORVNfTUFT SzsKPiArCQkJYWN0aXZlLQo+ID5wbGFuZXNbUExBTkVfQ1VSU09SXS53bVtsZXZlbF0ucGxhbmVf ZW4gPQo+ICsJCQkJaXNfZW5hYmxlZDsKPiArCQkJYWN0aXZlLQo+ID5wbGFuZXNbUExBTkVfQ1VS U09SXS53bVtsZXZlbF0ucGxhbmVfcmVzX2IgPQo+ICsJCQkJdmFsICYgUExBTkVfV01fQkxPQ0tT X01BU0s7Cj4gKwkJCWFjdGl2ZS0KPiA+cGxhbmVzW1BMQU5FX0NVUlNPUl0ud21bbGV2ZWxdLnBs YW5lX3Jlc19sID0KPiArCQkJCSh2YWwgPj4gUExBTkVfV01fTElORVNfU0hJRlQpICYKPiArCQkJ CVBMQU5FX1dNX0xJTkVTX01BU0s7Cj4gwqAJCX0KPiDCoAl9IGVsc2Ugewo+IMKgCQlpZiAoIWlz X2N1cnNvcikgewo+IC0JCQlhY3RpdmUtPnRyYW5zX3dtLnBsYW5lX2VuW2ldID0gaXNfZW5hYmxl ZDsKPiAtCQkJYWN0aXZlLT50cmFuc193bS5wbGFuZV9yZXNfYltpXSA9Cj4gLQkJCQkJdmFsICYg UExBTkVfV01fQkxPQ0tTX01BU0s7Cj4gLQkJCWFjdGl2ZS0+dHJhbnNfd20ucGxhbmVfcmVzX2xb aV0gPQo+IC0JCQkJCSh2YWwgPj4KPiBQTEFORV9XTV9MSU5FU19TSElGVCkgJgo+IC0JCQkJCQlQ TEFORV9XTV9MSU5FU19NQVNLOwo+ICsJCQlhY3RpdmUtPnBsYW5lc1tpXS50cmFuc193bS5wbGFu ZV9lbiA9Cj4gaXNfZW5hYmxlZDsKPiArCQkJYWN0aXZlLT5wbGFuZXNbaV0udHJhbnNfd20ucGxh bmVfcmVzX2IgPQo+ICsJCQkJdmFsICYgUExBTkVfV01fQkxPQ0tTX01BU0s7Cj4gKwkJCWFjdGl2 ZS0+cGxhbmVzW2ldLnRyYW5zX3dtLnBsYW5lX3Jlc19sID0KPiArCQkJCSh2YWwgPj4gUExBTkVf V01fTElORVNfU0hJRlQpICYKPiArCQkJCVBMQU5FX1dNX0xJTkVTX01BU0s7Cj4gwqAJCX0gZWxz ZSB7Cj4gLQkJCWFjdGl2ZS0+dHJhbnNfd20ucGxhbmVfZW5bUExBTkVfQ1VSU09SXSA9Cj4gaXNf ZW5hYmxlZDsKPiAtCQkJYWN0aXZlLT50cmFuc193bS5wbGFuZV9yZXNfYltQTEFORV9DVVJTT1Jd ID0KPiAtCQkJCQl2YWwgJiBQTEFORV9XTV9CTE9DS1NfTUFTSzsKPiAtCQkJYWN0aXZlLT50cmFu c193bS5wbGFuZV9yZXNfbFtQTEFORV9DVVJTT1JdID0KPiAtCQkJCQkodmFsID4+Cj4gUExBTkVf V01fTElORVNfU0hJRlQpICYKPiAtCQkJCQkJUExBTkVfV01fTElORVNfTUFTSzsKPiArCQkJYWN0 aXZlLQo+ID5wbGFuZXNbUExBTkVfQ1VSU09SXS50cmFuc193bS5wbGFuZV9lbiA9Cj4gKwkJCQlp c19lbmFibGVkOwo+ICsJCQlhY3RpdmUtCj4gPnBsYW5lc1tQTEFORV9DVVJTT1JdLnRyYW5zX3dt LnBsYW5lX3Jlc19iID0KPiArCQkJCXZhbCAmIFBMQU5FX1dNX0JMT0NLU19NQVNLOwo+ICsJCQlh Y3RpdmUtCj4gPnBsYW5lc1tQTEFORV9DVVJTT1JdLnRyYW5zX3dtLnBsYW5lX3Jlc19sID0KPiAr CQkJCSh2YWwgPj4gUExBTkVfV01fTElORVNfU0hJRlQpICYKPiArCQkJCVBMQU5FX1dNX0xJTkVT X01BU0s7Cj4gwqAJCX0KPiDCoAl9Cj4gwqB9Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f 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 S1752409AbcJKThF (ORCPT ); Tue, 11 Oct 2016 15:37:05 -0400 Received: from mga05.intel.com ([192.55.52.43]:60594 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752319AbcJKThD (ORCPT ); Tue, 11 Oct 2016 15:37:03 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.31,330,1473145200"; d="scan'208";a="19026530" Message-ID: <1476214616.2460.15.camel@intel.com> Subject: Re: [PATCH v2 03/10] drm/i915/gen9: Make skl_wm_level per-plane From: Paulo Zanoni To: Lyude , intel-gfx@lists.freedesktop.org Cc: Ville =?ISO-8859-1?Q?Syrj=E4l=E4?= , Daniel Vetter , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Date: Tue, 11 Oct 2016 16:36:56 -0300 In-Reply-To: <1475885497-6094-4-git-send-email-cpaul@redhat.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> <1475885497-6094-4-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 Sex, 2016-10-07 às 20:11 -0400, Lyude escreveu: > Having skl_wm_level contain all of the watermarks for each plane is > annoying since it prevents us from having any sort of object to > represent a single watermark level, something we take advantage of in > the next commit to cut down on all of the copy paste code in here. > > Changes since v1: > - Style nitpicks > - Fix accidental usage of i vs. PLANE_CURSOR > - Split out skl_pipe_wm_active_state simplification into separate > patch > > Signed-off-by: Lyude Reviewed-by: Paulo Zanoni > Reviewed-by: Maarten Lankhorst > Cc: Ville Syrjälä > Cc: Paulo Zanoni > --- >  drivers/gpu/drm/i915/i915_drv.h  |   6 +- >  drivers/gpu/drm/i915/intel_drv.h |   6 +- >  drivers/gpu/drm/i915/intel_pm.c  | 207 +++++++++++++++++++-------- > ------------ >  3 files changed, 111 insertions(+), 108 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.h > b/drivers/gpu/drm/i915/i915_drv.h > index e9d035ea..0287c93 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -1649,9 +1649,9 @@ struct skl_wm_values { >  }; >   >  struct skl_wm_level { > - bool plane_en[I915_MAX_PLANES]; > - uint16_t plane_res_b[I915_MAX_PLANES]; > - uint8_t plane_res_l[I915_MAX_PLANES]; > + bool plane_en; > + uint16_t plane_res_b; > + uint8_t plane_res_l; >  }; >   >  /* > diff --git a/drivers/gpu/drm/i915/intel_drv.h > b/drivers/gpu/drm/i915/intel_drv.h > index 35ba282..d684f4f 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -468,9 +468,13 @@ struct intel_pipe_wm { >   bool sprites_scaled; >  }; >   > -struct skl_pipe_wm { > +struct skl_plane_wm { >   struct skl_wm_level wm[8]; >   struct skl_wm_level trans_wm; > +}; > + > +struct skl_pipe_wm { > + struct skl_plane_wm planes[I915_MAX_PLANES]; >   uint32_t linetime; >  }; >   > diff --git a/drivers/gpu/drm/i915/intel_pm.c > b/drivers/gpu/drm/i915/intel_pm.c > index cc5d5e9..4c2ebcd 100644 > --- a/drivers/gpu/drm/i915/intel_pm.c > +++ b/drivers/gpu/drm/i915/intel_pm.c > @@ -3670,67 +3670,52 @@ static int >  skl_compute_wm_level(const struct drm_i915_private *dev_priv, >        struct skl_ddb_allocation *ddb, >        struct intel_crtc_state *cstate, > +      struct intel_plane *intel_plane, >        int level, >        struct skl_wm_level *result) >  { >   struct drm_atomic_state *state = cstate->base.state; >   struct intel_crtc *intel_crtc = to_intel_crtc(cstate- > >base.crtc); > - struct drm_plane *plane; > - struct intel_plane *intel_plane; > - struct intel_plane_state *intel_pstate; > + struct drm_plane *plane = &intel_plane->base; > + struct intel_plane_state *intel_pstate = NULL; >   uint16_t ddb_blocks; >   enum pipe pipe = intel_crtc->pipe; >   int ret; > + int i = skl_wm_plane_id(intel_plane); > + > + if (state) > + intel_pstate = > + intel_atomic_get_existing_plane_state(state, > +       intel_ > plane); >   >   /* > -  * We'll only calculate watermarks for planes that are > actually > -  * enabled, so make sure all other planes are set as > disabled. > +  * Note: If we start supporting multiple pending atomic > commits against > +  * the same planes/CRTC's in the future, plane->state will > no longer be > +  * the correct pre-state to use for the calculations here > and we'll > +  * need to change where we get the 'unchanged' plane data > from. > +  * > +  * For now this is fine because we only allow one queued > commit against > +  * a CRTC.  Even if the plane isn't modified by this > transaction and we > +  * don't have a plane lock, we still have the CRTC's lock, > so we know > +  * that no other transactions are racing with us to update > it. >    */ > - memset(result, 0, sizeof(*result)); > + if (!intel_pstate) > + intel_pstate = to_intel_plane_state(plane->state); >   > - for_each_intel_plane_mask(&dev_priv->drm, > -   intel_plane, > -   cstate->base.plane_mask) { > - int i = skl_wm_plane_id(intel_plane); > - > - plane = &intel_plane->base; > - intel_pstate = NULL; > - if (state) > - intel_pstate = > - intel_atomic_get_existing_plane_stat > e(state, > -      >   intel_plane); > + WARN_ON(!intel_pstate->base.fb); >   > - /* > -  * Note: If we start supporting multiple pending > atomic commits > -  * against the same planes/CRTC's in the future, > plane->state > -  * will no longer be the correct pre-state to use > for the > -  * calculations here and we'll need to change where > we get the > -  * 'unchanged' plane data from. > -  * > -  * For now this is fine because we only allow one > queued commit > -  * against a CRTC.  Even if the plane isn't modified > by this > -  * transaction and we don't have a plane lock, we > still have > -  * the CRTC's lock, so we know that no other > transactions are > -  * racing with us to update it. > -  */ > - if (!intel_pstate) > - intel_pstate = to_intel_plane_state(plane- > >state); > + ddb_blocks = skl_ddb_entry_size(&ddb->plane[pipe][i]); >   > - WARN_ON(!intel_pstate->base.fb); > - > - ddb_blocks = skl_ddb_entry_size(&ddb- > >plane[pipe][i]); > - > - ret = skl_compute_plane_wm(dev_priv, > -    cstate, > -    intel_pstate, > -    ddb_blocks, > -    level, > -    &result->plane_res_b[i], > -    &result->plane_res_l[i], > -    &result->plane_en[i]); > - if (ret) > - return ret; > - } > + ret = skl_compute_plane_wm(dev_priv, > +    cstate, > +    intel_pstate, > +    ddb_blocks, > +    level, > +    &result->plane_res_b, > +    &result->plane_res_l, > +    &result->plane_en); > + if (ret) > + return ret; >   >   return 0; >  } > @@ -3751,19 +3736,11 @@ skl_compute_linetime_wm(struct > intel_crtc_state *cstate) >  static void skl_compute_transition_wm(struct intel_crtc_state > *cstate, >         struct skl_wm_level *trans_wm > /* out */) >  { > - struct drm_crtc *crtc = cstate->base.crtc; > - struct intel_crtc *intel_crtc = to_intel_crtc(crtc); > - struct intel_plane *intel_plane; > - >   if (!cstate->base.active) >   return; >   >   /* Until we know more, just disable transition WMs */ > - for_each_intel_plane_on_crtc(crtc->dev, intel_crtc, > intel_plane) { > - int i = skl_wm_plane_id(intel_plane); > - > - trans_wm->plane_en[i] = false; > - } > + trans_wm->plane_en = false; >  } >   >  static int skl_build_pipe_wm(struct intel_crtc_state *cstate, > @@ -3772,19 +3749,33 @@ static int skl_build_pipe_wm(struct > intel_crtc_state *cstate, >  { >   struct drm_device *dev = cstate->base.crtc->dev; >   const struct drm_i915_private *dev_priv = to_i915(dev); > + struct intel_plane *intel_plane; > + struct skl_plane_wm *wm; >   int level, max_level = ilk_wm_max_level(dev); >   int ret; >   > - for (level = 0; level <= max_level; level++) { > - ret = skl_compute_wm_level(dev_priv, ddb, cstate, > -    level, &pipe_wm- > >wm[level]); > - if (ret) > - return ret; > + /* > +  * We'll only calculate watermarks for planes that are > actually > +  * enabled, so make sure all other planes are set as > disabled. > +  */ > + memset(pipe_wm->planes, 0, sizeof(pipe_wm->planes)); > + > + for_each_intel_plane_mask(&dev_priv->drm, > +   intel_plane, > +   cstate->base.plane_mask) { > + wm = &pipe_wm->planes[skl_wm_plane_id(intel_plane)]; > + > + for (level = 0; level <= max_level; level++) { > + ret = skl_compute_wm_level(dev_priv, ddb, > cstate, > +    intel_plane, > level, > +    &wm->wm[level]); > + if (ret) > + return ret; > + } > + skl_compute_transition_wm(cstate, &wm->trans_wm); >   } >   pipe_wm->linetime = skl_compute_linetime_wm(cstate); >   > - skl_compute_transition_wm(cstate, &pipe_wm->trans_wm); > - >   return 0; >  } >   > @@ -3794,50 +3785,56 @@ static void skl_compute_wm_results(struct > drm_device *dev, >      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 (level = 0; level <= max_level; level++) { > - for (i = 0; i < intel_num_planes(intel_crtc); 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 |= p_wm->wm[level].plane_res_l[i] << > + temp |= plane_wm->wm[level].plane_res_l << >   PLANE_WM_LINES_SHIFT; > - temp |= p_wm->wm[level].plane_res_b[i]; > - if (p_wm->wm[level].plane_en[i]) > + 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; >   } >   > - temp = 0; > - > - temp |= p_wm->wm[level].plane_res_l[PLANE_CURSOR] << > PLANE_WM_LINES_SHIFT; > - temp |= p_wm->wm[level].plane_res_b[PLANE_CURSOR]; > + } >   > - if (p_wm->wm[level].plane_en[PLANE_CURSOR]) > + 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 |= p_wm->trans_wm.plane_res_l[i] << > PLANE_WM_LINES_SHIFT; > - temp |= p_wm->trans_wm.plane_res_b[i]; > - if (p_wm->trans_wm.plane_en[i]) > + 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 |= p_wm->trans_wm.plane_res_l[PLANE_CURSOR] << > PLANE_WM_LINES_SHIFT; > - temp |= p_wm->trans_wm.plane_res_b[PLANE_CURSOR]; > - if (p_wm->trans_wm.plane_en[PLANE_CURSOR]) > + 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; > @@ -4278,35 +4275,37 @@ static void skl_pipe_wm_active_state(uint32_t > val, >   >   if (!is_transwm) { >   if (!is_cursor) { > - active->wm[level].plane_en[i] = is_enabled; > - active->wm[level].plane_res_b[i] = > - val & PLANE_WM_BLOCKS_MASK; > - active->wm[level].plane_res_l[i] = > - (val >> > PLANE_WM_LINES_SHIFT) & > - PLANE_WM_LINES_MASK; > + active->planes[i].wm[level].plane_en = > is_enabled; > + active->planes[i].wm[level].plane_res_b = > + val & PLANE_WM_BLOCKS_MASK; > + active->planes[i].wm[level].plane_res_l = > + (val >> PLANE_WM_LINES_SHIFT) & > + PLANE_WM_LINES_MASK; >   } else { > - active->wm[level].plane_en[PLANE_CURSOR] = > is_enabled; > - active->wm[level].plane_res_b[PLANE_CURSOR] > = > - val & PLANE_WM_BLOCKS_MASK; > - active->wm[level].plane_res_l[PLANE_CURSOR] > = > - (val >> > PLANE_WM_LINES_SHIFT) & > - PLANE_WM_LINES_MASK; > + active- > >planes[PLANE_CURSOR].wm[level].plane_en = > + is_enabled; > + active- > >planes[PLANE_CURSOR].wm[level].plane_res_b = > + val & PLANE_WM_BLOCKS_MASK; > + active- > >planes[PLANE_CURSOR].wm[level].plane_res_l = > + (val >> PLANE_WM_LINES_SHIFT) & > + PLANE_WM_LINES_MASK; >   } >   } else { >   if (!is_cursor) { > - active->trans_wm.plane_en[i] = is_enabled; > - active->trans_wm.plane_res_b[i] = > - val & PLANE_WM_BLOCKS_MASK; > - active->trans_wm.plane_res_l[i] = > - (val >> > PLANE_WM_LINES_SHIFT) & > - PLANE_WM_LINES_MASK; > + active->planes[i].trans_wm.plane_en = > is_enabled; > + active->planes[i].trans_wm.plane_res_b = > + val & PLANE_WM_BLOCKS_MASK; > + active->planes[i].trans_wm.plane_res_l = > + (val >> PLANE_WM_LINES_SHIFT) & > + PLANE_WM_LINES_MASK; >   } else { > - active->trans_wm.plane_en[PLANE_CURSOR] = > is_enabled; > - active->trans_wm.plane_res_b[PLANE_CURSOR] = > - val & PLANE_WM_BLOCKS_MASK; > - active->trans_wm.plane_res_l[PLANE_CURSOR] = > - (val >> > PLANE_WM_LINES_SHIFT) & > - PLANE_WM_LINES_MASK; > + active- > >planes[PLANE_CURSOR].trans_wm.plane_en = > + is_enabled; > + active- > >planes[PLANE_CURSOR].trans_wm.plane_res_b = > + val & PLANE_WM_BLOCKS_MASK; > + active- > >planes[PLANE_CURSOR].trans_wm.plane_res_l = > + (val >> PLANE_WM_LINES_SHIFT) & > + PLANE_WM_LINES_MASK; >   } >   } >  }