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