asoc: codecs: add support for digital only codec (6d75bc03) · Commits · e / devices / android_kernel_fairphone_FP3

asoc/codecs/sdm660_cdc/msm-digital-cdc.c

+384 −16

Original line number	Diff line number	Diff line
		@@ -23,7 +23,9 @@
		#include <sound/soc.h>
		#include <sound/soc-dapm.h>
		#include <sound/tlv.h>
		#include <linux/regulator/consumer.h>
		#include <dsp/q6afe-v2.h>
		#include <dsp/q6core.h>
		#include <ipc/apr.h>
		#include <soc/internal.h>
		#include "sdm660-cdc-registers.h"
		@@ -40,6 +42,8 @@
		#define CF_MIN_3DB_150HZ 0x2

		#define MSM_DIG_CDC_VERSION_ENTRY_SIZE 32
		#define MAX_ON_DEMAND_DIG_SUPPLY_NAME_LENGTH 64
		#define CODEC_DT_MAX_PROP_SIZE 40

		static unsigned long rx_digital_gain_reg[] = {
		MSM89XX_CDC_CORE_RX1_VOL_CTL_B2_CTL,
		@@ -65,6 +69,13 @@ static const DECLARE_TLV_DB_SCALE(digital_gain, 0, 1, 0);
		struct snd_soc_codec *registered_digcodec;
		struct hpf_work tx_hpf_work[NUM_DECIMATORS];

		static int msm_dig_cdc_enable_on_demand_supply(
		struct snd_soc_dapm_widget *w,
		struct snd_kcontrol *kcontrol, int event);
		static char on_demand_supply_name[][MAX_ON_DEMAND_DIG_SUPPLY_NAME_LENGTH] = {
		"cdc-vdd-digital",
		};

		/* Codec supports 2 IIR filters */
		enum {
		IIR1 = 0,
		@@ -1240,6 +1251,29 @@ int msm_dig_codec_info_create_codec_entry(struct snd_info_entry *codec_root,
		}
		EXPORT_SYMBOL(msm_dig_codec_info_create_codec_entry);

		static void msm_dig_cdc_update_micbias_regulator(
		const struct msm_dig_priv *dig_cdc,
		const char *name,
		struct on_demand_dig_supply *micbias_supply)
		{
		int i;

		for (i = 0; i < dig_cdc->num_of_supplies; i++) {
		if (dig_cdc->supplies[i].supply &&
		!strcmp(dig_cdc->supplies[i].supply, name)) {
		micbias_supply->supply =
		dig_cdc->supplies[i].consumer;
		micbias_supply->min_uv = dig_cdc->regulator[i].min_uv;
		micbias_supply->max_uv = dig_cdc->regulator[i].max_uv;
		micbias_supply->optimum_ua =
		dig_cdc->regulator[i].optimum_ua;
		return;
		}
		}

		dev_dbg(dig_cdc->dev, "Error: regulator not found:%s\n", name);
		}

		static void sdm660_tx_mute_update_callback(struct work_struct *work)
		{
		struct tx_mute_work *tx_mute_dwork;
		@@ -1306,6 +1340,13 @@ static int msm_dig_cdc_soc_probe(struct snd_soc_codec *codec)
		return ret;
		}
		}

		msm_dig_cdc_update_micbias_regulator(
		msm_dig_cdc,
		on_demand_supply_name[ON_DEMAND_DIGITAL],
		&msm_dig_cdc->on_demand_list[ON_DEMAND_DIGITAL]);
		atomic_set(&msm_dig_cdc->on_demand_list[ON_DEMAND_DIGITAL].ref, 0);

		registered_digcodec = codec;

		snd_soc_dapm_ignore_suspend(dapm, "AIF1 Playback");
		@@ -1796,6 +1837,11 @@ static const struct snd_soc_dapm_widget msm_dig_dapm_widgets[] = {
		SND_SOC_DAPM_SUPPLY("TX_I2S_CLK",
		MSM89XX_CDC_CORE_CLK_TX_I2S_CTL, 4, 0, NULL, 0),

		SND_SOC_DAPM_SUPPLY("DIGITAL_REGULATOR", SND_SOC_NOPM,
		ON_DEMAND_DIGITAL, 0,
		msm_dig_cdc_enable_on_demand_supply,
		SND_SOC_DAPM_PRE_PMU \|
		SND_SOC_DAPM_POST_PMD),

		SND_SOC_DAPM_MUX("I2S TX2 INP1", SND_SOC_NOPM, 0, 0,
		&i2s_tx2_inp1_mux),
		@@ -1979,6 +2025,218 @@ static const struct snd_kcontrol_new msm_dig_snd_controls[] = {
		MSM89XX_CDC_CORE_TX5_MUX_CTL, 3, 1, 0),
		};

		static int msm_dig_cdc_enable_on_demand_supply(
		struct snd_soc_dapm_widget *w,
		struct snd_kcontrol *kcontrol, int event)
		{
		int ret = 0;
		struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
		struct msm_dig_priv *msm_dig_cdc = snd_soc_codec_get_drvdata(codec);
		struct on_demand_dig_supply *supply;

		if (w->shift >= ON_DEMAND_DIG_SUPPLIES_MAX) {
		dev_err(codec->dev, "%s: error index >= MAX on demand supplies",
		__func__);
		ret = -EINVAL;
		goto out;
		}
		dev_dbg(codec->dev, "%s: supply: %s event: %d ref: %d\n",
		__func__, on_demand_supply_name[w->shift], event,
		atomic_read(&msm_dig_cdc->on_demand_list[w->shift].ref));

		supply = &msm_dig_cdc->on_demand_list[w->shift];
		if (!supply->supply) {
		dev_err(codec->dev, "%s: err supply not present ond for %d",
		__func__, w->shift);
		goto out;
		}
		switch (event) {
		case SND_SOC_DAPM_PRE_PMU:
		if (atomic_inc_return(&supply->ref) == 1) {
		ret = regulator_set_voltage(supply->supply,
		supply->min_uv,
		supply->max_uv);
		if (ret) {
		dev_err(codec->dev,
		"Setting regulator voltage(en) for micbias with err = %d\n",
		ret);
		goto out;
		}
		ret = regulator_set_load(supply->supply,
		supply->optimum_ua);
		if (ret < 0) {
		dev_err(codec->dev,
		"Setting regulator optimum mode(en) failed for micbias with err = %d\n",
		ret);
		goto out;
		}
		ret = regulator_enable(supply->supply);
		if (ret)
		dev_err(codec->dev, "%s: Failed to enable %s\n",
		__func__,
		on_demand_supply_name[w->shift]);
		}
		break;
		case SND_SOC_DAPM_POST_PMD:
		if (atomic_read(&supply->ref) == 0) {
		dev_dbg(codec->dev, "%s: %s supply has been disabled.\n",
		__func__, on_demand_supply_name[w->shift]);
		goto out;
		}
		if (atomic_dec_return(&supply->ref) == 0) {
		ret = regulator_disable(supply->supply);
		if (ret)
		dev_err(codec->dev, "%s: Failed to disable %s\n",
		__func__,
		on_demand_supply_name[w->shift]);
		ret = regulator_set_voltage(supply->supply,
		0,
		supply->max_uv);
		if (ret) {
		dev_err(codec->dev,
		"Setting regulator voltage(dis) failed for micbias with err = %d\n",
		ret);
		goto out;
		}
		ret = regulator_set_load(supply->supply, 0);
		if (ret < 0)
		dev_err(codec->dev,
		"Setting regulator optimum mode(dis) failed for micbias with err = %d\n",
		ret);
		}
		break;
		default:
		break;
		}
		out:
		return ret;
		}

		static int msm_digital_cdc_init_supplies(struct msm_dig_priv *msm_cdc)
		{
		int ret;
		int i;

		msm_cdc->supplies = devm_kzalloc(msm_cdc->dev,
		sizeof(struct regulator_bulk_data) *
		ARRAY_SIZE(msm_cdc->regulator),
		GFP_KERNEL);
		if (!msm_cdc->supplies) {
		ret = -ENOMEM;
		goto err;
		}

		msm_cdc->num_of_supplies = 0;

		if (ARRAY_SIZE(msm_cdc->regulator) > MAX_REGULATOR) {
		dev_err(msm_cdc->dev, "%s: Array Size out of bound\n",
		__func__);
		ret = -EINVAL;
		goto err;
		}

		for (i = 0; i < ARRAY_SIZE(msm_cdc->regulator); i++) {
		if (msm_cdc->regulator[i].name) {
		msm_cdc->supplies[i].supply =
		msm_cdc->regulator[i].name;
		msm_cdc->num_of_supplies++;
		}
		}

		ret = devm_regulator_bulk_get(msm_cdc->dev,
		msm_cdc->num_of_supplies,
		msm_cdc->supplies);
		if (ret != 0) {
		dev_err(msm_cdc->dev,
		"Failed to get supplies: err = %d\n",
		ret);
		goto err_supplies;
		}

		for (i = 0; i < msm_cdc->num_of_supplies; i++) {
		if (regulator_count_voltages(
		msm_cdc->supplies[i].consumer) <= 0)
		continue;
		ret = regulator_set_voltage(
		msm_cdc->supplies[i].consumer,
		msm_cdc->regulator[i].min_uv,
		msm_cdc->regulator[i].max_uv);
		if (ret) {
		dev_err(msm_cdc->dev,
		"Setting regulator voltage failed for regulator %s err = %d\n",
		msm_cdc->supplies[i].supply, ret);
		goto err_supplies;
		}
		ret = regulator_set_load(msm_cdc->supplies[i].consumer,
		msm_cdc->regulator[i].optimum_ua);
		if (ret < 0) {
		dev_err(msm_cdc->dev,
		"Setting regulator optimum mode failed for regulator %s err = %d\n",
		msm_cdc->supplies[i].supply, ret);
		goto err_supplies;
		} else {
		ret = 0;
		}
		}

		return ret;

		err_supplies:
		err:
		return ret;
		}

		static int msm_digital_cdc_dt_parse_vreg_info(struct device *dev,
		struct dig_cdc_regulator vreg, const char vreg_name)
		{
		int len, ret = 0;
		const __be32 *prop;
		char prop_name[CODEC_DT_MAX_PROP_SIZE];
		struct device_node *regnode = NULL;
		u32 prop_val;

		snprintf(prop_name, CODEC_DT_MAX_PROP_SIZE, "%s-supply",
		vreg_name);
		regnode = of_parse_phandle(dev->of_node, prop_name, 0);

		if (!regnode) {
		dev_err(dev, "Looking up %s property in node %s failed\n",
		prop_name, dev->of_node->full_name);
		return -ENODEV;
		}

		dev_dbg(dev, "Looking up %s property in node %s\n",
		prop_name, dev->of_node->full_name);

		vreg->name = vreg_name;

		snprintf(prop_name, CODEC_DT_MAX_PROP_SIZE,
		"qcom,%s-voltage", vreg_name);
		prop = of_get_property(dev->of_node, prop_name, &len);

		if (!prop \|\| (len != (2 * sizeof(__be32)))) {
		dev_err(dev, "%s %s property\n",
		prop ? "invalid format" : "no", prop_name);
		return -EINVAL;
		}
		vreg->min_uv = be32_to_cpup(&prop[0]);
		vreg->max_uv = be32_to_cpup(&prop[1]);

		snprintf(prop_name, CODEC_DT_MAX_PROP_SIZE,
		"qcom,%s-current", vreg_name);

		ret = of_property_read_u32(dev->of_node, prop_name, &prop_val);
		if (ret) {
		dev_err(dev, "Looking up %s property in node %s failed",
		prop_name, dev->of_node->full_name);
		return -EFAULT;
		}
		vreg->optimum_ua = prop_val;
		dev_dbg(dev, "%s: vol=[%d %d]uV, curr=[%d]uA\n", vreg->name,
		vreg->min_uv, vreg->max_uv, vreg->optimum_ua);
		return 0;
		}

		static struct snd_soc_dai_ops msm_dig_dai_ops = {
		.hw_params = msm_dig_cdc_hw_params,
		};
		@@ -2095,23 +2353,131 @@ const struct regmap_config msm_digital_regmap_config = {
		.max_register = MSM89XX_CDC_CORE_MAX_REGISTER,
		};

		static bool msm_digital_cdc_populate_dt_pdata(
		struct device *dev,
		struct msm_dig_priv *dig_priv)
		{
		int ret, ond_cnt, i, idx = 0;
		const char *name = NULL;
		const char *ond_prop_name = "qcom,cdc-on-demand-supplies";

		ond_cnt = of_property_count_strings(dev->of_node, ond_prop_name);
		if (ond_cnt < 0)
		ond_cnt = 0;

		if (ond_cnt > ARRAY_SIZE(dig_priv->regulator)) {
		ret = -EINVAL;
		goto err;
		}

		for (i = 0; i < ond_cnt; i++, idx++) {
		ret = of_property_read_string_index(dev->of_node, ond_prop_name,
		i, &name);
		if (ret) {
		dev_err(dev, "%s: err parsing on_demand for %s idx %d\n",
		__func__, ond_prop_name, i);
		goto err;
		}

		dev_dbg(dev, "%s: Found on-demand cdc supply %s\n", __func__,
		name);
		ret = msm_digital_cdc_dt_parse_vreg_info(dev,
		&dig_priv->regulator[idx],
		name);
		if (ret) {
		dev_err(dev, "%s: err parsing vreg on_demand for %s idx %d\n",
		__func__, name, idx);
		goto err;
		}
		}

		return true;
		err:
		dev_err(dev, "%s: Failed to populate DT data ret = %d\n",
		__func__, ret);
		return false;
		}

		static void msm_digital_cdc_disable_supplies(struct msm_dig_priv *msm_cdc)
		{
		int i;

		if (!msm_cdc->supplies)
		return;

		regulator_bulk_disable(msm_cdc->num_of_supplies,
		msm_cdc->supplies);
		for (i = 0; i < msm_cdc->num_of_supplies; i++) {
		if (regulator_count_voltages(
		msm_cdc->supplies[i].consumer) <= 0)
		continue;
		regulator_set_voltage(msm_cdc->supplies[i].consumer, 0,
		msm_cdc->regulator[i].max_uv);
		regulator_set_load(msm_cdc->supplies[i].consumer, 0);
		}
		regulator_bulk_free(msm_cdc->num_of_supplies,
		msm_cdc->supplies);
		devm_kfree(msm_cdc->dev, msm_cdc->supplies);
		}

		static int msm_dig_cdc_probe(struct platform_device *pdev)
		{
		int ret;
		int ret = -EINVAL;
		u32 dig_cdc_addr;
		struct msm_dig_priv *msm_dig_cdc;
		struct dig_ctrl_platform_data *pdata;
		struct dig_ctrl_platform_data *pdata = NULL;
		bool no_analog_codec = false;
		int adsp_state;

		adsp_state = apr_get_subsys_state();
		if ((adsp_state != APR_SUBSYS_LOADED) \|\| (!q6core_is_adsp_ready())) {
		dev_err(&pdev->dev, "Adsp is not loaded yet %d\n",
		adsp_state);
		return -EPROBE_DEFER;
		}

		device_init_wakeup(&pdev->dev, true);

		msm_dig_cdc = devm_kzalloc(&pdev->dev, sizeof(struct msm_dig_priv),
		GFP_KERNEL);
		if (!msm_dig_cdc)
		return -ENOMEM;

		msm_dig_cdc->dev = &pdev->dev;
		if (pdev->dev.of_node == NULL)
		return -EINVAL;

		if (pdev->dev.of_node)
		no_analog_codec = of_property_read_bool(pdev->dev.of_node,
		"qcom,no-analog-codec");

		if (no_analog_codec) {
		dev_dbg(&pdev->dev, "%s:Platform data from device tree\n",
		__func__);
		if (msm_digital_cdc_populate_dt_pdata(&pdev->dev,
		msm_dig_cdc)) {
		ret = msm_digital_cdc_init_supplies(
		msm_dig_cdc);
		if (ret) {
		dev_err(&pdev->dev,
		"%s: Fail to enable Codec supplies\n",
		__func__);
		goto rtn;
		}
		}
		} else {
		pdata = dev_get_platdata(&pdev->dev);
		if (!pdata) {
		dev_err(&pdev->dev, "%s: pdata from parent is NULL\n",
		__func__);
		ret = -EINVAL;
		goto rtn;
		goto err_supplies;
		}
		msm_dig_cdc->update_clkdiv = pdata->update_clkdiv;
		msm_dig_cdc->set_compander_mode = pdata->set_compander_mode;
		msm_dig_cdc->get_cdc_version = pdata->get_cdc_version;
		msm_dig_cdc->handle = pdata->handle;
		msm_dig_cdc->register_notifier = pdata->register_notifier;
		}

		ret = of_property_read_u32(pdev->dev.of_node, "reg",
		@@ -2119,37 +2485,39 @@ static int msm_dig_cdc_probe(struct platform_device *pdev)
		if (ret) {
		dev_err(&pdev->dev, "%s: could not find %s entry in dt\n",
		__func__, "reg");
		return ret;
		goto err_supplies;
		}

		msm_dig_cdc->dig_base = ioremap(dig_cdc_addr,
		MSM89XX_CDC_CORE_MAX_REGISTER);
		if (msm_dig_cdc->dig_base == NULL) {
		dev_err(&pdev->dev, "%s ioremap failed\n", __func__);
		return -ENOMEM;
		ret = -ENOMEM;
		goto err_supplies;
		}
		msm_dig_cdc->regmap =
		devm_regmap_init_mmio_clk(&pdev->dev, NULL,
		msm_dig_cdc->dig_base, &msm_digital_regmap_config);

		msm_dig_cdc->update_clkdiv = pdata->update_clkdiv;
		msm_dig_cdc->set_compander_mode = pdata->set_compander_mode;
		msm_dig_cdc->get_cdc_version = pdata->get_cdc_version;
		msm_dig_cdc->handle = pdata->handle;
		msm_dig_cdc->register_notifier = pdata->register_notifier;

		dev_set_drvdata(&pdev->dev, msm_dig_cdc);
		snd_soc_register_codec(&pdev->dev, &soc_msm_dig_codec,
		msm_codec_dais, ARRAY_SIZE(msm_codec_dais));
		dev_dbg(&pdev->dev, "%s: registered DIG CODEC 0x%x\n",
		__func__, dig_cdc_addr);
		return ret;
		err_supplies:
		if (no_analog_codec)
		msm_digital_cdc_disable_supplies(msm_dig_cdc);
		rtn:
		return ret;
		}

		static int msm_dig_cdc_remove(struct platform_device *pdev)
		{
		struct msm_dig_priv *msm_cdc = dev_get_drvdata(&pdev->dev);

		snd_soc_unregister_codec(&pdev->dev);
		msm_digital_cdc_disable_supplies(msm_cdc);
		return 0;
		}

asoc/codecs/sdm660_cdc/msm-digital-cdc.h

+27 −1

Original line number	Diff line number	Diff line
		@@ -15,7 +15,7 @@
		#define HPHL_PA_DISABLE (0x01 << 1)
		#define HPHR_PA_DISABLE (0x01 << 2)
		#define SPKR_PA_DISABLE (0x01 << 3)

		#define MAX_REGULATOR 7
		#define NUM_DECIMATORS 5
		/* Codec supports 1 compander */
		enum {
		@@ -32,6 +32,27 @@ enum {
		MSM89XX_RX_MAX,
		};

		enum {
		ON_DEMAND_DIGITAL = 0,
		ON_DEMAND_DIG_SUPPLIES_MAX,
		};

		struct on_demand_dig_supply {
		struct regulator *supply;
		atomic_t ref;
		int min_uv;
		int max_uv;
		int optimum_ua;
		};

		struct dig_cdc_regulator {
		const char *name;
		int min_uv;
		int max_uv;
		int optimum_ua;
		struct regulator *regulator;
		};

		struct tx_mute_work {
		struct msm_dig_priv *dig_cdc;
		u32 decimator;
		@@ -45,6 +66,7 @@ struct msm_cap_mode {

		struct msm_dig_priv {
		struct snd_soc_codec *codec;
		struct device *dev;
		u32 comp_enabled[MSM89XX_RX_MAX];
		int (codec_hph_comp_gpio)(bool enable, struct snd_soc_codec codec);
		s32 dmic_1_2_clk_cnt;
		@@ -60,6 +82,7 @@ struct msm_dig_priv {
		u32 mute_mask;
		int dapm_bias_off;
		void *handle;
		struct on_demand_dig_supply on_demand_list[ON_DEMAND_DIG_SUPPLIES_MAX];
		void (set_compander_mode)(void handle, int val);
		void (update_clkdiv)(void handle, int val);
		int (get_cdc_version)(void handle);
		@@ -67,6 +90,9 @@ struct msm_dig_priv {
		struct notifier_block *nblock,
		bool enable);
		struct tx_mute_work tx_mute_dwork[NUM_DECIMATORS];
		u32 num_of_supplies;
		struct regulator_bulk_data *supplies;
		struct dig_cdc_regulator regulator[MAX_REGULATOR];
		};

		struct dig_ctrl_platform_data {