From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paulo Zanoni Subject: Re: [PATCH v2 01/10] drm/i915/skl: Move per-pipe ddb allocations into crtc states Date: Tue, 11 Oct 2016 16:36:12 -0300 Message-ID: <1476214572.2460.14.camel@intel.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> <1475885497-6094-2-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-2-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 RW0gU2V4LCAyMDE2LTEwLTA3IMOgcyAyMDoxMSAtMDQwMCwgTHl1ZGUgZXNjcmV2ZXU6Cj4gRmly c3QgcGFydCBvZiBjbGVhbmluZyB1cCBhbGwgb2YgdGhlIHNrbCB3YXRlcm1hcmsgY29kZS4gVGhp cyBtb3Zlcwo+IHRoZQo+IHN0cnVjdHVyZXMgZm9yIHN0b3JpbmcgdGhlIGRkYiBhbGxvY2F0aW9u cyBvZiBlYWNoIHBpcGUgaW50bwo+IGludGVsX2NydGNfc3RhdGUsIGFsb25nIHdpdGggbW92aW5n IHRoZSBzdHJ1Y3R1cmVzIGZvciBzdG9yaW5nIHRoZQo+IGN1cnJlbnQgZGRiIGFsbG9jYXRpb25z IGFjdGl2ZSBvbiBoYXJkd2FyZSBpbnRvIGludGVsX2NydGMuCj4gCj4gQ2hhbmdlcyBzaW5jZSB2 MToKPiAtIERvbid0IHJlcGxhY2UgYWxsb2MtPnN0YXJ0ID0gYWxsb2MtPmVuZCA9IDA7Cj4gCj4g U2lnbmVkLW9mZi1ieTogTHl1ZGUgPGNwYXVsQHJlZGhhdC5jb20+CgpSZXZpZXdlZC1ieTogUGF1 bG8gWmFub25pIDxwYXVsby5yLnphbm9uaUBpbnRlbC5jb20+Cgo+IFJldmlld2VkLWJ5OiBNYWFy dGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwuY29tPgo+IENjOiBW aWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgo+IENjOiBQYXVs byBaYW5vbmkgPHBhdWxvLnIuemFub25pQGludGVsLmNvbT4KPiAtLS0KPiDCoGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZHJ2LmjCoMKgwqDCoMKgwqB8wqDCoDEgLQo+IMKgZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIHwgMTYgKysrKysrKystLS0tLS0tCj4gwqBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaMKgwqDCoMKgwqB8wqDCoDggKysrKystLS0KPiDCoGRy aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmPCoMKgwqDCoMKgwqB8IDQwICsrKysrKysrKysr KysrKy0tLS0tLS0tLS0tCj4gLS0tLS0tLS0tLQo+IMKgNCBmaWxlcyBjaGFuZ2VkLCAzMCBpbnNl cnRpb25zKCspLCAzNSBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9kcnYuaAo+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAo+ IGluZGV4IGEyMTlhMzUuLmJiMmRlOGQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9kcnYuaAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiBA QCAtMTYzNyw3ICsxNjM3LDYgQEAgc3RhdGljIGlubGluZSBib29sIHNrbF9kZGJfZW50cnlfZXF1 YWwoY29uc3QKPiBzdHJ1Y3Qgc2tsX2RkYl9lbnRyeSAqZTEsCj4gwqB9Cj4gwqAKPiDCoHN0cnVj dCBza2xfZGRiX2FsbG9jYXRpb24gewo+IC0Jc3RydWN0IHNrbF9kZGJfZW50cnkgcGlwZVtJOTE1 X01BWF9QSVBFU107Cj4gwqAJc3RydWN0IHNrbF9kZGJfZW50cnkgcGxhbmVbSTkxNV9NQVhfUElQ RVNdW0k5MTVfTUFYX1BMQU5FU107Cj4gLyogcGFja2VkL3V2ICovCj4gwqAJc3RydWN0IHNrbF9k ZGJfZW50cnkKPiB5X3BsYW5lW0k5MTVfTUFYX1BJUEVTXVtJOTE1X01BWF9QTEFORVNdOwo+IMKg fTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4g Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiBpbmRleCBhMzY2NjU2Li4x NzczM2FmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXku Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IEBAIC0xNDIz NSwxMiArMTQyMzUsMTEgQEAgc3RhdGljIHZvaWQgc2tsX3VwZGF0ZV9jcnRjcyhzdHJ1Y3QKPiBk cm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKPiDCoAkJCcKgwqDCoMKgwqB1bnNpZ25lZCBpbnQgKmNy dGNfdmJsYW5rX21hc2spCj4gwqB7Cj4gwqAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IHN0YXRl LT5kZXY7Cj4gLQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGRl dik7Cj4gwqAJc3RydWN0IGludGVsX2F0b21pY19zdGF0ZSAqaW50ZWxfc3RhdGUgPQo+IHRvX2lu dGVsX2F0b21pY19zdGF0ZShzdGF0ZSk7Cj4gwqAJc3RydWN0IGRybV9jcnRjICpjcnRjOwo+ICsJ c3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGM7Cj4gwqAJc3RydWN0IGRybV9jcnRjX3N0YXRl ICpvbGRfY3J0Y19zdGF0ZTsKPiAtCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5ld19kZGIg PSAmaW50ZWxfc3RhdGUtCj4gPndtX3Jlc3VsdHMuZGRiOwo+IC0Jc3RydWN0IHNrbF9kZGJfYWxs b2NhdGlvbiAqY3VyX2RkYiA9ICZkZXZfcHJpdi0KPiA+d20uc2tsX2h3LmRkYjsKPiArCXN0cnVj dCBpbnRlbF9jcnRjX3N0YXRlICpjc3RhdGU7Cj4gwqAJdW5zaWduZWQgaW50IHVwZGF0ZWQgPSAw Owo+IMKgCWJvb2wgcHJvZ3Jlc3M7Cj4gwqAJZW51bSBwaXBlIHBpcGU7Cj4gQEAgLTE0MjU4LDEy ICsxNDI1NywxNCBAQCBzdGF0aWMgdm9pZCBza2xfdXBkYXRlX2NydGNzKHN0cnVjdAo+IGRybV9h dG9taWNfc3RhdGUgKnN0YXRlLAo+IMKgCQlmb3JfZWFjaF9jcnRjX2luX3N0YXRlKHN0YXRlLCBj cnRjLCBvbGRfY3J0Y19zdGF0ZSwKPiBpKSB7Cj4gwqAJCQlib29sIHZibF93YWl0ID0gZmFsc2U7 Cj4gwqAJCQl1bnNpZ25lZCBpbnQgY21hc2sgPSBkcm1fY3J0Y19tYXNrKGNydGMpOwo+IC0JCQlw aXBlID0gdG9faW50ZWxfY3J0YyhjcnRjKS0+cGlwZTsKPiArCj4gKwkJCWludGVsX2NydGMgPSB0 b19pbnRlbF9jcnRjKGNydGMpOwo+ICsJCQljc3RhdGUgPSB0b19pbnRlbF9jcnRjX3N0YXRlKGNy dGMtPnN0YXRlKTsKPiArCQkJcGlwZSA9IGludGVsX2NydGMtPnBpcGU7Cj4gwqAKPiDCoAkJCWlm ICh1cGRhdGVkICYgY21hc2sgfHwgIWNydGMtPnN0YXRlLT5hY3RpdmUpCj4gwqAJCQkJY29udGlu dWU7Cj4gLQkJCWlmIChza2xfZGRiX2FsbG9jYXRpb25fb3ZlcmxhcHMoc3RhdGUsCj4gY3VyX2Rk YiwgbmV3X2RkYiwKPiAtCQkJCQkJCXBpcGUpKQo+ICsJCQlpZiAoc2tsX2RkYl9hbGxvY2F0aW9u X292ZXJsYXBzKHN0YXRlLAo+IGludGVsX2NydGMpKQo+IMKgCQkJCWNvbnRpbnVlOwo+IMKgCj4g wqAJCQl1cGRhdGVkIHw9IGNtYXNrOwo+IEBAIC0xNDI3NCw3ICsxNDI3NSw4IEBAIHN0YXRpYyB2 b2lkIHNrbF91cGRhdGVfY3J0Y3Moc3RydWN0Cj4gZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCj4g wqAJCQnCoCogdGhlbiB3ZSBuZWVkIHRvIHdhaXQgZm9yIGEgdmJsYW5rIHRvIHBhc3MKPiBmb3Ig dGhlCj4gwqAJCQnCoCogbmV3IGRkYiBhbGxvY2F0aW9uIHRvIHRha2UgZWZmZWN0Lgo+IMKgCQkJ wqAqLwo+IC0JCQlpZiAoIXNrbF9kZGJfYWxsb2NhdGlvbl9lcXVhbHMoY3VyX2RkYiwKPiBuZXdf ZGRiLCBwaXBlKSAmJgo+ICsJCQlpZiAoIXNrbF9kZGJfZW50cnlfZXF1YWwoJmNzdGF0ZS0KPiA+ d20uc2tsLmRkYiwKPiArCQkJCQkJwqAmaW50ZWxfY3J0Yy0KPiA+aHdfZGRiKSAmJgo+IMKgCQkJ wqDCoMKgwqAhY3J0Yy0+c3RhdGUtPmFjdGl2ZV9jaGFuZ2VkICYmCj4gwqAJCQnCoMKgwqDCoGlu dGVsX3N0YXRlLT53bV9yZXN1bHRzLmRpcnR5X3BpcGVzICE9Cj4gdXBkYXRlZCkKPiDCoAkJCQl2 Ymxfd2FpdCA9IHRydWU7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2Rydi5oCj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IGluZGV4IGY0OGU3 OWEuLjM1YmEyODIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2 LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IEBAIC00OTYsNiAr NDk2LDcgQEAgc3RydWN0IGludGVsX2NydGNfd21fc3RhdGUgewo+IMKgCQlzdHJ1Y3Qgewo+IMKg CQkJLyogZ2VuOSsgb25seSBuZWVkcyAxLXN0ZXAgd20gcHJvZ3JhbW1pbmcgKi8KPiDCoAkJCXN0 cnVjdCBza2xfcGlwZV93bSBvcHRpbWFsOwo+ICsJCQlzdHJ1Y3Qgc2tsX2RkYl9lbnRyeSBkZGI7 Cj4gwqAKPiDCoAkJCS8qIGNhY2hlZCBwbGFuZSBkYXRhIHJhdGUgKi8KPiDCoAkJCXVuc2lnbmVk IHBsYW5lX2RhdGFfcmF0ZVtJOTE1X01BWF9QTEFORVNdOwo+IEBAIC03MzMsNiArNzM0LDkgQEAg c3RydWN0IGludGVsX2NydGMgewo+IMKgCQlib29sIGN4c3JfYWxsb3dlZDsKPiDCoAl9IHdtOwo+ IMKgCj4gKwkvKiBnZW45KzogZGRiIGFsbG9jYXRpb24gY3VycmVudGx5IGJlaW5nIHVzZWQgKi8K PiArCXN0cnVjdCBza2xfZGRiX2VudHJ5IGh3X2RkYjsKPiArCj4gwqAJaW50IHNjYW5saW5lX29m ZnNldDsKPiDCoAo+IMKgCXN0cnVjdCB7Cj4gQEAgLTE3NTUsOSArMTc1OSw3IEBAIGJvb2wgc2ts X2RkYl9hbGxvY2F0aW9uX2VxdWFscyhjb25zdCBzdHJ1Y3QKPiBza2xfZGRiX2FsbG9jYXRpb24g Km9sZCwKPiDCoAkJCcKgwqDCoMKgwqDCoMKgY29uc3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlv biAqbmV3LAo+IMKgCQkJwqDCoMKgwqDCoMKgwqBlbnVtIHBpcGUgcGlwZSk7Cj4gwqBib29sIHNr bF9kZGJfYWxsb2NhdGlvbl9vdmVybGFwcyhzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUs Cj4gLQkJCQnCoGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24KPiAqb2xkLAo+IC0JCQkJ wqBjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uCj4gKm5ldywKPiAtCQkJCcKgZW51bSBw aXBlIHBpcGUpOwo+ICsJCQkJwqBzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0Yyk7Cj4gwqB2 b2lkIHNrbF93cml0ZV9jdXJzb3Jfd20oc3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGMsCj4g wqAJCQnCoGNvbnN0IHN0cnVjdCBza2xfd21fdmFsdWVzICp3bSk7Cj4gwqB2b2lkIHNrbF93cml0 ZV9wbGFuZV93bShzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YywKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfcG0uYwo+IGluZGV4IGZlNmMxYzYuLjY4MzU1YjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3BtLmMKPiBAQCAtMzA1OCw3ICszMDU4LDYgQEAgc2tsX2RkYl9nZXRfcGlwZV9hbGxvY2F0 aW9uX2xpbWl0cyhzdHJ1Y3QKPiBkcm1fZGV2aWNlICpkZXYsCj4gwqAJc3RydWN0IGRybV9jcnRj ICpmb3JfY3J0YyA9IGNzdGF0ZS0+YmFzZS5jcnRjOwo+IMKgCXVuc2lnbmVkIGludCBwaXBlX3Np emUsIGRkYl9zaXplOwo+IMKgCWludCBudGhfYWN0aXZlX3BpcGU7Cj4gLQlpbnQgcGlwZSA9IHRv X2ludGVsX2NydGMoZm9yX2NydGMpLT5waXBlOwo+IMKgCj4gwqAJaWYgKFdBUk5fT04oIXN0YXRl KSB8fCAhY3N0YXRlLT5iYXNlLmFjdGl2ZSkgewo+IMKgCQlhbGxvYy0+c3RhcnQgPSAwOwo+IEBA IC0zMDg2LDcgKzMwODUsNyBAQCBza2xfZGRiX2dldF9waXBlX2FsbG9jYXRpb25fbGltaXRzKHN0 cnVjdAo+IGRybV9kZXZpY2UgKmRldiwKPiDCoAnCoCogd2UgY3VycmVudGx5IGhvbGQuCj4gwqAJ wqAqLwo+IMKgCWlmICghaW50ZWxfc3RhdGUtPmFjdGl2ZV9waXBlX2NoYW5nZXMpIHsKPiAtCQkq YWxsb2MgPSBkZXZfcHJpdi0+d20uc2tsX2h3LmRkYi5waXBlW3BpcGVdOwo+ICsJCSphbGxvYyA9 IHRvX2ludGVsX2NydGMoZm9yX2NydGMpLT5od19kZGI7Cj4gwqAJCXJldHVybjsKPiDCoAl9Cj4g wqAKPiBAQCAtMzM1NCw3ICszMzUzLDcgQEAgc2tsX2FsbG9jYXRlX3BpcGVfZGRiKHN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlCj4gKmNzdGF0ZSwKPiDCoAlzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZTsK PiDCoAlzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwc3RhdGU7Cj4gwqAJZW51bSBwaXBlIHBpcGUg PSBpbnRlbF9jcnRjLT5waXBlOwo+IC0Jc3RydWN0IHNrbF9kZGJfZW50cnkgKmFsbG9jID0gJmRk Yi0+cGlwZVtwaXBlXTsKPiArCXN0cnVjdCBza2xfZGRiX2VudHJ5ICphbGxvYyA9ICZjc3RhdGUt PndtLnNrbC5kZGI7Cj4gwqAJdWludDE2X3QgYWxsb2Nfc2l6ZSwgc3RhcnQsIGN1cnNvcl9ibG9j a3M7Cj4gwqAJdWludDE2X3QgKm1pbmltdW0gPSBjc3RhdGUtPndtLnNrbC5taW5pbXVtX2Jsb2Nr czsKPiDCoAl1aW50MTZfdCAqeV9taW5pbXVtID0gY3N0YXRlLT53bS5za2wubWluaW11bV95X2Js b2NrczsKPiBAQCAtMzM3MCw3ICszMzY5LDcgQEAgc2tsX2FsbG9jYXRlX3BpcGVfZGRiKHN0cnVj dCBpbnRlbF9jcnRjX3N0YXRlCj4gKmNzdGF0ZSwKPiDCoAkJcmV0dXJuIDA7Cj4gwqAKPiDCoAlp ZiAoIWNzdGF0ZS0+YmFzZS5hY3RpdmUpIHsKPiAtCQlkZGItPnBpcGVbcGlwZV0uc3RhcnQgPSBk ZGItPnBpcGVbcGlwZV0uZW5kID0gMDsKPiArCQlhbGxvYy0+c3RhcnQgPSBhbGxvYy0+ZW5kID0g MDsKPiDCoAkJcmV0dXJuIDA7Cj4gwqAJfQo+IMKgCj4gQEAgLTM4OTcsMTQgKzM4OTYsNiBAQCB2 b2lkIHNrbF93cml0ZV9jdXJzb3Jfd20oc3RydWN0IGludGVsX2NydGMKPiAqaW50ZWxfY3J0YywK PiDCoAkJCcKgwqDCoMKgJndtLT5kZGIucGxhbmVbcGlwZV1bUExBTkVfQ1VSU09SXSk7Cj4gwqB9 Cj4gwqAKPiAtYm9vbCBza2xfZGRiX2FsbG9jYXRpb25fZXF1YWxzKGNvbnN0IHN0cnVjdCBza2xf ZGRiX2FsbG9jYXRpb24gKm9sZCwKPiAtCQkJwqDCoMKgwqDCoMKgwqBjb25zdCBzdHJ1Y3Qgc2ts X2RkYl9hbGxvY2F0aW9uICpuZXcsCj4gLQkJCcKgwqDCoMKgwqDCoMKgZW51bSBwaXBlIHBpcGUp Cj4gLXsKPiAtCXJldHVybiBuZXctPnBpcGVbcGlwZV0uc3RhcnQgPT0gb2xkLT5waXBlW3BpcGVd LnN0YXJ0ICYmCj4gLQnCoMKgwqDCoMKgwqDCoG5ldy0+cGlwZVtwaXBlXS5lbmQgPT0gb2xkLT5w aXBlW3BpcGVdLmVuZDsKPiAtfQo+IC0KPiDCoHN0YXRpYyBpbmxpbmUgYm9vbCBza2xfZGRiX2Vu dHJpZXNfb3ZlcmxhcChjb25zdCBzdHJ1Y3QKPiBza2xfZGRiX2VudHJ5ICphLAo+IMKgCQkJCQnC oMKgwqBjb25zdCBzdHJ1Y3QKPiBza2xfZGRiX2VudHJ5ICpiKQo+IMKgewo+IEBAIC0zOTEyLDIy ICszOTAzLDIyIEBAIHN0YXRpYyBpbmxpbmUgYm9vbAo+IHNrbF9kZGJfZW50cmllc19vdmVybGFw KGNvbnN0IHN0cnVjdCBza2xfZGRiX2VudHJ5ICphLAo+IMKgfQo+IMKgCj4gwqBib29sIHNrbF9k ZGJfYWxsb2NhdGlvbl9vdmVybGFwcyhzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCj4g LQkJCQnCoGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24KPiAqb2xkLAo+IC0JCQkJwqBj b25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uCj4gKm5ldywKPiAtCQkJCcKgZW51bSBwaXBl IHBpcGUpCj4gKwkJCQnCoHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjKQo+IMKgewo+IC0J c3RydWN0IGRybV9kZXZpY2UgKmRldiA9IHN0YXRlLT5kZXY7Cj4gLQlzdHJ1Y3QgaW50ZWxfY3J0 YyAqaW50ZWxfY3J0YzsKPiAtCWVudW0gcGlwZSBvdGhlcnA7Cj4gKwlzdHJ1Y3QgZHJtX2NydGMg Km90aGVyX2NydGM7Cj4gKwlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKm90aGVyX2NzdGF0ZTsKPiAr CXN0cnVjdCBpbnRlbF9jcnRjICpvdGhlcl9pbnRlbF9jcnRjOwo+ICsJY29uc3Qgc3RydWN0IHNr bF9kZGJfZW50cnkgKmRkYiA9Cj4gKwkJJnRvX2ludGVsX2NydGNfc3RhdGUoaW50ZWxfY3J0Yy0+ YmFzZS5zdGF0ZSktCj4gPndtLnNrbC5kZGI7Cj4gKwlpbnQgaTsKPiDCoAo+IC0JZm9yX2VhY2hf aW50ZWxfY3J0YyhkZXYsIGludGVsX2NydGMpIHsKPiAtCQlvdGhlcnAgPSBpbnRlbF9jcnRjLT5w aXBlOwo+ICsJZm9yX2VhY2hfY3J0Y19pbl9zdGF0ZShzdGF0ZSwgb3RoZXJfY3J0Yywgb3RoZXJf Y3N0YXRlLCBpKSB7Cj4gKwkJb3RoZXJfaW50ZWxfY3J0YyA9IHRvX2ludGVsX2NydGMob3RoZXJf Y3J0Yyk7Cj4gwqAKPiAtCQlpZiAob3RoZXJwID09IHBpcGUpCj4gKwkJaWYgKG90aGVyX2ludGVs X2NydGMgPT0gaW50ZWxfY3J0YykKPiDCoAkJCWNvbnRpbnVlOwo+IMKgCj4gLQkJaWYgKHNrbF9k ZGJfZW50cmllc19vdmVybGFwKCZuZXctPnBpcGVbcGlwZV0sCj4gLQkJCQkJwqDCoMKgwqAmb2xk LT5waXBlW290aGVycF0pKQo+ICsJCWlmIChza2xfZGRiX2VudHJpZXNfb3ZlcmxhcChkZGIsICZv dGhlcl9pbnRlbF9jcnRjLQo+ID5od19kZGIpKQo+IMKgCQkJcmV0dXJuIHRydWU7Cj4gwqAJfQo+ IMKgCj4gQEAgLTQwOTIsNyArNDA4Myw2IEBAIHNrbF9jb3B5X3dtX2Zvcl9waXBlKHN0cnVjdCBz a2xfd21fdmFsdWVzICpkc3QsCj4gwqAJbWVtY3B5KGRzdC0+cGxhbmVfdHJhbnNbcGlwZV0sIHNy Yy0+cGxhbmVfdHJhbnNbcGlwZV0sCj4gwqAJwqDCoMKgwqDCoMKgwqBzaXplb2YoZHN0LT5wbGFu ZV90cmFuc1twaXBlXSkpOwo+IMKgCj4gLQlkc3QtPmRkYi5waXBlW3BpcGVdID0gc3JjLT5kZGIu cGlwZVtwaXBlXTsKPiDCoAltZW1jcHkoZHN0LT5kZGIueV9wbGFuZVtwaXBlXSwgc3JjLT5kZGIu eV9wbGFuZVtwaXBlXSwKPiDCoAnCoMKgwqDCoMKgwqDCoHNpemVvZihkc3QtPmRkYi55X3BsYW5l W3BpcGVdKSk7Cj4gwqAJbWVtY3B5KGRzdC0+ZGRiLnBsYW5lW3BpcGVdLCBzcmMtPmRkYi5wbGFu ZVtwaXBlXSwKPiBAQCAtNDIwMCw2ICs0MTkwLDggQEAgc3RhdGljIHZvaWQgc2tsX3VwZGF0ZV93 bShzdHJ1Y3QgZHJtX2NydGMKPiAqY3J0YykKPiDCoAo+IMKgCXNrbF9jb3B5X3dtX2Zvcl9waXBl KGh3X3ZhbHMsIHJlc3VsdHMsIHBpcGUpOwo+IMKgCj4gKwlpbnRlbF9jcnRjLT5od19kZGIgPSBj c3RhdGUtPndtLnNrbC5kZGI7Cj4gKwo+IMKgCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPndtLndt X211dGV4KTsKPiDCoH0KPiDCoApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVz a3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9p bnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752103AbcJKTgU (ORCPT ); Tue, 11 Oct 2016 15:36:20 -0400 Received: from mga03.intel.com ([134.134.136.65]:27371 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750717AbcJKTgS (ORCPT ); Tue, 11 Oct 2016 15:36:18 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.31,330,1473145200"; d="scan'208";a="178841827" Message-ID: <1476214572.2460.14.camel@intel.com> Subject: Re: [Intel-gfx] [PATCH v2 01/10] drm/i915/skl: Move per-pipe ddb allocations into crtc states 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: Tue, 11 Oct 2016 16:36:12 -0300 In-Reply-To: <1475885497-6094-2-git-send-email-cpaul@redhat.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> <1475885497-6094-2-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: > First part of cleaning up all of the skl watermark code. This moves > the > structures for storing the ddb allocations of each pipe into > intel_crtc_state, along with moving the structures for storing the > current ddb allocations active on hardware into intel_crtc. > > Changes since v1: > - Don't replace alloc->start = alloc->end = 0; > > 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      |  1 - >  drivers/gpu/drm/i915/intel_display.c | 16 ++++++++------- >  drivers/gpu/drm/i915/intel_drv.h     |  8 +++++--- >  drivers/gpu/drm/i915/intel_pm.c      | 40 +++++++++++++++----------- > ---------- >  4 files changed, 30 insertions(+), 35 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.h > b/drivers/gpu/drm/i915/i915_drv.h > index a219a35..bb2de8d 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -1637,7 +1637,6 @@ static inline bool skl_ddb_entry_equal(const > struct skl_ddb_entry *e1, >  } >   >  struct skl_ddb_allocation { > - struct skl_ddb_entry pipe[I915_MAX_PIPES]; >   struct skl_ddb_entry plane[I915_MAX_PIPES][I915_MAX_PLANES]; > /* packed/uv */ >   struct skl_ddb_entry > y_plane[I915_MAX_PIPES][I915_MAX_PLANES]; >  }; > diff --git a/drivers/gpu/drm/i915/intel_display.c > b/drivers/gpu/drm/i915/intel_display.c > index a366656..17733af 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -14235,12 +14235,11 @@ static void skl_update_crtcs(struct > drm_atomic_state *state, >        unsigned int *crtc_vblank_mask) >  { >   struct drm_device *dev = state->dev; > - 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 *intel_crtc; >   struct drm_crtc_state *old_crtc_state; > - struct skl_ddb_allocation *new_ddb = &intel_state- > >wm_results.ddb; > - struct skl_ddb_allocation *cur_ddb = &dev_priv- > >wm.skl_hw.ddb; > + struct intel_crtc_state *cstate; >   unsigned int updated = 0; >   bool progress; >   enum pipe pipe; > @@ -14258,12 +14257,14 @@ static void skl_update_crtcs(struct > drm_atomic_state *state, >   for_each_crtc_in_state(state, crtc, old_crtc_state, > i) { >   bool vbl_wait = false; >   unsigned int cmask = drm_crtc_mask(crtc); > - pipe = to_intel_crtc(crtc)->pipe; > + > + intel_crtc = to_intel_crtc(crtc); > + cstate = to_intel_crtc_state(crtc->state); > + pipe = intel_crtc->pipe; >   >   if (updated & cmask || !crtc->state->active) >   continue; > - if (skl_ddb_allocation_overlaps(state, > cur_ddb, new_ddb, > - pipe)) > + if (skl_ddb_allocation_overlaps(state, > intel_crtc)) >   continue; >   >   updated |= cmask; > @@ -14274,7 +14275,8 @@ static void skl_update_crtcs(struct > drm_atomic_state *state, >    * then we need to wait for a vblank to pass > for the >    * new ddb allocation to take effect. >    */ > - if (!skl_ddb_allocation_equals(cur_ddb, > new_ddb, pipe) && > + if (!skl_ddb_entry_equal(&cstate- > >wm.skl.ddb, > +  &intel_crtc- > >hw_ddb) && >       !crtc->state->active_changed && >       intel_state->wm_results.dirty_pipes != > updated) >   vbl_wait = true; > diff --git a/drivers/gpu/drm/i915/intel_drv.h > b/drivers/gpu/drm/i915/intel_drv.h > index f48e79a..35ba282 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -496,6 +496,7 @@ struct intel_crtc_wm_state { >   struct { >   /* gen9+ only needs 1-step wm programming */ >   struct skl_pipe_wm optimal; > + struct skl_ddb_entry ddb; >   >   /* cached plane data rate */ >   unsigned plane_data_rate[I915_MAX_PLANES]; > @@ -733,6 +734,9 @@ struct intel_crtc { >   bool cxsr_allowed; >   } wm; >   > + /* gen9+: ddb allocation currently being used */ > + struct skl_ddb_entry hw_ddb; > + >   int scanline_offset; >   >   struct { > @@ -1755,9 +1759,7 @@ bool skl_ddb_allocation_equals(const struct > skl_ddb_allocation *old, >          const struct skl_ddb_allocation *new, >          enum pipe pipe); >  bool skl_ddb_allocation_overlaps(struct drm_atomic_state *state, > -  const struct skl_ddb_allocation > *old, > -  const struct skl_ddb_allocation > *new, > -  enum pipe pipe); > +  struct intel_crtc *intel_crtc); >  void skl_write_cursor_wm(struct intel_crtc *intel_crtc, >    const struct skl_wm_values *wm); >  void skl_write_plane_wm(struct intel_crtc *intel_crtc, > diff --git a/drivers/gpu/drm/i915/intel_pm.c > b/drivers/gpu/drm/i915/intel_pm.c > index fe6c1c6..68355b0 100644 > --- a/drivers/gpu/drm/i915/intel_pm.c > +++ b/drivers/gpu/drm/i915/intel_pm.c > @@ -3058,7 +3058,6 @@ skl_ddb_get_pipe_allocation_limits(struct > drm_device *dev, >   struct drm_crtc *for_crtc = cstate->base.crtc; >   unsigned int pipe_size, ddb_size; >   int nth_active_pipe; > - int pipe = to_intel_crtc(for_crtc)->pipe; >   >   if (WARN_ON(!state) || !cstate->base.active) { >   alloc->start = 0; > @@ -3086,7 +3085,7 @@ skl_ddb_get_pipe_allocation_limits(struct > drm_device *dev, >    * we currently hold. >    */ >   if (!intel_state->active_pipe_changes) { > - *alloc = dev_priv->wm.skl_hw.ddb.pipe[pipe]; > + *alloc = to_intel_crtc(for_crtc)->hw_ddb; >   return; >   } >   > @@ -3354,7 +3353,7 @@ skl_allocate_pipe_ddb(struct intel_crtc_state > *cstate, >   struct drm_plane *plane; >   struct drm_plane_state *pstate; >   enum pipe pipe = intel_crtc->pipe; > - struct skl_ddb_entry *alloc = &ddb->pipe[pipe]; > + struct skl_ddb_entry *alloc = &cstate->wm.skl.ddb; >   uint16_t alloc_size, start, cursor_blocks; >   uint16_t *minimum = cstate->wm.skl.minimum_blocks; >   uint16_t *y_minimum = cstate->wm.skl.minimum_y_blocks; > @@ -3370,7 +3369,7 @@ skl_allocate_pipe_ddb(struct intel_crtc_state > *cstate, >   return 0; >   >   if (!cstate->base.active) { > - ddb->pipe[pipe].start = ddb->pipe[pipe].end = 0; > + alloc->start = alloc->end = 0; >   return 0; >   } >   > @@ -3897,14 +3896,6 @@ void skl_write_cursor_wm(struct intel_crtc > *intel_crtc, >       &wm->ddb.plane[pipe][PLANE_CURSOR]); >  } >   > -bool skl_ddb_allocation_equals(const struct skl_ddb_allocation *old, > -        const struct skl_ddb_allocation *new, > -        enum pipe pipe) > -{ > - return new->pipe[pipe].start == old->pipe[pipe].start && > -        new->pipe[pipe].end == old->pipe[pipe].end; > -} > - >  static inline bool skl_ddb_entries_overlap(const struct > skl_ddb_entry *a, >      const struct > skl_ddb_entry *b) >  { > @@ -3912,22 +3903,22 @@ static inline bool > skl_ddb_entries_overlap(const struct skl_ddb_entry *a, >  } >   >  bool skl_ddb_allocation_overlaps(struct drm_atomic_state *state, > -  const struct skl_ddb_allocation > *old, > -  const struct skl_ddb_allocation > *new, > -  enum pipe pipe) > +  struct intel_crtc *intel_crtc) >  { > - struct drm_device *dev = state->dev; > - struct intel_crtc *intel_crtc; > - enum pipe otherp; > + struct drm_crtc *other_crtc; > + struct drm_crtc_state *other_cstate; > + struct intel_crtc *other_intel_crtc; > + const struct skl_ddb_entry *ddb = > + &to_intel_crtc_state(intel_crtc->base.state)- > >wm.skl.ddb; > + int i; >   > - for_each_intel_crtc(dev, intel_crtc) { > - otherp = intel_crtc->pipe; > + for_each_crtc_in_state(state, other_crtc, other_cstate, i) { > + other_intel_crtc = to_intel_crtc(other_crtc); >   > - if (otherp == pipe) > + if (other_intel_crtc == intel_crtc) >   continue; >   > - if (skl_ddb_entries_overlap(&new->pipe[pipe], > -     &old->pipe[otherp])) > + if (skl_ddb_entries_overlap(ddb, &other_intel_crtc- > >hw_ddb)) >   return true; >   } >   > @@ -4092,7 +4083,6 @@ skl_copy_wm_for_pipe(struct skl_wm_values *dst, >   memcpy(dst->plane_trans[pipe], src->plane_trans[pipe], >          sizeof(dst->plane_trans[pipe])); >   > - dst->ddb.pipe[pipe] = src->ddb.pipe[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], > @@ -4200,6 +4190,8 @@ static void skl_update_wm(struct drm_crtc > *crtc) >   >   skl_copy_wm_for_pipe(hw_vals, results, pipe); >   > + intel_crtc->hw_ddb = cstate->wm.skl.ddb; > + >   mutex_unlock(&dev_priv->wm.wm_mutex); >  } >