From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v3 04/18] video/hdmi: Constify infoframe passed to the pack functions Date: Mon, 1 Oct 2018 22:10:37 +0300 Message-ID: <20181001191037.GN9144@intel.com> References: <20180920185145.1912-5-ville.syrjala@linux.intel.com> <20180921143332.28970-1-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: <20180921143332.28970-1-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Hans Verkuil , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBTZXAgMjEsIDIwMTggYXQgMDU6MzM6MzJQTSArMDMwMCwgVmlsbGUgU3lyamFsYSB3 cm90ZToKPiBGcm9tOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwu Y29tPgo+IAo+IExldCdzIG1ha2UgdGhlIGluZm9mcmFtZSBwYWNrIGZ1bmN0aW9ucyB1c2FibGUg d2l0aCBhIGNvbnN0IGluZm9mcmFtZQo+IHN0cnVjdHVyZS4gVGhpcyBhbGxvd3MgdXMgdG8gcHJl Y29tcHV0ZSB0aGUgaW5mb2ZyYW1lIGVhcmxpZXIsIGFuZCBzdGlsbAo+IHBhY2sgaXQgbGF0ZXIg d2hlbiB3ZSdyZSBubyBsb25nZXIgYWxsb3dlZCB0byBtb2RpZnkgdGhlIHN0cnVjdHVyZS4KPiBT byBub3cgd2UgZW5kIHVwIHdpdGggYSBfY2hlY2soKStfcGFja19vbmx5KCkgb3IgX3BhY2soKSBm dW5jdGlvbnMKPiBkZXBlbmRpbmcgb24gd2hldGhlciB5b3Ugd2FudCB0byBwcmVjb21wdXRlIHRo ZSBpbmZvZnJhbWVzIG9yIG5vdC4KPiBUaGUgbmFtZXMgYXJlbid0IGdyZWF0IGJ1dCBJIHdhcyBs YXp5IGFuZCBkaWRuJ3Qgd2FudCB0byBjaGFuZ2UgYWxsIHRoZQo+IGRyaXZlcnMuCj4gCj4gdjI6 IERlYWwgd2l0aCBleHlub3MgY2h1cm4KPiAgICAgQWN0dWFsbHkgZXhwb3J0IHRoZSBuZXcgZnVu Y3MKPiB2MzogRml4IHZhcmlvdXMgZG9jdW1lbnRhdGlvbiBmYWlscyAoSGFucykKCkhhbnMsIGFu eSBtb3JlIGNvbmNlcm5zIGFib3V0IHRoaXMgcGF0Y2g/Cgo+IAo+IENjOiBUaGllcnJ5IFJlZGlu ZyA8dGhpZXJyeS5yZWRpbmdAZ21haWwuY29tPgo+IENjOiBIYW5zIFZlcmt1aWwgPGhhbnMudmVy a3VpbEBjaXNjby5jb20+Cj4gQ2M6IGxpbnV4LW1lZGlhQHZnZXIua2VybmVsLm9yZwo+IFNpZ25l ZC1vZmYtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+ Cj4gLS0tCj4gIGRyaXZlcnMvdmlkZW8vaGRtaS5jIHwgNDI1ICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLQo+ICBpbmNsdWRlL2xpbnV4L2hkbWkuaCB8 ICAxOSArKy0KPiAgMiBmaWxlcyBjaGFuZ2VkLCA0MTYgaW5zZXJ0aW9ucygrKSwgMjggZGVsZXRp b25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vaGRtaS5jIGIvZHJpdmVycy92 aWRlby9oZG1pLmMKPiBpbmRleCA1M2U3ZWUyYzgzZmMuLjA4ZDk0YWIwMDQ2NyAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL3ZpZGVvL2hkbWkuYwo+ICsrKyBiL2RyaXZlcnMvdmlkZW8vaGRtaS5jCj4g QEAgLTY4LDggKzY4LDM2IEBAIGludCBoZG1pX2F2aV9pbmZvZnJhbWVfaW5pdChzdHJ1Y3QgaGRt aV9hdmlfaW5mb2ZyYW1lICpmcmFtZSkKPiAgfQo+ICBFWFBPUlRfU1lNQk9MKGhkbWlfYXZpX2lu Zm9mcmFtZV9pbml0KTsKPiAgCj4gK3N0YXRpYyBpbnQgaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNr X29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJhbWUpCj4gK3sKPiArCWlm IChmcmFtZS0+dHlwZSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX0FWSSB8fAo+ICsJICAgIGZyYW1l LT52ZXJzaW9uICE9IDIgfHwKPiArCSAgICBmcmFtZS0+bGVuZ3RoICE9IEhETUlfQVZJX0lORk9G UkFNRV9TSVpFKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCWlmIChmcmFtZS0+cGljdHVy ZV9hc3BlY3QgPiBIRE1JX1BJQ1RVUkVfQVNQRUNUXzE2XzkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7 Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gIC8qKgo+IC0gKiBoZG1pX2F2aV9pbmZvZnJh bWVfcGFjaygpIC0gd3JpdGUgSERNSSBBVkkgaW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKPiAr ICogaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNrKCkgLSBjaGVjayBhIEhETUkgQVZJIGluZm9mcmFt ZQo+ICsgKiBAZnJhbWU6IEhETUkgQVZJIGluZm9mcmFtZQo+ICsgKgo+ICsgKiBWYWxpZGF0ZXMg dGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZlZCBmaWVs ZHMKPiArICogKGVnLiBsZW5ndGgpIGJhc2VkIG9uIG90aGVyIGZpZWxkcy4KPiArICoKPiArICog UmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUu Cj4gKyAqLwo+ICtpbnQgaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNrKHN0cnVjdCBoZG1pX2F2aV9p bmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlyZXR1cm4gaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNr X29ubHkoZnJhbWUpOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woaGRtaV9hdmlfaW5mb2ZyYW1lX2No ZWNrKTsKPiArCj4gKy8qKgo+ICsgKiBoZG1pX2F2aV9pbmZvZnJhbWVfcGFja19vbmx5KCkgLSB3 cml0ZSBIRE1JIEFWSSBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ICAgKiBAZnJhbWU6IEhE TUkgQVZJIGluZm9mcmFtZQo+ICAgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiAgICog QHNpemU6IHNpemUgb2YgYnVmZmVyCj4gQEAgLTgyLDIwICsxMTAsMjIgQEAgRVhQT1JUX1NZTUJP TChoZG1pX2F2aV9pbmZvZnJhbWVfaW5pdCk7Cj4gICAqIFJldHVybnMgdGhlIG51bWJlciBvZiBi eXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCj4gICAqIGVy cm9yIGNvZGUgb24gZmFpbHVyZS4KPiAgICovCj4gLXNzaXplX3QgaGRtaV9hdmlfaW5mb2ZyYW1l X3BhY2soc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZlciwKPiAt CQkJCXNpemVfdCBzaXplKQo+ICtzc2l6ZV90IGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrX29ubHko Y29uc3Qgc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgICAgIHZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gIHsKPiAgCXU4ICpwdHIgPSBidWZmZXI7Cj4gIAlzaXpl X3QgbGVuZ3RoOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBoZG1pX2F2aV9pbmZvZnJhbWVf Y2hlY2tfb25seShmcmFtZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gIAo+ICAJ bGVuZ3RoID0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBmcmFtZS0+bGVuZ3RoOwo+ICAK PiAgCWlmIChzaXplIDwgbGVuZ3RoKQo+ICAJCXJldHVybiAtRU5PU1BDOwo+ICAKPiAtCWlmIChm cmFtZS0+cGljdHVyZV9hc3BlY3QgPiBIRE1JX1BJQ1RVUkVfQVNQRUNUXzE2XzkpCj4gLQkJcmV0 dXJuIC1FSU5WQUw7Cj4gLQo+ICAJbWVtc2V0KGJ1ZmZlciwgMCwgc2l6ZSk7Cj4gIAo+ICAJcHRy WzBdID0gZnJhbWUtPnR5cGU7Cj4gQEAgLTE1Miw2ICsxODIsMzYgQEAgc3NpemVfdCBoZG1pX2F2 aV9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAq YnVmZmVyLAo+ICAKPiAgCXJldHVybiBsZW5ndGg7Cj4gIH0KPiArRVhQT1JUX1NZTUJPTChoZG1p X2F2aV9pbmZvZnJhbWVfcGFja19vbmx5KTsKPiArCj4gKy8qKgo+ICsgKiBoZG1pX2F2aV9pbmZv ZnJhbWVfcGFjaygpIC0gY2hlY2sgYSBIRE1JIEFWSSBpbmZvZnJhbWUsCj4gKyAqICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZlcgo+ICsgKiBA ZnJhbWU6IEhETUkgQVZJIGluZm9mcmFtZQo+ICsgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZm ZXIKPiArICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gKyAqCj4gKyAqIFZhbGlkYXRlcyB0aGF0 IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRlciB3aGljaCBpdCBw YWNrcyB0aGUgaW5mb3JtYXRpb24KPiArICogY29udGFpbmVkIGluIHRoZSBAZnJhbWUgc3RydWN0 dXJlIGludG8gYSBiaW5hcnkgcmVwcmVzZW50YXRpb24gdGhhdAo+ICsgKiBjYW4gYmUgd3JpdHRl biBpbnRvIHRoZSBjb3JyZXNwb25kaW5nIGNvbnRyb2xsZXIgcmVnaXN0ZXJzLiBUaGlzIGZ1bmN0 aW9uCj4gKyAqIGFsc28gY29tcHV0ZXMgdGhlIGNoZWNrc3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rp b24gNS4zLjUgb2YgdGhlIEhETUkgMS40Cj4gKyAqIHNwZWNpZmljYXRpb24uCj4gKyAqCj4gKyAq IFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZl ciBvciBhIG5lZ2F0aXZlCj4gKyAqIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiArICovCj4gK3Nz aXplX3QgaGRtaV9hdmlfaW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAq ZnJhbWUsCj4gKwkJCQl2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICt7Cj4gKwlpbnQgcmV0 Owo+ICsKPiArCXJldCA9IGhkbWlfYXZpX2luZm9mcmFtZV9jaGVjayhmcmFtZSk7Cj4gKwlpZiAo cmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0dXJuIGhkbWlfYXZpX2luZm9mcmFtZV9w YWNrX29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6ZSk7Cj4gK30KPiAgRVhQT1JUX1NZTUJPTChoZG1p X2F2aV9pbmZvZnJhbWVfcGFjayk7Cj4gIAo+ICAvKioKPiBAQCAtMTc4LDggKzIzOCwzMyBAQCBp bnQgaGRtaV9zcGRfaW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJh bWUsCj4gIH0KPiAgRVhQT1JUX1NZTUJPTChoZG1pX3NwZF9pbmZvZnJhbWVfaW5pdCk7Cj4gIAo+ ICtzdGF0aWMgaW50IGhkbWlfc3BkX2luZm9mcmFtZV9jaGVja19vbmx5KGNvbnN0IHN0cnVjdCBo ZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlpZiAoZnJhbWUtPnR5cGUgIT0gSERN SV9JTkZPRlJBTUVfVFlQRV9TUEQgfHwKPiArCSAgICBmcmFtZS0+dmVyc2lvbiAhPSAxIHx8Cj4g KwkgICAgZnJhbWUtPmxlbmd0aCAhPSBIRE1JX1NQRF9JTkZPRlJBTUVfU0laRSkKPiArCQlyZXR1 cm4gLUVJTlZBTDsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAgLyoqCj4gLSAqIGhkbWlf c3BkX2luZm9mcmFtZV9wYWNrKCkgLSB3cml0ZSBIRE1JIFNQRCBpbmZvZnJhbWUgdG8gYmluYXJ5 IGJ1ZmZlcgo+ICsgKiBoZG1pX3NwZF9pbmZvZnJhbWVfY2hlY2soKSAtIGNoZWNrIGEgSERNSSBT UEQgaW5mb2ZyYW1lCj4gKyAqIEBmcmFtZTogSERNSSBTUEQgaW5mb2ZyYW1lCj4gKyAqCj4gKyAq IFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBk ZXJpdmVkIGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ ICsgKgo+ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUg b24gZmFpbHVyZS4KPiArICovCj4gK2ludCBoZG1pX3NwZF9pbmZvZnJhbWVfY2hlY2soc3RydWN0 IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUpCj4gK3sKPiArCXJldHVybiBoZG1pX3NwZF9pbmZv ZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChoZG1pX3NwZF9p bmZvZnJhbWVfY2hlY2spOwo+ICsKPiArLyoqCj4gKyAqIGhkbWlfc3BkX2luZm9mcmFtZV9wYWNr X29ubHkoKSAtIHdyaXRlIEhETUkgU1BEIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gICAq IEBmcmFtZTogSERNSSBTUEQgaW5mb2ZyYW1lCj4gICAqIEBidWZmZXI6IGRlc3RpbmF0aW9uIGJ1 ZmZlcgo+ICAgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKPiBAQCAtMTkyLDExICsyNzcsMTYgQEAg RVhQT1JUX1NZTUJPTChoZG1pX3NwZF9pbmZvZnJhbWVfaW5pdCk7Cj4gICAqIFJldHVybnMgdGhl IG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0 aXZlCj4gICAqIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiAgICovCj4gLXNzaXplX3QgaGRtaV9z cGRfaW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQg KmJ1ZmZlciwKPiAtCQkJCXNpemVfdCBzaXplKQo+ICtzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFt ZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJ CQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gIHsKPiAgCXU4ICpwdHIgPSBidWZm ZXI7Cj4gIAlzaXplX3QgbGVuZ3RoOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBoZG1pX3Nw ZF9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBy ZXQ7Cj4gIAo+ICAJbGVuZ3RoID0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBmcmFtZS0+ bGVuZ3RoOwo+ICAKPiBAQCAtMjIyLDYgKzMxMiwzNiBAQCBzc2l6ZV90IGhkbWlfc3BkX2luZm9m cmFtZV9wYWNrKHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIs Cj4gIAo+ICAJcmV0dXJuIGxlbmd0aDsKPiAgfQo+ICtFWFBPUlRfU1lNQk9MKGhkbWlfc3BkX2lu Zm9mcmFtZV9wYWNrX29ubHkpOwo+ICsKPiArLyoqCj4gKyAqIGhkbWlfc3BkX2luZm9mcmFtZV9w YWNrKCkgLSBjaGVjayBhIEhETUkgU1BEIGluZm9mcmFtZSwKPiArICogICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGFuZCB3cml0ZSBpdCB0byBiaW5hcnkgYnVmZmVyCj4gKyAqIEBmcmFtZTog SERNSSBTUEQgaW5mb2ZyYW1lCj4gKyAqIEBidWZmZXI6IGRlc3RpbmF0aW9uIGJ1ZmZlcgo+ICsg KiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKPiArICoKPiArICogVmFsaWRhdGVzIHRoYXQgdGhlIGlu Zm9mcmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1cGRhdGVzIGRlcml2ZWQgZmllbGRzCj4gKyAqIChl Zy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVyIHdoaWNoIGl0IHBhY2tzIHRo ZSBpbmZvcm1hdGlvbgo+ICsgKiBjb250YWluZWQgaW4gdGhlIEBmcmFtZSBzdHJ1Y3R1cmUgaW50 byBhIGJpbmFyeSByZXByZXNlbnRhdGlvbiB0aGF0Cj4gKyAqIGNhbiBiZSB3cml0dGVuIGludG8g dGhlIGNvcnJlc3BvbmRpbmcgY29udHJvbGxlciByZWdpc3RlcnMuIFRoaXMgZnVuY3Rpb24KPiAr ICogYWxzbyBjb21wdXRlcyB0aGUgY2hlY2tzdW0gYXMgcmVxdWlyZWQgYnkgc2VjdGlvbiA1LjMu NSBvZiB0aGUgSERNSSAxLjQKPiArICogc3BlY2lmaWNhdGlvbi4KPiArICoKPiArICogUmV0dXJu cyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHBhY2tlZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVyIG9yIGEg bmVnYXRpdmUKPiArICogZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ICsgKi8KPiArc3NpemVfdCBo ZG1pX3NwZF9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwK PiArCQkJCXZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ ICsJcmV0ID0gaGRtaV9zcGRfaW5mb2ZyYW1lX2NoZWNrKGZyYW1lKTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXR1cm4gaGRtaV9zcGRfaW5mb2ZyYW1lX3BhY2tfb25s eShmcmFtZSwgYnVmZmVyLCBzaXplKTsKPiArfQo+ICBFWFBPUlRfU1lNQk9MKGhkbWlfc3BkX2lu Zm9mcmFtZV9wYWNrKTsKPiAgCj4gIC8qKgo+IEBAIC0yNDIsOCArMzYyLDMzIEBAIGludCBoZG1p X2F1ZGlvX2luZm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJhbWUp Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChoZG1pX2F1ZGlvX2luZm9mcmFtZV9pbml0KTsKPiAgCj4g K3N0YXRpYyBpbnQgaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2tfb25seShjb25zdCBzdHJ1Y3Qg aGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlpZiAoZnJhbWUtPnR5cGUgIT0g SERNSV9JTkZPRlJBTUVfVFlQRV9BVURJTyB8fAo+ICsJICAgIGZyYW1lLT52ZXJzaW9uICE9IDEg fHwKPiArCSAgICBmcmFtZS0+bGVuZ3RoICE9IEhETUlfQVVESU9fSU5GT0ZSQU1FX1NJWkUpCj4g KwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gKy8qKgo+ICsg KiBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVjaygpIC0gY2hlY2sgYSBIRE1JIGF1ZGlvIGluZm9m cmFtZQo+ICsgKiBAZnJhbWU6IEhETUkgYXVkaW8gaW5mb2ZyYW1lCj4gKyAqCj4gKyAqIFZhbGlk YXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVk IGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ICsgKgo+ ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFp bHVyZS4KPiArICovCj4gK2ludCBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRt aV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlyZXR1cm4gaGRtaV9hdWRpb19pbmZv ZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChoZG1pX2F1ZGlv X2luZm9mcmFtZV9jaGVjayk7Cj4gKwo+ICAvKioKPiAtICogaGRtaV9hdWRpb19pbmZvZnJhbWVf cGFjaygpIC0gd3JpdGUgSERNSSBhdWRpbyBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ICsg KiBoZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRlIEhETUkgYXVkaW8gaW5m b2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKPiAgICogQGZyYW1lOiBIRE1JIGF1ZGlvIGluZm9mcmFt ZQo+ICAgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiAgICogQHNpemU6IHNpemUgb2Yg YnVmZmVyCj4gQEAgLTI1NiwxMiArNDAxLDE3IEBAIEVYUE9SVF9TWU1CT0woaGRtaV9hdWRpb19p bmZvZnJhbWVfaW5pdCk7Cj4gICAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQg aW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCj4gICAqIGVycm9yIGNvZGUgb24g ZmFpbHVyZS4KPiAgICovCj4gLXNzaXplX3QgaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjayhzdHJ1 Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lLAo+IC0JCQkJICB2b2lkICpidWZmZXIsIHNp emVfdCBzaXplKQo+ICtzc2l6ZV90IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2tfb25seShjb25z dCBzdHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCQkJICAgICAgIHZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gIHsKPiAgCXVuc2lnbmVkIGNoYXIgY2hhbm5lbHM7Cj4g IAl1OCAqcHRyID0gYnVmZmVyOwo+ICAJc2l6ZV90IGxlbmd0aDsKPiArCWludCByZXQ7Cj4gKwo+ ICsJcmV0ID0gaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gKwlpZiAo cmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gIAo+ICAJbGVuZ3RoID0gSERNSV9JTkZPRlJBTUVfSEVB REVSX1NJWkUgKyBmcmFtZS0+bGVuZ3RoOwo+ICAKPiBAQCAtMjk3LDYgKzQ0NywzNiBAQCBzc2l6 ZV90IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1l ICpmcmFtZSwKPiAgCj4gIAlyZXR1cm4gbGVuZ3RoOwo+ICB9Cj4gK0VYUE9SVF9TWU1CT0woaGRt aV9hdWRpb19pbmZvZnJhbWVfcGFja19vbmx5KTsKPiArCj4gKy8qKgo+ICsgKiBoZG1pX2F1ZGlv X2luZm9mcmFtZV9wYWNrKCkgLSBjaGVjayBhIEhETUkgQXVkaW8gaW5mb2ZyYW1lLAo+ICsgKiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZl cgo+ICsgKiBAZnJhbWU6IEhETUkgQXVkaW8gaW5mb2ZyYW1lCj4gKyAqIEBidWZmZXI6IGRlc3Rp bmF0aW9uIGJ1ZmZlcgo+ICsgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKPiArICoKPiArICogVmFs aWRhdGVzIHRoYXQgdGhlIGluZm9mcmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1cGRhdGVzIGRlcml2 ZWQgZmllbGRzCj4gKyAqIChlZy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVy IHdoaWNoIGl0IHBhY2tzIHRoZSBpbmZvcm1hdGlvbgo+ICsgKiBjb250YWluZWQgaW4gdGhlIEBm cmFtZSBzdHJ1Y3R1cmUgaW50byBhIGJpbmFyeSByZXByZXNlbnRhdGlvbiB0aGF0Cj4gKyAqIGNh biBiZSB3cml0dGVuIGludG8gdGhlIGNvcnJlc3BvbmRpbmcgY29udHJvbGxlciByZWdpc3RlcnMu IFRoaXMgZnVuY3Rpb24KPiArICogYWxzbyBjb21wdXRlcyB0aGUgY2hlY2tzdW0gYXMgcmVxdWly ZWQgYnkgc2VjdGlvbiA1LjMuNSBvZiB0aGUgSERNSSAxLjQKPiArICogc3BlY2lmaWNhdGlvbi4K PiArICoKPiArICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHBhY2tlZCBpbnRvIHRoZSBi aW5hcnkgYnVmZmVyIG9yIGEgbmVnYXRpdmUKPiArICogZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ ICsgKi8KPiArc3NpemVfdCBoZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX2F1 ZGlvX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUp Cj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hl Y2soZnJhbWUpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldHVybiBo ZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrX29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6ZSk7Cj4gK30K PiAgRVhQT1JUX1NZTUJPTChoZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrKTsKPiAgCj4gIC8qKgo+ IEBAIC0zMTksNiArNDk5LDcgQEAgaW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9pbml0KHN0cnVj dCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lKQo+ICAJICogdmFsdWUKPiAgCSAqLwo+ICAJ ZnJhbWUtPnMzZF9zdHJ1Y3QgPSBIRE1JXzNEX1NUUlVDVFVSRV9JTlZBTElEOwo+ICsJZnJhbWUt Pmxlbmd0aCA9IDQ7Cj4gIAo+ICAJcmV0dXJuIDA7Cj4gIH0KPiBAQCAtMzM1LDggKzUxNiw0MiBA QCBzdGF0aWMgaW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9sZW5ndGgoY29uc3Qgc3RydWN0IGhk bWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbQo+ICAJCXJldHVybiA0Owo+ICB9Cj4gIAo+ICtzdGF0 aWMgaW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9jaGVja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1p X3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlpZiAoZnJhbWUtPnR5cGUgIT0gSERN SV9JTkZPRlJBTUVfVFlQRV9WRU5ET1IgfHwKPiArCSAgICBmcmFtZS0+dmVyc2lvbiAhPSAxIHx8 Cj4gKwkgICAgZnJhbWUtPm91aSAhPSBIRE1JX0lFRUVfT1VJKQo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCS8qIG9ubHkgb25lIG9mIHRob3NlIGNhbiBiZSBzdXBwbGllZCAqLwo+ICsJaWYg KGZyYW1lLT52aWMgIT0gMCAmJiBmcmFtZS0+czNkX3N0cnVjdCAhPSBIRE1JXzNEX1NUUlVDVFVS RV9JTlZBTElEKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCWlmIChmcmFtZS0+bGVuZ3Ro ICE9IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9sZW5ndGgoZnJhbWUpKQo+ICsJCXJldHVybiAtRUlO VkFMOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICAvKioKPiAtICogaGRtaV92ZW5kb3Jf aW5mb2ZyYW1lX3BhY2soKSAtIHdyaXRlIGEgSERNSSB2ZW5kb3IgaW5mb2ZyYW1lIHRvIGJpbmFy eSBidWZmZXIKPiArICogaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrKCkgLSBjaGVjayBhIEhE TUkgdmVuZG9yIGluZm9mcmFtZQo+ICsgKiBAZnJhbWU6IEhETUkgaW5mb2ZyYW1lCj4gKyAqCj4g KyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRl cyBkZXJpdmVkIGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRz Lgo+ICsgKgo+ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNv ZGUgb24gZmFpbHVyZS4KPiArICovCj4gK2ludCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2so c3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUpCj4gK3sKPiArCWZyYW1lLT5sZW5n dGggPSBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGZyYW1lKTsKPiArCj4gKwlyZXR1cm4g aGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ICt9Cj4gK0VYUE9SVF9T WU1CT0woaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrKTsKPiArCj4gKy8qKgo+ICsgKiBoZG1p X3ZlbmRvcl9pbmZvZnJhbWVfcGFja19vbmx5KCkgLSB3cml0ZSBhIEhETUkgdmVuZG9yIGluZm9m cmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gICAqIEBmcmFtZTogSERNSSBpbmZvZnJhbWUKPiAgICog QGJ1ZmZlcjogZGVzdGluYXRpb24gYnVmZmVyCj4gICAqIEBzaXplOiBzaXplIG9mIGJ1ZmZlcgo+ IEBAIC0zNDksMTcgKzU2NCwxNiBAQCBzdGF0aWMgaW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9s ZW5ndGgoY29uc3Qgc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbQo+ICAgKiBSZXR1 cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3Ig YSBuZWdhdGl2ZQo+ICAgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gICAqLwo+IC1zc2l6ZV90 IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUg KmZyYW1lLAo+IC0JCQkJIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK3NzaXplX3QgaGRt aV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5m b2ZyYW1lICpmcmFtZSwKPiArCQkJCQl2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICB7Cj4g IAl1OCAqcHRyID0gYnVmZmVyOwo+ICAJc2l6ZV90IGxlbmd0aDsKPiArCWludCByZXQ7Cj4gIAo+ IC0JLyogb25seSBvbmUgb2YgdGhvc2UgY2FuIGJlIHN1cHBsaWVkICovCj4gLQlpZiAoZnJhbWUt PnZpYyAhPSAwICYmIGZyYW1lLT5zM2Rfc3RydWN0ICE9IEhETUlfM0RfU1RSVUNUVVJFX0lOVkFM SUQpCj4gLQkJcmV0dXJuIC1FSU5WQUw7Cj4gLQo+IC0JZnJhbWUtPmxlbmd0aCA9IGhkbWlfdmVu ZG9yX2luZm9mcmFtZV9sZW5ndGgoZnJhbWUpOwo+ICsJcmV0ID0gaGRtaV92ZW5kb3JfaW5mb2Zy YW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICAK PiAgCWxlbmd0aCA9IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgZnJhbWUtPmxlbmd0aDsK PiAgCj4gQEAgLTM5NCwyNCArNjA4LDEzNCBAQCBzc2l6ZV90IGhkbWlfdmVuZG9yX2luZm9mcmFt ZV9wYWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lLAo+ICAKPiAgCXJldHVy biBsZW5ndGg7Cj4gIH0KPiArRVhQT1JUX1NZTUJPTChoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFj a19vbmx5KTsKPiArCj4gKy8qKgo+ICsgKiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFjaygpIC0g Y2hlY2sgYSBIRE1JIFZlbmRvciBpbmZvZnJhbWUsCj4gKyAqICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZlcgo+ICsgKiBAZnJhbWU6IEhE TUkgVmVuZG9yIGluZm9mcmFtZQo+ICsgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiAr ICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gKyAqCj4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBp bmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ICsgKiAo ZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRlciB3aGljaCBpdCBwYWNrcyB0 aGUgaW5mb3JtYXRpb24KPiArICogY29udGFpbmVkIGluIHRoZSBAZnJhbWUgc3RydWN0dXJlIGlu dG8gYSBiaW5hcnkgcmVwcmVzZW50YXRpb24gdGhhdAo+ICsgKiBjYW4gYmUgd3JpdHRlbiBpbnRv IHRoZSBjb3JyZXNwb25kaW5nIGNvbnRyb2xsZXIgcmVnaXN0ZXJzLiBUaGlzIGZ1bmN0aW9uCj4g KyAqIGFsc28gY29tcHV0ZXMgdGhlIGNoZWNrc3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rpb24gNS4z LjUgb2YgdGhlIEhETUkgMS40Cj4gKyAqIHNwZWNpZmljYXRpb24uCj4gKyAqCj4gKyAqIFJldHVy bnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBh IG5lZ2F0aXZlCj4gKyAqIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiArICovCj4gK3NzaXplX3Qg aGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAq ZnJhbWUsCj4gKwkJCQkgICB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICt7Cj4gKwlpbnQg cmV0Owo+ICsKPiArCXJldCA9IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9jaGVjayhmcmFtZSk7Cj4g KwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0dXJuIGhkbWlfdmVuZG9yX2lu Zm9mcmFtZV9wYWNrX29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6ZSk7Cj4gK30KPiAgRVhQT1JUX1NZ TUJPTChoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFjayk7Cj4gIAo+ICtzdGF0aWMgaW50Cj4gK2hk bWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfY2hlY2tfb25seShjb25zdCB1bmlvbiBoZG1pX3ZlbmRv cl9hbnlfaW5mb2ZyYW1lICpmcmFtZSkKPiArewo+ICsJaWYgKGZyYW1lLT5hbnkudHlwZSAhPSBI RE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRPUiB8fAo+ICsJICAgIGZyYW1lLT5hbnkudmVyc2lvbiAh PSAxKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICAv Kgo+IC0gKiBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2soKSAtIHdyaXRlIGEgdmVuZG9y IGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gKyAqIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJh bWVfY2hlY2soKSAtIGNoZWNrIGEgdmVuZG9yIGluZm9mcmFtZQo+ICsgKi8KPiArc3RhdGljIGlu dAo+ICtoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2NoZWNrKHVuaW9uIGhkbWlfdmVuZG9yX2Fu eV9pbmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGhkbWlf dmVuZG9yX2FueV9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gKwlpZiAocmV0KQo+ICsJ CXJldHVybiByZXQ7Cj4gKwo+ICsJLyogd2Ugb25seSBrbm93IGFib3V0IEhETUkgdmVuZG9yIGlu Zm9mcmFtZXMgKi8KPiArCWlmIChmcmFtZS0+YW55Lm91aSAhPSBIRE1JX0lFRUVfT1VJKQo+ICsJ CXJldHVybiAtRUlOVkFMOwo+ICsKPiArCXJldHVybiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hl Y2soJmZyYW1lLT5oZG1pKTsKPiArfQo+ICsKPiArLyoKPiArICogaGRtaV92ZW5kb3JfYW55X2lu Zm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRlIGEgdmVuZG9yIGluZm9mcmFtZSB0byBiaW5hcnkg YnVmZmVyCj4gICAqLwo+ICBzdGF0aWMgc3NpemVfdAo+IC1oZG1pX3ZlbmRvcl9hbnlfaW5mb2Zy YW1lX3BhY2sodW5pb24gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUsCj4gLQkJCSAg IHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK2hkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVf cGFja19vbmx5KGNvbnN0IHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAo+ ICsJCQkJICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gIHsKPiArCWludCByZXQ7Cj4g Kwo+ICsJcmV0ID0gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9jaGVja19vbmx5KGZyYW1lKTsK PiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gIAkvKiB3ZSBvbmx5IGtub3cgYWJv dXQgSERNSSB2ZW5kb3IgaW5mb2ZyYW1lcyAqLwo+ICAJaWYgKGZyYW1lLT5hbnkub3VpICE9IEhE TUlfSUVFRV9PVUkpCj4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+IC0JcmV0dXJuIGhkbWlfdmVu ZG9yX2luZm9mcmFtZV9wYWNrKCZmcmFtZS0+aGRtaSwgYnVmZmVyLCBzaXplKTsKPiArCXJldHVy biBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+aGRtaSwgYnVmZmVyLCBz aXplKTsKPiArfQo+ICsKPiArLyoKPiArICogaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNr KCkgLSBjaGVjayBhIHZlbmRvciBpbmZvZnJhbWUsCj4gKyAqICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgYW5kIHdyaXRlIGl0IHRvIGJpbmFyeSBidWZmZXIKPiArICovCj4gK3N0 YXRpYyBzc2l6ZV90Cj4gK2hkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfcGFjayh1bmlvbiBoZG1p X3ZlbmRvcl9hbnlfaW5mb2ZyYW1lICpmcmFtZSwKPiArCQkJICAgICAgIHZvaWQgKmJ1ZmZlciwg c2l6ZV90IHNpemUpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gaGRtaV92ZW5kb3Jf YW55X2luZm9mcmFtZV9jaGVjayhmcmFtZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7 Cj4gKwo+ICsJcmV0dXJuIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfcGFja19vbmx5KGZyYW1l LCBidWZmZXIsIHNpemUpOwo+ICt9Cj4gKwo+ICsvKioKPiArICogaGRtaV9pbmZvZnJhbWVfY2hl Y2soKSAtIGNoZWNrIGEgSERNSSBpbmZvZnJhbWUKPiArICogQGZyYW1lOiBIRE1JIGluZm9mcmFt ZQo+ICsgKgo+ICsgKiBWYWxpZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQg YW5kIHVwZGF0ZXMgZGVyaXZlZCBmaWVsZHMKPiArICogKGVnLiBsZW5ndGgpIGJhc2VkIG9uIG90 aGVyIGZpZWxkcy4KPiArICoKPiArICogUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2 ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gKyAqLwo+ICtpbnQKPiAraGRtaV9pbmZvZnJhbWVf Y2hlY2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlzd2l0Y2ggKGZyYW1l LT5hbnkudHlwZSkgewo+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX0FWSToKPiArCQlyZXR1 cm4gaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNrKCZmcmFtZS0+YXZpKTsKPiArCWNhc2UgSERNSV9J TkZPRlJBTUVfVFlQRV9TUEQ6Cj4gKwkJcmV0dXJuIGhkbWlfc3BkX2luZm9mcmFtZV9jaGVjaygm ZnJhbWUtPnNwZCk7Cj4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfQVVESU86Cj4gKwkJcmV0 dXJuIGhkbWlfYXVkaW9faW5mb2ZyYW1lX2NoZWNrKCZmcmFtZS0+YXVkaW8pOwo+ICsJY2FzZSBI RE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRPUjoKPiArCQlyZXR1cm4gaGRtaV92ZW5kb3JfYW55X2lu Zm9mcmFtZV9jaGVjaygmZnJhbWUtPnZlbmRvcik7Cj4gKwlkZWZhdWx0Ogo+ICsJCVdBUk4oMSwg IkJhZCBpbmZvZnJhbWUgdHlwZSAlZFxuIiwgZnJhbWUtPmFueS50eXBlKTsKPiArCQlyZXR1cm4g LUVJTlZBTDsKPiArCX0KPiAgfQo+ICtFWFBPUlRfU1lNQk9MKGhkbWlfaW5mb2ZyYW1lX2NoZWNr KTsKPiAgCj4gIC8qKgo+IC0gKiBoZG1pX2luZm9mcmFtZV9wYWNrKCkgLSB3cml0ZSBhIEhETUkg aW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKPiArICogaGRtaV9pbmZvZnJhbWVfcGFja19vbmx5 KCkgLSB3cml0ZSBhIEhETUkgaW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKPiAgICogQGZyYW1l OiBIRE1JIGluZm9mcmFtZQo+ICAgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiAgICog QHNpemU6IHNpemUgb2YgYnVmZmVyCj4gQEAgLTQyNSw3ICs3NDksNTYgQEAgaGRtaV92ZW5kb3Jf YW55X2luZm9mcmFtZV9wYWNrKHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1l LAo+ICAgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gICAqLwo+ICBzc2l6ZV90Cj4gLWhkbWlf aW5mb2ZyYW1lX3BhY2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIs IHNpemVfdCBzaXplKQo+ICtoZG1pX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3QgdW5pb24gaGRt aV9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICt7Cj4gKwlz c2l6ZV90IGxlbmd0aDsKPiArCj4gKwlzd2l0Y2ggKGZyYW1lLT5hbnkudHlwZSkgewo+ICsJY2Fz ZSBIRE1JX0lORk9GUkFNRV9UWVBFX0FWSToKPiArCQlsZW5ndGggPSBoZG1pX2F2aV9pbmZvZnJh bWVfcGFja19vbmx5KCZmcmFtZS0+YXZpLAo+ICsJCQkJCQkgICAgICBidWZmZXIsIHNpemUpOwo+ ICsJCWJyZWFrOwo+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX1NQRDoKPiArCQlsZW5ndGgg PSBoZG1pX3NwZF9pbmZvZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+c3BkLAo+ICsJCQkJCQkgICAg ICBidWZmZXIsIHNpemUpOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBF X0FVRElPOgo+ICsJCWxlbmd0aCA9IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2tfb25seSgmZnJh bWUtPmF1ZGlvLAo+ICsJCQkJCQkJYnVmZmVyLCBzaXplKTsKPiArCQlicmVhazsKPiArCWNhc2Ug SERNSV9JTkZPRlJBTUVfVFlQRV9WRU5ET1I6Cj4gKwkJbGVuZ3RoID0gaGRtaV92ZW5kb3JfYW55 X2luZm9mcmFtZV9wYWNrX29ubHkoJmZyYW1lLT52ZW5kb3IsCj4gKwkJCQkJCQkgICAgIGJ1ZmZl ciwgc2l6ZSk7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCVdBUk4oMSwgIkJhZCBpbmZv ZnJhbWUgdHlwZSAlZFxuIiwgZnJhbWUtPmFueS50eXBlKTsKPiArCQlsZW5ndGggPSAtRUlOVkFM Owo+ICsJfQo+ICsKPiArCXJldHVybiBsZW5ndGg7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChoZG1p X2luZm9mcmFtZV9wYWNrX29ubHkpOwo+ICsKPiArLyoqCj4gKyAqIGhkbWlfaW5mb2ZyYW1lX3Bh Y2soKSAtIGNoZWNrIGEgSERNSSBpbmZvZnJhbWUsCj4gKyAqICAgICAgICAgICAgICAgICAgICAg ICAgIGFuZCB3cml0ZSBpdCB0byBiaW5hcnkgYnVmZmVyCj4gKyAqIEBmcmFtZTogSERNSSBpbmZv ZnJhbWUKPiArICogQGJ1ZmZlcjogZGVzdGluYXRpb24gYnVmZmVyCj4gKyAqIEBzaXplOiBzaXpl IG9mIGJ1ZmZlcgo+ICsgKgo+ICsgKiBWYWxpZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNv bnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZlZCBmaWVsZHMKPiArICogKGVnLiBsZW5ndGgpIGJh c2VkIG9uIG90aGVyIGZpZWxkcywgYWZ0ZXIgd2hpY2ggaXQgcGFja3MgdGhlIGluZm9ybWF0aW9u Cj4gKyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZyYW1lIHN0cnVjdHVyZSBpbnRvIGEgYmluYXJ5IHJl cHJlc2VudGF0aW9uIHRoYXQKPiArICogY2FuIGJlIHdyaXR0ZW4gaW50byB0aGUgY29ycmVzcG9u ZGluZyBjb250cm9sbGVyIHJlZ2lzdGVycy4gVGhpcyBmdW5jdGlvbgo+ICsgKiBhbHNvIGNvbXB1 dGVzIHRoZSBjaGVja3N1bSBhcyByZXF1aXJlZCBieSBzZWN0aW9uIDUuMy41IG9mIHRoZSBIRE1J IDEuNAo+ICsgKiBzcGVjaWZpY2F0aW9uLgo+ICsgKgo+ICsgKiBSZXR1cm5zIHRoZSBudW1iZXIg b2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQo+ICsg KiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gKyAqLwo+ICtzc2l6ZV90Cj4gK2hkbWlfaW5mb2Zy YW1lX3BhY2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCSAgICB2b2lkICpidWZm ZXIsIHNpemVfdCBzaXplKQo+ICB7Cj4gIAlzc2l6ZV90IGxlbmd0aDsKPiAgCj4gZGlmZiAtLWdp dCBhL2luY2x1ZGUvbGludXgvaGRtaS5oIGIvaW5jbHVkZS9saW51eC9oZG1pLmgKPiBpbmRleCBi Y2UxYWJiMWZlNTcuLmM3NmI1MGE0OGU0OCAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L2hk bWkuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvaGRtaS5oCj4gQEAgLTE2Myw2ICsxNjMsOSBAQCBz dHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lIHsKPiAgaW50IGhkbWlfYXZpX2luZm9mcmFtZV9pbml0 KHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lKTsKPiAgc3NpemVfdCBoZG1pX2F2aV9p bmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVm ZmVyLAo+ICAJCQkJc2l6ZV90IHNpemUpOwo+ICtzc2l6ZV90IGhkbWlfYXZpX2luZm9mcmFtZV9w YWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkg ICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ICtpbnQgaGRtaV9hdmlfaW5mb2ZyYW1l X2NoZWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lKTsKPiAgCj4gIGVudW0gaGRt aV9zcGRfc2RpIHsKPiAgCUhETUlfU1BEX1NESV9VTktOT1dOLAo+IEBAIC0xOTQsNiArMTk3LDkg QEAgaW50IGhkbWlfc3BkX2luZm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUg KmZyYW1lLAo+ICAJCQkgICAgY29uc3QgY2hhciAqdmVuZG9yLCBjb25zdCBjaGFyICpwcm9kdWN0 KTsKPiAgc3NpemVfdCBoZG1pX3NwZF9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9zcGRfaW5m b2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLAo+ICAJCQkJc2l6ZV90IHNpemUpOwo+ICtzc2l6 ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfc3BkX2lu Zm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ ICtpbnQgaGRtaV9zcGRfaW5mb2ZyYW1lX2NoZWNrKHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUg KmZyYW1lKTsKPiAgCj4gIGVudW0gaGRtaV9hdWRpb19jb2RpbmdfdHlwZSB7Cj4gIAlIRE1JX0FV RElPX0NPRElOR19UWVBFX1NUUkVBTSwKPiBAQCAtMjcyLDYgKzI3OCw5IEBAIHN0cnVjdCBoZG1p X2F1ZGlvX2luZm9mcmFtZSB7Cj4gIGludCBoZG1pX2F1ZGlvX2luZm9mcmFtZV9pbml0KHN0cnVj dCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJhbWUpOwo+ICBzc2l6ZV90IGhkbWlfYXVkaW9faW5m b2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSwKPiAgCQkJCSAg dm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4gK3NzaXplX3QgaGRtaV9hdWRpb19pbmZvZnJh bWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJhbWUsCj4g KwkJCQkgICAgICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4gK2ludCBoZG1pX2F1ZGlv X2luZm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lKTsKPiAg Cj4gIGVudW0gaGRtaV8zZF9zdHJ1Y3R1cmUgewo+ICAJSERNSV8zRF9TVFJVQ1RVUkVfSU5WQUxJ RCA9IC0xLAo+IEBAIC0yOTksNiArMzA4LDkgQEAgc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFt ZSB7Cj4gIGludCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV92ZW5kb3Jf aW5mb2ZyYW1lICpmcmFtZSk7Cj4gIHNzaXplX3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2so c3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUsCj4gIAkJCQkgICB2b2lkICpidWZm ZXIsIHNpemVfdCBzaXplKTsKPiArc3NpemVfdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFja19v bmx5KGNvbnN0IHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCQkJCXZv aWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ICtpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2No ZWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lKTsKPiAgCj4gIHVuaW9uIGhk bWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgewo+ICAJc3RydWN0IHsKPiBAQCAtMzMwLDggKzM0Miwx MSBAQCB1bmlvbiBoZG1pX2luZm9mcmFtZSB7Cj4gIAlzdHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJh bWUgYXVkaW87Cj4gIH07Cj4gIAo+IC1zc2l6ZV90Cj4gLWhkbWlfaW5mb2ZyYW1lX3BhY2sodW5p b24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsKPiAr c3NpemVfdCBoZG1pX2luZm9mcmFtZV9wYWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwg dm9pZCAqYnVmZmVyLAo+ICsJCQkgICAgc2l6ZV90IHNpemUpOwo+ICtzc2l6ZV90IGhkbWlfaW5m b2ZyYW1lX3BhY2tfb25seShjb25zdCB1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJ CQkgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4gK2ludCBoZG1pX2luZm9mcmFtZV9jaGVj ayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUpOwo+ICBpbnQgaGRtaV9pbmZvZnJhbWVfdW5w YWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwKPiAgCQkJICBjb25zdCB2b2lkICpidWZm ZXIsIHNpemVfdCBzaXplKTsKPiAgdm9pZCBoZG1pX2luZm9mcmFtZV9sb2coY29uc3QgY2hhciAq bGV2ZWwsIHN0cnVjdCBkZXZpY2UgKmRldiwKPiAtLSAKPiAyLjE2LjQKCi0tIApWaWxsZSBTeXJq w6Rsw6QKSW50ZWwKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4 Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga18.intel.com ([134.134.136.126]:29133 "EHLO mga18.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725958AbeJBBuK (ORCPT ); Mon, 1 Oct 2018 21:50:10 -0400 Date: Mon, 1 Oct 2018 22:10:37 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org Subject: Re: [PATCH v3 04/18] video/hdmi: Constify infoframe passed to the pack functions Message-ID: <20181001191037.GN9144@intel.com> References: <20180920185145.1912-5-ville.syrjala@linux.intel.com> <20180921143332.28970-1-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: <20180921143332.28970-1-ville.syrjala@linux.intel.com> Sender: linux-media-owner@vger.kernel.org List-ID: On Fri, Sep 21, 2018 at 05:33:32PM +0300, 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 great but I was lazy and didn't want to change all the > drivers. > > v2: Deal with exynos churn > Actually export the new funcs > v3: Fix various documentation fails (Hans) Hans, any more concerns about this patch? > > 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..08d94ab00467 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 a HDMI AVI infoframe > + * @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 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 it packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. This function > + * 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_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 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 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 it packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. This function > + * 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 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 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 it packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. This function > + * 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 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 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 it packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. This function > + * 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 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 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 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 a HDMI infoframe, > + * 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 it packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. This function > + * 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, > -- > 2.16.4 -- Ville Syrjälä Intel