From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v3 2/3] drm: Add API for capturing frame CRCs Date: Wed, 3 Aug 2016 10:06:38 +0300 Message-ID: <20160803070638.GE4329@intel.com> References: <1469196645-3061-1-git-send-email-tomeu.vizoso@collabora.com> <1469196645-3061-3-git-send-email-tomeu.vizoso@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTP id A21EA6E752 for ; Wed, 3 Aug 2016 07:06:43 +0000 (UTC) Content-Disposition: inline In-Reply-To: <1469196645-3061-3-git-send-email-tomeu.vizoso@collabora.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Tomeu Vizoso Cc: Jonathan Corbet , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Daniel Vetter , Emil Velikov List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBKdWwgMjIsIDIwMTYgYXQgMDQ6MTA6NDRQTSArMDIwMCwgVG9tZXUgVml6b3NvIHdy b3RlOgo+IEFkZHMgZmlsZXMgYW5kIGRpcmVjdG9yaWVzIHRvIGRlYnVnZnMgZm9yIGNvbnRyb2xs aW5nIGFuZCByZWFkaW5nIGZyYW1lCj4gQ1JDcywgcGVyIENSVEM6Cj4gCj4gZHJpLzAvY3J0Yy0w L2NyYwo+IGRyaS8wL2NydGMtMC9jcmMvY29udHJvbAo+IGRyaS8wL2NydGMtMC9jcmMvZGF0YQo+ IAo+IERyaXZlcnMgY2FuIGltcGxlbWVudCB0aGUgc2V0X2NyY19zb3VyY2UgY2FsbGJhY2soKSBp biBkcm1fY3J0Y19mdW5jcyB0bwo+IHN0YXJ0IGFuZCBzdG9wIGdlbmVyYXRpbmcgZnJhbWUgQ1JD cyBhbmQgY2FuIGFkZCBlbnRyaWVzIHRvIHRoZSBvdXRwdXQKPiBieSBjYWxsaW5nIGRybV9jcnRj X2FkZF9jcmNfZW50cnkuCj4gCj4gdjI6Cj4gICAgIC0gTG90cyBvZiBnb29kIGZpeGVzIHN1Z2dl c3RlZCBieSBUaGllcnJ5Lgo+ICAgICAtIEFkZGVkIGRvY3VtZW50YXRpb24uCj4gICAgIC0gQ2hh bmdlZCB0aGUgZGVidWdmcyBsYXlvdXQuCj4gICAgIC0gTW92ZWQgdG8gYWxsb2NhdGUgdGhlIGVu dHJpZXMgY2lyY3VsYXIgcXVldWUgb25jZSB3aGVuIGZyYW1lCj4gICAgICAgZ2VuZXJhdGlvbiBn ZXRzIGVuYWJsZWQgZm9yIHRoZSBmaXJzdCB0aW1lLgo+IHYzOgo+ICAgICAtIFVzZSB0aGUgY29u dHJvbCBmaWxlIGp1c3QgdG8gc2VsZWN0IHRoZSBzb3VyY2UsIGFuZCBzdGFydCBhbmQgc3RvcAo+ ICAgICAgIGNhcHR1cmUgd2hlbiB0aGUgZGF0YSBmaWxlIGlzIG9wZW5lZCBhbmQgY2xvc2VkLCBy ZXNwZWN0aXZlbHkuCj4gICAgIC0gTWFrZSB2YXJpYWJsZSB0aGUgbnVtYmVyIG9mIENSQyB2YWx1 ZXMgcGVyIGVudHJ5LCBwZXIgc291cmNlLgo+ICAgICAtIEFsbG9jYXRlIGVudHJpZXMgcXVldWUg ZWFjaCB0aW1lIHdlIHN0YXJ0IGNhcHR1cmluZyBhcyBub3cgdGhlcmUKPiAgICAgICBpc24ndCBh IGZpeGVkIG51bWJlciBvZiBDUkMgdmFsdWVzIHBlciBlbnRyeS4KPiAgICAgLSBTdG9yZSB0aGUg ZnJhbWUgY291bnRlciBpbiB0aGUgZGF0YSBmaWxlIGFzIGEgOC1kaWdpdCBoZXggbnVtYmVyLgo+ ICAgICAtIEZvciBzb3VyY2VzIHRoYXQgY2Fubm90IHByb3ZpZGUgdXNlZnVsIGZyYW1lIG51bWJl cnMsIHBsYWNlCj4gICAgICAgWFhYWFhYWFggaW4gdGhlIGZyYW1lIGZpZWxkLgo+IAo+IFNpZ25l ZC1vZmYtYnk6IFRvbWV1IFZpem9zbyA8dG9tZXUudml6b3NvQGNvbGxhYm9yYS5jb20+Cj4gLS0t Cj4gCj4gIERvY3VtZW50YXRpb24vZ3B1L2RybS11YXBpLnJzdCAgICB8ICAgNiArCj4gIGRyaXZl cnMvZ3B1L2RybS9NYWtlZmlsZSAgICAgICAgICB8ICAgMyArLQo+ICBkcml2ZXJzL2dwdS9kcm0v ZHJtX2NydGMuYyAgICAgICAgfCAgMTIgKysKPiAgZHJpdmVycy9ncHUvZHJtL2RybV9kZWJ1Z2Zz LmMgICAgIHwgIDM2ICsrKy0KPiAgZHJpdmVycy9ncHUvZHJtL2RybV9kZWJ1Z2ZzX2NyYy5jIHwg MzcwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZlcnMvZ3B1 L2RybS9kcm1fZHJ2LmMgICAgICAgICB8ICAgOSArCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1faW50 ZXJuYWwuaCAgICB8ICAxMCArKwo+ICBpbmNsdWRlL2RybS9kcm1QLmggICAgICAgICAgICAgICAg fCAgIDUgKwo+ICBpbmNsdWRlL2RybS9kcm1fY3J0Yy5oICAgICAgICAgICAgfCAgNDEgKysrKysK PiAgaW5jbHVkZS9kcm0vZHJtX2RlYnVnZnNfY3JjLmggICAgIHwgIDc0ICsrKysrKysrCj4gIDEw IGZpbGVzIGNoYW5nZWQsIDU2NCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+ICBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2RybV9kZWJ1Z2ZzX2NyYy5jCj4gIGNyZWF0 ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2RybS9kcm1fZGVidWdmc19jcmMuaAo+IAo+IGRpZmYgLS1n aXQgYS9Eb2N1bWVudGF0aW9uL2dwdS9kcm0tdWFwaS5yc3QgYi9Eb2N1bWVudGF0aW9uL2dwdS9k cm0tdWFwaS5yc3QKPiBpbmRleCA1MzZiZjNlYWFkZDQuLjMzZjc3ODY5NmNjZCAxMDA2NDQKPiAt LS0gYS9Eb2N1bWVudGF0aW9uL2dwdS9kcm0tdWFwaS5yc3QKPiArKysgYi9Eb2N1bWVudGF0aW9u L2dwdS9kcm0tdWFwaS5yc3QKPiBAQCAtMTA5LDMgKzEwOSw5IEBAIGludGVyZmFjZXMuIEVzcGVj aWFsbHkgc2luY2UgYWxsIGhhcmR3YXJlLWFjY2VsZXJhdGlvbiBpbnRlcmZhY2VzIHRvCj4gIHVz ZXJzcGFjZSBhcmUgZHJpdmVyIHNwZWNpZmljIGZvciBlZmZpY2llbmN5IGFuZCBvdGhlciByZWFz b25zIHRoZXNlCj4gIGludGVyZmFjZXMgY2FuIGJlIHJhdGhlciBzdWJzdGFudGlhbC4gSGVuY2Ug ZXZlcnkgZHJpdmVyIGhhcyBpdHMgb3duCj4gIGNoYXB0ZXIuCj4gKwo+ICtUZXN0aW5nIGFuZCB2 YWxpZGF0aW9uCj4gKz09PT09PT09PT09PT09PT09PT09PT0KPiArCj4gKy4uIGtlcm5lbC1kb2M6 OiBkcml2ZXJzL2dwdS9kcm0vZHJtX2RlYnVnZnNfY3JjLmMKPiArICAgOmRvYzogQ1JDIEFCSQo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0v TWFrZWZpbGUKPiBpbmRleCBlM2RiYTZmNDRhNzkuLmI1M2I1YWFhZWI0ZCAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vTWFrZWZp bGUKPiBAQCAtMTIsNyArMTIsOCBAQCBkcm0teSAgICAgICA6PQlkcm1fYXV0aC5vIGRybV9idWZz Lm8gZHJtX2NhY2hlLm8gXAo+ICAJCWRybV9pbmZvLm8gZHJtX2RlYnVnZnMubyBkcm1fZW5jb2Rl cl9zbGF2ZS5vIFwKPiAgCQlkcm1fdHJhY2VfcG9pbnRzLm8gZHJtX2dsb2JhbC5vIGRybV9wcmlt ZS5vIFwKPiAgCQlkcm1fcmVjdC5vIGRybV92bWFfbWFuYWdlci5vIGRybV9mbGlwX3dvcmsubyBc Cj4gLQkJZHJtX21vZGVzZXRfbG9jay5vIGRybV9hdG9taWMubyBkcm1fYnJpZGdlLm8KPiArCQlk cm1fbW9kZXNldF9sb2NrLm8gZHJtX2F0b21pYy5vIGRybV9icmlkZ2UubyBcCj4gKwkJZHJtX2Rl YnVnZnNfY3JjLm8KPiAgCj4gIGRybS0kKENPTkZJR19DT01QQVQpICs9IGRybV9pb2MzMi5vCj4g IGRybS0kKENPTkZJR19EUk1fR0VNX0NNQV9IRUxQRVIpICs9IGRybV9nZW1fY21hX2hlbHBlci5v Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fY3J0Yy5jIGIvZHJpdmVycy9ncHUv ZHJtL2RybV9jcnRjLmMKPiBpbmRleCAxMGI3M2Y2OGMwMjMuLjA4NzM0NWFmOTZlNyAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2NydGMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9kcm1fY3J0Yy5jCj4gQEAgLTQwLDYgKzQwLDcgQEAKPiAgI2luY2x1ZGUgPGRybS9kcm1fbW9k ZXNldF9sb2NrLmg+Cj4gICNpbmNsdWRlIDxkcm0vZHJtX2F0b21pYy5oPgo+ICAjaW5jbHVkZSA8 ZHJtL2RybV9hdXRoLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX2RlYnVnZnNfY3JjLmg+Cj4gIAo+ ICAjaW5jbHVkZSAiZHJtX2NydGNfaW50ZXJuYWwuaCIKPiAgI2luY2x1ZGUgImRybV9pbnRlcm5h bC5oIgo+IEBAIC03MzgsNiArNzM5LDEyIEBAIGludCBkcm1fY3J0Y19pbml0X3dpdGhfcGxhbmVz KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKPiAgCWlmIChj dXJzb3IpCj4gIAkJY3Vyc29yLT5wb3NzaWJsZV9jcnRjcyA9IDEgPDwgZHJtX2NydGNfaW5kZXgo Y3J0Yyk7Cj4gIAo+ICsjaWZkZWYgQ09ORklHX0RFQlVHX0ZTCj4gKwlzcGluX2xvY2tfaW5pdCgm Y3J0Yy0+Y3JjLmxvY2spOwo+ICsJaW5pdF93YWl0cXVldWVfaGVhZCgmY3J0Yy0+Y3JjLndxKTsK PiArCWNydGMtPmNyYy5zb3VyY2UgPSBrc3RyZHVwKCJhdXRvIiwgR0ZQX0tFUk5FTCk7Cj4gKyNl bmRpZgo+ICsKPiAgCWlmIChkcm1fY29yZV9jaGVja19mZWF0dXJlKGRldiwgRFJJVkVSX0FUT01J QykpIHsKPiAgCQlkcm1fb2JqZWN0X2F0dGFjaF9wcm9wZXJ0eSgmY3J0Yy0+YmFzZSwgY29uZmln LT5wcm9wX2FjdGl2ZSwgMCk7Cj4gIAkJZHJtX29iamVjdF9hdHRhY2hfcHJvcGVydHkoJmNydGMt PmJhc2UsIGNvbmZpZy0+cHJvcF9tb2RlX2lkLCAwKTsKPiBAQCAtNzY0LDYgKzc3MSwxMSBAQCB2 b2lkIGRybV9jcnRjX2NsZWFudXAoc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ICAJICogdGhlIGlu ZGljZXMgb24gdGhlIGRybV9jcnRjIGFmdGVyIHVzIGluIHRoZSBjcnRjX2xpc3QuCj4gIAkgKi8K PiAgCj4gKyNpZmRlZiBDT05GSUdfREVCVUdfRlMKPiArCWRybV9kZWJ1Z2ZzX2NydGNfcmVtb3Zl KGNydGMpOwo+ICsJa2ZyZWUoY3J0Yy0+Y3JjLnNvdXJjZSk7Cj4gKyNlbmRpZgo+ICsKPiAgCWtm cmVlKGNydGMtPmdhbW1hX3N0b3JlKTsKPiAgCWNydGMtPmdhbW1hX3N0b3JlID0gTlVMTDsKPiAg Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fZGVidWdmcy5jIGIvZHJpdmVycy9n cHUvZHJtL2RybV9kZWJ1Z2ZzLmMKPiBpbmRleCBmYTEwY2VmMmJhMzcuLjczNTMwY2JmMTMxNiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2RlYnVnZnMuYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fZGVidWdmcy5jCj4gQEAgLTQxNSw1ICs0MTUsMzkgQEAgdm9pZCBkcm1f ZGVidWdmc19jb25uZWN0b3JfcmVtb3ZlKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3Ip Cj4gIAljb25uZWN0b3ItPmRlYnVnZnNfZW50cnkgPSBOVUxMOwo+ICB9Cj4gIAo+IC0jZW5kaWYg LyogQ09ORklHX0RFQlVHX0ZTICovCj4gK2ludCBkcm1fZGVidWdmc19jcnRjX2FkZChzdHJ1Y3Qg ZHJtX2NydGMgKmNydGMpCj4gK3sKPiArCXN0cnVjdCBkcm1fbWlub3IgKm1pbm9yID0gY3J0Yy0+ ZGV2LT5wcmltYXJ5Owo+ICsJc3RydWN0IGRlbnRyeSAqcm9vdDsKPiArCWNoYXIgKm5hbWU7Cj4g Kwo+ICsJbmFtZSA9IGthc3ByaW50ZihHRlBfS0VSTkVMLCAiY3J0Yy0lZCIsIGNydGMtPmluZGV4 KTsKPiArCWlmICghbmFtZSkKPiArCQlyZXR1cm4gLUVOT01FTTsKPiAgCj4gKwlyb290ID0gZGVi dWdmc19jcmVhdGVfZGlyKG5hbWUsIG1pbm9yLT5kZWJ1Z2ZzX3Jvb3QpOwo+ICsJa2ZyZWUobmFt ZSk7Cj4gKwlpZiAoIXJvb3QpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJY3J0Yy0+ZGVi dWdmc19lbnRyeSA9IHJvb3Q7Cj4gKwo+ICsJaWYgKGRybV9kZWJ1Z2ZzX2NydGNfY3JjX2FkZChj cnRjKSkKPiArCQlnb3RvIGVycm9yOwo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZXJyb3I6Cj4g KwlkZWJ1Z2ZzX3JlbW92ZV9yZWN1cnNpdmUoY3J0Yy0+ZGVidWdmc19lbnRyeSk7Cj4gKwljcnRj LT5kZWJ1Z2ZzX2VudHJ5ID0gTlVMTDsKPiArCXJldHVybiAtRU5PTUVNOwo+ICt9Cj4gKwo+ICt2 b2lkIGRybV9kZWJ1Z2ZzX2NydGNfcmVtb3ZlKHN0cnVjdCBkcm1fY3J0YyAqY3J0YykKPiArewo+ ICsJZGVidWdmc19yZW1vdmVfcmVjdXJzaXZlKGNydGMtPmRlYnVnZnNfZW50cnkpOwo+ICsKPiAr CWNydGMtPmRlYnVnZnNfZW50cnkgPSBOVUxMOwo+ICt9Cj4gKwo+ICsjZW5kaWYgLyogQ09ORklH X0RFQlVHX0ZTICovCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fZGVidWdmc19j cmMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZGVidWdmc19jcmMuYwo+IG5ldyBmaWxlIG1vZGUg MTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi41ZWYwNzE0Mzc5NTIKPiAtLS0gL2Rldi9udWxs Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9kZWJ1Z2ZzX2NyYy5jCj4gQEAgLTAsMCArMSwz NzAgQEAKPiArLyoKPiArICogQ29weXJpZ2h0IMKpIDIwMDggSW50ZWwgQ29ycG9yYXRpb24KPiAr ICogQ29weXJpZ2h0IMKpIDIwMTYgQ29sbGFib3JhIEx0ZAo+ICsgKgo+ICsgKiBQZXJtaXNzaW9u IGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5p bmcgYQo+ICsgKiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRh dGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLAo+ICsgKiB0byBkZWFsIGluIHRoZSBTb2Z0d2Fy ZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCj4gKyAq IHRoZSByaWdodHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmli dXRlLCBzdWJsaWNlbnNlLAo+ICsgKiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJl LCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUKPiArICogU29mdHdhcmUgaXMgZnVy bmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKPiAr ICoKPiArICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBu b3RpY2UgKGluY2x1ZGluZyB0aGUgbmV4dAo+ICsgKiBwYXJhZ3JhcGgpIHNoYWxsIGJlIGluY2x1 ZGVkIGluIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlCj4gKyAqIFNv ZnR3YXJlLgo+ICsgKgo+ICsgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lU SE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgo+ICsgKiBJTVBMSUVELCBJTkNM VURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSwKPiArICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdF TUVOVC4gIElOIE5PIEVWRU5UIFNIQUxMCj4gKyAqIFRIRSBBVVRIT1JTIE9SIENPUFlSSUdIVCBI T0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCj4gKyAqIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJX SVNFLCBBUklTSU5HCj4gKyAqIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhF IFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MKPiArICogSU4gVEhFIFNPRlRX QVJFLgo+ICsgKgo+ICsgKiBBdXRob3JzOgo+ICsgKiAgICBFcmljIEFuaG9sdCA8ZXJpY0Bhbmhv bHQubmV0Pgo+ICsgKiAgICBLZWl0aCBQYWNrYXJkIDxrZWl0aHBAa2VpdGhwLmNvbT4KPiArICoK PiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvY2lyY19idWYuaD4KPiArI2luY2x1ZGUgPGxp bnV4L2N0eXBlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9kZWJ1Z2ZzLmg+Cj4gKyNpbmNsdWRlIDxk cm0vZHJtUC5oPgo+ICsKPiArLyoqCj4gKyAqIERPQzogQ1JDIEFCSQo+ICsgKgo+ICsgKiBEUk0g ZGV2aWNlIGRyaXZlcnMgY2FuIHByb3ZpZGUgdG8gdXNlcnNwYWNlIENSQyBpbmZvcm1hdGlvbiBv ZiBlYWNoIGZyYW1lIGFzCj4gKyAqIGl0IHJlYWNoZWQgYSBnaXZlbiBoYXJkd2FyZSBjb21wb25l bnQgKGEgInNvdXJjZSIpLgo+ICsgKgo+ICsgKiBVc2Vyc3BhY2UgY2FuIGNvbnRyb2wgZ2VuZXJh dGlvbiBvZiBDUkNzIGluIGEgZ2l2ZW4gQ1JUQyBieSB3cml0aW5nIHRvIHRoZQo+ICsgKiBmaWxl IGRyaS8wL2NydGMtTi9jcmMvY29udHJvbCBpbiBkZWJ1Z2ZzLCB3aXRoIE4gYmVpbmcgdGhlIGlu ZGV4IG9mIHRoZSBDUlRDLgo+ICsgKiBBY2NlcHRlZCB2YWx1ZXMgYXJlIHNvdXJjZSBuYW1lcyAo d2hpY2ggYXJlIGRyaXZlci1zcGVjaWZpYykgYW5kIHRoZSAibm9uZSIKPiArICogYW5kICJhdXRv IiBrZXl3b3Jkcy4gIm5vbmUiIHdpbGwgZGlzYWJsZSBDUkMgZ2VuZXJhdGlvbiBhbmQgImF1dG8i IHdpbGwgbGV0Cj4gKyAqIHRoZSBkcml2ZXIgc2VsZWN0IGEgZGVmYXVsdCBzb3VyY2Ugb2YgZnJh bWUgQ1JDcyBmb3IgdGhpcyBDUlRDLgo+ICsgKgo+ICsgKiBPbmNlIGZyYW1lIENSQyBnZW5lcmF0 aW9uIGlzIGVuYWJsZWQsIHVzZXJzcGFjZSBjYW4gY2FwdHVyZSB0aGVtIGJ5IHJlYWRpbmcKPiAr ICogdGhlIGRyaS8wL2NydGMtTi9jcmMvZGF0YSBmaWxlLiBFYWNoIGxpbmUgaW4gdGhhdCBmaWxl IGNvbnRhaW5zIHRoZSBmcmFtZQo+ICsgKiBudW1iZXIgaW4gdGhlIGZpcnN0IGZpZWxkIGFuZCB0 aGVuIGEgbnVtYmVyIG9mIHVuc2lnbmVkIGludGVnZXIgZmllbGRzCj4gKyAqIGNvbnRhaW5pbmcg dGhlIENSQyBkYXRhLiBGaWVsZHMgYXJlIHNlcGFyYXRlZCBieSBhIHNpbmdsZSBzcGFjZSBhbmQg dGhlIG51bWJlcgo+ICsgKiBvZiBDUkMgZmllbGRzIGlzIHNvdXJjZS1zcGVjaWZpYy4KPiArICoK PiArICogTm90ZSB0aGF0IHRob3VnaCBpbiBzb21lIGNhc2VzIHRoZSBDUkMgaXMgY29tcHV0ZWQg aW4gYSBzcGVjaWZpZWQgd2F5IGFuZCBvbgo+ICsgKiB0aGUgZnJhbWUgY29udGVudHMgYXMgc3Vw cGxpZWQgYnkgdXNlcnNwYWNlIChlRFAgMS4zKSwgaW4gZ2VuZXJhbCB0aGUgQ1JDCj4gKyAqIGNv bXB1dGF0aW9uIGlzIHBlcmZvcm1lZCBpbiBhbiB1bnNwZWNpZmllZCB3YXkgYW5kIG9uIGZyYW1l IGNvbnRlbnRzIHRoYXQgaGF2ZQo+ICsgKiBiZWVuIGFscmVhZHkgcHJvY2Vzc2VkIGluIGFsc28g YW4gdW5zcGVjaWZpZWQgd2F5IGFuZCB0aHVzIHVzZXJzcGFjZSBjYW5ub3QKPiArICogcmVseSBv biBiZWluZyBhYmxlIHRvIGdlbmVyYXRlIG1hdGNoaW5nIENSQyB2YWx1ZXMgZm9yIHRoZSBmcmFt ZSBjb250ZW50cyB0aGF0Cj4gKyAqIGl0IHN1Ym1pdHMuIEluIHRoaXMgZ2VuZXJhbCBjYXNlLCB0 aGUgbWF4aW11bSB1c2Vyc3BhY2UgY2FuIGRvIGlzIHRvIGNvbXBhcmUKPiArICogdGhlIHJlcG9y dGVkIENSQ3Mgb2YgZnJhbWVzIHRoYXQgc2hvdWxkIGhhdmUgdGhlIHNhbWUgY29udGVudHMuCj4g KyAqLwo+ICsjaWYgZGVmaW5lZChDT05GSUdfREVCVUdfRlMpCj4gKwo+ICtzdGF0aWMgaW50IGNy Y19jb250cm9sX3Nob3coc3RydWN0IHNlcV9maWxlICptLCB2b2lkICpkYXRhKQo+ICt7Cj4gKwlz dHJ1Y3QgZHJtX2NydGMgKmNydGMgPSBtLT5wcml2YXRlOwo+ICsKPiArCXNlcV9wcmludGYobSwg IiVzXG4iLCBjcnRjLT5jcmMuc291cmNlKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAr c3RhdGljIGludCBjcmNfY29udHJvbF9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBm aWxlICpmaWxlKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSBpbm9kZS0+aV9wcml2 YXRlOwo+ICsKPiArCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBjcmNfY29udHJvbF9zaG93LCBj cnRjKTsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgY3JjX2NvbnRyb2xfd3JpdGUoc3RydWN0 IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICp1YnVmLAo+ICsJCQkJIHNpemVfdCBsZW4s IGxvZmZfdCAqb2ZmcCkKPiArewo+ICsJc3RydWN0IHNlcV9maWxlICptID0gZmlsZS0+cHJpdmF0 ZV9kYXRhOwo+ICsJc3RydWN0IGRybV9jcnRjICpjcnRjID0gbS0+cHJpdmF0ZTsKPiArCXN0cnVj dCBkcm1fY3J0Y19jcmMgKmNyYyA9ICZjcnRjLT5jcmM7Cj4gKwljaGFyICpzb3VyY2U7Cj4gKwo+ ICsJaWYgKGxlbiA9PSAwKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCWlmIChsZW4gPiBQQUdFX1NJ WkUgLSAxKSB7Cj4gKwkJRFJNX0RFQlVHX0tNUygiRXhwZWN0ZWQgPCAlbHUgYnl0ZXMgaW50byBj cnRjIGNyYyBjb250cm9sXG4iLAo+ICsJCQkgICAgICBQQUdFX1NJWkUpOwo+ICsJCXJldHVybiAt RTJCSUc7Cj4gKwl9Cj4gKwo+ICsJc291cmNlID0ga21hbGxvYyhsZW4gKyAxLCBHRlBfS0VSTkVM KTsKPiArCWlmICghc291cmNlKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWlmIChjb3B5 X2Zyb21fdXNlcihzb3VyY2UsIHVidWYsIGxlbikpIHsKPiArCQlrZnJlZShzb3VyY2UpOwo+ICsJ CXJldHVybiAtRUZBVUxUOwo+ICsJfQoKbWVtZHVwX3VzZXJfbnVsKCkgPwoKPiArCj4gKwlpZiAo c291cmNlW2xlbiAtIDFdID09ICdcbicpCj4gKwkJc291cmNlW2xlbiAtIDFdID0gJ1wwJzsKPiAr CWVsc2UKPiArCQlzb3VyY2VbbGVuXSA9ICdcMCc7Cj4gKwo+ICsJc3Bpbl9sb2NrX2lycSgmY3Jj LT5sb2NrKTsKPiArCj4gKwlpZiAoY3JjLT5vcGVuZWQpIHsKPiArCQlrZnJlZShzb3VyY2UpOwo+ ICsJCXJldHVybiAtRUJVU1k7Cj4gKwl9CgpXaHkgbm90IGp1c3Qgc3RhcnQgdGhlIHRoaW5nIGhl cmU/Cgo+ICsKPiArCWtmcmVlKGNyYy0+c291cmNlKTsKPiArCWNyYy0+c291cmNlID0gc291cmNl Owo+ICsKPiArCXNwaW5fdW5sb2NrX2lycSgmY3JjLT5sb2NrKTsKPiArCj4gKwkqb2ZmcCArPSBs ZW47Cj4gKwlyZXR1cm4gbGVuOwo+ICt9Cj4gKwo+ICtjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRp b25zIGRybV9jcnRjX2NyY19jb250cm9sX2ZvcHMgPSB7Cj4gKwkub3duZXIgPSBUSElTX01PRFVM RSwKPiArCS5vcGVuID0gY3JjX2NvbnRyb2xfb3BlbiwKPiArCS5yZWFkID0gc2VxX3JlYWQsCj4g KwkubGxzZWVrID0gc2VxX2xzZWVrLAo+ICsJLnJlbGVhc2UgPSBzaW5nbGVfcmVsZWFzZSwKPiAr CS53cml0ZSA9IGNyY19jb250cm9sX3dyaXRlCj4gK307Cj4gKwo+ICtzdGF0aWMgaW50IGNydGNf Y3JjX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGVwKQo+ICt7Cj4g KwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSBpbm9kZS0+aV9wcml2YXRlOwo+ICsJc3RydWN0IGRy bV9jcnRjX2NyYyAqY3JjID0gJmNydGMtPmNyYzsKPiArCXN0cnVjdCBkcm1fY3J0Y19jcmNfZW50 cnkgKmVudHJpZXMgPSBOVUxMOwo+ICsJc2l6ZV90IGVudHJ5X3NpemUsIHZhbHVlc19jbnQ7Cj4g KwlpbnQgcmV0Owo+ICsKPiArCWlmIChjcmMtPm9wZW5lZCkKPiArCQlyZXR1cm4gLUVCVVNZOwo+ ICsKPiArCXJldCA9IGNydGMtPmZ1bmNzLT5zZXRfY3JjX3NvdXJjZShjcnRjLCBjcmMtPnNvdXJj ZSwgJnZhbHVlc19jbnQpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWlm IChXQVJOX09OKHZhbHVlc19jbnQgPiBEUk1fTUFYX0NSQ19OUikpIHsKPiArCQlyZXQgPSAtRUlO VkFMOwo+ICsJCWdvdG8gZXJyX2Rpc2FibGU7Cj4gKwl9Cj4gKwo+ICsJaWYgKFdBUk5fT04odmFs dWVzX2NudCA9PSAwKSkgewo+ICsJCXJldCA9IC1FSU5WQUw7Cj4gKwkJZ290byBlcnJfZGlzYWJs ZTsKPiArCX0KPiArCj4gKwllbnRyeV9zaXplID0gc2l6ZW9mKCpjcmMtPmVudHJpZXMpICsgc2l6 ZW9mKHVpbnQzMl90KSAqIHZhbHVlc19jbnQ7Cj4gKwllbnRyaWVzID0ga2NhbGxvYyhEUk1fQ1JD X0VOVFJJRVNfTlIsIGVudHJ5X3NpemUsIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFlbnRyaWVzKSB7 Cj4gKwkJcmV0ID0gLUVOT01FTTsKPiArCQlnb3RvIGVycl9kaXNhYmxlOwo+ICsJfQo+ICsKPiAr CXNwaW5fbG9ja19pcnEoJmNyYy0+bG9jayk7Cj4gKwljcmMtPmVudHJpZXMgPSBlbnRyaWVzOwo+ ICsJY3JjLT52YWx1ZXNfY250ID0gdmFsdWVzX2NudDsKPiArCWNyYy0+b3BlbmVkID0gdHJ1ZTsK PiArCXNwaW5fdW5sb2NrX2lycSgmY3JjLT5sb2NrKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArCj4g K2Vycl9kaXNhYmxlOgo+ICsJY3J0Yy0+ZnVuY3MtPnNldF9jcmNfc291cmNlKGNydGMsIE5VTEws ICZ2YWx1ZXNfY250KTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgY3J0 Y19jcmNfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZXApCj4g K3sKPiArCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9IGZpbGVwLT5mX2lub2RlLT5pX3ByaXZhdGU7 Cj4gKwlzdHJ1Y3QgZHJtX2NydGNfY3JjICpjcmMgPSAmY3J0Yy0+Y3JjOwo+ICsJc2l6ZV90IHZh bHVlc19jbnQ7Cj4gKwo+ICsJY3J0Yy0+ZnVuY3MtPnNldF9jcmNfc291cmNlKGNydGMsIE5VTEws ICZ2YWx1ZXNfY250KTsKPiArCj4gKwlzcGluX2xvY2tfaXJxKCZjcmMtPmxvY2spOwo+ICsJa2Zy ZWUoY3JjLT5lbnRyaWVzKTsKPiArCWNyYy0+ZW50cmllcyA9IE5VTEw7Cj4gKwljcmMtPmhlYWQg PSAwOwo+ICsJY3JjLT50YWlsID0gMDsKPiArCWNyYy0+dmFsdWVzX2NudCA9IDA7Cj4gKwljcmMt Pm9wZW5lZCA9IGZhbHNlOwo+ICsJc3Bpbl91bmxvY2tfaXJxKCZjcmMtPmxvY2spOwo+ICsKPiAr CXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNydGNfY3JjX2RhdGFfY291bnQoc3Ry dWN0IGRybV9jcnRjX2NyYyAqY3JjKQo+ICt7Cj4gKwlhc3NlcnRfc3Bpbl9sb2NrZWQoJmNyYy0+ bG9jayk7Cj4gKwlyZXR1cm4gQ0lSQ19DTlQoY3JjLT5oZWFkLCBjcmMtPnRhaWwsIERSTV9DUkNf RU5UUklFU19OUik7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgZHJtX2NydGNfY3JjX2VudHJ5 ICpjcnRjX2dldF9jcmNfZW50cnkoc3RydWN0IGRybV9jcnRjX2NyYyAqY3JjLAo+ICsJCQkJCQkg ICAgIGludCBpbmRleCkKPiArewo+ICsJdm9pZCAqcCA9IGNyYy0+ZW50cmllczsKPiArCXNpemVf dCBlbnRyeV9zaXplID0gKHNpemVvZigqY3JjLT5lbnRyaWVzKSArCj4gKwkJCSAgICAgc2l6ZW9m KCpjcmMtPmVudHJpZXNbMF0uY3JjcykgKiBjcmMtPnZhbHVlc19jbnQpOwoKVGhpcyBjb21wdXRh dGlvbiBpcyBkdXBsaWNhdGVkIGFsc28gaW4gY3J0Y19jcmNfb3BlbigpLiBjb3VsZCB1c2UgYQpj b21tb24gaGVscGVyIHRvIGRvIGl0LgoKU2hhbWUgdGhlIGxhbmd1YWdlIGRvZXNuJ3QgaGF2ZSBh IHdheSB0byBkZWFsIHdpdGggYXJyYXlzIG9mIHZhcmlhYmxlCnNpemVkIGFycmF5cyBpbiBhIG5p Y2Ugd2F5LgoKPiArCj4gKwlyZXR1cm4gcCArIGVudHJ5X3NpemUgKiBpbmRleDsKPiArfQo+ICsK PiArI2RlZmluZSBNQVhfTElORV9MRU4gKDggKyA5ICogRFJNX01BWF9DUkNfTlIgKyAxICsgMSkK PiArCj4gK3N0YXRpYyBzc2l6ZV90IGNydGNfY3JjX3JlYWQoc3RydWN0IGZpbGUgKmZpbGVwLCBj aGFyIF9fdXNlciAqdXNlcl9idWYsCj4gKwkJCSAgICAgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBv cykKPiArewo+ICsJc3RydWN0IGRybV9jcnRjICpjcnRjID0gZmlsZXAtPmZfaW5vZGUtPmlfcHJp dmF0ZTsKPiArCXN0cnVjdCBkcm1fY3J0Y19jcmMgKmNyYyA9ICZjcnRjLT5jcmM7Cj4gKwlzdHJ1 Y3QgZHJtX2NydGNfY3JjX2VudHJ5ICplbnRyeTsKPiArCWNoYXIgYnVmW01BWF9MSU5FX0xFTl07 Cj4gKwlpbnQgcmV0LCBpOwo+ICsKPiArCXNwaW5fbG9ja19pcnEoJmNyYy0+bG9jayk7Cj4gKwo+ ICsJaWYgKCFjcmMtPnNvdXJjZSkgewo+ICsJCXNwaW5fdW5sb2NrX2lycSgmY3JjLT5sb2NrKTsK PiArCQlyZXR1cm4gMDsKPiArCX0KPiArCj4gKwkvKiBOb3RoaW5nIHRvIHJlYWQ/ICovCj4gKwl3 aGlsZSAoY3J0Y19jcmNfZGF0YV9jb3VudChjcmMpID09IDApIHsKPiArCQlpZiAoZmlsZXAtPmZf ZmxhZ3MgJiBPX05PTkJMT0NLKSB7Cj4gKwkJCXNwaW5fdW5sb2NrX2lycSgmY3JjLT5sb2NrKTsK PiArCQkJcmV0dXJuIC1FQUdBSU47Cj4gKwkJfQo+ICsKPiArCQlyZXQgPSB3YWl0X2V2ZW50X2lu dGVycnVwdGlibGVfbG9ja19pcnEoY3JjLT53cSwKPiArCQkJCQkJCWNydGNfY3JjX2RhdGFfY291 bnQoY3JjKSwKPiArCQkJCQkJCWNyYy0+bG9jayk7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlzcGlu X3VubG9ja19pcnEoJmNyYy0+bG9jayk7Cj4gKwkJCXJldHVybiByZXQ7Cj4gKwkJfQo+ICsJfQo+ ICsKPiArCS8qIFdlIGtub3cgd2UgaGF2ZSBhbiBlbnRyeSB0byBiZSByZWFkICovCj4gKwllbnRy eSA9IGNydGNfZ2V0X2NyY19lbnRyeShjcmMsIGNyYy0+dGFpbCk7Cj4gKwo+ICsJLyoKPiArCSAq IDEgZnJhbWUgZmllbGQgb2YgOCBjaGFycyBwbHVzIGEgbnVtYmVyIG9mIENSQyBmaWVsZHMgb2Yg OAo+ICsJICogY2hhcnMgZWFjaCwgc3BhY2Ugc2VwYXJhdGVkIGFuZCB3aXRoIGEgbmV3bGluZSBh dCB0aGUgZW5kLgo+ICsJICovCj4gKwlpZiAoY291bnQgPCA4ICsgOSAqIGNyYy0+dmFsdWVzX2Nu dCArIDEgKyAxKSB7CgpKdXN0IDwgTUFYX0xJTkVfTEVOIHBlcmhhcHM/IE9yIGNvdWxkIG1ha2Ug YSBtYWNyby9mdW5jdGlvbiB0aGF0IHRha2VzCmNyYy0+dmFsdWVzX2NudCBvciBEUk1fTUFYX0NS Q19OUiBhcyBhbiBhcmd1bWVudC4KCj4gKwkJc3Bpbl91bmxvY2tfaXJxKCZjcmMtPmxvY2spOwo+ ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCUJVSUxEX0JVR19PTl9OT1RfUE9XRVJf T0ZfMihEUk1fQ1JDX0VOVFJJRVNfTlIpOwo+ICsJY3JjLT50YWlsID0gKGNyYy0+dGFpbCArIDEp ICYgKERSTV9DUkNfRU5UUklFU19OUiAtIDEpOwo+ICsKPiArCXNwaW5fdW5sb2NrX2lycSgmY3Jj LT5sb2NrKTsKPiArCj4gKwlpZiAoZW50cnktPmhhc19mcmFtZV9jb3VudGVyKQo+ICsJCXNucHJp bnRmKGJ1ZiwgOSwgIiUwOHgiLCBlbnRyeS0+ZnJhbWUpOwo+ICsJZWxzZQo+ICsJCXNucHJpbnRm KGJ1ZiwgOSwgIlhYWFhYWFhYIik7CgpTaG91bGQgd2UgYWRkICIweCIgcHJlZml4IHRvIGFsbCB0 aGVzZSBudW1iZXJzIHRvIG1ha2UgaXQgY2xlYXIgdGhhdAp0aGV5J3JlIGluIGZhY3QgaGV4PwoK PiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgY3JjLT52YWx1ZXNfY250OyBpKyspCj4gKwkJc25wcmlu dGYoYnVmICsgc3RybGVuKGJ1ZiksIDEwLCAiICUwOHgiLCBlbnRyeS0+Y3Jjc1tpXSk7CgpUaGUg J24nIGluIHNucHJpbnRmKCkgaGVyZSBzZWVtcyBwb2ludGxlc3MuIEFzIGRvZXMgdGhlIHN0cmxl bigpLgoKPiArCXNucHJpbnRmKGJ1ZiArIHN0cmxlbihidWYpLCAyLCAiXG4iKTsKPiArCj4gKwlp ZiAoY29weV90b191c2VyKHVzZXJfYnVmLCBidWYsIHN0cmxlbihidWYpICsgMSkpCj4gKwkJcmV0 dXJuIC1FRkFVTFQ7Cj4gKwo+ICsJcmV0dXJuIHN0cmxlbihidWYpICsgMTsKCk1vcmUgc3RybGVu KClzIHRoYXQgc2hvdWxkbid0IGJlIG5lZWRlZC4KCj4gK30KPiArCj4gK2NvbnN0IHN0cnVjdCBm aWxlX29wZXJhdGlvbnMgZHJtX2NydGNfY3JjX2RhdGFfZm9wcyA9IHsKPiArCS5vd25lciA9IFRI SVNfTU9EVUxFLAo+ICsJLm9wZW4gPSBjcnRjX2NyY19vcGVuLAo+ICsJLnJlYWQgPSBjcnRjX2Ny Y19yZWFkLAo+ICsJLnJlbGVhc2UgPSBjcnRjX2NyY19yZWxlYXNlLAo+ICt9Owo+ICsKPiArLyoq Cj4gKyAqIGRybV9kZWJ1Z2ZzX2NydGNfY3JjX2FkZCAtIEFkZCBmaWxlcyB0byBkZWJ1Z2ZzIGZv ciBjYXB0dXJlIG9mIGZyYW1lIENSQ3MKPiArICogQGNydGM6IENSVEMgdG8gd2hvbSB0aGUgZnJh bWVzIHdpbGwgYmVsb25nCj4gKyAqCj4gKyAqIEFkZHMgZmlsZXMgdG8gZGVidWdmcyBkaXJlY3Rv cnkgdGhhdCBhbGxvd3MgdXNlcnNwYWNlIHRvIGNvbnRyb2wgdGhlCj4gKyAqIGdlbmVyYXRpb24g b2YgZnJhbWUgQ1JDcyBhbmQgdG8gcmVhZCB0aGVtLgo+ICsgKgo+ICsgKiBSZXR1cm5zOgo+ICsg KiBaZXJvIG9uIHN1Y2Nlc3MsIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiArICovCj4gK2ludCBk cm1fZGVidWdmc19jcnRjX2NyY19hZGQoc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ICt7Cj4gKwlz dHJ1Y3QgZGVudHJ5ICpjcmNfZW50LCAqZW50Owo+ICsKPiArCWlmICghY3J0Yy0+ZnVuY3MtPnNl dF9jcmNfc291cmNlKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCWNyY19lbnQgPSBkZWJ1Z2ZzX2Ny ZWF0ZV9kaXIoImNyYyIsIGNydGMtPmRlYnVnZnNfZW50cnkpOwo+ICsJaWYgKCFjcmNfZW50KQo+ ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoImNv bnRyb2wiLCBTX0lSVUdPLCBjcmNfZW50LCBjcnRjLAo+ICsJCQkJICAmZHJtX2NydGNfY3JjX2Nv bnRyb2xfZm9wcyk7Cj4gKwlpZiAoIWVudCkKPiArCQlnb3RvIGVycm9yOwo+ICsKPiArCWVudCA9 IGRlYnVnZnNfY3JlYXRlX2ZpbGUoImRhdGEiLCBTX0lSVUdPLCBjcmNfZW50LCBjcnRjLAo+ICsJ CQkJICAmZHJtX2NydGNfY3JjX2RhdGFfZm9wcyk7Cj4gKwlpZiAoIWVudCkKPiArCQlnb3RvIGVy cm9yOwo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZXJyb3I6Cj4gKwlkZWJ1Z2ZzX3JlbW92ZV9y ZWN1cnNpdmUoY3JjX2VudCk7Cj4gKwo+ICsJcmV0dXJuIC1FTk9NRU07Cj4gK30KPiArCj4gKy8q Kgo+ICsgKiBkcm1fY3J0Y19hZGRfY3JjX2VudHJ5IC0gQWRkIGVudHJ5IHdpdGggQ1JDIGluZm9y bWF0aW9uIGZvciBhIGZyYW1lCj4gKyAqIEBjcnRjOiBDUlRDIHRvIHdoaWNoIHRoZSBmcmFtZSBi ZWxvbmdzCj4gKyAqIEBoYXNfZnJhbWU6IHdoZXRoZXIgdGhpcyBlbnRyeSBoYXMgYSBmcmFtZSBu dW1iZXIgdG8gZ28gd2l0aAo+ICsgKiBAZnJhbWU6IG51bWJlciBvZiB0aGUgZnJhbWUgdGhlc2Ug Q1JDcyBhcmUgYWJvdXQKPiArICogQGNyY3M6IGFycmF5IG9mIENSQyB2YWx1ZXMsIHdpdGggbGVu Z3RoIG1hdGNoaW5nICNkcm1fY3J0Y19jcmMudmFsdWVzX2NudAo+ICsgKgo+ICsgKiBGb3IgZWFj aCBmcmFtZSwgdGhlIGRyaXZlciBwb2xscyB0aGUgc291cmNlIG9mIENSQ3MgZm9yIG5ldyBkYXRh IGFuZCBjYWxscwo+ICsgKiB0aGlzIGZ1bmN0aW9uIHRvIGFkZCB0aGVtIHRvIHRoZSBidWZmZXIg ZnJvbSB3aGVyZSB1c2Vyc3BhY2UgcmVhZHMuCj4gKyAqLwo+ICtpbnQgZHJtX2NydGNfYWRkX2Ny Y19lbnRyeShzdHJ1Y3QgZHJtX2NydGMgKmNydGMsIGJvb2wgaGFzX2ZyYW1lLAo+ICsJCQkgICB1 aW50MzJfdCBmcmFtZSwgdWludDMyX3QgKmNyY3MpCj4gK3sKPiArCXN0cnVjdCBkcm1fY3J0Y19j cmMgKmNyYyA9ICZjcnRjLT5jcmM7Cj4gKwlzdHJ1Y3QgZHJtX2NydGNfY3JjX2VudHJ5ICplbnRy eTsKPiArCWludCBoZWFkLCB0YWlsOwo+ICsKPiArCWFzc2VydF9zcGluX2xvY2tlZCgmY3JjLT5s b2NrKTsKPiArCj4gKwkvKiBDYWxsZXIgbWF5IG5vdCBoYXZlIG5vdGljZWQgeWV0IHRoYXQgdXNl cnNwYWNlIGhhcyBzdG9wcGVkIHJlYWRpbmcgKi8KPiArCWlmICghY3JjLT5vcGVuZWQpCj4gKwkJ cmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaGVhZCA9IGNyYy0+aGVhZDsKPiArCXRhaWwgPSBjcmMt PnRhaWw7Cj4gKwo+ICsJaWYgKENJUkNfU1BBQ0UoaGVhZCwgdGFpbCwgRFJNX0NSQ19FTlRSSUVT X05SKSA8IDEpIHsKPiArCQlEUk1fRVJST1IoIk92ZXJmbG93IG9mIENSQyBidWZmZXIsIHVzZXJz cGFjZSByZWFkcyB0b28gc2xvdy5cbiIpOwo+ICsJCXJldHVybiAtRU5PQlVGUzsKPiArCX0KPiAr Cj4gKwllbnRyeSA9IGNydGNfZ2V0X2NyY19lbnRyeShjcmMsIGhlYWQpOwo+ICsJZW50cnktPmZy YW1lID0gZnJhbWU7Cj4gKwllbnRyeS0+aGFzX2ZyYW1lX2NvdW50ZXIgPSBoYXNfZnJhbWU7Cj4g KwltZW1jcHkoJmVudHJ5LT5jcmNzLCBjcmNzLCBzaXplb2YoKmNyY3MpICogY3JjLT52YWx1ZXNf Y250KTsKPiArCj4gKwloZWFkID0gKGhlYWQgKyAxKSAmIChEUk1fQ1JDX0VOVFJJRVNfTlIgLSAx KTsKPiArCWNyYy0+aGVhZCA9IGhlYWQ7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArRVhQT1JU X1NZTUJPTF9HUEwoZHJtX2NydGNfYWRkX2NyY19lbnRyeSk7Cj4gKyNlbmRpZiAvKiBDT05GSUdf REVCVUdfRlMgKi8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9kcnYuYyBiL2Ry aXZlcnMvZ3B1L2RybS9kcm1fZHJ2LmMKPiBpbmRleCBhZWFkOWZmY2JlMjkuLmEwMjQwNmY1MWQ5 OCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2Rydi5jCj4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL2RybV9kcnYuYwo+IEBAIC0xOTIsNiArMTkyLDcgQEAgc3RhdGljIHZvaWQgZHJt X21pbm9yX2ZyZWUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHR5cGUpCj4g IHN0YXRpYyBpbnQgZHJtX21pbm9yX3JlZ2lzdGVyKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHVu c2lnbmVkIGludCB0eXBlKQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX21pbm9yICptaW5vcjsKPiArCXN0 cnVjdCBkcm1fY3J0YyAqY3J0YzsKPiAgCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4gIAlpbnQgcmV0 Owo+ICAKPiBAQCAtMjA3LDYgKzIwOCwxNCBAQCBzdGF0aWMgaW50IGRybV9taW5vcl9yZWdpc3Rl cihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgdHlwZSkKPiAgCQlyZXR1cm4g cmV0Owo+ICAJfQo+ICAKPiArCWlmICh0eXBlID09IERSTV9NSU5PUl9MRUdBQ1kpIHsKPiArCQlk cm1fZm9yX2VhY2hfY3J0YyhjcnRjLCBkZXYpIHsKPiArCQkJcmV0ID0gZHJtX2RlYnVnZnNfY3J0 Y19hZGQoY3J0Yyk7Cj4gKwkJCWlmIChyZXQpCj4gKwkJCQlnb3RvIGVycl9kZWJ1Z2ZzOwo+ICsJ CX0KPiArCX0KPiArCj4gIAlyZXQgPSBkZXZpY2VfYWRkKG1pbm9yLT5rZGV2KTsKPiAgCWlmIChy ZXQpCj4gIAkJZ290byBlcnJfZGVidWdmczsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2RybV9pbnRlcm5hbC5oIGIvZHJpdmVycy9ncHUvZHJtL2RybV9pbnRlcm5hbC5oCj4gaW5kZXgg Yjg2ZGM5YjkyMWE1Li45OWNlNmQ0ZjI5MTYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2RybV9pbnRlcm5hbC5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9pbnRlcm5hbC5oCj4g QEAgLTk3LDYgKzk3LDggQEAgaW50IGRybV9kZWJ1Z2ZzX2luaXQoc3RydWN0IGRybV9taW5vciAq bWlub3IsIGludCBtaW5vcl9pZCwKPiAgaW50IGRybV9kZWJ1Z2ZzX2NsZWFudXAoc3RydWN0IGRy bV9taW5vciAqbWlub3IpOwo+ICBpbnQgZHJtX2RlYnVnZnNfY29ubmVjdG9yX2FkZChzdHJ1Y3Qg ZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKTsKPiAgdm9pZCBkcm1fZGVidWdmc19jb25uZWN0b3Jf cmVtb3ZlKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpOwo+ICtpbnQgZHJtX2RlYnVn ZnNfY3J0Y19hZGQoc3RydWN0IGRybV9jcnRjICpjcnRjKTsKPiArdm9pZCBkcm1fZGVidWdmc19j cnRjX3JlbW92ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpOwo+ICAjZWxzZQo+ICBzdGF0aWMgaW5s aW5lIGludCBkcm1fZGVidWdmc19pbml0KHN0cnVjdCBkcm1fbWlub3IgKm1pbm9yLCBpbnQgbWlu b3JfaWQsCj4gIAkJCQkgICBzdHJ1Y3QgZGVudHJ5ICpyb290KQo+IEBAIC0xMTYsNCArMTE4LDEy IEBAIHN0YXRpYyBpbmxpbmUgaW50IGRybV9kZWJ1Z2ZzX2Nvbm5lY3Rvcl9hZGQoc3RydWN0IGRy bV9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgc3RhdGljIGlubGluZSB2b2lkIGRybV9kZWJ1Z2Zz X2Nvbm5lY3Rvcl9yZW1vdmUoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgewo+ ICB9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGludCBkcm1fZGVidWdmc19jcnRjX2FkZChzdHJ1Y3Qg ZHJtX2NydGMgKmNydGMpCj4gK3sKPiArCXJldHVybiAwOwo+ICt9Cj4gK3N0YXRpYyBpbmxpbmUg dm9pZCBkcm1fZGVidWdmc19jcnRjX3JlbW92ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCj4gK3sK PiArfQo+ICAjZW5kaWYKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtUC5oIGIvaW5jbHVk ZS9kcm0vZHJtUC5oCj4gaW5kZXggY2Y5MThlM2U2YWZiLi44YTBiMjM1Y2NjMzkgMTAwNjQ0Cj4g LS0tIGEvaW5jbHVkZS9kcm0vZHJtUC5oCj4gKysrIGIvaW5jbHVkZS9kcm0vZHJtUC5oCj4gQEAg LTExMTEsNiArMTExMSwxMSBAQCBzdGF0aWMgX19pbmxpbmVfXyBib29sIGRybV9jYW5fc2xlZXAo dm9pZCkKPiAgCXJldHVybiB0cnVlOwo+ICB9Cj4gIAo+ICsjaWYgZGVmaW5lZChDT05GSUdfREVC VUdfRlMpCj4gK2V4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGRybV9jcmNfY29u dHJvbF9mb3BzOwo+ICtleHRlcm4gY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBkcm1fY3J0 Y19jcmNfZm9wczsKPiArI2VuZGlmCj4gKwo+ICAvKiBoZWxwZXIgZm9yIGhhbmRsaW5nIGNvbmRp dGlvbmFscyBpbiB2YXJpb3VzIGZvcl9lYWNoIG1hY3JvcyAqLwo+ICAjZGVmaW5lIGZvcl9lYWNo X2lmKGNvbmRpdGlvbikgaWYgKCEoY29uZGl0aW9uKSkge30gZWxzZQo+ICAKPiBkaWZmIC0tZ2l0 IGEvaW5jbHVkZS9kcm0vZHJtX2NydGMuaCBiL2luY2x1ZGUvZHJtL2RybV9jcnRjLmgKPiBpbmRl eCA3ODE2OTVjNzQ1MjguLmZjYzYzMjk0MGRjZSAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2RybS9k cm1fY3J0Yy5oCj4gKysrIGIvaW5jbHVkZS9kcm0vZHJtX2NydGMuaAo+IEBAIC0zNSw2ICszNSw3 IEBACj4gICNpbmNsdWRlIDx1YXBpL2RybS9kcm1fbW9kZS5oPgo+ICAjaW5jbHVkZSA8dWFwaS9k cm0vZHJtX2ZvdXJjYy5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9tb2Rlc2V0X2xvY2suaD4KPiAr I2luY2x1ZGUgPGRybS9kcm1fZGVidWdmc19jcmMuaD4KPiAgCj4gIHN0cnVjdCBkcm1fZGV2aWNl Owo+ICBzdHJ1Y3QgZHJtX21vZGVfc2V0Owo+IEBAIC03MzEsNiArNzMyLDMwIEBAIHN0cnVjdCBk cm1fY3J0Y19mdW5jcyB7Cj4gIAkgKiBiZWZvcmUgZGF0YSBzdHJ1Y3R1cmVzIGFyZSB0b3JuZG93 bi4KPiAgCSAqLwo+ICAJdm9pZCAoKmVhcmx5X3VucmVnaXN0ZXIpKHN0cnVjdCBkcm1fY3J0YyAq Y3J0Yyk7Cj4gKwo+ICsJLyoqCj4gKwkgKiBAc2V0X2NyY19zb3VyY2U6Cj4gKwkgKgo+ICsJICog Q2hhbmdlcyB0aGUgc291cmNlIG9mIENSQyBjaGVja3N1bXMgb2YgZnJhbWVzIGF0IHRoZSByZXF1 ZXN0IG9mCj4gKwkgKiB1c2Vyc3BhY2UsIHR5cGljYWxseSBmb3IgdGVzdGluZyBwdXJwb3Nlcy4g VGhlIHNvdXJjZXMgYXZhaWxhYmxlIGFyZQo+ICsJICogc3BlY2lmaWMgb2YgZWFjaCBkcml2ZXIg YW5kIGEgJU5VTEwgdmFsdWUgaW5kaWNhdGVzIHRoYXQgQ1JDCj4gKwkgKiBnZW5lcmF0aW9uIGlz IHRvIGJlIHN3aXRjaGVkIG9mZi4KPiArCSAqCj4gKwkgKiBXaGVuIENSQyBnZW5lcmF0aW9uIGlz IGVuYWJsZWQsIHRoZSBkcml2ZXIgc2hvdWxkIGNhbGwKPiArCSAqIGRybV9jcnRjX2FkZF9jcmNf ZW50cnkoKSBhdCBlYWNoIGZyYW1lLCBwcm92aWRpbmcgYW55IGluZm9ybWF0aW9uCj4gKwkgKiB0 aGF0IGNoYXJhY3Rlcml6ZXMgdGhlIGZyYW1lIGNvbnRlbnRzIGluIHRoZSBjcmNOIGFyZ3VtZW50 cywgYXMKPiArCSAqIHByb3ZpZGVkIGZyb20gdGhlIGNvbmZpZ3VyZWQgc291cmNlLiBEcml2ZXJz IHNob3VsZCBhY2NlcHQgYSAiYXV0byIKPiArCSAqIHNvdXJjZSBuYW1lIHRoYXQgd2lsbCBzZWxl Y3QgYSBkZWZhdWx0IHNvdXJjZSBmb3IgdGhpcyBDUlRDLgo+ICsJICoKPiArCSAqIFRoaXMgY2Fs bGJhY2sgaXMgb3B0aW9uYWwgaWYgdGhlIGRyaXZlciBkb2VzIG5vdCBzdXBwb3J0IGFueSBDUkMK PiArCSAqIGdlbmVyYXRpb24gZnVuY3Rpb25hbGl0eS4KPiArCSAqCj4gKwkgKiBSRVRVUk5TOgo+ ICsJICoKPiArCSAqIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFp bHVyZS4KPiArCSAqLwo+ICsJaW50ICgqc2V0X2NyY19zb3VyY2UpKHN0cnVjdCBkcm1fY3J0YyAq Y3J0YywgY29uc3QgY2hhciAqc291cmNlLAo+ICsJCQkgICAgICBzaXplX3QgKnZhbHVlc19jbnQp Owo+ICB9Owo+ICAKPiAgLyoqCj4gQEAgLTg0NCw2ICs4NjksMjIgQEAgc3RydWN0IGRybV9jcnRj IHsKPiAgCSAqIGNvbnRleHQuCj4gIAkgKi8KPiAgCXN0cnVjdCBkcm1fbW9kZXNldF9hY3F1aXJl X2N0eCAqYWNxdWlyZV9jdHg7Cj4gKwo+ICsjaWZkZWYgQ09ORklHX0RFQlVHX0ZTCj4gKwkvKioK PiArCSAqIEBkZWJ1Z2ZzX2VudHJ5Ogo+ICsJICoKPiArCSAqIERlYnVnZnMgZGlyZWN0b3J5IGZv ciB0aGlzIENSVEMuCj4gKwkgKi8KPiArCXN0cnVjdCBkZW50cnkgKmRlYnVnZnNfZW50cnk7Cj4g Kwo+ICsJLyoqCj4gKwkgKiBAY3JjOgo+ICsJICoKPiArCSAqIENvbmZpZ3VyYXRpb24gc2V0dGlu Z3Mgb2YgQ1JDIGNhcHR1cmUuCj4gKwkgKi8KPiArCXN0cnVjdCBkcm1fY3J0Y19jcmMgY3JjOwo+ ICsjZW5kaWYKPiAgfTsKPiAgCj4gIC8qKgo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1f ZGVidWdmc19jcmMuaCBiL2luY2x1ZGUvZHJtL2RybV9kZWJ1Z2ZzX2NyYy5oCj4gbmV3IGZpbGUg bW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmEzNDFmYzliZWNhZAo+IC0tLSAvZGV2 L251bGwKPiArKysgYi9pbmNsdWRlL2RybS9kcm1fZGVidWdmc19jcmMuaAo+IEBAIC0wLDAgKzEs NzQgQEAKPiArLyoKPiArICogQ29weXJpZ2h0IMKpIDIwMTYgQ29sbGFib3JhIEx0ZC4KPiArICoK PiArICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFu eSBwZXJzb24gb2J0YWluaW5nIGEKPiArICogY29weSBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3Nv Y2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwKPiArICogdG8gZGVh bCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQg bGltaXRhdGlvbgo+ICsgKiB0aGUgcmlnaHRzIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwg cHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwKPiArICogYW5kL29yIHNlbGwgY29waWVz IG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlCj4gKyAq IFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnM6Cj4gKyAqCj4gKyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0 aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCj4gKyAqIGFsbCBjb3Bp ZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgo+ICsgKgo+ICsgKiBU SEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkg S0lORCwgRVhQUkVTUyBPUgo+ICsgKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVE IFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKPiArICogRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNI QUxMCj4gKyAqIFRIRSBDT1BZUklHSFQgSE9MREVSKFMpIE9SIEFVVEhPUihTKSBCRSBMSUFCTEUg Rk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUgo+ICsgKiBPVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwKPiArICogQVJJU0lO RyBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUg VVNFIE9SCj4gKyAqIE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KPiArICovCj4gKyNp Zm5kZWYgX19EUk1fREVCVUdGU19DUkNfSF9fCj4gKyNkZWZpbmUgX19EUk1fREVCVUdGU19DUkNf SF9fCj4gKwo+ICsvKioKPiArICogc3RydWN0IGRybV9jcnRjX2NyY19lbnRyeSAtIGVudHJ5IGRl c2NyaWJpbmcgYSBmcmFtZSdzIGNvbnRlbnQKPiArICogQGZyYW1lOiBudW1iZXIgb2YgdGhlIGZy YW1lIHRoaXMgQ1JDIGlzIGFib3V0Cj4gKyAqIEBjcmM6IGFycmF5IG9mIHZhbHVlcyB0aGF0IGNo YXJhY3Rlcml6ZSB0aGUgZnJhbWUKPiArICovCj4gK3N0cnVjdCBkcm1fY3J0Y19jcmNfZW50cnkg ewo+ICsJYm9vbCBoYXNfZnJhbWVfY291bnRlcjsKPiArCXVpbnQzMl90IGZyYW1lOwo+ICsJdWlu dDMyX3QgY3Jjc1swXTsKPiArfTsKPiArCj4gKyNkZWZpbmUgRFJNX01BWF9DUkNfTlIJCTEwCj4g KyNkZWZpbmUgRFJNX0NSQ19FTlRSSUVTX05SCTEyOAo+ICsvKioKPiArICogc3RydWN0IGRybV9j cnRjX2NyYyAtIGRhdGEgc3VwcG9ydGluZyBDUkMgY2FwdHVyZSBvbiBhIGdpdmVuIENSVEMKPiAr ICogQGxvY2s6IHByb3RlY3RzIHRoZSBmaWVsZHMgaW4gdGhpcyBzdHJ1Y3QKPiArICogQHNvdXJj ZTogbmFtZSBvZiB0aGUgY3VycmVudGx5IGNvbmZpZ3VyZWQgc291cmNlIG9mIENSQ3MKPiArICog QG9wZW5lZDogd2hldGhlciB1c2Vyc3BhY2UgaGFzIG9wZW5lZCB0aGUgZGF0YSBmaWxlIGZvciBy ZWFkaW5nCj4gKyAqIEBlbnRyaWVzOiBhcnJheSBvZiBlbnRyaWVzLCB3aXRoIHNpemUgb2YgJURS TV9DUlRDX0NSQ19FTlRSSUVTX05SCj4gKyAqIEBoZWFkOiBoZWFkIG9mIGNpcmN1bGFyIHF1ZXVl Cj4gKyAqIEB0YWlsOiB0YWlsIG9mIGNpcmN1bGFyIHF1ZXVlCj4gKyAqIEB3cTogd29ya3F1ZXVl IHVzZWQgdG8gc3luY2hyb25pemUgcmVhZGluZyBhbmQgd3JpdGluZwo+ICsgKi8KPiArc3RydWN0 IGRybV9jcnRjX2NyYyB7Cj4gKwlzcGlubG9ja190IGxvY2s7Cj4gKwljb25zdCBjaGFyICpzb3Vy Y2U7Cj4gKwlib29sIG9wZW5lZDsKPiArCXN0cnVjdCBkcm1fY3J0Y19jcmNfZW50cnkgKmVudHJp ZXM7Cj4gKwlpbnQgaGVhZCwgdGFpbDsKPiArCXNpemVfdCB2YWx1ZXNfY250Owo+ICsJd2FpdF9x dWV1ZV9oZWFkX3Qgd3E7Cj4gK307Cj4gKwo+ICsjaWYgZGVmaW5lZChDT05GSUdfREVCVUdfRlMp Cj4gK2ludCBkcm1fZGVidWdmc19jcnRjX2NyY19hZGQoc3RydWN0IGRybV9jcnRjICpjcnRjKTsK PiAraW50IGRybV9jcnRjX2FkZF9jcmNfZW50cnkoc3RydWN0IGRybV9jcnRjICpjcnRjLCBib29s IGhhc19mcmFtZSwKPiArCQkJICAgdWludDMyX3QgZnJhbWUsIHVpbnQzMl90ICpjcmNzKTsKPiAr I2Vsc2UKPiArc3RhdGljIGlubGluZSBpbnQgZHJtX2RlYnVnZnNfY3J0Y19jcmNfYWRkKHN0cnVj dCBkcm1fY3J0YyAqY3J0YykKPiArewo+ICsJcmV0dXJuIDA7Cj4gK30KPiArc3RhdGljIGlubGlu ZSBpbnQgZHJtX2NydGNfYWRkX2NyY19lbnRyeShzdHJ1Y3QgZHJtX2NydGMgKmNydGMsIGJvb2wg aGFzX2ZyYW1lLAo+ICsJCQkJCSB1aW50MzJfdCBmcmFtZSwgdWludDMyX3QgKmNyY3MpCj4gK3sK PiArCXJldHVybiAtRUlOVkFMOwo+ICt9Cj4gKyNlbmRpZiAvKiBkZWZpbmVkKENPTkZJR19ERUJV R19GUykgKi8KPiArCj4gKyNlbmRpZiAvKiBfX0RSTV9ERUJVR0ZTX0NSQ19IX18gKi8KPiAtLSAK PiAyLjUuNQo+IAo+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCj4gZHJpLWRldmVsIG1haWxpbmcgbGlzdAo+IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKPiBodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbAoKLS0gClZpbGxlIFN5cmrDpGzDpApJbnRlbCBPVEMKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmkt ZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3Jn L21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755241AbcHCHJ7 (ORCPT ); Wed, 3 Aug 2016 03:09:59 -0400 Received: from mga02.intel.com ([134.134.136.20]:12937 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753599AbcHCHJt (ORCPT ); Wed, 3 Aug 2016 03:09:49 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,465,1464678000"; d="scan'208";a="1007498777" Date: Wed, 3 Aug 2016 10:06:38 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Tomeu Vizoso Cc: linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Jonathan Corbet , dri-devel@lists.freedesktop.org, Daniel Vetter , Emil Velikov Subject: Re: [PATCH v3 2/3] drm: Add API for capturing frame CRCs Message-ID: <20160803070638.GE4329@intel.com> References: <1469196645-3061-1-git-send-email-tomeu.vizoso@collabora.com> <1469196645-3061-3-git-send-email-tomeu.vizoso@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1469196645-3061-3-git-send-email-tomeu.vizoso@collabora.com> User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Jul 22, 2016 at 04:10:44PM +0200, Tomeu Vizoso wrote: > Adds files and directories to debugfs for controlling and reading frame > CRCs, per CRTC: > > dri/0/crtc-0/crc > dri/0/crtc-0/crc/control > dri/0/crtc-0/crc/data > > Drivers can implement the set_crc_source callback() in drm_crtc_funcs to > start and stop generating frame CRCs and can add entries to the output > by calling drm_crtc_add_crc_entry. > > v2: > - Lots of good fixes suggested by Thierry. > - Added documentation. > - Changed the debugfs layout. > - Moved to allocate the entries circular queue once when frame > generation gets enabled for the first time. > v3: > - Use the control file just to select the source, and start and stop > capture when the data file is opened and closed, respectively. > - Make variable the number of CRC values per entry, per source. > - Allocate entries queue each time we start capturing as now there > isn't a fixed number of CRC values per entry. > - Store the frame counter in the data file as a 8-digit hex number. > - For sources that cannot provide useful frame numbers, place > XXXXXXXX in the frame field. > > Signed-off-by: Tomeu Vizoso > --- > > Documentation/gpu/drm-uapi.rst | 6 + > drivers/gpu/drm/Makefile | 3 +- > drivers/gpu/drm/drm_crtc.c | 12 ++ > drivers/gpu/drm/drm_debugfs.c | 36 +++- > drivers/gpu/drm/drm_debugfs_crc.c | 370 ++++++++++++++++++++++++++++++++++++++ > drivers/gpu/drm/drm_drv.c | 9 + > drivers/gpu/drm/drm_internal.h | 10 ++ > include/drm/drmP.h | 5 + > include/drm/drm_crtc.h | 41 +++++ > include/drm/drm_debugfs_crc.h | 74 ++++++++ > 10 files changed, 564 insertions(+), 2 deletions(-) > create mode 100644 drivers/gpu/drm/drm_debugfs_crc.c > create mode 100644 include/drm/drm_debugfs_crc.h > > diff --git a/Documentation/gpu/drm-uapi.rst b/Documentation/gpu/drm-uapi.rst > index 536bf3eaadd4..33f778696ccd 100644 > --- a/Documentation/gpu/drm-uapi.rst > +++ b/Documentation/gpu/drm-uapi.rst > @@ -109,3 +109,9 @@ interfaces. Especially since all hardware-acceleration interfaces to > userspace are driver specific for efficiency and other reasons these > interfaces can be rather substantial. Hence every driver has its own > chapter. > + > +Testing and validation > +====================== > + > +.. kernel-doc:: drivers/gpu/drm/drm_debugfs_crc.c > + :doc: CRC ABI > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > index e3dba6f44a79..b53b5aaaeb4d 100644 > --- a/drivers/gpu/drm/Makefile > +++ b/drivers/gpu/drm/Makefile > @@ -12,7 +12,8 @@ drm-y := drm_auth.o drm_bufs.o drm_cache.o \ > drm_info.o drm_debugfs.o drm_encoder_slave.o \ > drm_trace_points.o drm_global.o drm_prime.o \ > drm_rect.o drm_vma_manager.o drm_flip_work.o \ > - drm_modeset_lock.o drm_atomic.o drm_bridge.o > + drm_modeset_lock.o drm_atomic.o drm_bridge.o \ > + drm_debugfs_crc.o > > drm-$(CONFIG_COMPAT) += drm_ioc32.o > drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o > diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c > index 10b73f68c023..087345af96e7 100644 > --- a/drivers/gpu/drm/drm_crtc.c > +++ b/drivers/gpu/drm/drm_crtc.c > @@ -40,6 +40,7 @@ > #include > #include > #include > +#include > > #include "drm_crtc_internal.h" > #include "drm_internal.h" > @@ -738,6 +739,12 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, > if (cursor) > cursor->possible_crtcs = 1 << drm_crtc_index(crtc); > > +#ifdef CONFIG_DEBUG_FS > + spin_lock_init(&crtc->crc.lock); > + init_waitqueue_head(&crtc->crc.wq); > + crtc->crc.source = kstrdup("auto", GFP_KERNEL); > +#endif > + > if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { > drm_object_attach_property(&crtc->base, config->prop_active, 0); > drm_object_attach_property(&crtc->base, config->prop_mode_id, 0); > @@ -764,6 +771,11 @@ void drm_crtc_cleanup(struct drm_crtc *crtc) > * the indices on the drm_crtc after us in the crtc_list. > */ > > +#ifdef CONFIG_DEBUG_FS > + drm_debugfs_crtc_remove(crtc); > + kfree(crtc->crc.source); > +#endif > + > kfree(crtc->gamma_store); > crtc->gamma_store = NULL; > > diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c > index fa10cef2ba37..73530cbf1316 100644 > --- a/drivers/gpu/drm/drm_debugfs.c > +++ b/drivers/gpu/drm/drm_debugfs.c > @@ -415,5 +415,39 @@ void drm_debugfs_connector_remove(struct drm_connector *connector) > connector->debugfs_entry = NULL; > } > > -#endif /* CONFIG_DEBUG_FS */ > +int drm_debugfs_crtc_add(struct drm_crtc *crtc) > +{ > + struct drm_minor *minor = crtc->dev->primary; > + struct dentry *root; > + char *name; > + > + name = kasprintf(GFP_KERNEL, "crtc-%d", crtc->index); > + if (!name) > + return -ENOMEM; > > + root = debugfs_create_dir(name, minor->debugfs_root); > + kfree(name); > + if (!root) > + return -ENOMEM; > + > + crtc->debugfs_entry = root; > + > + if (drm_debugfs_crtc_crc_add(crtc)) > + goto error; > + > + return 0; > + > +error: > + debugfs_remove_recursive(crtc->debugfs_entry); > + crtc->debugfs_entry = NULL; > + return -ENOMEM; > +} > + > +void drm_debugfs_crtc_remove(struct drm_crtc *crtc) > +{ > + debugfs_remove_recursive(crtc->debugfs_entry); > + > + crtc->debugfs_entry = NULL; > +} > + > +#endif /* CONFIG_DEBUG_FS */ > diff --git a/drivers/gpu/drm/drm_debugfs_crc.c b/drivers/gpu/drm/drm_debugfs_crc.c > new file mode 100644 > index 000000000000..5ef071437952 > --- /dev/null > +++ b/drivers/gpu/drm/drm_debugfs_crc.c > @@ -0,0 +1,370 @@ > +/* > + * Copyright © 2008 Intel Corporation > + * Copyright © 2016 Collabora Ltd > + * > + * Permission is hereby granted, free of charge, to any person obtaining a > + * copy of this software and associated documentation files (the "Software"), > + * to deal in the Software without restriction, including without limitation > + * the rights to use, copy, modify, merge, publish, distribute, sublicense, > + * and/or sell copies of the Software, and to permit persons to whom the > + * Software is furnished to do so, subject to the following conditions: > + * > + * The above copyright notice and this permission notice (including the next > + * paragraph) shall be included in all copies or substantial portions of the > + * Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL > + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER > + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING > + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS > + * IN THE SOFTWARE. > + * > + * Authors: > + * Eric Anholt > + * Keith Packard > + * > + */ > + > +#include > +#include > +#include > +#include > + > +/** > + * DOC: CRC ABI > + * > + * DRM device drivers can provide to userspace CRC information of each frame as > + * it reached a given hardware component (a "source"). > + * > + * Userspace can control generation of CRCs in a given CRTC by writing to the > + * file dri/0/crtc-N/crc/control in debugfs, with N being the index of the CRTC. > + * Accepted values are source names (which are driver-specific) and the "none" > + * and "auto" keywords. "none" will disable CRC generation and "auto" will let > + * the driver select a default source of frame CRCs for this CRTC. > + * > + * Once frame CRC generation is enabled, userspace can capture them by reading > + * the dri/0/crtc-N/crc/data file. Each line in that file contains the frame > + * number in the first field and then a number of unsigned integer fields > + * containing the CRC data. Fields are separated by a single space and the number > + * of CRC fields is source-specific. > + * > + * Note that though in some cases the CRC is computed in a specified way and on > + * the frame contents as supplied by userspace (eDP 1.3), in general the CRC > + * computation is performed in an unspecified way and on frame contents that have > + * been already processed in also an unspecified way and thus userspace cannot > + * rely on being able to generate matching CRC values for the frame contents that > + * it submits. In this general case, the maximum userspace can do is to compare > + * the reported CRCs of frames that should have the same contents. > + */ > +#if defined(CONFIG_DEBUG_FS) > + > +static int crc_control_show(struct seq_file *m, void *data) > +{ > + struct drm_crtc *crtc = m->private; > + > + seq_printf(m, "%s\n", crtc->crc.source); > + > + return 0; > +} > + > +static int crc_control_open(struct inode *inode, struct file *file) > +{ > + struct drm_crtc *crtc = inode->i_private; > + > + return single_open(file, crc_control_show, crtc); > +} > + > +static ssize_t crc_control_write(struct file *file, const char __user *ubuf, > + size_t len, loff_t *offp) > +{ > + struct seq_file *m = file->private_data; > + struct drm_crtc *crtc = m->private; > + struct drm_crtc_crc *crc = &crtc->crc; > + char *source; > + > + if (len == 0) > + return 0; > + > + if (len > PAGE_SIZE - 1) { > + DRM_DEBUG_KMS("Expected < %lu bytes into crtc crc control\n", > + PAGE_SIZE); > + return -E2BIG; > + } > + > + source = kmalloc(len + 1, GFP_KERNEL); > + if (!source) > + return -ENOMEM; > + > + if (copy_from_user(source, ubuf, len)) { > + kfree(source); > + return -EFAULT; > + } memdup_user_nul() ? > + > + if (source[len - 1] == '\n') > + source[len - 1] = '\0'; > + else > + source[len] = '\0'; > + > + spin_lock_irq(&crc->lock); > + > + if (crc->opened) { > + kfree(source); > + return -EBUSY; > + } Why not just start the thing here? > + > + kfree(crc->source); > + crc->source = source; > + > + spin_unlock_irq(&crc->lock); > + > + *offp += len; > + return len; > +} > + > +const struct file_operations drm_crtc_crc_control_fops = { > + .owner = THIS_MODULE, > + .open = crc_control_open, > + .read = seq_read, > + .llseek = seq_lseek, > + .release = single_release, > + .write = crc_control_write > +}; > + > +static int crtc_crc_open(struct inode *inode, struct file *filep) > +{ > + struct drm_crtc *crtc = inode->i_private; > + struct drm_crtc_crc *crc = &crtc->crc; > + struct drm_crtc_crc_entry *entries = NULL; > + size_t entry_size, values_cnt; > + int ret; > + > + if (crc->opened) > + return -EBUSY; > + > + ret = crtc->funcs->set_crc_source(crtc, crc->source, &values_cnt); > + if (ret) > + return ret; > + > + if (WARN_ON(values_cnt > DRM_MAX_CRC_NR)) { > + ret = -EINVAL; > + goto err_disable; > + } > + > + if (WARN_ON(values_cnt == 0)) { > + ret = -EINVAL; > + goto err_disable; > + } > + > + entry_size = sizeof(*crc->entries) + sizeof(uint32_t) * values_cnt; > + entries = kcalloc(DRM_CRC_ENTRIES_NR, entry_size, GFP_KERNEL); > + if (!entries) { > + ret = -ENOMEM; > + goto err_disable; > + } > + > + spin_lock_irq(&crc->lock); > + crc->entries = entries; > + crc->values_cnt = values_cnt; > + crc->opened = true; > + spin_unlock_irq(&crc->lock); > + > + return 0; > + > +err_disable: > + crtc->funcs->set_crc_source(crtc, NULL, &values_cnt); > + return ret; > +} > + > +static int crtc_crc_release(struct inode *inode, struct file *filep) > +{ > + struct drm_crtc *crtc = filep->f_inode->i_private; > + struct drm_crtc_crc *crc = &crtc->crc; > + size_t values_cnt; > + > + crtc->funcs->set_crc_source(crtc, NULL, &values_cnt); > + > + spin_lock_irq(&crc->lock); > + kfree(crc->entries); > + crc->entries = NULL; > + crc->head = 0; > + crc->tail = 0; > + crc->values_cnt = 0; > + crc->opened = false; > + spin_unlock_irq(&crc->lock); > + > + return 0; > +} > + > +static int crtc_crc_data_count(struct drm_crtc_crc *crc) > +{ > + assert_spin_locked(&crc->lock); > + return CIRC_CNT(crc->head, crc->tail, DRM_CRC_ENTRIES_NR); > +} > + > +static struct drm_crtc_crc_entry *crtc_get_crc_entry(struct drm_crtc_crc *crc, > + int index) > +{ > + void *p = crc->entries; > + size_t entry_size = (sizeof(*crc->entries) + > + sizeof(*crc->entries[0].crcs) * crc->values_cnt); This computation is duplicated also in crtc_crc_open(). could use a common helper to do it. Shame the language doesn't have a way to deal with arrays of variable sized arrays in a nice way. > + > + return p + entry_size * index; > +} > + > +#define MAX_LINE_LEN (8 + 9 * DRM_MAX_CRC_NR + 1 + 1) > + > +static ssize_t crtc_crc_read(struct file *filep, char __user *user_buf, > + size_t count, loff_t *pos) > +{ > + struct drm_crtc *crtc = filep->f_inode->i_private; > + struct drm_crtc_crc *crc = &crtc->crc; > + struct drm_crtc_crc_entry *entry; > + char buf[MAX_LINE_LEN]; > + int ret, i; > + > + spin_lock_irq(&crc->lock); > + > + if (!crc->source) { > + spin_unlock_irq(&crc->lock); > + return 0; > + } > + > + /* Nothing to read? */ > + while (crtc_crc_data_count(crc) == 0) { > + if (filep->f_flags & O_NONBLOCK) { > + spin_unlock_irq(&crc->lock); > + return -EAGAIN; > + } > + > + ret = wait_event_interruptible_lock_irq(crc->wq, > + crtc_crc_data_count(crc), > + crc->lock); > + if (ret) { > + spin_unlock_irq(&crc->lock); > + return ret; > + } > + } > + > + /* We know we have an entry to be read */ > + entry = crtc_get_crc_entry(crc, crc->tail); > + > + /* > + * 1 frame field of 8 chars plus a number of CRC fields of 8 > + * chars each, space separated and with a newline at the end. > + */ > + if (count < 8 + 9 * crc->values_cnt + 1 + 1) { Just < MAX_LINE_LEN perhaps? Or could make a macro/function that takes crc->values_cnt or DRM_MAX_CRC_NR as an argument. > + spin_unlock_irq(&crc->lock); > + return -EINVAL; > + } > + > + BUILD_BUG_ON_NOT_POWER_OF_2(DRM_CRC_ENTRIES_NR); > + crc->tail = (crc->tail + 1) & (DRM_CRC_ENTRIES_NR - 1); > + > + spin_unlock_irq(&crc->lock); > + > + if (entry->has_frame_counter) > + snprintf(buf, 9, "%08x", entry->frame); > + else > + snprintf(buf, 9, "XXXXXXXX"); Should we add "0x" prefix to all these numbers to make it clear that they're in fact hex? > + > + for (i = 0; i < crc->values_cnt; i++) > + snprintf(buf + strlen(buf), 10, " %08x", entry->crcs[i]); The 'n' in snprintf() here seems pointless. As does the strlen(). > + snprintf(buf + strlen(buf), 2, "\n"); > + > + if (copy_to_user(user_buf, buf, strlen(buf) + 1)) > + return -EFAULT; > + > + return strlen(buf) + 1; More strlen()s that shouldn't be needed. > +} > + > +const struct file_operations drm_crtc_crc_data_fops = { > + .owner = THIS_MODULE, > + .open = crtc_crc_open, > + .read = crtc_crc_read, > + .release = crtc_crc_release, > +}; > + > +/** > + * drm_debugfs_crtc_crc_add - Add files to debugfs for capture of frame CRCs > + * @crtc: CRTC to whom the frames will belong > + * > + * Adds files to debugfs directory that allows userspace to control the > + * generation of frame CRCs and to read them. > + * > + * Returns: > + * Zero on success, error code on failure. > + */ > +int drm_debugfs_crtc_crc_add(struct drm_crtc *crtc) > +{ > + struct dentry *crc_ent, *ent; > + > + if (!crtc->funcs->set_crc_source) > + return 0; > + > + crc_ent = debugfs_create_dir("crc", crtc->debugfs_entry); > + if (!crc_ent) > + return -ENOMEM; > + > + ent = debugfs_create_file("control", S_IRUGO, crc_ent, crtc, > + &drm_crtc_crc_control_fops); > + if (!ent) > + goto error; > + > + ent = debugfs_create_file("data", S_IRUGO, crc_ent, crtc, > + &drm_crtc_crc_data_fops); > + if (!ent) > + goto error; > + > + return 0; > + > +error: > + debugfs_remove_recursive(crc_ent); > + > + return -ENOMEM; > +} > + > +/** > + * drm_crtc_add_crc_entry - Add entry with CRC information for a frame > + * @crtc: CRTC to which the frame belongs > + * @has_frame: whether this entry has a frame number to go with > + * @frame: number of the frame these CRCs are about > + * @crcs: array of CRC values, with length matching #drm_crtc_crc.values_cnt > + * > + * For each frame, the driver polls the source of CRCs for new data and calls > + * this function to add them to the buffer from where userspace reads. > + */ > +int drm_crtc_add_crc_entry(struct drm_crtc *crtc, bool has_frame, > + uint32_t frame, uint32_t *crcs) > +{ > + struct drm_crtc_crc *crc = &crtc->crc; > + struct drm_crtc_crc_entry *entry; > + int head, tail; > + > + assert_spin_locked(&crc->lock); > + > + /* Caller may not have noticed yet that userspace has stopped reading */ > + if (!crc->opened) > + return -EINVAL; > + > + head = crc->head; > + tail = crc->tail; > + > + if (CIRC_SPACE(head, tail, DRM_CRC_ENTRIES_NR) < 1) { > + DRM_ERROR("Overflow of CRC buffer, userspace reads too slow.\n"); > + return -ENOBUFS; > + } > + > + entry = crtc_get_crc_entry(crc, head); > + entry->frame = frame; > + entry->has_frame_counter = has_frame; > + memcpy(&entry->crcs, crcs, sizeof(*crcs) * crc->values_cnt); > + > + head = (head + 1) & (DRM_CRC_ENTRIES_NR - 1); > + crc->head = head; > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(drm_crtc_add_crc_entry); > +#endif /* CONFIG_DEBUG_FS */ > diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c > index aead9ffcbe29..a02406f51d98 100644 > --- a/drivers/gpu/drm/drm_drv.c > +++ b/drivers/gpu/drm/drm_drv.c > @@ -192,6 +192,7 @@ static void drm_minor_free(struct drm_device *dev, unsigned int type) > static int drm_minor_register(struct drm_device *dev, unsigned int type) > { > struct drm_minor *minor; > + struct drm_crtc *crtc; > unsigned long flags; > int ret; > > @@ -207,6 +208,14 @@ static int drm_minor_register(struct drm_device *dev, unsigned int type) > return ret; > } > > + if (type == DRM_MINOR_LEGACY) { > + drm_for_each_crtc(crtc, dev) { > + ret = drm_debugfs_crtc_add(crtc); > + if (ret) > + goto err_debugfs; > + } > + } > + > ret = device_add(minor->kdev); > if (ret) > goto err_debugfs; > diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h > index b86dc9b921a5..99ce6d4f2916 100644 > --- a/drivers/gpu/drm/drm_internal.h > +++ b/drivers/gpu/drm/drm_internal.h > @@ -97,6 +97,8 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > int drm_debugfs_cleanup(struct drm_minor *minor); > int drm_debugfs_connector_add(struct drm_connector *connector); > void drm_debugfs_connector_remove(struct drm_connector *connector); > +int drm_debugfs_crtc_add(struct drm_crtc *crtc); > +void drm_debugfs_crtc_remove(struct drm_crtc *crtc); > #else > static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id, > struct dentry *root) > @@ -116,4 +118,12 @@ static inline int drm_debugfs_connector_add(struct drm_connector *connector) > static inline void drm_debugfs_connector_remove(struct drm_connector *connector) > { > } > + > +static inline int drm_debugfs_crtc_add(struct drm_crtc *crtc) > +{ > + return 0; > +} > +static inline void drm_debugfs_crtc_remove(struct drm_crtc *crtc) > +{ > +} > #endif > diff --git a/include/drm/drmP.h b/include/drm/drmP.h > index cf918e3e6afb..8a0b235ccc39 100644 > --- a/include/drm/drmP.h > +++ b/include/drm/drmP.h > @@ -1111,6 +1111,11 @@ static __inline__ bool drm_can_sleep(void) > return true; > } > > +#if defined(CONFIG_DEBUG_FS) > +extern const struct file_operations drm_crc_control_fops; > +extern const struct file_operations drm_crtc_crc_fops; > +#endif > + > /* helper for handling conditionals in various for_each macros */ > #define for_each_if(condition) if (!(condition)) {} else > > diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h > index 781695c74528..fcc632940dce 100644 > --- a/include/drm/drm_crtc.h > +++ b/include/drm/drm_crtc.h > @@ -35,6 +35,7 @@ > #include > #include > #include > +#include > > struct drm_device; > struct drm_mode_set; > @@ -731,6 +732,30 @@ struct drm_crtc_funcs { > * before data structures are torndown. > */ > void (*early_unregister)(struct drm_crtc *crtc); > + > + /** > + * @set_crc_source: > + * > + * Changes the source of CRC checksums of frames at the request of > + * userspace, typically for testing purposes. The sources available are > + * specific of each driver and a %NULL value indicates that CRC > + * generation is to be switched off. > + * > + * When CRC generation is enabled, the driver should call > + * drm_crtc_add_crc_entry() at each frame, providing any information > + * that characterizes the frame contents in the crcN arguments, as > + * provided from the configured source. Drivers should accept a "auto" > + * source name that will select a default source for this CRTC. > + * > + * This callback is optional if the driver does not support any CRC > + * generation functionality. > + * > + * RETURNS: > + * > + * 0 on success or a negative error code on failure. > + */ > + int (*set_crc_source)(struct drm_crtc *crtc, const char *source, > + size_t *values_cnt); > }; > > /** > @@ -844,6 +869,22 @@ struct drm_crtc { > * context. > */ > struct drm_modeset_acquire_ctx *acquire_ctx; > + > +#ifdef CONFIG_DEBUG_FS > + /** > + * @debugfs_entry: > + * > + * Debugfs directory for this CRTC. > + */ > + struct dentry *debugfs_entry; > + > + /** > + * @crc: > + * > + * Configuration settings of CRC capture. > + */ > + struct drm_crtc_crc crc; > +#endif > }; > > /** > diff --git a/include/drm/drm_debugfs_crc.h b/include/drm/drm_debugfs_crc.h > new file mode 100644 > index 000000000000..a341fc9becad > --- /dev/null > +++ b/include/drm/drm_debugfs_crc.h > @@ -0,0 +1,74 @@ > +/* > + * Copyright © 2016 Collabora Ltd. > + * > + * Permission is hereby granted, free of charge, to any person obtaining a > + * copy of this software and associated documentation files (the "Software"), > + * to deal in the Software without restriction, including without limitation > + * the rights to use, copy, modify, merge, publish, distribute, sublicense, > + * and/or sell copies of the Software, and to permit persons to whom the > + * Software is furnished to do so, subject to the following conditions: > + * > + * The above copyright notice and this permission notice shall be included in > + * all copies or substantial portions of the Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL > + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR > + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, > + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR > + * OTHER DEALINGS IN THE SOFTWARE. > + */ > +#ifndef __DRM_DEBUGFS_CRC_H__ > +#define __DRM_DEBUGFS_CRC_H__ > + > +/** > + * struct drm_crtc_crc_entry - entry describing a frame's content > + * @frame: number of the frame this CRC is about > + * @crc: array of values that characterize the frame > + */ > +struct drm_crtc_crc_entry { > + bool has_frame_counter; > + uint32_t frame; > + uint32_t crcs[0]; > +}; > + > +#define DRM_MAX_CRC_NR 10 > +#define DRM_CRC_ENTRIES_NR 128 > +/** > + * struct drm_crtc_crc - data supporting CRC capture on a given CRTC > + * @lock: protects the fields in this struct > + * @source: name of the currently configured source of CRCs > + * @opened: whether userspace has opened the data file for reading > + * @entries: array of entries, with size of %DRM_CRTC_CRC_ENTRIES_NR > + * @head: head of circular queue > + * @tail: tail of circular queue > + * @wq: workqueue used to synchronize reading and writing > + */ > +struct drm_crtc_crc { > + spinlock_t lock; > + const char *source; > + bool opened; > + struct drm_crtc_crc_entry *entries; > + int head, tail; > + size_t values_cnt; > + wait_queue_head_t wq; > +}; > + > +#if defined(CONFIG_DEBUG_FS) > +int drm_debugfs_crtc_crc_add(struct drm_crtc *crtc); > +int drm_crtc_add_crc_entry(struct drm_crtc *crtc, bool has_frame, > + uint32_t frame, uint32_t *crcs); > +#else > +static inline int drm_debugfs_crtc_crc_add(struct drm_crtc *crtc) > +{ > + return 0; > +} > +static inline int drm_crtc_add_crc_entry(struct drm_crtc *crtc, bool has_frame, > + uint32_t frame, uint32_t *crcs) > +{ > + return -EINVAL; > +} > +#endif /* defined(CONFIG_DEBUG_FS) */ > + > +#endif /* __DRM_DEBUGFS_CRC_H__ */ > -- > 2.5.5 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Ville Syrjälä Intel OTC