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  #ifndef HDCP_H_
27  #define HDCP_H_
28  
29  #include "mod_hdcp.h"
30  #include "hdcp_log.h"
31  
32  #include <drm/display/drm_dp_helper.h>
33  #include <drm/display/drm_hdcp_helper.h>
34  
35  enum mod_hdcp_trans_input_result {
36  	UNKNOWN = 0,
37  	PASS,
38  	FAIL
39  };
40  
41  struct mod_hdcp_transition_input_hdcp1 {
42  	uint8_t bksv_read;
43  	uint8_t bksv_validation;
44  	uint8_t create_session;
45  	uint8_t an_write;
46  	uint8_t aksv_write;
47  	uint8_t ainfo_write;
48  	uint8_t bcaps_read;
49  	uint8_t r0p_read;
50  	uint8_t rx_validation;
51  	uint8_t encryption;
52  	uint8_t link_maintenance;
53  	uint8_t ready_check;
54  	uint8_t bstatus_read;
55  	uint8_t max_cascade_check;
56  	uint8_t max_devs_check;
57  	uint8_t device_count_check;
58  	uint8_t ksvlist_read;
59  	uint8_t vp_read;
60  	uint8_t ksvlist_vp_validation;
61  
62  	uint8_t hdcp_capable_dp;
63  	uint8_t binfo_read_dp;
64  	uint8_t r0p_available_dp;
65  	uint8_t link_integrity_check;
66  	uint8_t reauth_request_check;
67  	uint8_t stream_encryption_dp;
68  };
69  
70  struct mod_hdcp_transition_input_hdcp2 {
71  	uint8_t hdcp2version_read;
72  	uint8_t hdcp2_capable_check;
73  	uint8_t create_session;
74  	uint8_t ake_init_prepare;
75  	uint8_t ake_init_write;
76  	uint8_t rxstatus_read;
77  	uint8_t ake_cert_available;
78  	uint8_t ake_cert_read;
79  	uint8_t ake_cert_validation;
80  	uint8_t stored_km_write;
81  	uint8_t no_stored_km_write;
82  	uint8_t h_prime_available;
83  	uint8_t h_prime_read;
84  	uint8_t pairing_available;
85  	uint8_t pairing_info_read;
86  	uint8_t h_prime_validation;
87  	uint8_t lc_init_prepare;
88  	uint8_t lc_init_write;
89  	uint8_t l_prime_available_poll;
90  	uint8_t l_prime_read;
91  	uint8_t l_prime_validation;
92  	uint8_t eks_prepare;
93  	uint8_t eks_write;
94  	uint8_t enable_encryption;
95  	uint8_t reauth_request_check;
96  	uint8_t rx_id_list_read;
97  	uint8_t device_count_check;
98  	uint8_t rx_id_list_validation;
99  	uint8_t repeater_auth_ack_write;
100  	uint8_t prepare_stream_manage;
101  	uint8_t stream_manage_write;
102  	uint8_t stream_ready_available;
103  	uint8_t stream_ready_read;
104  	uint8_t stream_ready_validation;
105  
106  	uint8_t rx_caps_read_dp;
107  	uint8_t content_stream_type_write;
108  	uint8_t link_integrity_check_dp;
109  	uint8_t stream_encryption_dp;
110  };
111  
112  union mod_hdcp_transition_input {
113  	struct mod_hdcp_transition_input_hdcp1 hdcp1;
114  	struct mod_hdcp_transition_input_hdcp2 hdcp2;
115  };
116  
117  struct mod_hdcp_message_hdcp1 {
118  	uint8_t		an[8];
119  	uint8_t		aksv[5];
120  	uint8_t		ainfo;
121  	uint8_t		bksv[5];
122  	uint16_t	r0p;
123  	uint8_t		bcaps;
124  	uint16_t	bstatus;
125  	uint8_t		ksvlist[635];
126  	uint16_t	ksvlist_size;
127  	uint8_t		vp[20];
128  
129  	uint16_t	binfo_dp;
130  };
131  
132  struct mod_hdcp_message_hdcp2 {
133  	uint8_t		hdcp2version_hdmi;
134  	uint8_t		rxcaps_dp[3];
135  	uint8_t		rxstatus[2];
136  
137  	uint8_t		ake_init[12];
138  	uint8_t		ake_cert[534];
139  	uint8_t		ake_no_stored_km[129];
140  	uint8_t		ake_stored_km[33];
141  	uint8_t		ake_h_prime[33];
142  	uint8_t		ake_pairing_info[17];
143  	uint8_t		lc_init[9];
144  	uint8_t		lc_l_prime[33];
145  	uint8_t		ske_eks[25];
146  	uint8_t		rx_id_list[177]; // 22 + 5 * 31
147  	uint16_t	rx_id_list_size;
148  	uint8_t		repeater_auth_ack[17];
149  	uint8_t		repeater_auth_stream_manage[68]; // 6 + 2 * 31
150  	uint16_t	stream_manage_size;
151  	uint8_t		repeater_auth_stream_ready[33];
152  	uint8_t		rxstatus_dp;
153  	uint8_t		content_stream_type_dp[2];
154  };
155  
156  union mod_hdcp_message {
157  	struct mod_hdcp_message_hdcp1 hdcp1;
158  	struct mod_hdcp_message_hdcp2 hdcp2;
159  };
160  
161  struct mod_hdcp_auth_counters {
162  	uint8_t stream_management_retry_count;
163  };
164  
165  /* contains values per connection */
166  struct mod_hdcp_connection {
167  	struct mod_hdcp_link link;
168  	uint8_t is_repeater;
169  	uint8_t is_km_stored;
170  	uint8_t is_hdcp1_revoked;
171  	uint8_t is_hdcp2_revoked;
172  	struct mod_hdcp_trace trace;
173  	uint8_t hdcp1_retry_count;
174  	uint8_t hdcp2_retry_count;
175  };
176  
177  /* contains values per authentication cycle */
178  struct mod_hdcp_authentication {
179  	uint32_t id;
180  	union mod_hdcp_message msg;
181  	union mod_hdcp_transition_input trans_input;
182  	struct mod_hdcp_auth_counters count;
183  };
184  
185  /* contains values per state change */
186  struct mod_hdcp_state {
187  	uint8_t id;
188  	uint32_t stay_count;
189  };
190  
191  /* per event in a state */
192  struct mod_hdcp_event_context {
193  	enum mod_hdcp_event event;
194  	uint8_t rx_id_list_ready;
195  	uint8_t unexpected_event;
196  };
197  
198  struct mod_hdcp {
199  	/* per link */
200  	struct mod_hdcp_config config;
201  	/* per connection */
202  	struct mod_hdcp_connection connection;
203  	/* per displays */
204  	struct mod_hdcp_display displays[MAX_NUM_OF_DISPLAYS];
205  	/* per authentication attempt */
206  	struct mod_hdcp_authentication auth;
207  	/* per state in an authentication */
208  	struct mod_hdcp_state state;
209  	/* reserved memory buffer */
210  	uint8_t buf[2025];
211  };
212  
213  enum mod_hdcp_initial_state_id {
214  	HDCP_UNINITIALIZED = 0x0,
215  	HDCP_INITIAL_STATE_START = HDCP_UNINITIALIZED,
216  	HDCP_INITIALIZED,
217  	HDCP_CP_NOT_DESIRED,
218  	HDCP_INITIAL_STATE_END = HDCP_CP_NOT_DESIRED
219  };
220  
221  enum mod_hdcp_hdcp1_state_id {
222  	HDCP1_STATE_START = HDCP_INITIAL_STATE_END,
223  	H1_A0_WAIT_FOR_ACTIVE_RX,
224  	H1_A1_EXCHANGE_KSVS,
225  	H1_A2_COMPUTATIONS_A3_VALIDATE_RX_A6_TEST_FOR_REPEATER,
226  	H1_A45_AUTHENTICATED,
227  	H1_A8_WAIT_FOR_READY,
228  	H1_A9_READ_KSV_LIST,
229  	HDCP1_STATE_END = H1_A9_READ_KSV_LIST
230  };
231  
232  enum mod_hdcp_hdcp1_dp_state_id {
233  	HDCP1_DP_STATE_START = HDCP1_STATE_END,
234  	D1_A0_DETERMINE_RX_HDCP_CAPABLE,
235  	D1_A1_EXCHANGE_KSVS,
236  	D1_A23_WAIT_FOR_R0_PRIME,
237  	D1_A2_COMPUTATIONS_A3_VALIDATE_RX_A5_TEST_FOR_REPEATER,
238  	D1_A4_AUTHENTICATED,
239  	D1_A6_WAIT_FOR_READY,
240  	D1_A7_READ_KSV_LIST,
241  	HDCP1_DP_STATE_END = D1_A7_READ_KSV_LIST,
242  };
243  
244  enum mod_hdcp_hdcp2_state_id {
245  	HDCP2_STATE_START = HDCP1_DP_STATE_END,
246  	H2_A0_KNOWN_HDCP2_CAPABLE_RX,
247  	H2_A1_SEND_AKE_INIT,
248  	H2_A1_VALIDATE_AKE_CERT,
249  	H2_A1_SEND_NO_STORED_KM,
250  	H2_A1_READ_H_PRIME,
251  	H2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME,
252  	H2_A1_SEND_STORED_KM,
253  	H2_A1_VALIDATE_H_PRIME,
254  	H2_A2_LOCALITY_CHECK,
255  	H2_A3_EXCHANGE_KS_AND_TEST_FOR_REPEATER,
256  	H2_ENABLE_ENCRYPTION,
257  	H2_A5_AUTHENTICATED,
258  	H2_A6_WAIT_FOR_RX_ID_LIST,
259  	H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK,
260  	H2_A9_SEND_STREAM_MANAGEMENT,
261  	H2_A9_VALIDATE_STREAM_READY,
262  	HDCP2_STATE_END = H2_A9_VALIDATE_STREAM_READY,
263  };
264  
265  enum mod_hdcp_hdcp2_dp_state_id {
266  	HDCP2_DP_STATE_START = HDCP2_STATE_END,
267  	D2_A0_DETERMINE_RX_HDCP_CAPABLE,
268  	D2_A1_SEND_AKE_INIT,
269  	D2_A1_VALIDATE_AKE_CERT,
270  	D2_A1_SEND_NO_STORED_KM,
271  	D2_A1_READ_H_PRIME,
272  	D2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME,
273  	D2_A1_SEND_STORED_KM,
274  	D2_A1_VALIDATE_H_PRIME,
275  	D2_A2_LOCALITY_CHECK,
276  	D2_A34_EXCHANGE_KS_AND_TEST_FOR_REPEATER,
277  	D2_SEND_CONTENT_STREAM_TYPE,
278  	D2_ENABLE_ENCRYPTION,
279  	D2_A5_AUTHENTICATED,
280  	D2_A6_WAIT_FOR_RX_ID_LIST,
281  	D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK,
282  	D2_A9_SEND_STREAM_MANAGEMENT,
283  	D2_A9_VALIDATE_STREAM_READY,
284  	HDCP2_DP_STATE_END = D2_A9_VALIDATE_STREAM_READY,
285  	HDCP_STATE_END = HDCP2_DP_STATE_END,
286  };
287  
288  /* hdcp1 executions and transitions */
289  typedef enum mod_hdcp_status (*mod_hdcp_action)(struct mod_hdcp *hdcp);
290  uint8_t mod_hdcp_execute_and_set(
291  		mod_hdcp_action func, uint8_t *flag,
292  		enum mod_hdcp_status *status, struct mod_hdcp *hdcp, char *str);
293  enum mod_hdcp_status mod_hdcp_hdcp1_execution(struct mod_hdcp *hdcp,
294  	struct mod_hdcp_event_context *event_ctx,
295  	struct mod_hdcp_transition_input_hdcp1 *input);
296  enum mod_hdcp_status mod_hdcp_hdcp1_dp_execution(struct mod_hdcp *hdcp,
297  	struct mod_hdcp_event_context *event_ctx,
298  	struct mod_hdcp_transition_input_hdcp1 *input);
299  enum mod_hdcp_status mod_hdcp_hdcp1_transition(struct mod_hdcp *hdcp,
300  	struct mod_hdcp_event_context *event_ctx,
301  	struct mod_hdcp_transition_input_hdcp1 *input,
302  	struct mod_hdcp_output *output);
303  enum mod_hdcp_status mod_hdcp_hdcp1_dp_transition(struct mod_hdcp *hdcp,
304  	struct mod_hdcp_event_context *event_ctx,
305  	struct mod_hdcp_transition_input_hdcp1 *input,
306  	struct mod_hdcp_output *output);
307  
308  /* hdcp2 executions and transitions */
309  enum mod_hdcp_status mod_hdcp_hdcp2_execution(struct mod_hdcp *hdcp,
310  	struct mod_hdcp_event_context *event_ctx,
311  	struct mod_hdcp_transition_input_hdcp2 *input);
312  enum mod_hdcp_status mod_hdcp_hdcp2_dp_execution(struct mod_hdcp *hdcp,
313  	struct mod_hdcp_event_context *event_ctx,
314  	struct mod_hdcp_transition_input_hdcp2 *input);
315  enum mod_hdcp_status mod_hdcp_hdcp2_transition(struct mod_hdcp *hdcp,
316  	struct mod_hdcp_event_context *event_ctx,
317  	struct mod_hdcp_transition_input_hdcp2 *input,
318  	struct mod_hdcp_output *output);
319  enum mod_hdcp_status mod_hdcp_hdcp2_dp_transition(struct mod_hdcp *hdcp,
320  	struct mod_hdcp_event_context *event_ctx,
321  	struct mod_hdcp_transition_input_hdcp2 *input,
322  	struct mod_hdcp_output *output);
323  
324  /* log functions */
325  void mod_hdcp_dump_binary_message(uint8_t *msg, uint32_t msg_size,
326  		uint8_t *buf, uint32_t buf_size);
327  void mod_hdcp_log_ddc_trace(struct mod_hdcp *hdcp);
328  /* TODO: add adjustment log */
329  
330  /* psp functions */
331  enum mod_hdcp_status mod_hdcp_add_display_to_topology(
332  		struct mod_hdcp *hdcp, struct mod_hdcp_display *display);
333  enum mod_hdcp_status mod_hdcp_remove_display_from_topology(
334  		struct mod_hdcp *hdcp, uint8_t index);
335  enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp);
336  enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp);
337  enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp);
338  enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp);
339  enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp);
340  enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(
341  	struct mod_hdcp *hdcp);
342  enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp);
343  enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp);
344  enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp);
345  enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp);
346  enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp);
347  enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp);
348  enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp);
349  enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp);
350  enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp);
351  enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp);
352  enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp);
353  enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(
354  		struct mod_hdcp *hdcp);
355  enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(
356  		struct mod_hdcp *hdcp);
357  enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(
358  		struct mod_hdcp *hdcp);
359  
360  /* ddc functions */
361  enum mod_hdcp_status mod_hdcp_read_bksv(struct mod_hdcp *hdcp);
362  enum mod_hdcp_status mod_hdcp_read_bcaps(struct mod_hdcp *hdcp);
363  enum mod_hdcp_status mod_hdcp_read_bstatus(struct mod_hdcp *hdcp);
364  enum mod_hdcp_status mod_hdcp_read_r0p(struct mod_hdcp *hdcp);
365  enum mod_hdcp_status mod_hdcp_read_ksvlist(struct mod_hdcp *hdcp);
366  enum mod_hdcp_status mod_hdcp_read_vp(struct mod_hdcp *hdcp);
367  enum mod_hdcp_status mod_hdcp_read_binfo(struct mod_hdcp *hdcp);
368  enum mod_hdcp_status mod_hdcp_write_aksv(struct mod_hdcp *hdcp);
369  enum mod_hdcp_status mod_hdcp_write_ainfo(struct mod_hdcp *hdcp);
370  enum mod_hdcp_status mod_hdcp_write_an(struct mod_hdcp *hdcp);
371  enum mod_hdcp_status mod_hdcp_read_hdcp2version(struct mod_hdcp *hdcp);
372  enum mod_hdcp_status mod_hdcp_read_rxcaps(struct mod_hdcp *hdcp);
373  enum mod_hdcp_status mod_hdcp_read_rxstatus(struct mod_hdcp *hdcp);
374  enum mod_hdcp_status mod_hdcp_read_ake_cert(struct mod_hdcp *hdcp);
375  enum mod_hdcp_status mod_hdcp_read_h_prime(struct mod_hdcp *hdcp);
376  enum mod_hdcp_status mod_hdcp_read_pairing_info(struct mod_hdcp *hdcp);
377  enum mod_hdcp_status mod_hdcp_read_l_prime(struct mod_hdcp *hdcp);
378  enum mod_hdcp_status mod_hdcp_read_rx_id_list(struct mod_hdcp *hdcp);
379  enum mod_hdcp_status mod_hdcp_read_stream_ready(struct mod_hdcp *hdcp);
380  enum mod_hdcp_status mod_hdcp_write_ake_init(struct mod_hdcp *hdcp);
381  enum mod_hdcp_status mod_hdcp_write_no_stored_km(struct mod_hdcp *hdcp);
382  enum mod_hdcp_status mod_hdcp_write_stored_km(struct mod_hdcp *hdcp);
383  enum mod_hdcp_status mod_hdcp_write_lc_init(struct mod_hdcp *hdcp);
384  enum mod_hdcp_status mod_hdcp_write_eks(struct mod_hdcp *hdcp);
385  enum mod_hdcp_status mod_hdcp_write_repeater_auth_ack(struct mod_hdcp *hdcp);
386  enum mod_hdcp_status mod_hdcp_write_stream_manage(struct mod_hdcp *hdcp);
387  enum mod_hdcp_status mod_hdcp_write_content_type(struct mod_hdcp *hdcp);
388  enum mod_hdcp_status mod_hdcp_clear_cp_irq_status(struct mod_hdcp *hdcp);
389  
390  /* hdcp version helpers */
is_dp_hdcp(struct mod_hdcp * hdcp)391  static inline uint8_t is_dp_hdcp(struct mod_hdcp *hdcp)
392  {
393  	return (hdcp->connection.link.mode == MOD_HDCP_MODE_DP);
394  }
395  
is_dp_mst_hdcp(struct mod_hdcp * hdcp)396  static inline uint8_t is_dp_mst_hdcp(struct mod_hdcp *hdcp)
397  {
398  	return (hdcp->connection.link.mode == MOD_HDCP_MODE_DP &&
399  			hdcp->connection.link.dp.mst_enabled);
400  }
401  
is_hdmi_dvi_sl_hdcp(struct mod_hdcp * hdcp)402  static inline uint8_t is_hdmi_dvi_sl_hdcp(struct mod_hdcp *hdcp)
403  {
404  	return (hdcp->connection.link.mode == MOD_HDCP_MODE_DEFAULT);
405  }
406  
407  /* hdcp state helpers */
current_state(struct mod_hdcp * hdcp)408  static inline uint8_t current_state(struct mod_hdcp *hdcp)
409  {
410  	return hdcp->state.id;
411  }
412  
set_state_id(struct mod_hdcp * hdcp,struct mod_hdcp_output * output,uint8_t id)413  static inline void set_state_id(struct mod_hdcp *hdcp,
414  		struct mod_hdcp_output *output, uint8_t id)
415  {
416  	memset(&hdcp->state, 0, sizeof(hdcp->state));
417  	hdcp->state.id = id;
418  	/* callback timer should be reset per state */
419  	output->callback_stop = 1;
420  	output->watchdog_timer_stop = 1;
421  	HDCP_NEXT_STATE_TRACE(hdcp, id, output);
422  }
423  
is_in_hdcp1_states(struct mod_hdcp * hdcp)424  static inline uint8_t is_in_hdcp1_states(struct mod_hdcp *hdcp)
425  {
426  	return (current_state(hdcp) > HDCP1_STATE_START &&
427  			current_state(hdcp) <= HDCP1_STATE_END);
428  }
429  
is_in_hdcp1_dp_states(struct mod_hdcp * hdcp)430  static inline uint8_t is_in_hdcp1_dp_states(struct mod_hdcp *hdcp)
431  {
432  	return (current_state(hdcp) > HDCP1_DP_STATE_START &&
433  			current_state(hdcp) <= HDCP1_DP_STATE_END);
434  }
435  
is_in_hdcp2_states(struct mod_hdcp * hdcp)436  static inline uint8_t is_in_hdcp2_states(struct mod_hdcp *hdcp)
437  {
438  	return (current_state(hdcp) > HDCP2_STATE_START &&
439  			current_state(hdcp) <= HDCP2_STATE_END);
440  }
441  
is_in_hdcp2_dp_states(struct mod_hdcp * hdcp)442  static inline uint8_t is_in_hdcp2_dp_states(struct mod_hdcp *hdcp)
443  {
444  	return (current_state(hdcp) > HDCP2_DP_STATE_START &&
445  			current_state(hdcp) <= HDCP2_DP_STATE_END);
446  }
447  
is_in_authenticated_states(struct mod_hdcp * hdcp)448  static inline uint8_t is_in_authenticated_states(struct mod_hdcp *hdcp)
449  {
450  	return (current_state(hdcp) == D1_A4_AUTHENTICATED ||
451  	current_state(hdcp) == H1_A45_AUTHENTICATED ||
452  	current_state(hdcp) == D2_A5_AUTHENTICATED ||
453  	current_state(hdcp) == H2_A5_AUTHENTICATED);
454  }
455  
is_hdcp1(struct mod_hdcp * hdcp)456  static inline uint8_t is_hdcp1(struct mod_hdcp *hdcp)
457  {
458  	return (is_in_hdcp1_states(hdcp) || is_in_hdcp1_dp_states(hdcp));
459  }
460  
is_hdcp2(struct mod_hdcp * hdcp)461  static inline uint8_t is_hdcp2(struct mod_hdcp *hdcp)
462  {
463  	return (is_in_hdcp2_states(hdcp) || is_in_hdcp2_dp_states(hdcp));
464  }
465  
is_in_cp_not_desired_state(struct mod_hdcp * hdcp)466  static inline uint8_t is_in_cp_not_desired_state(struct mod_hdcp *hdcp)
467  {
468  	return current_state(hdcp) == HDCP_CP_NOT_DESIRED;
469  }
470  
is_in_initialized_state(struct mod_hdcp * hdcp)471  static inline uint8_t is_in_initialized_state(struct mod_hdcp *hdcp)
472  {
473  	return current_state(hdcp) == HDCP_INITIALIZED;
474  }
475  
476  /* transition operation helpers */
increment_stay_counter(struct mod_hdcp * hdcp)477  static inline void increment_stay_counter(struct mod_hdcp *hdcp)
478  {
479  	hdcp->state.stay_count++;
480  }
481  
fail_and_restart_in_ms(uint16_t time,enum mod_hdcp_status * status,struct mod_hdcp_output * output)482  static inline void fail_and_restart_in_ms(uint16_t time,
483  		enum mod_hdcp_status *status,
484  		struct mod_hdcp_output *output)
485  {
486  	output->callback_needed = 1;
487  	output->callback_delay = time;
488  	output->watchdog_timer_needed = 0;
489  	output->watchdog_timer_delay = 0;
490  	*status = MOD_HDCP_STATUS_RESET_NEEDED;
491  }
492  
callback_in_ms(uint16_t time,struct mod_hdcp_output * output)493  static inline void callback_in_ms(uint16_t time, struct mod_hdcp_output *output)
494  {
495  	output->callback_needed = 1;
496  	output->callback_delay = time;
497  }
498  
set_watchdog_in_ms(struct mod_hdcp * hdcp,uint16_t time,struct mod_hdcp_output * output)499  static inline void set_watchdog_in_ms(struct mod_hdcp *hdcp, uint16_t time,
500  		struct mod_hdcp_output *output)
501  {
502  	output->watchdog_timer_needed = 1;
503  	output->watchdog_timer_delay = time;
504  }
505  
set_auth_complete(struct mod_hdcp * hdcp,struct mod_hdcp_output * output)506  static inline void set_auth_complete(struct mod_hdcp *hdcp,
507  		struct mod_hdcp_output *output)
508  {
509  	output->auth_complete = 1;
510  	mod_hdcp_log_ddc_trace(hdcp);
511  }
512  
513  /* connection topology helpers */
is_display_active(struct mod_hdcp_display * display)514  static inline uint8_t is_display_active(struct mod_hdcp_display *display)
515  {
516  	return display->state >= MOD_HDCP_DISPLAY_ACTIVE;
517  }
518  
is_display_encryption_enabled(struct mod_hdcp_display * display)519  static inline uint8_t is_display_encryption_enabled(struct mod_hdcp_display *display)
520  {
521  	return display->state >= MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
522  }
523  
get_active_display_count(struct mod_hdcp * hdcp)524  static inline uint8_t get_active_display_count(struct mod_hdcp *hdcp)
525  {
526  	uint8_t active_count = 0;
527  	uint8_t i;
528  
529  	for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
530  		if (is_display_active(&hdcp->displays[i]))
531  			active_count++;
532  	return active_count;
533  }
534  
get_first_active_display(struct mod_hdcp * hdcp)535  static inline struct mod_hdcp_display *get_first_active_display(
536  		struct mod_hdcp *hdcp)
537  {
538  	uint8_t i;
539  	struct mod_hdcp_display *display = NULL;
540  
541  	for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
542  		if (is_display_active(&hdcp->displays[i])) {
543  			display = &hdcp->displays[i];
544  			break;
545  		}
546  	return display;
547  }
548  
get_active_display_at_index(struct mod_hdcp * hdcp,uint8_t index)549  static inline struct mod_hdcp_display *get_active_display_at_index(
550  		struct mod_hdcp *hdcp, uint8_t index)
551  {
552  	uint8_t i;
553  	struct mod_hdcp_display *display = NULL;
554  
555  	for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
556  		if (hdcp->displays[i].index == index &&
557  				is_display_active(&hdcp->displays[i])) {
558  			display = &hdcp->displays[i];
559  			break;
560  		}
561  	return display;
562  }
563  
get_empty_display_container(struct mod_hdcp * hdcp)564  static inline struct mod_hdcp_display *get_empty_display_container(
565  		struct mod_hdcp *hdcp)
566  {
567  	uint8_t i;
568  	struct mod_hdcp_display *display = NULL;
569  
570  	for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
571  		if (!is_display_active(&hdcp->displays[i])) {
572  			display = &hdcp->displays[i];
573  			break;
574  		}
575  	return display;
576  }
577  
reset_retry_counts(struct mod_hdcp * hdcp)578  static inline void reset_retry_counts(struct mod_hdcp *hdcp)
579  {
580  	hdcp->connection.hdcp1_retry_count = 0;
581  	hdcp->connection.hdcp2_retry_count = 0;
582  }
583  
584  #endif /* HDCP_H_ */
585