Commit 152f2df9 authored by Suraj Kandpal's avatar Suraj Kandpal Committed by Mika Kahola
Browse files

drm/xe/hdcp: Enable HDCP for XE 



Enable HDCP for Xe by defining functions which take care of
interaction of HDCP as a client with the GSC CS interface.
Add intel_hdcp_gsc_message to Makefile and add corresponding
changes to xe_hdcp_gsc.c to make it build.

--v2
-add kfree at appropriate place [Daniele]
-remove useless define [Daniele]
-move host session logic to xe_gsc_submit.c [Daniele]
-call xe_gsc_check_and_update_pending directly in an if condition
[Daniele]
-use xe_device instead of drm_i915_private [Daniele]

--v3
-use xe prefix for newly exposed function [Daniele]
-remove client specific defines from intel_gsc_mtl_header [Daniele]
-add missing kfree() [Daniele]
-have NULL check for hdcp_message in finish function [Daniele]
-dont have too many variable declarations in the same line [Daniele]

--v4
-don't point the hdcp_message structure in xe_device to anything
until it properly gets initialized [Daniele]

--v5
-Squash commits for buildability

--v6
-Order includes alphabetically [Lucas]

Signed-off-by: default avatarSuraj Kandpal <suraj.kandpal@intel.com>
Reviewed-by: default avatarArun R Murthy <arun.r.murthy@intel.com>
Signed-off-by: default avatarMika Kahola <mika.kahola@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240306024247.1857881-6-suraj.kandpal@intel.com
parent 4af50beb

drivers/gpu/drm/xe/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -257,6 +257,7 @@ xe-$(CONFIG_DRM_XE_DISPLAY) += \ 
	i915-display/intel_global_state.o \

	i915-display/intel_gmbus.o \

	i915-display/intel_hdcp.o \

	i915-display/intel_hdcp_gsc_message.o \

	i915-display/intel_hdmi.o \

	i915-display/intel_hotplug.o \

	i915-display/intel_hotplug_irq.o \

drivers/gpu/drm/xe/display/xe_hdcp_gsc.c

+197 −5
Original line number Diff line number Diff line
@@ -4,15 +4,32 @@ 
 */



#include <drm/drm_print.h>

#include <drm/i915_hdcp_interface.h>

#include <linux/delay.h>



#include "abi/gsc_command_header_abi.h"

#include "intel_hdcp_gsc.h"

#include "xe_device_types.h"

#include "intel_hdcp_gsc_message.h"

#include "xe_bo.h"

#include "xe_device.h"

#include "xe_gt.h"

#include "xe_device_types.h"

#include "xe_gsc_proxy.h"

#include "xe_gsc_submit.h"

#include "xe_gt.h"

#include "xe_map.h"

#include "xe_pm.h"

#include "xe_uc_fw.h"



#define HECI_MEADDRESS_HDCP 18



struct intel_hdcp_gsc_message {

	struct xe_bo *hdcp_bo;

	u64 hdcp_cmd_in;

	u64 hdcp_cmd_out;

};



#define HDCP_GSC_HEADER_SIZE sizeof(struct intel_gsc_mtl_header)



bool intel_hdcp_gsc_cs_required(struct xe_device *xe)

{

	return true;
@@ -44,19 +61,194 @@ bool intel_hdcp_gsc_check_status(struct xe_device *xe) 
	return ret;

}



/*This function helps allocate memory for the command that we will send to gsc cs */

static int intel_hdcp_gsc_initialize_message(struct xe_device *xe,

					     struct intel_hdcp_gsc_message *hdcp_message)

{

	struct xe_bo *bo = NULL;

	u64 cmd_in, cmd_out;

	int ret = 0;



	/* allocate object of two page for HDCP command memory and store it */

	xe_device_mem_access_get(xe);

	bo = xe_bo_create_pin_map(xe, xe_device_get_root_tile(xe), NULL, PAGE_SIZE * 2,

				  ttm_bo_type_kernel,

				  XE_BO_CREATE_SYSTEM_BIT |

				  XE_BO_CREATE_GGTT_BIT);



