diff mbox

[v3,10/40] misc/mei/hdcp: Verify H_prime

Message ID 1522763873-23041-11-git-send-email-ramalingam.c@intel.com (mailing list archive)
State New, archived
Headers show

Commit Message

Ramalingam C April 3, 2018, 1:57 p.m. UTC
Requests for the verifcation of AKE_Send_H_prime.

ME will calculation the H and comparing it with received H_Prime.
Here AKE_Send_H_prime is a HDCP2.2 Authentication msg.

v2:
  Rebased.
v3:
  cldev is passed as first parameter [Tomas]
  Redundant comments and cast are removed [Tomas]

Signed-off-by: Ramalingam C <ramalingam.c@intel.com>
---
 drivers/misc/mei/hdcp/mei_hdcp.c | 58 ++++++++++++++++++++++++++++++++++++++++
 include/linux/mei_hdcp.h         |  8 ++++++
 2 files changed, 66 insertions(+)

Comments

kernel test robot April 3, 2018, 10:12 p.m. UTC | #1
Hi Ramalingam,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on drm-intel/for-linux-next]
[also build test ERROR on next-20180403]
[cannot apply to v4.16]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Ramalingam-C/drm-i915-Implement-HDCP2-2/20180404-031743
base:   git://anongit.freedesktop.org/drm-intel for-linux-next
config: i386-allmodconfig (attached as .config)
compiler: gcc-7 (Debian 7.3.0-1) 7.3.0
reproduce:
        # save the attached .config to linux build tree
        make ARCH=i386 

