Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a6ff39b5 authored by Linux Build Service Account's avatar Linux Build Service Account Committed by Gerrit - the friendly Code Review server
Browse files

Merge "ARM: dts: msm: add msm-ext-display module for sdm845"

parents 00edb839 b9c35033

Documentation/devicetree/bindings/drm/msm/sde-dp.txt

+22 −0
Original line number Diff line number Diff line
@@ -88,7 +88,28 @@ DP Controller: Required properties: 
					controller. These pin configurations are installed in the pinctrl

					device node. Refer to pinctrl-bindings.txt



msm_ext_disp is a device which manages the interaction between external

display interfaces, e.g. Display Port, and the audio subsystem.



Optional properties:

- qcom,ext-disp:		phandle for msm-ext-display module

- compatible:			Must be "qcom,msm-ext-disp"



[Optional child nodes]: These nodes are for devices which are

dependent on msm_ext_disp. If msm_ext_disp is disabled then

these devices will be disabled as well. Ex. Audio Codec device.



- ext_disp_audio_codec: Node for Audio Codec.

- compatible : "qcom,msm-ext-disp-audio-codec-rx";



Example:

	ext_disp: qcom,msm-ext-disp {

		compatible = "qcom,msm-ext-disp";

		ext_disp_audio_codec: qcom,msm-ext-disp-audio-codec-rx {

			compatible = "qcom,msm-ext-disp-audio-codec-rx";

		};

	};



	sde_dp: qcom,dp_display@0{

		cell-index = <0>;

		compatible = "qcom,dp-display";
@@ -131,6 +152,7 @@ Example: 
			"ctrl_pixel_clk", "pixel_clk_rcg", "pixel_parent";



		qcom,dp-usbpd-detection = <&pmi8998_pdphy>;

		qcom,ext-disp = <&ext_disp>;



		qcom,aux-cfg0-settings = [1c 00];

		qcom,aux-cfg1-settings = [20 13 23 1d];

arch/arm64/boot/dts/qcom/sdm845-sde-display.dtsi

+9 −0
Original line number Diff line number Diff line
@@ -369,6 +369,14 @@ 
		label = "wb_display";

	};



	ext_disp: qcom,msm-ext-disp {

		compatible = "qcom,msm-ext-disp";



		ext_disp_audio_codec: qcom,msm-ext-disp-audio-codec-rx {

			compatible = "qcom,msm-ext-disp-audio-codec-rx";

		};

	};



	sde_dp: qcom,dp_display@0{

		cell-index = <0>;

		compatible = "qcom,dp-display";
@@ -410,6 +418,7 @@ 
			"crypto_clk", "pixel_clk_rcg", "pixel_parent";



		qcom,dp-usbpd-detection = <&pmi8998_pdphy>;

		qcom,ext-disp = <&ext_disp>;



		qcom,aux-cfg0-settings = [20 00];

		qcom,aux-cfg1-settings = [24 13 23 1d];

drivers/gpu/drm/msm/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ config DRM_MSM 
	select SND_SOC_HDMI_CODEC if SND_SOC

	select SYNC_FILE

	select HDCP_QSEECOM

	select MSM_EXT_DISPLAY

	default y

	help

	  DRM/KMS driver for MSM/snapdragon.

drivers/gpu/drm/msm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ msm_drm-y := \ 
	dp/dp_panel.o \

	dp/dp_link.o \

	dp/dp_ctrl.o \

	dp/dp_audio.o \

	dp/dp_display.o \

	dp/dp_drm.o \

	dp/dp_hdcp2p2.o \

drivers/gpu/drm/msm/dp/dp_audio.c

0 → 100644
+794 −0
Original line number Diff line number Diff line 
/*

 * 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_RATE_810:

		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 *get_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 = get_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 = get_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 = get_audio_get_data(pdev);

	if (IS_ERR(audio)) {

		rc = PTR_ERR(audio);

		goto end;

	}



	if (!audio->panel) {

		pr_err("invalid panel data\n");

		rc = -EINVAL;

		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 = get_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 = get_audio_get_data(pdev);

	if (IS_ERR(audio))

		return;



	if (!audio->panel) {

		pr_err("invalid panel data\n");

		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 = get_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)

		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);



	kzfree(audio);

}