/* * Copyright 2019 Advanced Micro Devices, Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. * * Authors: AMD * */ #include #include "dm_services.h" #include "dm_helpers.h" #include "include/hdcp_msg_types.h" #include "include/signal_types.h" #include "core_types.h" #include "link.h" #include "link_hwss.h" #include "link/protocols/link_dpcd.h" #define DC_LOGGER \ link->ctx->logger #define HDCP14_KSV_SIZE 5 #define HDCP14_MAX_KSV_FIFO_SIZE 127*HDCP14_KSV_SIZE static const bool hdcp_cmd_is_read[HDCP_MESSAGE_ID_MAX] = { [HDCP_MESSAGE_ID_READ_BKSV] = true, [HDCP_MESSAGE_ID_READ_RI_R0] = true, [HDCP_MESSAGE_ID_READ_PJ] = true, [HDCP_MESSAGE_ID_WRITE_AKSV] = false, [HDCP_MESSAGE_ID_WRITE_AINFO] = false, [HDCP_MESSAGE_ID_WRITE_AN] = false, [HDCP_MESSAGE_ID_READ_VH_X] = true, [HDCP_MESSAGE_ID_READ_VH_0] = true, [HDCP_MESSAGE_ID_READ_VH_1] = true, [HDCP_MESSAGE_ID_READ_VH_2] = true, [HDCP_MESSAGE_ID_READ_VH_3] = true, [HDCP_MESSAGE_ID_READ_VH_4] = true, [HDCP_MESSAGE_ID_READ_BCAPS] = true, [HDCP_MESSAGE_ID_READ_BSTATUS] = true, [HDCP_MESSAGE_ID_READ_KSV_FIFO] = true, [HDCP_MESSAGE_ID_READ_BINFO] = true, [HDCP_MESSAGE_ID_HDCP2VERSION] = true, [HDCP_MESSAGE_ID_RX_CAPS] = true, [HDCP_MESSAGE_ID_WRITE_AKE_INIT] = false, [HDCP_MESSAGE_ID_READ_AKE_SEND_CERT] = true, [HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM] = false, [HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM] = false, [HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME] = true, [HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO] = true, [HDCP_MESSAGE_ID_WRITE_LC_INIT] = false, [HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME] = true, [HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS] = false, [HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST] = true, [HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK] = false, [HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE] = false, [HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY] = true, [HDCP_MESSAGE_ID_READ_RXSTATUS] = true, [HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE] = false }; static const uint8_t hdcp_i2c_offsets[HDCP_MESSAGE_ID_MAX] = { [HDCP_MESSAGE_ID_READ_BKSV] = 0x0, [HDCP_MESSAGE_ID_READ_RI_R0] = 0x8, [HDCP_MESSAGE_ID_READ_PJ] = 0xA, [HDCP_MESSAGE_ID_WRITE_AKSV] = 0x10, [HDCP_MESSAGE_ID_WRITE_AINFO] = 0x15, [HDCP_MESSAGE_ID_WRITE_AN] = 0x18, [HDCP_MESSAGE_ID_READ_VH_X] = 0x20, [HDCP_MESSAGE_ID_READ_VH_0] = 0x20, [HDCP_MESSAGE_ID_READ_VH_1] = 0x24, [HDCP_MESSAGE_ID_READ_VH_2] = 0x28, [HDCP_MESSAGE_ID_READ_VH_3] = 0x2C, [HDCP_MESSAGE_ID_READ_VH_4] = 0x30, [HDCP_MESSAGE_ID_READ_BCAPS] = 0x40, [HDCP_MESSAGE_ID_READ_BSTATUS] = 0x41, [HDCP_MESSAGE_ID_READ_KSV_FIFO] = 0x43, [HDCP_MESSAGE_ID_READ_BINFO] = 0xFF, [HDCP_MESSAGE_ID_HDCP2VERSION] = 0x50, [HDCP_MESSAGE_ID_WRITE_AKE_INIT] = 0x60, [HDCP_MESSAGE_ID_READ_AKE_SEND_CERT] = 0x80, [HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM] = 0x60, [HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM] = 0x60, [HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME] = 0x80, [HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO] = 0x80, [HDCP_MESSAGE_ID_WRITE_LC_INIT] = 0x60, [HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME] = 0x80, [HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS] = 0x60, [HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST] = 0x80, [HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK] = 0x60, [HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE] = 0x60, [HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY] = 0x80, [HDCP_MESSAGE_ID_READ_RXSTATUS] = 0x70, [HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE] = 0x0, }; struct protection_properties { bool supported; bool (*process_transaction)( struct dc_link *link, struct hdcp_protection_message *message_info); }; static const struct protection_properties non_supported_protection = { .supported = false }; static bool hdmi_14_process_transaction( struct dc_link *link, struct hdcp_protection_message *message_info) { uint8_t *buff = NULL; bool result; const uint8_t hdcp_i2c_addr_link_primary = 0x3a; /* 0x74 >> 1*/ const uint8_t hdcp_i2c_addr_link_secondary = 0x3b; /* 0x76 >> 1*/ struct i2c_command i2c_command; uint8_t offset; struct i2c_payload i2c_payloads[] = { { true, 0, 1, 0 }, /* actual hdcp payload, will be filled later, zeroed for now*/ { 0 } }; if (message_info->msg_id == HDCP_MESSAGE_ID_INVALID) { DC_LOG_ERROR("%s: Invalid message_info msg_id - %d\n", __func__, message_info->msg_id); return false; } offset = hdcp_i2c_offsets[message_info->msg_id]; i2c_payloads[0].data = &offset; switch (message_info->link) { case HDCP_LINK_SECONDARY: i2c_payloads[0].address = hdcp_i2c_addr_link_secondary; i2c_payloads[1].address = hdcp_i2c_addr_link_secondary; break; case HDCP_LINK_PRIMARY: default: i2c_payloads[0].address = hdcp_i2c_addr_link_primary; i2c_payloads[1].address = hdcp_i2c_addr_link_primary; break; } if (hdcp_cmd_is_read[message_info->msg_id]) { i2c_payloads[1].write = false; i2c_command.number_of_payloads = ARRAY_SIZE(i2c_payloads); i2c_payloads[1].length = message_info->length; i2c_payloads[1].data = message_info->data; } else { i2c_command.number_of_payloads = 1; buff = kzalloc(message_info->length + 1, GFP_KERNEL); if (!buff) return false; buff[0] = offset; memmove(&buff[1], message_info->data, message_info->length); i2c_payloads[0].length = message_info->length + 1; i2c_payloads[0].data = buff; } i2c_command.payloads = i2c_payloads; i2c_command.engine = I2C_COMMAND_ENGINE_HW;//only HW i2c_command.speed = link->ddc->ctx->dc->caps.i2c_speed_in_khz; result = dm_helpers_submit_i2c( link->ctx, link, &i2c_command); kfree(buff); return result; } static const struct protection_properties hdmi_14_protection = { .supported = true, .process_transaction = hdmi_14_process_transaction }; static const uint32_t hdcp_dpcd_addrs[HDCP_MESSAGE_ID_MAX] = { [HDCP_MESSAGE_ID_READ_BKSV] = 0x68000, [HDCP_MESSAGE_ID_READ_RI_R0] = 0x68005, [HDCP_MESSAGE_ID_READ_PJ] = 0xFFFFFFFF, [HDCP_MESSAGE_ID_WRITE_AKSV] = 0x68007, [HDCP_MESSAGE_ID_WRITE_AINFO] = 0x6803B, [HDCP_MESSAGE_ID_WRITE_AN] = 0x6800c, [HDCP_MESSAGE_ID_READ_VH_X] = 0x68014, [HDCP_MESSAGE_ID_READ_VH_0] = 0x68014, [HDCP_MESSAGE_ID_READ_VH_1] = 0x68018, [HDCP_MESSAGE_ID_READ_VH_2] = 0x6801c, [HDCP_MESSAGE_ID_READ_VH_3] = 0x68020, [HDCP_MESSAGE_ID_READ_VH_4] = 0x68024, [HDCP_MESSAGE_ID_READ_BCAPS] = 0x68028, [HDCP_MESSAGE_ID_READ_BSTATUS] = 0x68029, [HDCP_MESSAGE_ID_READ_KSV_FIFO] = 0x6802c, [HDCP_MESSAGE_ID_READ_BINFO] = 0x6802a, [HDCP_MESSAGE_ID_RX_CAPS] = 0x6921d, [HDCP_MESSAGE_ID_WRITE_AKE_INIT] = 0x69000, [HDCP_MESSAGE_ID_READ_AKE_SEND_CERT] = 0x6900b, [HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM] = 0x69220, [HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM] = 0x692a0, [HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME] = 0x692c0, [HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO] = 0x692e0, [HDCP_MESSAGE_ID_WRITE_LC_INIT] = 0x692f0, [HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME] = 0x692f8, [HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS] = 0x69318, [HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST] = 0x69330, [HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK] = 0x693e0, [HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE] = 0x693f0, [HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY] = 0x69473, [HDCP_MESSAGE_ID_READ_RXSTATUS] = 0x69493, [HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE] = 0x69494 }; static bool dpcd_access_helper( struct dc_link *link, uint32_t length, uint8_t *data, uint32_t dpcd_addr, bool is_read) { enum dc_status status; uint32_t cur_length = 0; uint32_t offset = 0; uint32_t ksv_read_size = 0x6803b - 0x6802c; /* Read KSV, need repeatedly handle */ if (dpcd_addr == 0x6802c) { if (length % HDCP14_KSV_SIZE) { DC_LOG_ERROR("%s: KsvFifo Size(%d) is not a multiple of HDCP14_KSV_SIZE(%d)\n", __func__, length, HDCP14_KSV_SIZE); } if (length > HDCP14_MAX_KSV_FIFO_SIZE) { DC_LOG_ERROR("%s: KsvFifo Size(%d) is greater than HDCP14_MAX_KSV_FIFO_SIZE(%d)\n", __func__, length, HDCP14_MAX_KSV_FIFO_SIZE); } DC_LOG_ERROR("%s: Reading %d Ksv(s) from KsvFifo\n", __func__, length / HDCP14_KSV_SIZE); while (length > 0) { if (length > ksv_read_size) { status = core_link_read_dpcd( link, dpcd_addr + offset, data + offset, ksv_read_size); data += ksv_read_size; length -= ksv_read_size; } else { status = core_link_read_dpcd( link, dpcd_addr + offset, data + offset, length); data += length; length = 0; } if (status != DC_OK) return false; } } else { while (length > 0) { if (length > DEFAULT_AUX_MAX_DATA_SIZE) cur_length = DEFAULT_AUX_MAX_DATA_SIZE; else cur_length = length; if (is_read) { status = core_link_read_dpcd( link, dpcd_addr + offset, data + offset, cur_length); } else { status = core_link_write_dpcd( link, dpcd_addr + offset, data + offset, cur_length); } if (status != DC_OK) return false; length -= cur_length; offset += cur_length; } } return true; } static bool dp_11_process_transaction( struct dc_link *link, struct hdcp_protection_message *message_info) { if (message_info->msg_id == HDCP_MESSAGE_ID_INVALID) { DC_LOG_ERROR("%s: Invalid message_info msg_id - %d\n", __func__, message_info->msg_id); return false; } return dpcd_access_helper( link, message_info->length, message_info->data, hdcp_dpcd_addrs[message_info->msg_id], hdcp_cmd_is_read[message_info->msg_id]); } static const struct protection_properties dp_11_protection = { .supported = true, .process_transaction = dp_11_process_transaction }; static const struct protection_properties *get_protection_properties_by_signal( struct dc_link *link, enum amd_signal_type st, enum hdcp_version version) { switch (version) { case HDCP_VERSION_14: switch (st) { case SIGNAL_TYPE_DVI_SINGLE_LINK: case SIGNAL_TYPE_DVI_DUAL_LINK: case SIGNAL_TYPE_HDMI_TYPE_A: return &hdmi_14_protection; case SIGNAL_TYPE_DISPLAY_PORT: if (link && (link->dpcd_caps.dongle_type == DISPLAY_DONGLE_DP_VGA_CONVERTER || link->dpcd_caps.dongle_caps.dongle_type == DISPLAY_DONGLE_DP_VGA_CONVERTER)) { return &non_supported_protection; } return &dp_11_protection; case SIGNAL_TYPE_DISPLAY_PORT_MST: case SIGNAL_TYPE_EDP: return &dp_11_protection; default: return &non_supported_protection; } break; case HDCP_VERSION_22: switch (st) { case SIGNAL_TYPE_DVI_SINGLE_LINK: case SIGNAL_TYPE_DVI_DUAL_LINK: case SIGNAL_TYPE_HDMI_TYPE_A: return &hdmi_14_protection; //todo version2.2 case SIGNAL_TYPE_DISPLAY_PORT: case SIGNAL_TYPE_DISPLAY_PORT_MST: case SIGNAL_TYPE_EDP: return &dp_11_protection; //todo version2.2 default: return &non_supported_protection; } break; default: return &non_supported_protection; } } enum hdcp_message_status dc_process_hdcp_msg( enum amd_signal_type signal, struct dc_link *link, struct hdcp_protection_message *message_info) { enum hdcp_message_status status = HDCP_MESSAGE_FAILURE; uint32_t i = 0; const struct protection_properties *protection_props; if (!message_info) return HDCP_MESSAGE_UNSUPPORTED; if (message_info->msg_id < HDCP_MESSAGE_ID_READ_BKSV || message_info->msg_id >= HDCP_MESSAGE_ID_MAX) return HDCP_MESSAGE_UNSUPPORTED; protection_props = get_protection_properties_by_signal( link, signal, message_info->version); if (!protection_props->supported) return HDCP_MESSAGE_UNSUPPORTED; if (protection_props->process_transaction( link, message_info)) { status = HDCP_MESSAGE_SUCCESS; } else { for (i = 0; i < message_info->max_retries; i++) { if (protection_props->process_transaction( link, message_info)) { status = HDCP_MESSAGE_SUCCESS; break; } } } return status; }