2 * Copyright 2019 Advanced Micro Devices, Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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.
26 #include "amdgpu_dm_hdcp.h"
28 #include "amdgpu_dm.h"
29 #include "dm_helpers.h"
30 #include <drm/drm_hdcp.h>
34 * If the SRM version being loaded is less than or equal to the
35 * currently loaded SRM, psp will return 0xFFFF as the version
37 #define PSP_SRM_VERSION_MAX 0xFFFF
40 lp_write_i2c(void *handle
, uint32_t address
, const uint8_t *data
, uint32_t size
)
43 struct dc_link
*link
= handle
;
44 struct i2c_payload i2c_payloads
[] = {{true, address
, size
, (void *)data
} };
45 struct i2c_command cmd
= {i2c_payloads
, 1, I2C_COMMAND_ENGINE_HW
, link
->dc
->caps
.i2c_speed_in_khz
};
47 return dm_helpers_submit_i2c(link
->ctx
, link
, &cmd
);
51 lp_read_i2c(void *handle
, uint32_t address
, uint8_t offset
, uint8_t *data
, uint32_t size
)
53 struct dc_link
*link
= handle
;
55 struct i2c_payload i2c_payloads
[] = {{true, address
, 1, &offset
}, {false, address
, size
, data
} };
56 struct i2c_command cmd
= {i2c_payloads
, 2, I2C_COMMAND_ENGINE_HW
, link
->dc
->caps
.i2c_speed_in_khz
};
58 return dm_helpers_submit_i2c(link
->ctx
, link
, &cmd
);
62 lp_write_dpcd(void *handle
, uint32_t address
, const uint8_t *data
, uint32_t size
)
64 struct dc_link
*link
= handle
;
66 return dm_helpers_dp_write_dpcd(link
->ctx
, link
, address
, data
, size
);
70 lp_read_dpcd(void *handle
, uint32_t address
, uint8_t *data
, uint32_t size
)
72 struct dc_link
*link
= handle
;
74 return dm_helpers_dp_read_dpcd(link
->ctx
, link
, address
, data
, size
);
77 static uint8_t *psp_get_srm(struct psp_context
*psp
, uint32_t *srm_version
, uint32_t *srm_size
)
80 struct ta_hdcp_shared_memory
*hdcp_cmd
;
82 if (!psp
->hdcp_context
.hdcp_initialized
) {
83 DRM_WARN("Failed to get hdcp srm. HDCP TA is not initialized.");
87 hdcp_cmd
= (struct ta_hdcp_shared_memory
*)psp
->hdcp_context
.hdcp_shared_buf
;
88 memset(hdcp_cmd
, 0, sizeof(struct ta_hdcp_shared_memory
));
90 hdcp_cmd
->cmd_id
= TA_HDCP_COMMAND__HDCP_GET_SRM
;
91 psp_hdcp_invoke(psp
, hdcp_cmd
->cmd_id
);
93 if (hdcp_cmd
->hdcp_status
!= TA_HDCP_STATUS__SUCCESS
)
96 *srm_version
= hdcp_cmd
->out_msg
.hdcp_get_srm
.srm_version
;
97 *srm_size
= hdcp_cmd
->out_msg
.hdcp_get_srm
.srm_buf_size
;
100 return hdcp_cmd
->out_msg
.hdcp_get_srm
.srm_buf
;
103 static int psp_set_srm(struct psp_context
*psp
, uint8_t *srm
, uint32_t srm_size
, uint32_t *srm_version
)
106 struct ta_hdcp_shared_memory
*hdcp_cmd
;
108 if (!psp
->hdcp_context
.hdcp_initialized
) {
109 DRM_WARN("Failed to get hdcp srm. HDCP TA is not initialized.");
113 hdcp_cmd
= (struct ta_hdcp_shared_memory
*)psp
->hdcp_context
.hdcp_shared_buf
;
114 memset(hdcp_cmd
, 0, sizeof(struct ta_hdcp_shared_memory
));
116 memcpy(hdcp_cmd
->in_msg
.hdcp_set_srm
.srm_buf
, srm
, srm_size
);
117 hdcp_cmd
->in_msg
.hdcp_set_srm
.srm_buf_size
= srm_size
;
118 hdcp_cmd
->cmd_id
= TA_HDCP_COMMAND__HDCP_SET_SRM
;
120 psp_hdcp_invoke(psp
, hdcp_cmd
->cmd_id
);
122 if (hdcp_cmd
->hdcp_status
!= TA_HDCP_STATUS__SUCCESS
|| hdcp_cmd
->out_msg
.hdcp_set_srm
.valid_signature
!= 1 ||
123 hdcp_cmd
->out_msg
.hdcp_set_srm
.srm_version
== PSP_SRM_VERSION_MAX
)
126 *srm_version
= hdcp_cmd
->out_msg
.hdcp_set_srm
.srm_version
;
130 static void process_output(struct hdcp_workqueue
*hdcp_work
)
132 struct mod_hdcp_output output
= hdcp_work
->output
;
134 if (output
.callback_stop
)
135 cancel_delayed_work(&hdcp_work
->callback_dwork
);
137 if (output
.callback_needed
)
138 schedule_delayed_work(&hdcp_work
->callback_dwork
,
139 msecs_to_jiffies(output
.callback_delay
));
141 if (output
.watchdog_timer_stop
)
142 cancel_delayed_work(&hdcp_work
->watchdog_timer_dwork
);
144 if (output
.watchdog_timer_needed
)
145 schedule_delayed_work(&hdcp_work
->watchdog_timer_dwork
,
146 msecs_to_jiffies(output
.watchdog_timer_delay
));
148 schedule_delayed_work(&hdcp_work
->property_validate_dwork
, msecs_to_jiffies(0));
151 static void link_lock(struct hdcp_workqueue
*work
, bool lock
)
156 for (i
= 0; i
< work
->max_link
; i
++) {
158 mutex_lock(&work
[i
].mutex
);
160 mutex_unlock(&work
[i
].mutex
);
163 void hdcp_update_display(struct hdcp_workqueue
*hdcp_work
,
164 unsigned int link_index
,
165 struct amdgpu_dm_connector
*aconnector
,
166 uint8_t content_type
,
167 bool enable_encryption
)
169 struct hdcp_workqueue
*hdcp_w
= &hdcp_work
[link_index
];
170 struct mod_hdcp_display
*display
= &hdcp_work
[link_index
].display
;
171 struct mod_hdcp_link
*link
= &hdcp_work
[link_index
].link
;
172 struct mod_hdcp_display_query query
;
174 mutex_lock(&hdcp_w
->mutex
);
175 hdcp_w
->aconnector
= aconnector
;
177 query
.display
= NULL
;
178 mod_hdcp_query_display(&hdcp_w
->hdcp
, aconnector
->base
.index
, &query
);
180 if (query
.display
!= NULL
) {
181 memcpy(display
, query
.display
, sizeof(struct mod_hdcp_display
));
182 mod_hdcp_remove_display(&hdcp_w
->hdcp
, aconnector
->base
.index
, &hdcp_w
->output
);
184 hdcp_w
->link
.adjust
.hdcp2
.force_type
= MOD_HDCP_FORCE_TYPE_0
;
186 if (enable_encryption
) {
187 /* Explicitly set the saved SRM as sysfs call will be after we already enabled hdcp
190 if (hdcp_work
->srm_size
> 0)
191 psp_set_srm(hdcp_work
->hdcp
.config
.psp
.handle
, hdcp_work
->srm
, hdcp_work
->srm_size
,
192 &hdcp_work
->srm_version
);
194 display
->adjust
.disable
= 0;
195 if (content_type
== DRM_MODE_HDCP_CONTENT_TYPE0
) {
196 hdcp_w
->link
.adjust
.hdcp1
.disable
= 0;
197 hdcp_w
->link
.adjust
.hdcp2
.force_type
= MOD_HDCP_FORCE_TYPE_0
;
198 } else if (content_type
== DRM_MODE_HDCP_CONTENT_TYPE1
) {
199 hdcp_w
->link
.adjust
.hdcp1
.disable
= 1;
200 hdcp_w
->link
.adjust
.hdcp2
.force_type
= MOD_HDCP_FORCE_TYPE_1
;
203 schedule_delayed_work(&hdcp_w
->property_validate_dwork
,
204 msecs_to_jiffies(DRM_HDCP_CHECK_PERIOD_MS
));
206 display
->adjust
.disable
= 1;
207 hdcp_w
->encryption_status
= MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF
;
208 cancel_delayed_work(&hdcp_w
->property_validate_dwork
);
211 display
->state
= MOD_HDCP_DISPLAY_ACTIVE
;
214 mod_hdcp_add_display(&hdcp_w
->hdcp
, link
, display
, &hdcp_w
->output
);
216 process_output(hdcp_w
);
217 mutex_unlock(&hdcp_w
->mutex
);
220 static void hdcp_remove_display(struct hdcp_workqueue
*hdcp_work
,
221 unsigned int link_index
,
222 struct amdgpu_dm_connector
*aconnector
)
224 struct hdcp_workqueue
*hdcp_w
= &hdcp_work
[link_index
];
226 mutex_lock(&hdcp_w
->mutex
);
227 hdcp_w
->aconnector
= aconnector
;
229 mod_hdcp_remove_display(&hdcp_w
->hdcp
, aconnector
->base
.index
, &hdcp_w
->output
);
231 process_output(hdcp_w
);
232 mutex_unlock(&hdcp_w
->mutex
);
234 void hdcp_reset_display(struct hdcp_workqueue
*hdcp_work
, unsigned int link_index
)
236 struct hdcp_workqueue
*hdcp_w
= &hdcp_work
[link_index
];
238 mutex_lock(&hdcp_w
->mutex
);
240 mod_hdcp_reset_connection(&hdcp_w
->hdcp
, &hdcp_w
->output
);
242 cancel_delayed_work(&hdcp_w
->property_validate_dwork
);
243 hdcp_w
->encryption_status
= MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF
;
245 process_output(hdcp_w
);
247 mutex_unlock(&hdcp_w
->mutex
);
250 void hdcp_handle_cpirq(struct hdcp_workqueue
*hdcp_work
, unsigned int link_index
)
252 struct hdcp_workqueue
*hdcp_w
= &hdcp_work
[link_index
];
254 schedule_work(&hdcp_w
->cpirq_work
);
260 static void event_callback(struct work_struct
*work
)
262 struct hdcp_workqueue
*hdcp_work
;
264 hdcp_work
= container_of(to_delayed_work(work
), struct hdcp_workqueue
,
267 mutex_lock(&hdcp_work
->mutex
);
269 cancel_delayed_work(&hdcp_work
->callback_dwork
);
271 mod_hdcp_process_event(&hdcp_work
->hdcp
, MOD_HDCP_EVENT_CALLBACK
,
274 process_output(hdcp_work
);
276 mutex_unlock(&hdcp_work
->mutex
);
280 static void event_property_update(struct work_struct
*work
)
283 struct hdcp_workqueue
*hdcp_work
= container_of(work
, struct hdcp_workqueue
, property_update_work
);
284 struct amdgpu_dm_connector
*aconnector
= hdcp_work
->aconnector
;
285 struct drm_device
*dev
= hdcp_work
->aconnector
->base
.dev
;
288 drm_modeset_lock(&dev
->mode_config
.connection_mutex
, NULL
);
289 mutex_lock(&hdcp_work
->mutex
);
292 if (aconnector
->base
.state
->commit
) {
293 ret
= wait_for_completion_interruptible_timeout(&aconnector
->base
.state
->commit
->hw_done
, 10 * HZ
);
296 DRM_ERROR("HDCP state unknown! Setting it to DESIRED");
297 hdcp_work
->encryption_status
= MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF
;
301 if (hdcp_work
->encryption_status
!= MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF
) {
302 if (aconnector
->base
.state
->hdcp_content_type
== DRM_MODE_HDCP_CONTENT_TYPE0
&&
303 hdcp_work
->encryption_status
<= MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON
)
304 drm_hdcp_update_content_protection(&aconnector
->base
, DRM_MODE_CONTENT_PROTECTION_ENABLED
);
305 else if (aconnector
->base
.state
->hdcp_content_type
== DRM_MODE_HDCP_CONTENT_TYPE1
&&
306 hdcp_work
->encryption_status
== MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON
)
307 drm_hdcp_update_content_protection(&aconnector
->base
, DRM_MODE_CONTENT_PROTECTION_ENABLED
);
309 drm_hdcp_update_content_protection(&aconnector
->base
, DRM_MODE_CONTENT_PROTECTION_DESIRED
);
313 mutex_unlock(&hdcp_work
->mutex
);
314 drm_modeset_unlock(&dev
->mode_config
.connection_mutex
);
317 static void event_property_validate(struct work_struct
*work
)
319 struct hdcp_workqueue
*hdcp_work
=
320 container_of(to_delayed_work(work
), struct hdcp_workqueue
, property_validate_dwork
);
321 struct mod_hdcp_display_query query
;
322 struct amdgpu_dm_connector
*aconnector
= hdcp_work
->aconnector
;
327 mutex_lock(&hdcp_work
->mutex
);
329 query
.encryption_status
= MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF
;
330 mod_hdcp_query_display(&hdcp_work
->hdcp
, aconnector
->base
.index
, &query
);
332 if (query
.encryption_status
!= hdcp_work
->encryption_status
) {
333 hdcp_work
->encryption_status
= query
.encryption_status
;
334 schedule_work(&hdcp_work
->property_update_work
);
337 mutex_unlock(&hdcp_work
->mutex
);
340 static void event_watchdog_timer(struct work_struct
*work
)
342 struct hdcp_workqueue
*hdcp_work
;
344 hdcp_work
= container_of(to_delayed_work(work
),
345 struct hdcp_workqueue
,
346 watchdog_timer_dwork
);
348 mutex_lock(&hdcp_work
->mutex
);
350 cancel_delayed_work(&hdcp_work
->watchdog_timer_dwork
);
352 mod_hdcp_process_event(&hdcp_work
->hdcp
,
353 MOD_HDCP_EVENT_WATCHDOG_TIMEOUT
,
356 process_output(hdcp_work
);
358 mutex_unlock(&hdcp_work
->mutex
);
362 static void event_cpirq(struct work_struct
*work
)
364 struct hdcp_workqueue
*hdcp_work
;
366 hdcp_work
= container_of(work
, struct hdcp_workqueue
, cpirq_work
);
368 mutex_lock(&hdcp_work
->mutex
);
370 mod_hdcp_process_event(&hdcp_work
->hdcp
, MOD_HDCP_EVENT_CPIRQ
, &hdcp_work
->output
);
372 process_output(hdcp_work
);
374 mutex_unlock(&hdcp_work
->mutex
);
379 void hdcp_destroy(struct hdcp_workqueue
*hdcp_work
)
383 for (i
= 0; i
< hdcp_work
->max_link
; i
++) {
384 cancel_delayed_work_sync(&hdcp_work
[i
].callback_dwork
);
385 cancel_delayed_work_sync(&hdcp_work
[i
].watchdog_timer_dwork
);
388 kfree(hdcp_work
->srm
);
389 kfree(hdcp_work
->srm_temp
);
393 static void update_config(void *handle
, struct cp_psp_stream_config
*config
)
395 struct hdcp_workqueue
*hdcp_work
= handle
;
396 struct amdgpu_dm_connector
*aconnector
= config
->dm_stream_ctx
;
397 int link_index
= aconnector
->dc_link
->link_index
;
398 struct mod_hdcp_display
*display
= &hdcp_work
[link_index
].display
;
399 struct mod_hdcp_link
*link
= &hdcp_work
[link_index
].link
;
401 memset(display
, 0, sizeof(*display
));
402 memset(link
, 0, sizeof(*link
));
404 display
->index
= aconnector
->base
.index
;
406 if (config
->dpms_off
) {
407 hdcp_remove_display(hdcp_work
, link_index
, aconnector
);
410 display
->state
= MOD_HDCP_DISPLAY_ACTIVE
;
412 if (aconnector
->dc_sink
!= NULL
)
413 link
->mode
= mod_hdcp_signal_type_to_operation_mode(aconnector
->dc_sink
->sink_signal
);
415 display
->controller
= CONTROLLER_ID_D0
+ config
->otg_inst
;
416 display
->dig_fe
= config
->stream_enc_inst
;
417 link
->dig_be
= config
->link_enc_inst
;
418 link
->ddc_line
= aconnector
->dc_link
->ddc_hw_inst
+ 1;
419 link
->dp
.rev
= aconnector
->dc_link
->dpcd_caps
.dpcd_rev
.raw
;
420 link
->dp
.mst_supported
= config
->mst_supported
;
421 display
->adjust
.disable
= 1;
422 link
->adjust
.auth_delay
= 3;
423 link
->adjust
.hdcp1
.disable
= 0;
425 hdcp_update_display(hdcp_work
, link_index
, aconnector
, DRM_MODE_HDCP_CONTENT_TYPE0
, false);
429 /* NOTE: From the usermodes prospective you only need to call write *ONCE*, the kernel
430 * will automatically call once or twice depending on the size
432 * call: "cat file > /sys/class/drm/card0/device/hdcp_srm" from usermode no matter what the size is
434 * The kernel can only send PAGE_SIZE at once and since MAX_SRM_FILE(5120) > PAGE_SIZE(4096),
435 * srm_data_write can be called multiple times.
437 * sysfs interface doesn't tell us the size we will get so we are sending partial SRMs to psp and on
438 * the last call we will send the full SRM. PSP will fail on every call before the last.
440 * This means we don't know if the SRM is good until the last call. And because of this limitation we
441 * cannot throw errors early as it will stop the kernel from writing to sysfs
444 * Good SRM size = 5096
445 * first call to write 4096 -> PSP fails
446 * Second call to write 1000 -> PSP Pass -> SRM is set
449 * Bad SRM size = 4096
450 * first call to write 4096 -> PSP fails (This is the same as above, but we don't know if this
454 * 1: Parse the SRM? -> It is signed so we don't know the EOF
455 * 2: We can have another sysfs that passes the size before calling set. -> simpler solution
459 * Always call get after Set to verify if set was successful.
460 * +----------------------+
462 * +----------------------+
463 * PSP will only update its srm if its older than the one we are trying to load.
464 * Always do set first than get.
465 * -if we try to "1. SET" a older version PSP will reject it and we can "2. GET" the newer
466 * version and save it
468 * -if we try to "1. SET" a newer version PSP will accept it and we can "2. GET" the
469 * same(newer) version back and save it
471 * -if we try to "1. SET" a newer version and PSP rejects it. That means the format is
472 * incorrect/corrupted and we should correct our SRM by getting it from PSP
474 static ssize_t
srm_data_write(struct file
*filp
, struct kobject
*kobj
, struct bin_attribute
*bin_attr
, char *buffer
,
475 loff_t pos
, size_t count
)
477 struct hdcp_workqueue
*work
;
478 uint32_t srm_version
= 0;
480 work
= container_of(bin_attr
, struct hdcp_workqueue
, attr
);
481 link_lock(work
, true);
483 memcpy(work
->srm_temp
+ pos
, buffer
, count
);
485 if (!psp_set_srm(work
->hdcp
.config
.psp
.handle
, work
->srm_temp
, pos
+ count
, &srm_version
)) {
486 DRM_DEBUG_DRIVER("HDCP SRM SET version 0x%X", srm_version
);
487 memcpy(work
->srm
, work
->srm_temp
, pos
+ count
);
488 work
->srm_size
= pos
+ count
;
489 work
->srm_version
= srm_version
;
493 link_lock(work
, false);
498 static ssize_t
srm_data_read(struct file
*filp
, struct kobject
*kobj
, struct bin_attribute
*bin_attr
, char *buffer
,
499 loff_t pos
, size_t count
)
501 struct hdcp_workqueue
*work
;
503 uint32_t srm_version
;
507 work
= container_of(bin_attr
, struct hdcp_workqueue
, attr
);
509 link_lock(work
, true);
511 srm
= psp_get_srm(work
->hdcp
.config
.psp
.handle
, &srm_version
, &srm_size
);
519 if (srm_size
- pos
< count
) {
520 memcpy(buffer
, srm
+ pos
, srm_size
- pos
);
521 ret
= srm_size
- pos
;
525 memcpy(buffer
, srm
+ pos
, count
);
528 link_lock(work
, false);
532 /* From the hdcp spec (5.Renewability) SRM needs to be stored in a non-volatile memory.
535 * if Application "A" sets the SRM (ver 2) and we reboot/suspend and later when Application "B"
536 * needs to use HDCP, the version in PSP should be SRM(ver 2). So SRM should be persistent
537 * across boot/reboots/suspend/resume/shutdown
539 * Currently when the system goes down (suspend/shutdown) the SRM is cleared from PSP. For HDCP we need
540 * to make the SRM persistent.
542 * -PSP owns the checking of SRM but doesn't have the ability to store it in a non-volatile memory.
543 * -The kernel cannot write to the file systems.
544 * -So we need usermode to do this for us, which is why an interface for usermode is needed
548 * Usermode can read/write to/from PSP using the sysfs interface
550 * to save SRM from PSP to storage : cat /sys/class/drm/card0/device/hdcp_srm > srmfile
551 * to load from storage to PSP: cat srmfile > /sys/class/drm/card0/device/hdcp_srm
553 static const struct bin_attribute data_attr
= {
554 .attr
= {.name
= "hdcp_srm", .mode
= 0664},
555 .size
= PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE
, /* Limit SRM size */
556 .write
= srm_data_write
,
557 .read
= srm_data_read
,
561 struct hdcp_workqueue
*hdcp_create_workqueue(struct amdgpu_device
*adev
, struct cp_psp
*cp_psp
, struct dc
*dc
)
564 int max_caps
= dc
->caps
.max_links
;
565 struct hdcp_workqueue
*hdcp_work
;
568 hdcp_work
= kcalloc(max_caps
, sizeof(*hdcp_work
), GFP_KERNEL
);
569 if (hdcp_work
== NULL
)
572 hdcp_work
->srm
= kcalloc(PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE
, sizeof(*hdcp_work
->srm
), GFP_KERNEL
);
574 if (hdcp_work
->srm
== NULL
)
575 goto fail_alloc_context
;
577 hdcp_work
->srm_temp
= kcalloc(PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE
, sizeof(*hdcp_work
->srm_temp
), GFP_KERNEL
);
579 if (hdcp_work
->srm_temp
== NULL
)
580 goto fail_alloc_context
;
582 hdcp_work
->max_link
= max_caps
;
584 for (i
= 0; i
< max_caps
; i
++) {
585 mutex_init(&hdcp_work
[i
].mutex
);
587 INIT_WORK(&hdcp_work
[i
].cpirq_work
, event_cpirq
);
588 INIT_WORK(&hdcp_work
[i
].property_update_work
, event_property_update
);
589 INIT_DELAYED_WORK(&hdcp_work
[i
].callback_dwork
, event_callback
);
590 INIT_DELAYED_WORK(&hdcp_work
[i
].watchdog_timer_dwork
, event_watchdog_timer
);
591 INIT_DELAYED_WORK(&hdcp_work
[i
].property_validate_dwork
, event_property_validate
);
593 hdcp_work
[i
].hdcp
.config
.psp
.handle
= &adev
->psp
;
594 hdcp_work
[i
].hdcp
.config
.ddc
.handle
= dc_get_link_at_index(dc
, i
);
595 hdcp_work
[i
].hdcp
.config
.ddc
.funcs
.write_i2c
= lp_write_i2c
;
596 hdcp_work
[i
].hdcp
.config
.ddc
.funcs
.read_i2c
= lp_read_i2c
;
597 hdcp_work
[i
].hdcp
.config
.ddc
.funcs
.write_dpcd
= lp_write_dpcd
;
598 hdcp_work
[i
].hdcp
.config
.ddc
.funcs
.read_dpcd
= lp_read_dpcd
;
601 cp_psp
->funcs
.update_stream_config
= update_config
;
602 cp_psp
->handle
= hdcp_work
;
604 /* File created at /sys/class/drm/card0/device/hdcp_srm*/
605 hdcp_work
[0].attr
= data_attr
;
607 if (sysfs_create_bin_file(&adev
->dev
->kobj
, &hdcp_work
[0].attr
))
608 DRM_WARN("Failed to create device file hdcp_srm");
613 kfree(hdcp_work
->srm
);
614 kfree(hdcp_work
->srm_temp
);