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

Commit b497f11b authored by Banajit Goswami's avatar Banajit Goswami
Browse files

ASoC: wcd: remove unused audio external clock driver 



ext-audio-clk driver is not used anymore on newer MSM
targets. Remove this unused driver.

Change-Id: I35aab0a4d85fc762c30ad619f621d2de805398d6
Signed-off-by: default avatarBanajit Goswami <bgoswami@codeaurora.org>
parent 28cc8018

Documentation/devicetree/bindings/sound/qcom-audio-dev.txt

+1 −1
Original line number Diff line number Diff line
@@ -329,7 +329,7 @@ Required properties: 
 - qcom,gpio-connect                       Gpio that connects to parent

                                           interrupt controller



* audio-ext-clk

* audio-ext-clk-up



Required properties:

sound/soc/codecs/Makefile

+1 −8
Original line number Diff line number Diff line
@@ -162,14 +162,7 @@ snd-soc-wcd9335-objs := wcd9335.o 
snd-soc-wcd934x-objs := wcd934x.o

snd-soc-wcd9xxx-objs := wcd9xxx-common-v2.o wcd9xxx-resmgr-v2.o \

			wcdcal-hwdep.o wcd-dsp-mgr.o wcd-dsp-utils.o \

			wcd9xxx-soc-init.o

ifeq ($(CONFIG_COMMON_CLK_MSM), y)

	snd-soc-wcd9xxx-objs += audio-ext-clk.o

endif



ifeq ($(CONFIG_COMMON_CLK_QCOM), y)

	snd-soc-wcd9xxx-objs += audio-ext-clk-up.o

endif

			wcd9xxx-soc-init.o audio-ext-clk-up.o

snd-soc-wcd-cpe-objs := wcd_cpe_services.o wcd_cpe_core.o

snd-soc-wsa881x-objs := wsa881x.o wsa881x-tables.o wsa881x-regmap.o wsa881x-temp-sensor.o

ifneq (,$(filter $(CONFIG_SND_SOC_WCD_MBHC_LEGACY),y m))

sound/soc/codecs/audio-ext-clk.c

deleted100644 → 0
+0 −348
Original line number Diff line number Diff line 
/* Copyright (c) 2015-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.

 */



#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/clk.h>

#include <linux/clk/msm-clk-provider.h>

#include <linux/clk/msm-clk.h>

#include <linux/platform_device.h>

#include <linux/gpio.h>

#include <linux/of_gpio.h>

#include <dt-bindings/clock/audio-ext-clk.h>

#include <sound/q6afe-v2.h>

#include "audio-ext-clk-up.h"



struct pinctrl_info {

	struct pinctrl *pinctrl;

	struct pinctrl_state *sleep;

	struct pinctrl_state *active;

};



struct audio_ext_ap_clk {

	bool enabled;

	int gpio;

	struct clk c;

};



struct audio_ext_pmi_clk {

	int gpio;

	struct clk c;

};



struct audio_ext_ap_clk2 {

	bool enabled;

	struct pinctrl_info pnctrl_info;

	struct clk c;

};



static struct afe_clk_set clk2_config = {

	Q6AFE_LPASS_CLK_CONFIG_API_VERSION,

	Q6AFE_LPASS_CLK_ID_SPEAKER_I2S_OSR,

	Q6AFE_LPASS_IBIT_CLK_11_P2896_MHZ,

	Q6AFE_LPASS_CLK_ATTRIBUTE_COUPLE_NO,

	Q6AFE_LPASS_CLK_ROOT_DEFAULT,

	0,

};



static inline struct audio_ext_ap_clk *to_audio_ap_clk(struct clk *clk)

{

	return container_of(clk, struct audio_ext_ap_clk, c);

}



static int audio_ext_clk_prepare(struct clk *clk)

{

	struct audio_ext_ap_clk *audio_clk = to_audio_ap_clk(clk);



	pr_debug("%s: gpio: %d\n", __func__, audio_clk->gpio);

	if (gpio_is_valid(audio_clk->gpio))

		return gpio_direction_output(audio_clk->gpio, 1);

	return 0;

}



static void audio_ext_clk_unprepare(struct clk *clk)

{

	struct audio_ext_ap_clk *audio_clk = to_audio_ap_clk(clk);



	pr_debug("%s: gpio: %d\n", __func__, audio_clk->gpio);

	if (gpio_is_valid(audio_clk->gpio))

		gpio_direction_output(audio_clk->gpio, 0);

}



static inline struct audio_ext_ap_clk2 *to_audio_ap_clk2(struct clk *clk)

