1 // SPDX-License-Identifier: MIT
2 /*
3 * Copyright 2023, Intel Corporation.
4 */
5
6 #include <drm/i915_hdcp_interface.h>
7
8 #include "gem/i915_gem_region.h"
9 #include "gt/intel_gt.h"
10 #include "gt/uc/intel_gsc_uc_heci_cmd_submit.h"
11 #include "i915_drv.h"
12 #include "i915_utils.h"
13 #include "intel_hdcp_gsc.h"
14
intel_hdcp_gsc_cs_required(struct drm_i915_private * i915)15 bool intel_hdcp_gsc_cs_required(struct drm_i915_private *i915)
16 {
17 return DISPLAY_VER(i915) >= 14;
18 }
19
20 static int
gsc_hdcp_initiate_session(struct device * dev,struct hdcp_port_data * data,struct hdcp2_ake_init * ake_data)21 gsc_hdcp_initiate_session(struct device *dev, struct hdcp_port_data *data,
22 struct hdcp2_ake_init *ake_data)
23 {
24 STUB();
25 return -ENOSYS;
26 #ifdef notyet
27 struct wired_cmd_initiate_hdcp2_session_in session_init_in = { { 0 } };
28 struct wired_cmd_initiate_hdcp2_session_out
29 session_init_out = { { 0 } };
30 struct drm_i915_private *i915;
31 ssize_t byte;
32
33 if (!dev || !data || !ake_data)
34 return -EINVAL;
35
36 i915 = kdev_to_i915(dev);
37 if (!i915) {
38 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
39 return -ENODEV;
40 }
41
42 session_init_in.header.api_version = HDCP_API_VERSION;
43 session_init_in.header.command_id = WIRED_INITIATE_HDCP2_SESSION;
44 session_init_in.header.status = FW_HDCP_STATUS_SUCCESS;
45 session_init_in.header.buffer_len =
46 WIRED_CMD_BUF_LEN_INITIATE_HDCP2_SESSION_IN;
47
48 session_init_in.port.integrated_port_type = data->port_type;
49 session_init_in.port.physical_port = (u8)data->hdcp_ddi;
50 session_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
51 session_init_in.protocol = data->protocol;
52
53 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&session_init_in,
54 sizeof(session_init_in),
55 (u8 *)&session_init_out,
56 sizeof(session_init_out));
57 if (byte < 0) {
58 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
59 return byte;
60 }
61
62 if (session_init_out.header.status != FW_HDCP_STATUS_SUCCESS) {
63 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. Status: 0x%X\n",
64 WIRED_INITIATE_HDCP2_SESSION,
65 session_init_out.header.status);
66 return -EIO;
67 }
68
69 ake_data->msg_id = HDCP_2_2_AKE_INIT;
70 ake_data->tx_caps = session_init_out.tx_caps;
71 memcpy(ake_data->r_tx, session_init_out.r_tx, HDCP_2_2_RTX_LEN);
72
73 return 0;
74 #endif
75 }
76
77 static int
gsc_hdcp_verify_receiver_cert_prepare_km(struct device * dev,struct hdcp_port_data * data,struct hdcp2_ake_send_cert * rx_cert,bool * km_stored,struct hdcp2_ake_no_stored_km * ek_pub_km,size_t * msg_sz)78 gsc_hdcp_verify_receiver_cert_prepare_km(struct device *dev,
79 struct hdcp_port_data *data,
80 struct hdcp2_ake_send_cert *rx_cert,
81 bool *km_stored,
82 struct hdcp2_ake_no_stored_km
83 *ek_pub_km,
84 size_t *msg_sz)
85 {
86 STUB();
87 return -ENOSYS;
88 #ifdef notyet
89 struct wired_cmd_verify_receiver_cert_in verify_rxcert_in = { { 0 } };
90 struct wired_cmd_verify_receiver_cert_out verify_rxcert_out = { { 0 } };
91 struct drm_i915_private *i915;
92 ssize_t byte;
93
94 if (!dev || !data || !rx_cert || !km_stored || !ek_pub_km || !msg_sz)
95 return -EINVAL;
96
97 i915 = kdev_to_i915(dev);
98 if (!i915) {
99 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
100 return -ENODEV;
101 }
102
103 verify_rxcert_in.header.api_version = HDCP_API_VERSION;
104 verify_rxcert_in.header.command_id = WIRED_VERIFY_RECEIVER_CERT;
105 verify_rxcert_in.header.status = FW_HDCP_STATUS_SUCCESS;
106 verify_rxcert_in.header.buffer_len =
107 WIRED_CMD_BUF_LEN_VERIFY_RECEIVER_CERT_IN;
108
109 verify_rxcert_in.port.integrated_port_type = data->port_type;
110 verify_rxcert_in.port.physical_port = (u8)data->hdcp_ddi;
111 verify_rxcert_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
112
113 verify_rxcert_in.cert_rx = rx_cert->cert_rx;
114 memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, HDCP_2_2_RRX_LEN);
115 memcpy(verify_rxcert_in.rx_caps, rx_cert->rx_caps, HDCP_2_2_RXCAPS_LEN);
116
117 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_rxcert_in,
118 sizeof(verify_rxcert_in),
119 (u8 *)&verify_rxcert_out,
120 sizeof(verify_rxcert_out));
121 if (byte < 0) {
122 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed: %zd\n", byte);
123 return byte;
124 }
125
126 if (verify_rxcert_out.header.status != FW_HDCP_STATUS_SUCCESS) {
127 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. Status: 0x%X\n",
128 WIRED_VERIFY_RECEIVER_CERT,
129 verify_rxcert_out.header.status);
130 return -EIO;
131 }
132
133 *km_stored = !!verify_rxcert_out.km_stored;
134 if (verify_rxcert_out.km_stored) {
135 ek_pub_km->msg_id = HDCP_2_2_AKE_STORED_KM;
136 *msg_sz = sizeof(struct hdcp2_ake_stored_km);
137 } else {
138 ek_pub_km->msg_id = HDCP_2_2_AKE_NO_STORED_KM;
139 *msg_sz = sizeof(struct hdcp2_ake_no_stored_km);
140 }
141
142 memcpy(ek_pub_km->e_kpub_km, &verify_rxcert_out.ekm_buff,
143 sizeof(verify_rxcert_out.ekm_buff));
144
145 return 0;
146 #endif
147 }
148
149 static int
gsc_hdcp_verify_hprime(struct device * dev,struct hdcp_port_data * data,struct hdcp2_ake_send_hprime * rx_hprime)150 gsc_hdcp_verify_hprime(struct device *dev, struct hdcp_port_data *data,
151 struct hdcp2_ake_send_hprime *rx_hprime)
152 {
153 STUB();
154 return -ENOSYS;
155 #ifdef notyet
156 struct wired_cmd_ake_send_hprime_in send_hprime_in = { { 0 } };
157 struct wired_cmd_ake_send_hprime_out send_hprime_out = { { 0 } };
158 struct drm_i915_private *i915;
159 ssize_t byte;
160
161 if (!dev || !data || !rx_hprime)
162 return -EINVAL;
163
164 i915 = kdev_to_i915(dev);
165 if (!i915) {
166 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
167 return -ENODEV;
168 }
169
170 send_hprime_in.header.api_version = HDCP_API_VERSION;
171 send_hprime_in.header.command_id = WIRED_AKE_SEND_HPRIME;
172 send_hprime_in.header.status = FW_HDCP_STATUS_SUCCESS;
173 send_hprime_in.header.buffer_len = WIRED_CMD_BUF_LEN_AKE_SEND_HPRIME_IN;
174
175 send_hprime_in.port.integrated_port_type = data->port_type;
176 send_hprime_in.port.physical_port = (u8)data->hdcp_ddi;
177 send_hprime_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
178
179 memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,
180 HDCP_2_2_H_PRIME_LEN);
181
182 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&send_hprime_in,
183 sizeof(send_hprime_in),
184 (u8 *)&send_hprime_out,
185 sizeof(send_hprime_out));
186 if (byte < 0) {
187 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
188 return byte;
189 }
190
191 if (send_hprime_out.header.status != FW_HDCP_STATUS_SUCCESS) {
192 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. Status: 0x%X\n",
193 WIRED_AKE_SEND_HPRIME, send_hprime_out.header.status);
194 return -EIO;
195 }
196
197 return 0;
198 #endif
199 }
200
201 static int
gsc_hdcp_store_pairing_info(struct device * dev,struct hdcp_port_data * data,struct hdcp2_ake_send_pairing_info * pairing_info)202 gsc_hdcp_store_pairing_info(struct device *dev, struct hdcp_port_data *data,
203 struct hdcp2_ake_send_pairing_info *pairing_info)
204 {
205 STUB();
206 return -ENOSYS;
207 #ifdef notyet
208 struct wired_cmd_ake_send_pairing_info_in pairing_info_in = { { 0 } };
209 struct wired_cmd_ake_send_pairing_info_out pairing_info_out = { { 0 } };
210 struct drm_i915_private *i915;
211 ssize_t byte;
212
213 if (!dev || !data || !pairing_info)
214 return -EINVAL;
215
216 i915 = kdev_to_i915(dev);
217 if (!i915) {
218 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
219 return -ENODEV;
220 }
221
222 pairing_info_in.header.api_version = HDCP_API_VERSION;
223 pairing_info_in.header.command_id = WIRED_AKE_SEND_PAIRING_INFO;
224 pairing_info_in.header.status = FW_HDCP_STATUS_SUCCESS;
225 pairing_info_in.header.buffer_len =
226 WIRED_CMD_BUF_LEN_SEND_PAIRING_INFO_IN;
227
228 pairing_info_in.port.integrated_port_type = data->port_type;
229 pairing_info_in.port.physical_port = (u8)data->hdcp_ddi;
230 pairing_info_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
231
232 memcpy(pairing_info_in.e_kh_km, pairing_info->e_kh_km,
233 HDCP_2_2_E_KH_KM_LEN);
234
235 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&pairing_info_in,
236 sizeof(pairing_info_in),
237 (u8 *)&pairing_info_out,
238 sizeof(pairing_info_out));
239 if (byte < 0) {
240 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
241 return byte;
242 }
243
244 if (pairing_info_out.header.status != FW_HDCP_STATUS_SUCCESS) {
245 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. Status: 0x%X\n",
246 WIRED_AKE_SEND_PAIRING_INFO,
247 pairing_info_out.header.status);
248 return -EIO;
249 }
250
251 return 0;
252 #endif
253 }
254
255 static int
gsc_hdcp_initiate_locality_check(struct device * dev,struct hdcp_port_data * data,struct hdcp2_lc_init * lc_init_data)256 gsc_hdcp_initiate_locality_check(struct device *dev,
257 struct hdcp_port_data *data,
258 struct hdcp2_lc_init *lc_init_data)
259 {
260 STUB();
261 return -ENOSYS;
262 #ifdef notyet
263 struct wired_cmd_init_locality_check_in lc_init_in = { { 0 } };
264 struct wired_cmd_init_locality_check_out lc_init_out = { { 0 } };
265 struct drm_i915_private *i915;
266 ssize_t byte;
267
268 if (!dev || !data || !lc_init_data)
269 return -EINVAL;
270
271 i915 = kdev_to_i915(dev);
272 if (!i915) {
273 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
274 return -ENODEV;
275 }
276
277 lc_init_in.header.api_version = HDCP_API_VERSION;
278 lc_init_in.header.command_id = WIRED_INIT_LOCALITY_CHECK;
279 lc_init_in.header.status = FW_HDCP_STATUS_SUCCESS;
280 lc_init_in.header.buffer_len = WIRED_CMD_BUF_LEN_INIT_LOCALITY_CHECK_IN;
281
282 lc_init_in.port.integrated_port_type = data->port_type;
283 lc_init_in.port.physical_port = (u8)data->hdcp_ddi;
284 lc_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
285
286 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&lc_init_in, sizeof(lc_init_in),
287 (u8 *)&lc_init_out, sizeof(lc_init_out));
288 if (byte < 0) {
289 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
290 return byte;
291 }
292
293 if (lc_init_out.header.status != FW_HDCP_STATUS_SUCCESS) {
294 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. status: 0x%X\n",
295 WIRED_INIT_LOCALITY_CHECK, lc_init_out.header.status);
296 return -EIO;
297 }
298
299 lc_init_data->msg_id = HDCP_2_2_LC_INIT;
300 memcpy(lc_init_data->r_n, lc_init_out.r_n, HDCP_2_2_RN_LEN);
301
302 return 0;
303 #endif
304 }
305
306 static int
gsc_hdcp_verify_lprime(struct device * dev,struct hdcp_port_data * data,struct hdcp2_lc_send_lprime * rx_lprime)307 gsc_hdcp_verify_lprime(struct device *dev, struct hdcp_port_data *data,
308 struct hdcp2_lc_send_lprime *rx_lprime)
309 {
310 STUB();
311 return -ENOSYS;
312 #ifdef notyet
313 struct wired_cmd_validate_locality_in verify_lprime_in = { { 0 } };
314 struct wired_cmd_validate_locality_out verify_lprime_out = { { 0 } };
315 struct drm_i915_private *i915;
316 ssize_t byte;
317
318 if (!dev || !data || !rx_lprime)
319 return -EINVAL;
320
321 i915 = kdev_to_i915(dev);
322 if (!i915) {
323 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
324 return -ENODEV;
325 }
326
327 verify_lprime_in.header.api_version = HDCP_API_VERSION;
328 verify_lprime_in.header.command_id = WIRED_VALIDATE_LOCALITY;
329 verify_lprime_in.header.status = FW_HDCP_STATUS_SUCCESS;
330 verify_lprime_in.header.buffer_len =
331 WIRED_CMD_BUF_LEN_VALIDATE_LOCALITY_IN;
332
333 verify_lprime_in.port.integrated_port_type = data->port_type;
334 verify_lprime_in.port.physical_port = (u8)data->hdcp_ddi;
335 verify_lprime_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
336
337 memcpy(verify_lprime_in.l_prime, rx_lprime->l_prime,
338 HDCP_2_2_L_PRIME_LEN);
339
340 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_lprime_in,
341 sizeof(verify_lprime_in),
342 (u8 *)&verify_lprime_out,
343 sizeof(verify_lprime_out));
344 if (byte < 0) {
345 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
346 return byte;
347 }
348
349 if (verify_lprime_out.header.status != FW_HDCP_STATUS_SUCCESS) {
350 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
351 WIRED_VALIDATE_LOCALITY,
352 verify_lprime_out.header.status);
353 return -EIO;
354 }
355
356 return 0;
357 #endif
358 }
359
gsc_hdcp_get_session_key(struct device * dev,struct hdcp_port_data * data,struct hdcp2_ske_send_eks * ske_data)360 static int gsc_hdcp_get_session_key(struct device *dev,
361 struct hdcp_port_data *data,
362 struct hdcp2_ske_send_eks *ske_data)
363 {
364 STUB();
365 return -ENOSYS;
366 #ifdef notyet
367 struct wired_cmd_get_session_key_in get_skey_in = { { 0 } };
368 struct wired_cmd_get_session_key_out get_skey_out = { { 0 } };
369 struct drm_i915_private *i915;
370 ssize_t byte;
371
372 if (!dev || !data || !ske_data)
373 return -EINVAL;
374
375 i915 = kdev_to_i915(dev);
376 if (!i915) {
377 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
378 return -ENODEV;
379 }
380
381 get_skey_in.header.api_version = HDCP_API_VERSION;
382 get_skey_in.header.command_id = WIRED_GET_SESSION_KEY;
383 get_skey_in.header.status = FW_HDCP_STATUS_SUCCESS;
384 get_skey_in.header.buffer_len = WIRED_CMD_BUF_LEN_GET_SESSION_KEY_IN;
385
386 get_skey_in.port.integrated_port_type = data->port_type;
387 get_skey_in.port.physical_port = (u8)data->hdcp_ddi;
388 get_skey_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
389
390 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&get_skey_in, sizeof(get_skey_in),
391 (u8 *)&get_skey_out, sizeof(get_skey_out));
392 if (byte < 0) {
393 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
394 return byte;
395 }
396
397 if (get_skey_out.header.status != FW_HDCP_STATUS_SUCCESS) {
398 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
399 WIRED_GET_SESSION_KEY, get_skey_out.header.status);
400 return -EIO;
401 }
402
403 ske_data->msg_id = HDCP_2_2_SKE_SEND_EKS;
404 memcpy(ske_data->e_dkey_ks, get_skey_out.e_dkey_ks,
405 HDCP_2_2_E_DKEY_KS_LEN);
406 memcpy(ske_data->riv, get_skey_out.r_iv, HDCP_2_2_RIV_LEN);
407
408 return 0;
409 #endif
410 }
411
412 static int
gsc_hdcp_repeater_check_flow_prepare_ack(struct device * dev,struct hdcp_port_data * data,struct hdcp2_rep_send_receiverid_list * rep_topology,struct hdcp2_rep_send_ack * rep_send_ack)413 gsc_hdcp_repeater_check_flow_prepare_ack(struct device *dev,
414 struct hdcp_port_data *data,
415 struct hdcp2_rep_send_receiverid_list
416 *rep_topology,
417 struct hdcp2_rep_send_ack
418 *rep_send_ack)
419 {
420 STUB();
421 return -ENOSYS;
422 #ifdef notyet
423 struct wired_cmd_verify_repeater_in verify_repeater_in = { { 0 } };
424 struct wired_cmd_verify_repeater_out verify_repeater_out = { { 0 } };
425 struct drm_i915_private *i915;
426 ssize_t byte;
427
428 if (!dev || !rep_topology || !rep_send_ack || !data)
429 return -EINVAL;
430
431 i915 = kdev_to_i915(dev);
432 if (!i915) {
433 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
434 return -ENODEV;
435 }
436
437 verify_repeater_in.header.api_version = HDCP_API_VERSION;
438 verify_repeater_in.header.command_id = WIRED_VERIFY_REPEATER;
439 verify_repeater_in.header.status = FW_HDCP_STATUS_SUCCESS;
440 verify_repeater_in.header.buffer_len =
441 WIRED_CMD_BUF_LEN_VERIFY_REPEATER_IN;
442
443 verify_repeater_in.port.integrated_port_type = data->port_type;
444 verify_repeater_in.port.physical_port = (u8)data->hdcp_ddi;
445 verify_repeater_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
446
447 memcpy(verify_repeater_in.rx_info, rep_topology->rx_info,
448 HDCP_2_2_RXINFO_LEN);
449 memcpy(verify_repeater_in.seq_num_v, rep_topology->seq_num_v,
450 HDCP_2_2_SEQ_NUM_LEN);
451 memcpy(verify_repeater_in.v_prime, rep_topology->v_prime,
452 HDCP_2_2_V_PRIME_HALF_LEN);
453 memcpy(verify_repeater_in.receiver_ids, rep_topology->receiver_ids,
454 HDCP_2_2_RECEIVER_IDS_MAX_LEN);
455
456 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_repeater_in,
457 sizeof(verify_repeater_in),
458 (u8 *)&verify_repeater_out,
459 sizeof(verify_repeater_out));
460 if (byte < 0) {
461 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
462 return byte;
463 }
464
465 if (verify_repeater_out.header.status != FW_HDCP_STATUS_SUCCESS) {
466 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
467 WIRED_VERIFY_REPEATER,
468 verify_repeater_out.header.status);
469 return -EIO;
470 }
471
472 memcpy(rep_send_ack->v, verify_repeater_out.v,
473 HDCP_2_2_V_PRIME_HALF_LEN);
474 rep_send_ack->msg_id = HDCP_2_2_REP_SEND_ACK;
475
476 return 0;
477 #endif
478 }
479
gsc_hdcp_verify_mprime(struct device * dev,struct hdcp_port_data * data,struct hdcp2_rep_stream_ready * stream_ready)480 static int gsc_hdcp_verify_mprime(struct device *dev,
481 struct hdcp_port_data *data,
482 struct hdcp2_rep_stream_ready *stream_ready)
483 {
484 STUB();
485 return -ENOSYS;
486 #ifdef notyet
487 struct wired_cmd_repeater_auth_stream_req_in *verify_mprime_in;
488 struct wired_cmd_repeater_auth_stream_req_out
489 verify_mprime_out = { { 0 } };
490 struct drm_i915_private *i915;
491 ssize_t byte;
492 size_t cmd_size;
493
494 if (!dev || !stream_ready || !data)
495 return -EINVAL;
496
497 i915 = kdev_to_i915(dev);
498 if (!i915) {
499 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
500 return -ENODEV;
501 }
502
503 cmd_size = struct_size(verify_mprime_in, streams, data->k);
504 if (cmd_size == SIZE_MAX)
505 return -EINVAL;
506
507 verify_mprime_in = kzalloc(cmd_size, GFP_KERNEL);
508 if (!verify_mprime_in)
509 return -ENOMEM;
510
511 verify_mprime_in->header.api_version = HDCP_API_VERSION;
512 verify_mprime_in->header.command_id = WIRED_REPEATER_AUTH_STREAM_REQ;
513 verify_mprime_in->header.status = FW_HDCP_STATUS_SUCCESS;
514 verify_mprime_in->header.buffer_len = cmd_size - sizeof(verify_mprime_in->header);
515
516 verify_mprime_in->port.integrated_port_type = data->port_type;
517 verify_mprime_in->port.physical_port = (u8)data->hdcp_ddi;
518 verify_mprime_in->port.attached_transcoder = (u8)data->hdcp_transcoder;
519
520 memcpy(verify_mprime_in->m_prime, stream_ready->m_prime, HDCP_2_2_MPRIME_LEN);
521 drm_hdcp_cpu_to_be24(verify_mprime_in->seq_num_m, data->seq_num_m);
522
523 memcpy(verify_mprime_in->streams, data->streams,
524 array_size(data->k, sizeof(*data->streams)));
525
526 verify_mprime_in->k = cpu_to_be16(data->k);
527
528 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)verify_mprime_in, cmd_size,
529 (u8 *)&verify_mprime_out,
530 sizeof(verify_mprime_out));
531 kfree(verify_mprime_in);
532 if (byte < 0) {
533 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
534 return byte;
535 }
536
537 if (verify_mprime_out.header.status != FW_HDCP_STATUS_SUCCESS) {
538 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
539 WIRED_REPEATER_AUTH_STREAM_REQ,
540 verify_mprime_out.header.status);
541 return -EIO;
542 }
543
544 return 0;
545 #endif
546 }
547
gsc_hdcp_enable_authentication(struct device * dev,struct hdcp_port_data * data)548 static int gsc_hdcp_enable_authentication(struct device *dev,
549 struct hdcp_port_data *data)
550 {
551 STUB();
552 return -ENOSYS;
553 #ifdef notyet
554 struct wired_cmd_enable_auth_in enable_auth_in = { { 0 } };
555 struct wired_cmd_enable_auth_out enable_auth_out = { { 0 } };
556 struct drm_i915_private *i915;
557 ssize_t byte;
558
559 if (!dev || !data)
560 return -EINVAL;
561
562 i915 = kdev_to_i915(dev);
563 if (!i915) {
564 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
565 return -ENODEV;
566 }
567
568 enable_auth_in.header.api_version = HDCP_API_VERSION;
569 enable_auth_in.header.command_id = WIRED_ENABLE_AUTH;
570 enable_auth_in.header.status = FW_HDCP_STATUS_SUCCESS;
571 enable_auth_in.header.buffer_len = WIRED_CMD_BUF_LEN_ENABLE_AUTH_IN;
572
573 enable_auth_in.port.integrated_port_type = data->port_type;
574 enable_auth_in.port.physical_port = (u8)data->hdcp_ddi;
575 enable_auth_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
576 enable_auth_in.stream_type = data->streams[0].stream_type;
577
578 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&enable_auth_in,
579 sizeof(enable_auth_in),
580 (u8 *)&enable_auth_out,
581 sizeof(enable_auth_out));
582 if (byte < 0) {
583 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
584 return byte;
585 }
586
587 if (enable_auth_out.header.status != FW_HDCP_STATUS_SUCCESS) {
588 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
589 WIRED_ENABLE_AUTH, enable_auth_out.header.status);
590 return -EIO;
591 }
592
593 return 0;
594 #endif
595 }
596
597 static int
gsc_hdcp_close_session(struct device * dev,struct hdcp_port_data * data)598 gsc_hdcp_close_session(struct device *dev, struct hdcp_port_data *data)
599 {
600 STUB();
601 return -ENOSYS;
602 #ifdef notyet
603 struct wired_cmd_close_session_in session_close_in = { { 0 } };
604 struct wired_cmd_close_session_out session_close_out = { { 0 } };
605 struct drm_i915_private *i915;
606 ssize_t byte;
607
608 if (!dev || !data)
609 return -EINVAL;
610
611 i915 = kdev_to_i915(dev);
612 if (!i915) {
613 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
614 return -ENODEV;
615 }
616
617 session_close_in.header.api_version = HDCP_API_VERSION;
618 session_close_in.header.command_id = WIRED_CLOSE_SESSION;
619 session_close_in.header.status = FW_HDCP_STATUS_SUCCESS;
620 session_close_in.header.buffer_len =
621 WIRED_CMD_BUF_LEN_CLOSE_SESSION_IN;
622
623 session_close_in.port.integrated_port_type = data->port_type;
624 session_close_in.port.physical_port = (u8)data->hdcp_ddi;
625 session_close_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
626
627 byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&session_close_in,
628 sizeof(session_close_in),
629 (u8 *)&session_close_out,
630 sizeof(session_close_out));
631 if (byte < 0) {
632 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
633 return byte;
634 }
635
636 if (session_close_out.header.status != FW_HDCP_STATUS_SUCCESS) {
637 drm_dbg_kms(&i915->drm, "Session Close Failed. status: 0x%X\n",
638 session_close_out.header.status);
639 return -EIO;
640 }
641
642 return 0;
643 #endif
644 }
645
646 static const struct i915_hdcp_ops gsc_hdcp_ops = {
647 .initiate_hdcp2_session = gsc_hdcp_initiate_session,
648 .verify_receiver_cert_prepare_km =
649 gsc_hdcp_verify_receiver_cert_prepare_km,
650 .verify_hprime = gsc_hdcp_verify_hprime,
651 .store_pairing_info = gsc_hdcp_store_pairing_info,
652 .initiate_locality_check = gsc_hdcp_initiate_locality_check,
653 .verify_lprime = gsc_hdcp_verify_lprime,
654 .get_session_key = gsc_hdcp_get_session_key,
655 .repeater_check_flow_prepare_ack =
656 gsc_hdcp_repeater_check_flow_prepare_ack,
657 .verify_mprime = gsc_hdcp_verify_mprime,
658 .enable_hdcp_authentication = gsc_hdcp_enable_authentication,
659 .close_hdcp_session = gsc_hdcp_close_session,
660 };
661
662 /*This function helps allocate memory for the command that we will send to gsc cs */
intel_hdcp_gsc_initialize_message(struct drm_i915_private * i915,struct intel_hdcp_gsc_message * hdcp_message)663 static int intel_hdcp_gsc_initialize_message(struct drm_i915_private *i915,
664 struct intel_hdcp_gsc_message *hdcp_message)
665 {
666 struct intel_gt *gt = i915->media_gt;
667 struct drm_i915_gem_object *obj = NULL;
668 struct i915_vma *vma = NULL;
669 void *cmd_in, *cmd_out;
670 int err;
671
672 /* allocate object of two page for HDCP command memory and store it */
673 obj = i915_gem_object_create_shmem(i915, 2 * PAGE_SIZE);
674
675 if (IS_ERR(obj)) {
676 drm_err(&i915->drm, "Failed to allocate HDCP streaming command!\n");
677 return PTR_ERR(obj);
678 }
679
680 cmd_in = i915_gem_object_pin_map_unlocked(obj, intel_gt_coherent_map_type(gt, obj, true));
681 if (IS_ERR(cmd_in)) {
682 drm_err(&i915->drm, "Failed to map gsc message page!\n");
683 err = PTR_ERR(cmd_in);
684 goto out_unpin;
685 }
686
687 cmd_out = cmd_in + PAGE_SIZE;
688
689 vma = i915_vma_instance(obj, >->ggtt->vm, NULL);
690 if (IS_ERR(vma)) {
691 err = PTR_ERR(vma);
692 goto out_unmap;
693 }
694
695 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
696 if (err)
697 goto out_unmap;
698
699 memset(cmd_in, 0, obj->base.size);
700
701 hdcp_message->hdcp_cmd_in = cmd_in;
702 hdcp_message->hdcp_cmd_out = cmd_out;
703 hdcp_message->vma = vma;
704
705 return 0;
706
707 out_unmap:
708 i915_gem_object_unpin_map(obj);
709 out_unpin:
710 i915_gem_object_put(obj);
711 return err;
712 }
713
intel_hdcp_gsc_hdcp2_init(struct drm_i915_private * i915)714 static int intel_hdcp_gsc_hdcp2_init(struct drm_i915_private *i915)
715 {
716 struct intel_hdcp_gsc_message *hdcp_message;
717 int ret;
718
719 hdcp_message = kzalloc(sizeof(*hdcp_message), GFP_KERNEL);
720
721 if (!hdcp_message)
722 return -ENOMEM;
723
724 /*
725 * NOTE: No need to lock the comp mutex here as it is already
726 * going to be taken before this function called
727 */
728 i915->display.hdcp.hdcp_message = hdcp_message;
729 ret = intel_hdcp_gsc_initialize_message(i915, hdcp_message);
730
731 if (ret)
732 drm_err(&i915->drm, "Could not initialize hdcp_message\n");
733
734 return ret;
735 }
736
intel_hdcp_gsc_free_message(struct drm_i915_private * i915)737 static void intel_hdcp_gsc_free_message(struct drm_i915_private *i915)
738 {
739 struct intel_hdcp_gsc_message *hdcp_message =
740 i915->display.hdcp.hdcp_message;
741
742 hdcp_message->hdcp_cmd_in = NULL;
743 hdcp_message->hdcp_cmd_out = NULL;
744 i915_vma_unpin_and_release(&hdcp_message->vma, I915_VMA_RELEASE_MAP);
745 kfree(hdcp_message);
746 }
747
intel_hdcp_gsc_init(struct drm_i915_private * i915)748 int intel_hdcp_gsc_init(struct drm_i915_private *i915)
749 {
750 struct i915_hdcp_arbiter *data;
751 int ret;
752
753 data = kzalloc(sizeof(struct i915_hdcp_arbiter), GFP_KERNEL);
754 if (!data)
755 return -ENOMEM;
756
757 mutex_lock(&i915->display.hdcp.hdcp_mutex);
758 i915->display.hdcp.arbiter = data;
759 i915->display.hdcp.arbiter->hdcp_dev = i915->drm.dev;
760 i915->display.hdcp.arbiter->ops = &gsc_hdcp_ops;
761 ret = intel_hdcp_gsc_hdcp2_init(i915);
762 mutex_unlock(&i915->display.hdcp.hdcp_mutex);
763
764 return ret;
765 }
766
intel_hdcp_gsc_fini(struct drm_i915_private * i915)767 void intel_hdcp_gsc_fini(struct drm_i915_private *i915)
768 {
769 intel_hdcp_gsc_free_message(i915);
770 kfree(i915->display.hdcp.arbiter);
771 }
772
intel_gsc_send_sync(struct drm_i915_private * i915,struct intel_gsc_mtl_header * header_in,struct intel_gsc_mtl_header * header_out,u64 addr_in,u64 addr_out,size_t msg_out_len)773 static int intel_gsc_send_sync(struct drm_i915_private *i915,
774 struct intel_gsc_mtl_header *header_in,
775 struct intel_gsc_mtl_header *header_out,
776 u64 addr_in, u64 addr_out,
777 size_t msg_out_len)
778 {
779 struct intel_gt *gt = i915->media_gt;
780 int ret;
781
782 ret = intel_gsc_uc_heci_cmd_submit_packet(>->uc.gsc, addr_in,
783 header_in->message_size,
784 addr_out,
785 msg_out_len + sizeof(*header_out));
786 if (ret) {
787 drm_err(&i915->drm, "failed to send gsc HDCP msg (%d)\n", ret);
788 return ret;
789 }
790
791 /*
792 * Checking validity marker and header status to see if some error has
793 * blocked us from sending message to gsc cs
794 */
795 if (header_out->validity_marker != GSC_HECI_VALIDITY_MARKER) {
796 drm_err(&i915->drm, "invalid validity marker\n");
797 return -EINVAL;
798 }
799
800 if (header_out->status != 0) {
801 drm_err(&i915->drm, "header status indicates error %d\n",
802 header_out->status);
803 return -EINVAL;
804 }
805
806 if (header_out->flags & GSC_OUTFLAG_MSG_PENDING) {
807 header_in->gsc_message_handle = header_out->gsc_message_handle;
808 return -EAGAIN;
809 }
810
811 return 0;
812 }
813
814 /*
815 * This function can now be used for sending requests and will also handle
816 * receipt of reply messages hence no different function of message retrieval
817 * is required. We will initialize intel_hdcp_gsc_message structure then add
818 * gsc cs memory header as stated in specs after which the normal HDCP payload
819 * will follow
820 */
intel_hdcp_gsc_msg_send(struct drm_i915_private * i915,u8 * msg_in,size_t msg_in_len,u8 * msg_out,size_t msg_out_len)821 ssize_t intel_hdcp_gsc_msg_send(struct drm_i915_private *i915, u8 *msg_in,
822 size_t msg_in_len, u8 *msg_out,
823 size_t msg_out_len)
824 {
825 struct intel_gt *gt = i915->media_gt;
826 struct intel_gsc_mtl_header *header_in, *header_out;
827 const size_t max_msg_size = PAGE_SIZE - sizeof(*header_in);
828 struct intel_hdcp_gsc_message *hdcp_message;
829 u64 addr_in, addr_out, host_session_id;
830 u32 reply_size, msg_size_in, msg_size_out;
831 int ret, tries = 0;
832
833 if (!intel_uc_uses_gsc_uc(>->uc))
834 return -ENODEV;
835
836 if (msg_in_len > max_msg_size || msg_out_len > max_msg_size)
837 return -ENOSPC;
838
839 msg_size_in = msg_in_len + sizeof(*header_in);
840 msg_size_out = msg_out_len + sizeof(*header_out);
841 hdcp_message = i915->display.hdcp.hdcp_message;
842 header_in = hdcp_message->hdcp_cmd_in;
843 header_out = hdcp_message->hdcp_cmd_out;
844 addr_in = i915_ggtt_offset(hdcp_message->vma);
845 addr_out = addr_in + PAGE_SIZE;
846
847 memset(header_in, 0, msg_size_in);
848 memset(header_out, 0, msg_size_out);
849 get_random_bytes(&host_session_id, sizeof(u64));
850 intel_gsc_uc_heci_cmd_emit_mtl_header(header_in, HECI_MEADDRESS_HDCP,
851 msg_size_in, host_session_id);
852 memcpy(hdcp_message->hdcp_cmd_in + sizeof(*header_in), msg_in, msg_in_len);
853
854 /*
855 * Keep sending request in case the pending bit is set no need to add
856 * message handle as we are using same address hence loc. of header is
857 * same and it will contain the message handle. we will send the message
858 * 20 times each message 50 ms apart
859 */
860 do {
861 ret = intel_gsc_send_sync(i915, header_in, header_out, addr_in,
862 addr_out, msg_out_len);
863
864 /* Only try again if gsc says so */
865 if (ret != -EAGAIN)
866 break;
867
868 drm_msleep(50);
869
870 } while (++tries < 20);
871
872 if (ret)
873 goto err;
874
875 /* we use the same mem for the reply, so header is in the same loc */
876 reply_size = header_out->message_size - sizeof(*header_out);
877 if (reply_size > msg_out_len) {
878 drm_warn(&i915->drm, "caller with insufficient HDCP reply size %u (%d)\n",
879 reply_size, (u32)msg_out_len);
880 reply_size = msg_out_len;
881 } else if (reply_size != msg_out_len) {
882 drm_dbg_kms(&i915->drm, "caller unexpected HCDP reply size %u (%d)\n",
883 reply_size, (u32)msg_out_len);
884 }
885
886 memcpy(msg_out, hdcp_message->hdcp_cmd_out + sizeof(*header_out), msg_out_len);
887
888 err:
889 return ret;
890 }
891