All errors (new ones prefixed by >>):

   drivers/misc/mei/hdcp/mei_hdcp.c:52:5: error: redefinition of 'mei_initiate_hdcp2_session'
    int mei_initiate_hdcp2_session(struct mei_cl_device *cldev,
        ^~~~~~~~~~~~~~~~~~~~~~~~~~
   In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
   include/linux/mei_hdcp.h:131:5: note: previous definition of 'mei_initiate_hdcp2_session' was here
    int mei_initiate_hdcp2_session(struct mei_cl_device *cldev,
        ^~~~~~~~~~~~~~~~~~~~~~~~~~
   drivers/misc/mei/hdcp/mei_hdcp.c:122:1: error: redefinition of 'mei_verify_receiver_cert_prepare_km'
    mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
   include/linux/mei_hdcp.h:138:1: note: previous definition of 'mei_verify_receiver_cert_prepare_km' was here
    mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>> drivers/misc/mei/hdcp/mei_hdcp.c:200:5: error: redefinition of 'mei_verify_hprime'
    int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
        ^~~~~~~~~~~~~~~~~
   In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
   include/linux/mei_hdcp.h:148:5: note: previous definition of 'mei_verify_hprime' was here
    int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
        ^~~~~~~~~~~~~~~~~
   drivers/misc/mei/hdcp/mei_hdcp.c:257:5: error: redefinition of 'mei_cldev_register_notify'
    int mei_cldev_register_notify(struct notifier_block *nb)
        ^~~~~~~~~~~~~~~~~~~~~~~~~
   In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
   include/linux/mei_hdcp.h:122:12: note: previous definition of 'mei_cldev_register_notify' was here
    static int mei_cldev_register_notify(struct notifier_block *nb)
               ^~~~~~~~~~~~~~~~~~~~~~~~~
   drivers/misc/mei/hdcp/mei_hdcp.c:263:5: error: redefinition of 'mei_cldev_unregister_notify'
    int mei_cldev_unregister_notify(struct notifier_block *nb)
        ^~~~~~~~~~~~~~~~~~~~~~~~~~~
   In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
   include/linux/mei_hdcp.h:126:12: note: previous definition of 'mei_cldev_unregister_notify' was here
    static int mei_cldev_unregister_notify(struct notifier_block *nb)
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~
   include/linux/mei_hdcp.h:126:12: warning: 'mei_cldev_unregister_notify' defined but not used [-Wunused-function]
   include/linux/mei_hdcp.h:122:12: warning: 'mei_cldev_register_notify' defined but not used [-Wunused-function]
    static int mei_cldev_register_notify(struct notifier_block *nb)
               ^~~~~~~~~~~~~~~~~~~~~~~~~

vim +/mei_verify_hprime +200 drivers/misc/mei/hdcp/mei_hdcp.c

   106	
   107	/**
   108	 * mei_verify_receiver_cert_prepare_km:
   109	 *	Function to verify the Receiver Certificate AKE_Send_Cert
   110	 *	and prepare AKE_Stored_Km or AKE_No_Stored_Km
   111	 *
   112	 * @cldev		: Pointer for mei client device
   113	 * @data		: Intel HW specific Data
   114	 * @rx_cert		: Pointer for AKE_Send_Cert
   115	 * @km_stored		: Pointer for pairing status flag
   116	 * @ek_pub_km		: Pointer for output msg
   117	 * @msg_sz		: Pointer for size of AKE_XXXXX_Km
   118	 *
   119	 * Returns 0 on Success, <0 on Failure
   120	 */
   121	int
 > 122	mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
   123					    struct mei_hdcp_data *data,
   124					    struct hdcp2_ake_send_cert *rx_cert,
   125					    bool *km_stored,
   126					    struct hdcp2_ake_no_stored_km *ek_pub_km,
   127					    size_t *msg_sz)
   128	{
   129		struct wired_cmd_verify_receiver_cert_in verify_rxcert_in = { { 0 } };
   130		struct wired_cmd_verify_receiver_cert_out verify_rxcert_out = { { 0 } };
   131		struct device *dev;
   132		ssize_t byte;
   133	
   134		if (!data || !rx_cert || !km_stored || !ek_pub_km || !msg_sz)
   135			return -EINVAL;
   136	
   137		dev = &cldev->dev;
   138	
   139		verify_rxcert_in.header.api_version = HDCP_API_VERSION;
   140		verify_rxcert_in.header.command_id = WIRED_VERIFY_RECEIVER_CERT;
   141		verify_rxcert_in.header.status = ME_HDCP_STATUS_SUCCESS;
   142		verify_rxcert_in.header.buffer_len =
   143					WIRED_CMD_BUF_LEN_VERIFY_RECEIVER_CERT_IN;
   144	
   145		verify_rxcert_in.port.integrated_port_type = data->port_type;
   146		verify_rxcert_in.port.physical_port = data->port;
   147	
   148		memcpy(&verify_rxcert_in.cert_rx, &rx_cert->cert_rx,
   149		       sizeof(rx_cert->cert_rx));
   150		memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, sizeof(rx_cert->r_rx));
   151		memcpy(verify_rxcert_in.rx_caps, rx_cert->rx_caps, HDCP_2_2_RXCAPS_LEN);
   152	
   153		byte = mei_cldev_send(cldev, (u8 *)&verify_rxcert_in,
   154				      sizeof(verify_rxcert_in));
   155		if (byte < 0) {
   156			dev_dbg(dev, "mei_cldev_send failed: %d\n", (int)byte);
   157			return byte;
   158		}
   159	
   160		byte = mei_cldev_recv(cldev, (u8 *)&verify_rxcert_out,
   161				      sizeof(verify_rxcert_out));
   162		if (byte < 0) {
   163			dev_dbg(dev, "mei_cldev_recv failed: %d\n", (int)byte);
   164			return byte;
   165		}
   166	
   167		if (verify_rxcert_out.header.status != ME_HDCP_STATUS_SUCCESS) {
   168			dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n",
   169				WIRED_VERIFY_RECEIVER_CERT,
   170				verify_rxcert_out.header.status);
   171			return -1;
   172		}
   173	
   174		*km_stored = verify_rxcert_out.km_stored;
   175		if (verify_rxcert_out.km_stored) {
   176			ek_pub_km->msg_id = HDCP_2_2_AKE_STORED_KM;
   177			*msg_sz = sizeof(struct hdcp2_ake_stored_km);
   178		} else {
   179			ek_pub_km->msg_id = HDCP_2_2_AKE_NO_STORED_KM;
   180			*msg_sz = sizeof(struct hdcp2_ake_no_stored_km);
   181		}
   182	
   183		memcpy(ek_pub_km->e_kpub_km, &verify_rxcert_out.ekm_buff,
   184		       sizeof(verify_rxcert_out.ekm_buff));
   185		return 0;
   186	}
   187	EXPORT_SYMBOL(mei_verify_receiver_cert_prepare_km);
   188	
   189	/**
   190	 * mei_verify_hprime:
   191	 *	Function to verify AKE_Send_H_prime received
   192	 *
   193	 * @cldev		: Pointer for mei client device
   194	 * @data		: Intel HW specific Data
   195	 * @rx_hprime		: Pointer for AKE_Send_H_prime
   196	 * @hprime_sz		: Input buffer size
   197	 *
   198	 * Returns 0 on Success, <0 on Failure
   199	 */
 > 200	int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
   201			      struct hdcp2_ake_send_hprime *rx_hprime)
   202	{
   203		struct wired_cmd_ake_send_hprime_in send_hprime_in = { { 0 } };
   204		struct wired_cmd_ake_send_hprime_out send_hprime_out = { { 0 } };
   205		struct device *dev;
   206		ssize_t byte;
   207	
   208		if (!data || !rx_hprime)
   209			return -EINVAL;
   210	
   211		dev = &cldev->dev;
   212	
   213		send_hprime_in.header.api_version = HDCP_API_VERSION;
   214		send_hprime_in.header.command_id = WIRED_AKE_SEND_HPRIME;
   215		send_hprime_in.header.status = ME_HDCP_STATUS_SUCCESS;
   216		send_hprime_in.header.buffer_len = WIRED_CMD_BUF_LEN_AKE_SEND_HPRIME_IN;
   217	
   218		send_hprime_in.port.integrated_port_type = data->port_type;
   219		send_hprime_in.port.physical_port = data->port;
   220	
   221		memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,
   222		       sizeof(rx_hprime->h_prime));
   223	
   224		byte = mei_cldev_send(cldev, (u8 *)&send_hprime_in,
   225				      sizeof(send_hprime_in));
   226		if (byte < 0) {
   227			dev_dbg(dev, "mei_cldev_send failed. %d\n", (int)byte);
   228			return byte;
   229		}
   230	
   231		byte = mei_cldev_recv(cldev, (u8 *)&send_hprime_out,
   232				      sizeof(send_hprime_out));
   233		if (byte < 0) {
   234			dev_dbg(dev, "mei_cldev_recv failed. %d\n", (int)byte);
   235			return byte;
   236		}
   237	
   238		if (send_hprime_out.header.status != ME_HDCP_STATUS_SUCCESS) {
   239			dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n",
   240				WIRED_AKE_SEND_HPRIME, send_hprime_out.header.status);
   241			return -1;
   242		}
   243		return 0;
   244	}
   245	EXPORT_SYMBOL(mei_verify_hprime);
   246	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
