From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH 04/18] video/hdmi: Constify infoframe passed to the pack functions Date: Fri, 21 Sep 2018 17:30:02 +0300 Message-ID: <20180921143002.GY5565@intel.com> References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-5-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Hans Verkuil Cc: intel-gfx@lists.freedesktop.org, Hans Verkuil , dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBTZXAgMjEsIDIwMTggYXQgMTA6MjQ6MjVBTSArMDIwMCwgSGFucyBWZXJrdWlsIHdy b3RlOgo+IE9uIDA5LzIwLzE4IDIwOjUxLCBWaWxsZSBTeXJqYWxhIHdyb3RlOgo+ID4gRnJvbTog VmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiA+IAo+ID4g TGV0J3MgbWFrZSB0aGUgaW5mb2ZyYW1lIHBhY2sgZnVuY3Rpb25zIHVzYWJsZSB3aXRoIGEgY29u c3QgaW5mb2ZyYW1lCj4gPiBzdHJ1Y3R1cmUuIFRoaXMgYWxsb3dzIHVzIHRvIHByZWNvbXB1dGUg dGhlIGluZm9mcmFtZSBlYXJsaWVyLCBhbmQgc3RpbGwKPiA+IHBhY2sgaXQgbGF0ZXIgd2hlbiB3 ZSdyZSBubyBsb25nZXIgYWxsb3dlZCB0byBtb2RpZnkgdGhlIHN0cnVjdHVyZS4KPiA+IFNvIG5v dyB3ZSBlbmQgdXAgd2l0aCBhIF9jaGVjaygpK19wYWNrX29ubHkoKSBvciBfcGFjaygpIGZ1bmN0 aW9ucwo+ID4gZGVwZW5kaW5nIG9uIHdoZXRoZXIgeW91IHdhbnQgdG8gcHJlY29tcHV0ZSB0aGUg aW5mb2ZyYW1lcyBvciBub3QuCj4gPiBUaGUgbmFtZXMgYXJlbid0IGdyZWF0ZSBidXQgSSB3YXMg bGF6eSBhbmQgZGlkbid0IHdhbnQgdG8gY2hhbmdlIGFsbCB0aGUKPiAKPiBncmVhdGUgLT4gZ3Jl YXQKClRoYW5rcyBmb3IgcmVhZGluZyB0aHJvdWdoIGl0LiBGaXhlZCB1cCBhbGwgdGhlIGNyYXAg eW91IHNwb3R0ZWQuCgo+IAo+ID4gZHJpdmVycy4KPiA+IAo+ID4gdjI6IERlYWwgd2l0aCBleHlu b3MgY2h1cm4KPiA+ICAgICBBY3R1YWxseSBleHBvcnQgdGhlIG5ldyBmdW5jcwo+ID4gCj4gPiBD YzogVGhpZXJyeSBSZWRpbmcgPHRoaWVycnkucmVkaW5nQGdtYWlsLmNvbT4KPiA+IENjOiBIYW5z IFZlcmt1aWwgPGhhbnMudmVya3VpbEBjaXNjby5jb20+Cj4gPiBDYzogbGludXgtbWVkaWFAdmdl ci5rZXJuZWwub3JnCj4gPiBTaWduZWQtb2ZmLWJ5OiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5 cmphbGFAbGludXguaW50ZWwuY29tPgo+ID4gLS0tCj4gPiAgZHJpdmVycy92aWRlby9oZG1pLmMg fCA0MjUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0t Cj4gPiAgaW5jbHVkZS9saW51eC9oZG1pLmggfCAgMTkgKystCj4gPiAgMiBmaWxlcyBjaGFuZ2Vk LCA0MTYgaW5zZXJ0aW9ucygrKSwgMjggZGVsZXRpb25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQg YS9kcml2ZXJzL3ZpZGVvL2hkbWkuYyBiL2RyaXZlcnMvdmlkZW8vaGRtaS5jCj4gPiBpbmRleCA1 M2U3ZWUyYzgzZmMuLjk1MDdmNjY4YTU2OSAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvdmlkZW8v aGRtaS5jCj4gPiArKysgYi9kcml2ZXJzL3ZpZGVvL2hkbWkuYwo+ID4gQEAgLTY4LDggKzY4LDM2 IEBAIGludCBoZG1pX2F2aV9pbmZvZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1l ICpmcmFtZSkKPiA+ICB9Cj4gPiAgRVhQT1JUX1NZTUJPTChoZG1pX2F2aV9pbmZvZnJhbWVfaW5p dCk7Cj4gPiAgCj4gPiArc3RhdGljIGludCBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2tfb25seShj b25zdCBzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSkKPiA+ICt7Cj4gPiArCWlmIChm cmFtZS0+dHlwZSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX0FWSSB8fAo+ID4gKwkgICAgZnJhbWUt PnZlcnNpb24gIT0gMiB8fAo+ID4gKwkgICAgZnJhbWUtPmxlbmd0aCAhPSBIRE1JX0FWSV9JTkZP RlJBTUVfU0laRSkKPiA+ICsJCXJldHVybiAtRUlOVkFMOwo+ID4gKwo+ID4gKwlpZiAoZnJhbWUt PnBpY3R1cmVfYXNwZWN0ID4gSERNSV9QSUNUVVJFX0FTUEVDVF8xNl85KQo+ID4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gPiArCj4gPiArCXJldHVybiAwOwo+ID4gK30KPiA+ICsKPiA+ICAvKioKPiA+ IC0gKiBoZG1pX2F2aV9pbmZvZnJhbWVfcGFjaygpIC0gd3JpdGUgSERNSSBBVkkgaW5mb2ZyYW1l IHRvIGJpbmFyeSBidWZmZXIKPiA+ICsgKiBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2soKSAtIENo ZWNrIGFuZCBjaGVjayBhIEhETUkgQVZJIGluZm9mcmFtZQo+IAo+ICJDaGVjayBhbmQgY2hlY2si PyBUaGlzIGlzIHJlcGVhdGVkIGVsc2V3aGVyZSBhcyB3ZWxsIChjbGVhcmx5IGNvcHktYW5kLXBh c3RlKS4KPiAKPiA+ICsgKiBAZnJhbWU6IEhETUkgQVZJIGluZm9mcmFtZQo+ID4gKyAqCj4gPiAr ICogVmFsaWRhdGVzIHRoYXQgdGhlIGluZm9mcmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1cGRhdGVz IGRlcml2ZWQgZmllbGRzCj4gPiArICogKGVnLiBsZW5ndGgpIGJhc2VkIG9uIG90aGVyIGZpZWxk cy4KPiA+ICsgKgo+ID4gKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzIG9yIGEgbmVnYXRpdmUgZXJy b3IgY29kZSBvbiBmYWlsdXJlLgo+ID4gKyAqLwo+ID4gK2ludCBoZG1pX2F2aV9pbmZvZnJhbWVf Y2hlY2soc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJhbWUpCj4gPiArewo+ID4gKwlyZXR1 cm4gaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ID4gK30KPiA+ICtFWFBP UlRfU1lNQk9MKGhkbWlfYXZpX2luZm9mcmFtZV9jaGVjayk7Cj4gPiArCj4gPiArLyoqCj4gPiAr ICogaGRtaV9hdmlfaW5mb2ZyYW1lX3BhY2tfb25seSgpIC0gd3JpdGUgSERNSSBBVkkgaW5mb2Zy YW1lIHRvIGJpbmFyeSBidWZmZXIKPiA+ICAgKiBAZnJhbWU6IEhETUkgQVZJIGluZm9mcmFtZQo+ ID4gICAqIEBidWZmZXI6IGRlc3RpbmF0aW9uIGJ1ZmZlcgo+ID4gICAqIEBzaXplOiBzaXplIG9m IGJ1ZmZlcgo+ID4gQEAgLTgyLDIwICsxMTAsMjIgQEAgRVhQT1JUX1NZTUJPTChoZG1pX2F2aV9p bmZvZnJhbWVfaW5pdCk7Cj4gPiAgICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHBhY2tl ZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVyIG9yIGEgbmVnYXRpdmUKPiA+ICAgKiBlcnJvciBjb2Rl IG9uIGZhaWx1cmUuCj4gPiAgICovCj4gPiAtc3NpemVfdCBoZG1pX2F2aV9pbmZvZnJhbWVfcGFj ayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLAo+ID4gLQkJ CQlzaXplX3Qgc2l6ZSkKPiA+ICtzc2l6ZV90IGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrX29ubHko Y29uc3Qgc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJhbWUsCj4gPiArCQkJCSAgICAgdm9p ZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiA+ICB7Cj4gPiAgCXU4ICpwdHIgPSBidWZmZXI7Cj4g PiAgCXNpemVfdCBsZW5ndGg7Cj4gPiArCWludCByZXQ7Cj4gPiArCj4gPiArCXJldCA9IGhkbWlf YXZpX2luZm9mcmFtZV9jaGVja19vbmx5KGZyYW1lKTsKPiA+ICsJaWYgKHJldCkKPiA+ICsJCXJl dHVybiByZXQ7Cj4gPiAgCj4gPiAgCWxlbmd0aCA9IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpF ICsgZnJhbWUtPmxlbmd0aDsKPiA+ICAKPiA+ICAJaWYgKHNpemUgPCBsZW5ndGgpCj4gPiAgCQly ZXR1cm4gLUVOT1NQQzsKPiA+ICAKPiA+IC0JaWYgKGZyYW1lLT5waWN0dXJlX2FzcGVjdCA+IEhE TUlfUElDVFVSRV9BU1BFQ1RfMTZfOSkKPiA+IC0JCXJldHVybiAtRUlOVkFMOwo+ID4gLQo+ID4g IAltZW1zZXQoYnVmZmVyLCAwLCBzaXplKTsKPiA+ICAKPiA+ICAJcHRyWzBdID0gZnJhbWUtPnR5 cGU7Cj4gPiBAQCAtMTUyLDYgKzE4MiwzNiBAQCBzc2l6ZV90IGhkbWlfYXZpX2luZm9mcmFtZV9w YWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIsCj4gPiAg Cj4gPiAgCXJldHVybiBsZW5ndGg7Cj4gPiAgfQo+ID4gK0VYUE9SVF9TWU1CT0woaGRtaV9hdmlf aW5mb2ZyYW1lX3BhY2tfb25seSk7Cj4gPiArCj4gPiArLyoqCj4gPiArICogaGRtaV9hdmlfaW5m b2ZyYW1lX3BhY2soKSAtIENoZWNrIGFuZCBjaGVjayBhIEhETUkgQVZJIGluZm9mcmFtZSwKPiA+ ICsgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYW5kIHdyaXRlIGl0IHRvIGJpbmFyeSBi dWZmZXIKPiA+ICsgKiBAZnJhbWU6IEhETUkgQVZJIGluZm9mcmFtZQo+ID4gKyAqIEBidWZmZXI6 IGRlc3RpbmF0aW9uIGJ1ZmZlcgo+ID4gKyAqIEBzaXplOiBzaXplIG9mIGJ1ZmZlcgo+ID4gKyAq Cj4gPiArICogVmFsaWRhdGVzIHRoYXQgdGhlIGluZm9mcmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1 cGRhdGVzIGRlcml2ZWQgZmllbGRzCj4gPiArICogKGVnLiBsZW5ndGgpIGJhc2VkIG9uIG90aGVy IGZpZWxkcywgYWZ0ZXIgd2hpY2ggcGFja3MgdGhlIGluZm9ybWF0aW9uCj4gCj4gd2hpY2ggcGFj a3MgLT4gd2hpY2ggaXQgcGFja3MKPiAKPiBEaXR0byBlbHNld2hlcmUuCj4gCj4gPiArICogY29u dGFpbmVkIGluIHRoZSBAZnJhbWUgc3RydWN0dXJlIGludG8gYSBiaW5hcnkgcmVwcmVzZW50YXRp b24gdGhhdAo+ID4gKyAqIGNhbiBiZSB3cml0dGVuIGludG8gdGhlIGNvcnJlc3BvbmRpbmcgY29u dHJvbGxlciByZWdpc3RlcnMuIEFsc28KPiAKPiBBbHNvIC0+IFRoaXMgZnVuY3Rpb24gYWxzbwo+ IAo+IERpdHRvIGVsc2V3aGVyZS4KPiAKPiA+ICsgKiBjb21wdXRlcyB0aGUgY2hlY2tzdW0gYXMg cmVxdWlyZWQgYnkgc2VjdGlvbiA1LjMuNSBvZiB0aGUgSERNSSAxLjQKPiA+ICsgKiBzcGVjaWZp Y2F0aW9uLgo+ID4gKyAqCj4gPiArICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHBhY2tl ZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVyIG9yIGEgbmVnYXRpdmUKPiA+ICsgKiBlcnJvciBjb2Rl IG9uIGZhaWx1cmUuCj4gPiArICovCj4gPiArc3NpemVfdCBoZG1pX2F2aV9pbmZvZnJhbWVfcGFj ayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwKPiA+ICsJCQkJdm9pZCAqYnVmZmVy LCBzaXplX3Qgc2l6ZSkKPiA+ICt7Cj4gPiArCWludCByZXQ7Cj4gPiArCj4gPiArCXJldCA9IGhk bWlfYXZpX2luZm9mcmFtZV9jaGVjayhmcmFtZSk7Cj4gPiArCWlmIChyZXQpCj4gPiArCQlyZXR1 cm4gcmV0Owo+ID4gKwo+ID4gKwlyZXR1cm4gaGRtaV9hdmlfaW5mb2ZyYW1lX3BhY2tfb25seShm cmFtZSwgYnVmZmVyLCBzaXplKTsKPiA+ICt9Cj4gPiAgRVhQT1JUX1NZTUJPTChoZG1pX2F2aV9p bmZvZnJhbWVfcGFjayk7Cj4gPiAgCj4gPiAgLyoqCj4gPiBAQCAtMTc4LDggKzIzOCwzMyBAQCBp bnQgaGRtaV9zcGRfaW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJh bWUsCj4gPiAgfQo+ID4gIEVYUE9SVF9TWU1CT0woaGRtaV9zcGRfaW5mb2ZyYW1lX2luaXQpOwo+ ID4gIAo+ID4gK3N0YXRpYyBpbnQgaGRtaV9zcGRfaW5mb2ZyYW1lX2NoZWNrX29ubHkoY29uc3Qg c3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUpCj4gPiArewo+ID4gKwlpZiAoZnJhbWUt PnR5cGUgIT0gSERNSV9JTkZPRlJBTUVfVFlQRV9TUEQgfHwKPiA+ICsJICAgIGZyYW1lLT52ZXJz aW9uICE9IDEgfHwKPiA+ICsJICAgIGZyYW1lLT5sZW5ndGggIT0gSERNSV9TUERfSU5GT0ZSQU1F X1NJWkUpCj4gPiArCQlyZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ICsJcmV0dXJuIDA7Cj4gPiAr fQo+ID4gKwo+ID4gIC8qKgo+ID4gLSAqIGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrKCkgLSB3cml0 ZSBIRE1JIFNQRCBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ID4gKyAqIGhkbWlfc3BkX2lu Zm9mcmFtZV9jaGVjaygpIC0gQ2hlY2sgYW5kIGNoZWNrIGEgSERNSSBTUEQgaW5mb2ZyYW1lCj4g PiArICogQGZyYW1lOiBIRE1JIFNQRCBpbmZvZnJhbWUKPiA+ICsgKgo+ID4gKyAqIFZhbGlkYXRl cyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZp ZWxkcwo+ID4gKyAqIChlZy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMuCj4gPiArICoK PiA+ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24g ZmFpbHVyZS4KPiA+ICsgKi8KPiA+ICtpbnQgaGRtaV9zcGRfaW5mb2ZyYW1lX2NoZWNrKHN0cnVj dCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lKQo+ID4gK3sKPiA+ICsJcmV0dXJuIGhkbWlfc3Bk X2luZm9mcmFtZV9jaGVja19vbmx5KGZyYW1lKTsKPiA+ICt9Cj4gPiArRVhQT1JUX1NZTUJPTCho ZG1pX3NwZF9pbmZvZnJhbWVfY2hlY2spOwo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGhkbWlfc3Bk X2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRlIEhETUkgU1BEIGluZm9mcmFtZSB0byBiaW5h cnkgYnVmZmVyCj4gPiAgICogQGZyYW1lOiBIRE1JIFNQRCBpbmZvZnJhbWUKPiA+ICAgKiBAYnVm ZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiA+ICAgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKPiA+ IEBAIC0xOTIsMTEgKzI3NywxNiBAQCBFWFBPUlRfU1lNQk9MKGhkbWlfc3BkX2luZm9mcmFtZV9p bml0KTsKPiA+ICAgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhl IGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQo+ID4gICAqIGVycm9yIGNvZGUgb24gZmFpbHVy ZS4KPiA+ICAgKi8KPiA+IC1zc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBo ZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIsCj4gPiAtCQkJCXNpemVfdCBz aXplKQo+ID4gK3NzaXplX3QgaGRtaV9zcGRfaW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCBzdHJ1 Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwKPiA+ICsJCQkJICAgICB2b2lkICpidWZmZXIs IHNpemVfdCBzaXplKQo+ID4gIHsKPiA+ICAJdTggKnB0ciA9IGJ1ZmZlcjsKPiA+ICAJc2l6ZV90 IGxlbmd0aDsKPiA+ICsJaW50IHJldDsKPiA+ICsKPiA+ICsJcmV0ID0gaGRtaV9zcGRfaW5mb2Zy YW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ID4gKwlpZiAocmV0KQo+ID4gKwkJcmV0dXJuIHJldDsK PiA+ICAKPiA+ICAJbGVuZ3RoID0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBmcmFtZS0+ bGVuZ3RoOwo+ID4gIAo+ID4gQEAgLTIyMiw2ICszMTIsMzYgQEAgc3NpemVfdCBoZG1pX3NwZF9p bmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVm ZmVyLAo+ID4gIAo+ID4gIAlyZXR1cm4gbGVuZ3RoOwo+ID4gIH0KPiA+ICtFWFBPUlRfU1lNQk9M KGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29ubHkpOwo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGhk bWlfc3BkX2luZm9mcmFtZV9wYWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIFNQRCBpbmZv ZnJhbWUsCj4gPiArICogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFuZCB3cml0ZSBpdCB0 byBiaW5hcnkgYnVmZmVyCj4gPiArICogQGZyYW1lOiBIRE1JIFNQRCBpbmZvZnJhbWUKPiA+ICsg KiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiA+ICsgKiBAc2l6ZTogc2l6ZSBvZiBidWZm ZXIKPiA+ICsgKgo+ID4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lz dGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ID4gKyAqIChlZy4gbGVuZ3RoKSBiYXNl ZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVyIHdoaWNoIHBhY2tzIHRoZSBpbmZvcm1hdGlvbgo+ID4g KyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZyYW1lIHN0cnVjdHVyZSBpbnRvIGEgYmluYXJ5IHJlcHJl c2VudGF0aW9uIHRoYXQKPiA+ICsgKiBjYW4gYmUgd3JpdHRlbiBpbnRvIHRoZSBjb3JyZXNwb25k aW5nIGNvbnRyb2xsZXIgcmVnaXN0ZXJzLiBBbHNvCj4gPiArICogY29tcHV0ZXMgdGhlIGNoZWNr c3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rpb24gNS4zLjUgb2YgdGhlIEhETUkgMS40Cj4gPiArICog c3BlY2lmaWNhdGlvbi4KPiA+ICsgKgo+ID4gKyAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRl cyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCj4gPiArICogZXJy b3IgY29kZSBvbiBmYWlsdXJlLgo+ID4gKyAqLwo+ID4gK3NzaXplX3QgaGRtaV9zcGRfaW5mb2Zy YW1lX3BhY2soc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsCj4gPiArCQkJCXZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gPiArewo+ID4gKwlpbnQgcmV0Owo+ID4gKwo+ID4gKwly ZXQgPSBoZG1pX3NwZF9pbmZvZnJhbWVfY2hlY2soZnJhbWUpOwo+ID4gKwlpZiAocmV0KQo+ID4g KwkJcmV0dXJuIHJldDsKPiA+ICsKPiA+ICsJcmV0dXJuIGhkbWlfc3BkX2luZm9mcmFtZV9wYWNr X29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6ZSk7Cj4gPiArfQo+ID4gIEVYUE9SVF9TWU1CT0woaGRt aV9zcGRfaW5mb2ZyYW1lX3BhY2spOwo+ID4gIAo+ID4gIC8qKgo+ID4gQEAgLTI0Miw4ICszNjIs MzMgQEAgaW50IGhkbWlfYXVkaW9faW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlfYXVkaW9faW5m b2ZyYW1lICpmcmFtZSkKPiA+ICB9Cj4gPiAgRVhQT1JUX1NZTUJPTChoZG1pX2F1ZGlvX2luZm9m cmFtZV9pbml0KTsKPiA+ICAKPiA+ICtzdGF0aWMgaW50IGhkbWlfYXVkaW9faW5mb2ZyYW1lX2No ZWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSkKPiA+ICt7 Cj4gPiArCWlmIChmcmFtZS0+dHlwZSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX0FVRElPIHx8Cj4g PiArCSAgICBmcmFtZS0+dmVyc2lvbiAhPSAxIHx8Cj4gPiArCSAgICBmcmFtZS0+bGVuZ3RoICE9 IEhETUlfQVVESU9fSU5GT0ZSQU1FX1NJWkUpCj4gPiArCQlyZXR1cm4gLUVJTlZBTDsKPiA+ICsK PiA+ICsJcmV0dXJuIDA7Cj4gPiArfQo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGhkbWlfYXVkaW9f aW5mb2ZyYW1lX2NoZWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIGF1ZGlvIGluZm9mcmFt ZQo+ID4gKyAqIEBmcmFtZTogSERNSSBhdWRpbyBpbmZvZnJhbWUKPiA+ICsgKgo+ID4gKyAqIFZh bGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJp dmVkIGZpZWxkcwo+ID4gKyAqIChlZy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMuCj4g PiArICoKPiA+ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNv ZGUgb24gZmFpbHVyZS4KPiA+ICsgKi8KPiA+ICtpbnQgaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hl Y2soc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSkKPiA+ICt7Cj4gPiArCXJldHVy biBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVja19vbmx5KGZyYW1lKTsKPiA+ICt9Cj4gPiArRVhQ T1JUX1NZTUJPTChoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVjayk7Cj4gPiArCj4gPiAgLyoqCj4g PiAtICogaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjaygpIC0gd3JpdGUgSERNSSBhdWRpbyBpbmZv ZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ID4gKyAqIGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2tf b25seSgpIC0gd3JpdGUgSERNSSBhdWRpbyBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ID4g ICAqIEBmcmFtZTogSERNSSBhdWRpbyBpbmZvZnJhbWUKPiA+ICAgKiBAYnVmZmVyOiBkZXN0aW5h dGlvbiBidWZmZXIKPiA+ICAgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKPiA+IEBAIC0yNTYsMTIg KzQwMSwxNyBAQCBFWFBPUlRfU1lNQk9MKGhkbWlfYXVkaW9faW5mb2ZyYW1lX2luaXQpOwo+ID4g ICAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1 ZmZlciBvciBhIG5lZ2F0aXZlCj4gPiAgICogZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ID4gICAq Lwo+ID4gLXNzaXplX3QgaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9hdWRp b19pbmZvZnJhbWUgKmZyYW1lLAo+ID4gLQkJCQkgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUp Cj4gPiArc3NpemVfdCBoZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0 IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSwKPiA+ICsJCQkJICAgICAgIHZvaWQgKmJ1ZmZl ciwgc2l6ZV90IHNpemUpCj4gPiAgewo+ID4gIAl1bnNpZ25lZCBjaGFyIGNoYW5uZWxzOwo+ID4g IAl1OCAqcHRyID0gYnVmZmVyOwo+ID4gIAlzaXplX3QgbGVuZ3RoOwo+ID4gKwlpbnQgcmV0Owo+ ID4gKwo+ID4gKwlyZXQgPSBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVja19vbmx5KGZyYW1lKTsK PiA+ICsJaWYgKHJldCkKPiA+ICsJCXJldHVybiByZXQ7Cj4gPiAgCj4gPiAgCWxlbmd0aCA9IEhE TUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgZnJhbWUtPmxlbmd0aDsKPiA+ICAKPiA+IEBAIC0y OTcsNiArNDQ3LDM2IEBAIHNzaXplX3QgaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjayhzdHJ1Y3Qg aGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lLAo+ID4gIAo+ID4gIAlyZXR1cm4gbGVuZ3RoOwo+ ID4gIH0KPiA+ICtFWFBPUlRfU1lNQk9MKGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2tfb25seSk7 Cj4gPiArCj4gPiArLyoqCj4gPiArICogaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjaygpIC0gQ2hl Y2sgYW5kIGNoZWNrIGEgSERNSSBBdWRpbyBpbmZvZnJhbWUsCj4gPiArICogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgYW5kIHdyaXRlIGl0IHRvIGJpbmFyeSBidWZmZXIKPiA+ICsgKiBA ZnJhbWU6IEhETUkgQXVkaW8gaW5mb2ZyYW1lCj4gPiArICogQGJ1ZmZlcjogZGVzdGluYXRpb24g YnVmZmVyCj4gPiArICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gPiArICoKPiA+ICsgKiBWYWxp ZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZl ZCBmaWVsZHMKPiA+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRl ciB3aGljaCBwYWNrcyB0aGUgaW5mb3JtYXRpb24KPiA+ICsgKiBjb250YWluZWQgaW4gdGhlIEBm cmFtZSBzdHJ1Y3R1cmUgaW50byBhIGJpbmFyeSByZXByZXNlbnRhdGlvbiB0aGF0Cj4gPiArICog Y2FuIGJlIHdyaXR0ZW4gaW50byB0aGUgY29ycmVzcG9uZGluZyBjb250cm9sbGVyIHJlZ2lzdGVy cy4gQWxzbwo+ID4gKyAqIGNvbXB1dGVzIHRoZSBjaGVja3N1bSBhcyByZXF1aXJlZCBieSBzZWN0 aW9uIDUuMy41IG9mIHRoZSBIRE1JIDEuNAo+ID4gKyAqIHNwZWNpZmljYXRpb24uCj4gPiArICoK PiA+ICsgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJpbmFy eSBidWZmZXIgb3IgYSBuZWdhdGl2ZQo+ID4gKyAqIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiA+ ICsgKi8KPiA+ICtzc2l6ZV90IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlf YXVkaW9faW5mb2ZyYW1lICpmcmFtZSwKPiA+ICsJCQkJICB2b2lkICpidWZmZXIsIHNpemVfdCBz aXplKQo+ID4gK3sKPiA+ICsJaW50IHJldDsKPiA+ICsKPiA+ICsJcmV0ID0gaGRtaV9hdWRpb19p bmZvZnJhbWVfY2hlY2soZnJhbWUpOwo+ID4gKwlpZiAocmV0KQo+ID4gKwkJcmV0dXJuIHJldDsK PiA+ICsKPiA+ICsJcmV0dXJuIGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2tfb25seShmcmFtZSwg YnVmZmVyLCBzaXplKTsKPiA+ICt9Cj4gPiAgRVhQT1JUX1NZTUJPTChoZG1pX2F1ZGlvX2luZm9m cmFtZV9wYWNrKTsKPiA+ICAKPiA+ICAvKioKPiA+IEBAIC0zMTksNiArNDk5LDcgQEAgaW50IGhk bWlfdmVuZG9yX2luZm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZy YW1lKQo+ID4gIAkgKiB2YWx1ZQo+ID4gIAkgKi8KPiA+ICAJZnJhbWUtPnMzZF9zdHJ1Y3QgPSBI RE1JXzNEX1NUUlVDVFVSRV9JTlZBTElEOwo+ID4gKwlmcmFtZS0+bGVuZ3RoID0gNDsKPiA+ICAK PiA+ICAJcmV0dXJuIDA7Cj4gPiAgfQo+ID4gQEAgLTMzNSw4ICs1MTYsNDIgQEAgc3RhdGljIGlu dCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGNvbnN0IHN0cnVjdCBoZG1pX3ZlbmRvcl9p bmZvZnJhbWUgKmZyYW0KPiA+ICAJCXJldHVybiA0Owo+ID4gIH0KPiA+ICAKPiA+ICtzdGF0aWMg aW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9jaGVja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX3Zl bmRvcl9pbmZvZnJhbWUgKmZyYW1lKQo+ID4gK3sKPiA+ICsJaWYgKGZyYW1lLT50eXBlICE9IEhE TUlfSU5GT0ZSQU1FX1RZUEVfVkVORE9SIHx8Cj4gPiArCSAgICBmcmFtZS0+dmVyc2lvbiAhPSAx IHx8Cj4gPiArCSAgICBmcmFtZS0+b3VpICE9IEhETUlfSUVFRV9PVUkpCj4gPiArCQlyZXR1cm4g LUVJTlZBTDsKPiA+ICsKPiA+ICsJLyogb25seSBvbmUgb2YgdGhvc2UgY2FuIGJlIHN1cHBsaWVk ICovCj4gPiArCWlmIChmcmFtZS0+dmljICE9IDAgJiYgZnJhbWUtPnMzZF9zdHJ1Y3QgIT0gSERN SV8zRF9TVFJVQ1RVUkVfSU5WQUxJRCkKPiA+ICsJCXJldHVybiAtRUlOVkFMOwo+ID4gKwo+ID4g KwlpZiAoZnJhbWUtPmxlbmd0aCAhPSBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGZyYW1l KSkKPiA+ICsJCXJldHVybiAtRUlOVkFMOwo+ID4gKwo+ID4gKwlyZXR1cm4gMDsKPiA+ICt9Cj4g PiArCj4gPiAgLyoqCj4gPiAtICogaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soKSAtIHdyaXRl IGEgSERNSSB2ZW5kb3IgaW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKPiA+ICsgKiBoZG1pX3Zl bmRvcl9pbmZvZnJhbWVfY2hlY2soKSAtIENoZWNrIGFuZCBjaGVjayBhIEhETUkgdmVuZG9yIGlu Zm9mcmFtZQo+ID4gKyAqIEBmcmFtZTogSERNSSBpbmZvZnJhbWUKPiA+ICsgKgo+ID4gKyAqIFZh bGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJp dmVkIGZpZWxkcwo+ID4gKyAqIChlZy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMuCj4g PiArICoKPiA+ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNv ZGUgb24gZmFpbHVyZS4KPiA+ICsgKi8KPiA+ICtpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2No ZWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lKQo+ID4gK3sKPiA+ICsJZnJh bWUtPmxlbmd0aCA9IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9sZW5ndGgoZnJhbWUpOwo+ID4gKwo+ ID4gKwlyZXR1cm4gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ID4g K30KPiA+ICtFWFBPUlRfU1lNQk9MKGhkbWlfdmVuZG9yX2luZm9mcmFtZV9jaGVjayk7Cj4gPiAr Cj4gPiArLyoqCj4gPiArICogaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2tfb25seSgpIC0gd3Jp dGUgYSBIRE1JIHZlbmRvciBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ID4gICAqIEBmcmFt ZTogSERNSSBpbmZvZnJhbWUKPiA+ICAgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiA+ ICAgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKPiA+IEBAIC0zNDksMTcgKzU2NCwxNiBAQCBzdGF0 aWMgaW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9sZW5ndGgoY29uc3Qgc3RydWN0IGhkbWlfdmVu ZG9yX2luZm9mcmFtZSAqZnJhbQo+ID4gICAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBw YWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCj4gPiAgICogZXJyb3Ig Y29kZSBvbiBmYWlsdXJlLgo+ID4gICAqLwo+ID4gLXNzaXplX3QgaGRtaV92ZW5kb3JfaW5mb2Zy YW1lX3BhY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUsCj4gPiAtCQkJCSB2 b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ID4gK3NzaXplX3QgaGRtaV92ZW5kb3JfaW5mb2Zy YW1lX3BhY2tfb25seShjb25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtZSwK PiA+ICsJCQkJCXZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gPiAgewo+ID4gIAl1OCAqcHRy ID0gYnVmZmVyOwo+ID4gIAlzaXplX3QgbGVuZ3RoOwo+ID4gKwlpbnQgcmV0Owo+ID4gIAo+ID4g LQkvKiBvbmx5IG9uZSBvZiB0aG9zZSBjYW4gYmUgc3VwcGxpZWQgKi8KPiA+IC0JaWYgKGZyYW1l LT52aWMgIT0gMCAmJiBmcmFtZS0+czNkX3N0cnVjdCAhPSBIRE1JXzNEX1NUUlVDVFVSRV9JTlZB TElEKQo+ID4gLQkJcmV0dXJuIC1FSU5WQUw7Cj4gPiAtCj4gPiAtCWZyYW1lLT5sZW5ndGggPSBo ZG1pX3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGZyYW1lKTsKPiA+ICsJcmV0ID0gaGRtaV92ZW5k b3JfaW5mb2ZyYW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ID4gKwlpZiAocmV0KQo+ID4gKwkJcmV0 dXJuIHJldDsKPiA+ICAKPiA+ICAJbGVuZ3RoID0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUg KyBmcmFtZS0+bGVuZ3RoOwo+ID4gIAo+ID4gQEAgLTM5NCwyNCArNjA4LDEzNCBAQCBzc2l6ZV90 IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUg KmZyYW1lLAo+ID4gIAo+ID4gIAlyZXR1cm4gbGVuZ3RoOwo+ID4gIH0KPiA+ICtFWFBPUlRfU1lN Qk9MKGhkbWlfdmVuZG9yX2luZm9mcmFtZV9wYWNrX29ubHkpOwo+ID4gKwo+ID4gKy8qKgo+ID4g KyAqIGhkbWlfdmVuZG9yX2luZm9mcmFtZV9wYWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1J IFZlbmRvciBpbmZvZnJhbWUsCj4gPiArICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGFuZCB3cml0ZSBpdCB0byBiaW5hcnkgYnVmZmVyCj4gPiArICogQGZyYW1lOiBIRE1JIFZlbmRv ciBpbmZvZnJhbWUKPiA+ICsgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiA+ICsgKiBA c2l6ZTogc2l6ZSBvZiBidWZmZXIKPiA+ICsgKgo+ID4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBp bmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ID4gKyAq IChlZy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVyIHdoaWNoIHBhY2tzIHRo ZSBpbmZvcm1hdGlvbgo+ID4gKyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZyYW1lIHN0cnVjdHVyZSBp bnRvIGEgYmluYXJ5IHJlcHJlc2VudGF0aW9uIHRoYXQKPiA+ICsgKiBjYW4gYmUgd3JpdHRlbiBp bnRvIHRoZSBjb3JyZXNwb25kaW5nIGNvbnRyb2xsZXIgcmVnaXN0ZXJzLiBBbHNvCj4gPiArICog Y29tcHV0ZXMgdGhlIGNoZWNrc3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rpb24gNS4zLjUgb2YgdGhl IEhETUkgMS40Cj4gPiArICogc3BlY2lmaWNhdGlvbi4KPiA+ICsgKgo+ID4gKyAqIFJldHVybnMg dGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5l Z2F0aXZlCj4gPiArICogZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ID4gKyAqLwo+ID4gK3NzaXpl X3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFt ZSAqZnJhbWUsCj4gPiArCQkJCSAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gPiArewo+ ID4gKwlpbnQgcmV0Owo+ID4gKwo+ID4gKwlyZXQgPSBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hl Y2soZnJhbWUpOwo+ID4gKwlpZiAocmV0KQo+ID4gKwkJcmV0dXJuIHJldDsKPiA+ICsKPiA+ICsJ cmV0dXJuIGhkbWlfdmVuZG9yX2luZm9mcmFtZV9wYWNrX29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6 ZSk7Cj4gPiArfQo+ID4gIEVYUE9SVF9TWU1CT0woaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2sp Owo+ID4gIAo+ID4gK3N0YXRpYyBpbnQKPiA+ICtoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2No ZWNrX29ubHkoY29uc3QgdW5pb24gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUpCj4g PiArewo+ID4gKwlpZiAoZnJhbWUtPmFueS50eXBlICE9IEhETUlfSU5GT0ZSQU1FX1RZUEVfVkVO RE9SIHx8Cj4gPiArCSAgICBmcmFtZS0+YW55LnZlcnNpb24gIT0gMSkKPiA+ICsJCXJldHVybiAt RUlOVkFMOwo+ID4gKwo+ID4gKwlyZXR1cm4gMDsKPiA+ICt9Cj4gPiArCj4gPiAgLyoKPiA+IC0g KiBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2soKSAtIHdyaXRlIGEgdmVuZG9yIGluZm9m cmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gPiArICogaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9j aGVjaygpIC0gY2hlY2sgYW5kIGNoZWNrIGEgdmVuZG9yIGluZm9mcmFtZQo+ID4gKyAqLwo+ID4g K3N0YXRpYyBpbnQKPiA+ICtoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2NoZWNrKHVuaW9uIGhk bWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lKQo+ID4gK3sKPiA+ICsJaW50IHJldDsKPiA+ ICsKPiA+ICsJcmV0ID0gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9jaGVja19vbmx5KGZyYW1l KTsKPiA+ICsJaWYgKHJldCkKPiA+ICsJCXJldHVybiByZXQ7Cj4gPiArCj4gPiArCS8qIHdlIG9u bHkga25vdyBhYm91dCBIRE1JIHZlbmRvciBpbmZvZnJhbWVzICovCj4gPiArCWlmIChmcmFtZS0+ YW55Lm91aSAhPSBIRE1JX0lFRUVfT1VJKQo+ID4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gPiArCj4g PiArCXJldHVybiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2soJmZyYW1lLT5oZG1pKTsKPiA+ ICt9Cj4gPiArCj4gPiArLyoKPiA+ICsgKiBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2tf b25seSgpIC0gd3JpdGUgYSB2ZW5kb3IgaW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKPiA+ICAg Ki8KPiA+ICBzdGF0aWMgc3NpemVfdAo+ID4gLWhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfcGFj ayh1bmlvbiBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lICpmcmFtZSwKPiA+IC0JCQkgICB2b2lk ICpidWZmZXIsIHNpemVfdCBzaXplKQo+ID4gK2hkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfcGFj a19vbmx5KGNvbnN0IHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAo+ID4g KwkJCQkgICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiA+ICB7Cj4gPiArCWludCByZXQ7 Cj4gPiArCj4gPiArCXJldCA9IGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfY2hlY2tfb25seShm cmFtZSk7Cj4gPiArCWlmIChyZXQpCj4gPiArCQlyZXR1cm4gcmV0Owo+ID4gKwo+ID4gIAkvKiB3 ZSBvbmx5IGtub3cgYWJvdXQgSERNSSB2ZW5kb3IgaW5mb2ZyYW1lcyAqLwo+ID4gIAlpZiAoZnJh bWUtPmFueS5vdWkgIT0gSERNSV9JRUVFX09VSSkKPiA+ICAJCXJldHVybiAtRUlOVkFMOwo+ID4g IAo+ID4gLQlyZXR1cm4gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soJmZyYW1lLT5oZG1pLCBi dWZmZXIsIHNpemUpOwo+ID4gKwlyZXR1cm4gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2tfb25s eSgmZnJhbWUtPmhkbWksIGJ1ZmZlciwgc2l6ZSk7Cj4gPiArfQo+ID4gKwo+ID4gKy8qCj4gPiAr ICogaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNrKCkgLSBjaGVjayBhbmQgY2hlY2sgYSB2 ZW5kb3IgaW5mb2ZyYW1lLAo+ID4gKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGFuZCB3cml0ZSBpdCB0byBiaW5hcnkgYnVmZmVyCj4gPiArICovCj4gPiAr c3RhdGljIHNzaXplX3QKPiA+ICtoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2sodW5pb24g aGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUsCj4gPiArCQkJICAgICAgIHZvaWQgKmJ1 ZmZlciwgc2l6ZV90IHNpemUpCj4gPiArewo+ID4gKwlpbnQgcmV0Owo+ID4gKwo+ID4gKwlyZXQg PSBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2NoZWNrKGZyYW1lKTsKPiA+ICsJaWYgKHJldCkK PiA+ICsJCXJldHVybiByZXQ7Cj4gPiArCj4gPiArCXJldHVybiBoZG1pX3ZlbmRvcl9hbnlfaW5m b2ZyYW1lX3BhY2tfb25seShmcmFtZSwgYnVmZmVyLCBzaXplKTsKPiA+ICt9Cj4gPiArCj4gPiAr LyoqCj4gPiArICogaGRtaV9pbmZvZnJhbWVfY2hlY2soKSAtIENoZWNrIGNoZWNrIGEgSERNSSBp bmZvZnJhbWUKPiA+ICsgKiBAZnJhbWU6IEhETUkgaW5mb2ZyYW1lCj4gPiArICoKPiA+ICsgKiBW YWxpZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVy aXZlZCBmaWVsZHMKPiA+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ ID4gKyAqCj4gPiArICogUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2ZSBlcnJvciBj b2RlIG9uIGZhaWx1cmUuCj4gPiArICovCj4gPiAraW50Cj4gPiAraGRtaV9pbmZvZnJhbWVfY2hl Y2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lKQo+ID4gK3sKPiA+ICsJc3dpdGNoIChmcmFt ZS0+YW55LnR5cGUpIHsKPiA+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX0FWSToKPiA+ICsJ CXJldHVybiBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2soJmZyYW1lLT5hdmkpOwo+ID4gKwljYXNl IEhETUlfSU5GT0ZSQU1FX1RZUEVfU1BEOgo+ID4gKwkJcmV0dXJuIGhkbWlfc3BkX2luZm9mcmFt ZV9jaGVjaygmZnJhbWUtPnNwZCk7Cj4gPiArCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9BVURJ TzoKPiA+ICsJCXJldHVybiBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVjaygmZnJhbWUtPmF1ZGlv KTsKPiA+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRPUjoKPiA+ICsJCXJldHVybiBo ZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2NoZWNrKCZmcmFtZS0+dmVuZG9yKTsKPiA+ICsJZGVm YXVsdDoKPiA+ICsJCVdBUk4oMSwgIkJhZCBpbmZvZnJhbWUgdHlwZSAlZFxuIiwgZnJhbWUtPmFu eS50eXBlKTsKPiA+ICsJCXJldHVybiAtRUlOVkFMOwo+ID4gKwl9Cj4gPiAgfQo+ID4gK0VYUE9S VF9TWU1CT0woaGRtaV9pbmZvZnJhbWVfY2hlY2spOwo+ID4gIAo+ID4gIC8qKgo+ID4gLSAqIGhk bWlfaW5mb2ZyYW1lX3BhY2soKSAtIHdyaXRlIGEgSERNSSBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1 ZmZlcgo+ID4gKyAqIGhkbWlfaW5mb2ZyYW1lX3BhY2tfb25seSgpIC0gd3JpdGUgYSBIRE1JIGlu Zm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gPiAgICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQo+ ID4gICAqIEBidWZmZXI6IGRlc3RpbmF0aW9uIGJ1ZmZlcgo+ID4gICAqIEBzaXplOiBzaXplIG9m IGJ1ZmZlcgo+ID4gQEAgLTQyNSw3ICs3NDksNTYgQEAgaGRtaV92ZW5kb3JfYW55X2luZm9mcmFt ZV9wYWNrKHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAo+ID4gICAqIGVy cm9yIGNvZGUgb24gZmFpbHVyZS4KPiA+ICAgKi8KPiA+ICBzc2l6ZV90Cj4gPiAtaGRtaV9pbmZv ZnJhbWVfcGFjayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZlciwgc2l6 ZV90IHNpemUpCj4gPiAraGRtaV9pbmZvZnJhbWVfcGFja19vbmx5KGNvbnN0IHVuaW9uIGhkbWlf aW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiA+ICt7Cj4gPiAr CXNzaXplX3QgbGVuZ3RoOwo+ID4gKwo+ID4gKwlzd2l0Y2ggKGZyYW1lLT5hbnkudHlwZSkgewo+ ID4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfQVZJOgo+ID4gKwkJbGVuZ3RoID0gaGRtaV9h dmlfaW5mb2ZyYW1lX3BhY2tfb25seSgmZnJhbWUtPmF2aSwKPiA+ICsJCQkJCQkgICAgICBidWZm ZXIsIHNpemUpOwo+ID4gKwkJYnJlYWs7Cj4gPiArCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9T UEQ6Cj4gPiArCQlsZW5ndGggPSBoZG1pX3NwZF9pbmZvZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+ c3BkLAo+ID4gKwkJCQkJCSAgICAgIGJ1ZmZlciwgc2l6ZSk7Cj4gPiArCQlicmVhazsKPiA+ICsJ Y2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX0FVRElPOgo+ID4gKwkJbGVuZ3RoID0gaGRtaV9hdWRp b19pbmZvZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+YXVkaW8sCj4gPiArCQkJCQkJCWJ1ZmZlciwg c2l6ZSk7Cj4gPiArCQlicmVhazsKPiA+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRP UjoKPiA+ICsJCWxlbmd0aCA9IGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfcGFja19vbmx5KCZm cmFtZS0+dmVuZG9yLAo+ID4gKwkJCQkJCQkgICAgIGJ1ZmZlciwgc2l6ZSk7Cj4gPiArCQlicmVh azsKPiA+ICsJZGVmYXVsdDoKPiA+ICsJCVdBUk4oMSwgIkJhZCBpbmZvZnJhbWUgdHlwZSAlZFxu IiwgZnJhbWUtPmFueS50eXBlKTsKPiA+ICsJCWxlbmd0aCA9IC1FSU5WQUw7Cj4gPiArCX0KPiA+ ICsKPiA+ICsJcmV0dXJuIGxlbmd0aDsKPiA+ICt9Cj4gPiArRVhQT1JUX1NZTUJPTChoZG1pX2lu Zm9mcmFtZV9wYWNrX29ubHkpOwo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGhkbWlfaW5mb2ZyYW1l X3BhY2soKSAtIENoZWNrIGNoZWNrIGEgSERNSSBpbmZvZnJhbWUsCj4gCj4gQ2hlY2sgY2hlY2s/ Cj4gCj4gPiArICogICAgICAgICAgICAgICAgICAgICAgICAgYW5kIHdyaXRlIGl0IHRvIGJpbmFy eSBidWZmZXIKPiA+ICsgKiBAZnJhbWU6IEhETUkgaW5mb2ZyYW1lCj4gPiArICogQGJ1ZmZlcjog ZGVzdGluYXRpb24gYnVmZmVyCj4gPiArICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gPiArICoK PiA+ICsgKiBWYWxpZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVw ZGF0ZXMgZGVyaXZlZCBmaWVsZHMKPiA+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIg ZmllbGRzLCBhZnRlciB3aGljaCBwYWNrcyB0aGUgaW5mb3JtYXRpb24KPiA+ICsgKiBjb250YWlu ZWQgaW4gdGhlIEBmcmFtZSBzdHJ1Y3R1cmUgaW50byBhIGJpbmFyeSByZXByZXNlbnRhdGlvbiB0 aGF0Cj4gPiArICogY2FuIGJlIHdyaXR0ZW4gaW50byB0aGUgY29ycmVzcG9uZGluZyBjb250cm9s bGVyIHJlZ2lzdGVycy4gQWxzbwo+ID4gKyAqIGNvbXB1dGVzIHRoZSBjaGVja3N1bSBhcyByZXF1 aXJlZCBieSBzZWN0aW9uIDUuMy41IG9mIHRoZSBIRE1JIDEuNAo+ID4gKyAqIHNwZWNpZmljYXRp b24uCj4gPiArICoKPiA+ICsgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGlu dG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQo+ID4gKyAqIGVycm9yIGNvZGUgb24g ZmFpbHVyZS4KPiA+ICsgKi8KPiA+ICtzc2l6ZV90Cj4gPiAraGRtaV9pbmZvZnJhbWVfcGFjayh1 bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsCj4gPiArCQkgICAgdm9pZCAqYnVmZmVyLCBzaXpl X3Qgc2l6ZSkKPiA+ICB7Cj4gPiAgCXNzaXplX3QgbGVuZ3RoOwo+ID4gIAo+ID4gZGlmZiAtLWdp dCBhL2luY2x1ZGUvbGludXgvaGRtaS5oIGIvaW5jbHVkZS9saW51eC9oZG1pLmgKPiA+IGluZGV4 IGJjZTFhYmIxZmU1Ny4uYzc2YjUwYTQ4ZTQ4IDEwMDY0NAo+ID4gLS0tIGEvaW5jbHVkZS9saW51 eC9oZG1pLmgKPiA+ICsrKyBiL2luY2x1ZGUvbGludXgvaGRtaS5oCj4gPiBAQCAtMTYzLDYgKzE2 Myw5IEBAIHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgewo+ID4gIGludCBoZG1pX2F2aV9pbmZv ZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSk7Cj4gPiAgc3NpemVf dCBoZG1pX2F2aV9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFt ZSwgdm9pZCAqYnVmZmVyLAo+ID4gIAkJCQlzaXplX3Qgc2l6ZSk7Cj4gPiArc3NpemVfdCBoZG1p X2F2aV9pbmZvZnJhbWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUg KmZyYW1lLAo+ID4gKwkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK2lu dCBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJh bWUpOwo+ID4gIAo+ID4gIGVudW0gaGRtaV9zcGRfc2RpIHsKPiA+ICAJSERNSV9TUERfU0RJX1VO S05PV04sCj4gPiBAQCAtMTk0LDYgKzE5Nyw5IEBAIGludCBoZG1pX3NwZF9pbmZvZnJhbWVfaW5p dChzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwKPiA+ICAJCQkgICAgY29uc3QgY2hh ciAqdmVuZG9yLCBjb25zdCBjaGFyICpwcm9kdWN0KTsKPiA+ICBzc2l6ZV90IGhkbWlfc3BkX2lu Zm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZm ZXIsCj4gPiAgCQkJCXNpemVfdCBzaXplKTsKPiA+ICtzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFt ZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsCj4gPiAr CQkJCSAgICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4gPiAraW50IGhkbWlfc3BkX2lu Zm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSk7Cj4gPiAgCj4g PiAgZW51bSBoZG1pX2F1ZGlvX2NvZGluZ190eXBlIHsKPiA+ICAJSERNSV9BVURJT19DT0RJTkdf VFlQRV9TVFJFQU0sCj4gPiBAQCAtMjcyLDYgKzI3OCw5IEBAIHN0cnVjdCBoZG1pX2F1ZGlvX2lu Zm9mcmFtZSB7Cj4gPiAgaW50IGhkbWlfYXVkaW9faW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlf YXVkaW9faW5mb2ZyYW1lICpmcmFtZSk7Cj4gPiAgc3NpemVfdCBoZG1pX2F1ZGlvX2luZm9mcmFt ZV9wYWNrKHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJhbWUsCj4gPiAgCQkJCSAgdm9p ZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4gPiArc3NpemVfdCBoZG1pX2F1ZGlvX2luZm9mcmFt ZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSwKPiA+ ICsJCQkJICAgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK2ludCBoZG1pX2F1 ZGlvX2luZm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lKTsK PiA+ICAKPiA+ICBlbnVtIGhkbWlfM2Rfc3RydWN0dXJlIHsKPiA+ICAJSERNSV8zRF9TVFJVQ1RV UkVfSU5WQUxJRCA9IC0xLAo+ID4gQEAgLTI5OSw2ICszMDgsOSBAQCBzdHJ1Y3QgaGRtaV92ZW5k b3JfaW5mb2ZyYW1lIHsKPiA+ICBpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2luaXQoc3RydWN0 IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUpOwo+ID4gIHNzaXplX3QgaGRtaV92ZW5kb3Jf aW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUsCj4gPiAg CQkJCSAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK3NzaXplX3QgaGRtaV92ZW5k b3JfaW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1l ICpmcmFtZSwKPiA+ICsJCQkJCXZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK2ludCBo ZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAq ZnJhbWUpOwo+ID4gIAo+ID4gIHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgewo+ID4g IAlzdHJ1Y3Qgewo+ID4gQEAgLTMzMCw4ICszNDIsMTEgQEAgdW5pb24gaGRtaV9pbmZvZnJhbWUg ewo+ID4gIAlzdHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgYXVkaW87Cj4gPiAgfTsKPiA+ICAK PiA+IC1zc2l6ZV90Cj4gPiAtaGRtaV9pbmZvZnJhbWVfcGFjayh1bmlvbiBoZG1pX2luZm9mcmFt ZSAqZnJhbWUsIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK3NzaXplX3QgaGRtaV9p bmZvZnJhbWVfcGFjayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZlciwK PiA+ICsJCQkgICAgc2l6ZV90IHNpemUpOwo+ID4gK3NzaXplX3QgaGRtaV9pbmZvZnJhbWVfcGFj a19vbmx5KGNvbnN0IHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwKPiA+ICsJCQkJIHZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK2ludCBoZG1pX2luZm9mcmFtZV9jaGVjayh1bmlv biBoZG1pX2luZm9mcmFtZSAqZnJhbWUpOwo+ID4gIGludCBoZG1pX2luZm9mcmFtZV91bnBhY2so dW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lLAo+ID4gIAkJCSAgY29uc3Qgdm9pZCAqYnVmZmVy LCBzaXplX3Qgc2l6ZSk7Cj4gPiAgdm9pZCBoZG1pX2luZm9mcmFtZV9sb2coY29uc3QgY2hhciAq bGV2ZWwsIHN0cnVjdCBkZXZpY2UgKmRldiwKPiA+IAo+IAo+IFJlZ2FyZHMsCj4gCj4gCUhhbnMK Ci0tIApWaWxsZSBTeXJqw6Rsw6QKSW50ZWwKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga01.intel.com ([192.55.52.88]:25813 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728313AbeIUUVw (ORCPT ); Fri, 21 Sep 2018 16:21:52 -0400 Date: Fri, 21 Sep 2018 17:30:02 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Hans Verkuil Cc: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org Subject: Re: [PATCH 04/18] video/hdmi: Constify infoframe passed to the pack functions Message-ID: <20180921143002.GY5565@intel.com> References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-5-ville.syrjala@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: Sender: linux-media-owner@vger.kernel.org List-ID: On Fri, Sep 21, 2018 at 10:24:25AM +0200, Hans Verkuil wrote: > On 09/20/18 20:51, Ville Syrjala wrote: > > From: Ville Syrjälä > > > > Let's make the infoframe pack functions usable with a const infoframe > > structure. This allows us to precompute the infoframe earlier, and still > > pack it later when we're no longer allowed to modify the structure. > > So now we end up with a _check()+_pack_only() or _pack() functions > > depending on whether you want to precompute the infoframes or not. > > The names aren't greate but I was lazy and didn't want to change all the > > greate -> great Thanks for reading through it. Fixed up all the crap you spotted. > > > drivers. > > > > v2: Deal with exynos churn > > Actually export the new funcs > > > > Cc: Thierry Reding > > Cc: Hans Verkuil > > Cc: linux-media@vger.kernel.org > > Signed-off-by: Ville Syrjälä > > --- > > drivers/video/hdmi.c | 425 +++++++++++++++++++++++++++++++++++++++++++++++---- > > include/linux/hdmi.h | 19 ++- > > 2 files changed, 416 insertions(+), 28 deletions(-) > > > > diff --git a/drivers/video/hdmi.c b/drivers/video/hdmi.c > > index 53e7ee2c83fc..9507f668a569 100644 > > --- a/drivers/video/hdmi.c > > +++ b/drivers/video/hdmi.c > > @@ -68,8 +68,36 @@ int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame) > > } > > EXPORT_SYMBOL(hdmi_avi_infoframe_init); > > > > +static int hdmi_avi_infoframe_check_only(const struct hdmi_avi_infoframe *frame) > > +{ > > + if (frame->type != HDMI_INFOFRAME_TYPE_AVI || > > + frame->version != 2 || > > + frame->length != HDMI_AVI_INFOFRAME_SIZE) > > + return -EINVAL; > > + > > + if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9) > > + return -EINVAL; > > + > > + return 0; > > +} > > + > > /** > > - * hdmi_avi_infoframe_pack() - write HDMI AVI infoframe to binary buffer > > + * hdmi_avi_infoframe_check() - Check and check a HDMI AVI infoframe > > "Check and check"? This is repeated elsewhere as well (clearly copy-and-paste). > > > + * @frame: HDMI AVI infoframe > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields. > > + * > > + * Returns 0 on success or a negative error code on failure. > > + */ > > +int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame) > > +{ > > + return hdmi_avi_infoframe_check_only(frame); > > +} > > +EXPORT_SYMBOL(hdmi_avi_infoframe_check); > > + > > +/** > > + * hdmi_avi_infoframe_pack_only() - write HDMI AVI infoframe to binary buffer > > * @frame: HDMI AVI infoframe > > * @buffer: destination buffer > > * @size: size of buffer > > @@ -82,20 +110,22 @@ EXPORT_SYMBOL(hdmi_avi_infoframe_init); > > * Returns the number of bytes packed into the binary buffer or a negative > > * error code on failure. > > */ > > -ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, > > - size_t size) > > +ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame, > > + void *buffer, size_t size) > > { > > u8 *ptr = buffer; > > size_t length; > > + int ret; > > + > > + ret = hdmi_avi_infoframe_check_only(frame); > > + if (ret) > > + return ret; > > > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > > > if (size < length) > > return -ENOSPC; > > > > - if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9) > > - return -EINVAL; > > - > > memset(buffer, 0, size); > > > > ptr[0] = frame->type; > > @@ -152,6 +182,36 @@ ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, > > > > return length; > > } > > +EXPORT_SYMBOL(hdmi_avi_infoframe_pack_only); > > + > > +/** > > + * hdmi_avi_infoframe_pack() - Check and check a HDMI AVI infoframe, > > + * and write it to binary buffer > > + * @frame: HDMI AVI infoframe > > + * @buffer: destination buffer > > + * @size: size of buffer > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields, after which packs the information > > which packs -> which it packs > > Ditto elsewhere. > > > + * contained in the @frame structure into a binary representation that > > + * can be written into the corresponding controller registers. Also > > Also -> This function also > > Ditto elsewhere. > > > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > > + * specification. > > + * > > + * Returns the number of bytes packed into the binary buffer or a negative > > + * error code on failure. > > + */ > > +ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, > > + void *buffer, size_t size) > > +{ > > + int ret; > > + > > + ret = hdmi_avi_infoframe_check(frame); > > + if (ret) > > + return ret; > > + > > + return hdmi_avi_infoframe_pack_only(frame, buffer, size); > > +} > > EXPORT_SYMBOL(hdmi_avi_infoframe_pack); > > > > /** > > @@ -178,8 +238,33 @@ int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, > > } > > EXPORT_SYMBOL(hdmi_spd_infoframe_init); > > > > +static int hdmi_spd_infoframe_check_only(const struct hdmi_spd_infoframe *frame) > > +{ > > + if (frame->type != HDMI_INFOFRAME_TYPE_SPD || > > + frame->version != 1 || > > + frame->length != HDMI_SPD_INFOFRAME_SIZE) > > + return -EINVAL; > > + > > + return 0; > > +} > > + > > /** > > - * hdmi_spd_infoframe_pack() - write HDMI SPD infoframe to binary buffer > > + * hdmi_spd_infoframe_check() - Check and check a HDMI SPD infoframe > > + * @frame: HDMI SPD infoframe > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields. > > + * > > + * Returns 0 on success or a negative error code on failure. > > + */ > > +int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame) > > +{ > > + return hdmi_spd_infoframe_check_only(frame); > > +} > > +EXPORT_SYMBOL(hdmi_spd_infoframe_check); > > + > > +/** > > + * hdmi_spd_infoframe_pack_only() - write HDMI SPD infoframe to binary buffer > > * @frame: HDMI SPD infoframe > > * @buffer: destination buffer > > * @size: size of buffer > > @@ -192,11 +277,16 @@ EXPORT_SYMBOL(hdmi_spd_infoframe_init); > > * Returns the number of bytes packed into the binary buffer or a negative > > * error code on failure. > > */ > > -ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, > > - size_t size) > > +ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame, > > + void *buffer, size_t size) > > { > > u8 *ptr = buffer; > > size_t length; > > + int ret; > > + > > + ret = hdmi_spd_infoframe_check_only(frame); > > + if (ret) > > + return ret; > > > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > > > @@ -222,6 +312,36 @@ ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, > > > > return length; > > } > > +EXPORT_SYMBOL(hdmi_spd_infoframe_pack_only); > > + > > +/** > > + * hdmi_spd_infoframe_pack() - Check and check a HDMI SPD infoframe, > > + * and write it to binary buffer > > + * @frame: HDMI SPD infoframe > > + * @buffer: destination buffer > > + * @size: size of buffer > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields, after which packs the information > > + * contained in the @frame structure into a binary representation that > > + * can be written into the corresponding controller registers. Also > > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > > + * specification. > > + * > > + * Returns the number of bytes packed into the binary buffer or a negative > > + * error code on failure. > > + */ > > +ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, > > + void *buffer, size_t size) > > +{ > > + int ret; > > + > > + ret = hdmi_spd_infoframe_check(frame); > > + if (ret) > > + return ret; > > + > > + return hdmi_spd_infoframe_pack_only(frame, buffer, size); > > +} > > EXPORT_SYMBOL(hdmi_spd_infoframe_pack); > > > > /** > > @@ -242,8 +362,33 @@ int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame) > > } > > EXPORT_SYMBOL(hdmi_audio_infoframe_init); > > > > +static int hdmi_audio_infoframe_check_only(const struct hdmi_audio_infoframe *frame) > > +{ > > + if (frame->type != HDMI_INFOFRAME_TYPE_AUDIO || > > + frame->version != 1 || > > + frame->length != HDMI_AUDIO_INFOFRAME_SIZE) > > + return -EINVAL; > > + > > + return 0; > > +} > > + > > +/** > > + * hdmi_audio_infoframe_check() - Check and check a HDMI audio infoframe > > + * @frame: HDMI audio infoframe > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields. > > + * > > + * Returns 0 on success or a negative error code on failure. > > + */ > > +int hdmi_audio_infoframe_check(struct hdmi_audio_infoframe *frame) > > +{ > > + return hdmi_audio_infoframe_check_only(frame); > > +} > > +EXPORT_SYMBOL(hdmi_audio_infoframe_check); > > + > > /** > > - * hdmi_audio_infoframe_pack() - write HDMI audio infoframe to binary buffer > > + * hdmi_audio_infoframe_pack_only() - write HDMI audio infoframe to binary buffer > > * @frame: HDMI audio infoframe > > * @buffer: destination buffer > > * @size: size of buffer > > @@ -256,12 +401,17 @@ EXPORT_SYMBOL(hdmi_audio_infoframe_init); > > * Returns the number of bytes packed into the binary buffer or a negative > > * error code on failure. > > */ > > -ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > > - void *buffer, size_t size) > > +ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame, > > + void *buffer, size_t size) > > { > > unsigned char channels; > > u8 *ptr = buffer; > > size_t length; > > + int ret; > > + > > + ret = hdmi_audio_infoframe_check_only(frame); > > + if (ret) > > + return ret; > > > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > > > @@ -297,6 +447,36 @@ ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > > > > return length; > > } > > +EXPORT_SYMBOL(hdmi_audio_infoframe_pack_only); > > + > > +/** > > + * hdmi_audio_infoframe_pack() - Check and check a HDMI Audio infoframe, > > + * and write it to binary buffer > > + * @frame: HDMI Audio infoframe > > + * @buffer: destination buffer > > + * @size: size of buffer > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields, after which packs the information > > + * contained in the @frame structure into a binary representation that > > + * can be written into the corresponding controller registers. Also > > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > > + * specification. > > + * > > + * Returns the number of bytes packed into the binary buffer or a negative > > + * error code on failure. > > + */ > > +ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > > + void *buffer, size_t size) > > +{ > > + int ret; > > + > > + ret = hdmi_audio_infoframe_check(frame); > > + if (ret) > > + return ret; > > + > > + return hdmi_audio_infoframe_pack_only(frame, buffer, size); > > +} > > EXPORT_SYMBOL(hdmi_audio_infoframe_pack); > > > > /** > > @@ -319,6 +499,7 @@ int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame) > > * value > > */ > > frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID; > > + frame->length = 4; > > > > return 0; > > } > > @@ -335,8 +516,42 @@ static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *fram > > return 4; > > } > > > > +static int hdmi_vendor_infoframe_check_only(const struct hdmi_vendor_infoframe *frame) > > +{ > > + if (frame->type != HDMI_INFOFRAME_TYPE_VENDOR || > > + frame->version != 1 || > > + frame->oui != HDMI_IEEE_OUI) > > + return -EINVAL; > > + > > + /* only one of those can be supplied */ > > + if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) > > + return -EINVAL; > > + > > + if (frame->length != hdmi_vendor_infoframe_length(frame)) > > + return -EINVAL; > > + > > + return 0; > > +} > > + > > /** > > - * hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary buffer > > + * hdmi_vendor_infoframe_check() - Check and check a HDMI vendor infoframe > > + * @frame: HDMI infoframe > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields. > > + * > > + * Returns 0 on success or a negative error code on failure. > > + */ > > +int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame) > > +{ > > + frame->length = hdmi_vendor_infoframe_length(frame); > > + > > + return hdmi_vendor_infoframe_check_only(frame); > > +} > > +EXPORT_SYMBOL(hdmi_vendor_infoframe_check); > > + > > +/** > > + * hdmi_vendor_infoframe_pack_only() - write a HDMI vendor infoframe to binary buffer > > * @frame: HDMI infoframe > > * @buffer: destination buffer > > * @size: size of buffer > > @@ -349,17 +564,16 @@ static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *fram > > * Returns the number of bytes packed into the binary buffer or a negative > > * error code on failure. > > */ > > -ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > > - void *buffer, size_t size) > > +ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame, > > + void *buffer, size_t size) > > { > > u8 *ptr = buffer; > > size_t length; > > + int ret; > > > > - /* only one of those can be supplied */ > > - if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) > > - return -EINVAL; > > - > > - frame->length = hdmi_vendor_infoframe_length(frame); > > + ret = hdmi_vendor_infoframe_check_only(frame); > > + if (ret) > > + return ret; > > > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > > > @@ -394,24 +608,134 @@ ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > > > > return length; > > } > > +EXPORT_SYMBOL(hdmi_vendor_infoframe_pack_only); > > + > > +/** > > + * hdmi_vendor_infoframe_pack() - Check and check a HDMI Vendor infoframe, > > + * and write it to binary buffer > > + * @frame: HDMI Vendor infoframe > > + * @buffer: destination buffer > > + * @size: size of buffer > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields, after which packs the information > > + * contained in the @frame structure into a binary representation that > > + * can be written into the corresponding controller registers. Also > > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > > + * specification. > > + * > > + * Returns the number of bytes packed into the binary buffer or a negative > > + * error code on failure. > > + */ > > +ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > > + void *buffer, size_t size) > > +{ > > + int ret; > > + > > + ret = hdmi_vendor_infoframe_check(frame); > > + if (ret) > > + return ret; > > + > > + return hdmi_vendor_infoframe_pack_only(frame, buffer, size); > > +} > > EXPORT_SYMBOL(hdmi_vendor_infoframe_pack); > > > > +static int > > +hdmi_vendor_any_infoframe_check_only(const union hdmi_vendor_any_infoframe *frame) > > +{ > > + if (frame->any.type != HDMI_INFOFRAME_TYPE_VENDOR || > > + frame->any.version != 1) > > + return -EINVAL; > > + > > + return 0; > > +} > > + > > /* > > - * hdmi_vendor_any_infoframe_pack() - write a vendor infoframe to binary buffer > > + * hdmi_vendor_any_infoframe_check() - check and check a vendor infoframe > > + */ > > +static int > > +hdmi_vendor_any_infoframe_check(union hdmi_vendor_any_infoframe *frame) > > +{ > > + int ret; > > + > > + ret = hdmi_vendor_any_infoframe_check_only(frame); > > + if (ret) > > + return ret; > > + > > + /* we only know about HDMI vendor infoframes */ > > + if (frame->any.oui != HDMI_IEEE_OUI) > > + return -EINVAL; > > + > > + return hdmi_vendor_infoframe_check(&frame->hdmi); > > +} > > + > > +/* > > + * hdmi_vendor_any_infoframe_pack_only() - write a vendor infoframe to binary buffer > > */ > > static ssize_t > > -hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, > > - void *buffer, size_t size) > > +hdmi_vendor_any_infoframe_pack_only(const union hdmi_vendor_any_infoframe *frame, > > + void *buffer, size_t size) > > { > > + int ret; > > + > > + ret = hdmi_vendor_any_infoframe_check_only(frame); > > + if (ret) > > + return ret; > > + > > /* we only know about HDMI vendor infoframes */ > > if (frame->any.oui != HDMI_IEEE_OUI) > > return -EINVAL; > > > > - return hdmi_vendor_infoframe_pack(&frame->hdmi, buffer, size); > > + return hdmi_vendor_infoframe_pack_only(&frame->hdmi, buffer, size); > > +} > > + > > +/* > > + * hdmi_vendor_any_infoframe_pack() - check and check a vendor infoframe, > > + * and write it to binary buffer > > + */ > > +static ssize_t > > +hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, > > + void *buffer, size_t size) > > +{ > > + int ret; > > + > > + ret = hdmi_vendor_any_infoframe_check(frame); > > + if (ret) > > + return ret; > > + > > + return hdmi_vendor_any_infoframe_pack_only(frame, buffer, size); > > +} > > + > > +/** > > + * hdmi_infoframe_check() - Check check a HDMI infoframe > > + * @frame: HDMI infoframe > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields. > > + * > > + * Returns 0 on success or a negative error code on failure. > > + */ > > +int > > +hdmi_infoframe_check(union hdmi_infoframe *frame) > > +{ > > + switch (frame->any.type) { > > + case HDMI_INFOFRAME_TYPE_AVI: > > + return hdmi_avi_infoframe_check(&frame->avi); > > + case HDMI_INFOFRAME_TYPE_SPD: > > + return hdmi_spd_infoframe_check(&frame->spd); > > + case HDMI_INFOFRAME_TYPE_AUDIO: > > + return hdmi_audio_infoframe_check(&frame->audio); > > + case HDMI_INFOFRAME_TYPE_VENDOR: > > + return hdmi_vendor_any_infoframe_check(&frame->vendor); > > + default: > > + WARN(1, "Bad infoframe type %d\n", frame->any.type); > > + return -EINVAL; > > + } > > } > > +EXPORT_SYMBOL(hdmi_infoframe_check); > > > > /** > > - * hdmi_infoframe_pack() - write a HDMI infoframe to binary buffer > > + * hdmi_infoframe_pack_only() - write a HDMI infoframe to binary buffer > > * @frame: HDMI infoframe > > * @buffer: destination buffer > > * @size: size of buffer > > @@ -425,7 +749,56 @@ hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, > > * error code on failure. > > */ > > ssize_t > > -hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size) > > +hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size) > > +{ > > + ssize_t length; > > + > > + switch (frame->any.type) { > > + case HDMI_INFOFRAME_TYPE_AVI: > > + length = hdmi_avi_infoframe_pack_only(&frame->avi, > > + buffer, size); > > + break; > > + case HDMI_INFOFRAME_TYPE_SPD: > > + length = hdmi_spd_infoframe_pack_only(&frame->spd, > > + buffer, size); > > + break; > > + case HDMI_INFOFRAME_TYPE_AUDIO: > > + length = hdmi_audio_infoframe_pack_only(&frame->audio, > > + buffer, size); > > + break; > > + case HDMI_INFOFRAME_TYPE_VENDOR: > > + length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor, > > + buffer, size); > > + break; > > + default: > > + WARN(1, "Bad infoframe type %d\n", frame->any.type); > > + length = -EINVAL; > > + } > > + > > + return length; > > +} > > +EXPORT_SYMBOL(hdmi_infoframe_pack_only); > > + > > +/** > > + * hdmi_infoframe_pack() - Check check a HDMI infoframe, > > Check check? > > > + * and write it to binary buffer > > + * @frame: HDMI infoframe > > + * @buffer: destination buffer > > + * @size: size of buffer > > + * > > + * Validates that the infoframe is consistent and updates derived fields > > + * (eg. length) based on other fields, after which packs the information > > + * contained in the @frame structure into a binary representation that > > + * can be written into the corresponding controller registers. Also > > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > > + * specification. > > + * > > + * Returns the number of bytes packed into the binary buffer or a negative > > + * error code on failure. > > + */ > > +ssize_t > > +hdmi_infoframe_pack(union hdmi_infoframe *frame, > > + void *buffer, size_t size) > > { > > ssize_t length; > > > > diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h > > index bce1abb1fe57..c76b50a48e48 100644 > > --- a/include/linux/hdmi.h > > +++ b/include/linux/hdmi.h > > @@ -163,6 +163,9 @@ struct hdmi_avi_infoframe { > > int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame); > > ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, > > size_t size); > > +ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame, > > + void *buffer, size_t size); > > +int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame); > > > > enum hdmi_spd_sdi { > > HDMI_SPD_SDI_UNKNOWN, > > @@ -194,6 +197,9 @@ int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, > > const char *vendor, const char *product); > > ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, > > size_t size); > > +ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame, > > + void *buffer, size_t size); > > +int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame); > > > > enum hdmi_audio_coding_type { > > HDMI_AUDIO_CODING_TYPE_STREAM, > > @@ -272,6 +278,9 @@ struct hdmi_audio_infoframe { > > int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame); > > ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > > void *buffer, size_t size); > > +ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame, > > + void *buffer, size_t size); > > +int hdmi_audio_infoframe_check(struct hdmi_audio_infoframe *frame); > > > > enum hdmi_3d_structure { > > HDMI_3D_STRUCTURE_INVALID = -1, > > @@ -299,6 +308,9 @@ struct hdmi_vendor_infoframe { > > int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame); > > ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > > void *buffer, size_t size); > > +ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame, > > + void *buffer, size_t size); > > +int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame); > > > > union hdmi_vendor_any_infoframe { > > struct { > > @@ -330,8 +342,11 @@ union hdmi_infoframe { > > struct hdmi_audio_infoframe audio; > > }; > > > > -ssize_t > > -hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size); > > +ssize_t hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, > > + size_t size); > > +ssize_t hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, > > + void *buffer, size_t size); > > +int hdmi_infoframe_check(union hdmi_infoframe *frame); > > int hdmi_infoframe_unpack(union hdmi_infoframe *frame, > > const void *buffer, size_t size); > > void hdmi_infoframe_log(const char *level, struct device *dev, > > > > Regards, > > Hans -- Ville Syrjälä Intel