2011-01-08 08:36:16 +03:00
|
|
|
/*
|
2011-04-12 21:40:36 +04:00
|
|
|
* tegra_wm8903.c - Tegra machine ASoC driver for boards using WM8903 codec.
|
2011-01-08 08:36:16 +03:00
|
|
|
*
|
|
|
|
* Author: Stephen Warren <swarren@nvidia.com>
|
2012-03-21 00:55:49 +04:00
|
|
|
* Copyright (C) 2010-2012 - NVIDIA, Inc.
|
2011-01-08 08:36:16 +03:00
|
|
|
*
|
|
|
|
* Based on code copyright/by:
|
|
|
|
*
|
|
|
|
* (c) 2009, 2010 Nvidia Graphics Pvt. Ltd.
|
|
|
|
*
|
|
|
|
* Copyright 2007 Wolfson Microelectronics PLC.
|
|
|
|
* Author: Graeme Gregory
|
|
|
|
* graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
|
|
* 02110-1301 USA
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
2011-01-29 00:26:36 +03:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/slab.h>
|
2011-01-29 00:26:37 +03:00
|
|
|
#include <linux/gpio.h>
|
2011-12-13 02:55:36 +04:00
|
|
|
#include <linux/of_gpio.h>
|
2011-01-29 00:26:37 +03:00
|
|
|
|
2011-01-08 08:36:16 +03:00
|
|
|
#include <sound/core.h>
|
2011-02-03 23:56:13 +03:00
|
|
|
#include <sound/jack.h>
|
2011-01-08 08:36:16 +03:00
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include <sound/soc.h>
|
2012-09-05 20:27:14 +04:00
|
|
|
#include <sound/tegra_wm8903.h>
|
2011-01-08 08:36:16 +03:00
|
|
|
|
2011-02-11 01:37:16 +03:00
|
|
|
#include "../codecs/wm8903.h"
|
|
|
|
|
2011-01-08 08:36:16 +03:00
|
|
|
#include "tegra_asoc_utils.h"
|
|
|
|
|
2011-04-12 21:29:00 +04:00
|
|
|
#define DRV_NAME "tegra-snd-wm8903"
|
2011-01-08 08:36:16 +03:00
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
struct tegra_wm8903 {
|
2011-12-13 02:55:36 +04:00
|
|
|
struct tegra_wm8903_platform_data pdata;
|
2011-01-29 00:26:40 +03:00
|
|
|
struct tegra_asoc_utils_data util_data;
|
2011-01-29 00:26:36 +03:00
|
|
|
};
|
2011-01-08 08:36:16 +03:00
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static int tegra_wm8903_hw_params(struct snd_pcm_substream *substream,
|
2011-01-08 08:36:16 +03:00
|
|
|
struct snd_pcm_hw_params *params)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = substream->private_data;
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
2012-06-07 03:15:49 +04:00
|
|
|
struct snd_soc_codec *codec = codec_dai->codec;
|
2011-01-29 00:26:39 +03:00
|
|
|
struct snd_soc_card *card = codec->card;
|
2011-04-12 21:40:36 +04:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
2011-04-20 01:25:09 +04:00
|
|
|
int srate, mclk;
|
2011-01-08 08:36:16 +03:00
|
|
|
int err;
|
|
|
|
|
|
|
|
srate = params_rate(params);
|
|
|
|
switch (srate) {
|
|
|
|
case 64000:
|
|
|
|
case 88200:
|
|
|
|
case 96000:
|
|
|
|
mclk = 128 * srate;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mclk = 256 * srate;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FIXME: Codec only requires >= 3MHz if OSR==0 */
|
|
|
|
while (mclk < 6000000)
|
|
|
|
mclk *= 2;
|
|
|
|
|
2011-04-20 01:25:09 +04:00
|
|
|
err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
|
2011-01-08 08:36:16 +03:00
|
|
|
if (err < 0) {
|
2011-01-29 00:26:39 +03:00
|
|
|
dev_err(card->dev, "Can't configure clocks\n");
|
2011-01-08 08:36:16 +03:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-04-20 01:25:09 +04:00
|
|
|
err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
|
|
|
|
SND_SOC_CLOCK_IN);
|
|
|
|
if (err < 0) {
|
|
|
|
dev_err(card->dev, "codec_dai clock not set\n");
|
|
|
|
return err;
|
2011-01-08 08:36:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct snd_soc_ops tegra_wm8903_ops = {
|
|
|
|
.hw_params = tegra_wm8903_hw_params,
|
2011-01-08 08:36:16 +03:00
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct snd_soc_jack tegra_wm8903_hp_jack;
|
2011-02-03 23:56:13 +03:00
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct snd_soc_jack_pin tegra_wm8903_hp_jack_pins[] = {
|
2011-02-03 23:56:13 +03:00
|
|
|
{
|
|
|
|
.pin = "Headphone Jack",
|
|
|
|
.mask = SND_JACK_HEADPHONE,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:38 +04:00
|
|
|
static struct snd_soc_jack_gpio tegra_wm8903_hp_jack_gpio = {
|
|
|
|
.name = "headphone detect",
|
|
|
|
.report = SND_JACK_HEADPHONE,
|
|
|
|
.debounce_time = 150,
|
|
|
|
.invert = 1,
|
2011-02-03 23:56:13 +03:00
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct snd_soc_jack tegra_wm8903_mic_jack;
|
2011-02-11 01:37:16 +03:00
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct snd_soc_jack_pin tegra_wm8903_mic_jack_pins[] = {
|
2011-02-11 01:37:16 +03:00
|
|
|
{
|
|
|
|
.pin = "Mic Jack",
|
|
|
|
.mask = SND_JACK_MICROPHONE,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static int tegra_wm8903_event_int_spk(struct snd_soc_dapm_widget *w,
|
2011-01-29 00:26:37 +03:00
|
|
|
struct snd_kcontrol *k, int event)
|
|
|
|
{
|
2011-04-20 01:25:10 +04:00
|
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
|
|
|
struct snd_soc_card *card = dapm->card;
|
2011-04-12 21:40:36 +04:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
2011-12-13 02:55:36 +04:00
|
|
|
struct tegra_wm8903_platform_data *pdata = &machine->pdata;
|
2011-01-29 00:26:37 +03:00
|
|
|
|
2012-05-23 02:08:53 +04:00
|
|
|
if (!gpio_is_valid(pdata->gpio_spkr_en))
|
2011-04-12 21:40:39 +04:00
|
|
|
return 0;
|
|
|
|
|
2011-01-29 00:26:37 +03:00
|
|
|
gpio_set_value_cansleep(pdata->gpio_spkr_en,
|
2011-01-31 21:00:17 +03:00
|
|
|
SND_SOC_DAPM_EVENT_ON(event));
|
2011-01-29 00:26:37 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 21:40:39 +04:00
|
|
|
static int tegra_wm8903_event_hp(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol *k, int event)
|
|
|
|
{
|
2011-04-20 01:25:10 +04:00
|
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
|
|
|
struct snd_soc_card *card = dapm->card;
|
2011-04-12 21:40:39 +04:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
2011-12-13 02:55:36 +04:00
|
|
|
struct tegra_wm8903_platform_data *pdata = &machine->pdata;
|
2011-04-12 21:40:39 +04:00
|
|
|
|
2012-05-23 02:08:53 +04:00
|
|
|
if (!gpio_is_valid(pdata->gpio_hp_mute))
|
2011-04-12 21:40:39 +04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
gpio_set_value_cansleep(pdata->gpio_hp_mute,
|
|
|
|
!SND_SOC_DAPM_EVENT_ON(event));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static const struct snd_soc_dapm_widget tegra_wm8903_dapm_widgets[] = {
|
|
|
|
SND_SOC_DAPM_SPK("Int Spk", tegra_wm8903_event_int_spk),
|
2011-04-12 21:40:39 +04:00
|
|
|
SND_SOC_DAPM_HP("Headphone Jack", tegra_wm8903_event_hp),
|
2011-01-14 01:22:08 +03:00
|
|
|
SND_SOC_DAPM_MIC("Mic Jack", NULL),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct snd_soc_dapm_route harmony_audio_map[] = {
|
|
|
|
{"Headphone Jack", NULL, "HPOUTR"},
|
|
|
|
{"Headphone Jack", NULL, "HPOUTL"},
|
2011-01-29 00:26:37 +03:00
|
|
|
{"Int Spk", NULL, "ROP"},
|
|
|
|
{"Int Spk", NULL, "RON"},
|
|
|
|
{"Int Spk", NULL, "LOP"},
|
|
|
|
{"Int Spk", NULL, "LON"},
|
2011-11-27 16:20:08 +04:00
|
|
|
{"Mic Jack", NULL, "MICBIAS"},
|
|
|
|
{"IN1L", NULL, "Mic Jack"},
|
2011-01-14 01:22:08 +03:00
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static const struct snd_kcontrol_new tegra_wm8903_controls[] = {
|
2011-02-03 23:56:14 +03:00
|
|
|
SOC_DAPM_PIN_SWITCH("Int Spk"),
|
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd)
|
2011-01-14 01:22:08 +03:00
|
|
|
{
|
2012-06-07 03:15:49 +04:00
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
struct snd_soc_codec *codec = codec_dai->codec;
|
2011-01-14 01:22:08 +03:00
|
|
|
struct snd_soc_dapm_context *dapm = &codec->dapm;
|
2011-01-29 00:26:37 +03:00
|
|
|
struct snd_soc_card *card = codec->card;
|
2011-04-12 21:40:36 +04:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
2011-12-13 02:55:36 +04:00
|
|
|
struct tegra_wm8903_platform_data *pdata = &machine->pdata;
|
2011-02-11 01:37:18 +03:00
|
|
|
|
2011-04-12 21:40:39 +04:00
|
|
|
if (gpio_is_valid(pdata->gpio_hp_det)) {
|
|
|
|
tegra_wm8903_hp_jack_gpio.gpio = pdata->gpio_hp_det;
|
|
|
|
snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
|
|
|
|
&tegra_wm8903_hp_jack);
|
|
|
|
snd_soc_jack_add_pins(&tegra_wm8903_hp_jack,
|
|
|
|
ARRAY_SIZE(tegra_wm8903_hp_jack_pins),
|
|
|
|
tegra_wm8903_hp_jack_pins);
|
|
|
|
snd_soc_jack_add_gpios(&tegra_wm8903_hp_jack,
|
|
|
|
1,
|
|
|
|
&tegra_wm8903_hp_jack_gpio);
|
|
|
|
}
|
2011-02-03 23:56:13 +03:00
|
|
|
|
2011-02-11 01:37:16 +03:00
|
|
|
snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,
|
2011-04-12 21:40:36 +04:00
|
|
|
&tegra_wm8903_mic_jack);
|
|
|
|
snd_soc_jack_add_pins(&tegra_wm8903_mic_jack,
|
|
|
|
ARRAY_SIZE(tegra_wm8903_mic_jack_pins),
|
|
|
|
tegra_wm8903_mic_jack_pins);
|
|
|
|
wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE,
|
|
|
|
0);
|
2011-02-11 01:37:16 +03:00
|
|
|
|
2011-11-27 16:20:08 +04:00
|
|
|
snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
|
2011-02-11 01:37:16 +03:00
|
|
|
|
2011-01-14 01:22:08 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-11 21:27:19 +04:00
|
|
|
static int tegra_wm8903_remove(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &(card->rtd[0]);
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
struct snd_soc_codec *codec = codec_dai->codec;
|
|
|
|
|
|
|
|
wm8903_mic_detect(codec, NULL, 0, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct snd_soc_dai_link tegra_wm8903_dai = {
|
2011-01-08 08:36:16 +03:00
|
|
|
.name = "WM8903",
|
|
|
|
.stream_name = "WM8903 PCM",
|
2011-02-09 16:47:06 +03:00
|
|
|
.codec_name = "wm8903.0-001a",
|
2012-04-06 20:30:52 +04:00
|
|
|
.platform_name = "tegra20-i2s.0",
|
|
|
|
.cpu_dai_name = "tegra20-i2s.0",
|
2011-01-08 08:36:16 +03:00
|
|
|
.codec_dai_name = "wm8903-hifi",
|
2011-04-12 21:40:36 +04:00
|
|
|
.init = tegra_wm8903_init,
|
|
|
|
.ops = &tegra_wm8903_ops,
|
2012-06-07 03:15:48 +04:00
|
|
|
.dai_fmt = SND_SOC_DAIFMT_I2S |
|
|
|
|
SND_SOC_DAIFMT_NB_NF |
|
|
|
|
SND_SOC_DAIFMT_CBS_CFS,
|
2011-01-08 08:36:16 +03:00
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct snd_soc_card snd_soc_tegra_wm8903 = {
|
|
|
|
.name = "tegra-wm8903",
|
2011-12-22 17:23:01 +04:00
|
|
|
.owner = THIS_MODULE,
|
2011-04-12 21:40:36 +04:00
|
|
|
.dai_link = &tegra_wm8903_dai,
|
2011-01-08 08:36:16 +03:00
|
|
|
.num_links = 1,
|
2011-04-20 01:25:12 +04:00
|
|
|
|
2012-06-11 21:27:19 +04:00
|
|
|
.remove = tegra_wm8903_remove,
|
|
|
|
|
2011-04-20 01:25:12 +04:00
|
|
|
.controls = tegra_wm8903_controls,
|
|
|
|
.num_controls = ARRAY_SIZE(tegra_wm8903_controls),
|
|
|
|
.dapm_widgets = tegra_wm8903_dapm_widgets,
|
|
|
|
.num_dapm_widgets = ARRAY_SIZE(tegra_wm8903_dapm_widgets),
|
2011-11-23 23:42:05 +04:00
|
|
|
.fully_routed = true,
|
2011-01-08 08:36:16 +03:00
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static __devinit int tegra_wm8903_driver_probe(struct platform_device *pdev)
|
2011-01-08 08:36:16 +03:00
|
|
|
{
|
2012-05-23 02:08:54 +04:00
|
|
|
struct device_node *np = pdev->dev.of_node;
|
2011-04-12 21:40:36 +04:00
|
|
|
struct snd_soc_card *card = &snd_soc_tegra_wm8903;
|
|
|
|
struct tegra_wm8903 *machine;
|
2012-05-23 02:08:54 +04:00
|
|
|
struct tegra_wm8903_platform_data *pdata;
|
2011-01-08 08:36:16 +03:00
|
|
|
int ret;
|
|
|
|
|
2011-12-13 02:55:36 +04:00
|
|
|
if (!pdev->dev.platform_data && !pdev->dev.of_node) {
|
2011-04-12 21:40:39 +04:00
|
|
|
dev_err(&pdev->dev, "No platform data supplied\n");
|
2011-01-29 00:26:37 +03:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-11-23 05:21:20 +04:00
|
|
|
machine = devm_kzalloc(&pdev->dev, sizeof(struct tegra_wm8903),
|
|
|
|
GFP_KERNEL);
|
2011-04-12 21:40:36 +04:00
|
|
|
if (!machine) {
|
|
|
|
dev_err(&pdev->dev, "Can't allocate tegra_wm8903 struct\n");
|
2011-11-23 05:21:20 +04:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
2011-01-08 08:36:16 +03:00
|
|
|
}
|
2012-05-23 02:08:54 +04:00
|
|
|
pdata = &machine->pdata;
|
2011-01-08 08:36:16 +03:00
|
|
|
|
2011-01-29 00:26:36 +03:00
|
|
|
card->dev = &pdev->dev;
|
|
|
|
platform_set_drvdata(pdev, card);
|
2011-04-12 21:40:36 +04:00
|
|
|
snd_soc_card_set_drvdata(card, machine);
|
2011-01-08 08:36:16 +03:00
|
|
|
|
2012-05-23 02:08:54 +04:00
|
|
|
if (pdev->dev.platform_data) {
|
|
|
|
memcpy(pdata, card->dev->platform_data, sizeof(*pdata));
|
|
|
|
} else if (np) {
|
|
|
|
pdata->gpio_spkr_en = of_get_named_gpio(np,
|
|
|
|
"nvidia,spkr-en-gpios", 0);
|
2012-06-18 20:42:21 +04:00
|
|
|
if (pdata->gpio_spkr_en == -EPROBE_DEFER)
|
2012-05-23 02:08:54 +04:00
|
|
|
return -EPROBE_DEFER;
|
|
|
|
|
|
|
|
pdata->gpio_hp_mute = of_get_named_gpio(np,
|
|
|
|
"nvidia,hp-mute-gpios", 0);
|
2012-06-18 20:42:21 +04:00
|
|
|
if (pdata->gpio_hp_mute == -EPROBE_DEFER)
|
2012-05-23 02:08:54 +04:00
|
|
|
return -EPROBE_DEFER;
|
|
|
|
|
|
|
|
pdata->gpio_hp_det = of_get_named_gpio(np,
|
|
|
|
"nvidia,hp-det-gpios", 0);
|
2012-06-18 20:42:21 +04:00
|
|
|
if (pdata->gpio_hp_det == -EPROBE_DEFER)
|
2012-05-23 02:08:54 +04:00
|
|
|
return -EPROBE_DEFER;
|
|
|
|
|
|
|
|
pdata->gpio_int_mic_en = of_get_named_gpio(np,
|
|
|
|
"nvidia,int-mic-en-gpios", 0);
|
2012-06-18 20:42:21 +04:00
|
|
|
if (pdata->gpio_int_mic_en == -EPROBE_DEFER)
|
2012-05-23 02:08:54 +04:00
|
|
|
return -EPROBE_DEFER;
|
|
|
|
|
|
|
|
pdata->gpio_ext_mic_en = of_get_named_gpio(np,
|
|
|
|
"nvidia,ext-mic-en-gpios", 0);
|
2012-06-18 20:42:21 +04:00
|
|
|
if (pdata->gpio_ext_mic_en == -EPROBE_DEFER)
|
2012-05-23 02:08:54 +04:00
|
|
|
return -EPROBE_DEFER;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (np) {
|
2011-12-13 02:55:36 +04:00
|
|
|
ret = snd_soc_of_parse_card_name(card, "nvidia,model");
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
ret = snd_soc_of_parse_audio_routing(card,
|
|
|
|
"nvidia,audio-routing");
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
tegra_wm8903_dai.codec_name = NULL;
|
2012-05-23 02:08:54 +04:00
|
|
|
tegra_wm8903_dai.codec_of_node = of_parse_phandle(np,
|
|
|
|
"nvidia,audio-codec", 0);
|
2011-12-13 02:55:36 +04:00
|
|
|
if (!tegra_wm8903_dai.codec_of_node) {
|
|
|
|
dev_err(&pdev->dev,
|
|
|
|
"Property 'nvidia,audio-codec' missing or invalid\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
tegra_wm8903_dai.cpu_dai_name = NULL;
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 04:22:11 +04:00
|
|
|
tegra_wm8903_dai.cpu_of_node = of_parse_phandle(np,
|
2012-05-23 02:08:54 +04:00
|
|
|
"nvidia,i2s-controller", 0);
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 04:22:11 +04:00
|
|
|
if (!tegra_wm8903_dai.cpu_of_node) {
|
2011-12-13 02:55:36 +04:00
|
|
|
dev_err(&pdev->dev,
|
|
|
|
"Property 'nvidia,i2s-controller' missing or invalid\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2012-03-21 00:55:49 +04:00
|
|
|
tegra_wm8903_dai.platform_name = NULL;
|
|
|
|
tegra_wm8903_dai.platform_of_node =
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 04:22:11 +04:00
|
|
|
tegra_wm8903_dai.cpu_of_node;
|
2011-04-20 01:25:12 +04:00
|
|
|
} else {
|
2012-05-23 02:11:19 +04:00
|
|
|
card->dapm_routes = harmony_audio_map;
|
|
|
|
card->num_dapm_routes = ARRAY_SIZE(harmony_audio_map);
|
2011-04-20 01:25:12 +04:00
|
|
|
}
|
|
|
|
|
2012-05-23 02:08:54 +04:00
|
|
|
if (gpio_is_valid(pdata->gpio_spkr_en)) {
|
2012-05-23 02:08:55 +04:00
|
|
|
ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_spkr_en,
|
|
|
|
GPIOF_OUT_INIT_LOW, "spkr_en");
|
2012-05-23 02:08:54 +04:00
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get spkr_en gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gpio_is_valid(pdata->gpio_hp_mute)) {
|
2012-05-23 02:08:55 +04:00
|
|
|
ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_hp_mute,
|
|
|
|
GPIOF_OUT_INIT_HIGH, "hp_mute");
|
2012-05-23 02:08:54 +04:00
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get hp_mute gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gpio_is_valid(pdata->gpio_int_mic_en)) {
|
2012-05-23 02:08:55 +04:00
|
|
|
/* Disable int mic; enable signal is active-high */
|
|
|
|
ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_int_mic_en,
|
|
|
|
GPIOF_OUT_INIT_LOW, "int_mic_en");
|
2012-05-23 02:08:54 +04:00
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get int_mic_en gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
|
2012-05-23 02:08:55 +04:00
|
|
|
/* Enable ext mic; enable signal is active-low */
|
|
|
|
ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_ext_mic_en,
|
|
|
|
GPIOF_OUT_INIT_LOW, "ext_mic_en");
|
2012-05-23 02:08:54 +04:00
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get ext_mic_en gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-13 02:55:36 +04:00
|
|
|
ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);
|
|
|
|
if (ret)
|
2012-03-21 00:55:49 +04:00
|
|
|
goto err;
|
2011-12-13 02:55:36 +04:00
|
|
|
|
2011-01-29 00:26:36 +03:00
|
|
|
ret = snd_soc_register_card(card);
|
2011-01-08 08:36:16 +03:00
|
|
|
if (ret) {
|
2011-01-29 00:26:36 +03:00
|
|
|
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
|
2011-01-08 08:36:16 +03:00
|
|
|
ret);
|
2011-04-20 01:25:08 +04:00
|
|
|
goto err_fini_utils;
|
2011-01-08 08:36:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2011-04-20 01:25:08 +04:00
|
|
|
err_fini_utils:
|
2011-04-12 21:40:36 +04:00
|
|
|
tegra_asoc_utils_fini(&machine->util_data);
|
2011-11-23 05:21:20 +04:00
|
|
|
err:
|
2011-01-08 08:36:16 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static int __devexit tegra_wm8903_driver_remove(struct platform_device *pdev)
|
2011-01-08 08:36:16 +03:00
|
|
|
{
|
2011-01-29 00:26:36 +03:00
|
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
2011-04-12 21:40:36 +04:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
2011-01-29 00:26:36 +03:00
|
|
|
|
2012-05-23 02:08:56 +04:00
|
|
|
snd_soc_jack_free_gpios(&tegra_wm8903_hp_jack, 1,
|
|
|
|
&tegra_wm8903_hp_jack_gpio);
|
ASoC: Tegra: wm8903 machine driver: Allow re-insertion of module
Two issues were preventing module snd-soc-tegra-wm8903.ko from being
removed and re-inserted:
a) The speaker-enable GPIO is hosted by the WM8903 chip. This GPIO must
be freed before snd_soc_unregister_card() is called, because that
triggers wm8903.c:wm8903_remove(), which calls gpiochip_remove(), which
then fails if any of the GPIOs are in use. To solve this, free all GPIOs
first, so the code doesn't care where they come from.
b) We need to call snd_soc_jack_free_gpios() to match the call to
snd_soc_jack_add_gpios() during initialization. Without this, the
call to snd_soc_jack_add_gpios() fails during any subsequent modprobe
and initialization, since the GPIO and IRQ are already registered. In
turn, this causes the headphone state not to be monitored, so the
headphone is assumed not to be plugged in, and the audio path to it is
never enabled.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Cc: stable@kernel.org
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-08-05 02:44:43 +04:00
|
|
|
|
|
|
|
snd_soc_unregister_card(card);
|
|
|
|
|
|
|
|
tegra_asoc_utils_fini(&machine->util_data);
|
2011-01-29 00:26:37 +03:00
|
|
|
|
2011-01-29 00:26:36 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-19 22:25:33 +04:00
|
|
|
static const struct of_device_id tegra_wm8903_of_match[] = {
|
2011-12-13 02:55:36 +04:00
|
|
|
{ .compatible = "nvidia,tegra-audio-wm8903", },
|
|
|
|
{},
|
|
|
|
};
|
|
|
|
|
2011-04-12 21:40:36 +04:00
|
|
|
static struct platform_driver tegra_wm8903_driver = {
|
2011-01-29 00:26:36 +03:00
|
|
|
.driver = {
|
|
|
|
.name = DRV_NAME,
|
|
|
|
.owner = THIS_MODULE,
|
2011-04-06 05:35:30 +04:00
|
|
|
.pm = &snd_soc_pm_ops,
|
2011-12-13 02:55:36 +04:00
|
|
|
.of_match_table = tegra_wm8903_of_match,
|
2011-01-29 00:26:36 +03:00
|
|
|
},
|
2011-04-12 21:40:36 +04:00
|
|
|
.probe = tegra_wm8903_driver_probe,
|
|
|
|
.remove = __devexit_p(tegra_wm8903_driver_remove),
|
2011-01-29 00:26:36 +03:00
|
|
|
};
|
2011-11-23 05:21:20 +04:00
|
|
|
module_platform_driver(tegra_wm8903_driver);
|
2011-01-08 08:36:16 +03:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
|
2011-04-12 21:40:36 +04:00
|
|
|
MODULE_DESCRIPTION("Tegra+WM8903 machine ASoC driver");
|
2011-01-08 08:36:16 +03:00
|
|
|
MODULE_LICENSE("GPL");
|
2011-02-11 01:37:19 +03:00
|
|
|
MODULE_ALIAS("platform:" DRV_NAME);
|
2011-12-13 02:55:36 +04:00
|
|
|
MODULE_DEVICE_TABLE(of, tegra_wm8903_of_match);
|