Shankar, Uma May 9, 2018, 10:16 a.m. UTC | #2
>-----Original Message-----

>From: Intel-gfx [mailto:intel-gfx-bounces@lists.freedesktop.org] On Behalf Of

>Ramalingam C

>Sent: Tuesday, April 3, 2018 7:27 PM

>To: intel-gfx@lists.freedesktop.org; dri-devel@lists.freedesktop.org;

>seanpaul@chromium.org; daniel@ffwll.ch; chris@chris-wilson.co.uk;

>jani.nikula@linux.intel.com; Winkler, Tomas <tomas.winkler@intel.com>;

>Usyskin, Alexander <alexander.usyskin@intel.com>

>Cc: Vivi, Rodrigo <rodrigo.vivi@intel.com>

>Subject: [Intel-gfx] [PATCH v3 10/40] misc/mei/hdcp: Verify H_prime

>

>Requests for the verifcation of AKE_Send_H_prime.


Typo in verification.

>

>ME will calculation the H and comparing it with received H_Prime.


Change to "calculate". Also change "comparing" to "compares".

>Here AKE_Send_H_prime is a HDCP2.2 Authentication msg.

>

>v2:

>  Rebased.

>v3:

>  cldev is passed as first parameter [Tomas]

>  Redundant comments and cast are removed [Tomas]

