From mboxrd@z Thu Jan 1 00:00:00 1970 From: Helen Koike Subject: [PATCH v3 2/4] drm/atomic: rename async_{update, check} to amend_{update, check} Date: Fri, 12 Apr 2019 09:58:25 -0300 Message-ID: <20190412125827.5877-3-helen.koike@collabora.com> References: <20190412125827.5877-1-helen.koike@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190412125827.5877-1-helen.koike-ZGY8ohtN/8qB+jHODAdFcQ@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: freedreno-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Freedreno" To: dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, David Airlie Cc: =?UTF-8?q?Heiko=20St=C3=BCbner?= , Sean Paul , alexandros.frantzis-ZGY8ohtN/8qB+jHODAdFcQ@public.gmane.org, Maxime Ripard , daniel.vetter-/w4YWyX8dFk@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Eric Anholt , Mamta Shukla , tina.zhang-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org, kernel-ZGY8ohtN/8qB+jHODAdFcQ@public.gmane.org, Anthony Koo , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , "David (ChunMing) Zhou" , Jonathan Corbet , Sean Paul , David Francis , linux-doc-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Gustavo Padovan , linux-rockchip-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, Harry Wentland , daniels-ZGY8ohtN/8qB+jHODAdFcQ@public.gmane.org, Leo Li , linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Maarten Lankhorst List-Id: linux-arm-msm@vger.kernel.org QXN5bmNocm9ub3VzIHVwZGF0ZSBpcyB0aGUgYWJpbGl0eSBjaGFuZ2UgdGhlIGh3IHN0YXRlIGF0 IGFueSB0aW1lLCBub3QKb25seSBkdXJpbmcgdmJsYW5rLgoKQW1lbmQgbW9kZSBpcyB0aGUgYWJp bGl0eSB0byBwZXJmb3JtIDEwMDAgY29tbWl0cyB0byBiZSBhcHBsaWVkIGFzIHNvb24KYXMgcG9z c2libGUgd2l0aG91dCB3YWl0aW5nIGZvciAxMDAwIHZibGFua3MuCgphc3luYyB1cGRhdGVzIGNh biBiZSBzZWVuIGFzIGFtZW5kLCBidXQgdGhlIG9wcG9zaXRlIGlzIG5vdCB0cnVlLgoKJmRybV9w bGFuZV9oZWxwZXJfZnVuY3MuYXRvbWljX2FzeW5jX3t1cGRhdGUsY2hlY2t9KCkgd2FzIGJlaW5n IHVzZWQgYnkKZHJpdmVycyB0byBpbXBsZW1lbnQgYW1lbmQgYW5kIG5vdCBhc3luYy4gU28gcmVu YW1lIHRoZW0gdG8gYW1lbmQuCgpBbHNvIGltcHJvdmUgZG9jcyBleHBsYWluaW5nIHRoZSBkaWZm ZXJlbmNlLgoKSWYgYXN5bmNocm9ub3VzIGlzIHJlcXVpcmVkLCBub3JtYWwgcGFnZSBmbGlwIGNh biBiZSBwZXJmb3JtZWQgdXNpbmcKRFJNX01PREVfUEFHRV9GTElQX0FTWU5DIGZsYWcuCgpTaWdu ZWQtb2ZmLWJ5OiBIZWxlbiBLb2lrZSA8aGVsZW4ua29pa2VAY29sbGFib3JhLmNvbT4KCi0tLQpI ZWxsbywKCkkgd291bGQgbGlrZSB0byBvZmZpY2lhbGx5IGNsYXJpZnkgd2hhdCBhc3luYyB1cGRh dGUgbWVhbnMgYnkgYWRkaW5nIGl0CmluIHRoZSBkb2NzLgpQbGVhc2UgY29ycmVjdCBtZSBpZiBJ IGFtIHdyb25nLCBidXQgdGhlIGN1cnJlbnQgYXN5bmNfe3VwZGF0ZSxjaGVja30KY2FsbGJhY2tz IGFyZSBiZWluZyB1c2VkIHRvIGRvIGFtZW5kICh0aGUgbGVnYWN5IGN1cnNvciBiZWhhdmlvciks IGkuZS4KdG8gYWxsb3cgMTAwMCB1cGRhdGVzIHdpdGhvdXQgd2FpdGluZyBmb3IgMTAwMCB2Ymxh bmtzLgoKU28gSSB3b3VsZCBsaWtlIHRvIGNsYXJpZnkgdGhpcyBpbiB0aGUgZG9jcyBhbmQgcmVu YW1lIHRoZSBjdXJyZW50CmNhbGxiYWNrcyB0byByZWZsZWN0IHRoaXMgYmVoYXZpb3VyLgoKSSBh bHNvIHNlZSB0aGF0IGZvciByZWFsIGFzeW5jIHVwZGF0ZXMsIHRoZSBmbGFnCkRSTV9NT0RFX1BB R0VfRkxJUF9BU1lOQyBjYW4gYmUgdXNlZCBpbiBhIG5vcm1hbCBzeW5jIHVwZGF0ZSAoaXQgaXMK YWxyZWFkeSBiZWluZyB1c2VkIGJ5IHNvbWUgZHJpdmVycyBhY3R1YWxseSwgaW4gdGhlIGF0b21p YyBwYXRoLCBub3Qgb25seQppbiB0aGUgbGVnYWN5IHBhZ2UgZmxpcCwgYXQgbGVhc3QgaXMgd2hh dCBJIHVuZGVyc3Rvb2QgZnJvbQphbWRncHVfZG1fYXRvbWljX2NvbW1pdF90YWlsKCkgaW1wbGVt ZW50YXRpb24pLgoKUGxlYXNlLCBsZXQgbWUga25vdyBpZiBJIG1pc3VuZGVyc3Rvb2QgYW55dGhp bmcuIE90aGVyd2lzZSByZW5hbWluZyBhbmQKaW1wcm92aW5nIHRoZSBkb2NzIHdvdWxkIHB1dCB1 cyBhbGwgaW4gc3luYy4KClRoYW5rcyEKSGVsZW4KCkNoYW5nZXMgaW4gdjM6IE5vbmUKQ2hhbmdl cyBpbiB2MjogTm9uZQpDaGFuZ2VzIGluIHYxOiBOb25lCgogRG9jdW1lbnRhdGlvbi9ncHUvZHJt LWttcy1oZWxwZXJzLnJzdCAgICAgICAgIHwgICA4ICstCiAuLi4vZ3B1L2RybS9hbWQvZGlzcGxh eS9hbWRncHVfZG0vYW1kZ3B1X2RtLmMgfCAgMTAgKy0KIGRyaXZlcnMvZ3B1L2RybS9kcm1fYXRv bWljX2hlbHBlci5jICAgICAgICAgICB8IDExMSArKysrKysrKysrKysrLS0tLS0KIGRyaXZlcnMv Z3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfcGxhbmUuYyAgICB8ICAgOCArLQogZHJpdmVycy9n cHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuYyAgIHwgICA4ICstCiBkcml2ZXJzL2dw dS9kcm0vdmM0L3ZjNF9rbXMuYyAgICAgICAgICAgICAgICAgfCAgIDQgKy0KIGRyaXZlcnMvZ3B1 L2RybS92YzQvdmM0X3BsYW5lLmMgICAgICAgICAgICAgICB8ICAgOCArLQogaW5jbHVkZS9kcm0v ZHJtX2F0b21pYy5oICAgICAgICAgICAgICAgICAgICAgIHwgICA0ICstCiBpbmNsdWRlL2RybS9k cm1fYXRvbWljX2hlbHBlci5oICAgICAgICAgICAgICAgfCAgIDQgKy0KIGluY2x1ZGUvZHJtL2Ry bV9tb2Rlc2V0X2hlbHBlcl92dGFibGVzLmggICAgICB8ICAzOCArKystLS0KIDEwIGZpbGVzIGNo YW5nZWQsIDEzOSBpbnNlcnRpb25zKCspLCA2NCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9E b2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0IGIvRG9jdW1lbnRhdGlvbi9ncHUv ZHJtLWttcy1oZWxwZXJzLnJzdAppbmRleCA1OGIzNzVlNDc2MTUuLmMwNjdhMTk2OTAyZCAxMDA2 NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLWttcy1oZWxwZXJzLnJzdAorKysgYi9Eb2N1 bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0CkBAIC01MywxMiArNTMsMTggQEAgT3Zl cnZpZXcKIC4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIu YwogICAgOmRvYzogb3ZlcnZpZXcKIAotSW1wbGVtZW50aW5nIEFzeW5jaHJvbm91cyBBdG9taWMg Q29tbWl0CitJbXBsZW1lbnRpbmcgTm9uYmxvY2tpbmcgQXRvbWljIENvbW1pdAogLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIC4uIGtlcm5lbC1kb2M6OiBkcml2ZXJz L2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwogICAgOmRvYzogaW1wbGVtZW50aW5nIG5vbmJs b2NraW5nIGNvbW1pdAogCitBbWVuZCBNb2RlIEF0b21pYyBDb21taXQKKy0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorCisuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNf aGVscGVyLmMKKyAgIDpkb2M6IGFtZW5kIG1vZGUgYXRvbWljIGNvbW1pdAorCiBIZWxwZXIgRnVu Y3Rpb25zIFJlZmVyZW5jZQogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIApkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYyBiL2Ry aXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtLmMKaW5kZXggMmYy NjU4MWI5M2ZmLi43MTFlNzcxNWUxMTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQv ZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9k aXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYwpAQCAtMzc3OSw4ICszNzc5LDEyIEBAIHN0YXRp YyBjb25zdCBzdHJ1Y3QgZHJtX3BsYW5lX2hlbHBlcl9mdW5jcyBkbV9wbGFuZV9oZWxwZXJfZnVu Y3MgPSB7CiAJLnByZXBhcmVfZmIgPSBkbV9wbGFuZV9oZWxwZXJfcHJlcGFyZV9mYiwKIAkuY2xl YW51cF9mYiA9IGRtX3BsYW5lX2hlbHBlcl9jbGVhbnVwX2ZiLAogCS5hdG9taWNfY2hlY2sgPSBk bV9wbGFuZV9hdG9taWNfY2hlY2ssCi0JLmF0b21pY19hc3luY19jaGVjayA9IGRtX3BsYW5lX2F0 b21pY19hc3luY19jaGVjaywKLQkuYXRvbWljX2FzeW5jX3VwZGF0ZSA9IGRtX3BsYW5lX2F0b21p Y19hc3luY191cGRhdGUKKwkvKgorCSAqIEZJWE1FOiBpZGVhbGx5LCBpbnN0ZWFkIG9mIGhvb2tp bmcgYXN5bmMgdXBkYXRlcyB0byBhbWVuZCwKKwkgKiB3ZSBjb3VsZCBhdm9pZCB0ZWFyaW5nIGJ5 IG1vZGlmeWluZyB0aGUgcGVuZGluZyBjb21taXQuCisJICovCisJLmF0b21pY19hbWVuZF9jaGVj ayA9IGRtX3BsYW5lX2F0b21pY19hc3luY19jaGVjaywKKwkuYXRvbWljX2FtZW5kX3VwZGF0ZSA9 IGRtX3BsYW5lX2F0b21pY19hc3luY191cGRhdGUKIH07CiAKIC8qCkBAIC02MTQwLDcgKzYxNDQs NyBAQCBzdGF0aWMgaW50IGFtZGdwdV9kbV9hdG9taWNfY2hlY2soc3RydWN0IGRybV9kZXZpY2Ug KmRldiwKIAkJICogaGVscGVyLCBjaGVjayBpZiBpdCBjYW4gYmUgZG9uZSBhc3luY2hyb25vdXNs eSBmb3IgYmV0dGVyCiAJCSAqIHBlcmZvcm1hbmNlLgogCQkgKi8KLQkJc3RhdGUtPmFzeW5jX3Vw ZGF0ZSA9ICFkcm1fYXRvbWljX2hlbHBlcl9hc3luY19jaGVjayhkZXYsIHN0YXRlKTsKKwkJc3Rh dGUtPmFtZW5kX3VwZGF0ZSA9ICFkcm1fYXRvbWljX2hlbHBlcl9hbWVuZF9jaGVjayhkZXYsIHN0 YXRlKTsKIAl9CiAKIAkvKiBNdXN0IGJlIHN1Y2Nlc3MgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9kcm1fYXRvbWljX2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNf aGVscGVyLmMKaW5kZXggMjQ1MzY3OGQxMTg2Li5lYjVkY2Q4NGZlYTcgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX2hlbHBlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9k cm1fYXRvbWljX2hlbHBlci5jCkBAIC05NDgsNyArOTQ4LDcgQEAgaW50IGRybV9hdG9taWNfaGVs cGVyX2NoZWNrKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJCXJldHVybiByZXQ7CiAKIAlpZiAo c3RhdGUtPmxlZ2FjeV9jdXJzb3JfdXBkYXRlKQotCQlzdGF0ZS0+YXN5bmNfdXBkYXRlID0gIWRy bV9hdG9taWNfaGVscGVyX2FzeW5jX2NoZWNrKGRldiwgc3RhdGUpOworCQlzdGF0ZS0+YW1lbmRf dXBkYXRlID0gIWRybV9hdG9taWNfaGVscGVyX2FtZW5kX2NoZWNrKGRldiwgc3RhdGUpOwogCiAJ cmV0dXJuIHJldDsKIH0KQEAgLTE1NjksMTkgKzE1NjksNjggQEAgc3RhdGljIHZvaWQgY29tbWl0 X3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogfQogCiAvKioKLSAqIGRybV9hdG9taWNf aGVscGVyX2FzeW5jX2NoZWNrIC0gY2hlY2sgaWYgc3RhdGUgY2FuIGJlIGNvbW1pdGVkIGFzeW5j aHJvbm91c2x5CisgKiBET0M6IGFtZW5kIG1vZGUgYXRvbWljIGNvbW1pdAorICoKKyAqIFRoZSBh bWVuZCBmZWF0dXJlIHByb3ZpZGVzIGEgd2F5IHRvIHBlcmZvcm0gMTAwMCB1cGRhdGVzIHRvIGJl IGFwcGxpZWQgYXMKKyAqIHNvb24gYXMgcG9zc2libGUgd2l0aG91dCB3YWl0aW5nIGZvciAxMDAw IHZibGFua3MuCisKKyAqIEN1cnJlbnRseSwgb25seSB0aGUgbGVnYWN5IGN1cnNvciB1cGRhdGUg dXNlcyBhbWVuZCBtb2RlLCB3aGVyZSBoaXN0b3JpY2FsbHksCisgKiB1c2Vyc3BhY2UgcGVyZm9y bXMgc2V2ZXJhbCB1cGRhdGVzIGJlZm9yZSB0aGUgbmV4dCB2YmxhbmsgYW5kIGRvbid0IHdhbnQg dG8KKyAqIHNlZSBhIGRlbGF5IGluIHRoZSBjdXJzb3IncyBtb3ZlbWVudC4KKyAqIElmIGFtZW5k IGlzIG5vdCBzdXBwb3J0ZWQsIGxlZ2FjeSBjdXJzb3IgZmFsbHMgYmFjayB0byBhIG5vcm1hbCBz eW5jIHVwZGF0ZS4KKyAqCisgKiBUbyBpbXBsZW1lbnQgdGhlIGxlZ2FjeSBjdXJzb3IgdXBkYXRl LCBkcml2ZXJzIHNob3VsZCBwcm92aWRlCisgKiAmZHJtX3BsYW5lX2hlbHBlcl9mdW5jcy5hdG9t aWNfYW1lbmRfY2hlY2soKSBhbmQKKyAqICZkcm1fcGxhbmVfaGVscGVyX2Z1bmNzLmF0b21pY19h bWVuZF91cGRhdGUoKQorICoKKyAqIERyaXZlcnMganVzdCBuZWVkIHRvIG1ha2Ugc3VyZSB0aGUg bGFzdCBzdGF0ZSBvdmVycmlkZXMgdGhlIHByZXZpb3VzIG9uZSwgc28KKyAqIHRoYXQgaWYgWCB1 cGRhdGVzIHdlcmUgcGVyZm9ybWVkLCB0aGVuLCBpbiBzb21lIHBvaW50IGluIHRoZSBuZWFyIGZ1 dHVyZSwKKyAqIHByZWZlcmVudGlhbGx5IGluIHRoZSBuZXh0IHZibGFuaywgdGhlIFh0aCBzdGF0 ZSB3aWxsIGJlIHRoZSBoYXJkd2FyZSBzdGF0ZS4KKyAqCisgKiBJZiB0aGUgaGFyZHdhcmUgc3Vw cG9ydHMgYXN5bmNocm9ub3VzIHVwZGF0ZSwgaS5lLCBjaGFuZ2luZyBpdHMgc3RhdGUgd2l0aG91 dAorICogd2FpdGluZyBmb3IgdmJsYW5rLCB0aGVuICZkcm1fcGxhbmVfaGVscGVyX2Z1bmNzLmF0 b21pY19hbWVuZF91cGRhdGUoKSBjYW4gYmUKKyAqIGltcGxlbWVudGVkIHVzaW5nIGFzeW5jaHJv bm91cyB1cGRhdGUgKHRoZSBhbWVuZCBtb2RlIHByb3BlcnR5IGlzIGhlbGQpLCBidXQKKyAqIGl0 IGNhbiBjYXVzZSB0ZWFyaW5nIGluIHRoZSBpbWFnZS4KKyAqCisgKiBPdGhlcndpc2UgKGlmIGFz eW5jIGlzIG5vdCBzdXBwb3J0ZWQgYnkgdGhlIGh3KSwgZHJpdmVycyBuZWVkIHRvIG92ZXJyaWRl IHRoZQorICogY29tbWl0IHRvIGJlIGFwcGxpZWQgaW4gdGhlIG5leHQgdmJsYW5rLCBhbmQgYWxz byB0aGV5IG5lZWQgdG8gdGFrZSBjYXJlIG9mCisgKiBmcmFtZWJ1ZmZlciByZWZlcmVuY2VzIHdo ZW4gcHJvZ3JhbW1pbmcgYSBuZXcgZnJhbWVidWZmZXIsIGFzIGh3IGNhbiBzdGlsbCBiZQorICog c2Nhbm5pbmcgb3V0IHRoZSBvbGQgZnJhbWVidWZmZXIuIEZvciBub3cgZHJpdmVycyBtdXN0IGlt cGxlbWVudCB0aGVpciBvd24KKyAqIHdvcmtlcnMgZm9yIGRlZmVycmluZyBpZiBuZWVkZWQsIHVu dGlsIGEgY29tbW9uIHNvbHV0aW9uIGlzIGNyZWF0ZWQuCisgKgorICoKKyAqIE5vdGVzIC8gaGln aGxpZ2h0czoKKyAqCisgKiAtIGFtZW5kIHVwZGF0ZSBpcyBwZXJmb3JtZWQgb24gbGVnYWN5IGN1 cnNvciB1cGRhdGVzLgorICoKKyAqIC0gYW1lbmQgdXBkYXRlIHdvbid0IGhhcHBlbiBpZiB0aGVy ZSBpcyBhbiBvdXRzdGFuZGluZyBjb21taXQgbW9kaWZ5aW5nIHRoZQorICogICBzYW1lIHBsYW5l LgorICoKKyAqIC0gYW1lbmQgdXBkYXRlIHdvbid0IGhhcHBlbiBpZiBhdG9taWNfYW1lbmRfY2hl Y2soKSByZXR1cm5zIGZhbHNlLgorICoKKyAqIC0gaWYgYXRvbWljX2FtZW5kX2NoZWNrKCkgZmFp bHMsIGl0IGZhbGxzIGJhY2sgdG8gYSBub3JtYWwgc3luY2hyb25vdXMKKyAqICAgdXBkYXRlLgor ICoKKyAqIC0gaWYgdXNlcnNwYWNlIHdhbnRzIHRvIGVuc3VyZSBhbiBhc3luY2hyb25vdXMgcGFn ZSBmbGlwLCBpLmUuIGNoYW5nZSBodworICogICBzdGF0ZSBpbW1lZGlhdGVseSwgc2VlIERSTV9N T0RFX1BBR0VfRkxJUF9BU1lOQyBmbGFnCisgKiAgIChhc3luY2hyb25vdXMgcGFnZSBmbGlwIG1h aW50YWlucyB0aGUgYW1lbmQgcHJvcGVydHkgYnkgZGVmaW5pdGlvbikuCisgKgorICogLSBBc3lu Y2hyb25vdXMgbW9kZXNldCBkb2Vzbid0IG1ha2Ugc2Vuc2UsIG9ubHkgYXN5bmNocm9ub3VzIHBh Z2UgZmxpcC4KKyAqLworCisvKioKKyAqIGRybV9hdG9taWNfaGVscGVyX2FtZW5kX2NoZWNrIC0g Y2hlY2sgaWYgc3RhdGUgY2FuIGJlIGFtZW5kZWQuCiAgKiBAZGV2OiBEUk0gZGV2aWNlCiAgKiBA c3RhdGU6IHRoZSBkcml2ZXIgc3RhdGUgb2JqZWN0CiAgKgotICogVGhpcyBoZWxwZXIgd2lsbCBj aGVjayBpZiBpdCBpcyBwb3NzaWJsZSB0byBjb21taXQgdGhlIHN0YXRlIGFzeW5jaHJvbm91c2x5 LgotICogQXN5bmMgY29tbWl0cyBhcmUgbm90IHN1cHBvc2VkIHRvIHN3YXAgdGhlIHN0YXRlcyBs aWtlIG5vcm1hbCBzeW5jIGNvbW1pdHMKLSAqIGJ1dCBqdXN0IGRvIGluLXBsYWNlIGNoYW5nZXMg b24gdGhlIGN1cnJlbnQgc3RhdGUuCisgKiBUaGlzIGhlbHBlciB3aWxsIGNoZWNrIGlmIGl0IGlz IHBvc3NpYmxlIHBlcmZvcm0gYSBjb21taXQgaW4gYW1lbmQgbW9kZS4KKyAqIEZvciBhbWVuZCBt b2RlIGRlZmluaXRpb24gc2VlIDpkb2M6IGFtZW5kIG1vZGUgYXRvbWljIGNvbW1pdAogICoKLSAq IEl0IHdpbGwgcmV0dXJuIDAgaWYgdGhlIGNvbW1pdCBjYW4gaGFwcGVuIGluIGFuIGFzeW5jaHJv bm91cyBmYXNoaW9uIG9yIGVycm9yCi0gKiBpZiBub3QuIE5vdGUgdGhhdCBlcnJvciBqdXN0IG1l YW4gaXQgY2FuJ3QgYmUgY29tbWl0ZWQgYXN5bmNocm9ub3VzbHksIGlmIGl0Ci0gKiBmYWlscyB0 aGUgY29tbWl0IHNob3VsZCBiZSB0cmVhdGVkIGxpa2UgYSBub3JtYWwgc3luY2hyb25vdXMgY29t bWl0LgorICogSXQgd2lsbCByZXR1cm4gMCBpZiB0aGUgY29tbWl0IGNhbiBoYXBwZW4gaW4gYW4g YW1lbmQgZmFzaGlvbiBvciBlcnJvcgorICogaWYgbm90LiBOb3RlIHRoYXQgZXJyb3IganVzdCBt ZWFuIGl0IGNhbid0IGJlIGNvbW1pdHRlZCBpbiBhbWVuZCBtb2RlLCBpZiBpdAorICogZmFpbHMg dGhlIGNvbW1pdCBzaG91bGQgYmUgdHJlYXRlZCBsaWtlIGEgbm9ybWFsIGNvbW1pdC4KICAqLwot aW50IGRybV9hdG9taWNfaGVscGVyX2FzeW5jX2NoZWNrKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs CitpbnQgZHJtX2F0b21pY19oZWxwZXJfYW1lbmRfY2hlY2soc3RydWN0IGRybV9kZXZpY2UgKmRl diwKIAkJCQkgICBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCiB7CiAJc3RydWN0IGRy bV9jcnRjICpjcnRjOwpAQCAtMTYxMCw3ICsxNjU5LDcgQEAgaW50IGRybV9hdG9taWNfaGVscGVy X2FzeW5jX2NoZWNrKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAKIAkvKgogCSAqIEZJWE1FOiBT aW5jZSBwcmVwYXJlX2ZiIGFuZCBjbGVhbnVwX2ZiIGFyZSBhbHdheXMgY2FsbGVkIG9uCi0JICog dGhlIG5ld19wbGFuZV9zdGF0ZSBmb3IgYXN5bmMgdXBkYXRlcyB3ZSBuZWVkIHRvIGJsb2NrIGZy YW1lYnVmZmVyCisJICogdGhlIG5ld19wbGFuZV9zdGF0ZSBmb3IgYW1lbmQgdXBkYXRlcywgd2Ug bmVlZCB0byBibG9jayBmcmFtZWJ1ZmZlcgogCSAqIGNoYW5nZXMuIFRoaXMgcHJldmVudHMgdXNl IG9mIGEgZmIgdGhhdCdzIGJlZW4gY2xlYW5lZCB1cCBhbmQKIAkgKiBkb3VibGUgY2xlYW51cHMg ZnJvbSBvY2N1cmluZy4KIAkgKi8KQEAgLTE2MTgsMzcgKzE2NjcsNDMgQEAgaW50IGRybV9hdG9t aWNfaGVscGVyX2FzeW5jX2NoZWNrKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJCXJldHVybiAt RUlOVkFMOwogCiAJZnVuY3MgPSBwbGFuZS0+aGVscGVyX3ByaXZhdGU7Ci0JaWYgKCFmdW5jcy0+ YXRvbWljX2FzeW5jX3VwZGF0ZSkKKwlpZiAoIWZ1bmNzLT5hdG9taWNfYW1lbmRfdXBkYXRlKQog CQlyZXR1cm4gLUVJTlZBTDsKIAogCWlmIChuZXdfcGxhbmVfc3RhdGUtPmZlbmNlKQogCQlyZXR1 cm4gLUVJTlZBTDsKIAogCS8qCi0JICogRG9uJ3QgZG8gYW4gYXN5bmMgdXBkYXRlIGlmIHRoZXJl IGlzIGFuIG91dHN0YW5kaW5nIGNvbW1pdCBtb2RpZnlpbmcKLQkgKiB0aGUgcGxhbmUuICBUaGlz IHByZXZlbnRzIG91ciBhc3luYyB1cGRhdGUncyBjaGFuZ2VzIGZyb20gZ2V0dGluZwotCSAqIG92 ZXJyaWRkZW4gYnkgYSBwcmV2aW91cyBzeW5jaHJvbm91cyB1cGRhdGUncyBzdGF0ZS4KKwkgKiBE b24ndCBkbyBhbiBhbWVuZCB1cGRhdGUgaWYgdGhlcmUgaXMgYW4gb3V0c3RhbmRpbmcgY29tbWl0 IG1vZGlmeWluZworCSAqIHRoZSBwbGFuZS4KKwkgKiBUT0RPOiBhZGQgc3VwcG9ydCBmb3IgbW9k aWZ5aW5nIHRoZSBvdXRzdGFuZGluZyBjb21taXQuCiAJICovCiAJaWYgKG9sZF9wbGFuZV9zdGF0 ZS0+Y29tbWl0ICYmCiAJICAgICF0cnlfd2FpdF9mb3JfY29tcGxldGlvbigmb2xkX3BsYW5lX3N0 YXRlLT5jb21taXQtPmh3X2RvbmUpKQogCQlyZXR1cm4gLUVCVVNZOwogCi0JcmV0dXJuIGZ1bmNz LT5hdG9taWNfYXN5bmNfY2hlY2socGxhbmUsIG5ld19wbGFuZV9zdGF0ZSk7CisJcmV0dXJuIGZ1 bmNzLT5hdG9taWNfYW1lbmRfY2hlY2socGxhbmUsIG5ld19wbGFuZV9zdGF0ZSk7CiB9Ci1FWFBP UlRfU1lNQk9MKGRybV9hdG9taWNfaGVscGVyX2FzeW5jX2NoZWNrKTsKK0VYUE9SVF9TWU1CT0wo ZHJtX2F0b21pY19oZWxwZXJfYW1lbmRfY2hlY2spOwogCiAvKioKLSAqIGRybV9hdG9taWNfaGVs cGVyX2FzeW5jX2NvbW1pdCAtIGNvbW1pdCBzdGF0ZSBhc3luY2hyb25vdXNseQorICogZHJtX2F0 b21pY19oZWxwZXJfYW1lbmRfY29tbWl0IC0gY29tbWl0IHN0YXRlIGluIGFtZW5kIG1vZGUKICAq IEBkZXY6IERSTSBkZXZpY2UKICAqIEBzdGF0ZTogdGhlIGRyaXZlciBzdGF0ZSBvYmplY3QKICAq Ci0gKiBUaGlzIGZ1bmN0aW9uIGNvbW1pdHMgYSBzdGF0ZSBhc3luY2hyb25vdXNseSwgaS5lLiwg bm90IHZibGFuawotICogc3luY2hyb25pemVkLiBJdCBzaG91bGQgYmUgdXNlZCBvbiBhIHN0YXRl IG9ubHkgd2hlbgotICogZHJtX2F0b21pY19hc3luY19jaGVjaygpIHN1Y2NlZWRzLiBBc3luYyBj b21taXRzIGFyZSBub3Qgc3VwcG9zZWQgdG8gc3dhcAotICogdGhlIHN0YXRlcyBsaWtlIG5vcm1h bCBzeW5jIGNvbW1pdHMsIGJ1dCBqdXN0IGRvIGluLXBsYWNlIGNoYW5nZXMgb24gdGhlCi0gKiBj dXJyZW50IHN0YXRlLgorICogVGhpcyBmdW5jdGlvbiBjb21taXRzIGEgc3RhdGUgaW4gYW1lbmQg bW9kZS4KKyAqIEZvciBhbWVuZCBtb2RlIGRlZmluaXRpb24gc2VlIDpkb2M6IGFtZW5kIG1vZGUg YXRvbWljIGNvbW1pdAorICoKKyAqIEl0IHNob3VsZCBiZSB1c2VkIG9uIGEgc3RhdGUgb25seSB3 aGVuIGRybV9hdG9taWNfYW1lbmRfY2hlY2soKSBzdWNjZWVkcy4KKyAqCisgKiBBbWVuZCBjb21t aXRzIGFyZSBub3Qgc3VwcG9zZWQgdG8gc3dhcCB0aGUgc3RhdGVzIGxpa2Ugbm9ybWFsIHN5bmMg Y29tbWl0cywKKyAqIGJ1dCBqdXN0IGRvIGluLXBsYWNlIGNoYW5nZXMgb24gdGhlIGN1cnJlbnQg c3RhdGUuCisgKgorICogVE9ETzogaW5zdGVhZCBvZiBkb2luZyBpbi1wbGFjZSBjaGFuZ2VzLCBt b2RpZnkgdGhlIG5ld19zdGF0ZSBhbmQgcGVyZm9ybSBhbgorICogaW1tZWRpYXRlIGZsaXAuIERy aXZlcnMgY291bGQgcmV1c2UgdGhlIHBhZ2VfZmxpcCBjb2RlIGFuZCBldmVuIHVzZSB0aGUKKyAq IERSTV9NT0RFX1BBR0VfRkxJUF9BU1lOQyBmbGFnIGlmIHRoZSBoYXJkd2FyZSBzdXBwb3J0cyBh c3luY3Jvbm91cyB1cGRhdGUuCiAgKi8KLXZvaWQgZHJtX2F0b21pY19oZWxwZXJfYXN5bmNfY29t bWl0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCit2b2lkIGRybV9hdG9taWNfaGVscGVyX2FtZW5k X2NvbW1pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCQkJCSAgICBzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUpCiB7CiAJc3RydWN0IGRybV9wbGFuZSAqcGxhbmU7CkBAIC0xNjU4LDEw ICsxNzEzLDEwIEBAIHZvaWQgZHJtX2F0b21pY19oZWxwZXJfYXN5bmNfY29tbWl0KHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsCiAKIAlmb3JfZWFjaF9uZXdfcGxhbmVfaW5fc3RhdGUoc3RhdGUsIHBs YW5lLCBwbGFuZV9zdGF0ZSwgaSkgewogCQlmdW5jcyA9IHBsYW5lLT5oZWxwZXJfcHJpdmF0ZTsK LQkJZnVuY3MtPmF0b21pY19hc3luY191cGRhdGUocGxhbmUsIHBsYW5lX3N0YXRlKTsKKwkJZnVu Y3MtPmF0b21pY19hbWVuZF91cGRhdGUocGxhbmUsIHBsYW5lX3N0YXRlKTsKIAogCQkvKgotCQkg KiAtPmF0b21pY19hc3luY191cGRhdGUoKSBpcyBzdXBwb3NlZCB0byB1cGRhdGUgdGhlCisJCSAq IC0+YXRvbWljX2FtZW5kX3VwZGF0ZSgpIGlzIHN1cHBvc2VkIHRvIHVwZGF0ZSB0aGUKIAkJICog cGxhbmUtPnN0YXRlIGluLXBsYWNlLCBtYWtlIHN1cmUgYXQgbGVhc3QgY29tbW9uCiAJCSAqIHBy b3BlcnRpZXMgaGF2ZSBiZWVuIHByb3Blcmx5IHVwZGF0ZWQuCiAJCSAqLwpAQCAtMTY3Miw3ICsx NzI3LDcgQEAgdm9pZCBkcm1fYXRvbWljX2hlbHBlcl9hc3luY19jb21taXQoc3RydWN0IGRybV9k ZXZpY2UgKmRldiwKIAkJV0FSTl9PTl9PTkNFKHBsYW5lLT5zdGF0ZS0+c3JjX3kgIT0gcGxhbmVf c3RhdGUtPnNyY195KTsKIAl9CiB9Ci1FWFBPUlRfU1lNQk9MKGRybV9hdG9taWNfaGVscGVyX2Fz eW5jX2NvbW1pdCk7CitFWFBPUlRfU1lNQk9MKGRybV9hdG9taWNfaGVscGVyX2FtZW5kX2NvbW1p dCk7CiAKIC8qKgogICogZHJtX2F0b21pY19oZWxwZXJfY29tbWl0IC0gY29tbWl0IHZhbGlkYXRl ZCBzdGF0ZSBvYmplY3QKQEAgLTE2OTgsMTIgKzE3NTMsMTIgQEAgaW50IGRybV9hdG9taWNfaGVs cGVyX2NvbW1pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogewogCWludCByZXQ7CiAKLQlpZiAo c3RhdGUtPmFzeW5jX3VwZGF0ZSkgeworCWlmIChzdGF0ZS0+YW1lbmRfdXBkYXRlKSB7CiAJCXJl dCA9IGRybV9hdG9taWNfaGVscGVyX3ByZXBhcmVfcGxhbmVzKGRldiwgc3RhdGUpOwogCQlpZiAo cmV0KQogCQkJcmV0dXJuIHJldDsKIAotCQlkcm1fYXRvbWljX2hlbHBlcl9hc3luY19jb21taXQo ZGV2LCBzdGF0ZSk7CisJCWRybV9hdG9taWNfaGVscGVyX2FtZW5kX2NvbW1pdChkZXYsIHN0YXRl KTsKIAkJZHJtX2F0b21pY19oZWxwZXJfY2xlYW51cF9wbGFuZXMoZGV2LCBzdGF0ZSk7CiAKIAkJ cmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1 X3BsYW5lLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X3BsYW5lLmMKaW5k ZXggYmUxMzE0MDk2N2I0Li44MTRlODIzMGNlYzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9tc20vZGlzcC9tZHA1L21kcDVfcGxhbmUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rp c3AvbWRwNS9tZHA1X3BsYW5lLmMKQEAgLTUzMSw4ICs1MzEsMTIgQEAgc3RhdGljIGNvbnN0IHN0 cnVjdCBkcm1fcGxhbmVfaGVscGVyX2Z1bmNzIG1kcDVfcGxhbmVfaGVscGVyX2Z1bmNzID0gewog CQkuY2xlYW51cF9mYiA9IG1kcDVfcGxhbmVfY2xlYW51cF9mYiwKIAkJLmF0b21pY19jaGVjayA9 IG1kcDVfcGxhbmVfYXRvbWljX2NoZWNrLAogCQkuYXRvbWljX3VwZGF0ZSA9IG1kcDVfcGxhbmVf YXRvbWljX3VwZGF0ZSwKLQkJLmF0b21pY19hc3luY19jaGVjayA9IG1kcDVfcGxhbmVfYXRvbWlj X2FzeW5jX2NoZWNrLAotCQkuYXRvbWljX2FzeW5jX3VwZGF0ZSA9IG1kcDVfcGxhbmVfYXRvbWlj X2FzeW5jX3VwZGF0ZSwKKwkJLyoKKwkJICogRklYTUU6IGlkZWFsbHksIGluc3RlYWQgb2YgaG9v a2luZyBhc3luYyB1cGRhdGVzIHRvIGFtZW5kLAorCQkgKiB3ZSBjb3VsZCBhdm9pZCB0ZWFyaW5n IGJ5IG1vZGlmeWluZyB0aGUgcGVuZGluZyBjb21taXQuCisJCSAqLworCQkuYXRvbWljX2FtZW5k X2NoZWNrID0gbWRwNV9wbGFuZV9hdG9taWNfYXN5bmNfY2hlY2ssCisJCS5hdG9taWNfYW1lbmRf dXBkYXRlID0gbWRwNV9wbGFuZV9hdG9taWNfYXN5bmNfdXBkYXRlLAogfTsKIAogc3RhdGljIHZv aWQgc2V0X3NjYW5vdXRfbG9ja2VkKHN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMsCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5jIGIvZHJpdmVy cy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuYwppbmRleCBhN2NiZjZjOWExNTMu LjIxNmFkNzYxMThkYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tj aGlwX2RybV92b3AuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJt X3ZvcC5jCkBAIC04NzcsNyArODc3LDcgQEAgc3RhdGljIHZvaWQgdm9wX3BsYW5lX2F0b21pY191 cGRhdGUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCiAJc3Bpbl91bmxvY2soJnZvcC0+cmVnX2xv Y2spOwogfQogCi1zdGF0aWMgaW50IHZvcF9wbGFuZV9hdG9taWNfYXN5bmNfY2hlY2soc3RydWN0 IGRybV9wbGFuZSAqcGxhbmUsCitzdGF0aWMgaW50IHZvcF9wbGFuZV9hdG9taWNfYW1lbmRfY2hl Y2soc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCiAJCQkJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUg KnN0YXRlKQogewogCXN0cnVjdCB2b3Bfd2luICp2b3Bfd2luID0gdG9fdm9wX3dpbihwbGFuZSk7 CkBAIC05MDgsNyArOTA4LDcgQEAgc3RhdGljIGludCB2b3BfcGxhbmVfYXRvbWljX2FzeW5jX2No ZWNrKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAogCQkJCQkJICAgdHJ1ZSwgdHJ1ZSk7CiB9CiAK LXN0YXRpYyB2b2lkIHZvcF9wbGFuZV9hdG9taWNfYXN5bmNfdXBkYXRlKHN0cnVjdCBkcm1fcGxh bmUgKnBsYW5lLAorc3RhdGljIHZvaWQgdm9wX3BsYW5lX2F0b21pY19hbWVuZF91cGRhdGUoc3Ry dWN0IGRybV9wbGFuZSAqcGxhbmUsCiAJCQkJCSAgc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqbmV3 X3N0YXRlKQogewogCXN0cnVjdCB2b3AgKnZvcCA9IHRvX3ZvcChwbGFuZS0+c3RhdGUtPmNydGMp OwpAQCAtOTUyLDggKzk1Miw4IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX3BsYW5lX2hlbHBl cl9mdW5jcyBwbGFuZV9oZWxwZXJfZnVuY3MgPSB7CiAJLmF0b21pY19jaGVjayA9IHZvcF9wbGFu ZV9hdG9taWNfY2hlY2ssCiAJLmF0b21pY191cGRhdGUgPSB2b3BfcGxhbmVfYXRvbWljX3VwZGF0 ZSwKIAkuYXRvbWljX2Rpc2FibGUgPSB2b3BfcGxhbmVfYXRvbWljX2Rpc2FibGUsCi0JLmF0b21p Y19hc3luY19jaGVjayA9IHZvcF9wbGFuZV9hdG9taWNfYXN5bmNfY2hlY2ssCi0JLmF0b21pY19h c3luY191cGRhdGUgPSB2b3BfcGxhbmVfYXRvbWljX2FzeW5jX3VwZGF0ZSwKKwkuYXRvbWljX2Ft ZW5kX2NoZWNrID0gdm9wX3BsYW5lX2F0b21pY19hbWVuZF9jaGVjaywKKwkuYXRvbWljX2FtZW5k X3VwZGF0ZSA9IHZvcF9wbGFuZV9hdG9taWNfYW1lbmRfdXBkYXRlLAogCS5wcmVwYXJlX2ZiID0g ZHJtX2dlbV9mYl9wcmVwYXJlX2ZiLAogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3ZjNC92YzRfa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0vdmM0L3ZjNF9rbXMuYwppbmRleCAyOTVk YWNjOGJjYjkuLjIyOTAzMmIxYjMxNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3ZjNC92 YzRfa21zLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3ZjNC92YzRfa21zLmMKQEAgLTIxNiw3ICsy MTYsNyBAQCBzdGF0aWMgaW50IHZjNF9hdG9taWNfY29tbWl0KHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCiAJc3RydWN0IHZjNF9kZXYgKnZjNCA9IHRvX3ZjNF9kZXYoZGV2KTsKIAlpbnQgcmV0Owog Ci0JaWYgKHN0YXRlLT5hc3luY191cGRhdGUpIHsKKwlpZiAoc3RhdGUtPmFtZW5kX3VwZGF0ZSkg ewogCQlyZXQgPSBkb3duX2ludGVycnVwdGlibGUoJnZjNC0+YXN5bmNfbW9kZXNldCk7CiAJCWlm IChyZXQpCiAJCQlyZXR1cm4gcmV0OwpAQCAtMjI3LDcgKzIyNyw3IEBAIHN0YXRpYyBpbnQgdmM0 X2F0b21pY19jb21taXQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJCXJldHVybiByZXQ7CiAJ CX0KIAotCQlkcm1fYXRvbWljX2hlbHBlcl9hc3luY19jb21taXQoZGV2LCBzdGF0ZSk7CisJCWRy bV9hdG9taWNfaGVscGVyX2FtZW5kX2NvbW1pdChkZXYsIHN0YXRlKTsKIAogCQlkcm1fYXRvbWlj X2hlbHBlcl9jbGVhbnVwX3BsYW5lcyhkZXYsIHN0YXRlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL3ZjNC92YzRfcGxhbmUuYyBiL2RyaXZlcnMvZ3B1L2RybS92YzQvdmM0X3BsYW5l LmMKaW5kZXggNGQ5MThkM2U0ODU4Li5lYTU2MDAwMDIyMmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS92YzQvdmM0X3BsYW5lLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3ZjNC92YzRfcGxh bmUuYwpAQCAtMTE2OSw4ICsxMTY5LDEyIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX3BsYW5l X2hlbHBlcl9mdW5jcyB2YzRfcGxhbmVfaGVscGVyX2Z1bmNzID0gewogCS5hdG9taWNfdXBkYXRl ID0gdmM0X3BsYW5lX2F0b21pY191cGRhdGUsCiAJLnByZXBhcmVfZmIgPSB2YzRfcHJlcGFyZV9m YiwKIAkuY2xlYW51cF9mYiA9IHZjNF9jbGVhbnVwX2ZiLAotCS5hdG9taWNfYXN5bmNfY2hlY2sg PSB2YzRfcGxhbmVfYXRvbWljX2FzeW5jX2NoZWNrLAotCS5hdG9taWNfYXN5bmNfdXBkYXRlID0g dmM0X3BsYW5lX2F0b21pY19hc3luY191cGRhdGUsCisJLyoKKwkgKiBGSVhNRTogaWRlYWxseSwg aW5zdGVhZCBvZiBob29raW5nIGFzeW5jIHVwZGF0ZXMgdG8gYW1lbmQsCisJICogd2UgY291bGQg YXZvaWQgdGVhcmluZyBieSBtb2RpZnlpbmcgdGhlIHBlbmRpbmcgY29tbWl0LgorCSAqLworCS5h dG9taWNfYW1lbmRfY2hlY2sgPSB2YzRfcGxhbmVfYXRvbWljX2FzeW5jX2NoZWNrLAorCS5hdG9t aWNfYW1lbmRfdXBkYXRlID0gdmM0X3BsYW5lX2F0b21pY19hc3luY191cGRhdGUsCiB9OwogCiBz dGF0aWMgdm9pZCB2YzRfcGxhbmVfZGVzdHJveShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSkKZGlm ZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaCBiL2luY2x1ZGUvZHJtL2RybV9hdG9t aWMuaAppbmRleCA4MjRhNWVkNGUyMTYuLmIxY2VkMDY5ZmZjMSAxMDA2NDQKLS0tIGEvaW5jbHVk ZS9kcm0vZHJtX2F0b21pYy5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaApAQCAtMzAw LDcgKzMwMCw3IEBAIHN0cnVjdCBfX2RybV9wcml2YXRlX29ianNfc3RhdGUgewogICogQHJlZjog Y291bnQgb2YgYWxsIHJlZmVyZW5jZXMgdG8gdGhpcyBzdGF0ZSAod2lsbCBub3QgYmUgZnJlZWQg dW50aWwgemVybykKICAqIEBkZXY6IHBhcmVudCBEUk0gZGV2aWNlCiAgKiBAbGVnYWN5X2N1cnNv cl91cGRhdGU6IGhpbnQgdG8gZW5mb3JjZSBsZWdhY3kgY3Vyc29yIElPQ1RMIHNlbWFudGljcwot ICogQGFzeW5jX3VwZGF0ZTogaGludCBmb3IgYXN5bmNocm9ub3VzIHBsYW5lIHVwZGF0ZQorICog QGFtZW5kX3VwZGF0ZTogaGludCBmb3IgYW1lbmQgcGxhbmUgdXBkYXRlCiAgKiBAcGxhbmVzOiBw b2ludGVyIHRvIGFycmF5IG9mIHN0cnVjdHVyZXMgd2l0aCBwZXItcGxhbmUgZGF0YQogICogQGNy dGNzOiBwb2ludGVyIHRvIGFycmF5IG9mIENSVEMgcG9pbnRlcnMKICAqIEBudW1fY29ubmVjdG9y OiBzaXplIG9mIHRoZSBAY29ubmVjdG9ycyBhbmQgQGNvbm5lY3Rvcl9zdGF0ZXMgYXJyYXlzCkBA IC0zMjgsNyArMzI4LDcgQEAgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgewogCSAqLwogCWJvb2wg YWxsb3dfbW9kZXNldCA6IDE7CiAJYm9vbCBsZWdhY3lfY3Vyc29yX3VwZGF0ZSA6IDE7Ci0JYm9v bCBhc3luY191cGRhdGUgOiAxOworCWJvb2wgYW1lbmRfdXBkYXRlIDogMTsKIAkvKioKIAkgKiBA ZHVwbGljYXRlZDoKIAkgKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2F0b21pY19oZWxw ZXIuaCBiL2luY2x1ZGUvZHJtL2RybV9hdG9taWNfaGVscGVyLmgKaW5kZXggNTgyMTRiZTNiZjNk Li44Y2UwNTk0Y2NmYjkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9hdG9taWNfaGVscGVy LmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX2F0b21pY19oZWxwZXIuaApAQCAtNTUsOSArNTUsOSBA QCB2b2lkIGRybV9hdG9taWNfaGVscGVyX2NvbW1pdF90YWlsX3JwbShzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUpOwogaW50IGRybV9hdG9taWNfaGVscGVyX2NvbW1pdChzdHJ1Y3QgZHJt X2RldmljZSAqZGV2LAogCQkJICAgICBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCiAJ CQkgICAgIGJvb2wgbm9uYmxvY2spOwotaW50IGRybV9hdG9taWNfaGVscGVyX2FzeW5jX2NoZWNr KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCitpbnQgZHJtX2F0b21pY19oZWxwZXJfYW1lbmRfY2hl Y2soc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJCQkgIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRl ICpzdGF0ZSk7Ci12b2lkIGRybV9hdG9taWNfaGVscGVyX2FzeW5jX2NvbW1pdChzdHJ1Y3QgZHJt X2RldmljZSAqZGV2LAordm9pZCBkcm1fYXRvbWljX2hlbHBlcl9hbWVuZF9jb21taXQoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwKIAkJCQkgICAgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRl KTsKIAogaW50IGRybV9hdG9taWNfaGVscGVyX3dhaXRfZm9yX2ZlbmNlcyhzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX21vZGVzZXRfaGVscGVyX3Z0 YWJsZXMuaCBiL2luY2x1ZGUvZHJtL2RybV9tb2Rlc2V0X2hlbHBlcl92dGFibGVzLmgKaW5kZXgg Y2ZiN2JlNDBiZWQ3Li5kOTJlNjJkZDc2YzQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9t b2Rlc2V0X2hlbHBlcl92dGFibGVzLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX21vZGVzZXRfaGVs cGVyX3Z0YWJsZXMuaApAQCAtMTEzNiw1MyArMTEzNiw1NSBAQCBzdHJ1Y3QgZHJtX3BsYW5lX2hl bHBlcl9mdW5jcyB7CiAJCQkgICAgICAgc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqb2xkX3N0YXRl KTsKIAogCS8qKgotCSAqIEBhdG9taWNfYXN5bmNfY2hlY2s6CisJICogQGF0b21pY19hbWVuZF9j aGVjazoKIAkgKgogCSAqIERyaXZlcnMgc2hvdWxkIHNldCB0aGlzIGZ1bmN0aW9uIHBvaW50ZXIg dG8gY2hlY2sgaWYgdGhlIHBsYW5lIHN0YXRlCi0JICogY2FuIGJlIHVwZGF0ZWQgaW4gYSBhc3lu YyBmYXNoaW9uLiBIZXJlIGFzeW5jIG1lYW5zICJub3QgdmJsYW5rCi0JICogc3luY2hyb25pemVk Ii4KKwkgKiBjYW4gYmUgdXBkYXRlZCBpbiBhbWVuZCBtb2RlLgorCSAqIEZvciBhbWVuZCBtb2Rl IGRlZmluaXRpb24gc2VlIDpkb2M6IGFtZW5kIG1vZGUgYXRvbWljIGNvbW1pdAogCSAqCi0JICog VGhpcyBob29rIGlzIGNhbGxlZCBieSBkcm1fYXRvbWljX2FzeW5jX2NoZWNrKCkgdG8gZXN0YWJs aXNoIGlmIGEKLQkgKiBnaXZlbiB1cGRhdGUgY2FuIGJlIGNvbW1pdHRlZCBhc3luY2hyb25vdXNs eSwgdGhhdCBpcywgaWYgaXQgY2FuCisJICogVGhpcyBob29rIGlzIGNhbGxlZCBieSBkcm1fYXRv bWljX2FtZW5kX2NoZWNrKCkgdG8gZXN0YWJsaXNoIGlmIGEKKwkgKiBnaXZlbiB1cGRhdGUgY2Fu IGJlIGNvbW1pdHRlZCBpbiBhbWVuZCBtb2RlLCB0aGF0IGlzLCBpZiBpdCBjYW4KIAkgKiBqdW1w IGFoZWFkIG9mIHRoZSBzdGF0ZSBjdXJyZW50bHkgcXVldWVkIGZvciB1cGRhdGUuCiAJICoKIAkg KiBSRVRVUk5TOgogCSAqCiAJICogUmV0dXJuIDAgb24gc3VjY2VzcyBhbmQgYW55IGVycm9yIHJl dHVybmVkIGluZGljYXRlcyB0aGF0IHRoZSB1cGRhdGUKLQkgKiBjYW4gbm90IGJlIGFwcGxpZWQg aW4gYXN5bmNocm9ub3VzIG1hbm5lci4KKwkgKiBjYW4gbm90IGJlIGFwcGxpZWQgaW4gYW1lbmQg bW9kZS4KIAkgKi8KLQlpbnQgKCphdG9taWNfYXN5bmNfY2hlY2spKHN0cnVjdCBkcm1fcGxhbmUg KnBsYW5lLAorCWludCAoKmF0b21pY19hbWVuZF9jaGVjaykoc3RydWN0IGRybV9wbGFuZSAqcGxh bmUsCiAJCQkJICBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpzdGF0ZSk7CiAKIAkvKioKLQkgKiBA YXRvbWljX2FzeW5jX3VwZGF0ZToKKwkgKiBAYXRvbWljX2FtZW5kX3VwZGF0ZToKIAkgKgotCSAq IERyaXZlcnMgc2hvdWxkIHNldCB0aGlzIGZ1bmN0aW9uIHBvaW50ZXIgdG8gcGVyZm9ybSBhc3lu Y2hyb25vdXMKLQkgKiB1cGRhdGVzIG9mIHBsYW5lcywgdGhhdCBpcywganVtcCBhaGVhZCBvZiB0 aGUgY3VycmVudGx5IHF1ZXVlZAotCSAqIHN0YXRlIGFuZCB1cGRhdGUgdGhlIHBsYW5lLiBIZXJl IGFzeW5jIG1lYW5zICJub3QgdmJsYW5rCi0JICogc3luY2hyb25pemVkIi4KKwkgKiBEcml2ZXJz IHNob3VsZCBzZXQgdGhpcyBmdW5jdGlvbiBwb2ludGVyIHRvIHBlcmZvcm0gYW1lbmQKKwkgKiB1 cGRhdGVzIG9mIHBsYW5lcy4KKwkgKiBUaGUgYW1lbmQgZmVhdHVyZSBwcm92aWRlcyBhIHdheSB0 byBwZXJmb3JtIDEwMDAgY29tbWl0cywgd2l0aG91dAorCSAqIHdhaXRpbmcgZm9yIDEwMDAgdmJs YW5rcyB0byBnZXQgdGhlIGxhc3Qgc3RhdGUgYXBwbGllZC4KIAkgKgotCSAqIFRoaXMgaG9vayBp cyBjYWxsZWQgYnkgZHJtX2F0b21pY19oZWxwZXJfYXN5bmNfY29tbWl0KCkuCisJICogRm9yIGFt ZW5kIG1vZGUgZGVmaW5pdGlvbiBzZWUgOmRvYzogYW1lbmQgbW9kZSBhdG9taWMgY29tbWl0CiAJ ICoKLQkgKiBBbiBhc3luYyB1cGRhdGUgd2lsbCBoYXBwZW4gb24gbGVnYWN5IGN1cnNvciB1cGRh dGVzLiBBbiBhc3luYworCSAqIFRoaXMgaG9vayBpcyBjYWxsZWQgYnkgZHJtX2F0b21pY19oZWxw ZXJfYW1lbmRfY29tbWl0KCkuCisJICoKKwkgKiBBbiBhbWVuZCB1cGRhdGUgd2lsbCBoYXBwZW4g b24gbGVnYWN5IGN1cnNvciB1cGRhdGVzLiBBbiBhbWVuZAogCSAqIHVwZGF0ZSB3b24ndCBoYXBw ZW4gaWYgdGhlcmUgaXMgYW4gb3V0c3RhbmRpbmcgY29tbWl0IG1vZGlmeWluZwogCSAqIHRoZSBz YW1lIHBsYW5lLgogCSAqCiAJICogTm90ZSB0aGF0IHVubGlrZSAmZHJtX3BsYW5lX2hlbHBlcl9m dW5jcy5hdG9taWNfdXBkYXRlIHRoaXMgaG9vawotCSAqIHRha2VzIHRoZSBuZXcgJmRybV9wbGFu ZV9zdGF0ZSBhcyBwYXJhbWV0ZXIuIFdoZW4gZG9pbmcgYXN5bmNfdXBkYXRlCisJICogdGFrZXMg dGhlIG5ldyAmZHJtX3BsYW5lX3N0YXRlIGFzIHBhcmFtZXRlci4gV2hlbiBkb2luZyBhbWVuZF91 cGRhdGUKIAkgKiBkcml2ZXJzIHNob3VsZG4ndCByZXBsYWNlIHRoZSAmZHJtX3BsYW5lX3N0YXRl IGJ1dCB1cGRhdGUgdGhlCiAJICogY3VycmVudCBvbmUgd2l0aCB0aGUgbmV3IHBsYW5lIGNvbmZp Z3VyYXRpb25zIGluIHRoZSBuZXcKIAkgKiBwbGFuZV9zdGF0ZS4KIAkgKgogCSAqIEZJWE1FOgog CSAqICAtIEl0IG9ubHkgd29ya3MgZm9yIHNpbmdsZSBwbGFuZSB1cGRhdGVzCi0JICogIC0gQXN5 bmMgUGFnZWZsaXBzIGFyZSBub3Qgc3VwcG9ydGVkIHlldAotCSAqICAtIFNvbWUgaHcgbWlnaHQg c3RpbGwgc2NhbiBvdXQgdGhlIG9sZCBidWZmZXIgdW50aWwgdGhlIG5leHQKKwkgKiAgLSBJZiBo YXJkd2FyZSBkb24ndCBzdXBwb3J0IGFzeW5jcm9ub3VzIHVwZGF0ZSB0byBpbXBsZW1lbnQgYW1l bmQsCisJICogICAgc29tZSBodyBtaWdodCBzdGlsbCBzY2FuIG91dCB0aGUgb2xkIGJ1ZmZlciB1 bnRpbCB0aGUgbmV4dAogCSAqICAgIHZibGFuaywgaG93ZXZlciB3ZSBsZXQgZ28gb2YgdGhlIGZi IHJlZmVyZW5jZXMgYXMgc29vbiBhcwogCSAqICAgIHdlIHJ1biB0aGlzIGhvb2suIEZvciBub3cg ZHJpdmVycyBtdXN0IGltcGxlbWVudCB0aGVpciBvd24gd29ya2VycwogCSAqICAgIGZvciBkZWZl cnJpbmcgaWYgbmVlZGVkLCB1bnRpbCBhIGNvbW1vbiBzb2x1dGlvbiBpcyBjcmVhdGVkLgogCSAq LwotCXZvaWQgKCphdG9taWNfYXN5bmNfdXBkYXRlKShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwK Kwl2b2lkICgqYXRvbWljX2FtZW5kX3VwZGF0ZSkoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCiAJ CQkJICAgIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm5ld19zdGF0ZSk7CiB9OwogCi0tIAoyLjIw LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkZyZWVk cmVubyBtYWlsaW5nIGxpc3QKRnJlZWRyZW5vQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ZyZWVkcmVubw== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.9 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0FC45C10F0E for ; Fri, 12 Apr 2019 12:59:13 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id B50EF20818 for ; Fri, 12 Apr 2019 12:59:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726755AbfDLM7M (ORCPT ); Fri, 12 Apr 2019 08:59:12 -0400 Received: from bhuna.collabora.co.uk ([46.235.227.227]:34540 "EHLO bhuna.collabora.co.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726702AbfDLM7L (ORCPT ); Fri, 12 Apr 2019 08:59:11 -0400 Received: from localhost.localdomain (unknown [IPv6:2804:431:9718:a5e8:c168:522a:50d5:d06d]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: koike) by bhuna.collabora.co.uk (Postfix) with ESMTPSA id 95480281296; Fri, 12 Apr 2019 13:58:58 +0100 (BST) From: Helen Koike To: dri-devel@lists.freedesktop.org, David Airlie Cc: dnicoara@chromium.org, daniels@collabora.com, alexandros.frantzis@collabora.com, daniel.vetter@ffwll.ch, linux-kernel@vger.kernel.org, tomasz Figa , tina.zhang@intel.com, boris.brezillon@collabora.com, Sean Paul , kernel@collabora.com, nicholas.kazlauskas@amd.com, =?UTF-8?q?St=C3=A9phane=20Marchesin?= , Gustavo Padovan , Helen Koike , Sean Paul , Sandy Huang , linux-doc@vger.kernel.org, Thomas Zimmermann , Jonathan Corbet , Harry Wentland , Alex Deucher , Bhawanpreet Lakha , "David (ChunMing) Zhou" , Anthony Koo , Russell King , linux-rockchip@lists.infradead.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Rob Clark , =?UTF-8?q?Heiko=20St=C3=BCbner?= , Eric Anholt , Leo Li , linux-arm-msm@vger.kernel.org, =?UTF-8?q?Christian=20K=C3=B6nig?= , linux-arm-kernel@lists.infradead.org, David Francis , Mikita Lipski , amd-gfx@lists.freedesktop.org, Maarten Lankhorst , Maxime Ripard , freedreno@lists.freedesktop.org, Mamta Shukla , Daniel Vetter Subject: [PATCH v3 2/4] drm/atomic: rename async_{update,check} to amend_{update,check} Date: Fri, 12 Apr 2019 09:58:25 -0300 Message-Id: <20190412125827.5877-3-helen.koike@collabora.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190412125827.5877-1-helen.koike@collabora.com> References: <20190412125827.5877-1-helen.koike@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Message-ID: <20190412125825.W5je7iqF_7DEPswd0OMzh9PK1gZg_zU3jnnUdweBVP8@z> Asynchronous update is the ability change the hw state at any time, not only during vblank. Amend mode is the ability to perform 1000 commits to be applied as soon as possible without waiting for 1000 vblanks. async updates can be seen as amend, but the opposite is not true. &drm_plane_helper_funcs.atomic_async_{update,check}() was being used by drivers to implement amend and not async. So rename them to amend. Also improve docs explaining the difference. If asynchronous is required, normal page flip can be performed using DRM_MODE_PAGE_FLIP_ASYNC flag. Signed-off-by: Helen Koike --- Hello, I would like to officially clarify what async update means by adding it in the docs. Please correct me if I am wrong, but the current async_{update,check} callbacks are being used to do amend (the legacy cursor behavior), i.e. to allow 1000 updates without waiting for 1000 vblanks. So I would like to clarify this in the docs and rename the current callbacks to reflect this behaviour. I also see that for real async updates, the flag DRM_MODE_PAGE_FLIP_ASYNC can be used in a normal sync update (it is already being used by some drivers actually, in the atomic path, not only in the legacy page flip, at least is what I understood from amdgpu_dm_atomic_commit_tail() implementation). Please, let me know if I misunderstood anything. Otherwise renaming and improving the docs would put us all in sync. Thanks! Helen Changes in v3: None Changes in v2: None Changes in v1: None Documentation/gpu/drm-kms-helpers.rst | 8 +- .../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 10 +- drivers/gpu/drm/drm_atomic_helper.c | 111 +++++++++++++----- drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c | 8 +- drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 8 +- drivers/gpu/drm/vc4/vc4_kms.c | 4 +- drivers/gpu/drm/vc4/vc4_plane.c | 8 +- include/drm/drm_atomic.h | 4 +- include/drm/drm_atomic_helper.h | 4 +- include/drm/drm_modeset_helper_vtables.h | 38 +++--- 10 files changed, 139 insertions(+), 64 deletions(-) diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst index 58b375e47615..c067a196902d 100644 --- a/Documentation/gpu/drm-kms-helpers.rst +++ b/Documentation/gpu/drm-kms-helpers.rst @@ -53,12 +53,18 @@ Overview .. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c :doc: overview -Implementing Asynchronous Atomic Commit +Implementing Nonblocking Atomic Commit --------------------------------------- .. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c :doc: implementing nonblocking commit +Amend Mode Atomic Commit +------------------------ + +.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c + :doc: amend mode atomic commit + Helper Functions Reference -------------------------- diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c index 2f26581b93ff..711e7715e112 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c @@ -3779,8 +3779,12 @@ static const struct drm_plane_helper_funcs dm_plane_helper_funcs = { .prepare_fb = dm_plane_helper_prepare_fb, .cleanup_fb = dm_plane_helper_cleanup_fb, .atomic_check = dm_plane_atomic_check, - .atomic_async_check = dm_plane_atomic_async_check, - .atomic_async_update = dm_plane_atomic_async_update + /* + * FIXME: ideally, instead of hooking async updates to amend, + * we could avoid tearing by modifying the pending commit. + */ + .atomic_amend_check = dm_plane_atomic_async_check, + .atomic_amend_update = dm_plane_atomic_async_update }; /* @@ -6140,7 +6144,7 @@ static int amdgpu_dm_atomic_check(struct drm_device *dev, * helper, check if it can be done asynchronously for better * performance. */ - state->async_update = !drm_atomic_helper_async_check(dev, state); + state->amend_update = !drm_atomic_helper_amend_check(dev, state); } /* Must be success */ diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index 2453678d1186..eb5dcd84fea7 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -948,7 +948,7 @@ int drm_atomic_helper_check(struct drm_device *dev, return ret; if (state->legacy_cursor_update) - state->async_update = !drm_atomic_helper_async_check(dev, state); + state->amend_update = !drm_atomic_helper_amend_check(dev, state); return ret; } @@ -1569,19 +1569,68 @@ static void commit_work(struct work_struct *work) } /** - * drm_atomic_helper_async_check - check if state can be commited asynchronously + * DOC: amend mode atomic commit + * + * The amend feature provides a way to perform 1000 updates to be applied as + * soon as possible without waiting for 1000 vblanks. + + * Currently, only the legacy cursor update uses amend mode, where historically, + * userspace performs several updates before the next vblank and don't want to + * see a delay in the cursor's movement. + * If amend is not supported, legacy cursor falls back to a normal sync update. + * + * To implement the legacy cursor update, drivers should provide + * &drm_plane_helper_funcs.atomic_amend_check() and + * &drm_plane_helper_funcs.atomic_amend_update() + * + * Drivers just need to make sure the last state overrides the previous one, so + * that if X updates were performed, then, in some point in the near future, + * preferentially in the next vblank, the Xth state will be the hardware state. + * + * If the hardware supports asynchronous update, i.e, changing its state without + * waiting for vblank, then &drm_plane_helper_funcs.atomic_amend_update() can be + * implemented using asynchronous update (the amend mode property is held), but + * it can cause tearing in the image. + * + * Otherwise (if async is not supported by the hw), drivers need to override the + * commit to be applied in the next vblank, and also they need to take care of + * framebuffer references when programming a new framebuffer, as hw can still be + * scanning out the old framebuffer. For now drivers must implement their own + * workers for deferring if needed, until a common solution is created. + * + * + * Notes / highlights: + * + * - amend update is performed on legacy cursor updates. + * + * - amend update won't happen if there is an outstanding commit modifying the + * same plane. + * + * - amend update won't happen if atomic_amend_check() returns false. + * + * - if atomic_amend_check() fails, it falls back to a normal synchronous + * update. + * + * - if userspace wants to ensure an asynchronous page flip, i.e. change hw + * state immediately, see DRM_MODE_PAGE_FLIP_ASYNC flag + * (asynchronous page flip maintains the amend property by definition). + * + * - Asynchronous modeset doesn't make sense, only asynchronous page flip. + */ + +/** + * drm_atomic_helper_amend_check - check if state can be amended. * @dev: DRM device * @state: the driver state object * - * This helper will check if it is possible to commit the state asynchronously. - * Async commits are not supposed to swap the states like normal sync commits - * but just do in-place changes on the current state. + * This helper will check if it is possible perform a commit in amend mode. + * For amend mode definition see :doc: amend mode atomic commit * - * It will return 0 if the commit can happen in an asynchronous fashion or error - * if not. Note that error just mean it can't be commited asynchronously, if it - * fails the commit should be treated like a normal synchronous commit. + * It will return 0 if the commit can happen in an amend fashion or error + * if not. Note that error just mean it can't be committed in amend mode, if it + * fails the commit should be treated like a normal commit. */ -int drm_atomic_helper_async_check(struct drm_device *dev, +int drm_atomic_helper_amend_check(struct drm_device *dev, struct drm_atomic_state *state) { struct drm_crtc *crtc; @@ -1610,7 +1659,7 @@ int drm_atomic_helper_async_check(struct drm_device *dev, /* * FIXME: Since prepare_fb and cleanup_fb are always called on - * the new_plane_state for async updates we need to block framebuffer + * the new_plane_state for amend updates, we need to block framebuffer * changes. This prevents use of a fb that's been cleaned up and * double cleanups from occuring. */ @@ -1618,37 +1667,43 @@ int drm_atomic_helper_async_check(struct drm_device *dev, return -EINVAL; funcs = plane->helper_private; - if (!funcs->atomic_async_update) + if (!funcs->atomic_amend_update) return -EINVAL; if (new_plane_state->fence) return -EINVAL; /* - * Don't do an async update if there is an outstanding commit modifying - * the plane. This prevents our async update's changes from getting - * overridden by a previous synchronous update's state. + * Don't do an amend update if there is an outstanding commit modifying + * the plane. + * TODO: add support for modifying the outstanding commit. */ if (old_plane_state->commit && !try_wait_for_completion(&old_plane_state->commit->hw_done)) return -EBUSY; - return funcs->atomic_async_check(plane, new_plane_state); + return funcs->atomic_amend_check(plane, new_plane_state); } -EXPORT_SYMBOL(drm_atomic_helper_async_check); +EXPORT_SYMBOL(drm_atomic_helper_amend_check); /** - * drm_atomic_helper_async_commit - commit state asynchronously + * drm_atomic_helper_amend_commit - commit state in amend mode * @dev: DRM device * @state: the driver state object * - * This function commits a state asynchronously, i.e., not vblank - * synchronized. It should be used on a state only when - * drm_atomic_async_check() succeeds. Async commits are not supposed to swap - * the states like normal sync commits, but just do in-place changes on the - * current state. + * This function commits a state in amend mode. + * For amend mode definition see :doc: amend mode atomic commit + * + * It should be used on a state only when drm_atomic_amend_check() succeeds. + * + * Amend commits are not supposed to swap the states like normal sync commits, + * but just do in-place changes on the current state. + * + * TODO: instead of doing in-place changes, modify the new_state and perform an + * immediate flip. Drivers could reuse the page_flip code and even use the + * DRM_MODE_PAGE_FLIP_ASYNC flag if the hardware supports asyncronous update. */ -void drm_atomic_helper_async_commit(struct drm_device *dev, +void drm_atomic_helper_amend_commit(struct drm_device *dev, struct drm_atomic_state *state) { struct drm_plane *plane; @@ -1658,10 +1713,10 @@ void drm_atomic_helper_async_commit(struct drm_device *dev, for_each_new_plane_in_state(state, plane, plane_state, i) { funcs = plane->helper_private; - funcs->atomic_async_update(plane, plane_state); + funcs->atomic_amend_update(plane, plane_state); /* - * ->atomic_async_update() is supposed to update the + * ->atomic_amend_update() is supposed to update the * plane->state in-place, make sure at least common * properties have been properly updated. */ @@ -1672,7 +1727,7 @@ void drm_atomic_helper_async_commit(struct drm_device *dev, WARN_ON_ONCE(plane->state->src_y != plane_state->src_y); } } -EXPORT_SYMBOL(drm_atomic_helper_async_commit); +EXPORT_SYMBOL(drm_atomic_helper_amend_commit); /** * drm_atomic_helper_commit - commit validated state object @@ -1698,12 +1753,12 @@ int drm_atomic_helper_commit(struct drm_device *dev, { int ret; - if (state->async_update) { + if (state->amend_update) { ret = drm_atomic_helper_prepare_planes(dev, state); if (ret) return ret; - drm_atomic_helper_async_commit(dev, state); + drm_atomic_helper_amend_commit(dev, state); drm_atomic_helper_cleanup_planes(dev, state); return 0; diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c index be13140967b4..814e8230cec6 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c @@ -531,8 +531,12 @@ static const struct drm_plane_helper_funcs mdp5_plane_helper_funcs = { .cleanup_fb = mdp5_plane_cleanup_fb, .atomic_check = mdp5_plane_atomic_check, .atomic_update = mdp5_plane_atomic_update, - .atomic_async_check = mdp5_plane_atomic_async_check, - .atomic_async_update = mdp5_plane_atomic_async_update, + /* + * FIXME: ideally, instead of hooking async updates to amend, + * we could avoid tearing by modifying the pending commit. + */ + .atomic_amend_check = mdp5_plane_atomic_async_check, + .atomic_amend_update = mdp5_plane_atomic_async_update, }; static void set_scanout_locked(struct mdp5_kms *mdp5_kms, diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c index a7cbf6c9a153..216ad76118dc 100644 --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c @@ -877,7 +877,7 @@ static void vop_plane_atomic_update(struct drm_plane *plane, spin_unlock(&vop->reg_lock); } -static int vop_plane_atomic_async_check(struct drm_plane *plane, +static int vop_plane_atomic_amend_check(struct drm_plane *plane, struct drm_plane_state *state) { struct vop_win *vop_win = to_vop_win(plane); @@ -908,7 +908,7 @@ static int vop_plane_atomic_async_check(struct drm_plane *plane, true, true); } -static void vop_plane_atomic_async_update(struct drm_plane *plane, +static void vop_plane_atomic_amend_update(struct drm_plane *plane, struct drm_plane_state *new_state) { struct vop *vop = to_vop(plane->state->crtc); @@ -952,8 +952,8 @@ static const struct drm_plane_helper_funcs plane_helper_funcs = { .atomic_check = vop_plane_atomic_check, .atomic_update = vop_plane_atomic_update, .atomic_disable = vop_plane_atomic_disable, - .atomic_async_check = vop_plane_atomic_async_check, - .atomic_async_update = vop_plane_atomic_async_update, + .atomic_amend_check = vop_plane_atomic_amend_check, + .atomic_amend_update = vop_plane_atomic_amend_update, .prepare_fb = drm_gem_fb_prepare_fb, }; diff --git a/drivers/gpu/drm/vc4/vc4_kms.c b/drivers/gpu/drm/vc4/vc4_kms.c index 295dacc8bcb9..229032b1b315 100644 --- a/drivers/gpu/drm/vc4/vc4_kms.c +++ b/drivers/gpu/drm/vc4/vc4_kms.c @@ -216,7 +216,7 @@ static int vc4_atomic_commit(struct drm_device *dev, struct vc4_dev *vc4 = to_vc4_dev(dev); int ret; - if (state->async_update) { + if (state->amend_update) { ret = down_interruptible(&vc4->async_modeset); if (ret) return ret; @@ -227,7 +227,7 @@ static int vc4_atomic_commit(struct drm_device *dev, return ret; } - drm_atomic_helper_async_commit(dev, state); + drm_atomic_helper_amend_commit(dev, state); drm_atomic_helper_cleanup_planes(dev, state); diff --git a/drivers/gpu/drm/vc4/vc4_plane.c b/drivers/gpu/drm/vc4/vc4_plane.c index 4d918d3e4858..ea560000222d 100644 --- a/drivers/gpu/drm/vc4/vc4_plane.c +++ b/drivers/gpu/drm/vc4/vc4_plane.c @@ -1169,8 +1169,12 @@ static const struct drm_plane_helper_funcs vc4_plane_helper_funcs = { .atomic_update = vc4_plane_atomic_update, .prepare_fb = vc4_prepare_fb, .cleanup_fb = vc4_cleanup_fb, - .atomic_async_check = vc4_plane_atomic_async_check, - .atomic_async_update = vc4_plane_atomic_async_update, + /* + * FIXME: ideally, instead of hooking async updates to amend, + * we could avoid tearing by modifying the pending commit. + */ + .atomic_amend_check = vc4_plane_atomic_async_check, + .atomic_amend_update = vc4_plane_atomic_async_update, }; static void vc4_plane_destroy(struct drm_plane *plane) diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 824a5ed4e216..b1ced069ffc1 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -300,7 +300,7 @@ struct __drm_private_objs_state { * @ref: count of all references to this state (will not be freed until zero) * @dev: parent DRM device * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics - * @async_update: hint for asynchronous plane update + * @amend_update: hint for amend plane update * @planes: pointer to array of structures with per-plane data * @crtcs: pointer to array of CRTC pointers * @num_connector: size of the @connectors and @connector_states arrays @@ -328,7 +328,7 @@ struct drm_atomic_state { */ bool allow_modeset : 1; bool legacy_cursor_update : 1; - bool async_update : 1; + bool amend_update : 1; /** * @duplicated: * diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h index 58214be3bf3d..8ce0594ccfb9 100644 --- a/include/drm/drm_atomic_helper.h +++ b/include/drm/drm_atomic_helper.h @@ -55,9 +55,9 @@ void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *state); int drm_atomic_helper_commit(struct drm_device *dev, struct drm_atomic_state *state, bool nonblock); -int drm_atomic_helper_async_check(struct drm_device *dev, +int drm_atomic_helper_amend_check(struct drm_device *dev, struct drm_atomic_state *state); -void drm_atomic_helper_async_commit(struct drm_device *dev, +void drm_atomic_helper_amend_commit(struct drm_device *dev, struct drm_atomic_state *state); int drm_atomic_helper_wait_for_fences(struct drm_device *dev, diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h index cfb7be40bed7..d92e62dd76c4 100644 --- a/include/drm/drm_modeset_helper_vtables.h +++ b/include/drm/drm_modeset_helper_vtables.h @@ -1136,53 +1136,55 @@ struct drm_plane_helper_funcs { struct drm_plane_state *old_state); /** - * @atomic_async_check: + * @atomic_amend_check: * * Drivers should set this function pointer to check if the plane state - * can be updated in a async fashion. Here async means "not vblank - * synchronized". + * can be updated in amend mode. + * For amend mode definition see :doc: amend mode atomic commit * - * This hook is called by drm_atomic_async_check() to establish if a - * given update can be committed asynchronously, that is, if it can + * This hook is called by drm_atomic_amend_check() to establish if a + * given update can be committed in amend mode, that is, if it can * jump ahead of the state currently queued for update. * * RETURNS: * * Return 0 on success and any error returned indicates that the update - * can not be applied in asynchronous manner. + * can not be applied in amend mode. */ - int (*atomic_async_check)(struct drm_plane *plane, + int (*atomic_amend_check)(struct drm_plane *plane, struct drm_plane_state *state); /** - * @atomic_async_update: + * @atomic_amend_update: * - * Drivers should set this function pointer to perform asynchronous - * updates of planes, that is, jump ahead of the currently queued - * state and update the plane. Here async means "not vblank - * synchronized". + * Drivers should set this function pointer to perform amend + * updates of planes. + * The amend feature provides a way to perform 1000 commits, without + * waiting for 1000 vblanks to get the last state applied. * - * This hook is called by drm_atomic_helper_async_commit(). + * For amend mode definition see :doc: amend mode atomic commit * - * An async update will happen on legacy cursor updates. An async + * This hook is called by drm_atomic_helper_amend_commit(). + * + * An amend update will happen on legacy cursor updates. An amend * update won't happen if there is an outstanding commit modifying * the same plane. * * Note that unlike &drm_plane_helper_funcs.atomic_update this hook - * takes the new &drm_plane_state as parameter. When doing async_update + * takes the new &drm_plane_state as parameter. When doing amend_update * drivers shouldn't replace the &drm_plane_state but update the * current one with the new plane configurations in the new * plane_state. * * FIXME: * - It only works for single plane updates - * - Async Pageflips are not supported yet - * - Some hw might still scan out the old buffer until the next + * - If hardware don't support asyncronous update to implement amend, + * some hw might still scan out the old buffer until the next * vblank, however we let go of the fb references as soon as * we run this hook. For now drivers must implement their own workers * for deferring if needed, until a common solution is created. */ - void (*atomic_async_update)(struct drm_plane *plane, + void (*atomic_amend_update)(struct drm_plane *plane, struct drm_plane_state *new_state); }; -- 2.20.1