dissector for HDMI (High-Definition Multimedia Interface)

messages on the Data Display Channel (DDC)

this dissector is available as an option for I2C messages

it handles EDID messages (Extended Display Identification Data)
and passes HDCP messages on to the HDCP dissector

Change-Id: Ia8d8e73c36e2a1ad560b911dd4c1c9f34997b5c2
Reviewed-on: https://code.wireshark.org/review/63
Reviewed-by: Martin Kaiser <wireshark@kaiser.cx>
Tested-by: Martin Kaiser <wireshark@kaiser.cx>

7 files changed, 326 insertions, 56 deletions

diff --git a/docbook/release-notes.asciidoc b/docbook/release-notes.asciidoc
index 72aa2dc6c8..0ce5dcfab7 100644
--- a/docbook/release-notes.asciidoc
+++ b/docbook/release-notes.asciidoc
@@ -96,6 +96,7 @@ Cisco MetaData
 ELF file format
 EXPORTED PDU
 FINGER
+HDMI
 HTTP2
 IDRP
 ILP
diff --git a/epan/CMakeLists.txt b/epan/CMakeLists.txt
index 2fd4b7dd7e..7c77914e6b 100644
--- a/epan/CMakeLists.txt
+++ b/epan/CMakeLists.txt
@@ -741,6 +741,7 @@ set(DISSECTOR_SRC
 	dissectors/packet-hdcp2.c
 	dissectors/packet-hdfs.c
 	dissectors/packet-hdfsdata.c
+	dissectors/packet-hdmi.c
 	dissectors/packet-hip.c
 	dissectors/packet-homeplug-av.c
 	dissectors/packet-homeplug.c
diff --git a/epan/dissectors/Makefile.common b/epan/dissectors/Makefile.common
index 4cca67d275..9d3b916b70 100644
--- a/epan/dissectors/Makefile.common
+++ b/epan/dissectors/Makefile.common
@@ -663,6 +663,7 @@ DISSECTOR_SRC = \
 	packet-hdcp2.c		\
 	packet-hdfs.c		\
 	packet-hdfsdata.c	\
+	packet-hdmi.c		\
 	packet-hip.c		\
 	packet-homeplug-av.c	\
 	packet-homeplug.c	\
@@ -1431,7 +1432,7 @@ DISSECTOR_INCLUDES =	\
 	packet-h264.h	\
 	packet-h323.h	\
 	packet-h450-ros.h	\
-	packet-hdcp.h	\
+	packet-hdmi.h	\
 	packet-hpext.h	\
 	packet-http.h	\
 	packet-i2c.h	\
diff --git a/epan/dissectors/packet-hdcp.c b/epan/dissectors/packet-hdcp.c
index 8ce0a2bd5d..cbf84a3a65 100644
--- a/epan/dissectors/packet-hdcp.c
+++ b/epan/dissectors/packet-hdcp.c
@@ -1,6 +1,6 @@
 /* packet-hdcp.c
  * Routines for HDCP dissection
- * Copyright 2011-2012, Martin Kaiser <martin@kaiser.cx>
+ * Copyright 2011-2014, Martin Kaiser <martin@kaiser.cx>
  *
  * $Id$
  *
@@ -38,7 +38,6 @@
 #include <epan/ptvcursor.h>
 #include <epan/expert.h>
 #include <epan/wmem/wmem.h>
-#include "packet-hdcp.h"
 
 void proto_register_hdcp(void);
 
@@ -48,7 +47,6 @@ static wmem_tree_t *transactions = NULL;
 
 static gint ett_hdcp = -1;
 
-static int hf_hdcp_addr = -1;
 static int hf_hdcp_reg = -1;
 static int hf_hdcp_resp_in = -1;
 static int hf_hdcp_resp_to = -1;
@@ -68,16 +66,6 @@ static int hf_hdcp_max_devs_exc = -1;
 static int hf_hdcp_downstream = -1;
 static int hf_hdcp_link_vfy = -1;
 
-/* the addresses used by this dissector are 8bit, including the direction bit
-   (to be in line with the HDCP specification) */
-#define ADDR8_HDCP_WRITE 0x74  /* transmitter->receiver */
-#define ADDR8_HDCP_READ  0x75  /* receiver->transmitter */
-
-#define HDCP_ADDR8(x)   (x==ADDR8_HDCP_WRITE || x==ADDR8_HDCP_READ)
-
-#define ADDR8_RCV "Receiver"
-#define ADDR8_TRX "Transmitter"
-
 #define REG_BKSV    0x0
 #define REG_AKSV    0x10
 #define REG_AN      0x18
@@ -90,12 +78,6 @@ typedef struct _hdcp_transaction_t {
     guint8 rqst_type;
 } hdcp_transaction_t;
 
-static const value_string hdcp_addr[] = {
-    { ADDR8_HDCP_WRITE, "transmitter writes data for receiver" },
-    { ADDR8_HDCP_READ, "transmitter reads data from receiver" },
-    { 0, NULL }
-};
-
 static const value_string hdcp_reg[] = {
     { REG_BKSV, "B_ksv" },
     { REG_AKSV, "A_ksv" },
@@ -105,22 +87,14 @@ static const value_string hdcp_reg[] = {
     { 0, NULL }
 };
 
-gboolean
-sub_check_hdcp(packet_info *pinfo _U_)
-{
-    /* by looking at the i2c_phdr only, we can't decide if this packet is HDCPv1
-       this function is called when the user explicitly selected HDCPv1
-       in the preferences
-       therefore, we always return TRUE and hand the data to the (new
-       style) dissector who will check if the packet is HDCPv1 */
-
-   return TRUE;
-}
 
+/* the input tvb contains an HDCP message without the leading address byte
+   (the address byte is handled by the HDMI dissector)
+   the caller must set the direction in pinfo */
 static int
 dissect_hdcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
 {
-    guint8 addr, reg;
+    guint8 reg;
     proto_item *pi;
     ptvcursor_t *cursor;
     proto_tree *hdcp_tree;
@@ -128,9 +102,7 @@ dissect_hdcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
     proto_item *it;
     guint64 a_ksv, b_ksv;
 
-    addr = tvb_get_guint8(tvb, 0);
-    if (!HDCP_ADDR8(addr))
-        return 0;
+    /* XXX check if the packet is really HDCP? */
 
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "HDCP");
     col_clear(pinfo->cinfo, COL_INFO);
@@ -140,15 +112,12 @@ dissect_hdcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
     hdcp_tree = proto_item_add_subtree(pi, ett_hdcp);
 
     cursor = ptvcursor_new(hdcp_tree, tvb, 0);
-    /* all values in HDCP are little endian */
-    ptvcursor_add(cursor, hf_hdcp_addr, 1, ENC_LITTLE_ENDIAN);
 
-    if (addr==ADDR8_HDCP_WRITE) {
+    if (pinfo->p2p_dir==P2P_DIR_SENT) {
         /* transmitter sends data to the receiver */
-        SET_ADDRESS(&pinfo->src, AT_STRINGZ, (int)strlen(ADDR8_TRX)+1, ADDR8_TRX);
-        SET_ADDRESS(&pinfo->dst, AT_STRINGZ, (int)strlen(ADDR8_RCV)+1, ADDR8_RCV);
 
         reg = tvb_get_guint8(tvb, ptvcursor_current_offset(cursor));
+        /* all values in HDCP are little endian */
         ptvcursor_add(cursor, hf_hdcp_reg, 1, ENC_LITTLE_ENDIAN);
 
         if (tvb_reported_length_remaining(tvb,
@@ -209,8 +178,6 @@ dissect_hdcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
     }
     else {
         /* transmitter reads from receiver */
-        SET_ADDRESS(&pinfo->src, AT_STRINGZ, (int)strlen(ADDR8_RCV)+1, ADDR8_RCV);
-        SET_ADDRESS(&pinfo->dst, AT_STRINGZ, (int)strlen(ADDR8_TRX)+1, ADDR8_TRX);
 
        if (transactions) {
            hdcp_trans = (hdcp_transaction_t *)wmem_tree_lookup32_le(
@@ -296,9 +263,6 @@ void
 proto_register_hdcp(void)
 {
     static hf_register_info hf[] = {
-        { &hf_hdcp_addr,
-            { "8bit I2C address", "hdcp.addr", FT_UINT8, BASE_HEX,
-                VALS(hdcp_addr), 0, NULL, HFILL } },
         { &hf_hdcp_reg,
             { "Register offset", "hdcp.reg", FT_UINT8, BASE_HEX,
                 VALS(hdcp_reg), 0, NULL, HFILL } },
diff --git a/epan/dissectors/packet-hdmi.c b/epan/dissectors/packet-hdmi.c
new file mode 100644
index 0000000000..f3034773a3
--- /dev/null
+++ b/epan/dissectors/packet-hdmi.c
@@ -0,0 +1,303 @@
+/* packet-hdmi.c
+ * Routines for HDMI dissection
+ * Copyright 2014 Martin Kaiser <martin@kaiser.cx>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* this dissector handles I2C messages on the HDMI Display Data Channel (DDC)
+ *
+ * EDID (Extended Display Identification Data) messages are dissected here,
+ * HDCP messages are passed on to the HDCP dissector
+ */
+
+#include "config.h"
+
+#include <glib.h>
+#include <epan/packet.h>
+#include <epan/ptvcursor.h>
+#include <epan/expert.h>
+#include <epan/wmem/wmem.h>
+#include "packet-hdmi.h"
+
+void proto_register_hdmi(void);
+
+static int proto_hdmi  = -1;
+
+static dissector_handle_t hdcp_handle;
+
+static gint ett_hdmi = -1;
+static gint ett_hdmi_edid = -1;
+
+static int hf_hdmi_addr = -1;
+static int hf_hdmi_edid_offset = -1;
+static int hf_hdmi_edid_hdr = -1;
+static int hf_hdmi_edid_manf_id = -1;
+static int hf_hdmi_edid_manf_prod_code = -1;
+static int hf_hdmi_edid_manf_serial = -1;
+static int hf_hdmi_edid_manf_week = -1;
+static int hf_hdmi_edid_mod_year = -1;
+static int hf_hdmi_edid_manf_year = -1;
+
+
+/* also called Source and Sink in the HDMI spec */
+#define ADDR_TRX "Transmitter"
+#define ADDR_RCV "Receiver"
+
+/* we use 8bit I2C addresses, including the direction bit */
+#define ADDR8_HDCP_WRITE 0x74  /* transmitter->receiver */
+#define ADDR8_HDCP_READ  0x75  /* r->t */
+#define ADDR8_EDID_WRITE 0xA0  /* t->r */
+#define ADDR8_EDID_READ  0xA1  /* r->t */
+
+#define HDCP_ADDR8(x)   (x==ADDR8_HDCP_WRITE || x==ADDR8_HDCP_READ)
+
+static const value_string hdmi_addr[] = {
+    { ADDR8_HDCP_WRITE, "transmitter writes HDCP data for receiver" },
+    { ADDR8_HDCP_READ,  "transmitter reads HDCP data from receiver" },
+
+    { ADDR8_EDID_WRITE, "EDID request" },
+    { ADDR8_EDID_READ,  "EDID read" },
+    { 0, NULL }
+};
+
+#define EDID_HDR_VALUE G_GUINT64_CONSTANT(0x00ffffffffffff00)
+
+/* grab 5 bits, from bit n to n+4, from a big-endian number x
+   map those bits to a capital letter such that A==1, B==2, ... */
+#define CAPITAL_LETTER(x, n) ('A'-1 + (((x) & (0x1F<<n)) >> n))
+
+
+gboolean
+sub_check_hdmi(packet_info *pinfo _U_)
+{
+    /* by looking at the i2c_phdr only, we can't decide if this packet is HDMI
+       this function is called when the user explicitly selected HDMI
+       in the preferences
+       therefore, we always return TRUE and hand the data to the (new
+       style) dissector who sees the 8bit address and the packet content */
+
+   return TRUE;
+}
+
+
+/* dissect EDID data from the receiver
+   return the offset after the dissected data */
+static gint
+dissect_hdmi_edid(tvbuff_t *tvb, gint offset, packet_info *pinfo, proto_tree *tree)
+{
+    proto_item *ti, *yi;
+    proto_tree *edid_tree;
+    guint64     edid_hdr;
+    guint16     manf_id;
+    gchar       manf_id_str[4]; /* 3 letters + 0-termination */
+    guint8      week, year;
+    int         year_hf;
+    guint8      edid_ver, edid_rev;
+
+
+    ti = proto_tree_add_text(tree, tvb,
+            offset, tvb_reported_length_remaining(tvb, offset),
+            "Extended Display Identification Data (EDID)");
+    edid_tree = proto_item_add_subtree(ti, ett_hdmi_edid);
+
+    edid_hdr = tvb_get_ntoh64(tvb, offset);
+    if (edid_hdr != EDID_HDR_VALUE)
+        return offset; /* XXX handle fragmented EDID messages */
+
+    col_append_sep_str(pinfo->cinfo, COL_INFO, NULL, "EDID");
+
+    proto_tree_add_item(edid_tree, hf_hdmi_edid_hdr,
+            tvb, offset, 8, ENC_LITTLE_ENDIAN);
+    offset += 8;
+
+    /* read as big endian for easier splitting */
+    manf_id = tvb_get_ntohs(tvb, offset);
+    /* XXX check that MSB is 0 */
+    manf_id_str[0] = CAPITAL_LETTER(manf_id, 10);
+    manf_id_str[1] = CAPITAL_LETTER(manf_id,  5);
+    manf_id_str[2] = CAPITAL_LETTER(manf_id,  0);
+    manf_id_str[3] = 0;
+    proto_tree_add_string(edid_tree, hf_hdmi_edid_manf_id,
+            tvb, offset, 2, manf_id_str);
+    offset += 2;
+
+    proto_tree_add_item(edid_tree, hf_hdmi_edid_manf_prod_code,
+            tvb, offset, 2, ENC_LITTLE_ENDIAN);
+    offset += 2;
+
+    proto_tree_add_item(edid_tree, hf_hdmi_edid_manf_serial,
+            tvb, offset, 4, ENC_LITTLE_ENDIAN);
+    offset += 4;
+
+    week = tvb_get_guint8(tvb, offset);
+    proto_tree_add_item(edid_tree, hf_hdmi_edid_manf_week,
+            tvb, offset, 1, ENC_LITTLE_ENDIAN);
+    offset++;
+
+    year_hf = week==255 ? hf_hdmi_edid_mod_year : hf_hdmi_edid_manf_year;
+    year = tvb_get_guint8(tvb, offset);
+    yi = proto_tree_add_item(edid_tree, year_hf,
+            tvb, offset, 1, ENC_LITTLE_ENDIAN);
+    proto_item_append_text(yi, " (year %d)", 1990+year);
+    offset++;
+
+    edid_ver = tvb_get_guint8(tvb, offset);
+    edid_rev = tvb_get_guint8(tvb, offset+1);
+
+    /* XXX make this filterable */
+    proto_tree_add_text(edid_tree, tvb, offset, 2,
+            "EDID Version %d.%d", edid_ver, edid_rev);
+
+    /* XXX dissect the parts following the EDID header */
+
+    return tvb_reported_length(tvb);
+}
+
+ 
+static int
+dissect_hdmi(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+    guint8      addr;
+    gint        offset=0;
+    proto_item *pi;
+    proto_tree *hdmi_tree;
+
+    /* the I2C address in the first byte is always handled by the HDMI
+       dissector, even if the packet contains HDCP data */
+    addr = tvb_get_guint8(tvb, 0);
+    if (!try_val_to_str(addr, hdmi_addr))
+        return 0; /* no HDMI packet */
+
+    col_set_str(pinfo->cinfo, COL_PROTOCOL, "HDMI");
+    col_clear(pinfo->cinfo, COL_INFO);
+
+    pi = proto_tree_add_protocol_format(tree, proto_hdmi,
+            tvb, 0, tvb_reported_length(tvb), "HDMI");
+    hdmi_tree = proto_item_add_subtree(pi, ett_hdmi);
+
+    if (addr&0x01) {
+        SET_ADDRESS(&pinfo->src, AT_STRINGZ, (int)strlen(ADDR_RCV)+1, ADDR_RCV);
+        SET_ADDRESS(&pinfo->dst, AT_STRINGZ, (int)strlen(ADDR_TRX)+1, ADDR_TRX);
+        pinfo->p2p_dir = P2P_DIR_RECV;
+    }
+    else {
+        SET_ADDRESS(&pinfo->src, AT_STRINGZ, (int)strlen(ADDR_TRX)+1, ADDR_TRX);
+        SET_ADDRESS(&pinfo->dst, AT_STRINGZ, (int)strlen(ADDR_RCV)+1, ADDR_RCV);
+        pinfo->p2p_dir = P2P_DIR_SENT;
+    }
+
+    /* there's no explicit statement in the spec saying that the protocol is
+        big or little endian
+       there's three cases: one byte values, symmetrical values or values
+        that are explicitly marked as little endian
+       for the sake of simplicity, we use little endian everywhere */
+    proto_tree_add_item(hdmi_tree, hf_hdmi_addr, tvb, offset, 1, ENC_LITTLE_ENDIAN);
+    offset++;
+
+    if (HDCP_ADDR8(addr)) {
+        gint      hdcp_len;
+        tvbuff_t *hdcp_tvb;
+
+        hdcp_len = tvb_reported_length_remaining(tvb, offset);
+        hdcp_tvb = tvb_new_subset(tvb, offset, hdcp_len, hdcp_len);
+
+        return call_dissector(hdcp_handle, hdcp_tvb, pinfo, hdmi_tree);
+    }
+
+    if (addr==ADDR8_EDID_WRITE) {
+        col_append_sep_str(pinfo->cinfo, COL_INFO, NULL, "EDID request");
+        proto_tree_add_item(hdmi_tree, hf_hdmi_edid_offset,
+            tvb, offset, 1, ENC_LITTLE_ENDIAN);
+        offset++;
+        return offset;
+    }
+
+    return dissect_hdmi_edid(tvb, offset, pinfo, hdmi_tree);
+}
+
+
+void
+proto_register_hdmi(void)
+{
+    static hf_register_info hf[] = {
+        { &hf_hdmi_addr,
+            { "8bit I2C address", "hdmi.addr", FT_UINT8, BASE_HEX,
+                VALS(hdmi_addr), 0, NULL, HFILL } },
+        { &hf_hdmi_edid_offset,
+            { "Offset", "hdmi.edid.offset",
+                FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
+        { &hf_hdmi_edid_hdr,
+            { "EDID header", "hdmi.edid.hdr",
+                FT_UINT64, BASE_HEX, NULL, 0, NULL, HFILL } },
+        { &hf_hdmi_edid_manf_id,
+            { "Manufacturer ID", "hdmi.edid.manf_id",
+                FT_STRING, STR_ASCII, NULL, 0, NULL, HFILL } },
+        { &hf_hdmi_edid_manf_prod_code,
+            { "Manufacturer product code", "hdmi.edid.manf_prod_code",
+                FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
+        { &hf_hdmi_edid_manf_serial,
+            { "Serial number", "hdmi.edid.serial_num",
+                FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } },
+        { &hf_hdmi_edid_manf_week,
+            { "Week of manufacture", "hdmi.edid.manf_week",
+                FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
+        { &hf_hdmi_edid_mod_year,
+            { "Model year", "hdmi.edid.model_year",
+                FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
+        { &hf_hdmi_edid_manf_year,
+            { "Year of manufacture", "hdmi.edid.manf_year",
+                FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }
+    };
+
+    static gint *ett[] = {
+        &ett_hdmi,
+        &ett_hdmi_edid
+    };
+
+    proto_hdmi = proto_register_protocol(
+            "High-Definition Multimedia Interface", "HDMI", "hdmi");
+
+    proto_register_field_array(proto_hdmi, hf, array_length(hf));
+    proto_register_subtree_array(ett, array_length(ett));
+
+    new_register_dissector("hdmi", dissect_hdmi, proto_hdmi);
+}
+
+
+void
+proto_reg_handoff_hdmi(void)
+{
+    hdcp_handle = find_dissector("hdcp");
+}
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
diff --git a/epan/dissectors/packet-hdcp.h b/epan/dissectors/packet-hdmi.h
index 43050fc676..d7f7792e90 100644
--- a/epan/dissectors/packet-hdcp.h
+++ b/epan/dissectors/packet-hdmi.h
@@ -1,6 +1,6 @@
-/* packet-hdcp.h
- * Routines for HDCP dissection
- * Copyright 2011-2012, Martin Kaiser <martin@kaiser.cx>
+/* packet-hdmi.h
+ * Routines for HDMI dissection
+ * Copyright 2014 Martin Kaiser <martin@kaiser.cx>
  *
  * $Id$
  *
@@ -23,13 +23,13 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#ifndef __PACKET_HDCP_H__
-#define __PACKET_HDCP_H__
+#ifndef __PACKET_HDMI_H__
+#define __PACKET_HDMI_H__
 
 #include <glib.h>
 #include <epan/packet.h>
 
-gboolean sub_check_hdcp(packet_info *pinfo _U_);
+gboolean sub_check_hdmi(packet_info *pinfo _U_);
 
 #endif
 
diff --git a/epan/dissectors/packet-i2c.c b/epan/dissectors/packet-i2c.c
index 61cfa56171..dc158185ed 100644
--- a/epan/dissectors/packet-i2c.c
+++ b/epan/dissectors/packet-i2c.c
@@ -34,7 +34,7 @@
 #include <wiretap/wtap.h>
 
 #include "packet-i2c.h"
-#include "packet-hdcp.h"
+#include "packet-hdmi.h"
 
 void proto_register_i2c(void);
 void proto_reg_handoff_i2c(void);
@@ -51,7 +51,7 @@ static gint ett_i2c = -1;
 enum {
 	SUB_DATA = 0,
 	SUB_IPMB,
-	SUB_HDCP,
+	SUB_HDMI,
 
 	SUB_MAX
 };
@@ -183,7 +183,7 @@ sub_check_ipmb(packet_info *pinfo)
 static sub_checkfunc_t sub_check[SUB_MAX] = {
 	NULL, /* raw data */
 	sub_check_ipmb, /* IPMI */
-	sub_check_hdcp  /* HDCP */
+	sub_check_hdmi  /* HDMI */
 };
 
 static void
@@ -274,7 +274,7 @@ proto_register_i2c(void)
 	static const enum_val_t sub_enum_vals[] = {
 		{ "none", "None (raw I2C)", SUB_DATA },
 		{ "ipmb", "IPMB", SUB_IPMB },
-		{ "hdcp", "HDCP", SUB_HDCP },
+		{ "hdmi", "HDMI (including HDCP)", SUB_HDMI },
 		{ NULL, NULL, 0 }
 	};
 	module_t *m;
@@ -296,7 +296,7 @@ proto_reg_handoff_i2c(void)
 
 	sub_handles[SUB_DATA] = find_dissector("data");
 	sub_handles[SUB_IPMB] = find_dissector("ipmi");
-	sub_handles[SUB_HDCP] = find_dissector("hdcp");
+	sub_handles[SUB_HDMI] = find_dissector("hdmi");
 	i2c_handle = create_dissector_handle(dissect_i2c, proto_i2c);
 	dissector_add_uint("wtap_encap", WTAP_ENCAP_I2C, i2c_handle);
 }