{

	return container_of(clk, struct audio_ext_ap_clk2, c);

}



static int audio_ext_clk2_prepare(struct clk *clk)

{

	struct audio_ext_ap_clk2 *audio_clk2 = to_audio_ap_clk2(clk);

	struct pinctrl_info *pnctrl_info = &audio_clk2->pnctrl_info;

	int ret;





	if (!pnctrl_info->pinctrl || !pnctrl_info->active)

		return 0;



	ret = pinctrl_select_state(pnctrl_info->pinctrl,

				   pnctrl_info->active);

	if (ret) {

		pr_err("%s: active state select failed with %d\n",

			__func__, ret);

		return -EIO;

	}



	clk2_config.enable = 1;

	ret = afe_set_lpass_clk_cfg(IDX_RSVD_3, &clk2_config);

	if (ret < 0) {

		pr_err("%s: failed to set clock, ret = %d\n", __func__, ret);

		return -EINVAL;

	}



	return 0;

}



static void audio_ext_clk2_unprepare(struct clk *clk)

{

	struct audio_ext_ap_clk2 *audio_clk2 = to_audio_ap_clk2(clk);

	struct pinctrl_info *pnctrl_info = &audio_clk2->pnctrl_info;

	int ret;



	if (!pnctrl_info->pinctrl || !pnctrl_info->sleep)

		return;



	ret = pinctrl_select_state(pnctrl_info->pinctrl,

				   pnctrl_info->sleep);

	if (ret)

		pr_err("%s: sleep state select failed with %d\n",

			__func__, ret);



	clk2_config.enable = 0;

	ret = afe_set_lpass_clk_cfg(IDX_RSVD_3, &clk2_config);

	if (ret < 0)

		pr_err("%s: failed to reset clock, ret = %d\n", __func__, ret);

}



static const struct clk_ops audio_ext_ap_clk_ops = {

	.prepare = audio_ext_clk_prepare,

	.unprepare = audio_ext_clk_unprepare,

};



static const struct clk_ops audio_ext_ap_clk2_ops = {

	.prepare = audio_ext_clk2_prepare,

	.unprepare = audio_ext_clk2_unprepare,

};



static struct audio_ext_pmi_clk audio_pmi_clk = {

	.gpio = -EINVAL,

	.c = {

		.dbg_name = "audio_ext_pmi_clk",

		.ops = &clk_ops_dummy,

		CLK_INIT(audio_pmi_clk.c),

	},

};



static struct audio_ext_pmi_clk audio_pmi_lnbb_clk = {

	.gpio = -EINVAL,

	.c = {

		.dbg_name = "audio_ext_pmi_lnbb_clk",

		.ops = &clk_ops_dummy,

		CLK_INIT(audio_pmi_lnbb_clk.c),

	},

};



static struct audio_ext_ap_clk audio_ap_clk = {

	.gpio = -EINVAL,

	.c = {

		.dbg_name = "audio_ext_ap_clk",

		.ops = &audio_ext_ap_clk_ops,

		CLK_INIT(audio_ap_clk.c),

	},

};



static struct audio_ext_ap_clk2 audio_ap_clk2 = {

	.c = {

		.dbg_name = "audio_ext_ap_clk2",

		.ops = &audio_ext_ap_clk2_ops,

		CLK_INIT(audio_ap_clk2.c),

	},

};



static struct clk_lookup audio_ref_clock[] = {

	CLK_LIST(audio_ap_clk),

	CLK_LIST(audio_pmi_clk),

	CLK_LIST(audio_pmi_lnbb_clk),

	CLK_LIST(audio_ap_clk2),

};



static int audio_get_pinctrl(struct platform_device *pdev)