>

>Signed-off-by: Ramalingam C <ramalingam.c@intel.com>

>---

> drivers/misc/mei/hdcp/mei_hdcp.c | 58

>++++++++++++++++++++++++++++++++++++++++

> include/linux/mei_hdcp.h         |  8 ++++++

> 2 files changed, 66 insertions(+)

>

>diff --git a/drivers/misc/mei/hdcp/mei_hdcp.c

>b/drivers/misc/mei/hdcp/mei_hdcp.c

>index 181994529058..fa548310de7a 100644

>--- a/drivers/misc/mei/hdcp/mei_hdcp.c

>+++ b/drivers/misc/mei/hdcp/mei_hdcp.c

>@@ -186,6 +186,64 @@ mei_verify_receiver_cert_prepare_km(struct

>mei_cl_device *cldev,  }

>EXPORT_SYMBOL(mei_verify_receiver_cert_prepare_km);

>

>+/**

>+ * mei_verify_hprime:

>+ *	Function to verify AKE_Send_H_prime received

>+ *

>+ * @cldev		: Pointer for mei client device

>+ * @data		: Intel HW specific Data

>+ * @rx_hprime		: Pointer for AKE_Send_H_prime

>+ * @hprime_sz		: Input buffer size

>+ *

>+ * Returns 0 on Success, <0 on Failure

>+ */

>+int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,

>+		      struct hdcp2_ake_send_hprime *rx_hprime) {

>+	struct wired_cmd_ake_send_hprime_in send_hprime_in = { { 0 } };

>+	struct wired_cmd_ake_send_hprime_out send_hprime_out = { { 0 } };

>+	struct device *dev;

>+	ssize_t byte;

>+

>+	if (!data || !rx_hprime)

>+		return -EINVAL;

>+

>+	dev = &cldev->dev;

>+

>+	send_hprime_in.header.api_version = HDCP_API_VERSION;

>+	send_hprime_in.header.command_id = WIRED_AKE_SEND_HPRIME;

>+	send_hprime_in.header.status = ME_HDCP_STATUS_SUCCESS;

>+	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.physical_port = data->port;

>+

>+	memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,


Need to validate rx_hprime->h_prime for NULL.

>+	       sizeof(rx_hprime->h_prime));

>+

>+	byte = mei_cldev_send(cldev, (u8 *)&send_hprime_in,

>+			      sizeof(send_hprime_in));

>+	if (byte < 0) {

>+		dev_dbg(dev, "mei_cldev_send failed. %d\n", (int)byte);

>+		return byte;

>+	}

>+

>+	byte = mei_cldev_recv(cldev, (u8 *)&send_hprime_out,

>+			      sizeof(send_hprime_out));

>+	if (byte < 0) {

>+		dev_dbg(dev, "mei_cldev_recv failed. %d\n", (int)byte);

>+		return byte;

>+	}

>+

>+	if (send_hprime_out.header.status != ME_HDCP_STATUS_SUCCESS) {

>+		dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n",

>+			WIRED_AKE_SEND_HPRIME,

>send_hprime_out.header.status);

>+		return -1;

>+	}


Leave a blank line here.

>+	return 0;


One clarification required - the h prime value sent and received are not compared here. So, whether 
hw matches them and returns success only if they match or it just returns the H prime value
and driver should compare ?

>+}

>+EXPORT_SYMBOL(mei_verify_hprime);

>+

