From mboxrd@z Thu Jan 1 00:00:00 1970 From: Rob Clark Subject: [RFC 1/4] drm: Add writeback connector type Date: Fri, 23 Feb 2018 08:17:51 -0500 Message-ID: <20180223131758.18362-2-robdclark@gmail.com> References: <20180223131758.18362-1-robdclark@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180223131758.18362-1-robdclark-Re5JQEeQqe8AvxtiuMwx3w@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 Cc: Jonathan Corbet , Maarten Lankhorst , linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-doc-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Liviu Dudau , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, David Airlie , Rob Clark , Sean Paul , Gustavo Padovan , Mihail Atanassov , freedreno-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Brian Starkey List-Id: linux-arm-msm@vger.kernel.org RnJvbTogQnJpYW4gU3RhcmtleSA8YnJpYW4uc3RhcmtleUBhcm0uY29tPgoKV3JpdGViYWNrIGNv bm5lY3RvcnMgcmVwcmVzZW50IHdyaXRlYmFjayBlbmdpbmVzIHdoaWNoIGNhbiB3cml0ZSB0aGUK Q1JUQyBvdXRwdXQgdG8gYSBtZW1vcnkgZnJhbWVidWZmZXIuIEFkZCBhIHdyaXRlYmFjayBjb25u ZWN0b3IgdHlwZSBhbmQKcmVsYXRlZCBzdXBwb3J0IGZ1bmN0aW9ucy4KCkRyaXZlcnMgc2hvdWxk IGluaXRpYWxpemUgYSB3cml0ZWJhY2sgY29ubmVjdG9yIHdpdGgKZHJtX3dyaXRlYmFja19jb25u ZWN0b3JfaW5pdCgpIHdoaWNoIHRha2VzIGNhcmUgb2Ygc2V0dGluZyB1cCBhbGwgdGhlCndyaXRl YmFjay1zcGVjaWZpYyBkZXRhaWxzIG9uIHRvcCBvZiB0aGUgbm9ybWFsIGZ1bmN0aW9uYWxpdHkg b2YKZHJtX2Nvbm5lY3Rvcl9pbml0KCkuCgpXcml0ZWJhY2sgY29ubmVjdG9ycyBoYXZlIGEgV1JJ VEVCQUNLX0ZCX0lEIHByb3BlcnR5LCB1c2VkIHRvIHNldCB0aGUKb3V0cHV0IGZyYW1lYnVmZmVy LCBhbmQgYSBXUklURUJBQ0tfUElYRUxfRk9STUFUUyBibG9iIHVzZWQgdG8gZXhwb3NlIHRoZQpz dXBwb3J0ZWQgd3JpdGViYWNrIGZvcm1hdHMgdG8gdXNlcnNwYWNlLgoKV2hlbiBhIGZyYW1lYnVm ZmVyIGlzIGF0dGFjaGVkIHRvIGEgd3JpdGViYWNrIGNvbm5lY3RvciB3aXRoIHRoZQpXUklURUJB Q0tfRkJfSUQgcHJvcGVydHksIGl0IGlzIHVzZWQgb25seSBvbmNlIChmb3IgdGhlIGNvbW1pdCBp biB3aGljaAppdCB3YXMgaW5jbHVkZWQpLCBhbmQgdXNlcnNwYWNlIGNhbiBuZXZlciByZWFkIGJh Y2sgdGhlIHZhbHVlIG9mCldSSVRFQkFDS19GQl9JRC4gV1JJVEVCQUNLX0ZCX0lEIGNhbiBvbmx5 IGJlIHNldCBpZiB0aGUgY29ubmVjdG9yIGlzCmF0dGFjaGVkIHRvIGEgQ1JUQy4KCkNoYW5nZXMg c2luY2UgdjE6CiAtIEFkZGVkIGRybV93cml0ZWJhY2suYyArIGRvY3VtZW50YXRpb24KIC0gQWRk ZWQgaGVscGVyIHRvIGluaXRpYWxpemUgd3JpdGViYWNrIGNvbm5lY3RvciBpbiBvbmUgZ28KIC0g QWRkZWQgY29yZSBjaGVja3MKIC0gU3F1YXNoZWQgaW50byBhIHNpbmdsZSBjb21taXQKIC0gRHJv cHBlZCB0aGUgY2xpZW50IGNhcAogLSBXcml0ZWJhY2sgZnJhbWVidWZmZXJzIGFyZSBubyBsb25n ZXIgcGVyc2lzdGVudAoKQ2hhbmdlcyBzaW5jZSB2MjoKIERhbmllbCBWZXR0ZXI6CiAtIFN1YmNs YXNzIGRybV9jb25uZWN0b3IgdG8gZHJtX3dyaXRlYmFja19jb25uZWN0b3IKIC0gUmVsYXggY2hl Y2sgdG8gYWxsb3cgQ1JUQyB0byBiZSBzZXQgd2l0aG91dCBhbiBGQgogLSBBZGQgc29tZSB3cml0 ZWJhY2tfIHByZWZpeGVzCiAtIERyb3AgUElYRUxfRk9STUFUU19TSVpFIHByb3BlcnR5LCBhcyBp dCB3YXMgdW5uZWNlc3NhcnkKIEd1c3Rhdm8gUGFkb3ZhbjoKIC0gQWRkIGRybV93cml0ZWJhY2tf am9iIHRvIGhhbmRsZSB3cml0ZWJhY2sgc2lnbmFsbGluZyBjZW50cmFsbHkKCkNoYW5nZXMgc2lu Y2UgdjM6CiAtIFJlYmFzZWQKIC0gUmVuYW1lIFBJWEVMX0ZPUk1BVFMgLT4gV1JJVEVCQUNLX1BJ WEVMX0ZPUk1BVFMKCkNoYW5nZXMgc2luY2UgdjQ6CiAtIEFkZGVkIGF0b21pY19jb21taXQoKSB2 ZnVuYyB0byBjb25uZWN0b3IgaGVscGVyIGZ1bmNzLCBzbyB0aGF0CiAgIHdyaXRlYmFjayBqb2Jz IGFyZSBjb21taXR0ZWQgZnJvbSBhdG9taWMgaGVscGVycwoKU2lnbmVkLW9mZi1ieTogQnJpYW4g U3RhcmtleSA8YnJpYW4uc3RhcmtleUBhcm0uY29tPgpbcmViYXNlZCBhbmQgZml4ZWQgY29uZmxp Y3RzXQpTaWduZWQtb2ZmLWJ5OiBNaWhhaWwgQXRhbmFzc292IDxtaWhhaWwuYXRhbmFzc292QGFy bS5jb20+ClNpZ25lZC1vZmYtYnk6IExpdml1IER1ZGF1IDxsaXZpdS5kdWRhdUBhcm0uY29tPgpb cmViYXNlZCBhbmQgYWRkZWQgYXRvbWljX2NvbW1pdCgpIHZmdW5jIGZvciB3cml0ZWJhY2sgam9i c10KU2lnbmVkLW9mZi1ieTogUm9iIENsYXJrIDxyb2JkY2xhcmtAZ21haWwuY29tPgotLS0KIERv Y3VtZW50YXRpb24vZ3B1L2RybS1rbXMucnN0ICAgICAgICAgICAgfCAgIDkgKysKIGRyaXZlcnMv Z3B1L2RybS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgfCAgIDIgKy0KIGRyaXZlcnMvZ3B1L2Ry bS9kcm1fYXRvbWljLmMgICAgICAgICAgICAgfCAxMzAgKysrKysrKysrKysrKysrKwogZHJpdmVy cy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMgICAgICB8ICAzMCArKysrCiBkcml2ZXJzL2dw dS9kcm0vZHJtX2Nvbm5lY3Rvci5jICAgICAgICAgIHwgICA0ICstCiBkcml2ZXJzL2dwdS9kcm0v ZHJtX3dyaXRlYmFjay5jICAgICAgICAgIHwgMjU3ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysKIGluY2x1ZGUvZHJtL2RybV9hdG9taWMuaCAgICAgICAgICAgICAgICAgfCAgIDMgKwog aW5jbHVkZS9kcm0vZHJtX2Nvbm5lY3Rvci5oICAgICAgICAgICAgICB8ICAxMyArKwogaW5jbHVk ZS9kcm0vZHJtX21vZGVfY29uZmlnLmggICAgICAgICAgICB8ICAxNCArKwogaW5jbHVkZS9kcm0v ZHJtX21vZGVzZXRfaGVscGVyX3Z0YWJsZXMuaCB8ICAxMSArKwogaW5jbHVkZS9kcm0vZHJtX3dy aXRlYmFjay5oICAgICAgICAgICAgICB8ICA4OSArKysrKysrKysrKwogaW5jbHVkZS91YXBpL2Ry bS9kcm1fbW9kZS5oICAgICAgICAgICAgICB8ICAgMSArCiAxMiBmaWxlcyBjaGFuZ2VkLCA1NjEg aW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L2dwdS9kcm0vZHJtX3dyaXRlYmFjay5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9kcm0v ZHJtX3dyaXRlYmFjay5oCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLWttcy5y c3QgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLnJzdAppbmRleCAyZGNmNWI0MjAxNWQuLmU3 NTkwZGQyZjcxZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLWttcy5yc3QKKysr IGIvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLWttcy5yc3QKQEAgLTM3MCw2ICszNzAsMTUgQEAgQ29u bmVjdG9yIEZ1bmN0aW9ucyBSZWZlcmVuY2UKIC4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9k cm0vZHJtX2Nvbm5lY3Rvci5jCiAgICA6ZXhwb3J0OgogCitXcml0ZWJhY2sgQ29ubmVjdG9ycwor LS0tLS0tLS0tLS0tLS0tLS0tLS0KKworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS9k cm1fd3JpdGViYWNrLmMKKyAgOmRvYzogb3ZlcnZpZXcKKworLi4ga2VybmVsLWRvYzo6IGRyaXZl cnMvZ3B1L2RybS9kcm1fd3JpdGViYWNrLmMKKyAgOmV4cG9ydDoKKwogRW5jb2RlciBBYnN0cmFj dGlvbgogPT09PT09PT09PT09PT09PT09PQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v TWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKaW5kZXggNTAwOTNmZjQ0NzliLi4z ZDcwODk1OWIyMjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQorKysgYi9k cml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKQEAgLTE4LDcgKzE4LDcgQEAgZHJtLXkgICAgICAgOj0J ZHJtX2F1dGgubyBkcm1fYnVmcy5vIGRybV9jYWNoZS5vIFwKIAkJZHJtX2VuY29kZXIubyBkcm1f bW9kZV9vYmplY3QubyBkcm1fcHJvcGVydHkubyBcCiAJCWRybV9wbGFuZS5vIGRybV9jb2xvcl9t Z210Lm8gZHJtX3ByaW50Lm8gXAogCQlkcm1fZHVtYl9idWZmZXJzLm8gZHJtX21vZGVfY29uZmln Lm8gZHJtX3ZibGFuay5vIFwKLQkJZHJtX3N5bmNvYmoubyBkcm1fbGVhc2UubworCQlkcm1fc3lu Y29iai5vIGRybV9sZWFzZS5vIGRybV93cml0ZWJhY2subwogCiBkcm0tJChDT05GSUdfRFJNX0xJ Ql9SQU5ET00pICs9IGxpYi9kcm1fcmFuZG9tLm8KIGRybS0kKENPTkZJR19EUk1fVk0pICs9IGRy bV92bS5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jIGIvZHJpdmVy cy9ncHUvZHJtL2RybV9hdG9taWMuYwppbmRleCA0NjczM2Q1MzQ1ODcuLjAxOWYxMzFmZThiZSAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYworKysgYi9kcml2ZXJzL2dw dS9kcm0vZHJtX2F0b21pYy5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8ZHJtL2RybV9h dG9taWMuaD4KICNpbmNsdWRlIDxkcm0vZHJtX21vZGUuaD4KICNpbmNsdWRlIDxkcm0vZHJtX3By aW50Lmg+CisjaW5jbHVkZSA8ZHJtL2RybV93cml0ZWJhY2suaD4KICNpbmNsdWRlIDxsaW51eC9z eW5jX2ZpbGUuaD4KIAogI2luY2x1ZGUgImRybV9jcnRjX2ludGVybmFsLmgiCkBAIC02MzgsNiAr NjM5LDQ2IEBAIHN0YXRpYyB2b2lkIGRybV9hdG9taWNfY3J0Y19wcmludF9zdGF0ZShzdHJ1Y3Qg ZHJtX3ByaW50ZXIgKnAsCiAJCWNydGMtPmZ1bmNzLT5hdG9taWNfcHJpbnRfc3RhdGUocCwgc3Rh dGUpOwogfQogCisvKioKKyAqIGRybV9hdG9taWNfY29ubmVjdG9yX2NoZWNrIC0gY2hlY2sgY29u bmVjdG9yIHN0YXRlCisgKiBAY29ubmVjdG9yOiBjb25uZWN0b3IgdG8gY2hlY2sKKyAqIEBzdGF0 ZTogY29ubmVjdG9yIHN0YXRlIHRvIGNoZWNrCisgKgorICogUHJvdmlkZXMgY29yZSBzYW5pdHkg Y2hlY2tzIGZvciBjb25uZWN0b3Igc3RhdGUuCisgKgorICogUkVUVVJOUzoKKyAqIFplcm8gb24g c3VjY2VzcywgZXJyb3IgY29kZSBvbiBmYWlsdXJlCisgKi8KK3N0YXRpYyBpbnQgZHJtX2F0b21p Y19jb25uZWN0b3JfY2hlY2soc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKKwkJc3Ry dWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKnN0YXRlKQoreworCXN0cnVjdCBkcm1fY3J0Y19zdGF0 ZSAqY3J0Y19zdGF0ZTsKKwlzdHJ1Y3QgZHJtX3dyaXRlYmFja19qb2IgKndyaXRlYmFja19qb2Ig PSBzdGF0ZS0+d3JpdGViYWNrX2pvYjsKKworCWlmICgoY29ubmVjdG9yLT5jb25uZWN0b3JfdHlw ZSAhPSBEUk1fTU9ERV9DT05ORUNUT1JfV1JJVEVCQUNLKSB8fAorCSAgICAhd3JpdGViYWNrX2pv YikKKwkJcmV0dXJuIDA7CisKKwlpZiAod3JpdGViYWNrX2pvYi0+ZmIgJiYgIXN0YXRlLT5jcnRj KSB7CisJCURSTV9ERUJVR19BVE9NSUMoIltDT05ORUNUT1I6JWQ6JXNdIGZyYW1lYnVmZmVyIHdp dGhvdXQgQ1JUQ1xuIiwKKwkJCQkgY29ubmVjdG9yLT5iYXNlLmlkLCBjb25uZWN0b3ItPm5hbWUp OworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlpZiAoc3RhdGUtPmNydGMpCisJCWNydGNfc3Rh dGUgPSBkcm1fYXRvbWljX2dldF9leGlzdGluZ19jcnRjX3N0YXRlKHN0YXRlLT5zdGF0ZSwKKwkJ CQkJCQkJc3RhdGUtPmNydGMpOworCisJaWYgKHdyaXRlYmFja19qb2ItPmZiICYmICFjcnRjX3N0 YXRlLT5hY3RpdmUpIHsKKwkJRFJNX0RFQlVHX0FUT01JQygiW0NPTk5FQ1RPUjolZDolc10gaGFz IGZyYW1lYnVmZmVyLCBidXQgW0NSVEM6JWRdIGlzIG9mZlxuIiwKKwkJCQkgY29ubmVjdG9yLT5i YXNlLmlkLCBjb25uZWN0b3ItPm5hbWUsCisJCQkJIHN0YXRlLT5jcnRjLT5iYXNlLmlkKTsKKwkJ cmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0dXJuIDA7Cit9CisKIC8qKgogICogZHJtX2F0b21p Y19nZXRfcGxhbmVfc3RhdGUgLSBnZXQgcGxhbmUgc3RhdGUKICAqIEBzdGF0ZTogZ2xvYmFsIGF0 b21pYyBzdGF0ZSBvYmplY3QKQEAgLTEyMzAsNiArMTI3MSwxMiBAQCBzdGF0aWMgaW50IGRybV9h dG9taWNfY29ubmVjdG9yX3NldF9wcm9wZXJ0eShzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVj dG9yLAogCQkJcmV0dXJuIC1FSU5WQUw7CiAJCX0KIAkJc3RhdGUtPmNvbnRlbnRfcHJvdGVjdGlv biA9IHZhbDsKKwl9IGVsc2UgaWYgKHByb3BlcnR5ID09IGNvbmZpZy0+d3JpdGViYWNrX2ZiX2lk X3Byb3BlcnR5KSB7CisJCXN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiID0gZHJtX2ZyYW1lYnVm ZmVyX2xvb2t1cChkZXYsIE5VTEwsIHZhbCk7CisJCWludCByZXQgPSBkcm1fYXRvbWljX3NldF93 cml0ZWJhY2tfZmJfZm9yX2Nvbm5lY3RvcihzdGF0ZSwgZmIpOworCQlpZiAoZmIpCisJCQlkcm1f ZnJhbWVidWZmZXJfdW5yZWZlcmVuY2UoZmIpOworCQlyZXR1cm4gcmV0OwogCX0gZWxzZSBpZiAo Y29ubmVjdG9yLT5mdW5jcy0+YXRvbWljX3NldF9wcm9wZXJ0eSkgewogCQlyZXR1cm4gY29ubmVj dG9yLT5mdW5jcy0+YXRvbWljX3NldF9wcm9wZXJ0eShjb25uZWN0b3IsCiAJCQkJc3RhdGUsIHBy b3BlcnR5LCB2YWwpOwpAQCAtMTMxMSw2ICsxMzU4LDkgQEAgZHJtX2F0b21pY19jb25uZWN0b3Jf Z2V0X3Byb3BlcnR5KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCiAJCSp2YWwgPSBz dGF0ZS0+c2NhbGluZ19tb2RlOwogCX0gZWxzZSBpZiAocHJvcGVydHkgPT0gY29ubmVjdG9yLT5j b250ZW50X3Byb3RlY3Rpb25fcHJvcGVydHkpIHsKIAkJKnZhbCA9IHN0YXRlLT5jb250ZW50X3By b3RlY3Rpb247CisJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBjb25maWctPndyaXRlYmFja19mYl9p ZF9wcm9wZXJ0eSkgeworCQkvKiBXcml0ZWJhY2sgZnJhbWVidWZmZXIgaXMgb25lLXNob3QsIHdy aXRlIGFuZCBmb3JnZXQgKi8KKwkJKnZhbCA9IDA7CiAJfSBlbHNlIGlmIChjb25uZWN0b3ItPmZ1 bmNzLT5hdG9taWNfZ2V0X3Byb3BlcnR5KSB7CiAJCXJldHVybiBjb25uZWN0b3ItPmZ1bmNzLT5h dG9taWNfZ2V0X3Byb3BlcnR5KGNvbm5lY3RvciwKIAkJCQlzdGF0ZSwgcHJvcGVydHksIHZhbCk7 CkBAIC0xNTE4LDYgKzE1NjgsNzUgQEAgZHJtX2F0b21pY19zZXRfY3J0Y19mb3JfY29ubmVjdG9y KHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAogfQogRVhQT1JUX1NZTUJP TChkcm1fYXRvbWljX3NldF9jcnRjX2Zvcl9jb25uZWN0b3IpOwogCisvKgorICogZHJtX2F0b21p Y19nZXRfd3JpdGViYWNrX2pvYiAtIHJldHVybiBvciBhbGxvY2F0ZSBhIHdyaXRlYmFjayBqb2IK KyAqIEBjb25uX3N0YXRlOiBDb25uZWN0b3Igc3RhdGUgdG8gZ2V0IHRoZSBqb2IgZm9yCisgKgor ICogV3JpdGViYWNrIGpvYnMgaGF2ZSBhIGRpZmZlcmVudCBsaWZldGltZSB0byB0aGUgYXRvbWlj IHN0YXRlIHRoZXkgYXJlCisgKiBhc3NvY2lhdGVkIHdpdGguIFRoaXMgY29udmVuaWVuY2UgZnVu Y3Rpb24gdGFrZXMgY2FyZSBvZiBhbGxvY2F0aW5nIGEgam9iCisgKiBpZiB0aGVyZSBpc24ndCB5 ZXQgb25lIGFzc29jaWF0ZWQgd2l0aCB0aGUgY29ubmVjdG9yIHN0YXRlLCBvdGhlcndpc2UKKyAq IGl0IGp1c3QgcmV0dXJucyB0aGUgZXhpc3Rpbmcgam9iLgorICoKKyAqIFJldHVybnM6IFRoZSB3 cml0ZWJhY2sgam9iIGZvciB0aGUgZ2l2ZW4gY29ubmVjdG9yIHN0YXRlCisgKi8KK3N0YXRpYyBz dHJ1Y3QgZHJtX3dyaXRlYmFja19qb2IgKgorZHJtX2F0b21pY19nZXRfd3JpdGViYWNrX2pvYihz dHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKK3sKKwlXQVJOX09OKGNvbm5f c3RhdGUtPmNvbm5lY3Rvci0+Y29ubmVjdG9yX3R5cGUgIT0KKwkJRFJNX01PREVfQ09OTkVDVE9S X1dSSVRFQkFDSyk7CisKKwlpZiAoIWNvbm5fc3RhdGUtPndyaXRlYmFja19qb2IpCisJCWNvbm5f c3RhdGUtPndyaXRlYmFja19qb2IgPQorCQkJa3phbGxvYyhzaXplb2YoKmNvbm5fc3RhdGUtPndy aXRlYmFja19qb2IpLCBHRlBfS0VSTkVMKTsKKworCXJldHVybiBjb25uX3N0YXRlLT53cml0ZWJh Y2tfam9iOworfQorCisvKioKKyAqIGRybV9hdG9taWNfc2V0X3dyaXRlYmFja19mYl9mb3JfY29u bmVjdG9yIC0gc2V0IHdyaXRlYmFjayBmcmFtZWJ1ZmZlcgorICogQGNvbm5fc3RhdGU6IGF0b21p YyBzdGF0ZSBvYmplY3QgZm9yIHRoZSBjb25uZWN0b3IKKyAqIEBmYjogZmIgdG8gdXNlIGZvciB0 aGUgY29ubmVjdG9yCisgKgorICogVGhpcyBpcyB1c2VkIHRvIHNldCB0aGUgZnJhbWVidWZmZXIg Zm9yIGEgd3JpdGViYWNrIGNvbm5lY3Rvciwgd2hpY2ggb3V0cHV0cworICogdG8gYSBidWZmZXIg aW5zdGVhZCBvZiBhbiBhY3R1YWwgcGh5c2ljYWwgY29ubmVjdG9yLgorICogQ2hhbmdpbmcgdGhl IGFzc2lnbmVkIGZyYW1lYnVmZmVyIHJlcXVpcmVzIHVzIHRvIGdyYWIgYSByZWZlcmVuY2UgdG8g dGhlIG5ldworICogZmIgYW5kIGRyb3AgdGhlIHJlZmVyZW5jZSB0byB0aGUgb2xkIGZiLCBpZiB0 aGVyZSBpcyBvbmUuIFRoaXMgZnVuY3Rpb24KKyAqIHRha2VzIGNhcmUgb2YgYWxsIHRoZXNlIGRl dGFpbHMgYmVzaWRlcyB1cGRhdGluZyB0aGUgcG9pbnRlciBpbiB0aGUKKyAqIHN0YXRlIG9iamVj dCBpdHNlbGYuCisgKgorICogTm90ZTogVGhlIG9ubHkgd2F5IGNvbm5fc3RhdGUgY2FuIGFscmVh ZHkgaGF2ZSBhbiBmYiBzZXQgaXMgaWYgdGhlIGNvbW1pdAorICogc2V0cyB0aGUgcHJvcGVydHkg bW9yZSB0aGFuIG9uY2UuCisgKgorICogU2VlIGFsc286IGRybV93cml0ZWJhY2tfY29ubmVjdG9y X2luaXQoKQorICoKKyAqIFJldHVybnM6IDAgb24gc3VjY2VzcworICovCitpbnQgZHJtX2F0b21p Y19zZXRfd3JpdGViYWNrX2ZiX2Zvcl9jb25uZWN0b3IoCisJCXN0cnVjdCBkcm1fY29ubmVjdG9y X3N0YXRlICpjb25uX3N0YXRlLAorCQlzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYikKK3sKKwlz dHJ1Y3QgZHJtX3dyaXRlYmFja19qb2IgKmpvYiA9CisJCWRybV9hdG9taWNfZ2V0X3dyaXRlYmFj a19qb2IoY29ubl9zdGF0ZSk7CisJaWYgKCFqb2IpCisJCXJldHVybiAtRU5PTUVNOworCisJaWYg KGpvYi0+ZmIpCisJCWRybV9mcmFtZWJ1ZmZlcl91bnJlZmVyZW5jZShqb2ItPmZiKTsKKwlpZiAo ZmIpCisJCWRybV9mcmFtZWJ1ZmZlcl9yZWZlcmVuY2UoZmIpOworCWpvYi0+ZmIgPSBmYjsKKwor CWlmIChmYikKKwkJRFJNX0RFQlVHX0FUT01JQygiU2V0IFtGQjolZF0gZm9yIGNvbm5lY3RvciBz dGF0ZSAlcFxuIiwKKwkJCQkgZmItPmJhc2UuaWQsIGNvbm5fc3RhdGUpOworCWVsc2UKKwkJRFJN X0RFQlVHX0FUT01JQygiU2V0IFtOT0ZCXSBmb3IgY29ubmVjdG9yIHN0YXRlICVwXG4iLAorCQkJ CSBjb25uX3N0YXRlKTsKKworCXJldHVybiAwOworfQorRVhQT1JUX1NZTUJPTChkcm1fYXRvbWlj X3NldF93cml0ZWJhY2tfZmJfZm9yX2Nvbm5lY3Rvcik7CisKIC8qKgogICogZHJtX2F0b21pY19h ZGRfYWZmZWN0ZWRfY29ubmVjdG9ycyAtIGFkZCBjb25uZWN0b3JzIGZvciBjcnRjCiAgKiBAc3Rh dGU6IGF0b21pYyBzdGF0ZQpAQCAtMTYzNiw2ICsxNzU1LDggQEAgaW50IGRybV9hdG9taWNfY2hl Y2tfb25seShzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCiAJc3RydWN0IGRybV9wbGFu ZV9zdGF0ZSAqcGxhbmVfc3RhdGU7CiAJc3RydWN0IGRybV9jcnRjICpjcnRjOwogCXN0cnVjdCBk cm1fY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZTsKKwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubjsK KwlzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZTsKIAlpbnQgaSwgcmV0ID0g MDsKIAogCURSTV9ERUJVR19BVE9NSUMoImNoZWNraW5nICVwXG4iLCBzdGF0ZSk7CkBAIC0xNjU4 LDYgKzE3NzksMTUgQEAgaW50IGRybV9hdG9taWNfY2hlY2tfb25seShzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUpCiAJCX0KIAl9CiAKKwlmb3JfZWFjaF9uZXdfY29ubmVjdG9yX2luX3N0 YXRlKHN0YXRlLCBjb25uLCBjb25uX3N0YXRlLCBpKSB7CisJCXJldCA9IGRybV9hdG9taWNfY29u bmVjdG9yX2NoZWNrKGNvbm4sIGNvbm5fc3RhdGUpOworCQlpZiAocmV0KSB7CisJCQlEUk1fREVC VUdfQVRPTUlDKCJbQ09OTkVDVE9SOiVkOiVzXSBhdG9taWMgY29yZSBjaGVjayBmYWlsZWRcbiIs CisJCQkJCSBjb25uLT5iYXNlLmlkLCBjb25uLT5uYW1lKTsKKwkJCXJldHVybiByZXQ7CisJCX0K Kwl9CisKIAlpZiAoY29uZmlnLT5mdW5jcy0+YXRvbWljX2NoZWNrKQogCQlyZXQgPSBjb25maWct PmZ1bmNzLT5hdG9taWNfY2hlY2soc3RhdGUtPmRldiwgc3RhdGUpOwogCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1f YXRvbWljX2hlbHBlci5jCmluZGV4IGFlM2NiZmU5ZTAxYy4uMTJiOTEwNzU1ZDg0IDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYworKysgYi9kcml2ZXJzL2dw dS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgPGRy bS9kcm1fcGxhbmVfaGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgog I2luY2x1ZGUgPGRybS9kcm1fYXRvbWljX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fd3Jp dGViYWNrLmg+CiAjaW5jbHVkZSA8bGludXgvZG1hLWZlbmNlLmg+CiAKICNpbmNsdWRlICJkcm1f Y3J0Y19oZWxwZXJfaW50ZXJuYWwuaCIKQEAgLTExNTksNiArMTE2MCwyNyBAQCB2b2lkIGRybV9h dG9taWNfaGVscGVyX2NvbW1pdF9tb2Rlc2V0X2Rpc2FibGVzKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCiB9CiBFWFBPUlRfU1lNQk9MKGRybV9hdG9taWNfaGVscGVyX2NvbW1pdF9tb2Rlc2V0X2Rp c2FibGVzKTsKIAorc3RhdGljIHZvaWQgY29tbWl0X3dyaXRlYmFja3Moc3RydWN0IGRybV9kZXZp Y2UgKmRldiwgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKm9sZF9zdGF0ZSkKK3sKKwlzdHJ1Y3Qg ZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yOworCXN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpu ZXdfY29ubl9zdGF0ZTsKKwlpbnQgaTsKKworCWZvcl9lYWNoX25ld19jb25uZWN0b3JfaW5fc3Rh dGUob2xkX3N0YXRlLCBjb25uZWN0b3IsIG5ld19jb25uX3N0YXRlLCBpKSB7CisJCWNvbnN0IHN0 cnVjdCBkcm1fY29ubmVjdG9yX2hlbHBlcl9mdW5jcyAqZnVuY3M7CisKKwkJZnVuY3MgPSBjb25u ZWN0b3ItPmhlbHBlcl9wcml2YXRlOworCisJCWlmIChuZXdfY29ubl9zdGF0ZS0+d3JpdGViYWNr X2pvYiAmJgorCQkgICAgbmV3X2Nvbm5fc3RhdGUtPndyaXRlYmFja19qb2ItPmZiKSB7CisJCQlX QVJOX09OKGNvbm5lY3Rvci0+Y29ubmVjdG9yX3R5cGUgIT0KKwkJCQlEUk1fTU9ERV9DT05ORUNU T1JfV1JJVEVCQUNLKTsKKwkJCWZ1bmNzLT5hdG9taWNfY29tbWl0KGNvbm5lY3RvciwKKwkJCQkJ ICAgICBuZXdfY29ubl9zdGF0ZS0+d3JpdGViYWNrX2pvYik7CisJCX0KKwl9Cit9CisKIC8qKgog ICogZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X21vZGVzZXRfZW5hYmxlcyAtIG1vZGVzZXQgY29t bWl0IHRvIGVuYWJsZSBvdXRwdXRzCiAgKiBAZGV2OiBEUk0gZGV2aWNlCkBAIC0xMjM4LDYgKzEy NjAsOCBAQCB2b2lkIGRybV9hdG9taWNfaGVscGVyX2NvbW1pdF9tb2Rlc2V0X2VuYWJsZXMoc3Ry dWN0IGRybV9kZXZpY2UgKmRldiwKIAogCQlkcm1fYnJpZGdlX2VuYWJsZShlbmNvZGVyLT5icmlk Z2UpOwogCX0KKworCWNvbW1pdF93cml0ZWJhY2tzKGRldiwgb2xkX3N0YXRlKTsKIH0KIEVYUE9S VF9TWU1CT0woZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X21vZGVzZXRfZW5hYmxlcyk7CiAKQEAg LTM2MjcsNiArMzY1MSw5IEBAIF9fZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2R1cGxpY2F0 ZV9zdGF0ZShzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLAogCWlmIChzdGF0ZS0+Y3J0 YykKIAkJZHJtX2Nvbm5lY3Rvcl9nZXQoY29ubmVjdG9yKTsKIAlzdGF0ZS0+Y29tbWl0ID0gTlVM TDsKKworCS8qIERvbid0IGNvcHkgb3ZlciBhIHdyaXRlYmFjayBqb2IsIHRoZXkgYXJlIHVzZWQg b25seSBvbmNlICovCisJc3RhdGUtPndyaXRlYmFja19qb2IgPSBOVUxMOwogfQogRVhQT1JUX1NZ TUJPTChfX2RybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kdXBsaWNhdGVfc3RhdGUpOwogCkBA IC0zNzU2LDYgKzM3ODMsOSBAQCBfX2RybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kZXN0cm95 X3N0YXRlKHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpzdGF0ZSkKIAogCWlmIChzdGF0ZS0+ Y29tbWl0KQogCQlkcm1fY3J0Y19jb21taXRfcHV0KHN0YXRlLT5jb21taXQpOworCisJaWYgKHN0 YXRlLT53cml0ZWJhY2tfam9iKQorCQlkcm1fd3JpdGViYWNrX2NsZWFudXBfam9iKHN0YXRlLT53 cml0ZWJhY2tfam9iKTsKIH0KIEVYUE9SVF9TWU1CT0woX19kcm1fYXRvbWljX2hlbHBlcl9jb25u ZWN0b3JfZGVzdHJveV9zdGF0ZSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1f Y29ubmVjdG9yLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2Nvbm5lY3Rvci5jCmluZGV4IDE2Yjlj MzgxMGFmMi4uYWRkNDdmMDZhZTcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2Nv bm5lY3Rvci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fY29ubmVjdG9yLmMKQEAgLTg3LDYg Kzg3LDcgQEAgc3RhdGljIHN0cnVjdCBkcm1fY29ubl9wcm9wX2VudW1fbGlzdCBkcm1fY29ubmVj dG9yX2VudW1fbGlzdFtdID0gewogCXsgRFJNX01PREVfQ09OTkVDVE9SX1ZJUlRVQUwsICJWaXJ0 dWFsIiB9LAogCXsgRFJNX01PREVfQ09OTkVDVE9SX0RTSSwgIkRTSSIgfSwKIAl7IERSTV9NT0RF X0NPTk5FQ1RPUl9EUEksICJEUEkiIH0sCisJeyBEUk1fTU9ERV9DT05ORUNUT1JfV1JJVEVCQUNL LCAiV3JpdGViYWNrIiB9LAogfTsKIAogdm9pZCBkcm1fY29ubmVjdG9yX2lkYV9pbml0KHZvaWQp CkBAIC0yNDksNyArMjUwLDggQEAgaW50IGRybV9jb25uZWN0b3JfaW5pdChzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LAogCWNvbmZpZy0+bnVtX2Nvbm5lY3RvcisrOwogCXNwaW5fdW5sb2NrX2lycSgm Y29uZmlnLT5jb25uZWN0b3JfbGlzdF9sb2NrKTsKIAotCWlmIChjb25uZWN0b3JfdHlwZSAhPSBE Uk1fTU9ERV9DT05ORUNUT1JfVklSVFVBTCkKKwlpZiAoY29ubmVjdG9yX3R5cGUgIT0gRFJNX01P REVfQ09OTkVDVE9SX1ZJUlRVQUwgJiYKKwkgICAgY29ubmVjdG9yX3R5cGUgIT0gRFJNX01PREVf Q09OTkVDVE9SX1dSSVRFQkFDSykKIAkJZHJtX29iamVjdF9hdHRhY2hfcHJvcGVydHkoJmNvbm5l Y3Rvci0+YmFzZSwKIAkJCQkJICAgICAgY29uZmlnLT5lZGlkX3Byb3BlcnR5LAogCQkJCQkgICAg ICAwKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fd3JpdGViYWNrLmMgYi9kcml2 ZXJzL2dwdS9kcm0vZHJtX3dyaXRlYmFjay5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMC4uZGE2MWY5MjljYmMzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2RybV93cml0ZWJhY2suYwpAQCAtMCwwICsxLDI1NyBAQAorLyoKKyAqIChDKSBDT1BZUklH SFQgMjAxNiBBUk0gTGltaXRlZC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIEF1dGhvcjogQnJp YW4gU3RhcmtleSA8YnJpYW4uc3RhcmtleUBhcm0uY29tPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBp cyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hl ZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91 IG9mIHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcworICogb2Ygc3VjaCBHTlUg bGljZW5jZS4KKyAqLworCisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjLmg+CisjaW5jbHVkZSA8ZHJt L2RybV9tb2Rlc2V0X2hlbHBlcl92dGFibGVzLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9wcm9wZXJ0 eS5oPgorI2luY2x1ZGUgPGRybS9kcm1fd3JpdGViYWNrLmg+CisjaW5jbHVkZSA8ZHJtL2RybVAu aD4KKworLyoqCisgKiBET0M6IG92ZXJ2aWV3CisgKgorICogV3JpdGViYWNrIGNvbm5lY3RvcnMg YXJlIHVzZWQgdG8gZXhwb3NlIGhhcmR3YXJlIHdoaWNoIGNhbiB3cml0ZSB0aGUgb3V0cHV0Cisg KiBmcm9tIGEgQ1JUQyB0byBhIG1lbW9yeSBidWZmZXIuIFRoZXkgYXJlIHVzZWQgYW5kIGFjdCBz aW1pbGFybHkgdG8gb3RoZXIKKyAqIHR5cGVzIG9mIGNvbm5lY3RvcnMsIHdpdGggc29tZSBpbXBv cnRhbnQgZGlmZmVyZW5jZXM6CisgKiAgLSBXcml0ZWJhY2sgY29ubmVjdG9ycyBkb24ndCBwcm92 aWRlIGEgd2F5IHRvIG91dHB1dCB2aXN1YWxseSB0byB0aGUgdXNlci4KKyAqICAtIFdyaXRlYmFj ayBjb25uZWN0b3JzIHNob3VsZCBhbHdheXMgcmVwb3J0IGFzICJkaXNjb25uZWN0ZWQiIChzbyB0 aGF0CisgKiAgICBjbGllbnRzIHdoaWNoIGRvbid0IHVuZGVyc3RhbmQgdGhlbSB3aWxsIGlnbm9y ZSB0aGVtKS4KKyAqICAtIFdyaXRlYmFjayBjb25uZWN0b3JzIGRvbid0IGhhdmUgRURJRC4KKyAq CisgKiBBIGZyYW1lYnVmZmVyIG1heSBvbmx5IGJlIGF0dGFjaGVkIHRvIGEgd3JpdGViYWNrIGNv bm5lY3RvciB3aGVuIHRoZQorICogY29ubmVjdG9yIGlzIGF0dGFjaGVkIHRvIGEgQ1JUQy4gVGhl IFdSSVRFQkFDS19GQl9JRCBwcm9wZXJ0eSB3aGljaCBzZXRzIHRoZQorICogZnJhbWVidWZmZXIg YXBwbGllcyBvbmx5IHRvIGEgc2luZ2xlIGNvbW1pdCAoc2VlIGJlbG93KS4gQSBmcmFtZWJ1ZmZl ciBtYXkKKyAqIG5vdCBiZSBhdHRhY2hlZCB3aGlsZSB0aGUgQ1JUQyBpcyBvZmYuCisgKgorICog V3JpdGViYWNrIGNvbm5lY3RvcnMgaGF2ZSBzb21lIGFkZGl0aW9uYWwgcHJvcGVydGllcywgd2hp Y2ggdXNlcnNwYWNlCisgKiBjYW4gdXNlIHRvIHF1ZXJ5IGFuZCBjb250cm9sIHRoZW06CisgKgor ICogICJXUklURUJBQ0tfRkJfSUQiOgorICoJV3JpdGUtb25seSBvYmplY3QgcHJvcGVydHkgc3Rv cmluZyBhIERSTV9NT0RFX09CSkVDVF9GQjogaXQgc3RvcmVzIHRoZQorICoJZnJhbWVidWZmZXIg dG8gYmUgd3JpdHRlbiBieSB0aGUgd3JpdGViYWNrIGNvbm5lY3Rvci4gVGhpcyBwcm9wZXJ0eSBp cworICoJc2ltaWxhciB0byB0aGUgRkJfSUQgcHJvcGVydHkgb24gcGxhbmVzLCBidXQgd2lsbCBh bHdheXMgcmVhZCBhcyB6ZXJvCisgKglhbmQgaXMgbm90IHByZXNlcnZlZCBhY3Jvc3MgY29tbWl0 cy4KKyAqCVVzZXJzcGFjZSBtdXN0IHNldCB0aGlzIHByb3BlcnR5IHRvIGFuIG91dHB1dCBidWZm ZXIgZXZlcnkgdGltZSBpdAorICoJd2lzaGVzIHRoZSBidWZmZXIgdG8gZ2V0IGZpbGxlZC4KKyAq CisgKiAgIldSSVRFQkFDS19QSVhFTF9GT1JNQVRTIjoKKyAqCUltbXV0YWJsZSBibG9iIHByb3Bl cnR5IHRvIHN0b3JlIHRoZSBzdXBwb3J0ZWQgcGl4ZWwgZm9ybWF0cyB0YWJsZS4gVGhlCisgKglk YXRhIGlzIGFuIGFycmF5IG9mIHUzMiBEUk1fRk9STUFUXyogZm91cmNjIHZhbHVlcy4KKyAqCVVz ZXJzcGFjZSBjYW4gdXNlIHRoaXMgYmxvYiB0byBmaW5kIG91dCB3aGF0IHBpeGVsIGZvcm1hdHMg YXJlIHN1cHBvcnRlZAorICoJYnkgdGhlIGNvbm5lY3RvcidzIHdyaXRlYmFjayBlbmdpbmUuCisg Ki8KKworc3RhdGljIGJvb2wgY3JlYXRlX3dyaXRlYmFja19wcm9wZXJ0aWVzKHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYpCit7CisJc3RydWN0IGRybV9wcm9wZXJ0eSAqcHJvcDsKKworCWlmICghZGV2 LT5tb2RlX2NvbmZpZy53cml0ZWJhY2tfZmJfaWRfcHJvcGVydHkpIHsKKwkJcHJvcCA9IGRybV9w cm9wZXJ0eV9jcmVhdGVfb2JqZWN0KGRldiwgRFJNX01PREVfUFJPUF9BVE9NSUMsCisJCQkJCQkg ICJXUklURUJBQ0tfRkJfSUQiLAorCQkJCQkJICBEUk1fTU9ERV9PQkpFQ1RfRkIpOworCQlpZiAo IXByb3ApCisJCQlyZXR1cm4gZmFsc2U7CisJCWRldi0+bW9kZV9jb25maWcud3JpdGViYWNrX2Zi X2lkX3Byb3BlcnR5ID0gcHJvcDsKKwl9CisKKwlpZiAoIWRldi0+bW9kZV9jb25maWcud3JpdGVi YWNrX3BpeGVsX2Zvcm1hdHNfcHJvcGVydHkpIHsKKwkJcHJvcCA9IGRybV9wcm9wZXJ0eV9jcmVh dGUoZGV2LCBEUk1fTU9ERV9QUk9QX0JMT0IgfCBEUk1fTU9ERV9QUk9QX0lNTVVUQUJMRSwKKwkJ CQkJICAgIldSSVRFQkFDS19QSVhFTF9GT1JNQVRTIiwgMCk7CisJCWlmICghcHJvcCkKKwkJCXJl dHVybiBmYWxzZTsKKwkJZGV2LT5tb2RlX2NvbmZpZy53cml0ZWJhY2tfcGl4ZWxfZm9ybWF0c19w cm9wZXJ0eSA9IHByb3A7CisJfQorCisJcmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgZHJtX2VuY29kZXJfZnVuY3MgZHJtX3dyaXRlYmFja19lbmNvZGVyX2Z1bmNzID0gewor CS5kZXN0cm95ID0gZHJtX2VuY29kZXJfY2xlYW51cCwKK307CisKKy8qKgorICogZHJtX3dyaXRl YmFja19jb25uZWN0b3JfaW5pdCAtIEluaXRpYWxpemUgYSB3cml0ZWJhY2sgY29ubmVjdG9yIGFu ZCBpdHMgcHJvcGVydGllcworICogQGRldjogRFJNIGRldmljZQorICogQHdiX2Nvbm5lY3Rvcjog V3JpdGViYWNrIGNvbm5lY3RvciB0byBpbml0aWFsaXplCisgKiBAY29uX2Z1bmNzOiBDb25uZWN0 b3IgZnVuY3MgdnRhYmxlCisgKiBAZW5jX2hlbHBlcl9mdW5jczogRW5jb2RlciBoZWxwZXIgZnVu Y3MgdnRhYmxlIHRvIGJlIHVzZWQgYnkgdGhlIGludGVybmFsIGVuY29kZXIKKyAqIEBmb3JtYXRz OiBBcnJheSBvZiBzdXBwb3J0ZWQgcGl4ZWwgZm9ybWF0cyBmb3IgdGhlIHdyaXRlYmFjayBlbmdp bmUKKyAqIEBuX2Zvcm1hdHM6IExlbmd0aCBvZiB0aGUgZm9ybWF0cyBhcnJheQorICoKKyAqIFRo aXMgZnVuY3Rpb24gY3JlYXRlcyB0aGUgd3JpdGViYWNrLWNvbm5lY3Rvci1zcGVjaWZpYyBwcm9w ZXJ0aWVzIGlmIHRoZXkKKyAqIGhhdmUgbm90IGJlZW4gYWxyZWFkeSBjcmVhdGVkLCBpbml0aWFs aXplcyB0aGUgY29ubmVjdG9yIGFzCisgKiB0eXBlIERSTV9NT0RFX0NPTk5FQ1RPUl9XUklURUJB Q0ssIGFuZCBjb3JyZWN0bHkgaW5pdGlhbGl6ZXMgdGhlIHByb3BlcnR5CisgKiB2YWx1ZXMuIEl0 IHdpbGwgYWxzbyBjcmVhdGUgYW4gaW50ZXJuYWwgZW5jb2RlciBhc3NvY2lhdGVkIHdpdGggdGhl CisgKiBkcm1fd3JpdGViYWNrX2Nvbm5lY3RvciBhbmQgc2V0IGl0IHRvIHVzZSB0aGUgQGVuY19o ZWxwZXJfZnVuY3MgdnRhYmxlIGZvcgorICogdGhlIGVuY29kZXIgaGVscGVyLgorICoKKyAqIERy aXZlcnMgc2hvdWxkIGFsd2F5cyB1c2UgdGhpcyBmdW5jdGlvbiBpbnN0ZWFkIG9mIGRybV9jb25u ZWN0b3JfaW5pdCgpIHRvCisgKiBzZXQgdXAgd3JpdGViYWNrIGNvbm5lY3RvcnMuCisgKgorICog UmV0dXJuczogMCBvbiBzdWNjZXNzLCBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUKKyAqLworaW50 IGRybV93cml0ZWJhY2tfY29ubmVjdG9yX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJ CQkgc3RydWN0IGRybV93cml0ZWJhY2tfY29ubmVjdG9yICp3Yl9jb25uZWN0b3IsCisJCQkJIGNv bnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2Z1bmNzICpjb25fZnVuY3MsCisJCQkJIGNvbnN0IHN0 cnVjdCBkcm1fZW5jb2Rlcl9oZWxwZXJfZnVuY3MgKmVuY19oZWxwZXJfZnVuY3MsCisJCQkJIGNv bnN0IHUzMiAqZm9ybWF0cywgaW50IG5fZm9ybWF0cykKK3sKKwlpbnQgcmV0OworCXN0cnVjdCBk cm1fcHJvcGVydHlfYmxvYiAqYmxvYjsKKwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y ID0gJndiX2Nvbm5lY3Rvci0+YmFzZTsKKwlzdHJ1Y3QgZHJtX21vZGVfY29uZmlnICpjb25maWcg PSAmZGV2LT5tb2RlX2NvbmZpZzsKKworCWlmICghY3JlYXRlX3dyaXRlYmFja19wcm9wZXJ0aWVz KGRldikpCisJCXJldHVybiAtRUlOVkFMOworCisJYmxvYiA9IGRybV9wcm9wZXJ0eV9jcmVhdGVf YmxvYihkZXYsIG5fZm9ybWF0cyAqIHNpemVvZigqZm9ybWF0cyksCisJCQkJCWZvcm1hdHMpOwor CWlmIChJU19FUlIoYmxvYikpCisJCXJldHVybiBQVFJfRVJSKGJsb2IpOworCisJZHJtX2VuY29k ZXJfaGVscGVyX2FkZCgmd2JfY29ubmVjdG9yLT5lbmNvZGVyLCBlbmNfaGVscGVyX2Z1bmNzKTsK KwlyZXQgPSBkcm1fZW5jb2Rlcl9pbml0KGRldiwgJndiX2Nvbm5lY3Rvci0+ZW5jb2RlciwKKwkJ CSAgICAgICAmZHJtX3dyaXRlYmFja19lbmNvZGVyX2Z1bmNzLAorCQkJICAgICAgIERSTV9NT0RF X0VOQ09ERVJfVklSVFVBTCwgTlVMTCk7CisJaWYgKHJldCkKKwkJZ290byBmYWlsOworCisJY29u bmVjdG9yLT5pbnRlcmxhY2VfYWxsb3dlZCA9IDA7CisKKwlyZXQgPSBkcm1fY29ubmVjdG9yX2lu aXQoZGV2LCBjb25uZWN0b3IsIGNvbl9mdW5jcywKKwkJCQkgRFJNX01PREVfQ09OTkVDVE9SX1dS SVRFQkFDSyk7CisJaWYgKHJldCkKKwkJZ290byBjb25uZWN0b3JfZmFpbDsKKworCXJldCA9IGRy bV9tb2RlX2Nvbm5lY3Rvcl9hdHRhY2hfZW5jb2Rlcihjb25uZWN0b3IsCisJCQkJCQkmd2JfY29u bmVjdG9yLT5lbmNvZGVyKTsKKwlpZiAocmV0KQorCQlnb3RvIGF0dGFjaF9mYWlsOworCisJSU5J VF9MSVNUX0hFQUQoJndiX2Nvbm5lY3Rvci0+am9iX3F1ZXVlKTsKKwlzcGluX2xvY2tfaW5pdCgm d2JfY29ubmVjdG9yLT5qb2JfbG9jayk7CisKKwlkcm1fb2JqZWN0X2F0dGFjaF9wcm9wZXJ0eSgm Y29ubmVjdG9yLT5iYXNlLAorCQkJCSAgIGNvbmZpZy0+d3JpdGViYWNrX2ZiX2lkX3Byb3BlcnR5 LCAwKTsKKworCWRybV9vYmplY3RfYXR0YWNoX3Byb3BlcnR5KCZjb25uZWN0b3ItPmJhc2UsCisJ CQkJICAgY29uZmlnLT53cml0ZWJhY2tfcGl4ZWxfZm9ybWF0c19wcm9wZXJ0eSwKKwkJCQkgICBi bG9iLT5iYXNlLmlkKTsKKwl3Yl9jb25uZWN0b3ItPnBpeGVsX2Zvcm1hdHNfYmxvYl9wdHIgPSBi bG9iOworCisJcmV0dXJuIDA7CisKK2F0dGFjaF9mYWlsOgorCWRybV9jb25uZWN0b3JfY2xlYW51 cChjb25uZWN0b3IpOworY29ubmVjdG9yX2ZhaWw6CisJZHJtX2VuY29kZXJfY2xlYW51cCgmd2Jf Y29ubmVjdG9yLT5lbmNvZGVyKTsKK2ZhaWw6CisJZHJtX3Byb3BlcnR5X3VucmVmZXJlbmNlX2Js b2IoYmxvYik7CisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0woZHJtX3dyaXRlYmFja19j b25uZWN0b3JfaW5pdCk7CisKKy8qKgorICogZHJtX3dyaXRlYmFja19xdWV1ZV9qb2IgLSBRdWV1 ZSBhIHdyaXRlYmFjayBqb2IgZm9yIGxhdGVyIHNpZ25hbGxpbmcKKyAqIEB3Yl9jb25uZWN0b3I6 IFRoZSB3cml0ZWJhY2sgY29ubmVjdG9yIHRvIHF1ZXVlIGEgam9iIG9uCisgKiBAam9iOiBUaGUg am9iIHRvIHF1ZXVlCisgKgorICogVGhpcyBmdW5jdGlvbiBhZGRzIGEgam9iIHRvIHRoZSBqb2Jf cXVldWUgZm9yIGEgd3JpdGViYWNrIGNvbm5lY3Rvci4gSXQKKyAqIHNob3VsZCBiZSBjb25zaWRl cmVkIHRvIHRha2Ugb3duZXJzaGlwIG9mIHRoZSB3cml0ZWJhY2sgam9iLCBhbmQgc28gYW55IG90 aGVyCisgKiByZWZlcmVuY2VzIHRvIHRoZSBqb2IgbXVzdCBiZSBjbGVhcmVkIGFmdGVyIGNhbGxp bmcgdGhpcyBmdW5jdGlvbi4KKyAqCisgKiBEcml2ZXJzIG11c3QgZW5zdXJlIHRoYXQgZm9yIGEg Z2l2ZW4gd3JpdGViYWNrIGNvbm5lY3Rvciwgam9icyBhcmUgcXVldWVkIGluCisgKiBleGFjdGx5 IHRoZSBzYW1lIG9yZGVyIGFzIHRoZXkgd2lsbCBiZSBjb21wbGV0ZWQgYnkgdGhlIGhhcmR3YXJl IChhbmQKKyAqIHNpZ25hbGVkIHZpYSBkcm1fd3JpdGViYWNrX3NpZ25hbF9jb21wbGV0aW9uKS4K KyAqCisgKiBGb3IgZXZlcnkgY2FsbCB0byBkcm1fd3JpdGViYWNrX3F1ZXVlX2pvYigpIHRoZXJl IG11c3QgYmUgZXhhY3RseSBvbmUgY2FsbCB0bworICogZHJtX3dyaXRlYmFja19zaWduYWxfY29t cGxldGlvbigpCisgKgorICogU2VlIGFsc286IGRybV93cml0ZWJhY2tfc2lnbmFsX2NvbXBsZXRp b24oKQorICovCit2b2lkIGRybV93cml0ZWJhY2tfcXVldWVfam9iKHN0cnVjdCBkcm1fd3JpdGVi YWNrX2Nvbm5lY3RvciAqd2JfY29ubmVjdG9yLAorCQkJICAgICBzdHJ1Y3QgZHJtX3dyaXRlYmFj a19qb2IgKmpvYikKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNh dmUoJndiX2Nvbm5lY3Rvci0+am9iX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2FkZF90YWlsKCZqb2It Pmxpc3RfZW50cnksICZ3Yl9jb25uZWN0b3ItPmpvYl9xdWV1ZSk7CisJc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmd2JfY29ubmVjdG9yLT5qb2JfbG9jaywgZmxhZ3MpOworfQorRVhQT1JUX1NZTUJP TChkcm1fd3JpdGViYWNrX3F1ZXVlX2pvYik7CisKKy8qKgorICogZHJtX3dyaXRlYmFja19jbGVh bnVwX2pvYiAtIENsZWFudXAgYW5kIGZyZWUgYSB3cml0ZWJhY2sgam9iCisgKiBAam9iOiBUaGUg d3JpdGViYWNrIGpvYiB0byBmcmVlCisgKgorICogRHJvcHMgYW55IHJlZmVyZW5jZXMgaGVsZCBi eSB0aGUgd3JpdGViYWNrIGpvYiwgYW5kIGZyZWVzIHRoZSBzdHJ1Y3R1cmUuCisgKi8KK3ZvaWQg ZHJtX3dyaXRlYmFja19jbGVhbnVwX2pvYihzdHJ1Y3QgZHJtX3dyaXRlYmFja19qb2IgKmpvYikK K3sKKwlpZiAoIWpvYikKKwkJcmV0dXJuOworCisJaWYgKGpvYi0+ZmIpCisJCWRybV9mcmFtZWJ1 ZmZlcl91bnJlZmVyZW5jZShqb2ItPmZiKTsKKwlrZnJlZShqb2IpOworfQorRVhQT1JUX1NZTUJP TChkcm1fd3JpdGViYWNrX2NsZWFudXBfam9iKTsKKworLyoKKyAqIEBjbGVhbnVwX3dvcms6IGRl ZmVycmVkIGNsZWFudXAgb2YgYSB3cml0ZWJhY2sgam9iCisgKgorICogVGhlIGpvYiBjYW5ub3Qg YmUgY2xlYW5lZCB1cCBkaXJlY3RseSBpbiBkcm1fd3JpdGViYWNrX3NpZ25hbF9jb21wbGV0aW9u LAorICogYmVjYXVzZSBpdCBtYXkgYmUgY2FsbGVkIGluIGludGVycnVwdCBjb250ZXh0LiBEcm9w cGluZyB0aGUgZnJhbWVidWZmZXIKKyAqIHJlZmVyZW5jZSBjYW4gc2xlZXAsIGFuZCBzbyB0aGUg Y2xlYW51cCBpcyBkZWZlcnJlZCB0byBhIHdvcmtxdWV1ZS4KKyAqLworc3RhdGljIHZvaWQgY2xl YW51cF93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKK3sKKwlzdHJ1Y3QgZHJtX3dyaXRl YmFja19qb2IgKmpvYiA9IGNvbnRhaW5lcl9vZih3b3JrLAorCQkJCQkJICAgICBzdHJ1Y3QgZHJt X3dyaXRlYmFja19qb2IsCisJCQkJCQkgICAgIGNsZWFudXBfd29yayk7CisJZHJtX3dyaXRlYmFj a19jbGVhbnVwX2pvYihqb2IpOworfQorCisvKioKKyAqIGRybV93cml0ZWJhY2tfc2lnbmFsX2Nv bXBsZXRpb24gLSBTaWduYWwgdGhlIGNvbXBsZXRpb24gb2YgYSB3cml0ZWJhY2sgam9iCisgKiBA d2JfY29ubmVjdG9yOiBUaGUgd3JpdGViYWNrIGNvbm5lY3RvciB3aG9zZSBqb2IgaXMgY29tcGxl dGUKKyAqCisgKiBEcml2ZXJzIHNob3VsZCBjYWxsIHRoaXMgdG8gc2lnbmFsIHRoZSBjb21wbGV0 aW9uIG9mIGEgcHJldmlvdXNseSBxdWV1ZWQKKyAqIHdyaXRlYmFjayBqb2IuIEl0IHNob3VsZCBi ZSBjYWxsZWQgYXMgc29vbiBhcyBwb3NzaWJsZSBhZnRlciB0aGUgaGFyZHdhcmUKKyAqIGhhcyBm aW5pc2hlZCB3cml0aW5nLCBhbmQgbWF5IGJlIGNhbGxlZCBmcm9tIGludGVycnVwdCBjb250ZXh0 LgorICogSXQgaXMgdGhlIGRyaXZlcidzIHJlc3BvbnNpYmlsaXR5IHRvIGVuc3VyZSB0aGF0IGZv ciBhIGdpdmVuIGNvbm5lY3RvciwgdGhlCisgKiBoYXJkd2FyZSBjb21wbGV0ZXMgd3JpdGViYWNr IGpvYnMgaW4gdGhlIHNhbWUgb3JkZXIgYXMgdGhleSBhcmUgcXVldWVkLgorICoKKyAqIFVubGVz cyB0aGUgZHJpdmVyIGlzIGhvbGRpbmcgaXRzIG93biByZWZlcmVuY2UgdG8gdGhlIGZyYW1lYnVm ZmVyLCBpdCBtdXN0CisgKiBub3QgYmUgYWNjZXNzZWQgYWZ0ZXIgY2FsbGluZyB0aGlzIGZ1bmN0 aW9uLgorICoKKyAqIFNlZSBhbHNvOiBkcm1fd3JpdGViYWNrX3F1ZXVlX2pvYigpCisgKi8KK3Zv aWQKK2RybV93cml0ZWJhY2tfc2lnbmFsX2NvbXBsZXRpb24oc3RydWN0IGRybV93cml0ZWJhY2tf Y29ubmVjdG9yICp3Yl9jb25uZWN0b3IpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1 Y3QgZHJtX3dyaXRlYmFja19qb2IgKmpvYjsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZ3Yl9jb25u ZWN0b3ItPmpvYl9sb2NrLCBmbGFncyk7CisJam9iID0gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxs KCZ3Yl9jb25uZWN0b3ItPmpvYl9xdWV1ZSwKKwkJCQkgICAgICAgc3RydWN0IGRybV93cml0ZWJh Y2tfam9iLAorCQkJCSAgICAgICBsaXN0X2VudHJ5KTsKKwlpZiAoam9iKQorCQlsaXN0X2RlbCgm am9iLT5saXN0X2VudHJ5KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ3Yl9jb25uZWN0b3It PmpvYl9sb2NrLCBmbGFncyk7CisKKwlpZiAoV0FSTl9PTigham9iKSkKKwkJcmV0dXJuOworCisJ SU5JVF9XT1JLKCZqb2ItPmNsZWFudXBfd29yaywgY2xlYW51cF93b3JrKTsKKwlxdWV1ZV93b3Jr KHN5c3RlbV9sb25nX3dxLCAmam9iLT5jbGVhbnVwX3dvcmspOworfQorRVhQT1JUX1NZTUJPTChk cm1fd3JpdGViYWNrX3NpZ25hbF9jb21wbGV0aW9uKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJt L2RybV9hdG9taWMuaCBiL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaAppbmRleCBjZjEzODQyYTZk YmQuLmQ3YjAyNjNjYzVjZiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2F0b21pYy5oCisr KyBiL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaApAQCAtNTk0LDYgKzU5NCw5IEBAIHZvaWQgZHJt X2F0b21pY19zZXRfZmVuY2VfZm9yX3BsYW5lKHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5l X3N0YXRlLAogaW50IF9fbXVzdF9jaGVjawogZHJtX2F0b21pY19zZXRfY3J0Y19mb3JfY29ubmVj dG9yKHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAogCQkJCSAgc3RydWN0 IGRybV9jcnRjICpjcnRjKTsKK2ludCBkcm1fYXRvbWljX3NldF93cml0ZWJhY2tfZmJfZm9yX2Nv bm5lY3RvcigKKwkJc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCisJCXN0 cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiKTsKIGludCBfX211c3RfY2hlY2sKIGRybV9hdG9taWNf YWRkX2FmZmVjdGVkX2Nvbm5lY3RvcnMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAog CQkJCSAgIHN0cnVjdCBkcm1fY3J0YyAqY3J0Yyk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9k cm1fY29ubmVjdG9yLmggYi9pbmNsdWRlL2RybS9kcm1fY29ubmVjdG9yLmgKaW5kZXggNzU4YTE3 NmU3YjU3Li44NzAxZWJjYzY4YjMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9jb25uZWN0 b3IuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fY29ubmVjdG9yLmgKQEAgLTQyNSw2ICs0MjUsMTkg QEAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgewogCSAqIHByb3RlY3Rpb24uIFRoaXMgaXMg bW9zdCBjb21tb25seSB1c2VkIGZvciBIRENQLgogCSAqLwogCXVuc2lnbmVkIGludCBjb250ZW50 X3Byb3RlY3Rpb247CisKKwkvKioKKwkgKiBAd3JpdGViYWNrX2pvYjogV3JpdGViYWNrIGpvYiBm b3Igd3JpdGViYWNrIGNvbm5lY3RvcnMKKwkgKgorCSAqIEhvbGRzIHRoZSBmcmFtZWJ1ZmZlciBm b3IgYSB3cml0ZWJhY2sgY29ubmVjdG9yLiBBcyB0aGUgd3JpdGViYWNrCisJICogY29tcGxldGlv biBtYXkgYmUgYXN5bmNocm9ub3VzIHRvIHRoZSBub3JtYWwgY29tbWl0IGN5Y2xlLCB0aGUKKwkg KiB3cml0ZWJhY2sgam9iIGxpZmV0aW1lIGlzIG1hbmFnZWQgc2VwYXJhdGVseSBmcm9tIHRoZSBu b3JtYWwgYXRvbWljCisJICogc3RhdGUgYnkgdGhpcyBvYmplY3QuCisJICoKKwkgKiBTZWUgYWxz bzogZHJtX3dyaXRlYmFja19xdWV1ZV9qb2IoKSBhbmQKKwkgKiBkcm1fd3JpdGViYWNrX3NpZ25h bF9jb21wbGV0aW9uKCkKKwkgKi8KKwlzdHJ1Y3QgZHJtX3dyaXRlYmFja19qb2IgKndyaXRlYmFj a19qb2I7CiB9OwogCiAvKioKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZp Zy5oIGIvaW5jbHVkZS9kcm0vZHJtX21vZGVfY29uZmlnLmgKaW5kZXggNzU2OWYyMmZmZWY2Li5j MDEyZTExNDhlYzAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCisr KyBiL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCkBAIC03NzksNiArNzc5LDIwIEBAIHN0 cnVjdCBkcm1fbW9kZV9jb25maWcgewogCSAqLwogCXN0cnVjdCBkcm1fcHJvcGVydHkgKnBhbmVs X29yaWVudGF0aW9uX3Byb3BlcnR5OwogCisJLyoqCisJICogQHdyaXRlYmFja19mYl9pZF9wcm9w ZXJ0eTogUHJvcGVydHkgZm9yIHdyaXRlYmFjayBjb25uZWN0b3JzLCBzdG9yaW5nCisJICogdGhl IElEIG9mIHRoZSBvdXRwdXQgZnJhbWVidWZmZXIuCisJICogU2VlIGFsc286IGRybV93cml0ZWJh Y2tfY29ubmVjdG9yX2luaXQoKQorCSAqLworCXN0cnVjdCBkcm1fcHJvcGVydHkgKndyaXRlYmFj a19mYl9pZF9wcm9wZXJ0eTsKKwkvKioKKwkgKiBAd3JpdGViYWNrX3BpeGVsX2Zvcm1hdHNfcHJv cGVydHk6IFByb3BlcnR5IGZvciB3cml0ZWJhY2sgY29ubmVjdG9ycywKKwkgKiBzdG9yaW5nIGFu IGFycmF5IG9mIHRoZSBzdXBwb3J0ZWQgcGl4ZWwgZm9ybWF0cyBmb3IgdGhlIHdyaXRlYmFjawor CSAqIGVuZ2luZSAocmVhZC1vbmx5KS4KKwkgKiBTZWUgYWxzbzogZHJtX3dyaXRlYmFja19jb25u ZWN0b3JfaW5pdCgpCisJICovCisJc3RydWN0IGRybV9wcm9wZXJ0eSAqd3JpdGViYWNrX3BpeGVs X2Zvcm1hdHNfcHJvcGVydHk7CisKIAkvKiBkdW1iIGlvY3RsIHBhcmFtZXRlcnMgKi8KIAl1aW50 MzJfdCBwcmVmZXJyZWRfZGVwdGgsIHByZWZlcl9zaGFkb3c7CiAKZGlmZiAtLWdpdCBhL2luY2x1 ZGUvZHJtL2RybV9tb2Rlc2V0X2hlbHBlcl92dGFibGVzLmggYi9pbmNsdWRlL2RybS9kcm1fbW9k ZXNldF9oZWxwZXJfdnRhYmxlcy5oCmluZGV4IDNlNzZjYTgwNWIwZi4uOTdkM2E4MTBiYzg1IDEw MDY0NAotLS0gYS9pbmNsdWRlL2RybS9kcm1fbW9kZXNldF9oZWxwZXJfdnRhYmxlcy5oCisrKyBi L2luY2x1ZGUvZHJtL2RybV9tb2Rlc2V0X2hlbHBlcl92dGFibGVzLmgKQEAgLTk3NCw2ICs5NzQs MTcgQEAgc3RydWN0IGRybV9jb25uZWN0b3JfaGVscGVyX2Z1bmNzIHsKIAkgKi8KIAlpbnQgKCph dG9taWNfY2hlY2spKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCiAJCQkgICAgc3Ry dWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKnN0YXRlKTsKKworCS8qKgorCSAqIEBhdG9taWNfY29t bWl0OgorCSAqCisJICogRm9yIHdyaXRlLWJhY2sgY29ubmVjdG9ycywgdGhpcyBpcyB0aGUgcG9p bnQgdG8gY29tbWl0IHRoZSB3cml0ZS0KKwkgKiBiYWNrIGpvYiB0byBody4KKwkgKgorCSAqIFRo aXMgY2FsbGJhY2sgaXMgdXNlZCBieSB0aGUgYXRvbWljIG1vZGVzZXQgaGVscGVycy4KKwkgKi8K Kwl2b2lkICgqYXRvbWljX2NvbW1pdCkoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwK KwkJCSAgICAgIHN0cnVjdCBkcm1fd3JpdGViYWNrX2pvYiAqd3JpdGViYWNrX2pvYik7CiB9Owog CiAvKioKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV93cml0ZWJhY2suaCBiL2luY2x1ZGUv ZHJtL2RybV93cml0ZWJhY2suaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAuLjBiYjk1ZmQ0OTA3ZAotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvZHJtL2RybV93cml0 ZWJhY2suaApAQCAtMCwwICsxLDg5IEBACisvKgorICogKEMpIENPUFlSSUdIVCAyMDE2IEFSTSBM aW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQXV0aG9yOiBCcmlhbiBTdGFya2V5IDxi cmlhbi5zdGFya2V5QGFybS5jb20+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdh cmUgYW5kIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgb2YgdGhlCisgKiBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBhbmQgYW55IHVzZSBieSB5b3Ugb2YgdGhpcyBwcm9n cmFtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zCisgKiBvZiBzdWNoIEdOVSBsaWNlbmNlLgorICov CisKKyNpZm5kZWYgX19EUk1fV1JJVEVCQUNLX0hfXworI2RlZmluZSBfX0RSTV9XUklURUJBQ0tf SF9fCisjaW5jbHVkZSA8ZHJtL2RybV9jb25uZWN0b3IuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2Vu Y29kZXIuaD4KKyNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KKworc3RydWN0IGRybV93cml0 ZWJhY2tfY29ubmVjdG9yIHsKKwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciBiYXNlOworCisJLyoqCisJ ICogQGVuY29kZXI6IEludGVybmFsIGVuY29kZXIgdXNlZCBieSB0aGUgY29ubmVjdG9yIHRvIGZ1 bGZpbGwKKwkgKiB0aGUgRFJNIGZyYW1ld29yayByZXF1aXJlbWVudHMuIFRoZSB1c2VycyBvZiB0 aGUKKwkgKiBAZHJtX3dyaXRlYmFja19jb25uZWN0b3IgY29udHJvbCB0aGUgYmVoYXZpb3VyIG9m IHRoZSBAZW5jb2RlcgorCSAqIGJ5IHBhc3NpbmcgdGhlIEBlbmNfZnVuY3MgcGFyYW1ldGVyIHRv IGRybV93cml0ZWJhY2tfY29ubmVjdG9yX2luaXQoKQorCSAqIGZ1bmN0aW9uLgorCSAqLworCXN0 cnVjdCBkcm1fZW5jb2RlciBlbmNvZGVyOworCisJLyoqCisJICogQHBpeGVsX2Zvcm1hdHNfYmxv Yl9wdHI6CisJICoKKwkgKiBEUk0gYmxvYiBwcm9wZXJ0eSBkYXRhIGZvciB0aGUgcGl4ZWwgZm9y bWF0cyBsaXN0IG9uIHdyaXRlYmFjaworCSAqIGNvbm5lY3RvcnMKKwkgKiBTZWUgYWxzbyBkcm1f d3JpdGViYWNrX2Nvbm5lY3Rvcl9pbml0KCkKKwkgKi8KKwlzdHJ1Y3QgZHJtX3Byb3BlcnR5X2Js b2IgKnBpeGVsX2Zvcm1hdHNfYmxvYl9wdHI7CisKKwkvKiogQGpvYl9sb2NrOiBQcm90ZWN0cyBq b2JfcXVldWUgKi8KKwlzcGlubG9ja190IGpvYl9sb2NrOworCisJLyoqCisJICogQGpvYl9xdWV1 ZToKKwkgKgorCSAqIEhvbGRzIGEgbGlzdCBvZiBhIGNvbm5lY3RvcidzIHdyaXRlYmFjayBqb2Jz OyB0aGUgbGFzdCBpdGVtIGlzIHRoZQorCSAqIG1vc3QgcmVjZW50LiBUaGUgZmlyc3QgaXRlbSBt YXkgYmUgZWl0aGVyIHdhaXRpbmcgZm9yIHRoZSBoYXJkd2FyZQorCSAqIHRvIGJlZ2luIHdyaXRp bmcsIG9yIGN1cnJlbnRseSBiZWluZyB3cml0dGVuLgorCSAqCisJICogU2VlIGFsc286IGRybV93 cml0ZWJhY2tfcXVldWVfam9iKCkgYW5kCisJICogZHJtX3dyaXRlYmFja19zaWduYWxfY29tcGxl dGlvbigpCisJICovCisJc3RydWN0IGxpc3RfaGVhZCBqb2JfcXVldWU7Cit9OworI2RlZmluZSB0 b193Yl9jb25uZWN0b3IoeCkgY29udGFpbmVyX29mKHgsIHN0cnVjdCBkcm1fd3JpdGViYWNrX2Nv bm5lY3RvciwgYmFzZSkKKworc3RydWN0IGRybV93cml0ZWJhY2tfam9iIHsKKwkvKioKKwkgKiBA Y2xlYW51cF93b3JrOgorCSAqCisJICogVXNlZCB0byBhbGxvdyBkcm1fd3JpdGViYWNrX3NpZ25h bF9jb21wbGV0aW9uIHRvIGRlZmVyIGRyb3BwaW5nIHRoZQorCSAqIGZyYW1lYnVmZmVyIHJlZmVy ZW5jZSB0byBhIHdvcmtxdWV1ZS4KKwkgKi8KKwlzdHJ1Y3Qgd29ya19zdHJ1Y3QgY2xlYW51cF93 b3JrOworCS8qKgorCSAqIEBsaXN0X2VudHJ5OgorCSAqCisJICogTGlzdCBpdGVtIGZvciB0aGUg Y29ubmVjdG9yJ3MgQGpvYl9xdWV1ZQorCSAqLworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdF9lbnRy eTsKKwkvKioKKwkgKiBAZmI6CisJICoKKwkgKiBGcmFtZWJ1ZmZlciB0byBiZSB3cml0dGVuIHRv IGJ5IHRoZSB3cml0ZWJhY2sgY29ubmVjdG9yLiBEbyBub3Qgc2V0CisJICogZGlyZWN0bHksIHVz ZSBkcm1fYXRvbWljX3NldF93cml0ZWJhY2tfZmJfZm9yX2Nvbm5lY3RvcigpCisJICovCisJc3Ry dWN0IGRybV9mcmFtZWJ1ZmZlciAqZmI7Cit9OworCitpbnQgZHJtX3dyaXRlYmFja19jb25uZWN0 b3JfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQkJCSBzdHJ1Y3QgZHJtX3dyaXRlYmFj a19jb25uZWN0b3IgKndiX2Nvbm5lY3RvciwKKwkJCQkgY29uc3Qgc3RydWN0IGRybV9jb25uZWN0 b3JfZnVuY3MgKmNvbl9mdW5jcywKKwkJCQkgY29uc3Qgc3RydWN0IGRybV9lbmNvZGVyX2hlbHBl cl9mdW5jcyAqZW5jX2hlbHBlcl9mdW5jcywKKwkJCQkgY29uc3QgdTMyICpmb3JtYXRzLCBpbnQg bl9mb3JtYXRzKTsKKwordm9pZCBkcm1fd3JpdGViYWNrX3F1ZXVlX2pvYihzdHJ1Y3QgZHJtX3dy aXRlYmFja19jb25uZWN0b3IgKndiX2Nvbm5lY3RvciwKKwkJCSAgICAgc3RydWN0IGRybV93cml0 ZWJhY2tfam9iICpqb2IpOworCit2b2lkIGRybV93cml0ZWJhY2tfY2xlYW51cF9qb2Ioc3RydWN0 IGRybV93cml0ZWJhY2tfam9iICpqb2IpOwordm9pZCBkcm1fd3JpdGViYWNrX3NpZ25hbF9jb21w bGV0aW9uKHN0cnVjdCBkcm1fd3JpdGViYWNrX2Nvbm5lY3RvciAqd2JfY29ubmVjdG9yKTsKKyNl bmRpZgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oIGIvaW5jbHVkZS91 YXBpL2RybS9kcm1fbW9kZS5oCmluZGV4IDJjNTc1Nzk0ZmI1Mi4uN2I0N2UxODRlOTVlIDEwMDY0 NAotLS0gYS9pbmNsdWRlL3VhcGkvZHJtL2RybV9tb2RlLmgKKysrIGIvaW5jbHVkZS91YXBpL2Ry bS9kcm1fbW9kZS5oCkBAIC0zMzgsNiArMzM4LDcgQEAgZW51bSBkcm1fbW9kZV9zdWJjb25uZWN0 b3IgewogI2RlZmluZSBEUk1fTU9ERV9DT05ORUNUT1JfVklSVFVBTCAgICAgIDE1CiAjZGVmaW5l IERSTV9NT0RFX0NPTk5FQ1RPUl9EU0kJCTE2CiAjZGVmaW5lIERSTV9NT0RFX0NPTk5FQ1RPUl9E UEkJCTE3CisjZGVmaW5lIERSTV9NT0RFX0NPTk5FQ1RPUl9XUklURUJBQ0sJMTgKIAogc3RydWN0 IGRybV9tb2RlX2dldF9jb25uZWN0b3IgewogCi0tIAoyLjE0LjMKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkZyZWVkcmVubyBtYWlsaW5nIGxpc3QKRnJl ZWRyZW5vQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2ZyZWVkcmVubwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751713AbeBWNUA (ORCPT ); Fri, 23 Feb 2018 08:20:00 -0500 Received: from mail-qk0-f193.google.com ([209.85.220.193]:39587 "EHLO mail-qk0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751663AbeBWNT6 (ORCPT ); Fri, 23 Feb 2018 08:19:58 -0500 X-Google-Smtp-Source: AG47ELsBAFIEBqozfmT1QEt4u76NWPy3wdz/X3rDulpJ6B7m/JPvD2bMXZRSeGwWzxcF20k2/RwdTQ== From: Rob Clark To: dri-devel@lists.freedesktop.org Cc: freedreno@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, Brian Starkey , Liviu Dudau , Mihail Atanassov , Rob Clark , Gustavo Padovan , Maarten Lankhorst , Sean Paul , David Airlie , Jonathan Corbet , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC 1/4] drm: Add writeback connector type Date: Fri, 23 Feb 2018 08:17:51 -0500 Message-Id: <20180223131758.18362-2-robdclark@gmail.com> X-Mailer: git-send-email 2.14.3 In-Reply-To: <20180223131758.18362-1-robdclark@gmail.com> References: <20180223131758.18362-1-robdclark@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Brian Starkey Writeback connectors represent writeback engines which can write the CRTC output to a memory framebuffer. Add a writeback connector type and related support functions. Drivers should initialize a writeback connector with drm_writeback_connector_init() which takes care of setting up all the writeback-specific details on top of the normal functionality of drm_connector_init(). Writeback connectors have a WRITEBACK_FB_ID property, used to set the output framebuffer, and a WRITEBACK_PIXEL_FORMATS blob used to expose the supported writeback formats to userspace. When a framebuffer is attached to a writeback connector with the WRITEBACK_FB_ID property, it is used only once (for the commit in which it was included), and userspace can never read back the value of WRITEBACK_FB_ID. WRITEBACK_FB_ID can only be set if the connector is attached to a CRTC. Changes since v1: - Added drm_writeback.c + documentation - Added helper to initialize writeback connector in one go - Added core checks - Squashed into a single commit - Dropped the client cap - Writeback framebuffers are no longer persistent Changes since v2: Daniel Vetter: - Subclass drm_connector to drm_writeback_connector - Relax check to allow CRTC to be set without an FB - Add some writeback_ prefixes - Drop PIXEL_FORMATS_SIZE property, as it was unnecessary Gustavo Padovan: - Add drm_writeback_job to handle writeback signalling centrally Changes since v3: - Rebased - Rename PIXEL_FORMATS -> WRITEBACK_PIXEL_FORMATS Changes since v4: - Added atomic_commit() vfunc to connector helper funcs, so that writeback jobs are committed from atomic helpers Signed-off-by: Brian Starkey [rebased and fixed conflicts] Signed-off-by: Mihail Atanassov Signed-off-by: Liviu Dudau [rebased and added atomic_commit() vfunc for writeback jobs] Signed-off-by: Rob Clark --- Documentation/gpu/drm-kms.rst | 9 ++ drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_atomic.c | 130 ++++++++++++++++ drivers/gpu/drm/drm_atomic_helper.c | 30 ++++ drivers/gpu/drm/drm_connector.c | 4 +- drivers/gpu/drm/drm_writeback.c | 257 +++++++++++++++++++++++++++++++ include/drm/drm_atomic.h | 3 + include/drm/drm_connector.h | 13 ++ include/drm/drm_mode_config.h | 14 ++ include/drm/drm_modeset_helper_vtables.h | 11 ++ include/drm/drm_writeback.h | 89 +++++++++++ include/uapi/drm/drm_mode.h | 1 + 12 files changed, 561 insertions(+), 2 deletions(-) create mode 100644 drivers/gpu/drm/drm_writeback.c create mode 100644 include/drm/drm_writeback.h diff --git a/Documentation/gpu/drm-kms.rst b/Documentation/gpu/drm-kms.rst index 2dcf5b42015d..e7590dd2f71e 100644 --- a/Documentation/gpu/drm-kms.rst +++ b/Documentation/gpu/drm-kms.rst @@ -370,6 +370,15 @@ Connector Functions Reference .. kernel-doc:: drivers/gpu/drm/drm_connector.c :export: +Writeback Connectors +-------------------- + +.. kernel-doc:: drivers/gpu/drm/drm_writeback.c + :doc: overview + +.. kernel-doc:: drivers/gpu/drm/drm_writeback.c + :export: + Encoder Abstraction =================== diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 50093ff4479b..3d708959b224 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -18,7 +18,7 @@ drm-y := drm_auth.o drm_bufs.o drm_cache.o \ drm_encoder.o drm_mode_object.o drm_property.o \ drm_plane.o drm_color_mgmt.o drm_print.o \ drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \ - drm_syncobj.o drm_lease.o + drm_syncobj.o drm_lease.o drm_writeback.o drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o drm-$(CONFIG_DRM_VM) += drm_vm.o diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 46733d534587..019f131fe8be 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include "drm_crtc_internal.h" @@ -638,6 +639,46 @@ static void drm_atomic_crtc_print_state(struct drm_printer *p, crtc->funcs->atomic_print_state(p, state); } +/** + * drm_atomic_connector_check - check connector state + * @connector: connector to check + * @state: connector state to check + * + * Provides core sanity checks for connector state. + * + * RETURNS: + * Zero on success, error code on failure + */ +static int drm_atomic_connector_check(struct drm_connector *connector, + struct drm_connector_state *state) +{ + struct drm_crtc_state *crtc_state; + struct drm_writeback_job *writeback_job = state->writeback_job; + + if ((connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK) || + !writeback_job) + return 0; + + if (writeback_job->fb && !state->crtc) { + DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] framebuffer without CRTC\n", + connector->base.id, connector->name); + return -EINVAL; + } + + if (state->crtc) + crtc_state = drm_atomic_get_existing_crtc_state(state->state, + state->crtc); + + if (writeback_job->fb && !crtc_state->active) { + DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] has framebuffer, but [CRTC:%d] is off\n", + connector->base.id, connector->name, + state->crtc->base.id); + return -EINVAL; + } + + return 0; +} + /** * drm_atomic_get_plane_state - get plane state * @state: global atomic state object @@ -1230,6 +1271,12 @@ static int drm_atomic_connector_set_property(struct drm_connector *connector, return -EINVAL; } state->content_protection = val; + } else if (property == config->writeback_fb_id_property) { + struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, NULL, val); + int ret = drm_atomic_set_writeback_fb_for_connector(state, fb); + if (fb) + drm_framebuffer_unreference(fb); + return ret; } else if (connector->funcs->atomic_set_property) { return connector->funcs->atomic_set_property(connector, state, property, val); @@ -1311,6 +1358,9 @@ drm_atomic_connector_get_property(struct drm_connector *connector, *val = state->scaling_mode; } else if (property == connector->content_protection_property) { *val = state->content_protection; + } else if (property == config->writeback_fb_id_property) { + /* Writeback framebuffer is one-shot, write and forget */ + *val = 0; } else if (connector->funcs->atomic_get_property) { return connector->funcs->atomic_get_property(connector, state, property, val); @@ -1518,6 +1568,75 @@ drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, } EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector); +/* + * drm_atomic_get_writeback_job - return or allocate a writeback job + * @conn_state: Connector state to get the job for + * + * Writeback jobs have a different lifetime to the atomic state they are + * associated with. This convenience function takes care of allocating a job + * if there isn't yet one associated with the connector state, otherwise + * it just returns the existing job. + * + * Returns: The writeback job for the given connector state + */ +static struct drm_writeback_job * +drm_atomic_get_writeback_job(struct drm_connector_state *conn_state) +{ + WARN_ON(conn_state->connector->connector_type != + DRM_MODE_CONNECTOR_WRITEBACK); + + if (!conn_state->writeback_job) + conn_state->writeback_job = + kzalloc(sizeof(*conn_state->writeback_job), GFP_KERNEL); + + return conn_state->writeback_job; +} + +/** + * drm_atomic_set_writeback_fb_for_connector - set writeback framebuffer + * @conn_state: atomic state object for the connector + * @fb: fb to use for the connector + * + * This is used to set the framebuffer for a writeback connector, which outputs + * to a buffer instead of an actual physical connector. + * Changing the assigned framebuffer requires us to grab a reference to the new + * fb and drop the reference to the old fb, if there is one. This function + * takes care of all these details besides updating the pointer in the + * state object itself. + * + * Note: The only way conn_state can already have an fb set is if the commit + * sets the property more than once. + * + * See also: drm_writeback_connector_init() + * + * Returns: 0 on success + */ +int drm_atomic_set_writeback_fb_for_connector( + struct drm_connector_state *conn_state, + struct drm_framebuffer *fb) +{ + struct drm_writeback_job *job = + drm_atomic_get_writeback_job(conn_state); + if (!job) + return -ENOMEM; + + if (job->fb) + drm_framebuffer_unreference(job->fb); + if (fb) + drm_framebuffer_reference(fb); + job->fb = fb; + + if (fb) + DRM_DEBUG_ATOMIC("Set [FB:%d] for connector state %p\n", + fb->base.id, conn_state); + else + DRM_DEBUG_ATOMIC("Set [NOFB] for connector state %p\n", + conn_state); + + return 0; +} +EXPORT_SYMBOL(drm_atomic_set_writeback_fb_for_connector); + /** * drm_atomic_add_affected_connectors - add connectors for crtc * @state: atomic state @@ -1636,6 +1755,8 @@ int drm_atomic_check_only(struct drm_atomic_state *state) struct drm_plane_state *plane_state; struct drm_crtc *crtc; struct drm_crtc_state *crtc_state; + struct drm_connector *conn; + struct drm_connector_state *conn_state; int i, ret = 0; DRM_DEBUG_ATOMIC("checking %p\n", state); @@ -1658,6 +1779,15 @@ int drm_atomic_check_only(struct drm_atomic_state *state) } } + for_each_new_connector_in_state(state, conn, conn_state, i) { + ret = drm_atomic_connector_check(conn, conn_state); + if (ret) { + DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] atomic core check failed\n", + conn->base.id, conn->name); + return ret; + } + } + if (config->funcs->atomic_check) ret = config->funcs->atomic_check(state->dev, state); diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index ae3cbfe9e01c..12b910755d84 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include "drm_crtc_helper_internal.h" @@ -1159,6 +1160,27 @@ void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev, } EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables); +static void commit_writebacks(struct drm_device *dev, struct drm_atomic_state *old_state) +{ + struct drm_connector *connector; + struct drm_connector_state *new_conn_state; + int i; + + for_each_new_connector_in_state(old_state, connector, new_conn_state, i) { + const struct drm_connector_helper_funcs *funcs; + + funcs = connector->helper_private; + + if (new_conn_state->writeback_job && + new_conn_state->writeback_job->fb) { + WARN_ON(connector->connector_type != + DRM_MODE_CONNECTOR_WRITEBACK); + funcs->atomic_commit(connector, + new_conn_state->writeback_job); + } + } +} + /** * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs * @dev: DRM device @@ -1238,6 +1260,8 @@ void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev, drm_bridge_enable(encoder->bridge); } + + commit_writebacks(dev, old_state); } EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables); @@ -3627,6 +3651,9 @@ __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector, if (state->crtc) drm_connector_get(connector); state->commit = NULL; + + /* Don't copy over a writeback job, they are used only once */ + state->writeback_job = NULL; } EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state); @@ -3756,6 +3783,9 @@ __drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state) if (state->commit) drm_crtc_commit_put(state->commit); + + if (state->writeback_job) + drm_writeback_cleanup_job(state->writeback_job); } EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state); diff --git a/drivers/gpu/drm/drm_connector.c b/drivers/gpu/drm/drm_connector.c index 16b9c3810af2..add47f06ae70 100644 --- a/drivers/gpu/drm/drm_connector.c +++ b/drivers/gpu/drm/drm_connector.c @@ -87,6 +87,7 @@ static struct drm_conn_prop_enum_list drm_connector_enum_list[] = { { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" }, { DRM_MODE_CONNECTOR_DSI, "DSI" }, { DRM_MODE_CONNECTOR_DPI, "DPI" }, + { DRM_MODE_CONNECTOR_WRITEBACK, "Writeback" }, }; void drm_connector_ida_init(void) @@ -249,7 +250,8 @@ int drm_connector_init(struct drm_device *dev, config->num_connector++; spin_unlock_irq(&config->connector_list_lock); - if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL) + if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL && + connector_type != DRM_MODE_CONNECTOR_WRITEBACK) drm_object_attach_property(&connector->base, config->edid_property, 0); diff --git a/drivers/gpu/drm/drm_writeback.c b/drivers/gpu/drm/drm_writeback.c new file mode 100644 index 000000000000..da61f929cbc3 --- /dev/null +++ b/drivers/gpu/drm/drm_writeback.c @@ -0,0 +1,257 @@ +/* + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved. + * Author: Brian Starkey + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + */ + +#include +#include +#include +#include +#include + +/** + * DOC: overview + * + * Writeback connectors are used to expose hardware which can write the output + * from a CRTC to a memory buffer. They are used and act similarly to other + * types of connectors, with some important differences: + * - Writeback connectors don't provide a way to output visually to the user. + * - Writeback connectors should always report as "disconnected" (so that + * clients which don't understand them will ignore them). + * - Writeback connectors don't have EDID. + * + * A framebuffer may only be attached to a writeback connector when the + * connector is attached to a CRTC. The WRITEBACK_FB_ID property which sets the + * framebuffer applies only to a single commit (see below). A framebuffer may + * not be attached while the CRTC is off. + * + * Writeback connectors have some additional properties, which userspace + * can use to query and control them: + * + * "WRITEBACK_FB_ID": + * Write-only object property storing a DRM_MODE_OBJECT_FB: it stores the + * framebuffer to be written by the writeback connector. This property is + * similar to the FB_ID property on planes, but will always read as zero + * and is not preserved across commits. + * Userspace must set this property to an output buffer every time it + * wishes the buffer to get filled. + * + * "WRITEBACK_PIXEL_FORMATS": + * Immutable blob property to store the supported pixel formats table. The + * data is an array of u32 DRM_FORMAT_* fourcc values. + * Userspace can use this blob to find out what pixel formats are supported + * by the connector's writeback engine. + */ + +static bool create_writeback_properties(struct drm_device *dev) +{ + struct drm_property *prop; + + if (!dev->mode_config.writeback_fb_id_property) { + prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC, + "WRITEBACK_FB_ID", + DRM_MODE_OBJECT_FB); + if (!prop) + return false; + dev->mode_config.writeback_fb_id_property = prop; + } + + if (!dev->mode_config.writeback_pixel_formats_property) { + prop = drm_property_create(dev, DRM_MODE_PROP_BLOB | DRM_MODE_PROP_IMMUTABLE, + "WRITEBACK_PIXEL_FORMATS", 0); + if (!prop) + return false; + dev->mode_config.writeback_pixel_formats_property = prop; + } + + return true; +} + +static const struct drm_encoder_funcs drm_writeback_encoder_funcs = { + .destroy = drm_encoder_cleanup, +}; + +/** + * drm_writeback_connector_init - Initialize a writeback connector and its properties + * @dev: DRM device + * @wb_connector: Writeback connector to initialize + * @con_funcs: Connector funcs vtable + * @enc_helper_funcs: Encoder helper funcs vtable to be used by the internal encoder + * @formats: Array of supported pixel formats for the writeback engine + * @n_formats: Length of the formats array + * + * This function creates the writeback-connector-specific properties if they + * have not been already created, initializes the connector as + * type DRM_MODE_CONNECTOR_WRITEBACK, and correctly initializes the property + * values. It will also create an internal encoder associated with the + * drm_writeback_connector and set it to use the @enc_helper_funcs vtable for + * the encoder helper. + * + * Drivers should always use this function instead of drm_connector_init() to + * set up writeback connectors. + * + * Returns: 0 on success, or a negative error code + */ +int drm_writeback_connector_init(struct drm_device *dev, + struct drm_writeback_connector *wb_connector, + const struct drm_connector_funcs *con_funcs, + const struct drm_encoder_helper_funcs *enc_helper_funcs, + const u32 *formats, int n_formats) +{ + int ret; + struct drm_property_blob *blob; + struct drm_connector *connector = &wb_connector->base; + struct drm_mode_config *config = &dev->mode_config; + + if (!create_writeback_properties(dev)) + return -EINVAL; + + blob = drm_property_create_blob(dev, n_formats * sizeof(*formats), + formats); + if (IS_ERR(blob)) + return PTR_ERR(blob); + + drm_encoder_helper_add(&wb_connector->encoder, enc_helper_funcs); + ret = drm_encoder_init(dev, &wb_connector->encoder, + &drm_writeback_encoder_funcs, + DRM_MODE_ENCODER_VIRTUAL, NULL); + if (ret) + goto fail; + + connector->interlace_allowed = 0; + + ret = drm_connector_init(dev, connector, con_funcs, + DRM_MODE_CONNECTOR_WRITEBACK); + if (ret) + goto connector_fail; + + ret = drm_mode_connector_attach_encoder(connector, + &wb_connector->encoder); + if (ret) + goto attach_fail; + + INIT_LIST_HEAD(&wb_connector->job_queue); + spin_lock_init(&wb_connector->job_lock); + + drm_object_attach_property(&connector->base, + config->writeback_fb_id_property, 0); + + drm_object_attach_property(&connector->base, + config->writeback_pixel_formats_property, + blob->base.id); + wb_connector->pixel_formats_blob_ptr = blob; + + return 0; + +attach_fail: + drm_connector_cleanup(connector); +connector_fail: + drm_encoder_cleanup(&wb_connector->encoder); +fail: + drm_property_unreference_blob(blob); + return ret; +} +EXPORT_SYMBOL(drm_writeback_connector_init); + +/** + * drm_writeback_queue_job - Queue a writeback job for later signalling + * @wb_connector: The writeback connector to queue a job on + * @job: The job to queue + * + * This function adds a job to the job_queue for a writeback connector. It + * should be considered to take ownership of the writeback job, and so any other + * references to the job must be cleared after calling this function. + * + * Drivers must ensure that for a given writeback connector, jobs are queued in + * exactly the same order as they will be completed by the hardware (and + * signaled via drm_writeback_signal_completion). + * + * For every call to drm_writeback_queue_job() there must be exactly one call to + * drm_writeback_signal_completion() + * + * See also: drm_writeback_signal_completion() + */ +void drm_writeback_queue_job(struct drm_writeback_connector *wb_connector, + struct drm_writeback_job *job) +{ + unsigned long flags; + + spin_lock_irqsave(&wb_connector->job_lock, flags); + list_add_tail(&job->list_entry, &wb_connector->job_queue); + spin_unlock_irqrestore(&wb_connector->job_lock, flags); +} +EXPORT_SYMBOL(drm_writeback_queue_job); + +/** + * drm_writeback_cleanup_job - Cleanup and free a writeback job + * @job: The writeback job to free + * + * Drops any references held by the writeback job, and frees the structure. + */ +void drm_writeback_cleanup_job(struct drm_writeback_job *job) +{ + if (!job) + return; + + if (job->fb) + drm_framebuffer_unreference(job->fb); + kfree(job); +} +EXPORT_SYMBOL(drm_writeback_cleanup_job); + +/* + * @cleanup_work: deferred cleanup of a writeback job + * + * The job cannot be cleaned up directly in drm_writeback_signal_completion, + * because it may be called in interrupt context. Dropping the framebuffer + * reference can sleep, and so the cleanup is deferred to a workqueue. + */ +static void cleanup_work(struct work_struct *work) +{ + struct drm_writeback_job *job = container_of(work, + struct drm_writeback_job, + cleanup_work); + drm_writeback_cleanup_job(job); +} + +/** + * drm_writeback_signal_completion - Signal the completion of a writeback job + * @wb_connector: The writeback connector whose job is complete + * + * Drivers should call this to signal the completion of a previously queued + * writeback job. It should be called as soon as possible after the hardware + * has finished writing, and may be called from interrupt context. + * It is the driver's responsibility to ensure that for a given connector, the + * hardware completes writeback jobs in the same order as they are queued. + * + * Unless the driver is holding its own reference to the framebuffer, it must + * not be accessed after calling this function. + * + * See also: drm_writeback_queue_job() + */ +void +drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector) +{ + unsigned long flags; + struct drm_writeback_job *job; + + spin_lock_irqsave(&wb_connector->job_lock, flags); + job = list_first_entry_or_null(&wb_connector->job_queue, + struct drm_writeback_job, + list_entry); + if (job) + list_del(&job->list_entry); + spin_unlock_irqrestore(&wb_connector->job_lock, flags); + + if (WARN_ON(!job)) + return; + + INIT_WORK(&job->cleanup_work, cleanup_work); + queue_work(system_long_wq, &job->cleanup_work); +} +EXPORT_SYMBOL(drm_writeback_signal_completion); diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index cf13842a6dbd..d7b0263cc5cf 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -594,6 +594,9 @@ void drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state, int __must_check drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, struct drm_crtc *crtc); +int drm_atomic_set_writeback_fb_for_connector( + struct drm_connector_state *conn_state, + struct drm_framebuffer *fb); int __must_check drm_atomic_add_affected_connectors(struct drm_atomic_state *state, struct drm_crtc *crtc); diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index 758a176e7b57..8701ebcc68b3 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -425,6 +425,19 @@ struct drm_connector_state { * protection. This is most commonly used for HDCP. */ unsigned int content_protection; + + /** + * @writeback_job: Writeback job for writeback connectors + * + * Holds the framebuffer for a writeback connector. As the writeback + * completion may be asynchronous to the normal commit cycle, the + * writeback job lifetime is managed separately from the normal atomic + * state by this object. + * + * See also: drm_writeback_queue_job() and + * drm_writeback_signal_completion() + */ + struct drm_writeback_job *writeback_job; }; /** diff --git a/include/drm/drm_mode_config.h b/include/drm/drm_mode_config.h index 7569f22ffef6..c012e1148ec0 100644 --- a/include/drm/drm_mode_config.h +++ b/include/drm/drm_mode_config.h @@ -779,6 +779,20 @@ struct drm_mode_config { */ struct drm_property *panel_orientation_property; + /** + * @writeback_fb_id_property: Property for writeback connectors, storing + * the ID of the output framebuffer. + * See also: drm_writeback_connector_init() + */ + struct drm_property *writeback_fb_id_property; + /** + * @writeback_pixel_formats_property: Property for writeback connectors, + * storing an array of the supported pixel formats for the writeback + * engine (read-only). + * See also: drm_writeback_connector_init() + */ + struct drm_property *writeback_pixel_formats_property; + /* dumb ioctl parameters */ uint32_t preferred_depth, prefer_shadow; diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h index 3e76ca805b0f..97d3a810bc85 100644 --- a/include/drm/drm_modeset_helper_vtables.h +++ b/include/drm/drm_modeset_helper_vtables.h @@ -974,6 +974,17 @@ struct drm_connector_helper_funcs { */ int (*atomic_check)(struct drm_connector *connector, struct drm_connector_state *state); + + /** + * @atomic_commit: + * + * For write-back connectors, this is the point to commit the write- + * back job to hw. + * + * This callback is used by the atomic modeset helpers. + */ + void (*atomic_commit)(struct drm_connector *connector, + struct drm_writeback_job *writeback_job); }; /** diff --git a/include/drm/drm_writeback.h b/include/drm/drm_writeback.h new file mode 100644 index 000000000000..0bb95fd4907d --- /dev/null +++ b/include/drm/drm_writeback.h @@ -0,0 +1,89 @@ +/* + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved. + * Author: Brian Starkey + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + */ + +#ifndef __DRM_WRITEBACK_H__ +#define __DRM_WRITEBACK_H__ +#include +#include +#include + +struct drm_writeback_connector { + struct drm_connector base; + + /** + * @encoder: Internal encoder used by the connector to fulfill + * the DRM framework requirements. The users of the + * @drm_writeback_connector control the behaviour of the @encoder + * by passing the @enc_funcs parameter to drm_writeback_connector_init() + * function. + */ + struct drm_encoder encoder; + + /** + * @pixel_formats_blob_ptr: + * + * DRM blob property data for the pixel formats list on writeback + * connectors + * See also drm_writeback_connector_init() + */ + struct drm_property_blob *pixel_formats_blob_ptr; + + /** @job_lock: Protects job_queue */ + spinlock_t job_lock; + + /** + * @job_queue: + * + * Holds a list of a connector's writeback jobs; the last item is the + * most recent. The first item may be either waiting for the hardware + * to begin writing, or currently being written. + * + * See also: drm_writeback_queue_job() and + * drm_writeback_signal_completion() + */ + struct list_head job_queue; +}; +#define to_wb_connector(x) container_of(x, struct drm_writeback_connector, base) + +struct drm_writeback_job { + /** + * @cleanup_work: + * + * Used to allow drm_writeback_signal_completion to defer dropping the + * framebuffer reference to a workqueue. + */ + struct work_struct cleanup_work; + /** + * @list_entry: + * + * List item for the connector's @job_queue + */ + struct list_head list_entry; + /** + * @fb: + * + * Framebuffer to be written to by the writeback connector. Do not set + * directly, use drm_atomic_set_writeback_fb_for_connector() + */ + struct drm_framebuffer *fb; +}; + +int drm_writeback_connector_init(struct drm_device *dev, + struct drm_writeback_connector *wb_connector, + const struct drm_connector_funcs *con_funcs, + const struct drm_encoder_helper_funcs *enc_helper_funcs, + const u32 *formats, int n_formats); + +void drm_writeback_queue_job(struct drm_writeback_connector *wb_connector, + struct drm_writeback_job *job); + +void drm_writeback_cleanup_job(struct drm_writeback_job *job); +void drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector); +#endif diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h index 2c575794fb52..7b47e184e95e 100644 --- a/include/uapi/drm/drm_mode.h +++ b/include/uapi/drm/drm_mode.h @@ -338,6 +338,7 @@ enum drm_mode_subconnector { #define DRM_MODE_CONNECTOR_VIRTUAL 15 #define DRM_MODE_CONNECTOR_DSI 16 #define DRM_MODE_CONNECTOR_DPI 17 +#define DRM_MODE_CONNECTOR_WRITEBACK 18 struct drm_mode_get_connector { -- 2.14.3