{

	struct pinctrl_info *pnctrl_info;

	struct pinctrl *pinctrl;

	int ret;



	pnctrl_info = &audio_ap_clk2.pnctrl_info;



	if (pnctrl_info->pinctrl) {

		dev_dbg(&pdev->dev, "%s: already requested before\n",

			__func__);

		return -EINVAL;

	}



	pinctrl = devm_pinctrl_get(&pdev->dev);

	if (IS_ERR_OR_NULL(pinctrl)) {

		dev_dbg(&pdev->dev, "%s: Unable to get pinctrl handle\n",

			__func__);

		return -EINVAL;

	}

	pnctrl_info->pinctrl = pinctrl;

	/* get all state handles from Device Tree */

	pnctrl_info->sleep = pinctrl_lookup_state(pinctrl, "sleep");

	if (IS_ERR(pnctrl_info->sleep)) {

		dev_err(&pdev->dev, "%s: could not get sleep pinstate\n",

			__func__);

		goto err;

	}

	pnctrl_info->active = pinctrl_lookup_state(pinctrl, "active");

	if (IS_ERR(pnctrl_info->active)) {

		dev_err(&pdev->dev, "%s: could not get active pinstate\n",

			__func__);

		goto err;

	}

	/* Reset the TLMM pins to a default state */

	ret = pinctrl_select_state(pnctrl_info->pinctrl,

				   pnctrl_info->sleep);

	if (ret) {

		dev_err(&pdev->dev, "%s: Disable TLMM pins failed with %d\n",

			__func__, ret);

		goto err;

	}

	return 0;



err:

	devm_pinctrl_put(pnctrl_info->pinctrl);

	return -EINVAL;

}



static int audio_ref_clk_probe(struct platform_device *pdev)

{

	int clk_gpio;

	int ret;

	struct clk *audio_clk;



	clk_gpio = of_get_named_gpio(pdev->dev.of_node,

				     "qcom,audio-ref-clk-gpio", 0);

	if (clk_gpio > 0) {

		ret = gpio_request(clk_gpio, "EXT_CLK");

		if (ret) {

			dev_err(&pdev->dev,

				"Request ext clk gpio failed %d, err:%d\n",

				clk_gpio, ret);

			goto err;

		}

		if (of_property_read_bool(pdev->dev.of_node,

					"qcom,node_has_rpm_clock")) {

			audio_clk = clk_get(&pdev->dev, NULL);

			if (IS_ERR(audio_clk)) {

				dev_err(&pdev->dev, "Failed to get RPM div clk\n");

				ret = PTR_ERR(audio_clk);

				goto err_gpio;

			}

			audio_pmi_clk.c.parent = audio_clk;

			audio_pmi_clk.gpio = clk_gpio;

		} else

			audio_ap_clk.gpio = clk_gpio;



	} else {

		if (of_property_read_bool(pdev->dev.of_node,

					"qcom,node_has_rpm_clock")) {

			audio_clk = clk_get(&pdev->dev, NULL);

			if (IS_ERR(audio_clk)) {

				dev_err(&pdev->dev, "Failed to get lnbbclk2\n");

				ret = PTR_ERR(audio_clk);

				goto err;

			}

			audio_pmi_lnbb_clk.c.parent = audio_clk;

			audio_pmi_lnbb_clk.gpio = -EINVAL;

		}

	}



	ret = audio_get_pinctrl(pdev);

	if (ret)

		dev_dbg(&pdev->dev, "%s: Parsing pinctrl failed\n",

			__func__);



	ret = of_msm_clock_register(pdev->dev.of_node, audio_ref_clock,

			      ARRAY_SIZE(audio_ref_clock));

	if (ret) {

		dev_err(&pdev->dev, "%s: audio ref clock register failed\n",

			__func__);

		goto err_gpio;

	}



	return 0;



err_gpio:

	gpio_free(clk_gpio);



err:

	return ret;

}



static int audio_ref_clk_remove(struct platform_device *pdev)

{

	struct pinctrl_info *pnctrl_info = &audio_ap_clk2.pnctrl_info;



	if (audio_pmi_clk.gpio > 0)

		gpio_free(audio_pmi_clk.gpio);

	else if (audio_ap_clk.gpio > 0)

		gpio_free(audio_ap_clk.gpio);



	if (pnctrl_info->pinctrl) {

		devm_pinctrl_put(pnctrl_info->pinctrl);

		pnctrl_info->pinctrl = NULL;

	}



	return 0;

}



static const struct of_device_id audio_ref_clk_match[] = {

	{.compatible = "qcom,audio-ref-clk"},

	{}

};

MODULE_DEVICE_TABLE(of, audio_ref_clk_match);



static struct platform_driver audio_ref_clk_driver = {

	.driver = {

		.name = "audio-ref-clk",

		.owner = THIS_MODULE,

		.of_match_table = audio_ref_clk_match,

	},

	.probe = audio_ref_clk_probe,

	.remove = audio_ref_clk_remove,

};



int audio_ref_clk_platform_init(void)

{

	return platform_driver_register(&audio_ref_clk_driver);

}



void audio_ref_clk_platform_exit(void)

{

	platform_driver_unregister(&audio_ref_clk_driver);

}



MODULE_DESCRIPTION("Audio Ref Clock module platform driver");

MODULE_LICENSE("GPL v2");