blob: ff4884def584fe5771b5b03d0a757595df80e3ef [file] [log] [blame]
/*
* Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
*
* Based on imx-sgtl5000.c
* Copyright (C) 2012 Freescale Semiconductor, Inc.
* Copyright (C) 2012 Linaro Ltd.
*
* The code contained herein is licensed under the GNU General Public
* License. You may obtain a copy of the GNU General Public License
* Version 2 or later at the following locations:
*
* http://www.opensource.org/licenses/gpl-license.html
* http://www.gnu.org/copyleft/gpl.html
*/
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/i2c.h>
#include <linux/of_gpio.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/clk.h>
#include <linux/switch.h>
#include <sound/soc.h>
#include <sound/jack.h>
#include <sound/control.h>
#include <sound/pcm_params.h>
#include <sound/soc-dapm.h>
#include <linux/pinctrl/consumer.h>
#include "../codecs/wm8962.h"
#include "imx-audmux.h"
#define DAI_NAME_SIZE 32
struct imx_wm8962_data {
struct snd_soc_dai_link dai[3];
struct snd_soc_card card;
char codec_dai_name[DAI_NAME_SIZE];
char platform_name[DAI_NAME_SIZE];
unsigned int clk_frequency;
};
struct imx_priv {
int hp_gpio;
int hp_active_low;
int mic_gpio;
int mic_active_low;
bool amic_mono;
bool dmic_mono;
struct snd_soc_codec *codec;
struct platform_device *pdev;
struct snd_pcm_substream *first_stream;
struct snd_pcm_substream *second_stream;
struct snd_kcontrol *headphone_kctl;
struct snd_card *snd_card;
struct platform_device *asrc_pdev;
u32 asrc_rate;
u32 asrc_format;
struct switch_dev sdev;
};
static struct imx_priv card_priv;
#ifdef CONFIG_SND_SOC_IMX_WM8962_ANDROID
static int sample_rate = 44100;
static snd_pcm_format_t sample_format = SNDRV_PCM_FORMAT_S16_LE;
#endif
static struct snd_soc_jack imx_hp_jack;
static struct snd_soc_jack_pin imx_hp_jack_pins[] = {
{
.pin = "Headphone Jack",
.mask = SND_JACK_HEADPHONE,
},
};
static struct snd_soc_jack_gpio imx_hp_jack_gpio = {
.name = "headphone detect",
.report = SND_JACK_HEADPHONE,
.debounce_time = 250,
.invert = 0,
};
static struct snd_soc_jack imx_mic_jack;
static struct snd_soc_jack_pin imx_mic_jack_pins[] = {
{
.pin = "AMIC",
.mask = SND_JACK_MICROPHONE,
},
};
static struct snd_soc_jack_gpio imx_mic_jack_gpio = {
.name = "microphone detect",
.report = SND_JACK_MICROPHONE,
.debounce_time = 250,
.invert = 0,
};
static int hpjack_status_check(void)
{
struct imx_priv *priv = &card_priv;
struct platform_device *pdev = priv->pdev;
char *envp[3], *buf;
int hp_status, ret;
if (!gpio_is_valid(priv->hp_gpio))
return 0;
hp_status = gpio_get_value(priv->hp_gpio) ? 1 : 0;
buf = kmalloc(32, GFP_ATOMIC);
if (!buf) {
dev_err(&pdev->dev, "%s kmalloc failed\n", __func__);
return -ENOMEM;
}
if (hp_status != priv->hp_active_low) {
snprintf(buf, 32, "STATE=%d", 2);
#ifdef CONFIG_SWITCH
switch_set_state(&priv->sdev, 2);
#endif
snd_soc_dapm_disable_pin(&priv->codec->dapm, "Ext Spk");
ret = imx_hp_jack_gpio.report;
snd_kctl_jack_report(priv->snd_card, priv->headphone_kctl, 1);
} else {
snprintf(buf, 32, "STATE=%d", 0);
#ifdef CONFIG_SWITCH
switch_set_state(&priv->sdev, 0);
#endif
snd_soc_dapm_enable_pin(&priv->codec->dapm, "Ext Spk");
ret = 0;
snd_kctl_jack_report(priv->snd_card, priv->headphone_kctl, 0);
}
envp[0] = "NAME=headphone";
envp[1] = buf;
envp[2] = NULL;
kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp);
kfree(buf);
return ret;
}
static int micjack_status_check(void)
{
struct imx_priv *priv = &card_priv;
struct platform_device *pdev = priv->pdev;
char *envp[3], *buf;
int mic_status, ret;
if (!gpio_is_valid(priv->mic_gpio))
return 0;
mic_status = gpio_get_value(priv->mic_gpio) ? 1 : 0;
if ((mic_status != priv->mic_active_low && priv->amic_mono)
|| (mic_status == priv->mic_active_low && priv->dmic_mono))
snd_soc_update_bits(priv->codec, WM8962_THREED1,
WM8962_ADC_MONOMIX_MASK, WM8962_ADC_MONOMIX);
else
snd_soc_update_bits(priv->codec, WM8962_THREED1,
WM8962_ADC_MONOMIX_MASK, 0);
buf = kmalloc(32, GFP_ATOMIC);
if (!buf) {
dev_err(&pdev->dev, "%s kmalloc failed\n", __func__);
return -ENOMEM;
}
if (mic_status != priv->mic_active_low) {
snprintf(buf, 32, "STATE=%d", 2);
snd_soc_dapm_disable_pin(&priv->codec->dapm, "DMIC");
ret = imx_mic_jack_gpio.report;
} else {
snprintf(buf, 32, "STATE=%d", 0);
snd_soc_dapm_enable_pin(&priv->codec->dapm, "DMIC");
ret = 0;
}
envp[0] = "NAME=microphone";
envp[1] = buf;
envp[2] = NULL;
kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp);
kfree(buf);
return ret;
}
static const struct snd_soc_dapm_widget imx_wm8962_dapm_widgets[] = {
SND_SOC_DAPM_HP("Headphone Jack", NULL),
SND_SOC_DAPM_SPK("Ext Spk", NULL),
SND_SOC_DAPM_MIC("AMIC", NULL),
SND_SOC_DAPM_MIC("DMIC", NULL),
};
#ifdef CONFIG_SND_SOC_IMX_WM8962_ANDROID
static int imx_hifi_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_soc_dai *codec_dai = rtd->codec_dai;
struct imx_priv *priv = &card_priv;
struct device *dev = &priv->pdev->dev;
u32 dai_format;
int ret = 0;
sample_rate = params_rate(params);
sample_format = params_format(params);
dai_format = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
SND_SOC_DAIFMT_CBM_CFM;
/* set codec DAI configuration */
ret = snd_soc_dai_set_fmt(codec_dai, dai_format);
if (ret) {
dev_err(dev, "failed to set codec dai fmt: %d\n", ret);
return ret;
}
return 0;
}
static struct snd_soc_ops imx_hifi_ops = {
.hw_params = imx_hifi_hw_params,
};
static int imx_wm8962_set_bias_level(struct snd_soc_card *card,
struct snd_soc_dapm_context *dapm,
enum snd_soc_bias_level level)
{
struct snd_soc_dai *codec_dai = card->rtd[0].codec_dai;
struct imx_priv *priv = &card_priv;
struct imx_wm8962_data *data = snd_soc_card_get_drvdata(card);
struct device *dev = &priv->pdev->dev;
unsigned int pll_out;
int ret;
if (dapm->dev != codec_dai->dev)
return 0;
switch (level) {
case SND_SOC_BIAS_PREPARE:
if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
if (sample_format == SNDRV_PCM_FORMAT_S24_LE)
pll_out = sample_rate * 384;
else
pll_out = sample_rate * 256;
ret = snd_soc_dai_set_pll(codec_dai, WM8962_FLL,
WM8962_FLL_MCLK, data->clk_frequency,
pll_out);
if (ret < 0) {
dev_err(dev, "failed to start FLL: %d\n", ret);
return ret;
}
ret = snd_soc_dai_set_sysclk(codec_dai,
WM8962_SYSCLK_FLL, pll_out,
SND_SOC_CLOCK_IN);
if (ret < 0) {
dev_err(dev, "failed to set SYSCLK: %d\n", ret);
return ret;
}
}
break;
case SND_SOC_BIAS_STANDBY:
if (dapm->bias_level == SND_SOC_BIAS_PREPARE) {
ret = snd_soc_dai_set_sysclk(codec_dai,
WM8962_SYSCLK_MCLK, data->clk_frequency,
SND_SOC_CLOCK_IN);
if (ret < 0) {
dev_err(dev,
"failed to switch away from FLL: %d\n",
ret);
return ret;
}
ret = snd_soc_dai_set_pll(codec_dai, WM8962_FLL,
0, 0, 0);
if (ret < 0) {
dev_err(dev, "failed to stop FLL: %d\n", ret);
return ret;
}
}
break;
default:
break;
}
return 0;
}
#else
static int imx_hifi_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_soc_dai *codec_dai = rtd->codec_dai;
struct imx_priv *priv = &card_priv;
struct device *dev = &priv->pdev->dev;
struct snd_soc_card *card = platform_get_drvdata(priv->pdev);
struct imx_wm8962_data *data = snd_soc_card_get_drvdata(card);
unsigned int sample_rate = params_rate(params);
snd_pcm_format_t sample_format = params_format(params);
u32 dai_format, pll_out;
int ret = 0;
if (!priv->first_stream) {
priv->first_stream = substream;
} else {
priv->second_stream = substream;
/* We suppose the two substream are using same params */
return 0;
}
dai_format = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
SND_SOC_DAIFMT_CBM_CFM;
/* set codec DAI configuration */
ret = snd_soc_dai_set_fmt(codec_dai, dai_format);
if (ret) {
dev_err(dev, "failed to set codec dai fmt: %d\n", ret);
return ret;
}
if (sample_format == SNDRV_PCM_FORMAT_S24_LE)
pll_out = sample_rate * 384;
else
pll_out = sample_rate * 256;
ret = snd_soc_dai_set_pll(codec_dai, WM8962_FLL, WM8962_FLL_MCLK,
data->clk_frequency, pll_out);
if (ret) {
dev_err(dev, "failed to start FLL: %d\n", ret);
return ret;
}
ret = snd_soc_dai_set_sysclk(codec_dai, WM8962_SYSCLK_FLL,
pll_out, SND_SOC_CLOCK_IN);
if (ret) {
dev_err(dev, "failed to set SYSCLK: %d\n", ret);
return ret;
}
return 0;
}
static int imx_hifi_hw_free(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_soc_dai *codec_dai = rtd->codec_dai;
struct imx_priv *priv = &card_priv;
struct device *dev = &priv->pdev->dev;
int ret;
/* We don't need to handle anything if there's no substream running */
if (!priv->first_stream)
return 0;
if (priv->first_stream == substream)
priv->first_stream = priv->second_stream;
priv->second_stream = NULL;
if (!priv->first_stream) {
/*
* Continuously setting FLL would cause playback distortion.
* We can fix it just by mute codec after playback.
*/
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
snd_soc_dai_digital_mute(codec_dai, 1, substream->stream);
/*
* WM8962 doesn't allow us to continuously setting FLL,
* So we set MCLK as sysclk once, which'd remove the limitation.
*/
ret = snd_soc_dai_set_sysclk(codec_dai, WM8962_SYSCLK_MCLK,
0, SND_SOC_CLOCK_IN);
if (ret < 0) {
dev_err(dev, "failed to switch away from FLL: %d\n", ret);
return ret;
}
/* Disable FLL and let codec do pm_runtime_put() */
ret = snd_soc_dai_set_pll(codec_dai, WM8962_FLL,
WM8962_FLL_MCLK, 0, 0);
if (ret < 0) {
dev_err(dev, "failed to stop FLL: %d\n", ret);
return ret;
}
}
return 0;
}
static struct snd_soc_ops imx_hifi_ops = {
.hw_params = imx_hifi_hw_params,
.hw_free = imx_hifi_hw_free,
};
#endif /* CONFIG_SND_SOC_IMX_WM8962_ANDROID */
static int imx_wm8962_gpio_init(struct snd_soc_card *card)
{
struct snd_soc_dai *codec_dai = card->rtd[0].codec_dai;
struct snd_soc_codec *codec = codec_dai->codec;
struct imx_priv *priv = &card_priv;
priv->codec = codec;
if (gpio_is_valid(priv->hp_gpio)) {
imx_hp_jack_gpio.gpio = priv->hp_gpio;
imx_hp_jack_gpio.jack_status_check = hpjack_status_check;
snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE, &imx_hp_jack);
snd_soc_jack_add_pins(&imx_hp_jack,
ARRAY_SIZE(imx_hp_jack_pins), imx_hp_jack_pins);
snd_soc_jack_add_gpios(&imx_hp_jack, 1, &imx_hp_jack_gpio);
}
if (gpio_is_valid(priv->mic_gpio)) {
imx_mic_jack_gpio.gpio = priv->mic_gpio;
imx_mic_jack_gpio.jack_status_check = micjack_status_check;
snd_soc_jack_new(codec, "AMIC", SND_JACK_MICROPHONE, &imx_mic_jack);
snd_soc_jack_add_pins(&imx_mic_jack,
ARRAY_SIZE(imx_mic_jack_pins), imx_mic_jack_pins);
snd_soc_jack_add_gpios(&imx_mic_jack, 1, &imx_mic_jack_gpio);
} else if (priv->amic_mono || priv->dmic_mono) {
/*
* Permanent set monomix bit if only one microphone
* is present on the board while it needs monomix.
*/
snd_soc_update_bits(priv->codec, WM8962_THREED1,
WM8962_ADC_MONOMIX_MASK, WM8962_ADC_MONOMIX);
}
return 0;
}
static ssize_t show_headphone(struct device_driver *dev, char *buf)
{
struct imx_priv *priv = &card_priv;
int hp_status;
if (!gpio_is_valid(priv->hp_gpio)) {
strcpy(buf, "no detect gpio connected\n");
return strlen(buf);
}
/* Check if headphone is plugged in */
hp_status = gpio_get_value(priv->hp_gpio) ? 1 : 0;
if (hp_status != priv->hp_active_low)
strcpy(buf, "headphone\n");
else
strcpy(buf, "speaker\n");
return strlen(buf);
}
static DRIVER_ATTR(headphone, S_IRUGO | S_IWUSR, show_headphone, NULL);
static ssize_t show_mic(struct device_driver *dev, char *buf)
{
struct imx_priv *priv = &card_priv;
int mic_status;
if (!gpio_is_valid(priv->mic_gpio)) {
strcpy(buf, "no detect gpio connected\n");
return strlen(buf);
}
/* Check if analog microphone is plugged in */
mic_status = gpio_get_value(priv->mic_gpio) ? 1 : 0;
if (mic_status != priv->mic_active_low)
strcpy(buf, "amic\n");
else
strcpy(buf, "dmic\n");
return strlen(buf);
}
static DRIVER_ATTR(microphone, S_IRUGO | S_IWUSR, show_mic, NULL);
static int imx_wm8962_late_probe(struct snd_soc_card *card)
{
struct snd_soc_dai *codec_dai = card->rtd[0].codec_dai;
struct imx_priv *priv = &card_priv;
struct imx_wm8962_data *data = snd_soc_card_get_drvdata(card);
struct device *dev = &priv->pdev->dev;
int ret;
ret = snd_soc_dai_set_sysclk(codec_dai, WM8962_SYSCLK_MCLK,
data->clk_frequency, SND_SOC_CLOCK_IN);
if (ret < 0)
dev_err(dev, "failed to set sysclk in %s\n", __func__);
return ret;
}
static int be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
struct snd_pcm_hw_params *params) {
struct imx_priv *priv = &card_priv;
struct snd_interval *rate;
struct snd_mask *mask;
if (!priv->asrc_pdev)
return -EINVAL;
rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
rate->max = rate->min = priv->asrc_rate;
mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
snd_mask_none(mask);
snd_mask_set(mask, priv->asrc_format);
return 0;
}
static int imx_wm8962_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct device_node *cpu_np, *codec_np;
struct platform_device *cpu_pdev;
struct imx_priv *priv = &card_priv;
struct i2c_client *codec_dev;
struct imx_wm8962_data *data;
struct clk *codec_clk = NULL;
int int_port, ext_port;
int ret;
struct platform_device *asrc_pdev = NULL;
struct device_node *asrc_np;
u32 width;
priv->pdev = pdev;
priv->asrc_pdev = NULL;
cpu_np = of_parse_phandle(pdev->dev.of_node, "cpu-dai", 0);
if (!cpu_np) {
dev_err(&pdev->dev, "cpu dai phandle missing or invalid\n");
ret = -EINVAL;
goto fail;
}
if (!strstr(cpu_np->name, "ssi"))
goto audmux_bypass;
ret = of_property_read_u32(np, "mux-int-port", &int_port);
if (ret) {
dev_err(&pdev->dev, "mux-int-port missing or invalid\n");
return ret;
}
ret = of_property_read_u32(np, "mux-ext-port", &ext_port);
if (ret) {
dev_err(&pdev->dev, "mux-ext-port missing or invalid\n");
return ret;
}
/*
* The port numbering in the hardware manual starts at 1, while
* the audmux API expects it starts at 0.
*/
int_port--;
ext_port--;
ret = imx_audmux_v2_configure_port(int_port,
IMX_AUDMUX_V2_PTCR_SYN |
IMX_AUDMUX_V2_PTCR_TFSEL(ext_port) |
IMX_AUDMUX_V2_PTCR_TCSEL(ext_port) |
IMX_AUDMUX_V2_PTCR_TFSDIR |
IMX_AUDMUX_V2_PTCR_TCLKDIR,
IMX_AUDMUX_V2_PDCR_RXDSEL(ext_port));
if (ret) {
dev_err(&pdev->dev, "audmux internal port setup failed\n");
return ret;
}
ret = imx_audmux_v2_configure_port(ext_port,
IMX_AUDMUX_V2_PTCR_SYN,
IMX_AUDMUX_V2_PDCR_RXDSEL(int_port));
if (ret) {
dev_err(&pdev->dev, "audmux external port setup failed\n");
return ret;
}
audmux_bypass:
codec_np = of_parse_phandle(pdev->dev.of_node, "audio-codec", 0);
if (!codec_np) {
dev_err(&pdev->dev, "phandle missing or invalid\n");
ret = -EINVAL;
goto fail;
}
cpu_pdev = of_find_device_by_node(cpu_np);
if (!cpu_pdev) {
dev_err(&pdev->dev, "failed to find SSI platform device\n");
ret = -EINVAL;
goto fail;
}
codec_dev = of_find_i2c_device_by_node(codec_np);
if (!codec_dev || !codec_dev->dev.driver) {
dev_err(&pdev->dev, "failed to find codec platform device\n");
ret = -EINVAL;
goto fail;
}
asrc_np = of_parse_phandle(pdev->dev.of_node, "asrc-controller", 0);
if (asrc_np) {
asrc_pdev = of_find_device_by_node(asrc_np);
priv->asrc_pdev = asrc_pdev;
}
priv->first_stream = NULL;
priv->second_stream = NULL;
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
if (!data) {
ret = -ENOMEM;
goto fail;
}
codec_clk = devm_clk_get(&codec_dev->dev, NULL);
if (IS_ERR(codec_clk)) {
ret = PTR_ERR(codec_clk);
dev_err(&codec_dev->dev, "failed to get codec clk: %d\n", ret);
goto fail;
}
data->clk_frequency = clk_get_rate(codec_clk);
priv->amic_mono = of_property_read_bool(codec_np, "amic-mono");
priv->dmic_mono = of_property_read_bool(codec_np, "dmic-mono");
priv->hp_gpio = of_get_named_gpio_flags(np, "hp-det-gpios", 0,
(enum of_gpio_flags *)&priv->hp_active_low);
priv->mic_gpio = of_get_named_gpio_flags(np, "mic-det-gpios", 0,
(enum of_gpio_flags *)&priv->mic_active_low);
data->dai[0].name = "HiFi";
data->dai[0].stream_name = "HiFi";
data->dai[0].codec_dai_name = "wm8962";
data->dai[0].codec_of_node = codec_np;
data->dai[0].cpu_dai_name = dev_name(&cpu_pdev->dev);
data->dai[0].platform_of_node = cpu_np;
data->dai[0].ops = &imx_hifi_ops;
data->dai[0].dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
SND_SOC_DAIFMT_CBM_CFM;
data->card.num_links = 1;
if (asrc_pdev) {
data->dai[0].ignore_pmdown_time = 1;
data->dai[1].name = "HiFi-ASRC-FE";
data->dai[1].stream_name = "HiFi-ASRC-FE";
data->dai[1].codec_name = "snd-soc-dummy";
data->dai[1].codec_dai_name = "snd-soc-dummy-dai";
data->dai[1].cpu_of_node = asrc_np;
data->dai[1].platform_of_node = asrc_np;
data->dai[1].dynamic = 1;
data->dai[1].ignore_pmdown_time = 1;
data->dai[1].dpcm_playback = 1;
data->dai[1].dpcm_capture = 1;
data->dai[2].name = "HiFi-ASRC-BE";
data->dai[2].stream_name = "HiFi-ASRC-BE";
data->dai[2].codec_dai_name = "wm8962";
data->dai[2].codec_of_node = codec_np;
data->dai[2].cpu_dai_name = dev_name(&cpu_pdev->dev);
data->dai[2].platform_name = "snd-soc-dummy";
data->dai[2].ops = &imx_hifi_ops;
data->dai[2].be_hw_params_fixup = be_hw_params_fixup;
data->dai[2].no_pcm = 1;
data->dai[2].ignore_pmdown_time = 1;
data->dai[2].dpcm_playback = 1;
data->dai[2].dpcm_capture = 1;
data->card.num_links = 3;
ret = of_property_read_u32(asrc_np, "fsl,asrc-rate",
&priv->asrc_rate);
if (ret) {
dev_err(&pdev->dev, "failed to get output rate\n");
ret = -EINVAL;
goto fail;
}
ret = of_property_read_u32(asrc_np, "fsl,asrc-width", &width);
if (ret) {
dev_err(&pdev->dev, "failed to get output rate\n");
ret = -EINVAL;
goto fail;
}
if (width == 24)
priv->asrc_format = SNDRV_PCM_FORMAT_S24_LE;
else
priv->asrc_format = SNDRV_PCM_FORMAT_S16_LE;
}
data->card.dev = &pdev->dev;
ret = snd_soc_of_parse_card_name(&data->card, "model");
if (ret)
goto fail;
ret = snd_soc_of_parse_audio_routing(&data->card, "audio-routing");
if (ret)
goto fail;
data->card.dai_link = data->dai;
data->card.dapm_widgets = imx_wm8962_dapm_widgets;
data->card.num_dapm_widgets = ARRAY_SIZE(imx_wm8962_dapm_widgets);
data->card.late_probe = imx_wm8962_late_probe;
#ifdef CONFIG_SND_SOC_IMX_WM8962_ANDROID
data->card.set_bias_level = imx_wm8962_set_bias_level;
#endif
platform_set_drvdata(pdev, &data->card);
snd_soc_card_set_drvdata(&data->card, data);
priv->sdev.name = "h2w";
#ifdef CONFIG_SWITCH
ret = switch_dev_register(&priv->sdev);
#endif
if (ret < 0) {
ret = -EINVAL;
goto fail;
}
ret = devm_snd_soc_register_card(&pdev->dev, &data->card);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret);
goto fail;
}
priv->snd_card = data->card.snd_card;
priv->headphone_kctl = snd_kctl_jack_new("Headphone", 0, NULL);
ret = snd_ctl_add(data->card.snd_card, priv->headphone_kctl);
if (ret)
goto fail;
imx_wm8962_gpio_init(&data->card);
if (gpio_is_valid(priv->hp_gpio)) {
ret = driver_create_file(pdev->dev.driver, &driver_attr_headphone);
if (ret) {
dev_err(&pdev->dev, "create hp attr failed (%d)\n", ret);
goto fail_hp;
}
}
if (gpio_is_valid(priv->mic_gpio)) {
ret = driver_create_file(pdev->dev.driver, &driver_attr_microphone);
if (ret) {
dev_err(&pdev->dev, "create mic attr failed (%d)\n", ret);
goto fail_mic;
}
}
goto fail;
fail_mic:
driver_remove_file(pdev->dev.driver, &driver_attr_headphone);
fail_hp:
fail:
if (cpu_np)
of_node_put(cpu_np);
if (codec_np)
of_node_put(codec_np);
return ret;
}
static int imx_wm8962_remove(struct platform_device *pdev)
{
struct snd_soc_card *card = platform_get_drvdata(pdev);
struct imx_priv *priv = &card_priv;
driver_remove_file(pdev->dev.driver, &driver_attr_microphone);
driver_remove_file(pdev->dev.driver, &driver_attr_headphone);
#ifdef CONFIG_SWITCH
switch_dev_unregister(&priv->sdev);
#endif
return 0;
}
static const struct of_device_id imx_wm8962_dt_ids[] = {
{ .compatible = "fsl,imx-audio-wm8962", },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, imx_wm8962_dt_ids);
static struct platform_driver imx_wm8962_driver = {
.driver = {
.name = "imx-wm8962",
.owner = THIS_MODULE,
.pm = &snd_soc_pm_ops,
.of_match_table = imx_wm8962_dt_ids,
},
.probe = imx_wm8962_probe,
.remove = imx_wm8962_remove,
};
module_platform_driver(imx_wm8962_driver);
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("Freescale i.MX WM8962 ASoC machine driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:imx-wm8962");