From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH v6 6/6] drm/i915/skl: Update DDB values atomically with wms/plane attrs Date: Tue, 2 Aug 2016 18:37:37 -0400 Message-ID: <1470177458-31984-7-git-send-email-cpaul@redhat.com> References: <1470177458-31984-1-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: <1470177458-31984-1-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: Radhakrishna Sripada , linux-kernel@vger.kernel.org, Hans de Goede , dri-devel@lists.freedesktop.org, Daniel Vetter , Lyude List-Id: dri-devel@lists.freedesktop.org Tm93IHRoYXQgd2UgY2FuIGhvb2sgaW50byB1cGRhdGVfY3J0Y3MgYW5kIGNvbnRyb2wgdGhlIG9y ZGVyIGluIHdoaWNoIHdlCnVwZGF0ZSBDUlRDcyBhdCBlYWNoIG1vZGVzZXQsIHdlIGNhbiBmaW5p c2ggdGhlIGZpbmFsIHN0ZXAgb2YgZml4aW5nClNreWxha2UncyB3YXRlcm1hcmsgaGFuZGxpbmcg YnkgcGVyZm9ybWluZyBEREIgdXBkYXRlcyBhdCB0aGUgc2FtZSB0aW1lCmFzIHBsYW5lIHVwZGF0 ZXMgYW5kIHdhdGVybWFyayB1cGRhdGVzLgoKVGhlIGZpcnN0IG1ham9yIGNoYW5nZSBpbiB0aGlz IHBhdGNoIGlzIHNrbF91cGRhdGVfY3J0Y3MoKSwgd2hpY2gKaGFuZGxlcyBlbnN1cmluZyB0aGF0 IHdlIG9yZGVyIGVhY2ggQ1JUQyB1cGRhdGUgaW4gb3VyIGF0b21pYyBjb21taXRzCnByb3Blcmx5 IHNvIHRoYXQgdGhleSBob25vciB0aGUgRERCIGZsdXNoIG9yZGVyLgoKVGhlIHNlY29uZCBtYWpv ciBjaGFuZ2UgaW4gdGhpcyBwYXRjaCBpcyB0aGUgb3JkZXIgaW4gd2hpY2ggd2UgZmx1c2ggdGhl CnBpcGVzLiBXaGlsZSB0aGUgcHJldmlvdXMgb3JkZXIgbWF5IGhhdmUgd29ya2VkLCBpdCBjYW4n dCBiZSB1c2VkIGluCnRoaXMgYXBwcm9hY2ggc2luY2UgaXQgbm8gbG9uZ2VyIHdpbGwgZG8gdGhl IHJpZ2h0IHRoaW5nLiBGb3IgZXhhbXBsZSwKdXNpbmcgdGhlIG9sZCBkZGIgZmx1c2ggb3JkZXI6 CgpXZSBoYXZlIHBpcGVzIEEsIEIsIGFuZCBDIGVuYWJsZWQsIGFuZCB3ZSdyZSBkaXNhYmxpbmcg Qy4gSW5pdGlhbCBkZGIKYWxsb2NhdGlvbiBsb29rcyBsaWtlIHRoaXM6Cgp8ICAgQSAgIHwgICBC ICAgfHh4eHh4eHh8CgpTaW5jZSB3ZSdyZSBwZXJmb3JtaW5nIHRoZSBkZGIgdXBkYXRlcyBhZnRl ciBwZXJmb3JtaW5nIGFueSBDUlRDCmRpc2FibGVtZW50cyBpbiBpbnRlbF9hdG9taWNfY29tbWl0 X3RhaWwoKSwgdGhlIHNwYWNlIHRvIHRoZSByaWdodCBvZgpwaXBlIEIgaXMgdW5hbGxvY2F0ZWQu CgoxLiBGbHVzaCBwaXBlcyB3aXRoIG5ldyBhbGxvY2F0aW9uIGNvbnRhaW5lZCBpbnRvIG9sZCBz cGFjZS4gTm9uZQogICBhcHBseSwgc28gd2Ugc2tpcCB0aGlzCjIuIEZsdXNoIHBpcGVzIGhhdmlu ZyB0aGVpciBhbGxvY2F0aW9uIHJlZHVjZWQsIGJ1dCBvdmVybGFwcGluZyB3aXRoIGEKICAgcHJl dmlvdXMgYWxsb2NhdGlvbi4gTm9uZSBhcHBseSwgc28gd2UgYWxzbyBza2lwIHRoaXMKMy4gRmx1 c2ggcGlwZXMgdGhhdCBnb3QgbW9yZSBzcGFjZSBhbGxvY2F0ZWQuIFRoaXMgYXBwbGllcyB0byBB IGFuZCBCLAogICBnaXZpbmcgdXMgdGhlIGZvbGxvd2luZyB1cGRhdGUgb3JkZXI6IEEsIEIKClRo aXMgaXMgd3JvbmcsIHNpbmNlIHVwZGF0aW5nIHBpcGUgQSBmaXJzdCB3aWxsIGNhdXNlIGl0IHRv IG92ZXJsYXAgd2l0aApCIGFuZCBwb3RlbnRpYWxseSBidXJzdCBpbnRvIGZsYW1lcy4gT3VyIG5l dyBvcmRlciAoc2VlIHRoZSBjb2RlCmNvbW1lbnRzIGZvciBkZXRhaWxzKSB3b3VsZCB1cGRhdGUg dGhlIHBpcGVzIGluIHRoZSBwcm9wZXIgb3JkZXI6IEIsIEEuCgpBcyB3ZWxsLCB3ZSBjYWxjdWxh dGUgdGhlIG9yZGVyIGZvciBlYWNoIEREQiB1cGRhdGUgZHVyaW5nIHRoZSBjaGVjawpwaGFzZSwg YW5kIHJlZmVyZW5jZSBpdCBsYXRlciBpbiB0aGUgY29tbWl0IHBoYXNlIHdoZW4gd2UgaGl0CnNr bF91cGRhdGVfY3J0Y3MoKS4KClRoaXMgbG9uZyBvdmVyZHVlIHBhdGNoIGZpeGVzIHRoZSByZXN0 IG9mIHRoZSB1bmRlcnJ1bnMgb24gU2t5bGFrZS4KCkNoYW5nZXMgc2luY2UgdjE6CiAtIEFkZCBz a2xfZGRiX2VudHJ5X3dyaXRlKCkgZm9yIGN1cnNvciBpbnRvIHNrbF93cml0ZV9jdXJzb3Jfd20o KQoKRml4ZXM6IDBlOGZiN2JhN2NhNSAoImRybS9pOTE1L3NrbDogRmx1c2ggdGhlIFdNIGNvbmZp Z3VyYXRpb24iKQpGaXhlczogODIxMWJkNWJkZjVlICgiZHJtL2k5MTUvc2tsOiBQcm9ncmFtIHRo ZSBEREIgYWxsb2NhdGlvbiIpClNpZ25lZC1vZmYtYnk6IEx5dWRlIDxjcGF1bEByZWRoYXQuY29t Pgpbb21pdHRpbmcgQ0MgZm9yIHN0YWJsZSwgc2luY2UgdGhpcyBwYXRjaCB3aWxsIG5lZWQgdG8g YmUgY2hhbmdlZCBmb3IKc3VjaCBiYWNrcG9ydHMgZmlyc3RdCkNjOiBWaWxsZSBTeXJqw6Rsw6Qg PHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgpDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVs LnZldHRlckBpbnRlbC5jb20+CkNjOiBSYWRoYWtyaXNobmEgU3JpcGFkYSA8cmFkaGFrcmlzaG5h LnNyaXBhZGFAaW50ZWwuY29tPgpDYzogSGFucyBkZSBHb2VkZSA8aGRlZ29lZGVAcmVkaGF0LmNv bT4KQ2M6IE1hdHQgUm9wZXIgPG1hdHRoZXcuZC5yb3BlckBpbnRlbC5jb20+Ci0tLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIHwgMTAwICsrKysrKysrKystLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICAgIHwgIDEwICsrCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9wbS5jICAgICAgfCAyODggKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0t LS0tLS0KIDMgZmlsZXMgY2hhbmdlZCwgMjMzIGluc2VydGlvbnMoKyksIDE2NSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKaW5kZXggNTljZjUxMy4uMDYyOTVm NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwpAQCAtMTI4OTcsMTYgKzEyODk3 LDIzIEBAIHN0YXRpYyB2b2lkIHZlcmlmeV93bV9zdGF0ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMs CiAJCQkgIGh3X2VudHJ5LT5zdGFydCwgaHdfZW50cnktPmVuZCk7CiAJfQogCi0JLyogY3Vyc29y ICovCi0JaHdfZW50cnkgPSAmaHdfZGRiLnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07Ci0Jc3df ZW50cnkgPSAmc3dfZGRiLT5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdOwotCi0JaWYgKCFza2xf ZGRiX2VudHJ5X2VxdWFsKGh3X2VudHJ5LCBzd19lbnRyeSkpIHsKLQkJRFJNX0VSUk9SKCJtaXNt YXRjaCBpbiBEREIgc3RhdGUgcGlwZSAlYyBjdXJzb3IgIgotCQkJICAiKGV4cGVjdGVkICgldSwl dSksIGZvdW5kICgldSwldSkpXG4iLAotCQkJICBwaXBlX25hbWUocGlwZSksCi0JCQkgIHN3X2Vu dHJ5LT5zdGFydCwgc3dfZW50cnktPmVuZCwKLQkJCSAgaHdfZW50cnktPnN0YXJ0LCBod19lbnRy eS0+ZW5kKTsKKwkvKgorCSAqIGN1cnNvcgorCSAqIElmIHRoZSBjdXJzb3IgcGxhbmUgaXNuJ3Qg YWN0aXZlLCB3ZSBtYXkgbm90IGhhdmUgdXBkYXRlZCBpdCdzIGRkYgorCSAqIGFsbG9jYXRpb24u IEluIHRoYXQgY2FzZSBzaW5jZSB0aGUgZGRiIGFsbG9jYXRpb24gd2lsbCBiZSB1cGRhdGVkCisJ ICogb25jZSB0aGUgcGxhbmUgYmVjb21lcyB2aXNpYmxlLCB3ZSBjYW4gc2tpcCB0aGlzIGNoZWNr CisJICovCisJaWYgKGludGVsX2NydGMtPmN1cnNvcl9hZGRyKSB7CisJCWh3X2VudHJ5ID0gJmh3 X2RkYi5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdOworCQlzd19lbnRyeSA9ICZzd19kZGItPnBs YW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07CisKKwkJaWYgKCFza2xfZGRiX2VudHJ5X2VxdWFsKGh3 X2VudHJ5LCBzd19lbnRyeSkpIHsKKwkJCURSTV9FUlJPUigibWlzbWF0Y2ggaW4gRERCIHN0YXRl IHBpcGUgJWMgY3Vyc29yICIKKwkJCQkgICIoZXhwZWN0ZWQgKCV1LCV1KSwgZm91bmQgKCV1LCV1 KSlcbiIsCisJCQkJICBwaXBlX25hbWUocGlwZSksCisJCQkJICBzd19lbnRyeS0+c3RhcnQsIHN3 X2VudHJ5LT5lbmQsCisJCQkJICBod19lbnRyeS0+c3RhcnQsIGh3X2VudHJ5LT5lbmQpOworCQl9 CiAJfQogfQogCkBAIC0xMzY1OCw2ICsxMzY2NSw3MiBAQCBzdGF0aWMgdm9pZCBpbnRlbF91cGRh dGVfY3J0Y3Moc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAogCX0KIH0KIAorc3RhdGlj IGlubGluZSB2b2lkCitza2xfZG9fZGRiX3N0ZXAoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0 YXRlLAorCQllbnVtIHNrbF9kZGJfc3RlcCBzdGVwKQoreworCXN0cnVjdCBpbnRlbF9hdG9taWNf c3RhdGUgKmludGVsX3N0YXRlID0gdG9faW50ZWxfYXRvbWljX3N0YXRlKHN0YXRlKTsKKwlzdHJ1 Y3QgZHJtX2NydGMgKmNydGM7CisJc3RydWN0IGRybV9jcnRjX3N0YXRlICpvbGRfY3J0Y19zdGF0 ZTsKKwl1bnNpZ25lZCBpbnQgY3J0Y192YmxhbmtfbWFzazsgLyogdW51c2VkICovCisJaW50IGk7 CisKKwlmb3JfZWFjaF9jcnRjX2luX3N0YXRlKHN0YXRlLCBjcnRjLCBvbGRfY3J0Y19zdGF0ZSwg aSkgeworCQlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YyA9IHRvX2ludGVsX2NydGMoY3J0 Yyk7CisJCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjc3RhdGUgPQorCQkJdG9faW50ZWxfY3J0 Y19zdGF0ZShjcnRjLT5zdGF0ZSk7CisJCWJvb2wgdmJsYW5rX3dhaXQgPSBmYWxzZTsKKworCQlp ZiAoY3N0YXRlLT53bS5za2wuZGRiX3JlYWxsb2MgIT0gc3RlcCB8fCAhY3J0Yy0+c3RhdGUtPmFj dGl2ZSkKKwkJCWNvbnRpbnVlOworCisJCS8qCisJCSAqIElmIHdlJ3JlIGNoYW5naW5nIHRoZSBk ZGIgYWxsb2NhdGlvbiBvZiB0aGlzIHBpcGUgdG8gbWFrZQorCQkgKiByb29tIGZvciBhbm90aGVy IHBpcGUsIHdlIGhhdmUgdG8gd2FpdCBmb3IgdGhlIHBpcGUncyBkZGIKKwkJICogYWxsb2NhdGlv bnMgdG8gYWN0dWFsbHkgdXBkYXRlIGJ5IHdhaXRpbmcgZm9yIGEgdmJsYW5rLgorCQkgKiBPdGhl cndpc2Ugd2UgcmlzayB0aGUgbmV4dCBwaXBlIHVwZGF0aW5nIGJlZm9yZSB0aGlzIHBpcGUKKwkJ ICogZmluaXNoZXMsIHJlc3VsdGluZyBpbiB0aGUgcGlwZSBmZXRjaGluZyBmcm9tIGRkYiBzcGFj ZSBmb3IKKwkJICogdGhlIHdyb25nIHBpcGUuCisJCSAqCisJCSAqIEhvd2V2ZXIsIGlmIHdlIGtu b3cgd2UgZG9uJ3QgaGF2ZSBhbnkgbW9yZSBwaXBlcyB0byBtb3ZlCisJCSAqIGFyb3VuZCwgd2Ug Y2FuIHNraXAgdGhpcyB3YWl0IGFuZCB0aGUgbmV3IGRkYiBhbGxvY2F0aW9uCisJCSAqIHdpbGwg dGFrZSBlZmZlY3QgYXQgdGhlIHN0YXJ0IG9mIHRoZSBuZXh0IHZibGFuay4KKwkJICovCisJCXN3 aXRjaCAoc3RlcCkgeworCQljYXNlIFNLTF9EREJfU1RFUF9OT19PVkVSTEFQOgorCQljYXNlIFNL TF9EREJfU1RFUF9PVkVSTEFQOgorCQkJaWYgKHN0ZXAgIT0gaW50ZWxfc3RhdGUtPmxhc3RfZGRi X3N0ZXApCisJCQkJdmJsYW5rX3dhaXQgPSB0cnVlOworCisJCS8qIGRyb3AgdGhyb3VnaCAqLwor CQljYXNlIFNLTF9EREJfU1RFUF9GSU5BTDoKKwkJCURSTV9ERUJVR19LTVMoCisJCQkgICAgIlVw ZGF0aW5nIFtDUlRDOiVkOnBpcGUgJWNdIGZvciBEREIgc3RlcCAlZFxuIiwKKwkJCSAgICBjcnRj LT5iYXNlLmlkLCBwaXBlX25hbWUoaW50ZWxfY3J0Yy0+cGlwZSksCisJCQkgICAgc3RlcCk7CisK KwkJY2FzZSBTS0xfRERCX1NURVBfTk9ORToKKwkJCWJyZWFrOworCQl9CisKKwkJaW50ZWxfdXBk YXRlX2NydGMoY3J0Yywgc3RhdGUsIG9sZF9jcnRjX3N0YXRlLAorCQkJCSAgJmNydGNfdmJsYW5r X21hc2spOworCisJCWlmICh2Ymxhbmtfd2FpdCkKKwkJCWludGVsX3dhaXRfZm9yX3ZibGFuayhz dGF0ZS0+ZGV2LCBpbnRlbF9jcnRjLT5waXBlKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIHNrbF91 cGRhdGVfY3J0Y3Moc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAorCQkJICAgICB1bnNp Z25lZCBpbnQgKmNydGNfdmJsYW5rX21hc2spCit7CisJc3RydWN0IGludGVsX2F0b21pY19zdGF0 ZSAqaW50ZWxfc3RhdGUgPSB0b19pbnRlbF9hdG9taWNfc3RhdGUoc3RhdGUpOworCWVudW0gc2ts X2RkYl9zdGVwIHN0ZXA7CisKKwlmb3IgKHN0ZXAgPSAwOyBzdGVwIDw9IGludGVsX3N0YXRlLT5s YXN0X2RkYl9zdGVwOyBzdGVwKyspCisJCXNrbF9kb19kZGJfc3RlcChzdGF0ZSwgc3RlcCk7Cit9 CisKIHN0YXRpYyB2b2lkIGludGVsX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUpCiB7CiAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IHN0YXRlLT5kZXY7 CkBAIC0xNTIzNSw4ICsxNTMwOCw2IEBAIHZvaWQgaW50ZWxfaW5pdF9kaXNwbGF5X2hvb2tzKHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKIAkJZGV2X3ByaXYtPmRpc3BsYXkuY3J0 Y19kaXNhYmxlID0gaTl4eF9jcnRjX2Rpc2FibGU7CiAJfQogCi0JZGV2X3ByaXYtPmRpc3BsYXku dXBkYXRlX2NydGNzID0gaW50ZWxfdXBkYXRlX2NydGNzOwotCiAJLyogUmV0dXJucyB0aGUgY29y ZSBkaXNwbGF5IGNsb2NrIHNwZWVkICovCiAJaWYgKElTX1NLWUxBS0UoZGV2X3ByaXYpIHx8IElT X0tBQllMQUtFKGRldl9wcml2KSkKIAkJZGV2X3ByaXYtPmRpc3BsYXkuZ2V0X2Rpc3BsYXlfY2xv Y2tfc3BlZWQgPQpAQCAtMTUzMjYsNiArMTUzOTcsMTEgQEAgdm9pZCBpbnRlbF9pbml0X2Rpc3Bs YXlfaG9va3Moc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCQkJc2tsX21vZGVz ZXRfY2FsY19jZGNsazsKIAl9CiAKKwlpZiAoZGV2X3ByaXYtPmluZm8uZ2VuID49IDkpCisJCWRl dl9wcml2LT5kaXNwbGF5LnVwZGF0ZV9jcnRjcyA9IHNrbF91cGRhdGVfY3J0Y3M7CisJZWxzZQor CQlkZXZfcHJpdi0+ZGlzcGxheS51cGRhdGVfY3J0Y3MgPSBpbnRlbF91cGRhdGVfY3J0Y3M7CisK IAlzd2l0Y2ggKElOVEVMX0lORk8oZGV2X3ByaXYpLT5nZW4pIHsKIAljYXNlIDI6CiAJCWRldl9w cml2LT5kaXNwbGF5LnF1ZXVlX2ZsaXAgPSBpbnRlbF9nZW4yX3F1ZXVlX2ZsaXA7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2Rydi5oCmluZGV4IDFiNDQ0ZDMuLmNmNWRhODMgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2Rydi5oCkBAIC0zMzQsNiArMzM0LDcgQEAgc3RydWN0IGludGVsX2F0b21pY19zdGF0ZSB7 CiAKIAkvKiBHZW45KyBvbmx5ICovCiAJc3RydWN0IHNrbF93bV92YWx1ZXMgd21fcmVzdWx0czsK KwlpbnQgbGFzdF9kZGJfc3RlcDsKIH07CiAKIHN0cnVjdCBpbnRlbF9wbGFuZV9zdGF0ZSB7CkBA IC00MzcsNiArNDM4LDEzIEBAIHN0cnVjdCBza2xfcGlwZV93bSB7CiAJdWludDMyX3QgbGluZXRp bWU7CiB9OwogCitlbnVtIHNrbF9kZGJfc3RlcCB7CisJU0tMX0REQl9TVEVQX05PTkUgPSAwLAor CVNLTF9EREJfU1RFUF9OT19PVkVSTEFQLAorCVNLTF9EREJfU1RFUF9PVkVSTEFQLAorCVNLTF9E REJfU1RFUF9GSU5BTAorfTsKKwogc3RydWN0IGludGVsX2NydGNfd21fc3RhdGUgewogCXVuaW9u IHsKIAkJc3RydWN0IHsKQEAgLTQ2Nyw2ICs0NzUsOCBAQCBzdHJ1Y3QgaW50ZWxfY3J0Y193bV9z dGF0ZSB7CiAJCQkvKiBtaW5pbXVtIGJsb2NrIGFsbG9jYXRpb24gKi8KIAkJCXVpbnQxNl90IG1p bmltdW1fYmxvY2tzW0k5MTVfTUFYX1BMQU5FU107CiAJCQl1aW50MTZfdCBtaW5pbXVtX3lfYmxv Y2tzW0k5MTVfTUFYX1BMQU5FU107CisKKwkJCWVudW0gc2tsX2RkYl9zdGVwIGRkYl9yZWFsbG9j OwogCQl9IHNrbDsKIAl9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9wbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwppbmRleCA2ZjViZWIzLi42 MzZjOTBhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKQEAgLTM4MTYsNiArMzgxNiwxMSBAQCB2 b2lkIHNrbF93cml0ZV9wbGFuZV93bShzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YywKIAkJ CSAgIHdtLT5wbGFuZVtwaXBlXVtwbGFuZV1bbGV2ZWxdKTsKIAl9CiAJSTkxNV9XUklURShQTEFO RV9XTV9UUkFOUyhwaXBlLCBwbGFuZSksIHdtLT5wbGFuZV90cmFuc1twaXBlXVtwbGFuZV0pOwor CisJc2tsX2RkYl9lbnRyeV93cml0ZShkZXZfcHJpdiwgUExBTkVfQlVGX0NGRyhwaXBlLCBwbGFu ZSksCisJCQkgICAgJndtLT5kZGIucGxhbmVbcGlwZV1bcGxhbmVdKTsKKwlza2xfZGRiX2VudHJ5 X3dyaXRlKGRldl9wcml2LCBQTEFORV9OVjEyX0JVRl9DRkcocGlwZSwgcGxhbmUpLAorCQkJICAg ICZ3bS0+ZGRiLnlfcGxhbmVbcGlwZV1bcGxhbmVdKTsKIH0KIAogdm9pZCBza2xfd3JpdGVfY3Vy c29yX3dtKHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjLApAQCAtMzgzMiwxNzAgKzM4Mzcs NTEgQEAgdm9pZCBza2xfd3JpdGVfY3Vyc29yX3dtKHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9j cnRjLAogCQkJICAgd20tPnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl1bbGV2ZWxdKTsKIAl9CiAJ STkxNV9XUklURShDVVJfV01fVFJBTlMocGlwZSksIHdtLT5wbGFuZV90cmFuc1twaXBlXVtQTEFO RV9DVVJTT1JdKTsKLX0KLQotc3RhdGljIHZvaWQgc2tsX3dyaXRlX3dtX3ZhbHVlcyhzdHJ1Y3Qg ZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCi0JCQkJY29uc3Qgc3RydWN0IHNrbF93bV92YWx1 ZXMgKm5ldykKLXsKLQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gJmRldl9wcml2LT5kcm07Ci0J c3RydWN0IGludGVsX2NydGMgKmNydGM7Ci0KLQlmb3JfZWFjaF9pbnRlbF9jcnRjKGRldiwgY3J0 YykgewotCQlpbnQgaTsKLQkJZW51bSBwaXBlIHBpcGUgPSBjcnRjLT5waXBlOwotCi0JCWlmICgo bmV3LT5kaXJ0eV9waXBlcyAmIGRybV9jcnRjX21hc2soJmNydGMtPmJhc2UpKSA9PSAwKQotCQkJ Y29udGludWU7Ci0JCWlmICghY3J0Yy0+YWN0aXZlKQotCQkJY29udGludWU7CiAKLQkJZm9yIChp ID0gMDsgaSA8IGludGVsX251bV9wbGFuZXMoY3J0Yyk7IGkrKykgewotCQkJc2tsX2RkYl9lbnRy eV93cml0ZShkZXZfcHJpdiwKLQkJCQkJICAgIFBMQU5FX0JVRl9DRkcocGlwZSwgaSksCi0JCQkJ CSAgICAmbmV3LT5kZGIucGxhbmVbcGlwZV1baV0pOwotCQkJc2tsX2RkYl9lbnRyeV93cml0ZShk ZXZfcHJpdiwKLQkJCQkJICAgIFBMQU5FX05WMTJfQlVGX0NGRyhwaXBlLCBpKSwKLQkJCQkJICAg ICZuZXctPmRkYi55X3BsYW5lW3BpcGVdW2ldKTsKLQkJfQotCi0JCXNrbF9kZGJfZW50cnlfd3Jp dGUoZGV2X3ByaXYsIENVUl9CVUZfQ0ZHKHBpcGUpLAotCQkJCSAgICAmbmV3LT5kZGIucGxhbmVb cGlwZV1bUExBTkVfQ1VSU09SXSk7Ci0JfQorCXNrbF9kZGJfZW50cnlfd3JpdGUoZGV2X3ByaXYs IENVUl9CVUZfQ0ZHKHBpcGUpLAorCQkJICAgICZ3bS0+ZGRiLnBsYW5lW3BpcGVdW1BMQU5FX0NV UlNPUl0pOwogfQogCi0vKgotICogV2hlbiBzZXR0aW5nIHVwIGEgbmV3IEREQiBhbGxvY2F0aW9u IGFycmFuZ2VtZW50LCB3ZSBuZWVkIHRvIGNvcnJlY3RseQotICogc2VxdWVuY2UgdGhlIHRpbWVz IGF0IHdoaWNoIHRoZSBuZXcgYWxsb2NhdGlvbnMgZm9yIHRoZSBwaXBlcyBhcmUgdGFrZW4gaW50 bwotICogYWNjb3VudCBvciB3ZSdsbCBoYXZlIHBpcGVzIGZldGNoaW5nIGZyb20gc3BhY2UgcHJl dmlvdXNseSBhbGxvY2F0ZWQgdG8KLSAqIGFub3RoZXIgcGlwZS4KLSAqCi0gKiBSb3VnaGx5IHRo ZSBzZXF1ZW5jZSBsb29rcyBsaWtlOgotICogIDEuIHJlLWFsbG9jYXRlIHRoZSBwaXBlKHMpIHdp dGggdGhlIGFsbG9jYXRpb24gYmVpbmcgcmVkdWNlZCBhbmQgbm90Ci0gKiAgICAgb3ZlcmxhcHBp bmcgd2l0aCBhIHByZXZpb3VzIGxpZ2h0LXVwIHBpcGUgKGFub3RoZXIgd2F5IHRvIHB1dCBpdCBp czoKLSAqICAgICBwaXBlcyB3aXRoIHRoZWlyIG5ldyBhbGxvY2F0aW9uIHN0cmlja2x5IGluY2x1 ZGVkIGludG8gdGhlaXIgb2xkIG9uZXMpLgotICogIDIuIHJlLWFsbG9jYXRlIHRoZSBvdGhlciBw aXBlcyB0aGF0IGdldCB0aGVpciBhbGxvY2F0aW9uIHJlZHVjZWQKLSAqICAzLiBhbGxvY2F0ZSB0 aGUgcGlwZXMgaGF2aW5nIHRoZWlyIGFsbG9jYXRpb24gaW5jcmVhc2VkCi0gKgotICogU3RlcHMg MS4gYW5kIDIuIGFyZSBoZXJlIHRvIHRha2UgY2FyZSBvZiB0aGUgZm9sbG93aW5nIGNhc2U6Ci0g KiAtIEluaXRpYWxseSBEREIgbG9va3MgbGlrZSB0aGlzOgotICogICAgIHwgICBCICAgIHwgICBD ICAgIHwKLSAqIC0gZW5hYmxlIHBpcGUgQS4KLSAqIC0gcGlwZSBCIGhhcyBhIHJlZHVjZWQgRERC IGFsbG9jYXRpb24gdGhhdCBvdmVybGFwcyB3aXRoIHRoZSBvbGQgcGlwZSBDCi0gKiAgIGFsbG9j YXRpb24KLSAqICAgICB8ICBBICB8ICBCICB8ICBDICB8Ci0gKgotICogV2UgbmVlZCB0byBzZXF1 ZW5jZSB0aGUgcmUtYWxsb2NhdGlvbjogQywgQiwgQSAoYW5kIG5vdCBCLCBDLCBBKS4KLSAqLwot Ci1zdGF0aWMgdm9pZAotc2tsX3dtX2ZsdXNoX3BpcGUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg KmRldl9wcml2LCBlbnVtIHBpcGUgcGlwZSwgaW50IHBhc3MpCitzdGF0aWMgYm9vbAorc2tsX2Rk Yl9hbGxvY2F0aW9uX2VxdWFscyhjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQs CisJCQkgIGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5ldywKKwkJCSAgZW51bSBw aXBlIHBpcGUpCiB7Ci0JaW50IHBsYW5lOwotCi0JRFJNX0RFQlVHX0tNUygiZmx1c2ggcGlwZSAl YyAocGFzcyAlZClcbiIsIHBpcGVfbmFtZShwaXBlKSwgcGFzcyk7Ci0KLQlmb3JfZWFjaF9wbGFu ZShkZXZfcHJpdiwgcGlwZSwgcGxhbmUpIHsKLQkJSTkxNV9XUklURShQTEFORV9TVVJGKHBpcGUs IHBsYW5lKSwKLQkJCSAgIEk5MTVfUkVBRChQTEFORV9TVVJGKHBpcGUsIHBsYW5lKSkpOwotCX0K LQlJOTE1X1dSSVRFKENVUkJBU0UocGlwZSksIEk5MTVfUkVBRChDVVJCQVNFKHBpcGUpKSk7CisJ cmV0dXJuIG5ldy0+cGlwZVtwaXBlXS5zdGFydCA9PSBvbGQtPnBpcGVbcGlwZV0uc3RhcnQgJiYK KwkgICAgICAgbmV3LT5waXBlW3BpcGVdLmVuZCA9PSBvbGQtPnBpcGVbcGlwZV0uZW5kOwogfQog CiBzdGF0aWMgYm9vbAotc2tsX2RkYl9hbGxvY2F0aW9uX2luY2x1ZGVkKGNvbnN0IHN0cnVjdCBz a2xfZGRiX2FsbG9jYXRpb24gKm9sZCwKK3NrbF9kZGJfYWxsb2NhdGlvbl9vdmVybGFwcyhzdHJ1 Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCisJCQkgICAgY29uc3Qgc3RydWN0IHNrbF9kZGJf YWxsb2NhdGlvbiAqb2xkLAogCQkJICAgIGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24g Km5ldywKIAkJCSAgICBlbnVtIHBpcGUgcGlwZSkKIHsKLQl1aW50MTZfdCBvbGRfc2l6ZSwgbmV3 X3NpemU7Ci0KLQlvbGRfc2l6ZSA9IHNrbF9kZGJfZW50cnlfc2l6ZSgmb2xkLT5waXBlW3BpcGVd KTsKLQluZXdfc2l6ZSA9IHNrbF9kZGJfZW50cnlfc2l6ZSgmbmV3LT5waXBlW3BpcGVdKTsKLQot CXJldHVybiBvbGRfc2l6ZSAhPSBuZXdfc2l6ZSAmJgotCSAgICAgICBuZXctPnBpcGVbcGlwZV0u c3RhcnQgPj0gb2xkLT5waXBlW3BpcGVdLnN0YXJ0ICYmCi0JICAgICAgIG5ldy0+cGlwZVtwaXBl XS5lbmQgPD0gb2xkLT5waXBlW3BpcGVdLmVuZDsKLX0KLQotc3RhdGljIHZvaWQgc2tsX2ZsdXNo X3dtX3ZhbHVlcyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCi0JCQkJc3RydWN0 IHNrbF93bV92YWx1ZXMgKm5ld192YWx1ZXMpCi17Ci0Jc3RydWN0IGRybV9kZXZpY2UgKmRldiA9 ICZkZXZfcHJpdi0+ZHJtOwotCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKmN1cl9kZGIsICpu ZXdfZGRiOwotCWJvb2wgcmVhbGxvY2F0ZWRbSTkxNV9NQVhfUElQRVNdID0ge307Ci0Jc3RydWN0 IGludGVsX2NydGMgKmNydGM7Ci0JZW51bSBwaXBlIHBpcGU7Ci0KLQluZXdfZGRiID0gJm5ld192 YWx1ZXMtPmRkYjsKLQljdXJfZGRiID0gJmRldl9wcml2LT53bS5za2xfaHcuZGRiOwotCi0JLyoK LQkgKiBGaXJzdCBwYXNzOiBmbHVzaCB0aGUgcGlwZXMgd2l0aCB0aGUgbmV3IGFsbG9jYXRpb24g Y29udGFpbmVkIGludG8KLQkgKiB0aGUgb2xkIHNwYWNlLgotCSAqCi0JICogV2UnbGwgd2FpdCBm b3IgdGhlIHZibGFuayBvbiB0aG9zZSBwaXBlcyB0byBlbnN1cmUgd2UgY2FuIHNhZmVseQotCSAq IHJlLWFsbG9jYXRlIHRoZSBmcmVlZCBzcGFjZSB3aXRob3V0IHRoaXMgcGlwZSBmZXRjaGluZyBm cm9tIGl0LgotCSAqLwotCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRjKSB7Ci0JCWlmICgh Y3J0Yy0+YWN0aXZlKQotCQkJY29udGludWU7Ci0KLQkJcGlwZSA9IGNydGMtPnBpcGU7Ci0KLQkJ aWYgKCFza2xfZGRiX2FsbG9jYXRpb25faW5jbHVkZWQoY3VyX2RkYiwgbmV3X2RkYiwgcGlwZSkp Ci0JCQljb250aW51ZTsKLQotCQlza2xfd21fZmx1c2hfcGlwZShkZXZfcHJpdiwgcGlwZSwgMSk7 Ci0JCWludGVsX3dhaXRfZm9yX3ZibGFuayhkZXYsIHBpcGUpOwotCi0JCXJlYWxsb2NhdGVkW3Bp cGVdID0gdHJ1ZTsKLQl9Ci0KLQotCS8qCi0JICogU2Vjb25kIHBhc3M6IGZsdXNoIHRoZSBwaXBl cyB0aGF0IGFyZSBoYXZpbmcgdGhlaXIgYWxsb2NhdGlvbgotCSAqIHJlZHVjZWQsIGJ1dCBvdmVy bGFwcGluZyB3aXRoIGEgcHJldmlvdXMgYWxsb2NhdGlvbi4KLQkgKgotCSAqIEhlcmUgYXMgd2Vs bCB3ZSBuZWVkIHRvIHdhaXQgZm9yIHRoZSB2YmxhbmsgdG8gbWFrZSBzdXJlIHRoZSBmcmVlZAot CSAqIHNwYWNlIGlzIG5vdCB1c2VkIGFueW1vcmUuCi0JICovCi0JZm9yX2VhY2hfaW50ZWxfY3J0 YyhkZXYsIGNydGMpIHsKLQkJaWYgKCFjcnRjLT5hY3RpdmUpCi0JCQljb250aW51ZTsKLQotCQlw aXBlID0gY3J0Yy0+cGlwZTsKLQotCQlpZiAocmVhbGxvY2F0ZWRbcGlwZV0pCi0JCQljb250aW51 ZTsKLQotCQlpZiAoc2tsX2RkYl9lbnRyeV9zaXplKCZuZXdfZGRiLT5waXBlW3BpcGVdKSA8Ci0J CSAgICBza2xfZGRiX2VudHJ5X3NpemUoJmN1cl9kZGItPnBpcGVbcGlwZV0pKSB7Ci0JCQlza2xf d21fZmx1c2hfcGlwZShkZXZfcHJpdiwgcGlwZSwgMik7Ci0JCQlpbnRlbF93YWl0X2Zvcl92Ymxh bmsoZGV2LCBwaXBlKTsKLQkJCXJlYWxsb2NhdGVkW3BpcGVdID0gdHJ1ZTsKLQkJfQotCX0KLQot CS8qCi0JICogVGhpcmQgcGFzczogZmx1c2ggdGhlIHBpcGVzIHRoYXQgZ290IG1vcmUgc3BhY2Ug YWxsb2NhdGVkLgotCSAqCi0JICogV2UgZG9uJ3QgbmVlZCB0byBhY3RpdmVseSB3YWl0IGZvciB0 aGUgdXBkYXRlIGhlcmUsIG5leHQgdmJsYW5rCi0JICogd2lsbCBqdXN0IGdldCBtb3JlIEREQiBz cGFjZSB3aXRoIHRoZSBjb3JyZWN0IFdNIHZhbHVlcy4KLQkgKi8KLQlmb3JfZWFjaF9pbnRlbF9j cnRjKGRldiwgY3J0YykgewotCQlpZiAoIWNydGMtPmFjdGl2ZSkKLQkJCWNvbnRpbnVlOworCXN0 cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBzdGF0ZS0+ZGV2OworCXN0cnVjdCBpbnRlbF9jcnRjICpp bnRlbF9jcnRjOworCWVudW0gcGlwZSBvdGhlcnA7CiAKLQkJcGlwZSA9IGNydGMtPnBpcGU7CisJ Zm9yX2VhY2hfaW50ZWxfY3J0YyhkZXYsIGludGVsX2NydGMpIHsKKwkJb3RoZXJwID0gaW50ZWxf Y3J0Yy0+cGlwZTsKIAogCQkvKgotCQkgKiBBdCB0aGlzIHBvaW50LCBvbmx5IHRoZSBwaXBlcyBt b3JlIHNwYWNlIHRoYW4gYmVmb3JlIGFyZQotCQkgKiBsZWZ0IHRvIHJlLWFsbG9jYXRlLgorCQkg KiBXaGVuIGNoZWNraW5nIGZvciBvdmVybGFwcywgd2UgZG9uJ3Qgd2FudCB0bzoKKwkJICogIC0g Q29tcGFyZSBhZ2FpbnN0IG91cnNlbHZlcworCQkgKiAgLSBDb21wYXJlIGFnYWluc3QgcGlwZXMg dGhhdCB3aWxsIGJlIGRpc2FibGVkIGluIHN0ZXAgMAorCQkgKiAgLSBDb21wYXJlIGFnYWluc3Qg cGlwZXMgdGhhdCB3b24ndCBiZSBlbmFibGVkIHVudGlsIHN0ZXAgMwogCQkgKi8KLQkJaWYgKHJl YWxsb2NhdGVkW3BpcGVdKQorCQlpZiAob3RoZXJwID09IHBpcGUgfHwgIW5ldy0+cGlwZVtvdGhl cnBdLmVuZCB8fAorCQkgICAgIW9sZC0+cGlwZVtvdGhlcnBdLmVuZCkKIAkJCWNvbnRpbnVlOwog Ci0JCXNrbF93bV9mbHVzaF9waXBlKGRldl9wcml2LCBwaXBlLCAzKTsKKwkJaWYgKChuZXctPnBp cGVbcGlwZV0uc3RhcnQgPj0gb2xkLT5waXBlW290aGVycF0uc3RhcnQgJiYKKwkJICAgICBuZXct PnBpcGVbcGlwZV0uc3RhcnQgPCBvbGQtPnBpcGVbb3RoZXJwXS5lbmQpIHx8CisJCSAgICAob2xk LT5waXBlW290aGVycF0uc3RhcnQgPj0gbmV3LT5waXBlW3BpcGVdLnN0YXJ0ICYmCisJCSAgICAg b2xkLT5waXBlW290aGVycF0uc3RhcnQgPCBuZXctPnBpcGVbcGlwZV0uZW5kKSkKKwkJCXJldHVy biB0cnVlOwogCX0KKworCXJldHVybiBmYWxzZTsKIH0KIAogc3RhdGljIGludCBza2xfdXBkYXRl X3BpcGVfd20oc3RydWN0IGRybV9jcnRjX3N0YXRlICpjc3RhdGUsCkBAIC00MDM4LDggKzM5MjQs MTAgQEAgc2tsX2NvbXB1dGVfZGRiKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKIAlz dHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gc3RhdGUtPmRldjsKIAlzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGRldik7CiAJc3RydWN0IGludGVsX2F0b21pY19zdGF0 ZSAqaW50ZWxfc3RhdGUgPSB0b19pbnRlbF9hdG9taWNfc3RhdGUoc3RhdGUpOworCXN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlICpjc3RhdGU7CiAJc3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGM7 Ci0Jc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqZGRiID0gJmludGVsX3N0YXRlLT53bV9yZXN1 bHRzLmRkYjsKKwlzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGRfZGRiID0gJmRldl9wcml2 LT53bS5za2xfaHcuZGRiOworCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5ld19kZGIgPSAm aW50ZWxfc3RhdGUtPndtX3Jlc3VsdHMuZGRiOwogCXVpbnQzMl90IHJlYWxsb2NfcGlwZXMgPSBw aXBlc19tb2RpZmllZChzdGF0ZSk7CiAJaW50IHJldDsKIApAQCAtNDA3MSwxMyArMzk1OSwxMSBA QCBza2xfY29tcHV0ZV9kZGIoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQogCX0KIAog CWZvcl9lYWNoX2ludGVsX2NydGNfbWFzayhkZXYsIGludGVsX2NydGMsIHJlYWxsb2NfcGlwZXMp IHsKLQkJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZTsKLQogCQljc3RhdGUgPSBpbnRl bF9hdG9taWNfZ2V0X2NydGNfc3RhdGUoc3RhdGUsIGludGVsX2NydGMpOwogCQlpZiAoSVNfRVJS KGNzdGF0ZSkpCiAJCQlyZXR1cm4gUFRSX0VSUihjc3RhdGUpOwogCi0JCXJldCA9IHNrbF9hbGxv Y2F0ZV9waXBlX2RkYihjc3RhdGUsIGRkYik7CisJCXJldCA9IHNrbF9hbGxvY2F0ZV9waXBlX2Rk Yihjc3RhdGUsIG5ld19kZGIpOwogCQlpZiAocmV0KQogCQkJcmV0dXJuIHJldDsKIApAQCAtNDA4 Niw2ICszOTcyLDczIEBAIHNrbF9jb21wdXRlX2RkYihzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAq c3RhdGUpCiAJCQlyZXR1cm4gcmV0OwogCX0KIAorCS8qCisJICogV2hlbiBzZXR0aW5nIHVwIGEg bmV3IEREQiBhbGxvY2F0aW9uIGFycmFuZ2VtZW50LCB3ZSBuZWVkIHRvCisJICogY29ycmVjdGx5 IHNlcXVlbmNlIHRoZSB0aW1lcyBhdCB3aGljaCB0aGUgbmV3IGFsbG9jYXRpb25zIGZvciB0aGUK KwkgKiBwaXBlcyBhcmUgdGFrZW4gaW50byBhY2NvdW50IG9yIHdlJ2xsIGhhdmUgcGlwZXMgZmV0 Y2hpbmcgZnJvbSBzcGFjZQorCSAqIHByZXZpb3VzbHkgYWxsb2NhdGVkIHRvIGFub3RoZXIgcGlw ZS4KKwkgKgorCSAqIFJvdWdobHkgdGhlIGZpbmFsIHNlcXVlbmNlIHdlIHdhbnQgbG9va3MgbGlr ZSB0aGlzOgorCSAqICAxLiBEaXNhYmxlIGFueSBwaXBlcyB3ZSdyZSBub3QgZ29pbmcgdG8gYmUg dXNpbmcgYW55bW9yZQorCSAqICAyLiBSZWFsbG9jYXRlIGFsbCBvZiB0aGUgYWN0aXZlIHBpcGVz IHdob3NlIG5ldyBkZGIgYWxsb2NhdGlvbnMKKwkgKiAgd29uJ3Qgb3ZlcmxhcCB3aXRoIGFub3Ro ZXIgYWN0aXZlIHBpcGUncyBkZGIgYWxsb2NhdGlvbi4KKwkgKiAgMy4gUmVhbGxvY2F0ZSByZW1h aW5pbmcgYWN0aXZlIHBpcGVzLCBpZiBhbnkuCisJICogIDQuIEVuYWJsZSBhbnkgbmV3IHBpcGVz LCBpZiBhbnkuCisJICoKKwkgKiBFeGFtcGxlOgorCSAqIEluaXRpYWxseSBEREIgbG9va3MgbGlr ZSB0aGlzOgorCSAqICAgfCAgIEIgICAgfCAgIEMgICAgfAorCSAqIEFuZCB0aGUgZmluYWwgRERC IHNob3VsZCBsb29rIGxpa2UgdGhpczoKKwkgKiAgIHwgIEIgIHwgIEMgIHwgIEEgIHwKKwkgKgor CSAqIDEuIFdlJ3JlIG5vdCBkaXNhYmxpbmcgYW55IHBpcGVzLCBzbyBkbyBub3RoaW5nIG9uIHRo aXMgc3RlcC4KKwkgKiAyLiBQaXBlIEIncyBuZXcgYWxsb2NhdGlvbiB3b3VsZG4ndCBvdmVybGFw IHdpdGggcGlwZSBDLCBob3dldmVyCisJICogcGlwZSBDJ3MgbmV3IGFsbG9jYXRpb24gZG9lcyBv dmVybGFwIHdpdGggcGlwZSBCJ3MgY3VycmVudAorCSAqIGFsbG9jYXRpb24uIFJlYWxsb2NhdGUg QiBmaXJzdCBzbyB0aGUgRERCIGxvb2tzIGxpa2UgdGhpczoKKwkgKiAgIHwgIEIgIHx4eHwgICBD ICAgIHwKKwkgKiAzLiBOb3cgd2UgY2FuIHNhZmVseSByZWFsbG9jYXRlIHBpcGUgQyB0byBpdCdz IG5ldyBsb2NhdGlvbjoKKwkgKiAgIHwgIEIgIHwgIEMgIHx4eHh4eHwKKwkgKiA0LiBFbmFibGUg YW55IHJlbWFpbmluZyBwaXBlcywgaW4gdGhpcyBjYXNlIEEKKwkgKiAgIHwgIEIgIHwgIEMgIHwg IEEgIHwKKwkgKgorCSAqIEFzIHdlbGwsIGJldHdlZW4gZXZlcnkgcGlwZSByZWFsbG9jYXRpb24g d2UgaGF2ZSB0byB3YWl0IGZvciBhCisJICogdmJsYW5rIG9uIHRoZSBwaXBlIHNvIHRoYXQgd2Ug ZW5zdXJlIGl0J3MgbmV3IGFsbG9jYXRpb24gaGFzIHRha2VuCisJICogZWZmZWN0IGJ5IHRoZSB0 aW1lIHdlIHN0YXJ0IG1vdmluZyB0aGUgbmV4dCBwaXBlLiBUaGlzIGNhbiBiZQorCSAqIHNraXBw ZWQgb24gdGhlIGxhc3Qgc3RlcCB3ZSBuZWVkIHRvIHBlcmZvcm0sIHdoaWNoIGlzIHdoeSB3ZSBr ZWVwCisJICogdHJhY2sgb2YgdGhhdCBpbmZvcm1hdGlvbiBoZXJlLiBGb3IgZXhhbXBsZSwgaWYg d2UndmUgcmVhbGxvY2F0ZWQKKwkgKiBhbGwgdGhlIHBpcGVzIHRoYXQgbmVlZCBjaGFuZ2luZyBi eSB0aGUgdGltZSB3ZSByZWFjaCBzdGVwIDMsIHdlIGNhbgorCSAqIGZpbmlzaCB3aXRob3V0IHdh aXRpbmcgZm9yIHRoZSBwaXBlcyB3ZSBjaGFuZ2VkIGluIHN0ZXAgMyB0byB1cGRhdGUuCisJICov CisJZm9yX2VhY2hfaW50ZWxfY3J0Y19tYXNrKGRldiwgaW50ZWxfY3J0YywgcmVhbGxvY19waXBl cykgeworCQllbnVtIHBpcGUgcGlwZSA9IGludGVsX2NydGMtPnBpcGU7CisJCWVudW0gc2tsX2Rk Yl9zdGVwIHN0ZXA7CisKKwkJY3N0YXRlID0gaW50ZWxfYXRvbWljX2dldF9jcnRjX3N0YXRlKHN0 YXRlLCBpbnRlbF9jcnRjKTsKKwkJaWYgKElTX0VSUihjc3RhdGUpKQorCQkJcmV0dXJuIFBUUl9F UlIoY3N0YXRlKTsKKworCQkvKiBTdGVwIDE6IFBpcGVzIHdlJ3JlIGRpc2FibGluZyAvIGhhdmVu J3QgY2hhbmdlZCAqLworCQlpZiAoc2tsX2RkYl9hbGxvY2F0aW9uX2VxdWFscyhvbGRfZGRiLCBu ZXdfZGRiLCBwaXBlKSB8fAorCQkgICAgbmV3X2RkYi0+cGlwZVtwaXBlXS5lbmQgPT0gMCkgewor CQkJc3RlcCA9IFNLTF9EREJfU1RFUF9OT05FOworCQkvKiBTdGVwIDItMzogQWN0aXZlIHBpcGVz IHdlJ3JlIHJlYWxsb2NhdGluZyAqLworCQl9IGVsc2UgaWYgKG9sZF9kZGItPnBpcGVbcGlwZV0u ZW5kICE9IDApIHsKKwkJCWlmIChza2xfZGRiX2FsbG9jYXRpb25fb3ZlcmxhcHMoc3RhdGUsIG9s ZF9kZGIsIG5ld19kZGIsCisJCQkJCQkJcGlwZSkpCisJCQkJc3RlcCA9IFNLTF9EREJfU1RFUF9P VkVSTEFQOworCQkJZWxzZQorCQkJCXN0ZXAgPSBTS0xfRERCX1NURVBfTk9fT1ZFUkxBUDsKKwkJ LyogU3RlcCA0OiBQaXBlcyB3ZSdyZSBlbmFibGluZyAqLworCQl9IGVsc2UgeworCQkJc3RlcCA9 IFNLTF9EREJfU1RFUF9GSU5BTDsKKwkJfQorCisJCWNzdGF0ZS0+d20uc2tsLmRkYl9yZWFsbG9j ID0gc3RlcDsKKworCQlpZiAoc3RlcCA+IGludGVsX3N0YXRlLT5sYXN0X2RkYl9zdGVwKQorCQkJ aW50ZWxfc3RhdGUtPmxhc3RfZGRiX3N0ZXAgPSBzdGVwOworCX0KKwogCXJldHVybiAwOwogfQog CkBAIC00MTEwLDEwICs0MDYzLDEzIEBAIHNrbF9jb3B5X3dtX2Zvcl9waXBlKHN0cnVjdCBza2xf d21fdmFsdWVzICpkc3QsCiBzdGF0aWMgaW50CiBza2xfY29tcHV0ZV93bShzdHJ1Y3QgZHJtX2F0 b21pY19zdGF0ZSAqc3RhdGUpCiB7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2 ID0gdG9faTkxNShzdGF0ZS0+ZGV2KTsKIAlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CiAJc3RydWN0 IGRybV9jcnRjX3N0YXRlICpjc3RhdGU7CiAJc3RydWN0IGludGVsX2F0b21pY19zdGF0ZSAqaW50 ZWxfc3RhdGUgPSB0b19pbnRlbF9hdG9taWNfc3RhdGUoc3RhdGUpOwogCXN0cnVjdCBza2xfd21f dmFsdWVzICpyZXN1bHRzID0gJmludGVsX3N0YXRlLT53bV9yZXN1bHRzOworCXN0cnVjdCBza2xf ZGRiX2FsbG9jYXRpb24gKm9sZF9kZGIgPSAmZGV2X3ByaXYtPndtLnNrbF9ody5kZGI7CisJc3Ry dWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqbmV3X2RkYiA9ICZyZXN1bHRzLT5kZGI7CiAJc3RydWN0 IHNrbF9waXBlX3dtICpwaXBlX3dtOwogCWJvb2wgY2hhbmdlZCA9IGZhbHNlOwogCWludCByZXQs IGk7CkBAIC00MTUyLDcgKzQxMDgsMTAgQEAgc2tsX2NvbXB1dGVfd20oc3RydWN0IGRybV9hdG9t aWNfc3RhdGUgKnN0YXRlKQogCQlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YyA9IHRvX2lu dGVsX2NydGMoY3J0Yyk7CiAJCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICppbnRlbF9jc3RhdGUg PQogCQkJdG9faW50ZWxfY3J0Y19zdGF0ZShjc3RhdGUpOworCQllbnVtIHNrbF9kZGJfc3RlcCBz dGVwOworCQllbnVtIHBpcGUgcGlwZTsKIAorCQlwaXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsKIAkJ cGlwZV93bSA9ICZpbnRlbF9jc3RhdGUtPndtLnNrbC5vcHRpbWFsOwogCQlyZXQgPSBza2xfdXBk YXRlX3BpcGVfd20oY3N0YXRlLCAmcmVzdWx0cy0+ZGRiLCBwaXBlX3dtLAogCQkJCQkgJmNoYW5n ZWQpOwpAQCAtNDE2Nyw3ICs0MTI2LDE4IEBAIHNrbF9jb21wdXRlX3dtKHN0cnVjdCBkcm1fYXRv bWljX3N0YXRlICpzdGF0ZSkKIAkJCWNvbnRpbnVlOwogCiAJCWludGVsX2NzdGF0ZS0+dXBkYXRl X3dtX3ByZSA9IHRydWU7CisJCXN0ZXAgPSBpbnRlbF9jc3RhdGUtPndtLnNrbC5kZGJfcmVhbGxv YzsKIAkJc2tsX2NvbXB1dGVfd21fcmVzdWx0cyhjcnRjLT5kZXYsIHBpcGVfd20sIHJlc3VsdHMs IGludGVsX2NydGMpOworCisJCWlmICghc2tsX2RkYl9lbnRyeV9lcXVhbCgmb2xkX2RkYi0+cGlw ZVtwaXBlXSwKKwkJCQkJICZuZXdfZGRiLT5waXBlW3BpcGVdKSkgeworCQkJRFJNX0RFQlVHX0tN UygKKwkJCSAgICAiRERCIGNoYW5nZXMgZm9yIFtDUlRDOiVkOnBpcGUgJWNdOiAoJTNkIC0gJTNk KSAtPiAoJTNkIC0gJTNkKSBvbiBzdGVwICVkXG4iLAorCQkJICAgIGludGVsX2NydGMtPmJhc2Uu YmFzZS5pZCwgcGlwZV9uYW1lKHBpcGUpLAorCQkJICAgIG9sZF9kZGItPnBpcGVbcGlwZV0uc3Rh cnQsIG9sZF9kZGItPnBpcGVbcGlwZV0uZW5kLAorCQkJICAgIG5ld19kZGItPnBpcGVbcGlwZV0u c3RhcnQsIG5ld19kZGItPnBpcGVbcGlwZV0uZW5kLAorCQkJICAgIHN0ZXApOworCQl9CiAJfQog CiAJcmV0dXJuIDA7CkBAIC00MTkxLDggKzQxNjEsMjAgQEAgc3RhdGljIHZvaWQgc2tsX3VwZGF0 ZV93bShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCiAKIAltdXRleF9sb2NrKCZkZXZfcHJpdi0+d20u d21fbXV0ZXgpOwogCi0Jc2tsX3dyaXRlX3dtX3ZhbHVlcyhkZXZfcHJpdiwgcmVzdWx0cyk7Ci0J c2tsX2ZsdXNoX3dtX3ZhbHVlcyhkZXZfcHJpdiwgcmVzdWx0cyk7CisJLyoKKwkgKiBJZiB0aGlz IHBpcGUgaXNuJ3QgYWN0aXZlIGFscmVhZHksIHdlJ3JlIGdvaW5nIHRvIGJlIGVuYWJsaW5nIGl0 CisJICogdmVyeSBzb29uLiBTaW5jZSBpdCdzIHNhZmUgdG8gdXBkYXRlIHRoZXNlIHdoaWxlIHRo ZSBwaXBlJ3Mgc2h1dCBvZmYsCisJICoganVzdCBkbyBzbyBoZXJlLiBBbHJlYWR5IGFjdGl2ZSBw aXBlcyB3aWxsIGhhdmUgdGhlaXIgd2F0ZXJtYXJrcworCSAqIHVwZGF0ZWQgb25jZSB3ZSB1cGRh dGUgdGhlaXIgcGxhbmVzLgorCSAqLworCWlmICghaW50ZWxfY3J0Yy0+YWN0aXZlKSB7CisJCWlu dCBwbGFuZTsKKworCQlmb3IgKHBsYW5lID0gMDsgcGxhbmUgPCBpbnRlbF9udW1fcGxhbmVzKGlu dGVsX2NydGMpOyBwbGFuZSsrKQorCQkJc2tsX3dyaXRlX3BsYW5lX3dtKGludGVsX2NydGMsIHJl c3VsdHMsIHBsYW5lKTsKKworCQlza2xfd3JpdGVfY3Vyc29yX3dtKGludGVsX2NydGMsIHJlc3Vs dHMpOworCX0KIAogCS8qCiAJICogU3RvcmUgdGhlIG5ldyBjb25maWd1cmF0aW9uIChidXQgb25s eSBmb3IgdGhlIHBpcGVzIHRoYXQgaGF2ZQotLSAKMi43LjQKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRl dmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756576AbcHBWqf (ORCPT ); Tue, 2 Aug 2016 18:46:35 -0400 Received: from mx1.redhat.com ([209.132.183.28]:49670 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756456AbcHBWqY (ORCPT ); Tue, 2 Aug 2016 18:46:24 -0400 From: Lyude To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: Lyude , Daniel Vetter , Radhakrishna Sripada , Hans de Goede , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 6/6] drm/i915/skl: Update DDB values atomically with wms/plane attrs Date: Tue, 2 Aug 2016 18:37:37 -0400 Message-Id: <1470177458-31984-7-git-send-email-cpaul@redhat.com> In-Reply-To: <1470177458-31984-1-git-send-email-cpaul@redhat.com> References: <1470177458-31984-1-git-send-email-cpaul@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.39]); Tue, 02 Aug 2016 22:38:28 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Now that we can hook into update_crtcs and control the order in which we update CRTCs at each modeset, we can finish the final step of fixing Skylake's watermark handling by performing DDB updates at the same time as plane updates and watermark updates. The first major change in this patch is skl_update_crtcs(), which handles ensuring that we order each CRTC update in our atomic commits properly so that they honor the DDB flush order. The second major change in this patch is the order in which we flush the pipes. While the previous order may have worked, it can't be used in this approach since it no longer will do the right thing. For example, using the old ddb flush order: We have pipes A, B, and C enabled, and we're disabling C. Initial ddb allocation looks like this: | A | B |xxxxxxx| Since we're performing the ddb updates after performing any CRTC disablements in intel_atomic_commit_tail(), the space to the right of pipe B is unallocated. 1. Flush pipes with new allocation contained into old space. None apply, so we skip this 2. Flush pipes having their allocation reduced, but overlapping with a previous allocation. None apply, so we also skip this 3. Flush pipes that got more space allocated. This applies to A and B, giving us the following update order: A, B This is wrong, since updating pipe A first will cause it to overlap with B and potentially burst into flames. Our new order (see the code comments for details) would update the pipes in the proper order: B, A. As well, we calculate the order for each DDB update during the check phase, and reference it later in the commit phase when we hit skl_update_crtcs(). This long overdue patch fixes the rest of the underruns on Skylake. Changes since v1: - Add skl_ddb_entry_write() for cursor into skl_write_cursor_wm() Fixes: 0e8fb7ba7ca5 ("drm/i915/skl: Flush the WM configuration") Fixes: 8211bd5bdf5e ("drm/i915/skl: Program the DDB allocation") Signed-off-by: Lyude [omitting CC for stable, since this patch will need to be changed for such backports first] Cc: Ville Syrjälä Cc: Daniel Vetter Cc: Radhakrishna Sripada Cc: Hans de Goede Cc: Matt Roper --- drivers/gpu/drm/i915/intel_display.c | 100 ++++++++++-- drivers/gpu/drm/i915/intel_drv.h | 10 ++ drivers/gpu/drm/i915/intel_pm.c | 288 ++++++++++++++++------------------- 3 files changed, 233 insertions(+), 165 deletions(-) diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 59cf513..06295f7 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -12897,16 +12897,23 @@ static void verify_wm_state(struct drm_crtc *crtc, hw_entry->start, hw_entry->end); } - /* cursor */ - hw_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; - sw_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; - - if (!skl_ddb_entry_equal(hw_entry, sw_entry)) { - DRM_ERROR("mismatch in DDB state pipe %c cursor " - "(expected (%u,%u), found (%u,%u))\n", - pipe_name(pipe), - sw_entry->start, sw_entry->end, - hw_entry->start, hw_entry->end); + /* + * cursor + * If the cursor plane isn't active, we may not have updated it's ddb + * allocation. In that case since the ddb allocation will be updated + * once the plane becomes visible, we can skip this check + */ + if (intel_crtc->cursor_addr) { + hw_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; + sw_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; + + if (!skl_ddb_entry_equal(hw_entry, sw_entry)) { + DRM_ERROR("mismatch in DDB state pipe %c cursor " + "(expected (%u,%u), found (%u,%u))\n", + pipe_name(pipe), + sw_entry->start, sw_entry->end, + hw_entry->start, hw_entry->end); + } } } @@ -13658,6 +13665,72 @@ static void intel_update_crtcs(struct drm_atomic_state *state, } } +static inline void +skl_do_ddb_step(struct drm_atomic_state *state, + enum skl_ddb_step step) +{ + struct intel_atomic_state *intel_state = to_intel_atomic_state(state); + struct drm_crtc *crtc; + struct drm_crtc_state *old_crtc_state; + unsigned int crtc_vblank_mask; /* unused */ + int i; + + for_each_crtc_in_state(state, crtc, old_crtc_state, i) { + struct intel_crtc *intel_crtc = to_intel_crtc(crtc); + struct intel_crtc_state *cstate = + to_intel_crtc_state(crtc->state); + bool vblank_wait = false; + + if (cstate->wm.skl.ddb_realloc != step || !crtc->state->active) + continue; + + /* + * If we're changing the ddb allocation of this pipe to make + * room for another pipe, we have to wait for the pipe's ddb + * allocations to actually update by waiting for a vblank. + * Otherwise we risk the next pipe updating before this pipe + * finishes, resulting in the pipe fetching from ddb space for + * the wrong pipe. + * + * However, if we know we don't have any more pipes to move + * around, we can skip this wait and the new ddb allocation + * will take effect at the start of the next vblank. + */ + switch (step) { + case SKL_DDB_STEP_NO_OVERLAP: + case SKL_DDB_STEP_OVERLAP: + if (step != intel_state->last_ddb_step) + vblank_wait = true; + + /* drop through */ + case SKL_DDB_STEP_FINAL: + DRM_DEBUG_KMS( + "Updating [CRTC:%d:pipe %c] for DDB step %d\n", + crtc->base.id, pipe_name(intel_crtc->pipe), + step); + + case SKL_DDB_STEP_NONE: + break; + } + + intel_update_crtc(crtc, state, old_crtc_state, + &crtc_vblank_mask); + + if (vblank_wait) + intel_wait_for_vblank(state->dev, intel_crtc->pipe); + } +} + +static void skl_update_crtcs(struct drm_atomic_state *state, + unsigned int *crtc_vblank_mask) +{ + struct intel_atomic_state *intel_state = to_intel_atomic_state(state); + enum skl_ddb_step step; + + for (step = 0; step <= intel_state->last_ddb_step; step++) + skl_do_ddb_step(state, step); +} + static void intel_atomic_commit_tail(struct drm_atomic_state *state) { struct drm_device *dev = state->dev; @@ -15235,8 +15308,6 @@ void intel_init_display_hooks(struct drm_i915_private *dev_priv) dev_priv->display.crtc_disable = i9xx_crtc_disable; } - dev_priv->display.update_crtcs = intel_update_crtcs; - /* Returns the core display clock speed */ if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)) dev_priv->display.get_display_clock_speed = @@ -15326,6 +15397,11 @@ void intel_init_display_hooks(struct drm_i915_private *dev_priv) skl_modeset_calc_cdclk; } + if (dev_priv->info.gen >= 9) + dev_priv->display.update_crtcs = skl_update_crtcs; + else + dev_priv->display.update_crtcs = intel_update_crtcs; + switch (INTEL_INFO(dev_priv)->gen) { case 2: dev_priv->display.queue_flip = intel_gen2_queue_flip; diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 1b444d3..cf5da83 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -334,6 +334,7 @@ struct intel_atomic_state { /* Gen9+ only */ struct skl_wm_values wm_results; + int last_ddb_step; }; struct intel_plane_state { @@ -437,6 +438,13 @@ struct skl_pipe_wm { uint32_t linetime; }; +enum skl_ddb_step { + SKL_DDB_STEP_NONE = 0, + SKL_DDB_STEP_NO_OVERLAP, + SKL_DDB_STEP_OVERLAP, + SKL_DDB_STEP_FINAL +}; + struct intel_crtc_wm_state { union { struct { @@ -467,6 +475,8 @@ struct intel_crtc_wm_state { /* minimum block allocation */ uint16_t minimum_blocks[I915_MAX_PLANES]; uint16_t minimum_y_blocks[I915_MAX_PLANES]; + + enum skl_ddb_step ddb_realloc; } skl; }; diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c index 6f5beb3..636c90a 100644 --- a/drivers/gpu/drm/i915/intel_pm.c +++ b/drivers/gpu/drm/i915/intel_pm.c @@ -3816,6 +3816,11 @@ void skl_write_plane_wm(struct intel_crtc *intel_crtc, wm->plane[pipe][plane][level]); } I915_WRITE(PLANE_WM_TRANS(pipe, plane), wm->plane_trans[pipe][plane]); + + skl_ddb_entry_write(dev_priv, PLANE_BUF_CFG(pipe, plane), + &wm->ddb.plane[pipe][plane]); + skl_ddb_entry_write(dev_priv, PLANE_NV12_BUF_CFG(pipe, plane), + &wm->ddb.y_plane[pipe][plane]); } void skl_write_cursor_wm(struct intel_crtc *intel_crtc, @@ -3832,170 +3837,51 @@ void skl_write_cursor_wm(struct intel_crtc *intel_crtc, wm->plane[pipe][PLANE_CURSOR][level]); } I915_WRITE(CUR_WM_TRANS(pipe), wm->plane_trans[pipe][PLANE_CURSOR]); -} - -static void skl_write_wm_values(struct drm_i915_private *dev_priv, - const struct skl_wm_values *new) -{ - struct drm_device *dev = &dev_priv->drm; - struct intel_crtc *crtc; - - for_each_intel_crtc(dev, crtc) { - int i; - enum pipe pipe = crtc->pipe; - - if ((new->dirty_pipes & drm_crtc_mask(&crtc->base)) == 0) - continue; - if (!crtc->active) - continue; - for (i = 0; i < intel_num_planes(crtc); i++) { - skl_ddb_entry_write(dev_priv, - PLANE_BUF_CFG(pipe, i), - &new->ddb.plane[pipe][i]); - skl_ddb_entry_write(dev_priv, - PLANE_NV12_BUF_CFG(pipe, i), - &new->ddb.y_plane[pipe][i]); - } - - skl_ddb_entry_write(dev_priv, CUR_BUF_CFG(pipe), - &new->ddb.plane[pipe][PLANE_CURSOR]); - } + skl_ddb_entry_write(dev_priv, CUR_BUF_CFG(pipe), + &wm->ddb.plane[pipe][PLANE_CURSOR]); } -/* - * When setting up a new DDB allocation arrangement, we need to correctly - * sequence the times at which the new allocations for the pipes are taken into - * account or we'll have pipes fetching from space previously allocated to - * another pipe. - * - * Roughly the sequence looks like: - * 1. re-allocate the pipe(s) with the allocation being reduced and not - * overlapping with a previous light-up pipe (another way to put it is: - * pipes with their new allocation strickly included into their old ones). - * 2. re-allocate the other pipes that get their allocation reduced - * 3. allocate the pipes having their allocation increased - * - * Steps 1. and 2. are here to take care of the following case: - * - Initially DDB looks like this: - * | B | C | - * - enable pipe A. - * - pipe B has a reduced DDB allocation that overlaps with the old pipe C - * allocation - * | A | B | C | - * - * We need to sequence the re-allocation: C, B, A (and not B, C, A). - */ - -static void -skl_wm_flush_pipe(struct drm_i915_private *dev_priv, enum pipe pipe, int pass) +static bool +skl_ddb_allocation_equals(const struct skl_ddb_allocation *old, + const struct skl_ddb_allocation *new, + enum pipe pipe) { - int plane; - - DRM_DEBUG_KMS("flush pipe %c (pass %d)\n", pipe_name(pipe), pass); - - for_each_plane(dev_priv, pipe, plane) { - I915_WRITE(PLANE_SURF(pipe, plane), - I915_READ(PLANE_SURF(pipe, plane))); - } - I915_WRITE(CURBASE(pipe), I915_READ(CURBASE(pipe))); + return new->pipe[pipe].start == old->pipe[pipe].start && + new->pipe[pipe].end == old->pipe[pipe].end; } static bool -skl_ddb_allocation_included(const struct skl_ddb_allocation *old, +skl_ddb_allocation_overlaps(struct drm_atomic_state *state, + const struct skl_ddb_allocation *old, const struct skl_ddb_allocation *new, enum pipe pipe) { - uint16_t old_size, new_size; - - old_size = skl_ddb_entry_size(&old->pipe[pipe]); - new_size = skl_ddb_entry_size(&new->pipe[pipe]); - - return old_size != new_size && - new->pipe[pipe].start >= old->pipe[pipe].start && - new->pipe[pipe].end <= old->pipe[pipe].end; -} - -static void skl_flush_wm_values(struct drm_i915_private *dev_priv, - struct skl_wm_values *new_values) -{ - struct drm_device *dev = &dev_priv->drm; - struct skl_ddb_allocation *cur_ddb, *new_ddb; - bool reallocated[I915_MAX_PIPES] = {}; - struct intel_crtc *crtc; - enum pipe pipe; - - new_ddb = &new_values->ddb; - cur_ddb = &dev_priv->wm.skl_hw.ddb; - - /* - * First pass: flush the pipes with the new allocation contained into - * the old space. - * - * We'll wait for the vblank on those pipes to ensure we can safely - * re-allocate the freed space without this pipe fetching from it. - */ - for_each_intel_crtc(dev, crtc) { - if (!crtc->active) - continue; - - pipe = crtc->pipe; - - if (!skl_ddb_allocation_included(cur_ddb, new_ddb, pipe)) - continue; - - skl_wm_flush_pipe(dev_priv, pipe, 1); - intel_wait_for_vblank(dev, pipe); - - reallocated[pipe] = true; - } - - - /* - * Second pass: flush the pipes that are having their allocation - * reduced, but overlapping with a previous allocation. - * - * Here as well we need to wait for the vblank to make sure the freed - * space is not used anymore. - */ - for_each_intel_crtc(dev, crtc) { - if (!crtc->active) - continue; - - pipe = crtc->pipe; - - if (reallocated[pipe]) - continue; - - if (skl_ddb_entry_size(&new_ddb->pipe[pipe]) < - skl_ddb_entry_size(&cur_ddb->pipe[pipe])) { - skl_wm_flush_pipe(dev_priv, pipe, 2); - intel_wait_for_vblank(dev, pipe); - reallocated[pipe] = true; - } - } - - /* - * Third pass: flush the pipes that got more space allocated. - * - * We don't need to actively wait for the update here, next vblank - * will just get more DDB space with the correct WM values. - */ - for_each_intel_crtc(dev, crtc) { - if (!crtc->active) - continue; + struct drm_device *dev = state->dev; + struct intel_crtc *intel_crtc; + enum pipe otherp; - pipe = crtc->pipe; + for_each_intel_crtc(dev, intel_crtc) { + otherp = intel_crtc->pipe; /* - * At this point, only the pipes more space than before are - * left to re-allocate. + * When checking for overlaps, we don't want to: + * - Compare against ourselves + * - Compare against pipes that will be disabled in step 0 + * - Compare against pipes that won't be enabled until step 3 */ - if (reallocated[pipe]) + if (otherp == pipe || !new->pipe[otherp].end || + !old->pipe[otherp].end) continue; - skl_wm_flush_pipe(dev_priv, pipe, 3); + if ((new->pipe[pipe].start >= old->pipe[otherp].start && + new->pipe[pipe].start < old->pipe[otherp].end) || + (old->pipe[otherp].start >= new->pipe[pipe].start && + old->pipe[otherp].start < new->pipe[pipe].end)) + return true; } + + return false; } static int skl_update_pipe_wm(struct drm_crtc_state *cstate, @@ -4038,8 +3924,10 @@ skl_compute_ddb(struct drm_atomic_state *state) 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 intel_crtc_state *cstate; struct intel_crtc *intel_crtc; - struct skl_ddb_allocation *ddb = &intel_state->wm_results.ddb; + struct skl_ddb_allocation *old_ddb = &dev_priv->wm.skl_hw.ddb; + struct skl_ddb_allocation *new_ddb = &intel_state->wm_results.ddb; uint32_t realloc_pipes = pipes_modified(state); int ret; @@ -4071,13 +3959,11 @@ skl_compute_ddb(struct drm_atomic_state *state) } for_each_intel_crtc_mask(dev, intel_crtc, realloc_pipes) { - struct intel_crtc_state *cstate; - cstate = intel_atomic_get_crtc_state(state, intel_crtc); if (IS_ERR(cstate)) return PTR_ERR(cstate); - ret = skl_allocate_pipe_ddb(cstate, ddb); + ret = skl_allocate_pipe_ddb(cstate, new_ddb); if (ret) return ret; @@ -4086,6 +3972,73 @@ skl_compute_ddb(struct drm_atomic_state *state) return ret; } + /* + * When setting up a new DDB allocation arrangement, we need to + * correctly sequence the times at which the new allocations for the + * pipes are taken into account or we'll have pipes fetching from space + * previously allocated to another pipe. + * + * Roughly the final sequence we want looks like this: + * 1. Disable any pipes we're not going to be using anymore + * 2. Reallocate all of the active pipes whose new ddb allocations + * won't overlap with another active pipe's ddb allocation. + * 3. Reallocate remaining active pipes, if any. + * 4. Enable any new pipes, if any. + * + * Example: + * Initially DDB looks like this: + * | B | C | + * And the final DDB should look like this: + * | B | C | A | + * + * 1. We're not disabling any pipes, so do nothing on this step. + * 2. Pipe B's new allocation wouldn't overlap with pipe C, however + * pipe C's new allocation does overlap with pipe B's current + * allocation. Reallocate B first so the DDB looks like this: + * | B |xx| C | + * 3. Now we can safely reallocate pipe C to it's new location: + * | B | C |xxxxx| + * 4. Enable any remaining pipes, in this case A + * | B | C | A | + * + * As well, between every pipe reallocation we have to wait for a + * vblank on the pipe so that we ensure it's new allocation has taken + * effect by the time we start moving the next pipe. This can be + * skipped on the last step we need to perform, which is why we keep + * track of that information here. For example, if we've reallocated + * all the pipes that need changing by the time we reach step 3, we can + * finish without waiting for the pipes we changed in step 3 to update. + */ + for_each_intel_crtc_mask(dev, intel_crtc, realloc_pipes) { + enum pipe pipe = intel_crtc->pipe; + enum skl_ddb_step step; + + cstate = intel_atomic_get_crtc_state(state, intel_crtc); + if (IS_ERR(cstate)) + return PTR_ERR(cstate); + + /* Step 1: Pipes we're disabling / haven't changed */ + if (skl_ddb_allocation_equals(old_ddb, new_ddb, pipe) || + new_ddb->pipe[pipe].end == 0) { + step = SKL_DDB_STEP_NONE; + /* Step 2-3: Active pipes we're reallocating */ + } else if (old_ddb->pipe[pipe].end != 0) { + if (skl_ddb_allocation_overlaps(state, old_ddb, new_ddb, + pipe)) + step = SKL_DDB_STEP_OVERLAP; + else + step = SKL_DDB_STEP_NO_OVERLAP; + /* Step 4: Pipes we're enabling */ + } else { + step = SKL_DDB_STEP_FINAL; + } + + cstate->wm.skl.ddb_realloc = step; + + if (step > intel_state->last_ddb_step) + intel_state->last_ddb_step = step; + } + return 0; } @@ -4110,10 +4063,13 @@ skl_copy_wm_for_pipe(struct skl_wm_values *dst, static int skl_compute_wm(struct drm_atomic_state *state) { + struct drm_i915_private *dev_priv = to_i915(state->dev); struct drm_crtc *crtc; struct drm_crtc_state *cstate; struct intel_atomic_state *intel_state = to_intel_atomic_state(state); struct skl_wm_values *results = &intel_state->wm_results; + struct skl_ddb_allocation *old_ddb = &dev_priv->wm.skl_hw.ddb; + struct skl_ddb_allocation *new_ddb = &results->ddb; struct skl_pipe_wm *pipe_wm; bool changed = false; int ret, i; @@ -4152,7 +4108,10 @@ skl_compute_wm(struct drm_atomic_state *state) struct intel_crtc *intel_crtc = to_intel_crtc(crtc); struct intel_crtc_state *intel_cstate = to_intel_crtc_state(cstate); + enum skl_ddb_step step; + enum pipe pipe; + pipe = intel_crtc->pipe; pipe_wm = &intel_cstate->wm.skl.optimal; ret = skl_update_pipe_wm(cstate, &results->ddb, pipe_wm, &changed); @@ -4167,7 +4126,18 @@ skl_compute_wm(struct drm_atomic_state *state) continue; intel_cstate->update_wm_pre = true; + step = intel_cstate->wm.skl.ddb_realloc; skl_compute_wm_results(crtc->dev, pipe_wm, results, intel_crtc); + + if (!skl_ddb_entry_equal(&old_ddb->pipe[pipe], + &new_ddb->pipe[pipe])) { + DRM_DEBUG_KMS( + "DDB changes for [CRTC:%d:pipe %c]: (%3d - %3d) -> (%3d - %3d) on step %d\n", + intel_crtc->base.base.id, pipe_name(pipe), + old_ddb->pipe[pipe].start, old_ddb->pipe[pipe].end, + new_ddb->pipe[pipe].start, new_ddb->pipe[pipe].end, + step); + } } return 0; @@ -4191,8 +4161,20 @@ static void skl_update_wm(struct drm_crtc *crtc) mutex_lock(&dev_priv->wm.wm_mutex); - skl_write_wm_values(dev_priv, results); - skl_flush_wm_values(dev_priv, results); + /* + * If this pipe isn't active already, we're going to be enabling it + * very soon. Since it's safe to update these while the pipe's shut off, + * just do so here. Already active pipes will have their watermarks + * updated once we update their planes. + */ + if (!intel_crtc->active) { + int plane; + + for (plane = 0; plane < intel_num_planes(intel_crtc); plane++) + skl_write_plane_wm(intel_crtc, results, plane); + + skl_write_cursor_wm(intel_crtc, results); + } /* * Store the new configuration (but only for the pipes that have -- 2.7.4