drivers/gpu/drm/imx/hdp/imx-hdcp.c - linux-imx - Git at Google

 /*
  * Copyright 2019 NXP
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <drm/drmP.h>
 #include <drm/drm_hdcp.h>
 #include <linux/i2c.h>
 #include <linux/random.h>
 #include <linux/of_address.h>
 #include <linux/io.h>
 #include <linux/of.h>
 #include "imx-hdp.h"
 #include "imx-hdcp-private.h"

 static uint8_t recv_id[] = {
 	0x8B, 0xA4, 0x47, 0x42, 0xFB
 };

 static uint8_t m[] = {
 	0xF9, 0xF1, 0x30, 0xA8,
 	0x2D, 0x5B, 0xE5, 0xC3,
 	0xE1, 0x7A, 0xB0, 0xFD,
 	0x0F, 0x54, 0x40, 0x52
 };

 static uint8_t km[] = {
 	0xCA, 0x9F, 0x83, 0x95,
 	0x70, 0xD0, 0xD0, 0xF9,
 	0xCF, 0xE4, 0xEB, 0x54,
 	0x7E, 0x09, 0xFA, 0x3B
 };

 static uint8_t ekhkm[] = {
 	0xE6, 0x57, 0x8E, 0xBC,
 	0xC7, 0x68, 0x44, 0x87,
 	0x88, 0x8A, 0x9B, 0xD7,
 	0xD6, 0xAE, 0x38, 0xBE
 };

 static char const *g_last_error[16] = {
 	"No Error",
 	"HPD is down",
 	"SRM failure",
 	"Signature verification error",
 	"h tag != h",
 	"V tag diff v",
 	"Locality check",
 	"DDC error",
 	"REAUTH_REQ",
 	"Topology error",
 	"Verify receiver ID list failed",
 	"HDCP_RSVD1 was not 0,0,0",
 	"HDMI capability or mode",
 	"RI result was different than expected",
 	"WatchDog expired",
 	"Repeater integrity failed"
 };

 static char const *g_rx_type[4] = {
 	"Unknown", "HDCP 1", "HDCP 2", "Unknown" };

 #define HDCP_MAX_RECEIVERS 32
 #define HDCP_RECEIVER_ID_SIZE_BYTES 5
 #define HPD_EVENT 1
 #define HDCP_STATUS_SIZE         0x5
 #define HDCP_PORT_STS_AUTH       0x1
 #define HDCP_PORT_STS_REPEATER   0x2
 #define HDCP_PORT_STS_REPEATER   0x2
 #define HDCP_PORT_STS_TYPE_MASK  0xc
 #define HDCP_PORT_STS_TYPE_SHIFT 0x2
 #define HDCP_PORT_STS_AUTH_STREAM_ID_SHIFT 0x4
 #define HDCP_PORT_STS_AUTH_STREAM_ID_MASK 0x10
 #define HDCP_PORT_STS_LAST_ERR_SHIFT 0x5
 #define HDCP_PORT_STS_LAST_ERR_MASK  (0x0F << 5)
 #define GET_HDCP_PORT_STS_LAST_ERR(__sts__) \
 	(((__sts__) & HDCP_PORT_STS_LAST_ERR_MASK) >> \
 	 HDCP_PORT_STS_LAST_ERR_SHIFT)
 #define HDCP_PORT_STS_1_1_FEATURES   0x200

 #define HDCP_DPCD_CERTRX_ADDRESS 0x6900B

 #define HDCP_CONFIG_NONE    ((u8) 0)
 #define HDCP_CONFIG_1_4     ((u8) 1) /* use HDCP 1.4 only */
 #define HDCP_CONFIG_2_2     ((u8) 2) /* use HDCP 2.2 only */
 /* use All HDCP versions */
 #define HDCP_CONFIG_ALL     (HDCP_CONFIG_1_4 | HDCP_CONFIG_2_2)

 static void imx_hdcp_print_port_status(uint16_t sts)
 {
 	DRM_DEBUG_KMS("INFO: HDCP Port Status: 0x%04x\n", sts);
 	DRM_DEBUG_KMS(" Authenticated: %d\n",
 		      (bool)(sts & HDCP_PORT_STS_AUTH));
 	DRM_DEBUG_KMS(" Receiver is repeater: %d\n",
 		      (bool)(sts & HDCP_PORT_STS_REPEATER));
 	DRM_DEBUG_KMS(" RX Type: %s\n",
 		      g_rx_type[((sts & HDCP_PORT_STS_TYPE_MASK)
 				 >> HDCP_PORT_STS_TYPE_SHIFT)]);
 	DRM_DEBUG_KMS(" AuthStreamId: %d\n",
 		      (bool)(sts & HDCP_PORT_STS_AUTH_STREAM_ID_MASK));
 	DRM_DEBUG_KMS(" Last Error: %s\n",
 		      g_last_error[((sts & HDCP_PORT_STS_LAST_ERR_MASK)
 				    >> HDCP_PORT_STS_LAST_ERR_SHIFT)]);
 	DRM_DEBUG_KMS(" Enable 1.1 Features: %d\n",
 		      (bool)(sts & HDCP_PORT_STS_1_1_FEATURES));
 }

 static unsigned int wait4event(struct imx_hdp *hdp,
 			       unsigned int *events,
 			       unsigned int event_to_wait)
 {
 	unsigned int reg_events;
 	unsigned int returned_events;
 	unsigned int event_mask = 1U << event_to_wait |
 		1U << EVENT_ID_HDCPTX_STATUS;
 	int timeout = 50000; /* 50000 * 10 u is at least ~500 miliseconds */

 	while ((event_mask & *events) == 0) {
 		if (timeout-- == 0)
 			return 0;
 		udelay(10);
 		CDN_API_Get_Event(&hdp->state, &reg_events);
 		*events |= reg_events;
 	}

 	returned_events = *events & event_mask;
 	*events &= ~event_mask;
 	return returned_events;
 }

 static inline
 uint16_t imx_hdcp_get_port_status(u8 hdcp_status[HDCP_STATUS_SIZE])
 {
 	return (hdcp_status[0] << 8) | hdcp_status[1];
 }

 static u16 imx_hdcp_get_status(struct imx_hdp *hdp)
 {
 	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
 	u8 hdcp_status[HDCP_STATUS_SIZE];
 	u16 hdcp_port_status;

 	DRM_DEBUG_KMS("INFO: Reading HDCP TX status\n");
 	CDN_API_HDCP_TX_STATUS_REQ_blocking(&hdp->state, hdcp_status, bt);

 	hdcp_port_status = imx_hdcp_get_port_status(hdcp_status);

 	return hdcp_port_status;
 }

 static inline unsigned char check_event(unsigned int events,
 					unsigned int tested)
 {
 	if ((events & (1 << tested)) == 0)
 		return 0;
 	return 1;
 }

 /* Prints status. Returns error code (0 = no error) */
 static unsigned char imx_hdcp_handle_status(unsigned short status)
 {
 	imx_hdcp_print_port_status(status);
 	if (status & HDCP_PORT_STS_LAST_ERR_MASK)
 		DRM_ERROR("ERROR: HDCP error was set to %s\n",
 			  g_last_error[((status & HDCP_PORT_STS_LAST_ERR_MASK)
 					>> HDCP_PORT_STS_LAST_ERR_SHIFT)]);
 	return GET_HDCP_PORT_STS_LAST_ERR(status);
 }

 static int imx_hdcp_set_config(struct imx_hdp *hdp, u8 hdcp_config)
 {
 	CDN_API_STATUS ret;
 	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
 	uint8_t apb_cfg_dpcd_sts = 0;
 	uint8_t apb_cfg_hdcp_sts = 0;
 	uint8_t apb_cfg_capb_sts = 0;
 	uint8_t hdcp_cfg;

 	unsigned int events = 0;
 	unsigned int retEvents;
 	unsigned short hdcp_port_status;

 	if (bt == CDN_BUS_TYPE_SAPB) {
 		DRM_DEBUG_KMS("INFO: Switching HDCP Commands to SAPB.\n");
 		ret = CDN_API_ApbConf_blocking
 			(&hdp->state,
 			 0, 0, /* set DPCD to APB (don't lock) */
 			 1, 0, /* set HDCP to SAPB (don't lock) */
 			 0, 0, /* set CAPB owner CPU (don't lock) */
 			 &apb_cfg_dpcd_sts,
 			 &apb_cfg_hdcp_sts,
 			 &apb_cfg_capb_sts);

 		if (ret != CDN_OK) {
 			DRM_ERROR("Failed to set APB configuration.\n");
 			return -1;
 		}
 		if (apb_cfg_hdcp_sts == 1) { /* 1 - locked */
 			DRM_ERROR("Failed to switch HDCP to SAPB Mailbox\n");
 			return -1;
 		}
 		DRM_DEBUG_KMS("INFO: HDCP switched to SAPB\n");
 	} else
 		DRM_DEBUG_KMS("INFO: Leaving HDCP to APB\n");

 	/* HDCP 2.2(and/or 1.4) | activate | km-key |  0 */
 	hdcp_cfg = hdcp_config | 0x04 | 0x10 | (HDCP_CONTENT_TYPE_0 << 3);

 	DRM_DEBUG_KMS("INFO: Enabling HDCP...\n");
 	CDN_API_HDCP_TX_CONFIGURATION_blocking(&hdp->state, hdcp_cfg, bt);

 	/* Wait until HDCP_TX_STATUS EVENT appears */
 	DRM_DEBUG_KMS("INFO: wait4event -> EVENT_ID_HDCPTX_STATUS\n");
 	retEvents = wait4event(hdp, &events, EVENT_ID_HDCPTX_STATUS);

 	/* Set TX STATUS REQUEST */
 	DRM_DEBUG_KMS("INFO: Getting port status\n");
 	hdcp_port_status = imx_hdcp_get_status(hdp);
 	if (imx_hdcp_handle_status(hdcp_port_status) != 0)
 		return -1;

 	return 0;
 }

 static int imx_hdcp_auth_check(struct imx_hdp *hdp)
 {
 	u32 events;
 	u16 hdcp_port_status;

 	/* Wait until HDCP_TX_STATUS EVENT appears */
 	events = wait4event(hdp, &events, EVENT_ID_HDCPTX_STATUS);
 	if (events == 0)
 		return -1;
 	DRM_DEBUG_KMS("HDCP: EVENT_ID_HDCPTX_STATUS\n");

 	hdcp_port_status = imx_hdcp_get_status(hdp);
 	if (imx_hdcp_handle_status(hdcp_port_status) != 0)
 		return -1;

 	if (hdcp_port_status & 1) {
 		DRM_INFO("Authentication completed successfully!\n");
 		return 0;
 	}
 	DRM_ERROR("Authentication failed\n");
 	return -1;
 }

 static int imx_hdcp_check_receviers(struct imx_hdp *hdp)
 {
 	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
 	unsigned int events = 0;
 	unsigned int ret_events;
 	uint8_t hdcp_num_rec;
 	uint8_t hdcp_rec_id[HDCP_MAX_RECEIVERS][HDCP_RECEIVER_ID_SIZE_BYTES];
 	uint8_t i;

 	DRM_DEBUG_KMS("INFO: Waiting for Receiver ID valid event\n");
 	ret_events = wait4event(hdp, &events,
 				EVENT_ID_HDCPTX_IS_RECEIVER_ID_VALID);
 	DRM_DEBUG_KMS("INFO: Requesting Receivers ID's\n");

 	hdcp_num_rec = 0;
 	memset(&hdcp_rec_id, 0, sizeof(hdcp_rec_id));

 	CDN_API_HDCP_TX_IS_RECEIVER_ID_VALID_REQ_blocking
 		(&hdp->state,
 		 &hdcp_num_rec,
 		 (unsigned char *)
 		 hdcp_rec_id,
 		 bt
 		);

 	DRM_DEBUG_KMS("INFO: Number of Receivers: %d\n", hdcp_num_rec);

 	for (i = 0; i < hdcp_num_rec; ++i) {
 		DRM_INFO("\tReveiver ID%2d: %.2X%.2X%.2X%.2X%.2X\n",
 			 i,
 			 hdcp_rec_id[i][0],
 			 hdcp_rec_id[i][1],
 			 hdcp_rec_id[i][2],
 			 hdcp_rec_id[i][3],
 			 hdcp_rec_id[i][4]
 			);
 	}

 	/* fixme: Check Receiver ID's against revocation list */

 	DRM_DEBUG_KMS("INFO: Responding with Receiver ID's OK!\n");
 	CDN_API_HDCP_TX_RESPOND_RECEIVER_ID_VALID_blocking(&hdp->state, 1,
 							   hdp->hdcp.bus_type);

 	return 0;
 }

 static inline int imx_hdcp_auth_22(struct imx_hdp *hdp)
 {
 	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
 	unsigned char kmStored = 0;
 	unsigned int events = 0;
 	unsigned int retEvents;
 	unsigned short hdcp_port_status;
 	u8 resp[HDCP_STATUS_SIZE];
 	S_HDCP_TRANS_PAIRING_DATA pairing;

 	DRM_DEBUG_KMS("HDCP: Start 2.2 Authentication\n");

 	/* Wait until HDCP2_TX_IS_KM_STORED EVENT appears */
 	retEvents = 0;
 	DRM_DEBUG_KMS("INFO: Wait until HDCP2_TX_IS_KM_STORED EVENT appears\n");
 	while (check_event(retEvents, EVENT_ID_HDCPTX_IS_KM_STORED) == 0) {
 		DRM_DEBUG_KMS("INFO: Waiting FOR _IS_KM_STORED EVENT\n");
 		retEvents = wait4event(hdp, &events,
 				       EVENT_ID_HDCPTX_IS_KM_STORED);
 		if (retEvents == 0) {
 			/* time out occurred, stop hdcp and return error */
 			CDN_API_HDCP_TX_CONFIGURATION_blocking(&hdp->state,
 							       0, bt);
 			return -1;
 		}
 		if (check_event(retEvents, EVENT_ID_HDCPTX_STATUS) != 0) {
 			hdcp_port_status = imx_hdcp_get_status(hdp);
 			if (imx_hdcp_handle_status(hdcp_port_status) != 0)
 				return -1;
 		}
 	}

 	DRM_DEBUG_KMS("HDCP: EVENT_ID_HDCPTX_IS_KM_STORED\n");

 	/* Set HDCP2 TX KM STORED REQUEST */
 	CDN_API_HDCP2_TX_IS_KM_STORED_REQ_blocking(&hdp->state, resp, bt);
 	DRM_DEBUG_KMS("HDCP: CDN_API_HDCP2_TX_IS_KM_STORED_REQ_blocking\n");
 	DRM_DEBUG_KMS("HDCP: Receiver ID: 0x%x%x%x%x%x\n",
 		      resp[0], resp[1], resp[2], resp[3], resp[4]);

 	/* Check if KM is stored */
 	if (kmStored != 0) {
 		DRM_DEBUG_KMS("INFO: KM is stored\n");
 		/* Set HDCP2 TX RESPOND KM with stored KM */
 		memcpy(pairing.receiver_id, recv_id, sizeof(recv_id));
 		memcpy(pairing.m, m, sizeof(m));
 		memcpy(pairing.km, km, sizeof(km));
 		memcpy(pairing.ekh, ekhkm, sizeof(ekhkm));
 		CDN_API_HDCP2_TX_RESPOND_KM_blocking(&hdp->state, &pairing, bt);
 		DRM_DEBUG_KMS("HDCP: CDN_API_HDCP2_TX_RESPOND_KM_blocking\n");
 	} else { /* KM is not stored */
 		DRM_DEBUG_KMS("INFO: KM is not stored\n");
 		/* Set HDCP2 TX RESPOND KM with empty data */
 		CDN_API_HDCP2_TX_RESPOND_KM_blocking(&hdp->state, NULL, bt);
 	}

 	imx_hdcp_check_receviers(hdp);

 	/* Check if KM is not stored */
 	if (kmStored == 0) {
 		/* Wait until HDCP2_TX_STORE_KM EVENT appears */
 		retEvents = 0;
 		while (check_event(retEvents, EVENT_ID_HDCPTX_STORE_KM) == 0) {
 			retEvents = wait4event(hdp, &events,
 					       EVENT_ID_HDCPTX_STORE_KM);
 			if (check_event(retEvents, EVENT_ID_HDCPTX_STATUS)
 			    != 0) {
 				hdcp_port_status = imx_hdcp_get_status(hdp);
 				if (imx_hdcp_handle_status(hdcp_port_status)
 				    != 0)
 					return -1;
 			}
 		}
 		DRM_DEBUG_KMS("HDCP: EVENT_ID_HDCPTX_STORE_KM\n");

 		/* Set HDCP2_TX_STORE_KM REQUEST */
 		CDN_API_HDCP2_TX_STORE_KM_REQ_blocking(&hdp->state, &pairing,
 						       bt);
 		DRM_DEBUG_KMS("HDCP: CDN_API_HDCP2_TX_STORE_KM_REQ_blocking");
 	}

 	return 0;
 }

 static inline int imx_hdcp_auth_14(struct imx_hdp *hdp)
 {
 	DRM_DEBUG_KMS("HDCP: Starting 1.4 Authentication\n");
 	return imx_hdcp_check_receviers(hdp);
 }

 static int imx_hdcp_auth(struct imx_hdp *hdp, u8 hdcp_config)
 {
 	int ret;

 	DRM_DEBUG_KMS("HDCP: Start Authentication\n");
 	ret = imx_hdcp_set_config(hdp, hdcp_config);
 	if (ret) {
 		DRM_ERROR("imx_hdcp_set_config failed\n");
 		return -1;
 	}
 	if (hdcp_config == HDCP_TX_1)
 		ret = imx_hdcp_auth_14(hdp);
 	else
 		ret = imx_hdcp_auth_22(hdp);

 	if (ret) {
 		DRM_ERROR("imx_hdcp_auth_%s failed\n",
 			  (hdcp_config == HDCP_TX_1) ? "14" : "22");
 		return -1;
 	}

 	ret = imx_hdcp_auth_check(hdp);
 	if (ret)
 		ret = imx_hdcp_auth_check(hdp);
 	return ret;
 }

 static int _imx_hdcp_disable(struct imx_hdp *hdp)
 {
 	int ret = 0;
 	uint8_t hdcp_cfg = 0;
 	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;

 	DRM_DEBUG_KMS("[%s:%d] HDCP is being disabled...\n",
 		      hdp->connector.name, hdp->connector.base.id);
 	DRM_DEBUG_KMS("INFO: Disabling HDCP...\n");

 	ret = CDN_API_HDCP_TX_CONFIGURATION_blocking(&hdp->state, hdcp_cfg, bt);

 	DRM_DEBUG_KMS("HDCP is disabled\n");

 	return ret;
 }


 static int _imx_hdcp_enable(struct imx_hdp *hdp)
 {
 	int i, ret = 0, tries = 3;

 	DRM_DEBUG_KMS("[%s:%d] HDCP is being enabled...\n",
 		      hdp->connector.name, hdp->connector.base.id);

 	/* Incase of authentication failures, HDCP spec expects reauth. */
 	for (i = 0; i < tries; i++) {
 		if (hdp->hdcp.config & HDCP_CONFIG_2_2) {
 			ret = imx_hdcp_auth(hdp, HDCP_TX_2);
 			if (ret == 0)
 				return 0;
 		}
 		_imx_hdcp_disable(hdp);
 		if (hdp->hdcp.config & HDCP_CONFIG_1_4) {
 			ret = imx_hdcp_auth(hdp, HDCP_TX_1);
 			if (!ret)
 				return 0;
 		}
 		DRM_DEBUG_KMS("HDCP Auth failure (%d)\n", ret);

 		/* Ensuring HDCP encryption and signalling are stopped. */
 		_imx_hdcp_disable(hdp);
 	}

 	DRM_ERROR("HDCP authentication failed (%d tries/%d)\n", tries, ret);
 	return ret;
 }

 static void imx_hdcp_check_work(struct work_struct *work)
 {
 	struct imx_hdcp *hdcp = container_of(work,
 					     struct imx_hdcp,
 					     check_work.work);
 	struct imx_hdp *hdp = container_of(hdcp,
 					   struct imx_hdp,
 					   hdcp);
 	if (!imx_hdcp_check_link(hdp))
 		schedule_delayed_work(&hdcp->check_work,
 				      DRM_HDCP_CHECK_PERIOD_MS);
 }


 static void imx_hdcp_prop_work(struct work_struct *work)
 {
 	struct imx_hdcp *hdcp = container_of(work,
 					     struct imx_hdcp,
 					     prop_work);
 	struct imx_hdp *hdp = container_of(hdcp,
 					   struct imx_hdp,
 					   hdcp);

 	struct drm_device *dev = hdp->drm_dev;
 	struct drm_connector_state *state;

 	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 	mutex_lock(&hdp->hdcp.mutex);

 	/*
 	 * This worker is only used to flip between ENABLED/DESIRED. Either of
 	 * those to UNDESIRED is handled by core. If hdcp_value == UNDESIRED,
 	 * we're running just after hdcp has been disabled, so just exit
 	 */
 	if (hdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
 		state = hdp->connector.state;
 		state->content_protection = hdp->hdcp.value;
 	}

 	mutex_unlock(&hdp->hdcp.mutex);
 	drm_modeset_unlock(&dev->mode_config.connection_mutex);
 }

 static void show_hdcp_supported(struct imx_hdp *hdp)
 {
 	if ((hdp->hdcp.config & (HDCP_CONFIG_1_4 | HDCP_CONFIG_2_2)) ==
 		    (HDCP_CONFIG_1_4 | HDCP_CONFIG_2_2))
 		DRM_INFO("Both HDCP 1.4 and 2 2 are enabled\n");
 	else if (hdp->hdcp.config & HDCP_CONFIG_1_4)
 		DRM_INFO("Only HDCP 1.4 is enabled\n");
 	else if (hdp->hdcp.config & HDCP_CONFIG_2_2)
 		DRM_INFO("Only HDCP 2.2 is enabled\n");
 	else
 		DRM_INFO("HDCP is disabled\n");
 }

 int imx_hdcp_init(struct imx_hdp *hdp, struct device_node *of_node)
 {
 	int ret;
 	const char *compat;
 	u32 temp;

 	ret = of_property_read_string(of_node, "compatible", &compat);
 	if (ret) {
 		DRM_ERROR("Failed to compatible dts string\n");
 		return ret;
 	}

 	ret = of_property_read_u32(of_node, "hdcp-config", &temp);
 	if (ret) {
 		/* hdp->hdcp_config = HDCP_CONFIG_ALL; */
 		/* using highest level by default */
 		hdp->hdcp.config = HDCP_CONFIG_2_2;
 		DRM_INFO("Failed to get HDCP config - using HDCP 2.2 only\n");
 	} else {
 		hdp->hdcp.config = temp;
 		show_hdcp_supported(hdp);
 	}

 	if (!check_hdcp_enabled())
 		return -EPERM;

 	if (!strstr(compat, "hdmi"))
 		return -EPERM;

 	if (strstr(compat, "imx8mq"))
 		hdp->hdcp.bus_type = CDN_BUS_TYPE_SAPB;
 	else
 		hdp->hdcp.bus_type = CDN_BUS_TYPE_APB;

 	ret = drm_connector_attach_content_protection_property(&hdp->connector);
 	if (ret)
 		return ret;

 	/*connector->hdcp_shim = hdcp_shim;*/
 	mutex_init(&hdp->hdcp.mutex);
 	INIT_DELAYED_WORK(&hdp->hdcp.check_work, imx_hdcp_check_work);
 	INIT_WORK(&hdp->hdcp.prop_work, imx_hdcp_prop_work);
 	return 0;
 }

 int imx_hdcp_enable(struct imx_hdp *hdp)
 {
 	int ret;

 	mutex_lock(&hdp->hdcp.mutex);

 	ret = _imx_hdcp_enable(hdp);
 	if (ret)
 		goto out;

 	hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
 	schedule_work(&hdp->hdcp.prop_work);
 	schedule_delayed_work(&hdp->hdcp.check_work,
 			      DRM_HDCP_CHECK_PERIOD_MS);
 out:
 	mutex_unlock(&hdp->hdcp.mutex);
 	return ret;
 }

 int imx_hdcp_disable(struct imx_hdp *hdp)
 {
 	int ret = 0;

 	mutex_lock(&hdp->hdcp.mutex);
 	if (hdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
 		hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
 		ret = _imx_hdcp_disable(hdp);
 	}
 	mutex_unlock(&hdp->hdcp.mutex);
 	cancel_delayed_work_sync(&hdp->hdcp.check_work);

 	return ret;
 }

 void imx_hdcp_atomic_check(struct drm_connector *connector,
 			   struct drm_connector_state *old_state,
 			   struct drm_connector_state *new_state)
 {
 	uint64_t old_cp = old_state->content_protection;
 	uint64_t new_cp = new_state->content_protection;
 	struct drm_crtc_state *crtc_state;

 	if (!new_state->crtc) {
 		/*
 		 * If the connector is being disabled with CP enabled, mark it
 		 * desired so it's re-enabled when the connector is brought back
 		 */
 		if (old_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED)
 			new_state->content_protection =
 				DRM_MODE_CONTENT_PROTECTION_DESIRED;
 		return;
 	}

 	/*
 	 * Nothing to do if the state didn't change, or HDCP was activated since
 	 * the last commit
 	 */
 	if (old_cp == new_cp ||
 	    (old_cp == DRM_MODE_CONTENT_PROTECTION_DESIRED &&
 	     new_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED))
 		return;

 	crtc_state = drm_atomic_get_new_crtc_state(new_state->state,
 						   new_state->crtc);
 	crtc_state->mode_changed = true;
 }

 int imx_hdcp_check_link(struct imx_hdp *hdp)
 {
 	int ret = 0;
 	u16 hdcp_port_status;
 	u8 hdcp_last_error;

 	mutex_lock(&hdp->hdcp.mutex);

 	if (hdp->hdcp.value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
 		goto out;

 	/* get port status */
 	hdcp_port_status = imx_hdcp_get_status(hdp);
 	hdcp_last_error = GET_HDCP_PORT_STS_LAST_ERR(hdcp_port_status);
 	if (hdcp_last_error)
 		DRM_ERROR("HDCP error no: %u\n", hdcp_last_error);

 	if (hdcp_port_status &  HDCP_PORT_STS_AUTH) {
 		if (hdp->hdcp.value !=
 			    DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
 			hdp->hdcp.value =
 				DRM_MODE_CONTENT_PROTECTION_ENABLED;
 			schedule_work(&hdp->hdcp.prop_work);
 		}
 		DRM_DEBUG_KMS("INFO: HDCP authenticated\n");
 		/* HDCP is authenticated*/
 		goto out;
 	}

 	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
 		      hdp->connector.name, hdp->connector.base.id);

 	ret = _imx_hdcp_disable(hdp);
 	if (ret) {
 		DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
 		hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
 		schedule_work(&hdp->hdcp.prop_work);
 		goto out;
 	}

 	ret = _imx_hdcp_enable(hdp);
 	if (ret) {
 		DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
 		hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
 		schedule_work(&hdp->hdcp.prop_work);
 		goto out;
 	}

 out:
 	mutex_unlock(&hdp->hdcp.mutex);
 	return ret;
 }
	/*
	* Copyright 2019 NXP
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <drm/drmP.h>
	#include <drm/drm_hdcp.h>
	#include <linux/i2c.h>
	#include <linux/random.h>
	#include <linux/of_address.h>
	#include <linux/io.h>
	#include <linux/of.h>
	#include "imx-hdp.h"
	#include "imx-hdcp-private.h"

	static uint8_t recv_id[] = {
	0x8B, 0xA4, 0x47, 0x42, 0xFB
	};

	static uint8_t m[] = {
	0xF9, 0xF1, 0x30, 0xA8,
	0x2D, 0x5B, 0xE5, 0xC3,
	0xE1, 0x7A, 0xB0, 0xFD,
	0x0F, 0x54, 0x40, 0x52
	};

	static uint8_t km[] = {
	0xCA, 0x9F, 0x83, 0x95,
	0x70, 0xD0, 0xD0, 0xF9,
	0xCF, 0xE4, 0xEB, 0x54,
	0x7E, 0x09, 0xFA, 0x3B
	};

	static uint8_t ekhkm[] = {
	0xE6, 0x57, 0x8E, 0xBC,
	0xC7, 0x68, 0x44, 0x87,
	0x88, 0x8A, 0x9B, 0xD7,
	0xD6, 0xAE, 0x38, 0xBE
	};

	static char const *g_last_error[16] = {
	"No Error",
	"HPD is down",
	"SRM failure",
	"Signature verification error",
	"h tag != h",
	"V tag diff v",
	"Locality check",
	"DDC error",
	"REAUTH_REQ",
	"Topology error",
	"Verify receiver ID list failed",
	"HDCP_RSVD1 was not 0,0,0",
	"HDMI capability or mode",
	"RI result was different than expected",
	"WatchDog expired",
	"Repeater integrity failed"
	};

	static char const *g_rx_type[4] = {
	"Unknown", "HDCP 1", "HDCP 2", "Unknown" };

	#define HDCP_MAX_RECEIVERS 32
	#define HDCP_RECEIVER_ID_SIZE_BYTES 5
	#define HPD_EVENT 1
	#define HDCP_STATUS_SIZE 0x5
	#define HDCP_PORT_STS_AUTH 0x1
	#define HDCP_PORT_STS_REPEATER 0x2
	#define HDCP_PORT_STS_REPEATER 0x2
	#define HDCP_PORT_STS_TYPE_MASK 0xc
	#define HDCP_PORT_STS_TYPE_SHIFT 0x2
	#define HDCP_PORT_STS_AUTH_STREAM_ID_SHIFT 0x4
	#define HDCP_PORT_STS_AUTH_STREAM_ID_MASK 0x10
	#define HDCP_PORT_STS_LAST_ERR_SHIFT 0x5
	#define HDCP_PORT_STS_LAST_ERR_MASK (0x0F << 5)
	#define GET_HDCP_PORT_STS_LAST_ERR(__sts__) \
	(((__sts__) & HDCP_PORT_STS_LAST_ERR_MASK) >> \
	HDCP_PORT_STS_LAST_ERR_SHIFT)
	#define HDCP_PORT_STS_1_1_FEATURES 0x200

	#define HDCP_DPCD_CERTRX_ADDRESS 0x6900B

	#define HDCP_CONFIG_NONE ((u8) 0)
	#define HDCP_CONFIG_1_4 ((u8) 1) /* use HDCP 1.4 only */
	#define HDCP_CONFIG_2_2 ((u8) 2) /* use HDCP 2.2 only */
	/* use All HDCP versions */
	#define HDCP_CONFIG_ALL (HDCP_CONFIG_1_4 \| HDCP_CONFIG_2_2)

	static void imx_hdcp_print_port_status(uint16_t sts)
	{
	DRM_DEBUG_KMS("INFO: HDCP Port Status: 0x%04x\n", sts);
	DRM_DEBUG_KMS(" Authenticated: %d\n",
	(bool)(sts & HDCP_PORT_STS_AUTH));
	DRM_DEBUG_KMS(" Receiver is repeater: %d\n",
	(bool)(sts & HDCP_PORT_STS_REPEATER));
	DRM_DEBUG_KMS(" RX Type: %s\n",
	g_rx_type[((sts & HDCP_PORT_STS_TYPE_MASK)
	>> HDCP_PORT_STS_TYPE_SHIFT)]);
	DRM_DEBUG_KMS(" AuthStreamId: %d\n",
	(bool)(sts & HDCP_PORT_STS_AUTH_STREAM_ID_MASK));
	DRM_DEBUG_KMS(" Last Error: %s\n",
	g_last_error[((sts & HDCP_PORT_STS_LAST_ERR_MASK)
	>> HDCP_PORT_STS_LAST_ERR_SHIFT)]);
	DRM_DEBUG_KMS(" Enable 1.1 Features: %d\n",
	(bool)(sts & HDCP_PORT_STS_1_1_FEATURES));
	}

	static unsigned int wait4event(struct imx_hdp *hdp,
	unsigned int *events,
	unsigned int event_to_wait)
	{
	unsigned int reg_events;
	unsigned int returned_events;
	unsigned int event_mask = 1U << event_to_wait \|
	1U << EVENT_ID_HDCPTX_STATUS;
	int timeout = 50000; /* 50000 * 10 u is at least ~500 miliseconds */

	while ((event_mask & *events) == 0) {
	if (timeout-- == 0)
	return 0;
	udelay(10);
	CDN_API_Get_Event(&hdp->state, &reg_events);
	*events \|= reg_events;
	}

	returned_events = *events & event_mask;
	*events &= ~event_mask;
	return returned_events;
	}

	static inline
	uint16_t imx_hdcp_get_port_status(u8 hdcp_status[HDCP_STATUS_SIZE])
	{
	return (hdcp_status[0] << 8) \| hdcp_status[1];
	}

	static u16 imx_hdcp_get_status(struct imx_hdp *hdp)
	{
	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
	u8 hdcp_status[HDCP_STATUS_SIZE];
	u16 hdcp_port_status;

	DRM_DEBUG_KMS("INFO: Reading HDCP TX status\n");
	CDN_API_HDCP_TX_STATUS_REQ_blocking(&hdp->state, hdcp_status, bt);

	hdcp_port_status = imx_hdcp_get_port_status(hdcp_status);

	return hdcp_port_status;
	}

	static inline unsigned char check_event(unsigned int events,
	unsigned int tested)
	{
	if ((events & (1 << tested)) == 0)
	return 0;
	return 1;
	}

	/* Prints status. Returns error code (0 = no error) */
	static unsigned char imx_hdcp_handle_status(unsigned short status)
	{
	imx_hdcp_print_port_status(status);
	if (status & HDCP_PORT_STS_LAST_ERR_MASK)
	DRM_ERROR("ERROR: HDCP error was set to %s\n",
	g_last_error[((status & HDCP_PORT_STS_LAST_ERR_MASK)
	>> HDCP_PORT_STS_LAST_ERR_SHIFT)]);
	return GET_HDCP_PORT_STS_LAST_ERR(status);
	}

	static int imx_hdcp_set_config(struct imx_hdp *hdp, u8 hdcp_config)
	{
	CDN_API_STATUS ret;
	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
	uint8_t apb_cfg_dpcd_sts = 0;
	uint8_t apb_cfg_hdcp_sts = 0;
	uint8_t apb_cfg_capb_sts = 0;
	uint8_t hdcp_cfg;

	unsigned int events = 0;
	unsigned int retEvents;
	unsigned short hdcp_port_status;

	if (bt == CDN_BUS_TYPE_SAPB) {
	DRM_DEBUG_KMS("INFO: Switching HDCP Commands to SAPB.\n");
	ret = CDN_API_ApbConf_blocking
	(&hdp->state,
	0, 0, /* set DPCD to APB (don't lock) */
	1, 0, /* set HDCP to SAPB (don't lock) */
	0, 0, /* set CAPB owner CPU (don't lock) */
	&apb_cfg_dpcd_sts,
	&apb_cfg_hdcp_sts,
	&apb_cfg_capb_sts);

	if (ret != CDN_OK) {
	DRM_ERROR("Failed to set APB configuration.\n");
	return -1;
	}
	if (apb_cfg_hdcp_sts == 1) { /* 1 - locked */
	DRM_ERROR("Failed to switch HDCP to SAPB Mailbox\n");
	return -1;
	}
	DRM_DEBUG_KMS("INFO: HDCP switched to SAPB\n");
	} else
	DRM_DEBUG_KMS("INFO: Leaving HDCP to APB\n");

	/* HDCP 2.2(and/or 1.4) \| activate \| km-key \| 0 */
	hdcp_cfg = hdcp_config \| 0x04 \| 0x10 \| (HDCP_CONTENT_TYPE_0 << 3);

	DRM_DEBUG_KMS("INFO: Enabling HDCP...\n");
	CDN_API_HDCP_TX_CONFIGURATION_blocking(&hdp->state, hdcp_cfg, bt);

	/* Wait until HDCP_TX_STATUS EVENT appears */
	DRM_DEBUG_KMS("INFO: wait4event -> EVENT_ID_HDCPTX_STATUS\n");
	retEvents = wait4event(hdp, &events, EVENT_ID_HDCPTX_STATUS);

	/* Set TX STATUS REQUEST */
	DRM_DEBUG_KMS("INFO: Getting port status\n");
	hdcp_port_status = imx_hdcp_get_status(hdp);
	if (imx_hdcp_handle_status(hdcp_port_status) != 0)
	return -1;

	return 0;
	}

	static int imx_hdcp_auth_check(struct imx_hdp *hdp)
	{
	u32 events;
	u16 hdcp_port_status;

	/* Wait until HDCP_TX_STATUS EVENT appears */
	events = wait4event(hdp, &events, EVENT_ID_HDCPTX_STATUS);
	if (events == 0)
	return -1;
	DRM_DEBUG_KMS("HDCP: EVENT_ID_HDCPTX_STATUS\n");

	hdcp_port_status = imx_hdcp_get_status(hdp);
	if (imx_hdcp_handle_status(hdcp_port_status) != 0)
	return -1;

	if (hdcp_port_status & 1) {
	DRM_INFO("Authentication completed successfully!\n");
	return 0;
	}
	DRM_ERROR("Authentication failed\n");
	return -1;
	}

	static int imx_hdcp_check_receviers(struct imx_hdp *hdp)
	{
	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
	unsigned int events = 0;
	unsigned int ret_events;
	uint8_t hdcp_num_rec;
	uint8_t hdcp_rec_id[HDCP_MAX_RECEIVERS][HDCP_RECEIVER_ID_SIZE_BYTES];
	uint8_t i;

	DRM_DEBUG_KMS("INFO: Waiting for Receiver ID valid event\n");
	ret_events = wait4event(hdp, &events,
	EVENT_ID_HDCPTX_IS_RECEIVER_ID_VALID);
	DRM_DEBUG_KMS("INFO: Requesting Receivers ID's\n");

	hdcp_num_rec = 0;
	memset(&hdcp_rec_id, 0, sizeof(hdcp_rec_id));

	CDN_API_HDCP_TX_IS_RECEIVER_ID_VALID_REQ_blocking
	(&hdp->state,
	&hdcp_num_rec,
	(unsigned char *)
	hdcp_rec_id,
	bt
	);

	DRM_DEBUG_KMS("INFO: Number of Receivers: %d\n", hdcp_num_rec);

	for (i = 0; i < hdcp_num_rec; ++i) {
	DRM_INFO("\tReveiver ID%2d: %.2X%.2X%.2X%.2X%.2X\n",
	i,
	hdcp_rec_id[i][0],
	hdcp_rec_id[i][1],
	hdcp_rec_id[i][2],
	hdcp_rec_id[i][3],
	hdcp_rec_id[i][4]
	);
	}

	/* fixme: Check Receiver ID's against revocation list */

	DRM_DEBUG_KMS("INFO: Responding with Receiver ID's OK!\n");
	CDN_API_HDCP_TX_RESPOND_RECEIVER_ID_VALID_blocking(&hdp->state, 1,
	hdp->hdcp.bus_type);

	return 0;
	}

	static inline int imx_hdcp_auth_22(struct imx_hdp *hdp)
	{
	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;
	unsigned char kmStored = 0;
	unsigned int events = 0;
	unsigned int retEvents;
	unsigned short hdcp_port_status;
	u8 resp[HDCP_STATUS_SIZE];
	S_HDCP_TRANS_PAIRING_DATA pairing;

	DRM_DEBUG_KMS("HDCP: Start 2.2 Authentication\n");

	/* Wait until HDCP2_TX_IS_KM_STORED EVENT appears */
	retEvents = 0;
	DRM_DEBUG_KMS("INFO: Wait until HDCP2_TX_IS_KM_STORED EVENT appears\n");
	while (check_event(retEvents, EVENT_ID_HDCPTX_IS_KM_STORED) == 0) {
	DRM_DEBUG_KMS("INFO: Waiting FOR _IS_KM_STORED EVENT\n");
	retEvents = wait4event(hdp, &events,
	EVENT_ID_HDCPTX_IS_KM_STORED);
	if (retEvents == 0) {
	/* time out occurred, stop hdcp and return error */
	CDN_API_HDCP_TX_CONFIGURATION_blocking(&hdp->state,
	0, bt);
	return -1;
	}
	if (check_event(retEvents, EVENT_ID_HDCPTX_STATUS) != 0) {
	hdcp_port_status = imx_hdcp_get_status(hdp);
	if (imx_hdcp_handle_status(hdcp_port_status) != 0)
	return -1;
	}
	}

	DRM_DEBUG_KMS("HDCP: EVENT_ID_HDCPTX_IS_KM_STORED\n");

	/* Set HDCP2 TX KM STORED REQUEST */
	CDN_API_HDCP2_TX_IS_KM_STORED_REQ_blocking(&hdp->state, resp, bt);
	DRM_DEBUG_KMS("HDCP: CDN_API_HDCP2_TX_IS_KM_STORED_REQ_blocking\n");
	DRM_DEBUG_KMS("HDCP: Receiver ID: 0x%x%x%x%x%x\n",
	resp[0], resp[1], resp[2], resp[3], resp[4]);

	/* Check if KM is stored */
	if (kmStored != 0) {
	DRM_DEBUG_KMS("INFO: KM is stored\n");
	/* Set HDCP2 TX RESPOND KM with stored KM */
	memcpy(pairing.receiver_id, recv_id, sizeof(recv_id));
	memcpy(pairing.m, m, sizeof(m));
	memcpy(pairing.km, km, sizeof(km));
	memcpy(pairing.ekh, ekhkm, sizeof(ekhkm));
	CDN_API_HDCP2_TX_RESPOND_KM_blocking(&hdp->state, &pairing, bt);
	DRM_DEBUG_KMS("HDCP: CDN_API_HDCP2_TX_RESPOND_KM_blocking\n");
	} else { /* KM is not stored */
	DRM_DEBUG_KMS("INFO: KM is not stored\n");
	/* Set HDCP2 TX RESPOND KM with empty data */
	CDN_API_HDCP2_TX_RESPOND_KM_blocking(&hdp->state, NULL, bt);
	}

	imx_hdcp_check_receviers(hdp);

	/* Check if KM is not stored */
	if (kmStored == 0) {
	/* Wait until HDCP2_TX_STORE_KM EVENT appears */
	retEvents = 0;
	while (check_event(retEvents, EVENT_ID_HDCPTX_STORE_KM) == 0) {
	retEvents = wait4event(hdp, &events,
	EVENT_ID_HDCPTX_STORE_KM);
	if (check_event(retEvents, EVENT_ID_HDCPTX_STATUS)
	!= 0) {
	hdcp_port_status = imx_hdcp_get_status(hdp);
	if (imx_hdcp_handle_status(hdcp_port_status)
	!= 0)
	return -1;
	}
	}
	DRM_DEBUG_KMS("HDCP: EVENT_ID_HDCPTX_STORE_KM\n");

	/* Set HDCP2_TX_STORE_KM REQUEST */
	CDN_API_HDCP2_TX_STORE_KM_REQ_blocking(&hdp->state, &pairing,
	bt);
	DRM_DEBUG_KMS("HDCP: CDN_API_HDCP2_TX_STORE_KM_REQ_blocking");
	}

	return 0;
	}

	static inline int imx_hdcp_auth_14(struct imx_hdp *hdp)
	{
	DRM_DEBUG_KMS("HDCP: Starting 1.4 Authentication\n");
	return imx_hdcp_check_receviers(hdp);
	}

	static int imx_hdcp_auth(struct imx_hdp *hdp, u8 hdcp_config)
	{
	int ret;

	DRM_DEBUG_KMS("HDCP: Start Authentication\n");
	ret = imx_hdcp_set_config(hdp, hdcp_config);
	if (ret) {
	DRM_ERROR("imx_hdcp_set_config failed\n");
	return -1;
	}
	if (hdcp_config == HDCP_TX_1)
	ret = imx_hdcp_auth_14(hdp);
	else
	ret = imx_hdcp_auth_22(hdp);

	if (ret) {
	DRM_ERROR("imx_hdcp_auth_%s failed\n",
	(hdcp_config == HDCP_TX_1) ? "14" : "22");
	return -1;
	}

	ret = imx_hdcp_auth_check(hdp);
	if (ret)
	ret = imx_hdcp_auth_check(hdp);
	return ret;
	}

	static int _imx_hdcp_disable(struct imx_hdp *hdp)
	{
	int ret = 0;
	uint8_t hdcp_cfg = 0;
	CDN_BUS_TYPE bt = hdp->hdcp.bus_type;

	DRM_DEBUG_KMS("[%s:%d] HDCP is being disabled...\n",
	hdp->connector.name, hdp->connector.base.id);
	DRM_DEBUG_KMS("INFO: Disabling HDCP...\n");

	ret = CDN_API_HDCP_TX_CONFIGURATION_blocking(&hdp->state, hdcp_cfg, bt);

	DRM_DEBUG_KMS("HDCP is disabled\n");

	return ret;
	}


	static int _imx_hdcp_enable(struct imx_hdp *hdp)
	{
	int i, ret = 0, tries = 3;

	DRM_DEBUG_KMS("[%s:%d] HDCP is being enabled...\n",
	hdp->connector.name, hdp->connector.base.id);

	/* Incase of authentication failures, HDCP spec expects reauth. */
	for (i = 0; i < tries; i++) {
	if (hdp->hdcp.config & HDCP_CONFIG_2_2) {
	ret = imx_hdcp_auth(hdp, HDCP_TX_2);
	if (ret == 0)
	return 0;
	}
	_imx_hdcp_disable(hdp);
	if (hdp->hdcp.config & HDCP_CONFIG_1_4) {
	ret = imx_hdcp_auth(hdp, HDCP_TX_1);
	if (!ret)
	return 0;
	}
	DRM_DEBUG_KMS("HDCP Auth failure (%d)\n", ret);

	/* Ensuring HDCP encryption and signalling are stopped. */
	_imx_hdcp_disable(hdp);
	}

	DRM_ERROR("HDCP authentication failed (%d tries/%d)\n", tries, ret);
	return ret;
	}

	static void imx_hdcp_check_work(struct work_struct *work)
	{
	struct imx_hdcp *hdcp = container_of(work,
	struct imx_hdcp,
	check_work.work);
	struct imx_hdp *hdp = container_of(hdcp,
	struct imx_hdp,
	hdcp);
	if (!imx_hdcp_check_link(hdp))
	schedule_delayed_work(&hdcp->check_work,
	DRM_HDCP_CHECK_PERIOD_MS);
	}


	static void imx_hdcp_prop_work(struct work_struct *work)
	{
	struct imx_hdcp *hdcp = container_of(work,
	struct imx_hdcp,
	prop_work);
	struct imx_hdp *hdp = container_of(hdcp,
	struct imx_hdp,
	hdcp);

	struct drm_device *dev = hdp->drm_dev;
	struct drm_connector_state *state;

	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
	mutex_lock(&hdp->hdcp.mutex);

	/*
	* This worker is only used to flip between ENABLED/DESIRED. Either of
	* those to UNDESIRED is handled by core. If hdcp_value == UNDESIRED,
	* we're running just after hdcp has been disabled, so just exit
	*/
	if (hdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
	state = hdp->connector.state;
	state->content_protection = hdp->hdcp.value;
	}

	mutex_unlock(&hdp->hdcp.mutex);
	drm_modeset_unlock(&dev->mode_config.connection_mutex);
	}

	static void show_hdcp_supported(struct imx_hdp *hdp)
	{
	if ((hdp->hdcp.config & (HDCP_CONFIG_1_4 \| HDCP_CONFIG_2_2)) ==
	(HDCP_CONFIG_1_4 \| HDCP_CONFIG_2_2))
	DRM_INFO("Both HDCP 1.4 and 2 2 are enabled\n");
	else if (hdp->hdcp.config & HDCP_CONFIG_1_4)
	DRM_INFO("Only HDCP 1.4 is enabled\n");
	else if (hdp->hdcp.config & HDCP_CONFIG_2_2)
	DRM_INFO("Only HDCP 2.2 is enabled\n");
	else
	DRM_INFO("HDCP is disabled\n");
	}

	int imx_hdcp_init(struct imx_hdp hdp, struct device_node of_node)
	{
	int ret;
	const char *compat;
	u32 temp;

	ret = of_property_read_string(of_node, "compatible", &compat);
	if (ret) {
	DRM_ERROR("Failed to compatible dts string\n");
	return ret;
	}

	ret = of_property_read_u32(of_node, "hdcp-config", &temp);
	if (ret) {
	/* hdp->hdcp_config = HDCP_CONFIG_ALL; */
	/* using highest level by default */
	hdp->hdcp.config = HDCP_CONFIG_2_2;
	DRM_INFO("Failed to get HDCP config - using HDCP 2.2 only\n");
	} else {
	hdp->hdcp.config = temp;
	show_hdcp_supported(hdp);
	}

	if (!check_hdcp_enabled())
	return -EPERM;

	if (!strstr(compat, "hdmi"))
	return -EPERM;

	if (strstr(compat, "imx8mq"))
	hdp->hdcp.bus_type = CDN_BUS_TYPE_SAPB;
	else
	hdp->hdcp.bus_type = CDN_BUS_TYPE_APB;

	ret = drm_connector_attach_content_protection_property(&hdp->connector);
	if (ret)
	return ret;

	/connector->hdcp_shim = hdcp_shim;/
	mutex_init(&hdp->hdcp.mutex);
	INIT_DELAYED_WORK(&hdp->hdcp.check_work, imx_hdcp_check_work);
	INIT_WORK(&hdp->hdcp.prop_work, imx_hdcp_prop_work);
	return 0;
	}

	int imx_hdcp_enable(struct imx_hdp *hdp)
	{
	int ret;

	mutex_lock(&hdp->hdcp.mutex);

	ret = _imx_hdcp_enable(hdp);
	if (ret)
	goto out;

	hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
	schedule_work(&hdp->hdcp.prop_work);
	schedule_delayed_work(&hdp->hdcp.check_work,
	DRM_HDCP_CHECK_PERIOD_MS);
	out:
	mutex_unlock(&hdp->hdcp.mutex);
	return ret;
	}

	int imx_hdcp_disable(struct imx_hdp *hdp)
	{
	int ret = 0;

	mutex_lock(&hdp->hdcp.mutex);
	if (hdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
	hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
	ret = _imx_hdcp_disable(hdp);
	}
	mutex_unlock(&hdp->hdcp.mutex);
	cancel_delayed_work_sync(&hdp->hdcp.check_work);

	return ret;
	}

	void imx_hdcp_atomic_check(struct drm_connector *connector,
	struct drm_connector_state *old_state,
	struct drm_connector_state *new_state)
	{
	uint64_t old_cp = old_state->content_protection;
	uint64_t new_cp = new_state->content_protection;
	struct drm_crtc_state *crtc_state;

	if (!new_state->crtc) {
	/*
	* If the connector is being disabled with CP enabled, mark it
	* desired so it's re-enabled when the connector is brought back
	*/
	if (old_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED)
	new_state->content_protection =
	DRM_MODE_CONTENT_PROTECTION_DESIRED;
	return;
	}

	/*
	* Nothing to do if the state didn't change, or HDCP was activated since
	* the last commit
	*/
	if (old_cp == new_cp \|\|
	(old_cp == DRM_MODE_CONTENT_PROTECTION_DESIRED &&
	new_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED))
	return;

	crtc_state = drm_atomic_get_new_crtc_state(new_state->state,
	new_state->crtc);
	crtc_state->mode_changed = true;
	}

	int imx_hdcp_check_link(struct imx_hdp *hdp)
	{
	int ret = 0;
	u16 hdcp_port_status;
	u8 hdcp_last_error;

	mutex_lock(&hdp->hdcp.mutex);

	if (hdp->hdcp.value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
	goto out;

	/* get port status */
	hdcp_port_status = imx_hdcp_get_status(hdp);
	hdcp_last_error = GET_HDCP_PORT_STS_LAST_ERR(hdcp_port_status);
	if (hdcp_last_error)
	DRM_ERROR("HDCP error no: %u\n", hdcp_last_error);

	if (hdcp_port_status & HDCP_PORT_STS_AUTH) {
	if (hdp->hdcp.value !=
	DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
	hdp->hdcp.value =
	DRM_MODE_CONTENT_PROTECTION_ENABLED;
	schedule_work(&hdp->hdcp.prop_work);
	}
	DRM_DEBUG_KMS("INFO: HDCP authenticated\n");
	/* HDCP is authenticated*/
	goto out;
	}

	DRM_DEBUG_KMS("[%s:%d] HDCP link failed, retrying authentication\n",
	hdp->connector.name, hdp->connector.base.id);

	ret = _imx_hdcp_disable(hdp);
	if (ret) {
	DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
	hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
	schedule_work(&hdp->hdcp.prop_work);
	goto out;
	}

	ret = _imx_hdcp_enable(hdp);
	if (ret) {
	DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
	hdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
	schedule_work(&hdp->hdcp.prop_work);
	goto out;
	}

	out:
	mutex_unlock(&hdp->hdcp.mutex);
	return ret;
	}