Skip to contentSkip to conversation

drm/i915: Implement HDCP2.2

PATCH Superseded Ramalingam C 6 participants 80 messages Nov 27, 2018 – Dec 13, 2018 Page 1 of 2

Subsystems (5)

v8 of 15 Superseded Latest is v15 →

lore
Share & tools
lore
#0 lore raw

v8 cover drm/i915: Implement HDCP2.2

This series enables the HDCP2.2 for I915. The sequence for HDCP2.2 authentication and encryption is implemented as a generic flow between HDMI and DP. Encoder specific implementations are moved into hdcp_shim.

Intel HWs supports HDCP2.2 through ME FW. Hence this series introduces a client driver for mei bus, so that for HDCP2.2 authentication, HDCP2.2 stack in I915 can avail the services from ME FW. To enable this client driver set the config variable CONFIG_INTEL_MEI_HDCP.

Userspace interface remains unchanged as version agnostic. When userspace request for HDCP enable, Kernel will detect the HDCP source and sink's HDCP version(1.4/2.2)capability and enable the best capable version for that combination.

This series enables the HDCP2.2 for Type0 content strams.

Major changes in v8:
- Mei_hdcp component binding status will impact HDCP2.2 alone.
- hdcp2_check_work is cancelled only when hdcp2 is supported.
- Errors due to sinks are reported as DEBUG logs.
- HDCP2.2 auth will be attempted only if the mei_hdcp interface is up.
- Maintainability ease MEI i/f changes are gathered in single patch.
- intel_hdcp_exit is defined and used.

To ease the review process, series is hosted at
https://github.com/ramalingampc2008/drm-tip.git hdcp2_2_v8

Ramalingam C (33):
drm/i915: debug log for REPLY_ACK missing drm/i915: Increase timeout for Encrypt status change linux/mei: Header for mei_hdcp driver interface drm/i915: Initialize HDCP2.2
drm/i915: MEI interface definition
drm/i915: Enable and Disable of HDCP2.2
drm/i915: Implement HDCP2.2 receiver authentication drm/i915: Implement HDCP2.2 repeater authentication drm/i915: Implement HDCP2.2 link integrity check drm/i915: Handle HDCP2.2 downstream topology change drm/i915: Check HDCP 1.4 and 2.2 link on CP_IRQ drm/i915: Implement the HDCP2.2 support for DP drm/i915: Implement the HDCP2.2 support for HDMI drm/i915: Add HDCP2.2 support for DP connectors drm/i915: Add HDCP2.2 support for HDMI connectors misc/mei/hdcp: Client driver for HDCP application misc/mei/hdcp: Define ME FW interface for HDCP2.2 misc/mei/hdcp: Initiate Wired HDCP2.2 Tx Session misc/mei/hdcp: Verify Receiver Cert and prepare km misc/mei/hdcp: Verify H_prime
misc/mei/hdcp: Store the HDCP Pairing info misc/mei/hdcp: Initiate Locality check misc/mei/hdcp: Verify L_prime
misc/mei/hdcp: Prepare Session Key
misc/mei/hdcp: Repeater topology verification and ack misc/mei/hdcp: Verify M_prime
misc/mei/hdcp: Enabling the HDCP authentication misc/mei/hdcp: Closing wired HDCP2.2 Tx Session misc/mei/hdcp: Component framework for I915 Interface drm/i915: Commit CP without modeset
drm/i915: Fix KBL HDCP2.2 encrypt status signalling
FOR_TEST: i915/Kconfig: Select mei_hdcp by I915
FOR_TESTING_ONLY: debugfs: Excluding the LSPCon for HDCP1.4

Tomas Winkler (2):
mei: bus: whitelist hdcp client
mei: bus: export to_mei_cl_device for mei client device drivers

 MAINTAINERS                          |    1 +
 drivers/gpu/drm/i915/i915_debugfs.c  |   10 +-
 drivers/gpu/drm/i915/i915_drv.c      |    2 +
 drivers/gpu/drm/i915/i915_drv.h      |    2 +
 drivers/gpu/drm/i915/intel_ddi.c     |    7 -
 drivers/gpu/drm/i915/intel_display.c |   21 +-
 drivers/gpu/drm/i915/intel_dp.c      |  349 ++++++++-
 drivers/gpu/drm/i915/intel_drv.h     |   81 +-
 drivers/gpu/drm/i915/intel_hdcp.c    | 1390 +++++++++++++++++++++++++++++++---
 drivers/gpu/drm/i915/intel_hdmi.c    |  193 ++++-
 drivers/misc/mei/Kconfig             |    8 +
 drivers/misc/mei/Makefile            |    2 +
 drivers/misc/mei/bus-fixup.c         |   16 +
 drivers/misc/mei/bus.c               |    1 -
 drivers/misc/mei/hdcp/Makefile       |    7 +
 drivers/misc/mei/hdcp/mei_hdcp.c     |  825 ++++++++++++++++++++
 drivers/misc/mei/hdcp/mei_hdcp.h     |  366 +++++++++
 include/drm/drm_hdcp.h               |   23 +
 include/drm/i915_component.h         |   71 ++
 include/linux/mei_cl_bus.h           |    2 +
 include/linux/mei_hdcp.h             |   91 +++
 21 files changed, 3340 insertions(+), 128 deletions(-)
 create mode 100644 drivers/misc/mei/hdcp/Makefile
 create mode 100644 drivers/misc/mei/hdcp/mei_hdcp.c
 create mode 100644 drivers/misc/mei/hdcp/mei_hdcp.h
 create mode 100644 include/linux/mei_hdcp.h
Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#1 lore raw

PATCH v8 1/35 drm/i915: debug log for REPLY_ACK missing

Adding a DRM_DEBUG log when the DP_AUX_NATIVE_REPLY_ACK is missing for aksv write.

---
 drivers/gpu/drm/i915/intel_dp.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_dp.c +5 -1
index 70ae3d57316b..18e3a5a3d873 100644
@@ -5390,7 +5390,11 @@ int intel_dp_hdcp_write_an_aksv(struct intel_digital_port *intel_dig_port,
 	}
 
 	reply = (rxbuf[0] >> 4) & DP_AUX_NATIVE_REPLY_MASK;
-	return reply == DP_AUX_NATIVE_REPLY_ACK ? 0 : -EIO;
+	ret = reply == DP_AUX_NATIVE_REPLY_ACK ? 0 : -EIO;
+	if (ret)
+		DRM_DEBUG_KMS("Aksv write: DP_AUX_NATIVE_REPLY_ACK missing\n");
+
+	return ret;
 }
 
 static int intel_dp_hdcp_read_bksv(struct intel_digital_port *intel_dig_port,
Signature · 6 lines
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#2 lore raw

PATCH v8 2/35 drm/i915: Increase timeout for Encrypt status change

In reply to Ramalingam C

At enable/disable of the HDCP encryption, for encryption status change we need minimum one frame duration. And we might program this bit any point(start/End) in the previous frame.

With 20mSec, observed the timeout for change in encryption status. Since this is not time critical operation and we need to hold on until the status is changed, fixing the timeout to 50mSec. (Based on trial and error method!)

---
 drivers/gpu/drm/i915/intel_hdcp.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_hdcp.c +4 -2
index 1bf487f94254..04ba6c13e715 100644
@@ -15,6 +15,7 @@
 #include "i915_reg.h"
 
 #define KEY_LOAD_TRIES	5
+#define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
 
 static
 bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -636,7 +637,8 @@ static int intel_hdcp_auth(struct intel_digital_port *intel_dig_port,
 
 	/* Wait for encryption confirmation */
 	if (intel_wait_for_register(dev_priv, PORT_HDCP_STATUS(port),
-				    HDCP_STATUS_ENC, HDCP_STATUS_ENC, 20)) {
+				    HDCP_STATUS_ENC, HDCP_STATUS_ENC,
+				    TIME_FOR_ENCRYPT_STATUS_CHANGE)) {
 		DRM_ERROR("Timed out waiting for encryption\n");
 		return -ETIMEDOUT;
 	}
@@ -666,7 +668,7 @@ static int _intel_hdcp_disable(struct intel_connector *connector)
 
 	I915_WRITE(PORT_HDCP_CONF(port), 0);
 	if (intel_wait_for_register(dev_priv, PORT_HDCP_STATUS(port), ~0, 0,
-				    20)) {
+				    TIME_FOR_ENCRYPT_STATUS_CHANGE)) {
 		DRM_ERROR("Failed to disable HDCP, timeout clearing status\n");
 		return -ETIMEDOUT;
 	}
Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#3 lore raw

PATCH v8 3/35 linux/mei: Header for mei_hdcp driver interface

In reply to Ramalingam C

Data structures and Enum for the I915-MEI_HDCP interface are defined at <linux/mei_hdcp.h>

v2:
Rebased.
v3:
mei_cl_device is removed from mei_hdcp_data [Tomas]
v4:
Comment style and typo fixed [Uma]
v5:
Rebased.
v6:
No changes.
v7:
Remove redundant text from the License header Change uintXX_t type to uXX_t types
Remove unneeded include to mei_cl_bus.h Coding style fixed [Uma]
V8:
Tab cleanup
Fix kdoc and namespaces
Update MAINTAINERS

---
 MAINTAINERS              |  1 +
 include/linux/mei_hdcp.h | 91 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+)
 create mode 100644 include/linux/mei_hdcp.h
MAINTAINERS +1 -0
index 1026150ae90f..2fd6555bf040 100644
@@ -7540,6 +7540,7 @@ L:	[email protected]
 S:	Supported
 F:	include/uapi/linux/mei.h
 F:	include/linux/mei_cl_bus.h
+F:	include/linux/mei_hdcp.h
 F:	drivers/misc/mei/*
 F:	drivers/watchdog/mei_wdt.c
 F:	Documentation/misc-devices/mei/*
include/linux/mei_hdcp.h new file +91 -0

91 lines not on this page · raw message

Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#4 lore raw

Re: [PATCH v8 03/35] linux/mei: Header for mei_hdcp driver interface

Hi,

In one of the offline discussion Tomas has shared his review comments on v8.
So I am sharing the abstract of his suggestions here for the discussion and for the agreement of interface in the community. Tomas please correct/add if I am missing any points.

1. Remove the include/linux/mei_hdcp.h to make the i915-mei interface more generic.
1. Move the definition of the struct mei_hdcp_data to i915 and mei_hdcp.c and pass the void* in the ops' functions.
2. Move the conversion of enum port value to mei_ddi_port value into mei_hdcp.c. Let I915 pass the enum port value as such.
3. Modified local definition of the struct mei_hdcp_data will looks like
4.

+/* hdcp data per port */
+struct hdcp_port_data {
+ short int port;
+ u8 port_type;
+ u8 protocol;
+ u16 k;
+ u32 seq_num_m;
+ struct hdcp2_streamid_type *streams;
};

2. Add K-Doc compliant commenting in the mei_hdcp.c

I have implemented these changes and posted for intel-gfx-trybot. Just incase anyone wants to refer the code please look at https://patchwork.freedesktop.org/series/53655/ . Not shared on #intel-gfx as further review discussions are on-going on intel-gfx.

--Ram

Quoted 131 lines · Ramalingam C

Data structures and Enum for the I915-MEI_HDCP interface are defined at <linux/mei_hdcp.h>

v2:
Rebased.
v3:
mei_cl_device is removed from mei_hdcp_data [Tomas]
v4:
Comment style and typo fixed [Uma]
v5:
Rebased.
v6:
No changes.
v7:
Remove redundant text from the License header Change uintXX_t type to uXX_t types
Remove unneeded include to mei_cl_bus.h Coding style fixed [Uma]
V8:
Tab cleanup
Fix kdoc and namespaces
Update MAINTAINERS

---
  MAINTAINERS              |  1 +
  include/linux/mei_hdcp.h | 91 ++++++++++++++++++++++++++++++++++++++++++++++++
  2 files changed, 92 insertions(+)

create mode 100644 include/linux/mei_hdcp.h

MAINTAINERS +1 -0
index 1026150ae90f..2fd6555bf040 100644
@@ -7540,6 +7540,7 @@ L:	[email protected]
  S:	Supported
  F:	include/uapi/linux/mei.h
  F:	include/linux/mei_cl_bus.h
+F:	include/linux/mei_hdcp.h
  F:	drivers/misc/mei/*
  F:	drivers/watchdog/mei_wdt.c
  F:	Documentation/misc-devices/mei/*
include/linux/mei_hdcp.h new file +81 -0
new file mode 100644
index 000000000000..716123003dd1
@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
+/*
+ * Copyright © 2017-2018 Intel Corporation
+ *
+ * Authors:
+ * Ramalingam C <[email protected]>
+ */
+
+#ifndef _LINUX_MEI_HDCP_H
+#define _LINUX_MEI_HDCP_H
+
+/**
+ * enum mei_hdcp_ddi - The physical digital display interface (DDI)
+ *     available on the platform
+ * @MEI_DDI_INVALID_PORT: Not a valid port
+ * @MEI_DDI_RANGE_BEGIN: Beginning of the valid DDI port range
+ * @MEI_DDI_B: Port DDI B
+ * @MEI_DDI_C: Port DDI C
+ * @MEI_DDI_D: Port DDI D
+ * @MEI_DDI_E: Port DDI E
+ * @MEI_DDI_F: Port DDI F
+ * @MEI_DDI_A: Port DDI A
+ * @MEI_DDI_RANGE_END: End of the valid DDI port range
+ */
+enum mei_hdcp_ddi {
+	MEI_DDI_INVALID_PORT = 0x00,
+
+	MEI_DDI_RANGE_BEGIN = 0x01,
+	MEI_DDI_B           = 0x01,
+	MEI_DDI_C           = 0x02,
+	MEI_DDI_D           = 0x03,
+	MEI_DDI_E           = 0x04,
+	MEI_DDI_F           = 0x05,
+	MEI_DDI_A           = 0x07,
+	MEI_DDI_RANGE_END   = MEI_DDI_A,
+};
+
+/**
+ * enum mei_hdcp_port_type - The types of HDCP 2.2 ports supported
+ *
+ * @MEI_HDCP_PORT_TYPE_INVALID: Invalid port
+ * @MEI_HDCP_PORT_TYPE_INTEGRATED: ports that are integrated into Intel HW
+ * @MEI_HDCP_PORT_TYPE_LSPCON: discrete wired Tx port with LSPCON (HDMI 2.0)
+ * @MEI_HDCP_PORT_TYPE_CPDP: discrete wired Tx port using the CPDP (DP 1.3)
+ */
+enum mei_hdcp_port_type {
+	MEI_HDCP_PORT_TYPE_INVALID    = 0x00,
+	MEI_HDCP_PORT_TYPE_INTEGRATED = 0x01,
+	MEI_HDCP_PORT_TYPE_LSPCON     = 0x02,
+	MEI_HDCP_PORT_TYPE_CPDP       = 0x03,
+};
+
+/*
+ * enum mei_hdcp_wired_protocol - Supported integrated wired HDCP protocol.
+ * @HDCP_PROTOCOL_INVALID: invalid type
+ * @HDCP_PROTOCOL_HDMI: HDMI
+ * @HDCP_PROTOCOL_DP: DP
+ *
+ * Based on this value, Minor difference needed between wired specifications
+ * are handled.
+ */
+enum mei_hdcp_wired_protocol {
+	MEI_HDCP_PROTOCOL_INVALID,
+	MEI_HDCP_PROTOCOL_HDMI,
+	MEI_HDCP_PROTOCOL_DP
+};
+
+/**
+ * struct mei_hdcp_data - Input data to the mei_hdcp APIs
+ * @port: The physical port (ddi).
+ * @port_type: The port type.
+ * @protocol: The Protocol on the port.
+ * @k: Number of streams transmitted on the port.
+ *     In case of HDMI & DP SST, a single stream will be
+ *     transmitted on the port.
+ * @seq_num_m: A sequence number of RepeaterAuth_Stream_Manage msg propagated.
+ *     Initialized to 0 on AKE_INIT. Incremented after every successful
+ *     transmission of RepeaterAuth_Stream_Manage message. When it rolls
+ *     over re-Auth has to be triggered.
+ * @streams: array[k] of streamid
+ */

include/linux/mei_hdcp.h line 91

Quoted 10 lines
include/linux/mei_hdcp.h new file +10 -0
+struct mei_hdcp_data {
+	enum mei_hdcp_ddi port;
+	enum mei_hdcp_port_type port_type;
+	enum mei_hdcp_wired_protocol protocol;
+	u16 k;
+	u32 seq_num_m;
+	struct hdcp2_streamid_type *streams;
+};
+
+#endif /* !_LINUX_MEI_HDCP_H */

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

#5 lore raw

Re: [PATCH v8 03/35] linux/mei: Header for mei_hdcp driver interface

Quoted 3 lines · Ramalingam

Hi,

In one of the offline discussion Tomas has shared his review comments on v8.

Let's please have all review here on the mailing list for better coordination. Playing a game of telephone isn't efficient.

Quoted 7 lines

So I am sharing the abstract of his suggestions here for the discussion and for the agreement of interface in the community. Tomas please correct/add if I am missing any points.

1. Remove the include/linux/mei_hdcp.h to make the i915-mei interface more generic.
1. Move the definition of the struct mei_hdcp_data to i915 and mei_hdcp.c and pass the void* in the ops' functions.

I don't get this. Using void * instead of the actual type we're passing isn't more generic, it's just less safe. If we later on need to extend the api contract between mei_hdcp and i915 we can always do that. Like we already do with the i915/snd-hda-intel component contract in i915_component.h and drm_audio_component.h.

Aside: Header names for the audio interface are maybe not the best, this isn't primarily a component thing. So maybe call it i915_mei_hdcp_interface.h and stuff all the structures/function pointers that define the interface between the two drivers in there. Or some other suitable name you like better.

Quoted 2 lines

2. Move the conversion of enum port value to mei_ddi_port value into mei_hdcp.c. Let I915 pass the enum port value as such.

logical port 2 physical register index mapping tends to shift around and is always highly machine specific. As long as we do it consistently somewhere we should be good. Seems fine to me.

Quoted 2 lines

3. Modified local definition of the struct mei_hdcp_data will looks like

No local defintions of structures please. Otherwise I'm ok with whatever gets the job done.

Quoted 12 lines

4.

+/* hdcp data per port */
+struct hdcp_port_data {
+ short int port;
+ u8 port_type;
+ u8 protocol;
+ u16 k;
+ u32 seq_num_m;
+ struct hdcp2_streamid_type *streams;
};

Quoted 1 line

2. Add K-Doc compliant commenting in the mei_hdcp.c

If you do that, please include the relevant comments into the drm/i915 docbook, like we do already with the audio stuff.

Quoted 3 lines

I have implemented these changes and posted for intel-gfx-trybot. Just incase anyone wants to refer the code please look at https://patchwork.freedesktop.org/series/53655/ . Not shared on #intel-gfx as further review discussions are on-going on intel-gfx.

As discussed, no void * in the interface, and we definitely need a shared header for ops/data structures. We want the compiler to help us catch when one side of this i915/mei_hdcp api contract changes as much as possible. All the other changes seem reasonable.

Thanks, Daniel

Quoted 146 lines

--Ram

Quoted 141 lines · Ramalingam C

Data structures and Enum for the I915-MEI_HDCP interface are defined at <linux/mei_hdcp.h>

v2:
Rebased.
v3:
mei_cl_device is removed from mei_hdcp_data [Tomas]
v4:
Comment style and typo fixed [Uma]
v5:
Rebased.
v6:
No changes.
v7:
Remove redundant text from the License header Change uintXX_t type to uXX_t types
Remove unneeded include to mei_cl_bus.h Coding style fixed [Uma]
V8:
Tab cleanup
Fix kdoc and namespaces
Update MAINTAINERS

---
  MAINTAINERS              |  1 +
  include/linux/mei_hdcp.h | 91 ++++++++++++++++++++++++++++++++++++++++++++++++
  2 files changed, 92 insertions(+)

create mode 100644 include/linux/mei_hdcp.h

MAINTAINERS +1 -0
index 1026150ae90f..2fd6555bf040 100644
@@ -7540,6 +7540,7 @@ L:	[email protected]
  S:	Supported
  F:	include/uapi/linux/mei.h
  F:	include/linux/mei_cl_bus.h
+F:	include/linux/mei_hdcp.h
  F:	drivers/misc/mei/*
  F:	drivers/watchdog/mei_wdt.c
  F:	Documentation/misc-devices/mei/*
include/linux/mei_hdcp.h new file +91 -0
new file mode 100644
index 000000000000..716123003dd1
@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
+/*
+ * Copyright © 2017-2018 Intel Corporation
+ *
+ * Authors:
+ * Ramalingam C <[email protected]>
+ */
+
+#ifndef _LINUX_MEI_HDCP_H
+#define _LINUX_MEI_HDCP_H
+
+/**
+ * enum mei_hdcp_ddi - The physical digital display interface (DDI)
+ *     available on the platform
+ * @MEI_DDI_INVALID_PORT: Not a valid port
+ * @MEI_DDI_RANGE_BEGIN: Beginning of the valid DDI port range
+ * @MEI_DDI_B: Port DDI B
+ * @MEI_DDI_C: Port DDI C
+ * @MEI_DDI_D: Port DDI D
+ * @MEI_DDI_E: Port DDI E
+ * @MEI_DDI_F: Port DDI F
+ * @MEI_DDI_A: Port DDI A
+ * @MEI_DDI_RANGE_END: End of the valid DDI port range
+ */
+enum mei_hdcp_ddi {
+	MEI_DDI_INVALID_PORT = 0x00,
+
+	MEI_DDI_RANGE_BEGIN = 0x01,
+	MEI_DDI_B           = 0x01,
+	MEI_DDI_C           = 0x02,
+	MEI_DDI_D           = 0x03,
+	MEI_DDI_E           = 0x04,
+	MEI_DDI_F           = 0x05,
+	MEI_DDI_A           = 0x07,
+	MEI_DDI_RANGE_END   = MEI_DDI_A,
+};
+
+/**
+ * enum mei_hdcp_port_type - The types of HDCP 2.2 ports supported
+ *
+ * @MEI_HDCP_PORT_TYPE_INVALID: Invalid port
+ * @MEI_HDCP_PORT_TYPE_INTEGRATED: ports that are integrated into Intel HW
+ * @MEI_HDCP_PORT_TYPE_LSPCON: discrete wired Tx port with LSPCON (HDMI 2.0)
+ * @MEI_HDCP_PORT_TYPE_CPDP: discrete wired Tx port using the CPDP (DP 1.3)
+ */
+enum mei_hdcp_port_type {
+	MEI_HDCP_PORT_TYPE_INVALID    = 0x00,
+	MEI_HDCP_PORT_TYPE_INTEGRATED = 0x01,
+	MEI_HDCP_PORT_TYPE_LSPCON     = 0x02,
+	MEI_HDCP_PORT_TYPE_CPDP       = 0x03,
+};
+
+/*
+ * enum mei_hdcp_wired_protocol - Supported integrated wired HDCP protocol.
+ * @HDCP_PROTOCOL_INVALID: invalid type
+ * @HDCP_PROTOCOL_HDMI: HDMI
+ * @HDCP_PROTOCOL_DP: DP
+ *
+ * Based on this value, Minor difference needed between wired specifications
+ * are handled.
+ */
+enum mei_hdcp_wired_protocol {
+	MEI_HDCP_PROTOCOL_INVALID,
+	MEI_HDCP_PROTOCOL_HDMI,
+	MEI_HDCP_PROTOCOL_DP
+};
+
+/**
+ * struct mei_hdcp_data - Input data to the mei_hdcp APIs
+ * @port: The physical port (ddi).
+ * @port_type: The port type.
+ * @protocol: The Protocol on the port.
+ * @k: Number of streams transmitted on the port.
+ *     In case of HDMI & DP SST, a single stream will be
+ *     transmitted on the port.
+ * @seq_num_m: A sequence number of RepeaterAuth_Stream_Manage msg propagated.
+ *     Initialized to 0 on AKE_INIT. Incremented after every successful
+ *     transmission of RepeaterAuth_Stream_Manage message. When it rolls
+ *     over re-Auth has to be triggered.
+ * @streams: array[k] of streamid
+ */
+struct mei_hdcp_data {
+	enum mei_hdcp_ddi port;
+	enum mei_hdcp_port_type port_type;
+	enum mei_hdcp_wired_protocol protocol;
+	u16 k;
+	u32 seq_num_m;
+	struct hdcp2_streamid_type *streams;
+};
+
+#endif /* !_LINUX_MEI_HDCP_H */
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#6 lore raw

Re: [PATCH v8 03/35] linux/mei: Header for mei_hdcp driver interface

Quoted 8 lines · Ramalingam
Quoted 3 lines

Hi,

In one of the offline discussion Tomas has shared his review comments on v8.

Let's please have all review here on the mailing list for better coordination. Playing a game of telephone isn't efficient.

It's not different from IRC or meeting on a conference, after all we end up with code we can comment on.

Quoted 10 lines
Quoted 2 lines

So I am sharing the abstract of his suggestions here for the discussion and for

the agreement of interface in the community.

Quoted 6 lines

Tomas please correct/add if I am missing any points.

1. Remove the include/linux/mei_hdcp.h to make the i915-mei interface more generic.
1. Move the definition of the struct mei_hdcp_data to i915 and mei_hdcp.c and pass the void* in the ops' functions.

Quoted 5 lines

I don't get this. Using void * instead of the actual type we're passing isn't more generic, it's just less safe. If we later on need to extend the api contract between mei_hdcp and i915 we can always do that. Like we already do with the i915/snd-hda-intel component contract in i915_component.h and drm_audio_component.h.

No I haven't suggesting using void *, what I've suggest is to use HDCP construct instead of mei specific types.

Quoted 39 lines

Aside: Header names for the audio interface are maybe not the best, this isn't primarily a component thing. So maybe call it i915_mei_hdcp_interface.h and stuff all the structures/function pointers that define the interface between the two drivers in there. Or some other suitable name you like better.

Quoted 2 lines

2. Move the conversion of enum port value to mei_ddi_port value into mei_hdcp.c. Let I915 pass the enum port value as such.

logical port 2 physical register index mapping tends to shift around and is always highly machine specific. As long as we do it consistently somewhere we should be good. Seems fine to me.

Quoted 2 lines

3. Modified local definition of the struct mei_hdcp_data will looks like

No local defintions of structures please. Otherwise I'm ok with whatever gets the job done.

Quoted 12 lines

4.

+/* hdcp data per port */
+struct hdcp_port_data {
+ short int port;
+ u8 port_type;
+ u8 protocol;
+ u16 k;
+ u32 seq_num_m;
+ struct hdcp2_streamid_type *streams;
};

Quoted 1 line

2. Add K-Doc compliant commenting in the mei_hdcp.c

If you do that, please include the relevant comments into the drm/i915 docbook, like we do already with the audio stuff.

Quoted 2 lines

I have implemented these changes and posted for intel-gfx-trybot. Just incase anyone wants to refer the code please look at

https://patchwork.freedesktop.org/series/53655/ .

Quoted 1 line

Not shared on #intel-gfx as further review discussions are on-going on intel-

Quoted 8 lines

gfx.

As discussed, no void * in the interface, and we definitely need a shared header for ops/data structures. We want the compiler to help us catch when one side of this i915/mei_hdcp api contract changes as much as possible.
All the other changes seem reasonable.

Thanks, Daniel

I agree with no void *, that was not my intention. It will be better to comment on v9 series.

Quoted 145 lines
Quoted 34 lines

--Ram

Quoted 29 lines · Ramalingam C

Data structures and Enum for the I915-MEI_HDCP interface are defined at <linux/mei_hdcp.h>

v2:
Rebased.
v3:
mei_cl_device is removed from mei_hdcp_data [Tomas]
v4:
Comment style and typo fixed [Uma]
v5:
Rebased.
v6:
No changes.
v7:
Remove redundant text from the License header Change uintXX_t type to uXX_t types
Remove unneeded include to mei_cl_bus.h Coding style fixed [Uma]
V8:
Tab cleanup
Fix kdoc and namespaces
Update MAINTAINERS

---
  MAINTAINERS              |  1 +
  include/linux/mei_hdcp.h | 91

++++++++++++++++++++++++++++++++++++++++++++++++

Quoted 65 lines
Quoted 65 lines
  2 files changed, 92 insertions(+)

create mode 100644 include/linux/mei_hdcp.h

MAINTAINERS index renamed from MAINTAINERS +0 -0

1026150ae90f..2fd6555bf040 100644

MAINTAINERS +1 -0
@@ -7540,6 +7540,7 @@ L:	[email protected]
  S:	Supported
  F:	include/uapi/linux/mei.h
  F:	include/linux/mei_cl_bus.h
+F:	include/linux/mei_hdcp.h
  F:	drivers/misc/mei/*
  F:	drivers/watchdog/mei_wdt.c
  F:	Documentation/misc-devices/mei/*
include/linux/mei_hdcp.h new renamed from include/linux/mei_hdcp.h +0 -0

file mode 100644 index 000000000000..716123003dd1

include/linux/mei_hdcp.h new file +45 -0
@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
+/*
+ * Copyright (c) 2017-2018 Intel Corporation
+ *
+ * Authors:
+ * Ramalingam C <[email protected]>  */
+
+#ifndef _LINUX_MEI_HDCP_H
+#define _LINUX_MEI_HDCP_H
+
+/**
+ * enum mei_hdcp_ddi - The physical digital display interface (DDI)
+ *     available on the platform
+ * @MEI_DDI_INVALID_PORT: Not a valid port
+ * @MEI_DDI_RANGE_BEGIN: Beginning of the valid DDI port range
+ * @MEI_DDI_B: Port DDI B
+ * @MEI_DDI_C: Port DDI C
+ * @MEI_DDI_D: Port DDI D
+ * @MEI_DDI_E: Port DDI E
+ * @MEI_DDI_F: Port DDI F
+ * @MEI_DDI_A: Port DDI A
+ * @MEI_DDI_RANGE_END: End of the valid DDI port range  */ enum
+mei_hdcp_ddi {
+	MEI_DDI_INVALID_PORT = 0x00,
+
+	MEI_DDI_RANGE_BEGIN = 0x01,
+	MEI_DDI_B           = 0x01,
+	MEI_DDI_C           = 0x02,
+	MEI_DDI_D           = 0x03,
+	MEI_DDI_E           = 0x04,
+	MEI_DDI_F           = 0x05,
+	MEI_DDI_A           = 0x07,
+	MEI_DDI_RANGE_END   = MEI_DDI_A,
+};
+
+/**
+ * enum mei_hdcp_port_type - The types of HDCP 2.2 ports supported
+ *
+ * @MEI_HDCP_PORT_TYPE_INVALID: Invalid port
+ * @MEI_HDCP_PORT_TYPE_INTEGRATED: ports that are integrated into
+Intel HW
+ * @MEI_HDCP_PORT_TYPE_LSPCON: discrete wired Tx port with LSPCON
+(HDMI 2.0)
+ * @MEI_HDCP_PORT_TYPE_CPDP: discrete wired Tx port using the CPDP
+(DP 1.3)  */ enum mei_hdcp_port_type {
Quoted 8 lines

include/linux/mei_hdcp.h

Quoted 8 lines
include/linux/mei_hdcp.h new file +8 -0
+	MEI_HDCP_PORT_TYPE_INVALID    = 0x00,
+	MEI_HDCP_PORT_TYPE_INTEGRATED = 0x01,
+	MEI_HDCP_PORT_TYPE_LSPCON     = 0x02,
+	MEI_HDCP_PORT_TYPE_CPDP       = 0x03,
+};
+
+/*
+ * enum mei_hdcp_wired_protocol - Supported integrated wired HDCP

protocol.

Quoted 15 lines
Quoted 15 lines
include/linux/mei_hdcp.h new file +15 -0
+ * @HDCP_PROTOCOL_INVALID: invalid type
+ * @HDCP_PROTOCOL_HDMI: HDMI
+ * @HDCP_PROTOCOL_DP: DP
+ *
+ * Based on this value, Minor difference needed between wired
+specifications
+ * are handled.
+ */
+enum mei_hdcp_wired_protocol {
+	MEI_HDCP_PROTOCOL_INVALID,
+	MEI_HDCP_PROTOCOL_HDMI,
+	MEI_HDCP_PROTOCOL_DP
+};
+
+/**
Quoted 8 lines

include/linux/mei_hdcp.h

Quoted 8 lines
include/linux/mei_hdcp.h new file +8 -0
+ * struct mei_hdcp_data - Input data to the mei_hdcp APIs
+ * @port: The physical port (ddi).
+ * @port_type: The port type.
+ * @protocol: The Protocol on the port.
+ * @k: Number of streams transmitted on the port.
+ *     In case of HDMI & DP SST, a single stream will be
+ *     transmitted on the port.
+ * @seq_num_m: A sequence number of RepeaterAuth_Stream_Manage

msg propagated.

Quoted 2 lines

include/linux/mei_hdcp.h line 78

Quoted 2 lines
include/linux/mei_hdcp.h new file +2 -0
+ *     Initialized to 0 on AKE_INIT. Incremented after every successful
+ *     transmission of RepeaterAuth_Stream_Manage message. When it

rolls

Quoted 9 lines
Quoted 9 lines
include/linux/mei_hdcp.h new file +9 -0
+ *     over re-Auth has to be triggered.
+ * @streams: array[k] of streamid
+ */
+struct mei_hdcp_data {
+	enum mei_hdcp_ddi port;
+	enum mei_hdcp_port_type port_type;
+	enum mei_hdcp_wired_protocol protocol;
+	u16 k;
+	u32 seq_num_m;
Quoted 8 lines
Quoted 3 lines

include/linux/mei_hdcp.h line 91

Quoted 3 lines
include/linux/mei_hdcp.h new file +3 -0
+	struct hdcp2_streamid_type *streams; };
+
+#endif /* !_LINUX_MEI_HDCP_H */

--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#7 lore raw

Re: [PATCH v8 03/35] linux/mei: Header for mei_hdcp driver interface

Quoted 9 lines · Tomas
Quoted 8 lines · Ramalingam
Quoted 3 lines

Hi,

In one of the offline discussion Tomas has shared his review comments on v8.

Let's please have all review here on the mailing list for better coordination. Playing a game of telephone isn't efficient.

It's not different from IRC or meeting on a conference, after all we end up with code we can comment on.

For IRC we try to summarize discussions on the mailing list too. Same for conferences (if that ever happens for public stuff).

Quoted 9 lines
Quoted 9 lines
Quoted 1 line

So I am sharing the abstract of his suggestions here for the discussion and for

the agreement of interface in the community.

Quoted 6 lines

Tomas please correct/add if I am missing any points.

1. Remove the include/linux/mei_hdcp.h to make the i915-mei interface more generic.
1. Move the definition of the struct mei_hdcp_data to i915 and mei_hdcp.c and pass the void* in the ops' functions.

Quoted 7 lines
Quoted 5 lines

I don't get this. Using void * instead of the actual type we're passing isn't more generic, it's just less safe. If we later on need to extend the api contract between mei_hdcp and i915 we can always do that. Like we already do with the i915/snd-hda-intel component contract in i915_component.h and drm_audio_component.h.

No I haven't suggesting using void *, what I've suggest is to use HDCP construct instead of mei specific types.

Ah, makes sense. I thought v7 pretty much does that already though, at least as far as we define these structures on the drm side (it's just a register file in an i2c target address after all).
-Daniel

Quoted 204 lines
Quoted 39 lines

Aside: Header names for the audio interface are maybe not the best, this isn't primarily a component thing. So maybe call it i915_mei_hdcp_interface.h and stuff all the structures/function pointers that define the interface between the two drivers in there. Or some other suitable name you like better.

Quoted 2 lines

2. Move the conversion of enum port value to mei_ddi_port value into mei_hdcp.c. Let I915 pass the enum port value as such.

logical port 2 physical register index mapping tends to shift around and is always highly machine specific. As long as we do it consistently somewhere we should be good. Seems fine to me.

Quoted 2 lines

3. Modified local definition of the struct mei_hdcp_data will looks like

No local defintions of structures please. Otherwise I'm ok with whatever gets the job done.

Quoted 12 lines

4.

+/* hdcp data per port */
+struct hdcp_port_data {
+ short int port;
+ u8 port_type;
+ u8 protocol;
+ u16 k;
+ u32 seq_num_m;
+ struct hdcp2_streamid_type *streams;
};

Quoted 1 line

2. Add K-Doc compliant commenting in the mei_hdcp.c

If you do that, please include the relevant comments into the drm/i915 docbook, like we do already with the audio stuff.

Quoted 2 lines

I have implemented these changes and posted for intel-gfx-trybot. Just incase anyone wants to refer the code please look at

https://patchwork.freedesktop.org/series/53655/ .

Quoted 1 line

Not shared on #intel-gfx as further review discussions are on-going on intel-

Quoted 8 lines

gfx.

As discussed, no void * in the interface, and we definitely need a shared header for ops/data structures. We want the compiler to help us catch when one side of this i915/mei_hdcp api contract changes as much as possible.
All the other changes seem reasonable.

Thanks, Daniel

I agree with no void *, that was not my intention. It will be better to comment on v9 series.

Quoted 153 lines
Quoted 34 lines

--Ram

Quoted 29 lines · Ramalingam C

Data structures and Enum for the I915-MEI_HDCP interface are defined at <linux/mei_hdcp.h>

v2:
Rebased.
v3:
mei_cl_device is removed from mei_hdcp_data [Tomas]
v4:
Comment style and typo fixed [Uma]
v5:
Rebased.
v6:
No changes.
v7:
Remove redundant text from the License header Change uintXX_t type to uXX_t types
Remove unneeded include to mei_cl_bus.h Coding style fixed [Uma]
V8:
Tab cleanup
Fix kdoc and namespaces
Update MAINTAINERS

---
  MAINTAINERS              |  1 +
  include/linux/mei_hdcp.h | 91

++++++++++++++++++++++++++++++++++++++++++++++++

Quoted 65 lines
Quoted 65 lines
  2 files changed, 92 insertions(+)

create mode 100644 include/linux/mei_hdcp.h

MAINTAINERS index renamed from MAINTAINERS +0 -0

1026150ae90f..2fd6555bf040 100644

MAINTAINERS +1 -0
@@ -7540,6 +7540,7 @@ L:	[email protected]
  S:	Supported
  F:	include/uapi/linux/mei.h
  F:	include/linux/mei_cl_bus.h
+F:	include/linux/mei_hdcp.h
  F:	drivers/misc/mei/*
  F:	drivers/watchdog/mei_wdt.c
  F:	Documentation/misc-devices/mei/*
include/linux/mei_hdcp.h new renamed from include/linux/mei_hdcp.h +0 -0

file mode 100644 index 000000000000..716123003dd1

include/linux/mei_hdcp.h new file +45 -0
@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
+/*
+ * Copyright (c) 2017-2018 Intel Corporation
+ *
+ * Authors:
+ * Ramalingam C <[email protected]>  */
+
+#ifndef _LINUX_MEI_HDCP_H
+#define _LINUX_MEI_HDCP_H
+
+/**
+ * enum mei_hdcp_ddi - The physical digital display interface (DDI)
+ *     available on the platform
+ * @MEI_DDI_INVALID_PORT: Not a valid port
+ * @MEI_DDI_RANGE_BEGIN: Beginning of the valid DDI port range
+ * @MEI_DDI_B: Port DDI B
+ * @MEI_DDI_C: Port DDI C
+ * @MEI_DDI_D: Port DDI D
+ * @MEI_DDI_E: Port DDI E
+ * @MEI_DDI_F: Port DDI F
+ * @MEI_DDI_A: Port DDI A
+ * @MEI_DDI_RANGE_END: End of the valid DDI port range  */ enum
+mei_hdcp_ddi {
+	MEI_DDI_INVALID_PORT = 0x00,
+
+	MEI_DDI_RANGE_BEGIN = 0x01,
+	MEI_DDI_B           = 0x01,
+	MEI_DDI_C           = 0x02,
+	MEI_DDI_D           = 0x03,
+	MEI_DDI_E           = 0x04,
+	MEI_DDI_F           = 0x05,
+	MEI_DDI_A           = 0x07,
+	MEI_DDI_RANGE_END   = MEI_DDI_A,
+};
+
+/**
+ * enum mei_hdcp_port_type - The types of HDCP 2.2 ports supported
+ *
+ * @MEI_HDCP_PORT_TYPE_INVALID: Invalid port
+ * @MEI_HDCP_PORT_TYPE_INTEGRATED: ports that are integrated into
+Intel HW
+ * @MEI_HDCP_PORT_TYPE_LSPCON: discrete wired Tx port with LSPCON
+(HDMI 2.0)
+ * @MEI_HDCP_PORT_TYPE_CPDP: discrete wired Tx port using the CPDP
+(DP 1.3)  */ enum mei_hdcp_port_type {
Quoted 8 lines

include/linux/mei_hdcp.h

Quoted 8 lines
include/linux/mei_hdcp.h new file +8 -0
+	MEI_HDCP_PORT_TYPE_INVALID    = 0x00,
+	MEI_HDCP_PORT_TYPE_INTEGRATED = 0x01,
+	MEI_HDCP_PORT_TYPE_LSPCON     = 0x02,
+	MEI_HDCP_PORT_TYPE_CPDP       = 0x03,
+};
+
+/*
+ * enum mei_hdcp_wired_protocol - Supported integrated wired HDCP

protocol.

Quoted 15 lines
Quoted 15 lines
include/linux/mei_hdcp.h new file +15 -0
+ * @HDCP_PROTOCOL_INVALID: invalid type
+ * @HDCP_PROTOCOL_HDMI: HDMI
+ * @HDCP_PROTOCOL_DP: DP
+ *
+ * Based on this value, Minor difference needed between wired
+specifications
+ * are handled.
+ */
+enum mei_hdcp_wired_protocol {
+	MEI_HDCP_PROTOCOL_INVALID,
+	MEI_HDCP_PROTOCOL_HDMI,
+	MEI_HDCP_PROTOCOL_DP
+};
+
+/**
Quoted 8 lines

include/linux/mei_hdcp.h

Quoted 8 lines
include/linux/mei_hdcp.h new file +8 -0
+ * struct mei_hdcp_data - Input data to the mei_hdcp APIs
+ * @port: The physical port (ddi).
+ * @port_type: The port type.
+ * @protocol: The Protocol on the port.
+ * @k: Number of streams transmitted on the port.
+ *     In case of HDMI & DP SST, a single stream will be
+ *     transmitted on the port.
+ * @seq_num_m: A sequence number of RepeaterAuth_Stream_Manage

msg propagated.

Quoted 2 lines

include/linux/mei_hdcp.h line 78

Quoted 2 lines
include/linux/mei_hdcp.h new file +2 -0
+ *     Initialized to 0 on AKE_INIT. Incremented after every successful
+ *     transmission of RepeaterAuth_Stream_Manage message. When it

rolls

Quoted 4 lines
Quoted 4 lines
include/linux/mei_hdcp.h new file +4 -0
+ *     over re-Auth has to be triggered.
+ * @streams: array[k] of streamid
+ */
+struct mei_hdcp_data {
Quoted 8 lines

include/linux/mei_hdcp.h line 91

Quoted 8 lines
include/linux/mei_hdcp.h new file +8 -0
+	enum mei_hdcp_ddi port;
+	enum mei_hdcp_port_type port_type;
+	enum mei_hdcp_wired_protocol protocol;
+	u16 k;
+	u32 seq_num_m;
+	struct hdcp2_streamid_type *streams; };
+
+#endif /* !_LINUX_MEI_HDCP_H */

--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#8 lore raw

PATCH v8 4/35 drm/i915: Initialize HDCP2.2

In reply to Ramalingam C

Add the HDCP2.2 initialization to the existing HDCP1.4 stack.

v2:
mei interface handle is protected with mutex. [Chris Wilson]
v3:
Notifiers are used for the mei interface state.
v4:
Poll for mei client device state
Error msg for out of mem [Uma]
Inline req for init function removed [Uma]
v5:
Rebase as Part of reordering.
Component is used for the I915 and MEI_HDCP interface [Daniel]
v6:
HDCP2.2 uses the I915 component master to communicate with mei_hdcp
- [Daniel]
Required HDCP2.2 variables defined [Sean Paul]
v7:
intel_hdcp2.2_init returns void [Uma]
Realigning the codes.
v8:
Avoid using bool structure members.
MEI interface related changes are moved into separate patch. Commit msg is updated accordingly.
intel_hdcp_exit is defined and used from i915_unload

---
 drivers/gpu/drm/i915/i915_drv.c   |   2 +
 drivers/gpu/drm/i915/intel_dp.c   |   3 +-
 drivers/gpu/drm/i915/intel_drv.h  |  16 +++-
 drivers/gpu/drm/i915/intel_hdcp.c | 172 ++++++++++++++++++++++++--------------
 drivers/gpu/drm/i915/intel_hdmi.c |   2 +-
 5 files changed, 130 insertions(+), 65 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +2 -0
index b1d23c73c147..fbedd5024afe 100644
@@ -1755,6 +1755,8 @@ void i915_driver_unload(struct drm_device *dev)
 
 	disable_rpm_wakeref_asserts(dev_priv);
 
+	intel_hdcp_exit(dev_priv);
+
 	i915_driver_unregister(dev_priv);
 
 	if (i915_gem_suspend(dev_priv))
drivers/gpu/drm/i915/intel_dp.c +2 -1
index 18e3a5a3d873..ac62af073688 100644
@@ -6675,7 +6675,8 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
 	intel_dp_add_properties(intel_dp, connector);
 
 	if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
-		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim);
+		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim,
+					  false);
 		if (ret)
 			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
 	}
drivers/gpu/drm/i915/intel_drv.h +15 -1
index a62d77b76291..85a526598096 100644
@@ -388,6 +388,17 @@ struct intel_hdcp {
 	u64 value;
 	struct delayed_work check_work;
 	struct work_struct prop_work;
+
+	/* HDCP2.2 related definitions */
+	/* Flag indicates whether this connector supports HDCP2.2 or not. */
+	u8 hdcp2_supported;
+
+	/*
+	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
+	 * flow in the link protected by HDCP2.2 or HDCP1.4, where as TYPE1(0x1)
+	 * content can flow only through a link protected by HDCP2.2.
+	 */
+	u8 content_type;
 };
 
 struct intel_connector {
@@ -2016,12 +2027,15 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
 			     struct drm_connector_state *old_state,
 			     struct drm_connector_state *new_state);
 int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *hdcp_shim);
+		    const struct intel_hdcp_shim *hdcp_shim,
+		    bool hdcp2_supported);
 int intel_hdcp_enable(struct intel_connector *connector);
 int intel_hdcp_disable(struct intel_connector *connector);
 int intel_hdcp_check_link(struct intel_connector *connector);
 bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port);
 bool intel_hdcp_capable(struct intel_connector *connector);
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv);
+void intel_hdcp_exit(struct drm_i915_private *dev_priv);
 
 /* intel_psr.c */
 #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) && dev_priv->psr.sink_support)
drivers/gpu/drm/i915/intel_hdcp.c +110 -62

201 lines not on this page · raw message

drivers/gpu/drm/i915/intel_hdmi.c +1 -1
index e2c6a2b3e8f2..e755a3370bca 100644
@@ -2417,7 +2417,7 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
 
 	if (is_hdcp_supported(dev_priv, port)) {
 		int ret = intel_hdcp_init(intel_connector,
-					  &intel_hdmi_hdcp_shim);
+					  &intel_hdmi_hdcp_shim, false);
 		if (ret)
 			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
 	}
Signature · 6 lines
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#9 lore raw

Re: [PATCH v8 04/35] drm/i915: Initialize HDCP2.2

Quoted 1 line · Ramalingam C

Add the HDCP2.2 initialization to the existing HDCP1.4 stack.

With the comments below addressed the commit message is a bit untrue, since this just wires up a basic hdcp2_supported flag in a few places. Please make that clear.

Quoted 39 lines

v2:
mei interface handle is protected with mutex. [Chris Wilson]
v3:
Notifiers are used for the mei interface state.
v4:
Poll for mei client device state
Error msg for out of mem [Uma]
Inline req for init function removed [Uma]
v5:
Rebase as Part of reordering.
Component is used for the I915 and MEI_HDCP interface [Daniel]
v6:
HDCP2.2 uses the I915 component master to communicate with mei_hdcp
- [Daniel]
Required HDCP2.2 variables defined [Sean Paul]
v7:
intel_hdcp2.2_init returns void [Uma]
Realigning the codes.
v8:
Avoid using bool structure members.
MEI interface related changes are moved into separate patch. Commit msg is updated accordingly.
intel_hdcp_exit is defined and used from i915_unload

---
 drivers/gpu/drm/i915/i915_drv.c   |   2 +
 drivers/gpu/drm/i915/intel_dp.c   |   3 +-
 drivers/gpu/drm/i915/intel_drv.h  |  16 +++-
 drivers/gpu/drm/i915/intel_hdcp.c | 172 ++++++++++++++++++++++++--------------
 drivers/gpu/drm/i915/intel_hdmi.c |   2 +-
 5 files changed, 130 insertions(+), 65 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +0 -0
index b1d23c73c147..fbedd5024afe 100644

drivers/gpu/drm/i915/i915_drv.c void i915_driver_unload(struct drm_device *dev) · line 1758

Quoted 4 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
@@ -1755,6 +1755,8 @@ void i915_driver_unload(struct drm_device *dev)
 
 	disable_rpm_wakeref_asserts(dev_priv);
 
+	intel_hdcp_exit(dev_priv);

This smells like a separate patch. Needs to be split out. Looking at the implementation of intel_hdcp_exit I think it's papering over some unload trouble. We should be shutting down all the outputs on driver unload, which mei should be triggering (with the component stuff), which means this code should be unecessary. But I'm not sure.

Either way needs to be split out, but I think proper solution is to drop it.

Quoted 62 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
+
 	i915_driver_unregister(dev_priv);
 
 	if (i915_gem_suspend(dev_priv))
drivers/gpu/drm/i915/intel_dp.c +2 -1
index 18e3a5a3d873..ac62af073688 100644
@@ -6675,7 +6675,8 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
 	intel_dp_add_properties(intel_dp, connector);
 
 	if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
-		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim);
+		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim,
+					  false);
 		if (ret)
 			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
 	}
drivers/gpu/drm/i915/intel_drv.h +15 -1
index a62d77b76291..85a526598096 100644
@@ -388,6 +388,17 @@ struct intel_hdcp {
 	u64 value;
 	struct delayed_work check_work;
 	struct work_struct prop_work;
+
+	/* HDCP2.2 related definitions */
+	/* Flag indicates whether this connector supports HDCP2.2 or not. */
+	u8 hdcp2_supported;
+
+	/*
+	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
+	 * flow in the link protected by HDCP2.2 or HDCP1.4, where as TYPE1(0x1)
+	 * content can flow only through a link protected by HDCP2.2.
+	 */
+	u8 content_type;
 };
 
 struct intel_connector {
@@ -2016,12 +2027,15 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
 			     struct drm_connector_state *old_state,
 			     struct drm_connector_state *new_state);
 int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *hdcp_shim);
+		    const struct intel_hdcp_shim *hdcp_shim,
+		    bool hdcp2_supported);
 int intel_hdcp_enable(struct intel_connector *connector);
 int intel_hdcp_disable(struct intel_connector *connector);
 int intel_hdcp_check_link(struct intel_connector *connector);
 bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port);
 bool intel_hdcp_capable(struct intel_connector *connector);
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv);
+void intel_hdcp_exit(struct drm_i915_private *dev_priv);
 
 /* intel_psr.c */
 #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) && dev_priv->psr.sink_support)
drivers/gpu/drm/i915/intel_hdcp.c +0 -0
index 04ba6c13e715..99dddb540958 100644

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp) · line 734

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
@@ -730,6 +730,65 @@ struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)
 	return container_of(hdcp, struct intel_connector, hdcp);
 }
 
+/* Implements Part 3 of the HDCP authorization procedure */
+int intel_hdcp_check_link(struct intel_connector *connector)

Spurious movement of this function. Please drop, or if you need this function moved, split it out into a separate patch that only moves the function around.

Quoted 204 lines
drivers/gpu/drm/i915/intel_hdcp.c +108 -62
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	enum port port = intel_dig_port->base.port;
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
+		DRM_ERROR("%s:%d HDCP check failed: link is not encrypted,%x\n",
+			  connector->base.name, connector->base.base.id,
+			  I915_READ(PORT_HDCP_STATUS(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	if (hdcp->shim->check_link(intel_dig_port)) {
+		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp_disable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp_enable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
 static void intel_hdcp_check_work(struct work_struct *work)
 {
 	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
@@ -774,14 +833,34 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
 		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
 }
 
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
+{
+	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
+		 IS_KABYLAKE(dev_priv)) && IS_ENABLED(CONFIG_INTEL_MEI_HDCP));
+}
+
+static void intel_hdcp2_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+
+	WARN_ON(!is_hdcp2_supported(dev_priv));
+
+	/* TODO: MEI interface needs to be initialized here */
+	hdcp->hdcp2_supported = 1;
+}
+
 int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *shim)
+		    const struct intel_hdcp_shim *shim,
+		    bool hdcp2_supported)
 {
 	struct intel_hdcp *hdcp = &connector->hdcp;
 	int ret;
 
-	ret = drm_connector_attach_content_protection_property(
-			&connector->base);
+	if (!shim)
+		return -EINVAL;
+
+	ret = drm_connector_attach_content_protection_property(&connector->base);
 	if (ret)
 		return ret;
 
@@ -789,9 +868,37 @@ int intel_hdcp_init(struct intel_connector *connector,
 	mutex_init(&hdcp->mutex);
 	INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);
 	INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);
+
+	if (hdcp2_supported)
+		intel_hdcp2_init(connector);
+
 	return 0;
 }
 
+void intel_hdcp_exit(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+
+		if (!intel_connector->hdcp.shim)
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+
+		mutex_lock(&intel_connector->hdcp.mutex);
+		intel_connector->hdcp.hdcp2_supported = 0;
+		intel_connector->hdcp.shim = NULL;
+		mutex_unlock(&intel_connector->hdcp.mutex);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
 int intel_hdcp_enable(struct intel_connector *connector)
 {
 	struct intel_hdcp *hdcp = &connector->hdcp;
@@ -867,62 +974,3 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
 						   new_state->crtc);
 	crtc_state->mode_changed = true;
 }
-
-/* Implements Part 3 of the HDCP authorization procedure */
-int intel_hdcp_check_link(struct intel_connector *connector)
-{
-	struct intel_hdcp *hdcp = &connector->hdcp;
-	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
-	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
-	enum port port = intel_dig_port->base.port;
-	int ret = 0;
-
-	if (!hdcp->shim)
-		return -ENOENT;
-
-	mutex_lock(&hdcp->mutex);
-
-	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
-		goto out;
-
-	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
-		DRM_ERROR("%s:%d HDCP check failed: link is not encrypted,%x\n",
-			  connector->base.name, connector->base.base.id,
-			  I915_READ(PORT_HDCP_STATUS(port)));
-		ret = -ENXIO;
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	if (hdcp->shim->check_link(intel_dig_port)) {
-		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
-			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-			schedule_work(&hdcp->prop_work);
-		}
-		goto out;
-	}
-
-	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
-		      connector->base.name, connector->base.base.id);
-
-	ret = _intel_hdcp_disable(connector);
-	if (ret) {
-		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	ret = _intel_hdcp_enable(connector);
-	if (ret) {
-		DRM_DEBUG_KMS("Failed to enable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-out:
-	mutex_unlock(&hdcp->mutex);
-	return ret;
-}
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
index e2c6a2b3e8f2..e755a3370bca 100644

drivers/gpu/drm/i915/intel_hdmi.c void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port, · line 2422

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdmi.c +1 -1
@@ -2417,7 +2417,7 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
 
 	if (is_hdcp_supported(dev_priv, port)) {
 		int ret = intel_hdcp_init(intel_connector,
-					  &intel_hdmi_hdcp_shim);
+					  &intel_hdmi_hdcp_shim, false);
 		if (ret)
 			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");

The actual change left to wire hdcp2_supported seems ok with me, but hard to tell without seeing more yet :-)
-Daniel

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
 	}
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#10 lore raw

Re: [PATCH v8 04/35] drm/i915: Initialize HDCP2.2

Quoted 54 lines · Daniel Vetter
Quoted 1 line · Ramalingam C

Add the HDCP2.2 initialization to the existing HDCP1.4 stack.

With the comments below addressed the commit message is a bit untrue, since this just wires up a basic hdcp2_supported flag in a few places. Please make that clear.

Quoted 38 lines

v2:
mei interface handle is protected with mutex. [Chris Wilson]
v3:
Notifiers are used for the mei interface state.
v4:
Poll for mei client device state
Error msg for out of mem [Uma]
Inline req for init function removed [Uma]
v5:
Rebase as Part of reordering.
Component is used for the I915 and MEI_HDCP interface [Daniel]
v6:
HDCP2.2 uses the I915 component master to communicate with mei_hdcp
- [Daniel]
Required HDCP2.2 variables defined [Sean Paul]
v7:
intel_hdcp2.2_init returns void [Uma]
Realigning the codes.
v8:
Avoid using bool structure members.
MEI interface related changes are moved into separate patch. Commit msg is updated accordingly.
intel_hdcp_exit is defined and used from i915_unload

---
  drivers/gpu/drm/i915/i915_drv.c   |   2 +
  drivers/gpu/drm/i915/intel_dp.c   |   3 +-
  drivers/gpu/drm/i915/intel_drv.h  |  16 +++-
  drivers/gpu/drm/i915/intel_hdcp.c | 172 ++++++++++++++++++++++++--------------
  drivers/gpu/drm/i915/intel_hdmi.c |   2 +-
  5 files changed, 130 insertions(+), 65 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +0 -0
index b1d23c73c147..fbedd5024afe 100644

drivers/gpu/drm/i915/i915_drv.c void i915_driver_unload(struct drm_device *dev) · line 1758

Quoted 4 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
@@ -1755,6 +1755,8 @@ void i915_driver_unload(struct drm_device *dev)
 
  	disable_rpm_wakeref_asserts(dev_priv);
 
+	intel_hdcp_exit(dev_priv);

This smells like a separate patch. Needs to be split out. Looking at the implementation of intel_hdcp_exit I think it's papering over some unload trouble. We should be shutting down all the outputs on driver unload, which mei should be triggering (with the component stuff), which means this code should be unecessary. But I'm not sure.

Quoted 2 lines

Either way needs to be split out, but I think proper solution is to drop it.

As we discussed, during v7-->v8 i changed the component usage such that it wont affect i915 load/unload. During the first connector init, component master will be added. And during the mei_client dev and driver binding, component will be added hence the binding will happen with interface initialization from mei.

Upon HDCP2.2 request, component binding will be checked before attempting for HDCP2.2 auth.
So component master unbind triggered due to mei component_del, will teardown the HDCP2.2 capability of the I915.

So in case of I915 unload trigger, from whatsoever reason, we need to clear the HDCP activities and bring down the i915_hdcp_component_master and the interface with mei. For this purpose only intel_hdcp_exit is written here.

Quoted 66 lines
Quoted 66 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
+
  	i915_driver_unregister(dev_priv);
 
  	if (i915_gem_suspend(dev_priv))
drivers/gpu/drm/i915/intel_dp.c +2 -1
index 18e3a5a3d873..ac62af073688 100644
@@ -6675,7 +6675,8 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
  	intel_dp_add_properties(intel_dp, connector);
 
  	if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
-		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim);
+		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim,
+					  false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
  	}
drivers/gpu/drm/i915/intel_drv.h +15 -1
index a62d77b76291..85a526598096 100644
@@ -388,6 +388,17 @@ struct intel_hdcp {
  	u64 value;
  	struct delayed_work check_work;
  	struct work_struct prop_work;
+
+	/* HDCP2.2 related definitions */
+	/* Flag indicates whether this connector supports HDCP2.2 or not. */
+	u8 hdcp2_supported;
+
+	/*
+	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
+	 * flow in the link protected by HDCP2.2 or HDCP1.4, where as TYPE1(0x1)
+	 * content can flow only through a link protected by HDCP2.2.
+	 */
+	u8 content_type;
  };
 
  struct intel_connector {
@@ -2016,12 +2027,15 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
  			     struct drm_connector_state *old_state,
  			     struct drm_connector_state *new_state);
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *hdcp_shim);
+		    const struct intel_hdcp_shim *hdcp_shim,
+		    bool hdcp2_supported);
  int intel_hdcp_enable(struct intel_connector *connector);
  int intel_hdcp_disable(struct intel_connector *connector);
  int intel_hdcp_check_link(struct intel_connector *connector);
  bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port);
  bool intel_hdcp_capable(struct intel_connector *connector);
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv);
+void intel_hdcp_exit(struct drm_i915_private *dev_priv);
 
  /* intel_psr.c */
  #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) && dev_priv->psr.sink_support)
drivers/gpu/drm/i915/intel_hdcp.c +0 -0
index 04ba6c13e715..99dddb540958 100644
@@ -730,6 +730,65 @@ struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)
  	return container_of(hdcp, struct intel_connector, hdcp);
  }
 
Quoted 5 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp) · line 734

Quoted 2 lines
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
+/* Implements Part 3 of the HDCP authorization procedure */
+int intel_hdcp_check_link(struct intel_connector *connector)

Spurious movement of this function. Please drop, or if you need this function moved, split it out into a separate patch that only moves the function around.

Intention is gathering the hdcp1.4 functions together before implementing the hdcp2.2 code. But as you mentioned i will do it as a separate patch.

--Ram

Quoted 205 lines
Quoted 205 lines
drivers/gpu/drm/i915/intel_hdcp.c +108 -62
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	enum port port = intel_dig_port->base.port;
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
+		DRM_ERROR("%s:%d HDCP check failed: link is not encrypted,%x\n",
+			  connector->base.name, connector->base.base.id,
+			  I915_READ(PORT_HDCP_STATUS(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	if (hdcp->shim->check_link(intel_dig_port)) {
+		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp_disable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp_enable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
  static void intel_hdcp_check_work(struct work_struct *work)
  {
  	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
@@ -774,14 +833,34 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
 
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
+{
+	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
+		 IS_KABYLAKE(dev_priv)) && IS_ENABLED(CONFIG_INTEL_MEI_HDCP));
+}
+
+static void intel_hdcp2_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+
+	WARN_ON(!is_hdcp2_supported(dev_priv));
+
+	/* TODO: MEI interface needs to be initialized here */
+	hdcp->hdcp2_supported = 1;
+}
+
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *shim)
+		    const struct intel_hdcp_shim *shim,
+		    bool hdcp2_supported)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
  	int ret;
 
-	ret = drm_connector_attach_content_protection_property(
-			&connector->base);
+	if (!shim)
+		return -EINVAL;
+
+	ret = drm_connector_attach_content_protection_property(&connector->base);
  	if (ret)
  		return ret;
 
@@ -789,9 +868,37 @@ int intel_hdcp_init(struct intel_connector *connector,
  	mutex_init(&hdcp->mutex);
  	INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);
  	INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);
+
+	if (hdcp2_supported)
+		intel_hdcp2_init(connector);
+
  	return 0;
  }
 
+void intel_hdcp_exit(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+
+		if (!intel_connector->hdcp.shim)
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+
+		mutex_lock(&intel_connector->hdcp.mutex);
+		intel_connector->hdcp.hdcp2_supported = 0;
+		intel_connector->hdcp.shim = NULL;
+		mutex_unlock(&intel_connector->hdcp.mutex);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
  int intel_hdcp_enable(struct intel_connector *connector)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
@@ -867,62 +974,3 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
  						   new_state->crtc);
  	crtc_state->mode_changed = true;
  }
-
-/* Implements Part 3 of the HDCP authorization procedure */
-int intel_hdcp_check_link(struct intel_connector *connector)
-{
-	struct intel_hdcp *hdcp = &connector->hdcp;
-	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
-	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
-	enum port port = intel_dig_port->base.port;
-	int ret = 0;
-
-	if (!hdcp->shim)
-		return -ENOENT;
-
-	mutex_lock(&hdcp->mutex);
-
-	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
-		goto out;
-
-	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
-		DRM_ERROR("%s:%d HDCP check failed: link is not encrypted,%x\n",
-			  connector->base.name, connector->base.base.id,
-			  I915_READ(PORT_HDCP_STATUS(port)));
-		ret = -ENXIO;
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	if (hdcp->shim->check_link(intel_dig_port)) {
-		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
-			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-			schedule_work(&hdcp->prop_work);
-		}
-		goto out;
-	}
-
-	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
-		      connector->base.name, connector->base.base.id);
-
-	ret = _intel_hdcp_disable(connector);
-	if (ret) {
-		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	ret = _intel_hdcp_enable(connector);
-	if (ret) {
-		DRM_DEBUG_KMS("Failed to enable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-out:
-	mutex_unlock(&hdcp->mutex);
-	return ret;
-}
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
index e2c6a2b3e8f2..e755a3370bca 100644
@@ -2417,7 +2417,7 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
 
Quoted 14 lines

drivers/gpu/drm/i915/intel_hdmi.c void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port, · line 2422

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdmi.c +1 -1
  	if (is_hdcp_supported(dev_priv, port)) {
  		int ret = intel_hdcp_init(intel_connector,
-					  &intel_hdmi_hdcp_shim);
+					  &intel_hdmi_hdcp_shim, false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");

The actual change left to wire hdcp2_supported seems ok with me, but hard to tell without seeing more yet :-)
-Daniel

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
  	}
Signature · 1 line
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#11 lore raw

Re: [PATCH v8 04/35] drm/i915: Initialize HDCP2.2

Quoted 61 lines · Ramalingam
Quoted 52 lines · Daniel Vetter
Quoted 1 line · Ramalingam C

Add the HDCP2.2 initialization to the existing HDCP1.4 stack.

With the comments below addressed the commit message is a bit untrue, since this just wires up a basic hdcp2_supported flag in a few places. Please make that clear.

Quoted 38 lines

v2:
mei interface handle is protected with mutex. [Chris Wilson]
v3:
Notifiers are used for the mei interface state.
v4:
Poll for mei client device state
Error msg for out of mem [Uma]
Inline req for init function removed [Uma]
v5:
Rebase as Part of reordering.
Component is used for the I915 and MEI_HDCP interface [Daniel]
v6:
HDCP2.2 uses the I915 component master to communicate with mei_hdcp
- [Daniel]
Required HDCP2.2 variables defined [Sean Paul]
v7:
intel_hdcp2.2_init returns void [Uma]
Realigning the codes.
v8:
Avoid using bool structure members.
MEI interface related changes are moved into separate patch. Commit msg is updated accordingly.
intel_hdcp_exit is defined and used from i915_unload

---
  drivers/gpu/drm/i915/i915_drv.c   |   2 +
  drivers/gpu/drm/i915/intel_dp.c   |   3 +-
  drivers/gpu/drm/i915/intel_drv.h  |  16 +++-
  drivers/gpu/drm/i915/intel_hdcp.c | 172 ++++++++++++++++++++++++--------------
  drivers/gpu/drm/i915/intel_hdmi.c |   2 +-
  5 files changed, 130 insertions(+), 65 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +0 -0
index b1d23c73c147..fbedd5024afe 100644

drivers/gpu/drm/i915/i915_drv.c void i915_driver_unload(struct drm_device *dev) · line 1756

Quoted 2 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
@@ -1755,6 +1755,8 @@ void i915_driver_unload(struct drm_device *dev)
  	disable_rpm_wakeref_asserts(dev_priv);
+	intel_hdcp_exit(dev_priv);

This smells like a separate patch. Needs to be split out. Looking at the implementation of intel_hdcp_exit I think it's papering over some unload trouble. We should be shutting down all the outputs on driver unload, which mei should be triggering (with the component stuff), which means this code should be unecessary. But I'm not sure.

Quoted 2 lines

Either way needs to be split out, but I think proper solution is to drop it.

As we discussed, during v7-->v8 i changed the component usage such that it wont affect i915 load/unload. During the first connector init, component master will be added. And during the mei_client dev and driver binding, component will be added hence the binding will happen with interface initialization from mei.

Quoted 5 lines

Upon HDCP2.2 request, component binding will be checked before attempting for HDCP2.2 auth.
So component master unbind triggered due to mei component_del, will teardown the HDCP2.2 capability of the I915.

So in case of I915 unload trigger, from whatsoever reason, we need to clear the HDCP activities and bring down the i915_hdcp_component_master and the interface with mei. For this purpose only intel_hdcp_exit is written here.

Summarizing our irc discussion:

- I like the component usage of v7 much more.

- I still don't think we have a use-case for loading/unloading mei_hdcp on demand, or at least not in lockstep with i915.ko:
- CrOS won't use ME
- usual linux distros don't care about content protection, so won't even enable the MEI_HDCP driver
- iotg/embedded either wants it (and then probably always) or doesn't want it (in which case it won't be built in). Plus embedded tends to have all built-in drivers anyway, so they all load in order.

And I don't want to review the validation coverage and locking and runtime consequences of making this possible, since I'm lazy :-)

- I looked lockdep splat in v7 again in more detail. It's not actually an issue with component usage, but just unlucky to now run into a preexisting issue: Any driver you unbind through the sysfs file will generate a lockdep splat if it removes any sysfs files itself. That's a pre-existing bug, easily reproduced by unbinding i915.

Only thing new is that component connects the snd-hda-intel and i915 unload sequence through the component lock (but does _not_ create a loop), and since we unbind snd-hda-intel through sysfs and i919 unregisters _lots_ of sysfs files lockdep now sees the cycle. It's always been there.

I'm working on a separate patch to fix this.

Cheers, Daniel

Quoted 68 lines
Quoted 59 lines
Quoted 59 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
+
  	i915_driver_unregister(dev_priv);
  	if (i915_gem_suspend(dev_priv))
drivers/gpu/drm/i915/intel_dp.c +2 -1
index 18e3a5a3d873..ac62af073688 100644
@@ -6675,7 +6675,8 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
  	intel_dp_add_properties(intel_dp, connector);
  	if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
-		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim);
+		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim,
+					  false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
  	}
drivers/gpu/drm/i915/intel_drv.h +15 -1
index a62d77b76291..85a526598096 100644
@@ -388,6 +388,17 @@ struct intel_hdcp {
  	u64 value;
  	struct delayed_work check_work;
  	struct work_struct prop_work;
+
+	/* HDCP2.2 related definitions */
+	/* Flag indicates whether this connector supports HDCP2.2 or not. */
+	u8 hdcp2_supported;
+
+	/*
+	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
+	 * flow in the link protected by HDCP2.2 or HDCP1.4, where as TYPE1(0x1)
+	 * content can flow only through a link protected by HDCP2.2.
+	 */
+	u8 content_type;
  };
  struct intel_connector {
@@ -2016,12 +2027,15 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
  			     struct drm_connector_state *old_state,
  			     struct drm_connector_state *new_state);
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *hdcp_shim);
+		    const struct intel_hdcp_shim *hdcp_shim,
+		    bool hdcp2_supported);
  int intel_hdcp_enable(struct intel_connector *connector);
  int intel_hdcp_disable(struct intel_connector *connector);
  int intel_hdcp_check_link(struct intel_connector *connector);
  bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port);
  bool intel_hdcp_capable(struct intel_connector *connector);
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv);
+void intel_hdcp_exit(struct drm_i915_private *dev_priv);
  /* intel_psr.c */
  #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) && dev_priv->psr.sink_support)
drivers/gpu/drm/i915/intel_hdcp.c +0 -0
index 04ba6c13e715..99dddb540958 100644
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp) · line 733

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
@@ -730,6 +730,65 @@ struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)
  	return container_of(hdcp, struct intel_connector, hdcp);
  }
+/* Implements Part 3 of the HDCP authorization procedure */
+int intel_hdcp_check_link(struct intel_connector *connector)

Spurious movement of this function. Please drop, or if you need this function moved, split it out into a separate patch that only moves the function around.

Quoted 2 lines

Intention is gathering the hdcp1.4 functions together before implementing the hdcp2.2 code. But as you mentioned i will do it as a separate patch.

Ah yeah that makes sense, but commit message didn't explain that. Separate patch sounds good.
-Daniel

Quoted 217 lines

--Ram

Quoted 214 lines
Quoted 200 lines
drivers/gpu/drm/i915/intel_hdcp.c +108 -62
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	enum port port = intel_dig_port->base.port;
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
+		DRM_ERROR("%s:%d HDCP check failed: link is not encrypted,%x\n",
+			  connector->base.name, connector->base.base.id,
+			  I915_READ(PORT_HDCP_STATUS(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	if (hdcp->shim->check_link(intel_dig_port)) {
+		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp_disable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp_enable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
  static void intel_hdcp_check_work(struct work_struct *work)
  {
  	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
@@ -774,14 +833,34 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
+{
+	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
+		 IS_KABYLAKE(dev_priv)) && IS_ENABLED(CONFIG_INTEL_MEI_HDCP));
+}
+
+static void intel_hdcp2_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+
+	WARN_ON(!is_hdcp2_supported(dev_priv));
+
+	/* TODO: MEI interface needs to be initialized here */
+	hdcp->hdcp2_supported = 1;
+}
+
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *shim)
+		    const struct intel_hdcp_shim *shim,
+		    bool hdcp2_supported)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
  	int ret;
-	ret = drm_connector_attach_content_protection_property(
-			&connector->base);
+	if (!shim)
+		return -EINVAL;
+
+	ret = drm_connector_attach_content_protection_property(&connector->base);
  	if (ret)
  		return ret;
@@ -789,9 +868,37 @@ int intel_hdcp_init(struct intel_connector *connector,
  	mutex_init(&hdcp->mutex);
  	INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);
  	INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);
+
+	if (hdcp2_supported)
+		intel_hdcp2_init(connector);
+
  	return 0;
  }
+void intel_hdcp_exit(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+
+		if (!intel_connector->hdcp.shim)
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+
+		mutex_lock(&intel_connector->hdcp.mutex);
+		intel_connector->hdcp.hdcp2_supported = 0;
+		intel_connector->hdcp.shim = NULL;
+		mutex_unlock(&intel_connector->hdcp.mutex);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
  int intel_hdcp_enable(struct intel_connector *connector)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
@@ -867,62 +974,3 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
  						   new_state->crtc);
  	crtc_state->mode_changed = true;
  }
-
-/* Implements Part 3 of the HDCP authorization procedure */
-int intel_hdcp_check_link(struct intel_connector *connector)
-{
-	struct intel_hdcp *hdcp = &connector->hdcp;
-	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
-	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
-	enum port port = intel_dig_port->base.port;
-	int ret = 0;
-
-	if (!hdcp->shim)
-		return -ENOENT;
-
-	mutex_lock(&hdcp->mutex);
-
-	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
-		goto out;
-
-	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
-		DRM_ERROR("%s:%d HDCP check failed: link is not encrypted,%x\n",
-			  connector->base.name, connector->base.base.id,
-			  I915_READ(PORT_HDCP_STATUS(port)));
-		ret = -ENXIO;
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	if (hdcp->shim->check_link(intel_dig_port)) {
-		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
-			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-			schedule_work(&hdcp->prop_work);
-		}
-		goto out;
-	}
-
-	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
-		      connector->base.name, connector->base.base.id);
-
-	ret = _intel_hdcp_disable(connector);
-	if (ret) {
-		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	ret = _intel_hdcp_enable(connector);
-	if (ret) {
-		DRM_DEBUG_KMS("Failed to enable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-out:
-	mutex_unlock(&hdcp->mutex);
-	return ret;
-}
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
index e2c6a2b3e8f2..e755a3370bca 100644

drivers/gpu/drm/i915/intel_hdmi.c void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port, · line 2421

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdmi.c +1 -1
@@ -2417,7 +2417,7 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
  	if (is_hdcp_supported(dev_priv, port)) {
  		int ret = intel_hdcp_init(intel_connector,
-					  &intel_hdmi_hdcp_shim);
+					  &intel_hdmi_hdcp_shim, false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");

The actual change left to wire hdcp2_supported seems ok with me, but hard to tell without seeing more yet :-)
-Daniel

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
  	}
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#12 lore raw

Re: [PATCH v8 04/35] drm/i915: Initialize HDCP2.2

Quoted 90 lines

-----Original Message-----
From: Daniel Vetter [mailto:[email protected]] On Behalf Of Daniel Vetter
Sent: Friday, December 07, 2018 16:17
To: C, Ramalingam <[email protected]>
Cc: Daniel Vetter <[email protected]>; [email protected]; dri- [email protected]; [email protected]; Winkler, Tomas <[email protected]>; Shankar, Uma <[email protected]>
Subject: Re: [PATCH v8 04/35] drm/i915: Initialize HDCP2.2

Quoted 6 lines · Ramalingam
Quoted 4 lines · Daniel Vetter
Quoted 1 line · Ramalingam C

Add the HDCP2.2 initialization to the existing HDCP1.4 stack.

With the comments below addressed the commit message is a bit untrue, since this just wires up a basic hdcp2_supported flag in a few

places.

Quoted 15 lines
Quoted 15 lines

Please make that clear.

Quoted 13 lines

v2:
mei interface handle is protected with mutex. [Chris Wilson]
v3:
Notifiers are used for the mei interface state.
v4:
Poll for mei client device state
Error msg for out of mem [Uma]
Inline req for init function removed [Uma]
v5:
Rebase as Part of reordering.
Component is used for the I915 and MEI_HDCP interface [Daniel]
v6:
HDCP2.2 uses the I915 component master to communicate with

mei_hdcp

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

- [Daniel]
Required HDCP2.2 variables defined [Sean Paul]
v7:
intel_hdcp2.2_init returns void [Uma]
Realigning the codes.
v8:
Avoid using bool structure members.
MEI interface related changes are moved into separate patch. Commit msg is updated accordingly.
intel_hdcp_exit is defined and used from i915_unload

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
---
  drivers/gpu/drm/i915/i915_drv.c   |   2 +
  drivers/gpu/drm/i915/intel_dp.c   |   3 +-
  drivers/gpu/drm/i915/intel_drv.h  |  16 +++-
  drivers/gpu/drm/i915/intel_hdcp.c | 172 ++++++++++++++++++++++++--

------------

Quoted 9 lines
Quoted 9 lines

drivers/gpu/drm/i915/i915_drv.c void i915_driver_unload(struct drm_device

Quoted 9 lines
  drivers/gpu/drm/i915/intel_hdmi.c |   2 +-
  5 files changed, 130 insertions(+), 65 deletions(-)
(quoted diff) +0 -0

b/drivers/gpu/drm/i915/i915_drv.c index b1d23c73c147..fbedd5024afe 100644

drivers/gpu/drm/i915/i915_drv.c +0 -0
@@ -1755,6 +1755,8 @@ void i915_driver_unload(struct drm_device

*dev)

Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/i915_drv.c void i915_driver_unload(struct drm_device *dev) · line 1758

Quoted 2 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
  	disable_rpm_wakeref_asserts(dev_priv);
+	intel_hdcp_exit(dev_priv);

This smells like a separate patch. Needs to be split out. Looking at the implementation of intel_hdcp_exit I think it's papering over some unload trouble. We should be shutting down all the outputs on driver unload, which mei should be triggering (with the component stuff), which means this code should be unecessary. But I'm not sure.

Quoted 4 lines
Quoted 2 lines

Either way needs to be split out, but I think proper solution is to drop it.

As we discussed, during v7-->v8 i changed the component usage such that it

wont affect i915 load/unload.

Quoted 2 lines

During the first connector init, component master will be added. And during the mei_client dev and driver binding, component will be added hence

the binding will happen with interface initialization from mei.

Quoted 2 lines

Upon HDCP2.2 request, component binding will be checked before

attempting for HDCP2.2 auth.

Quoted 1 line

So component master unbind triggered due to mei component_del, will

teardown the HDCP2.2 capability of the I915.

Quoted 3 lines

So in case of I915 unload trigger, from whatsoever reason, we need to clear the HDCP activities and bring down the i915_hdcp_component_master

and the interface with mei. For this purpose only intel_hdcp_exit is written here.

Quoted 6 lines

Summarizing our irc discussion:

- I like the component usage of v7 much more.

- I still don't think we have a use-case for loading/unloading mei_hdcp on demand, or at least not in lockstep with i915.ko:

We are testing all the MEI modules reloading, this would be suddenly an exception.

Quoted 1 line

- CrOS won't use ME

I'm not so sure, we are working on it.

Quoted 5 lines

- usual linux distros don't care about content protection, so won't even enable the MEI_HDCP driver
- iotg/embedded either wants it (and then probably always) or doesn't want it (in which case it won't be built in). Plus embedded tends to have all built-in drivers anyway, so they all load in order.

It really depends, there product range si really wide.

Quoted 338 lines

And I don't want to review the validation coverage and locking and runtime consequences of making this possible, since I'm lazy :-)

- I looked lockdep splat in v7 again in more detail. It's not actually an issue with component usage, but just unlucky to now run into a preexisting issue: Any driver you unbind through the sysfs file will generate a lockdep splat if it removes any sysfs files itself. That's a pre-existing bug, easily reproduced by unbinding i915.

Only thing new is that component connects the snd-hda-intel and i915 unload sequence through the component lock (but does _not_ create a loop), and since we unbind snd-hda-intel through sysfs and i919 unregisters _lots_ of sysfs files lockdep now sees the cycle. It's always been there.

I'm working on a separate patch to fix this.

Cheers, Daniel

Quoted 11 lines
Quoted 11 lines

drivers/gpu/drm/i915/intel_dp.c intel_dp_init_connector(struct

Quoted 11 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
+
  	i915_driver_unregister(dev_priv);
  	if (i915_gem_suspend(dev_priv)) diff --git

a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c index 18e3a5a3d873..ac62af073688 100644

drivers/gpu/drm/i915/intel_dp.c +0 -0
@@ -6675,7 +6675,8 @@ intel_dp_init_connector(struct

intel_digital_port *intel_dig_port,

Quoted 3 lines
Quoted 3 lines

drivers/gpu/drm/i915/intel_dp.c intel_dp_init_connector(struct intel_digital_port *intel_dig_port,

Quoted 3 lines
drivers/gpu/drm/i915/intel_dp.c +0 -1
  	intel_dp_add_properties(intel_dp, connector);
  	if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
-		int ret = intel_hdcp_init(intel_connector,

&intel_dp_hdcp_shim);

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_dp.c intel_dp_init_connector(struct · line 6677

Quoted 1 line
drivers/gpu/drm/i915/intel_dp.c +1 -0
+		int ret = intel_hdcp_init(intel_connector,

&intel_dp_hdcp_shim,

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
drivers/gpu/drm/i915/intel_dp.c +1 -0
+					  false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
  	}
drivers/gpu/drm/i915/intel_drv.h +0 -0
index a62d77b76291..85a526598096 100644
@@ -388,6 +388,17 @@ struct intel_hdcp {
  	u64 value;
  	struct delayed_work check_work;
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp {

Quoted 8 lines
drivers/gpu/drm/i915/intel_drv.h +7 -0
  	struct work_struct prop_work;
+
+	/* HDCP2.2 related definitions */
+	/* Flag indicates whether this connector supports HDCP2.2 or not. */
+	u8 hdcp2_supported;
+
+	/*
+	 * Content Stream Type defined by content owner. TYPE0(0x0) content

can

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp { · line 398

Quoted 1 line
drivers/gpu/drm/i915/intel_drv.h +1 -0
+	 * flow in the link protected by HDCP2.2 or HDCP1.4, where as

TYPE1(0x1)

Quoted 6 lines
Quoted 6 lines

drivers/gpu/drm/i915/intel_drv.h void intel_hdcp_atomic_check(struct

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
+	 * content can flow only through a link protected by HDCP2.2.
+	 */
+	u8 content_type;
  };
  struct intel_connector {
@@ -2016,12 +2027,15 @@ void intel_hdcp_atomic_check(struct

drm_connector *connector,

Quoted 10 lines
Quoted 10 lines

drivers/gpu/drm/i915/intel_drv.h void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 10 lines
drivers/gpu/drm/i915/intel_drv.h +2 -1
  			     struct drm_connector_state *old_state,
  			     struct drm_connector_state *new_state);
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *hdcp_shim);
+		    const struct intel_hdcp_shim *hdcp_shim,
+		    bool hdcp2_supported);
  int intel_hdcp_enable(struct intel_connector *connector);
  int intel_hdcp_disable(struct intel_connector *connector);
  int intel_hdcp_check_link(struct intel_connector *connector);
  bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port

port);

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
drivers/gpu/drm/i915/intel_drv.h +2 -0
  bool intel_hdcp_capable(struct intel_connector *connector);
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv); void
+intel_hdcp_exit(struct drm_i915_private *dev_priv);
  /* intel_psr.c */
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector

Quoted 8 lines
drivers/gpu/drm/i915/intel_drv.h +0 -0
  #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) &&

dev_priv->psr.sink_support) diff --git
a/drivers/gpu/drm/i915/intel_hdcp.c
b/drivers/gpu/drm/i915/intel_hdcp.c
index 04ba6c13e715..99dddb540958 100644

drivers/gpu/drm/i915/intel_hdcp.c +0 -0
@@ -730,6 +730,65 @@ struct intel_connector

*intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 9 lines
Quoted 7 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
  	return container_of(hdcp, struct intel_connector, hdcp);
  }
+/* Implements Part 3 of the HDCP authorization procedure */ int
+intel_hdcp_check_link(struct intel_connector *connector)

Spurious movement of this function. Please drop, or if you need this function moved, split it out into a separate patch that only moves the function around.

Intention is gathering the hdcp1.4 functions together before implementing

the hdcp2.2 code.

Quoted 1 line

But as you mentioned i will do it as a separate patch.

Ah yeah that makes sense, but commit message didn't explain that. Separate patch sounds good.
-Daniel

Quoted 8 lines

--Ram

Quoted 3 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct drm_i915_private *dev_priv = connector->base.dev-

dev_private;

Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector · line 737

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	struct intel_digital_port *intel_dig_port =

conn_to_dig_port(connector);

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	enum port port = intel_dig_port->base.port;
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +8 -0
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
+		DRM_ERROR("%s:%d HDCP check failed: link is not

encrypted,%x\n",

Quoted 10 lines
Quoted 10 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+			  connector->base.name, connector->base.base.id,
+			  I915_READ(PORT_HDCP_STATUS(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	if (hdcp->shim->check_link(intel_dig_port)) {
+		if (hdcp->value !=

DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector · line 761

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+			hdcp->value =

DRM_MODE_CONTENT_PROTECTION_ENABLED;

Quoted 6 lines
Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying

authentication\n",

Quoted 19 lines
Quoted 19 lines
Quoted 19 lines
drivers/gpu/drm/i915/intel_hdcp.c +19 -0
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp_disable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp_enable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
  static void intel_hdcp_check_work(struct work_struct *work)
  {
  	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
@@ -774,14 +833,34 @@ bool is_hdcp_supported(struct

drm_i915_private *dev_priv, enum port port)

Quoted 5 lines
Quoted 5 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv) {
+	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
+		 IS_KABYLAKE(dev_priv)) &&

IS_ENABLED(CONFIG_INTEL_MEI_HDCP));

Quoted 22 lines
Quoted 22 lines
Quoted 22 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -3
+}
+
+static void intel_hdcp2_init(struct intel_connector *connector) {
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+
+	WARN_ON(!is_hdcp2_supported(dev_priv));
+
+	/* TODO: MEI interface needs to be initialized here */
+	hdcp->hdcp2_supported = 1;
+}
+
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *shim)
+		    const struct intel_hdcp_shim *shim,
+		    bool hdcp2_supported)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
  	int ret;
-	ret = drm_connector_attach_content_protection_property(
-			&connector->base);
+	if (!shim)
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c int intel_hdcp_init(struct intel_connector

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+		return -EINVAL;
+
+	ret =
+drm_connector_attach_content_protection_property(&connector->base
+);
  	if (ret)
  		return ret;
@@ -789,9 +868,37 @@ int intel_hdcp_init(struct intel_connector

*connector,

Quoted 45 lines
Quoted 36 lines
Quoted 36 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
  	mutex_init(&hdcp->mutex);
  	INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);
  	INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);
+
+	if (hdcp2_supported)
+		intel_hdcp2_init(connector);
+
  	return 0;
  }
+void intel_hdcp_exit(struct drm_i915_private *dev_priv) {
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+
+		if (!intel_connector->hdcp.shim)
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+
+		mutex_lock(&intel_connector->hdcp.mutex);
+		intel_connector->hdcp.hdcp2_supported = 0;
+		intel_connector->hdcp.shim = NULL;
+		mutex_unlock(&intel_connector->hdcp.mutex);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
  int intel_hdcp_enable(struct intel_connector *connector)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp; @@ -867,62 +974,3
 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -2
  						   new_state->crtc);
  	crtc_state->mode_changed = true;
  }
-
-/* Implements Part 3 of the HDCP authorization procedure */ -int

intel_hdcp_check_link(struct intel_connector *connector) -{

drivers/gpu/drm/i915/intel_hdcp.c +0 -2
-	struct intel_hdcp *hdcp = &connector->hdcp;
-	struct drm_i915_private *dev_priv = connector->base.dev-

dev_private;

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +0 -1
-	struct intel_digital_port *intel_dig_port =

conn_to_dig_port(connector);

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -5
-	enum port port = intel_dig_port->base.port;
-	int ret = 0;
-
-	if (!hdcp->shim)
-		return -ENOENT;
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -8
-
-	mutex_lock(&hdcp->mutex);
-
-	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
-		goto out;
-
-	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
-		DRM_ERROR("%s:%d HDCP check failed: link is not

encrypted,%x\n",

Quoted 10 lines
Quoted 10 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -10
-			  connector->base.name, connector->base.base.id,
-			  I915_READ(PORT_HDCP_STATUS(port)));
-		ret = -ENXIO;
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	if (hdcp->shim->check_link(intel_dig_port)) {
-		if (hdcp->value !=

DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +0 -1
-			hdcp->value =

DRM_MODE_CONTENT_PROTECTION_ENABLED;

Quoted 6 lines
Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -6
-			schedule_work(&hdcp->prop_work);
-		}
-		goto out;
-	}
-
-	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying

authentication\n",

Quoted 20 lines
Quoted 20 lines
Quoted 20 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -20
-		      connector->base.name, connector->base.base.id);
-
-	ret = _intel_hdcp_disable(connector);
-	if (ret) {
-		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	ret = _intel_hdcp_enable(connector);
-	if (ret) {
-		DRM_DEBUG_KMS("Failed to enable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-out:
-	mutex_unlock(&hdcp->mutex);
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdmi.c void intel_hdmi_init_connector(struct

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -2
-	return ret;
-}
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
index e2c6a2b3e8f2..e755a3370bca 100644
@@ -2417,7 +2417,7 @@ void intel_hdmi_init_connector(struct

intel_digital_port *intel_dig_port,

Quoted 9 lines
Quoted 9 lines

drivers/gpu/drm/i915/intel_hdmi.c void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port, · line 2422

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdmi.c +1 -1
  	if (is_hdcp_supported(dev_priv, port)) {
  		int ret = intel_hdcp_init(intel_connector,
-					  &intel_hdmi_hdcp_shim);
+					  &intel_hdmi_hdcp_shim, false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");

The actual change left to wire hdcp2_supported seems ok with me, but hard to tell without seeing more yet :-) -Daniel

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
drivers/gpu/drm/i915/intel_hdmi.c +0 -1
  	}
--

2.7.4

Quoted 4 lines

--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#13 lore raw

Re: [PATCH v8 04/35] drm/i915: Initialize HDCP2.2

Quoted 90 lines · Tomas
Quoted 90 lines

-----Original Message-----
From: Daniel Vetter [mailto:[email protected]] On Behalf Of Daniel Vetter
Sent: Friday, December 07, 2018 16:17
To: C, Ramalingam <[email protected]>
Cc: Daniel Vetter <[email protected]>; [email protected]; dri- [email protected]; [email protected]; Winkler, Tomas <[email protected]>; Shankar, Uma <[email protected]>
Subject: Re: [PATCH v8 04/35] drm/i915: Initialize HDCP2.2

Quoted 6 lines · Ramalingam
Quoted 4 lines · Daniel Vetter
Quoted 1 line · Ramalingam C

Add the HDCP2.2 initialization to the existing HDCP1.4 stack.

With the comments below addressed the commit message is a bit untrue, since this just wires up a basic hdcp2_supported flag in a few

places.

Quoted 15 lines
Quoted 15 lines

Please make that clear.

Quoted 13 lines

v2:
mei interface handle is protected with mutex. [Chris Wilson]
v3:
Notifiers are used for the mei interface state.
v4:
Poll for mei client device state
Error msg for out of mem [Uma]
Inline req for init function removed [Uma]
v5:
Rebase as Part of reordering.
Component is used for the I915 and MEI_HDCP interface [Daniel]
v6:
HDCP2.2 uses the I915 component master to communicate with

mei_hdcp

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

- [Daniel]
Required HDCP2.2 variables defined [Sean Paul]
v7:
intel_hdcp2.2_init returns void [Uma]
Realigning the codes.
v8:
Avoid using bool structure members.
MEI interface related changes are moved into separate patch. Commit msg is updated accordingly.
intel_hdcp_exit is defined and used from i915_unload

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
---
  drivers/gpu/drm/i915/i915_drv.c   |   2 +
  drivers/gpu/drm/i915/intel_dp.c   |   3 +-
  drivers/gpu/drm/i915/intel_drv.h  |  16 +++-
  drivers/gpu/drm/i915/intel_hdcp.c | 172 ++++++++++++++++++++++++--

------------

Quoted 9 lines
Quoted 9 lines

drivers/gpu/drm/i915/i915_drv.c void i915_driver_unload(struct drm_device

Quoted 9 lines
  drivers/gpu/drm/i915/intel_hdmi.c |   2 +-
  5 files changed, 130 insertions(+), 65 deletions(-)
(quoted diff) +0 -0

b/drivers/gpu/drm/i915/i915_drv.c index b1d23c73c147..fbedd5024afe 100644

drivers/gpu/drm/i915/i915_drv.c +0 -0
@@ -1755,6 +1755,8 @@ void i915_driver_unload(struct drm_device

*dev)

Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/i915_drv.c void i915_driver_unload(struct drm_device *dev) · line 1758

Quoted 2 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
  	disable_rpm_wakeref_asserts(dev_priv);
+	intel_hdcp_exit(dev_priv);

This smells like a separate patch. Needs to be split out. Looking at the implementation of intel_hdcp_exit I think it's papering over some unload trouble. We should be shutting down all the outputs on driver unload, which mei should be triggering (with the component stuff), which means this code should be unecessary. But I'm not sure.

Quoted 4 lines
Quoted 2 lines

Either way needs to be split out, but I think proper solution is to drop it.

As we discussed, during v7-->v8 i changed the component usage such that it

wont affect i915 load/unload.

Quoted 2 lines

During the first connector init, component master will be added. And during the mei_client dev and driver binding, component will be added hence

the binding will happen with interface initialization from mei.

Quoted 2 lines

Upon HDCP2.2 request, component binding will be checked before

attempting for HDCP2.2 auth.

Quoted 1 line

So component master unbind triggered due to mei component_del, will

teardown the HDCP2.2 capability of the I915.

Quoted 3 lines

So in case of I915 unload trigger, from whatsoever reason, we need to clear the HDCP activities and bring down the i915_hdcp_component_master

and the interface with mei. For this purpose only intel_hdcp_exit is written here.

Quoted 7 lines
Quoted 6 lines

Summarizing our irc discussion:

- I like the component usage of v7 much more.

- I still don't think we have a use-case for loading/unloading mei_hdcp on demand, or at least not in lockstep with i915.ko:

We are testing all the MEI modules reloading, this would be suddenly an exception.

We're doing the same. And with the component stuff you can do that too in a clean way. But there's a difference between a useful feature for developers and something we need in production.

What I mean here is that I don't see a use-case for unloading mei_hdcp, while i915 still needs to keep working. That's the only difference between v7 and v8 in features support wrt driver loading/unloading.

Quoted 2 lines
Quoted 1 line

- CrOS won't use ME

I'm not so sure, we are working on it.

Hm, that's interesting. We can't support HDCP2 on CrOS because of the ME thing, and I haven't heard anything new from CrOS kernel engineers. -Daniel

Quoted 349 lines
Quoted 5 lines

- usual linux distros don't care about content protection, so won't even enable the MEI_HDCP driver
- iotg/embedded either wants it (and then probably always) or doesn't want it (in which case it won't be built in). Plus embedded tends to have all built-in drivers anyway, so they all load in order.

It really depends, there product range si really wide.

Quoted 342 lines

And I don't want to review the validation coverage and locking and runtime consequences of making this possible, since I'm lazy :-)

- I looked lockdep splat in v7 again in more detail. It's not actually an issue with component usage, but just unlucky to now run into a preexisting issue: Any driver you unbind through the sysfs file will generate a lockdep splat if it removes any sysfs files itself. That's a pre-existing bug, easily reproduced by unbinding i915.

Only thing new is that component connects the snd-hda-intel and i915 unload sequence through the component lock (but does _not_ create a loop), and since we unbind snd-hda-intel through sysfs and i919 unregisters _lots_ of sysfs files lockdep now sees the cycle. It's always been there.

I'm working on a separate patch to fix this.

Cheers, Daniel

Quoted 11 lines
Quoted 11 lines

drivers/gpu/drm/i915/intel_dp.c intel_dp_init_connector(struct

Quoted 11 lines
drivers/gpu/drm/i915/i915_drv.c +1 -0
+
  	i915_driver_unregister(dev_priv);
  	if (i915_gem_suspend(dev_priv)) diff --git

a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c index 18e3a5a3d873..ac62af073688 100644

drivers/gpu/drm/i915/intel_dp.c +0 -0
@@ -6675,7 +6675,8 @@ intel_dp_init_connector(struct

intel_digital_port *intel_dig_port,

Quoted 3 lines
Quoted 3 lines

drivers/gpu/drm/i915/intel_dp.c intel_dp_init_connector(struct intel_digital_port *intel_dig_port,

Quoted 3 lines
drivers/gpu/drm/i915/intel_dp.c +0 -1
  	intel_dp_add_properties(intel_dp, connector);
  	if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
-		int ret = intel_hdcp_init(intel_connector,

&intel_dp_hdcp_shim);

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_dp.c intel_dp_init_connector(struct · line 6677

Quoted 1 line
drivers/gpu/drm/i915/intel_dp.c +1 -0
+		int ret = intel_hdcp_init(intel_connector,

&intel_dp_hdcp_shim,

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
drivers/gpu/drm/i915/intel_dp.c +1 -0
+					  false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
  	}
drivers/gpu/drm/i915/intel_drv.h +0 -0
index a62d77b76291..85a526598096 100644
@@ -388,6 +388,17 @@ struct intel_hdcp {
  	u64 value;
  	struct delayed_work check_work;
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp {

Quoted 8 lines
drivers/gpu/drm/i915/intel_drv.h +7 -0
  	struct work_struct prop_work;
+
+	/* HDCP2.2 related definitions */
+	/* Flag indicates whether this connector supports HDCP2.2 or not. */
+	u8 hdcp2_supported;
+
+	/*
+	 * Content Stream Type defined by content owner. TYPE0(0x0) content

can

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp { · line 398

Quoted 1 line
drivers/gpu/drm/i915/intel_drv.h +1 -0
+	 * flow in the link protected by HDCP2.2 or HDCP1.4, where as

TYPE1(0x1)

Quoted 6 lines
Quoted 6 lines

drivers/gpu/drm/i915/intel_drv.h void intel_hdcp_atomic_check(struct

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
+	 * content can flow only through a link protected by HDCP2.2.
+	 */
+	u8 content_type;
  };
  struct intel_connector {
@@ -2016,12 +2027,15 @@ void intel_hdcp_atomic_check(struct

drm_connector *connector,

Quoted 10 lines
Quoted 10 lines

drivers/gpu/drm/i915/intel_drv.h void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 10 lines
drivers/gpu/drm/i915/intel_drv.h +2 -1
  			     struct drm_connector_state *old_state,
  			     struct drm_connector_state *new_state);
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *hdcp_shim);
+		    const struct intel_hdcp_shim *hdcp_shim,
+		    bool hdcp2_supported);
  int intel_hdcp_enable(struct intel_connector *connector);
  int intel_hdcp_disable(struct intel_connector *connector);
  int intel_hdcp_check_link(struct intel_connector *connector);
  bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port

port);

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
drivers/gpu/drm/i915/intel_drv.h +2 -0
  bool intel_hdcp_capable(struct intel_connector *connector);
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv); void
+intel_hdcp_exit(struct drm_i915_private *dev_priv);
  /* intel_psr.c */
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector

Quoted 8 lines
drivers/gpu/drm/i915/intel_drv.h +0 -0
  #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) &&

dev_priv->psr.sink_support) diff --git
a/drivers/gpu/drm/i915/intel_hdcp.c
b/drivers/gpu/drm/i915/intel_hdcp.c
index 04ba6c13e715..99dddb540958 100644

drivers/gpu/drm/i915/intel_hdcp.c +0 -0
@@ -730,6 +730,65 @@ struct intel_connector

*intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 9 lines
Quoted 7 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
  	return container_of(hdcp, struct intel_connector, hdcp);
  }
+/* Implements Part 3 of the HDCP authorization procedure */ int
+intel_hdcp_check_link(struct intel_connector *connector)

Spurious movement of this function. Please drop, or if you need this function moved, split it out into a separate patch that only moves the function around.

Intention is gathering the hdcp1.4 functions together before implementing

the hdcp2.2 code.

Quoted 1 line

But as you mentioned i will do it as a separate patch.

Ah yeah that makes sense, but commit message didn't explain that. Separate patch sounds good.
-Daniel

Quoted 8 lines

--Ram

Quoted 3 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct drm_i915_private *dev_priv = connector->base.dev-

dev_private;

Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector · line 737

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	struct intel_digital_port *intel_dig_port =

conn_to_dig_port(connector);

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	enum port port = intel_dig_port->base.port;
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +8 -0
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
+		DRM_ERROR("%s:%d HDCP check failed: link is not

encrypted,%x\n",

Quoted 10 lines
Quoted 10 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+			  connector->base.name, connector->base.base.id,
+			  I915_READ(PORT_HDCP_STATUS(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	if (hdcp->shim->check_link(intel_dig_port)) {
+		if (hdcp->value !=

DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector · line 761

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+			hdcp->value =

DRM_MODE_CONTENT_PROTECTION_ENABLED;

Quoted 6 lines
Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying

authentication\n",

Quoted 19 lines
Quoted 19 lines
Quoted 19 lines
drivers/gpu/drm/i915/intel_hdcp.c +19 -0
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp_disable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp_enable(connector);
+	if (ret) {
+		DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
  static void intel_hdcp_check_work(struct work_struct *work)
  {
  	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
@@ -774,14 +833,34 @@ bool is_hdcp_supported(struct

drm_i915_private *dev_priv, enum port port)

Quoted 5 lines
Quoted 5 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
+bool is_hdcp2_supported(struct drm_i915_private *dev_priv) {
+	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
+		 IS_KABYLAKE(dev_priv)) &&

IS_ENABLED(CONFIG_INTEL_MEI_HDCP));

Quoted 22 lines
Quoted 22 lines
Quoted 22 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -3
+}
+
+static void intel_hdcp2_init(struct intel_connector *connector) {
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+
+	WARN_ON(!is_hdcp2_supported(dev_priv));
+
+	/* TODO: MEI interface needs to be initialized here */
+	hdcp->hdcp2_supported = 1;
+}
+
  int intel_hdcp_init(struct intel_connector *connector,
-		    const struct intel_hdcp_shim *shim)
+		    const struct intel_hdcp_shim *shim,
+		    bool hdcp2_supported)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
  	int ret;
-	ret = drm_connector_attach_content_protection_property(
-			&connector->base);
+	if (!shim)
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c int intel_hdcp_init(struct intel_connector

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+		return -EINVAL;
+
+	ret =
+drm_connector_attach_content_protection_property(&connector->base
+);
  	if (ret)
  		return ret;
@@ -789,9 +868,37 @@ int intel_hdcp_init(struct intel_connector

*connector,

Quoted 45 lines
Quoted 36 lines
Quoted 36 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
  	mutex_init(&hdcp->mutex);
  	INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);
  	INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);
+
+	if (hdcp2_supported)
+		intel_hdcp2_init(connector);
+
  	return 0;
  }
+void intel_hdcp_exit(struct drm_i915_private *dev_priv) {
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+
+		if (!intel_connector->hdcp.shim)
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+
+		mutex_lock(&intel_connector->hdcp.mutex);
+		intel_connector->hdcp.hdcp2_supported = 0;
+		intel_connector->hdcp.shim = NULL;
+		mutex_unlock(&intel_connector->hdcp.mutex);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
  int intel_hdcp_enable(struct intel_connector *connector)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp; @@ -867,62 +974,3
 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -2
  						   new_state->crtc);
  	crtc_state->mode_changed = true;
  }
-
-/* Implements Part 3 of the HDCP authorization procedure */ -int

intel_hdcp_check_link(struct intel_connector *connector) -{

drivers/gpu/drm/i915/intel_hdcp.c +0 -2
-	struct intel_hdcp *hdcp = &connector->hdcp;
-	struct drm_i915_private *dev_priv = connector->base.dev-

dev_private;

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +0 -1
-	struct intel_digital_port *intel_dig_port =

conn_to_dig_port(connector);

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -5
-	enum port port = intel_dig_port->base.port;
-	int ret = 0;
-
-	if (!hdcp->shim)
-		return -ENOENT;
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -8
-
-	mutex_lock(&hdcp->mutex);
-
-	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
-		goto out;
-
-	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
-		DRM_ERROR("%s:%d HDCP check failed: link is not

encrypted,%x\n",

Quoted 10 lines
Quoted 10 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -10
-			  connector->base.name, connector->base.base.id,
-			  I915_READ(PORT_HDCP_STATUS(port)));
-		ret = -ENXIO;
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	if (hdcp->shim->check_link(intel_dig_port)) {
-		if (hdcp->value !=

DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

Quoted 1 line
Quoted 1 line

drivers/gpu/drm/i915/intel_hdcp.c

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +0 -1
-			hdcp->value =

DRM_MODE_CONTENT_PROTECTION_ENABLED;

Quoted 6 lines
Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_atomic_check(struct drm_connector *connector,

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -6
-			schedule_work(&hdcp->prop_work);
-		}
-		goto out;
-	}
-
-	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying

authentication\n",

Quoted 20 lines
Quoted 20 lines
Quoted 20 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -20
-		      connector->base.name, connector->base.base.id);
-
-	ret = _intel_hdcp_disable(connector);
-	if (ret) {
-		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-	ret = _intel_hdcp_enable(connector);
-	if (ret) {
-		DRM_DEBUG_KMS("Failed to enable hdcp (%d)\n", ret);
-		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-		schedule_work(&hdcp->prop_work);
-		goto out;
-	}
-
-out:
-	mutex_unlock(&hdcp->mutex);
Quoted 8 lines
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdmi.c void intel_hdmi_init_connector(struct

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -2
-	return ret;
-}
drivers/gpu/drm/i915/intel_hdmi.c +0 -0
index e2c6a2b3e8f2..e755a3370bca 100644
@@ -2417,7 +2417,7 @@ void intel_hdmi_init_connector(struct

intel_digital_port *intel_dig_port,

Quoted 9 lines
Quoted 9 lines

drivers/gpu/drm/i915/intel_hdmi.c void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port, · line 2422

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdmi.c +1 -1
  	if (is_hdcp_supported(dev_priv, port)) {
  		int ret = intel_hdcp_init(intel_connector,
-					  &intel_hdmi_hdcp_shim);
+					  &intel_hdmi_hdcp_shim, false);
  		if (ret)
  			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");

The actual change left to wire hdcp2_supported seems ok with me, but hard to tell without seeing more yet :-) -Daniel

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
drivers/gpu/drm/i915/intel_hdmi.c +0 -1
  	}
--

2.7.4

--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#14 lore raw

PATCH v8 5/35 drm/i915: MEI interface definition

In reply to Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
 drivers/gpu/drm/i915/i915_drv.h   |   2 +
 drivers/gpu/drm/i915/intel_drv.h  |   7 +
 drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
 include/drm/i915_component.h      |  71 ++++++
 4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
 
 	struct i915_pmu pmu;
 
+	struct i915_hdcp_component_master *hdcp_comp;
+
 	/*
 	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
 	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +7 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
 #include <linux/i2c.h>
 #include <linux/hdmi.h>
 #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
 #include <drm/i915_drm.h>
 #include "i915_drv.h"
 #include <drm/drm_crtc.h>
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
 	/* Detects panel's hdcp capability. This is optional for HDMI. */
 	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
 			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);
 };
 
 struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
 	 * content can flow only through a link protected by HDCP2.2.
 	 */
 	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +441 -1

480 lines not on this page · raw message

include/drm/i915_component.h +71 -0

83 lines not on this page · raw message

Signature · 6 lines
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#15 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 38 lines · Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
 drivers/gpu/drm/i915/i915_drv.h   |   2 +
 drivers/gpu/drm/i915/intel_drv.h  |   7 +
 drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
 include/drm/i915_component.h      |  71 ++++++
 4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
 
 	struct i915_pmu pmu;
 
+	struct i915_hdcp_component_master *hdcp_comp;
+
 	/*
 	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
 	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
 #include <linux/i2c.h>
 #include <linux/hdmi.h>
 #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
 #include <drm/i915_drm.h>
 #include "i915_drv.h"
 #include <drm/drm_crtc.h>

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp_shim { · line 385

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
 	/* Detects panel's hdcp capability. This is optional for HDMI. */
 	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
 			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);

Looking ahead, this seems hardwired to constant return value? Or why do we need a function here?

Quoted 55 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
 };
 
 struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
 	 * content can flow only through a link protected by HDCP2.2.
 	 */
 	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +19 -0
index 99dddb540958..760780f1105c 100644
@@ -8,14 +8,20 @@
 
 #include <drm/drmP.h>
 #include <drm/drm_hdcp.h>
+#include <drm/i915_component.h>
 #include <linux/i2c.h>
 #include <linux/random.h>
+#include <linux/component.h>
 
 #include "intel_drv.h"
 #include "i915_reg.h"
 
 #define KEY_LOAD_TRIES	5
 #define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
+#define GET_MEI_DDI_INDEX(p) ({                            \
+	typeof(p) __p = (p);                               \
+	__p == PORT_A ? MEI_DDI_A : (enum mei_hdcp_ddi)__p;\
+})
 
 static
 bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -833,6 +839,417 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
 		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
 }
 
+static __attribute__((unused)) int
+hdcp2_prepare_ake_init(struct intel_connector *connector,
+		       struct hdcp2_ake_init *ake_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 864

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);
+
+	/* Clear ME FW instance for the port, just incase */
+	comp->ops->close_hdcp_session(comp->dev, data);

Sounds like a bug somewhere if we need this? I'd put this code into the ->initiate_hdcp2_session, with a big WARN_ON if it's actually needed.

"Just in case" papering over programming bugs of our own just makes debugging harder.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 867

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+
+	ret = comp->ops->initiate_hdcp2_session(comp->dev,
+						data, ake_data);

We should set the port only after successfully initializing this.

Quoted 12 lines
drivers/gpu/drm/i915/intel_hdcp.c +12 -0
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
+				struct hdcp2_ake_send_cert *rx_cert,
+				bool *paired,
+				struct hdcp2_ake_no_stored_km *ek_pub_km,
+				size_t *msg_sz)
+{

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 889

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {

These all look like programming mistakes that should result in a WARN_ON.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 9 lines
drivers/gpu/drm/i915/intel_hdcp.c +9 -0
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_receiver_cert_prepare_km(comp->dev, data,
+							 rx_cert, paired,
+							 ek_pub_km, msg_sz);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);

Error handling here seems a bit strange. You close the session, but don't reset the port. So next op will be totally unaware that things have blown up. Also no warning.

If we want to close the session, then I think that should be a decision made higher up.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 899

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	mutex_unlock(&comp->mutex);

With component do we still need this mutex stuff here?

Exact same comments everywhere below.

Quoted 226 lines
drivers/gpu/drm/i915/intel_hdcp.c +226 -0
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_hprime(struct intel_connector *connector,
+		    struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_hprime(comp->dev, data, rx_hprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_store_pairing_info(struct intel_connector *connector,
+			 struct hdcp2_ake_send_pairing_info *pairing_info)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->store_pairing_info(comp->dev,
+					    data, pairing_info);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_prepare_lc_init(struct intel_connector *connector,
+		      struct hdcp2_lc_init *lc_init)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->initiate_locality_check(comp->dev,
+						 data, lc_init);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_lprime(struct intel_connector *connector,
+		    struct hdcp2_lc_send_lprime *rx_lprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_lprime(comp->dev, data, rx_lprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_prepare_skey(struct intel_connector *connector,
+		       struct hdcp2_ske_send_eks *ske_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->get_session_key(comp->dev, data, ske_data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
+				      struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+				      struct hdcp2_rep_send_ack *rep_send_ack)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->repeater_check_flow_prepare_ack(comp->dev,
+							 data, rep_topology,
+							 rep_send_ack);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_mprime(struct intel_connector *connector,
+		    struct hdcp2_rep_stream_ready *stream_ready)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_mprime(comp->dev, data, stream_ready);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_authenticate_port(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->enable_hdcp_authentication(comp->dev, data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_close_mei_session(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1135

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev ||
+	    data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->close_hdcp_session(comp->dev, data);

Need to reset the port here I think.

Quoted 30 lines
drivers/gpu/drm/i915/intel_hdcp.c +30 -0
+	mutex_unlock(&comp->mutex);
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_deauthenticate_port(struct intel_connector *connector)
+{
+	return hdcp2_close_mei_session(connector);
+}
+
+static int i915_hdcp_component_master_bind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	return component_bind_all(dev, dev_priv->hdcp_comp);
+}
+
+static void intel_connectors_hdcp_disable(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+		if (!(intel_connector->hdcp.shim))
+			continue;
+

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+		intel_hdcp_disable(intel_connector);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

Quoted 22 lines
drivers/gpu/drm/i915/intel_hdcp.c +22 -0
+	component_unbind_all(dev, dev_priv->hdcp_comp);
+}
+
+static const struct component_master_ops i915_hdcp_component_master_ops = {
+	.bind = i915_hdcp_component_master_bind,
+	.unbind = i915_hdcp_component_master_unbind,
+};
+
+static int i915_hdcp_component_match(struct device *dev, void *data)
+{
+	return !strcmp(dev->driver->name, "mei_hdcp");
+}
+
+static int intel_hdcp_component_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp;
+	struct component_match *match = NULL;
+	int ret;
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp)

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1207

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+		return -ENOMEM;
+
+	mutex_init(&comp->mutex);
+	dev_priv->hdcp_comp = comp;
+
+	component_match_add(dev_priv->drm.dev, &match,
+			    i915_hdcp_component_match, dev_priv);
+	ret = component_master_add_with_match(dev_priv->drm.dev,
+					      &i915_hdcp_component_master_ops,
+					      match);

So I'm not sure this will work out well, hiding the master_ops here in hdcp. Definitely needs to be rewritten as soon as i915 needs another component. And might make the load/unload split complicated.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1211

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	if (ret < 0)
+		goto out_err;
+
+	DRM_INFO("I915 hdcp component master added.\n");

You add both the master and the hdcp component here. Output is a bit confusing.

Quoted 72 lines
drivers/gpu/drm/i915/intel_hdcp.c +57 -1
+	return ret;
+
+out_err:
+	component_master_del(dev_priv->drm.dev,
+			     &i915_hdcp_component_master_ops);
+	kfree(comp);
+	dev_priv->hdcp_comp = NULL;
+	DRM_ERROR("Failed to add i915 hdcp component master (%d)\n", ret);
+
+	return ret;
+}
+
+static int initialize_mei_hdcp_data(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct mei_hdcp_data *data = &hdcp->mei_data;
+	enum port port;
+
+	if (connector->encoder) {
+		port = connector->encoder->port;
+		data->port = GET_MEI_DDI_INDEX(port);
+	}
+
+	data->port_type = MEI_HDCP_PORT_TYPE_INTEGRATED;
+	data->protocol = hdcp->shim->hdcp_protocol();
+
+	data->k = 1;
+	if (!data->streams)
+		data->streams = kcalloc(data->k, sizeof(data->streams[0]),
+					GFP_KERNEL);
+	if (!data->streams) {
+		DRM_ERROR("Out of Memory\n");
+		return -ENOMEM;
+	}
+
+	data->streams[0].stream_id = 0;
+	data->streams[0].stream_type = hdcp->content_type;
+
+	return 0;
+}
+
 bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
 {
 	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
@@ -843,10 +1260,25 @@ static void intel_hdcp2_init(struct intel_connector *connector)
 {
 	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
 
 	WARN_ON(!is_hdcp2_supported(dev_priv));
 
-	/* TODO: MEI interface needs to be initialized here */
+	ret = initialize_mei_hdcp_data(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("Mei hdcp data init failed\n");
+		return;
+	}
+
+	if (!dev_priv->hdcp_comp)
+		ret = intel_hdcp_component_init(connector);
+
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP comp init failed\n");
+		kfree(hdcp->mei_data.streams);
+		return;
+	}
+
 	hdcp->hdcp2_supported = 1;
 }
 

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_exit(struct drm_i915_private *dev_priv) · line 1329

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
@@ -894,9 +1326,17 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
 		mutex_lock(&intel_connector->hdcp.mutex);
 		intel_connector->hdcp.hdcp2_supported = 0;
 		intel_connector->hdcp.shim = NULL;
+		kfree(intel_connector->hdcp.mei_data.streams);

We need to push this into a per-connector hdcp cleanup function. Or just into the generic connector cleanup.

Quoted 31 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
 		mutex_unlock(&intel_connector->hdcp.mutex);
 	}
 	drm_connector_list_iter_end(&conn_iter);
+
+	if (dev_priv->hdcp_comp) {
+		component_master_del(dev_priv->drm.dev,
+				     &i915_hdcp_component_master_ops);
+		kfree(dev_priv->hdcp_comp);
+		dev_priv->hdcp_comp = NULL;
+	}
 }
 
 int intel_hdcp_enable(struct intel_connector *connector)
include/drm/i915_component.h +4 -0
index fca22d463e1b..12268228f4dc 100644
@@ -24,8 +24,12 @@
 #ifndef _I915_COMPONENT_H_
 #define _I915_COMPONENT_H_
 
+#include <linux/mutex.h>
+
 #include "drm_audio_component.h"
 
+#include <drm/drm_hdcp.h>
+
 /* MAX_PORT is the number of port
  * It must be sync with I915_MAX_PORTS defined i915_drv.h
  */

include/drm/i915_component.h struct i915_audio_component { · line 53

Quoted 4 lines
include/drm/i915_component.h +1 -0
@@ -46,4 +50,71 @@ struct i915_audio_component {
 	int aud_sample_rate[MAX_PORTS];
 };
 
+struct i915_hdcp_component_ops {

Imo that should be called mei_hdcp_component_ops and put into the linux/mei_hdcp.h header. Or was that Thomas' review comment?

Aside: Review here in public channels instead of in private would be much better for coordination.

Quoted 70 lines
include/drm/i915_component.h +66 -0
+	/**
+	 * @owner: mei_hdcp module
+	 */
+	struct module *owner;
+
+	int (*initiate_hdcp2_session)(struct device *dev,
+				      void *hdcp_data,
+				      struct hdcp2_ake_init *ake_data);
+	int (*verify_receiver_cert_prepare_km)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_ake_send_cert
+								*rx_cert,
+					       bool *km_stored,
+					       struct hdcp2_ake_no_stored_km
+								*ek_pub_km,
+					       size_t *msg_sz);
+	int (*verify_hprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_ake_send_hprime *rx_hprime);
+	int (*store_pairing_info)(struct device *dev,
+				  void *hdcp_data,
+				  struct hdcp2_ake_send_pairing_info
+								*pairing_info);
+	int (*initiate_locality_check)(struct device *dev,
+				       void *hdcp_data,
+				       struct hdcp2_lc_init *lc_init_data);
+	int (*verify_lprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_lc_send_lprime *rx_lprime);
+	int (*get_session_key)(struct device *dev,
+			       void *hdcp_data,
+			       struct hdcp2_ske_send_eks *ske_data);
+	int (*repeater_check_flow_prepare_ack)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+					       struct hdcp2_rep_send_ack
+								*rep_send_ack);
+	int (*verify_mprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_rep_stream_ready *stream_ready);
+	int (*enable_hdcp_authentication)(struct device *dev,
+					  void *hdcp_data);
+	int (*close_hdcp_session)(struct device *dev,
+				  void *hdcp_data);
+};
+
+/**
+ * struct i915_hdcp_component_master - Used for communication between i915
+ * and mei_hdcp for HDCP2.2 services.
+ */
+struct i915_hdcp_component_master {
+	/**
+	 * @dev: a device providing hdcp
+	 */
+	struct device *dev;
+	/**
+	 * @mutex: Mutex to protect the state of dev
+	 */
+	struct mutex mutex;
+	/**
+	 * @ops: Ops implemented by mei_hdcp driver, used by i915 driver.
+	 */
+	const struct i915_hdcp_component_ops *ops;
+};
+
 #endif /* _I915_COMPONENT_H_ */
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#16 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 39 lines · Daniel Vetter
Quoted 38 lines · Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
  drivers/gpu/drm/i915/i915_drv.h   |   2 +
  drivers/gpu/drm/i915/intel_drv.h  |   7 +
  drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
  include/drm/i915_component.h      |  71 ++++++
  4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
 
  	struct i915_pmu pmu;
 
+	struct i915_hdcp_component_master *hdcp_comp;
+
  	/*
  	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
  	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
  #include <linux/i2c.h>
  #include <linux/hdmi.h>
  #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
  #include <drm/i915_drm.h>
  #include "i915_drv.h"
  #include <drm/drm_crtc.h>
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp_shim { · line 385

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  	/* Detects panel's hdcp capability. This is optional for HDMI. */
  	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
  			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);

Looking ahead, this seems hardwired to constant return value? Or why do we need a function here?

This is hardwired based on the connector type(DP/HDMI).
Since we have the shim for hdcp's connector based work, I have added this function.

Could have done this just with connector_type check, but in that way whole hdcp_shim can be done in that way. So going with the larger design here.

Quoted 60 lines
Quoted 60 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  };
 
  struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
  	 * content can flow only through a link protected by HDCP2.2.
  	 */
  	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
  };
 
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +23 -0
index 99dddb540958..760780f1105c 100644
@@ -8,14 +8,20 @@
 
  #include <drm/drmP.h>
  #include <drm/drm_hdcp.h>
+#include <drm/i915_component.h>
  #include <linux/i2c.h>
  #include <linux/random.h>
+#include <linux/component.h>
 
  #include "intel_drv.h"
  #include "i915_reg.h"
 
  #define KEY_LOAD_TRIES	5
  #define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
+#define GET_MEI_DDI_INDEX(p) ({                            \
+	typeof(p) __p = (p);                               \
+	__p == PORT_A ? MEI_DDI_A : (enum mei_hdcp_ddi)__p;\
+})
 
  static
  bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -833,6 +839,417 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
 
+static __attribute__((unused)) int
+hdcp2_prepare_ake_init(struct intel_connector *connector,
+		       struct hdcp2_ake_init *ake_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 864

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);
+
+	/* Clear ME FW instance for the port, just incase */
+	comp->ops->close_hdcp_session(comp->dev, data);

Sounds like a bug somewhere if we need this? I'd put this code into the ->initiate_hdcp2_session, with a big WARN_ON if it's actually needed.

Not really. Lets say you have progressed beyond the first step of HDCP2.2 auth along with ME FW. Now if authentication failed due to some reason, then the HDCP2.2 season created with ME FW for that port is not closed yet.

So we need to call close_hdcp_session() explicitly on authentication failures. Session has to be closed before restarting the auth on that port with initialite_hdcp_session. If we are closing the hdcp session of the port on all auth errors, we dont need this just before start of the hdcp session.

Quoted 8 lines

"Just in case" papering over programming bugs of our own just makes debugging harder.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 867

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+
+	ret = comp->ops->initiate_hdcp2_session(comp->dev,
+						data, ake_data);

We should set the port only after successfully initializing this.

hdcp2_session is created for each port at ME FW. Hence we need the port initialized even before calling the initiate_hdcp2_session.

Quoted 16 lines
Quoted 16 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -0
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
+				struct hdcp2_ake_send_cert *rx_cert,
+				bool *paired,
+				struct hdcp2_ake_no_stored_km *ek_pub_km,
+				size_t *msg_sz)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 889

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {

These all look like programming mistakes that should result in a WARN_ON.

We are using the comp->mutex for protecting the interface during the interface init, usage for mei communication and interface teardown.

But what if mei interface teardown happens between mei communications? So when we try to access the mei interface after such possible tear down scenario, we are checking the integrity of the interface.

Possible alternate solution is hold the comp->mutex across the authentication steps. But consequence is that mei module removal will be blocked for authentication duration and even if the mei_dev is removed, component unbind will be blocked due to this mutex dependency.

Quoted 14 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +9 -0
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_receiver_cert_prepare_km(comp->dev, data,
+							 rx_cert, paired,
+							 ek_pub_km, msg_sz);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);

Error handling here seems a bit strange. You close the session, but don't reset the port. So next op will be totally unaware that things have blown up. Also no warning.

Quoted 2 lines

If we want to close the session, then I think that should be a decision made higher up.

This is needed as explained above. But as you have mentioned this can be moved to the end of the authentication on error scenario. I will work on that.

Quoted 235 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 899

Quoted 2 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	mutex_unlock(&comp->mutex);

With component do we still need this mutex stuff here?

Exact same comments everywhere below.

Quoted 229 lines
drivers/gpu/drm/i915/intel_hdcp.c +229 -0
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_hprime(struct intel_connector *connector,
+		    struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_hprime(comp->dev, data, rx_hprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_store_pairing_info(struct intel_connector *connector,
+			 struct hdcp2_ake_send_pairing_info *pairing_info)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->store_pairing_info(comp->dev,
+					    data, pairing_info);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_prepare_lc_init(struct intel_connector *connector,
+		      struct hdcp2_lc_init *lc_init)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->initiate_locality_check(comp->dev,
+						 data, lc_init);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_lprime(struct intel_connector *connector,
+		    struct hdcp2_lc_send_lprime *rx_lprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_lprime(comp->dev, data, rx_lprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_prepare_skey(struct intel_connector *connector,
+		       struct hdcp2_ske_send_eks *ske_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->get_session_key(comp->dev, data, ske_data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
+				      struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+				      struct hdcp2_rep_send_ack *rep_send_ack)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->repeater_check_flow_prepare_ack(comp->dev,
+							 data, rep_topology,
+							 rep_send_ack);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_mprime(struct intel_connector *connector,
+		    struct hdcp2_rep_stream_ready *stream_ready)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_mprime(comp->dev, data, stream_ready);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_authenticate_port(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->enable_hdcp_authentication(comp->dev, data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_close_mei_session(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1135

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	if (!comp->ops || !comp->dev ||
+	    data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->close_hdcp_session(comp->dev, data);

Need to reset the port here I think.

What is the reset of the port you are referring to? port is not
configured for encryption. And this is the call for marking the port as de-authenticated too.

Quoted 36 lines
Quoted 36 lines
drivers/gpu/drm/i915/intel_hdcp.c +35 -0
+	mutex_unlock(&comp->mutex);
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_deauthenticate_port(struct intel_connector *connector)
+{
+	return hdcp2_close_mei_session(connector);
+}
+
+static int i915_hdcp_component_master_bind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	return component_bind_all(dev, dev_priv->hdcp_comp);
+}
+
+static void intel_connectors_hdcp_disable(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+		if (!(intel_connector->hdcp.shim))
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 28 lines
Quoted 28 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
+	component_unbind_all(dev, dev_priv->hdcp_comp);
+}
+
+static const struct component_master_ops i915_hdcp_component_master_ops = {
+	.bind = i915_hdcp_component_master_bind,
+	.unbind = i915_hdcp_component_master_unbind,
+};
+
+static int i915_hdcp_component_match(struct device *dev, void *data)
+{
+	return !strcmp(dev->driver->name, "mei_hdcp");
+}
+
+static int intel_hdcp_component_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp;
+	struct component_match *match = NULL;
+	int ret;
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp)
+		return -ENOMEM;
+
+	mutex_init(&comp->mutex);
+	dev_priv->hdcp_comp = comp;
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1207

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	component_match_add(dev_priv->drm.dev, &match,
+			    i915_hdcp_component_match, dev_priv);
+	ret = component_master_add_with_match(dev_priv->drm.dev,
+					      &i915_hdcp_component_master_ops,
+					      match);

So I'm not sure this will work out well, hiding the master_ops here in hdcp. Definitely needs to be rewritten as soon as i915 needs another component. And might make the load/unload split complicated.

we have already discussed this.

Quoted 7 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1211

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	if (ret < 0)
+		goto out_err;
+
+	DRM_INFO("I915 hdcp component master added.\n");

You add both the master and the hdcp component here. Output is a bit confusing.

we have component master and a component from mei which will match to the master.

Here we are adding the component master.

Quoted 72 lines
Quoted 72 lines
drivers/gpu/drm/i915/intel_hdcp.c +57 -1
+	return ret;
+
+out_err:
+	component_master_del(dev_priv->drm.dev,
+			     &i915_hdcp_component_master_ops);
+	kfree(comp);
+	dev_priv->hdcp_comp = NULL;
+	DRM_ERROR("Failed to add i915 hdcp component master (%d)\n", ret);
+
+	return ret;
+}
+
+static int initialize_mei_hdcp_data(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct mei_hdcp_data *data = &hdcp->mei_data;
+	enum port port;
+
+	if (connector->encoder) {
+		port = connector->encoder->port;
+		data->port = GET_MEI_DDI_INDEX(port);
+	}
+
+	data->port_type = MEI_HDCP_PORT_TYPE_INTEGRATED;
+	data->protocol = hdcp->shim->hdcp_protocol();
+
+	data->k = 1;
+	if (!data->streams)
+		data->streams = kcalloc(data->k, sizeof(data->streams[0]),
+					GFP_KERNEL);
+	if (!data->streams) {
+		DRM_ERROR("Out of Memory\n");
+		return -ENOMEM;
+	}
+
+	data->streams[0].stream_id = 0;
+	data->streams[0].stream_type = hdcp->content_type;
+
+	return 0;
+}
+
  bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
  {
  	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
@@ -843,10 +1260,25 @@ static void intel_hdcp2_init(struct intel_connector *connector)
  {
  	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
  	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
 
  	WARN_ON(!is_hdcp2_supported(dev_priv));
 
-	/* TODO: MEI interface needs to be initialized here */
+	ret = initialize_mei_hdcp_data(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("Mei hdcp data init failed\n");
+		return;
+	}
+
+	if (!dev_priv->hdcp_comp)
+		ret = intel_hdcp_component_init(connector);
+
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP comp init failed\n");
+		kfree(hdcp->mei_data.streams);
+		return;
+	}
+
  	hdcp->hdcp2_supported = 1;
  }
 
Quoted 7 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_exit(struct drm_i915_private *dev_priv) · line 1329

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
@@ -894,9 +1326,17 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
  		mutex_lock(&intel_connector->hdcp.mutex);
  		intel_connector->hdcp.hdcp2_supported = 0;
  		intel_connector->hdcp.shim = NULL;
+		kfree(intel_connector->hdcp.mei_data.streams);

We need to push this into a per-connector hdcp cleanup function. Or just into the generic connector cleanup.

We could move it to per connector  hdcp cleanup function.

Quoted 35 lines
Quoted 35 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
  		mutex_unlock(&intel_connector->hdcp.mutex);
  	}
  	drm_connector_list_iter_end(&conn_iter);
+
+	if (dev_priv->hdcp_comp) {
+		component_master_del(dev_priv->drm.dev,
+				     &i915_hdcp_component_master_ops);
+		kfree(dev_priv->hdcp_comp);
+		dev_priv->hdcp_comp = NULL;
+	}
  }
 
  int intel_hdcp_enable(struct intel_connector *connector)
include/drm/i915_component.h +4 -0
index fca22d463e1b..12268228f4dc 100644
@@ -24,8 +24,12 @@
  #ifndef _I915_COMPONENT_H_
  #define _I915_COMPONENT_H_
 
+#include <linux/mutex.h>
+
  #include "drm_audio_component.h"
 
+#include <drm/drm_hdcp.h>
+
  /* MAX_PORT is the number of port
   * It must be sync with I915_MAX_PORTS defined i915_drv.h
   */
@@ -46,4 +50,71 @@ struct i915_audio_component {
  	int aud_sample_rate[MAX_PORTS];
  };
 
Quoted 3 lines

include/drm/i915_component.h struct i915_audio_component { · line 53

Quoted 1 line
include/drm/i915_component.h +1 -0
+struct i915_hdcp_component_ops {

Imo that should be called mei_hdcp_component_ops and put into the linux/mei_hdcp.h header. Or was that Thomas' review comment?

Nope this is there for many versions. i915_hdcp_component_ops are implemented by mei_hdcp.c and initializes the component with the &ops.

Quoted 3 lines

Aside: Review here in public channels instead of in private would be much better for coordination.

Tomas,

Could you please help on this ask.?

--Ram

Quoted 63 lines
Quoted 63 lines
include/drm/i915_component.h +62 -0
+	/**
+	 * @owner: mei_hdcp module
+	 */
+	struct module *owner;
+
+	int (*initiate_hdcp2_session)(struct device *dev,
+				      void *hdcp_data,
+				      struct hdcp2_ake_init *ake_data);
+	int (*verify_receiver_cert_prepare_km)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_ake_send_cert
+								*rx_cert,
+					       bool *km_stored,
+					       struct hdcp2_ake_no_stored_km
+								*ek_pub_km,
+					       size_t *msg_sz);
+	int (*verify_hprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_ake_send_hprime *rx_hprime);
+	int (*store_pairing_info)(struct device *dev,
+				  void *hdcp_data,
+				  struct hdcp2_ake_send_pairing_info
+								*pairing_info);
+	int (*initiate_locality_check)(struct device *dev,
+				       void *hdcp_data,
+				       struct hdcp2_lc_init *lc_init_data);
+	int (*verify_lprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_lc_send_lprime *rx_lprime);
+	int (*get_session_key)(struct device *dev,
+			       void *hdcp_data,
+			       struct hdcp2_ske_send_eks *ske_data);
+	int (*repeater_check_flow_prepare_ack)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+					       struct hdcp2_rep_send_ack
+								*rep_send_ack);
+	int (*verify_mprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_rep_stream_ready *stream_ready);
+	int (*enable_hdcp_authentication)(struct device *dev,
+					  void *hdcp_data);
+	int (*close_hdcp_session)(struct device *dev,
+				  void *hdcp_data);
+};
+
+/**
+ * struct i915_hdcp_component_master - Used for communication between i915
+ * and mei_hdcp for HDCP2.2 services.
+ */
+struct i915_hdcp_component_master {
+	/**
+	 * @dev: a device providing hdcp
+	 */
+	struct device *dev;
+	/**
+	 * @mutex: Mutex to protect the state of dev
+	 */
+	struct mutex mutex;
+	/**
+	 * @ops: Ops implemented by mei_hdcp driver, used by i915 driver.
Quoted 8 lines
Quoted 8 lines
include/drm/i915_component.h +4 -0
+	 */
+	const struct i915_hdcp_component_ops *ops;
+};
+
  #endif /* _I915_COMPONENT_H_ */
Signature · 1 line
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#17 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 640 lines · Ramalingam
Quoted 39 lines · Daniel Vetter
Quoted 38 lines · Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
  drivers/gpu/drm/i915/i915_drv.h   |   2 +
  drivers/gpu/drm/i915/intel_drv.h  |   7 +
  drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
  include/drm/i915_component.h      |  71 ++++++
  4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
 
  	struct i915_pmu pmu;
 
+	struct i915_hdcp_component_master *hdcp_comp;
+
  	/*
  	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
  	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
  #include <linux/i2c.h>
  #include <linux/hdmi.h>
  #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
  #include <drm/i915_drm.h>
  #include "i915_drv.h"
  #include <drm/drm_crtc.h>
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp_shim { · line 385

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  	/* Detects panel's hdcp capability. This is optional for HDMI. */
  	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
  			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);

Looking ahead, this seems hardwired to constant return value? Or why do we need a function here?

This is hardwired based on the connector type(DP/HDMI).
Since we have the shim for hdcp's connector based work, I have added this function.

Could have done this just with connector_type check, but in that way whole hdcp_shim can be done in that way. So going with the larger design here.

Quoted 59 lines
Quoted 59 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  };
 
  struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
  	 * content can flow only through a link protected by HDCP2.2.
  	 */
  	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
  };
 
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +23 -0
index 99dddb540958..760780f1105c 100644
@@ -8,14 +8,20 @@
 
  #include <drm/drmP.h>
  #include <drm/drm_hdcp.h>
+#include <drm/i915_component.h>
  #include <linux/i2c.h>
  #include <linux/random.h>
+#include <linux/component.h>
 
  #include "intel_drv.h"
  #include "i915_reg.h"
 
  #define KEY_LOAD_TRIES	5
  #define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
+#define GET_MEI_DDI_INDEX(p) ({                            \
+	typeof(p) __p = (p);                               \
+	__p == PORT_A ? MEI_DDI_A : (enum mei_hdcp_ddi)__p;\
+})
 
  static
  bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -833,6 +839,417 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
 
+static __attribute__((unused)) int
+hdcp2_prepare_ake_init(struct intel_connector *connector,
+		       struct hdcp2_ake_init *ake_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 864

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);
+
+	/* Clear ME FW instance for the port, just incase */
+	comp->ops->close_hdcp_session(comp->dev, data);

Sounds like a bug somewhere if we need this? I'd put this code into the ->initiate_hdcp2_session, with a big WARN_ON if it's actually needed.

Not really. Lets say you have progressed beyond the first step of HDCP2.2 auth along with ME FW. Now if authentication failed due to some reason, then the HDCP2.2 season created with ME FW for that port is not closed yet.

So we need to call close_hdcp_session() explicitly on authentication failures. Session has to be closed before restarting the auth on that port with initialite_hdcp_session. If we are closing the hdcp session of the port on all auth errors, we dont need this just before start of the hdcp session.

Quoted 7 lines

"Just in case" papering over programming bugs of our own just makes debugging harder.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 867

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+
+	ret = comp->ops->initiate_hdcp2_session(comp->dev,
+						data, ake_data);

We should set the port only after successfully initializing this.

hdcp2_session is created for each port at ME FW. Hence we need the port initialized even before calling the initiate_hdcp2_session.

Quoted 15 lines
Quoted 15 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -0
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
+				struct hdcp2_ake_send_cert *rx_cert,
+				bool *paired,
+				struct hdcp2_ake_no_stored_km *ek_pub_km,
+				size_t *msg_sz)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 889

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {

These all look like programming mistakes that should result in a WARN_ON.

We are using the comp->mutex for protecting the interface during the interface init, usage for mei communication and interface teardown.

But what if mei interface teardown happens between mei communications? So when we try to access the mei interface after such possible tear down scenario, we are checking the integrity of the interface.

Possible alternate solution is hold the comp->mutex across the authentication steps. But consequence is that mei module removal will be blocked for authentication duration and even if the mei_dev is removed, component unbind will be blocked due to this mutex dependency.

Quoted 13 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 9 lines
drivers/gpu/drm/i915/intel_hdcp.c +9 -0
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_receiver_cert_prepare_km(comp->dev, data,
+							 rx_cert, paired,
+							 ek_pub_km, msg_sz);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);

Error handling here seems a bit strange. You close the session, but don't reset the port. So next op will be totally unaware that things have blown up. Also no warning.

Quoted 2 lines

If we want to close the session, then I think that should be a decision made higher up.

This is needed as explained above. But as you have mentioned this can be moved to the end of the authentication on error scenario. I will work on that.

Quoted 234 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 899

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	mutex_unlock(&comp->mutex);

With component do we still need this mutex stuff here?

Exact same comments everywhere below.

Quoted 229 lines
drivers/gpu/drm/i915/intel_hdcp.c +229 -0
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_hprime(struct intel_connector *connector,
+		    struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_hprime(comp->dev, data, rx_hprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_store_pairing_info(struct intel_connector *connector,
+			 struct hdcp2_ake_send_pairing_info *pairing_info)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->store_pairing_info(comp->dev,
+					    data, pairing_info);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_prepare_lc_init(struct intel_connector *connector,
+		      struct hdcp2_lc_init *lc_init)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->initiate_locality_check(comp->dev,
+						 data, lc_init);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_lprime(struct intel_connector *connector,
+		    struct hdcp2_lc_send_lprime *rx_lprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_lprime(comp->dev, data, rx_lprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_prepare_skey(struct intel_connector *connector,
+		       struct hdcp2_ske_send_eks *ske_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->get_session_key(comp->dev, data, ske_data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
+				      struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+				      struct hdcp2_rep_send_ack *rep_send_ack)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->repeater_check_flow_prepare_ack(comp->dev,
+							 data, rep_topology,
+							 rep_send_ack);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_mprime(struct intel_connector *connector,
+		    struct hdcp2_rep_stream_ready *stream_ready)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_mprime(comp->dev, data, stream_ready);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_authenticate_port(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->enable_hdcp_authentication(comp->dev, data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_close_mei_session(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1135

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	if (!comp->ops || !comp->dev ||
+	    data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->close_hdcp_session(comp->dev, data);

Need to reset the port here I think.

What is the reset of the port you are referring to? port is not
configured for encryption. And this is the call for marking the port as de-authenticated too.

Quoted 35 lines
Quoted 35 lines
drivers/gpu/drm/i915/intel_hdcp.c +35 -0
+	mutex_unlock(&comp->mutex);
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_deauthenticate_port(struct intel_connector *connector)
+{
+	return hdcp2_close_mei_session(connector);
+}
+
+static int i915_hdcp_component_master_bind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	return component_bind_all(dev, dev_priv->hdcp_comp);
+}
+
+static void intel_connectors_hdcp_disable(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+		if (!(intel_connector->hdcp.shim))
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 27 lines
Quoted 27 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
+	component_unbind_all(dev, dev_priv->hdcp_comp);
+}
+
+static const struct component_master_ops i915_hdcp_component_master_ops = {
+	.bind = i915_hdcp_component_master_bind,
+	.unbind = i915_hdcp_component_master_unbind,
+};
+
+static int i915_hdcp_component_match(struct device *dev, void *data)
+{
+	return !strcmp(dev->driver->name, "mei_hdcp");
+}
+
+static int intel_hdcp_component_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp;
+	struct component_match *match = NULL;
+	int ret;
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp)
+		return -ENOMEM;
+
+	mutex_init(&comp->mutex);
+	dev_priv->hdcp_comp = comp;
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1207

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	component_match_add(dev_priv->drm.dev, &match,
+			    i915_hdcp_component_match, dev_priv);
+	ret = component_master_add_with_match(dev_priv->drm.dev,
+					      &i915_hdcp_component_master_ops,
+					      match);

So I'm not sure this will work out well, hiding the master_ops here in hdcp. Definitely needs to be rewritten as soon as i915 needs another component. And might make the load/unload split complicated.

we have already discussed this.

Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1211

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	if (ret < 0)
+		goto out_err;
+
+	DRM_INFO("I915 hdcp component master added.\n");

You add both the master and the hdcp component here. Output is a bit confusing.

we have component master and a component from mei which will match to the master.

Here we are adding the component master.

Quoted 71 lines
Quoted 71 lines
drivers/gpu/drm/i915/intel_hdcp.c +57 -1
+	return ret;
+
+out_err:
+	component_master_del(dev_priv->drm.dev,
+			     &i915_hdcp_component_master_ops);
+	kfree(comp);
+	dev_priv->hdcp_comp = NULL;
+	DRM_ERROR("Failed to add i915 hdcp component master (%d)\n", ret);
+
+	return ret;
+}
+
+static int initialize_mei_hdcp_data(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct mei_hdcp_data *data = &hdcp->mei_data;
+	enum port port;
+
+	if (connector->encoder) {
+		port = connector->encoder->port;
+		data->port = GET_MEI_DDI_INDEX(port);
+	}
+
+	data->port_type = MEI_HDCP_PORT_TYPE_INTEGRATED;
+	data->protocol = hdcp->shim->hdcp_protocol();
+
+	data->k = 1;
+	if (!data->streams)
+		data->streams = kcalloc(data->k, sizeof(data->streams[0]),
+					GFP_KERNEL);
+	if (!data->streams) {
+		DRM_ERROR("Out of Memory\n");
+		return -ENOMEM;
+	}
+
+	data->streams[0].stream_id = 0;
+	data->streams[0].stream_type = hdcp->content_type;
+
+	return 0;
+}
+
  bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
  {
  	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
@@ -843,10 +1260,25 @@ static void intel_hdcp2_init(struct intel_connector *connector)
  {
  	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
  	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
 
  	WARN_ON(!is_hdcp2_supported(dev_priv));
 
-	/* TODO: MEI interface needs to be initialized here */
+	ret = initialize_mei_hdcp_data(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("Mei hdcp data init failed\n");
+		return;
+	}
+
+	if (!dev_priv->hdcp_comp)
+		ret = intel_hdcp_component_init(connector);
+
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP comp init failed\n");
+		kfree(hdcp->mei_data.streams);
+		return;
+	}
+
  	hdcp->hdcp2_supported = 1;
  }
 
Quoted 7 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_exit(struct drm_i915_private *dev_priv) · line 1329

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
@@ -894,9 +1326,17 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
  		mutex_lock(&intel_connector->hdcp.mutex);
  		intel_connector->hdcp.hdcp2_supported = 0;
  		intel_connector->hdcp.shim = NULL;
+		kfree(intel_connector->hdcp.mei_data.streams);

We need to push this into a per-connector hdcp cleanup function. Or just into the generic connector cleanup.

We could move it to per connector  hdcp cleanup function.

Quoted 34 lines
Quoted 34 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
  		mutex_unlock(&intel_connector->hdcp.mutex);
  	}
  	drm_connector_list_iter_end(&conn_iter);
+
+	if (dev_priv->hdcp_comp) {
+		component_master_del(dev_priv->drm.dev,
+				     &i915_hdcp_component_master_ops);
+		kfree(dev_priv->hdcp_comp);
+		dev_priv->hdcp_comp = NULL;
+	}
  }
 
  int intel_hdcp_enable(struct intel_connector *connector)
include/drm/i915_component.h +4 -0
index fca22d463e1b..12268228f4dc 100644
@@ -24,8 +24,12 @@
  #ifndef _I915_COMPONENT_H_
  #define _I915_COMPONENT_H_
 
+#include <linux/mutex.h>
+
  #include "drm_audio_component.h"
 
+#include <drm/drm_hdcp.h>
+
  /* MAX_PORT is the number of port
   * It must be sync with I915_MAX_PORTS defined i915_drv.h
   */
@@ -46,4 +50,71 @@ struct i915_audio_component {
  	int aud_sample_rate[MAX_PORTS];
  };
 
Quoted 5 lines
Quoted 3 lines

include/drm/i915_component.h struct i915_audio_component { · line 53

Quoted 1 line
include/drm/i915_component.h +1 -0
+struct i915_hdcp_component_ops {

Imo that should be called mei_hdcp_component_ops and put into the linux/mei_hdcp.h header. Or was that Thomas' review comment?

Nope this is there for many versions. i915_hdcp_component_ops are implemented by mei_hdcp.c and initializes the component with the &ops.

Tomas and Daniel,

Is this fine? Defining the ops at i915_component.h and I915 and mei_hdcp using it for their purpose?

If it has to be compulsorily defined by the service provider then we need to move this into the include/linux/mei_hdcp.h. In that we can avoid the global header from the mei_hdcp Tomas. Please help here to clarify the direction.

-Ram

Quoted 72 lines
Quoted 2 lines

Aside: Review here in public channels instead of in private would be much better for coordination.

Tomas,
Could you please help on this ask.?
--Ram

Quoted 67 lines
Quoted 67 lines
include/drm/i915_component.h +66 -0
+	/**
+	 * @owner: mei_hdcp module
+	 */
+	struct module *owner;
+
+	int (*initiate_hdcp2_session)(struct device *dev,
+				      void *hdcp_data,
+				      struct hdcp2_ake_init *ake_data);
+	int (*verify_receiver_cert_prepare_km)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_ake_send_cert
+								*rx_cert,
+					       bool *km_stored,
+					       struct hdcp2_ake_no_stored_km
+								*ek_pub_km,
+					       size_t *msg_sz);
+	int (*verify_hprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_ake_send_hprime *rx_hprime);
+	int (*store_pairing_info)(struct device *dev,
+				  void *hdcp_data,
+				  struct hdcp2_ake_send_pairing_info
+								*pairing_info);
+	int (*initiate_locality_check)(struct device *dev,
+				       void *hdcp_data,
+				       struct hdcp2_lc_init *lc_init_data);
+	int (*verify_lprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_lc_send_lprime *rx_lprime);
+	int (*get_session_key)(struct device *dev,
+			       void *hdcp_data,
+			       struct hdcp2_ske_send_eks *ske_data);
+	int (*repeater_check_flow_prepare_ack)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+					       struct hdcp2_rep_send_ack
+								*rep_send_ack);
+	int (*verify_mprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_rep_stream_ready *stream_ready);
+	int (*enable_hdcp_authentication)(struct device *dev,
+					  void *hdcp_data);
+	int (*close_hdcp_session)(struct device *dev,
+				  void *hdcp_data);
+};
+
+/**
+ * struct i915_hdcp_component_master - Used for communication between i915
+ * and mei_hdcp for HDCP2.2 services.
+ */
+struct i915_hdcp_component_master {
+	/**
+	 * @dev: a device providing hdcp
+	 */
+	struct device *dev;
+	/**
+	 * @mutex: Mutex to protect the state of dev
+	 */
+	struct mutex mutex;
+	/**
+	 * @ops: Ops implemented by mei_hdcp driver, used by i915 driver.
+	 */
+	const struct i915_hdcp_component_ops *ops;
+};
+
  #endif /* _I915_COMPONENT_H_ */
Quoted 8 lines
Quoted 3 lines
Quoted 3 lines
Signature · 1 line
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#18 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

In reply to C, Ramalingam
Quoted 640 lines · Ramalingam
Quoted 39 lines · Daniel Vetter
Quoted 38 lines · Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
  drivers/gpu/drm/i915/i915_drv.h   |   2 +
  drivers/gpu/drm/i915/intel_drv.h  |   7 +
  drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
  include/drm/i915_component.h      |  71 ++++++
  4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
 
  	struct i915_pmu pmu;
 
+	struct i915_hdcp_component_master *hdcp_comp;
+
  	/*
  	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
  	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
  #include <linux/i2c.h>
  #include <linux/hdmi.h>
  #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
  #include <drm/i915_drm.h>
  #include "i915_drv.h"
  #include <drm/drm_crtc.h>
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp_shim { · line 385

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  	/* Detects panel's hdcp capability. This is optional for HDMI. */
  	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
  			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);

Looking ahead, this seems hardwired to constant return value? Or why do we need a function here?

This is hardwired based on the connector type(DP/HDMI).
Since we have the shim for hdcp's connector based work, I have added this function.

Could have done this just with connector_type check, but in that way whole hdcp_shim can be done in that way. So going with the larger design here.

Quoted 59 lines
Quoted 59 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  };
 
  struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
  	 * content can flow only through a link protected by HDCP2.2.
  	 */
  	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
  };
 
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +23 -0
index 99dddb540958..760780f1105c 100644
@@ -8,14 +8,20 @@
 
  #include <drm/drmP.h>
  #include <drm/drm_hdcp.h>
+#include <drm/i915_component.h>
  #include <linux/i2c.h>
  #include <linux/random.h>
+#include <linux/component.h>
 
  #include "intel_drv.h"
  #include "i915_reg.h"
 
  #define KEY_LOAD_TRIES	5
  #define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
+#define GET_MEI_DDI_INDEX(p) ({                            \
+	typeof(p) __p = (p);                               \
+	__p == PORT_A ? MEI_DDI_A : (enum mei_hdcp_ddi)__p;\
+})
 
  static
  bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -833,6 +839,417 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
 
+static __attribute__((unused)) int
+hdcp2_prepare_ake_init(struct intel_connector *connector,
+		       struct hdcp2_ake_init *ake_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 864

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);
+
+	/* Clear ME FW instance for the port, just incase */
+	comp->ops->close_hdcp_session(comp->dev, data);

Sounds like a bug somewhere if we need this? I'd put this code into the ->initiate_hdcp2_session, with a big WARN_ON if it's actually needed.

Not really. Lets say you have progressed beyond the first step of HDCP2.2 auth along with ME FW. Now if authentication failed due to some reason, then the HDCP2.2 season created with ME FW for that port is not closed yet.

So we need to call close_hdcp_session() explicitly on authentication failures. Session has to be closed before restarting the auth on that port with initialite_hdcp_session. If we are closing the hdcp session of the port on all auth errors, we dont need this just before start of the hdcp session.

Quoted 7 lines

"Just in case" papering over programming bugs of our own just makes debugging harder.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 867

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+
+	ret = comp->ops->initiate_hdcp2_session(comp->dev,
+						data, ake_data);

We should set the port only after successfully initializing this.

hdcp2_session is created for each port at ME FW. Hence we need the port initialized even before calling the initiate_hdcp2_session.

Quoted 15 lines
Quoted 15 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -0
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
+				struct hdcp2_ake_send_cert *rx_cert,
+				bool *paired,
+				struct hdcp2_ake_no_stored_km *ek_pub_km,
+				size_t *msg_sz)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 889

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {

These all look like programming mistakes that should result in a WARN_ON.

We are using the comp->mutex for protecting the interface during the interface init, usage for mei communication and interface teardown.

But what if mei interface teardown happens between mei communications? So when we try to access the mei interface after such possible tear down scenario, we are checking the integrity of the interface.

Possible alternate solution is hold the comp->mutex across the authentication steps. But consequence is that mei module removal will be blocked for authentication duration and even if the mei_dev is removed, component unbind will be blocked due to this mutex dependency.

Quoted 13 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 9 lines
drivers/gpu/drm/i915/intel_hdcp.c +9 -0
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_receiver_cert_prepare_km(comp->dev, data,
+							 rx_cert, paired,
+							 ek_pub_km, msg_sz);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);

Error handling here seems a bit strange. You close the session, but don't reset the port. So next op will be totally unaware that things have blown up. Also no warning.

Quoted 2 lines

If we want to close the session, then I think that should be a decision made higher up.

This is needed as explained above. But as you have mentioned this can be moved to the end of the authentication on error scenario. I will work on that.

Quoted 234 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 899

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	mutex_unlock(&comp->mutex);

With component do we still need this mutex stuff here?

Exact same comments everywhere below.

Quoted 229 lines
drivers/gpu/drm/i915/intel_hdcp.c +229 -0
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_hprime(struct intel_connector *connector,
+		    struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_hprime(comp->dev, data, rx_hprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_store_pairing_info(struct intel_connector *connector,
+			 struct hdcp2_ake_send_pairing_info *pairing_info)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->store_pairing_info(comp->dev,
+					    data, pairing_info);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_prepare_lc_init(struct intel_connector *connector,
+		      struct hdcp2_lc_init *lc_init)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->initiate_locality_check(comp->dev,
+						 data, lc_init);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_lprime(struct intel_connector *connector,
+		    struct hdcp2_lc_send_lprime *rx_lprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_lprime(comp->dev, data, rx_lprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_prepare_skey(struct intel_connector *connector,
+		       struct hdcp2_ske_send_eks *ske_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->get_session_key(comp->dev, data, ske_data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
+				      struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+				      struct hdcp2_rep_send_ack *rep_send_ack)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->repeater_check_flow_prepare_ack(comp->dev,
+							 data, rep_topology,
+							 rep_send_ack);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_mprime(struct intel_connector *connector,
+		    struct hdcp2_rep_stream_ready *stream_ready)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_mprime(comp->dev, data, stream_ready);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_authenticate_port(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->enable_hdcp_authentication(comp->dev, data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_close_mei_session(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1135

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	if (!comp->ops || !comp->dev ||
+	    data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->close_hdcp_session(comp->dev, data);

Need to reset the port here I think.

What is the reset of the port you are referring to? port is not
configured for encryption. And this is the call for marking the port as de-authenticated too.

Quoted 35 lines
Quoted 35 lines
drivers/gpu/drm/i915/intel_hdcp.c +35 -0
+	mutex_unlock(&comp->mutex);
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_deauthenticate_port(struct intel_connector *connector)
+{
+	return hdcp2_close_mei_session(connector);
+}
+
+static int i915_hdcp_component_master_bind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	return component_bind_all(dev, dev_priv->hdcp_comp);
+}
+
+static void intel_connectors_hdcp_disable(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+		if (!(intel_connector->hdcp.shim))
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 27 lines
Quoted 27 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
+	component_unbind_all(dev, dev_priv->hdcp_comp);
+}
+
+static const struct component_master_ops i915_hdcp_component_master_ops = {
+	.bind = i915_hdcp_component_master_bind,
+	.unbind = i915_hdcp_component_master_unbind,
+};
+
+static int i915_hdcp_component_match(struct device *dev, void *data)
+{
+	return !strcmp(dev->driver->name, "mei_hdcp");
+}
+
+static int intel_hdcp_component_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp;
+	struct component_match *match = NULL;
+	int ret;
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp)
+		return -ENOMEM;
+
+	mutex_init(&comp->mutex);
+	dev_priv->hdcp_comp = comp;
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1207

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	component_match_add(dev_priv->drm.dev, &match,
+			    i915_hdcp_component_match, dev_priv);
+	ret = component_master_add_with_match(dev_priv->drm.dev,
+					      &i915_hdcp_component_master_ops,
+					      match);

So I'm not sure this will work out well, hiding the master_ops here in hdcp. Definitely needs to be rewritten as soon as i915 needs another component. And might make the load/unload split complicated.

we have already discussed this.

Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1211

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	if (ret < 0)
+		goto out_err;
+
+	DRM_INFO("I915 hdcp component master added.\n");

You add both the master and the hdcp component here. Output is a bit confusing.

we have component master and a component from mei which will match to the master.

Here we are adding the component master.

Quoted 71 lines
Quoted 71 lines
drivers/gpu/drm/i915/intel_hdcp.c +57 -1
+	return ret;
+
+out_err:
+	component_master_del(dev_priv->drm.dev,
+			     &i915_hdcp_component_master_ops);
+	kfree(comp);
+	dev_priv->hdcp_comp = NULL;
+	DRM_ERROR("Failed to add i915 hdcp component master (%d)\n", ret);
+
+	return ret;
+}
+
+static int initialize_mei_hdcp_data(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct mei_hdcp_data *data = &hdcp->mei_data;
+	enum port port;
+
+	if (connector->encoder) {
+		port = connector->encoder->port;
+		data->port = GET_MEI_DDI_INDEX(port);
+	}
+
+	data->port_type = MEI_HDCP_PORT_TYPE_INTEGRATED;
+	data->protocol = hdcp->shim->hdcp_protocol();
+
+	data->k = 1;
+	if (!data->streams)
+		data->streams = kcalloc(data->k, sizeof(data->streams[0]),
+					GFP_KERNEL);
+	if (!data->streams) {
+		DRM_ERROR("Out of Memory\n");
+		return -ENOMEM;
+	}
+
+	data->streams[0].stream_id = 0;
+	data->streams[0].stream_type = hdcp->content_type;
+
+	return 0;
+}
+
  bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
  {
  	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
@@ -843,10 +1260,25 @@ static void intel_hdcp2_init(struct intel_connector *connector)
  {
  	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
  	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
 
  	WARN_ON(!is_hdcp2_supported(dev_priv));
 
-	/* TODO: MEI interface needs to be initialized here */
+	ret = initialize_mei_hdcp_data(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("Mei hdcp data init failed\n");
+		return;
+	}
+
+	if (!dev_priv->hdcp_comp)
+		ret = intel_hdcp_component_init(connector);
+
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP comp init failed\n");
+		kfree(hdcp->mei_data.streams);
+		return;
+	}
+
  	hdcp->hdcp2_supported = 1;
  }
 
Quoted 7 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_exit(struct drm_i915_private *dev_priv) · line 1329

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
@@ -894,9 +1326,17 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
  		mutex_lock(&intel_connector->hdcp.mutex);
  		intel_connector->hdcp.hdcp2_supported = 0;
  		intel_connector->hdcp.shim = NULL;
+		kfree(intel_connector->hdcp.mei_data.streams);

We need to push this into a per-connector hdcp cleanup function. Or just into the generic connector cleanup.

We could move it to per connector  hdcp cleanup function.

Quoted 34 lines
Quoted 34 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
  		mutex_unlock(&intel_connector->hdcp.mutex);
  	}
  	drm_connector_list_iter_end(&conn_iter);
+
+	if (dev_priv->hdcp_comp) {
+		component_master_del(dev_priv->drm.dev,
+				     &i915_hdcp_component_master_ops);
+		kfree(dev_priv->hdcp_comp);
+		dev_priv->hdcp_comp = NULL;
+	}
  }
 
  int intel_hdcp_enable(struct intel_connector *connector)
include/drm/i915_component.h +4 -0
index fca22d463e1b..12268228f4dc 100644
@@ -24,8 +24,12 @@
  #ifndef _I915_COMPONENT_H_
  #define _I915_COMPONENT_H_
 
+#include <linux/mutex.h>
+
  #include "drm_audio_component.h"
 
+#include <drm/drm_hdcp.h>
+
  /* MAX_PORT is the number of port
   * It must be sync with I915_MAX_PORTS defined i915_drv.h
   */
@@ -46,4 +50,71 @@ struct i915_audio_component {
  	int aud_sample_rate[MAX_PORTS];
  };
 
Quoted 5 lines
Quoted 3 lines

include/drm/i915_component.h struct i915_audio_component { · line 53

Quoted 1 line
include/drm/i915_component.h +1 -0
+struct i915_hdcp_component_ops {

Imo that should be called mei_hdcp_component_ops and put into the linux/mei_hdcp.h header. Or was that Thomas' review comment?

Nope this is there for many versions. i915_hdcp_component_ops are implemented by mei_hdcp.c and initializes the component with the &ops.

Tomas and Daniel,

Is this fine? Defining the ops at i915_component.h and I915 and mei_hdcp using it for their purpose?

If it has to be compulsorily defined by the service provider then we need to move this into the include/linux/mei_hdcp.h. In that we can avoid the global header from the mei_hdcp Tomas. Please help here to clarify the direction.

-Ram

Quoted 72 lines
Quoted 2 lines

Aside: Review here in public channels instead of in private would be much better for coordination.

Tomas,
Could you please help on this ask.?
--Ram

Quoted 67 lines
Quoted 67 lines
include/drm/i915_component.h +66 -0
+	/**
+	 * @owner: mei_hdcp module
+	 */
+	struct module *owner;
+
+	int (*initiate_hdcp2_session)(struct device *dev,
+				      void *hdcp_data,
+				      struct hdcp2_ake_init *ake_data);
+	int (*verify_receiver_cert_prepare_km)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_ake_send_cert
+								*rx_cert,
+					       bool *km_stored,
+					       struct hdcp2_ake_no_stored_km
+								*ek_pub_km,
+					       size_t *msg_sz);
+	int (*verify_hprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_ake_send_hprime *rx_hprime);
+	int (*store_pairing_info)(struct device *dev,
+				  void *hdcp_data,
+				  struct hdcp2_ake_send_pairing_info
+								*pairing_info);
+	int (*initiate_locality_check)(struct device *dev,
+				       void *hdcp_data,
+				       struct hdcp2_lc_init *lc_init_data);
+	int (*verify_lprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_lc_send_lprime *rx_lprime);
+	int (*get_session_key)(struct device *dev,
+			       void *hdcp_data,
+			       struct hdcp2_ske_send_eks *ske_data);
+	int (*repeater_check_flow_prepare_ack)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+					       struct hdcp2_rep_send_ack
+								*rep_send_ack);
+	int (*verify_mprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_rep_stream_ready *stream_ready);
+	int (*enable_hdcp_authentication)(struct device *dev,
+					  void *hdcp_data);
+	int (*close_hdcp_session)(struct device *dev,
+				  void *hdcp_data);
+};
+
+/**
+ * struct i915_hdcp_component_master - Used for communication between i915
+ * and mei_hdcp for HDCP2.2 services.
+ */
+struct i915_hdcp_component_master {
+	/**
+	 * @dev: a device providing hdcp
+	 */
+	struct device *dev;
+	/**
+	 * @mutex: Mutex to protect the state of dev
+	 */
+	struct mutex mutex;
+	/**
+	 * @ops: Ops implemented by mei_hdcp driver, used by i915 driver.
+	 */
+	const struct i915_hdcp_component_ops *ops;
+};
+
  #endif /* _I915_COMPONENT_H_ */
Quoted 8 lines
Quoted 3 lines
Quoted 3 lines
Signature · 1 line
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#19 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 633 lines · Ramalingam
Quoted 628 lines · Ramalingam
Quoted 37 lines · Daniel Vetter
Quoted 36 lines · Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
  drivers/gpu/drm/i915/i915_drv.h   |   2 +
  drivers/gpu/drm/i915/intel_drv.h  |   7 +
  drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
  include/drm/i915_component.h      |  71 ++++++
  4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
  	struct i915_pmu pmu;
+	struct i915_hdcp_component_master *hdcp_comp;
+
  	/*
  	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
  	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
  #include <linux/i2c.h>
  #include <linux/hdmi.h>
  #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
  #include <drm/i915_drm.h>
  #include "i915_drv.h"
  #include <drm/drm_crtc.h>
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp_shim { · line 385

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  	/* Detects panel's hdcp capability. This is optional for HDMI. */
  	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
  			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);

Looking ahead, this seems hardwired to constant return value? Or why do we need a function here?

This is hardwired based on the connector type(DP/HDMI).
Since we have the shim for hdcp's connector based work, I have added this function.

Could have done this just with connector_type check, but in that way whole hdcp_shim can be done in that way. So going with the larger design here.

Quoted 52 lines
Quoted 52 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  };
  struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
  	 * content can flow only through a link protected by HDCP2.2.
  	 */
  	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
  };
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +23 -0
index 99dddb540958..760780f1105c 100644
@@ -8,14 +8,20 @@
  #include <drm/drmP.h>
  #include <drm/drm_hdcp.h>
+#include <drm/i915_component.h>
  #include <linux/i2c.h>
  #include <linux/random.h>
+#include <linux/component.h>
  #include "intel_drv.h"
  #include "i915_reg.h"
  #define KEY_LOAD_TRIES	5
  #define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
+#define GET_MEI_DDI_INDEX(p) ({                            \
+	typeof(p) __p = (p);                               \
+	__p == PORT_A ? MEI_DDI_A : (enum mei_hdcp_ddi)__p;\
+})
  static
  bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -833,6 +839,417 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
+static __attribute__((unused)) int
+hdcp2_prepare_ake_init(struct intel_connector *connector,
+		       struct hdcp2_ake_init *ake_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 864

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);
+
+	/* Clear ME FW instance for the port, just incase */
+	comp->ops->close_hdcp_session(comp->dev, data);

Sounds like a bug somewhere if we need this? I'd put this code into the ->initiate_hdcp2_session, with a big WARN_ON if it's actually needed.

Not really. Lets say you have progressed beyond the first step of HDCP2.2 auth along with ME FW. Now if authentication failed due to some reason, then the HDCP2.2 season created with ME FW for that port is not closed yet.

So we need to call close_hdcp_session() explicitly on authentication failures. Session has to be closed before restarting the auth on that port with initialite_hdcp_session. If we are closing the hdcp session of the port on all auth errors, we dont need this just before start of the hdcp session.

Quoted 7 lines

"Just in case" papering over programming bugs of our own just makes debugging harder.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 867

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+
+	ret = comp->ops->initiate_hdcp2_session(comp->dev,
+						data, ake_data);

We should set the port only after successfully initializing this.

hdcp2_session is created for each port at ME FW. Hence we need the port initialized even before calling the initiate_hdcp2_session.

Quoted 15 lines
Quoted 15 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -0
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
+				struct hdcp2_ake_send_cert *rx_cert,
+				bool *paired,
+				struct hdcp2_ake_no_stored_km *ek_pub_km,
+				size_t *msg_sz)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 889

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {

These all look like programming mistakes that should result in a WARN_ON.

We are using the comp->mutex for protecting the interface during the interface init, usage for mei communication and interface teardown.

But what if mei interface teardown happens between mei communications? So when we try to access the mei interface after such possible tear down scenario, we are checking the integrity of the interface.

Possible alternate solution is hold the comp->mutex across the authentication steps. But consequence is that mei module removal will be blocked for authentication duration and even if the mei_dev is removed, component unbind will be blocked due to this mutex dependency.

Quoted 13 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 9 lines
drivers/gpu/drm/i915/intel_hdcp.c +9 -0
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_receiver_cert_prepare_km(comp->dev, data,
+							 rx_cert, paired,
+							 ek_pub_km, msg_sz);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);

Error handling here seems a bit strange. You close the session, but don't reset the port. So next op will be totally unaware that things have blown up. Also no warning.

Quoted 2 lines

If we want to close the session, then I think that should be a decision made higher up.

This is needed as explained above. But as you have mentioned this can be moved to the end of the authentication on error scenario. I will work on that.

Quoted 234 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	mutex_unlock(&comp->mutex);

With component do we still need this mutex stuff here?

Exact same comments everywhere below.

Quoted 229 lines
drivers/gpu/drm/i915/intel_hdcp.c +229 -0
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_hprime(struct intel_connector *connector,
+		    struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_hprime(comp->dev, data, rx_hprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_store_pairing_info(struct intel_connector *connector,
+			 struct hdcp2_ake_send_pairing_info *pairing_info)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->store_pairing_info(comp->dev,
+					    data, pairing_info);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_prepare_lc_init(struct intel_connector *connector,
+		      struct hdcp2_lc_init *lc_init)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->initiate_locality_check(comp->dev,
+						 data, lc_init);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_lprime(struct intel_connector *connector,
+		    struct hdcp2_lc_send_lprime *rx_lprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_lprime(comp->dev, data, rx_lprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_prepare_skey(struct intel_connector *connector,
+		       struct hdcp2_ske_send_eks *ske_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->get_session_key(comp->dev, data, ske_data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
+				      struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+				      struct hdcp2_rep_send_ack *rep_send_ack)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->repeater_check_flow_prepare_ack(comp->dev,
+							 data, rep_topology,
+							 rep_send_ack);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_mprime(struct intel_connector *connector,
+		    struct hdcp2_rep_stream_ready *stream_ready)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_mprime(comp->dev, data, stream_ready);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_authenticate_port(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->enable_hdcp_authentication(comp->dev, data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_close_mei_session(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1135

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	if (!comp->ops || !comp->dev ||
+	    data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->close_hdcp_session(comp->dev, data);

Need to reset the port here I think.

What is the reset of the port you are referring to? port is not
configured for encryption. And this is the call for marking the port as de-authenticated too.

Quoted 35 lines
Quoted 35 lines
drivers/gpu/drm/i915/intel_hdcp.c +35 -0
+	mutex_unlock(&comp->mutex);
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_deauthenticate_port(struct intel_connector *connector)
+{
+	return hdcp2_close_mei_session(connector);
+}
+
+static int i915_hdcp_component_master_bind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	return component_bind_all(dev, dev_priv->hdcp_comp);
+}
+
+static void intel_connectors_hdcp_disable(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+		if (!(intel_connector->hdcp.shim))
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 27 lines
Quoted 27 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
+	component_unbind_all(dev, dev_priv->hdcp_comp);
+}
+
+static const struct component_master_ops i915_hdcp_component_master_ops = {
+	.bind = i915_hdcp_component_master_bind,
+	.unbind = i915_hdcp_component_master_unbind,
+};
+
+static int i915_hdcp_component_match(struct device *dev, void *data)
+{
+	return !strcmp(dev->driver->name, "mei_hdcp");
+}
+
+static int intel_hdcp_component_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp;
+	struct component_match *match = NULL;
+	int ret;
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp)
+		return -ENOMEM;
+
+	mutex_init(&comp->mutex);
+	dev_priv->hdcp_comp = comp;
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1207

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	component_match_add(dev_priv->drm.dev, &match,
+			    i915_hdcp_component_match, dev_priv);
+	ret = component_master_add_with_match(dev_priv->drm.dev,
+					      &i915_hdcp_component_master_ops,
+					      match);

So I'm not sure this will work out well, hiding the master_ops here in hdcp. Definitely needs to be rewritten as soon as i915 needs another component. And might make the load/unload split complicated.

we have already discussed this.

Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1211

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	if (ret < 0)
+		goto out_err;
+
+	DRM_INFO("I915 hdcp component master added.\n");

You add both the master and the hdcp component here. Output is a bit confusing.

we have component master and a component from mei which will match to the master.

Here we are adding the component master.

Quoted 67 lines
Quoted 67 lines
drivers/gpu/drm/i915/intel_hdcp.c +57 -1
+	return ret;
+
+out_err:
+	component_master_del(dev_priv->drm.dev,
+			     &i915_hdcp_component_master_ops);
+	kfree(comp);
+	dev_priv->hdcp_comp = NULL;
+	DRM_ERROR("Failed to add i915 hdcp component master (%d)\n", ret);
+
+	return ret;
+}
+
+static int initialize_mei_hdcp_data(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct mei_hdcp_data *data = &hdcp->mei_data;
+	enum port port;
+
+	if (connector->encoder) {
+		port = connector->encoder->port;
+		data->port = GET_MEI_DDI_INDEX(port);
+	}
+
+	data->port_type = MEI_HDCP_PORT_TYPE_INTEGRATED;
+	data->protocol = hdcp->shim->hdcp_protocol();
+
+	data->k = 1;
+	if (!data->streams)
+		data->streams = kcalloc(data->k, sizeof(data->streams[0]),
+					GFP_KERNEL);
+	if (!data->streams) {
+		DRM_ERROR("Out of Memory\n");
+		return -ENOMEM;
+	}
+
+	data->streams[0].stream_id = 0;
+	data->streams[0].stream_type = hdcp->content_type;
+
+	return 0;
+}
+
  bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
  {
  	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
@@ -843,10 +1260,25 @@ static void intel_hdcp2_init(struct intel_connector *connector)
  {
  	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
  	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
  	WARN_ON(!is_hdcp2_supported(dev_priv));
-	/* TODO: MEI interface needs to be initialized here */
+	ret = initialize_mei_hdcp_data(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("Mei hdcp data init failed\n");
+		return;
+	}
+
+	if (!dev_priv->hdcp_comp)
+		ret = intel_hdcp_component_init(connector);
+
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP comp init failed\n");
+		kfree(hdcp->mei_data.streams);
+		return;
+	}
+
  	hdcp->hdcp2_supported = 1;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_exit(struct drm_i915_private *dev_priv) · line 1329

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
  }
@@ -894,9 +1326,17 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
  		mutex_lock(&intel_connector->hdcp.mutex);
  		intel_connector->hdcp.hdcp2_supported = 0;
  		intel_connector->hdcp.shim = NULL;
+		kfree(intel_connector->hdcp.mei_data.streams);

We need to push this into a per-connector hdcp cleanup function. Or just into the generic connector cleanup.

We could move it to per connector  hdcp cleanup function.

Quoted 25 lines
Quoted 25 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
  		mutex_unlock(&intel_connector->hdcp.mutex);
  	}
  	drm_connector_list_iter_end(&conn_iter);
+
+	if (dev_priv->hdcp_comp) {
+		component_master_del(dev_priv->drm.dev,
+				     &i915_hdcp_component_master_ops);
+		kfree(dev_priv->hdcp_comp);
+		dev_priv->hdcp_comp = NULL;
+	}
  }
  int intel_hdcp_enable(struct intel_connector *connector)
include/drm/i915_component.h +4 -0
index fca22d463e1b..12268228f4dc 100644
@@ -24,8 +24,12 @@
  #ifndef _I915_COMPONENT_H_
  #define _I915_COMPONENT_H_
+#include <linux/mutex.h>
+
  #include "drm_audio_component.h"
+#include <drm/drm_hdcp.h>
+
  /* MAX_PORT is the number of port
Quoted 8 lines

include/drm/i915_component.h struct i915_audio_component { · line 52

Quoted 6 lines
include/drm/i915_component.h +1 -0
   * It must be sync with I915_MAX_PORTS defined i915_drv.h
   */
@@ -46,4 +50,71 @@ struct i915_audio_component {
  	int aud_sample_rate[MAX_PORTS];
  };
+struct i915_hdcp_component_ops {

Imo that should be called mei_hdcp_component_ops and put into the linux/mei_hdcp.h header. Or was that Thomas' review comment?

Quoted 2 lines

Nope this is there for many versions. i915_hdcp_component_ops are implemented by mei_hdcp.c and initializes the component with the &ops.

Quoted 8 lines

Tomas and Daniel,

Is this fine? Defining the ops at i915_component.h and I915 and mei_hdcp using it for their purpose?

If it has to be compulsorily defined by the service provider then we need to move this into the include/linux/mei_hdcp.h. In that we can avoid the global header from the mei_hdcp Tomas. Please help here to clarify the direction.

Let's move this discussion to the other reply chain, to avoid splitting discussion up too much.
-Daniel

Quoted 83 lines

-Ram

Quoted 80 lines
Quoted 2 lines

Aside: Review here in public channels instead of in private would be much better for coordination.

Tomas,
Could you please help on this ask.?
--Ram

Quoted 62 lines
Quoted 62 lines
include/drm/i915_component.h +62 -0
+	/**
+	 * @owner: mei_hdcp module
+	 */
+	struct module *owner;
+
+	int (*initiate_hdcp2_session)(struct device *dev,
+				      void *hdcp_data,
+				      struct hdcp2_ake_init *ake_data);
+	int (*verify_receiver_cert_prepare_km)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_ake_send_cert
+								*rx_cert,
+					       bool *km_stored,
+					       struct hdcp2_ake_no_stored_km
+								*ek_pub_km,
+					       size_t *msg_sz);
+	int (*verify_hprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_ake_send_hprime *rx_hprime);
+	int (*store_pairing_info)(struct device *dev,
+				  void *hdcp_data,
+				  struct hdcp2_ake_send_pairing_info
+								*pairing_info);
+	int (*initiate_locality_check)(struct device *dev,
+				       void *hdcp_data,
+				       struct hdcp2_lc_init *lc_init_data);
+	int (*verify_lprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_lc_send_lprime *rx_lprime);
+	int (*get_session_key)(struct device *dev,
+			       void *hdcp_data,
+			       struct hdcp2_ske_send_eks *ske_data);
+	int (*repeater_check_flow_prepare_ack)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+					       struct hdcp2_rep_send_ack
+								*rep_send_ack);
+	int (*verify_mprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_rep_stream_ready *stream_ready);
+	int (*enable_hdcp_authentication)(struct device *dev,
+					  void *hdcp_data);
+	int (*close_hdcp_session)(struct device *dev,
+				  void *hdcp_data);
+};
+
+/**
+ * struct i915_hdcp_component_master - Used for communication between i915
+ * and mei_hdcp for HDCP2.2 services.
+ */
+struct i915_hdcp_component_master {
+	/**
+	 * @dev: a device providing hdcp
+	 */
+	struct device *dev;
+	/**
+	 * @mutex: Mutex to protect the state of dev
+	 */
+	struct mutex mutex;
+	/**
+	 * @ops: Ops implemented by mei_hdcp driver, used by i915 driver.
Quoted 8 lines
Quoted 8 lines
include/drm/i915_component.h +4 -0
+	 */
+	const struct i915_hdcp_component_ops *ops;
+};
+
  #endif /* _I915_COMPONENT_H_ */
Signature · 1 line
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#20 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

In reply to C, Ramalingam
Quoted 48 lines · Ramalingam
Quoted 37 lines · Daniel Vetter
Quoted 36 lines · Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
  drivers/gpu/drm/i915/i915_drv.h   |   2 +
  drivers/gpu/drm/i915/intel_drv.h  |   7 +
  drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
  include/drm/i915_component.h      |  71 ++++++
  4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
  	struct i915_pmu pmu;
+	struct i915_hdcp_component_master *hdcp_comp;
+
  	/*
  	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
  	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
  #include <linux/i2c.h>
  #include <linux/hdmi.h>
  #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
  #include <drm/i915_drm.h>
  #include "i915_drv.h"
  #include <drm/drm_crtc.h>
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp_shim { · line 385

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  	/* Detects panel's hdcp capability. This is optional for HDMI. */
  	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
  			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);

Looking ahead, this seems hardwired to constant return value? Or why do we need a function here?

Quoted 5 lines

This is hardwired based on the connector type(DP/HDMI).
Since we have the shim for hdcp's connector based work, I have added this function.

Could have done this just with connector_type check, but in that way whole hdcp_shim can be done in that way. So going with the larger design here.

If it's hardwired then just make it a hardwired struct member. As long as it's all const, we can mix data an function pointers. If you have runtime variable data, then it's better to split it out from the ops structure, so that we can keep ops read-only and protected against possible exploits (any function pointers are a high-value target in the kernel).

Quoted 63 lines
Quoted 54 lines
Quoted 54 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
  };
  struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
  	 * content can flow only through a link protected by HDCP2.2.
  	 */
  	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
  };
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +23 -0
index 99dddb540958..760780f1105c 100644
@@ -8,14 +8,20 @@
  #include <drm/drmP.h>
  #include <drm/drm_hdcp.h>
+#include <drm/i915_component.h>
  #include <linux/i2c.h>
  #include <linux/random.h>
+#include <linux/component.h>
  #include "intel_drv.h"
  #include "i915_reg.h"
  #define KEY_LOAD_TRIES	5
  #define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
+#define GET_MEI_DDI_INDEX(p) ({                            \
+	typeof(p) __p = (p);                               \
+	__p == PORT_A ? MEI_DDI_A : (enum mei_hdcp_ddi)__p;\
+})
  static
  bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -833,6 +839,417 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
  		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
  }
+static __attribute__((unused)) int
+hdcp2_prepare_ake_init(struct intel_connector *connector,
+		       struct hdcp2_ake_init *ake_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 864

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);
+
+	/* Clear ME FW instance for the port, just incase */
+	comp->ops->close_hdcp_session(comp->dev, data);

Sounds like a bug somewhere if we need this? I'd put this code into the ->initiate_hdcp2_session, with a big WARN_ON if it's actually needed.

Quoted 8 lines

Not really. Lets say you have progressed beyond the first step of HDCP2.2 auth along with ME FW. Now if authentication failed due to some reason, then the HDCP2.2 season created with ME FW for that port is not closed yet.

So we need to call close_hdcp_session() explicitly on authentication failures. Session has to be closed before restarting the auth on that port with initialite_hdcp_session. If we are closing the hdcp session of the port on all auth errors, we dont need this just before start of the hdcp session.

Yeah, makes sense. But right now the close_session stuff is sprinkled all over, so it's hard to see what's going on and whether there's bugs somewhere. I much prefer code that looks like it knows what it's doing. I think one top-level close_session call in the main hdcp2 functions (called when everything is done, or on failure) would be much cleaner.

Plus then some WARN_ON to make sure we never forget to close a session. Sprinkling cleanup code all over the place looks like it's easier, but long term it's much harder code to maintain and refactor because you never sure which cleanup code is actually doing the cleanup, and which cleanup code is just there for nothing.

Quoted 10 lines
Quoted 9 lines

"Just in case" papering over programming bugs of our own just makes debugging harder.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 867

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+
+	ret = comp->ops->initiate_hdcp2_session(comp->dev,
+						data, ake_data);

We should set the port only after successfully initializing this.

Quoted 5 lines

hdcp2_session is created for each port at ME FW. Hence we need the port initialized even before calling the initiate_hdcp2_session.

Quoted 2 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 861

Quoted 2 lines
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);

This line right above in your patch should only run on success. I think.

Also, looking at this again: Why could connector->encoder ever be NULL? That smells like another possible bug in our setup code. Better to wrap this in a WARN_ON and bail out.

Quoted 29 lines
Quoted 17 lines
Quoted 17 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -0
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
+				struct hdcp2_ake_send_cert *rx_cert,
+				bool *paired,
+				struct hdcp2_ake_no_stored_km *ek_pub_km,
+				size_t *msg_sz)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 889

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {

These all look like programming mistakes that should result in a WARN_ON.

We are using the comp->mutex for protecting the interface during the interface init, usage for mei communication and interface teardown.

Quoted 7 lines

But what if mei interface teardown happens between mei communications? So when we try to access the mei interface after such possible tear down scenario, we are checking the integrity of the interface.

Possible alternate solution is hold the comp->mutex across the authentication steps. But consequence is that mei module removal will be blocked for authentication duration and even if the mei_dev is removed, component unbind will be blocked due to this mutex dependency.

I think with the v7 component code this should all be impossible and we can remove it. With the v8 component code it's definitely necessary (which is why I don't like the v8 component code). This is all because I didn't fully realize the changes with v8 when reading the patches again ...

Quoted 15 lines
Quoted 15 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 11 lines
drivers/gpu/drm/i915/intel_hdcp.c +9 -0
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_receiver_cert_prepare_km(comp->dev, data,
+							 rx_cert, paired,
+							 ek_pub_km, msg_sz);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);

Error handling here seems a bit strange. You close the session, but don't reset the port. So next op will be totally unaware that things have blown up. Also no warning.

Quoted 5 lines
Quoted 2 lines

If we want to close the session, then I think that should be a decision made higher up.

This is needed as explained above. But as you have mentioned this can be moved to the end of the authentication on error scenario. I will work on that.

Yeah, I think that'll lead to cleaner code.

Quoted 293 lines
Quoted 236 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 900

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	mutex_unlock(&comp->mutex);

With component do we still need this mutex stuff here?

Exact same comments everywhere below.

Quoted 229 lines
drivers/gpu/drm/i915/intel_hdcp.c +229 -0
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_hprime(struct intel_connector *connector,
+		    struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_hprime(comp->dev, data, rx_hprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_store_pairing_info(struct intel_connector *connector,
+			 struct hdcp2_ake_send_pairing_info *pairing_info)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->store_pairing_info(comp->dev,
+					    data, pairing_info);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_prepare_lc_init(struct intel_connector *connector,
+		      struct hdcp2_lc_init *lc_init)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->initiate_locality_check(comp->dev,
+						 data, lc_init);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_lprime(struct intel_connector *connector,
+		    struct hdcp2_lc_send_lprime *rx_lprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_lprime(comp->dev, data, rx_lprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_prepare_skey(struct intel_connector *connector,
+		       struct hdcp2_ske_send_eks *ske_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->get_session_key(comp->dev, data, ske_data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
+				      struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+				      struct hdcp2_rep_send_ack *rep_send_ack)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->repeater_check_flow_prepare_ack(comp->dev,
+							 data, rep_topology,
+							 rep_send_ack);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_mprime(struct intel_connector *connector,
+		    struct hdcp2_rep_stream_ready *stream_ready)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_mprime(comp->dev, data, stream_ready);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_authenticate_port(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->enable_hdcp_authentication(comp->dev, data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_close_mei_session(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1135

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	if (!comp->ops || !comp->dev ||
+	    data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->close_hdcp_session(comp->dev, data);

Need to reset the port here I think.

What is the reset of the port you are referring to? port is not
configured for encryption. And this is the call for marking the port as de-authenticated too.

Quoted 36 lines
Quoted 36 lines
drivers/gpu/drm/i915/intel_hdcp.c +35 -0
+	mutex_unlock(&comp->mutex);
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_deauthenticate_port(struct intel_connector *connector)
+{
+	return hdcp2_close_mei_session(connector);
+}
+
+static int i915_hdcp_component_master_bind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	return component_bind_all(dev, dev_priv->hdcp_comp);
+}
+
+static void intel_connectors_hdcp_disable(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+		if (!(intel_connector->hdcp.shim))
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

Quoted 4 lines

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

I looked at your v7 component code again. I think if we put the drm_atomic_helper_shutdown() call into master_unbind, then we'll have taken care of that. Essentially what you're doing here is open-coding part of that function. Better to just move the existing call to the right place.

And shutting down the entire hw is kinda what master_unbind should be doing I think. We might also need to move the general hw quiescent into master_unbind, that should work too.

Quoted 127 lines
Quoted 29 lines
Quoted 29 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
+	component_unbind_all(dev, dev_priv->hdcp_comp);
+}
+
+static const struct component_master_ops i915_hdcp_component_master_ops = {
+	.bind = i915_hdcp_component_master_bind,
+	.unbind = i915_hdcp_component_master_unbind,
+};
+
+static int i915_hdcp_component_match(struct device *dev, void *data)
+{
+	return !strcmp(dev->driver->name, "mei_hdcp");
+}
+
+static int intel_hdcp_component_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp;
+	struct component_match *match = NULL;
+	int ret;
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp)
+		return -ENOMEM;
+
+	mutex_init(&comp->mutex);
+	dev_priv->hdcp_comp = comp;
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1207

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	component_match_add(dev_priv->drm.dev, &match,
+			    i915_hdcp_component_match, dev_priv);
+	ret = component_master_add_with_match(dev_priv->drm.dev,
+					      &i915_hdcp_component_master_ops,
+					      match);

So I'm not sure this will work out well, hiding the master_ops here in hdcp. Definitely needs to be rewritten as soon as i915 needs another component. And might make the load/unload split complicated.

we have already discussed this.

Quoted 7 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1211

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	if (ret < 0)
+		goto out_err;
+
+	DRM_INFO("I915 hdcp component master added.\n");

You add both the master and the hdcp component here. Output is a bit confusing.

we have component master and a component from mei which will match to the master.

Here we are adding the component master.

Quoted 68 lines
Quoted 68 lines
drivers/gpu/drm/i915/intel_hdcp.c +57 -1
+	return ret;
+
+out_err:
+	component_master_del(dev_priv->drm.dev,
+			     &i915_hdcp_component_master_ops);
+	kfree(comp);
+	dev_priv->hdcp_comp = NULL;
+	DRM_ERROR("Failed to add i915 hdcp component master (%d)\n", ret);
+
+	return ret;
+}
+
+static int initialize_mei_hdcp_data(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct mei_hdcp_data *data = &hdcp->mei_data;
+	enum port port;
+
+	if (connector->encoder) {
+		port = connector->encoder->port;
+		data->port = GET_MEI_DDI_INDEX(port);
+	}
+
+	data->port_type = MEI_HDCP_PORT_TYPE_INTEGRATED;
+	data->protocol = hdcp->shim->hdcp_protocol();
+
+	data->k = 1;
+	if (!data->streams)
+		data->streams = kcalloc(data->k, sizeof(data->streams[0]),
+					GFP_KERNEL);
+	if (!data->streams) {
+		DRM_ERROR("Out of Memory\n");
+		return -ENOMEM;
+	}
+
+	data->streams[0].stream_id = 0;
+	data->streams[0].stream_type = hdcp->content_type;
+
+	return 0;
+}
+
  bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
  {
  	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
@@ -843,10 +1260,25 @@ static void intel_hdcp2_init(struct intel_connector *connector)
  {
  	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
  	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
  	WARN_ON(!is_hdcp2_supported(dev_priv));
-	/* TODO: MEI interface needs to be initialized here */
+	ret = initialize_mei_hdcp_data(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("Mei hdcp data init failed\n");
+		return;
+	}
+
+	if (!dev_priv->hdcp_comp)
+		ret = intel_hdcp_component_init(connector);
+
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP comp init failed\n");
+		kfree(hdcp->mei_data.streams);
+		return;
+	}
+
  	hdcp->hdcp2_supported = 1;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_exit(struct drm_i915_private *dev_priv) · line 1329

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
  }
@@ -894,9 +1326,17 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
  		mutex_lock(&intel_connector->hdcp.mutex);
  		intel_connector->hdcp.hdcp2_supported = 0;
  		intel_connector->hdcp.shim = NULL;
+		kfree(intel_connector->hdcp.mei_data.streams);

We need to push this into a per-connector hdcp cleanup function. Or just into the generic connector cleanup.

Quoted 1 line

We could move it to per connector  hdcp cleanup function.

Yeah I think that would be cleaner.

Quoted 35 lines
Quoted 26 lines
Quoted 26 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
  		mutex_unlock(&intel_connector->hdcp.mutex);
  	}
  	drm_connector_list_iter_end(&conn_iter);
+
+	if (dev_priv->hdcp_comp) {
+		component_master_del(dev_priv->drm.dev,
+				     &i915_hdcp_component_master_ops);
+		kfree(dev_priv->hdcp_comp);
+		dev_priv->hdcp_comp = NULL;
+	}
  }
  int intel_hdcp_enable(struct intel_connector *connector)
include/drm/i915_component.h +4 -0
index fca22d463e1b..12268228f4dc 100644
@@ -24,8 +24,12 @@
  #ifndef _I915_COMPONENT_H_
  #define _I915_COMPONENT_H_
+#include <linux/mutex.h>
+
  #include "drm_audio_component.h"
+#include <drm/drm_hdcp.h>
+
  /* MAX_PORT is the number of port
Quoted 8 lines

include/drm/i915_component.h struct i915_audio_component { · line 52

Quoted 6 lines
include/drm/i915_component.h +1 -0
   * It must be sync with I915_MAX_PORTS defined i915_drv.h
   */
@@ -46,4 +50,71 @@ struct i915_audio_component {
  	int aud_sample_rate[MAX_PORTS];
  };
+struct i915_hdcp_component_ops {

Imo that should be called mei_hdcp_component_ops and put into the linux/mei_hdcp.h header. Or was that Thomas' review comment?

Quoted 2 lines

Nope this is there for many versions. i915_hdcp_component_ops are implemented by mei_hdcp.c and initializes the component with the &ops.

I summarized all the discussion around the i915/mei_hdcp interface in the thread in an earlier patch in this series.

Cheers, Daniel

Quoted 82 lines
Quoted 4 lines

Aside: Review here in public channels instead of in private would be much better for coordination.

Tomas,

Could you please help on this ask.?

--Ram

Quoted 71 lines
Quoted 71 lines
include/drm/i915_component.h +66 -0
+	/**
+	 * @owner: mei_hdcp module
+	 */
+	struct module *owner;
+
+	int (*initiate_hdcp2_session)(struct device *dev,
+				      void *hdcp_data,
+				      struct hdcp2_ake_init *ake_data);
+	int (*verify_receiver_cert_prepare_km)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_ake_send_cert
+								*rx_cert,
+					       bool *km_stored,
+					       struct hdcp2_ake_no_stored_km
+								*ek_pub_km,
+					       size_t *msg_sz);
+	int (*verify_hprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_ake_send_hprime *rx_hprime);
+	int (*store_pairing_info)(struct device *dev,
+				  void *hdcp_data,
+				  struct hdcp2_ake_send_pairing_info
+								*pairing_info);
+	int (*initiate_locality_check)(struct device *dev,
+				       void *hdcp_data,
+				       struct hdcp2_lc_init *lc_init_data);
+	int (*verify_lprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_lc_send_lprime *rx_lprime);
+	int (*get_session_key)(struct device *dev,
+			       void *hdcp_data,
+			       struct hdcp2_ske_send_eks *ske_data);
+	int (*repeater_check_flow_prepare_ack)(struct device *dev,
+					       void *hdcp_data,
+					       struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+					       struct hdcp2_rep_send_ack
+								*rep_send_ack);
+	int (*verify_mprime)(struct device *dev,
+			     void *hdcp_data,
+			     struct hdcp2_rep_stream_ready *stream_ready);
+	int (*enable_hdcp_authentication)(struct device *dev,
+					  void *hdcp_data);
+	int (*close_hdcp_session)(struct device *dev,
+				  void *hdcp_data);
+};
+
+/**
+ * struct i915_hdcp_component_master - Used for communication between i915
+ * and mei_hdcp for HDCP2.2 services.
+ */
+struct i915_hdcp_component_master {
+	/**
+	 * @dev: a device providing hdcp
+	 */
+	struct device *dev;
+	/**
+	 * @mutex: Mutex to protect the state of dev
+	 */
+	struct mutex mutex;
+	/**
+	 * @ops: Ops implemented by mei_hdcp driver, used by i915 driver.
+	 */
+	const struct i915_hdcp_component_ops *ops;
+};
+
  #endif /* _I915_COMPONENT_H_ */
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#21 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 50 lines · Daniel Vetter
Quoted 49 lines · Ramalingam
Quoted 37 lines · Daniel Vetter
Quoted 36 lines · Ramalingam C

Defining the mei-i915 interface functions and initialization of the interface.

---
   drivers/gpu/drm/i915/i915_drv.h   |   2 +
   drivers/gpu/drm/i915/intel_drv.h  |   7 +
   drivers/gpu/drm/i915/intel_hdcp.c | 442 +++++++++++++++++++++++++++++++++++++-
   include/drm/i915_component.h      |  71 ++++++
   4 files changed, 521 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +2 -0
index f763b30f98d9..b68bc980b7cd 100644
@@ -2015,6 +2015,8 @@ struct drm_i915_private {
   	struct i915_pmu pmu;
+	struct i915_hdcp_component_master *hdcp_comp;
+
   	/*
   	 * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch
   	 * will be rejected. Instead look for a better place.
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 85a526598096..bde82f3ada85 100644
@@ -29,6 +29,7 @@
   #include <linux/i2c.h>
   #include <linux/hdmi.h>
   #include <linux/sched/clock.h>
+#include <linux/mei_hdcp.h>
   #include <drm/i915_drm.h>
   #include "i915_drv.h"
   #include <drm/drm_crtc.h>
@@ -379,6 +380,9 @@ struct intel_hdcp_shim {
Quoted 8 lines

drivers/gpu/drm/i915/intel_drv.h struct intel_hdcp_shim { · line 385

Quoted 6 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
   	/* Detects panel's hdcp capability. This is optional for HDMI. */
   	int (*hdcp_capable)(struct intel_digital_port *intel_dig_port,
   			    bool *hdcp_capable);
+
+	/* Detects the HDCP protocol(DP/HDMI) required on the port */
+	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);

Looking ahead, this seems hardwired to constant return value? Or why do we need a function here?

This is hardwired based on the connector type(DP/HDMI).
Since we have the shim for hdcp's connector based work, I have added this function.

Quoted 7 lines
Quoted 2 lines

Could have done this just with connector_type check, but in that way whole hdcp_shim can be done in that way. So going with the larger design here.

If it's hardwired then just make it a hardwired struct member. As long as it's all const, we can mix data an function pointers. If you have runtime variable data, then it's better to split it out from the ops structure, so that we can keep ops read-only and protected against possible exploits (any function pointers are a high-value target in the kernel).

Sure. Done.

Quoted 68 lines
Quoted 60 lines
Quoted 52 lines
Quoted 52 lines
drivers/gpu/drm/i915/intel_drv.h +3 -0
   };
   struct intel_hdcp {
@@ -399,6 +403,9 @@ struct intel_hdcp {
   	 * content can flow only through a link protected by HDCP2.2.
   	 */
   	u8 content_type;
+
+	/* mei interface related information */
+	struct mei_hdcp_data mei_data;
   };
   struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +23 -0
index 99dddb540958..760780f1105c 100644
@@ -8,14 +8,20 @@
   #include <drm/drmP.h>
   #include <drm/drm_hdcp.h>
+#include <drm/i915_component.h>
   #include <linux/i2c.h>
   #include <linux/random.h>
+#include <linux/component.h>
   #include "intel_drv.h"
   #include "i915_reg.h"
   #define KEY_LOAD_TRIES	5
   #define TIME_FOR_ENCRYPT_STATUS_CHANGE	50
+#define GET_MEI_DDI_INDEX(p) ({                            \
+	typeof(p) __p = (p);                               \
+	__p == PORT_A ? MEI_DDI_A : (enum mei_hdcp_ddi)__p;\
+})
   static
   bool intel_hdcp_is_ksv_valid(u8 *ksv)
@@ -833,6 +839,417 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
   		!IS_CHERRYVIEW(dev_priv) && port < PORT_E);
   }
+static __attribute__((unused)) int
+hdcp2_prepare_ake_init(struct intel_connector *connector,
+		       struct hdcp2_ake_init *ake_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 864

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
+
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);
+
+	/* Clear ME FW instance for the port, just incase */
+	comp->ops->close_hdcp_session(comp->dev, data);

Sounds like a bug somewhere if we need this? I'd put this code into the ->initiate_hdcp2_session, with a big WARN_ON if it's actually needed.

Quoted 8 lines

Not really. Lets say you have progressed beyond the first step of HDCP2.2 auth along with ME FW. Now if authentication failed due to some reason, then the HDCP2.2 season created with ME FW for that port is not closed yet.

So we need to call close_hdcp_session() explicitly on authentication failures. Session has to be closed before restarting the auth on that port with initialite_hdcp_session. If we are closing the hdcp session of the port on all auth errors, we dont need this just before start of the hdcp session.

Quoted 5 lines

Yeah, makes sense. But right now the close_session stuff is sprinkled all over, so it's hard to see what's going on and whether there's bugs somewhere. I much prefer code that looks like it knows what it's doing. I think one top-level close_session call in the main hdcp2 functions (called when everything is done, or on failure) would be much cleaner.

Ok. Sure.

Quoted 54 lines

Plus then some WARN_ON to make sure we never forget to close a session. Sprinkling cleanup code all over the place looks like it's easier, but long term it's much harder code to maintain and refactor because you never sure which cleanup code is actually doing the cleanup, and which cleanup code is just there for nothing.

Quoted 11 lines
Quoted 7 lines

"Just in case" papering over programming bugs of our own just makes debugging harder.

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 867

Quoted 3 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
+
+	ret = comp->ops->initiate_hdcp2_session(comp->dev,
+						data, ake_data);

We should set the port only after successfully initializing this.

hdcp2_session is created for each port at ME FW. Hence we need the port initialized even before calling the initiate_hdcp2_session.

Quoted 2 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 861

Quoted 2 lines
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
+	if (data->port == MEI_DDI_INVALID_PORT && connector->encoder)
+		data->port = GET_MEI_DDI_INDEX(connector->encoder->port);

This line right above in your patch should only run on success. I think.

Also, looking at this again: Why could connector->encoder ever be NULL? That smells like another possible bug in our setup code. Better to wrap this in a WARN_ON and bail out.

Quoted 30 lines
Quoted 15 lines
Quoted 15 lines
drivers/gpu/drm/i915/intel_hdcp.c +15 -0
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
+				struct hdcp2_ake_send_cert *rx_cert,
+				bool *paired,
+				struct hdcp2_ake_no_stored_km *ek_pub_km,
+				size_t *msg_sz)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 889

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {

These all look like programming mistakes that should result in a WARN_ON.

We are using the comp->mutex for protecting the interface during the interface init, usage for mei communication and interface teardown.

But what if mei interface teardown happens between mei communications? So when we try to access the mei interface after such possible tear down scenario, we are checking the integrity of the interface.

Quoted 7 lines
Quoted 3 lines

Possible alternate solution is hold the comp->mutex across the authentication steps. But consequence is that mei module removal will be blocked for authentication duration and even if the mei_dev is removed, component unbind will be blocked due to this mutex dependency.

I think with the v7 component code this should all be impossible and we can remove it. With the v8 component code it's definitely necessary (which is why I don't like the v8 component code). This is all because I didn't fully realize the changes with v8 when reading the patches again ...

Got addressed as soon as we move to version implemented in v7.

Quoted 311 lines
Quoted 13 lines
Quoted 13 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 898

Quoted 9 lines
drivers/gpu/drm/i915/intel_hdcp.c +9 -0
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_receiver_cert_prepare_km(comp->dev, data,
+							 rx_cert, paired,
+							 ek_pub_km, msg_sz);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);

Error handling here seems a bit strange. You close the session, but don't reset the port. So next op will be totally unaware that things have blown up. Also no warning.

Quoted 4 lines
Quoted 2 lines

If we want to close the session, then I think that should be a decision made higher up.

This is needed as explained above. But as you have mentioned this can be moved to the end of the authentication on error scenario. I will work on that.

Yeah, I think that'll lead to cleaner code.

Quoted 288 lines
Quoted 234 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 900

Quoted 1 line
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
+	mutex_unlock(&comp->mutex);

With component do we still need this mutex stuff here?

Exact same comments everywhere below.

Quoted 229 lines
drivers/gpu/drm/i915/intel_hdcp.c +229 -0
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_hprime(struct intel_connector *connector,
+		    struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_hprime(comp->dev, data, rx_hprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_store_pairing_info(struct intel_connector *connector,
+			 struct hdcp2_ake_send_pairing_info *pairing_info)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->store_pairing_info(comp->dev,
+					    data, pairing_info);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_prepare_lc_init(struct intel_connector *connector,
+		      struct hdcp2_lc_init *lc_init)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->initiate_locality_check(comp->dev,
+						 data, lc_init);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_lprime(struct intel_connector *connector,
+		    struct hdcp2_lc_send_lprime *rx_lprime)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_lprime(comp->dev, data, rx_lprime);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_prepare_skey(struct intel_connector *connector,
+		       struct hdcp2_ske_send_eks *ske_data)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->get_session_key(comp->dev, data, ske_data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
+				      struct hdcp2_rep_send_receiverid_list
+								*rep_topology,
+				      struct hdcp2_rep_send_ack *rep_send_ack)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->repeater_check_flow_prepare_ack(comp->dev,
+							 data, rep_topology,
+							 rep_send_ack);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused)) int
+hdcp2_verify_mprime(struct intel_connector *connector,
+		    struct hdcp2_rep_stream_ready *stream_ready)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->verify_mprime(comp->dev, data, stream_ready);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_authenticate_port(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev || data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->enable_hdcp_authentication(comp->dev, data);
+	if (ret < 0)
+		comp->ops->close_hdcp_session(comp->dev, data);
+	mutex_unlock(&comp->mutex);
+
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_close_mei_session(struct intel_connector *connector)
+{
+	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+	int ret;
+
+	if (!comp)
+		return -EINVAL;
+
+	mutex_lock(&comp->mutex);
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1135

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	if (!comp->ops || !comp->dev ||
+	    data->port == MEI_DDI_INVALID_PORT) {
+		mutex_unlock(&comp->mutex);
+		return -EINVAL;
+	}
+
+	ret = comp->ops->close_hdcp_session(comp->dev, data);

Need to reset the port here I think.

What is the reset of the port you are referring to? port is not
configured for encryption. And this is the call for marking the port as de-authenticated too.

Quoted 35 lines
Quoted 35 lines
drivers/gpu/drm/i915/intel_hdcp.c +35 -0
+	mutex_unlock(&comp->mutex);
+	return ret;
+}
+
+static __attribute__((unused))
+int hdcp2_deauthenticate_port(struct intel_connector *connector)
+{
+	return hdcp2_close_mei_session(connector);
+}
+
+static int i915_hdcp_component_master_bind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	return component_bind_all(dev, dev_priv->hdcp_comp);
+}
+
+static void intel_connectors_hdcp_disable(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = &dev_priv->drm;
+	struct intel_connector *intel_connector;
+	struct drm_connector *connector;
+	struct drm_connector_list_iter conn_iter;
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(connector, &conn_iter) {
+		intel_connector = to_intel_connector(connector);
+		if (!(intel_connector->hdcp.shim))
+			continue;
+
+		intel_hdcp_disable(intel_connector);
+	}
+	drm_connector_list_iter_end(&conn_iter);
+}
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

Quoted 4 lines

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 8 lines

I looked at your v7 component code again. I think if we put the drm_atomic_helper_shutdown() call into master_unbind, then we'll have taken care of that. Essentially what you're doing here is open-coding part of that function. Better to just move the existing call to the right place.

And shutting down the entire hw is kinda what master_unbind should be doing I think. We might also need to move the general hw quiescent into master_unbind, that should work too.

Need some more information on this. As per v7 on master_unbind will invoke i915_unload_head that is i915_driver_unregister(dev_priv);
Similarly master_bind will call the load_tail that is i915_driver_register(dev_priv);

We are not initializing/shutting the HW in master_bind/unbind .
But this comment is contradicting with current approach. Could you please elaborate.?

-Ram

Quoted 235 lines
Quoted 122 lines
Quoted 27 lines
Quoted 27 lines
drivers/gpu/drm/i915/intel_hdcp.c +27 -0
+	component_unbind_all(dev, dev_priv->hdcp_comp);
+}
+
+static const struct component_master_ops i915_hdcp_component_master_ops = {
+	.bind = i915_hdcp_component_master_bind,
+	.unbind = i915_hdcp_component_master_unbind,
+};
+
+static int i915_hdcp_component_match(struct device *dev, void *data)
+{
+	return !strcmp(dev->driver->name, "mei_hdcp");
+}
+
+static int intel_hdcp_component_init(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp;
+	struct component_match *match = NULL;
+	int ret;
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp)
+		return -ENOMEM;
+
+	mutex_init(&comp->mutex);
+	dev_priv->hdcp_comp = comp;
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1207

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+	component_match_add(dev_priv->drm.dev, &match,
+			    i915_hdcp_component_match, dev_priv);
+	ret = component_master_add_with_match(dev_priv->drm.dev,
+					      &i915_hdcp_component_master_ops,
+					      match);

So I'm not sure this will work out well, hiding the master_ops here in hdcp. Definitely needs to be rewritten as soon as i915 needs another component. And might make the load/unload split complicated.

we have already discussed this.

Quoted 6 lines

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1211

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+	if (ret < 0)
+		goto out_err;
+
+	DRM_INFO("I915 hdcp component master added.\n");

You add both the master and the hdcp component here. Output is a bit confusing.

we have component master and a component from mei which will match to the master.

Here we are adding the component master.

Quoted 67 lines
Quoted 67 lines
drivers/gpu/drm/i915/intel_hdcp.c +57 -1
+	return ret;
+
+out_err:
+	component_master_del(dev_priv->drm.dev,
+			     &i915_hdcp_component_master_ops);
+	kfree(comp);
+	dev_priv->hdcp_comp = NULL;
+	DRM_ERROR("Failed to add i915 hdcp component master (%d)\n", ret);
+
+	return ret;
+}
+
+static int initialize_mei_hdcp_data(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	struct mei_hdcp_data *data = &hdcp->mei_data;
+	enum port port;
+
+	if (connector->encoder) {
+		port = connector->encoder->port;
+		data->port = GET_MEI_DDI_INDEX(port);
+	}
+
+	data->port_type = MEI_HDCP_PORT_TYPE_INTEGRATED;
+	data->protocol = hdcp->shim->hdcp_protocol();
+
+	data->k = 1;
+	if (!data->streams)
+		data->streams = kcalloc(data->k, sizeof(data->streams[0]),
+					GFP_KERNEL);
+	if (!data->streams) {
+		DRM_ERROR("Out of Memory\n");
+		return -ENOMEM;
+	}
+
+	data->streams[0].stream_id = 0;
+	data->streams[0].stream_type = hdcp->content_type;
+
+	return 0;
+}
+
   bool is_hdcp2_supported(struct drm_i915_private *dev_priv)
   {
   	return ((INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv) ||
@@ -843,10 +1260,25 @@ static void intel_hdcp2_init(struct intel_connector *connector)
   {
   	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
   	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
   	WARN_ON(!is_hdcp2_supported(dev_priv));
-	/* TODO: MEI interface needs to be initialized here */
+	ret = initialize_mei_hdcp_data(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("Mei hdcp data init failed\n");
+		return;
+	}
+
+	if (!dev_priv->hdcp_comp)
+		ret = intel_hdcp_component_init(connector);
+
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP comp init failed\n");
+		kfree(hdcp->mei_data.streams);
+		return;
+	}
+
   	hdcp->hdcp2_supported = 1;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_exit(struct drm_i915_private *dev_priv) · line 1329

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +1 -0
   }
@@ -894,9 +1326,17 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
   		mutex_lock(&intel_connector->hdcp.mutex);
   		intel_connector->hdcp.hdcp2_supported = 0;
   		intel_connector->hdcp.shim = NULL;
+		kfree(intel_connector->hdcp.mei_data.streams);

We need to push this into a per-connector hdcp cleanup function. Or just into the generic connector cleanup.

Quoted 1 line

We could move it to per connector  hdcp cleanup function.

Yeah I think that would be cleaner.

Quoted 33 lines
Quoted 25 lines
Quoted 25 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
   		mutex_unlock(&intel_connector->hdcp.mutex);
   	}
   	drm_connector_list_iter_end(&conn_iter);
+
+	if (dev_priv->hdcp_comp) {
+		component_master_del(dev_priv->drm.dev,
+				     &i915_hdcp_component_master_ops);
+		kfree(dev_priv->hdcp_comp);
+		dev_priv->hdcp_comp = NULL;
+	}
   }
   int intel_hdcp_enable(struct intel_connector *connector)
include/drm/i915_component.h +4 -0
index fca22d463e1b..12268228f4dc 100644
@@ -24,8 +24,12 @@
   #ifndef _I915_COMPONENT_H_
   #define _I915_COMPONENT_H_
+#include <linux/mutex.h>
+
   #include "drm_audio_component.h"
+#include <drm/drm_hdcp.h>
+
   /* MAX_PORT is the number of port
Quoted 8 lines

include/drm/i915_component.h struct i915_audio_component { · line 52

Quoted 6 lines
include/drm/i915_component.h +1 -0
    * It must be sync with I915_MAX_PORTS defined i915_drv.h
    */
@@ -46,4 +50,71 @@ struct i915_audio_component {
   	int aud_sample_rate[MAX_PORTS];
   };
+struct i915_hdcp_component_ops {

Imo that should be called mei_hdcp_component_ops and put into the linux/mei_hdcp.h header. Or was that Thomas' review comment?

Quoted 2 lines

Nope this is there for many versions. i915_hdcp_component_ops are implemented by mei_hdcp.c and initializes the component with the &ops.

I summarized all the discussion around the i915/mei_hdcp interface in the thread in an earlier patch in this series.

Cheers, Daniel

Quoted 70 lines
Quoted 2 lines

2 lines not shown · raw message

65 lines not shown · raw message

Quoted 8 lines

8 lines not shown · raw message

4 lines not shown · raw message

Part of this message is not shown here. View the raw message.

#22 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 25 lines · Ramalingam
Quoted 15 lines · Daniel Vetter
Quoted 10 lines · Ramalingam
Quoted 9 lines · Daniel Vetter

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines · Ramalingam C
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

Quoted 4 lines

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 8 lines

I looked at your v7 component code again. I think if we put the drm_atomic_helper_shutdown() call into master_unbind, then we'll have taken care of that. Essentially what you're doing here is open-coding part of that function. Better to just move the existing call to the right place.

And shutting down the entire hw is kinda what master_unbind should be doing I think. We might also need to move the general hw quiescent into master_unbind, that should work too.

Quoted 6 lines

Need some more information on this. As per v7 on master_unbind will invoke i915_unload_head that is i915_driver_unregister(dev_priv);
Similarly master_bind will call the load_tail that is i915_driver_register(dev_priv);

We are not initializing/shutting the HW in master_bind/unbind .
But this comment is contradicting with current approach. Could you please elaborate.?

So my understanding is that we need to shut down all hdcp usage before master_unbind completes, because otherwise we'll blow up: The mei_hdcp component is gone already.

Now the other case for master_unbind is that the i915 pci device is unloaded, and in that case again I think it makes sense to shut down the hardware in master_unbind.

Now when I looked at v7, right after the component_unbind code in the i915 unload sequences comes the function calls to shut down the hardware. I think it would make sense to them (or at least the drm_atomic_helper_shutdown() call) into master_unbind.

This is somewhat asymetric, but that's ok: Load path doesn't enable anything, we just keep the hardware as-is (to be able to support flicker-free boôt-up). First modest is done by usersapce. Exception is if you have fbcon enabled (and not use the fastboot patches that Hans just merged), in that case the kernel will do the first modeset when we regiseter the fbdev device.

Anyway, moving the drm_atomic_helper_shutdown() into the master_unbind function in v7 should take care of disabling all outputs, and hence also disabling all usage of hdcp component.
-Daniel

Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#23 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 51 lines · Daniel Vetter
Quoted 24 lines · Ramalingam
Quoted 15 lines · Daniel Vetter
Quoted 10 lines · Ramalingam
Quoted 9 lines · Daniel Vetter

drivers/gpu/drm/i915/intel_hdcp.c bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) · line 1175

Quoted 5 lines · Ramalingam C
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

Quoted 4 lines

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 8 lines

I looked at your v7 component code again. I think if we put the drm_atomic_helper_shutdown() call into master_unbind, then we'll have taken care of that. Essentially what you're doing here is open-coding part of that function. Better to just move the existing call to the right place.

And shutting down the entire hw is kinda what master_unbind should be doing I think. We might also need to move the general hw quiescent into master_unbind, that should work too.

Quoted 6 lines

Need some more information on this. As per v7 on master_unbind will invoke i915_unload_head that is i915_driver_unregister(dev_priv);
Similarly master_bind will call the load_tail that is i915_driver_register(dev_priv);

We are not initializing/shutting the HW in master_bind/unbind .
But this comment is contradicting with current approach. Could you please elaborate.?

So my understanding is that we need to shut down all hdcp usage before master_unbind completes, because otherwise we'll blow up: The mei_hdcp component is gone already.

Now the other case for master_unbind is that the i915 pci device is unloaded, and in that case again I think it makes sense to shut down the hardware in master_unbind.

Now when I looked at v7, right after the component_unbind code in the i915 unload sequences comes the function calls to shut down the hardware. I think it would make sense to them (or at least the drm_atomic_helper_shutdown() call) into master_unbind.

This is somewhat asymetric, but that's ok: Load path doesn't enable anything, we just keep the hardware as-is (to be able to support flicker-free boôt-up). First modest is done by usersapce. Exception is if you have fbcon enabled (and not use the fastboot patches that Hans just merged), in that case the kernel will do the first modeset when we regiseter the fbdev device.

Quoted 3 lines

Anyway, moving the drm_atomic_helper_shutdown() into the master_unbind function in v7 should take care of disabling all outputs, and hence also disabling all usage of hdcp component.

But in that case master_bind should do the reverse of the drm_atomic_helper_shutdown()right? else lets say mei_hdcp is removed, master_unbind triggered and hence all hw is shutdown.
And then mei_hdcp is loaded so master_bind should initialize the hw right? Which is not the scenario right now.

-Ram

Quoted 1 line

-Daniel

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#24 lore raw

Re: [PATCH v8 05/35] drm/i915: MEI interface definition

Quoted 54 lines · Ramalingam
Quoted 51 lines · Daniel Vetter
Quoted 24 lines · Ramalingam
Quoted 15 lines · Daniel Vetter
Quoted 10 lines · Ramalingam
Quoted 9 lines · Daniel Vetter

Review

Quoted 5 lines · Ramalingam C
(quoted diff) +5 -0
+static void i915_hdcp_component_master_unbind(struct device *dev)
+{
+	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
+
+	intel_connectors_hdcp_disable(dev_priv);

Why this code? Once we've unregistered the driver, we should have shut down the hardware completely. Which should have shut down all the hdcp users too.

Quoted 4 lines

This unbind might be triggered either due to master_del or component_del. if its triggered from mei through component_del, then before teardown of the i/f in component_unbind(), disable the ongoing HDCP session through hdcp_disable() for each connectors.

Quoted 8 lines

I looked at your v7 component code again. I think if we put the drm_atomic_helper_shutdown() call into master_unbind, then we'll have taken care of that. Essentially what you're doing here is open-coding part of that function. Better to just move the existing call to the right place.

And shutting down the entire hw is kinda what master_unbind should be doing I think. We might also need to move the general hw quiescent into master_unbind, that should work too.

Quoted 6 lines

Need some more information on this. As per v7 on master_unbind will invoke i915_unload_head that is i915_driver_unregister(dev_priv);
Similarly master_bind will call the load_tail that is i915_driver_register(dev_priv);

We are not initializing/shutting the HW in master_bind/unbind .
But this comment is contradicting with current approach. Could you please elaborate.?

So my understanding is that we need to shut down all hdcp usage before master_unbind completes, because otherwise we'll blow up: The mei_hdcp component is gone already.

Now the other case for master_unbind is that the i915 pci device is unloaded, and in that case again I think it makes sense to shut down the hardware in master_unbind.

Now when I looked at v7, right after the component_unbind code in the i915 unload sequences comes the function calls to shut down the hardware. I think it would make sense to them (or at least the drm_atomic_helper_shutdown() call) into master_unbind.

This is somewhat asymetric, but that's ok: Load path doesn't enable anything, we just keep the hardware as-is (to be able to support flicker-free boôt-up). First modest is done by usersapce. Exception is if you have fbcon enabled (and not use the fastboot patches that Hans just merged), in that case the kernel will do the first modeset when we regiseter the fbdev device.

Quoted 6 lines
Quoted 3 lines

Anyway, moving the drm_atomic_helper_shutdown() into the master_unbind function in v7 should take care of disabling all outputs, and hence also disabling all usage of hdcp component.

But in that case master_bind should do the reverse of the drm_atomic_helper_shutdown()right? else lets say mei_hdcp is removed, master_unbind triggered and hence all hw is shutdown.
And then mei_hdcp is loaded so master_bind should initialize the hw right? Which is not the scenario right now.

Summarizing the #intel-gfx IRC discussion:

As i915 load and unload  are already asymetric, there is no harm in moving the drm_atomic_helper_shutdown() into the master_unbind(). So going ahead with daniel's suggestion.

-Ram

Quoted 3 lines

-Ram

Quoted 1 line

-Daniel

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

#25 lore raw

PATCH v8 6/35 drm/i915: Enable and Disable of HDCP2.2

In reply to Ramalingam C

Considering that HDCP2.2 is more secure than HDCP1.4, When a setup supports HDCP2.2 and HDCP1.4, HDCP2.2 will be enabled.

When HDCP2.2 enabling fails and HDCP1.4 is supported, HDCP1.4 is enabled.

This change implements a sequence of enabling and disabling of HDCP2.2 authentication and HDCP2.2 port encryption.

v2:
Included few optimization suggestions [Chris Wilson] Commit message is updated as per the rebased version. intel_wait_for_register is used instead of wait_for. [Chris Wilson]
v3:
No changes.
v4:
Extra comment added and Style issue fixed [Uma]
v5:
Rebased as part of patch reordering.
HDCP2 encryption status is tracked.
HW state check is moved into WARN_ON [Daniel]
v6:
Redefined the mei service functions as per comp redesign. Merged patches related to hdcp2.2 enabling and disabling [Sean Paul]. Required shim functionality is defined [Sean Paul]
v7:
Return values are handles [Uma]
Realigned the code.
Check for comp_master is removed.
v8:
HDCP2.2 is attempted only if mei interface is up.
Adjust to the new interface
Avoid bool usage in struct [Tomas]

---
 drivers/gpu/drm/i915/intel_drv.h  |   5 +
 drivers/gpu/drm/i915/intel_hdcp.c | 223 +++++++++++++++++++++++++++++++++++---
 2 files changed, 214 insertions(+), 14 deletions(-)
drivers/gpu/drm/i915/intel_drv.h +5 -0
index bde82f3ada85..3e9f21d23442 100644
@@ -383,6 +383,10 @@ struct intel_hdcp_shim {
 
 	/* Detects the HDCP protocol(DP/HDMI) required on the port */
 	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);
+
+	/* Detects whether Panel is HDCP2.2 capable */
+	int (*hdcp_2_2_capable)(struct intel_digital_port *intel_dig_port,
+				bool *capable);
 };
 
 struct intel_hdcp {
@@ -396,6 +400,7 @@ struct intel_hdcp {
 	/* HDCP2.2 related definitions */
 	/* Flag indicates whether this connector supports HDCP2.2 or not. */
 	u8 hdcp2_supported;
+	u8 hdcp2_in_use;
 
 	/*
 	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
drivers/gpu/drm/i915/intel_hdcp.c +209 -14

264 lines not on this page · raw message

Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#26 lore raw

Re: [PATCH v8 06/35] drm/i915: Enable and Disable of HDCP2.2

Quoted 8 lines · Ramalingam C

Considering that HDCP2.2 is more secure than HDCP1.4, When a setup supports HDCP2.2 and HDCP1.4, HDCP2.2 will be enabled.

When HDCP2.2 enabling fails and HDCP1.4 is supported, HDCP1.4 is enabled.

This change implements a sequence of enabling and disabling of HDCP2.2 authentication and HDCP2.2 port encryption.

Patch series suggestion for next time around: First build out the helper functions, then time them into the big picture like here. Personally I think that makes it easier to understand, but it's kinda personal choice. I guess this here works too.

Quoted 83 lines

v2:
Included few optimization suggestions [Chris Wilson] Commit message is updated as per the rebased version. intel_wait_for_register is used instead of wait_for. [Chris Wilson]
v3:
No changes.
v4:
Extra comment added and Style issue fixed [Uma]
v5:
Rebased as part of patch reordering.
HDCP2 encryption status is tracked.
HW state check is moved into WARN_ON [Daniel]
v6:
Redefined the mei service functions as per comp redesign. Merged patches related to hdcp2.2 enabling and disabling [Sean Paul]. Required shim functionality is defined [Sean Paul]
v7:
Return values are handles [Uma]
Realigned the code.
Check for comp_master is removed.
v8:
HDCP2.2 is attempted only if mei interface is up.
Adjust to the new interface
Avoid bool usage in struct [Tomas]

---
 drivers/gpu/drm/i915/intel_drv.h  |   5 +
 drivers/gpu/drm/i915/intel_hdcp.c | 223 +++++++++++++++++++++++++++++++++++---
 2 files changed, 214 insertions(+), 14 deletions(-)
drivers/gpu/drm/i915/intel_drv.h +5 -0
index bde82f3ada85..3e9f21d23442 100644
@@ -383,6 +383,10 @@ struct intel_hdcp_shim {
 
 	/* Detects the HDCP protocol(DP/HDMI) required on the port */
 	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);
+
+	/* Detects whether Panel is HDCP2.2 capable */
+	int (*hdcp_2_2_capable)(struct intel_digital_port *intel_dig_port,
+				bool *capable);
 };
 
 struct intel_hdcp {
@@ -396,6 +400,7 @@ struct intel_hdcp {
 	/* HDCP2.2 related definitions */
 	/* Flag indicates whether this connector supports HDCP2.2 or not. */
 	u8 hdcp2_supported;
+	u8 hdcp2_in_use;
 
 	/*
 	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
drivers/gpu/drm/i915/intel_hdcp.c +20 -0
index 760780f1105c..c1bd1ccd47cd 100644
@@ -79,6 +79,43 @@ bool intel_hdcp_capable(struct intel_connector *connector)
 	return capable;
 }
 
+/* At present whether mei_hdcp component is binded with i915 master component */
+static bool intel_hdcp2_mei_binded(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return false;
+	}
+	mutex_unlock(&comp->mutex);
+
+	return true;
+}
+
+/* Is HDCP2.2 capable on Platform and Sink */
+static bool intel_hdcp2_capable(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);

drivers/gpu/drm/i915/intel_hdcp.c bool intel_hdcp_capable(struct intel_connector *connector) · line 111

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	bool capable = false;
+
+	/* I915 support for HDCP2.2 */
+	if (!hdcp->hdcp2_supported)
+		return false;
+
+	/* MEI services for HDCP2.2 */
+	if (!intel_hdcp2_mei_binded(connector))
+		return false;

Why do we still need this with component? Driver load should be stalled out until it's all there, that was kinda the entire point of component, so we don't have to recheck all the time whether hdcp2 is still there or not.

Quoted 224 lines
drivers/gpu/drm/i915/intel_hdcp.c +175 -13
+
+	/* Sink's capability for HDCP2.2 */
+	hdcp->shim->hdcp_2_2_capable(intel_dig_port, &capable);
+
+	return capable;
+}
+
 static int intel_hdcp_poll_ksv_fifo(struct intel_digital_port *intel_dig_port,
 				    const struct intel_hdcp_shim *shim)
 {
@@ -1114,8 +1151,7 @@ int hdcp2_authenticate_port(struct intel_connector *connector)
 	return ret;
 }
 
-static __attribute__((unused))
-int hdcp2_close_mei_session(struct intel_connector *connector)
+static int hdcp2_close_mei_session(struct intel_connector *connector)
 {
 	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
 	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
@@ -1137,12 +1173,157 @@ int hdcp2_close_mei_session(struct intel_connector *connector)
 	return ret;
 }
 
-static __attribute__((unused))
-int hdcp2_deauthenticate_port(struct intel_connector *connector)
+static int hdcp2_deauthenticate_port(struct intel_connector *connector)
 {
 	return hdcp2_close_mei_session(connector);
 }
 
+static int hdcp2_authenticate_sink(struct intel_connector *connector)
+{
+	DRM_ERROR("Sink authentication is done in subsequent patches\n");
+
+	return -EINVAL;
+}
+
+static int hdcp2_enable_encryption(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+	int ret;
+
+	WARN_ON(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS);
+
+	if (hdcp->shim->toggle_signalling) {
+		ret = hdcp->shim->toggle_signalling(intel_dig_port, true);
+		if (ret) {
+			DRM_ERROR("Failed to enable HDCP signalling. %d\n",
+				  ret);
+			return ret;
+		}
+	}
+
+	if (I915_READ(HDCP2_STATUS_DDI(port)) & LINK_AUTH_STATUS) {
+		/* Link is Authenticated. Now set for Encryption */
+		I915_WRITE(HDCP2_CTL_DDI(port),
+			   I915_READ(HDCP2_CTL_DDI(port)) |
+			   CTL_LINK_ENCRYPTION_REQ);
+	}
+
+	ret = intel_wait_for_register(dev_priv, HDCP2_STATUS_DDI(port),
+				      LINK_ENCRYPTION_STATUS,
+				      LINK_ENCRYPTION_STATUS,
+				      TIME_FOR_ENCRYPT_STATUS_CHANGE);
+
+	return ret;
+}
+
+static int hdcp2_disable_encryption(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+	int ret;
+
+	WARN_ON(!(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS));
+
+	I915_WRITE(HDCP2_CTL_DDI(port),
+		   I915_READ(HDCP2_CTL_DDI(port)) & ~CTL_LINK_ENCRYPTION_REQ);
+
+	ret = intel_wait_for_register(dev_priv, HDCP2_STATUS_DDI(port),
+				      LINK_ENCRYPTION_STATUS, 0x0,
+				      TIME_FOR_ENCRYPT_STATUS_CHANGE);
+	if (ret == -ETIMEDOUT)
+		DRM_DEBUG_KMS("Disable Encryption Timedout");
+
+	if (hdcp->shim->toggle_signalling) {
+		ret = hdcp->shim->toggle_signalling(intel_dig_port, false);
+		if (ret) {
+			DRM_ERROR("Failed to disable HDCP signalling. %d\n",
+				  ret);
+			return ret;
+		}
+	}
+
+	return ret;
+}
+
+static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector)
+{
+	int ret, i, tries = 3;
+
+	for (i = 0; i < tries; i++) {
+		ret = hdcp2_authenticate_sink(connector);
+		if (!ret)
+			break;
+
+		/* Clearing the mei hdcp session */
+		DRM_DEBUG_KMS("HDCP2.2 Auth %d of %d Failed.(%d)\n",
+			      i + 1, tries, ret);
+		if (hdcp2_deauthenticate_port(connector) < 0)
+			DRM_DEBUG_KMS("Port deauth failed.\n");
+	}
+
+	if (i != tries) {
+		/*
+		 * Ensuring the required 200mSec min time interval between
+		 * Session Key Exchange and encryption.
+		 */
+		msleep(HDCP_2_2_DELAY_BEFORE_ENCRYPTION_EN);
+		ret = hdcp2_enable_encryption(connector);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("Encryption Enable Failed.(%d)\n", ret);
+			if (hdcp2_deauthenticate_port(connector) < 0)
+				DRM_DEBUG_KMS("Port deauth failed.\n");
+		}
+	}
+
+	return ret;
+}
+
+static int _intel_hdcp2_enable(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being enabled. Type: %d\n",
+		      connector->base.name, connector->base.base.id,
+		      hdcp->content_type);
+
+	ret = hdcp2_authenticate_and_encrypt(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP2 Type%d  Enabling Failed. (%d)\n",
+			      hdcp->content_type, ret);
+		return ret;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is enabled. Type %d\n",
+		      connector->base.name, connector->base.base.id,
+		      hdcp->content_type);
+
+	hdcp->hdcp2_in_use = true;
+	return 0;
+}
+
+static int _intel_hdcp2_disable(struct intel_connector *connector)
+{
+	int ret;
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being Disabled\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = hdcp2_disable_encryption(connector);
+
+	if (hdcp2_deauthenticate_port(connector) < 0)
+		DRM_DEBUG_KMS("Port deauth failed.\n");
+
+	connector->hdcp.hdcp2_in_use = false;
+
+	return ret;
+}
+
 static int i915_hdcp_component_master_bind(struct device *dev)
 {
 	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
@@ -1342,22 +1523,33 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
 int intel_hdcp_enable(struct intel_connector *connector)
 {
 	struct intel_hdcp *hdcp = &connector->hdcp;
-	int ret;
+	int ret = -EINVAL;
 
 	if (!hdcp->shim)
 		return -ENOENT;
 
 	mutex_lock(&hdcp->mutex);
 
-	ret = _intel_hdcp_enable(connector);
-	if (ret)
-		goto out;
+	/*
+	 * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
+	 * is capable of HDCP2.2, it is preferred to use HDCP2.2.
+	 */
+	if (intel_hdcp2_capable(connector))
+		ret = _intel_hdcp2_enable(connector);
+
+	/* When HDCP2.2 fails, HDCP1.4 will be attempted */
+	if (ret && intel_hdcp_capable(connector)) {
+		ret = _intel_hdcp_enable(connector);
+		if (!ret)
+			schedule_delayed_work(&hdcp->check_work,
+					      DRM_HDCP_CHECK_PERIOD_MS);
+	}
+
+	if (!ret) {
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+		schedule_work(&hdcp->prop_work);
+	}
 
-	hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-	schedule_work(&hdcp->prop_work);
-	schedule_delayed_work(&hdcp->check_work,
-			      DRM_HDCP_CHECK_PERIOD_MS);
-out:
 	mutex_unlock(&hdcp->mutex);
 	return ret;
 }

drivers/gpu/drm/i915/intel_hdcp.c int intel_hdcp_disable(struct intel_connector *connector) · line 1572

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -1
@@ -1374,7 +1566,10 @@ int intel_hdcp_disable(struct intel_connector *connector)
 
 	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
 		hdcp->value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
-		ret = _intel_hdcp_disable(connector);
+		if (hdcp->hdcp2_in_use)
+			ret = _intel_hdcp2_disable(connector);
+		else
+			ret = _intel_hdcp_disable(connector);

Looks reasonable. So one thing we could be doing is already internally have a DRM_MODE_CONTENT_PROTECTION_ENABLED_TYPE1 for hdcp2. But the uapi would only return _ENABLED to userspace. But for internal tracking this would avoid the need for the separate hdcp2_in_use variable.

Probably good cleanup/prep patch for the type0/1 uapi extension, once we get there.

Aside from the component intergration question seems all reasonable. But I didn't yet review the hdcp2 flow, will do that once it's more complete in later patches.
-Daniel

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -0
 	}
 
 	mutex_unlock(&hdcp->mutex);
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#27 lore raw

Re: [PATCH v8 06/35] drm/i915: Enable and Disable of HDCP2.2

Quoted 4 lines · Daniel Vetter
Quoted 3 lines · Ramalingam C

Considering that HDCP2.2 is more secure than HDCP1.4, When a setup supports HDCP2.2 and HDCP1.4, HDCP2.2 will be enabled.

Quoted 8 lines
Quoted 5 lines

When HDCP2.2 enabling fails and HDCP1.4 is supported, HDCP1.4 is enabled.

This change implements a sequence of enabling and disabling of HDCP2.2 authentication and HDCP2.2 port encryption.

Patch series suggestion for next time around: First build out the helper functions, then time them into the big picture like here. Personally I think that makes it easier to understand, but it's kinda personal choice.

Tried that already. But bisecting will give warnings as "defined but unused functions"

Hence moved to this approach.

Quoted 90 lines

I guess this here works too.

Quoted 88 lines

v2:
Included few optimization suggestions [Chris Wilson] Commit message is updated as per the rebased version. intel_wait_for_register is used instead of wait_for. [Chris Wilson]
v3:
No changes.
v4:
Extra comment added and Style issue fixed [Uma]
v5:
Rebased as part of patch reordering.
HDCP2 encryption status is tracked.
HW state check is moved into WARN_ON [Daniel]
v6:
Redefined the mei service functions as per comp redesign. Merged patches related to hdcp2.2 enabling and disabling [Sean Paul]. Required shim functionality is defined [Sean Paul]
v7:
Return values are handles [Uma]
Realigned the code.
Check for comp_master is removed.
v8:
HDCP2.2 is attempted only if mei interface is up.
Adjust to the new interface
Avoid bool usage in struct [Tomas]

---
  drivers/gpu/drm/i915/intel_drv.h  |   5 +
  drivers/gpu/drm/i915/intel_hdcp.c | 223 +++++++++++++++++++++++++++++++++++---
  2 files changed, 214 insertions(+), 14 deletions(-)
drivers/gpu/drm/i915/intel_drv.h +5 -0
index bde82f3ada85..3e9f21d23442 100644
@@ -383,6 +383,10 @@ struct intel_hdcp_shim {
 
  	/* Detects the HDCP protocol(DP/HDMI) required on the port */
  	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);
+
+	/* Detects whether Panel is HDCP2.2 capable */
+	int (*hdcp_2_2_capable)(struct intel_digital_port *intel_dig_port,
+				bool *capable);
  };
 
  struct intel_hdcp {
@@ -396,6 +400,7 @@ struct intel_hdcp {
  	/* HDCP2.2 related definitions */
  	/* Flag indicates whether this connector supports HDCP2.2 or not. */
  	u8 hdcp2_supported;
+	u8 hdcp2_in_use;
 
  	/*
  	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
drivers/gpu/drm/i915/intel_hdcp.c +26 -0
index 760780f1105c..c1bd1ccd47cd 100644
@@ -79,6 +79,43 @@ bool intel_hdcp_capable(struct intel_connector *connector)
  	return capable;
  }
 
+/* At present whether mei_hdcp component is binded with i915 master component */
+static bool intel_hdcp2_mei_binded(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return false;
+	}
+	mutex_unlock(&comp->mutex);
+
+	return true;
+}
+
+/* Is HDCP2.2 capable on Platform and Sink */
+static bool intel_hdcp2_capable(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	bool capable = false;
+
+	/* I915 support for HDCP2.2 */
+	if (!hdcp->hdcp2_supported)
+		return false;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool intel_hdcp_capable(struct intel_connector *connector) · line 111

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+
+	/* MEI services for HDCP2.2 */
+	if (!intel_hdcp2_mei_binded(connector))
+		return false;

Why do we still need this with component? Driver load should be stalled out until it's all there, that was kinda the entire point of component, so we don't have to recheck all the time whether hdcp2 is still there or not.

We discussed this in previous patches. Lets decide whether this approach is good enough or not.

--Ram

Quoted 238 lines
Quoted 225 lines
drivers/gpu/drm/i915/intel_hdcp.c +175 -13
+
+	/* Sink's capability for HDCP2.2 */
+	hdcp->shim->hdcp_2_2_capable(intel_dig_port, &capable);
+
+	return capable;
+}
+
  static int intel_hdcp_poll_ksv_fifo(struct intel_digital_port *intel_dig_port,
  				    const struct intel_hdcp_shim *shim)
  {
@@ -1114,8 +1151,7 @@ int hdcp2_authenticate_port(struct intel_connector *connector)
  	return ret;
  }
 
-static __attribute__((unused))
-int hdcp2_close_mei_session(struct intel_connector *connector)
+static int hdcp2_close_mei_session(struct intel_connector *connector)
  {
  	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
  	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
@@ -1137,12 +1173,157 @@ int hdcp2_close_mei_session(struct intel_connector *connector)
  	return ret;
  }
 
-static __attribute__((unused))
-int hdcp2_deauthenticate_port(struct intel_connector *connector)
+static int hdcp2_deauthenticate_port(struct intel_connector *connector)
  {
  	return hdcp2_close_mei_session(connector);
  }
 
+static int hdcp2_authenticate_sink(struct intel_connector *connector)
+{
+	DRM_ERROR("Sink authentication is done in subsequent patches\n");
+
+	return -EINVAL;
+}
+
+static int hdcp2_enable_encryption(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+	int ret;
+
+	WARN_ON(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS);
+
+	if (hdcp->shim->toggle_signalling) {
+		ret = hdcp->shim->toggle_signalling(intel_dig_port, true);
+		if (ret) {
+			DRM_ERROR("Failed to enable HDCP signalling. %d\n",
+				  ret);
+			return ret;
+		}
+	}
+
+	if (I915_READ(HDCP2_STATUS_DDI(port)) & LINK_AUTH_STATUS) {
+		/* Link is Authenticated. Now set for Encryption */
+		I915_WRITE(HDCP2_CTL_DDI(port),
+			   I915_READ(HDCP2_CTL_DDI(port)) |
+			   CTL_LINK_ENCRYPTION_REQ);
+	}
+
+	ret = intel_wait_for_register(dev_priv, HDCP2_STATUS_DDI(port),
+				      LINK_ENCRYPTION_STATUS,
+				      LINK_ENCRYPTION_STATUS,
+				      TIME_FOR_ENCRYPT_STATUS_CHANGE);
+
+	return ret;
+}
+
+static int hdcp2_disable_encryption(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+	int ret;
+
+	WARN_ON(!(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS));
+
+	I915_WRITE(HDCP2_CTL_DDI(port),
+		   I915_READ(HDCP2_CTL_DDI(port)) & ~CTL_LINK_ENCRYPTION_REQ);
+
+	ret = intel_wait_for_register(dev_priv, HDCP2_STATUS_DDI(port),
+				      LINK_ENCRYPTION_STATUS, 0x0,
+				      TIME_FOR_ENCRYPT_STATUS_CHANGE);
+	if (ret == -ETIMEDOUT)
+		DRM_DEBUG_KMS("Disable Encryption Timedout");
+
+	if (hdcp->shim->toggle_signalling) {
+		ret = hdcp->shim->toggle_signalling(intel_dig_port, false);
+		if (ret) {
+			DRM_ERROR("Failed to disable HDCP signalling. %d\n",
+				  ret);
+			return ret;
+		}
+	}
+
+	return ret;
+}
+
+static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector)
+{
+	int ret, i, tries = 3;
+
+	for (i = 0; i < tries; i++) {
+		ret = hdcp2_authenticate_sink(connector);
+		if (!ret)
+			break;
+
+		/* Clearing the mei hdcp session */
+		DRM_DEBUG_KMS("HDCP2.2 Auth %d of %d Failed.(%d)\n",
+			      i + 1, tries, ret);
+		if (hdcp2_deauthenticate_port(connector) < 0)
+			DRM_DEBUG_KMS("Port deauth failed.\n");
+	}
+
+	if (i != tries) {
+		/*
+		 * Ensuring the required 200mSec min time interval between
+		 * Session Key Exchange and encryption.
+		 */
+		msleep(HDCP_2_2_DELAY_BEFORE_ENCRYPTION_EN);
+		ret = hdcp2_enable_encryption(connector);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("Encryption Enable Failed.(%d)\n", ret);
+			if (hdcp2_deauthenticate_port(connector) < 0)
+				DRM_DEBUG_KMS("Port deauth failed.\n");
+		}
+	}
+
+	return ret;
+}
+
+static int _intel_hdcp2_enable(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being enabled. Type: %d\n",
+		      connector->base.name, connector->base.base.id,
+		      hdcp->content_type);
+
+	ret = hdcp2_authenticate_and_encrypt(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP2 Type%d  Enabling Failed. (%d)\n",
+			      hdcp->content_type, ret);
+		return ret;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is enabled. Type %d\n",
+		      connector->base.name, connector->base.base.id,
+		      hdcp->content_type);
+
+	hdcp->hdcp2_in_use = true;
+	return 0;
+}
+
+static int _intel_hdcp2_disable(struct intel_connector *connector)
+{
+	int ret;
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being Disabled\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = hdcp2_disable_encryption(connector);
+
+	if (hdcp2_deauthenticate_port(connector) < 0)
+		DRM_DEBUG_KMS("Port deauth failed.\n");
+
+	connector->hdcp.hdcp2_in_use = false;
+
+	return ret;
+}
+
  static int i915_hdcp_component_master_bind(struct device *dev)
  {
  	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
@@ -1342,22 +1523,33 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
  int intel_hdcp_enable(struct intel_connector *connector)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
-	int ret;
+	int ret = -EINVAL;
 
  	if (!hdcp->shim)
  		return -ENOENT;
 
  	mutex_lock(&hdcp->mutex);
 
-	ret = _intel_hdcp_enable(connector);
-	if (ret)
-		goto out;
+	/*
+	 * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
+	 * is capable of HDCP2.2, it is preferred to use HDCP2.2.
+	 */
+	if (intel_hdcp2_capable(connector))
+		ret = _intel_hdcp2_enable(connector);
+
+	/* When HDCP2.2 fails, HDCP1.4 will be attempted */
+	if (ret && intel_hdcp_capable(connector)) {
+		ret = _intel_hdcp_enable(connector);
+		if (!ret)
+			schedule_delayed_work(&hdcp->check_work,
+					      DRM_HDCP_CHECK_PERIOD_MS);
+	}
+
+	if (!ret) {
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+		schedule_work(&hdcp->prop_work);
+	}
 
-	hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-	schedule_work(&hdcp->prop_work);
-	schedule_delayed_work(&hdcp->check_work,
-			      DRM_HDCP_CHECK_PERIOD_MS);
-out:
  	mutex_unlock(&hdcp->mutex);
  	return ret;
  }

drivers/gpu/drm/i915/intel_hdcp.c int intel_hdcp_disable(struct intel_connector *connector) · line 1572

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -1
@@ -1374,7 +1566,10 @@ int intel_hdcp_disable(struct intel_connector *connector)
 
  	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
  		hdcp->value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
-		ret = _intel_hdcp_disable(connector);
+		if (hdcp->hdcp2_in_use)
+			ret = _intel_hdcp2_disable(connector);
+		else
+			ret = _intel_hdcp_disable(connector);

Looks reasonable. So one thing we could be doing is already internally have a DRM_MODE_CONTENT_PROTECTION_ENABLED_TYPE1 for hdcp2.But the uapi would only return _ENABLED to userspace. But for internal tracking this would avoid the need for the separate hdcp2_in_use variable.

Quoted 14 lines

Probably good cleanup/prep patch for the type0/1 uapi extension, once we get there.

Aside from the component intergration question seems all reasonable. But I didn't yet review the hdcp2 flow, will do that once it's more complete in later patches.
-Daniel

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -0
  	}
 
  	mutex_unlock(&hdcp->mutex);
Signature · 1 line
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

#28 lore raw

Re: [PATCH v8 06/35] drm/i915: Enable and Disable of HDCP2.2

Quoted 11 lines · Ramalingam
Quoted 9 lines · Daniel Vetter
Quoted 8 lines · Ramalingam C

Considering that HDCP2.2 is more secure than HDCP1.4, When a setup supports HDCP2.2 and HDCP1.4, HDCP2.2 will be enabled.

When HDCP2.2 enabling fails and HDCP1.4 is supported, HDCP1.4 is enabled.

This change implements a sequence of enabling and disabling of HDCP2.2 authentication and HDCP2.2 port encryption.

Quoted 8 lines
Quoted 3 lines

Patch series suggestion for next time around: First build out the helper functions, then time them into the big picture like here. Personally I think that makes it easier to understand, but it's kinda personal choice.

Tried that already. But bisecting will give warnings as "defined but unused functions"

Hence moved to this approach.

Ah right, that's the annoying part with that approach. I tend to just ignore that until the series is built up (it's just a warning), but good point. As mentioned, there's pro/cons to each approach. -Daniel

Quoted 344 lines
Quoted 87 lines

I guess this here works too.

Quoted 84 lines

v2:
Included few optimization suggestions [Chris Wilson] Commit message is updated as per the rebased version. intel_wait_for_register is used instead of wait_for. [Chris Wilson]
v3:
No changes.
v4:
Extra comment added and Style issue fixed [Uma]
v5:
Rebased as part of patch reordering.
HDCP2 encryption status is tracked.
HW state check is moved into WARN_ON [Daniel]
v6:
Redefined the mei service functions as per comp redesign. Merged patches related to hdcp2.2 enabling and disabling [Sean Paul]. Required shim functionality is defined [Sean Paul]
v7:
Return values are handles [Uma]
Realigned the code.
Check for comp_master is removed.
v8:
HDCP2.2 is attempted only if mei interface is up.
Adjust to the new interface
Avoid bool usage in struct [Tomas]

---
  drivers/gpu/drm/i915/intel_drv.h  |   5 +
  drivers/gpu/drm/i915/intel_hdcp.c | 223 +++++++++++++++++++++++++++++++++++---
  2 files changed, 214 insertions(+), 14 deletions(-)
drivers/gpu/drm/i915/intel_drv.h +5 -0
index bde82f3ada85..3e9f21d23442 100644
@@ -383,6 +383,10 @@ struct intel_hdcp_shim {
  	/* Detects the HDCP protocol(DP/HDMI) required on the port */
  	enum mei_hdcp_wired_protocol (*hdcp_protocol)(void);
+
+	/* Detects whether Panel is HDCP2.2 capable */
+	int (*hdcp_2_2_capable)(struct intel_digital_port *intel_dig_port,
+				bool *capable);
  };
  struct intel_hdcp {
@@ -396,6 +400,7 @@ struct intel_hdcp {
  	/* HDCP2.2 related definitions */
  	/* Flag indicates whether this connector supports HDCP2.2 or not. */
  	u8 hdcp2_supported;
+	u8 hdcp2_in_use;
  	/*
  	 * Content Stream Type defined by content owner. TYPE0(0x0) content can
drivers/gpu/drm/i915/intel_hdcp.c +26 -0
index 760780f1105c..c1bd1ccd47cd 100644
@@ -79,6 +79,43 @@ bool intel_hdcp_capable(struct intel_connector *connector)
  	return capable;
  }
+/* At present whether mei_hdcp component is binded with i915 master component */
+static bool intel_hdcp2_mei_binded(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct i915_hdcp_component_master *comp = dev_priv->hdcp_comp;
+
+	mutex_lock(&comp->mutex);
+	if (!comp->ops || !comp->dev) {
+		mutex_unlock(&comp->mutex);
+		return false;
+	}
+	mutex_unlock(&comp->mutex);
+
+	return true;
+}
+
+/* Is HDCP2.2 capable on Platform and Sink */
+static bool intel_hdcp2_capable(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	bool capable = false;
+
+	/* I915 support for HDCP2.2 */
+	if (!hdcp->hdcp2_supported)
+		return false;
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c bool intel_hdcp_capable(struct intel_connector *connector) · line 111

Quoted 4 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+
+	/* MEI services for HDCP2.2 */
+	if (!intel_hdcp2_mei_binded(connector))
+		return false;

Why do we still need this with component? Driver load should be stalled out until it's all there, that was kinda the entire point of component, so we don't have to recheck all the time whether hdcp2 is still there or not.

We discussed this in previous patches. Lets decide whether this approach is good enough or not.

--Ram

Quoted 243 lines
Quoted 218 lines
drivers/gpu/drm/i915/intel_hdcp.c +175 -13
+
+	/* Sink's capability for HDCP2.2 */
+	hdcp->shim->hdcp_2_2_capable(intel_dig_port, &capable);
+
+	return capable;
+}
+
  static int intel_hdcp_poll_ksv_fifo(struct intel_digital_port *intel_dig_port,
  				    const struct intel_hdcp_shim *shim)
  {
@@ -1114,8 +1151,7 @@ int hdcp2_authenticate_port(struct intel_connector *connector)
  	return ret;
  }
-static __attribute__((unused))
-int hdcp2_close_mei_session(struct intel_connector *connector)
+static int hdcp2_close_mei_session(struct intel_connector *connector)
  {
  	struct mei_hdcp_data *data = &connector->hdcp.mei_data;
  	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
@@ -1137,12 +1173,157 @@ int hdcp2_close_mei_session(struct intel_connector *connector)
  	return ret;
  }
-static __attribute__((unused))
-int hdcp2_deauthenticate_port(struct intel_connector *connector)
+static int hdcp2_deauthenticate_port(struct intel_connector *connector)
  {
  	return hdcp2_close_mei_session(connector);
  }
+static int hdcp2_authenticate_sink(struct intel_connector *connector)
+{
+	DRM_ERROR("Sink authentication is done in subsequent patches\n");
+
+	return -EINVAL;
+}
+
+static int hdcp2_enable_encryption(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+	int ret;
+
+	WARN_ON(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS);
+
+	if (hdcp->shim->toggle_signalling) {
+		ret = hdcp->shim->toggle_signalling(intel_dig_port, true);
+		if (ret) {
+			DRM_ERROR("Failed to enable HDCP signalling. %d\n",
+				  ret);
+			return ret;
+		}
+	}
+
+	if (I915_READ(HDCP2_STATUS_DDI(port)) & LINK_AUTH_STATUS) {
+		/* Link is Authenticated. Now set for Encryption */
+		I915_WRITE(HDCP2_CTL_DDI(port),
+			   I915_READ(HDCP2_CTL_DDI(port)) |
+			   CTL_LINK_ENCRYPTION_REQ);
+	}
+
+	ret = intel_wait_for_register(dev_priv, HDCP2_STATUS_DDI(port),
+				      LINK_ENCRYPTION_STATUS,
+				      LINK_ENCRYPTION_STATUS,
+				      TIME_FOR_ENCRYPT_STATUS_CHANGE);
+
+	return ret;
+}
+
+static int hdcp2_disable_encryption(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+	int ret;
+
+	WARN_ON(!(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS));
+
+	I915_WRITE(HDCP2_CTL_DDI(port),
+		   I915_READ(HDCP2_CTL_DDI(port)) & ~CTL_LINK_ENCRYPTION_REQ);
+
+	ret = intel_wait_for_register(dev_priv, HDCP2_STATUS_DDI(port),
+				      LINK_ENCRYPTION_STATUS, 0x0,
+				      TIME_FOR_ENCRYPT_STATUS_CHANGE);
+	if (ret == -ETIMEDOUT)
+		DRM_DEBUG_KMS("Disable Encryption Timedout");
+
+	if (hdcp->shim->toggle_signalling) {
+		ret = hdcp->shim->toggle_signalling(intel_dig_port, false);
+		if (ret) {
+			DRM_ERROR("Failed to disable HDCP signalling. %d\n",
+				  ret);
+			return ret;
+		}
+	}
+
+	return ret;
+}
+
+static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector)
+{
+	int ret, i, tries = 3;
+
+	for (i = 0; i < tries; i++) {
+		ret = hdcp2_authenticate_sink(connector);
+		if (!ret)
+			break;
+
+		/* Clearing the mei hdcp session */
+		DRM_DEBUG_KMS("HDCP2.2 Auth %d of %d Failed.(%d)\n",
+			      i + 1, tries, ret);
+		if (hdcp2_deauthenticate_port(connector) < 0)
+			DRM_DEBUG_KMS("Port deauth failed.\n");
+	}
+
+	if (i != tries) {
+		/*
+		 * Ensuring the required 200mSec min time interval between
+		 * Session Key Exchange and encryption.
+		 */
+		msleep(HDCP_2_2_DELAY_BEFORE_ENCRYPTION_EN);
+		ret = hdcp2_enable_encryption(connector);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("Encryption Enable Failed.(%d)\n", ret);
+			if (hdcp2_deauthenticate_port(connector) < 0)
+				DRM_DEBUG_KMS("Port deauth failed.\n");
+		}
+	}
+
+	return ret;
+}
+
+static int _intel_hdcp2_enable(struct intel_connector *connector)
+{
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	int ret;
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being enabled. Type: %d\n",
+		      connector->base.name, connector->base.base.id,
+		      hdcp->content_type);
+
+	ret = hdcp2_authenticate_and_encrypt(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("HDCP2 Type%d  Enabling Failed. (%d)\n",
+			      hdcp->content_type, ret);
+		return ret;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is enabled. Type %d\n",
+		      connector->base.name, connector->base.base.id,
+		      hdcp->content_type);
+
+	hdcp->hdcp2_in_use = true;
+	return 0;
+}
+
+static int _intel_hdcp2_disable(struct intel_connector *connector)
+{
+	int ret;
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being Disabled\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = hdcp2_disable_encryption(connector);
+
+	if (hdcp2_deauthenticate_port(connector) < 0)
+		DRM_DEBUG_KMS("Port deauth failed.\n");
+
+	connector->hdcp.hdcp2_in_use = false;
+
+	return ret;
+}
+
  static int i915_hdcp_component_master_bind(struct device *dev)
  {
  	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
@@ -1342,22 +1523,33 @@ void intel_hdcp_exit(struct drm_i915_private *dev_priv)
  int intel_hdcp_enable(struct intel_connector *connector)
  {
  	struct intel_hdcp *hdcp = &connector->hdcp;
-	int ret;
+	int ret = -EINVAL;
  	if (!hdcp->shim)
  		return -ENOENT;
  	mutex_lock(&hdcp->mutex);
-	ret = _intel_hdcp_enable(connector);
-	if (ret)
-		goto out;
+	/*
+	 * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
+	 * is capable of HDCP2.2, it is preferred to use HDCP2.2.
+	 */
+	if (intel_hdcp2_capable(connector))
+		ret = _intel_hdcp2_enable(connector);
+
+	/* When HDCP2.2 fails, HDCP1.4 will be attempted */
+	if (ret && intel_hdcp_capable(connector)) {
+		ret = _intel_hdcp_enable(connector);
+		if (!ret)
+			schedule_delayed_work(&hdcp->check_work,
+					      DRM_HDCP_CHECK_PERIOD_MS);
+	}
+
+	if (!ret) {
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+		schedule_work(&hdcp->prop_work);
+	}
-	hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-	schedule_work(&hdcp->prop_work);
-	schedule_delayed_work(&hdcp->check_work,
-			      DRM_HDCP_CHECK_PERIOD_MS);
-out:
  	mutex_unlock(&hdcp->mutex);
  	return ret;
  }

drivers/gpu/drm/i915/intel_hdcp.c int intel_hdcp_disable(struct intel_connector *connector) · line 1571

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -1
@@ -1374,7 +1566,10 @@ int intel_hdcp_disable(struct intel_connector *connector)
  	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
  		hdcp->value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
-		ret = _intel_hdcp_disable(connector);
+		if (hdcp->hdcp2_in_use)
+			ret = _intel_hdcp2_disable(connector);
+		else
+			ret = _intel_hdcp_disable(connector);

Looks reasonable. So one thing we could be doing is already internally have a DRM_MODE_CONTENT_PROTECTION_ENABLED_TYPE1 for hdcp2.But the uapi would only return _ENABLED to userspace. But for internal tracking this would avoid the need for the separate hdcp2_in_use variable.

Probably good cleanup/prep patch for the type0/1 uapi extension, once we get there.

Aside from the component intergration question seems all reasonable. But I didn't yet review the hdcp2 flow, will do that once it's more complete in later patches.
-Daniel

Quoted 5 lines
drivers/gpu/drm/i915/intel_hdcp.c +0 -0
  	}
  	mutex_unlock(&hdcp->mutex);
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#29 lore raw

PATCH v8 7/35 drm/i915: Implement HDCP2.2 receiver authentication

In reply to Ramalingam C

Implements HDCP2.2 authentication for hdcp2.2 receivers, with following steps:
Authentication and Key exchange (AKE). Locality Check (LC).
Session Key Exchange(SKE).
DP Errata for stream type configuration for receivers.

At AKE, the HDCP Receiver’s public key certificate is verified by the HDCP Transmitter. A Master Key k m is exchanged.

At LC, the HDCP Transmitter enforces locality on the content by requiring that the Round Trip Time (RTT) between a pair of messages is not more than 20 ms.

At SKE, The HDCP Transmitter exchanges Session Key ks with the HDCP Receiver.

In DP HDCP2.2 encryption and decryption logics use the stream type as one of the parameter. So Before enabling the Encryption DP HDCP2.2 receiver needs to be communicated with stream type. This is added to spec as ERRATA.

This generic implementation is complete only with the hdcp2_shim defined.

v2:
Rebased.
v3:
No Changes.
v4:
%s/PARING/PAIRING
Coding style fixing [Uma]
v5:
Rebased as part of patch reordering.
Defined the functions for mei services. [Daniel]
v6:
Redefined the mei service functions as per comp redesign. Required intel_hdcp members are defined [Sean Paul]
v7:
Typo of cipher is Fixed [Uma]
%s/uintxx_t/uxx
Check for comp_master is removed.
v8:
Adjust to the new interface.
Avoid using bool structure members. [Tomas]

---
 drivers/gpu/drm/i915/intel_drv.h  |  34 ++++++
 drivers/gpu/drm/i915/intel_hdcp.c | 211 +++++++++++++++++++++++++++++++++++---
 2 files changed, 230 insertions(+), 15 deletions(-)
drivers/gpu/drm/i915/intel_drv.h +34 -0
index 3e9f21d23442..24d258488efe 100644
@@ -387,6 +387,22 @@ struct intel_hdcp_shim {
 	/* Detects whether Panel is HDCP2.2 capable */
 	int (*hdcp_2_2_capable)(struct intel_digital_port *intel_dig_port,
 				bool *capable);
+
+	/* Write HDCP2.2 messages */
+	int (*write_2_2_msg)(struct intel_digital_port *intel_dig_port,
+			     void *buf, size_t size);
+
+	/* Read HDCP2.2 messages */
+	int (*read_2_2_msg)(struct intel_digital_port *intel_dig_port,
+			    u8 msg_id, void *buf, size_t size);
+
+	/*
+	 * Implementation of DP HDCP2.2 Errata for the communication of stream
+	 * type to Receivers. In DP HDCP2.2 Stream type is one of the input to
+	 * the HDCP2.2 Cipher for En/De-Cryption. Not applicable for HDMI.
+	 */
+	int (*config_stream_type)(struct intel_digital_port *intel_dig_port,
+				  void *buf, size_t size);
 };
 
 struct intel_hdcp {
@@ -411,6 +427,24 @@ struct intel_hdcp {
 
 	/* mei interface related information */
 	struct mei_hdcp_data mei_data;
+
+	u8 is_paired;
+	u8 is_repeater;
+
+	/*
+	 * Count of ReceiverID_List received. Initialized to 0 at AKE_INIT.
+	 * Incremented after processing the RepeaterAuth_Send_ReceiverID_List.
+	 * When it rolls over re-auth has to be triggered.
+	 */
+	u32 seq_num_v;
+
+	/*
+	 * Count of RepeaterAuth_Stream_Manage msg propagated.
+	 * Initialized to 0 on AKE_INIT. Incremented after every successful
+	 * transmission of RepeaterAuth_Stream_Manage message. When it rolls
+	 * over re-Auth has to be triggered.
+	 */
+	u32 seq_num_m;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +196 -15

274 lines not on this page · raw message

Signature · 6 lines
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#30 lore raw

PATCH v8 8/35 drm/i915: Implement HDCP2.2 repeater authentication

In reply to Ramalingam C

Implements the HDCP2.2 repeaters authentication steps such as verifying the downstream topology and sending stream management information.

v2:
Rebased.
v3:
No Changes.
v4:
-EINVAL is returned for topology error and rollover scenario. Endianness conversion func from drm_hdcp.h is used [Uma]
v5:
Rebased as part of patches reordering.
Defined the mei service functions [Daniel]
v6:
Redefined the mei service functions as per comp redesign.
v7:
%s/uintxx_t/uxx
Check for comp_master is removed.
v8:
Adjust to the new mei interface.
style issue fixed.

---
 drivers/gpu/drm/i915/intel_hdcp.c | 125 +++++++++++++++++++++++++++++++++++++-
 include/drm/drm_hdcp.h            |  15 +++++
 2 files changed, 138 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_hdcp.c +123 -2
index 0d7fea9c9bb1..679f3c164582 100644
@@ -1069,7 +1069,7 @@ static int hdcp2_prepare_skey(struct intel_connector *connector,
 	return ret;
 }
 
-static __attribute__((unused)) int
+static int
 hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
 				      struct hdcp2_rep_send_receiverid_list
 								*rep_topology,
@@ -1099,7 +1099,7 @@ hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
 	return ret;
 }
 
-static __attribute__((unused)) int
+static int
 hdcp2_verify_mprime(struct intel_connector *connector,
 		    struct hdcp2_rep_stream_ready *stream_ready)
 {
@@ -1315,6 +1315,121 @@ static int hdcp2_session_key_exchange(struct intel_connector *connector)
 	return 0;
 }
 
+static
+int hdcp2_propagate_stream_management_info(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	union {
+		struct hdcp2_rep_stream_manage stream_manage;
+		struct hdcp2_rep_stream_ready stream_ready;
+	} msgs;
+	const struct intel_hdcp_shim *shim = hdcp->shim;
+	int ret;
+
+	/* Prepare RepeaterAuth_Stream_Manage msg */
+	msgs.stream_manage.msg_id = HDCP_2_2_REP_STREAM_MANAGE;
+	reverse_endianness(msgs.stream_manage.seq_num_m, HDCP_2_2_SEQ_NUM_LEN,
+			   (u8 *)&hdcp->seq_num_m);
+
+	/* K no of streams is fixed as 1. Stored as big-endian. */
+	msgs.stream_manage.k = __swab16(1);
+
+	/* For HDMI this is forced to be 0x0. For DP SST also this is 0x0. */
+	msgs.stream_manage.streams[0].stream_id = 0;
+	msgs.stream_manage.streams[0].stream_type = hdcp->content_type;
+
+	/* Send it to Repeater */
+	ret = shim->write_2_2_msg(intel_dig_port, &msgs.stream_manage,
+				  sizeof(msgs.stream_manage));
+	if (ret < 0)
+		return ret;
+
+	ret = shim->read_2_2_msg(intel_dig_port, HDCP_2_2_REP_STREAM_READY,
+				 &msgs.stream_ready, sizeof(msgs.stream_ready));
+	if (ret < 0)
+		return ret;
+
+	hdcp->mei_data.seq_num_m = hdcp->seq_num_m;
+	hdcp->mei_data.streams[0].stream_type = hdcp->content_type;
+
+	ret = hdcp2_verify_mprime(connector, &msgs.stream_ready);
+	if (ret < 0)
+		return ret;
+
+	hdcp->seq_num_m++;
+
+	if (hdcp->seq_num_m > HDCP_2_2_SEQ_NUM_MAX) {
+		DRM_DEBUG_KMS("seq_num_m roll over.\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+static
+int hdcp2_authenticate_repeater_topology(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	union {
+		struct hdcp2_rep_send_receiverid_list recvid_list;
+		struct hdcp2_rep_send_ack rep_ack;
+	} msgs;
+	const struct intel_hdcp_shim *shim = hdcp->shim;
+	u8 *rx_info;
+	u32 seq_num_v;
+	int ret;
+
+	ret = shim->read_2_2_msg(intel_dig_port, HDCP_2_2_REP_SEND_RECVID_LIST,
+				 &msgs.recvid_list, sizeof(msgs.recvid_list));
+	if (ret < 0)
+		return ret;
+
+	rx_info = msgs.recvid_list.rx_info;
+
+	if (HDCP_2_2_MAX_CASCADE_EXCEEDED(rx_info[1]) ||
+	    HDCP_2_2_MAX_DEVS_EXCEEDED(rx_info[1])) {
+		DRM_DEBUG_KMS("Topology Max Size Exceeded\n");
+		return -EINVAL;
+	}
+
+	/* Converting and Storing the seq_num_v to local variable as DWORD */
+	reverse_endianness((u8 *)&seq_num_v, HDCP_2_2_SEQ_NUM_LEN,
+			   msgs.recvid_list.seq_num_v);
+
+	if (seq_num_v < hdcp->seq_num_v) {
+		/* Roll over of the seq_num_v from repeater. Reauthenticate. */
+		DRM_DEBUG_KMS("Seq_num_v roll over.\n");
+		return -EINVAL;
+	}
+
+	ret = hdcp2_verify_rep_topology_prepare_ack(connector,
+						    &msgs.recvid_list,
+						    &msgs.rep_ack);
+	if (ret < 0)
+		return ret;
+
+	hdcp->seq_num_v = seq_num_v;
+	ret = shim->write_2_2_msg(intel_dig_port, &msgs.rep_ack,
+				  sizeof(msgs.rep_ack));
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static int hdcp2_authenticate_repeater(struct intel_connector *connector)
+{
+	int ret;
+
+	ret = hdcp2_authenticate_repeater_topology(connector);
+	if (ret < 0)
+		return ret;
+
+	return hdcp2_propagate_stream_management_info(connector);
+}
+
 static int hdcp2_authenticate_sink(struct intel_connector *connector)
 {
 	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
@@ -1356,6 +1471,12 @@ static int hdcp2_authenticate_sink(struct intel_connector *connector)
 					       sizeof(stream_type_msg));
 		if (ret < 0)
 			return ret;
+	} else if (hdcp->is_repeater) {
+		ret = hdcp2_authenticate_repeater(connector);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("Repeater Auth Failed. Err: %d\n", ret);
+			return ret;
+		}
 	}
 
 	hdcp->mei_data.streams[0].stream_type = hdcp->content_type;
include/drm/drm_hdcp.h +15 -0
index a6de09c5e47f..3e45a7618ab3 100644
@@ -250,4 +250,19 @@ struct hdcp2_dp_errata_stream_type {
 #define HDCP_2_2_HDMI_RXSTATUS_READY(x)		((x) & BIT(2))
 #define HDCP_2_2_HDMI_RXSTATUS_REAUTH_REQ(x)	((x) & BIT(3))
 
+/*
+ * Library functions for endianness are aligned for 16/32/64 bits.
+ * But hdcp sequence numbers are 24bits. So for their Byte swapping,
+ * a conversion function is developed.
+ */
+static inline void reverse_endianness(u8 *dest, size_t sz, u8 *src)
+{
+	u32 index;
+
+	if (!sz || sz > sizeof(u32))
+		return;
+	for (index = 0; index < sz; index++)
+		dest[sz - index - 1] = src[index];
+}
+
 #endif
Signature · 6 lines
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#31 lore raw

Re: [PATCH v8 08/35] drm/i915: Implement HDCP2.2 repeater authentication

Quoted 190 lines · Ramalingam C

Implements the HDCP2.2 repeaters authentication steps such as verifying the downstream topology and sending stream management information.

v2:
Rebased.
v3:
No Changes.
v4:
-EINVAL is returned for topology error and rollover scenario. Endianness conversion func from drm_hdcp.h is used [Uma]
v5:
Rebased as part of patches reordering.
Defined the mei service functions [Daniel]
v6:
Redefined the mei service functions as per comp redesign.
v7:
%s/uintxx_t/uxx
Check for comp_master is removed.
v8:
Adjust to the new mei interface.
style issue fixed.

---
 drivers/gpu/drm/i915/intel_hdcp.c | 125 +++++++++++++++++++++++++++++++++++++-
 include/drm/drm_hdcp.h            |  15 +++++
 2 files changed, 138 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_hdcp.c +123 -2
index 0d7fea9c9bb1..679f3c164582 100644
@@ -1069,7 +1069,7 @@ static int hdcp2_prepare_skey(struct intel_connector *connector,
 	return ret;
 }
 
-static __attribute__((unused)) int
+static int
 hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
 				      struct hdcp2_rep_send_receiverid_list
 								*rep_topology,
@@ -1099,7 +1099,7 @@ hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
 	return ret;
 }
 
-static __attribute__((unused)) int
+static int
 hdcp2_verify_mprime(struct intel_connector *connector,
 		    struct hdcp2_rep_stream_ready *stream_ready)
 {
@@ -1315,6 +1315,121 @@ static int hdcp2_session_key_exchange(struct intel_connector *connector)
 	return 0;
 }
 
+static
+int hdcp2_propagate_stream_management_info(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	union {
+		struct hdcp2_rep_stream_manage stream_manage;
+		struct hdcp2_rep_stream_ready stream_ready;
+	} msgs;
+	const struct intel_hdcp_shim *shim = hdcp->shim;
+	int ret;
+
+	/* Prepare RepeaterAuth_Stream_Manage msg */
+	msgs.stream_manage.msg_id = HDCP_2_2_REP_STREAM_MANAGE;
+	reverse_endianness(msgs.stream_manage.seq_num_m, HDCP_2_2_SEQ_NUM_LEN,
+			   (u8 *)&hdcp->seq_num_m);
+
+	/* K no of streams is fixed as 1. Stored as big-endian. */
+	msgs.stream_manage.k = __swab16(1);
+
+	/* For HDMI this is forced to be 0x0. For DP SST also this is 0x0. */
+	msgs.stream_manage.streams[0].stream_id = 0;
+	msgs.stream_manage.streams[0].stream_type = hdcp->content_type;
+
+	/* Send it to Repeater */
+	ret = shim->write_2_2_msg(intel_dig_port, &msgs.stream_manage,
+				  sizeof(msgs.stream_manage));
+	if (ret < 0)
+		return ret;
+
+	ret = shim->read_2_2_msg(intel_dig_port, HDCP_2_2_REP_STREAM_READY,
+				 &msgs.stream_ready, sizeof(msgs.stream_ready));
+	if (ret < 0)
+		return ret;
+
+	hdcp->mei_data.seq_num_m = hdcp->seq_num_m;
+	hdcp->mei_data.streams[0].stream_type = hdcp->content_type;
+
+	ret = hdcp2_verify_mprime(connector, &msgs.stream_ready);
+	if (ret < 0)
+		return ret;
+
+	hdcp->seq_num_m++;
+
+	if (hdcp->seq_num_m > HDCP_2_2_SEQ_NUM_MAX) {
+		DRM_DEBUG_KMS("seq_num_m roll over.\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+static
+int hdcp2_authenticate_repeater_topology(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	union {
+		struct hdcp2_rep_send_receiverid_list recvid_list;
+		struct hdcp2_rep_send_ack rep_ack;
+	} msgs;
+	const struct intel_hdcp_shim *shim = hdcp->shim;
+	u8 *rx_info;
+	u32 seq_num_v;
+	int ret;
+
+	ret = shim->read_2_2_msg(intel_dig_port, HDCP_2_2_REP_SEND_RECVID_LIST,
+				 &msgs.recvid_list, sizeof(msgs.recvid_list));
+	if (ret < 0)
+		return ret;
+
+	rx_info = msgs.recvid_list.rx_info;
+
+	if (HDCP_2_2_MAX_CASCADE_EXCEEDED(rx_info[1]) ||
+	    HDCP_2_2_MAX_DEVS_EXCEEDED(rx_info[1])) {
+		DRM_DEBUG_KMS("Topology Max Size Exceeded\n");
+		return -EINVAL;
+	}
+
+	/* Converting and Storing the seq_num_v to local variable as DWORD */
+	reverse_endianness((u8 *)&seq_num_v, HDCP_2_2_SEQ_NUM_LEN,
+			   msgs.recvid_list.seq_num_v);
+
+	if (seq_num_v < hdcp->seq_num_v) {
+		/* Roll over of the seq_num_v from repeater. Reauthenticate. */
+		DRM_DEBUG_KMS("Seq_num_v roll over.\n");
+		return -EINVAL;
+	}
+
+	ret = hdcp2_verify_rep_topology_prepare_ack(connector,
+						    &msgs.recvid_list,
+						    &msgs.rep_ack);
+	if (ret < 0)
+		return ret;
+
+	hdcp->seq_num_v = seq_num_v;
+	ret = shim->write_2_2_msg(intel_dig_port, &msgs.rep_ack,
+				  sizeof(msgs.rep_ack));
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static int hdcp2_authenticate_repeater(struct intel_connector *connector)
+{
+	int ret;
+
+	ret = hdcp2_authenticate_repeater_topology(connector);
+	if (ret < 0)
+		return ret;
+
+	return hdcp2_propagate_stream_management_info(connector);
+}
+
 static int hdcp2_authenticate_sink(struct intel_connector *connector)
 {
 	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
@@ -1356,6 +1471,12 @@ static int hdcp2_authenticate_sink(struct intel_connector *connector)
 					       sizeof(stream_type_msg));
 		if (ret < 0)
 			return ret;
+	} else if (hdcp->is_repeater) {
+		ret = hdcp2_authenticate_repeater(connector);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("Repeater Auth Failed. Err: %d\n", ret);
+			return ret;
+		}
 	}
 
 	hdcp->mei_data.streams[0].stream_type = hdcp->content_type;
include/drm/drm_hdcp.h +0 -0
index a6de09c5e47f..3e45a7618ab3 100644

include/drm/drm_hdcp.h struct hdcp2_dp_errata_stream_type { · line 258

Quoted 9 lines
include/drm/drm_hdcp.h +6 -0
@@ -250,4 +250,19 @@ struct hdcp2_dp_errata_stream_type {
 #define HDCP_2_2_HDMI_RXSTATUS_READY(x)		((x) & BIT(2))
 #define HDCP_2_2_HDMI_RXSTATUS_REAUTH_REQ(x)	((x) & BIT(3))
 
+/*
+ * Library functions for endianness are aligned for 16/32/64 bits.
+ * But hdcp sequence numbers are 24bits. So for their Byte swapping,
+ * a conversion function is developed.
+ */
+static inline void reverse_endianness(u8 *dest, size_t sz, u8 *src)

This feels a bit fake-generic and doesn't fit that well into what you want it to do in the code actually. What about:

u32 drm_hdcp2_seq_num_to_u32(u8 seq_num[HDCP_2_2_SEQ_NUM_LEN])

{
	return seq_num[2] | seq_num[1] << 8 | seq_num[0] << 16;
}

(I didn't check the math).

I think this would both make the code more clearer and avoid the problem of "shouldn't we make sure this works for everything and put it into linux/string.h?"

Again I'll check the actual hdcp2 flow later on.

In general I'm kinda not happy with the shim midlayer design, but I wasn't happy with that with hdcp1 either, and hdcp2 is just an extension, and I don't really have a better idea either so seems all good to me. -Daniel

Quoted 13 lines
include/drm/drm_hdcp.h +9 -0
+{
+	u32 index;
+
+	if (!sz || sz > sizeof(u32))
+		return;
+	for (index = 0; index < sz; index++)
+		dest[sz - index - 1] = src[index];
+}
+
 #endif
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#32 lore raw

Re: [PATCH v8 08/35] drm/i915: Implement HDCP2.2 repeater authentication

Quoted 203 lines · Daniel Vetter
Quoted 190 lines · Ramalingam C

Implements the HDCP2.2 repeaters authentication steps such as verifying the downstream topology and sending stream management information.

v2:
Rebased.
v3:
No Changes.
v4:
-EINVAL is returned for topology error and rollover scenario. Endianness conversion func from drm_hdcp.h is used [Uma]
v5:
Rebased as part of patches reordering.
Defined the mei service functions [Daniel]
v6:
Redefined the mei service functions as per comp redesign.
v7:
%s/uintxx_t/uxx
Check for comp_master is removed.
v8:
Adjust to the new mei interface.
style issue fixed.

---
  drivers/gpu/drm/i915/intel_hdcp.c | 125 +++++++++++++++++++++++++++++++++++++-
  include/drm/drm_hdcp.h            |  15 +++++
  2 files changed, 138 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_hdcp.c +123 -2
index 0d7fea9c9bb1..679f3c164582 100644
@@ -1069,7 +1069,7 @@ static int hdcp2_prepare_skey(struct intel_connector *connector,
  	return ret;
  }
 
-static __attribute__((unused)) int
+static int
  hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
  				      struct hdcp2_rep_send_receiverid_list
  								*rep_topology,
@@ -1099,7 +1099,7 @@ hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
  	return ret;
  }
 
-static __attribute__((unused)) int
+static int
  hdcp2_verify_mprime(struct intel_connector *connector,
  		    struct hdcp2_rep_stream_ready *stream_ready)
  {
@@ -1315,6 +1315,121 @@ static int hdcp2_session_key_exchange(struct intel_connector *connector)
  	return 0;
  }
 
+static
+int hdcp2_propagate_stream_management_info(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	union {
+		struct hdcp2_rep_stream_manage stream_manage;
+		struct hdcp2_rep_stream_ready stream_ready;
+	} msgs;
+	const struct intel_hdcp_shim *shim = hdcp->shim;
+	int ret;
+
+	/* Prepare RepeaterAuth_Stream_Manage msg */
+	msgs.stream_manage.msg_id = HDCP_2_2_REP_STREAM_MANAGE;
+	reverse_endianness(msgs.stream_manage.seq_num_m, HDCP_2_2_SEQ_NUM_LEN,
+			   (u8 *)&hdcp->seq_num_m);
+
+	/* K no of streams is fixed as 1. Stored as big-endian. */
+	msgs.stream_manage.k = __swab16(1);
+
+	/* For HDMI this is forced to be 0x0. For DP SST also this is 0x0. */
+	msgs.stream_manage.streams[0].stream_id = 0;
+	msgs.stream_manage.streams[0].stream_type = hdcp->content_type;
+
+	/* Send it to Repeater */
+	ret = shim->write_2_2_msg(intel_dig_port, &msgs.stream_manage,
+				  sizeof(msgs.stream_manage));
+	if (ret < 0)
+		return ret;
+
+	ret = shim->read_2_2_msg(intel_dig_port, HDCP_2_2_REP_STREAM_READY,
+				 &msgs.stream_ready, sizeof(msgs.stream_ready));
+	if (ret < 0)
+		return ret;
+
+	hdcp->mei_data.seq_num_m = hdcp->seq_num_m;
+	hdcp->mei_data.streams[0].stream_type = hdcp->content_type;
+
+	ret = hdcp2_verify_mprime(connector, &msgs.stream_ready);
+	if (ret < 0)
+		return ret;
+
+	hdcp->seq_num_m++;
+
+	if (hdcp->seq_num_m > HDCP_2_2_SEQ_NUM_MAX) {
+		DRM_DEBUG_KMS("seq_num_m roll over.\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+static
+int hdcp2_authenticate_repeater_topology(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	union {
+		struct hdcp2_rep_send_receiverid_list recvid_list;
+		struct hdcp2_rep_send_ack rep_ack;
+	} msgs;
+	const struct intel_hdcp_shim *shim = hdcp->shim;
+	u8 *rx_info;
+	u32 seq_num_v;
+	int ret;
+
+	ret = shim->read_2_2_msg(intel_dig_port, HDCP_2_2_REP_SEND_RECVID_LIST,
+				 &msgs.recvid_list, sizeof(msgs.recvid_list));
+	if (ret < 0)
+		return ret;
+
+	rx_info = msgs.recvid_list.rx_info;
+
+	if (HDCP_2_2_MAX_CASCADE_EXCEEDED(rx_info[1]) ||
+	    HDCP_2_2_MAX_DEVS_EXCEEDED(rx_info[1])) {
+		DRM_DEBUG_KMS("Topology Max Size Exceeded\n");
+		return -EINVAL;
+	}
+
+	/* Converting and Storing the seq_num_v to local variable as DWORD */
+	reverse_endianness((u8 *)&seq_num_v, HDCP_2_2_SEQ_NUM_LEN,
+			   msgs.recvid_list.seq_num_v);
+
+	if (seq_num_v < hdcp->seq_num_v) {
+		/* Roll over of the seq_num_v from repeater. Reauthenticate. */
+		DRM_DEBUG_KMS("Seq_num_v roll over.\n");
+		return -EINVAL;
+	}
+
+	ret = hdcp2_verify_rep_topology_prepare_ack(connector,
+						    &msgs.recvid_list,
+						    &msgs.rep_ack);
+	if (ret < 0)
+		return ret;
+
+	hdcp->seq_num_v = seq_num_v;
+	ret = shim->write_2_2_msg(intel_dig_port, &msgs.rep_ack,
+				  sizeof(msgs.rep_ack));
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static int hdcp2_authenticate_repeater(struct intel_connector *connector)
+{
+	int ret;
+
+	ret = hdcp2_authenticate_repeater_topology(connector);
+	if (ret < 0)
+		return ret;
+
+	return hdcp2_propagate_stream_management_info(connector);
+}
+
  static int hdcp2_authenticate_sink(struct intel_connector *connector)
  {
  	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
@@ -1356,6 +1471,12 @@ static int hdcp2_authenticate_sink(struct intel_connector *connector)
  					       sizeof(stream_type_msg));
  		if (ret < 0)
  			return ret;
+	} else if (hdcp->is_repeater) {
+		ret = hdcp2_authenticate_repeater(connector);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("Repeater Auth Failed. Err: %d\n", ret);
+			return ret;
+		}
  	}
 
  	hdcp->mei_data.streams[0].stream_type = hdcp->content_type;
include/drm/drm_hdcp.h +0 -0
index a6de09c5e47f..3e45a7618ab3 100644

include/drm/drm_hdcp.h struct hdcp2_dp_errata_stream_type { · line 258

Quoted 9 lines
include/drm/drm_hdcp.h +6 -0
@@ -250,4 +250,19 @@ struct hdcp2_dp_errata_stream_type {
  #define HDCP_2_2_HDMI_RXSTATUS_READY(x)		((x) & BIT(2))
  #define HDCP_2_2_HDMI_RXSTATUS_REAUTH_REQ(x)	((x) & BIT(3))
 
+/*
+ * Library functions for endianness are aligned for 16/32/64 bits.
+ * But hdcp sequence numbers are 24bits. So for their Byte swapping,
+ * a conversion function is developed.
+ */
+static inline void reverse_endianness(u8 *dest, size_t sz, u8 *src)

This feels a bit fake-generic and doesn't fit that well into what you want it to do in the code actually. What about:

Quoted 4 lines

u32 drm_hdcp2_seq_num_to_u32(u8 seq_num[HDCP_2_2_SEQ_NUM_LEN])

{
	return seq_num[2] | seq_num[1] << 8 | seq_num[0] << 16;
}

Understood the point. we need drm_hdcp2_u32_to_seq_num too... I will add that too.

-Ram

Quoted 14 lines

(I didn't check the math).

I think this would both make the code more clearer and avoid the problem of "shouldn't we make sure this works for everything and put it into linux/string.h?"

Again I'll check the actual hdcp2 flow later on.

In general I'm kinda not happy with the shim midlayer design, but I wasn't happy with that with hdcp1 either, and hdcp2 is just an extension, and I don't really have a better idea either so seems all good to me. -Daniel

Quoted 13 lines
Quoted 13 lines
include/drm/drm_hdcp.h +9 -0
+{
+	u32 index;
+
+	if (!sz || sz > sizeof(u32))
+		return;
+	for (index = 0; index < sz; index++)
+		dest[sz - index - 1] = src[index];
+}
+
  #endif
Signature · 1 line
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

#33 lore raw

PATCH v8 9/35 drm/i915: Implement HDCP2.2 link integrity check

In reply to Ramalingam C

Implements the link integrity check once in 500mSec.

Once encryption is enabled, an ongoing Link Integrity Check is performed by the HDCP Receiver to check that cipher synchronization is maintained between the HDCP Transmitter and the HDCP Receiver.

On the detection of synchronization lost, the HDCP Receiver must assert the corresponding bits of the RxStatus register. The Transmitter polls the RxStatus register and it may initiate re-authentication.

v2:
Rebased.
v3:
No Changes.
v4:
enum check_link_response is used check the link status [Uma]
v5:
Rebased as part of patch reordering.
v6:
Required members of intel_hdcp is defined [Sean Paul]
v7:
hdcp2_check_link is cancelled at required places.
v8:
Rebased for the component i/f changes.
Errors due to the sinks are reported as DEBUG logs.

---
 drivers/gpu/drm/i915/intel_display.c | 11 +++--
 drivers/gpu/drm/i915/intel_drv.h     |  5 +++
 drivers/gpu/drm/i915/intel_hdcp.c    | 83 +++++++++++++++++++++++++++++++++++-
 include/drm/drm_hdcp.h               |  8 ++++
 4 files changed, 103 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/intel_display.c +8 -3
index e9f4e22b2a4e..fc63babce165 100644
@@ -15833,15 +15833,20 @@ static void intel_hpd_poll_fini(struct drm_device *dev)
 {
 	struct intel_connector *connector;
 	struct drm_connector_list_iter conn_iter;
+	struct intel_hdcp *hdcp;
 
 	/* Kill all the work that may have been queued by hpd. */
 	drm_connector_list_iter_begin(dev, &conn_iter);
 	for_each_intel_connector_iter(connector, &conn_iter) {
+		hdcp = &connector->hdcp;
+
 		if (connector->modeset_retry_work.func)
 			cancel_work_sync(&connector->modeset_retry_work);
-		if (connector->hdcp.shim) {
-			cancel_delayed_work_sync(&connector->hdcp.check_work);
-			cancel_work_sync(&connector->hdcp.prop_work);
+		if (hdcp->shim) {
+			cancel_delayed_work_sync(&hdcp->check_work);
+			cancel_work_sync(&hdcp->prop_work);
+			if (hdcp->hdcp2_supported)
+				cancel_delayed_work_sync(&hdcp->hdcp2_check_work);
 		}
 	}
 	drm_connector_list_iter_end(&conn_iter);
drivers/gpu/drm/i915/intel_drv.h +5 -0
index 24d258488efe..e6e32bf52568 100644
@@ -403,6 +403,9 @@ struct intel_hdcp_shim {
 	 */
 	int (*config_stream_type)(struct intel_digital_port *intel_dig_port,
 				  void *buf, size_t size);
+
+	/* HDCP2.2 Link Integrity Check */
+	int (*check_2_2_link)(struct intel_digital_port *intel_dig_port);
 };
 
 struct intel_hdcp {
@@ -445,6 +448,8 @@ struct intel_hdcp {
 	 * over re-Auth has to be triggered.
 	 */
 	u32 seq_num_m;
+
+	struct delayed_work hdcp2_check_work;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +82 -1

108 lines not on this page · raw message

include/drm/drm_hdcp.h +8 -0
index 3e45a7618ab3..be07a2b56d23 100644
@@ -11,6 +11,14 @@
 
 /* Period of hdcp checks (to ensure we're still authenticated) */
 #define DRM_HDCP_CHECK_PERIOD_MS		(128 * 16)
+#define DRM_HDCP2_CHECK_PERIOD_MS		500
+
+enum check_link_response {
+	DRM_HDCP_LINK_PROTECTED	= 0,
+	DRM_HDCP_TOPOLOGY_CHANGE,
+	DRM_HDCP_LINK_INTEGRITY_FAILURE,
+	DRM_HDCP_REAUTH_REQUEST
+};
 
 /* Shared lengths/masks between HDMI/DVI/DisplayPort */
 #define DRM_HDCP_AN_LEN				8
Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#34 lore raw

Re: [PATCH v8 09/35] drm/i915: Implement HDCP2.2 link integrity check

Quoted 50 lines · Ramalingam C

Implements the link integrity check once in 500mSec.

Once encryption is enabled, an ongoing Link Integrity Check is performed by the HDCP Receiver to check that cipher synchronization is maintained between the HDCP Transmitter and the HDCP Receiver.

On the detection of synchronization lost, the HDCP Receiver must assert the corresponding bits of the RxStatus register. The Transmitter polls the RxStatus register and it may initiate re-authentication.

v2:
Rebased.
v3:
No Changes.
v4:
enum check_link_response is used check the link status [Uma]
v5:
Rebased as part of patch reordering.
v6:
Required members of intel_hdcp is defined [Sean Paul]
v7:
hdcp2_check_link is cancelled at required places.
v8:
Rebased for the component i/f changes.
Errors due to the sinks are reported as DEBUG logs.

---
 drivers/gpu/drm/i915/intel_display.c | 11 +++--
 drivers/gpu/drm/i915/intel_drv.h     |  5 +++
 drivers/gpu/drm/i915/intel_hdcp.c    | 83 +++++++++++++++++++++++++++++++++++-
 include/drm/drm_hdcp.h               |  8 ++++
 4 files changed, 103 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/intel_display.c +3 -0
index e9f4e22b2a4e..fc63babce165 100644
@@ -15833,15 +15833,20 @@ static void intel_hpd_poll_fini(struct drm_device *dev)
 {
 	struct intel_connector *connector;
 	struct drm_connector_list_iter conn_iter;
+	struct intel_hdcp *hdcp;
 
 	/* Kill all the work that may have been queued by hpd. */
 	drm_connector_list_iter_begin(dev, &conn_iter);
 	for_each_intel_connector_iter(connector, &conn_iter) {
+		hdcp = &connector->hdcp;
+

drivers/gpu/drm/i915/intel_display.c static void intel_hpd_poll_fini(struct drm_device *dev) · line 15849

Quoted 10 lines
drivers/gpu/drm/i915/intel_display.c +5 -3
 		if (connector->modeset_retry_work.func)
 			cancel_work_sync(&connector->modeset_retry_work);
-		if (connector->hdcp.shim) {
-			cancel_delayed_work_sync(&connector->hdcp.check_work);
-			cancel_work_sync(&connector->hdcp.prop_work);
+		if (hdcp->shim) {
+			cancel_delayed_work_sync(&hdcp->check_work);
+			cancel_work_sync(&hdcp->prop_work);
+			if (hdcp->hdcp2_supported)
+				cancel_delayed_work_sync(&hdcp->hdcp2_check_work);

Locking of these workers is always tricky ... why can't we use the same worker for both checking hdcp2 and hdcp1 link status?

Of course need to use the right timeout and call the right functions, but I think gives us less duplication in the complicated code.

Quoted 36 lines
drivers/gpu/drm/i915/intel_display.c +0 -0
 		}
 	}
 	drm_connector_list_iter_end(&conn_iter);
drivers/gpu/drm/i915/intel_drv.h +5 -0
index 24d258488efe..e6e32bf52568 100644
@@ -403,6 +403,9 @@ struct intel_hdcp_shim {
 	 */
 	int (*config_stream_type)(struct intel_digital_port *intel_dig_port,
 				  void *buf, size_t size);
+
+	/* HDCP2.2 Link Integrity Check */
+	int (*check_2_2_link)(struct intel_digital_port *intel_dig_port);
 };
 
 struct intel_hdcp {
@@ -445,6 +448,8 @@ struct intel_hdcp {
 	 * over re-Auth has to be triggered.
 	 */
 	u32 seq_num_m;
+
+	struct delayed_work hdcp2_check_work;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
index 679f3c164582..98b112395a5a 100644
@@ -1626,6 +1626,81 @@ static int _intel_hdcp2_disable(struct intel_connector *connector)
 	return ret;
 }
 
+/* Implements the Link Integrity Check for HDCP2.2 */
+static int intel_hdcp2_check_link(struct intel_connector *connector)

drivers/gpu/drm/i915/intel_hdcp.c static int _intel_hdcp2_disable(struct intel_connector *connector) · line 1640

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;

Why is this possible? Should we wrap it into at least a WARN_ON?

Quoted 102 lines
drivers/gpu/drm/i915/intel_hdcp.c +70 -1
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS)) {
+		DRM_ERROR("HDCP2.2 check failed: link is not encrypted, %x\n",
+			  I915_READ(HDCP2_STATUS_DDI(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = hdcp->shim->check_2_2_link(intel_dig_port);
+	if (ret == DRM_HDCP_LINK_PROTECTED) {
+		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp2_disable(connector);
+	if (ret) {
+		DRM_ERROR("[%s:%d] Failed to disable hdcp2.2 (%d)\n",
+			  connector->base.name, connector->base.base.id, ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp2_enable(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("[%s:%d] Failed to enable hdcp2.2 (%d)\n",
+			      connector->base.name, connector->base.base.id,
+			      ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
+static void intel_hdcp2_check_work(struct work_struct *work)
+{
+	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
+					       struct intel_hdcp,
+					       hdcp2_check_work);
+	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
+
+	if (!intel_hdcp2_check_link(connector))
+		schedule_delayed_work(&hdcp->hdcp2_check_work,
+				      DRM_HDCP2_CHECK_PERIOD_MS);
+}
+
 static int i915_hdcp_component_master_bind(struct device *dev)
 {
 	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
@@ -1762,6 +1837,7 @@ static void intel_hdcp2_init(struct intel_connector *connector)
 		return;
 	}
 
+	INIT_DELAYED_WORK(&hdcp->hdcp2_check_work, intel_hdcp2_check_work);
 	hdcp->hdcp2_supported = 1;
 }
 
@@ -1836,8 +1912,12 @@ int intel_hdcp_enable(struct intel_connector *connector)
 	 * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
 	 * is capable of HDCP2.2, it is preferred to use HDCP2.2.
 	 */
-	if (intel_hdcp2_capable(connector))
+	if (intel_hdcp2_capable(connector)) {
 		ret = _intel_hdcp2_enable(connector);
+		if (!ret)
+			schedule_delayed_work(&hdcp->hdcp2_check_work,
+					      DRM_HDCP2_CHECK_PERIOD_MS);
+	}
 
 	/* When HDCP2.2 fails, HDCP1.4 will be attempted */
 	if (ret && intel_hdcp_capable(connector)) {
@@ -1876,6 +1956,7 @@ int intel_hdcp_disable(struct intel_connector *connector)
 
 	mutex_unlock(&hdcp->mutex);
 	cancel_delayed_work_sync(&hdcp->check_work);
+	cancel_delayed_work_sync(&hdcp->hdcp2_check_work);
 	return ret;
 }
 
include/drm/drm_hdcp.h +0 -0
index 3e45a7618ab3..be07a2b56d23 100644
@@ -11,6 +11,14 @@
 

include/drm/drm_hdcp.h line 21

Quoted 10 lines
include/drm/drm_hdcp.h +8 -0
 /* Period of hdcp checks (to ensure we're still authenticated) */
 #define DRM_HDCP_CHECK_PERIOD_MS		(128 * 16)
+#define DRM_HDCP2_CHECK_PERIOD_MS		500
+
+enum check_link_response {
+	DRM_HDCP_LINK_PROTECTED	= 0,
+	DRM_HDCP_TOPOLOGY_CHANGE,
+	DRM_HDCP_LINK_INTEGRITY_FAILURE,
+	DRM_HDCP_REAUTH_REQUEST
+};

The drm_hdcp.h changes need to be all split out into sepearate patches I think. Just for highlighting of the new shared bits. Also applies to the previous one.

Otherwise looks all reasonable.
-Daniel

Quoted 6 lines
include/drm/drm_hdcp.h +0 -0
 /* Shared lengths/masks between HDMI/DVI/DisplayPort */
 #define DRM_HDCP_AN_LEN				8
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#35 lore raw

Re: [PATCH v8 09/35] drm/i915: Implement HDCP2.2 link integrity check

Quoted 65 lines · Daniel Vetter
Quoted 50 lines · Ramalingam C

Implements the link integrity check once in 500mSec.

Once encryption is enabled, an ongoing Link Integrity Check is performed by the HDCP Receiver to check that cipher synchronization is maintained between the HDCP Transmitter and the HDCP Receiver.

On the detection of synchronization lost, the HDCP Receiver must assert the corresponding bits of the RxStatus register. The Transmitter polls the RxStatus register and it may initiate re-authentication.

v2:
Rebased.
v3:
No Changes.
v4:
enum check_link_response is used check the link status [Uma]
v5:
Rebased as part of patch reordering.
v6:
Required members of intel_hdcp is defined [Sean Paul]
v7:
hdcp2_check_link is cancelled at required places.
v8:
Rebased for the component i/f changes.
Errors due to the sinks are reported as DEBUG logs.

---
 drivers/gpu/drm/i915/intel_display.c | 11 +++--
 drivers/gpu/drm/i915/intel_drv.h     |  5 +++
 drivers/gpu/drm/i915/intel_hdcp.c    | 83 +++++++++++++++++++++++++++++++++++-
 include/drm/drm_hdcp.h               |  8 ++++
 4 files changed, 103 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/intel_display.c +3 -0
index e9f4e22b2a4e..fc63babce165 100644
@@ -15833,15 +15833,20 @@ static void intel_hpd_poll_fini(struct drm_device *dev)
 {
 	struct intel_connector *connector;
 	struct drm_connector_list_iter conn_iter;
+	struct intel_hdcp *hdcp;
 
 	/* Kill all the work that may have been queued by hpd. */
 	drm_connector_list_iter_begin(dev, &conn_iter);
 	for_each_intel_connector_iter(connector, &conn_iter) {
+		hdcp = &connector->hdcp;
+

drivers/gpu/drm/i915/intel_display.c static void intel_hpd_poll_fini(struct drm_device *dev) · line 15849

Quoted 10 lines
drivers/gpu/drm/i915/intel_display.c +5 -3
 		if (connector->modeset_retry_work.func)
 			cancel_work_sync(&connector->modeset_retry_work);
-		if (connector->hdcp.shim) {
-			cancel_delayed_work_sync(&connector->hdcp.check_work);
-			cancel_work_sync(&connector->hdcp.prop_work);
+		if (hdcp->shim) {
+			cancel_delayed_work_sync(&hdcp->check_work);
+			cancel_work_sync(&hdcp->prop_work);
+			if (hdcp->hdcp2_supported)
+				cancel_delayed_work_sync(&hdcp->hdcp2_check_work);

Locking of these workers is always tricky ... why can't we use the same worker for both checking hdcp2 and hdcp1 link status?

Quoted 2 lines

Of course need to use the right timeout and call the right functions, but I think gives us less duplication in the complicated code.

Locking and also the logic to update the content protection property. I think sharing the entire main function, and splitting to hdcp1 vs. hdcp2 in the check/enable/disable functions would be neat.
-Daniel

Quoted 183 lines
Quoted 38 lines
drivers/gpu/drm/i915/intel_display.c +0 -0
 		}
 	}
 	drm_connector_list_iter_end(&conn_iter);
drivers/gpu/drm/i915/intel_drv.h +5 -0
index 24d258488efe..e6e32bf52568 100644
@@ -403,6 +403,9 @@ struct intel_hdcp_shim {
 	 */
 	int (*config_stream_type)(struct intel_digital_port *intel_dig_port,
 				  void *buf, size_t size);
+
+	/* HDCP2.2 Link Integrity Check */
+	int (*check_2_2_link)(struct intel_digital_port *intel_dig_port);
 };
 
 struct intel_hdcp {
@@ -445,6 +448,8 @@ struct intel_hdcp {
 	 * over re-Auth has to be triggered.
 	 */
 	u32 seq_num_m;
+
+	struct delayed_work hdcp2_check_work;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +2 -0
index 679f3c164582..98b112395a5a 100644
@@ -1626,6 +1626,81 @@ static int _intel_hdcp2_disable(struct intel_connector *connector)
 	return ret;
 }
 
+/* Implements the Link Integrity Check for HDCP2.2 */
+static int intel_hdcp2_check_link(struct intel_connector *connector)

drivers/gpu/drm/i915/intel_hdcp.c static int _intel_hdcp2_disable(struct intel_connector *connector) · line 1640

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdcp.c +10 -0
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;

Why is this possible? Should we wrap it into at least a WARN_ON?

Quoted 102 lines
drivers/gpu/drm/i915/intel_hdcp.c +70 -1
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS)) {
+		DRM_ERROR("HDCP2.2 check failed: link is not encrypted, %x\n",
+			  I915_READ(HDCP2_STATUS_DDI(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = hdcp->shim->check_2_2_link(intel_dig_port);
+	if (ret == DRM_HDCP_LINK_PROTECTED) {
+		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp2_disable(connector);
+	if (ret) {
+		DRM_ERROR("[%s:%d] Failed to disable hdcp2.2 (%d)\n",
+			  connector->base.name, connector->base.base.id, ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp2_enable(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("[%s:%d] Failed to enable hdcp2.2 (%d)\n",
+			      connector->base.name, connector->base.base.id,
+			      ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
+static void intel_hdcp2_check_work(struct work_struct *work)
+{
+	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
+					       struct intel_hdcp,
+					       hdcp2_check_work);
+	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
+
+	if (!intel_hdcp2_check_link(connector))
+		schedule_delayed_work(&hdcp->hdcp2_check_work,
+				      DRM_HDCP2_CHECK_PERIOD_MS);
+}
+
 static int i915_hdcp_component_master_bind(struct device *dev)
 {
 	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
@@ -1762,6 +1837,7 @@ static void intel_hdcp2_init(struct intel_connector *connector)
 		return;
 	}
 
+	INIT_DELAYED_WORK(&hdcp->hdcp2_check_work, intel_hdcp2_check_work);
 	hdcp->hdcp2_supported = 1;
 }
 
@@ -1836,8 +1912,12 @@ int intel_hdcp_enable(struct intel_connector *connector)
 	 * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
 	 * is capable of HDCP2.2, it is preferred to use HDCP2.2.
 	 */
-	if (intel_hdcp2_capable(connector))
+	if (intel_hdcp2_capable(connector)) {
 		ret = _intel_hdcp2_enable(connector);
+		if (!ret)
+			schedule_delayed_work(&hdcp->hdcp2_check_work,
+					      DRM_HDCP2_CHECK_PERIOD_MS);
+	}
 
 	/* When HDCP2.2 fails, HDCP1.4 will be attempted */
 	if (ret && intel_hdcp_capable(connector)) {
@@ -1876,6 +1956,7 @@ int intel_hdcp_disable(struct intel_connector *connector)
 
 	mutex_unlock(&hdcp->mutex);
 	cancel_delayed_work_sync(&hdcp->check_work);
+	cancel_delayed_work_sync(&hdcp->hdcp2_check_work);
 	return ret;
 }
 
include/drm/drm_hdcp.h +0 -0
index 3e45a7618ab3..be07a2b56d23 100644
@@ -11,6 +11,14 @@
 

include/drm/drm_hdcp.h line 21

Quoted 10 lines
include/drm/drm_hdcp.h +8 -0
 /* Period of hdcp checks (to ensure we're still authenticated) */
 #define DRM_HDCP_CHECK_PERIOD_MS		(128 * 16)
+#define DRM_HDCP2_CHECK_PERIOD_MS		500
+
+enum check_link_response {
+	DRM_HDCP_LINK_PROTECTED	= 0,
+	DRM_HDCP_TOPOLOGY_CHANGE,
+	DRM_HDCP_LINK_INTEGRITY_FAILURE,
+	DRM_HDCP_REAUTH_REQUEST
+};

The drm_hdcp.h changes need to be all split out into sepearate patches I think. Just for highlighting of the new shared bits. Also applies to the previous one.

Otherwise looks all reasonable.
-Daniel

Quoted 6 lines
include/drm/drm_hdcp.h +0 -0
 /* Shared lengths/masks between HDMI/DVI/DisplayPort */
 #define DRM_HDCP_AN_LEN				8
Signature · 1 line
2.7.4
Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#36 lore raw

Re: [PATCH v8 09/35] drm/i915: Implement HDCP2.2 link integrity check

In reply to Daniel Vetter
Quoted 55 lines · Daniel Vetter
Quoted 54 lines · Ramalingam C

Implements the link integrity check once in 500mSec.

Once encryption is enabled, an ongoing Link Integrity Check is performed by the HDCP Receiver to check that cipher synchronization is maintained between the HDCP Transmitter and the HDCP Receiver.

On the detection of synchronization lost, the HDCP Receiver must assert the corresponding bits of the RxStatus register. The Transmitter polls the RxStatus register and it may initiate re-authentication.

v2:
Rebased.
v3:
No Changes.
v4:
enum check_link_response is used check the link status [Uma]
v5:
Rebased as part of patch reordering.
v6:
Required members of intel_hdcp is defined [Sean Paul]
v7:
hdcp2_check_link is cancelled at required places.
v8:
Rebased for the component i/f changes.
Errors due to the sinks are reported as DEBUG logs.

---
  drivers/gpu/drm/i915/intel_display.c | 11 +++--
  drivers/gpu/drm/i915/intel_drv.h     |  5 +++
  drivers/gpu/drm/i915/intel_hdcp.c    | 83 +++++++++++++++++++++++++++++++++++-
  include/drm/drm_hdcp.h               |  8 ++++
  4 files changed, 103 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/intel_display.c +3 -2
index e9f4e22b2a4e..fc63babce165 100644
@@ -15833,15 +15833,20 @@ static void intel_hpd_poll_fini(struct drm_device *dev)
  {
  	struct intel_connector *connector;
  	struct drm_connector_list_iter conn_iter;
+	struct intel_hdcp *hdcp;
 
  	/* Kill all the work that may have been queued by hpd. */
  	drm_connector_list_iter_begin(dev, &conn_iter);
  	for_each_intel_connector_iter(connector, &conn_iter) {
+		hdcp = &connector->hdcp;
+
  		if (connector->modeset_retry_work.func)
  			cancel_work_sync(&connector->modeset_retry_work);
-		if (connector->hdcp.shim) {
-			cancel_delayed_work_sync(&connector->hdcp.check_work);
Quoted 8 lines

drivers/gpu/drm/i915/intel_display.c static void intel_hpd_poll_fini(struct drm_device *dev) · line 15849

Quoted 6 lines
drivers/gpu/drm/i915/intel_display.c +5 -1
-			cancel_work_sync(&connector->hdcp.prop_work);
+		if (hdcp->shim) {
+			cancel_delayed_work_sync(&hdcp->check_work);
+			cancel_work_sync(&hdcp->prop_work);
+			if (hdcp->hdcp2_supported)
+				cancel_delayed_work_sync(&hdcp->hdcp2_check_work);

Locking of these workers is always tricky ... why can't we use the same worker for both checking hdcp2 and hdcp1 link status?

Doable similar to how we are doing hdcp_enable. Needs the tracking of the spec in use to pick proper timeout and functions.

I will look into it.

Quoted 39 lines

Of course need to use the right timeout and call the right functions, but I think gives us less duplication in the complicated code.

Quoted 34 lines
drivers/gpu/drm/i915/intel_display.c +0 -0
  		}
  	}
  	drm_connector_list_iter_end(&conn_iter);
drivers/gpu/drm/i915/intel_drv.h +5 -0
index 24d258488efe..e6e32bf52568 100644
@@ -403,6 +403,9 @@ struct intel_hdcp_shim {
  	 */
  	int (*config_stream_type)(struct intel_digital_port *intel_dig_port,
  				  void *buf, size_t size);
+
+	/* HDCP2.2 Link Integrity Check */
+	int (*check_2_2_link)(struct intel_digital_port *intel_dig_port);
  };
 
  struct intel_hdcp {
@@ -445,6 +448,8 @@ struct intel_hdcp {
  	 * over re-Auth has to be triggered.
  	 */
  	u32 seq_num_m;
+
+	struct delayed_work hdcp2_check_work;
  };
 
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +0 -0
index 679f3c164582..98b112395a5a 100644
@@ -1626,6 +1626,81 @@ static int _intel_hdcp2_disable(struct intel_connector *connector)
  	return ret;
  }
 
Quoted 13 lines

drivers/gpu/drm/i915/intel_hdcp.c static int _intel_hdcp2_disable(struct intel_connector *connector) · line 1640

Quoted 12 lines
drivers/gpu/drm/i915/intel_hdcp.c +12 -0
+/* Implements the Link Integrity Check for HDCP2.2 */
+static int intel_hdcp2_check_link(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;

Why is this possible? Should we wrap it into at least a WARN_ON?

we could land here from CP_IRQ, with hdcp_exit called for shim removal. But could avoid if we assert on the HDCP auth/encrypt status of the port before check_link.

Quoted 103 lines
Quoted 103 lines
drivers/gpu/drm/i915/intel_hdcp.c +70 -1
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS)) {
+		DRM_ERROR("HDCP2.2 check failed: link is not encrypted, %x\n",
+			  I915_READ(HDCP2_STATUS_DDI(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = hdcp->shim->check_2_2_link(intel_dig_port);
+	if (ret == DRM_HDCP_LINK_PROTECTED) {
+		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp2_disable(connector);
+	if (ret) {
+		DRM_ERROR("[%s:%d] Failed to disable hdcp2.2 (%d)\n",
+			  connector->base.name, connector->base.base.id, ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp2_enable(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("[%s:%d] Failed to enable hdcp2.2 (%d)\n",
+			      connector->base.name, connector->base.base.id,
+			      ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
+static void intel_hdcp2_check_work(struct work_struct *work)
+{
+	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
+					       struct intel_hdcp,
+					       hdcp2_check_work);
+	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
+
+	if (!intel_hdcp2_check_link(connector))
+		schedule_delayed_work(&hdcp->hdcp2_check_work,
+				      DRM_HDCP2_CHECK_PERIOD_MS);
+}
+
  static int i915_hdcp_component_master_bind(struct device *dev)
  {
  	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
@@ -1762,6 +1837,7 @@ static void intel_hdcp2_init(struct intel_connector *connector)
  		return;
  	}
 
+	INIT_DELAYED_WORK(&hdcp->hdcp2_check_work, intel_hdcp2_check_work);
  	hdcp->hdcp2_supported = 1;
  }
 
@@ -1836,8 +1912,12 @@ int intel_hdcp_enable(struct intel_connector *connector)
  	 * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
  	 * is capable of HDCP2.2, it is preferred to use HDCP2.2.
  	 */
-	if (intel_hdcp2_capable(connector))
+	if (intel_hdcp2_capable(connector)) {
  		ret = _intel_hdcp2_enable(connector);
+		if (!ret)
+			schedule_delayed_work(&hdcp->hdcp2_check_work,
+					      DRM_HDCP2_CHECK_PERIOD_MS);
+	}
 
  	/* When HDCP2.2 fails, HDCP1.4 will be attempted */
  	if (ret && intel_hdcp_capable(connector)) {
@@ -1876,6 +1956,7 @@ int intel_hdcp_disable(struct intel_connector *connector)
 
  	mutex_unlock(&hdcp->mutex);
  	cancel_delayed_work_sync(&hdcp->check_work);
+	cancel_delayed_work_sync(&hdcp->hdcp2_check_work);
  	return ret;
  }
 
include/drm/drm_hdcp.h +0 -0
index 3e45a7618ab3..be07a2b56d23 100644
@@ -11,6 +11,14 @@
 
Quoted 13 lines

include/drm/drm_hdcp.h line 21

Quoted 10 lines
include/drm/drm_hdcp.h +8 -0
  /* Period of hdcp checks (to ensure we're still authenticated) */
  #define DRM_HDCP_CHECK_PERIOD_MS		(128 * 16)
+#define DRM_HDCP2_CHECK_PERIOD_MS		500
+
+enum check_link_response {
+	DRM_HDCP_LINK_PROTECTED	= 0,
+	DRM_HDCP_TOPOLOGY_CHANGE,
+	DRM_HDCP_LINK_INTEGRITY_FAILURE,
+	DRM_HDCP_REAUTH_REQUEST
+};

The drm_hdcp.h changes need to be all split out into sepearate patches I think. Just for highlighting of the new shared bits. Also applies to the previous one.

Is this specific to drm_hdcp.h? In the previous version i had all header changes in a single patch. But Seanpaul suggested for better understanding of the changes, to introduce the changes at the patches where they are used.

Still should we go back on this?

--Ram

Quoted 11 lines

Otherwise looks all reasonable.
-Daniel

Quoted 6 lines
include/drm/drm_hdcp.h +0 -0
  /* Shared lengths/masks between HDMI/DVI/DisplayPort */
  #define DRM_HDCP_AN_LEN				8
Signature · 1 line
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#37 lore raw

Re: [PATCH v8 09/35] drm/i915: Implement HDCP2.2 link integrity check

Quoted 65 lines · Ramalingam
Quoted 54 lines · Daniel Vetter
Quoted 53 lines · Ramalingam C

Implements the link integrity check once in 500mSec.

Once encryption is enabled, an ongoing Link Integrity Check is performed by the HDCP Receiver to check that cipher synchronization is maintained between the HDCP Transmitter and the HDCP Receiver.

On the detection of synchronization lost, the HDCP Receiver must assert the corresponding bits of the RxStatus register. The Transmitter polls the RxStatus register and it may initiate re-authentication.

v2:
Rebased.
v3:
No Changes.
v4:
enum check_link_response is used check the link status [Uma]
v5:
Rebased as part of patch reordering.
v6:
Required members of intel_hdcp is defined [Sean Paul]
v7:
hdcp2_check_link is cancelled at required places.
v8:
Rebased for the component i/f changes.
Errors due to the sinks are reported as DEBUG logs.

---
  drivers/gpu/drm/i915/intel_display.c | 11 +++--
  drivers/gpu/drm/i915/intel_drv.h     |  5 +++
  drivers/gpu/drm/i915/intel_hdcp.c    | 83 +++++++++++++++++++++++++++++++++++-
  include/drm/drm_hdcp.h               |  8 ++++
  4 files changed, 103 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/intel_display.c +3 -2
index e9f4e22b2a4e..fc63babce165 100644
@@ -15833,15 +15833,20 @@ static void intel_hpd_poll_fini(struct drm_device *dev)
  {
  	struct intel_connector *connector;
  	struct drm_connector_list_iter conn_iter;
+	struct intel_hdcp *hdcp;
  	/* Kill all the work that may have been queued by hpd. */
  	drm_connector_list_iter_begin(dev, &conn_iter);
  	for_each_intel_connector_iter(connector, &conn_iter) {
+		hdcp = &connector->hdcp;
+
  		if (connector->modeset_retry_work.func)
  			cancel_work_sync(&connector->modeset_retry_work);
-		if (connector->hdcp.shim) {
-			cancel_delayed_work_sync(&connector->hdcp.check_work);
Quoted 8 lines

drivers/gpu/drm/i915/intel_display.c static void intel_hpd_poll_fini(struct drm_device *dev) · line 15849

Quoted 6 lines
drivers/gpu/drm/i915/intel_display.c +5 -1
-			cancel_work_sync(&connector->hdcp.prop_work);
+		if (hdcp->shim) {
+			cancel_delayed_work_sync(&hdcp->check_work);
+			cancel_work_sync(&hdcp->prop_work);
+			if (hdcp->hdcp2_supported)
+				cancel_delayed_work_sync(&hdcp->hdcp2_check_work);

Locking of these workers is always tricky ... why can't we use the same worker for both checking hdcp2 and hdcp1 link status?

Quoted 2 lines

Doable similar to how we are doing hdcp_enable. Needs the tracking of the spec in use to pick proper timeout and functions.

Yeah we definitely want separate enable/disable functions for hdcp1 and hdcp2. I was thinking of only sharing the content_protection status logic, and the worker scheduling logic. That looks the same, and imo that's the tricky part. I.e. separate the drm interfacing side more from the hdcp hw flow.

Quoted 167 lines

I will look into it.

Quoted 41 lines

Of course need to use the right timeout and call the right functions, but I think gives us less duplication in the complicated code.

Quoted 36 lines
drivers/gpu/drm/i915/intel_display.c +0 -0
  		}
  	}
  	drm_connector_list_iter_end(&conn_iter);
drivers/gpu/drm/i915/intel_drv.h +5 -0
index 24d258488efe..e6e32bf52568 100644
@@ -403,6 +403,9 @@ struct intel_hdcp_shim {
  	 */
  	int (*config_stream_type)(struct intel_digital_port *intel_dig_port,
  				  void *buf, size_t size);
+
+	/* HDCP2.2 Link Integrity Check */
+	int (*check_2_2_link)(struct intel_digital_port *intel_dig_port);
  };
  struct intel_hdcp {
@@ -445,6 +448,8 @@ struct intel_hdcp {
  	 * over re-Auth has to be triggered.
  	 */
  	u32 seq_num_m;
+
+	struct delayed_work hdcp2_check_work;
  };
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
index 679f3c164582..98b112395a5a 100644
@@ -1626,6 +1626,81 @@ static int _intel_hdcp2_disable(struct intel_connector *connector)
  	return ret;
  }
+/* Implements the Link Integrity Check for HDCP2.2 */
+static int intel_hdcp2_check_link(struct intel_connector *connector)
+{
+	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
Quoted 8 lines

drivers/gpu/drm/i915/intel_hdcp.c static int _intel_hdcp2_disable(struct intel_connector *connector) · line 1640

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +7 -0
+	struct intel_hdcp *hdcp = &connector->hdcp;
+	enum port port = connector->encoder->port;
+
+	int ret = 0;
+
+	if (!hdcp->shim)
+		return -ENOENT;

Why is this possible? Should we wrap it into at least a WARN_ON?

we could land here from CP_IRQ, with hdcp_exit called for shim removal. But could avoid if we assert on the HDCP auth/encrypt status of the port before check_link.

Quoted 102 lines
Quoted 102 lines
drivers/gpu/drm/i915/intel_hdcp.c +70 -1
+
+	mutex_lock(&hdcp->mutex);
+
+	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+		goto out;
+
+	if (!(I915_READ(HDCP2_STATUS_DDI(port)) & LINK_ENCRYPTION_STATUS)) {
+		DRM_ERROR("HDCP2.2 check failed: link is not encrypted, %x\n",
+			  I915_READ(HDCP2_STATUS_DDI(port)));
+		ret = -ENXIO;
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = hdcp->shim->check_2_2_link(intel_dig_port);
+	if (ret == DRM_HDCP_LINK_PROTECTED) {
+		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+		}
+		goto out;
+	}
+
+	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
+		      connector->base.name, connector->base.base.id);
+
+	ret = _intel_hdcp2_disable(connector);
+	if (ret) {
+		DRM_ERROR("[%s:%d] Failed to disable hdcp2.2 (%d)\n",
+			  connector->base.name, connector->base.base.id, ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+	ret = _intel_hdcp2_enable(connector);
+	if (ret) {
+		DRM_DEBUG_KMS("[%s:%d] Failed to enable hdcp2.2 (%d)\n",
+			      connector->base.name, connector->base.base.id,
+			      ret);
+		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
+		schedule_work(&hdcp->prop_work);
+		goto out;
+	}
+
+out:
+	mutex_unlock(&hdcp->mutex);
+	return ret;
+}
+
+static void intel_hdcp2_check_work(struct work_struct *work)
+{
+	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
+					       struct intel_hdcp,
+					       hdcp2_check_work);
+	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
+
+	if (!intel_hdcp2_check_link(connector))
+		schedule_delayed_work(&hdcp->hdcp2_check_work,
+				      DRM_HDCP2_CHECK_PERIOD_MS);
+}
+
  static int i915_hdcp_component_master_bind(struct device *dev)
  {
  	struct drm_i915_private *dev_priv = kdev_to_i915(dev);
@@ -1762,6 +1837,7 @@ static void intel_hdcp2_init(struct intel_connector *connector)
  		return;
  	}
+	INIT_DELAYED_WORK(&hdcp->hdcp2_check_work, intel_hdcp2_check_work);
  	hdcp->hdcp2_supported = 1;
  }
@@ -1836,8 +1912,12 @@ int intel_hdcp_enable(struct intel_connector *connector)
  	 * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
  	 * is capable of HDCP2.2, it is preferred to use HDCP2.2.
  	 */
-	if (intel_hdcp2_capable(connector))
+	if (intel_hdcp2_capable(connector)) {
  		ret = _intel_hdcp2_enable(connector);
+		if (!ret)
+			schedule_delayed_work(&hdcp->hdcp2_check_work,
+					      DRM_HDCP2_CHECK_PERIOD_MS);
+	}
  	/* When HDCP2.2 fails, HDCP1.4 will be attempted */
  	if (ret && intel_hdcp_capable(connector)) {
@@ -1876,6 +1956,7 @@ int intel_hdcp_disable(struct intel_connector *connector)
  	mutex_unlock(&hdcp->mutex);
  	cancel_delayed_work_sync(&hdcp->check_work);
+	cancel_delayed_work_sync(&hdcp->hdcp2_check_work);
  	return ret;
  }
include/drm/drm_hdcp.h +3 -0
index 3e45a7618ab3..be07a2b56d23 100644
@@ -11,6 +11,14 @@
  /* Period of hdcp checks (to ensure we're still authenticated) */
  #define DRM_HDCP_CHECK_PERIOD_MS		(128 * 16)
+#define DRM_HDCP2_CHECK_PERIOD_MS		500
+
+enum check_link_response {
Quoted 8 lines

include/drm/drm_hdcp.h line 21

Quoted 5 lines
include/drm/drm_hdcp.h +5 -0
+	DRM_HDCP_LINK_PROTECTED	= 0,
+	DRM_HDCP_TOPOLOGY_CHANGE,
+	DRM_HDCP_LINK_INTEGRITY_FAILURE,
+	DRM_HDCP_REAUTH_REQUEST
+};

The drm_hdcp.h changes need to be all split out into sepearate patches I think. Just for highlighting of the new shared bits. Also applies to the previous one.

Quoted 3 lines

Is this specific to drm_hdcp.h? In the previous version i had all header changes in a single patch. But Seanpaul suggested for better understanding of the changes, to introduce the changes at the patches where they are used.

Hm, conflicting review comments :-/

Quoted 1 line

Still should we go back on this?

We need acks for all drm changes when we want to merge them through drm-intel (which I think is the best tree for this series). So it helps to split them out. You can still have them all just split out right before the i915 patch that uses the new functions (instead of one overall drm_hdcp.h patch, which I agree with Sean can be tricky to understand).

Separate patch is more to highlight to non-intel people that we're touching core code here too.
-Daniel

Quoted 13 lines

--Ram

Quoted 10 lines

Otherwise looks all reasonable.
-Daniel

Quoted 5 lines
include/drm/drm_hdcp.h +0 -0
  /* Shared lengths/masks between HDMI/DVI/DisplayPort */
  #define DRM_HDCP_AN_LEN				8
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#38 lore raw

PATCH v8 10/35 drm/i915: Handle HDCP2.2 downstream topology change

In reply to Ramalingam C

When repeater notifies a downstream topology change, this patch reauthenticate the repeater alone without disabling the hdcp encryption. If that fails then complete reauthentication is executed.

v2:
Rebased.
v3:
No Changes.
v4:
Typo in commit msg is fixed [Uma]
v5:
Rebased as part of patch reordering.
Minor style fixes.
v6:
Rebased.
v7:
Rebased.
v8:
Errors due to sinks are reported as DEBUG logs.

---
 drivers/gpu/drm/i915/intel_hdcp.c | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_hdcp.c +18 -2
index 98b112395a5a..df0fb6d9200b 100644
@@ -1662,8 +1662,24 @@ static int intel_hdcp2_check_link(struct intel_connector *connector)
 		goto out;
 	}
 
-	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
-		      connector->base.name, connector->base.base.id);
+	if (ret == DRM_HDCP_TOPOLOGY_CHANGE) {
+		if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+			goto out;
+
+		DRM_DEBUG_KMS("HDCP2.2 Downstream topology change\n");
+		ret = hdcp2_authenticate_repeater_topology(connector);
+		if (!ret) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+			goto out;
+		}
+		DRM_DEBUG_KMS("[%s:%d] Repeater topology auth failed.(%d)\n",
+			      connector->base.name, connector->base.base.id,
+			      ret);
+	} else {
+		DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
+			      connector->base.name, connector->base.base.id);
+	}
 
 	ret = _intel_hdcp2_disable(connector);
 	if (ret) {
Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#39 lore raw

Re: [PATCH v8 10/35] drm/i915: Handle HDCP2.2 downstream topology change

Quoted 20 lines · Ramalingam C

When repeater notifies a downstream topology change, this patch reauthenticate the repeater alone without disabling the hdcp encryption. If that fails then complete reauthentication is executed.

v2:
Rebased.
v3:
No Changes.
v4:
Typo in commit msg is fixed [Uma]
v5:
Rebased as part of patch reordering.
Minor style fixes.
v6:
Rebased.
v7:
Rebased.
v8:
Errors due to sinks are reported as DEBUG logs.

Quoted 2 lines

Trusting Uma's hdcp knowledge here.
-Daniel

Quoted 38 lines
---
 drivers/gpu/drm/i915/intel_hdcp.c | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_hdcp.c +18 -2
index 98b112395a5a..df0fb6d9200b 100644
@@ -1662,8 +1662,24 @@ static int intel_hdcp2_check_link(struct intel_connector *connector)
 		goto out;
 	}
 
-	DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
-		      connector->base.name, connector->base.base.id);
+	if (ret == DRM_HDCP_TOPOLOGY_CHANGE) {
+		if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
+			goto out;
+
+		DRM_DEBUG_KMS("HDCP2.2 Downstream topology change\n");
+		ret = hdcp2_authenticate_repeater_topology(connector);
+		if (!ret) {
+			hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
+			schedule_work(&hdcp->prop_work);
+			goto out;
+		}
+		DRM_DEBUG_KMS("[%s:%d] Repeater topology auth failed.(%d)\n",
+			      connector->base.name, connector->base.base.id,
+			      ret);
+	} else {
+		DRM_DEBUG_KMS("[%s:%d] HDCP2.2 link failed, retrying auth\n",
+			      connector->base.name, connector->base.base.id);
+	}
 
 	ret = _intel_hdcp2_disable(connector);
 	if (ret) {
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#40 lore raw

PATCH v8 11/35 drm/i915: Check HDCP 1.4 and 2.2 link on CP_IRQ

In reply to Ramalingam C

On DP HDCP1.4 and 2.2, when CP_IRQ is received, start the link integrity check for the HDCP version that is enabled.

v2:
Rebased. Function name is changed.
v3:
No Changes.
v4:
No Changes.
v5:
No Changes.
v6:
%s/_in_force/_in_use [Sean Paul]
v7:
Rebased.
v8:
Rebased.

---
 drivers/gpu/drm/i915/intel_dp.c   |  2 +-
 drivers/gpu/drm/i915/intel_drv.h  |  2 +-
 drivers/gpu/drm/i915/intel_hdcp.c | 29 +++++++++++++++++++++++++++++
 3 files changed, 31 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_dp.c +1 -1
index ac62af073688..ecc4706db7dc 100644
@@ -4532,7 +4532,7 @@ static void intel_dp_check_service_irq(struct intel_dp *intel_dp)
 		intel_dp_handle_test_request(intel_dp);
 
 	if (val & DP_CP_IRQ)
-		intel_hdcp_check_link(intel_dp->attached_connector);
+		intel_hdcp_handle_cp_irq(intel_dp->attached_connector);
 
 	if (val & DP_SINK_SPECIFIC_IRQ)
 		DRM_DEBUG_DRIVER("Sink specific irq unhandled\n");
drivers/gpu/drm/i915/intel_drv.h +1 -1
index e6e32bf52568..d5ab1ff9cc69 100644
@@ -2082,11 +2082,11 @@ int intel_hdcp_init(struct intel_connector *connector,
 		    bool hdcp2_supported);
 int intel_hdcp_enable(struct intel_connector *connector);
 int intel_hdcp_disable(struct intel_connector *connector);
-int intel_hdcp_check_link(struct intel_connector *connector);
 bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port);
 bool intel_hdcp_capable(struct intel_connector *connector);
 bool is_hdcp2_supported(struct drm_i915_private *dev_priv);
 void intel_hdcp_exit(struct drm_i915_private *dev_priv);
+void intel_hdcp_handle_cp_irq(struct intel_connector *connector);
 
 /* intel_psr.c */
 #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) && dev_priv->psr.sink_support)
drivers/gpu/drm/i915/intel_hdcp.c +29 -0
index df0fb6d9200b..b9e5f73c640d 100644
@@ -117,6 +117,26 @@ static bool intel_hdcp2_capable(struct intel_connector *connector)
 	return capable;
 }
 
+static inline bool intel_hdcp_in_use(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	enum port port = connector->encoder->port;
+	u32 reg;
+
+	reg = I915_READ(PORT_HDCP_STATUS(port));
+	return reg & (HDCP_STATUS_AUTH | HDCP_STATUS_ENC);
+}
+
+static inline bool intel_hdcp2_in_use(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	enum port port = connector->encoder->port;
+	u32 reg;
+
+	reg = I915_READ(HDCP2_STATUS_DDI(port));
+	return reg & (LINK_ENCRYPTION_STATUS | LINK_AUTH_STATUS);
+}
+
 static int intel_hdcp_poll_ksv_fifo(struct intel_digital_port *intel_dig_port,
 				    const struct intel_hdcp_shim *shim)
 {
@@ -2008,3 +2028,12 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
 						   new_state->crtc);
 	crtc_state->mode_changed = true;
 }
+
+/* Handles the CP_IRQ raised from the DP HDCP sink */
+void intel_hdcp_handle_cp_irq(struct intel_connector *connector)
+{
+	if (intel_hdcp_in_use(connector))
+		intel_hdcp_check_link(connector);
+	else if (intel_hdcp2_in_use(connector))
+		intel_hdcp2_check_link(connector);
+}
Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#41 lore raw

Re: [PATCH v8 11/35] drm/i915: Check HDCP 1.4 and 2.2 link on CP_IRQ

Quoted 45 lines · Ramalingam C

On DP HDCP1.4 and 2.2, when CP_IRQ is received, start the link integrity check for the HDCP version that is enabled.

v2:
Rebased. Function name is changed.
v3:
No Changes.
v4:
No Changes.
v5:
No Changes.
v6:
%s/_in_force/_in_use [Sean Paul]
v7:
Rebased.
v8:
Rebased.

---
 drivers/gpu/drm/i915/intel_dp.c   |  2 +-
 drivers/gpu/drm/i915/intel_drv.h  |  2 +-
 drivers/gpu/drm/i915/intel_hdcp.c | 29 +++++++++++++++++++++++++++++
 3 files changed, 31 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_dp.c +1 -1
index ac62af073688..ecc4706db7dc 100644
@@ -4532,7 +4532,7 @@ static void intel_dp_check_service_irq(struct intel_dp *intel_dp)
 		intel_dp_handle_test_request(intel_dp);
 
 	if (val & DP_CP_IRQ)
-		intel_hdcp_check_link(intel_dp->attached_connector);
+		intel_hdcp_handle_cp_irq(intel_dp->attached_connector);
 
 	if (val & DP_SINK_SPECIFIC_IRQ)
 		DRM_DEBUG_DRIVER("Sink specific irq unhandled\n");
drivers/gpu/drm/i915/intel_drv.h +0 -0
index e6e32bf52568..d5ab1ff9cc69 100644

drivers/gpu/drm/i915/intel_drv.h int intel_hdcp_init(struct intel_connector *connector, · line 2089

Quoted 9 lines
drivers/gpu/drm/i915/intel_drv.h +1 -1
@@ -2082,11 +2082,11 @@ int intel_hdcp_init(struct intel_connector *connector,
 		    bool hdcp2_supported);
 int intel_hdcp_enable(struct intel_connector *connector);
 int intel_hdcp_disable(struct intel_connector *connector);
-int intel_hdcp_check_link(struct intel_connector *connector);
 bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port);
 bool intel_hdcp_capable(struct intel_connector *connector);
 bool is_hdcp2_supported(struct drm_i915_private *dev_priv);
 void intel_hdcp_exit(struct drm_i915_private *dev_priv);
+void intel_hdcp_handle_cp_irq(struct intel_connector *connector);

Renaming doesn't seem to gain us anything, pls drop.

Quoted 35 lines
drivers/gpu/drm/i915/intel_drv.h +0 -0
 /* intel_psr.c */
 #define CAN_PSR(dev_priv) (HAS_PSR(dev_priv) && dev_priv->psr.sink_support)
drivers/gpu/drm/i915/intel_hdcp.c +20 -0
index df0fb6d9200b..b9e5f73c640d 100644
@@ -117,6 +117,26 @@ static bool intel_hdcp2_capable(struct intel_connector *connector)
 	return capable;
 }
 
+static inline bool intel_hdcp_in_use(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	enum port port = connector->encoder->port;
+	u32 reg;
+
+	reg = I915_READ(PORT_HDCP_STATUS(port));
+	return reg & (HDCP_STATUS_AUTH | HDCP_STATUS_ENC);
+}
+
+static inline bool intel_hdcp2_in_use(struct intel_connector *connector)
+{
+	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+	enum port port = connector->encoder->port;
+	u32 reg;
+
+	reg = I915_READ(HDCP2_STATUS_DDI(port));
+	return reg & (LINK_ENCRYPTION_STATUS | LINK_AUTH_STATUS);
+}
+
 static int intel_hdcp_poll_ksv_fifo(struct intel_digital_port *intel_dig_port,
 				    const struct intel_hdcp_shim *shim)
 {

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_atomic_check(struct drm_connector *connector, · line 2035

Quoted 8 lines
drivers/gpu/drm/i915/intel_hdcp.c +5 -0
@@ -2008,3 +2028,12 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
 						   new_state->crtc);
 	crtc_state->mode_changed = true;
 }
+
+/* Handles the CP_IRQ raised from the DP HDCP sink */
+void intel_hdcp_handle_cp_irq(struct intel_connector *connector)
+{
+	if (intel_hdcp_in_use(connector))

Reading registers to figure out what we're doing is bad style. I think reading register to double-check that our sw-side tracking is correct is good, so maybe put these checks into hdcp1/2_check_link in a WARN_ON. But here we should take the hdcp mutex and look at the sw state.

This will naturally fall out of the check_link worker merging in the earlier patch I think.
-Daniel

Quoted 7 lines
drivers/gpu/drm/i915/intel_hdcp.c +4 -0
+		intel_hdcp_check_link(connector);
+	else if (intel_hdcp2_in_use(connector))
+		intel_hdcp2_check_link(connector);
+}
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#42 lore raw

PATCH v8 12/35 drm/i915: Implement the HDCP2.2 support for DP

In reply to Ramalingam C

Implements the DP adaptation specific HDCP2.2 functions.

These functions perform the DPCD read and write for communicating the HDCP2.2 auth message back and forth.

v2:
wait for cp_irq is merged with this patch. Rebased.
v3:
wait_queue is used for wait for cp_irq [Chris Wilson]
v4:
Style fixed.
%s/PARING/PAIRING
Few style fixes [Uma]
v5:
Lookup table for DP HDCP2.2 msg details [Daniel]. Extra lines are removed.
v6:
Rebased.
v7:
Fixed some regression introduced at v5. [Ankit] Macro HDCP_2_2_RX_CAPS_VERSION_VAL is reused [Uma] Converted a function to inline [Uma] %s/uintxx_t/uxx
v8:
Error due to the sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
 drivers/gpu/drm/i915/intel_dp.c   | 338 ++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_drv.h  |   7 +
 drivers/gpu/drm/i915/intel_hdcp.c |   6 +
 3 files changed, 351 insertions(+)
drivers/gpu/drm/i915/intel_dp.c +338 -0
index ecc4706db7dc..1cc82e490999 100644
@@ -31,6 +31,7 @@
 #include <linux/types.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
+#include <linux/mei_hdcp.h>
 #include <asm/byteorder.h>
 #include <drm/drmP.h>
 #include <drm/drm_atomic_helper.h>
@@ -5347,6 +5348,27 @@ void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
 	pps_unlock(intel_dp);
 }
 
+static int intel_dp_hdcp_wait_for_cp_irq(struct intel_hdcp *hdcp,
+					 int timeout)
+{
+	long ret;
+
+	/* Reinit */
+	atomic_set(&hdcp->cp_irq_recved, 0);
+
+#define C (atomic_read(&hdcp->cp_irq_recved) > 0)
+	ret = wait_event_interruptible_timeout(hdcp->cp_irq_queue, C,
+					       msecs_to_jiffies(timeout));
+
+	if (ret > 0) {
+		atomic_set(&hdcp->cp_irq_recved, 0);
+		return 0;
+	} else if (!ret) {
+		return -ETIMEDOUT;
+	}
+	return (int)ret;
+}
+
 static
 int intel_dp_hdcp_write_an_aksv(struct intel_digital_port *intel_dig_port,
 				u8 *an)
@@ -5570,6 +5592,316 @@ int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port,
 	return 0;
 }
 
+static struct hdcp2_dp_msg_data {
+	u8 msg_id;
+	u32 offset;
+	bool msg_detectable;
+	u32 timeout;
+	u32 timeout2; /* Added for non_paired situation */
+	} hdcp2_msg_data[] = {
+		{HDCP_2_2_AKE_INIT, DP_HDCP_2_2_AKE_INIT_OFFSET, false, 0, 0},
+		{HDCP_2_2_AKE_SEND_CERT, DP_HDCP_2_2_AKE_SEND_CERT_OFFSET,
+				false, HDCP_2_2_CERT_TIMEOUT_MS, 0},
+		{HDCP_2_2_AKE_NO_STORED_KM, DP_HDCP_2_2_AKE_NO_STORED_KM_OFFSET,
+				false, 0, 0},
+		{HDCP_2_2_AKE_STORED_KM, DP_HDCP_2_2_AKE_STORED_KM_OFFSET,
+				false, 0, 0},
+		{HDCP_2_2_AKE_SEND_HPRIME, DP_HDCP_2_2_AKE_SEND_HPRIME_OFFSET,
+				true, HDCP_2_2_HPRIME_PAIRED_TIMEOUT_MS,
+				HDCP_2_2_HPRIME_NO_PAIRED_TIMEOUT_MS},
+		{HDCP_2_2_AKE_SEND_PAIRING_INFO,
+				DP_HDCP_2_2_AKE_SEND_PAIRING_INFO_OFFSET, true,
+				HDCP_2_2_PAIRING_TIMEOUT_MS, 0},
+		{HDCP_2_2_LC_INIT, DP_HDCP_2_2_LC_INIT_OFFSET, false, 0, 0},
+		{HDCP_2_2_LC_SEND_LPRIME, DP_HDCP_2_2_LC_SEND_LPRIME_OFFSET,
+				false, HDCP_2_2_DP_LPRIME_TIMEOUT_MS, 0},
+		{HDCP_2_2_SKE_SEND_EKS, DP_HDCP_2_2_SKE_SEND_EKS_OFFSET, false,
+				0, 0},
+		{HDCP_2_2_REP_SEND_RECVID_LIST,
+				DP_HDCP_2_2_REP_SEND_RECVID_LIST_OFFSET, true,
+				HDCP_2_2_RECVID_LIST_TIMEOUT_MS, 0},
+		{HDCP_2_2_REP_SEND_ACK, DP_HDCP_2_2_REP_SEND_ACK_OFFSET, false,
+				0, 0},
+		{HDCP_2_2_REP_STREAM_MANAGE,
+				DP_HDCP_2_2_REP_STREAM_MANAGE_OFFSET, false,
+				0, 0},
+		{HDCP_2_2_REP_STREAM_READY, DP_HDCP_2_2_REP_STREAM_READY_OFFSET,
+				false, HDCP_2_2_STREAM_READY_TIMEOUT_MS, 0},
+		{HDCP_2_2_ERRATA_DP_STREAM_TYPE,
+				DP_HDCP_2_2_REG_STREAM_TYPE_OFFSET, false,
+				0, 0},
+		};
+
+static inline
+int intel_dp_hdcp2_read_rx_status(struct intel_digital_port *intel_dig_port,
+				  u8 *rx_status)
+{
+	ssize_t ret;
+
+	ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+			       DP_HDCP_2_2_REG_RXSTATUS_OFFSET, rx_status,
+			       HDCP_2_2_DP_RXSTATUS_LEN);
+	if (ret != HDCP_2_2_DP_RXSTATUS_LEN) {
+		DRM_DEBUG_KMS("Read bstatus from DP/AUX failed (%zd)\n", ret);
+		return ret >= 0 ? -EIO : ret;
+	}
+
+	return 0;
+}
+
+static
+int hdcp2_detect_msg_availability(struct intel_digital_port *intel_dig_port,
+				  u8 msg_id, bool *msg_ready)
+{
+	u8 rx_status;
+	int ret;
+
+	*msg_ready = false;
+	ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+	if (ret < 0)
+		return ret;
+
+	switch (msg_id) {
+	case HDCP_2_2_AKE_SEND_HPRIME:
+		if (HDCP_2_2_DP_RXSTATUS_H_PRIME(rx_status))
+			*msg_ready = true;
+		break;
+	case HDCP_2_2_AKE_SEND_PAIRING_INFO:
+		if (HDCP_2_2_DP_RXSTATUS_PAIRING(rx_status))
+			*msg_ready = true;
+		break;
+	case HDCP_2_2_REP_SEND_RECVID_LIST:
+		if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+			*msg_ready = true;
+		break;
+	default:
+		DRM_ERROR("Unidentified msg_id: %d\n", msg_id);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static ssize_t
+intel_dp_hdcp2_wait_for_msg(struct intel_digital_port *intel_dig_port,
+			    struct hdcp2_dp_msg_data *hdcp2_msg_data)
+{
+	struct intel_dp *dp = &intel_dig_port->dp;
+	struct intel_hdcp *hdcp = &dp->attached_connector->hdcp;
+	int ret, timeout;
+	bool msg_ready = false;
+
+	if (hdcp2_msg_data->msg_id == HDCP_2_2_AKE_SEND_HPRIME &&
+	    !hdcp->is_paired)
+		timeout = hdcp2_msg_data->timeout2;
+	else
+		timeout = hdcp2_msg_data->timeout;
+
+	/*
+	 * There is no way to detect the CERT, LPRIME and STREAM_READY
+	 * availability. So Wait for timeout and read the msg.
+	 */
+	if (!hdcp2_msg_data->msg_detectable) {
+		mdelay(timeout);
+		ret = 0;
+	} else {
+		/*
+		 * Ignoring the return of the intel_dp_hdcp_wait_for_cp_irq,
+		 * Just to detect the msg availability before failing it.
+		 */
+		intel_dp_hdcp_wait_for_cp_irq(hdcp, timeout);
+		ret = hdcp2_detect_msg_availability(intel_dig_port,
+						    hdcp2_msg_data->msg_id,
+						    &msg_ready);
+		if (!msg_ready)
+			ret = -ETIMEDOUT;
+	}
+
+	if (ret)
+		DRM_DEBUG_KMS("msg_id %d, ret %d, timeout(mSec): %d\n",
+			      hdcp2_msg_data->msg_id, ret, timeout);
+
+	return ret;
+}
+
+static struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id)
+{
+	int i;
+
+	for (i = 0; i < sizeof(hdcp2_msg_data); i++)
+		if (hdcp2_msg_data[i].msg_id == msg_id)
+			return &hdcp2_msg_data[i];
+
+	return NULL;
+}
+
+static
+int intel_dp_hdcp2_write_msg(struct intel_digital_port *intel_dig_port,
+			     void *buf, size_t size)
+{
+	unsigned int offset;
+	u8 *byte = buf;
+	ssize_t ret, bytes_to_write, len;
+	struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+	hdcp2_msg_data = get_hdcp2_dp_msg_data(*byte);
+	if (!hdcp2_msg_data)
+		return -EINVAL;
+
+	offset = hdcp2_msg_data->offset;
+
+	/* No msg_id in DP HDCP2.2 msgs */
+	bytes_to_write = size - 1;
+	byte++;
+
+	while (bytes_to_write) {
+		len = bytes_to_write > DP_AUX_MAX_PAYLOAD_BYTES ?
+				DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_write;
+
+		ret = drm_dp_dpcd_write(&intel_dig_port->dp.aux,
+					offset, (void *)byte, len);
+		if (ret < 0)
+			return ret;
+
+		bytes_to_write -= ret;
+		byte += ret;
+		offset += ret;
+	}
+
+	return size;
+}
+
+static
+ssize_t get_receiver_id_list_size(struct intel_digital_port *intel_dig_port)
+{
+	u8 rx_info[HDCP_2_2_RXINFO_LEN];
+	u32 dev_cnt;
+	ssize_t ret;
+
+	ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+			       DP_HDCP_2_2_REG_RXINFO_OFFSET,
+			       (void *)rx_info, HDCP_2_2_RXINFO_LEN);
+	if (ret != HDCP_2_2_RXINFO_LEN)
+		return ret >= 0 ? -EIO : ret;
+
+	dev_cnt = (HDCP_2_2_DEV_COUNT_HI(rx_info[0]) << 4 |
+		   HDCP_2_2_DEV_COUNT_LO(rx_info[1]));
+
+	if (dev_cnt > HDCP_2_2_MAX_DEVICE_COUNT)
+		dev_cnt = HDCP_2_2_MAX_DEVICE_COUNT;
+
+	ret = sizeof(struct hdcp2_rep_send_receiverid_list) -
+		HDCP_2_2_RECEIVER_IDS_MAX_LEN +
+		(dev_cnt * HDCP_2_2_RECEIVER_ID_LEN);
+
+	return ret;
+}
+
+static
+int intel_dp_hdcp2_read_msg(struct intel_digital_port *intel_dig_port,
+			    u8 msg_id, void *buf, size_t size)
+{
+	unsigned int offset;
+	u8 *byte = buf;
+	ssize_t ret, bytes_to_recv, len;
+	struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+	hdcp2_msg_data = get_hdcp2_dp_msg_data(msg_id);
+	if (!hdcp2_msg_data)
+		return -EINVAL;
+	offset = hdcp2_msg_data->offset;
+
+	ret = intel_dp_hdcp2_wait_for_msg(intel_dig_port, hdcp2_msg_data);
+	if (ret < 0)
+		return ret;
+
+	if (msg_id == HDCP_2_2_REP_SEND_RECVID_LIST) {
+		ret = get_receiver_id_list_size(intel_dig_port);
+		if (ret < 0)
+			return ret;
+
+		size = ret;
+	}
+	bytes_to_recv = size - 1;
+
+	/* DP adaptation msgs has no msg_id */
+	byte++;
+
+	while (bytes_to_recv) {
+		len = bytes_to_recv > DP_AUX_MAX_PAYLOAD_BYTES ?
+		      DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_recv;
+
+		ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux, offset,
+				       (void *)byte, len);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("msg_id %d, ret %zd\n", msg_id, ret);
+			return ret;
+		}
+
+		bytes_to_recv -= ret;
+		byte += ret;
+		offset += ret;
+	}
+	byte = buf;
+	*byte = msg_id;
+
+	return size;
+}
+
+static
+int intel_dp_hdcp2_config_stream_type(struct intel_digital_port *intel_dig_port,
+				      void *buf, size_t size)
+{
+	return intel_dp_hdcp2_write_msg(intel_dig_port, buf, size);
+}
+
+static
+int intel_dp_hdcp2_check_link(struct intel_digital_port *intel_dig_port)
+{
+	u8 rx_status;
+	int ret;
+
+	ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+	if (ret)
+		return ret;
+
+	if (HDCP_2_2_DP_RXSTATUS_REAUTH_REQ(rx_status))
+		ret = DRM_HDCP_REAUTH_REQUEST;
+	else if (HDCP_2_2_DP_RXSTATUS_LINK_FAILED(rx_status))
+		ret = DRM_HDCP_LINK_INTEGRITY_FAILURE;
+	else if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+		ret = DRM_HDCP_TOPOLOGY_CHANGE;
+
+	return ret;
+}
+
+static
+int intel_dp_hdcp2_capable(struct intel_digital_port *intel_dig_port,
+			   bool *capable)
+{
+	u8 rx_caps[3];
+	int ret;
+
+	*capable = false;
+	ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+			       DP_HDCP_2_2_REG_RX_CAPS_OFFSET,
+			       rx_caps, HDCP_2_2_RXCAPS_LEN);
+	if (ret != HDCP_2_2_RXCAPS_LEN)
+		return ret >= 0 ? -EIO : ret;
+
+	if (rx_caps[0] == HDCP_2_2_RX_CAPS_VERSION_VAL &&
+	    HDCP_2_2_DP_HDCP_CAPABLE(rx_caps[2]))
+		*capable = true;
+
+	return 0;
+}
+
+static inline
+enum mei_hdcp_wired_protocol intel_dp_hdcp2_protocol(void)
+{
+	return MEI_HDCP_PROTOCOL_DP;
+}
+
 static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
 	.write_an_aksv = intel_dp_hdcp_write_an_aksv,
 	.read_bksv = intel_dp_hdcp_read_bksv,
@@ -5582,6 +5914,12 @@ static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
 	.toggle_signalling = intel_dp_hdcp_toggle_signalling,
 	.check_link = intel_dp_hdcp_check_link,
 	.hdcp_capable = intel_dp_hdcp_capable,
+	.write_2_2_msg = intel_dp_hdcp2_write_msg,
+	.read_2_2_msg = intel_dp_hdcp2_read_msg,
+	.config_stream_type = intel_dp_hdcp2_config_stream_type,
+	.check_2_2_link = intel_dp_hdcp2_check_link,
+	.hdcp_2_2_capable = intel_dp_hdcp2_capable,
+	.hdcp_protocol = intel_dp_hdcp2_protocol,
 };
 
 static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
drivers/gpu/drm/i915/intel_drv.h +7 -0
index d5ab1ff9cc69..2b7181b76475 100644
@@ -450,6 +450,13 @@ struct intel_hdcp {
 	u32 seq_num_m;
 
 	struct delayed_work hdcp2_check_work;
+
+	/*
+	 * Work queue to signal the CP_IRQ. Used for the waiters to read the
+	 * available information from HDCP DP sink.
+	 */
+	wait_queue_head_t cp_irq_queue;
+	atomic_t cp_irq_recved;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +6 -0
index b9e5f73c640d..be475914c3cd 100644
@@ -1899,6 +1899,9 @@ int intel_hdcp_init(struct intel_connector *connector,
 	if (hdcp2_supported)
 		intel_hdcp2_init(connector);
 
+	atomic_set(&hdcp->cp_irq_recved, 0);
+	init_waitqueue_head(&hdcp->cp_irq_queue);
+
 	return 0;
 }
 
@@ -2036,4 +2039,7 @@ void intel_hdcp_handle_cp_irq(struct intel_connector *connector)
 		intel_hdcp_check_link(connector);
 	else if (intel_hdcp2_in_use(connector))
 		intel_hdcp2_check_link(connector);
+
+	atomic_set(&connector->hdcp.cp_irq_recved, 1);
+	wake_up_all(&connector->hdcp.cp_irq_queue);
 }
Signature · 6 lines
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#43 lore raw

Re: [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

I'm not formally reviewing this series, but while glancing at it, I noticed....

Quoted 64 lines

-----Original Message-----
From: Intel-gfx <[email protected]> On Behalf Of Ramalingam C
Sent: Tuesday, November 27, 2018 2:43 AM
To: [email protected]; [email protected]; [email protected]; Winkler, Tomas <[email protected]>
Subject: [Intel-gfx] [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

Implements the DP adaptation specific HDCP2.2 functions.

These functions perform the DPCD read and write for communicating the HDCP2.2 auth message back and forth.

v2:
wait for cp_irq is merged with this patch. Rebased.
v3:
wait_queue is used for wait for cp_irq [Chris Wilson]
v4:
Style fixed.
%s/PARING/PAIRING
Few style fixes [Uma]
v5:
Lookup table for DP HDCP2.2 msg details [Daniel]. Extra lines are removed.
v6:
Rebased.
v7:
Fixed some regression introduced at v5. [Ankit] Macro HDCP_2_2_RX_CAPS_VERSION_VAL is reused [Uma] Converted a function to inline [Uma] %s/uintxx_t/uxx
v8:
Error due to the sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
 drivers/gpu/drm/i915/intel_dp.c   | 338
++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_drv.h  |   7 +
 drivers/gpu/drm/i915/intel_hdcp.c |   6 +
 3 files changed, 351 insertions(+)
drivers/gpu/drm/i915/intel_dp.c +1 -0
index ecc4706db7dc..1cc82e490999 100644
@@ -31,6 +31,7 @@
 #include <linux/types.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
+#include <linux/mei_hdcp.h>
 #include <asm/byteorder.h>
 #include <drm/drmP.h>
 #include <drm/drm_atomic_helper.h>
@@ -5347,6 +5348,27 @@ void intel_dp_encoder_suspend(struct
 intel_encoder *intel_encoder)
 	pps_unlock(intel_dp);
 }
 

<SNIP>

drivers/gpu/drm/i915/intel_dp.c int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port, · line 5731

Quoted 6 lines
drivers/gpu/drm/i915/intel_dp.c +6 -0
+
+static struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id)
+{
+	int i;
+
+	for (i = 0; i < sizeof(hdcp2_msg_data); i++)

Should be
sizeof(hdcp2_msg_data) / sizeof(*hdcp2_msg_data)
or equivalent.

Has the failure return been tested?

Quoted 6 lines
drivers/gpu/drm/i915/intel_dp.c +6 -0
+		if (hdcp2_msg_data[i].msg_id == msg_id)
+			return &hdcp2_msg_data[i];
+
+	return NULL;
+}
+

<SNIP>

Quoted 7 lines

--
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#44 lore raw

Re: [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

Quoted 67 lines · Jon

I'm not formally reviewing this series, but while glancing at it, I noticed....

Quoted 64 lines

-----Original Message-----
From: Intel-gfx <[email protected]> On Behalf Of Ramalingam C
Sent: Tuesday, November 27, 2018 2:43 AM
To: [email protected]; [email protected]; [email protected]; Winkler, Tomas <[email protected]>
Subject: [Intel-gfx] [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

Implements the DP adaptation specific HDCP2.2 functions.

These functions perform the DPCD read and write for communicating the HDCP2.2 auth message back and forth.

v2:
wait for cp_irq is merged with this patch. Rebased.
v3:
wait_queue is used for wait for cp_irq [Chris Wilson]
v4:
Style fixed.
%s/PARING/PAIRING
Few style fixes [Uma]
v5:
Lookup table for DP HDCP2.2 msg details [Daniel]. Extra lines are removed.
v6:
Rebased.
v7:
Fixed some regression introduced at v5. [Ankit] Macro HDCP_2_2_RX_CAPS_VERSION_VAL is reused [Uma] Converted a function to inline [Uma] %s/uintxx_t/uxx
v8:
Error due to the sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
 drivers/gpu/drm/i915/intel_dp.c   | 338
++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_drv.h  |   7 +
 drivers/gpu/drm/i915/intel_hdcp.c |   6 +
 3 files changed, 351 insertions(+)
drivers/gpu/drm/i915/intel_dp.c +1 -0
index ecc4706db7dc..1cc82e490999 100644
@@ -31,6 +31,7 @@
 #include <linux/types.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
+#include <linux/mei_hdcp.h>
 #include <asm/byteorder.h>
 #include <drm/drmP.h>
 #include <drm/drm_atomic_helper.h>
@@ -5347,6 +5348,27 @@ void intel_dp_encoder_suspend(struct
 intel_encoder *intel_encoder)
 	pps_unlock(intel_dp);
 }
 

<SNIP>

Quoted 10 lines

drivers/gpu/drm/i915/intel_dp.c int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port, · line 5731

Quoted 6 lines
drivers/gpu/drm/i915/intel_dp.c +6 -0
+
+static struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id)
+{
+	int i;
+
+	for (i = 0; i < sizeof(hdcp2_msg_data); i++)

Should be
sizeof(hdcp2_msg_data) / sizeof(*hdcp2_msg_data)
or equivalent.

ARRAY_SIZE is probably what you want here.
-Daniel

Quoted 17 lines

Has the failure return been tested?

Quoted 6 lines
drivers/gpu/drm/i915/intel_dp.c +6 -0
+		if (hdcp2_msg_data[i].msg_id == msg_id)
+			return &hdcp2_msg_data[i];
+
+	return NULL;
+}
+

<SNIP>

Quoted 7 lines

--
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#45 lore raw

Re: [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

Quoted 77 lines · Daniel Vetter
Quoted 67 lines · Jon

I'm not formally reviewing this series, but while glancing at it, I noticed....

Quoted 64 lines

-----Original Message-----
From: Intel-gfx <[email protected]> On Behalf Of Ramalingam C
Sent: Tuesday, November 27, 2018 2:43 AM
To: [email protected]; [email protected]; [email protected]; Winkler, Tomas <[email protected]>
Subject: [Intel-gfx] [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

Implements the DP adaptation specific HDCP2.2 functions.

These functions perform the DPCD read and write for communicating the HDCP2.2 auth message back and forth.

v2:
wait for cp_irq is merged with this patch. Rebased.
v3:
wait_queue is used for wait for cp_irq [Chris Wilson]
v4:
Style fixed.
%s/PARING/PAIRING
Few style fixes [Uma]
v5:
Lookup table for DP HDCP2.2 msg details [Daniel]. Extra lines are removed.
v6:
Rebased.
v7:
Fixed some regression introduced at v5. [Ankit] Macro HDCP_2_2_RX_CAPS_VERSION_VAL is reused [Uma] Converted a function to inline [Uma] %s/uintxx_t/uxx
v8:
Error due to the sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
  drivers/gpu/drm/i915/intel_dp.c   | 338
++++++++++++++++++++++++++++++++++++++
  drivers/gpu/drm/i915/intel_drv.h  |   7 +
  drivers/gpu/drm/i915/intel_hdcp.c |   6 +
  3 files changed, 351 insertions(+)
drivers/gpu/drm/i915/intel_dp.c +1 -0
index ecc4706db7dc..1cc82e490999 100644
@@ -31,6 +31,7 @@
  #include <linux/types.h>
  #include <linux/notifier.h>
  #include <linux/reboot.h>
+#include <linux/mei_hdcp.h>
  #include <asm/byteorder.h>
  #include <drm/drmP.h>
  #include <drm/drm_atomic_helper.h>
@@ -5347,6 +5348,27 @@ void intel_dp_encoder_suspend(struct
 intel_encoder *intel_encoder)
  	pps_unlock(intel_dp);
  }
 

<SNIP>

Quoted 9 lines

drivers/gpu/drm/i915/intel_dp.c int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port, · line 5731

Quoted 6 lines
drivers/gpu/drm/i915/intel_dp.c +6 -0
+
+static struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id)
+{
+	int i;
+
+	for (i = 0; i < sizeof(hdcp2_msg_data); i++)

Should be
sizeof(hdcp2_msg_data) / sizeof(*hdcp2_msg_data)
or equivalent.

Quoted 1 line

ARRAY_SIZE is probably what you want here.

yes. missed it as authentication flow always provides the valid msg_id. Will fix it.

--Ram

Quoted 18 lines

-Daniel

Quoted 16 lines

Has the failure return been tested?

Quoted 6 lines
drivers/gpu/drm/i915/intel_dp.c +6 -0
+		if (hdcp2_msg_data[i].msg_id == msg_id)
+			return &hdcp2_msg_data[i];
+
+	return NULL;
+}
+

<SNIP>

Quoted 7 lines

--
2.7.4

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#46 lore raw

Re: [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

In reply to Ramalingam C

Hi,

Just a drive-by comment, but did you check that this fails gracefully on platforms which don't enable the ME? For example Chrome OS :)

Stéphane

Quoted 450 lines · Ramalingam C

Implements the DP adaptation specific HDCP2.2 functions.

These functions perform the DPCD read and write for communicating the HDCP2.2 auth message back and forth.

v2:
wait for cp_irq is merged with this patch. Rebased.
v3:
wait_queue is used for wait for cp_irq [Chris Wilson]
v4:
Style fixed.
%s/PARING/PAIRING
Few style fixes [Uma]
v5:
Lookup table for DP HDCP2.2 msg details [Daniel]. Extra lines are removed.
v6:
Rebased.
v7:
Fixed some regression introduced at v5. [Ankit] Macro HDCP_2_2_RX_CAPS_VERSION_VAL is reused [Uma] Converted a function to inline [Uma] %s/uintxx_t/uxx
v8:
Error due to the sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
 drivers/gpu/drm/i915/intel_dp.c   | 338 ++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_drv.h  |   7 +
 drivers/gpu/drm/i915/intel_hdcp.c |   6 +
 3 files changed, 351 insertions(+)
drivers/gpu/drm/i915/intel_dp.c +338 -0
index ecc4706db7dc..1cc82e490999 100644
@@ -31,6 +31,7 @@
 #include <linux/types.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
+#include <linux/mei_hdcp.h>
 #include <asm/byteorder.h>
 #include <drm/drmP.h>
 #include <drm/drm_atomic_helper.h>
@@ -5347,6 +5348,27 @@ void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
        pps_unlock(intel_dp);
 }
 
+static int intel_dp_hdcp_wait_for_cp_irq(struct intel_hdcp *hdcp,
+                                        int timeout)
+{
+       long ret;
+
+       /* Reinit */
+       atomic_set(&hdcp->cp_irq_recved, 0);
+
+#define C (atomic_read(&hdcp->cp_irq_recved) > 0)
+       ret = wait_event_interruptible_timeout(hdcp->cp_irq_queue, C,
+                                              msecs_to_jiffies(timeout));
+
+       if (ret > 0) {
+               atomic_set(&hdcp->cp_irq_recved, 0);
+               return 0;
+       } else if (!ret) {
+               return -ETIMEDOUT;
+       }
+       return (int)ret;
+}
+
 static
 int intel_dp_hdcp_write_an_aksv(struct intel_digital_port *intel_dig_port,
                                u8 *an)
@@ -5570,6 +5592,316 @@ int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port,
        return 0;
 }
 
+static struct hdcp2_dp_msg_data {
+       u8 msg_id;
+       u32 offset;
+       bool msg_detectable;
+       u32 timeout;
+       u32 timeout2; /* Added for non_paired situation */
+       } hdcp2_msg_data[] = {
+               {HDCP_2_2_AKE_INIT, DP_HDCP_2_2_AKE_INIT_OFFSET, false, 0, 0},
+               {HDCP_2_2_AKE_SEND_CERT, DP_HDCP_2_2_AKE_SEND_CERT_OFFSET,
+                               false, HDCP_2_2_CERT_TIMEOUT_MS, 0},
+               {HDCP_2_2_AKE_NO_STORED_KM, DP_HDCP_2_2_AKE_NO_STORED_KM_OFFSET,
+                               false, 0, 0},
+               {HDCP_2_2_AKE_STORED_KM, DP_HDCP_2_2_AKE_STORED_KM_OFFSET,
+                               false, 0, 0},
+               {HDCP_2_2_AKE_SEND_HPRIME, DP_HDCP_2_2_AKE_SEND_HPRIME_OFFSET,
+                               true, HDCP_2_2_HPRIME_PAIRED_TIMEOUT_MS,
+                               HDCP_2_2_HPRIME_NO_PAIRED_TIMEOUT_MS},
+               {HDCP_2_2_AKE_SEND_PAIRING_INFO,
+                               DP_HDCP_2_2_AKE_SEND_PAIRING_INFO_OFFSET, true,
+                               HDCP_2_2_PAIRING_TIMEOUT_MS, 0},
+               {HDCP_2_2_LC_INIT, DP_HDCP_2_2_LC_INIT_OFFSET, false, 0, 0},
+               {HDCP_2_2_LC_SEND_LPRIME, DP_HDCP_2_2_LC_SEND_LPRIME_OFFSET,
+                               false, HDCP_2_2_DP_LPRIME_TIMEOUT_MS, 0},
+               {HDCP_2_2_SKE_SEND_EKS, DP_HDCP_2_2_SKE_SEND_EKS_OFFSET, false,
+                               0, 0},
+               {HDCP_2_2_REP_SEND_RECVID_LIST,
+                               DP_HDCP_2_2_REP_SEND_RECVID_LIST_OFFSET, true,
+                               HDCP_2_2_RECVID_LIST_TIMEOUT_MS, 0},
+               {HDCP_2_2_REP_SEND_ACK, DP_HDCP_2_2_REP_SEND_ACK_OFFSET, false,
+                               0, 0},
+               {HDCP_2_2_REP_STREAM_MANAGE,
+                               DP_HDCP_2_2_REP_STREAM_MANAGE_OFFSET, false,
+                               0, 0},
+               {HDCP_2_2_REP_STREAM_READY, DP_HDCP_2_2_REP_STREAM_READY_OFFSET,
+                               false, HDCP_2_2_STREAM_READY_TIMEOUT_MS, 0},
+               {HDCP_2_2_ERRATA_DP_STREAM_TYPE,
+                               DP_HDCP_2_2_REG_STREAM_TYPE_OFFSET, false,
+                               0, 0},
+               };
+
+static inline
+int intel_dp_hdcp2_read_rx_status(struct intel_digital_port *intel_dig_port,
+                                 u8 *rx_status)
+{
+       ssize_t ret;
+
+       ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+                              DP_HDCP_2_2_REG_RXSTATUS_OFFSET, rx_status,
+                              HDCP_2_2_DP_RXSTATUS_LEN);
+       if (ret != HDCP_2_2_DP_RXSTATUS_LEN) {
+               DRM_DEBUG_KMS("Read bstatus from DP/AUX failed (%zd)\n", ret);
+               return ret >= 0 ? -EIO : ret;
+       }
+
+       return 0;
+}
+
+static
+int hdcp2_detect_msg_availability(struct intel_digital_port *intel_dig_port,
+                                 u8 msg_id, bool *msg_ready)
+{
+       u8 rx_status;
+       int ret;
+
+       *msg_ready = false;
+       ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+       if (ret < 0)
+               return ret;
+
+       switch (msg_id) {
+       case HDCP_2_2_AKE_SEND_HPRIME:
+               if (HDCP_2_2_DP_RXSTATUS_H_PRIME(rx_status))
+                       *msg_ready = true;
+               break;
+       case HDCP_2_2_AKE_SEND_PAIRING_INFO:
+               if (HDCP_2_2_DP_RXSTATUS_PAIRING(rx_status))
+                       *msg_ready = true;
+               break;
+       case HDCP_2_2_REP_SEND_RECVID_LIST:
+               if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+                       *msg_ready = true;
+               break;
+       default:
+               DRM_ERROR("Unidentified msg_id: %d\n", msg_id);
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static ssize_t
+intel_dp_hdcp2_wait_for_msg(struct intel_digital_port *intel_dig_port,
+                           struct hdcp2_dp_msg_data *hdcp2_msg_data)
+{
+       struct intel_dp *dp = &intel_dig_port->dp;
+       struct intel_hdcp *hdcp = &dp->attached_connector->hdcp;
+       int ret, timeout;
+       bool msg_ready = false;
+
+       if (hdcp2_msg_data->msg_id == HDCP_2_2_AKE_SEND_HPRIME &&
+           !hdcp->is_paired)
+               timeout = hdcp2_msg_data->timeout2;
+       else
+               timeout = hdcp2_msg_data->timeout;
+
+       /*
+        * There is no way to detect the CERT, LPRIME and STREAM_READY
+        * availability. So Wait for timeout and read the msg.
+        */
+       if (!hdcp2_msg_data->msg_detectable) {
+               mdelay(timeout);
+               ret = 0;
+       } else {
+               /*
+                * Ignoring the return of the intel_dp_hdcp_wait_for_cp_irq,
+                * Just to detect the msg availability before failing it.
+                */
+               intel_dp_hdcp_wait_for_cp_irq(hdcp, timeout);
+               ret = hdcp2_detect_msg_availability(intel_dig_port,
+                                                   hdcp2_msg_data->msg_id,
+                                                   &msg_ready);
+               if (!msg_ready)
+                       ret = -ETIMEDOUT;
+       }
+
+       if (ret)
+               DRM_DEBUG_KMS("msg_id %d, ret %d, timeout(mSec): %d\n",
+                             hdcp2_msg_data->msg_id, ret, timeout);
+
+       return ret;
+}
+
+static struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id)
+{
+       int i;
+
+       for (i = 0; i < sizeof(hdcp2_msg_data); i++)
+               if (hdcp2_msg_data[i].msg_id == msg_id)
+                       return &hdcp2_msg_data[i];
+
+       return NULL;
+}
+
+static
+int intel_dp_hdcp2_write_msg(struct intel_digital_port *intel_dig_port,
+                            void *buf, size_t size)
+{
+       unsigned int offset;
+       u8 *byte = buf;
+       ssize_t ret, bytes_to_write, len;
+       struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+       hdcp2_msg_data = get_hdcp2_dp_msg_data(*byte);
+       if (!hdcp2_msg_data)
+               return -EINVAL;
+
+       offset = hdcp2_msg_data->offset;
+
+       /* No msg_id in DP HDCP2.2 msgs */
+       bytes_to_write = size - 1;
+       byte++;
+
+       while (bytes_to_write) {
+               len = bytes_to_write > DP_AUX_MAX_PAYLOAD_BYTES ?
+                               DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_write;
+
+               ret = drm_dp_dpcd_write(&intel_dig_port->dp.aux,
+                                       offset, (void *)byte, len);
+               if (ret < 0)
+                       return ret;
+
+               bytes_to_write -= ret;
+               byte += ret;
+               offset += ret;
+       }
+
+       return size;
+}
+
+static
+ssize_t get_receiver_id_list_size(struct intel_digital_port *intel_dig_port)
+{
+       u8 rx_info[HDCP_2_2_RXINFO_LEN];
+       u32 dev_cnt;
+       ssize_t ret;
+
+       ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+                              DP_HDCP_2_2_REG_RXINFO_OFFSET,
+                              (void *)rx_info, HDCP_2_2_RXINFO_LEN);
+       if (ret != HDCP_2_2_RXINFO_LEN)
+               return ret >= 0 ? -EIO : ret;
+
+       dev_cnt = (HDCP_2_2_DEV_COUNT_HI(rx_info[0]) << 4 |
+                  HDCP_2_2_DEV_COUNT_LO(rx_info[1]));
+
+       if (dev_cnt > HDCP_2_2_MAX_DEVICE_COUNT)
+               dev_cnt = HDCP_2_2_MAX_DEVICE_COUNT;
+
+       ret = sizeof(struct hdcp2_rep_send_receiverid_list) -
+               HDCP_2_2_RECEIVER_IDS_MAX_LEN +
+               (dev_cnt * HDCP_2_2_RECEIVER_ID_LEN);
+
+       return ret;
+}
+
+static
+int intel_dp_hdcp2_read_msg(struct intel_digital_port *intel_dig_port,
+                           u8 msg_id, void *buf, size_t size)
+{
+       unsigned int offset;
+       u8 *byte = buf;
+       ssize_t ret, bytes_to_recv, len;
+       struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+       hdcp2_msg_data = get_hdcp2_dp_msg_data(msg_id);
+       if (!hdcp2_msg_data)
+               return -EINVAL;
+       offset = hdcp2_msg_data->offset;
+
+       ret = intel_dp_hdcp2_wait_for_msg(intel_dig_port, hdcp2_msg_data);
+       if (ret < 0)
+               return ret;
+
+       if (msg_id == HDCP_2_2_REP_SEND_RECVID_LIST) {
+               ret = get_receiver_id_list_size(intel_dig_port);
+               if (ret < 0)
+                       return ret;
+
+               size = ret;
+       }
+       bytes_to_recv = size - 1;
+
+       /* DP adaptation msgs has no msg_id */
+       byte++;
+
+       while (bytes_to_recv) {
+               len = bytes_to_recv > DP_AUX_MAX_PAYLOAD_BYTES ?
+                     DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_recv;
+
+               ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux, offset,
+                                      (void *)byte, len);
+               if (ret < 0) {
+                       DRM_DEBUG_KMS("msg_id %d, ret %zd\n", msg_id, ret);
+                       return ret;
+               }
+
+               bytes_to_recv -= ret;
+               byte += ret;
+               offset += ret;
+       }
+       byte = buf;
+       *byte = msg_id;
+
+       return size;
+}
+
+static
+int intel_dp_hdcp2_config_stream_type(struct intel_digital_port *intel_dig_port,
+                                     void *buf, size_t size)
+{
+       return intel_dp_hdcp2_write_msg(intel_dig_port, buf, size);
+}
+
+static
+int intel_dp_hdcp2_check_link(struct intel_digital_port *intel_dig_port)
+{
+       u8 rx_status;
+       int ret;
+
+       ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+       if (ret)
+               return ret;
+
+       if (HDCP_2_2_DP_RXSTATUS_REAUTH_REQ(rx_status))
+               ret = DRM_HDCP_REAUTH_REQUEST;
+       else if (HDCP_2_2_DP_RXSTATUS_LINK_FAILED(rx_status))
+               ret = DRM_HDCP_LINK_INTEGRITY_FAILURE;
+       else if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+               ret = DRM_HDCP_TOPOLOGY_CHANGE;
+
+       return ret;
+}
+
+static
+int intel_dp_hdcp2_capable(struct intel_digital_port *intel_dig_port,
+                          bool *capable)
+{
+       u8 rx_caps[3];
+       int ret;
+
+       *capable = false;
+       ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+                              DP_HDCP_2_2_REG_RX_CAPS_OFFSET,
+                              rx_caps, HDCP_2_2_RXCAPS_LEN);
+       if (ret != HDCP_2_2_RXCAPS_LEN)
+               return ret >= 0 ? -EIO : ret;
+
+       if (rx_caps[0] == HDCP_2_2_RX_CAPS_VERSION_VAL &&
+           HDCP_2_2_DP_HDCP_CAPABLE(rx_caps[2]))
+               *capable = true;
+
+       return 0;
+}
+
+static inline
+enum mei_hdcp_wired_protocol intel_dp_hdcp2_protocol(void)
+{
+       return MEI_HDCP_PROTOCOL_DP;
+}
+
 static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
        .write_an_aksv = intel_dp_hdcp_write_an_aksv,
        .read_bksv = intel_dp_hdcp_read_bksv,
@@ -5582,6 +5914,12 @@ static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
        .toggle_signalling = intel_dp_hdcp_toggle_signalling,
        .check_link = intel_dp_hdcp_check_link,
        .hdcp_capable = intel_dp_hdcp_capable,
+       .write_2_2_msg = intel_dp_hdcp2_write_msg,
+       .read_2_2_msg = intel_dp_hdcp2_read_msg,
+       .config_stream_type = intel_dp_hdcp2_config_stream_type,
+       .check_2_2_link = intel_dp_hdcp2_check_link,
+       .hdcp_2_2_capable = intel_dp_hdcp2_capable,
+       .hdcp_protocol = intel_dp_hdcp2_protocol,
 };
 
 static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
drivers/gpu/drm/i915/intel_drv.h +7 -0
index d5ab1ff9cc69..2b7181b76475 100644
@@ -450,6 +450,13 @@ struct intel_hdcp {
        u32 seq_num_m;
 
        struct delayed_work hdcp2_check_work;
+
+       /*
+        * Work queue to signal the CP_IRQ. Used for the waiters to read the
+        * available information from HDCP DP sink.
+        */
+       wait_queue_head_t cp_irq_queue;
+       atomic_t cp_irq_recved;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +6 -1
index b9e5f73c640d..be475914c3cd 100644
@@ -1899,6 +1899,9 @@ int intel_hdcp_init(struct intel_connector *connector,
        if (hdcp2_supported)
                intel_hdcp2_init(connector);
 
+       atomic_set(&hdcp->cp_irq_recved, 0);
+       init_waitqueue_head(&hdcp->cp_irq_queue);
+
        return 0;
 }
 
@@ -2036,4 +2039,7 @@ void intel_hdcp_handle_cp_irq(struct intel_connector *connector)
                intel_hdcp_check_link(connector);
        else if (intel_hdcp2_in_use(connector))
                intel_hdcp2_check_link(connector);
+
+       atomic_set(&connector->hdcp.cp_irq_recved, 1);
+       wake_up_all(&connector->hdcp.cp_irq_queue);
 }
--

2.7.4

Quoted 4 lines

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#47 lore raw

Re: [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

Quoted 4 lines · Stéphane Marchesin

Hi,

Just a drive-by comment, but did you check that this fails gracefully on platforms which don't enable the ME? For example Chrome OS :)

That is taken care :) HDCP2.2 is attempted only if platform enables the ME and its required kernel drivers.

--Ram

Quoted 453 lines

Stéphane

Quoted 449 lines · Ramalingam C

Implements the DP adaptation specific HDCP2.2 functions.

These functions perform the DPCD read and write for communicating the HDCP2.2 auth message back and forth.

v2:
wait for cp_irq is merged with this patch. Rebased.
v3:
wait_queue is used for wait for cp_irq [Chris Wilson]
v4:
Style fixed.
%s/PARING/PAIRING
Few style fixes [Uma]
v5:
Lookup table for DP HDCP2.2 msg details [Daniel]. Extra lines are removed.
v6:
Rebased.
v7:
Fixed some regression introduced at v5. [Ankit] Macro HDCP_2_2_RX_CAPS_VERSION_VAL is reused [Uma] Converted a function to inline [Uma] %s/uintxx_t/uxx
v8:
Error due to the sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
  drivers/gpu/drm/i915/intel_dp.c   | 338 ++++++++++++++++++++++++++++++++++++++
  drivers/gpu/drm/i915/intel_drv.h  |   7 +
  drivers/gpu/drm/i915/intel_hdcp.c |   6 +
  3 files changed, 351 insertions(+)
drivers/gpu/drm/i915/intel_dp.c +338 -0
index ecc4706db7dc..1cc82e490999 100644
@@ -31,6 +31,7 @@
  #include <linux/types.h>
  #include <linux/notifier.h>
  #include <linux/reboot.h>
+#include <linux/mei_hdcp.h>
  #include <asm/byteorder.h>
  #include <drm/drmP.h>
  #include <drm/drm_atomic_helper.h>
@@ -5347,6 +5348,27 @@ void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
         pps_unlock(intel_dp);
  }
 
+static int intel_dp_hdcp_wait_for_cp_irq(struct intel_hdcp *hdcp,
+                                        int timeout)
+{
+       long ret;
+
+       /* Reinit */
+       atomic_set(&hdcp->cp_irq_recved, 0);
+
+#define C (atomic_read(&hdcp->cp_irq_recved) > 0)
+       ret = wait_event_interruptible_timeout(hdcp->cp_irq_queue, C,
+                                              msecs_to_jiffies(timeout));
+
+       if (ret > 0) {
+               atomic_set(&hdcp->cp_irq_recved, 0);
+               return 0;
+       } else if (!ret) {
+               return -ETIMEDOUT;
+       }
+       return (int)ret;
+}
+
  static
  int intel_dp_hdcp_write_an_aksv(struct intel_digital_port *intel_dig_port,
                                 u8 *an)
@@ -5570,6 +5592,316 @@ int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port,
         return 0;
  }
 
+static struct hdcp2_dp_msg_data {
+       u8 msg_id;
+       u32 offset;
+       bool msg_detectable;
+       u32 timeout;
+       u32 timeout2; /* Added for non_paired situation */
+       } hdcp2_msg_data[] = {
+               {HDCP_2_2_AKE_INIT, DP_HDCP_2_2_AKE_INIT_OFFSET, false, 0, 0},
+               {HDCP_2_2_AKE_SEND_CERT, DP_HDCP_2_2_AKE_SEND_CERT_OFFSET,
+                               false, HDCP_2_2_CERT_TIMEOUT_MS, 0},
+               {HDCP_2_2_AKE_NO_STORED_KM, DP_HDCP_2_2_AKE_NO_STORED_KM_OFFSET,
+                               false, 0, 0},
+               {HDCP_2_2_AKE_STORED_KM, DP_HDCP_2_2_AKE_STORED_KM_OFFSET,
+                               false, 0, 0},
+               {HDCP_2_2_AKE_SEND_HPRIME, DP_HDCP_2_2_AKE_SEND_HPRIME_OFFSET,
+                               true, HDCP_2_2_HPRIME_PAIRED_TIMEOUT_MS,
+                               HDCP_2_2_HPRIME_NO_PAIRED_TIMEOUT_MS},
+               {HDCP_2_2_AKE_SEND_PAIRING_INFO,
+                               DP_HDCP_2_2_AKE_SEND_PAIRING_INFO_OFFSET, true,
+                               HDCP_2_2_PAIRING_TIMEOUT_MS, 0},
+               {HDCP_2_2_LC_INIT, DP_HDCP_2_2_LC_INIT_OFFSET, false, 0, 0},
+               {HDCP_2_2_LC_SEND_LPRIME, DP_HDCP_2_2_LC_SEND_LPRIME_OFFSET,
+                               false, HDCP_2_2_DP_LPRIME_TIMEOUT_MS, 0},
+               {HDCP_2_2_SKE_SEND_EKS, DP_HDCP_2_2_SKE_SEND_EKS_OFFSET, false,
+                               0, 0},
+               {HDCP_2_2_REP_SEND_RECVID_LIST,
+                               DP_HDCP_2_2_REP_SEND_RECVID_LIST_OFFSET, true,
+                               HDCP_2_2_RECVID_LIST_TIMEOUT_MS, 0},
+               {HDCP_2_2_REP_SEND_ACK, DP_HDCP_2_2_REP_SEND_ACK_OFFSET, false,
+                               0, 0},
+               {HDCP_2_2_REP_STREAM_MANAGE,
+                               DP_HDCP_2_2_REP_STREAM_MANAGE_OFFSET, false,
+                               0, 0},
+               {HDCP_2_2_REP_STREAM_READY, DP_HDCP_2_2_REP_STREAM_READY_OFFSET,
+                               false, HDCP_2_2_STREAM_READY_TIMEOUT_MS, 0},
+               {HDCP_2_2_ERRATA_DP_STREAM_TYPE,
+                               DP_HDCP_2_2_REG_STREAM_TYPE_OFFSET, false,
+                               0, 0},
+               };
+
+static inline
+int intel_dp_hdcp2_read_rx_status(struct intel_digital_port *intel_dig_port,
+                                 u8 *rx_status)
+{
+       ssize_t ret;
+
+       ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+                              DP_HDCP_2_2_REG_RXSTATUS_OFFSET, rx_status,
+                              HDCP_2_2_DP_RXSTATUS_LEN);
+       if (ret != HDCP_2_2_DP_RXSTATUS_LEN) {
+               DRM_DEBUG_KMS("Read bstatus from DP/AUX failed (%zd)\n", ret);
+               return ret >= 0 ? -EIO : ret;
+       }
+
+       return 0;
+}
+
+static
+int hdcp2_detect_msg_availability(struct intel_digital_port *intel_dig_port,
+                                 u8 msg_id, bool *msg_ready)
+{
+       u8 rx_status;
+       int ret;
+
+       *msg_ready = false;
+       ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+       if (ret < 0)
+               return ret;
+
+       switch (msg_id) {
+       case HDCP_2_2_AKE_SEND_HPRIME:
+               if (HDCP_2_2_DP_RXSTATUS_H_PRIME(rx_status))
+                       *msg_ready = true;
+               break;
+       case HDCP_2_2_AKE_SEND_PAIRING_INFO:
+               if (HDCP_2_2_DP_RXSTATUS_PAIRING(rx_status))
+                       *msg_ready = true;
+               break;
+       case HDCP_2_2_REP_SEND_RECVID_LIST:
+               if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+                       *msg_ready = true;
+               break;
+       default:
+               DRM_ERROR("Unidentified msg_id: %d\n", msg_id);
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static ssize_t
+intel_dp_hdcp2_wait_for_msg(struct intel_digital_port *intel_dig_port,
+                           struct hdcp2_dp_msg_data *hdcp2_msg_data)
+{
+       struct intel_dp *dp = &intel_dig_port->dp;
+       struct intel_hdcp *hdcp = &dp->attached_connector->hdcp;
+       int ret, timeout;
+       bool msg_ready = false;
+
+       if (hdcp2_msg_data->msg_id == HDCP_2_2_AKE_SEND_HPRIME &&
+           !hdcp->is_paired)
+               timeout = hdcp2_msg_data->timeout2;
+       else
+               timeout = hdcp2_msg_data->timeout;
+
+       /*
+        * There is no way to detect the CERT, LPRIME and STREAM_READY
+        * availability. So Wait for timeout and read the msg.
+        */
+       if (!hdcp2_msg_data->msg_detectable) {
+               mdelay(timeout);
+               ret = 0;
+       } else {
+               /*
+                * Ignoring the return of the intel_dp_hdcp_wait_for_cp_irq,
+                * Just to detect the msg availability before failing it.
+                */
+               intel_dp_hdcp_wait_for_cp_irq(hdcp, timeout);
+               ret = hdcp2_detect_msg_availability(intel_dig_port,
+                                                   hdcp2_msg_data->msg_id,
+                                                   &msg_ready);
+               if (!msg_ready)
+                       ret = -ETIMEDOUT;
+       }
+
+       if (ret)
+               DRM_DEBUG_KMS("msg_id %d, ret %d, timeout(mSec): %d\n",
+                             hdcp2_msg_data->msg_id, ret, timeout);
+
+       return ret;
+}
+
+static struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id)
+{
+       int i;
+
+       for (i = 0; i < sizeof(hdcp2_msg_data); i++)
+               if (hdcp2_msg_data[i].msg_id == msg_id)
+                       return &hdcp2_msg_data[i];
+
+       return NULL;
+}
+
+static
+int intel_dp_hdcp2_write_msg(struct intel_digital_port *intel_dig_port,
+                            void *buf, size_t size)
+{
+       unsigned int offset;
+       u8 *byte = buf;
+       ssize_t ret, bytes_to_write, len;
+       struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+       hdcp2_msg_data = get_hdcp2_dp_msg_data(*byte);
+       if (!hdcp2_msg_data)
+               return -EINVAL;
+
+       offset = hdcp2_msg_data->offset;
+
+       /* No msg_id in DP HDCP2.2 msgs */
+       bytes_to_write = size - 1;
+       byte++;
+
+       while (bytes_to_write) {
+               len = bytes_to_write > DP_AUX_MAX_PAYLOAD_BYTES ?
+                               DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_write;
+
+               ret = drm_dp_dpcd_write(&intel_dig_port->dp.aux,
+                                       offset, (void *)byte, len);
+               if (ret < 0)
+                       return ret;
+
+               bytes_to_write -= ret;
+               byte += ret;
+               offset += ret;
+       }
+
+       return size;
+}
+
+static
+ssize_t get_receiver_id_list_size(struct intel_digital_port *intel_dig_port)
+{
+       u8 rx_info[HDCP_2_2_RXINFO_LEN];
+       u32 dev_cnt;
+       ssize_t ret;
+
+       ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+                              DP_HDCP_2_2_REG_RXINFO_OFFSET,
+                              (void *)rx_info, HDCP_2_2_RXINFO_LEN);
+       if (ret != HDCP_2_2_RXINFO_LEN)
+               return ret >= 0 ? -EIO : ret;
+
+       dev_cnt = (HDCP_2_2_DEV_COUNT_HI(rx_info[0]) << 4 |
+                  HDCP_2_2_DEV_COUNT_LO(rx_info[1]));
+
+       if (dev_cnt > HDCP_2_2_MAX_DEVICE_COUNT)
+               dev_cnt = HDCP_2_2_MAX_DEVICE_COUNT;
+
+       ret = sizeof(struct hdcp2_rep_send_receiverid_list) -
+               HDCP_2_2_RECEIVER_IDS_MAX_LEN +
+               (dev_cnt * HDCP_2_2_RECEIVER_ID_LEN);
+
+       return ret;
+}
+
+static
+int intel_dp_hdcp2_read_msg(struct intel_digital_port *intel_dig_port,
+                           u8 msg_id, void *buf, size_t size)
+{
+       unsigned int offset;
+       u8 *byte = buf;
+       ssize_t ret, bytes_to_recv, len;
+       struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+       hdcp2_msg_data = get_hdcp2_dp_msg_data(msg_id);
+       if (!hdcp2_msg_data)
+               return -EINVAL;
+       offset = hdcp2_msg_data->offset;
+
+       ret = intel_dp_hdcp2_wait_for_msg(intel_dig_port, hdcp2_msg_data);
+       if (ret < 0)
+               return ret;
+
+       if (msg_id == HDCP_2_2_REP_SEND_RECVID_LIST) {
+               ret = get_receiver_id_list_size(intel_dig_port);
+               if (ret < 0)
+                       return ret;
+
+               size = ret;
+       }
+       bytes_to_recv = size - 1;
+
+       /* DP adaptation msgs has no msg_id */
+       byte++;
+
+       while (bytes_to_recv) {
+               len = bytes_to_recv > DP_AUX_MAX_PAYLOAD_BYTES ?
+                     DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_recv;
+
+               ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux, offset,
+                                      (void *)byte, len);
+               if (ret < 0) {
+                       DRM_DEBUG_KMS("msg_id %d, ret %zd\n", msg_id, ret);
+                       return ret;
+               }
+
+               bytes_to_recv -= ret;
+               byte += ret;
+               offset += ret;
+       }
+       byte = buf;
+       *byte = msg_id;
+
+       return size;
+}
+
+static
+int intel_dp_hdcp2_config_stream_type(struct intel_digital_port *intel_dig_port,
+                                     void *buf, size_t size)
+{
+       return intel_dp_hdcp2_write_msg(intel_dig_port, buf, size);
+}
+
+static
+int intel_dp_hdcp2_check_link(struct intel_digital_port *intel_dig_port)
+{
+       u8 rx_status;
+       int ret;
+
+       ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+       if (ret)
+               return ret;
+
+       if (HDCP_2_2_DP_RXSTATUS_REAUTH_REQ(rx_status))
+               ret = DRM_HDCP_REAUTH_REQUEST;
+       else if (HDCP_2_2_DP_RXSTATUS_LINK_FAILED(rx_status))
+               ret = DRM_HDCP_LINK_INTEGRITY_FAILURE;
+       else if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+               ret = DRM_HDCP_TOPOLOGY_CHANGE;
+
+       return ret;
+}
+
+static
+int intel_dp_hdcp2_capable(struct intel_digital_port *intel_dig_port,
+                          bool *capable)
+{
+       u8 rx_caps[3];
+       int ret;
+
+       *capable = false;
+       ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+                              DP_HDCP_2_2_REG_RX_CAPS_OFFSET,
+                              rx_caps, HDCP_2_2_RXCAPS_LEN);
+       if (ret != HDCP_2_2_RXCAPS_LEN)
+               return ret >= 0 ? -EIO : ret;
+
+       if (rx_caps[0] == HDCP_2_2_RX_CAPS_VERSION_VAL &&
+           HDCP_2_2_DP_HDCP_CAPABLE(rx_caps[2]))
+               *capable = true;
+
+       return 0;
+}
+
+static inline
+enum mei_hdcp_wired_protocol intel_dp_hdcp2_protocol(void)
+{
+       return MEI_HDCP_PROTOCOL_DP;
+}
+
  static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
         .write_an_aksv = intel_dp_hdcp_write_an_aksv,
         .read_bksv = intel_dp_hdcp_read_bksv,
@@ -5582,6 +5914,12 @@ static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
         .toggle_signalling = intel_dp_hdcp_toggle_signalling,
         .check_link = intel_dp_hdcp_check_link,
         .hdcp_capable = intel_dp_hdcp_capable,
+       .write_2_2_msg = intel_dp_hdcp2_write_msg,
+       .read_2_2_msg = intel_dp_hdcp2_read_msg,
+       .config_stream_type = intel_dp_hdcp2_config_stream_type,
+       .check_2_2_link = intel_dp_hdcp2_check_link,
+       .hdcp_2_2_capable = intel_dp_hdcp2_capable,
+       .hdcp_protocol = intel_dp_hdcp2_protocol,
  };
 
  static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
drivers/gpu/drm/i915/intel_drv.h +7 -0
index d5ab1ff9cc69..2b7181b76475 100644
@@ -450,6 +450,13 @@ struct intel_hdcp {
         u32 seq_num_m;
 
         struct delayed_work hdcp2_check_work;
+
+       /*
+        * Work queue to signal the CP_IRQ. Used for the waiters to read the
+        * available information from HDCP DP sink.
+        */
+       wait_queue_head_t cp_irq_queue;
+       atomic_t cp_irq_recved;
  };
 
  struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +6 -1
index b9e5f73c640d..be475914c3cd 100644
@@ -1899,6 +1899,9 @@ int intel_hdcp_init(struct intel_connector *connector,
         if (hdcp2_supported)
                 intel_hdcp2_init(connector);
 
+       atomic_set(&hdcp->cp_irq_recved, 0);
+       init_waitqueue_head(&hdcp->cp_irq_queue);
+
         return 0;
  }
 
@@ -2036,4 +2039,7 @@ void intel_hdcp_handle_cp_irq(struct intel_connector *connector)
                 intel_hdcp_check_link(connector);
         else if (intel_hdcp2_in_use(connector))
                 intel_hdcp2_check_link(connector);
+
+       atomic_set(&connector->hdcp.cp_irq_recved, 1);
+       wake_up_all(&connector->hdcp.cp_irq_queue);
  }
--

2.7.4

Quoted 4 lines
Quoted 4 lines

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

#48 lore raw

Re: [PATCH v8 12/35] drm/i915: Implement the HDCP2.2 support for DP

In reply to Ramalingam C
Quoted 49 lines · Ramalingam C

Implements the DP adaptation specific HDCP2.2 functions.

These functions perform the DPCD read and write for communicating the HDCP2.2 auth message back and forth.

v2:
wait for cp_irq is merged with this patch. Rebased.
v3:
wait_queue is used for wait for cp_irq [Chris Wilson]
v4:
Style fixed.
%s/PARING/PAIRING
Few style fixes [Uma]
v5:
Lookup table for DP HDCP2.2 msg details [Daniel]. Extra lines are removed.
v6:
Rebased.
v7:
Fixed some regression introduced at v5. [Ankit] Macro HDCP_2_2_RX_CAPS_VERSION_VAL is reused [Uma] Converted a function to inline [Uma] %s/uintxx_t/uxx
v8:
Error due to the sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
 drivers/gpu/drm/i915/intel_dp.c   | 338 ++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_drv.h  |   7 +
 drivers/gpu/drm/i915/intel_hdcp.c |   6 +
 3 files changed, 351 insertions(+)
drivers/gpu/drm/i915/intel_dp.c +1 -0
index ecc4706db7dc..1cc82e490999 100644
@@ -31,6 +31,7 @@
 #include <linux/types.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
+#include <linux/mei_hdcp.h>
 #include <asm/byteorder.h>
 #include <drm/drmP.h>
 #include <drm/drm_atomic_helper.h>

drivers/gpu/drm/i915/intel_dp.c void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder) · line 5357

Quoted 10 lines
drivers/gpu/drm/i915/intel_dp.c +7 -0
@@ -5347,6 +5348,27 @@ void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
 	pps_unlock(intel_dp);
 }
 
+static int intel_dp_hdcp_wait_for_cp_irq(struct intel_hdcp *hdcp,
+					 int timeout)
+{
+	long ret;
+
+	/* Reinit */
+	atomic_set(&hdcp->cp_irq_recved, 0);

This here doesn't fix any race here, you might as well use

#define C true

here (Except of course it rechecks that).

drivers/gpu/drm/i915/intel_dp.c void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder) · line 5361

Quoted 4 lines
drivers/gpu/drm/i915/intel_dp.c +4 -0
+
+#define C (atomic_read(&hdcp->cp_irq_recved) > 0)
+	ret = wait_event_interruptible_timeout(hdcp->cp_irq_queue, C,
+					       msecs_to_jiffies(timeout));

What you really need/want to do to check whether the wait succeeded is call hdcp2_detect_msg_availability(). Might be better to open-code the wait_event for clarity.

Also debug ouptut to complain when we timed out here would be good (since you ignore the error later on)

Quoted 125 lines
drivers/gpu/drm/i915/intel_dp.c +118 -0
+
+	if (ret > 0) {
+		atomic_set(&hdcp->cp_irq_recved, 0);
+		return 0;
+	} else if (!ret) {
+		return -ETIMEDOUT;
+	}
+	return (int)ret;
+}
+
 static
 int intel_dp_hdcp_write_an_aksv(struct intel_digital_port *intel_dig_port,
 				u8 *an)
@@ -5570,6 +5592,316 @@ int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port,
 	return 0;
 }
 
+static struct hdcp2_dp_msg_data {
+	u8 msg_id;
+	u32 offset;
+	bool msg_detectable;
+	u32 timeout;
+	u32 timeout2; /* Added for non_paired situation */
+	} hdcp2_msg_data[] = {
+		{HDCP_2_2_AKE_INIT, DP_HDCP_2_2_AKE_INIT_OFFSET, false, 0, 0},
+		{HDCP_2_2_AKE_SEND_CERT, DP_HDCP_2_2_AKE_SEND_CERT_OFFSET,
+				false, HDCP_2_2_CERT_TIMEOUT_MS, 0},
+		{HDCP_2_2_AKE_NO_STORED_KM, DP_HDCP_2_2_AKE_NO_STORED_KM_OFFSET,
+				false, 0, 0},
+		{HDCP_2_2_AKE_STORED_KM, DP_HDCP_2_2_AKE_STORED_KM_OFFSET,
+				false, 0, 0},
+		{HDCP_2_2_AKE_SEND_HPRIME, DP_HDCP_2_2_AKE_SEND_HPRIME_OFFSET,
+				true, HDCP_2_2_HPRIME_PAIRED_TIMEOUT_MS,
+				HDCP_2_2_HPRIME_NO_PAIRED_TIMEOUT_MS},
+		{HDCP_2_2_AKE_SEND_PAIRING_INFO,
+				DP_HDCP_2_2_AKE_SEND_PAIRING_INFO_OFFSET, true,
+				HDCP_2_2_PAIRING_TIMEOUT_MS, 0},
+		{HDCP_2_2_LC_INIT, DP_HDCP_2_2_LC_INIT_OFFSET, false, 0, 0},
+		{HDCP_2_2_LC_SEND_LPRIME, DP_HDCP_2_2_LC_SEND_LPRIME_OFFSET,
+				false, HDCP_2_2_DP_LPRIME_TIMEOUT_MS, 0},
+		{HDCP_2_2_SKE_SEND_EKS, DP_HDCP_2_2_SKE_SEND_EKS_OFFSET, false,
+				0, 0},
+		{HDCP_2_2_REP_SEND_RECVID_LIST,
+				DP_HDCP_2_2_REP_SEND_RECVID_LIST_OFFSET, true,
+				HDCP_2_2_RECVID_LIST_TIMEOUT_MS, 0},
+		{HDCP_2_2_REP_SEND_ACK, DP_HDCP_2_2_REP_SEND_ACK_OFFSET, false,
+				0, 0},
+		{HDCP_2_2_REP_STREAM_MANAGE,
+				DP_HDCP_2_2_REP_STREAM_MANAGE_OFFSET, false,
+				0, 0},
+		{HDCP_2_2_REP_STREAM_READY, DP_HDCP_2_2_REP_STREAM_READY_OFFSET,
+				false, HDCP_2_2_STREAM_READY_TIMEOUT_MS, 0},
+		{HDCP_2_2_ERRATA_DP_STREAM_TYPE,
+				DP_HDCP_2_2_REG_STREAM_TYPE_OFFSET, false,
+				0, 0},
+		};
+
+static inline
+int intel_dp_hdcp2_read_rx_status(struct intel_digital_port *intel_dig_port,
+				  u8 *rx_status)
+{
+	ssize_t ret;
+
+	ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+			       DP_HDCP_2_2_REG_RXSTATUS_OFFSET, rx_status,
+			       HDCP_2_2_DP_RXSTATUS_LEN);
+	if (ret != HDCP_2_2_DP_RXSTATUS_LEN) {
+		DRM_DEBUG_KMS("Read bstatus from DP/AUX failed (%zd)\n", ret);
+		return ret >= 0 ? -EIO : ret;
+	}
+
+	return 0;
+}
+
+static
+int hdcp2_detect_msg_availability(struct intel_digital_port *intel_dig_port,
+				  u8 msg_id, bool *msg_ready)
+{
+	u8 rx_status;
+	int ret;
+
+	*msg_ready = false;
+	ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+	if (ret < 0)
+		return ret;
+
+	switch (msg_id) {
+	case HDCP_2_2_AKE_SEND_HPRIME:
+		if (HDCP_2_2_DP_RXSTATUS_H_PRIME(rx_status))
+			*msg_ready = true;
+		break;
+	case HDCP_2_2_AKE_SEND_PAIRING_INFO:
+		if (HDCP_2_2_DP_RXSTATUS_PAIRING(rx_status))
+			*msg_ready = true;
+		break;
+	case HDCP_2_2_REP_SEND_RECVID_LIST:
+		if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+			*msg_ready = true;
+		break;
+	default:
+		DRM_ERROR("Unidentified msg_id: %d\n", msg_id);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static ssize_t
+intel_dp_hdcp2_wait_for_msg(struct intel_digital_port *intel_dig_port,
+			    struct hdcp2_dp_msg_data *hdcp2_msg_data)
+{
+	struct intel_dp *dp = &intel_dig_port->dp;
+	struct intel_hdcp *hdcp = &dp->attached_connector->hdcp;
+	int ret, timeout;
+	bool msg_ready = false;
+
+	if (hdcp2_msg_data->msg_id == HDCP_2_2_AKE_SEND_HPRIME &&
+	    !hdcp->is_paired)
+		timeout = hdcp2_msg_data->timeout2;
+	else
+		timeout = hdcp2_msg_data->timeout;
+
+	/*
+	 * There is no way to detect the CERT, LPRIME and STREAM_READY
+	 * availability. So Wait for timeout and read the msg.

drivers/gpu/drm/i915/intel_dp.c int intel_dp_hdcp_capable(struct intel_digital_port *intel_dig_port, · line 5712

Quoted 10 lines
drivers/gpu/drm/i915/intel_dp.c +10 -0
+	 */
+	if (!hdcp2_msg_data->msg_detectable) {
+		mdelay(timeout);
+		ret = 0;
+	} else {
+		/*
+		 * Ignoring the return of the intel_dp_hdcp_wait_for_cp_irq,
+		 * Just to detect the msg availability before failing it.
+		 */
+		intel_dp_hdcp_wait_for_cp_irq(hdcp, timeout);

If you ignore the error of a static function, make it return void. Otherwise just confusing to the reader.

Quoted 241 lines
drivers/gpu/drm/i915/intel_dp.c +198 -0
+		ret = hdcp2_detect_msg_availability(intel_dig_port,
+						    hdcp2_msg_data->msg_id,
+						    &msg_ready);
+		if (!msg_ready)
+			ret = -ETIMEDOUT;
+	}
+
+	if (ret)
+		DRM_DEBUG_KMS("msg_id %d, ret %d, timeout(mSec): %d\n",
+			      hdcp2_msg_data->msg_id, ret, timeout);
+
+	return ret;
+}
+
+static struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id)
+{
+	int i;
+
+	for (i = 0; i < sizeof(hdcp2_msg_data); i++)
+		if (hdcp2_msg_data[i].msg_id == msg_id)
+			return &hdcp2_msg_data[i];
+
+	return NULL;
+}
+
+static
+int intel_dp_hdcp2_write_msg(struct intel_digital_port *intel_dig_port,
+			     void *buf, size_t size)
+{
+	unsigned int offset;
+	u8 *byte = buf;
+	ssize_t ret, bytes_to_write, len;
+	struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+	hdcp2_msg_data = get_hdcp2_dp_msg_data(*byte);
+	if (!hdcp2_msg_data)
+		return -EINVAL;
+
+	offset = hdcp2_msg_data->offset;
+
+	/* No msg_id in DP HDCP2.2 msgs */
+	bytes_to_write = size - 1;
+	byte++;
+
+	while (bytes_to_write) {
+		len = bytes_to_write > DP_AUX_MAX_PAYLOAD_BYTES ?
+				DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_write;
+
+		ret = drm_dp_dpcd_write(&intel_dig_port->dp.aux,
+					offset, (void *)byte, len);
+		if (ret < 0)
+			return ret;
+
+		bytes_to_write -= ret;
+		byte += ret;
+		offset += ret;
+	}
+
+	return size;
+}
+
+static
+ssize_t get_receiver_id_list_size(struct intel_digital_port *intel_dig_port)
+{
+	u8 rx_info[HDCP_2_2_RXINFO_LEN];
+	u32 dev_cnt;
+	ssize_t ret;
+
+	ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+			       DP_HDCP_2_2_REG_RXINFO_OFFSET,
+			       (void *)rx_info, HDCP_2_2_RXINFO_LEN);
+	if (ret != HDCP_2_2_RXINFO_LEN)
+		return ret >= 0 ? -EIO : ret;
+
+	dev_cnt = (HDCP_2_2_DEV_COUNT_HI(rx_info[0]) << 4 |
+		   HDCP_2_2_DEV_COUNT_LO(rx_info[1]));
+
+	if (dev_cnt > HDCP_2_2_MAX_DEVICE_COUNT)
+		dev_cnt = HDCP_2_2_MAX_DEVICE_COUNT;
+
+	ret = sizeof(struct hdcp2_rep_send_receiverid_list) -
+		HDCP_2_2_RECEIVER_IDS_MAX_LEN +
+		(dev_cnt * HDCP_2_2_RECEIVER_ID_LEN);
+
+	return ret;
+}
+
+static
+int intel_dp_hdcp2_read_msg(struct intel_digital_port *intel_dig_port,
+			    u8 msg_id, void *buf, size_t size)
+{
+	unsigned int offset;
+	u8 *byte = buf;
+	ssize_t ret, bytes_to_recv, len;
+	struct hdcp2_dp_msg_data *hdcp2_msg_data;
+
+	hdcp2_msg_data = get_hdcp2_dp_msg_data(msg_id);
+	if (!hdcp2_msg_data)
+		return -EINVAL;
+	offset = hdcp2_msg_data->offset;
+
+	ret = intel_dp_hdcp2_wait_for_msg(intel_dig_port, hdcp2_msg_data);
+	if (ret < 0)
+		return ret;
+
+	if (msg_id == HDCP_2_2_REP_SEND_RECVID_LIST) {
+		ret = get_receiver_id_list_size(intel_dig_port);
+		if (ret < 0)
+			return ret;
+
+		size = ret;
+	}
+	bytes_to_recv = size - 1;
+
+	/* DP adaptation msgs has no msg_id */
+	byte++;
+
+	while (bytes_to_recv) {
+		len = bytes_to_recv > DP_AUX_MAX_PAYLOAD_BYTES ?
+		      DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_recv;
+
+		ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux, offset,
+				       (void *)byte, len);
+		if (ret < 0) {
+			DRM_DEBUG_KMS("msg_id %d, ret %zd\n", msg_id, ret);
+			return ret;
+		}
+
+		bytes_to_recv -= ret;
+		byte += ret;
+		offset += ret;
+	}
+	byte = buf;
+	*byte = msg_id;
+
+	return size;
+}
+
+static
+int intel_dp_hdcp2_config_stream_type(struct intel_digital_port *intel_dig_port,
+				      void *buf, size_t size)
+{
+	return intel_dp_hdcp2_write_msg(intel_dig_port, buf, size);
+}
+
+static
+int intel_dp_hdcp2_check_link(struct intel_digital_port *intel_dig_port)
+{
+	u8 rx_status;
+	int ret;
+
+	ret = intel_dp_hdcp2_read_rx_status(intel_dig_port, &rx_status);
+	if (ret)
+		return ret;
+
+	if (HDCP_2_2_DP_RXSTATUS_REAUTH_REQ(rx_status))
+		ret = DRM_HDCP_REAUTH_REQUEST;
+	else if (HDCP_2_2_DP_RXSTATUS_LINK_FAILED(rx_status))
+		ret = DRM_HDCP_LINK_INTEGRITY_FAILURE;
+	else if (HDCP_2_2_DP_RXSTATUS_READY(rx_status))
+		ret = DRM_HDCP_TOPOLOGY_CHANGE;
+
+	return ret;
+}
+
+static
+int intel_dp_hdcp2_capable(struct intel_digital_port *intel_dig_port,
+			   bool *capable)
+{
+	u8 rx_caps[3];
+	int ret;
+
+	*capable = false;
+	ret = drm_dp_dpcd_read(&intel_dig_port->dp.aux,
+			       DP_HDCP_2_2_REG_RX_CAPS_OFFSET,
+			       rx_caps, HDCP_2_2_RXCAPS_LEN);
+	if (ret != HDCP_2_2_RXCAPS_LEN)
+		return ret >= 0 ? -EIO : ret;
+
+	if (rx_caps[0] == HDCP_2_2_RX_CAPS_VERSION_VAL &&
+	    HDCP_2_2_DP_HDCP_CAPABLE(rx_caps[2]))
+		*capable = true;
+
+	return 0;
+}
+
+static inline
+enum mei_hdcp_wired_protocol intel_dp_hdcp2_protocol(void)
+{
+	return MEI_HDCP_PROTOCOL_DP;
+}
+
 static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
 	.write_an_aksv = intel_dp_hdcp_write_an_aksv,
 	.read_bksv = intel_dp_hdcp_read_bksv,
@@ -5582,6 +5914,12 @@ static const struct intel_hdcp_shim intel_dp_hdcp_shim = {
 	.toggle_signalling = intel_dp_hdcp_toggle_signalling,
 	.check_link = intel_dp_hdcp_check_link,
 	.hdcp_capable = intel_dp_hdcp_capable,
+	.write_2_2_msg = intel_dp_hdcp2_write_msg,
+	.read_2_2_msg = intel_dp_hdcp2_read_msg,
+	.config_stream_type = intel_dp_hdcp2_config_stream_type,
+	.check_2_2_link = intel_dp_hdcp2_check_link,
+	.hdcp_2_2_capable = intel_dp_hdcp2_capable,
+	.hdcp_protocol = intel_dp_hdcp2_protocol,
 };
 
 static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
drivers/gpu/drm/i915/intel_drv.h +7 -0
index d5ab1ff9cc69..2b7181b76475 100644
@@ -450,6 +450,13 @@ struct intel_hdcp {
 	u32 seq_num_m;
 
 	struct delayed_work hdcp2_check_work;
+
+	/*
+	 * Work queue to signal the CP_IRQ. Used for the waiters to read the
+	 * available information from HDCP DP sink.
+	 */
+	wait_queue_head_t cp_irq_queue;
+	atomic_t cp_irq_recved;
 };
 
 struct intel_connector {
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
index b9e5f73c640d..be475914c3cd 100644
@@ -1899,6 +1899,9 @@ int intel_hdcp_init(struct intel_connector *connector,
 	if (hdcp2_supported)
 		intel_hdcp2_init(connector);
 
+	atomic_set(&hdcp->cp_irq_recved, 0);
+	init_waitqueue_head(&hdcp->cp_irq_queue);
+
 	return 0;
 }
 

drivers/gpu/drm/i915/intel_hdcp.c void intel_hdcp_handle_cp_irq(struct intel_connector *connector) · line 2044

Quoted 6 lines
drivers/gpu/drm/i915/intel_hdcp.c +3 -0
@@ -2036,4 +2039,7 @@ void intel_hdcp_handle_cp_irq(struct intel_connector *connector)
 		intel_hdcp_check_link(connector);
 	else if (intel_hdcp2_in_use(connector))
 		intel_hdcp2_check_link(connector);
+
+	atomic_set(&connector->hdcp.cp_irq_recved, 1);
+	wake_up_all(&connector->hdcp.cp_irq_queue);

This deadlocks the waiter, and you'll time out (which saves the day). If check_link needs to do some HDCP2 writes, which needs to wait for the cp interrupt, then this will never happened because the exact same worker is waiting for that cp interrupt to be signaled.

You need 2 workers to make this work:
1. Handles the CP interrupt and calls wake_up_all(), plus schedules the check_link worker (if needed .... how should we decide that exactly?)

2. 2nd worker runs the check_link work.

This way the 2nd worker can go through the entire sequence, while the 1st worker handles interrupts and does wake_up_all calls as needed. Problem is, if the first worker also schedules the 2nd one, you're now in an endless loop.

Since the entire thing seems to be not that well thought out: What about just going with the msleep(timeout) for now, and figuring this out later? Defacto this is what your code already does.

For the hdcp2 logic itself I'm going to trust Uma again. -Daniel

Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#49 lore raw

PATCH v8 13/35 drm/i915: Implement the HDCP2.2 support for HDMI

In reply to Ramalingam C

Implements the HDMI adaptation specific HDCP2.2 operations.

Basically these are DDC read and write for authenticating through HDCP2.2 messages.

v2:
Rebased.
v3:
No Changes.
v4:
No more special handling of Gmbus burst read for AKE_SEND_CERT. Style fixed with few naming. [Uma]
%s/PARING/PAIRING
v5:
msg_sz is initialized at definition.
Lookup table is defined for HDMI HDCP2.2 msgs [Daniel].
v6:
Rebased.
v7:
Make a function as inline [Uma]
%s/uintxx_t/uxx
v8:
Errors due to sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
 drivers/gpu/drm/i915/intel_hdmi.c | 190 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 190 insertions(+)
drivers/gpu/drm/i915/intel_hdmi.c +190 -0
index e755a3370bca..912f50133645 100644
@@ -30,6 +30,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/hdmi.h>
+#include <linux/mei_hdcp.h>
 #include <drm/drmP.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc.h>
@@ -1117,6 +1118,190 @@ bool intel_hdmi_hdcp_check_link(struct intel_digital_port *intel_dig_port)
 	return true;
 }
 
+static struct hdcp2_hdmi_msg_data {
+	u8 msg_id;
+	u32 timeout;
+	u32 timeout2;
+	} hdcp2_msg_data[] = {
+		{HDCP_2_2_AKE_INIT, 0, 0},
+		{HDCP_2_2_AKE_SEND_CERT, HDCP_2_2_CERT_TIMEOUT_MS, 0},
+		{HDCP_2_2_AKE_NO_STORED_KM, 0, 0},
+		{HDCP_2_2_AKE_STORED_KM, 0, 0},
+		{HDCP_2_2_AKE_SEND_HPRIME, HDCP_2_2_HPRIME_PAIRED_TIMEOUT_MS,
+				HDCP_2_2_HPRIME_NO_PAIRED_TIMEOUT_MS},
+		{HDCP_2_2_AKE_SEND_PAIRING_INFO, HDCP_2_2_PAIRING_TIMEOUT_MS,
+				0},
+		{HDCP_2_2_LC_INIT, 0, 0},
+		{HDCP_2_2_LC_SEND_LPRIME, HDCP_2_2_HDMI_LPRIME_TIMEOUT_MS, 0},
+		{HDCP_2_2_SKE_SEND_EKS, 0, 0},
+		{HDCP_2_2_REP_SEND_RECVID_LIST,
+				HDCP_2_2_RECVID_LIST_TIMEOUT_MS, 0},
+		{HDCP_2_2_REP_SEND_ACK, 0, 0},
+		{HDCP_2_2_REP_STREAM_MANAGE, 0, 0},
+		{HDCP_2_2_REP_STREAM_READY, HDCP_2_2_STREAM_READY_TIMEOUT_MS,
+				0},
+	};
+
+static
+int intel_hdmi_hdcp2_read_rx_status(struct intel_digital_port *intel_dig_port,
+				    uint8_t *rx_status)
+{
+	return intel_hdmi_hdcp_read(intel_dig_port,
+				    HDCP_2_2_HDMI_REG_RXSTATUS_OFFSET,
+				    rx_status,
+				    HDCP_2_2_HDMI_RXSTATUS_LEN);
+}
+
+static int get_hdcp2_msg_timeout(u8 msg_id, bool is_paired)
+{
+	int i;
+
+	for (i = 0; i < sizeof(hdcp2_msg_data); i++)
+		if (hdcp2_msg_data[i].msg_id == msg_id &&
+		    (msg_id != HDCP_2_2_AKE_SEND_HPRIME || is_paired))
+			return hdcp2_msg_data[i].timeout;
+		else if (hdcp2_msg_data[i].msg_id == msg_id)
+			return hdcp2_msg_data[i].timeout2;
+
+	return -EINVAL;
+}
+
+static inline
+int hdcp2_detect_msg_availability(struct intel_digital_port *intel_digital_port,
+				  u8 msg_id, bool *msg_ready,
+				  ssize_t *msg_sz)
+{
+	u8 rx_status[HDCP_2_2_HDMI_RXSTATUS_LEN];
+	int ret;
+
+	ret = intel_hdmi_hdcp2_read_rx_status(intel_digital_port, rx_status);
+	if (ret < 0) {
+		DRM_DEBUG_KMS("rx_status read failed. Err %d\n", ret);
+		return ret;
+	}
+
+	*msg_sz = ((HDCP_2_2_HDMI_RXSTATUS_MSG_SZ_HI(rx_status[1]) << 8) |
+		  rx_status[0]);
+
+	if (msg_id == HDCP_2_2_REP_SEND_RECVID_LIST)
+		*msg_ready = (HDCP_2_2_HDMI_RXSTATUS_READY(rx_status[1]) &&
+			     *msg_sz);
+	else
+		*msg_ready = *msg_sz;
+
+	return 0;
+}
+
+static ssize_t
+intel_hdmi_hdcp2_wait_for_msg(struct intel_digital_port *intel_dig_port,
+			      u8 msg_id, bool paired)
+{
+	bool msg_ready = false;
+	int timeout, ret;
+	ssize_t msg_sz = 0;
+
+	timeout = get_hdcp2_msg_timeout(msg_id, paired);
+	if (timeout < 0)
+		return timeout;
+
+	ret = __wait_for(ret = hdcp2_detect_msg_availability(intel_dig_port,
+							     msg_id, &msg_ready,
+							     &msg_sz),
+			 !ret && msg_ready && msg_sz, timeout * 1000,
+			 1000, 5 * 1000);
+	if (ret)
+		DRM_DEBUG_KMS("msg_id: %d, ret: %d, timeout: %d\n",
+			      msg_id, ret, timeout);
+
+	return ret ? ret : msg_sz;
+}
+
+static
+int intel_hdmi_hdcp2_write_msg(struct intel_digital_port *intel_dig_port,
+			       void *buf, size_t size)
+{
+	unsigned int offset;
+
+	offset = HDCP_2_2_HDMI_REG_WR_MSG_OFFSET;
+	return intel_hdmi_hdcp_write(intel_dig_port, offset, buf, size);
+}
+
+static
+int intel_hdmi_hdcp2_read_msg(struct intel_digital_port *intel_dig_port,
+			      u8 msg_id, void *buf, size_t size)
+{
+	struct intel_hdmi *hdmi = &intel_dig_port->hdmi;
+	struct intel_hdcp *hdcp = &hdmi->attached_connector->hdcp;
+	unsigned int offset;
+	ssize_t ret;
+
+	ret = intel_hdmi_hdcp2_wait_for_msg(intel_dig_port, msg_id,
+					    hdcp->is_paired);
+	if (ret < 0)
+		return ret;
+
+	/*
+	 * Available msg size should be equal to or lesser than the
+	 * available buffer.
+	 */
+	if (ret > size) {
+		DRM_DEBUG_KMS("msg_sz(%zd) is more than exp size(%zu)\n",
+			      ret, size);
+		return -1;
+	}
+
+	offset = HDCP_2_2_HDMI_REG_RD_MSG_OFFSET;
+	ret = intel_hdmi_hdcp_read(intel_dig_port, offset, buf, ret);
+	if (ret)
+		DRM_DEBUG_KMS("Failed to read msg_id: %d(%zd)\n", msg_id, ret);
+
+	return ret;
+}
+
+static
+int intel_hdmi_hdcp2_check_link(struct intel_digital_port *intel_dig_port)
+{
+	u8 rx_status[HDCP_2_2_HDMI_RXSTATUS_LEN];
+	int ret;
+
+	ret = intel_hdmi_hdcp2_read_rx_status(intel_dig_port, rx_status);
+	if (ret)
+		return ret;
+
+	/*
+	 * Re-auth request and Link Integrity Failures are represented by
+	 * same bit. i.e reauth_req.
+	 */
+	if (HDCP_2_2_HDMI_RXSTATUS_REAUTH_REQ(rx_status[1]))
+		ret = DRM_HDCP_REAUTH_REQUEST;
+	else if (HDCP_2_2_HDMI_RXSTATUS_READY(rx_status[1]))
+		ret = DRM_HDCP_TOPOLOGY_CHANGE;
+
+	return ret;
+}
+
+static
+int intel_hdmi_hdcp2_capable(struct intel_digital_port *intel_dig_port,
+			     bool *capable)
+{
+	u8 hdcp2_version;
+	int ret;
+
+	*capable = false;
+	ret = intel_hdmi_hdcp_read(intel_dig_port, HDCP_2_2_HDMI_REG_VER_OFFSET,
+				   &hdcp2_version, sizeof(hdcp2_version));
+	if (!ret && hdcp2_version & HDCP_2_2_HDMI_SUPPORT_MASK)
+		*capable = true;
+
+	return ret;
+}
+
+static inline
+enum mei_hdcp_wired_protocol intel_hdmi_hdcp2_protocol(void)
+{
+	return MEI_HDCP_PROTOCOL_HDMI;
+}
+
 static const struct intel_hdcp_shim intel_hdmi_hdcp_shim = {
 	.write_an_aksv = intel_hdmi_hdcp_write_an_aksv,
 	.read_bksv = intel_hdmi_hdcp_read_bksv,
@@ -1128,6 +1313,11 @@ static const struct intel_hdcp_shim intel_hdmi_hdcp_shim = {
 	.read_v_prime_part = intel_hdmi_hdcp_read_v_prime_part,
 	.toggle_signalling = intel_hdmi_hdcp_toggle_signalling,
 	.check_link = intel_hdmi_hdcp_check_link,
+	.write_2_2_msg = intel_hdmi_hdcp2_write_msg,
+	.read_2_2_msg = intel_hdmi_hdcp2_read_msg,
+	.check_2_2_link	= intel_hdmi_hdcp2_check_link,
+	.hdcp_2_2_capable = intel_hdmi_hdcp2_capable,
+	.hdcp_protocol = intel_hdmi_hdcp2_protocol,
 };
 
 static void intel_hdmi_prepare(struct intel_encoder *encoder,
Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#50 lore raw

Re: [PATCH v8 13/35] drm/i915: Implement the HDCP2.2 support for HDMI

Quoted 128 lines · Ramalingam C

Implements the HDMI adaptation specific HDCP2.2 operations.

Basically these are DDC read and write for authenticating through HDCP2.2 messages.

v2:
Rebased.
v3:
No Changes.
v4:
No more special handling of Gmbus burst read for AKE_SEND_CERT. Style fixed with few naming. [Uma]
%s/PARING/PAIRING
v5:
msg_sz is initialized at definition.
Lookup table is defined for HDMI HDCP2.2 msgs [Daniel].
v6:
Rebased.
v7:
Make a function as inline [Uma]
%s/uintxx_t/uxx
v8:
Errors due to sinks are reported as DEBUG logs. Adjust to the new mei interface.

---
 drivers/gpu/drm/i915/intel_hdmi.c | 190 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 190 insertions(+)
drivers/gpu/drm/i915/intel_hdmi.c +82 -0
index e755a3370bca..912f50133645 100644
@@ -30,6 +30,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/hdmi.h>
+#include <linux/mei_hdcp.h>
 #include <drm/drmP.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc.h>
@@ -1117,6 +1118,190 @@ bool intel_hdmi_hdcp_check_link(struct intel_digital_port *intel_dig_port)
 	return true;
 }
 
+static struct hdcp2_hdmi_msg_data {
+	u8 msg_id;
+	u32 timeout;
+	u32 timeout2;
+	} hdcp2_msg_data[] = {
+		{HDCP_2_2_AKE_INIT, 0, 0},
+		{HDCP_2_2_AKE_SEND_CERT, HDCP_2_2_CERT_TIMEOUT_MS, 0},
+		{HDCP_2_2_AKE_NO_STORED_KM, 0, 0},
+		{HDCP_2_2_AKE_STORED_KM, 0, 0},
+		{HDCP_2_2_AKE_SEND_HPRIME, HDCP_2_2_HPRIME_PAIRED_TIMEOUT_MS,
+				HDCP_2_2_HPRIME_NO_PAIRED_TIMEOUT_MS},
+		{HDCP_2_2_AKE_SEND_PAIRING_INFO, HDCP_2_2_PAIRING_TIMEOUT_MS,
+				0},
+		{HDCP_2_2_LC_INIT, 0, 0},
+		{HDCP_2_2_LC_SEND_LPRIME, HDCP_2_2_HDMI_LPRIME_TIMEOUT_MS, 0},
+		{HDCP_2_2_SKE_SEND_EKS, 0, 0},
+		{HDCP_2_2_REP_SEND_RECVID_LIST,
+				HDCP_2_2_RECVID_LIST_TIMEOUT_MS, 0},
+		{HDCP_2_2_REP_SEND_ACK, 0, 0},
+		{HDCP_2_2_REP_STREAM_MANAGE, 0, 0},
+		{HDCP_2_2_REP_STREAM_READY, HDCP_2_2_STREAM_READY_TIMEOUT_MS,
+				0},
+	};
+
+static
+int intel_hdmi_hdcp2_read_rx_status(struct intel_digital_port *intel_dig_port,
+				    uint8_t *rx_status)
+{
+	return intel_hdmi_hdcp_read(intel_dig_port,
+				    HDCP_2_2_HDMI_REG_RXSTATUS_OFFSET,
+				    rx_status,
+				    HDCP_2_2_HDMI_RXSTATUS_LEN);
+}
+
+static int get_hdcp2_msg_timeout(u8 msg_id, bool is_paired)
+{
+	int i;
+
+	for (i = 0; i < sizeof(hdcp2_msg_data); i++)
+		if (hdcp2_msg_data[i].msg_id == msg_id &&
+		    (msg_id != HDCP_2_2_AKE_SEND_HPRIME || is_paired))
+			return hdcp2_msg_data[i].timeout;
+		else if (hdcp2_msg_data[i].msg_id == msg_id)
+			return hdcp2_msg_data[i].timeout2;
+
+	return -EINVAL;
+}
+
+static inline
+int hdcp2_detect_msg_availability(struct intel_digital_port *intel_digital_port,
+				  u8 msg_id, bool *msg_ready,
+				  ssize_t *msg_sz)
+{
+	u8 rx_status[HDCP_2_2_HDMI_RXSTATUS_LEN];
+	int ret;
+
+	ret = intel_hdmi_hdcp2_read_rx_status(intel_digital_port, rx_status);
+	if (ret < 0) {
+		DRM_DEBUG_KMS("rx_status read failed. Err %d\n", ret);
+		return ret;
+	}
+
+	*msg_sz = ((HDCP_2_2_HDMI_RXSTATUS_MSG_SZ_HI(rx_status[1]) << 8) |
+		  rx_status[0]);
+
+	if (msg_id == HDCP_2_2_REP_SEND_RECVID_LIST)
+		*msg_ready = (HDCP_2_2_HDMI_RXSTATUS_READY(rx_status[1]) &&
+			     *msg_sz);
+	else
+		*msg_ready = *msg_sz;
+
+	return 0;
+}
+
+static ssize_t
+intel_hdmi_hdcp2_wait_for_msg(struct intel_digital_port *intel_dig_port,
+			      u8 msg_id, bool paired)
+{
+	bool msg_ready = false;
+	int timeout, ret;
+	ssize_t msg_sz = 0;

drivers/gpu/drm/i915/intel_hdmi.c bool intel_hdmi_hdcp_check_link(struct intel_digital_port *intel_dig_port) · line 1211

Quoted 10 lines
drivers/gpu/drm/i915/intel_hdmi.c +10 -0
+
+	timeout = get_hdcp2_msg_timeout(msg_id, paired);
+	if (timeout < 0)
+		return timeout;
+
+	ret = __wait_for(ret = hdcp2_detect_msg_availability(intel_dig_port,
+							     msg_id, &msg_ready,
+							     &msg_sz),
+			 !ret && msg_ready && msg_sz, timeout * 1000,
+			 1000, 5 * 1000);

Yeah, doing this also for DP is imo much simpler.

lgtm.
-Daniel

Quoted 111 lines
drivers/gpu/drm/i915/intel_hdmi.c +98 -0
+	if (ret)
+		DRM_DEBUG_KMS("msg_id: %d, ret: %d, timeout: %d\n",
+			      msg_id, ret, timeout);
+
+	return ret ? ret : msg_sz;
+}
+
+static
+int intel_hdmi_hdcp2_write_msg(struct intel_digital_port *intel_dig_port,
+			       void *buf, size_t size)
+{
+	unsigned int offset;
+
+	offset = HDCP_2_2_HDMI_REG_WR_MSG_OFFSET;
+	return intel_hdmi_hdcp_write(intel_dig_port, offset, buf, size);
+}
+
+static
+int intel_hdmi_hdcp2_read_msg(struct intel_digital_port *intel_dig_port,
+			      u8 msg_id, void *buf, size_t size)
+{
+	struct intel_hdmi *hdmi = &intel_dig_port->hdmi;
+	struct intel_hdcp *hdcp = &hdmi->attached_connector->hdcp;
+	unsigned int offset;
+	ssize_t ret;
+
+	ret = intel_hdmi_hdcp2_wait_for_msg(intel_dig_port, msg_id,
+					    hdcp->is_paired);
+	if (ret < 0)
+		return ret;
+
+	/*
+	 * Available msg size should be equal to or lesser than the
+	 * available buffer.
+	 */
+	if (ret > size) {
+		DRM_DEBUG_KMS("msg_sz(%zd) is more than exp size(%zu)\n",
+			      ret, size);
+		return -1;
+	}
+
+	offset = HDCP_2_2_HDMI_REG_RD_MSG_OFFSET;
+	ret = intel_hdmi_hdcp_read(intel_dig_port, offset, buf, ret);
+	if (ret)
+		DRM_DEBUG_KMS("Failed to read msg_id: %d(%zd)\n", msg_id, ret);
+
+	return ret;
+}
+
+static
+int intel_hdmi_hdcp2_check_link(struct intel_digital_port *intel_dig_port)
+{
+	u8 rx_status[HDCP_2_2_HDMI_RXSTATUS_LEN];
+	int ret;
+
+	ret = intel_hdmi_hdcp2_read_rx_status(intel_dig_port, rx_status);
+	if (ret)
+		return ret;
+
+	/*
+	 * Re-auth request and Link Integrity Failures are represented by
+	 * same bit. i.e reauth_req.
+	 */
+	if (HDCP_2_2_HDMI_RXSTATUS_REAUTH_REQ(rx_status[1]))
+		ret = DRM_HDCP_REAUTH_REQUEST;
+	else if (HDCP_2_2_HDMI_RXSTATUS_READY(rx_status[1]))
+		ret = DRM_HDCP_TOPOLOGY_CHANGE;
+
+	return ret;
+}
+
+static
+int intel_hdmi_hdcp2_capable(struct intel_digital_port *intel_dig_port,
+			     bool *capable)
+{
+	u8 hdcp2_version;
+	int ret;
+
+	*capable = false;
+	ret = intel_hdmi_hdcp_read(intel_dig_port, HDCP_2_2_HDMI_REG_VER_OFFSET,
+				   &hdcp2_version, sizeof(hdcp2_version));
+	if (!ret && hdcp2_version & HDCP_2_2_HDMI_SUPPORT_MASK)
+		*capable = true;
+
+	return ret;
+}
+
+static inline
+enum mei_hdcp_wired_protocol intel_hdmi_hdcp2_protocol(void)
+{
+	return MEI_HDCP_PROTOCOL_HDMI;
+}
+
 static const struct intel_hdcp_shim intel_hdmi_hdcp_shim = {
 	.write_an_aksv = intel_hdmi_hdcp_write_an_aksv,
 	.read_bksv = intel_hdmi_hdcp_read_bksv,
@@ -1128,6 +1313,11 @@ static const struct intel_hdcp_shim intel_hdmi_hdcp_shim = {
 	.read_v_prime_part = intel_hdmi_hdcp_read_v_prime_part,
 	.toggle_signalling = intel_hdmi_hdcp_toggle_signalling,
 	.check_link = intel_hdmi_hdcp_check_link,
+	.write_2_2_msg = intel_hdmi_hdcp2_write_msg,
+	.read_2_2_msg = intel_hdmi_hdcp2_read_msg,
+	.check_2_2_link	= intel_hdmi_hdcp2_check_link,
+	.hdcp_2_2_capable = intel_hdmi_hdcp2_capable,
+	.hdcp_protocol = intel_hdmi_hdcp2_protocol,
 };
 
 static void intel_hdmi_prepare(struct intel_encoder *encoder,
Signature · 1 line
2.7.4
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#51 lore raw

PATCH v8 14/35 drm/i915: Add HDCP2.2 support for DP connectors

In reply to Ramalingam C

On DP connector init, intel_hdcp_init is passed with a flag for hdcp2.2 support based on the platform capability.

v2:
Rebased.
v3:
No Changes.
v4:
Collected the reviewed-by received.
v5:
No change.
v6:
No change.
v7:
No change.
v8:
No change.

---
 drivers/gpu/drm/i915/intel_dp.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_dp.c +1 -1
index 1cc82e490999..b907ce28adbd 100644
@@ -7014,7 +7014,7 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
 
 	if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
 		int ret = intel_hdcp_init(intel_connector, &intel_dp_hdcp_shim,
-					  false);
+					  is_hdcp2_supported(dev_priv));
 		if (ret)
 			DRM_DEBUG_KMS("HDCP init failed, skipping.\n");
 	}
Signature · 6 lines
2.7.4

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel