1 /* $NetBSD: amdgpu_hdcp_ddc.c,v 1.3 2021/12/19 12:02:39 riastradh Exp $ */
2
3 /*
4 * Copyright 2019 Advanced Micro Devices, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors: AMD
25 *
26 */
27
28 #include <sys/cdefs.h>
29 __KERNEL_RCSID(0, "$NetBSD: amdgpu_hdcp_ddc.c,v 1.3 2021/12/19 12:02:39 riastradh Exp $");
30
31 #include "hdcp.h"
32
33 #define HDCP_I2C_ADDR 0x3a /* 0x74 >> 1*/
34 #define KSV_READ_SIZE 0xf /* 0x6803b - 0x6802c */
35 #define HDCP_MAX_AUX_TRANSACTION_SIZE 16
36
37 enum mod_hdcp_ddc_message_id {
38 MOD_HDCP_MESSAGE_ID_INVALID = -1,
39
40 /* HDCP 1.4 */
41
42 MOD_HDCP_MESSAGE_ID_READ_BKSV = 0,
43 MOD_HDCP_MESSAGE_ID_READ_RI_R0,
44 MOD_HDCP_MESSAGE_ID_WRITE_AKSV,
45 MOD_HDCP_MESSAGE_ID_WRITE_AINFO,
46 MOD_HDCP_MESSAGE_ID_WRITE_AN,
47 MOD_HDCP_MESSAGE_ID_READ_VH_X,
48 MOD_HDCP_MESSAGE_ID_READ_VH_0,
49 MOD_HDCP_MESSAGE_ID_READ_VH_1,
50 MOD_HDCP_MESSAGE_ID_READ_VH_2,
51 MOD_HDCP_MESSAGE_ID_READ_VH_3,
52 MOD_HDCP_MESSAGE_ID_READ_VH_4,
53 MOD_HDCP_MESSAGE_ID_READ_BCAPS,
54 MOD_HDCP_MESSAGE_ID_READ_BSTATUS,
55 MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO,
56 MOD_HDCP_MESSAGE_ID_READ_BINFO,
57
58 /* HDCP 2.2 */
59
60 MOD_HDCP_MESSAGE_ID_HDCP2VERSION,
61 MOD_HDCP_MESSAGE_ID_RX_CAPS,
62 MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT,
63 MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT,
64 MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM,
65 MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM,
66 MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME,
67 MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO,
68 MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT,
69 MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME,
70 MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS,
71 MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST,
72 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK,
73 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE,
74 MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY,
75 MOD_HDCP_MESSAGE_ID_READ_RXSTATUS,
76 MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE,
77
78 MOD_HDCP_MESSAGE_ID_MAX
79 };
80
81 static const uint8_t hdcp_i2c_offsets[] = {
82 [MOD_HDCP_MESSAGE_ID_READ_BKSV] = 0x0,
83 [MOD_HDCP_MESSAGE_ID_READ_RI_R0] = 0x8,
84 [MOD_HDCP_MESSAGE_ID_WRITE_AKSV] = 0x10,
85 [MOD_HDCP_MESSAGE_ID_WRITE_AINFO] = 0x15,
86 [MOD_HDCP_MESSAGE_ID_WRITE_AN] = 0x18,
87 [MOD_HDCP_MESSAGE_ID_READ_VH_X] = 0x20,
88 [MOD_HDCP_MESSAGE_ID_READ_VH_0] = 0x20,
89 [MOD_HDCP_MESSAGE_ID_READ_VH_1] = 0x24,
90 [MOD_HDCP_MESSAGE_ID_READ_VH_2] = 0x28,
91 [MOD_HDCP_MESSAGE_ID_READ_VH_3] = 0x2C,
92 [MOD_HDCP_MESSAGE_ID_READ_VH_4] = 0x30,
93 [MOD_HDCP_MESSAGE_ID_READ_BCAPS] = 0x40,
94 [MOD_HDCP_MESSAGE_ID_READ_BSTATUS] = 0x41,
95 [MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO] = 0x43,
96 [MOD_HDCP_MESSAGE_ID_READ_BINFO] = 0xFF,
97 [MOD_HDCP_MESSAGE_ID_HDCP2VERSION] = 0x50,
98 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT] = 0x60,
99 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT] = 0x80,
100 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM] = 0x60,
101 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM] = 0x60,
102 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME] = 0x80,
103 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO] = 0x80,
104 [MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT] = 0x60,
105 [MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME] = 0x80,
106 [MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS] = 0x60,
107 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST] = 0x80,
108 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK] = 0x60,
109 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE] = 0x60,
110 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY] = 0x80,
111 [MOD_HDCP_MESSAGE_ID_READ_RXSTATUS] = 0x70,
112 [MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE] = 0x0
113 };
114
115 static const uint32_t hdcp_dpcd_addrs[] = {
116 [MOD_HDCP_MESSAGE_ID_READ_BKSV] = 0x68000,
117 [MOD_HDCP_MESSAGE_ID_READ_RI_R0] = 0x68005,
118 [MOD_HDCP_MESSAGE_ID_WRITE_AKSV] = 0x68007,
119 [MOD_HDCP_MESSAGE_ID_WRITE_AINFO] = 0x6803B,
120 [MOD_HDCP_MESSAGE_ID_WRITE_AN] = 0x6800c,
121 [MOD_HDCP_MESSAGE_ID_READ_VH_X] = 0x68014,
122 [MOD_HDCP_MESSAGE_ID_READ_VH_0] = 0x68014,
123 [MOD_HDCP_MESSAGE_ID_READ_VH_1] = 0x68018,
124 [MOD_HDCP_MESSAGE_ID_READ_VH_2] = 0x6801c,
125 [MOD_HDCP_MESSAGE_ID_READ_VH_3] = 0x68020,
126 [MOD_HDCP_MESSAGE_ID_READ_VH_4] = 0x68024,
127 [MOD_HDCP_MESSAGE_ID_READ_BCAPS] = 0x68028,
128 [MOD_HDCP_MESSAGE_ID_READ_BSTATUS] = 0x68029,
129 [MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO] = 0x6802c,
130 [MOD_HDCP_MESSAGE_ID_READ_BINFO] = 0x6802a,
131 [MOD_HDCP_MESSAGE_ID_RX_CAPS] = 0x6921d,
132 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT] = 0x69000,
133 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT] = 0x6900b,
134 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM] = 0x69220,
135 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM] = 0x692a0,
136 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME] = 0x692c0,
137 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO] = 0x692e0,
138 [MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT] = 0x692f0,
139 [MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME] = 0x692f8,
140 [MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS] = 0x69318,
141 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST] = 0x69330,
142 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK] = 0x693e0,
143 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE] = 0x693f0,
144 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY] = 0x69473,
145 [MOD_HDCP_MESSAGE_ID_READ_RXSTATUS] = 0x69493,
146 [MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE] = 0x69494
147 };
148
read(struct mod_hdcp * hdcp,enum mod_hdcp_ddc_message_id msg_id,uint8_t * buf,uint32_t buf_len)149 static enum mod_hdcp_status read(struct mod_hdcp *hdcp,
150 enum mod_hdcp_ddc_message_id msg_id,
151 uint8_t *buf,
152 uint32_t buf_len)
153 {
154 bool success = true;
155 uint32_t cur_size = 0;
156 uint32_t data_offset = 0;
157
158 if (is_dp_hdcp(hdcp)) {
159 while (buf_len > 0) {
160 cur_size = MIN(buf_len, HDCP_MAX_AUX_TRANSACTION_SIZE);
161 success = hdcp->config.ddc.funcs.read_dpcd(hdcp->config.ddc.handle,
162 hdcp_dpcd_addrs[msg_id] + data_offset,
163 buf + data_offset,
164 cur_size);
165
166 if (!success)
167 break;
168
169 buf_len -= cur_size;
170 data_offset += cur_size;
171 }
172 } else {
173 success = hdcp->config.ddc.funcs.read_i2c(
174 hdcp->config.ddc.handle,
175 HDCP_I2C_ADDR,
176 hdcp_i2c_offsets[msg_id],
177 buf,
178 (uint32_t)buf_len);
179 }
180
181 return success ? MOD_HDCP_STATUS_SUCCESS : MOD_HDCP_STATUS_DDC_FAILURE;
182 }
183
read_repeatedly(struct mod_hdcp * hdcp,enum mod_hdcp_ddc_message_id msg_id,uint8_t * buf,uint32_t buf_len,uint8_t read_size)184 static enum mod_hdcp_status read_repeatedly(struct mod_hdcp *hdcp,
185 enum mod_hdcp_ddc_message_id msg_id,
186 uint8_t *buf,
187 uint32_t buf_len,
188 uint8_t read_size)
189 {
190 enum mod_hdcp_status status = MOD_HDCP_STATUS_DDC_FAILURE;
191 uint32_t cur_size = 0;
192 uint32_t data_offset = 0;
193
194 while (buf_len > 0) {
195 cur_size = MIN(buf_len, read_size);
196 status = read(hdcp, msg_id, buf + data_offset, cur_size);
197
198 if (status != MOD_HDCP_STATUS_SUCCESS)
199 break;
200
201 buf_len -= cur_size;
202 data_offset += cur_size;
203 }
204
205 return status;
206 }
207
write(struct mod_hdcp * hdcp,enum mod_hdcp_ddc_message_id msg_id,uint8_t * buf,uint32_t buf_len)208 static enum mod_hdcp_status write(struct mod_hdcp *hdcp,
209 enum mod_hdcp_ddc_message_id msg_id,
210 uint8_t *buf,
211 uint32_t buf_len)
212 {
213 bool success = true;
214 uint32_t cur_size = 0;
215 uint32_t data_offset = 0;
216
217 if (is_dp_hdcp(hdcp)) {
218 while (buf_len > 0) {
219 cur_size = MIN(buf_len, HDCP_MAX_AUX_TRANSACTION_SIZE);
220 success = hdcp->config.ddc.funcs.write_dpcd(
221 hdcp->config.ddc.handle,
222 hdcp_dpcd_addrs[msg_id] + data_offset,
223 buf + data_offset,
224 cur_size);
225
226 if (!success)
227 break;
228
229 buf_len -= cur_size;
230 data_offset += cur_size;
231 }
232 } else {
233 hdcp->buf[0] = hdcp_i2c_offsets[msg_id];
234 memmove(&hdcp->buf[1], buf, buf_len);
235 success = hdcp->config.ddc.funcs.write_i2c(
236 hdcp->config.ddc.handle,
237 HDCP_I2C_ADDR,
238 hdcp->buf,
239 (uint32_t)(buf_len+1));
240 }
241
242 return success ? MOD_HDCP_STATUS_SUCCESS : MOD_HDCP_STATUS_DDC_FAILURE;
243 }
244
mod_hdcp_read_bksv(struct mod_hdcp * hdcp)245 enum mod_hdcp_status mod_hdcp_read_bksv(struct mod_hdcp *hdcp)
246 {
247 return read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BKSV,
248 hdcp->auth.msg.hdcp1.bksv,
249 sizeof(hdcp->auth.msg.hdcp1.bksv));
250 }
251
mod_hdcp_read_bcaps(struct mod_hdcp * hdcp)252 enum mod_hdcp_status mod_hdcp_read_bcaps(struct mod_hdcp *hdcp)
253 {
254 return read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BCAPS,
255 &hdcp->auth.msg.hdcp1.bcaps,
256 sizeof(hdcp->auth.msg.hdcp1.bcaps));
257 }
258
mod_hdcp_read_bstatus(struct mod_hdcp * hdcp)259 enum mod_hdcp_status mod_hdcp_read_bstatus(struct mod_hdcp *hdcp)
260 {
261 enum mod_hdcp_status status;
262
263 if (is_dp_hdcp(hdcp))
264 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BSTATUS,
265 (uint8_t *)&hdcp->auth.msg.hdcp1.bstatus,
266 1);
267 else
268 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BSTATUS,
269 (uint8_t *)&hdcp->auth.msg.hdcp1.bstatus,
270 sizeof(hdcp->auth.msg.hdcp1.bstatus));
271 return status;
272 }
273
mod_hdcp_read_r0p(struct mod_hdcp * hdcp)274 enum mod_hdcp_status mod_hdcp_read_r0p(struct mod_hdcp *hdcp)
275 {
276 return read(hdcp, MOD_HDCP_MESSAGE_ID_READ_RI_R0,
277 (uint8_t *)&hdcp->auth.msg.hdcp1.r0p,
278 sizeof(hdcp->auth.msg.hdcp1.r0p));
279 }
280
281 /* special case, reading repeatedly at the same address, don't use read() */
mod_hdcp_read_ksvlist(struct mod_hdcp * hdcp)282 enum mod_hdcp_status mod_hdcp_read_ksvlist(struct mod_hdcp *hdcp)
283 {
284 enum mod_hdcp_status status;
285
286 if (is_dp_hdcp(hdcp))
287 status = read_repeatedly(hdcp, MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO,
288 hdcp->auth.msg.hdcp1.ksvlist,
289 hdcp->auth.msg.hdcp1.ksvlist_size,
290 KSV_READ_SIZE);
291 else
292 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO,
293 (uint8_t *)&hdcp->auth.msg.hdcp1.ksvlist,
294 hdcp->auth.msg.hdcp1.ksvlist_size);
295 return status;
296 }
297
mod_hdcp_read_vp(struct mod_hdcp * hdcp)298 enum mod_hdcp_status mod_hdcp_read_vp(struct mod_hdcp *hdcp)
299 {
300 enum mod_hdcp_status status;
301
302 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_0,
303 &hdcp->auth.msg.hdcp1.vp[0], 4);
304 if (status != MOD_HDCP_STATUS_SUCCESS)
305 goto out;
306
307 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_1,
308 &hdcp->auth.msg.hdcp1.vp[4], 4);
309 if (status != MOD_HDCP_STATUS_SUCCESS)
310 goto out;
311
312 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_2,
313 &hdcp->auth.msg.hdcp1.vp[8], 4);
314 if (status != MOD_HDCP_STATUS_SUCCESS)
315 goto out;
316
317 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_3,
318 &hdcp->auth.msg.hdcp1.vp[12], 4);
319 if (status != MOD_HDCP_STATUS_SUCCESS)
320 goto out;
321
322 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_4,
323 &hdcp->auth.msg.hdcp1.vp[16], 4);
324 out:
325 return status;
326 }
327
mod_hdcp_read_binfo(struct mod_hdcp * hdcp)328 enum mod_hdcp_status mod_hdcp_read_binfo(struct mod_hdcp *hdcp)
329 {
330 enum mod_hdcp_status status;
331
332 if (is_dp_hdcp(hdcp))
333 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BINFO,
334 (uint8_t *)&hdcp->auth.msg.hdcp1.binfo_dp,
335 sizeof(hdcp->auth.msg.hdcp1.binfo_dp));
336 else
337 status = MOD_HDCP_STATUS_INVALID_OPERATION;
338
339 return status;
340 }
341
mod_hdcp_write_aksv(struct mod_hdcp * hdcp)342 enum mod_hdcp_status mod_hdcp_write_aksv(struct mod_hdcp *hdcp)
343 {
344 return write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKSV,
345 hdcp->auth.msg.hdcp1.aksv,
346 sizeof(hdcp->auth.msg.hdcp1.aksv));
347 }
348
mod_hdcp_write_ainfo(struct mod_hdcp * hdcp)349 enum mod_hdcp_status mod_hdcp_write_ainfo(struct mod_hdcp *hdcp)
350 {
351 return write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AINFO,
352 &hdcp->auth.msg.hdcp1.ainfo,
353 sizeof(hdcp->auth.msg.hdcp1.ainfo));
354 }
355
mod_hdcp_write_an(struct mod_hdcp * hdcp)356 enum mod_hdcp_status mod_hdcp_write_an(struct mod_hdcp *hdcp)
357 {
358 return write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AN,
359 hdcp->auth.msg.hdcp1.an,
360 sizeof(hdcp->auth.msg.hdcp1.an));
361 }
362
mod_hdcp_read_hdcp2version(struct mod_hdcp * hdcp)363 enum mod_hdcp_status mod_hdcp_read_hdcp2version(struct mod_hdcp *hdcp)
364 {
365 enum mod_hdcp_status status;
366
367 if (is_dp_hdcp(hdcp))
368 status = MOD_HDCP_STATUS_INVALID_OPERATION;
369 else
370 status = read(hdcp, MOD_HDCP_MESSAGE_ID_HDCP2VERSION,
371 &hdcp->auth.msg.hdcp2.hdcp2version_hdmi,
372 sizeof(hdcp->auth.msg.hdcp2.hdcp2version_hdmi));
373
374 return status;
375 }
376
mod_hdcp_read_rxcaps(struct mod_hdcp * hdcp)377 enum mod_hdcp_status mod_hdcp_read_rxcaps(struct mod_hdcp *hdcp)
378 {
379 enum mod_hdcp_status status;
380
381 if (!is_dp_hdcp(hdcp))
382 status = MOD_HDCP_STATUS_INVALID_OPERATION;
383 else
384 status = read(hdcp, MOD_HDCP_MESSAGE_ID_RX_CAPS,
385 hdcp->auth.msg.hdcp2.rxcaps_dp,
386 sizeof(hdcp->auth.msg.hdcp2.rxcaps_dp));
387
388 return status;
389 }
390
mod_hdcp_read_rxstatus(struct mod_hdcp * hdcp)391 enum mod_hdcp_status mod_hdcp_read_rxstatus(struct mod_hdcp *hdcp)
392 {
393 enum mod_hdcp_status status;
394
395 if (is_dp_hdcp(hdcp)) {
396 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_RXSTATUS,
397 &hdcp->auth.msg.hdcp2.rxstatus_dp,
398 1);
399 } else {
400 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_RXSTATUS,
401 (uint8_t *)&hdcp->auth.msg.hdcp2.rxstatus,
402 sizeof(hdcp->auth.msg.hdcp2.rxstatus));
403 }
404 return status;
405 }
406
mod_hdcp_read_ake_cert(struct mod_hdcp * hdcp)407 enum mod_hdcp_status mod_hdcp_read_ake_cert(struct mod_hdcp *hdcp)
408 {
409 enum mod_hdcp_status status;
410
411 if (is_dp_hdcp(hdcp)) {
412 hdcp->auth.msg.hdcp2.ake_cert[0] = 3;
413 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT,
414 hdcp->auth.msg.hdcp2.ake_cert+1,
415 sizeof(hdcp->auth.msg.hdcp2.ake_cert)-1);
416
417 } else {
418 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT,
419 hdcp->auth.msg.hdcp2.ake_cert,
420 sizeof(hdcp->auth.msg.hdcp2.ake_cert));
421 }
422 return status;
423 }
424
mod_hdcp_read_h_prime(struct mod_hdcp * hdcp)425 enum mod_hdcp_status mod_hdcp_read_h_prime(struct mod_hdcp *hdcp)
426 {
427 enum mod_hdcp_status status;
428
429 if (is_dp_hdcp(hdcp)) {
430 hdcp->auth.msg.hdcp2.ake_h_prime[0] = 7;
431 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME,
432 hdcp->auth.msg.hdcp2.ake_h_prime+1,
433 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)-1);
434
435 } else {
436 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME,
437 hdcp->auth.msg.hdcp2.ake_h_prime,
438 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime));
439 }
440 return status;
441 }
442
mod_hdcp_read_pairing_info(struct mod_hdcp * hdcp)443 enum mod_hdcp_status mod_hdcp_read_pairing_info(struct mod_hdcp *hdcp)
444 {
445 enum mod_hdcp_status status;
446
447 if (is_dp_hdcp(hdcp)) {
448 hdcp->auth.msg.hdcp2.ake_pairing_info[0] = 8;
449 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO,
450 hdcp->auth.msg.hdcp2.ake_pairing_info+1,
451 sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info)-1);
452
453 } else {
454 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO,
455 hdcp->auth.msg.hdcp2.ake_pairing_info,
456 sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info));
457 }
458 return status;
459 }
460
mod_hdcp_read_l_prime(struct mod_hdcp * hdcp)461 enum mod_hdcp_status mod_hdcp_read_l_prime(struct mod_hdcp *hdcp)
462 {
463 enum mod_hdcp_status status;
464
465 if (is_dp_hdcp(hdcp)) {
466 hdcp->auth.msg.hdcp2.lc_l_prime[0] = 10;
467 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME,
468 hdcp->auth.msg.hdcp2.lc_l_prime+1,
469 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime)-1);
470
471 } else {
472 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME,
473 hdcp->auth.msg.hdcp2.lc_l_prime,
474 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime));
475 }
476 return status;
477 }
478
mod_hdcp_read_rx_id_list(struct mod_hdcp * hdcp)479 enum mod_hdcp_status mod_hdcp_read_rx_id_list(struct mod_hdcp *hdcp)
480 {
481 enum mod_hdcp_status status;
482
483 if (is_dp_hdcp(hdcp)) {
484 hdcp->auth.msg.hdcp2.rx_id_list[0] = 12;
485 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST,
486 hdcp->auth.msg.hdcp2.rx_id_list+1,
487 sizeof(hdcp->auth.msg.hdcp2.rx_id_list)-1);
488
489 } else {
490 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST,
491 hdcp->auth.msg.hdcp2.rx_id_list,
492 hdcp->auth.msg.hdcp2.rx_id_list_size);
493 }
494 return status;
495 }
496
mod_hdcp_read_stream_ready(struct mod_hdcp * hdcp)497 enum mod_hdcp_status mod_hdcp_read_stream_ready(struct mod_hdcp *hdcp)
498 {
499 enum mod_hdcp_status status;
500
501 if (is_dp_hdcp(hdcp)) {
502 hdcp->auth.msg.hdcp2.repeater_auth_stream_ready[0] = 17;
503 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY,
504 hdcp->auth.msg.hdcp2.repeater_auth_stream_ready+1,
505 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready)-1);
506
507 } else {
508 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY,
509 hdcp->auth.msg.hdcp2.repeater_auth_stream_ready,
510 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready));
511 }
512 return status;
513 }
514
mod_hdcp_write_ake_init(struct mod_hdcp * hdcp)515 enum mod_hdcp_status mod_hdcp_write_ake_init(struct mod_hdcp *hdcp)
516 {
517 enum mod_hdcp_status status;
518
519 if (is_dp_hdcp(hdcp))
520 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT,
521 hdcp->auth.msg.hdcp2.ake_init+1,
522 sizeof(hdcp->auth.msg.hdcp2.ake_init)-1);
523 else
524 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT,
525 hdcp->auth.msg.hdcp2.ake_init,
526 sizeof(hdcp->auth.msg.hdcp2.ake_init));
527 return status;
528 }
529
mod_hdcp_write_no_stored_km(struct mod_hdcp * hdcp)530 enum mod_hdcp_status mod_hdcp_write_no_stored_km(struct mod_hdcp *hdcp)
531 {
532 enum mod_hdcp_status status;
533
534 if (is_dp_hdcp(hdcp))
535 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM,
536 hdcp->auth.msg.hdcp2.ake_no_stored_km+1,
537 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)-1);
538 else
539 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM,
540 hdcp->auth.msg.hdcp2.ake_no_stored_km,
541 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km));
542 return status;
543 }
544
mod_hdcp_write_stored_km(struct mod_hdcp * hdcp)545 enum mod_hdcp_status mod_hdcp_write_stored_km(struct mod_hdcp *hdcp)
546 {
547 enum mod_hdcp_status status;
548
549 if (is_dp_hdcp(hdcp))
550 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM,
551 hdcp->auth.msg.hdcp2.ake_stored_km+1,
552 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km)-1);
553 else
554 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM,
555 hdcp->auth.msg.hdcp2.ake_stored_km,
556 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km));
557 return status;
558 }
559
mod_hdcp_write_lc_init(struct mod_hdcp * hdcp)560 enum mod_hdcp_status mod_hdcp_write_lc_init(struct mod_hdcp *hdcp)
561 {
562 enum mod_hdcp_status status;
563
564 if (is_dp_hdcp(hdcp))
565 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT,
566 hdcp->auth.msg.hdcp2.lc_init+1,
567 sizeof(hdcp->auth.msg.hdcp2.lc_init)-1);
568 else
569 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT,
570 hdcp->auth.msg.hdcp2.lc_init,
571 sizeof(hdcp->auth.msg.hdcp2.lc_init));
572 return status;
573 }
574
mod_hdcp_write_eks(struct mod_hdcp * hdcp)575 enum mod_hdcp_status mod_hdcp_write_eks(struct mod_hdcp *hdcp)
576 {
577 enum mod_hdcp_status status;
578
579 if (is_dp_hdcp(hdcp))
580 status = write(hdcp,
581 MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS,
582 hdcp->auth.msg.hdcp2.ske_eks+1,
583 sizeof(hdcp->auth.msg.hdcp2.ske_eks)-1);
584 else
585 status = write(hdcp,
586 MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS,
587 hdcp->auth.msg.hdcp2.ske_eks,
588 sizeof(hdcp->auth.msg.hdcp2.ske_eks));
589 return status;
590 }
591
mod_hdcp_write_repeater_auth_ack(struct mod_hdcp * hdcp)592 enum mod_hdcp_status mod_hdcp_write_repeater_auth_ack(struct mod_hdcp *hdcp)
593 {
594 enum mod_hdcp_status status;
595
596 if (is_dp_hdcp(hdcp))
597 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK,
598 hdcp->auth.msg.hdcp2.repeater_auth_ack+1,
599 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack)-1);
600 else
601 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK,
602 hdcp->auth.msg.hdcp2.repeater_auth_ack,
603 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack));
604 return status;
605 }
606
mod_hdcp_write_stream_manage(struct mod_hdcp * hdcp)607 enum mod_hdcp_status mod_hdcp_write_stream_manage(struct mod_hdcp *hdcp)
608 {
609 enum mod_hdcp_status status;
610
611 if (is_dp_hdcp(hdcp))
612 status = write(hdcp,
613 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE,
614 hdcp->auth.msg.hdcp2.repeater_auth_stream_manage+1,
615 hdcp->auth.msg.hdcp2.stream_manage_size-1);
616 else
617 status = write(hdcp,
618 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE,
619 hdcp->auth.msg.hdcp2.repeater_auth_stream_manage,
620 hdcp->auth.msg.hdcp2.stream_manage_size);
621 return status;
622 }
623
mod_hdcp_write_content_type(struct mod_hdcp * hdcp)624 enum mod_hdcp_status mod_hdcp_write_content_type(struct mod_hdcp *hdcp)
625 {
626 enum mod_hdcp_status status;
627
628 if (is_dp_hdcp(hdcp))
629 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE,
630 hdcp->auth.msg.hdcp2.content_stream_type_dp+1,
631 sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp)-1);
632 else
633 status = MOD_HDCP_STATUS_INVALID_OPERATION;
634 return status;
635 }
636