From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga01.intel.com ([192.55.52.88]:3291 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753801AbdKMREj (ORCPT ); Mon, 13 Nov 2017 12:04:39 -0500 From: Ville Syrjala To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Shashank Sharma , Andrzej Hajda , Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org Subject: [PATCH 01/10] video/hdmi: Allow "empty" HDMI infoframes Date: Mon, 13 Nov 2017 19:04:18 +0200 Message-Id: <20171113170427.4150-2-ville.syrjala@linux.intel.com> In-Reply-To: <20171113170427.4150-1-ville.syrjala@linux.intel.com> References: <20171113170427.4150-1-ville.syrjala@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org List-ID: From: Ville Syrjälä HDMI 2.0 Appendix F suggest that we should keep sending the infoframe when switching from 3D to 2D mode, even if the infoframe isn't strictly necessary (ie. not needed to transmit the VIC or stereo information). This is a workaround against some sinks that fail to realize that they should switch from 3D to 2D mode when the source stop transmitting the infoframe. v2: Handle unpack() as well Pull the length calculation into a helper Cc: Shashank Sharma Cc: Andrzej Hajda Cc: Thierry Reding Cc: Hans Verkuil Cc: linux-media@vger.kernel.org Reviewed-by: Andrzej Hajda #v1 Signed-off-by: Ville Syrjälä --- drivers/video/hdmi.c | 51 +++++++++++++++++++++++++++++++-------------------- 1 file changed, 31 insertions(+), 20 deletions(-) diff --git a/drivers/video/hdmi.c b/drivers/video/hdmi.c index 1cf907ecded4..111a0ab6280a 100644 --- a/drivers/video/hdmi.c +++ b/drivers/video/hdmi.c @@ -321,6 +321,17 @@ int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame) } EXPORT_SYMBOL(hdmi_vendor_infoframe_init); +static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *frame) +{ + /* for side by side (half) we also need to provide 3D_Ext_Data */ + if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) + return 6; + else if (frame->vic != 0 || frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) + return 5; + else + return 4; +} + /** * hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary buffer * @frame: HDMI infoframe @@ -341,19 +352,11 @@ ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, u8 *ptr = buffer; size_t length; - /* empty info frame */ - if (frame->vic == 0 && frame->s3d_struct == HDMI_3D_STRUCTURE_INVALID) - return -EINVAL; - /* only one of those can be supplied */ if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) return -EINVAL; - /* for side by side (half) we also need to provide 3D_Ext_Data */ - if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) - frame->length = 6; - else - frame->length = 5; + frame->length = hdmi_vendor_infoframe_length(frame); length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; @@ -372,14 +375,16 @@ ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, ptr[5] = 0x0c; ptr[6] = 0x00; - if (frame->vic) { - ptr[7] = 0x1 << 5; /* video format */ - ptr[8] = frame->vic; - } else { + if (frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) { ptr[7] = 0x2 << 5; /* video format */ ptr[8] = (frame->s3d_struct & 0xf) << 4; if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) ptr[9] = (frame->s3d_ext_data & 0xf) << 4; + } else if (frame->vic) { + ptr[7] = 0x1 << 5; /* video format */ + ptr[8] = frame->vic; + } else { + ptr[7] = 0x0 << 5; /* video format */ } hdmi_infoframe_set_checksum(buffer, length); @@ -1165,7 +1170,7 @@ hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, if (ptr[0] != HDMI_INFOFRAME_TYPE_VENDOR || ptr[1] != 1 || - (ptr[2] != 5 && ptr[2] != 6)) + (ptr[2] != 4 && ptr[2] != 5 && ptr[2] != 6)) return -EINVAL; length = ptr[2]; @@ -1193,16 +1198,22 @@ hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, hvf->length = length; - if (hdmi_video_format == 0x1) { - hvf->vic = ptr[4]; - } else if (hdmi_video_format == 0x2) { + if (hdmi_video_format == 0x2) { + if (length != 5 && length != 6) + return -EINVAL; hvf->s3d_struct = ptr[4] >> 4; if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) { - if (length == 6) - hvf->s3d_ext_data = ptr[5] >> 4; - else + if (length != 6) return -EINVAL; + hvf->s3d_ext_data = ptr[5] >> 4; } + } else if (hdmi_video_format == 0x1) { + if (length != 5) + return -EINVAL; + hvf->vic = ptr[4]; + } else { + if (length != 4) + return -EINVAL; } return 0; -- 2.13.6 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville Syrjala Subject: [PATCH 01/10] video/hdmi: Allow "empty" HDMI infoframes Date: Mon, 13 Nov 2017 19:04:18 +0200 Message-ID: <20171113170427.4150-2-ville.syrjala@linux.intel.com> References: <20171113170427.4150-1-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: <20171113170427.4150-1-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org RnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KCkhE TUkgMi4wIEFwcGVuZGl4IEYgc3VnZ2VzdCB0aGF0IHdlIHNob3VsZCBrZWVwIHNlbmRpbmcgdGhl IGluZm9mcmFtZQp3aGVuIHN3aXRjaGluZyBmcm9tIDNEIHRvIDJEIG1vZGUsIGV2ZW4gaWYgdGhl IGluZm9mcmFtZSBpc24ndCBzdHJpY3RseQpuZWNlc3NhcnkgKGllLiBub3QgbmVlZGVkIHRvIHRy YW5zbWl0IHRoZSBWSUMgb3Igc3RlcmVvIGluZm9ybWF0aW9uKS4KVGhpcyBpcyBhIHdvcmthcm91 bmQgYWdhaW5zdCBzb21lIHNpbmtzIHRoYXQgZmFpbCB0byByZWFsaXplIHRoYXQgdGhleQpzaG91 bGQgc3dpdGNoIGZyb20gM0QgdG8gMkQgbW9kZSB3aGVuIHRoZSBzb3VyY2Ugc3RvcCB0cmFuc21p dHRpbmcKdGhlIGluZm9mcmFtZS4KCnYyOiBIYW5kbGUgdW5wYWNrKCkgYXMgd2VsbAogICAgUHVs bCB0aGUgbGVuZ3RoIGNhbGN1bGF0aW9uIGludG8gYSBoZWxwZXIKCkNjOiBTaGFzaGFuayBTaGFy bWEgPHNoYXNoYW5rLnNoYXJtYUBpbnRlbC5jb20+CkNjOiBBbmRyemVqIEhhamRhIDxhLmhhamRh QHNhbXN1bmcuY29tPgpDYzogVGhpZXJyeSBSZWRpbmcgPHRoaWVycnkucmVkaW5nQGdtYWlsLmNv bT4KQ2M6IEhhbnMgVmVya3VpbCA8aGFucy52ZXJrdWlsQGNpc2NvLmNvbT4KQ2M6IGxpbnV4LW1l ZGlhQHZnZXIua2VybmVsLm9yZwpSZXZpZXdlZC1ieTogQW5kcnplaiBIYWpkYSA8YS5oYWpkYUBz YW1zdW5nLmNvbT4gI3YxClNpZ25lZC1vZmYtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3ly amFsYUBsaW51eC5pbnRlbC5jb20+Ci0tLQogZHJpdmVycy92aWRlby9oZG1pLmMgfCA1MSArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBj aGFuZ2VkLCAzMSBpbnNlcnRpb25zKCspLCAyMCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9k cml2ZXJzL3ZpZGVvL2hkbWkuYyBiL2RyaXZlcnMvdmlkZW8vaGRtaS5jCmluZGV4IDFjZjkwN2Vj ZGVkNC4uMTExYTBhYjYyODBhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2hkbWkuYworKysg Yi9kcml2ZXJzL3ZpZGVvL2hkbWkuYwpAQCAtMzIxLDYgKzMyMSwxNyBAQCBpbnQgaGRtaV92ZW5k b3JfaW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUpCiB9 CiBFWFBPUlRfU1lNQk9MKGhkbWlfdmVuZG9yX2luZm9mcmFtZV9pbml0KTsKIAorc3RhdGljIGlu dCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGNvbnN0IHN0cnVjdCBoZG1pX3ZlbmRvcl9p bmZvZnJhbWUgKmZyYW1lKQoreworCS8qIGZvciBzaWRlIGJ5IHNpZGUgKGhhbGYpIHdlIGFsc28g bmVlZCB0byBwcm92aWRlIDNEX0V4dF9EYXRhICovCisJaWYgKGZyYW1lLT5zM2Rfc3RydWN0ID49 IEhETUlfM0RfU1RSVUNUVVJFX1NJREVfQllfU0lERV9IQUxGKQorCQlyZXR1cm4gNjsKKwllbHNl IGlmIChmcmFtZS0+dmljICE9IDAgfHwgZnJhbWUtPnMzZF9zdHJ1Y3QgIT0gSERNSV8zRF9TVFJV Q1RVUkVfSU5WQUxJRCkKKwkJcmV0dXJuIDU7CisJZWxzZQorCQlyZXR1cm4gNDsKK30KKwogLyoq CiAgKiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFjaygpIC0gd3JpdGUgYSBIRE1JIHZlbmRvciBp bmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgogICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQpAQCAt MzQxLDE5ICszNTIsMTEgQEAgc3NpemVfdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFjayhzdHJ1 Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtZSwKIAl1OCAqcHRyID0gYnVmZmVyOwogCXNp emVfdCBsZW5ndGg7CiAKLQkvKiBlbXB0eSBpbmZvIGZyYW1lICovCi0JaWYgKGZyYW1lLT52aWMg PT0gMCAmJiBmcmFtZS0+czNkX3N0cnVjdCA9PSBIRE1JXzNEX1NUUlVDVFVSRV9JTlZBTElEKQot CQlyZXR1cm4gLUVJTlZBTDsKLQogCS8qIG9ubHkgb25lIG9mIHRob3NlIGNhbiBiZSBzdXBwbGll ZCAqLwogCWlmIChmcmFtZS0+dmljICE9IDAgJiYgZnJhbWUtPnMzZF9zdHJ1Y3QgIT0gSERNSV8z RF9TVFJVQ1RVUkVfSU5WQUxJRCkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQkvKiBmb3Igc2lkZSBi eSBzaWRlIChoYWxmKSB3ZSBhbHNvIG5lZWQgdG8gcHJvdmlkZSAzRF9FeHRfRGF0YSAqLwotCWlm IChmcmFtZS0+czNkX3N0cnVjdCA+PSBIRE1JXzNEX1NUUlVDVFVSRV9TSURFX0JZX1NJREVfSEFM RikKLQkJZnJhbWUtPmxlbmd0aCA9IDY7Ci0JZWxzZQotCQlmcmFtZS0+bGVuZ3RoID0gNTsKKwlm cmFtZS0+bGVuZ3RoID0gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2xlbmd0aChmcmFtZSk7CiAKIAls ZW5ndGggPSBIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRSArIGZyYW1lLT5sZW5ndGg7CiAKQEAg LTM3MiwxNCArMzc1LDE2IEBAIHNzaXplX3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soc3Ry dWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUsCiAJcHRyWzVdID0gMHgwYzsKIAlwdHJb Nl0gPSAweDAwOwogCi0JaWYgKGZyYW1lLT52aWMpIHsKLQkJcHRyWzddID0gMHgxIDw8IDU7CS8q IHZpZGVvIGZvcm1hdCAqLwotCQlwdHJbOF0gPSBmcmFtZS0+dmljOwotCX0gZWxzZSB7CisJaWYg KGZyYW1lLT5zM2Rfc3RydWN0ICE9IEhETUlfM0RfU1RSVUNUVVJFX0lOVkFMSUQpIHsKIAkJcHRy WzddID0gMHgyIDw8IDU7CS8qIHZpZGVvIGZvcm1hdCAqLwogCQlwdHJbOF0gPSAoZnJhbWUtPnMz ZF9zdHJ1Y3QgJiAweGYpIDw8IDQ7CiAJCWlmIChmcmFtZS0+czNkX3N0cnVjdCA+PSBIRE1JXzNE X1NUUlVDVFVSRV9TSURFX0JZX1NJREVfSEFMRikKIAkJCXB0cls5XSA9IChmcmFtZS0+czNkX2V4 dF9kYXRhICYgMHhmKSA8PCA0OworCX0gZWxzZSBpZiAoZnJhbWUtPnZpYykgeworCQlwdHJbN10g PSAweDEgPDwgNTsJLyogdmlkZW8gZm9ybWF0ICovCisJCXB0cls4XSA9IGZyYW1lLT52aWM7CisJ fSBlbHNlIHsKKwkJcHRyWzddID0gMHgwIDw8IDU7CS8qIHZpZGVvIGZvcm1hdCAqLwogCX0KIAog CWhkbWlfaW5mb2ZyYW1lX3NldF9jaGVja3N1bShidWZmZXIsIGxlbmd0aCk7CkBAIC0xMTY1LDcg KzExNzAsNyBAQCBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3VucGFjayh1bmlvbiBoZG1pX3Zl bmRvcl9hbnlfaW5mb2ZyYW1lICpmcmFtZSwKIAogCWlmIChwdHJbMF0gIT0gSERNSV9JTkZPRlJB TUVfVFlQRV9WRU5ET1IgfHwKIAkgICAgcHRyWzFdICE9IDEgfHwKLQkgICAgKHB0clsyXSAhPSA1 ICYmIHB0clsyXSAhPSA2KSkKKwkgICAgKHB0clsyXSAhPSA0ICYmIHB0clsyXSAhPSA1ICYmIHB0 clsyXSAhPSA2KSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKIAlsZW5ndGggPSBwdHJbMl07CkBAIC0x MTkzLDE2ICsxMTk4LDIyIEBAIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfdW5wYWNrKHVuaW9u IGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAogCiAJaHZmLT5sZW5ndGggPSBsZW5n dGg7CiAKLQlpZiAoaGRtaV92aWRlb19mb3JtYXQgPT0gMHgxKSB7Ci0JCWh2Zi0+dmljID0gcHRy WzRdOwotCX0gZWxzZSBpZiAoaGRtaV92aWRlb19mb3JtYXQgPT0gMHgyKSB7CisJaWYgKGhkbWlf dmlkZW9fZm9ybWF0ID09IDB4MikgeworCQlpZiAobGVuZ3RoICE9IDUgJiYgbGVuZ3RoICE9IDYp CisJCQlyZXR1cm4gLUVJTlZBTDsKIAkJaHZmLT5zM2Rfc3RydWN0ID0gcHRyWzRdID4+IDQ7CiAJ CWlmIChodmYtPnMzZF9zdHJ1Y3QgPj0gSERNSV8zRF9TVFJVQ1RVUkVfU0lERV9CWV9TSURFX0hB TEYpIHsKLQkJCWlmIChsZW5ndGggPT0gNikKLQkJCQlodmYtPnMzZF9leHRfZGF0YSA9IHB0cls1 XSA+PiA0OwotCQkJZWxzZQorCQkJaWYgKGxlbmd0aCAhPSA2KQogCQkJCXJldHVybiAtRUlOVkFM OworCQkJaHZmLT5zM2RfZXh0X2RhdGEgPSBwdHJbNV0gPj4gNDsKIAkJfQorCX0gZWxzZSBpZiAo aGRtaV92aWRlb19mb3JtYXQgPT0gMHgxKSB7CisJCWlmIChsZW5ndGggIT0gNSkKKwkJCXJldHVy biAtRUlOVkFMOworCQlodmYtPnZpYyA9IHB0cls0XTsKKwl9IGVsc2UgeworCQlpZiAobGVuZ3Ro ICE9IDQpCisJCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKIAlyZXR1cm4gMDsKLS0gCjIuMTMuNgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVs IG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==