From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH 07/18] video/hdmi: Handle the NTSC VBI infoframe Date: Fri, 21 Sep 2018 16:54:12 +0300 Message-ID: <20180921135412.GW5565@intel.com> References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-8-ville.syrjala@linux.intel.com> <4e790da9-a49c-e4b2-d528-4c6c8bca722e@cisco.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <4e790da9-a49c-e4b2-d528-4c6c8bca722e@cisco.com> 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 T24gRnJpLCBTZXAgMjEsIDIwMTggYXQgMTA6MzA6MTZBTSArMDIwMCwgSGFucyBWZXJrdWlsIHdy b3RlOgo+IE9uIDA5LzIwLzE4IDIwOjUxLCBWaWxsZSBTeXJqYWxhIHdyb3RlOgo+ID4gRnJvbTog VmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiA+IAo+ID4g QWRkIHRoZSBjb2RlIHRvIGRlYWwgd2l0aCB0aGUgTlRTQyBWQkkgaW5mb2ZyYW1lLgo+ID4gCj4g PiBJIGRlY2lkZWQgYWdhaW5zdCBwYXJzaW5nIHRoZSBQRVNfZGF0YV9maWVsZCBhbmQganVzdCBs ZWF2ZQo+ID4gaXQgYXMgYW4gb3BhcXVlIGJsb2IsIGp1c3QgZHVtcGluZyBpdCBvdXQgYXMgaGV4 IGluIHRoZSBsb2cuCj4gPiAKPiA+IEJsaW5kbHkgdHlwZWQgZnJvbSB0aGUgc3BlYywgYW5kIHRv dGFsbHkgdW50ZXN0ZWQuCj4gCj4gRG8gd2UgaGF2ZSBhbnkgZHJpdmVyIHRoYXQgdXNlcyB0aGlz PyBJIHdvdWxkIHByZWZlciB0byB3YWl0IHVudGlsIHNvbWVvbmUKPiBhY3R1YWxseSBuZWVkIHRo aXMuCgpObyB1c2VycyB0aGF0IEkga25vdyBvZi4gU28gdG90YWxseSBmaW5lIHdpdGggbWUgdG8g bGVhdmUgaXQgb3V0LgoKPiAKPiBSZWdhcmRzLAo+IAo+IAlIYW5zCj4gCj4gPiAKPiA+IENjOiBU aGllcnJ5IFJlZGluZyA8dGhpZXJyeS5yZWRpbmdAZ21haWwuY29tPgo+ID4gQ2M6IEhhbnMgVmVy a3VpbCA8aGFucy52ZXJrdWlsQGNpc2NvLmNvbT4KPiA+IENjOiBsaW51eC1tZWRpYUB2Z2VyLmtl cm5lbC5vcmcKPiA+IFNpZ25lZC1vZmYtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFs YUBsaW51eC5pbnRlbC5jb20+Cj4gPiAtLS0KPiA+ICBkcml2ZXJzL3ZpZGVvL2hkbWkuYyB8IDIw OCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiA+ ICBpbmNsdWRlL2xpbnV4L2hkbWkuaCB8ICAxOCArKysrKwo+ID4gIDIgZmlsZXMgY2hhbmdlZCwg MjI2IGluc2VydGlvbnMoKykKPiA+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vaGRt aS5jIGIvZHJpdmVycy92aWRlby9oZG1pLmMKPiA+IGluZGV4IDNkMjRjNzc0NmM1MS4uM2MzMjBk NjlmYTBhIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy92aWRlby9oZG1pLmMKPiA+ICsrKyBiL2Ry aXZlcnMvdmlkZW8vaGRtaS5jCj4gPiBAQCAtODMxLDYgKzgzMSwxMzkgQEAgc3NpemVfdCBoZG1p X21wZWdfc291cmNlX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX21wZWdfc291cmNlX2luZm9m cmFtZSAqZnJhbWUKPiA+ICB9Cj4gPiAgRVhQT1JUX1NZTUJPTChoZG1pX21wZWdfc291cmNlX2lu Zm9mcmFtZV9wYWNrKTsKPiA+ICAKPiA+ICsvKioKPiA+ICsgKiBoZG1pX250c2NfdmJpX2luZm9m cmFtZV9pbml0KCkgLSBpbml0aWFsaXplIGFuIEhETUkgTlRTQyBWQkkgaW5mb2ZyYW1lCj4gPiAr ICogQGZyYW1lOiBIRE1JIE5UU0MgVkJJIGluZm9mcmFtZQo+ID4gKyAqIEBwZXNfZGF0YV9maWVs ZDogQU5TSS9TQ1RFIDEyNyBQRVNfZGF0YV9maWVsZAo+ID4gKyAqIEBsZW5ndGg6IEFOU0kvU0NU RSAxMjcgUEVTX2RhdGFfZmllbGQgbGVuZ3RoCj4gPiArICoKPiA+ICsgKiBSZXR1cm5zIDAgb24g c3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiA+ICsgKi8KPiA+ ICtpbnQgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9p bmZvZnJhbWUgKmZyYW1lLAo+ID4gKwkJCQkgY29uc3Qgdm9pZCAqcGVzX2RhdGFfZmllbGQsCj4g PiArCQkJCSBzaXplX3QgbGVuZ3RoKQo+ID4gK3sKPiA+ICsJaWYgKGxlbmd0aCA8IDEgfHwgbGVu Z3RoID4gMjcpCj4gPiArCQlyZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ICsJbWVtc2V0KGZyYW1l LCAwLCBzaXplb2YoKmZyYW1lKSk7Cj4gPiArCj4gPiArCWZyYW1lLT50eXBlID0gSERNSV9JTkZP RlJBTUVfVFlQRV9OVFNDX1ZCSTsKPiA+ICsJZnJhbWUtPnZlcnNpb24gPSAxOwo+ID4gKwlmcmFt ZS0+bGVuZ3RoID0gbGVuZ3RoOwo+ID4gKwo+ID4gKwltZW1jcHkoZnJhbWUtPnBlc19kYXRhX2Zp ZWxkLCBwZXNfZGF0YV9maWVsZCwgbGVuZ3RoKTsKPiA+ICsKPiA+ICsJcmV0dXJuIDA7Cj4gPiAr fQo+ID4gK0VYUE9SVF9TWU1CT0woaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfaW5pdCk7Cj4gPiAr Cj4gPiArc3RhdGljIGludCBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9jaGVja19vbmx5KGNvbnN0 IHN0cnVjdCBoZG1pX250c2NfdmJpX2luZm9mcmFtZSAqZnJhbWUpCj4gPiArewo+ID4gKwlpZiAo ZnJhbWUtPnR5cGUgIT0gSERNSV9JTkZPRlJBTUVfVFlQRV9OVFNDX1ZCSSB8fAo+ID4gKwkgICAg ZnJhbWUtPnZlcnNpb24gIT0gMSB8fAo+ID4gKwkgICAgZnJhbWUtPmxlbmd0aCA8IDEgfHwgZnJh bWUtPmxlbmd0aCA+IDI3KQo+ID4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gPiArCj4gPiArCWlmIChm cmFtZS0+cGVzX2RhdGFfZmllbGRbMF0gIT0gMHg5OSkKPiA+ICsJCXJldHVybiAtRUlOVkFMOwo+ ID4gKwo+ID4gKwlyZXR1cm4gMDsKPiA+ICt9Cj4gPiArCj4gPiArLyoqCj4gPiArICogaGRtaV9u dHNjX3ZiaV9pbmZvZnJhbWVfY2hlY2soKSAtIENoZWNrIGFuZCBjaGVjayBhIEhETUkgTlRTQyBW QkkgaW5mb2ZyYW1lCj4gPiArICogQGZyYW1lOiBIRE1JIE5UU0MgVkJJIGluZm9mcmFtZQo+ID4g KyAqCj4gPiArICogVmFsaWRhdGVzIHRoYXQgdGhlIGluZm9mcmFtZSBpcyBjb25zaXN0ZW50IGFu ZCB1cGRhdGVzIGRlcml2ZWQgZmllbGRzCj4gPiArICogKGVnLiBsZW5ndGgpIGJhc2VkIG9uIG90 aGVyIGZpZWxkcy4KPiA+ICsgKgo+ID4gKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzIG9yIGEgbmVn YXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ID4gKyAqLwo+ID4gK2ludCBoZG1pX250c2Nf dmJpX2luZm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgKmZyYW1l KQo+ID4gK3sKPiA+ICsJcmV0dXJuIGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX2NoZWNrX29ubHko ZnJhbWUpOwo+ID4gK30KPiA+ICtFWFBPUlRfU1lNQk9MKGhkbWlfbnRzY192YmlfaW5mb2ZyYW1l X2NoZWNrKTsKPiA+ICsKPiA+ICsvKioKPiA+ICsgKiBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9w YWNrX29ubHkoKSAtIHdyaXRlIEhETUkgTlRTQyBWQkkgaW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZm ZXIKPiA+ICsgKiBAZnJhbWU6IEhETUkgTlRTQyBWQkkgaW5mb2ZyYW1lCj4gPiArICogQGJ1ZmZl cjogZGVzdGluYXRpb24gYnVmZmVyCj4gPiArICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gPiAr ICoKPiA+ICsgKiBQYWNrcyB0aGUgaW5mb3JtYXRpb24gY29udGFpbmVkIGluIHRoZSBAZnJhbWUg c3RydWN0dXJlIGludG8gYSBiaW5hcnkKPiA+ICsgKiByZXByZXNlbnRhdGlvbiB0aGF0IGNhbiBi ZSB3cml0dGVuIGludG8gdGhlIGNvcnJlc3BvbmRpbmcgY29udHJvbGxlcgo+ID4gKyAqIHJlZ2lz dGVycy4gQWxzbyBjb21wdXRlcyB0aGUgY2hlY2tzdW0gYXMgcmVxdWlyZWQgYnkgc2VjdGlvbiA1 LjMuNSBvZgo+ID4gKyAqIHRoZSBIRE1JIDEuNCBzcGVjaWZpY2F0aW9uLgo+ID4gKyAqCj4gPiAr ICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHBhY2tlZCBpbnRvIHRoZSBiaW5hcnkgYnVm ZmVyIG9yIGEgbmVnYXRpdmUKPiA+ICsgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gPiArICov Cj4gPiArc3NpemVfdCBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3Ry dWN0IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lICpmcmFtZSwKPiA+ICsJCQkJCSAgdm9pZCAqYnVm ZmVyLCBzaXplX3Qgc2l6ZSkKPiA+ICt7Cj4gPiArCXU4ICpwdHIgPSBidWZmZXI7Cj4gPiArCXNp emVfdCBsZW5ndGg7Cj4gPiArCWludCByZXQ7Cj4gPiArCj4gPiArCXJldCA9IGhkbWlfbnRzY192 YmlfaW5mb2ZyYW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ID4gKwlpZiAocmV0KQo+ID4gKwkJcmV0 dXJuIHJldDsKPiA+ICsKPiA+ICsJbGVuZ3RoID0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUg KyBmcmFtZS0+bGVuZ3RoOwo+ID4gKwo+ID4gKwlpZiAoc2l6ZSA8IGxlbmd0aCkKPiA+ICsJCXJl dHVybiAtRU5PU1BDOwo+ID4gKwo+ID4gKwltZW1zZXQoYnVmZmVyLCAwLCBzaXplKTsKPiA+ICsK PiA+ICsJcHRyWzBdID0gZnJhbWUtPnR5cGU7Cj4gPiArCXB0clsxXSA9IGZyYW1lLT52ZXJzaW9u Owo+ID4gKwlwdHJbMl0gPSBmcmFtZS0+bGVuZ3RoOwo+ID4gKwlwdHJbM10gPSAwOyAvKiBjaGVj a3N1bSAqLwo+ID4gKwo+ID4gKwkvKiBzdGFydCBpbmZvZnJhbWUgcGF5bG9hZCAqLwo+ID4gKwlw dHIgKz0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkU7Cj4gPiArCj4gPiArCW1lbWNweShwdHIs IGZyYW1lLT5wZXNfZGF0YV9maWVsZCwgZnJhbWUtPmxlbmd0aCk7Cj4gPiArCj4gPiArCWhkbWlf aW5mb2ZyYW1lX3NldF9jaGVja3N1bShidWZmZXIsIGxlbmd0aCk7Cj4gPiArCj4gPiArCXJldHVy biBsZW5ndGg7Cj4gPiArfQo+ID4gK0VYUE9SVF9TWU1CT0woaGRtaV9udHNjX3ZiaV9pbmZvZnJh bWVfcGFja19vbmx5KTsKPiA+ICsKPiA+ICsvKioKPiA+ICsgKiBoZG1pX250c2NfdmJpX2luZm9m cmFtZV9wYWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIE5UU0MgVkJJIGluZm9mcmFtZSwK PiA+ICsgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8g YmluYXJ5IGJ1ZmZlcgo+ID4gKyAqIEBmcmFtZTogSERNSSBOVFNDIFZCSSBpbmZvZnJhbWUKPiA+ ICsgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiA+ICsgKiBAc2l6ZTogc2l6ZSBvZiBi dWZmZXIKPiA+ICsgKgo+ID4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29u c2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ID4gKyAqIChlZy4gbGVuZ3RoKSBi YXNlZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVyIHdoaWNoIHBhY2tzIHRoZSBpbmZvcm1hdGlvbgo+ ID4gKyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZyYW1lIHN0cnVjdHVyZSBpbnRvIGEgYmluYXJ5IHJl cHJlc2VudGF0aW9uIHRoYXQKPiA+ICsgKiBjYW4gYmUgd3JpdHRlbiBpbnRvIHRoZSBjb3JyZXNw b25kaW5nIGNvbnRyb2xsZXIgcmVnaXN0ZXJzLiBBbHNvCj4gPiArICogY29tcHV0ZXMgdGhlIGNo ZWNrc3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rpb24gNS4zLjUgb2YgdGhlIEhETUkgMS40Cj4gPiAr ICogc3BlY2lmaWNhdGlvbi4KPiA+ICsgKgo+ID4gKyAqIFJldHVybnMgdGhlIG51bWJlciBvZiBi eXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCj4gPiArICog ZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ID4gKyAqLwo+ID4gK3NzaXplX3QgaGRtaV9udHNjX3Zi aV9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgKmZyYW1lLAo+ ID4gKwkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gPiArewo+ID4gKwlpbnQg cmV0Owo+ID4gKwo+ID4gKwlyZXQgPSBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9jaGVjayhmcmFt ZSk7Cj4gPiArCWlmIChyZXQpCj4gPiArCQlyZXR1cm4gcmV0Owo+ID4gKwo+ID4gKwlyZXR1cm4g aGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfcGFja19vbmx5KGZyYW1lLCBidWZmZXIsIHNpemUpOwo+ ID4gK30KPiA+ICtFWFBPUlRfU1lNQk9MKGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX3BhY2spOwo+ ID4gKwo+ID4gIC8qKgo+ID4gICAqIGhkbWlfaW5mb2ZyYW1lX2NoZWNrKCkgLSBDaGVjayBjaGVj ayBhIEhETUkgaW5mb2ZyYW1lCj4gPiAgICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQo+ID4gQEAg LTg1NCw2ICs5ODcsOCBAQCBoZG1pX2luZm9mcmFtZV9jaGVjayh1bmlvbiBoZG1pX2luZm9mcmFt ZSAqZnJhbWUpCj4gPiAgCQlyZXR1cm4gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9jaGVjaygm ZnJhbWUtPnZlbmRvcik7Cj4gPiAgCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9NUEVHX1NPVVJD RToKPiA+ICAJCXJldHVybiBoZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV9jaGVjaygmZnJhbWUt Pm1wZWdfc291cmNlKTsKPiA+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX05UU0NfVkJJOgo+ ID4gKwkJcmV0dXJuIGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX2NoZWNrKCZmcmFtZS0+bnRzY192 YmkpOwo+ID4gIAlkZWZhdWx0Ogo+ID4gIAkJV0FSTigxLCAiQmFkIGluZm9mcmFtZSB0eXBlICVk XG4iLCBmcmFtZS0+YW55LnR5cGUpOwo+ID4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gPiBAQCAtOTAx LDYgKzEwMzYsMTAgQEAgaGRtaV9pbmZvZnJhbWVfcGFja19vbmx5KGNvbnN0IHVuaW9uIGhkbWlf aW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLCBzaXplX3QKPiA+ICAJCWxlbmd0aCA9IGhk bWlfbXBlZ19zb3VyY2VfaW5mb2ZyYW1lX3BhY2tfb25seSgmZnJhbWUtPm1wZWdfc291cmNlLAo+ ID4gIAkJCQkJCQkgICAgICBidWZmZXIsIHNpemUpOwo+ID4gIAkJYnJlYWs7Cj4gPiArCWNhc2Ug SERNSV9JTkZPRlJBTUVfVFlQRV9OVFNDX1ZCSToKPiA+ICsJCWxlbmd0aCA9IGhkbWlfbnRzY192 YmlfaW5mb2ZyYW1lX3BhY2tfb25seSgmZnJhbWUtPm50c2NfdmJpLAo+ID4gKwkJCQkJCQkgICBi dWZmZXIsIHNpemUpOwo+ID4gKwkJYnJlYWs7Cj4gPiAgCWRlZmF1bHQ6Cj4gPiAgCQlXQVJOKDEs ICJCYWQgaW5mb2ZyYW1lIHR5cGUgJWRcbiIsIGZyYW1lLT5hbnkudHlwZSk7Cj4gPiAgCQlsZW5n dGggPSAtRUlOVkFMOwo+ID4gQEAgLTk1MSw2ICsxMDkwLDEwIEBAIGhkbWlfaW5mb2ZyYW1lX3Bh Y2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lLAo+ID4gIAkJbGVuZ3RoID0gaGRtaV9tcGVn X3NvdXJjZV9pbmZvZnJhbWVfcGFjaygmZnJhbWUtPm1wZWdfc291cmNlLAo+ID4gIAkJCQkJCQkg YnVmZmVyLCBzaXplKTsKPiA+ICAJCWJyZWFrOwo+ID4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZ UEVfTlRTQ19WQkk6Cj4gPiArCQlsZW5ndGggPSBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9wYWNr KCZmcmFtZS0+bnRzY192YmksCj4gPiArCQkJCQkJICAgICAgYnVmZmVyLCBzaXplKTsKPiA+ICsJ CWJyZWFrOwo+ID4gIAlkZWZhdWx0Ogo+ID4gIAkJV0FSTigxLCAiQmFkIGluZm9mcmFtZSB0eXBl ICVkXG4iLCBmcmFtZS0+YW55LnR5cGUpOwo+ID4gIAkJbGVuZ3RoID0gLUVJTlZBTDsKPiA+IEBA IC05NzUsNiArMTExOCw4IEBAIHN0YXRpYyBjb25zdCBjaGFyICpoZG1pX2luZm9mcmFtZV90eXBl X2dldF9uYW1lKGVudW0gaGRtaV9pbmZvZnJhbWVfdHlwZSB0eXBlKQo+ID4gIAkJcmV0dXJuICJB dWRpbyI7Cj4gPiAgCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9NUEVHX1NPVVJDRToKPiA+ICAJ CXJldHVybiAiTVBFRyBTb3VyY2UiOwo+ID4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfTlRT Q19WQkk6Cj4gPiArCQlyZXR1cm4gIk5UU0MgVkJJIjsKPiA+ICAJfQo+ID4gIAlyZXR1cm4gIlJl c2VydmVkIjsKPiA+ICB9Cj4gPiBAQCAtMTUyNiw2ICsxNjcxLDIyIEBAIHN0YXRpYyB2b2lkIGhk bWlfbXBlZ19zb3VyY2VfaW5mb2ZyYW1lX2xvZyhjb25zdCBjaGFyICpsZXZlbCwKPiA+ICAJCSBm cmFtZS0+ZmllbGRfcmVwZWF0ID8gIlllcyIgOiAiTm8iKTsKPiA+ICB9Cj4gPiAgCj4gPiArLyoq Cj4gPiArICogaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfbG9nKCkgLSBsb2cgaW5mbyBvZiBIRE1J IE5UU0MgVkJJIGluZm9mcmFtZQo+ID4gKyAqIEBsZXZlbDogbG9nZ2luZyBsZXZlbAo+ID4gKyAq IEBkZXY6IGRldmljZQo+ID4gKyAqIEBmcmFtZTogSERNSSBOVFNDIFZCSSBpbmZvZnJhbWUKPiA+ ICsgKi8KPiA+ICtzdGF0aWMgdm9pZCBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9sb2coY29uc3Qg Y2hhciAqbGV2ZWwsCj4gPiArCQkJCQlzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gPiArCQkJCQljb25z dCBzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgKmZyYW1lKQo+ID4gK3sKPiA+ICsJaGRt aV9pbmZvZnJhbWVfbG9nX2hlYWRlcihsZXZlbCwgZGV2LAo+ID4gKwkJCQkgIChjb25zdCBzdHJ1 Y3QgaGRtaV9hbnlfaW5mb2ZyYW1lICopZnJhbWUpOwo+ID4gKwo+ID4gKwloZG1pX2xvZygiICAg ICUqcGhcbiIsIGZyYW1lLT5sZW5ndGgsIGZyYW1lLT5wZXNfZGF0YV9maWVsZCk7Cj4gPiArfQo+ ID4gKwo+ID4gIC8qKgo+ID4gICAqIGhkbWlfaW5mb2ZyYW1lX2xvZygpIC0gbG9nIGluZm8gb2Yg SERNSSBpbmZvZnJhbWUKPiA+ICAgKiBAbGV2ZWw6IGxvZ2dpbmcgbGV2ZWwKPiA+IEBAIC0xNTUy LDYgKzE3MTMsOSBAQCB2b2lkIGhkbWlfaW5mb2ZyYW1lX2xvZyhjb25zdCBjaGFyICpsZXZlbCwK PiA+ICAJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX01QRUdfU09VUkNFOgo+ID4gIAkJaGRtaV9t cGVnX3NvdXJjZV9pbmZvZnJhbWVfbG9nKGxldmVsLCBkZXYsICZmcmFtZS0+bXBlZ19zb3VyY2Up Owo+ID4gIAkJYnJlYWs7Cj4gPiArCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9OVFNDX1ZCSToK PiA+ICsJCWhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX2xvZyhsZXZlbCwgZGV2LCAmZnJhbWUtPm50 c2NfdmJpKTsKPiA+ICsJCWJyZWFrOwo+ID4gIAl9Cj4gPiAgfQo+ID4gIEVYUE9SVF9TWU1CT0wo aGRtaV9pbmZvZnJhbWVfbG9nKTsKPiA+IEBAIC0xODQwLDYgKzIwMDQsNDcgQEAgc3RhdGljIGlu dCBoZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV91bnBhY2soc3RydWN0IGhkbWlfbXBlZ19zb3Vy Y2VfaW5mb2ZyYW1lICoKPiA+ICAJcmV0dXJuIDA7Cj4gPiAgfQo+ID4gIAo+ID4gKy8qKgo+ID4g KyAqIGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX3VucGFjaygpIC0gdW5wYWNrIGJpbmFyeSBidWZm ZXIgdG8gYSBIRE1JIE1QRUcgU291cmNlIGluZm9mcmFtZQo+ID4gKyAqIEBmcmFtZTogSERNSSBN UEVHIFNvdXJjZSBpbmZvZnJhbWUKPiA+ICsgKiBAYnVmZmVyOiBzb3VyY2UgYnVmZmVyCj4gPiAr ICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gPiArICoKPiA+ICsgKiBVbnBhY2tzIHRoZSBpbmZv cm1hdGlvbiBjb250YWluZWQgaW4gYmluYXJ5IEBidWZmZXIgaW50byBhIHN0cnVjdHVyZWQKPiA+ ICsgKiBAZnJhbWUgb2YgdGhlIEhETUkgTVBFRyBTb3VyY2UgaW5mb3JtYXRpb24gZnJhbWUuCj4g PiArICogQWxzbyB2ZXJpZmllcyB0aGUgY2hlY2tzdW0gYXMgcmVxdWlyZWQgYnkgc2VjdGlvbiA1 LjMuNSBvZiB0aGUgSERNSSAxLjQKPiA+ICsgKiBzcGVjaWZpY2F0aW9uLgo+ID4gKyAqCj4gPiAr ICogUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1 cmUuCj4gPiArICovCj4gPiArc3RhdGljIGludCBoZG1pX250c2NfdmJpX2luZm9mcmFtZV91bnBh Y2soc3RydWN0IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lICpmcmFtZSwKPiA+ICsJCQkJCSAgY29u c3Qgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiA+ICt7Cj4gPiArCWNvbnN0IHU4ICpwdHIg PSBidWZmZXI7Cj4gPiArCXNpemVfdCBsZW5ndGg7Cj4gPiArCj4gPiArCWlmIChzaXplIDwgSERN SV9JTkZPRlJBTUVfSEVBREVSX1NJWkUpCj4gPiArCQlyZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ ICsJaWYgKHB0clswXSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX05UU0NfVkJJIHx8Cj4gPiArCSAg ICBwdHJbMV0gIT0gMSB8fAo+ID4gKwkgICAgcHRyWzJdIDwgMSB8fCBwdHJbMl0gPiAyNykKPiA+ ICsJCXJldHVybiAtRUlOVkFMOwo+ID4gKwo+ID4gKwlsZW5ndGggPSBwdHJbMl07Cj4gPiArCj4g PiArCWlmIChzaXplIDwgSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBsZW5ndGgpCj4gPiAr CQlyZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ICsJaWYgKGhkbWlfaW5mb2ZyYW1lX2NoZWNrc3Vt KGJ1ZmZlciwKPiA+ICsJCQkJICAgIEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgbGVuZ3Ro KSAhPSAwKQo+ID4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gPiArCj4gPiArCXB0ciArPSBIRE1JX0lO Rk9GUkFNRV9IRUFERVJfU0laRTsKPiA+ICsKPiA+ICsJcmV0dXJuIGhkbWlfbnRzY192YmlfaW5m b2ZyYW1lX2luaXQoZnJhbWUsIHB0ciwgbGVuZ3RoKTsKPiA+ICt9Cj4gPiArCj4gPiAgLyoqCj4g PiAgICogaGRtaV9pbmZvZnJhbWVfdW5wYWNrKCkgLSB1bnBhY2sgYmluYXJ5IGJ1ZmZlciB0byBh IEhETUkgaW5mb2ZyYW1lCj4gPiAgICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQo+ID4gQEAgLTE4 NzgsNiArMjA4Myw5IEBAIGludCBoZG1pX2luZm9mcmFtZV91bnBhY2sodW5pb24gaGRtaV9pbmZv ZnJhbWUgKmZyYW1lLAo+ID4gIAljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfTVBFR19TT1VSQ0U6 Cj4gPiAgCQlyZXQgPSBoZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV91bnBhY2soJmZyYW1lLT5t cGVnX3NvdXJjZSwgYnVmZmVyLCBzaXplKTsKPiA+ICAJCWJyZWFrOwo+ID4gKwljYXNlIEhETUlf SU5GT0ZSQU1FX1RZUEVfTlRTQ19WQkk6Cj4gPiArCQlyZXQgPSBoZG1pX250c2NfdmJpX2luZm9m cmFtZV91bnBhY2soJmZyYW1lLT5udHNjX3ZiaSwgYnVmZmVyLCBzaXplKTsKPiA+ICsJCWJyZWFr Owo+ID4gIAlkZWZhdWx0Ogo+ID4gIAkJcmV0ID0gLUVJTlZBTDsKPiA+ICAJCWJyZWFrOwo+ID4g ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaGRtaS5oIGIvaW5jbHVkZS9saW51eC9oZG1pLmgK PiA+IGluZGV4IDJjOTMyMmY3NTM4ZC4uMzgyMTUxNmIzMzZjIDEwMDY0NAo+ID4gLS0tIGEvaW5j bHVkZS9saW51eC9oZG1pLmgKPiA+ICsrKyBiL2luY2x1ZGUvbGludXgvaGRtaS5oCj4gPiBAQCAt NDgsNiArNDgsNyBAQCBlbnVtIGhkbWlfaW5mb2ZyYW1lX3R5cGUgewo+ID4gIAlIRE1JX0lORk9G UkFNRV9UWVBFX1NQRCA9IDB4ODMsCj4gPiAgCUhETUlfSU5GT0ZSQU1FX1RZUEVfQVVESU8gPSAw eDg0LAo+ID4gIAlIRE1JX0lORk9GUkFNRV9UWVBFX01QRUdfU09VUkNFID0gMHg4NSwKPiA+ICsJ SERNSV9JTkZPRlJBTUVfVFlQRV9OVFNDX1ZCSSA9IDB4ODYsCj4gPiAgfTsKPiA+ICAKPiA+ICAj ZGVmaW5lIEhETUlfSUVFRV9PVUkgMHgwMDBjMDMKPiA+IEBAIC0zNjIsNiArMzYzLDIxIEBAIHNz aXplX3QgaGRtaV9tcGVnX3NvdXJjZV9pbmZvZnJhbWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBo ZG1pX21wZWdfc291cmNlX2luZm9mCj4gPiAgCQkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90 IHNpemUpOwo+ID4gIGludCBoZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV9jaGVjayhzdHJ1Y3Qg aGRtaV9tcGVnX3NvdXJjZV9pbmZvZnJhbWUgKmZyYW1lKTsKPiA+ICAKPiA+ICtzdHJ1Y3QgaGRt aV9udHNjX3ZiaV9pbmZvZnJhbWUgewo+ID4gKwllbnVtIGhkbWlfaW5mb2ZyYW1lX3R5cGUgdHlw ZTsKPiA+ICsJdW5zaWduZWQgY2hhciB2ZXJzaW9uOwo+ID4gKwl1bnNpZ25lZCBjaGFyIGxlbmd0 aDsKPiA+ICsJdW5zaWduZWQgY2hhciBwZXNfZGF0YV9maWVsZFsyN107Cj4gPiArfTsKPiA+ICsK PiA+ICtpbnQgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV9udHNjX3Zi aV9pbmZvZnJhbWUgKmZyYW1lLAo+ID4gKwkJCQkgY29uc3Qgdm9pZCAqcGVzX2RhdGFfZmllbGQs IHNpemVfdCBsZW5ndGgpOwo+ID4gK3NzaXplX3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfcGFj ayhzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgKmZyYW1lLAo+ID4gKwkJCQkgICAgIHZv aWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK3NzaXplX3QgaGRtaV9udHNjX3ZiaV9pbmZv ZnJhbWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX250c2NfdmJpX2luZm9mcmFtZSAqZnJh bWUsCj4gPiArCQkJCQkgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gK2ludCBoZG1p X250c2NfdmJpX2luZm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUg KmZyYW1lKTsKPiA+ICsKPiA+ICAvKioKPiA+ICAgKiB1bmlvbiBoZG1pX2luZm9mcmFtZSAtIG92 ZXJhbGwgdW5pb24gb2YgYWxsIGFic3RyYWN0IGluZm9mcmFtZSByZXByZXNlbnRhdGlvbnMKPiA+ ICAgKiBAYW55OiBnZW5lcmljIGluZm9mcmFtZQo+ID4gQEAgLTM3MCw2ICszODYsNyBAQCBpbnQg aGRtaV9tcGVnX3NvdXJjZV9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfbXBlZ19zb3VyY2Vf aW5mb2ZyYW1lICpmcmFtZSk7Cj4gPiAgICogQHZlbmRvcjogdW5pb24gb2YgYWxsIHZlbmRvciBp bmZvZnJhbWVzCj4gPiAgICogQGF1ZGlvOiBhdWRpbyBpbmZvZnJhbWUKPiA+ICAgKiBAbXBlZ19z b3VyY2U6IG1wZWcgc291cmNlIGluZm9mcmFtZQo+ID4gKyAqIEBudHNjX3ZiaTogbnRzYyB2Ymkg aW5mb2ZyYW1lCj4gPiAgICoKPiA+ICAgKiBUaGlzIGlzIHVzZWQgYnkgdGhlIGdlbmVyaWMgcGFj ayBmdW5jdGlvbi4gVGhpcyB3b3JrcyBzaW5jZSBhbGwgaW5mb2ZyYW1lcwo+ID4gICAqIGhhdmUg dGhlIHNhbWUgaGVhZGVyIHdoaWNoIGFsc28gaW5kaWNhdGVzIHdoaWNoIHR5cGUgb2YgaW5mb2Zy YW1lIHNob3VsZCBiZQo+ID4gQEAgLTM4Miw2ICszOTksNyBAQCB1bmlvbiBoZG1pX2luZm9mcmFt ZSB7Cj4gPiAgCXVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgdmVuZG9yOwo+ID4gIAlz dHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgYXVkaW87Cj4gPiAgCXN0cnVjdCBoZG1pX21wZWdf c291cmNlX2luZm9mcmFtZSBtcGVnX3NvdXJjZTsKPiA+ICsJc3RydWN0IGhkbWlfbnRzY192Ymlf aW5mb2ZyYW1lIG50c2NfdmJpOwo+ID4gIH07Cj4gPiAgCj4gPiAgc3NpemVfdCBoZG1pX2luZm9m cmFtZV9wYWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLAo+ID4g CgotLSAKVmlsbGUgU3lyasOkbMOkCkludGVsCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga06.intel.com ([134.134.136.31]:14060 "EHLO mga06.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727392AbeIUTnP (ORCPT ); Fri, 21 Sep 2018 15:43:15 -0400 Date: Fri, 21 Sep 2018 16:54:12 +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 07/18] video/hdmi: Handle the NTSC VBI infoframe Message-ID: <20180921135412.GW5565@intel.com> References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-8-ville.syrjala@linux.intel.com> <4e790da9-a49c-e4b2-d528-4c6c8bca722e@cisco.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <4e790da9-a49c-e4b2-d528-4c6c8bca722e@cisco.com> Sender: linux-media-owner@vger.kernel.org List-ID: On Fri, Sep 21, 2018 at 10:30:16AM +0200, Hans Verkuil wrote: > On 09/20/18 20:51, Ville Syrjala wrote: > > From: Ville Syrjälä > > > > Add the code to deal with the NTSC VBI infoframe. > > > > I decided against parsing the PES_data_field and just leave > > it as an opaque blob, just dumping it out as hex in the log. > > > > Blindly typed from the spec, and totally untested. > > Do we have any driver that uses this? I would prefer to wait until someone > actually need this. No users that I know of. So totally fine with me to leave it out. > > Regards, > > Hans > > > > > Cc: Thierry Reding > > Cc: Hans Verkuil > > Cc: linux-media@vger.kernel.org > > Signed-off-by: Ville Syrjälä > > --- > > drivers/video/hdmi.c | 208 +++++++++++++++++++++++++++++++++++++++++++++++++++ > > include/linux/hdmi.h | 18 +++++ > > 2 files changed, 226 insertions(+) > > > > diff --git a/drivers/video/hdmi.c b/drivers/video/hdmi.c > > index 3d24c7746c51..3c320d69fa0a 100644 > > --- a/drivers/video/hdmi.c > > +++ b/drivers/video/hdmi.c > > @@ -831,6 +831,139 @@ ssize_t hdmi_mpeg_source_infoframe_pack(struct hdmi_mpeg_source_infoframe *frame > > } > > EXPORT_SYMBOL(hdmi_mpeg_source_infoframe_pack); > > > > +/** > > + * hdmi_ntsc_vbi_infoframe_init() - initialize an HDMI NTSC VBI infoframe > > + * @frame: HDMI NTSC VBI infoframe > > + * @pes_data_field: ANSI/SCTE 127 PES_data_field > > + * @length: ANSI/SCTE 127 PES_data_field length > > + * > > + * Returns 0 on success or a negative error code on failure. > > + */ > > +int hdmi_ntsc_vbi_infoframe_init(struct hdmi_ntsc_vbi_infoframe *frame, > > + const void *pes_data_field, > > + size_t length) > > +{ > > + if (length < 1 || length > 27) > > + return -EINVAL; > > + > > + memset(frame, 0, sizeof(*frame)); > > + > > + frame->type = HDMI_INFOFRAME_TYPE_NTSC_VBI; > > + frame->version = 1; > > + frame->length = length; > > + > > + memcpy(frame->pes_data_field, pes_data_field, length); > > + > > + return 0; > > +} > > +EXPORT_SYMBOL(hdmi_ntsc_vbi_infoframe_init); > > + > > +static int hdmi_ntsc_vbi_infoframe_check_only(const struct hdmi_ntsc_vbi_infoframe *frame) > > +{ > > + if (frame->type != HDMI_INFOFRAME_TYPE_NTSC_VBI || > > + frame->version != 1 || > > + frame->length < 1 || frame->length > 27) > > + return -EINVAL; > > + > > + if (frame->pes_data_field[0] != 0x99) > > + return -EINVAL; > > + > > + return 0; > > +} > > + > > +/** > > + * hdmi_ntsc_vbi_infoframe_check() - Check and check a HDMI NTSC VBI infoframe > > + * @frame: HDMI NTSC VBI 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_ntsc_vbi_infoframe_check(struct hdmi_ntsc_vbi_infoframe *frame) > > +{ > > + return hdmi_ntsc_vbi_infoframe_check_only(frame); > > +} > > +EXPORT_SYMBOL(hdmi_ntsc_vbi_infoframe_check); > > + > > +/** > > + * hdmi_ntsc_vbi_infoframe_pack_only() - write HDMI NTSC VBI infoframe to binary buffer > > + * @frame: HDMI NTSC VBI infoframe > > + * @buffer: destination buffer > > + * @size: size of buffer > > + * > > + * 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_ntsc_vbi_infoframe_pack_only(const struct hdmi_ntsc_vbi_infoframe *frame, > > + void *buffer, size_t size) > > +{ > > + u8 *ptr = buffer; > > + size_t length; > > + int ret; > > + > > + ret = hdmi_ntsc_vbi_infoframe_check_only(frame); > > + if (ret) > > + return ret; > > + > > + length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > + > > + if (size < length) > > + return -ENOSPC; > > + > > + memset(buffer, 0, size); > > + > > + ptr[0] = frame->type; > > + ptr[1] = frame->version; > > + ptr[2] = frame->length; > > + ptr[3] = 0; /* checksum */ > > + > > + /* start infoframe payload */ > > + ptr += HDMI_INFOFRAME_HEADER_SIZE; > > + > > + memcpy(ptr, frame->pes_data_field, frame->length); > > + > > + hdmi_infoframe_set_checksum(buffer, length); > > + > > + return length; > > +} > > +EXPORT_SYMBOL(hdmi_ntsc_vbi_infoframe_pack_only); > > + > > +/** > > + * hdmi_ntsc_vbi_infoframe_pack() - Check and check a HDMI NTSC VBI infoframe, > > + * and write it to binary buffer > > + * @frame: HDMI NTSC VBI 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_ntsc_vbi_infoframe_pack(struct hdmi_ntsc_vbi_infoframe *frame, > > + void *buffer, size_t size) > > +{ > > + int ret; > > + > > + ret = hdmi_ntsc_vbi_infoframe_check(frame); > > + if (ret) > > + return ret; > > + > > + return hdmi_ntsc_vbi_infoframe_pack_only(frame, buffer, size); > > +} > > +EXPORT_SYMBOL(hdmi_ntsc_vbi_infoframe_pack); > > + > > /** > > * hdmi_infoframe_check() - Check check a HDMI infoframe > > * @frame: HDMI infoframe > > @@ -854,6 +987,8 @@ hdmi_infoframe_check(union hdmi_infoframe *frame) > > return hdmi_vendor_any_infoframe_check(&frame->vendor); > > case HDMI_INFOFRAME_TYPE_MPEG_SOURCE: > > return hdmi_mpeg_source_infoframe_check(&frame->mpeg_source); > > + case HDMI_INFOFRAME_TYPE_NTSC_VBI: > > + return hdmi_ntsc_vbi_infoframe_check(&frame->ntsc_vbi); > > default: > > WARN(1, "Bad infoframe type %d\n", frame->any.type); > > return -EINVAL; > > @@ -901,6 +1036,10 @@ hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t > > length = hdmi_mpeg_source_infoframe_pack_only(&frame->mpeg_source, > > buffer, size); > > break; > > + case HDMI_INFOFRAME_TYPE_NTSC_VBI: > > + length = hdmi_ntsc_vbi_infoframe_pack_only(&frame->ntsc_vbi, > > + buffer, size); > > + break; > > default: > > WARN(1, "Bad infoframe type %d\n", frame->any.type); > > length = -EINVAL; > > @@ -951,6 +1090,10 @@ hdmi_infoframe_pack(union hdmi_infoframe *frame, > > length = hdmi_mpeg_source_infoframe_pack(&frame->mpeg_source, > > buffer, size); > > break; > > + case HDMI_INFOFRAME_TYPE_NTSC_VBI: > > + length = hdmi_ntsc_vbi_infoframe_pack(&frame->ntsc_vbi, > > + buffer, size); > > + break; > > default: > > WARN(1, "Bad infoframe type %d\n", frame->any.type); > > length = -EINVAL; > > @@ -975,6 +1118,8 @@ static const char *hdmi_infoframe_type_get_name(enum hdmi_infoframe_type type) > > return "Audio"; > > case HDMI_INFOFRAME_TYPE_MPEG_SOURCE: > > return "MPEG Source"; > > + case HDMI_INFOFRAME_TYPE_NTSC_VBI: > > + return "NTSC VBI"; > > } > > return "Reserved"; > > } > > @@ -1526,6 +1671,22 @@ static void hdmi_mpeg_source_infoframe_log(const char *level, > > frame->field_repeat ? "Yes" : "No"); > > } > > > > +/** > > + * hdmi_ntsc_vbi_infoframe_log() - log info of HDMI NTSC VBI infoframe > > + * @level: logging level > > + * @dev: device > > + * @frame: HDMI NTSC VBI infoframe > > + */ > > +static void hdmi_ntsc_vbi_infoframe_log(const char *level, > > + struct device *dev, > > + const struct hdmi_ntsc_vbi_infoframe *frame) > > +{ > > + hdmi_infoframe_log_header(level, dev, > > + (const struct hdmi_any_infoframe *)frame); > > + > > + hdmi_log(" %*ph\n", frame->length, frame->pes_data_field); > > +} > > + > > /** > > * hdmi_infoframe_log() - log info of HDMI infoframe > > * @level: logging level > > @@ -1552,6 +1713,9 @@ void hdmi_infoframe_log(const char *level, > > case HDMI_INFOFRAME_TYPE_MPEG_SOURCE: > > hdmi_mpeg_source_infoframe_log(level, dev, &frame->mpeg_source); > > break; > > + case HDMI_INFOFRAME_TYPE_NTSC_VBI: > > + hdmi_ntsc_vbi_infoframe_log(level, dev, &frame->ntsc_vbi); > > + break; > > } > > } > > EXPORT_SYMBOL(hdmi_infoframe_log); > > @@ -1840,6 +2004,47 @@ static int hdmi_mpeg_source_infoframe_unpack(struct hdmi_mpeg_source_infoframe * > > return 0; > > } > > > > +/** > > + * hdmi_ntsc_vbi_infoframe_unpack() - unpack binary buffer to a HDMI MPEG Source infoframe > > + * @frame: HDMI MPEG Source infoframe > > + * @buffer: source buffer > > + * @size: size of buffer > > + * > > + * Unpacks the information contained in binary @buffer into a structured > > + * @frame of the HDMI MPEG Source information frame. > > + * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 > > + * specification. > > + * > > + * Returns 0 on success or a negative error code on failure. > > + */ > > +static int hdmi_ntsc_vbi_infoframe_unpack(struct hdmi_ntsc_vbi_infoframe *frame, > > + const void *buffer, size_t size) > > +{ > > + const u8 *ptr = buffer; > > + size_t length; > > + > > + if (size < HDMI_INFOFRAME_HEADER_SIZE) > > + return -EINVAL; > > + > > + if (ptr[0] != HDMI_INFOFRAME_TYPE_NTSC_VBI || > > + ptr[1] != 1 || > > + ptr[2] < 1 || ptr[2] > 27) > > + return -EINVAL; > > + > > + length = ptr[2]; > > + > > + if (size < HDMI_INFOFRAME_HEADER_SIZE + length) > > + return -EINVAL; > > + > > + if (hdmi_infoframe_checksum(buffer, > > + HDMI_INFOFRAME_HEADER_SIZE + length) != 0) > > + return -EINVAL; > > + > > + ptr += HDMI_INFOFRAME_HEADER_SIZE; > > + > > + return hdmi_ntsc_vbi_infoframe_init(frame, ptr, length); > > +} > > + > > /** > > * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe > > * @frame: HDMI infoframe > > @@ -1878,6 +2083,9 @@ int hdmi_infoframe_unpack(union hdmi_infoframe *frame, > > case HDMI_INFOFRAME_TYPE_MPEG_SOURCE: > > ret = hdmi_mpeg_source_infoframe_unpack(&frame->mpeg_source, buffer, size); > > break; > > + case HDMI_INFOFRAME_TYPE_NTSC_VBI: > > + ret = hdmi_ntsc_vbi_infoframe_unpack(&frame->ntsc_vbi, buffer, size); > > + break; > > default: > > ret = -EINVAL; > > break; > > diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h > > index 2c9322f7538d..3821516b336c 100644 > > --- a/include/linux/hdmi.h > > +++ b/include/linux/hdmi.h > > @@ -48,6 +48,7 @@ enum hdmi_infoframe_type { > > HDMI_INFOFRAME_TYPE_SPD = 0x83, > > HDMI_INFOFRAME_TYPE_AUDIO = 0x84, > > HDMI_INFOFRAME_TYPE_MPEG_SOURCE = 0x85, > > + HDMI_INFOFRAME_TYPE_NTSC_VBI = 0x86, > > }; > > > > #define HDMI_IEEE_OUI 0x000c03 > > @@ -362,6 +363,21 @@ ssize_t hdmi_mpeg_source_infoframe_pack_only(const struct hdmi_mpeg_source_infof > > void *buffer, size_t size); > > int hdmi_mpeg_source_infoframe_check(struct hdmi_mpeg_source_infoframe *frame); > > > > +struct hdmi_ntsc_vbi_infoframe { > > + enum hdmi_infoframe_type type; > > + unsigned char version; > > + unsigned char length; > > + unsigned char pes_data_field[27]; > > +}; > > + > > +int hdmi_ntsc_vbi_infoframe_init(struct hdmi_ntsc_vbi_infoframe *frame, > > + const void *pes_data_field, size_t length); > > +ssize_t hdmi_ntsc_vbi_infoframe_pack(struct hdmi_ntsc_vbi_infoframe *frame, > > + void *buffer, size_t size); > > +ssize_t hdmi_ntsc_vbi_infoframe_pack_only(const struct hdmi_ntsc_vbi_infoframe *frame, > > + void *buffer, size_t size); > > +int hdmi_ntsc_vbi_infoframe_check(struct hdmi_ntsc_vbi_infoframe *frame); > > + > > /** > > * union hdmi_infoframe - overall union of all abstract infoframe representations > > * @any: generic infoframe > > @@ -370,6 +386,7 @@ int hdmi_mpeg_source_infoframe_check(struct hdmi_mpeg_source_infoframe *frame); > > * @vendor: union of all vendor infoframes > > * @audio: audio infoframe > > * @mpeg_source: mpeg source infoframe > > + * @ntsc_vbi: ntsc vbi infoframe > > * > > * This is used by the generic pack function. This works since all infoframes > > * have the same header which also indicates which type of infoframe should be > > @@ -382,6 +399,7 @@ union hdmi_infoframe { > > union hdmi_vendor_any_infoframe vendor; > > struct hdmi_audio_infoframe audio; > > struct hdmi_mpeg_source_infoframe mpeg_source; > > + struct hdmi_ntsc_vbi_infoframe ntsc_vbi; > > }; > > > > ssize_t hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, > > -- Ville Syrjälä Intel