2011-01-08 05:36:16 +00:00
|
|
|
/*
|
2011-04-12 17:40:36 +00:00
|
|
|
* tegra_wm8903.c - Tegra machine ASoC driver for boards using WM8903 codec.
|
2011-01-08 05:36:16 +00:00
|
|
|
*
|
|
|
|
* Author: Stephen Warren <swarren@nvidia.com>
|
2011-01-28 21:26:36 +00:00
|
|
|
* Copyright (C) 2010-2011 - NVIDIA, Inc.
|
2011-01-08 05:36:16 +00: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 <asm/mach-types.h>
|
2011-01-28 21:26:36 +00:00
|
|
|
|
2011-01-08 05:36:16 +00:00
|
|
|
#include <linux/module.h>
|
2011-01-28 21:26:36 +00:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/slab.h>
|
2011-01-28 21:26:37 +00:00
|
|
|
#include <linux/gpio.h>
|
|
|
|
|
2011-04-12 17:28:59 +00:00
|
|
|
#include <mach/tegra_wm8903_pdata.h>
|
2011-01-28 21:26:36 +00:00
|
|
|
|
2011-01-08 05:36:16 +00:00
|
|
|
#include <sound/core.h>
|
2011-02-03 20:56:13 +00:00
|
|
|
#include <sound/jack.h>
|
2011-01-08 05:36:16 +00:00
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include <sound/soc.h>
|
|
|
|
|
2011-02-10 22:37:16 +00:00
|
|
|
#include "../codecs/wm8903.h"
|
|
|
|
|
2011-01-08 05:36:16 +00:00
|
|
|
#include "tegra_das.h"
|
|
|
|
#include "tegra_i2s.h"
|
|
|
|
#include "tegra_pcm.h"
|
|
|
|
#include "tegra_asoc_utils.h"
|
|
|
|
|
2011-04-12 17:29:00 +00:00
|
|
|
#define DRV_NAME "tegra-snd-wm8903"
|
2011-01-08 05:36:16 +00:00
|
|
|
|
2011-02-10 22:37:18 +00:00
|
|
|
#define GPIO_SPKR_EN BIT(0)
|
2011-04-12 17:40:39 +00:00
|
|
|
#define GPIO_HP_MUTE BIT(1)
|
|
|
|
#define GPIO_INT_MIC_EN BIT(2)
|
|
|
|
#define GPIO_EXT_MIC_EN BIT(3)
|
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-04 22:44:43 +00:00
|
|
|
#define GPIO_HP_DET BIT(4)
|
2011-02-10 22:37:18 +00:00
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
struct tegra_wm8903 {
|
2011-01-28 21:26:40 +00:00
|
|
|
struct tegra_asoc_utils_data util_data;
|
2011-04-12 17:28:59 +00:00
|
|
|
struct tegra_wm8903_platform_data *pdata;
|
2011-02-10 22:37:18 +00:00
|
|
|
int gpio_requested;
|
2011-01-28 21:26:36 +00:00
|
|
|
};
|
2011-01-08 05:36:16 +00:00
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static int tegra_wm8903_hw_params(struct snd_pcm_substream *substream,
|
2011-01-08 05:36:16 +00: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;
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2011-01-28 21:26:39 +00:00
|
|
|
struct snd_soc_codec *codec = rtd->codec;
|
|
|
|
struct snd_soc_card *card = codec->card;
|
2011-04-12 17:40:36 +00:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
2011-04-19 21:25:09 +00:00
|
|
|
int srate, mclk;
|
2011-01-08 05:36:16 +00: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-19 21:25:09 +00:00
|
|
|
err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
|
2011-01-08 05:36:16 +00:00
|
|
|
if (err < 0) {
|
2011-01-28 21:26:39 +00:00
|
|
|
dev_err(card->dev, "Can't configure clocks\n");
|
2011-01-08 05:36:16 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = snd_soc_dai_set_fmt(codec_dai,
|
|
|
|
SND_SOC_DAIFMT_I2S |
|
|
|
|
SND_SOC_DAIFMT_NB_NF |
|
|
|
|
SND_SOC_DAIFMT_CBS_CFS);
|
|
|
|
if (err < 0) {
|
2011-01-28 21:26:39 +00:00
|
|
|
dev_err(card->dev, "codec_dai fmt not set\n");
|
2011-01-08 05:36:16 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = snd_soc_dai_set_fmt(cpu_dai,
|
|
|
|
SND_SOC_DAIFMT_I2S |
|
|
|
|
SND_SOC_DAIFMT_NB_NF |
|
|
|
|
SND_SOC_DAIFMT_CBS_CFS);
|
|
|
|
if (err < 0) {
|
2011-01-28 21:26:39 +00:00
|
|
|
dev_err(card->dev, "cpu_dai fmt not set\n");
|
2011-01-08 05:36:16 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-04-19 21:25:09 +00: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 05:36:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct snd_soc_ops tegra_wm8903_ops = {
|
|
|
|
.hw_params = tegra_wm8903_hw_params,
|
2011-01-08 05:36:16 +00:00
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct snd_soc_jack tegra_wm8903_hp_jack;
|
2011-02-03 20:56:13 +00:00
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct snd_soc_jack_pin tegra_wm8903_hp_jack_pins[] = {
|
2011-02-03 20:56:13 +00:00
|
|
|
{
|
|
|
|
.pin = "Headphone Jack",
|
|
|
|
.mask = SND_JACK_HEADPHONE,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:38 +00: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 20:56:13 +00:00
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct snd_soc_jack tegra_wm8903_mic_jack;
|
2011-02-10 22:37:16 +00:00
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct snd_soc_jack_pin tegra_wm8903_mic_jack_pins[] = {
|
2011-02-10 22:37:16 +00:00
|
|
|
{
|
|
|
|
.pin = "Mic Jack",
|
|
|
|
.mask = SND_JACK_MICROPHONE,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static int tegra_wm8903_event_int_spk(struct snd_soc_dapm_widget *w,
|
2011-01-28 21:26:37 +00:00
|
|
|
struct snd_kcontrol *k, int event)
|
|
|
|
{
|
2011-04-19 21:25:10 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
|
|
|
struct snd_soc_card *card = dapm->card;
|
2011-04-12 17:40:36 +00:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
|
|
|
struct tegra_wm8903_platform_data *pdata = machine->pdata;
|
2011-01-28 21:26:37 +00:00
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
if (!(machine->gpio_requested & GPIO_SPKR_EN))
|
|
|
|
return 0;
|
|
|
|
|
2011-01-28 21:26:37 +00:00
|
|
|
gpio_set_value_cansleep(pdata->gpio_spkr_en,
|
2011-01-31 18:00:17 +00:00
|
|
|
SND_SOC_DAPM_EVENT_ON(event));
|
2011-01-28 21:26:37 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
static int tegra_wm8903_event_hp(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol *k, int event)
|
|
|
|
{
|
2011-04-19 21:25:10 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
|
|
|
struct snd_soc_card *card = dapm->card;
|
2011-04-12 17:40:39 +00:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
|
|
|
struct tegra_wm8903_platform_data *pdata = machine->pdata;
|
|
|
|
|
|
|
|
if (!(machine->gpio_requested & GPIO_HP_MUTE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
gpio_set_value_cansleep(pdata->gpio_hp_mute,
|
|
|
|
!SND_SOC_DAPM_EVENT_ON(event));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:36 +00: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 17:40:39 +00:00
|
|
|
SND_SOC_DAPM_HP("Headphone Jack", tegra_wm8903_event_hp),
|
2011-01-13 22:22:08 +00: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-28 21:26:37 +00:00
|
|
|
{"Int Spk", NULL, "ROP"},
|
|
|
|
{"Int Spk", NULL, "RON"},
|
|
|
|
{"Int Spk", NULL, "LOP"},
|
|
|
|
{"Int Spk", NULL, "LON"},
|
2011-01-13 22:22:08 +00:00
|
|
|
{"Mic Bias", NULL, "Mic Jack"},
|
|
|
|
{"IN1L", NULL, "Mic Bias"},
|
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
static const struct snd_soc_dapm_route seaboard_audio_map[] = {
|
|
|
|
{"Headphone Jack", NULL, "HPOUTR"},
|
|
|
|
{"Headphone Jack", NULL, "HPOUTL"},
|
|
|
|
{"Int Spk", NULL, "ROP"},
|
|
|
|
{"Int Spk", NULL, "RON"},
|
|
|
|
{"Int Spk", NULL, "LOP"},
|
|
|
|
{"Int Spk", NULL, "LON"},
|
|
|
|
{"Mic Bias", NULL, "Mic Jack"},
|
|
|
|
{"IN1R", NULL, "Mic Bias"},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct snd_soc_dapm_route kaen_audio_map[] = {
|
|
|
|
{"Headphone Jack", NULL, "HPOUTR"},
|
|
|
|
{"Headphone Jack", NULL, "HPOUTL"},
|
|
|
|
{"Int Spk", NULL, "ROP"},
|
|
|
|
{"Int Spk", NULL, "RON"},
|
|
|
|
{"Int Spk", NULL, "LOP"},
|
|
|
|
{"Int Spk", NULL, "LON"},
|
|
|
|
{"Mic Bias", NULL, "Mic Jack"},
|
|
|
|
{"IN2R", NULL, "Mic Bias"},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct snd_soc_dapm_route aebl_audio_map[] = {
|
|
|
|
{"Headphone Jack", NULL, "HPOUTR"},
|
|
|
|
{"Headphone Jack", NULL, "HPOUTL"},
|
|
|
|
{"Int Spk", NULL, "LINEOUTR"},
|
|
|
|
{"Int Spk", NULL, "LINEOUTL"},
|
|
|
|
{"Mic Bias", NULL, "Mic Jack"},
|
|
|
|
{"IN1R", NULL, "Mic Bias"},
|
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static const struct snd_kcontrol_new tegra_wm8903_controls[] = {
|
2011-02-03 20:56:14 +00:00
|
|
|
SOC_DAPM_PIN_SWITCH("Int Spk"),
|
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd)
|
2011-01-13 22:22:08 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = rtd->codec;
|
|
|
|
struct snd_soc_dapm_context *dapm = &codec->dapm;
|
2011-01-28 21:26:37 +00:00
|
|
|
struct snd_soc_card *card = codec->card;
|
2011-04-12 17:40:36 +00:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
|
|
|
struct tegra_wm8903_platform_data *pdata = machine->pdata;
|
2011-01-28 21:26:37 +00:00
|
|
|
int ret;
|
|
|
|
|
2011-11-23 01:21:13 +00:00
|
|
|
ret = tegra_das_connect_dap_to_dac(TEGRA_DAS_DAP_ID_1,
|
|
|
|
TEGRA_DAS_DAP_SEL_DAC1);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "Can't set up DAS DAP connection\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret = tegra_das_connect_dac_to_dap(TEGRA_DAS_DAC_ID_1,
|
|
|
|
TEGRA_DAS_DAC_SEL_DAP1);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "Can't set up DAS DAC connection\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
if (gpio_is_valid(pdata->gpio_spkr_en)) {
|
|
|
|
ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get spkr_en gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
machine->gpio_requested |= GPIO_SPKR_EN;
|
|
|
|
|
|
|
|
gpio_direction_output(pdata->gpio_spkr_en, 0);
|
2011-01-28 21:26:37 +00:00
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
if (gpio_is_valid(pdata->gpio_hp_mute)) {
|
|
|
|
ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get hp_mute gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
machine->gpio_requested |= GPIO_HP_MUTE;
|
2011-01-13 22:22:08 +00:00
|
|
|
|
2011-05-26 18:46:50 +00:00
|
|
|
gpio_direction_output(pdata->gpio_hp_mute, 1);
|
2011-02-10 22:37:18 +00:00
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
if (gpio_is_valid(pdata->gpio_int_mic_en)) {
|
|
|
|
ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get int_mic_en gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
machine->gpio_requested |= GPIO_INT_MIC_EN;
|
2011-02-10 22:37:18 +00:00
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
/* Disable int mic; enable signal is active-high */
|
|
|
|
gpio_direction_output(pdata->gpio_int_mic_en, 0);
|
2011-02-10 22:37:18 +00:00
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
|
|
|
|
ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "cannot get ext_mic_en gpio\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
machine->gpio_requested |= GPIO_EXT_MIC_EN;
|
|
|
|
|
|
|
|
/* Enable ext mic; enable signal is active-low */
|
|
|
|
gpio_direction_output(pdata->gpio_ext_mic_en, 0);
|
|
|
|
}
|
2011-02-10 22:37:18 +00:00
|
|
|
|
2011-04-12 17:40:39 +00: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);
|
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-04 22:44:43 +00:00
|
|
|
machine->gpio_requested |= GPIO_HP_DET;
|
2011-04-12 17:40:39 +00:00
|
|
|
}
|
2011-02-03 20:56:13 +00:00
|
|
|
|
2011-02-10 22:37:16 +00:00
|
|
|
snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,
|
2011-04-12 17:40:36 +00: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-10 22:37:16 +00:00
|
|
|
|
|
|
|
snd_soc_dapm_force_enable_pin(dapm, "Mic Bias");
|
|
|
|
|
2011-04-12 17:40:39 +00:00
|
|
|
/* FIXME: Calculate automatically based on DAPM routes? */
|
2011-08-23 17:16:28 +00:00
|
|
|
if (!machine_is_harmony())
|
2011-04-12 17:40:39 +00:00
|
|
|
snd_soc_dapm_nc_pin(dapm, "IN1L");
|
|
|
|
if (!machine_is_seaboard() && !machine_is_aebl())
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "IN1R");
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "IN2L");
|
|
|
|
if (!machine_is_kaen())
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "IN2R");
|
2011-02-10 22:37:17 +00:00
|
|
|
snd_soc_dapm_nc_pin(dapm, "IN3L");
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "IN3R");
|
2011-04-12 17:40:39 +00:00
|
|
|
|
|
|
|
if (machine_is_aebl()) {
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "LON");
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "RON");
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "ROP");
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "LOP");
|
|
|
|
} else {
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "LINEOUTR");
|
|
|
|
snd_soc_dapm_nc_pin(dapm, "LINEOUTL");
|
|
|
|
}
|
2011-02-10 22:37:17 +00:00
|
|
|
|
2011-01-13 22:22:08 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct snd_soc_dai_link tegra_wm8903_dai = {
|
2011-01-08 05:36:16 +00:00
|
|
|
.name = "WM8903",
|
|
|
|
.stream_name = "WM8903 PCM",
|
2011-02-09 13:47:06 +00:00
|
|
|
.codec_name = "wm8903.0-001a",
|
2011-01-08 05:36:16 +00:00
|
|
|
.platform_name = "tegra-pcm-audio",
|
|
|
|
.cpu_dai_name = "tegra-i2s.0",
|
|
|
|
.codec_dai_name = "wm8903-hifi",
|
2011-04-12 17:40:36 +00:00
|
|
|
.init = tegra_wm8903_init,
|
|
|
|
.ops = &tegra_wm8903_ops,
|
2011-01-08 05:36:16 +00:00
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct snd_soc_card snd_soc_tegra_wm8903 = {
|
|
|
|
.name = "tegra-wm8903",
|
|
|
|
.dai_link = &tegra_wm8903_dai,
|
2011-01-08 05:36:16 +00:00
|
|
|
.num_links = 1,
|
2011-04-19 21:25:12 +00: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-01-08 05:36:16 +00:00
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static __devinit int tegra_wm8903_driver_probe(struct platform_device *pdev)
|
2011-01-08 05:36:16 +00:00
|
|
|
{
|
2011-04-12 17:40:36 +00:00
|
|
|
struct snd_soc_card *card = &snd_soc_tegra_wm8903;
|
|
|
|
struct tegra_wm8903 *machine;
|
2011-04-12 17:28:59 +00:00
|
|
|
struct tegra_wm8903_platform_data *pdata;
|
2011-01-08 05:36:16 +00:00
|
|
|
int ret;
|
|
|
|
|
2011-01-28 21:26:37 +00:00
|
|
|
pdata = pdev->dev.platform_data;
|
|
|
|
if (!pdata) {
|
2011-04-12 17:40:39 +00:00
|
|
|
dev_err(&pdev->dev, "No platform data supplied\n");
|
2011-01-28 21:26:37 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
machine = kzalloc(sizeof(struct tegra_wm8903), GFP_KERNEL);
|
|
|
|
if (!machine) {
|
|
|
|
dev_err(&pdev->dev, "Can't allocate tegra_wm8903 struct\n");
|
2011-01-28 21:26:36 +00:00
|
|
|
return -ENOMEM;
|
2011-01-08 05:36:16 +00:00
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
machine->pdata = pdata;
|
2011-01-28 21:26:37 +00:00
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);
|
2011-01-28 21:26:36 +00:00
|
|
|
if (ret)
|
2011-04-12 17:40:36 +00:00
|
|
|
goto err_free_machine;
|
2011-01-08 05:36:16 +00:00
|
|
|
|
2011-01-28 21:26:36 +00:00
|
|
|
card->dev = &pdev->dev;
|
|
|
|
platform_set_drvdata(pdev, card);
|
2011-04-12 17:40:36 +00:00
|
|
|
snd_soc_card_set_drvdata(card, machine);
|
2011-01-08 05:36:16 +00:00
|
|
|
|
2011-08-23 17:16:28 +00:00
|
|
|
if (machine_is_harmony()) {
|
2011-04-19 21:25:12 +00:00
|
|
|
card->dapm_routes = harmony_audio_map;
|
|
|
|
card->num_dapm_routes = ARRAY_SIZE(harmony_audio_map);
|
|
|
|
} else if (machine_is_seaboard()) {
|
|
|
|
card->dapm_routes = seaboard_audio_map;
|
|
|
|
card->num_dapm_routes = ARRAY_SIZE(seaboard_audio_map);
|
|
|
|
} else if (machine_is_kaen()) {
|
|
|
|
card->dapm_routes = kaen_audio_map;
|
|
|
|
card->num_dapm_routes = ARRAY_SIZE(kaen_audio_map);
|
|
|
|
} else {
|
|
|
|
card->dapm_routes = aebl_audio_map;
|
|
|
|
card->num_dapm_routes = ARRAY_SIZE(aebl_audio_map);
|
|
|
|
}
|
|
|
|
|
2011-01-28 21:26:36 +00:00
|
|
|
ret = snd_soc_register_card(card);
|
2011-01-08 05:36:16 +00:00
|
|
|
if (ret) {
|
2011-01-28 21:26:36 +00:00
|
|
|
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
|
2011-01-08 05:36:16 +00:00
|
|
|
ret);
|
2011-04-19 21:25:08 +00:00
|
|
|
goto err_fini_utils;
|
2011-01-08 05:36:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2011-04-19 21:25:08 +00:00
|
|
|
err_fini_utils:
|
2011-04-12 17:40:36 +00:00
|
|
|
tegra_asoc_utils_fini(&machine->util_data);
|
|
|
|
err_free_machine:
|
|
|
|
kfree(machine);
|
2011-01-08 05:36:16 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static int __devexit tegra_wm8903_driver_remove(struct platform_device *pdev)
|
2011-01-08 05:36:16 +00:00
|
|
|
{
|
2011-01-28 21:26:36 +00:00
|
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
2011-04-12 17:40:36 +00:00
|
|
|
struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
|
|
|
|
struct tegra_wm8903_platform_data *pdata = machine->pdata;
|
2011-01-28 21:26:36 +00:00
|
|
|
|
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-04 22:44:43 +00:00
|
|
|
if (machine->gpio_requested & GPIO_HP_DET)
|
|
|
|
snd_soc_jack_free_gpios(&tegra_wm8903_hp_jack,
|
|
|
|
1,
|
|
|
|
&tegra_wm8903_hp_jack_gpio);
|
2011-04-12 17:40:36 +00:00
|
|
|
if (machine->gpio_requested & GPIO_EXT_MIC_EN)
|
2011-02-10 22:37:18 +00:00
|
|
|
gpio_free(pdata->gpio_ext_mic_en);
|
2011-04-12 17:40:36 +00:00
|
|
|
if (machine->gpio_requested & GPIO_INT_MIC_EN)
|
2011-02-10 22:37:18 +00:00
|
|
|
gpio_free(pdata->gpio_int_mic_en);
|
2011-04-12 17:40:39 +00:00
|
|
|
if (machine->gpio_requested & GPIO_HP_MUTE)
|
|
|
|
gpio_free(pdata->gpio_hp_mute);
|
2011-04-12 17:40:36 +00:00
|
|
|
if (machine->gpio_requested & GPIO_SPKR_EN)
|
2011-01-28 21:26:37 +00:00
|
|
|
gpio_free(pdata->gpio_spkr_en);
|
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-04 22:44:43 +00:00
|
|
|
machine->gpio_requested = 0;
|
|
|
|
|
|
|
|
snd_soc_unregister_card(card);
|
|
|
|
|
|
|
|
tegra_asoc_utils_fini(&machine->util_data);
|
2011-01-28 21:26:37 +00:00
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
kfree(machine);
|
2011-01-28 21:26:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static struct platform_driver tegra_wm8903_driver = {
|
2011-01-28 21:26:36 +00:00
|
|
|
.driver = {
|
|
|
|
.name = DRV_NAME,
|
|
|
|
.owner = THIS_MODULE,
|
2011-04-06 01:35:30 +00:00
|
|
|
.pm = &snd_soc_pm_ops,
|
2011-01-28 21:26:36 +00:00
|
|
|
},
|
2011-04-12 17:40:36 +00:00
|
|
|
.probe = tegra_wm8903_driver_probe,
|
|
|
|
.remove = __devexit_p(tegra_wm8903_driver_remove),
|
2011-01-28 21:26:36 +00:00
|
|
|
};
|
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static int __init tegra_wm8903_modinit(void)
|
2011-01-28 21:26:36 +00:00
|
|
|
{
|
2011-04-12 17:40:36 +00:00
|
|
|
return platform_driver_register(&tegra_wm8903_driver);
|
2011-01-28 21:26:36 +00:00
|
|
|
}
|
2011-04-12 17:40:36 +00:00
|
|
|
module_init(tegra_wm8903_modinit);
|
2011-01-28 21:26:36 +00:00
|
|
|
|
2011-04-12 17:40:36 +00:00
|
|
|
static void __exit tegra_wm8903_modexit(void)
|
2011-01-28 21:26:36 +00:00
|
|
|
{
|
2011-04-12 17:40:36 +00:00
|
|
|
platform_driver_unregister(&tegra_wm8903_driver);
|
2011-01-08 05:36:16 +00:00
|
|
|
}
|
2011-04-12 17:40:36 +00:00
|
|
|
module_exit(tegra_wm8903_modexit);
|
2011-01-08 05:36:16 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
|
2011-04-12 17:40:36 +00:00
|
|
|
MODULE_DESCRIPTION("Tegra+WM8903 machine ASoC driver");
|
2011-01-08 05:36:16 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
2011-02-10 22:37:19 +00:00
|
|
|
MODULE_ALIAS("platform:" DRV_NAME);
|