> void mei_cldev_state_notify_clients(struct mei_cl_device *cldev, bool enabled)  {

> 	if (enabled)

>diff --git a/include/linux/mei_hdcp.h b/include/linux/mei_hdcp.h index

>314b15f6afc0..00bfde251ba4 100644

>--- a/include/linux/mei_hdcp.h

>+++ b/include/linux/mei_hdcp.h

>@@ -116,6 +116,8 @@ mei_verify_receiver_cert_prepare_km(struct

>mei_cl_device *cldev,

> 				    bool *km_stored,

> 				    struct hdcp2_ake_no_stored_km

>*ek_pub_km,

> 				    size_t *msg_sz);

>+int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,

>+		      struct hdcp2_ake_send_hprime *rx_hprime);

> #else

> static int mei_cldev_register_notify(struct notifier_block *nb)  { @@ -142,5

>+144,11 @@ mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,

>{

> 	return -ENODEV;

> }

>+static inline

>+int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,

>+		      struct hdcp2_ake_send_hprime *rx_hprime) {

>+	return -ENODEV;

>+}

> #endif /* defined (CONFIG_INTEL_MEI_HDCP) */  #endif /* defined

>(_LINUX_MEI_HDCP_H) */

>--

>2.7.4

>

>_______________________________________________

>Intel-gfx mailing list

>Intel-gfx@lists.freedesktop.org

>https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Ramalingam C May 16, 2018, 3:43 p.m. UTC | #3
On Wednesday 09 May 2018 03:46 PM, Shankar, Uma wrote:
>
>> -----Original Message-----
>> From: Intel-gfx [mailto:intel-gfx-bounces@lists.freedesktop.org] On Behalf Of
>> Ramalingam C
>> Sent: Tuesday, April 3, 2018 7:27 PM
>> To: intel-gfx@lists.freedesktop.org; dri-devel@lists.freedesktop.org;
>> seanpaul@chromium.org; daniel@ffwll.ch; chris@chris-wilson.co.uk;
>> jani.nikula@linux.intel.com; Winkler, Tomas <tomas.winkler@intel.com>;
>> Usyskin, Alexander <alexander.usyskin@intel.com>
>> Cc: Vivi, Rodrigo <rodrigo.vivi@intel.com>
>> Subject: [Intel-gfx] [PATCH v3 10/40] misc/mei/hdcp: Verify H_prime
>>
>> Requests for the verifcation of AKE_Send_H_prime.
> Typo in verification.
thanks :)
>
>> ME will calculation the H and comparing it with received H_Prime.
> Change to "calculate". Also change "comparing" to "compares".
>
>> Here AKE_Send_H_prime is a HDCP2.2 Authentication msg.
>>
>> v2:
>>   Rebased.
>> v3:
>>   cldev is passed as first parameter [Tomas]
>>   Redundant comments and cast are removed [Tomas]
>>
>> Signed-off-by: Ramalingam C <ramalingam.c@intel.com>
>> ---
>> drivers/misc/mei/hdcp/mei_hdcp.c | 58
>> ++++++++++++++++++++++++++++++++++++++++
>> include/linux/mei_hdcp.h         |  8 ++++++
>> 2 files changed, 66 insertions(+)
>>
>> diff --git a/drivers/misc/mei/hdcp/mei_hdcp.c
>> b/drivers/misc/mei/hdcp/mei_hdcp.c
>> index 181994529058..fa548310de7a 100644
>> --- a/drivers/misc/mei/hdcp/mei_hdcp.c
>> +++ b/drivers/misc/mei/hdcp/mei_hdcp.c
>> @@ -186,6 +186,64 @@ mei_verify_receiver_cert_prepare_km(struct
>> mei_cl_device *cldev,  }
>> EXPORT_SYMBOL(mei_verify_receiver_cert_prepare_km);
>>
>> +/**
>> + * mei_verify_hprime:
>> + *	Function to verify AKE_Send_H_prime received
>> + *
>> + * @cldev		: Pointer for mei client device
>> + * @data		: Intel HW specific Data
>> + * @rx_hprime		: Pointer for AKE_Send_H_prime
>> + * @hprime_sz		: Input buffer size
>> + *
>> + * Returns 0 on Success, <0 on Failure
>> + */
>> +int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
>> +		      struct hdcp2_ake_send_hprime *rx_hprime) {
>> +	struct wired_cmd_ake_send_hprime_in send_hprime_in = { { 0 } };
>> +	struct wired_cmd_ake_send_hprime_out send_hprime_out = { { 0 } };
>> +	struct device *dev;
>> +	ssize_t byte;
>> +
>> +	if (!data || !rx_hprime)
>> +		return -EINVAL;
>> +
>> +	dev = &cldev->dev;
>> +
>> +	send_hprime_in.header.api_version = HDCP_API_VERSION;
>> +	send_hprime_in.header.command_id = WIRED_AKE_SEND_HPRIME;
>> +	send_hprime_in.header.status = ME_HDCP_STATUS_SUCCESS;
>> +	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.physical_port = data->port;
>> +
>> +	memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,
> Need to validate rx_hprime->h_prime for NULL.
h_prime is statically allocated array within rx_hprime. So we need not 
check .
>> +	       sizeof(rx_hprime->h_prime));
>> +
>> +	byte = mei_cldev_send(cldev, (u8 *)&send_hprime_in,
>> +			      sizeof(send_hprime_in));
>> +	if (byte < 0) {
>> +		dev_dbg(dev, "mei_cldev_send failed. %d\n", (int)byte);
>> +		return byte;
>> +	}
>> +
>> +	byte = mei_cldev_recv(cldev, (u8 *)&send_hprime_out,
>> +			      sizeof(send_hprime_out));
>> +	if (byte < 0) {
>> +		dev_dbg(dev, "mei_cldev_recv failed. %d\n", (int)byte);
>> +		return byte;
>> +	}
>> +
>> +	if (send_hprime_out.header.status != ME_HDCP_STATUS_SUCCESS) {
>> +		dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n",
>> +			WIRED_AKE_SEND_HPRIME,
>> send_hprime_out.header.status);
>> +		return -1;
>> +	}
> Leave a blank line here.
Sure.
>> +	return 0;
> One clarification required - the h prime value sent and received are not compared here. So, whether
> hw matches them and returns success only if they match or it just returns the H prime value
> and driver should compare ?
This shows that commit message need an edit :). Yes, ME FW calculate the 
hprime and compare it with the received hprime.
Returns the comparition result at send_hprime_out.header.status.

