From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paulo Zanoni Subject: Re: [PATCH 1/6] drm/i915/skl: Move per-pipe ddb allocations into crtc states Date: Wed, 05 Oct 2016 17:23:36 -0300 Message-ID: <1475699016.2381.55.camel@intel.com> References: <1475681598-12081-1-git-send-email-cpaul@redhat.com> <1475681598-12081-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: <1475681598-12081-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 RW0gUXVhLCAyMDE2LTEwLTA1IMOgcyAxMTozMyAtMDQwMCwgTHl1ZGUgZXNjcmV2ZXU6Cj4gRmly c3QgcGFydCBvZiBjbGVhbmluZyB1cCBhbGwgb2YgdGhlIHNrbCB3YXRlcm1hcmsgY29kZS4gVGhp cyBtb3Zlcwo+IHRoZQo+IHN0cnVjdHVyZXMgZm9yIHN0b3JpbmcgdGhlIGRkYiBhbGxvY2F0aW9u cyBvZiBlYWNoIHBpcGUgaW50bwo+IGludGVsX2NydGNfc3RhdGUsIGFsb25nIHdpdGggbW92aW5n IHRoZSBzdHJ1Y3R1cmVzIGZvciBzdG9yaW5nIHRoZQo+IGN1cnJlbnQgZGRiIGFsbG9jYXRpb25z IGFjdGl2ZSBvbiBoYXJkd2FyZSBpbnRvIGludGVsX2NydGMuCj4gCj4gU2lnbmVkLW9mZi1ieTog THl1ZGUgPGNwYXVsQHJlZGhhdC5jb20+Cj4gQ2M6IE1hYXJ0ZW4gTGFua2hvcnN0IDxtYWFydGVu Lmxhbmtob3JzdEBsaW51eC5pbnRlbC5jb20+Cj4gQ2M6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUu c3lyamFsYUBsaW51eC5pbnRlbC5jb20+Cj4gQ2M6IE1hdHQgUm9wZXIgPG1hdHRoZXcuZC5yb3Bl ckBpbnRlbC5jb20+Cj4gLS0tCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5owqDC oMKgwqDCoMKgfMKgwqAxIC0KPiDCoGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXku YyB8IDE2ICsrKysrKysrLS0tLS0tLQo+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2 LmjCoMKgwqDCoMKgfMKgwqA4ICsrKysrLS0tCj4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9wbS5jwqDCoMKgwqDCoMKgfCA0MCArKysrKysrKysrKysrKystLS0tLS0tLS0tLQo+IC0tLS0t LS0tLS0KPiDCoDQgZmlsZXMgY2hhbmdlZCwgMzAgaW5zZXJ0aW9ucygrKSwgMzUgZGVsZXRpb25z KC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiBpbmRleCBmOGM2NmVlLi44NWU1NDFj IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCj4gQEAgLTE2MzYsNyArMTYzNiw2IEBAIHN0 YXRpYyBpbmxpbmUgYm9vbCBza2xfZGRiX2VudHJ5X2VxdWFsKGNvbnN0Cj4gc3RydWN0IHNrbF9k ZGJfZW50cnkgKmUxLAo+IMKgfQo+IMKgCj4gwqBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uIHsK PiAtCXN0cnVjdCBza2xfZGRiX2VudHJ5IHBpcGVbSTkxNV9NQVhfUElQRVNdOwo+IMKgCXN0cnVj dCBza2xfZGRiX2VudHJ5IHBsYW5lW0k5MTVfTUFYX1BJUEVTXVtJOTE1X01BWF9QTEFORVNdOwo+ IC8qIHBhY2tlZC91diAqLwo+IMKgCXN0cnVjdCBza2xfZGRiX2VudHJ5Cj4geV9wbGFuZVtJOTE1 X01BWF9QSVBFU11bSTkxNV9NQVhfUExBTkVTXTsKPiDCoH07Cj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZGlzcGxheS5jCj4gaW5kZXggYTM2NjY1Ni4uMTc3MzNhZiAxMDA2NDQKPiAtLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiBAQCAtMTQyMzUsMTIgKzE0MjM1LDExIEBAIHN0YXRp YyB2b2lkIHNrbF91cGRhdGVfY3J0Y3Moc3RydWN0Cj4gZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUs Cj4gwqAJCQnCoMKgwqDCoMKgdW5zaWduZWQgaW50ICpjcnRjX3ZibGFua19tYXNrKQo+IMKgewo+ IMKgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBzdGF0ZS0+ZGV2Owo+IC0Jc3RydWN0IGRybV9p OTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShkZXYpOwo+IMKgCXN0cnVjdCBpbnRlbF9h dG9taWNfc3RhdGUgKmludGVsX3N0YXRlID0KPiB0b19pbnRlbF9hdG9taWNfc3RhdGUoc3RhdGUp Owo+IMKgCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKPiArCXN0cnVjdCBpbnRlbF9jcnRjICppbnRl bF9jcnRjOwo+IMKgCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqb2xkX2NydGNfc3RhdGU7Cj4gLQlz dHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpuZXdfZGRiID0gJmludGVsX3N0YXRlLQo+ID53bV9y ZXN1bHRzLmRkYjsKPiAtCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKmN1cl9kZGIgPSAmZGV2 X3ByaXYtCj4gPndtLnNrbF9ody5kZGI7Cj4gKwlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3N0 YXRlOwo+IMKgCXVuc2lnbmVkIGludCB1cGRhdGVkID0gMDsKPiDCoAlib29sIHByb2dyZXNzOwo+ IMKgCWVudW0gcGlwZSBwaXBlOwo+IEBAIC0xNDI1OCwxMiArMTQyNTcsMTQgQEAgc3RhdGljIHZv aWQgc2tsX3VwZGF0ZV9jcnRjcyhzdHJ1Y3QKPiBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKPiDC oAkJZm9yX2VhY2hfY3J0Y19pbl9zdGF0ZShzdGF0ZSwgY3J0Yywgb2xkX2NydGNfc3RhdGUsCj4g aSkgewo+IMKgCQkJYm9vbCB2Ymxfd2FpdCA9IGZhbHNlOwo+IMKgCQkJdW5zaWduZWQgaW50IGNt YXNrID0gZHJtX2NydGNfbWFzayhjcnRjKTsKPiAtCQkJcGlwZSA9IHRvX2ludGVsX2NydGMoY3J0 YyktPnBpcGU7Cj4gKwo+ICsJCQlpbnRlbF9jcnRjID0gdG9faW50ZWxfY3J0YyhjcnRjKTsKPiAr CQkJY3N0YXRlID0gdG9faW50ZWxfY3J0Y19zdGF0ZShjcnRjLT5zdGF0ZSk7Cj4gKwkJCXBpcGUg PSBpbnRlbF9jcnRjLT5waXBlOwo+IMKgCj4gwqAJCQlpZiAodXBkYXRlZCAmIGNtYXNrIHx8ICFj cnRjLT5zdGF0ZS0+YWN0aXZlKQo+IMKgCQkJCWNvbnRpbnVlOwo+IC0JCQlpZiAoc2tsX2RkYl9h bGxvY2F0aW9uX292ZXJsYXBzKHN0YXRlLAo+IGN1cl9kZGIsIG5ld19kZGIsCj4gLQkJCQkJCQlw aXBlKSkKPiArCQkJaWYgKHNrbF9kZGJfYWxsb2NhdGlvbl9vdmVybGFwcyhzdGF0ZSwKPiBpbnRl bF9jcnRjKSkKPiDCoAkJCQljb250aW51ZTsKPiDCoAo+IMKgCQkJdXBkYXRlZCB8PSBjbWFzazsK PiBAQCAtMTQyNzQsNyArMTQyNzUsOCBAQCBzdGF0aWMgdm9pZCBza2xfdXBkYXRlX2NydGNzKHN0 cnVjdAo+IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAo+IMKgCQkJwqAqIHRoZW4gd2UgbmVlZCB0 byB3YWl0IGZvciBhIHZibGFuayB0byBwYXNzCj4gZm9yIHRoZQo+IMKgCQkJwqAqIG5ldyBkZGIg YWxsb2NhdGlvbiB0byB0YWtlIGVmZmVjdC4KPiDCoAkJCcKgKi8KPiAtCQkJaWYgKCFza2xfZGRi X2FsbG9jYXRpb25fZXF1YWxzKGN1cl9kZGIsCj4gbmV3X2RkYiwgcGlwZSkgJiYKPiArCQkJaWYg KCFza2xfZGRiX2VudHJ5X2VxdWFsKCZjc3RhdGUtCj4gPndtLnNrbC5kZGIsCj4gKwkJCQkJCcKg JmludGVsX2NydGMtCj4gPmh3X2RkYikgJiYKPiDCoAkJCcKgwqDCoMKgIWNydGMtPnN0YXRlLT5h Y3RpdmVfY2hhbmdlZCAmJgo+IMKgCQkJwqDCoMKgwqBpbnRlbF9zdGF0ZS0+d21fcmVzdWx0cy5k aXJ0eV9waXBlcyAhPQo+IHVwZGF0ZWQpCj4gwqAJCQkJdmJsX3dhaXQgPSB0cnVlOwo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiBpbmRleCBmNDhlNzlhLi4zNWJhMjgyIDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiBAQCAtNDk2LDYgKzQ5Niw3IEBAIHN0cnVjdCBpbnRlbF9j cnRjX3dtX3N0YXRlIHsKPiDCoAkJc3RydWN0IHsKPiDCoAkJCS8qIGdlbjkrIG9ubHkgbmVlZHMg MS1zdGVwIHdtIHByb2dyYW1taW5nICovCj4gwqAJCQlzdHJ1Y3Qgc2tsX3BpcGVfd20gb3B0aW1h bDsKPiArCQkJc3RydWN0IHNrbF9kZGJfZW50cnkgZGRiOwo+IMKgCj4gwqAJCQkvKiBjYWNoZWQg cGxhbmUgZGF0YSByYXRlICovCj4gwqAJCQl1bnNpZ25lZCBwbGFuZV9kYXRhX3JhdGVbSTkxNV9N QVhfUExBTkVTXTsKPiBAQCAtNzMzLDYgKzczNCw5IEBAIHN0cnVjdCBpbnRlbF9jcnRjIHsKPiDC oAkJYm9vbCBjeHNyX2FsbG93ZWQ7Cj4gwqAJfSB3bTsKPiDCoAo+ICsJLyogZ2VuOSs6IGRkYiBh bGxvY2F0aW9uIGN1cnJlbnRseSBiZWluZyB1c2VkICovCj4gKwlzdHJ1Y3Qgc2tsX2RkYl9lbnRy eSBod19kZGI7Cj4gKwo+IMKgCWludCBzY2FubGluZV9vZmZzZXQ7Cj4gwqAKPiDCoAlzdHJ1Y3Qg ewo+IEBAIC0xNzU1LDkgKzE3NTksNyBAQCBib29sIHNrbF9kZGJfYWxsb2NhdGlvbl9lcXVhbHMo Y29uc3Qgc3RydWN0Cj4gc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCj4gwqAJCQnCoMKgwqDCoMKg wqDCoGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5ldywKPiDCoAkJCcKgwqDCoMKg wqDCoMKgZW51bSBwaXBlIHBpcGUpOwo+IMKgYm9vbCBza2xfZGRiX2FsbG9jYXRpb25fb3Zlcmxh cHMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAo+IC0JCQkJwqBjb25zdCBzdHJ1Y3Qg c2tsX2RkYl9hbGxvY2F0aW9uCj4gKm9sZCwKPiAtCQkJCcKgY29uc3Qgc3RydWN0IHNrbF9kZGJf YWxsb2NhdGlvbgo+ICpuZXcsCj4gLQkJCQnCoGVudW0gcGlwZSBwaXBlKTsKPiArCQkJCcKgc3Ry dWN0IGludGVsX2NydGMgKmludGVsX2NydGMpOwo+IMKgdm9pZCBza2xfd3JpdGVfY3Vyc29yX3dt KHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjLAo+IMKgCQkJwqBjb25zdCBzdHJ1Y3Qgc2ts X3dtX3ZhbHVlcyAqd20pOwo+IMKgdm9pZCBza2xfd3JpdGVfcGxhbmVfd20oc3RydWN0IGludGVs X2NydGMgKmludGVsX2NydGMsCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3BtLmMKPiBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKPiBpbmRleCA3ZjE3 NDhhLi4wMzgzNTE2IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Bt LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCj4gQEAgLTMwNTgsNyAr MzA1OCw2IEBAIHNrbF9kZGJfZ2V0X3BpcGVfYWxsb2NhdGlvbl9saW1pdHMoc3RydWN0Cj4gZHJt X2RldmljZSAqZGV2LAo+IMKgCXN0cnVjdCBkcm1fY3J0YyAqZm9yX2NydGMgPSBjc3RhdGUtPmJh c2UuY3J0YzsKPiDCoAl1bnNpZ25lZCBpbnQgcGlwZV9zaXplLCBkZGJfc2l6ZTsKPiDCoAlpbnQg bnRoX2FjdGl2ZV9waXBlOwo+IC0JaW50IHBpcGUgPSB0b19pbnRlbF9jcnRjKGZvcl9jcnRjKS0+ cGlwZTsKPiDCoAo+IMKgCWlmIChXQVJOX09OKCFzdGF0ZSkgfHwgIWNzdGF0ZS0+YmFzZS5hY3Rp dmUpIHsKPiDCoAkJYWxsb2MtPnN0YXJ0ID0gMDsKPiBAQCAtMzA4Niw3ICszMDg1LDcgQEAgc2ts X2RkYl9nZXRfcGlwZV9hbGxvY2F0aW9uX2xpbWl0cyhzdHJ1Y3QKPiBkcm1fZGV2aWNlICpkZXYs Cj4gwqAJwqAqIHdlIGN1cnJlbnRseSBob2xkLgo+IMKgCcKgKi8KPiDCoAlpZiAoIWludGVsX3N0 YXRlLT5hY3RpdmVfcGlwZV9jaGFuZ2VzKSB7Cj4gLQkJKmFsbG9jID0gZGV2X3ByaXYtPndtLnNr bF9ody5kZGIucGlwZVtwaXBlXTsKPiArCQkqYWxsb2MgPSB0b19pbnRlbF9jcnRjKGZvcl9jcnRj KS0+aHdfZGRiOwo+IMKgCQlyZXR1cm47Cj4gwqAJfQo+IMKgCj4gQEAgLTMzNTQsNyArMzM1Myw3 IEBAIHNrbF9hbGxvY2F0ZV9waXBlX2RkYihzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZQo+ICpjc3Rh dGUsCj4gwqAJc3RydWN0IGRybV9wbGFuZSAqcGxhbmU7Cj4gwqAJc3RydWN0IGRybV9wbGFuZV9z dGF0ZSAqcHN0YXRlOwo+IMKgCWVudW0gcGlwZSBwaXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsKPiAt CXN0cnVjdCBza2xfZGRiX2VudHJ5ICphbGxvYyA9ICZkZGItPnBpcGVbcGlwZV07Cj4gKwlzdHJ1 Y3Qgc2tsX2RkYl9lbnRyeSAqYWxsb2MgPSAmY3N0YXRlLT53bS5za2wuZGRiOwo+IMKgCXVpbnQx Nl90IGFsbG9jX3NpemUsIHN0YXJ0LCBjdXJzb3JfYmxvY2tzOwo+IMKgCXVpbnQxNl90ICptaW5p bXVtID0gY3N0YXRlLT53bS5za2wubWluaW11bV9ibG9ja3M7Cj4gwqAJdWludDE2X3QgKnlfbWlu aW11bSA9IGNzdGF0ZS0+d20uc2tsLm1pbmltdW1feV9ibG9ja3M7Cj4gQEAgLTMzNjYsNyArMzM2 NSw3IEBAIHNrbF9hbGxvY2F0ZV9waXBlX2RkYihzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZQo+ICpj c3RhdGUsCj4gwqAJCXJldHVybiAwOwo+IMKgCj4gwqAJaWYgKCFjc3RhdGUtPmJhc2UuYWN0aXZl KSB7Cj4gLQkJZGRiLT5waXBlW3BpcGVdLnN0YXJ0ID0gZGRiLT5waXBlW3BpcGVdLmVuZCA9IDA7 Cj4gKwkJbWVtc2V0KGFsbG9jLCAwLCBzaXplb2YoKmFsbG9jKSk7CgpOaXRwaWNrOiBJIHdvdWxk IGhhdmUga2VwdCB0aGUgZG91YmxlIGFzc2lnbm1lbnQgaGVyZSBpbnN0ZWFkIG9mCmNhbGxpbmcg bWVtc2V0OgphbGxvYy0+c3RhcnQgPSBhbGxvYy0+ZW5kID0gMDsKCkFueXdheSwgdGhpcyBjaHVu ayB3aWxsIGhhdmUgYSBzbWFsbCBjb25mbGljdCB3aXRoIG15IGN1cnJlbnQgbXVsdGktCnBpcGUg Zml4LCBhbmQgSSdkIGxpa2UgdG8gc2VlIHRoZSBtdWx0aS1waXBlIGZpeCBnZXQgbWVyZ2VkIGJl Zm9yZSB0aGlzCnNpbmNlIGl0IHdpbGwgbWFrZSBpdCBtdWNoIGVhc2llciB0byBiYWNrcG9ydCBp dCB0byBzdGFibGUgaWYgd2UgZG9uJ3QKaGF2ZSB5ZXQgYW5vdGhlciByb3VuZCBvZiBjb2RlIGNo dXJuIHNlcGFyYXRpbmcgc3RhYmxlIGZyb20gZGlucS4KCkFueXdheSwgdGhpcyBwYXRjaCBsb29r cyBjb3JyZWN0IGFuZCBhbmQgaXQgc2VlbXMgdGhlIG11bHRpLXBpcGUgZml4Cndvbid0IHJlcXVp cmUgYW55IGNoYW5nZSBiZXNpZGVzIHRoZSBzbWFsbCByZWJhc2UgYWJvdmUuIEknbSBzdGlsbApn b2luZyB0byB0ZXN0IHRoZSBzZXJpZXMgbGF0ZXIsIGJ1dCBJIHN1cHBvc2UgYSByZWJhc2VkIHZl cnNpb24gb2YgdGhpcwpwYXRjaCB3aWxsIGJlIHJlYWR5IHRvIGdldCBhIHJldmlld2VkLWJ5IHRh ZyBmcm9tIG1lLgoKCj4gwqAJCW1lbXNldChkZGItPnBsYW5lW3BpcGVdLCAwLCBzaXplb2YoZGRi LQo+ID5wbGFuZVtwaXBlXSkpOwo+IMKgCQltZW1zZXQoZGRiLT55X3BsYW5lW3BpcGVdLCAwLCBz aXplb2YoZGRiLQo+ID55X3BsYW5lW3BpcGVdKSk7Cj4gwqAJCXJldHVybiAwOwo+IEBAIC0zODk1 LDE0ICszODk0LDYgQEAgdm9pZCBza2xfd3JpdGVfY3Vyc29yX3dtKHN0cnVjdCBpbnRlbF9jcnRj Cj4gKmludGVsX2NydGMsCj4gwqAJCQnCoMKgwqDCoCZ3bS0+ZGRiLnBsYW5lW3BpcGVdW1BMQU5F X0NVUlNPUl0pOwo+IMKgfQo+IMKgCj4gLWJvb2wgc2tsX2RkYl9hbGxvY2F0aW9uX2VxdWFscyhj b25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCj4gLQkJCcKgwqDCoMKgwqDCoMKg Y29uc3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqbmV3LAo+IC0JCQnCoMKgwqDCoMKgwqDC oGVudW0gcGlwZSBwaXBlKQo+IC17Cj4gLQlyZXR1cm4gbmV3LT5waXBlW3BpcGVdLnN0YXJ0ID09 IG9sZC0+cGlwZVtwaXBlXS5zdGFydCAmJgo+IC0JwqDCoMKgwqDCoMKgwqBuZXctPnBpcGVbcGlw ZV0uZW5kID09IG9sZC0+cGlwZVtwaXBlXS5lbmQ7Cj4gLX0KPiAtCj4gwqBzdGF0aWMgaW5saW5l IGJvb2wgc2tsX2RkYl9lbnRyaWVzX292ZXJsYXAoY29uc3Qgc3RydWN0Cj4gc2tsX2RkYl9lbnRy eSAqYSwKPiDCoAkJCQkJwqDCoMKgY29uc3Qgc3RydWN0Cj4gc2tsX2RkYl9lbnRyeSAqYikKPiDC oHsKPiBAQCAtMzkxMCwyMiArMzkwMSwyMiBAQCBzdGF0aWMgaW5saW5lIGJvb2wKPiBza2xfZGRi X2VudHJpZXNfb3ZlcmxhcChjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9lbnRyeSAqYSwKPiDCoH0KPiDC oAo+IMKgYm9vbCBza2xfZGRiX2FsbG9jYXRpb25fb3ZlcmxhcHMoc3RydWN0IGRybV9hdG9taWNf c3RhdGUgKnN0YXRlLAo+IC0JCQkJwqBjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uCj4g Km9sZCwKPiAtCQkJCcKgY29uc3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbgo+ICpuZXcsCj4g LQkJCQnCoGVudW0gcGlwZSBwaXBlKQo+ICsJCQkJwqBzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxf Y3J0YykKPiDCoHsKPiAtCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBzdGF0ZS0+ZGV2Owo+IC0J c3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGM7Cj4gLQllbnVtIHBpcGUgb3RoZXJwOwo+ICsJ c3RydWN0IGRybV9jcnRjICpvdGhlcl9jcnRjOwo+ICsJc3RydWN0IGRybV9jcnRjX3N0YXRlICpv dGhlcl9jc3RhdGU7Cj4gKwlzdHJ1Y3QgaW50ZWxfY3J0YyAqb3RoZXJfaW50ZWxfY3J0YzsKPiAr CWNvbnN0IHN0cnVjdCBza2xfZGRiX2VudHJ5ICpkZGIgPQo+ICsJCSZ0b19pbnRlbF9jcnRjX3N0 YXRlKGludGVsX2NydGMtPmJhc2Uuc3RhdGUpLQo+ID53bS5za2wuZGRiOwo+ICsJaW50IGk7Cj4g wqAKPiAtCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBpbnRlbF9jcnRjKSB7Cj4gLQkJb3RoZXJw ID0gaW50ZWxfY3J0Yy0+cGlwZTsKPiArCWZvcl9lYWNoX2NydGNfaW5fc3RhdGUoc3RhdGUsIG90 aGVyX2NydGMsIG90aGVyX2NzdGF0ZSwgaSkgewo+ICsJCW90aGVyX2ludGVsX2NydGMgPSB0b19p bnRlbF9jcnRjKG90aGVyX2NydGMpOwo+IMKgCj4gLQkJaWYgKG90aGVycCA9PSBwaXBlKQo+ICsJ CWlmIChvdGhlcl9pbnRlbF9jcnRjID09IGludGVsX2NydGMpCj4gwqAJCQljb250aW51ZTsKPiDC oAo+IC0JCWlmIChza2xfZGRiX2VudHJpZXNfb3ZlcmxhcCgmbmV3LT5waXBlW3BpcGVdLAo+IC0J CQkJCcKgwqDCoMKgJm9sZC0+cGlwZVtvdGhlcnBdKSkKPiArCQlpZiAoc2tsX2RkYl9lbnRyaWVz X292ZXJsYXAoZGRiLCAmb3RoZXJfaW50ZWxfY3J0Yy0KPiA+aHdfZGRiKSkKPiDCoAkJCXJldHVy biB0cnVlOwo+IMKgCX0KPiDCoAo+IEBAIC00MDg0LDcgKzQwNzUsNiBAQCBza2xfY29weV93bV9m b3JfcGlwZShzdHJ1Y3Qgc2tsX3dtX3ZhbHVlcyAqZHN0LAo+IMKgCW1lbWNweShkc3QtPnBsYW5l X3RyYW5zW3BpcGVdLCBzcmMtPnBsYW5lX3RyYW5zW3BpcGVdLAo+IMKgCcKgwqDCoMKgwqDCoMKg c2l6ZW9mKGRzdC0+cGxhbmVfdHJhbnNbcGlwZV0pKTsKPiDCoAo+IC0JZHN0LT5kZGIucGlwZVtw aXBlXSA9IHNyYy0+ZGRiLnBpcGVbcGlwZV07Cj4gwqAJbWVtY3B5KGRzdC0+ZGRiLnlfcGxhbmVb cGlwZV0sIHNyYy0+ZGRiLnlfcGxhbmVbcGlwZV0sCj4gwqAJwqDCoMKgwqDCoMKgwqBzaXplb2Yo ZHN0LT5kZGIueV9wbGFuZVtwaXBlXSkpOwo+IMKgCW1lbWNweShkc3QtPmRkYi5wbGFuZVtwaXBl XSwgc3JjLT5kZGIucGxhbmVbcGlwZV0sCj4gQEAgLTQxOTIsNiArNDE4Miw4IEBAIHN0YXRpYyB2 b2lkIHNrbF91cGRhdGVfd20oc3RydWN0IGRybV9jcnRjCj4gKmNydGMpCj4gwqAKPiDCoAlza2xf Y29weV93bV9mb3JfcGlwZShod192YWxzLCByZXN1bHRzLCBwaXBlKTsKPiDCoAo+ICsJaW50ZWxf Y3J0Yy0+aHdfZGRiID0gY3N0YXRlLT53bS5za2wuZGRiOwo+ICsKPiDCoAltdXRleF91bmxvY2so JmRldl9wcml2LT53bS53bV9tdXRleCk7Cj4gwqB9Cj4gwqAKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1n ZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755006AbcJEUXn (ORCPT ); Wed, 5 Oct 2016 16:23:43 -0400 Received: from mga05.intel.com ([192.55.52.43]:55900 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754474AbcJEUXm (ORCPT ); Wed, 5 Oct 2016 16:23:42 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.31,302,1473145200"; d="scan'208";a="16575401" Message-ID: <1475699016.2381.55.camel@intel.com> Subject: Re: [Intel-gfx] [PATCH 1/6] 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: Wed, 05 Oct 2016 17:23:36 -0300 In-Reply-To: <1475681598-12081-2-git-send-email-cpaul@redhat.com> References: <1475681598-12081-1-git-send-email-cpaul@redhat.com> <1475681598-12081-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 Qua, 2016-10-05 às 11:33 -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. > > Signed-off-by: Lyude > Cc: Maarten Lankhorst > Cc: Ville Syrjälä > Cc: Matt Roper > --- >  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 f8c66ee..85e541c 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -1636,7 +1636,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 7f1748a..0383516 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; > @@ -3366,7 +3365,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; > + memset(alloc, 0, sizeof(*alloc)); Nitpick: I would have kept the double assignment here instead of calling memset: alloc->start = alloc->end = 0; Anyway, this chunk will have a small conflict with my current multi- pipe fix, and I'd like to see the multi-pipe fix get merged before this since it will make it much easier to backport it to stable if we don't have yet another round of code churn separating stable from dinq. Anyway, this patch looks correct and and it seems the multi-pipe fix won't require any change besides the small rebase above. I'm still going to test the series later, but I suppose a rebased version of this patch will be ready to get a reviewed-by tag from me. >   memset(ddb->plane[pipe], 0, sizeof(ddb- > >plane[pipe])); >   memset(ddb->y_plane[pipe], 0, sizeof(ddb- > >y_plane[pipe])); >   return 0; > @@ -3895,14 +3894,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) >  { > @@ -3910,22 +3901,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; >   } >   > @@ -4084,7 +4075,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], > @@ -4192,6 +4182,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); >  } >