	if (IS_ERR(bo)) {

		drm_err(&xe->drm, "Failed to allocate bo for HDCP streaming command!\n");

		ret = PTR_ERR(bo);

		goto out;

	}



	cmd_in = xe_bo_ggtt_addr(bo);

	cmd_out = cmd_in + PAGE_SIZE;

	xe_map_memset(xe, &bo->vmap, 0, 0, bo->size);



	hdcp_message->hdcp_bo = bo;

	hdcp_message->hdcp_cmd_in = cmd_in;

	hdcp_message->hdcp_cmd_out = cmd_out;

out:

	xe_device_mem_access_put(xe);

	return ret;

}



static int intel_hdcp_gsc_hdcp2_init(struct xe_device *xe)

{

	struct intel_hdcp_gsc_message *hdcp_message;

	int ret;



	hdcp_message = kzalloc(sizeof(*hdcp_message), GFP_KERNEL);



	if (!hdcp_message)

		return -ENOMEM;



	/*

	 * NOTE: No need to lock the comp mutex here as it is already

	 * going to be taken before this function called

	 */

	ret = intel_hdcp_gsc_initialize_message(xe, hdcp_message);

	if (ret) {

		drm_err(&xe->drm, "Could not initialize hdcp_message\n");

		kfree(hdcp_message);

		return ret;

	}



	xe->display.hdcp.hdcp_message = hdcp_message;

	return ret;

}



static const struct i915_hdcp_ops gsc_hdcp_ops = {

	.initiate_hdcp2_session = intel_hdcp_gsc_initiate_session,

	.verify_receiver_cert_prepare_km =

				intel_hdcp_gsc_verify_receiver_cert_prepare_km,

	.verify_hprime = intel_hdcp_gsc_verify_hprime,

	.store_pairing_info = intel_hdcp_gsc_store_pairing_info,

	.initiate_locality_check = intel_hdcp_gsc_initiate_locality_check,

	.verify_lprime = intel_hdcp_gsc_verify_lprime,

	.get_session_key = intel_hdcp_gsc_get_session_key,

	.repeater_check_flow_prepare_ack =

				intel_hdcp_gsc_repeater_check_flow_prepare_ack,

	.verify_mprime = intel_hdcp_gsc_verify_mprime,

	.enable_hdcp_authentication = intel_hdcp_gsc_enable_authentication,

	.close_hdcp_session = intel_hdcp_gsc_close_session,

};



int intel_hdcp_gsc_init(struct xe_device *xe)

{

	drm_dbg_kms(&xe->drm, "HDCP support not yet implemented\n");

	return -ENODEV;

	struct i915_hdcp_arbiter *data;

	int ret;



	data = kzalloc(sizeof(*data), GFP_KERNEL);

	if (!data)

		return -ENOMEM;



	mutex_lock(&xe->display.hdcp.hdcp_mutex);

	xe->display.hdcp.arbiter = data;

	xe->display.hdcp.arbiter->hdcp_dev = xe->drm.dev;

	xe->display.hdcp.arbiter->ops = &gsc_hdcp_ops;

	ret = intel_hdcp_gsc_hdcp2_init(xe);

	if (ret)

		kfree(data);



	mutex_unlock(&xe->display.hdcp.hdcp_mutex);



	return ret;

}



void intel_hdcp_gsc_fini(struct xe_device *xe)

{

	struct intel_hdcp_gsc_message *hdcp_message =

					xe->display.hdcp.hdcp_message;



	if (!hdcp_message)

		return;



	xe_bo_unpin_map_no_vm(hdcp_message->hdcp_bo);

	kfree(hdcp_message);

}



static int xe_gsc_send_sync(struct xe_device *xe,

			    struct intel_hdcp_gsc_message *hdcp_message,

			    u32 msg_size_in, u32 msg_size_out,

			    u32 addr_out_off)

