mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-10-02 15:18:19 +00:00
Code Issues Releases Wiki Activity

drm/i915/hdcp: Use generic names for HDCP helpers and structs

Browse source 
pre MTL we interact with mei interface to talk to
firmware and enable CP but going forward we will talk to gsc cs
because of which we are making all names for HDCP helpers and
structures generic as either mei or gsc cs maybe used.

Change the include/drm/i915_mei_hdcp_interface.h to
include/drm/i915_hdcp_interface.h

Change the i915_hdcp_interface.h header naming convention to
suit generic f/w type.
%s/MEI_/HDCP_
%s/mei_dev/hdcp_dev

Change structure name Accordingly.
%s/i915_hdcp_comp_master/i915_hdcp_master
%s/i915_hdcp_component_ops/i915_hdcp_ops

--v6
-make each patch build individually [Jani]

--v8
-change ME FW to ME/GSC FW [Ankit]
-fix formatting issue [Ankit]

--v9
-fix commit message and header [Uma]

--v10
-rename comp variable [Uma]

Cc: Tomas Winkler <tomas.winkler@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Uma Shankar <uma.shankar@intel.com>
Cc: Ankit Nautiyal <ankit.k.nautiyal@intel.com>
Signed-off-by: Anshuman Gupta <anshuman.gupta@intel.com>
Signed-off-by: Suraj Kandpal <suraj.kandpal@intel.com>
Reviewed-by: Ankit Nautiyal <ankit.k.nautiyal@intel.com>
Reviewed-by: Uma Shankar <uma.shankar@intel.com>
Acked-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Uma Shankar <uma.shankar@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20230316092927.668980-3-suraj.kandpal@intel.com
This commit is contained in:
Anshuman Gupta 2023-03-16 14:59:23 +05:30 committed by Uma Shankar
parent 459b26061a
commit 4f73dc7a07
5 changed files with 144 additions and 145 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/gpu/drm/i915/display/intel_display_core.h
View file

