From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sean Paul Subject: [PATCH v2 5/6] drm/msm: Remove msm_commit/worker, use atomic helper commit Date: Wed, 28 Mar 2018 15:06:51 -0400 Message-ID: <20180328190657.218661-6-seanpaul@chromium.org> References: <20180328190657.218661-1-seanpaul@chromium.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180328190657.218661-1-seanpaul-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: freedreno-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Freedreno" To: freedreno-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Cc: architt-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, abhinavk-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, robdclark-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, Sean Paul , jsanka-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, hoegsberg-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org List-Id: linux-arm-msm@vger.kernel.org TW92aW5nIGZ1cnRoZXIgdG93YXJkcyBzd2l0Y2hpbmcgZnVsbHkgdG8gdGhlIHRoZSBhdG9taWMg aGVscGVycywgdGhpcwpwYXRjaCByZW1vdmVzIHRoZSBoYW5kLXJvbGxlZCB3b3JrZXIgbm9uYmxv Y2sgY29tbWl0IGNvZGUgYW5kIHVzZXMgdGhlCmF0b21pYyBoZWxwZXJzIGNvbW1pdF93b3JrIG1v ZGVsLgoKQ2hhbmdlcyBpbiB2MjoKLSBSZW1vdmUgY29tbWl0X2Rlc3Ryb3koKQotIFNodWZmbGUg b3JkZXIgb2YgY29tbWl0X3RhaWwgY2FsbHMgdG8gZnVydGhlciBzZXJpYWxpemUgY29tbWl0cwot IFVzZSBzdGFsbCBpbiBzd2FwX3N0YXRlIHRvIGF2b2lkIGFiYW5kb25lZCBldmVudHMgb24gZGlz YWJsZQoKU2lnbmVkLW9mZi1ieTogU2VhbiBQYXVsIDxzZWFucGF1bEBjaHJvbWl1bS5vcmc+Ci0t LQogZHJpdmVycy9ncHUvZHJtL21zbS9tc21fYXRvbWljLmMgfCAxNTMgKysrKysrKysrLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMgICAgfCAgIDEg LQogZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmggICAgfCAgIDQgLQogMyBmaWxlcyBjaGFu Z2VkLCA0MiBpbnNlcnRpb25zKCspLCAxMTYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL21zbS9tc21fYXRvbWljLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9h dG9taWMuYwppbmRleCA2NzFhMThlZTk3N2QuLjUyMjQ5NTY1Y2MwMyAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL21zbS9tc21fYXRvbWljLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9t c21fYXRvbWljLmMKQEAgLTIwLDY2ICsyMCw2IEBACiAjaW5jbHVkZSAibXNtX2dlbS5oIgogI2lu Y2x1ZGUgIm1zbV9mZW5jZS5oIgogCi1zdHJ1Y3QgbXNtX2NvbW1pdCB7Ci0Jc3RydWN0IGRybV9k ZXZpY2UgKmRldjsKLQlzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGU7Ci0Jc3RydWN0IHdv cmtfc3RydWN0IHdvcms7Ci0JdWludDMyX3QgY3J0Y19tYXNrOwotfTsKLQotc3RhdGljIHZvaWQg Y29tbWl0X3dvcmtlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwotCi0vKiBibG9jayB1bnRp bCBzcGVjaWZpZWQgY3J0Y3MgYXJlIG5vIGxvbmdlciBwZW5kaW5nIHVwZGF0ZSwgYW5kCi0gKiBh dG9taWNhbGx5IG1hcmsgdGhlbSBhcyBwZW5kaW5nIHVwZGF0ZQotICovCi1zdGF0aWMgaW50IHN0 YXJ0X2F0b21pYyhzdHJ1Y3QgbXNtX2RybV9wcml2YXRlICpwcml2LCB1aW50MzJfdCBjcnRjX21h c2spCi17Ci0JaW50IHJldDsKLQotCXNwaW5fbG9jaygmcHJpdi0+cGVuZGluZ19jcnRjc19ldmVu dC5sb2NrKTsKLQlyZXQgPSB3YWl0X2V2ZW50X2ludGVycnVwdGlibGVfbG9ja2VkKHByaXYtPnBl bmRpbmdfY3J0Y3NfZXZlbnQsCi0JCQkhKHByaXYtPnBlbmRpbmdfY3J0Y3MgJiBjcnRjX21hc2sp KTsKLQlpZiAocmV0ID09IDApIHsKLQkJREJHKCJzdGFydDogJTA4eCIsIGNydGNfbWFzayk7Ci0J CXByaXYtPnBlbmRpbmdfY3J0Y3MgfD0gY3J0Y19tYXNrOwotCX0KLQlzcGluX3VubG9jaygmcHJp di0+cGVuZGluZ19jcnRjc19ldmVudC5sb2NrKTsKLQotCXJldHVybiByZXQ7Ci19Ci0KLS8qIGNs ZWFyIHNwZWNpZmllZCBjcnRjcyAobm8gbG9uZ2VyIHBlbmRpbmcgdXBkYXRlKQotICovCi1zdGF0 aWMgdm9pZCBlbmRfYXRvbWljKHN0cnVjdCBtc21fZHJtX3ByaXZhdGUgKnByaXYsIHVpbnQzMl90 IGNydGNfbWFzaykKLXsKLQlzcGluX2xvY2soJnByaXYtPnBlbmRpbmdfY3J0Y3NfZXZlbnQubG9j ayk7Ci0JREJHKCJlbmQ6ICUwOHgiLCBjcnRjX21hc2spOwotCXByaXYtPnBlbmRpbmdfY3J0Y3Mg Jj0gfmNydGNfbWFzazsKLQl3YWtlX3VwX2FsbF9sb2NrZWQoJnByaXYtPnBlbmRpbmdfY3J0Y3Nf ZXZlbnQpOwotCXNwaW5fdW5sb2NrKCZwcml2LT5wZW5kaW5nX2NydGNzX2V2ZW50LmxvY2spOwot fQotCi1zdGF0aWMgc3RydWN0IG1zbV9jb21taXQgKmNvbW1pdF9pbml0KHN0cnVjdCBkcm1fYXRv bWljX3N0YXRlICpzdGF0ZSkKLXsKLQlzdHJ1Y3QgbXNtX2NvbW1pdCAqYyA9IGt6YWxsb2Moc2l6 ZW9mKCpjKSwgR0ZQX0tFUk5FTCk7Ci0KLQlpZiAoIWMpCi0JCXJldHVybiBOVUxMOwotCi0JYy0+ ZGV2ID0gc3RhdGUtPmRldjsKLQljLT5zdGF0ZSA9IHN0YXRlOwotCi0JSU5JVF9XT1JLKCZjLT53 b3JrLCBjb21taXRfd29ya2VyKTsKLQotCXJldHVybiBjOwotfQotCi1zdGF0aWMgdm9pZCBjb21t aXRfZGVzdHJveShzdHJ1Y3QgbXNtX2NvbW1pdCAqYykKLXsKLQllbmRfYXRvbWljKGMtPmRldi0+ ZGV2X3ByaXZhdGUsIGMtPmNydGNfbWFzayk7Ci0Ja2ZyZWUoYyk7Ci19Ci0KIHN0YXRpYyB2b2lk IG1zbV9hdG9taWNfd2FpdF9mb3JfY29tbWl0X2RvbmUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwK IAkJc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKm9sZF9zdGF0ZSkKIHsKQEAgLTEyNiwzMSArNjYs MzcgQEAgc3RhdGljIHZvaWQgbXNtX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUpCiAKIAltc21fYXRvbWljX3dhaXRfZm9yX2NvbW1pdF9kb25lKGRldiwg c3RhdGUpOwogCi0JZHJtX2F0b21pY19oZWxwZXJfY2xlYW51cF9wbGFuZXMoZGV2LCBzdGF0ZSk7 Ci0KIAlrbXMtPmZ1bmNzLT5jb21wbGV0ZV9jb21taXQoa21zLCBzdGF0ZSk7CisKKwlkcm1fYXRv bWljX2hlbHBlcl93YWl0X2Zvcl92YmxhbmtzKGRldiwgc3RhdGUpOworCisJZHJtX2F0b21pY19o ZWxwZXJfY29tbWl0X2h3X2RvbmUoc3RhdGUpOworCisJZHJtX2F0b21pY19oZWxwZXJfY2xlYW51 cF9wbGFuZXMoZGV2LCBzdGF0ZSk7CiB9CiAKIC8qIFRoZSAocG90ZW50aWFsbHkpIGFzeW5jaHJv bm91cyBwYXJ0IG9mIHRoZSBjb21taXQuICBBdCB0aGlzIHBvaW50CiAgKiBub3RoaW5nIGNhbiBm YWlsIHNob3J0IG9mIGFybWFnZWRkb24uCiAgKi8KLXN0YXRpYyB2b2lkIGNvbXBsZXRlX2NvbW1p dChzdHJ1Y3QgbXNtX2NvbW1pdCAqYykKK3N0YXRpYyB2b2lkIGNvbW1pdF90YWlsKHN0cnVjdCBk cm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKIHsKLQlzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3Rh dGUgPSBjLT5zdGF0ZTsKLQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gc3RhdGUtPmRldjsKKwlk cm1fYXRvbWljX2hlbHBlcl93YWl0X2Zvcl9mZW5jZXMoc3RhdGUtPmRldiwgc3RhdGUsIGZhbHNl KTsKIAotCWRybV9hdG9taWNfaGVscGVyX3dhaXRfZm9yX2ZlbmNlcyhkZXYsIHN0YXRlLCBmYWxz ZSk7CisJZHJtX2F0b21pY19oZWxwZXJfd2FpdF9mb3JfZGVwZW5kZW5jaWVzKHN0YXRlKTsKIAog CW1zbV9hdG9taWNfY29tbWl0X3RhaWwoc3RhdGUpOwogCi0JZHJtX2F0b21pY19zdGF0ZV9wdXQo c3RhdGUpOworCWRybV9hdG9taWNfaGVscGVyX2NvbW1pdF9jbGVhbnVwX2RvbmUoc3RhdGUpOwog Ci0JY29tbWl0X2Rlc3Ryb3koYyk7CisJZHJtX2F0b21pY19zdGF0ZV9wdXQoc3RhdGUpOwogfQog Ci1zdGF0aWMgdm9pZCBjb21taXRfd29ya2VyKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKK3N0 YXRpYyB2b2lkIGNvbW1pdF93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIHsKLQljb21w bGV0ZV9jb21taXQoY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBtc21fY29tbWl0LCB3b3JrKSk7 CisJc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlID0gY29udGFpbmVyX29mKHdvcmssCisJ CQkJCQkgICAgICBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSwKKwkJCQkJCSAgICAgIGNvbW1pdF93 b3JrKTsKKwljb21taXRfdGFpbChzdGF0ZSk7CiB9CiAKIC8qKgpAQCAtMTY5LDE3ICsxMTUsMTIg QEAgaW50IG1zbV9hdG9taWNfY29tbWl0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJCXN0cnVj dCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwgYm9vbCBub25ibG9jaykKIHsKIAlzdHJ1Y3QgbXNt X2RybV9wcml2YXRlICpwcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKLQlzdHJ1Y3QgbXNtX2NvbW1p dCAqYzsKIAlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CiAJc3RydWN0IGRybV9jcnRjX3N0YXRlICpj cnRjX3N0YXRlOwogCXN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lOwogCXN0cnVjdCBkcm1fcGxhbmVf c3RhdGUgKm9sZF9wbGFuZV9zdGF0ZSwgKm5ld19wbGFuZV9zdGF0ZTsKIAlpbnQgaSwgcmV0Owog Ci0JcmV0ID0gZHJtX2F0b21pY19oZWxwZXJfcHJlcGFyZV9wbGFuZXMoZGV2LCBzdGF0ZSk7Ci0J aWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQogCS8qCiAJICogTm90ZSB0aGF0IHBsYW5lLT5hdG9t aWNfYXN5bmNfY2hlY2soKSBzaG91bGQgZmFpbCBpZiB3ZSBuZWVkCiAJICogdG8gcmUtYXNzaWdu IGh3cGlwZSBvciBhbnl0aGluZyB0aGF0IHRvdWNoZXMgZ2xvYmFsIGF0b21pYwpAQCAtMTg3LDQ1 ICsxMjgsMzkgQEAgaW50IG1zbV9hdG9taWNfY29tbWl0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs CiAJICogY2FzZXMuCiAJICovCiAJaWYgKHN0YXRlLT5hc3luY191cGRhdGUpIHsKKwkJcmV0ID0g ZHJtX2F0b21pY19oZWxwZXJfcHJlcGFyZV9wbGFuZXMoZGV2LCBzdGF0ZSk7CisJCWlmIChyZXQp CisJCQlyZXR1cm4gcmV0OworCiAJCWRybV9hdG9taWNfaGVscGVyX2FzeW5jX2NvbW1pdChkZXYs IHN0YXRlKTsKIAkJZHJtX2F0b21pY19oZWxwZXJfY2xlYW51cF9wbGFuZXMoZGV2LCBzdGF0ZSk7 CiAJCXJldHVybiAwOwogCX0KIAotCWMgPSBjb21taXRfaW5pdChzdGF0ZSk7Ci0JaWYgKCFjKSB7 Ci0JCXJldCA9IC1FTk9NRU07Ci0JCWdvdG8gZXJyb3I7Ci0JfQorCXJldCA9IGRybV9hdG9taWNf aGVscGVyX3NldHVwX2NvbW1pdChzdGF0ZSwgbm9uYmxvY2spOworCWlmIChyZXQpCisJCXJldHVy biByZXQ7CiAKLQkvKgotCSAqIEZpZ3VyZSBvdXQgd2hhdCBjcnRjcyB3ZSBoYXZlOgotCSAqLwot CWZvcl9lYWNoX25ld19jcnRjX2luX3N0YXRlKHN0YXRlLCBjcnRjLCBjcnRjX3N0YXRlLCBpKQot CQljLT5jcnRjX21hc2sgfD0gZHJtX2NydGNfbWFzayhjcnRjKTsKKwlJTklUX1dPUksoJnN0YXRl LT5jb21taXRfd29yaywgY29tbWl0X3dvcmspOwogCi0JLyoKLQkgKiBGaWd1cmUgb3V0IHdoYXQg ZmVuY2UgdG8gd2FpdCBmb3I6Ci0JICovCi0JZm9yX2VhY2hfb2xkbmV3X3BsYW5lX2luX3N0YXRl KHN0YXRlLCBwbGFuZSwgb2xkX3BsYW5lX3N0YXRlLCBuZXdfcGxhbmVfc3RhdGUsIGkpIHsKLQkJ aWYgKChuZXdfcGxhbmVfc3RhdGUtPmZiICE9IG9sZF9wbGFuZV9zdGF0ZS0+ZmIpICYmIG5ld19w bGFuZV9zdGF0ZS0+ZmIpIHsKLQkJCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqID0gbXNtX2Zy YW1lYnVmZmVyX2JvKG5ld19wbGFuZV9zdGF0ZS0+ZmIsIDApOwotCQkJc3RydWN0IG1zbV9nZW1f b2JqZWN0ICptc21fb2JqID0gdG9fbXNtX2JvKG9iaik7Ci0JCQlzdHJ1Y3QgZG1hX2ZlbmNlICpm ZW5jZSA9IHJlc2VydmF0aW9uX29iamVjdF9nZXRfZXhjbF9yY3UobXNtX29iai0+cmVzdik7Ci0K LQkJCWRybV9hdG9taWNfc2V0X2ZlbmNlX2Zvcl9wbGFuZShuZXdfcGxhbmVfc3RhdGUsIGZlbmNl KTsKLQkJfQorCXJldCA9IGRybV9hdG9taWNfaGVscGVyX3ByZXBhcmVfcGxhbmVzKGRldiwgc3Rh dGUpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlpZiAoIW5vbmJsb2NrKSB7CisJCXJl dCA9IGRybV9hdG9taWNfaGVscGVyX3dhaXRfZm9yX2ZlbmNlcyhkZXYsIHN0YXRlLCB0cnVlKTsK KwkJaWYgKHJldCkKKwkJCWdvdG8gZXJyb3I7CiAJfQogCiAJLyoKLQkgKiBXYWl0IGZvciBwZW5k aW5nIHVwZGF0ZXMgb24gYW55IG9mIHRoZSBzYW1lIGNydGMncyBhbmQgdGhlbgotCSAqIG1hcmsg b3VyIHNldCBvZiBjcnRjJ3MgYXMgYnVzeToKKwkgKiBUaGlzIGlzIHRoZSBwb2ludCBvZiBubyBy ZXR1cm4gLSBldmVyeXRoaW5nIGJlbG93IG5ldmVyIGZhaWxzIGV4Y2VwdAorCSAqIHdoZW4gdGhl IGh3IGdvZXMgYm9uZ2hpdHMuIFdoaWNoIG1lYW5zIHdlIGNhbiBjb21taXQgdGhlIG5ldyBzdGF0 ZSBvbgorCSAqIHRoZSBzb2Z0d2FyZSBzaWRlIG5vdy4KKwkgKgorCSAqIHN3YXAgZHJpdmVyIHBy aXZhdGUgc3RhdGUgd2hpbGUgc3RpbGwgaG9sZGluZyBzdGF0ZV9sb2NrCiAJICovCi0JcmV0ID0g c3RhcnRfYXRvbWljKGRldi0+ZGV2X3ByaXZhdGUsIGMtPmNydGNfbWFzayk7Ci0JaWYgKHJldCkK LQkJZ290byBlcnJfZnJlZTsKLQotCUJVR19PTihkcm1fYXRvbWljX2hlbHBlcl9zd2FwX3N0YXRl KHN0YXRlLCBmYWxzZSkgPCAwKTsKKwlCVUdfT04oZHJtX2F0b21pY19oZWxwZXJfc3dhcF9zdGF0 ZShzdGF0ZSwgdHJ1ZSkgPCAwKTsKIAogCS8qCiAJICogRXZlcnl0aGluZyBiZWxvdyBjYW4gYmUg cnVuIGFzeW5jaHJvbm91c2x5IHdpdGhvdXQgdGhlIG5lZWQgdG8gZ3JhYgpAQCAtMjQ0LDE3ICsx NzksMTMgQEAgaW50IG1zbV9hdG9taWNfY29tbWl0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJ ICovCiAKIAlkcm1fYXRvbWljX3N0YXRlX2dldChzdGF0ZSk7Ci0JaWYgKG5vbmJsb2NrKSB7Ci0J CXF1ZXVlX3dvcmsocHJpdi0+YXRvbWljX3dxLCAmYy0+d29yayk7Ci0JCXJldHVybiAwOwotCX0K LQotCWNvbXBsZXRlX2NvbW1pdChjKTsKKwlpZiAobm9uYmxvY2spCisJCXF1ZXVlX3dvcmsoc3lz dGVtX3VuYm91bmRfd3EsICZzdGF0ZS0+Y29tbWl0X3dvcmspOworCWVsc2UKKwkJY29tbWl0X3Rh aWwoc3RhdGUpOwogCiAJcmV0dXJuIDA7CiAKLWVycl9mcmVlOgotCWtmcmVlKGMpOwogZXJyb3I6 CiAJZHJtX2F0b21pY19oZWxwZXJfY2xlYW51cF9wbGFuZXMoZGV2LCBzdGF0ZSk7CiAJcmV0dXJu IHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5jIGIvZHJpdmVy cy9ncHUvZHJtL21zbS9tc21fZHJ2LmMKaW5kZXggN2U4ZjY0MDA2MmVmLi5kMWE0NWE2OGMyODcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9tc20vbXNtX2Rydi5jCkBAIC00NTksNyArNDU5LDYgQEAgc3RhdGljIGludCBtc21f ZHJtX2luaXQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2RyaXZlciAqZHJ2KQogCiAJ cHJpdi0+d3EgPSBhbGxvY19vcmRlcmVkX3dvcmtxdWV1ZSgibXNtIiwgMCk7CiAJcHJpdi0+YXRv bWljX3dxID0gYWxsb2Nfb3JkZXJlZF93b3JrcXVldWUoIm1zbTphdG9taWMiLCAwKTsKLQlpbml0 X3dhaXRxdWV1ZV9oZWFkKCZwcml2LT5wZW5kaW5nX2NydGNzX2V2ZW50KTsKIAogCUlOSVRfTElT VF9IRUFEKCZwcml2LT5pbmFjdGl2ZV9saXN0KTsKIAlJTklUX0xJU1RfSEVBRCgmcHJpdi0+dmJs YW5rX2N0cmwuZXZlbnRfbGlzdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21z bV9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5oCmluZGV4IGM1YjhjOTg5Yjg1 OS4uYjg5ZmE1MTg2ZWI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYu aAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuaApAQCAtMTE3LDEwICsxMTcsNiBA QCBzdHJ1Y3QgbXNtX2RybV9wcml2YXRlIHsKIAlzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqd3E7 CiAJc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKmF0b21pY193cTsKIAotCS8qIGNydGNzIHBlbmRp bmcgYXN5bmMgYXRvbWljIHVwZGF0ZXM6ICovCi0JdWludDMyX3QgcGVuZGluZ19jcnRjczsKLQl3 YWl0X3F1ZXVlX2hlYWRfdCBwZW5kaW5nX2NydGNzX2V2ZW50OwotCiAJdW5zaWduZWQgaW50IG51 bV9wbGFuZXM7CiAJc3RydWN0IGRybV9wbGFuZSAqcGxhbmVzWzE2XTsKIAotLSAKU2VhbiBQYXVs LCBTb2Z0d2FyZSBFbmdpbmVlciwgR29vZ2xlIC8gQ2hyb21pdW0gT1MKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkZyZWVkcmVubyBtYWlsaW5nIGxpc3QK RnJlZWRyZW5vQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ZyZWVkcmVubwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753899AbeC1TI5 (ORCPT ); Wed, 28 Mar 2018 15:08:57 -0400 Received: from mail-yw0-f195.google.com ([209.85.161.195]:44756 "EHLO mail-yw0-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753448AbeC1TIy (ORCPT ); Wed, 28 Mar 2018 15:08:54 -0400 X-Google-Smtp-Source: AIpwx48JxPmSehRXhX3vn18b8IFLRzhoB9daiZJVbZIUquofkiFuF6UuWw9zJn9B7+nd+zwko7GoAA== From: Sean Paul To: freedreno@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, dri-devel@lists.freedesktop.org Cc: robdclark@gmail.com, hoegsberg@chromium.org, jsanka@codeaurora.org, abhinavk@codeaurora.org, architt@codeaurora.org, Sean Paul , linux-kernel@vger.kernel.org Subject: [PATCH v2 5/6] drm/msm: Remove msm_commit/worker, use atomic helper commit Date: Wed, 28 Mar 2018 15:06:51 -0400 Message-Id: <20180328190657.218661-6-seanpaul@chromium.org> X-Mailer: git-send-email 2.17.0.rc1.321.gba9d0f2565-goog In-Reply-To: <20180328190657.218661-1-seanpaul@chromium.org> References: <20180328190657.218661-1-seanpaul@chromium.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Moving further towards switching fully to the the atomic helpers, this patch removes the hand-rolled worker nonblock commit code and uses the atomic helpers commit_work model. Changes in v2: - Remove commit_destroy() - Shuffle order of commit_tail calls to further serialize commits - Use stall in swap_state to avoid abandoned events on disable Signed-off-by: Sean Paul --- drivers/gpu/drm/msm/msm_atomic.c | 153 +++++++++---------------------- drivers/gpu/drm/msm/msm_drv.c | 1 - drivers/gpu/drm/msm/msm_drv.h | 4 - 3 files changed, 42 insertions(+), 116 deletions(-) diff --git a/drivers/gpu/drm/msm/msm_atomic.c b/drivers/gpu/drm/msm/msm_atomic.c index 671a18ee977d..52249565cc03 100644 --- a/drivers/gpu/drm/msm/msm_atomic.c +++ b/drivers/gpu/drm/msm/msm_atomic.c @@ -20,66 +20,6 @@ #include "msm_gem.h" #include "msm_fence.h" -struct msm_commit { - struct drm_device *dev; - struct drm_atomic_state *state; - struct work_struct work; - uint32_t crtc_mask; -}; - -static void commit_worker(struct work_struct *work); - -/* block until specified crtcs are no longer pending update, and - * atomically mark them as pending update - */ -static int start_atomic(struct msm_drm_private *priv, uint32_t crtc_mask) -{ - int ret; - - spin_lock(&priv->pending_crtcs_event.lock); - ret = wait_event_interruptible_locked(priv->pending_crtcs_event, - !(priv->pending_crtcs & crtc_mask)); - if (ret == 0) { - DBG("start: %08x", crtc_mask); - priv->pending_crtcs |= crtc_mask; - } - spin_unlock(&priv->pending_crtcs_event.lock); - - return ret; -} - -/* clear specified crtcs (no longer pending update) - */ -static void end_atomic(struct msm_drm_private *priv, uint32_t crtc_mask) -{ - spin_lock(&priv->pending_crtcs_event.lock); - DBG("end: %08x", crtc_mask); - priv->pending_crtcs &= ~crtc_mask; - wake_up_all_locked(&priv->pending_crtcs_event); - spin_unlock(&priv->pending_crtcs_event.lock); -} - -static struct msm_commit *commit_init(struct drm_atomic_state *state) -{ - struct msm_commit *c = kzalloc(sizeof(*c), GFP_KERNEL); - - if (!c) - return NULL; - - c->dev = state->dev; - c->state = state; - - INIT_WORK(&c->work, commit_worker); - - return c; -} - -static void commit_destroy(struct msm_commit *c) -{ - end_atomic(c->dev->dev_private, c->crtc_mask); - kfree(c); -} - static void msm_atomic_wait_for_commit_done(struct drm_device *dev, struct drm_atomic_state *old_state) { @@ -126,31 +66,37 @@ static void msm_atomic_commit_tail(struct drm_atomic_state *state) msm_atomic_wait_for_commit_done(dev, state); - drm_atomic_helper_cleanup_planes(dev, state); - kms->funcs->complete_commit(kms, state); + + drm_atomic_helper_wait_for_vblanks(dev, state); + + drm_atomic_helper_commit_hw_done(state); + + drm_atomic_helper_cleanup_planes(dev, state); } /* The (potentially) asynchronous part of the commit. At this point * nothing can fail short of armageddon. */ -static void complete_commit(struct msm_commit *c) +static void commit_tail(struct drm_atomic_state *state) { - struct drm_atomic_state *state = c->state; - struct drm_device *dev = state->dev; + drm_atomic_helper_wait_for_fences(state->dev, state, false); - drm_atomic_helper_wait_for_fences(dev, state, false); + drm_atomic_helper_wait_for_dependencies(state); msm_atomic_commit_tail(state); - drm_atomic_state_put(state); + drm_atomic_helper_commit_cleanup_done(state); - commit_destroy(c); + drm_atomic_state_put(state); } -static void commit_worker(struct work_struct *work) +static void commit_work(struct work_struct *work) { - complete_commit(container_of(work, struct msm_commit, work)); + struct drm_atomic_state *state = container_of(work, + struct drm_atomic_state, + commit_work); + commit_tail(state); } /** @@ -169,17 +115,12 @@ int msm_atomic_commit(struct drm_device *dev, struct drm_atomic_state *state, bool nonblock) { struct msm_drm_private *priv = dev->dev_private; - struct msm_commit *c; struct drm_crtc *crtc; struct drm_crtc_state *crtc_state; struct drm_plane *plane; struct drm_plane_state *old_plane_state, *new_plane_state; int i, ret; - ret = drm_atomic_helper_prepare_planes(dev, state); - if (ret) - return ret; - /* * Note that plane->atomic_async_check() should fail if we need * to re-assign hwpipe or anything that touches global atomic @@ -187,45 +128,39 @@ int msm_atomic_commit(struct drm_device *dev, * cases. */ if (state->async_update) { + ret = drm_atomic_helper_prepare_planes(dev, state); + if (ret) + return ret; + drm_atomic_helper_async_commit(dev, state); drm_atomic_helper_cleanup_planes(dev, state); return 0; } - c = commit_init(state); - if (!c) { - ret = -ENOMEM; - goto error; - } + ret = drm_atomic_helper_setup_commit(state, nonblock); + if (ret) + return ret; - /* - * Figure out what crtcs we have: - */ - for_each_new_crtc_in_state(state, crtc, crtc_state, i) - c->crtc_mask |= drm_crtc_mask(crtc); + INIT_WORK(&state->commit_work, commit_work); - /* - * Figure out what fence to wait for: - */ - for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) { - if ((new_plane_state->fb != old_plane_state->fb) && new_plane_state->fb) { - struct drm_gem_object *obj = msm_framebuffer_bo(new_plane_state->fb, 0); - struct msm_gem_object *msm_obj = to_msm_bo(obj); - struct dma_fence *fence = reservation_object_get_excl_rcu(msm_obj->resv); - - drm_atomic_set_fence_for_plane(new_plane_state, fence); - } + ret = drm_atomic_helper_prepare_planes(dev, state); + if (ret) + return ret; + + if (!nonblock) { + ret = drm_atomic_helper_wait_for_fences(dev, state, true); + if (ret) + goto error; } /* - * Wait for pending updates on any of the same crtc's and then - * mark our set of crtc's as busy: + * This is the point of no return - everything below never fails except + * when the hw goes bonghits. Which means we can commit the new state on + * the software side now. + * + * swap driver private state while still holding state_lock */ - ret = start_atomic(dev->dev_private, c->crtc_mask); - if (ret) - goto err_free; - - BUG_ON(drm_atomic_helper_swap_state(state, false) < 0); + BUG_ON(drm_atomic_helper_swap_state(state, true) < 0); /* * Everything below can be run asynchronously without the need to grab @@ -244,17 +179,13 @@ int msm_atomic_commit(struct drm_device *dev, */ drm_atomic_state_get(state); - if (nonblock) { - queue_work(priv->atomic_wq, &c->work); - return 0; - } - - complete_commit(c); + if (nonblock) + queue_work(system_unbound_wq, &state->commit_work); + else + commit_tail(state); return 0; -err_free: - kfree(c); error: drm_atomic_helper_cleanup_planes(dev, state); return ret; diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index 7e8f640062ef..d1a45a68c287 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -459,7 +459,6 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) priv->wq = alloc_ordered_workqueue("msm", 0); priv->atomic_wq = alloc_ordered_workqueue("msm:atomic", 0); - init_waitqueue_head(&priv->pending_crtcs_event); INIT_LIST_HEAD(&priv->inactive_list); INIT_LIST_HEAD(&priv->vblank_ctrl.event_list); diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h index c5b8c989b859..b89fa5186eb8 100644 --- a/drivers/gpu/drm/msm/msm_drv.h +++ b/drivers/gpu/drm/msm/msm_drv.h @@ -117,10 +117,6 @@ struct msm_drm_private { struct workqueue_struct *wq; struct workqueue_struct *atomic_wq; - /* crtcs pending async atomic updates: */ - uint32_t pending_crtcs; - wait_queue_head_t pending_crtcs_event; - unsigned int num_planes; struct drm_plane *planes[16]; -- Sean Paul, Software Engineer, Google / Chromium OS