i915/display/intel_hdcp.c

45 				     struct intel_hdcp *hdcp,
57 		rekey_reg = TRANS_DDI_FUNC_CTL(display, hdcp->cpu_transcoder);
61 		rekey_reg = TRANS_DDI_FUNC_CTL(display, hdcp->cpu_transcoder);
64 		rekey_reg = CHICKEN_TRANS(display, hdcp->cpu_transcoder);
118 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
122 	if (dig_port->hdcp.auth_status)
127 	if (!dig_port->hdcp.mst_type1_capable)
170 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
171 	struct intel_hdcp *hdcp = &connector->hdcp;
178 	data->streams[0].stream_type = hdcp->content_type;
223 	const struct intel_hdcp_shim *shim = connector->hdcp.shim;
252 	struct intel_hdcp *hdcp = &connector->hdcp;
255 	if (!hdcp->hdcp2_supported)
265 	mutex_lock(&display->hdcp.hdcp_mutex);
266 	if (!display->hdcp.comp_added || !display->hdcp.arbiter) {
267 		mutex_unlock(&display->hdcp.hdcp_mutex);
270 	mutex_unlock(&display->hdcp.hdcp_mutex);
278 	struct intel_hdcp *hdcp = &connector->hdcp;
285 	hdcp->shim->hdcp_2_2_get_capability(connector, &capable);
294 	struct intel_hdcp *hdcp = &connector->hdcp;
296 	if (!hdcp->shim->get_remote_hdcp_capability)
299 	hdcp->shim->get_remote_hdcp_capability(connector, hdcp_capable,
362 	 * Another req for hdcp key loadability is enabled state of pll for
489 	enum transcoder cpu_transcoder = connector->hdcp.cpu_transcoder;
731 	const struct intel_hdcp_shim *shim = connector->hdcp.shim;
814 	struct intel_hdcp *hdcp = &connector->hdcp;
815 	const struct intel_hdcp_shim *shim = hdcp->shim;
816 	enum transcoder cpu_transcoder = connector->hdcp.cpu_transcoder;
972 			    transcoder_name(hdcp->stream_transcoder));
986 	struct intel_hdcp *hdcp = &connector->hdcp;
988 	enum transcoder cpu_transcoder = hdcp->cpu_transcoder;
995 	if (hdcp->shim->stream_encryption) {
996 		ret = hdcp->shim->stream_encryption(connector, false);
1003 			    transcoder_name(hdcp->stream_transcoder));
1009 		if (dig_port->hdcp.num_streams > 0)
1013 	hdcp->hdcp_encrypted = false;
1027 	ret = hdcp->shim->toggle_signalling(dig_port, cpu_transcoder, false);
1040 	struct intel_hdcp *hdcp = &connector->hdcp;
1063 	intel_hdcp_adjust_hdcp_line_rekeying(connector->encoder, hdcp, true);
1069 			hdcp->hdcp_encrypted = true;
1084 static struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)
1086 	return container_of(hdcp, struct intel_connector, hdcp);
1094 	struct intel_hdcp *hdcp = &connector->hdcp;
1096 	drm_WARN_ON(display->drm, !mutex_is_locked(&hdcp->mutex));
1098 	if (hdcp->value == value)
1101 	drm_WARN_ON(display->drm, !mutex_is_locked(&dig_port->hdcp.mutex));
1103 	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_ENABLED) {
1104 		if (!drm_WARN_ON(display->drm, dig_port->hdcp.num_streams == 0))
1105 			dig_port->hdcp.num_streams--;
1107 		dig_port->hdcp.num_streams++;
1110 	hdcp->value = value;
1113 		if (!queue_work(display->wq.unordered, &hdcp->prop_work))
1123 	struct intel_hdcp *hdcp = &connector->hdcp;
1128 	mutex_lock(&hdcp->mutex);
1129 	mutex_lock(&dig_port->hdcp.mutex);
1131 	cpu_transcoder = hdcp->cpu_transcoder;
1134 	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_ENABLED ||
1135 	    !hdcp->hdcp_encrypted) {
1153 	if (hdcp->shim->check_link(dig_port, connector)) {
1154 		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
1167 		drm_err(display->drm, "Failed to disable hdcp (%d)\n", ret);
1176 		drm_err(display->drm, "Failed to enable hdcp (%d)\n", ret);
1184 	mutex_unlock(&dig_port->hdcp.mutex);
1185 	mutex_unlock(&hdcp->mutex);
1191 	struct intel_hdcp *hdcp = container_of(work, struct intel_hdcp,
1193 	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
1197 	mutex_lock(&hdcp->mutex);
1202 	 * we're running just after hdcp has been disabled, so just exit
1204 	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
1206 						   hdcp->value);
1208 	mutex_unlock(&hdcp->mutex);
1226 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1230 	mutex_lock(&display->hdcp.hdcp_mutex);
1231 	arbiter = display->hdcp.arbiter;
1234 		mutex_unlock(&display->hdcp.hdcp_mutex);
1242 	mutex_unlock(&display->hdcp.hdcp_mutex);
1256 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1260 	mutex_lock(&display->hdcp.hdcp_mutex);
1261 	arbiter = display->hdcp.arbiter;
1264 		mutex_unlock(&display->hdcp.hdcp_mutex);
1274 	mutex_unlock(&display->hdcp.hdcp_mutex);
1284 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1288 	mutex_lock(&display->hdcp.hdcp_mutex);
1289 	arbiter = display->hdcp.arbiter;
1292 		mutex_unlock(&display->hdcp.hdcp_mutex);
1299 	mutex_unlock(&display->hdcp.hdcp_mutex);
1310 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1314 	mutex_lock(&display->hdcp.hdcp_mutex);
1315 	arbiter = display->hdcp.arbiter;
1318 		mutex_unlock(&display->hdcp.hdcp_mutex);
1326 	mutex_unlock(&display->hdcp.hdcp_mutex);
1337 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1341 	mutex_lock(&display->hdcp.hdcp_mutex);
1342 	arbiter = display->hdcp.arbiter;
1345 		mutex_unlock(&display->hdcp.hdcp_mutex);
1353 	mutex_unlock(&display->hdcp.hdcp_mutex);
1364 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1368 	mutex_lock(&display->hdcp.hdcp_mutex);
1369 	arbiter = display->hdcp.arbiter;
1372 		mutex_unlock(&display->hdcp.hdcp_mutex);
1380 	mutex_unlock(&display->hdcp.hdcp_mutex);
1390 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1394 	mutex_lock(&display->hdcp.hdcp_mutex);
1395 	arbiter = display->hdcp.arbiter;
1398 		mutex_unlock(&display->hdcp.hdcp_mutex);
1406 	mutex_unlock(&display->hdcp.hdcp_mutex);
1419 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1423 	mutex_lock(&display->hdcp.hdcp_mutex);
1424 	arbiter = display->hdcp.arbiter;
1427 		mutex_unlock(&display->hdcp.hdcp_mutex);
1438 	mutex_unlock(&display->hdcp.hdcp_mutex);
1449 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1453 	mutex_lock(&display->hdcp.hdcp_mutex);
1454 	arbiter = display->hdcp.arbiter;
1457 		mutex_unlock(&display->hdcp.hdcp_mutex);
1464 	mutex_unlock(&display->hdcp.hdcp_mutex);
1473 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1477 	mutex_lock(&display->hdcp.hdcp_mutex);
1478 	arbiter = display->hdcp.arbiter;
1481 		mutex_unlock(&display->hdcp.hdcp_mutex);
1487 		drm_dbg_kms(display->drm, "Enable hdcp auth failed. %d\n",
1489 	mutex_unlock(&display->hdcp.hdcp_mutex);
1501 	mutex_lock(&display->hdcp.hdcp_mutex);
1502 	arbiter = display->hdcp.arbiter;
1505 		mutex_unlock(&display->hdcp.hdcp_mutex);
1510 					     &dig_port->hdcp.port_data);
1511 	mutex_unlock(&display->hdcp.hdcp_mutex);
1527 	struct intel_hdcp *hdcp = &connector->hdcp;
1535 	const struct intel_hdcp_shim *shim = hdcp->shim;
1540 	hdcp->seq_num_v = 0;
1541 	hdcp->seq_num_m = 0;
1591 	hdcp->is_repeater = HDCP_2_2_RX_REPEATER(msgs.send_cert.rx_caps[2]);
1605 					      &hdcp->is_paired,
1623 	if (!hdcp->is_paired) {
1635 		hdcp->is_paired = true;
1643 	struct intel_hdcp *hdcp = &connector->hdcp;
1648 	const struct intel_hdcp_shim *shim = hdcp->shim;
1678 	struct intel_hdcp *hdcp = &connector->hdcp;
1686 	ret = hdcp->shim->write_2_2_msg(connector, &send_eks,
1698 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1699 	struct intel_hdcp *hdcp = &connector->hdcp;
1704 	const struct intel_hdcp_shim *shim = hdcp->shim;
1707 	if (connector->hdcp.seq_num_m > HDCP_2_2_SEQ_NUM_MAX)
1712 	drm_hdcp_cpu_to_be24(msgs.stream_manage.seq_num_m, hdcp->seq_num_m);
1734 	data->seq_num_m = hdcp->seq_num_m;
1739 	hdcp->seq_num_m++;
1749 	struct intel_hdcp *hdcp = &connector->hdcp;
1754 	const struct intel_hdcp_shim *shim = hdcp->shim;
1776 	dig_port->hdcp.mst_type1_capable =
1780 	if (!dig_port->hdcp.mst_type1_capable && hdcp->content_type) {
1790 	if (!hdcp->hdcp2_encrypted && seq_num_v) {
1796 	if (seq_num_v < hdcp->seq_num_v) {
1817 	hdcp->seq_num_v = seq_num_v;
1829 	struct intel_hdcp *hdcp = &connector->hdcp;
1830 	const struct intel_hdcp_shim *shim = hdcp->shim;
1854 					       hdcp->is_repeater,
1855 					       hdcp->content_type);
1860 	if (hdcp->is_repeater) {
1876 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
1877 	struct intel_hdcp *hdcp = &connector->hdcp;
1878 	enum transcoder cpu_transcoder = hdcp->cpu_transcoder;
1890 	if (hdcp->shim->stream_2_2_encryption) {
1891 		ret = hdcp->shim->stream_2_2_encryption(connector, true);
1898 			    transcoder_name(hdcp->stream_transcoder));
1907 	dig_port->hdcp.auth_status = false;
1917 	struct intel_hdcp *hdcp = &connector->hdcp;
1919 	enum transcoder cpu_transcoder = hdcp->cpu_transcoder;
1925 	if (hdcp->shim->toggle_signalling) {
1926 		ret = hdcp->shim->toggle_signalling(dig_port, cpu_transcoder,
1947 	dig_port->hdcp.auth_status = true;
1956 	struct intel_hdcp *hdcp = &connector->hdcp;
1958 	enum transcoder cpu_transcoder = hdcp->cpu_transcoder;
1976 	if (hdcp->shim->toggle_signalling) {
1977 		ret = hdcp->shim->toggle_signalling(dig_port, cpu_transcoder,
1996 	if (!connector->hdcp.is_repeater)
2005 		if (connector->hdcp.seq_num_m > HDCP_2_2_SEQ_NUM_MAX) {
2026 	for (i = 0; i < tries && !dig_port->hdcp.auth_status; i++) {
2052 		/* Clearing the mei hdcp session */
2059 	if (!ret && !dig_port->hdcp.auth_status) {
2084 	struct intel_hdcp *hdcp = &connector->hdcp;
2089 		    hdcp->content_type);
2091 	intel_hdcp_adjust_hdcp_line_rekeying(connector->encoder, hdcp, false);
2096 			    hdcp->content_type, ret);
2102 		    hdcp->content_type);
2104 	hdcp->hdcp2_encrypted = true;
2113 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
2114 	struct intel_hdcp *hdcp = &connector->hdcp;
2120 	if (hdcp->shim->stream_2_2_encryption) {
2121 		ret = hdcp->shim->stream_2_2_encryption(connector, false);
2128 			    transcoder_name(hdcp->stream_transcoder));
2130 		if (dig_port->hdcp.num_streams > 0 && !hdcp2_link_recovery)
2139 	connector->hdcp.hdcp2_encrypted = false;
2140 	dig_port->hdcp.auth_status = false;
2151 	struct intel_hdcp *hdcp = &connector->hdcp;
2156 	mutex_lock(&hdcp->mutex);
2157 	mutex_lock(&dig_port->hdcp.mutex);
2158 	cpu_transcoder = hdcp->cpu_transcoder;
2161 	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_ENABLED ||
2162 	    !hdcp->hdcp2_encrypted) {
2180 	ret = hdcp->shim->check_2_2_link(dig_port, connector);
2182 		if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
2191 		if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
2228 	mutex_unlock(&dig_port->hdcp.mutex);
2229 	mutex_unlock(&hdcp->mutex);
2235 	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
2238 	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
2245 		queue_delayed_work(display->wq.unordered, &hdcp->check_work,
2248 		queue_delayed_work(display->wq.unordered, &hdcp->check_work,
2258 	mutex_lock(&display->hdcp.hdcp_mutex);
2259 	display->hdcp.arbiter = (struct i915_hdcp_arbiter *)data;
2260 	display->hdcp.arbiter->hdcp_dev = mei_kdev;
2261 	mutex_unlock(&display->hdcp.hdcp_mutex);
2272 	mutex_lock(&display->hdcp.hdcp_mutex);
2273 	display->hdcp.arbiter = NULL;
2274 	mutex_unlock(&display->hdcp.hdcp_mutex);
2309 	struct hdcp_port_data *data = &dig_port->hdcp.port_data;
2364 	mutex_lock(&display->hdcp.hdcp_mutex);
2365 	drm_WARN_ON(display->drm, display->hdcp.comp_added);
2367 	display->hdcp.comp_added = true;
2368 	mutex_unlock(&display->hdcp.hdcp_mutex);
2378 		mutex_lock(&display->hdcp.hdcp_mutex);
2379 		display->hdcp.comp_added = false;
2380 		mutex_unlock(&display->hdcp.hdcp_mutex);
2390 	struct intel_hdcp *hdcp = &connector->hdcp;
2395 		drm_dbg_kms(display->drm, "Mei hdcp data init failed\n");
2399 	hdcp->hdcp2_supported = true;
2407 	struct intel_hdcp *hdcp = &connector->hdcp;
2417 							       hdcp->hdcp2_supported);
2419 		hdcp->hdcp2_supported = false;
2420 		kfree(dig_port->hdcp.port_data.streams);
2424 	hdcp->shim = shim;
2425 	mutex_init(&hdcp->mutex);
2426 	INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);
2427 	INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);
2428 	init_waitqueue_head(&hdcp->cp_irq_queue);
2442 	struct intel_hdcp *hdcp = &connector->hdcp;
2446 	if (!hdcp->shim)
2455 	mutex_lock(&hdcp->mutex);
2456 	mutex_lock(&dig_port->hdcp.mutex);
2458 		    hdcp->value == DRM_MODE_CONTENT_PROTECTION_ENABLED);
2459 	hdcp->content_type = (u8)conn_state->hdcp_content_type;
2462 		hdcp->cpu_transcoder = pipe_config->mst_master_transcoder;
2463 		hdcp->stream_transcoder = pipe_config->cpu_transcoder;
2465 		hdcp->cpu_transcoder = pipe_config->cpu_transcoder;
2466 		hdcp->stream_transcoder = INVALID_TRANSCODER;
2470 		dig_port->hdcp.port_data.hdcp_transcoder =
2471 			intel_get_hdcp_transcoder(hdcp->cpu_transcoder);
2477 	if (!hdcp->force_hdcp14 && intel_hdcp2_get_capability(connector)) {
2484 	if (hdcp->force_hdcp14)
2492 	    hdcp->content_type != DRM_MODE_HDCP_CONTENT_TYPE1) {
2497 		queue_delayed_work(display->wq.unordered, &hdcp->check_work,
2504 	mutex_unlock(&dig_port->hdcp.mutex);
2505 	mutex_unlock(&hdcp->mutex);
2516 	struct intel_hdcp *hdcp = &connector->hdcp;
2519 	 * Enable hdcp if it's desired or if userspace is enabled and
2525 	    DRM_MODE_CONTENT_PROTECTION_ENABLED && hdcp->value ==
2533 	struct intel_hdcp *hdcp = &connector->hdcp;
2536 	if (!hdcp->shim)
2539 	mutex_lock(&hdcp->mutex);
2540 	mutex_lock(&dig_port->hdcp.mutex);
2542 	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
2547 	if (hdcp->hdcp2_encrypted)
2549 	else if (hdcp->hdcp_encrypted)
2553 	mutex_unlock(&dig_port->hdcp.mutex);
2554 	mutex_unlock(&hdcp->mutex);
2555 	cancel_delayed_work_sync(&hdcp->check_work);
2566 	struct intel_hdcp *hdcp = &connector->hdcp;
2570 	if (!connector->hdcp.shim)
2574 		(conn_state->hdcp_content_type != hdcp->content_type &&
2588 	 * Mark the hdcp state as DESIRED after the hdcp disable of type
2592 		mutex_lock(&hdcp->mutex);
2593 		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
2595 		if (!queue_work(display->wq.unordered, &hdcp->prop_work))
2597 		mutex_unlock(&hdcp->mutex);
2602 		mutex_lock(&hdcp->mutex);
2603 		/* Avoid enabling hdcp, if it already ENABLED */
2605 			hdcp->value != DRM_MODE_CONTENT_PROTECTION_ENABLED;
2606 		mutex_unlock(&hdcp->mutex);
2613 			if (!queue_work(display->wq.unordered, &hdcp->prop_work))
2625 	if (!connector->hdcp.shim)
2628 	cancel_delayed_work_sync(&connector->hdcp.check_work);
2629 	cancel_work_sync(&connector->hdcp.prop_work);
2634 	mutex_lock(&display->hdcp.hdcp_mutex);
2635 	if (!display->hdcp.comp_added) {
2636 		mutex_unlock(&display->hdcp.hdcp_mutex);
2640 	display->hdcp.comp_added = false;
2641 	mutex_unlock(&display->hdcp.hdcp_mutex);
2651 	struct intel_hdcp *hdcp = &connector->hdcp;
2653 	if (!hdcp->shim)
2667 	cancel_delayed_work_sync(&hdcp->check_work);
2678 	drm_WARN_ON(connector->base.dev, work_pending(&hdcp->prop_work));
2680 	mutex_lock(&hdcp->mutex);
2681 	hdcp->shim = NULL;
2682 	mutex_unlock(&hdcp->mutex);
2719 	 * the last commit. And also no change in hdcp content type.
2735 	struct intel_hdcp *hdcp = &connector->hdcp;
2738 	if (!hdcp->shim)
2741 	atomic_inc(&connector->hdcp.cp_irq_count);
2742 	wake_up_all(&connector->hdcp.cp_irq_queue);
2744 	queue_delayed_work(display->wq.unordered, &hdcp->check_work, 0);
2752 	if (!connector->hdcp.shim) {
2819 	struct intel_hdcp *hdcp = &connector->hdcp;
2830 	hdcp->force_hdcp14 = force_hdcp14;
2841 	struct intel_hdcp *hdcp = &connector->hdcp;
2859 		   str_yes_no(hdcp->force_hdcp14));