@ -395,7 +395,7 @@ struct intel_display {
} gmbus; } gmbus;
struct { struct {
struct i915_hdcp_comp_master *master; struct i915_hdcp_master *master;
bool comp_added; bool comp_added;
/* Mutex to protect the above hdcp component related values. */ /* Mutex to protect the above hdcp component related values. */

2
drivers/gpu/drm/i915/display/intel_display_types.h
View file

@ -43,7 +43,7 @@
#include <drm/drm_rect.h> #include <drm/drm_rect.h>
#include <drm/drm_vblank.h> #include <drm/drm_vblank.h>
#include <drm/drm_vblank_work.h> #include <drm/drm_vblank_work.h>
#include <drm/i915_mei_hdcp_interface.h> #include <drm/i915_hdcp_interface.h>
#include <media/cec-notifier.h> #include <media/cec-notifier.h>
#include "i915_vma.h" #include "i915_vma.h"

130
drivers/gpu/drm/i915/display/intel_hdcp.c
View file

@ -1142,18 +1142,18 @@ hdcp2_prepare_ake_init(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->initiate_hdcp2_session(comp->mei_dev, data, ake_data); ret = arbiter->ops->initiate_hdcp2_session(arbiter->hdcp_dev, data, ake_data);
if (ret) if (ret)
drm_dbg_kms(&dev_priv->drm, "Prepare_ake_init failed. %d\n", drm_dbg_kms(&dev_priv->drm, "Prepare_ake_init failed. %d\n",
ret); ret);
@ -1172,18 +1172,18 @@ hdcp2_verify_rx_cert_prepare_km(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->verify_receiver_cert_prepare_km(comp->mei_dev, data, ret = arbiter->ops->verify_receiver_cert_prepare_km(arbiter->hdcp_dev, data,
rx_cert, paired, rx_cert, paired,
ek_pub_km, msg_sz); ek_pub_km, msg_sz);
if (ret < 0) if (ret < 0)
@ -1200,18 +1200,18 @@ static int hdcp2_verify_hprime(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->verify_hprime(comp->mei_dev, data, rx_hprime); ret = arbiter->ops->verify_hprime(arbiter->hdcp_dev, data, rx_hprime);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, "Verify hprime failed. %d\n", ret); drm_dbg_kms(&dev_priv->drm, "Verify hprime failed. %d\n", ret);
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
@ -1226,18 +1226,18 @@ hdcp2_store_pairing_info(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->store_pairing_info(comp->mei_dev, data, pairing_info); ret = arbiter->ops->store_pairing_info(arbiter->hdcp_dev, data, pairing_info);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, "Store pairing info failed. %d\n", drm_dbg_kms(&dev_priv->drm, "Store pairing info failed. %d\n",
ret); ret);
@ -1253,18 +1253,18 @@ hdcp2_prepare_lc_init(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->initiate_locality_check(comp->mei_dev, data, lc_init); ret = arbiter->ops->initiate_locality_check(arbiter->hdcp_dev, data, lc_init);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, "Prepare lc_init failed. %d\n", drm_dbg_kms(&dev_priv->drm, "Prepare lc_init failed. %d\n",
ret); ret);
@ -1280,18 +1280,18 @@ hdcp2_verify_lprime(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->verify_lprime(comp->mei_dev, data, rx_lprime); ret = arbiter->ops->verify_lprime(arbiter->hdcp_dev, data, rx_lprime);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, "Verify L_Prime failed. %d\n", drm_dbg_kms(&dev_priv->drm, "Verify L_Prime failed. %d\n",
ret); ret);
@ -1306,18 +1306,18 @@ static int hdcp2_prepare_skey(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->get_session_key(comp->mei_dev, data, ske_data); ret = arbiter->ops->get_session_key(arbiter->hdcp_dev, data, ske_data);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, "Get session key failed. %d\n", drm_dbg_kms(&dev_priv->drm, "Get session key failed. %d\n",
ret); ret);
@ -1335,20 +1335,21 @@ hdcp2_verify_rep_topology_prepare_ack(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->repeater_check_flow_prepare_ack(comp->mei_dev, data, ret = arbiter->ops->repeater_check_flow_prepare_ack(arbiter->hdcp_dev,
rep_topology, data,
rep_send_ack); rep_topology,
rep_send_ack);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, drm_dbg_kms(&dev_priv->drm,
"Verify rep topology failed. %d\n", ret); "Verify rep topology failed. %d\n", ret);
@ -1364,18 +1365,18 @@ hdcp2_verify_mprime(struct intel_connector *connector,
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->verify_mprime(comp->mei_dev, data, stream_ready); ret = arbiter->ops->verify_mprime(arbiter->hdcp_dev, data, stream_ready);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, "Verify mprime failed. %d\n", ret); drm_dbg_kms(&dev_priv->drm, "Verify mprime failed. %d\n", ret);
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
@ -1388,18 +1389,18 @@ static int hdcp2_authenticate_port(struct intel_connector *connector)
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct hdcp_port_data *data = &dig_port->hdcp_port_data; struct hdcp_port_data *data = &dig_port->hdcp_port_data;
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->enable_hdcp_authentication(comp->mei_dev, data); ret = arbiter->ops->enable_hdcp_authentication(arbiter->hdcp_dev, data);
if (ret < 0) if (ret < 0)
drm_dbg_kms(&dev_priv->drm, "Enable hdcp auth failed. %d\n", drm_dbg_kms(&dev_priv->drm, "Enable hdcp auth failed. %d\n",
ret); ret);
@ -1412,18 +1413,18 @@ static int hdcp2_close_mei_session(struct intel_connector *connector)
{ {
struct intel_digital_port *dig_port = intel_attached_dig_port(connector); struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
struct i915_hdcp_comp_master *comp; struct i915_hdcp_master *arbiter;
int ret; int ret;
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
comp = dev_priv->display.hdcp.master; arbiter = dev_priv->display.hdcp.master;
if (!comp || !comp->ops) { if (!arbiter || !arbiter->ops) {
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return -EINVAL; return -EINVAL;
} }
ret = comp->ops->close_hdcp_session(comp->mei_dev, ret = arbiter->ops->close_hdcp_session(arbiter->hdcp_dev,
&dig_port->hdcp_port_data); &dig_port->hdcp_port_data);
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
@ -2142,8 +2143,8 @@ static int i915_hdcp_component_bind(struct device *i915_kdev,
drm_dbg(&dev_priv->drm, "I915 HDCP comp bind\n"); drm_dbg(&dev_priv->drm, "I915 HDCP comp bind\n");
mutex_lock(&dev_priv->display.hdcp.comp_mutex); mutex_lock(&dev_priv->display.hdcp.comp_mutex);
dev_priv->display.hdcp.master = (struct i915_hdcp_comp_master *)data; dev_priv->display.hdcp.master = (struct i915_hdcp_master *)data;
dev_priv->display.hdcp.master->mei_dev = mei_kdev; dev_priv->display.hdcp.master->hdcp_dev = mei_kdev;
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
return 0; return 0;
@ -2160,30 +2161,30 @@ static void i915_hdcp_component_unbind(struct device *i915_kdev,
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
} }
static const struct component_ops i915_hdcp_component_ops = { static const struct component_ops i915_hdcp_ops = {
.bind = i915_hdcp_component_bind, .bind = i915_hdcp_component_bind,
.unbind = i915_hdcp_component_unbind, .unbind = i915_hdcp_component_unbind,
}; };
static enum mei_fw_ddi intel_get_mei_fw_ddi_index(enum port port) static enum hdcp_ddi intel_get_hdcp_ddi_index(enum port port)
{ {
switch (port) { switch (port) {
case PORT_A: case PORT_A:
return MEI_DDI_A; return HDCP_DDI_A;
case PORT_B ... PORT_F: case PORT_B ... PORT_F:
return (enum mei_fw_ddi)port; return (enum hdcp_ddi)port;
default: default:
return MEI_DDI_INVALID_PORT; return HDCP_DDI_INVALID_PORT;
} }
} }
static enum mei_fw_tc intel_get_mei_fw_tc(enum transcoder cpu_transcoder) static enum hdcp_transcoder intel_get_hdcp_transcoder(enum transcoder cpu_transcoder)
{ {
switch (cpu_transcoder) { switch (cpu_transcoder) {
case TRANSCODER_A ... TRANSCODER_D: case TRANSCODER_A ... TRANSCODER_D:
return (enum mei_fw_tc)(cpu_transcoder | 0x10); return (enum hdcp_transcoder)(cpu_transcoder | 0x10);
default: /* eDP, DSI TRANSCODERS are non HDCP capable */ default: /* eDP, DSI TRANSCODERS are non HDCP capable */
return MEI_INVALID_TRANSCODER; return HDCP_INVALID_TRANSCODER;
} }
} }
@ -2197,20 +2198,20 @@ static int initialize_hdcp_port_data(struct intel_connector *connector,
enum port port = dig_port->base.port; enum port port = dig_port->base.port;
if (DISPLAY_VER(dev_priv) < 12) if (DISPLAY_VER(dev_priv) < 12)
data->fw_ddi = intel_get_mei_fw_ddi_index(port); data->hdcp_ddi = intel_get_hdcp_ddi_index(port);
else else
/* /*
* As per ME FW API expectation, for GEN 12+, fw_ddi is filled * As per ME FW API expectation, for GEN 12+, hdcp_ddi is filled
* with zero(INVALID PORT index). * with zero(INVALID PORT index).
*/ */
data->fw_ddi = MEI_DDI_INVALID_PORT; data->hdcp_ddi = HDCP_DDI_INVALID_PORT;
/* /*
* As associated transcoder is set and modified at modeset, here fw_tc * As associated transcoder is set and modified at modeset, here hdcp_transcoder
* is initialized to zero (invalid transcoder index). This will be * is initialized to zero (invalid transcoder index). This will be
* retained for <Gen12 forever. * retained for <Gen12 forever.
*/ */
data->fw_tc = MEI_INVALID_TRANSCODER; data->hdcp_transcoder = HDCP_INVALID_TRANSCODER;
data->port_type = (u8)HDCP_PORT_TYPE_INTEGRATED; data->port_type = (u8)HDCP_PORT_TYPE_INTEGRATED;
data->protocol = (u8)shim->protocol; data->protocol = (u8)shim->protocol;
@ -2253,7 +2254,7 @@ void intel_hdcp_component_init(struct drm_i915_private *dev_priv)
dev_priv->display.hdcp.comp_added = true; dev_priv->display.hdcp.comp_added = true;
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
ret = component_add_typed(dev_priv->drm.dev, &i915_hdcp_component_ops, ret = component_add_typed(dev_priv->drm.dev, &i915_hdcp_ops,
I915_COMPONENT_HDCP); I915_COMPONENT_HDCP);
if (ret < 0) { if (ret < 0) {
drm_dbg_kms(&dev_priv->drm, "Failed at component add(%d)\n", drm_dbg_kms(&dev_priv->drm, "Failed at component add(%d)\n",
@ -2347,7 +2348,8 @@ int intel_hdcp_enable(struct intel_connector *connector,
} }
if (DISPLAY_VER(dev_priv) >= 12) if (DISPLAY_VER(dev_priv) >= 12)
dig_port->hdcp_port_data.fw_tc = intel_get_mei_fw_tc(hdcp->cpu_transcoder); dig_port->hdcp_port_data.hdcp_transcoder =
intel_get_hdcp_transcoder(hdcp->cpu_transcoder);
/* /*
* Considering that HDCP2.2 is more secure than HDCP1.4, If the setup * Considering that HDCP2.2 is more secure than HDCP1.4, If the setup
@ -2482,7 +2484,7 @@ void intel_hdcp_component_fini(struct drm_i915_private *dev_priv)
dev_priv->display.hdcp.comp_added = false; dev_priv->display.hdcp.comp_added = false;
mutex_unlock(&dev_priv->display.hdcp.comp_mutex); mutex_unlock(&dev_priv->display.hdcp.comp_mutex);
component_del(dev_priv->drm.dev, &i915_hdcp_component_ops); component_del(dev_priv->drm.dev, &i915_hdcp_ops);
} }
void intel_hdcp_cleanup(struct intel_connector *connector) void intel_hdcp_cleanup(struct intel_connector *connector)

61
drivers/misc/mei/hdcp/mei_hdcp.c
View file

@ -23,7 +23,7 @@
#include <linux/component.h> #include <linux/component.h>
#include <drm/drm_connector.h> #include <drm/drm_connector.h>
#include <drm/i915_component.h> #include <drm/i915_component.h>
#include <drm/i915_mei_hdcp_interface.h> #include <drm/i915_hdcp_interface.h>
#include "mei_hdcp.h" #include "mei_hdcp.h"
@ -57,8 +57,8 @@ mei_hdcp_initiate_session(struct device *dev, struct hdcp_port_data *data,
WIRED_CMD_BUF_LEN_INITIATE_HDCP2_SESSION_IN; WIRED_CMD_BUF_LEN_INITIATE_HDCP2_SESSION_IN;
session_init_in.port.integrated_port_type = data->port_type; session_init_in.port.integrated_port_type = data->port_type;
session_init_in.port.physical_port = (u8)data->fw_ddi; session_init_in.port.physical_port = (u8)data->hdcp_ddi;
session_init_in.port.attached_transcoder = (u8)data->fw_tc; session_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
session_init_in.protocol = data->protocol; session_init_in.protocol = data->protocol;
byte = mei_cldev_send(cldev, (u8 *)&session_init_in, byte = mei_cldev_send(cldev, (u8 *)&session_init_in,
@ -127,8 +127,8 @@ mei_hdcp_verify_receiver_cert_prepare_km(struct device *dev,
WIRED_CMD_BUF_LEN_VERIFY_RECEIVER_CERT_IN; WIRED_CMD_BUF_LEN_VERIFY_RECEIVER_CERT_IN;
verify_rxcert_in.port.integrated_port_type = data->port_type; verify_rxcert_in.port.integrated_port_type = data->port_type;
verify_rxcert_in.port.physical_port = (u8)data->fw_ddi; verify_rxcert_in.port.physical_port = (u8)data->hdcp_ddi;
verify_rxcert_in.port.attached_transcoder = (u8)data->fw_tc; verify_rxcert_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
verify_rxcert_in.cert_rx = rx_cert->cert_rx; verify_rxcert_in.cert_rx = rx_cert->cert_rx;
memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, HDCP_2_2_RRX_LEN); memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, HDCP_2_2_RRX_LEN);
@ -198,8 +198,8 @@ mei_hdcp_verify_hprime(struct device *dev, struct hdcp_port_data *data,
send_hprime_in.header.buffer_len = WIRED_CMD_BUF_LEN_AKE_SEND_HPRIME_IN; send_hprime_in.header.buffer_len = WIRED_CMD_BUF_LEN_AKE_SEND_HPRIME_IN;
send_hprime_in.port.integrated_port_type = data->port_type; send_hprime_in.port.integrated_port_type = data->port_type;
send_hprime_in.port.physical_port = (u8)data->fw_ddi; send_hprime_in.port.physical_port = (u8)data->hdcp_ddi;
send_hprime_in.port.attached_transcoder = (u8)data->fw_tc; send_hprime_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
memcpy(send_hprime_in.h_prime, rx_hprime->h_prime, memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,
HDCP_2_2_H_PRIME_LEN); HDCP_2_2_H_PRIME_LEN);
@ -256,8 +256,8 @@ mei_hdcp_store_pairing_info(struct device *dev, struct hdcp_port_data *data,
WIRED_CMD_BUF_LEN_SEND_PAIRING_INFO_IN; WIRED_CMD_BUF_LEN_SEND_PAIRING_INFO_IN;
pairing_info_in.port.integrated_port_type = data->port_type; pairing_info_in.port.integrated_port_type = data->port_type;
pairing_info_in.port.physical_port = (u8)data->fw_ddi; pairing_info_in.port.physical_port = (u8)data->hdcp_ddi;
pairing_info_in.port.attached_transcoder = (u8)data->fw_tc; pairing_info_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
memcpy(pairing_info_in.e_kh_km, pairing_info->e_kh_km, memcpy(pairing_info_in.e_kh_km, pairing_info->e_kh_km,
HDCP_2_2_E_KH_KM_LEN); HDCP_2_2_E_KH_KM_LEN);
@ -315,8 +315,8 @@ mei_hdcp_initiate_locality_check(struct device *dev,
lc_init_in.header.buffer_len = WIRED_CMD_BUF_LEN_INIT_LOCALITY_CHECK_IN; lc_init_in.header.buffer_len = WIRED_CMD_BUF_LEN_INIT_LOCALITY_CHECK_IN;
lc_init_in.port.integrated_port_type = data->port_type; lc_init_in.port.integrated_port_type = data->port_type;
lc_init_in.port.physical_port = (u8)data->fw_ddi; lc_init_in.port.physical_port = (u8)data->hdcp_ddi;
lc_init_in.port.attached_transcoder = (u8)data->fw_tc; lc_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
byte = mei_cldev_send(cldev, (u8 *)&lc_init_in, sizeof(lc_init_in)); byte = mei_cldev_send(cldev, (u8 *)&lc_init_in, sizeof(lc_init_in));
if (byte < 0) { if (byte < 0) {
@ -371,8 +371,8 @@ mei_hdcp_verify_lprime(struct device *dev, struct hdcp_port_data *data,
WIRED_CMD_BUF_LEN_VALIDATE_LOCALITY_IN; WIRED_CMD_BUF_LEN_VALIDATE_LOCALITY_IN;
verify_lprime_in.port.integrated_port_type = data->port_type; verify_lprime_in.port.integrated_port_type = data->port_type;
verify_lprime_in.port.physical_port = (u8)data->fw_ddi; verify_lprime_in.port.physical_port = (u8)data->hdcp_ddi;
verify_lprime_in.port.attached_transcoder = (u8)data->fw_tc; verify_lprime_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
memcpy(verify_lprime_in.l_prime, rx_lprime->l_prime, memcpy(verify_lprime_in.l_prime, rx_lprime->l_prime,
HDCP_2_2_L_PRIME_LEN); HDCP_2_2_L_PRIME_LEN);
@ -429,8 +429,8 @@ static int mei_hdcp_get_session_key(struct device *dev,
get_skey_in.header.buffer_len = WIRED_CMD_BUF_LEN_GET_SESSION_KEY_IN; get_skey_in.header.buffer_len = WIRED_CMD_BUF_LEN_GET_SESSION_KEY_IN;
get_skey_in.port.integrated_port_type = data->port_type; get_skey_in.port.integrated_port_type = data->port_type;
get_skey_in.port.physical_port = (u8)data->fw_ddi; get_skey_in.port.physical_port = (u8)data->hdcp_ddi;
get_skey_in.port.attached_transcoder = (u8)data->fw_tc; get_skey_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
byte = mei_cldev_send(cldev, (u8 *)&get_skey_in, sizeof(get_skey_in)); byte = mei_cldev_send(cldev, (u8 *)&get_skey_in, sizeof(get_skey_in));
if (byte < 0) { if (byte < 0) {
@ -494,8 +494,8 @@ mei_hdcp_repeater_check_flow_prepare_ack(struct device *dev,
WIRED_CMD_BUF_LEN_VERIFY_REPEATER_IN; WIRED_CMD_BUF_LEN_VERIFY_REPEATER_IN;
verify_repeater_in.port.integrated_port_type = data->port_type; verify_repeater_in.port.integrated_port_type = data->port_type;
verify_repeater_in.port.physical_port = (u8)data->fw_ddi; verify_repeater_in.port.physical_port = (u8)data->hdcp_ddi;
verify_repeater_in.port.attached_transcoder = (u8)data->fw_tc; verify_repeater_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
memcpy(verify_repeater_in.rx_info, rep_topology->rx_info, memcpy(verify_repeater_in.rx_info, rep_topology->rx_info,
HDCP_2_2_RXINFO_LEN); HDCP_2_2_RXINFO_LEN);
@ -572,8 +572,8 @@ static int mei_hdcp_verify_mprime(struct device *dev,
verify_mprime_in->header.buffer_len = cmd_size - sizeof(verify_mprime_in->header); verify_mprime_in->header.buffer_len = cmd_size - sizeof(verify_mprime_in->header);
verify_mprime_in->port.integrated_port_type = data->port_type; verify_mprime_in->port.integrated_port_type = data->port_type;
verify_mprime_in->port.physical_port = (u8)data->fw_ddi; verify_mprime_in->port.physical_port = (u8)data->hdcp_ddi;
verify_mprime_in->port.attached_transcoder = (u8)data->fw_tc; verify_mprime_in->port.attached_transcoder = (u8)data->hdcp_transcoder;
memcpy(verify_mprime_in->m_prime, stream_ready->m_prime, HDCP_2_2_MPRIME_LEN); memcpy(verify_mprime_in->m_prime, stream_ready->m_prime, HDCP_2_2_MPRIME_LEN);
drm_hdcp_cpu_to_be24(verify_mprime_in->seq_num_m, data->seq_num_m); drm_hdcp_cpu_to_be24(verify_mprime_in->seq_num_m, data->seq_num_m);
@ -634,8 +634,8 @@ static int mei_hdcp_enable_authentication(struct device *dev,
enable_auth_in.header.buffer_len = WIRED_CMD_BUF_LEN_ENABLE_AUTH_IN; enable_auth_in.header.buffer_len = WIRED_CMD_BUF_LEN_ENABLE_AUTH_IN;
enable_auth_in.port.integrated_port_type = data->port_type; enable_auth_in.port.integrated_port_type = data->port_type;
enable_auth_in.port.physical_port = (u8)data->fw_ddi; enable_auth_in.port.physical_port = (u8)data->hdcp_ddi;
enable_auth_in.port.attached_transcoder = (u8)data->fw_tc; enable_auth_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
enable_auth_in.stream_type = data->streams[0].stream_type; enable_auth_in.stream_type = data->streams[0].stream_type;
byte = mei_cldev_send(cldev, (u8 *)&enable_auth_in, byte = mei_cldev_send(cldev, (u8 *)&enable_auth_in,
@ -689,8 +689,8 @@ mei_hdcp_close_session(struct device *dev, struct hdcp_port_data *data)
WIRED_CMD_BUF_LEN_CLOSE_SESSION_IN; WIRED_CMD_BUF_LEN_CLOSE_SESSION_IN;
session_close_in.port.integrated_port_type = data->port_type; session_close_in.port.integrated_port_type = data->port_type;
session_close_in.port.physical_port = (u8)data->fw_ddi; session_close_in.port.physical_port = (u8)data->hdcp_ddi;
session_close_in.port.attached_transcoder = (u8)data->fw_tc; session_close_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
byte = mei_cldev_send(cldev, (u8 *)&session_close_in, byte = mei_cldev_send(cldev, (u8 *)&session_close_in,
sizeof(session_close_in)); sizeof(session_close_in));
@ -715,7 +715,7 @@ mei_hdcp_close_session(struct device *dev, struct hdcp_port_data *data)
return 0; return 0;
} }
static const struct i915_hdcp_component_ops mei_hdcp_ops = { static const struct i915_hdcp_ops mei_hdcp_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.initiate_hdcp2_session = mei_hdcp_initiate_session, .initiate_hdcp2_session = mei_hdcp_initiate_session,
.verify_receiver_cert_prepare_km = .verify_receiver_cert_prepare_km =
@ -735,13 +735,12 @@ static const struct i915_hdcp_component_ops mei_hdcp_ops = {
static int mei_component_master_bind(struct device *dev) static int mei_component_master_bind(struct device *dev)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_cl_device *cldev = to_mei_cl_device(dev);
struct i915_hdcp_comp_master *comp_master = struct i915_hdcp_master *comp_master = mei_cldev_get_drvdata(cldev);
mei_cldev_get_drvdata(cldev);
int ret; int ret;
dev_dbg(dev, "%s\n", __func__); dev_dbg(dev, "%s\n", __func__);
comp_master->ops = &mei_hdcp_ops; comp_master->ops = &mei_hdcp_ops;
comp_master->mei_dev = dev; comp_master->hdcp_dev = dev;
ret = component_bind_all(dev, comp_master); ret = component_bind_all(dev, comp_master);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -752,8 +751,7 @@ static int mei_component_master_bind(struct device *dev)
static void mei_component_master_unbind(struct device *dev) static void mei_component_master_unbind(struct device *dev)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_cl_device *cldev = to_mei_cl_device(dev);
struct i915_hdcp_comp_master *comp_master = struct i915_hdcp_master *comp_master = mei_cldev_get_drvdata(cldev);
mei_cldev_get_drvdata(cldev);
dev_dbg(dev, "%s\n", __func__); dev_dbg(dev, "%s\n", __func__);
component_unbind_all(dev, comp_master); component_unbind_all(dev, comp_master);
@ -801,7 +799,7 @@ static int mei_hdcp_component_match(struct device *dev, int subcomponent,
static int mei_hdcp_probe(struct mei_cl_device *cldev, static int mei_hdcp_probe(struct mei_cl_device *cldev,
const struct mei_cl_device_id *id) const struct mei_cl_device_id *id)
{ {
struct i915_hdcp_comp_master *comp_master; struct i915_hdcp_master *comp_master;
struct component_match *master_match; struct component_match *master_match;
int ret; int ret;
@ -846,8 +844,7 @@ static int mei_hdcp_probe(struct mei_cl_device *cldev,
static void mei_hdcp_remove(struct mei_cl_device *cldev) static void mei_hdcp_remove(struct mei_cl_device *cldev)
{ {
struct i915_hdcp_comp_master *comp_master = struct i915_hdcp_master *comp_master = mei_cldev_get_drvdata(cldev);
mei_cldev_get_drvdata(cldev);
int ret; int ret;
component_master_del(&cldev->dev, &mei_component_master_ops); component_master_del(&cldev->dev, &mei_component_master_ops);

94
include/drm/i915_mei_hdcp_interface.h → include/drm/i915_hdcp_interface.h
View file

@ -6,15 +6,15 @@
* Ramalingam C <ramalingam.c@intel.com> * Ramalingam C <ramalingam.c@intel.com>
*/ */
#ifndef _I915_MEI_HDCP_INTERFACE_H_ #ifndef _I915_HDCP_INTERFACE_H_
#define _I915_MEI_HDCP_INTERFACE_H_ #define _I915_HDCP_INTERFACE_H_
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/device.h> #include <linux/device.h>
#include <drm/display/drm_hdcp.h> #include <drm/display/drm_hdcp.h>
/** /**
* enum hdcp_port_type - HDCP port implementation type defined by ME FW * enum hdcp_port_type - HDCP port implementation type defined by ME/GSC FW
* @HDCP_PORT_TYPE_INVALID: Invalid hdcp port type * @HDCP_PORT_TYPE_INVALID: Invalid hdcp port type
* @HDCP_PORT_TYPE_INTEGRATED: In-Host HDCP2.x port * @HDCP_PORT_TYPE_INTEGRATED: In-Host HDCP2.x port
* @HDCP_PORT_TYPE_LSPCON: HDCP2.2 discrete wired Tx port with LSPCON * @HDCP_PORT_TYPE_LSPCON: HDCP2.2 discrete wired Tx port with LSPCON
@ -41,46 +41,46 @@ enum hdcp_wired_protocol {
HDCP_PROTOCOL_DP HDCP_PROTOCOL_DP
}; };
enum mei_fw_ddi { enum hdcp_ddi {
MEI_DDI_INVALID_PORT = 0x0, HDCP_DDI_INVALID_PORT = 0x0,
MEI_DDI_B = 1, HDCP_DDI_B = 1,
MEI_DDI_C, HDCP_DDI_C,
MEI_DDI_D, HDCP_DDI_D,
MEI_DDI_E, HDCP_DDI_E,
MEI_DDI_F, HDCP_DDI_F,
MEI_DDI_A = 7, HDCP_DDI_A = 7,
MEI_DDI_RANGE_END = MEI_DDI_A, HDCP_DDI_RANGE_END = HDCP_DDI_A,
}; };
/** /**
* enum mei_fw_tc - ME Firmware defined index for transcoders * enum hdcp_tc - ME/GSC Firmware defined index for transcoders
* @MEI_INVALID_TRANSCODER: Index for Invalid transcoder * @HDCP_INVALID_TRANSCODER: Index for Invalid transcoder
* @MEI_TRANSCODER_EDP: Index for EDP Transcoder * @HDCP_TRANSCODER_EDP: Index for EDP Transcoder
* @MEI_TRANSCODER_DSI0: Index for DSI0 Transcoder * @HDCP_TRANSCODER_DSI0: Index for DSI0 Transcoder
* @MEI_TRANSCODER_DSI1: Index for DSI1 Transcoder * @HDCP_TRANSCODER_DSI1: Index for DSI1 Transcoder
* @MEI_TRANSCODER_A: Index for Transcoder A * @HDCP_TRANSCODER_A: Index for Transcoder A
* @MEI_TRANSCODER_B: Index for Transcoder B * @HDCP_TRANSCODER_B: Index for Transcoder B
* @MEI_TRANSCODER_C: Index for Transcoder C * @HDCP_TRANSCODER_C: Index for Transcoder C
* @MEI_TRANSCODER_D: Index for Transcoder D * @HDCP_TRANSCODER_D: Index for Transcoder D
*/ */
enum mei_fw_tc { enum hdcp_transcoder {
MEI_INVALID_TRANSCODER = 0x00, HDCP_INVALID_TRANSCODER = 0x00,
MEI_TRANSCODER_EDP, HDCP_TRANSCODER_EDP,
MEI_TRANSCODER_DSI0, HDCP_TRANSCODER_DSI0,
MEI_TRANSCODER_DSI1, HDCP_TRANSCODER_DSI1,
MEI_TRANSCODER_A = 0x10, HDCP_TRANSCODER_A = 0x10,
MEI_TRANSCODER_B, HDCP_TRANSCODER_B,
MEI_TRANSCODER_C, HDCP_TRANSCODER_C,
MEI_TRANSCODER_D HDCP_TRANSCODER_D
}; };
/** /**
* struct hdcp_port_data - intel specific HDCP port data * struct hdcp_port_data - intel specific HDCP port data
* @fw_ddi: ddi index as per ME FW * @hdcp_ddi: ddi index as per ME/GSC FW
* @fw_tc: transcoder index as per ME FW * @hdcp_transcoder: transcoder index as per ME/GSC FW
* @port_type: HDCP port type as per ME FW classification * @port_type: HDCP port type as per ME/GSC FW classification
* @protocol: HDCP adaptation as per ME FW * @protocol: HDCP adaptation as per ME/GSC FW
* @k: No of streams transmitted on a port. Only on DP MST this is != 1 * @k: No of streams transmitted on a port. Only on DP MST this is != 1
* @seq_num_m: Count of RepeaterAuth_Stream_Manage msg propagated. * @seq_num_m: Count of RepeaterAuth_Stream_Manage msg propagated.
* Initialized to 0 on AKE_INIT. Incremented after every successful * Initialized to 0 on AKE_INIT. Incremented after every successful
@ -90,8 +90,8 @@ enum mei_fw_tc {
* streams * streams
*/ */
struct hdcp_port_data { struct hdcp_port_data {
enum mei_fw_ddi fw_ddi; enum hdcp_ddi hdcp_ddi;
enum mei_fw_tc fw_tc; enum hdcp_transcoder hdcp_transcoder;
u8 port_type; u8 port_type;
u8 protocol; u8 protocol;
u16 k; u16 k;
@ -100,7 +100,7 @@ struct hdcp_port_data {
}; };
/** /**
* struct i915_hdcp_component_ops- ops for HDCP2.2 services. * struct i915_hdcp_ops- ops for HDCP2.2 services.
* @owner: Module providing the ops * @owner: Module providing the ops
* @initiate_hdcp2_session: Initiate a Wired HDCP2.2 Tx Session. * @initiate_hdcp2_session: Initiate a Wired HDCP2.2 Tx Session.
* And Prepare AKE_Init. * And Prepare AKE_Init.
@ -119,9 +119,9 @@ struct hdcp_port_data {
* @close_hdcp_session: Close the Wired HDCP Tx session per port. * @close_hdcp_session: Close the Wired HDCP Tx session per port.
* This also disables the authenticated state of the port. * This also disables the authenticated state of the port.
*/ */
struct i915_hdcp_component_ops { struct i915_hdcp_ops {
/** /**
* @owner: mei_hdcp module * @owner: hdcp module
*/ */
struct module *owner; struct module *owner;
@ -168,17 +168,17 @@ struct i915_hdcp_component_ops {
}; };
/** /**
* struct i915_hdcp_component_master - Used for communication between i915 * struct i915_hdcp_master - Used for communication between i915
* and mei_hdcp drivers for the HDCP2.2 services * and hdcp drivers for the HDCP2.2 services
* @mei_dev: device that provide the HDCP2.2 service from MEI Bus. * @hdcp_dev: device that provide the HDCP2.2 service from MEI Bus.
* @hdcp_ops: Ops implemented by mei_hdcp driver, used by i915 driver. * @hdcp_ops: Ops implemented by hdcp driver or intel_hdcp_gsc , used by i915 driver.
*/ */
struct i915_hdcp_comp_master { struct i915_hdcp_master {
struct device *mei_dev; struct device *hdcp_dev;
const struct i915_hdcp_component_ops *ops; const struct i915_hdcp_ops *ops;
/* To protect the above members. */ /* To protect the above members. */
struct mutex mutex; struct mutex mutex;
}; };
#endif /* _I915_MEI_HDCP_INTERFACE_H_ */ #endif /* _I915_HDCP_INTERFACE_H_ */