Commit a22fc2f2 authored by BabuSubashChandar's avatar BabuSubashChandar Committed by Phil Elwell
Browse files

Add clock changes and mute gpios (#1938)



Also improve code style and adhere to ALSA coding conventions.

Signed-off-by: default avatarBaswaraj K <jaikumar@cem-solutions.net>
Reviewed-by: default avatarVijay Kumar B. <vijaykumar@zilogic.com>
Reviewed-by: default avatarRaashid Muhammed <raashidmuhammed@zilogic.com>
parent 8ecb17cc
Loading
Loading
Loading
Loading
+3 −0
Original line number Diff line number Diff line
@@ -323,6 +323,9 @@ Params: 24db_digital_gain Allow gain to be applied via the PCM512x codec
                                responsibility of the user to ensure that
                                the Digital volume control is set to a value
                                that does not result in clipping/distortion!)
        glb_mclk                This option is only with Kali board. If enabled,
                                MCLK for Kali is used and PLL is disabled for
                                better voice quality. (default Off)


Name:   at86rf233
+8 −4
Original line number Diff line number Diff line
@@ -19,13 +19,13 @@
			#size-cells = <0>;
			status = "okay";

			pcm5122_4c: pcm5122@4c {
			allo_pcm5122_4c: pcm5122@4c {
				#sound-dai-cells = <0>;
				compatible = "ti,pcm5122";
				reg = <0x4c>;
				status = "okay";
			};
			pcm5122_4d: pcm5122@4d {
			allo_pcm5122_4d: pcm5122@4d {
				#sound-dai-cells = <0>;
				compatible = "ti,pcm5122";
				reg = <0x4d>;
@@ -38,14 +38,18 @@
		target = <&sound>;
		piano_dac: __overlay__ {
			compatible = "allo,piano-dac-plus";
			audio-codec = <&pcm5122_4c &pcm5122_4d>;
			audio-codec = <&allo_pcm5122_4c &allo_pcm5122_4d>;
			i2s-controller = <&i2s>;
			mute1-gpios = <&gpio 6 1>;
			mute2-gpios = <&gpio 25 1>;
			status = "okay";
		};
	};

	__overrides__ {
		24db_digital_gain =
			<&piano_dac>,"piano,24db_digital_gain?";
			<&piano_dac>,"allo,24db_digital_gain?";
		glb_mclk =
			<&piano_dac>,"allo,glb_mclk?";
	};
};
+1 −0
Original line number Diff line number Diff line
@@ -896,6 +896,7 @@ CONFIG_SND_BCM2708_SOC_DIONAUDIO_LOCO=m
CONFIG_SND_BCM2708_SOC_DIONAUDIO_LOCO_V2=m
CONFIG_SND_BCM2708_SOC_ALLO_BOSS_DAC=m
CONFIG_SND_BCM2708_SOC_ALLO_PIANO_DAC=m
CONFIG_SND_BCM2708_SOC_ALLO_PIANO_DAC_PLUS=m
CONFIG_SND_BCM2708_SOC_FE_PI_AUDIO=m
CONFIG_SND_PISOUND=m
CONFIG_SND_SOC_ADAU1701=m
+2 −0
Original line number Diff line number Diff line
@@ -887,7 +887,9 @@ CONFIG_SND_AUDIOINJECTOR_OCTO_SOUNDCARD=m
CONFIG_SND_DIGIDAC1_SOUNDCARD=m
CONFIG_SND_BCM2708_SOC_DIONAUDIO_LOCO=m
CONFIG_SND_BCM2708_SOC_DIONAUDIO_LOCO_V2=m
CONFIG_SND_BCM2708_SOC_ALLO_BOSS_DAC=m
CONFIG_SND_BCM2708_SOC_ALLO_PIANO_DAC=m
CONFIG_SND_BCM2708_SOC_ALLO_PIANO_DAC_PLUS=m
CONFIG_SND_BCM2708_SOC_FE_PI_AUDIO=m
CONFIG_SND_PISOUND=m
CONFIG_SND_SOC_ADAU1701=m
+277 −61
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@

#include <linux/module.h>
#include <linux/platform_device.h>

#include <linux/gpio/consumer.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
@@ -34,9 +34,19 @@ struct dsp_code {
	char val;
};

static struct snd_soc_pcm_runtime *rtd_glb;
struct glb_pool {
	struct mutex lock;
	unsigned int set_lowpass;
	unsigned int set_mode;
	unsigned int set_rate;
	unsigned int dsp_page_number;
};

static bool digital_gain_0db_limit = true;
unsigned int set_lowpass, set_mode, set_rate, dsp_page_number;
bool glb_mclk;

static struct gpio_desc *mute_gpio[2];


static const char * const allo_piano_mode_texts[] = {
	"2.0",
@@ -68,12 +78,14 @@ static const char * const allo_piano_dsp_low_pass_texts[] = {
static const SOC_ENUM_SINGLE_DECL(allo_piano_enum,
		0, 0, allo_piano_dsp_low_pass_texts);

static int snd_allo_piano_dsp_program(struct snd_soc_pcm_runtime *rtd,
static int __snd_allo_piano_dsp_program(struct snd_soc_pcm_runtime *rtd,
		unsigned int mode, unsigned int rate, unsigned int lowpass)
{
	const struct firmware *fw;
	char firmware_name[40];
	char firmware_name[60];
	int ret = 0, dac = 0;
	struct snd_soc_card *card = rtd->card;
	struct glb_pool *glb_ptr = card->drvdata;

	if (rate <= 46000)
		rate = 44100;
@@ -88,38 +100,41 @@ static int snd_allo_piano_dsp_program(struct snd_soc_pcm_runtime *rtd,
	else
		rate = 192000;

	/* same configuration loaded */
	if ((rate == set_rate) && (lowpass == set_lowpass)
			&& (mode == set_mode))
		return 1;
	if ((lowpass > 14) || (lowpass < 0))
		lowpass = 3;
	if ((mode > 2) || (mode < 0))
		mode = 0;

	set_rate = rate;
	set_mode = mode;
	/* same configuration loaded */
	if ((rate == glb_ptr->set_rate) && (lowpass == glb_ptr->set_lowpass)
			&& (mode == glb_ptr->set_mode))
		return 0;

	if (mode == 0) { /* 2.0 */
		snd_soc_write(rtd->codec_dais[1]->codec,
				PCM512x_MUTE, 0x11);
		glb_ptr->set_rate = rate;
		glb_ptr->set_mode = mode;
		glb_ptr->set_lowpass = lowpass;
		return 1;
	} else {
		snd_soc_write(rtd->codec_dais[1]->codec,
				PCM512x_MUTE, 0x00);
	}

	set_lowpass = lowpass;

	for (dac = 0; dac < rtd->num_codecs; dac++) {
		struct dsp_code *dsp_code_read;
		int i = 1;
		struct snd_soc_codec *codec = rtd->codec_dais[dac]->codec;
		int i = 1;

		if (dac == 0) { /* high */
			sprintf(firmware_name,
				"alloPiano/2.2/allo-piano-dsp-%d-%d-%d.bin",
				rate, ((set_lowpass * 10) + 60), dac);
				"allo/piano/2.2/allo-piano-dsp-%d-%d-%d.bin",
				rate, ((lowpass * 10) + 60), dac);
		} else { /* low */
			sprintf(firmware_name,
				"alloPiano/2.%d/allo-piano-dsp-%d-%d-%d.bin",
				set_mode, rate, ((set_lowpass * 10) + 60), dac);
				"allo/piano/2.%d/allo-piano-dsp-%d-%d-%d.bin",
				mode, rate, ((lowpass * 10) + 60), dac);
		}

		dev_info(codec->dev, "Dsp Firmware File Name: %s\n",
@@ -127,7 +142,8 @@ static int snd_allo_piano_dsp_program(struct snd_soc_pcm_runtime *rtd,

		ret = request_firmware(&fw, firmware_name, codec->dev);
		if (ret < 0) {
			dev_err(codec->dev, "Error: AlloPiano Firmware %s missing. %d\n",
			dev_err(codec->dev,
				"Error: Allo Piano Firmware %s missing. %d\n",
				firmware_name, ret);
			goto err;
		}
@@ -136,61 +152,96 @@ static int snd_allo_piano_dsp_program(struct snd_soc_pcm_runtime *rtd,
			dsp_code_read = (struct dsp_code *)&fw->data[i];

			if (dsp_code_read->offset == 0) {
				dsp_page_number = dsp_code_read->val;
				glb_ptr->dsp_page_number = dsp_code_read->val;
				ret = snd_soc_write(rtd->codec_dais[dac]->codec,
					PCM512x_PAGE_BASE(0),
					dsp_code_read->val);

			} else if (dsp_code_read->offset != 0) {
				ret = snd_soc_write(rtd->codec_dais[dac]->codec,
					(PCM512x_PAGE_BASE(dsp_page_number) +
					(PCM512x_PAGE_BASE(
						glb_ptr->dsp_page_number) +
					dsp_code_read->offset),
					dsp_code_read->val);

			}
			if (ret < 0) {
				dev_err(codec->dev,
					"Failed to write Register: %d\n", ret);
				release_firmware(fw);
				goto err;
			}
			i = i + 3;
		}
		release_firmware(fw);
	}
	glb_ptr->set_rate = rate;
	glb_ptr->set_mode = mode;
	glb_ptr->set_lowpass = lowpass;
	return 1;

err:
	release_firmware(fw);
	return ret;
}

static int snd_allo_piano_dsp_program(struct snd_soc_pcm_runtime *rtd,
		unsigned int mode, unsigned int rate, unsigned int lowpass)
{
	struct snd_soc_card *card = rtd->card;
	struct glb_pool *glb_ptr = card->drvdata;
	int ret = 0;

	mutex_lock(&glb_ptr->lock);

	ret = __snd_allo_piano_dsp_program(rtd,
				mode, rate, lowpass);
	mutex_unlock(&glb_ptr->lock);

	return ret;
}

static int snd_allo_piano_mode_get(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	ucontrol->value.integer.value[0] = set_mode;
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct glb_pool *glb_ptr = card->drvdata;

	ucontrol->value.integer.value[0] = glb_ptr->set_mode;
	return 0;
}

static int snd_allo_piano_mode_put(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	return(snd_allo_piano_dsp_program(rtd_glb,
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct snd_soc_pcm_runtime *rtd;
	struct glb_pool *glb_ptr = card->drvdata;

	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
	return(snd_allo_piano_dsp_program(rtd,
				ucontrol->value.integer.value[0],
			set_rate, set_lowpass));
				glb_ptr->set_rate, glb_ptr->set_lowpass));
}

static int snd_allo_piano_lowpass_get(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	ucontrol->value.integer.value[0] = set_lowpass;
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct glb_pool *glb_ptr = card->drvdata;

	ucontrol->value.integer.value[0] = glb_ptr->set_lowpass;
	return 0;
}

static int snd_allo_piano_lowpass_put(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	return(snd_allo_piano_dsp_program(rtd_glb,
			set_mode, set_rate,
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct snd_soc_pcm_runtime *rtd;
	struct glb_pool *glb_ptr = card->drvdata;

	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
	return(snd_allo_piano_dsp_program(rtd,
				glb_ptr->set_mode, glb_ptr->set_rate,
				ucontrol->value.integer.value[0]));
}

@@ -199,15 +250,18 @@ static int pcm512x_get_reg_sub(struct snd_kcontrol *kcontrol,
{
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct snd_soc_pcm_runtime *rtd;
	unsigned int left_val = 0;
	unsigned int right_val = 0;

	left_val = snd_soc_read(rtd_glb->codec_dais[1]->codec,
	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
	left_val = snd_soc_read(rtd->codec_dais[1]->codec,
			PCM512x_DIGITAL_VOLUME_2);
	if (left_val < 0)
		return left_val;

	right_val = snd_soc_read(rtd_glb->codec_dais[1]->codec,
	right_val = snd_soc_read(rtd->codec_dais[1]->codec,
			PCM512x_DIGITAL_VOLUME_3);
	if (right_val < 0)
		return right_val;
@@ -225,16 +279,19 @@ static int pcm512x_set_reg_sub(struct snd_kcontrol *kcontrol,
{
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct snd_soc_pcm_runtime *rtd;
	unsigned int left_val = (ucontrol->value.integer.value[0] & mc->max);
	unsigned int right_val = (ucontrol->value.integer.value[1] & mc->max);
	int ret = 0;

	ret = snd_soc_write(rtd_glb->codec_dais[1]->codec,
	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
	ret = snd_soc_write(rtd->codec_dais[1]->codec,
			PCM512x_DIGITAL_VOLUME_2, (~left_val));
	if (ret < 0)
		return ret;

	ret = snd_soc_write(rtd_glb->codec_dais[1]->codec,
	ret = snd_soc_write(rtd->codec_dais[1]->codec,
			PCM512x_DIGITAL_VOLUME_3, (~right_val));
	if (ret < 0)
		return ret;
@@ -245,9 +302,12 @@ static int pcm512x_set_reg_sub(struct snd_kcontrol *kcontrol,
static int pcm512x_get_reg_sub_switch(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct snd_soc_pcm_runtime *rtd;
	int val = 0;

	val = snd_soc_read(rtd_glb->codec_dais[1]->codec, PCM512x_MUTE);
	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
	val = snd_soc_read(rtd->codec_dais[1]->codec, PCM512x_MUTE);
	if (val < 0)
		return val;

@@ -260,11 +320,14 @@ static int pcm512x_get_reg_sub_switch(struct snd_kcontrol *kcontrol,
static int pcm512x_set_reg_sub_switch(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
	struct snd_soc_pcm_runtime *rtd;
	unsigned int left_val = (ucontrol->value.integer.value[0]);
	unsigned int right_val = (ucontrol->value.integer.value[1]);
	int ret = 0;

	ret = snd_soc_write(rtd_glb->codec_dais[1]->codec, PCM512x_MUTE,
	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
	ret = snd_soc_write(rtd->codec_dais[1]->codec, PCM512x_MUTE,
			~((left_val & 0x01)<<4 | (right_val & 0x01)));
	if (ret < 0)
		return ret;
@@ -276,23 +339,23 @@ static int pcm512x_set_reg_sub_switch(struct snd_kcontrol *kcontrol,
static const DECLARE_TLV_DB_SCALE(digital_tlv_sub, -10350, 50, 1);

static const struct snd_kcontrol_new allo_piano_controls[] = {
	SOC_ENUM_EXT("Subwoofer mode",
	SOC_ENUM_EXT("Subwoofer mode Route",
			allo_piano_mode_enum,
			snd_allo_piano_mode_get,
			snd_allo_piano_mode_put),

	SOC_ENUM_EXT("Lowpass", allo_piano_enum,
	SOC_ENUM_EXT("Lowpass Route", allo_piano_enum,
			snd_allo_piano_lowpass_get,
			snd_allo_piano_lowpass_put),

	SOC_DOUBLE_R_EXT_TLV("Subwoofer Digital Playback Volume",
	SOC_DOUBLE_R_EXT_TLV("Subwoofer Playback Volume",
			PCM512x_DIGITAL_VOLUME_2,
			PCM512x_DIGITAL_VOLUME_3, 0, 255, 1,
			pcm512x_get_reg_sub,
			pcm512x_set_reg_sub,
			digital_tlv_sub),

	SOC_DOUBLE_EXT("Subwoofer Digital Playback Switch",
	SOC_DOUBLE_EXT("Subwoofer Playback Switch",
			PCM512x_MUTE,
			PCM512x_RQML_SHIFT,
			PCM512x_RQMR_SHIFT, 1, 1,
@@ -302,11 +365,20 @@ static const struct snd_kcontrol_new allo_piano_controls[] = {

static int snd_allo_piano_dac_init(struct snd_soc_pcm_runtime *rtd)
{
	rtd_glb = rtd;
	struct snd_soc_card *card = rtd->card;
	struct glb_pool *glb_ptr;

	glb_ptr = kmalloc(sizeof(struct glb_pool), GFP_KERNEL);
	if (!glb_ptr)
		return -ENOMEM;

	memset(glb_ptr, 0x00, sizeof(glb_ptr));
	card->drvdata = glb_ptr;

	mutex_init(&glb_ptr->lock);

	if (digital_gain_0db_limit) {
		int ret;
		struct snd_soc_card *card = rtd->card;

		ret = snd_soc_limit_volume(card, "Digital Playback Volume",
					207);
@@ -318,7 +390,71 @@ static int snd_allo_piano_dac_init(struct snd_soc_pcm_runtime *rtd)
	return 0;
}

static int snd_allo_piano_dac_hw_params(struct snd_pcm_substream *substream,
static void snd_allo_piano_gpio_mute(struct snd_soc_card *card)
{
	if (mute_gpio[0])
		gpiod_set_value_cansleep(mute_gpio[0], 1);

	if (mute_gpio[1])
		gpiod_set_value_cansleep(mute_gpio[1], 1);
}

static void snd_allo_piano_gpio_unmute(struct snd_soc_card *card)
{
	if (mute_gpio[0])
		gpiod_set_value_cansleep(mute_gpio[0], 0);

	if (mute_gpio[1])
		gpiod_set_value_cansleep(mute_gpio[1], 0);
}

static int snd_allo_piano_set_bias_level(struct snd_soc_card *card,
	struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
{
	struct snd_soc_pcm_runtime *rtd;
	struct snd_soc_dai *codec_dai;

	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
	codec_dai = rtd->codec_dai;

	if (dapm->dev != codec_dai->dev)
		return 0;

	switch (level) {
	case SND_SOC_BIAS_PREPARE:
		if (dapm->bias_level != SND_SOC_BIAS_STANDBY)
			break;
		/* UNMUTE DAC */
		snd_allo_piano_gpio_unmute(card);
		break;

	case SND_SOC_BIAS_STANDBY:
		if (dapm->bias_level != SND_SOC_BIAS_PREPARE)
			break;
		/* MUTE DAC */
		snd_allo_piano_gpio_mute(card);
		break;

	default:
		break;
	}

	return 0;
}

static int snd_allo_piano_dac_startup(
	struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;

	snd_allo_piano_gpio_mute(card);

	return 0;
}

static int snd_allo_piano_dac_hw_params(
		struct snd_pcm_substream *substream,
		struct snd_pcm_hw_params *params)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
@@ -327,17 +463,49 @@ static int snd_allo_piano_dac_hw_params(struct snd_pcm_substream *substream,
		snd_pcm_format_physical_width(params_format(params));
	unsigned int rate = params_rate(params);
	struct snd_soc_card *card = rtd->card;
	int ret = 0;
	struct glb_pool *glb_ptr = card->drvdata;
	int ret = 0, val = 0, dac;

	for (dac = 0; (glb_mclk && dac < 2); dac++) {
		/* Configure the PLL clock reference for both the Codecs */
		val = snd_soc_read(rtd->codec_dais[dac]->codec,
					PCM512x_RATE_DET_4);
		if (val < 0) {
			dev_err(rtd->codec_dais[dac]->codec->dev,
					"Failed to read register PCM512x_RATE_DET_4\n");
			return val;
		}

		if (val & 0x40) {
			snd_soc_write(rtd->codec_dais[dac]->codec,
					PCM512x_PLL_REF,
					PCM512x_SREF_BCK);

			dev_info(rtd->codec_dais[dac]->codec->dev,
					"Setting BCLK as input clock & Enable PLL\n");
		} else {
			snd_soc_write(rtd->codec_dais[dac]->codec,
					PCM512x_PLL_EN,
					0x00);

			snd_soc_write(rtd->codec_dais[dac]->codec,
					PCM512x_PLL_REF,
					PCM512x_SREF_SCK);

			dev_info(rtd->codec_dais[dac]->codec->dev,
					"Setting SCLK as input clock & disabled PLL\n");
		}
	}

	rtd_glb = rtd;  /* TODO */
	if (digital_gain_0db_limit) {
		ret = snd_soc_limit_volume(card,
				"Subwoofer Digital Playback Volume", 207);
				"Subwoofer Playback Volume", 207);
		if (ret < 0)
			dev_warn(card->dev, "Failed to set volume limit: %d\n",
				ret);
	}
	ret = snd_allo_piano_dsp_program(rtd, set_mode, rate, set_lowpass);
	ret = snd_allo_piano_dsp_program(rtd, glb_ptr->set_mode, rate,
						glb_ptr->set_lowpass);
	if (ret < 0)
		return ret;

@@ -346,9 +514,21 @@ static int snd_allo_piano_dac_hw_params(struct snd_pcm_substream *substream,
	return ret;
}

static int snd_allo_piano_dac_prepare(
	struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;

	snd_allo_piano_gpio_unmute(card);
	return 0;
}

/* machine stream operations */
static struct snd_soc_ops snd_allo_piano_dac_ops = {
	.startup = snd_allo_piano_dac_startup,
	.hw_params = snd_allo_piano_dac_hw_params,
	.prepare = snd_allo_piano_dac_prepare,
};

static struct snd_soc_dai_link_component allo_piano_2_1_codecs[] = {
@@ -388,11 +568,11 @@ static struct snd_soc_card snd_allo_piano_dac = {

static int snd_allo_piano_dac_probe(struct platform_device *pdev)
{
	int ret = 0, i = 0;
	struct snd_soc_card *card = &snd_allo_piano_dac;
	int ret = 0, i = 0;

	card->dev = &pdev->dev;
	snd_allo_piano_dac.dev = &pdev->dev;
	platform_set_drvdata(pdev, &snd_allo_piano_dac);

	if (pdev->dev.of_node) {
		struct device_node *i2s_node;
@@ -413,6 +593,9 @@ static int snd_allo_piano_dac_probe(struct platform_device *pdev)
			!of_property_read_bool(pdev->dev.of_node,
						"allo,24db_digital_gain");

		glb_mclk = of_property_read_bool(pdev->dev.of_node,
						"allo,glb_mclk");

		allo_piano_2_1_codecs[0].of_node =
			of_parse_phandle(pdev->dev.of_node, "audio-codec", 0);
		if (!allo_piano_2_1_codecs[0].of_node) {
@@ -428,18 +611,51 @@ static int snd_allo_piano_dac_probe(struct platform_device *pdev)
				"Property 'audio-codec' missing or invalid\n");
			return -EINVAL;
		}

		mute_gpio[0] = devm_gpiod_get_optional(&pdev->dev, "mute1",
							GPIOD_OUT_LOW);
		if (IS_ERR(mute_gpio[0])) {
			ret = PTR_ERR(mute_gpio[0]);
			dev_err(&pdev->dev,
				"failed to get mute1 gpio6: %d\n", ret);
			return ret;
		}

	ret = snd_soc_register_card(&snd_allo_piano_dac);
	if (ret < 0)
		dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n",
			ret);
		mute_gpio[1] = devm_gpiod_get_optional(&pdev->dev, "mute2",
							GPIOD_OUT_LOW);
		if (IS_ERR(mute_gpio[1])) {
			ret = PTR_ERR(mute_gpio[1]);
			dev_err(&pdev->dev,
				"failed to get mute2 gpio25: %d\n", ret);
			return ret;
		}

		if (mute_gpio[0] && mute_gpio[1])
			snd_allo_piano_dac.set_bias_level =
				snd_allo_piano_set_bias_level;

		ret = snd_soc_register_card(&snd_allo_piano_dac);
		if (ret < 0) {
			dev_err(&pdev->dev,
				"snd_soc_register_card() failed: %d\n", ret);
			return ret;
		}

		if ((mute_gpio[0]) && (mute_gpio[1]))
			snd_allo_piano_gpio_mute(&snd_allo_piano_dac);

		return 0;
	}

	return -EINVAL;
}

static int snd_allo_piano_dac_remove(struct platform_device *pdev)
{
	struct snd_soc_card *card = platform_get_drvdata(pdev);

	kfree(&card->drvdata);
	snd_allo_piano_gpio_mute(&snd_allo_piano_dac);
	return snd_soc_unregister_card(&snd_allo_piano_dac);
}