--Ram
>
>> +}
>> +EXPORT_SYMBOL(mei_verify_hprime);
>> +
>> void mei_cldev_state_notify_clients(struct mei_cl_device *cldev, bool enabled)  {
>> 	if (enabled)
>> diff --git a/include/linux/mei_hdcp.h b/include/linux/mei_hdcp.h index
>> 314b15f6afc0..00bfde251ba4 100644
>> --- a/include/linux/mei_hdcp.h
>> +++ b/include/linux/mei_hdcp.h
>> @@ -116,6 +116,8 @@ mei_verify_receiver_cert_prepare_km(struct
>> mei_cl_device *cldev,
>> 				    bool *km_stored,
>> 				    struct hdcp2_ake_no_stored_km
>> *ek_pub_km,
>> 				    size_t *msg_sz);
>> +int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
>> +		      struct hdcp2_ake_send_hprime *rx_hprime);
>> #else
>> static int mei_cldev_register_notify(struct notifier_block *nb)  { @@ -142,5
>> +144,11 @@ mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
>> {
>> 	return -ENODEV;
>> }
>> +static inline
>> +int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
>> +		      struct hdcp2_ake_send_hprime *rx_hprime) {
>> +	return -ENODEV;
>> +}
>> #endif /* defined (CONFIG_INTEL_MEI_HDCP) */  #endif /* defined
>> (_LINUX_MEI_HDCP_H) */
>> --
>> 2.7.4
>>
>> _______________________________________________
>> Intel-gfx mailing list
>> Intel-gfx@lists.freedesktop.org
>> https://lists.freedesktop.org/mailman/listinfo/intel-gfx
diff mbox

