| /* |
| * Copyright (c) 2016-2017, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| */ |
| |
| #define pr_fmt(fmt) "[drm-dp] %s: " fmt, __func__ |
| |
| #include <linux/of_platform.h> |
| #include <linux/msm_ext_display.h> |
| |
| #include <drm/drm_dp_helper.h> |
| |
| #include "dp_catalog.h" |
| #include "dp_audio.h" |
| #include "dp_panel.h" |
| |
| #define HEADER_BYTE_2_BIT 0 |
| #define PARITY_BYTE_2_BIT 8 |
| #define HEADER_BYTE_1_BIT 16 |
| #define PARITY_BYTE_1_BIT 24 |
| #define HEADER_BYTE_3_BIT 16 |
| #define PARITY_BYTE_3_BIT 24 |
| |
| struct dp_audio_private { |
| struct platform_device *ext_pdev; |
| struct platform_device *pdev; |
| struct dp_catalog_audio *catalog; |
| struct msm_ext_disp_init_data ext_audio_data; |
| struct dp_panel *panel; |
| |
| bool ack_enabled; |
| bool session_on; |
| bool engine_on; |
| |
| u32 channels; |
| |
| struct completion hpd_comp; |
| |
| struct dp_audio dp_audio; |
| }; |
| |
| static u8 dp_audio_get_g0_value(u8 data) |
| { |
| u8 c[4]; |
| u8 g[4]; |
| u8 ret_data = 0; |
| u8 i; |
| |
| for (i = 0; i < 4; i++) |
| c[i] = (data >> i) & 0x01; |
| |
| g[0] = c[3]; |
| g[1] = c[0] ^ c[3]; |
| g[2] = c[1]; |
| g[3] = c[2]; |
| |
| for (i = 0; i < 4; i++) |
| ret_data = ((g[i] & 0x01) << i) | ret_data; |
| |
| return ret_data; |
| } |
| |
| static u8 dp_audio_get_g1_value(u8 data) |
| { |
| u8 c[4]; |
| u8 g[4]; |
| u8 ret_data = 0; |
| u8 i; |
| |
| for (i = 0; i < 4; i++) |
| c[i] = (data >> i) & 0x01; |
| |
| g[0] = c[0] ^ c[3]; |
| g[1] = c[0] ^ c[1] ^ c[3]; |
| g[2] = c[1] ^ c[2]; |
| g[3] = c[2] ^ c[3]; |
| |
| for (i = 0; i < 4; i++) |
| ret_data = ((g[i] & 0x01) << i) | ret_data; |
| |
| return ret_data; |
| } |
| |
| static u8 dp_audio_calculate_parity(u32 data) |
| { |
| u8 x0 = 0; |
| u8 x1 = 0; |
| u8 ci = 0; |
| u8 iData = 0; |
| u8 i = 0; |
| u8 parity_byte; |
| u8 num_byte = (data & 0xFF00) > 0 ? 8 : 2; |
| |
| for (i = 0; i < num_byte; i++) { |
| iData = (data >> i*4) & 0xF; |
| |
| ci = iData ^ x1; |
| x1 = x0 ^ dp_audio_get_g1_value(ci); |
| x0 = dp_audio_get_g0_value(ci); |
| } |
| |
| parity_byte = x1 | (x0 << 4); |
| |
| return parity_byte; |
| } |
| |
| static u32 dp_audio_get_header(struct dp_catalog_audio *catalog, |
| enum dp_catalog_audio_sdp_type sdp, |
| enum dp_catalog_audio_header_type header) |
| { |
| catalog->sdp_type = sdp; |
| catalog->sdp_header = header; |
| catalog->get_header(catalog); |
| |
| return catalog->data; |
| } |
| |
| static void dp_audio_set_header(struct dp_catalog_audio *catalog, |
| u32 data, |
| enum dp_catalog_audio_sdp_type sdp, |
| enum dp_catalog_audio_header_type header) |
| { |
| catalog->sdp_type = sdp; |
| catalog->sdp_header = header; |
| catalog->data = data; |
| catalog->set_header(catalog); |
| } |
| |
| static void dp_audio_stream_sdp(struct dp_audio_private *audio) |
| { |
| struct dp_catalog_audio *catalog = audio->catalog; |
| u32 value, new_value; |
| u8 parity_byte; |
| |
| /* Config header and parity byte 1 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_1); |
| |
| new_value = 0x02; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_1_BIT) |
| | (parity_byte << PARITY_BYTE_1_BIT)); |
| pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_1); |
| |
| /* Config header and parity byte 2 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_2); |
| new_value = value; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_2_BIT) |
| | (parity_byte << PARITY_BYTE_2_BIT)); |
| pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_2); |
| |
| /* Config header and parity byte 3 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_3); |
| |
| new_value = audio->channels - 1; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_3_BIT) |
| | (parity_byte << PARITY_BYTE_3_BIT)); |
| pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_3); |
| } |
| |
| static void dp_audio_timestamp_sdp(struct dp_audio_private *audio) |
| { |
| struct dp_catalog_audio *catalog = audio->catalog; |
| u32 value, new_value; |
| u8 parity_byte; |
| |
| /* Config header and parity byte 1 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_1); |
| |
| new_value = 0x1; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_1_BIT) |
| | (parity_byte << PARITY_BYTE_1_BIT)); |
| pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_1); |
| |
| /* Config header and parity byte 2 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_2); |
| |
| new_value = 0x17; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_2_BIT) |
| | (parity_byte << PARITY_BYTE_2_BIT)); |
| pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_2); |
| |
| /* Config header and parity byte 3 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_3); |
| |
| new_value = (0x0 | (0x11 << 2)); |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_3_BIT) |
| | (parity_byte << PARITY_BYTE_3_BIT)); |
| pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_3); |
| } |
| |
| static void dp_audio_infoframe_sdp(struct dp_audio_private *audio) |
| { |
| struct dp_catalog_audio *catalog = audio->catalog; |
| u32 value, new_value; |
| u8 parity_byte; |
| |
| /* Config header and parity byte 1 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_1); |
| |
| new_value = 0x84; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_1_BIT) |
| | (parity_byte << PARITY_BYTE_1_BIT)); |
| pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_1); |
| |
| /* Config header and parity byte 2 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_2); |
| |
| new_value = 0x1b; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_2_BIT) |
| | (parity_byte << PARITY_BYTE_2_BIT)); |
| pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_2); |
| |
| /* Config header and parity byte 3 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_3); |
| |
| new_value = (0x0 | (0x11 << 2)); |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_3_BIT) |
| | (parity_byte << PARITY_BYTE_3_BIT)); |
| pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", |
| new_value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_3); |
| } |
| |
| static void dp_audio_copy_management_sdp(struct dp_audio_private *audio) |
| { |
| struct dp_catalog_audio *catalog = audio->catalog; |
| u32 value, new_value; |
| u8 parity_byte; |
| |
| /* Config header and parity byte 1 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_1); |
| |
| new_value = 0x05; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_1_BIT) |
| | (parity_byte << PARITY_BYTE_1_BIT)); |
| pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_1); |
| |
| /* Config header and parity byte 2 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_2); |
| |
| new_value = 0x0F; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_2_BIT) |
| | (parity_byte << PARITY_BYTE_2_BIT)); |
| pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_2); |
| |
| /* Config header and parity byte 3 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_3); |
| |
| new_value = 0x0; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_3_BIT) |
| | (parity_byte << PARITY_BYTE_3_BIT)); |
| pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_3); |
| } |
| |
| static void dp_audio_isrc_sdp(struct dp_audio_private *audio) |
| { |
| struct dp_catalog_audio *catalog = audio->catalog; |
| u32 value, new_value; |
| u8 parity_byte; |
| |
| /* Config header and parity byte 1 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_1); |
| |
| new_value = 0x06; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_1_BIT) |
| | (parity_byte << PARITY_BYTE_1_BIT)); |
| pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_1); |
| |
| /* Config header and parity byte 2 */ |
| value = dp_audio_get_header(catalog, |
| DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_2); |
| |
| new_value = 0x0F; |
| parity_byte = dp_audio_calculate_parity(new_value); |
| value |= ((new_value << HEADER_BYTE_2_BIT) |
| | (parity_byte << PARITY_BYTE_2_BIT)); |
| pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", |
| value, parity_byte); |
| dp_audio_set_header(catalog, value, |
| DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_2); |
| } |
| |
| static void dp_audio_setup_sdp(struct dp_audio_private *audio) |
| { |
| audio->catalog->config_sdp(audio->catalog); |
| |
| dp_audio_stream_sdp(audio); |
| dp_audio_timestamp_sdp(audio); |
| dp_audio_infoframe_sdp(audio); |
| dp_audio_copy_management_sdp(audio); |
| dp_audio_isrc_sdp(audio); |
| } |
| |
| static void dp_audio_setup_acr(struct dp_audio_private *audio) |
| { |
| u32 select = 0; |
| struct dp_catalog_audio *catalog = audio->catalog; |
| |
| switch (audio->dp_audio.bw_code) { |
| case DP_LINK_BW_1_62: |
| select = 0; |
| break; |
| case DP_LINK_BW_2_7: |
| select = 1; |
| break; |
| case DP_LINK_BW_5_4: |
| select = 2; |
| break; |
| case DP_LINK_BW_8_1: |
| select = 3; |
| break; |
| default: |
| pr_debug("Unknown link rate\n"); |
| select = 0; |
| break; |
| } |
| |
| catalog->data = select; |
| catalog->config_acr(catalog); |
| } |
| |
| static void dp_audio_safe_to_exit_level(struct dp_audio_private *audio) |
| { |
| struct dp_catalog_audio *catalog = audio->catalog; |
| u32 safe_to_exit_level = 0; |
| |
| switch (audio->dp_audio.lane_count) { |
| case 1: |
| safe_to_exit_level = 14; |
| break; |
| case 2: |
| safe_to_exit_level = 8; |
| break; |
| case 4: |
| safe_to_exit_level = 5; |
| break; |
| default: |
| pr_debug("setting the default safe_to_exit_level = %u\n", |
| safe_to_exit_level); |
| safe_to_exit_level = 14; |
| break; |
| } |
| |
| catalog->data = safe_to_exit_level; |
| catalog->safe_to_exit_level(catalog); |
| } |
| |
| static void dp_audio_enable(struct dp_audio_private *audio, bool enable) |
| { |
| struct dp_catalog_audio *catalog = audio->catalog; |
| |
| catalog->data = enable; |
| catalog->enable(catalog); |
| |
| audio->engine_on = enable; |
| } |
| |
| static struct dp_audio_private *dp_audio_get_data(struct platform_device *pdev) |
| { |
| struct msm_ext_disp_data *ext_data; |
| struct dp_audio *dp_audio; |
| |
| if (!pdev) { |
| pr_err("invalid input\n"); |
| return ERR_PTR(-ENODEV); |
| } |
| |
| ext_data = platform_get_drvdata(pdev); |
| if (!ext_data) { |
| pr_err("invalid ext disp data\n"); |
| return ERR_PTR(-EINVAL); |
| } |
| |
| dp_audio = ext_data->intf_data; |
| if (!ext_data) { |
| pr_err("invalid intf data\n"); |
| return ERR_PTR(-EINVAL); |
| } |
| |
| return container_of(dp_audio, struct dp_audio_private, dp_audio); |
| } |
| |
| static int dp_audio_info_setup(struct platform_device *pdev, |
| struct msm_ext_disp_audio_setup_params *params) |
| { |
| int rc = 0; |
| struct dp_audio_private *audio; |
| |
| audio = dp_audio_get_data(pdev); |
| if (IS_ERR(audio)) { |
| rc = PTR_ERR(audio); |
| goto end; |
| } |
| |
| audio->channels = params->num_of_channels; |
| |
| dp_audio_setup_sdp(audio); |
| dp_audio_setup_acr(audio); |
| dp_audio_safe_to_exit_level(audio); |
| dp_audio_enable(audio, true); |
| end: |
| return rc; |
| } |
| |
| static int dp_audio_get_edid_blk(struct platform_device *pdev, |
| struct msm_ext_disp_audio_edid_blk *blk) |
| { |
| int rc = 0; |
| struct dp_audio_private *audio; |
| struct sde_edid_ctrl *edid; |
| |
| audio = dp_audio_get_data(pdev); |
| if (IS_ERR(audio)) { |
| rc = PTR_ERR(audio); |
| goto end; |
| } |
| |
| if (!audio->panel || !audio->panel->edid_ctrl) { |
| pr_err("invalid panel data\n"); |
| rc = -EINVAL; |
| goto end; |
| } |
| |
| edid = audio->panel->edid_ctrl; |
| |
| blk->audio_data_blk = edid->audio_data_block; |
| blk->audio_data_blk_size = edid->adb_size; |
| |
| blk->spk_alloc_data_blk = edid->spkr_alloc_data_block; |
| blk->spk_alloc_data_blk_size = edid->sadb_size; |
| end: |
| return rc; |
| } |
| |
| static int dp_audio_get_cable_status(struct platform_device *pdev, u32 vote) |
| { |
| int rc = 0; |
| struct dp_audio_private *audio; |
| |
| audio = dp_audio_get_data(pdev); |
| if (IS_ERR(audio)) { |
| rc = PTR_ERR(audio); |
| goto end; |
| } |
| |
| return audio->session_on; |
| end: |
| return rc; |
| } |
| |
| static int dp_audio_get_intf_id(struct platform_device *pdev) |
| { |
| int rc = 0; |
| struct dp_audio_private *audio; |
| |
| audio = dp_audio_get_data(pdev); |
| if (IS_ERR(audio)) { |
| rc = PTR_ERR(audio); |
| goto end; |
| } |
| |
| return EXT_DISPLAY_TYPE_DP; |
| end: |
| return rc; |
| } |
| |
| static void dp_audio_teardown_done(struct platform_device *pdev) |
| { |
| struct dp_audio_private *audio; |
| |
| audio = dp_audio_get_data(pdev); |
| if (IS_ERR(audio)) |
| return; |
| |
| dp_audio_enable(audio, false); |
| |
| complete_all(&audio->hpd_comp); |
| |
| pr_debug("audio engine disabled\n"); |
| } |
| |
| static int dp_audio_ack_done(struct platform_device *pdev, u32 ack) |
| { |
| int rc = 0, ack_hpd; |
| struct dp_audio_private *audio; |
| |
| audio = dp_audio_get_data(pdev); |
| if (IS_ERR(audio)) { |
| rc = PTR_ERR(audio); |
| goto end; |
| } |
| |
| if (ack & AUDIO_ACK_SET_ENABLE) { |
| audio->ack_enabled = ack & AUDIO_ACK_ENABLE ? |
| true : false; |
| |
| pr_debug("audio ack feature %s\n", |
| audio->ack_enabled ? "enabled" : "disabled"); |
| goto end; |
| } |
| |
| if (!audio->ack_enabled) |
| goto end; |
| |
| ack_hpd = ack & AUDIO_ACK_CONNECT; |
| |
| pr_debug("acknowledging audio (%d)\n", ack_hpd); |
| |
| if (!audio->engine_on) |
| complete_all(&audio->hpd_comp); |
| end: |
| return rc; |
| } |
| |
| static int dp_audio_init_ext_disp(struct dp_audio_private *audio) |
| { |
| int rc = 0; |
| struct device_node *pd = NULL; |
| const char *phandle = "qcom,ext-disp"; |
| struct msm_ext_disp_init_data *ext; |
| struct msm_ext_disp_audio_codec_ops *ops; |
| |
| ext = &audio->ext_audio_data; |
| ops = &ext->codec_ops; |
| |
| ext->type = EXT_DISPLAY_TYPE_DP; |
| ext->pdev = audio->pdev; |
| ext->intf_data = &audio->dp_audio; |
| |
| ops->audio_info_setup = dp_audio_info_setup; |
| ops->get_audio_edid_blk = dp_audio_get_edid_blk; |
| ops->cable_status = dp_audio_get_cable_status; |
| ops->get_intf_id = dp_audio_get_intf_id; |
| ops->teardown_done = dp_audio_teardown_done; |
| ops->acknowledge = dp_audio_ack_done; |
| |
| if (!audio->pdev->dev.of_node) { |
| pr_err("cannot find audio dev.of_node\n"); |
| rc = -ENODEV; |
| goto end; |
| } |
| |
| pd = of_parse_phandle(audio->pdev->dev.of_node, phandle, 0); |
| if (!pd) { |
| pr_err("cannot parse %s handle\n", phandle); |
| rc = -ENODEV; |
| goto end; |
| } |
| |
| audio->ext_pdev = of_find_device_by_node(pd); |
| if (!audio->ext_pdev) { |
| pr_err("cannot find %s pdev\n", phandle); |
| rc = -ENODEV; |
| goto end; |
| } |
| |
| rc = msm_ext_disp_register_intf(audio->ext_pdev, ext); |
| if (rc) |
| pr_err("failed to register disp\n"); |
| end: |
| if (pd) |
| of_node_put(pd); |
| |
| return rc; |
| } |
| |
| static int dp_audio_on(struct dp_audio *dp_audio) |
| { |
| int rc = 0; |
| struct dp_audio_private *audio; |
| struct msm_ext_disp_init_data *ext; |
| |
| if (!dp_audio) { |
| pr_err("invalid input\n"); |
| rc = -EINVAL; |
| goto end; |
| } |
| |
| audio = container_of(dp_audio, struct dp_audio_private, dp_audio); |
| |
| ext = &audio->ext_audio_data; |
| |
| audio->session_on = true; |
| |
| rc = ext->intf_ops.audio_config(audio->ext_pdev, |
| EXT_DISPLAY_TYPE_DP, |
| EXT_DISPLAY_CABLE_CONNECT); |
| if (rc) { |
| pr_err("failed to config audio, err=%d\n", rc); |
| goto end; |
| } |
| |
| rc = ext->intf_ops.audio_notify(audio->ext_pdev, |
| EXT_DISPLAY_TYPE_DP, |
| EXT_DISPLAY_CABLE_CONNECT); |
| if (rc) { |
| pr_err("failed to notify audio, err=%d\n", rc); |
| goto end; |
| } |
| |
| reinit_completion(&audio->hpd_comp); |
| rc = wait_for_completion_timeout(&audio->hpd_comp, HZ * 5); |
| if (!rc) { |
| pr_err("timeout\n"); |
| rc = -ETIMEDOUT; |
| goto end; |
| } |
| |
| pr_debug("success\n"); |
| end: |
| return rc; |
| } |
| |
| static int dp_audio_off(struct dp_audio *dp_audio) |
| { |
| int rc = 0; |
| struct dp_audio_private *audio; |
| struct msm_ext_disp_init_data *ext; |
| |
| if (!dp_audio) { |
| pr_err("invalid input\n"); |
| return -EINVAL; |
| } |
| |
| audio = container_of(dp_audio, struct dp_audio_private, dp_audio); |
| ext = &audio->ext_audio_data; |
| |
| rc = ext->intf_ops.audio_notify(audio->ext_pdev, |
| EXT_DISPLAY_TYPE_DP, |
| EXT_DISPLAY_CABLE_DISCONNECT); |
| if (rc) { |
| pr_err("failed to notify audio, err=%d\n", rc); |
| goto end; |
| } |
| |
| reinit_completion(&audio->hpd_comp); |
| rc = wait_for_completion_timeout(&audio->hpd_comp, HZ * 5); |
| if (!rc) { |
| pr_err("timeout\n"); |
| rc = -ETIMEDOUT; |
| goto end; |
| } |
| |
| pr_debug("success\n"); |
| end: |
| rc = ext->intf_ops.audio_config(audio->ext_pdev, |
| EXT_DISPLAY_TYPE_DP, |
| EXT_DISPLAY_CABLE_DISCONNECT); |
| if (rc) |
| pr_err("failed to config audio, err=%d\n", rc); |
| |
| audio->session_on = false; |
| audio->engine_on = false; |
| |
| return rc; |
| } |
| |
| struct dp_audio *dp_audio_get(struct platform_device *pdev, |
| struct dp_panel *panel, |
| struct dp_catalog_audio *catalog) |
| { |
| int rc = 0; |
| struct dp_audio_private *audio; |
| struct dp_audio *dp_audio; |
| |
| if (!pdev || !panel || !catalog) { |
| pr_err("invalid input\n"); |
| rc = -EINVAL; |
| goto error; |
| } |
| |
| audio = devm_kzalloc(&pdev->dev, sizeof(*audio), GFP_KERNEL); |
| if (!audio) { |
| rc = -ENOMEM; |
| goto error; |
| } |
| |
| init_completion(&audio->hpd_comp); |
| |
| audio->pdev = pdev; |
| audio->panel = panel; |
| audio->catalog = catalog; |
| |
| dp_audio = &audio->dp_audio; |
| |
| dp_audio->on = dp_audio_on; |
| dp_audio->off = dp_audio_off; |
| |
| rc = dp_audio_init_ext_disp(audio); |
| if (rc) { |
| devm_kfree(&pdev->dev, audio); |
| goto error; |
| } |
| |
| catalog->init(catalog); |
| |
| return dp_audio; |
| error: |
| return ERR_PTR(rc); |
| } |
| |
| void dp_audio_put(struct dp_audio *dp_audio) |
| { |
| struct dp_audio_private *audio; |
| |
| if (!dp_audio) |
| return; |
| |
| audio = container_of(dp_audio, struct dp_audio_private, dp_audio); |
| |
| devm_kfree(&audio->pdev->dev, audio); |
| } |