From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hans Verkuil Subject: Re: [PATCH 07/18] video/hdmi: Handle the NTSC VBI infoframe Date: Fri, 21 Sep 2018 10:30:16 +0200 Message-ID: <4e790da9-a49c-e4b2-d528-4c6c8bca722e@cisco.com> References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-8-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180920185145.1912-8-ville.syrjala@linux.intel.com> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Ville Syrjala , 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 T24gMDkvMjAvMTggMjA6NTEsIFZpbGxlIFN5cmphbGEgd3JvdGU6Cj4gRnJvbTogVmlsbGUgU3ly asOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiAKPiBBZGQgdGhlIGNvZGUg dG8gZGVhbCB3aXRoIHRoZSBOVFNDIFZCSSBpbmZvZnJhbWUuCj4gCj4gSSBkZWNpZGVkIGFnYWlu c3QgcGFyc2luZyB0aGUgUEVTX2RhdGFfZmllbGQgYW5kIGp1c3QgbGVhdmUKPiBpdCBhcyBhbiBv cGFxdWUgYmxvYiwganVzdCBkdW1waW5nIGl0IG91dCBhcyBoZXggaW4gdGhlIGxvZy4KPiAKPiBC bGluZGx5IHR5cGVkIGZyb20gdGhlIHNwZWMsIGFuZCB0b3RhbGx5IHVudGVzdGVkLgoKRG8gd2Ug aGF2ZSBhbnkgZHJpdmVyIHRoYXQgdXNlcyB0aGlzPyBJIHdvdWxkIHByZWZlciB0byB3YWl0IHVu dGlsIHNvbWVvbmUKYWN0dWFsbHkgbmVlZCB0aGlzLgoKUmVnYXJkcywKCglIYW5zCgo+IAo+IENj OiBUaGllcnJ5IFJlZGluZyA8dGhpZXJyeS5yZWRpbmdAZ21haWwuY29tPgo+IENjOiBIYW5zIFZl cmt1aWwgPGhhbnMudmVya3VpbEBjaXNjby5jb20+Cj4gQ2M6IGxpbnV4LW1lZGlhQHZnZXIua2Vy bmVsLm9yZwo+IFNpZ25lZC1vZmYtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBs aW51eC5pbnRlbC5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvdmlkZW8vaGRtaS5jIHwgMjA4ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBpbmNsdWRl L2xpbnV4L2hkbWkuaCB8ICAxOCArKysrKwo+ICAyIGZpbGVzIGNoYW5nZWQsIDIyNiBpbnNlcnRp b25zKCspCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vaGRtaS5jIGIvZHJpdmVycy92 aWRlby9oZG1pLmMKPiBpbmRleCAzZDI0Yzc3NDZjNTEuLjNjMzIwZDY5ZmEwYSAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL3ZpZGVvL2hkbWkuYwo+ICsrKyBiL2RyaXZlcnMvdmlkZW8vaGRtaS5jCj4g QEAgLTgzMSw2ICs4MzEsMTM5IEBAIHNzaXplX3QgaGRtaV9tcGVnX3NvdXJjZV9pbmZvZnJhbWVf cGFjayhzdHJ1Y3QgaGRtaV9tcGVnX3NvdXJjZV9pbmZvZnJhbWUgKmZyYW1lCj4gIH0KPiAgRVhQ T1JUX1NZTUJPTChoZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV9wYWNrKTsKPiAgCj4gKy8qKgo+ ICsgKiBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9pbml0KCkgLSBpbml0aWFsaXplIGFuIEhETUkg TlRTQyBWQkkgaW5mb2ZyYW1lCj4gKyAqIEBmcmFtZTogSERNSSBOVFNDIFZCSSBpbmZvZnJhbWUK PiArICogQHBlc19kYXRhX2ZpZWxkOiBBTlNJL1NDVEUgMTI3IFBFU19kYXRhX2ZpZWxkCj4gKyAq IEBsZW5ndGg6IEFOU0kvU0NURSAxMjcgUEVTX2RhdGFfZmllbGQgbGVuZ3RoCj4gKyAqCj4gKyAq IFJldHVybnMgMCBvbiBzdWNjZXNzIG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJl Lgo+ICsgKi8KPiAraW50IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlf bnRzY192YmlfaW5mb2ZyYW1lICpmcmFtZSwKPiArCQkJCSBjb25zdCB2b2lkICpwZXNfZGF0YV9m aWVsZCwKPiArCQkJCSBzaXplX3QgbGVuZ3RoKQo+ICt7Cj4gKwlpZiAobGVuZ3RoIDwgMSB8fCBs ZW5ndGggPiAyNykKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwltZW1zZXQoZnJhbWUsIDAs IHNpemVvZigqZnJhbWUpKTsKPiArCj4gKwlmcmFtZS0+dHlwZSA9IEhETUlfSU5GT0ZSQU1FX1RZ UEVfTlRTQ19WQkk7Cj4gKwlmcmFtZS0+dmVyc2lvbiA9IDE7Cj4gKwlmcmFtZS0+bGVuZ3RoID0g bGVuZ3RoOwo+ICsKPiArCW1lbWNweShmcmFtZS0+cGVzX2RhdGFfZmllbGQsIHBlc19kYXRhX2Zp ZWxkLCBsZW5ndGgpOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woaGRt aV9udHNjX3ZiaV9pbmZvZnJhbWVfaW5pdCk7Cj4gKwo+ICtzdGF0aWMgaW50IGhkbWlfbnRzY192 YmlfaW5mb2ZyYW1lX2NoZWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfbnRzY192YmlfaW5mb2Zy YW1lICpmcmFtZSkKPiArewo+ICsJaWYgKGZyYW1lLT50eXBlICE9IEhETUlfSU5GT0ZSQU1FX1RZ UEVfTlRTQ19WQkkgfHwKPiArCSAgICBmcmFtZS0+dmVyc2lvbiAhPSAxIHx8Cj4gKwkgICAgZnJh bWUtPmxlbmd0aCA8IDEgfHwgZnJhbWUtPmxlbmd0aCA+IDI3KQo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCWlmIChmcmFtZS0+cGVzX2RhdGFfZmllbGRbMF0gIT0gMHg5OSkKPiArCQlyZXR1 cm4gLUVJTlZBTDsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArLyoqCj4gKyAqIGhkbWlf bnRzY192YmlfaW5mb2ZyYW1lX2NoZWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIE5UU0Mg VkJJIGluZm9mcmFtZQo+ICsgKiBAZnJhbWU6IEhETUkgTlRTQyBWQkkgaW5mb2ZyYW1lCj4gKyAq Cj4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBk YXRlcyBkZXJpdmVkIGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmll bGRzLgo+ICsgKgo+ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9y IGNvZGUgb24gZmFpbHVyZS4KPiArICovCj4gK2ludCBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9j aGVjayhzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlyZXR1 cm4gaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gK30KPiArRVhQ T1JUX1NZTUJPTChoZG1pX250c2NfdmJpX2luZm9mcmFtZV9jaGVjayk7Cj4gKwo+ICsvKioKPiAr ICogaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfcGFja19vbmx5KCkgLSB3cml0ZSBIRE1JIE5UU0Mg VkJJIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gKyAqIEBmcmFtZTogSERNSSBOVFNDIFZC SSBpbmZvZnJhbWUKPiArICogQGJ1ZmZlcjogZGVzdGluYXRpb24gYnVmZmVyCj4gKyAqIEBzaXpl OiBzaXplIG9mIGJ1ZmZlcgo+ICsgKgo+ICsgKiBQYWNrcyB0aGUgaW5mb3JtYXRpb24gY29udGFp bmVkIGluIHRoZSBAZnJhbWUgc3RydWN0dXJlIGludG8gYSBiaW5hcnkKPiArICogcmVwcmVzZW50 YXRpb24gdGhhdCBjYW4gYmUgd3JpdHRlbiBpbnRvIHRoZSBjb3JyZXNwb25kaW5nIGNvbnRyb2xs ZXIKPiArICogcmVnaXN0ZXJzLiBBbHNvIGNvbXB1dGVzIHRoZSBjaGVja3N1bSBhcyByZXF1aXJl ZCBieSBzZWN0aW9uIDUuMy41IG9mCj4gKyAqIHRoZSBIRE1JIDEuNCBzcGVjaWZpY2F0aW9uLgo+ ICsgKgo+ICsgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJp bmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQo+ICsgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4g KyAqLwo+ICtzc2l6ZV90IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCBz dHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCQkJCSAgdm9pZCAqYnVm ZmVyLCBzaXplX3Qgc2l6ZSkKPiArewo+ICsJdTggKnB0ciA9IGJ1ZmZlcjsKPiArCXNpemVfdCBs ZW5ndGg7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1l X2NoZWNrX29ubHkoZnJhbWUpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiAr CWxlbmd0aCA9IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgZnJhbWUtPmxlbmd0aDsKPiAr Cj4gKwlpZiAoc2l6ZSA8IGxlbmd0aCkKPiArCQlyZXR1cm4gLUVOT1NQQzsKPiArCj4gKwltZW1z ZXQoYnVmZmVyLCAwLCBzaXplKTsKPiArCj4gKwlwdHJbMF0gPSBmcmFtZS0+dHlwZTsKPiArCXB0 clsxXSA9IGZyYW1lLT52ZXJzaW9uOwo+ICsJcHRyWzJdID0gZnJhbWUtPmxlbmd0aDsKPiArCXB0 clszXSA9IDA7IC8qIGNoZWNrc3VtICovCj4gKwo+ICsJLyogc3RhcnQgaW5mb2ZyYW1lIHBheWxv YWQgKi8KPiArCXB0ciArPSBIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRTsKPiArCj4gKwltZW1j cHkocHRyLCBmcmFtZS0+cGVzX2RhdGFfZmllbGQsIGZyYW1lLT5sZW5ndGgpOwo+ICsKPiArCWhk bWlfaW5mb2ZyYW1lX3NldF9jaGVja3N1bShidWZmZXIsIGxlbmd0aCk7Cj4gKwo+ICsJcmV0dXJu IGxlbmd0aDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX3Bh Y2tfb25seSk7Cj4gKwo+ICsvKioKPiArICogaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfcGFjaygp IC0gQ2hlY2sgYW5kIGNoZWNrIGEgSERNSSBOVFNDIFZCSSBpbmZvZnJhbWUsCj4gKyAqICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFuZCB3cml0ZSBpdCB0byBiaW5hcnkgYnVmZmVy Cj4gKyAqIEBmcmFtZTogSERNSSBOVFNDIFZCSSBpbmZvZnJhbWUKPiArICogQGJ1ZmZlcjogZGVz dGluYXRpb24gYnVmZmVyCj4gKyAqIEBzaXplOiBzaXplIG9mIGJ1ZmZlcgo+ICsgKgo+ICsgKiBW YWxpZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVy aXZlZCBmaWVsZHMKPiArICogKGVnLiBsZW5ndGgpIGJhc2VkIG9uIG90aGVyIGZpZWxkcywgYWZ0 ZXIgd2hpY2ggcGFja3MgdGhlIGluZm9ybWF0aW9uCj4gKyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZy YW1lIHN0cnVjdHVyZSBpbnRvIGEgYmluYXJ5IHJlcHJlc2VudGF0aW9uIHRoYXQKPiArICogY2Fu IGJlIHdyaXR0ZW4gaW50byB0aGUgY29ycmVzcG9uZGluZyBjb250cm9sbGVyIHJlZ2lzdGVycy4g QWxzbwo+ICsgKiBjb21wdXRlcyB0aGUgY2hlY2tzdW0gYXMgcmVxdWlyZWQgYnkgc2VjdGlvbiA1 LjMuNSBvZiB0aGUgSERNSSAxLjQKPiArICogc3BlY2lmaWNhdGlvbi4KPiArICoKPiArICogUmV0 dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHBhY2tlZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVyIG9y IGEgbmVnYXRpdmUKPiArICogZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ICsgKi8KPiArc3NpemVf dCBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX250c2NfdmJpX2luZm9m cmFtZSAqZnJhbWUsCj4gKwkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK3sK PiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfY2hlY2so ZnJhbWUpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldHVybiBoZG1p X250c2NfdmJpX2luZm9mcmFtZV9wYWNrX29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6ZSk7Cj4gK30K PiArRVhQT1JUX1NZTUJPTChoZG1pX250c2NfdmJpX2luZm9mcmFtZV9wYWNrKTsKPiArCj4gIC8q Kgo+ICAgKiBoZG1pX2luZm9mcmFtZV9jaGVjaygpIC0gQ2hlY2sgY2hlY2sgYSBIRE1JIGluZm9m cmFtZQo+ICAgKiBAZnJhbWU6IEhETUkgaW5mb2ZyYW1lCj4gQEAgLTg1NCw2ICs5ODcsOCBAQCBo ZG1pX2luZm9mcmFtZV9jaGVjayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUpCj4gIAkJcmV0 dXJuIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfY2hlY2soJmZyYW1lLT52ZW5kb3IpOwo+ICAJ Y2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX01QRUdfU09VUkNFOgo+ICAJCXJldHVybiBoZG1pX21w ZWdfc291cmNlX2luZm9mcmFtZV9jaGVjaygmZnJhbWUtPm1wZWdfc291cmNlKTsKPiArCWNhc2Ug SERNSV9JTkZPRlJBTUVfVFlQRV9OVFNDX1ZCSToKPiArCQlyZXR1cm4gaGRtaV9udHNjX3ZiaV9p bmZvZnJhbWVfY2hlY2soJmZyYW1lLT5udHNjX3ZiaSk7Cj4gIAlkZWZhdWx0Ogo+ICAJCVdBUk4o MSwgIkJhZCBpbmZvZnJhbWUgdHlwZSAlZFxuIiwgZnJhbWUtPmFueS50eXBlKTsKPiAgCQlyZXR1 cm4gLUVJTlZBTDsKPiBAQCAtOTAxLDYgKzEwMzYsMTAgQEAgaGRtaV9pbmZvZnJhbWVfcGFja19v bmx5KGNvbnN0IHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLCBzaXpl X3QKPiAgCQlsZW5ndGggPSBoZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV9wYWNrX29ubHkoJmZy YW1lLT5tcGVnX3NvdXJjZSwKPiAgCQkJCQkJCSAgICAgIGJ1ZmZlciwgc2l6ZSk7Cj4gIAkJYnJl YWs7Cj4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfTlRTQ19WQkk6Cj4gKwkJbGVuZ3RoID0g aGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+bnRzY192YmksCj4gKwkJ CQkJCQkgICBidWZmZXIsIHNpemUpOwo+ICsJCWJyZWFrOwo+ICAJZGVmYXVsdDoKPiAgCQlXQVJO KDEsICJCYWQgaW5mb2ZyYW1lIHR5cGUgJWRcbiIsIGZyYW1lLT5hbnkudHlwZSk7Cj4gIAkJbGVu Z3RoID0gLUVJTlZBTDsKPiBAQCAtOTUxLDYgKzEwOTAsMTAgQEAgaGRtaV9pbmZvZnJhbWVfcGFj ayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsCj4gIAkJbGVuZ3RoID0gaGRtaV9tcGVnX3Nv dXJjZV9pbmZvZnJhbWVfcGFjaygmZnJhbWUtPm1wZWdfc291cmNlLAo+ICAJCQkJCQkJIGJ1ZmZl ciwgc2l6ZSk7Cj4gIAkJYnJlYWs7Cj4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfTlRTQ19W Qkk6Cj4gKwkJbGVuZ3RoID0gaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfcGFjaygmZnJhbWUtPm50 c2NfdmJpLAo+ICsJCQkJCQkgICAgICBidWZmZXIsIHNpemUpOwo+ICsJCWJyZWFrOwo+ICAJZGVm YXVsdDoKPiAgCQlXQVJOKDEsICJCYWQgaW5mb2ZyYW1lIHR5cGUgJWRcbiIsIGZyYW1lLT5hbnku dHlwZSk7Cj4gIAkJbGVuZ3RoID0gLUVJTlZBTDsKPiBAQCAtOTc1LDYgKzExMTgsOCBAQCBzdGF0 aWMgY29uc3QgY2hhciAqaGRtaV9pbmZvZnJhbWVfdHlwZV9nZXRfbmFtZShlbnVtIGhkbWlfaW5m b2ZyYW1lX3R5cGUgdHlwZSkKPiAgCQlyZXR1cm4gIkF1ZGlvIjsKPiAgCWNhc2UgSERNSV9JTkZP RlJBTUVfVFlQRV9NUEVHX1NPVVJDRToKPiAgCQlyZXR1cm4gIk1QRUcgU291cmNlIjsKPiArCWNh c2UgSERNSV9JTkZPRlJBTUVfVFlQRV9OVFNDX1ZCSToKPiArCQlyZXR1cm4gIk5UU0MgVkJJIjsK PiAgCX0KPiAgCXJldHVybiAiUmVzZXJ2ZWQiOwo+ICB9Cj4gQEAgLTE1MjYsNiArMTY3MSwyMiBA QCBzdGF0aWMgdm9pZCBoZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV9sb2coY29uc3QgY2hhciAq bGV2ZWwsCj4gIAkJIGZyYW1lLT5maWVsZF9yZXBlYXQgPyAiWWVzIiA6ICJObyIpOwo+ICB9Cj4g IAo+ICsvKioKPiArICogaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfbG9nKCkgLSBsb2cgaW5mbyBv ZiBIRE1JIE5UU0MgVkJJIGluZm9mcmFtZQo+ICsgKiBAbGV2ZWw6IGxvZ2dpbmcgbGV2ZWwKPiAr ICogQGRldjogZGV2aWNlCj4gKyAqIEBmcmFtZTogSERNSSBOVFNDIFZCSSBpbmZvZnJhbWUKPiAr ICovCj4gK3N0YXRpYyB2b2lkIGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX2xvZyhjb25zdCBjaGFy ICpsZXZlbCwKPiArCQkJCQlzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQkJY29uc3Qgc3RydWN0 IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lICpmcmFtZSkKPiArewo+ICsJaGRtaV9pbmZvZnJhbWVf bG9nX2hlYWRlcihsZXZlbCwgZGV2LAo+ICsJCQkJICAoY29uc3Qgc3RydWN0IGhkbWlfYW55X2lu Zm9mcmFtZSAqKWZyYW1lKTsKPiArCj4gKwloZG1pX2xvZygiICAgICUqcGhcbiIsIGZyYW1lLT5s ZW5ndGgsIGZyYW1lLT5wZXNfZGF0YV9maWVsZCk7Cj4gK30KPiArCj4gIC8qKgo+ICAgKiBoZG1p X2luZm9mcmFtZV9sb2coKSAtIGxvZyBpbmZvIG9mIEhETUkgaW5mb2ZyYW1lCj4gICAqIEBsZXZl bDogbG9nZ2luZyBsZXZlbAo+IEBAIC0xNTUyLDYgKzE3MTMsOSBAQCB2b2lkIGhkbWlfaW5mb2Zy YW1lX2xvZyhjb25zdCBjaGFyICpsZXZlbCwKPiAgCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9N UEVHX1NPVVJDRToKPiAgCQloZG1pX21wZWdfc291cmNlX2luZm9mcmFtZV9sb2cobGV2ZWwsIGRl diwgJmZyYW1lLT5tcGVnX3NvdXJjZSk7Cj4gIAkJYnJlYWs7Cj4gKwljYXNlIEhETUlfSU5GT0ZS QU1FX1RZUEVfTlRTQ19WQkk6Cj4gKwkJaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfbG9nKGxldmVs LCBkZXYsICZmcmFtZS0+bnRzY192YmkpOwo+ICsJCWJyZWFrOwo+ICAJfQo+ICB9Cj4gIEVYUE9S VF9TWU1CT0woaGRtaV9pbmZvZnJhbWVfbG9nKTsKPiBAQCAtMTg0MCw2ICsyMDA0LDQ3IEBAIHN0 YXRpYyBpbnQgaGRtaV9tcGVnX3NvdXJjZV9pbmZvZnJhbWVfdW5wYWNrKHN0cnVjdCBoZG1pX21w ZWdfc291cmNlX2luZm9mcmFtZSAqCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiArLyoqCj4gKyAq IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX3VucGFjaygpIC0gdW5wYWNrIGJpbmFyeSBidWZmZXIg dG8gYSBIRE1JIE1QRUcgU291cmNlIGluZm9mcmFtZQo+ICsgKiBAZnJhbWU6IEhETUkgTVBFRyBT b3VyY2UgaW5mb2ZyYW1lCj4gKyAqIEBidWZmZXI6IHNvdXJjZSBidWZmZXIKPiArICogQHNpemU6 IHNpemUgb2YgYnVmZmVyCj4gKyAqCj4gKyAqIFVucGFja3MgdGhlIGluZm9ybWF0aW9uIGNvbnRh aW5lZCBpbiBiaW5hcnkgQGJ1ZmZlciBpbnRvIGEgc3RydWN0dXJlZAo+ICsgKiBAZnJhbWUgb2Yg dGhlIEhETUkgTVBFRyBTb3VyY2UgaW5mb3JtYXRpb24gZnJhbWUuCj4gKyAqIEFsc28gdmVyaWZp ZXMgdGhlIGNoZWNrc3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rpb24gNS4zLjUgb2YgdGhlIEhETUkg MS40Cj4gKyAqIHNwZWNpZmljYXRpb24uCj4gKyAqCj4gKyAqIFJldHVybnMgMCBvbiBzdWNjZXNz IG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ICsgKi8KPiArc3RhdGljIGlu dCBoZG1pX250c2NfdmJpX2luZm9mcmFtZV91bnBhY2soc3RydWN0IGhkbWlfbnRzY192YmlfaW5m b2ZyYW1lICpmcmFtZSwKPiArCQkJCQkgIGNvbnN0IHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUp Cj4gK3sKPiArCWNvbnN0IHU4ICpwdHIgPSBidWZmZXI7Cj4gKwlzaXplX3QgbGVuZ3RoOwo+ICsK PiArCWlmIChzaXplIDwgSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUpCj4gKwkJcmV0dXJuIC1F SU5WQUw7Cj4gKwo+ICsJaWYgKHB0clswXSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX05UU0NfVkJJ IHx8Cj4gKwkgICAgcHRyWzFdICE9IDEgfHwKPiArCSAgICBwdHJbMl0gPCAxIHx8IHB0clsyXSA+ IDI3KQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCWxlbmd0aCA9IHB0clsyXTsKPiArCj4g KwlpZiAoc2l6ZSA8IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgbGVuZ3RoKQo+ICsJCXJl dHVybiAtRUlOVkFMOwo+ICsKPiArCWlmIChoZG1pX2luZm9mcmFtZV9jaGVja3N1bShidWZmZXIs Cj4gKwkJCQkgICAgSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBsZW5ndGgpICE9IDApCj4g KwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJcHRyICs9IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9T SVpFOwo+ICsKPiArCXJldHVybiBoZG1pX250c2NfdmJpX2luZm9mcmFtZV9pbml0KGZyYW1lLCBw dHIsIGxlbmd0aCk7Cj4gK30KPiArCj4gIC8qKgo+ICAgKiBoZG1pX2luZm9mcmFtZV91bnBhY2so KSAtIHVucGFjayBiaW5hcnkgYnVmZmVyIHRvIGEgSERNSSBpbmZvZnJhbWUKPiAgICogQGZyYW1l OiBIRE1JIGluZm9mcmFtZQo+IEBAIC0xODc4LDYgKzIwODMsOSBAQCBpbnQgaGRtaV9pbmZvZnJh bWVfdW5wYWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwKPiAgCWNhc2UgSERNSV9JTkZP RlJBTUVfVFlQRV9NUEVHX1NPVVJDRToKPiAgCQlyZXQgPSBoZG1pX21wZWdfc291cmNlX2luZm9m cmFtZV91bnBhY2soJmZyYW1lLT5tcGVnX3NvdXJjZSwgYnVmZmVyLCBzaXplKTsKPiAgCQlicmVh azsKPiArCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9OVFNDX1ZCSToKPiArCQlyZXQgPSBoZG1p X250c2NfdmJpX2luZm9mcmFtZV91bnBhY2soJmZyYW1lLT5udHNjX3ZiaSwgYnVmZmVyLCBzaXpl KTsKPiArCQlicmVhazsKPiAgCWRlZmF1bHQ6Cj4gIAkJcmV0ID0gLUVJTlZBTDsKPiAgCQlicmVh azsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9oZG1pLmggYi9pbmNsdWRlL2xpbnV4L2hk bWkuaAo+IGluZGV4IDJjOTMyMmY3NTM4ZC4uMzgyMTUxNmIzMzZjIDEwMDY0NAo+IC0tLSBhL2lu Y2x1ZGUvbGludXgvaGRtaS5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9oZG1pLmgKPiBAQCAtNDgs NiArNDgsNyBAQCBlbnVtIGhkbWlfaW5mb2ZyYW1lX3R5cGUgewo+ICAJSERNSV9JTkZPRlJBTUVf VFlQRV9TUEQgPSAweDgzLAo+ICAJSERNSV9JTkZPRlJBTUVfVFlQRV9BVURJTyA9IDB4ODQsCj4g IAlIRE1JX0lORk9GUkFNRV9UWVBFX01QRUdfU09VUkNFID0gMHg4NSwKPiArCUhETUlfSU5GT0ZS QU1FX1RZUEVfTlRTQ19WQkkgPSAweDg2LAo+ICB9Owo+ICAKPiAgI2RlZmluZSBIRE1JX0lFRUVf T1VJIDB4MDAwYzAzCj4gQEAgLTM2Miw2ICszNjMsMjEgQEAgc3NpemVfdCBoZG1pX21wZWdfc291 cmNlX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfbXBlZ19zb3VyY2VfaW5m b2YKPiAgCQkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ICBpbnQgaGRtaV9t cGVnX3NvdXJjZV9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfbXBlZ19zb3VyY2VfaW5mb2Zy YW1lICpmcmFtZSk7Cj4gIAo+ICtzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgewo+ICsJ ZW51bSBoZG1pX2luZm9mcmFtZV90eXBlIHR5cGU7Cj4gKwl1bnNpZ25lZCBjaGFyIHZlcnNpb247 Cj4gKwl1bnNpZ25lZCBjaGFyIGxlbmd0aDsKPiArCXVuc2lnbmVkIGNoYXIgcGVzX2RhdGFfZmll bGRbMjddOwo+ICt9Owo+ICsKPiAraW50IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lX2luaXQoc3Ry dWN0IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lICpmcmFtZSwKPiArCQkJCSBjb25zdCB2b2lkICpw ZXNfZGF0YV9maWVsZCwgc2l6ZV90IGxlbmd0aCk7Cj4gK3NzaXplX3QgaGRtaV9udHNjX3ZiaV9p bmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9udHNjX3ZiaV9pbmZvZnJhbWUgKmZyYW1lLAo+ICsJ CQkJICAgICB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsKPiArc3NpemVfdCBoZG1pX250c2Nf dmJpX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfbnRzY192YmlfaW5mb2Zy YW1lICpmcmFtZSwKPiArCQkJCQkgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ICtpbnQg aGRtaV9udHNjX3ZiaV9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfbnRzY192YmlfaW5mb2Zy YW1lICpmcmFtZSk7Cj4gKwo+ICAvKioKPiAgICogdW5pb24gaGRtaV9pbmZvZnJhbWUgLSBvdmVy YWxsIHVuaW9uIG9mIGFsbCBhYnN0cmFjdCBpbmZvZnJhbWUgcmVwcmVzZW50YXRpb25zCj4gICAq IEBhbnk6IGdlbmVyaWMgaW5mb2ZyYW1lCj4gQEAgLTM3MCw2ICszODYsNyBAQCBpbnQgaGRtaV9t cGVnX3NvdXJjZV9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfbXBlZ19zb3VyY2VfaW5mb2Zy YW1lICpmcmFtZSk7Cj4gICAqIEB2ZW5kb3I6IHVuaW9uIG9mIGFsbCB2ZW5kb3IgaW5mb2ZyYW1l cwo+ICAgKiBAYXVkaW86IGF1ZGlvIGluZm9mcmFtZQo+ICAgKiBAbXBlZ19zb3VyY2U6IG1wZWcg c291cmNlIGluZm9mcmFtZQo+ICsgKiBAbnRzY192Ymk6IG50c2MgdmJpIGluZm9mcmFtZQo+ICAg Kgo+ICAgKiBUaGlzIGlzIHVzZWQgYnkgdGhlIGdlbmVyaWMgcGFjayBmdW5jdGlvbi4gVGhpcyB3 b3JrcyBzaW5jZSBhbGwgaW5mb2ZyYW1lcwo+ICAgKiBoYXZlIHRoZSBzYW1lIGhlYWRlciB3aGlj aCBhbHNvIGluZGljYXRlcyB3aGljaCB0eXBlIG9mIGluZm9mcmFtZSBzaG91bGQgYmUKPiBAQCAt MzgyLDYgKzM5OSw3IEBAIHVuaW9uIGhkbWlfaW5mb2ZyYW1lIHsKPiAgCXVuaW9uIGhkbWlfdmVu ZG9yX2FueV9pbmZvZnJhbWUgdmVuZG9yOwo+ICAJc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1l IGF1ZGlvOwo+ICAJc3RydWN0IGhkbWlfbXBlZ19zb3VyY2VfaW5mb2ZyYW1lIG1wZWdfc291cmNl Owo+ICsJc3RydWN0IGhkbWlfbnRzY192YmlfaW5mb2ZyYW1lIG50c2NfdmJpOwo+ICB9Owo+ICAK PiAgc3NpemVfdCBoZG1pX2luZm9mcmFtZV9wYWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFt ZSwgdm9pZCAqYnVmZmVyLAo+IAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v aW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from aer-iport-2.cisco.com ([173.38.203.52]:3007 "EHLO aer-iport-2.cisco.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726479AbeIUOSF (ORCPT ); Fri, 21 Sep 2018 10:18:05 -0400 Subject: Re: [PATCH 07/18] video/hdmi: Handle the NTSC VBI infoframe To: Ville Syrjala , dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-8-ville.syrjala@linux.intel.com> From: Hans Verkuil Message-ID: <4e790da9-a49c-e4b2-d528-4c6c8bca722e@cisco.com> Date: Fri, 21 Sep 2018 10:30:16 +0200 MIME-Version: 1.0 In-Reply-To: <20180920185145.1912-8-ville.syrjala@linux.intel.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org List-ID: 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. 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, >