Patch

diff --git a/drivers/misc/mei/hdcp/mei_hdcp.c b/drivers/misc/mei/hdcp/mei_hdcp.c
index 181994529058..fa548310de7a 100644
--- a/drivers/misc/mei/hdcp/mei_hdcp.c
+++ b/drivers/misc/mei/hdcp/mei_hdcp.c
@@ -186,6 +186,64 @@  mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
 }
 EXPORT_SYMBOL(mei_verify_receiver_cert_prepare_km);
 
+/**
+ * mei_verify_hprime:
+ *	Function to verify AKE_Send_H_prime received
+ *
+ * @cldev		: Pointer for mei client device
+ * @data		: Intel HW specific Data
+ * @rx_hprime		: Pointer for AKE_Send_H_prime
+ * @hprime_sz		: Input buffer size
+ *
+ * Returns 0 on Success, <0 on Failure
+ */
+int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
+		      struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	struct wired_cmd_ake_send_hprime_in send_hprime_in = { { 0 } };
+	struct wired_cmd_ake_send_hprime_out send_hprime_out = { { 0 } };
+	struct device *dev;
+	ssize_t byte;
+
+	if (!data || !rx_hprime)
+		return -EINVAL;
+
+	dev = &cldev->dev;
+
+	send_hprime_in.header.api_version = HDCP_API_VERSION;
+	send_hprime_in.header.command_id = WIRED_AKE_SEND_HPRIME;
+	send_hprime_in.header.status = ME_HDCP_STATUS_SUCCESS;
+	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.physical_port = data->port;
+
+	memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,
+	       sizeof(rx_hprime->h_prime));
+
+	byte = mei_cldev_send(cldev, (u8 *)&send_hprime_in,
+			      sizeof(send_hprime_in));
+	if (byte < 0) {
+		dev_dbg(dev, "mei_cldev_send failed. %d\n", (int)byte);
+		return byte;
+	}
+
+	byte = mei_cldev_recv(cldev, (u8 *)&send_hprime_out,
+			      sizeof(send_hprime_out));
+	if (byte < 0) {
+		dev_dbg(dev, "mei_cldev_recv failed. %d\n", (int)byte);
+		return byte;
+	}
+
+	if (send_hprime_out.header.status != ME_HDCP_STATUS_SUCCESS) {
+		dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n",
+			WIRED_AKE_SEND_HPRIME, send_hprime_out.header.status);
+		return -1;
+	}
+	return 0;
+}
+EXPORT_SYMBOL(mei_verify_hprime);
+
 void mei_cldev_state_notify_clients(struct mei_cl_device *cldev, bool enabled)
 {
 	if (enabled)
diff --git a/include/linux/mei_hdcp.h b/include/linux/mei_hdcp.h
index 314b15f6afc0..00bfde251ba4 100644
--- a/include/linux/mei_hdcp.h
+++ b/include/linux/mei_hdcp.h
@@ -116,6 +116,8 @@  mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
 				    bool *km_stored,
 				    struct hdcp2_ake_no_stored_km *ek_pub_km,
 				    size_t *msg_sz);
+int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
+		      struct hdcp2_ake_send_hprime *rx_hprime);
 #else
 static int mei_cldev_register_notify(struct notifier_block *nb)
 {
@@ -142,5 +144,11 @@  mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
 {
 	return -ENODEV;
 }
+static inline
+int mei_verify_hprime(struct mei_cl_device *cldev, struct mei_hdcp_data *data,
+		      struct hdcp2_ake_send_hprime *rx_hprime)
+{
+	return -ENODEV;
+}
 #endif /* defined (CONFIG_INTEL_MEI_HDCP) */
 #endif /* defined (_LINUX_MEI_HDCP_H) */