{

	struct xe_gt *gt = hdcp_message->hdcp_bo->tile->media_gt;

	struct iosys_map *map = &hdcp_message->hdcp_bo->vmap;

	struct xe_gsc *gsc = &gt->uc.gsc;

	int ret;



	ret = xe_gsc_pkt_submit_kernel(gsc, hdcp_message->hdcp_cmd_in, msg_size_in,

				       hdcp_message->hdcp_cmd_out, msg_size_out);

	if (ret) {

		drm_err(&xe->drm, "failed to send gsc HDCP msg (%d)\n", ret);

		return ret;

	}



	if (xe_gsc_check_and_update_pending(xe, map, 0, map, addr_out_off))

		return -EAGAIN;



	ret = xe_gsc_read_out_header(xe, map, addr_out_off,

				     sizeof(struct hdcp_cmd_header), NULL);



	return ret;

}



ssize_t intel_hdcp_gsc_msg_send(struct xe_device *xe, u8 *msg_in,

				size_t msg_in_len, u8 *msg_out,

				size_t msg_out_len)

{

	return -ENODEV;

	const size_t max_msg_size = PAGE_SIZE - HDCP_GSC_HEADER_SIZE;

	struct intel_hdcp_gsc_message *hdcp_message;

	u64 host_session_id;

	u32 msg_size_in, msg_size_out;

	u32 addr_out_off, addr_in_wr_off = 0;

	int ret, tries = 0;



	if (msg_in_len > max_msg_size || msg_out_len > max_msg_size) {

		ret = -ENOSPC;

		goto out;

	}



	msg_size_in = msg_in_len + HDCP_GSC_HEADER_SIZE;

	msg_size_out = msg_out_len + HDCP_GSC_HEADER_SIZE;

	hdcp_message = xe->display.hdcp.hdcp_message;

	addr_out_off = PAGE_SIZE;



	host_session_id = xe_gsc_create_host_session_id();

	xe_device_mem_access_get(xe);

	addr_in_wr_off = xe_gsc_emit_header(xe, &hdcp_message->hdcp_bo->vmap,

					    addr_in_wr_off, HECI_MEADDRESS_HDCP,

					    host_session_id, msg_in_len);

	xe_map_memcpy_to(xe, &hdcp_message->hdcp_bo->vmap, addr_in_wr_off,

			 msg_in, msg_in_len);

	/*

	 * Keep sending request in case the pending bit is set no need to add

	 * message handle as we are using same address hence loc. of header is

	 * same and it will contain the message handle. we will send the message

	 * 20 times each message 50 ms apart

	 */

	do {

		ret = xe_gsc_send_sync(xe, hdcp_message, msg_size_in, msg_size_out,

				       addr_out_off);



		/* Only try again if gsc says so */

		if (ret != -EAGAIN)

			break;



		msleep(50);



	} while (++tries < 20);



	if (ret)

		goto out;



	xe_map_memcpy_from(xe, msg_out, &hdcp_message->hdcp_bo->vmap,

			   addr_out_off + HDCP_GSC_HEADER_SIZE,

			   msg_out_len);



out:

	xe_device_mem_access_put(xe);

	return ret;

}

drivers/gpu/drm/xe/xe_gsc_submit.c

+15 −0
Original line number Diff line number Diff line
@@ -40,6 +40,21 @@ gsc_to_gt(struct xe_gsc *gsc) 
	return container_of(gsc, struct xe_gt, uc.gsc);

}



/**

 * xe_gsc_get_host_session_id - Creates a random 64 bit host_session id with

 * bits 56-63 masked.

 *

 * Returns: random host_session_id which can be used to send messages to gsc cs

 */

u64 xe_gsc_create_host_session_id(void)

{

	u64 host_session_id;



	get_random_bytes(&host_session_id, sizeof(u64));

	host_session_id &= ~HOST_SESSION_CLIENT_MASK;

	return host_session_id;

}



/**

 * xe_gsc_emit_header - write the MTL GSC header in memory

 * @xe: the Xe device

drivers/gpu/drm/xe/xe_gsc_submit.h

+1 −0
Original line number Diff line number Diff line
@@ -28,4 +28,5 @@ int xe_gsc_read_out_header(struct xe_device *xe, 
int xe_gsc_pkt_submit_kernel(struct xe_gsc *gsc, u64 addr_in, u32 size_in,

			     u64 addr_out, u32 size_out);



u64 xe_gsc_create_host_session_id(void);

#endif