--- /dev/null
+/*
+ * Copyright (C) 2013 Samsung Electronics Co., Ltd.
+ *
+ * Authors: KwangHui Cho <kwanghui.cho@samsung.com>
+ * Sylwester Nawrocki <s.nawrocki@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ */
+#define pr_fmt(fmt) "%s:%d " fmt, __func__, __LINE__
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/input.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/mfd/wm8994/core.h>
+#include <linux/mfd/wm8994/registers.h>
+#include <linux/mfd/wm8994/pdata.h>
+#include <linux/mfd/wm8994/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/pm_wakeup.h>
+#include <linux/regulator/machine.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/workqueue.h>
+
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/jack.h>
+
+#include "i2s.h"
+#include "i2s-regs.h"
+#include "s3c-i2s-v2.h"
+#include "../codecs/wm8994.h"
+
+#define XTAL_24MHZ_AP 24000000
+#define CODEC_CLK32K 32768
+#define CODEC_DEFAULT_SYNC_CLK 11289600
+
+#define WM1811_JACKDET_MODE_NONE 0x0000
+#define WM1811_JACKDET_MODE_JACK 0x0100
+#define WM1811_JACKDET_MODE_MIC 0x0080
+#define WM1811_JACKDET_MODE_AUDIO 0x0180
+
+#define WM1811_JACKDET_BTN0 0x04
+#define WM1811_JACKDET_BTN1 0x10
+#define WM1811_JACKDET_BTN2 0x08
+
+#define SND_SOC_DAPM_SPKMODE(wname, wevent) \
+{ .id = snd_soc_dapm_spk, .name = wname, .kcontrol_news = NULL, \
+ .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
+ .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}
+
+
+static char *mic_names[] = {
+ "Main Mic",
+ "Sub Mic",
+};
+
+static const struct wm8958_micd_rate machine_det_rates[] = {
+ { CODEC_CLK32K, true, 0, 0 },
+ { CODEC_CLK32K, false, 0, 0 },
+ { CODEC_DEFAULT_SYNC_CLK, true, 0xa, 0xb },
+ { CODEC_DEFAULT_SYNC_CLK, false, 0xa, 0xb },
+};
+
+static const struct wm8958_micd_rate machine_jackdet_rates[] = {
+ { CODEC_CLK32K, true, 0, 0 },
+ { CODEC_CLK32K, false, 0, 0 },
+ { CODEC_DEFAULT_SYNC_CLK, true, 12, 12 },
+ { CODEC_DEFAULT_SYNC_CLK, false, 7, 7 },
+};
+
+static int aif2_mode;
+const char *aif2_mode_text[] = {
+ "Slave", "Master"
+};
+enum {
+ MODE_CODEC_SLAVE,
+ MODE_CODEC_MASTER,
+};
+
+/* TODO: convert to DT properties */
+enum {
+ MIC_MAIN,
+ MIC_SUB,
+ MIC_MAX
+};
+
+enum exynos4_wm1811_gpios {
+ GPIO_VPS_SOUND,
+ GPIO_MIC_BIAS,
+ GPIO_MIC_SUB_BIAS,
+ GPIO_NUM
+};
+
+/* To support PBA function test */
+static struct class *audio_class;
+static struct device *jack_dev;
+static struct device *caps_dev;
+
+struct exynos_wm1811 {
+ struct snd_soc_jack jack;
+ struct snd_soc_codec *codec;
+ struct clk *codec_mclk;
+
+ int gpio_mic_bias[MIC_MAX];
+ int gpio_vps_en;
+ /* int gpios[GPIO_NUM]; */
+
+ u32 mic_avail[MIC_MAX];
+ bool ignore_earjack;
+ bool cp_wb_support;
+
+ /* Exynos4 EPLL clock */
+ struct clk *clk_pll;
+};
+
+static const struct soc_enum aif2_mode_enum[] = {
+ SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(aif2_mode_text), aif2_mode_text),
+};
+
+static int get_aif2_mode(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = aif2_mode;
+ return 0;
+}
+
+static int set_aif2_mode(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ if (aif2_mode == ucontrol->value.integer.value[0])
+ return 0;
+
+ aif2_mode = ucontrol->value.integer.value[0];
+
+ WARN_ON((aif2_mode != MODE_CODEC_SLAVE) &&
+ (aif2_mode != MODE_CODEC_MASTER));
+
+ pr_info("set AIF2 mode: %s\n", aif2_mode_text[aif2_mode]);
+ return 0;
+}
+
+static int exynos_snd_micbias(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ struct snd_soc_codec *codec = w->codec;
+ struct exynos_wm1811 *machine = snd_soc_card_get_drvdata(codec->card);
+ unsigned int mic;
+
+ dev_info(codec->dev, "Mic Bias: %s event is %02X", w->name, event);
+
+ if (!strncmp(w->name, mic_names[MIC_MAIN], strlen(mic_names[MIC_MAIN])))
+ mic = MIC_MAIN;
+ else if (!strncmp(w->name, mic_names[MIC_SUB],
+ strlen(mic_names[MIC_SUB])))
+ mic = MIC_SUB;
+ else {
+ pr_err("Sound: Unknown dapm widget %s\n", w->name);
+ return 0;
+ }
+
+ if (!machine->mic_avail[mic]) {
+ dev_err(codec->dev, "%s is not available on this board",
+ mic_names[mic]);
+ return 0;
+ }
+
+ if (gpio_is_valid(machine->gpio_mic_bias[mic])) {
+ switch (event) {
+ case SND_SOC_DAPM_PRE_PMU:
+ pr_info("Sound: %s bias enable", mic_names[mic]);
+ gpio_set_value(machine->gpio_mic_bias[mic], 1);
+ /* add delay to remove main mic pop up noise */
+ msleep(150);
+ break;
+ case SND_SOC_DAPM_POST_PMD:
+ pr_info("Sound: %s bias disable", mic_names[mic]);
+ gpio_set_value(machine->gpio_mic_bias[mic], 0);
+ break;
+ }
+ } else {
+ /* if EXYNOS gpio is not assigned to external ldo control
+ that means MICBIAS1 (A9 pin) is used for mic bias supply */
+ switch (event) {
+ case SND_SOC_DAPM_PRE_PMU:
+ pr_info("Sound: %s bias enable", mic_names[mic]);
+ snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
+ WM8994_MICB1_ENA_MASK, WM8994_MICB1_ENA);
+ break;
+ case SND_SOC_DAPM_POST_PMD:
+ pr_info("Sound: %s bias disable", mic_names[mic]);
+ snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
+ WM8994_MICB1_ENA_MASK, 0);
+ break;
+ }
+ }
+
+ return 0;
+}
+
+static int exynos_snd_spkmode(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ struct snd_soc_codec *codec = w->codec;
+ int ret = 0;
+
+ switch (event) {
+ case SND_SOC_DAPM_PRE_PMU:
+ dev_info(codec->dev, "set speaker L+R mix");
+ ret = snd_soc_update_bits(codec, WM8994_SPKOUT_MIXERS,
+ WM8994_SPKMIXR_TO_SPKOUTL_MASK,
+ WM8994_SPKMIXR_TO_SPKOUTL);
+ break;
+ case SND_SOC_DAPM_POST_PMD:
+ dev_info(codec->dev, "unset speaker L+R mix");
+ ret = snd_soc_update_bits(codec, WM8994_SPKOUT_MIXERS,
+ WM8994_SPKMIXR_TO_SPKOUTL_MASK,
+ 0);
+ break;
+ }
+
+ return ret;
+}
+
+static int exynos_snd_vps_switch(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ struct snd_soc_codec *codec = w->codec;
+ struct exynos_wm1811 *machine = snd_soc_card_get_drvdata(codec->card);
+
+ if (!gpio_is_valid(machine->gpio_vps_en))
+ return 0;
+
+ switch (event) {
+ case SND_SOC_DAPM_POST_PMU:
+ pr_info("vps switch enable");
+ gpio_set_value(machine->gpio_vps_en, 1);
+ break;
+ case SND_SOC_DAPM_PRE_PMD:
+ pr_info("vps switch disable");
+ gpio_set_value(machine->gpio_vps_en, 0);
+ break;
+ }
+
+ return 0;
+}
+
+static void codec_micd_set_rate(struct snd_soc_codec *codec)
+{
+ struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+ int best, i, sysclk, val;
+ bool idle;
+ const struct wm8958_micd_rate *rates = NULL;
+ int num_rates = 0;
+
+ idle = !wm8994->jack_mic;
+
+ sysclk = snd_soc_read(codec, WM8994_CLOCKING_1);
+ if (sysclk & WM8994_SYSCLK_SRC)
+ sysclk = wm8994->aifclk[1];
+ else
+ sysclk = wm8994->aifclk[0];
+
+ if (wm8994->jackdet) {
+ rates = machine_jackdet_rates;
+ num_rates = ARRAY_SIZE(machine_jackdet_rates);
+ } else {
+ rates = machine_det_rates;
+ num_rates = ARRAY_SIZE(machine_det_rates);
+ }
+
+ best = 0;
+ for (i = 0; i < num_rates; i++) {
+ if (rates[i].idle != idle)
+ continue;
+ if (abs(rates[i].sysclk - sysclk) <
+ abs(rates[best].sysclk - sysclk))
+ best = i;
+ else if (rates[best].idle != idle)
+ best = i;
+ }
+
+ val = rates[best].start << WM8958_MICD_BIAS_STARTTIME_SHIFT
+ | rates[best].rate << WM8958_MICD_RATE_SHIFT;
+
+ snd_soc_update_bits(codec, WM8958_MIC_DETECT_1,
+ WM8958_MICD_BIAS_STARTTIME_MASK |
+ WM8958_MICD_RATE_MASK, val);
+}
+
+static void codec_micdet(u16 status, void *data)
+{
+ struct exynos_wm1811 *machine = data;
+ struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(machine->codec);
+ int report;
+ static int check_report;
+
+ dev_info(machine->codec->dev, "jack status 0x%x", status);
+ /*
+ * LCD is still off even though earjack event has occurred.
+ * So platform daemon need time to deal this event
+ */
+ pm_wakeup_event(machine->codec->dev, 500);
+ /* Either nothing present or just starting detection */
+ if (!(status & WM8958_MICD_STS)) {
+ if (!wm8994->jackdet) {
+ /* If nothing present then clear our statuses */
+ dev_dbg(machine->codec->dev, "Detected open circuit\n");
+ wm8994->jack_mic = false;
+ wm8994->mic_detecting = true;
+
+ codec_micd_set_rate(machine->codec);
+
+ snd_soc_jack_report(wm8994->micdet[0].jack, 0,
+ wm8994->btn_mask |
+ SND_JACK_HEADSET);
+ }
+ return;
+ }
+ /*
+ * If the measurement is showing a high impedence we've got
+ * a microphone.
+ */
+ if (wm8994->mic_detecting && (status & 0x400)) {
+ dev_info(machine->codec->dev, "Detected microphone\n");
+
+ wm8994->mic_detecting = false;
+ wm8994->jack_mic = true;
+
+ codec_micd_set_rate(machine->codec);
+
+ snd_soc_jack_report(wm8994->micdet[0].jack,
+ SND_JACK_HEADSET, SND_JACK_HEADSET);
+ }
+
+ if (wm8994->mic_detecting && status & 0x4) {
+ dev_info(machine->codec->dev, "Detected headphone\n");
+ wm8994->mic_detecting = false;
+
+ codec_micd_set_rate(machine->codec);
+
+ snd_soc_jack_report(wm8994->micdet[0].jack,
+ SND_JACK_HEADPHONE, SND_JACK_HEADSET);
+
+ /* If we have jackdet that will detect removal */
+ if (wm8994->jackdet) {
+ mutex_lock(&wm8994->accdet_lock);
+
+ snd_soc_update_bits(machine->codec,
+ WM8958_MIC_DETECT_1,
+ WM8958_MICD_ENA, 0);
+
+ if (wm8994->active_refcount) {
+ snd_soc_update_bits(machine->codec,
+ WM8994_ANTIPOP_2,
+ WM1811_JACKDET_MODE_MASK,
+ WM1811_JACKDET_MODE_AUDIO);
+ }
+
+ mutex_unlock(&wm8994->accdet_lock);
+#if 0
+ if (wm8994->pdata->jd_ext_cap) {
+ mutex_lock(&wm1811->codec->mutex);
+ snd_soc_dapm_disable_pin(&wm1811->codec->dapm,
+ "MICBIAS2");
+ snd_soc_dapm_sync(&wm1811->codec->dapm);
+ mutex_unlock(&wm1811->codec->mutex);
+ }
+#endif
+
+ }
+ }
+
+ /* Report short circuit as a button */
+ if (wm8994->jack_mic) {
+ report = 0;
+ if (status & WM1811_JACKDET_BTN0)
+ report |= SND_JACK_BTN_0;
+
+ if (status & WM1811_JACKDET_BTN1)
+ report |= SND_JACK_BTN_1;
+
+ if (status & WM1811_JACKDET_BTN2)
+ report |= SND_JACK_BTN_2;
+
+ /* TODO : Check this on wm1811a */
+ if (check_report != report) {
+ dev_info(machine->codec->dev,
+ "Report Button: %08x (%08X)", report, status);
+ snd_soc_jack_report(wm8994->micdet[0].jack, report,
+ wm8994->btn_mask);
+ check_report = report;
+ } else
+ dev_info(machine->codec->dev, "Skip button report");
+ }
+}
+
+#ifndef CONFIG_SND_SAMSUNG_I2S_MASTER
+static int machine_aif1_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 *cpu_dai = rtd->cpu_dai;
+ struct snd_soc_dai *codec_dai = rtd->codec_dai;
+ unsigned int pll_out;
+ int ret;
+
+ pr_info("params_rate: %d\n", params_rate(params));
+
+ if (params_rate(params) == 8000 || params_rate(params) == 11025)
+ pll_out = params_rate(params) * 512;
+ else
+ pll_out = params_rate(params) * 256;
+
+ ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S
+ | SND_SOC_DAIFMT_NB_NF
+ | SND_SOC_DAIFMT_CBM_CFM);
+ if (ret < 0)
+ return ret;
+
+ /* Set the cpu DAI configuration */
+ ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S
+ | SND_SOC_DAIFMT_NB_NF
+ | SND_SOC_DAIFMT_CBM_CFM);
+ if (ret < 0)
+ return ret;
+
+ /* Switch FLL */
+ ret = snd_soc_dai_set_pll(codec_dai, WM8994_FLL1, WM8994_FLL_SRC_MCLK1,
+ XTAL_24MHZ_AP, pll_out);
+ if (ret < 0)
+ dev_err(codec_dai->dev, "Unable to start FLL1: %d\n", ret);
+
+ ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL1,
+ pll_out, SND_SOC_CLOCK_IN);
+ if (ret < 0) {
+ dev_err(codec_dai->dev,
+ "Unable to switch to FLL1: %d\n", ret);
+ return ret;
+ }
+
+ ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_OPCLK,
+ 0, MOD_OPCLK_PCLK);
+ if (ret < 0) {
+ dev_err(cpu_dai->dev,
+ "Unable to set i2s opclk: 0x%x\n", ret);
+ return ret;
+ }
+
+ codec_micd_set_rate(codec_dai->codec);
+
+ dev_info(codec_dai->dev,
+ "AIF1 DAI %s params ch %d, rate %d as i2s slave\n",
+ ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? \
+ "playback" : "capture"),
+ params_channels(params),
+ params_rate(params));
+ return 0;
+}
+#else /* CONFIG_SND_SAMSUNG_I2S_MASTER */
+
+static int machine_aif1_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 snd_soc_dai *cpu_dai = rtd->cpu_dai;
+ int bfs, psr, rfs, ret;
+ unsigned long rclk, epll_freq;
+
+ switch (params_format(params)) {
+ case SNDRV_PCM_FORMAT_U24:
+ case SNDRV_PCM_FORMAT_S24:
+ bfs = 48;
+ break;
+ case SNDRV_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ bfs = 32;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (params_rate(params)) {
+ case 16000:
+ case 22050:
+ case 24000:
+ case 32000:
+ case 44100:
+ case 48000:
+ case 88200:
+ case 96000:
+ if (bfs == 48)
+ rfs = 384;
+ else
+ rfs = 256;
+ break;
+ case 64000:
+ rfs = 384;
+ break;
+ case 8000:
+ case 11025:
+ case 12000:
+ if (bfs == 48)
+ rfs = 768;
+ else
+ rfs = 512;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ rclk = params_rate(params) * rfs;
+
+ switch (rclk) {
+ case 4096000:
+ case 5644800:
+ case 6144000:
+ case 8467200:
+ case 9216000:
+ psr = 8;
+ break;
+ case 8192000:
+ case 11289600:
+ case 12288000:
+ case 16934400:
+ case 18432000:
+ psr = 4;
+ break;
+ case 22579200:
+ case 24576000:
+ case 33868800:
+ case 36864000:
+ psr = 2;
+ break;
+ case 67737600:
+ case 73728000:
+ psr = 1;
+ break;
+ default:
+ printk(KERN_INFO "Not yet supported!\n");
+ return -EINVAL;
+ }
+
+ epll_freq = rclk * psr;
+
+ if (epll_freq != clk_get_rate(machine->clk_pll)) {
+ ret = clk_set_rate(machine->clk_pll, epll_freq);
+ if (ret < 0)
+ return ret;
+ pr_info("%s: fout_epll: %ld (%ld) Hz\n", __func__,
+ clk_get_rate(machine->clk_pll), epll_freq);
+ }
+
+ ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S
+ | SND_SOC_DAIFMT_NB_NF
+ | SND_SOC_DAIFMT_CBS_CFS);
+ if (ret < 0)
+ return ret;
+
+ ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S
+ | SND_SOC_DAIFMT_NB_NF
+ | SND_SOC_DAIFMT_CBS_CFS);
+ if (ret < 0)
+ return ret;
+
+ ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_MCLK1,
+ rclk, SND_SOC_CLOCK_IN);
+ if (ret < 0)
+ return ret;
+
+ ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_CDCLK,
+ 0, SND_SOC_CLOCK_OUT);
+ if (ret < 0)
+ return ret;
+
+ ret = snd_soc_dai_set_clkdiv(cpu_dai, SAMSUNG_I2S_DIV_BCLK, bfs);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+#endif /* CONFIG_SND_SAMSUNG_I2S_MASTER */
+
+/*
+ * WM1811 DAI operations.
+ */
+static struct snd_soc_ops machine_aif1_ops = {
+ .hw_params = machine_aif1_hw_params,
+};
+
+static int machine_aif2_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;
+ int ret;
+ int prate;
+ int bclk;
+ unsigned int fmt;
+ int pll_src;
+ unsigned int pll_freq_in;
+
+ prate = params_rate(params);
+ switch (params_rate(params)) {
+ case 8000:
+ case 16000:
+ break;
+ default:
+ dev_warn(codec_dai->dev, "Unsupported LRCLK %d, falling back to 8kHz\n",
+ (int)params_rate(params));
+ prate = 8000;
+ }
+
+ fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF;
+ if (aif2_mode == MODE_CODEC_SLAVE)
+ fmt |= SND_SOC_DAIFMT_CBS_CFS;
+ else /* MODE_CODEC_MASTER */
+ fmt |= SND_SOC_DAIFMT_CBM_CFM;
+
+ /* Set the codec DAI configuration */
+ ret = snd_soc_dai_set_fmt(codec_dai, fmt);
+
+ if (ret < 0)
+ return ret;
+
+ switch (prate) {
+ case 8000:
+ bclk = 256000;
+ break;
+ case 16000:
+ bclk = 512000;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ if (aif2_mode == MODE_CODEC_SLAVE) {
+ pll_src = WM8994_FLL_SRC_BCLK;
+ pll_freq_in = bclk;
+ } else {
+ pll_src = WM8994_FLL_SRC_MCLK1;
+ pll_freq_in = XTAL_24MHZ_AP;
+ }
+ ret = snd_soc_dai_set_pll(codec_dai, WM8994_FLL2,
+ pll_src, pll_freq_in,
+ prate * 256);
+ if (ret < 0)
+ dev_err(codec_dai->dev, "Unable to configure FLL2: %d\n", ret);
+
+ ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL2,
+ prate * 256, SND_SOC_CLOCK_IN);
+ if (ret < 0)
+ dev_err(codec_dai->dev, "Unable to switch to FLL2: %d\n", ret);
+
+ dev_info(codec_dai->dev,
+ "AIF2 DAI %s params ch %d, rate %d as Clock %s\n",
+ ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? \
+ "playback" : "capture"),
+ params_channels(params),
+ params_rate(params),
+ aif2_mode_text[aif2_mode]);
+ return 0;
+}
+
+static struct snd_soc_ops machine_aif2_ops = {
+ .hw_params = machine_aif2_hw_params,
+};
+
+static int machine_aif3_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;
+
+ dev_info(codec_dai->dev, "AIF3 DAI %s params ch %d, rate %d\n",
+ ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? \
+ "playback" : "capture"),
+ params_channels(params),
+ params_rate(params));
+ return 0;
+}
+
+static struct snd_soc_ops machine_aif3_ops = {
+ .hw_params = machine_aif3_hw_params,
+};
+
+static const struct snd_kcontrol_new card_controls[] = {
+ SOC_DAPM_PIN_SWITCH("HP"),
+ SOC_DAPM_PIN_SWITCH("SPK"),
+ SOC_DAPM_PIN_SWITCH("RCV"),
+ SOC_DAPM_PIN_SWITCH("LINE"),
+ SOC_DAPM_PIN_SWITCH("HDMI"),
+
+ SOC_DAPM_PIN_SWITCH("Main Mic"),
+ SOC_DAPM_PIN_SWITCH("Sub Mic"),
+ SOC_DAPM_PIN_SWITCH("Headset Mic"),
+};
+
+static const struct snd_kcontrol_new codec_controls[] = {
+ SOC_ENUM_EXT("AIF2 Mode", aif2_mode_enum[0],
+ get_aif2_mode, set_aif2_mode),
+};
+
+const struct snd_soc_dapm_widget machine_dapm_widgets[] = {
+ SND_SOC_DAPM_HP("HP", NULL),
+ SND_SOC_DAPM_SPKMODE("SPK", exynos_snd_spkmode),
+ SND_SOC_DAPM_SPK("RCV", NULL),
+ SND_SOC_DAPM_LINE("LINE", exynos_snd_vps_switch),
+ SND_SOC_DAPM_LINE("HDMI", NULL),
+
+ SND_SOC_DAPM_MIC("Headset Mic", NULL),
+ SND_SOC_DAPM_MIC("Main Mic", exynos_snd_micbias),
+ SND_SOC_DAPM_MIC("Sub Mic", exynos_snd_micbias),
+
+};
+
+const struct snd_soc_dapm_route machine_dapm_routes[] = {
+ { "HP", NULL, "HPOUT1L" },
+ { "HP", NULL, "HPOUT1R" },
+
+ { "SPK", NULL, "SPKOUTLN" },
+ { "SPK", NULL, "SPKOUTLP" },
+ { "SPK", NULL, "SPKOUTRN" },
+ { "SPK", NULL, "SPKOUTRP" },
+
+ { "RCV", NULL, "HPOUT2N" },
+ { "RCV", NULL, "HPOUT2P" },
+
+ { "LINE", NULL, "LINEOUT2N" },
+ { "LINE", NULL, "LINEOUT2P" },
+
+ { "HDMI", NULL, "LINEOUT1N" }, /* Not connected */
+ { "HDMI", NULL, "LINEOUT1P" }, /* Not connected */
+};
+
+const struct snd_soc_dapm_route wm1811_input_dapm_routes[] = {
+ { "IN1LP", NULL, "Main Mic" },
+ { "IN1LN", NULL, "Main Mic" },
+
+ { "IN1RP", NULL, "Sub Mic" },
+ { "IN1RN", NULL, "Sub Mic" },
+
+ { "IN2LP:VXRN", NULL, "MICBIAS2" },
+ { "MICBIAS2", NULL, "Headset Mic" },
+};
+
+const struct snd_soc_dapm_route redwood_input_dapm_routes[] = {
+ { "IN1LP", NULL, "Main Mic" },
+ { "IN1LN", NULL, "Main Mic" },
+
+ { "IN1RP", NULL, "MICBIAS2" },
+ { "IN1RN", NULL, "MICBIAS2" },
+
+ { "IN2LP:VXRN", NULL, "MICBIAS2" },
+ { "MICBIAS2", NULL, "Headset Mic" },
+};
+
+const struct snd_soc_dapm_route redwood45_input_dapm_routes[] = {
+ { "IN2LP:VXRN", NULL, "Main Mic" },
+ { "IN2LN", NULL, "Main Mic" },
+
+ /* if add route of MICBIAS1 to "Sub Mic",
+ it could be automatically controlled by dapm sequence
+ but we have alternative boards of n035 and redwood45
+ so MICBIAS1 should be controlled another SND_SOC_DAPM_MIC
+ "Sub Mic" control function */
+ { "IN1RP", NULL, "Sub Mic" },
+ { "IN1RN", NULL, "Sub Mic" },
+
+ { "IN1RP", NULL, "MICBIAS2" },
+ { "MICBIAS2", NULL, "Headset Mic" },
+};
+
+static ssize_t earjack_select_jack_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ pr_info("Sound: %s operate nothing", __func__);
+
+ return 0;
+}
+
+static ssize_t earjack_select_jack_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ struct snd_soc_codec *codec = dev_get_drvdata(dev);
+ struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+ int report = 0;
+
+ wm8994->mic_detecting = false;
+ wm8994->jack_mic = true;
+
+ codec_micd_set_rate(codec);
+
+ if ((!size) || (buf[0] == '0')) {
+ snd_soc_jack_report(wm8994->micdet[0].jack,
+ 0, SND_JACK_HEADSET);
+ dev_info(codec->dev, "Forced remove earjack\n");
+ } else {
+ if (buf[0] == '1') {
+ dev_info(codec->dev, "Forced detect microphone\n");
+ report = SND_JACK_HEADSET;
+ } else {
+ dev_info(codec->dev, "Forced detect headphone\n");
+ report = SND_JACK_HEADPHONE;
+ }
+ snd_soc_jack_report(wm8994->micdet[0].jack,
+ report, SND_JACK_HEADSET);
+ }
+
+ return size;
+}
+
+static DEVICE_ATTR(select_jack, S_IRUGO | S_IWUSR | S_IWGRP,
+ earjack_select_jack_show, earjack_select_jack_store);
+
+static ssize_t audio_caps_cp_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct exynos_wm1811 *machine = dev_get_drvdata(dev);
+
+ if (machine->cp_wb_support == true)
+ return sprintf(buf, "wb\n") + 1;
+ else
+ return sprintf(buf, "nb\n") + 1;
+}
+static DEVICE_ATTR(cp_caps, S_IRUGO, audio_caps_cp_show, NULL);
+
+static ssize_t audio_caps_mic_count_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct exynos_wm1811 *machine = dev_get_drvdata(dev);
+ int i, cnt = 0;
+
+ if (!machine)
+ return 0;
+
+ for (i = 0; i < MIC_MAX; i++) {
+ if (machine->mic_avail[i])
+ cnt++;
+ }
+
+ return sprintf(buf, "%d\n", cnt);
+}
+static DEVICE_ATTR(mic_count, S_IRUGO, audio_caps_mic_count_show, NULL);
+
+static int machine_init_paiftx(struct snd_soc_pcm_runtime *rtd)
+{
+ struct snd_soc_codec *codec = rtd->codec;
+ struct snd_soc_card *card = rtd->card;
+ struct exynos_wm1811 *machine = snd_soc_card_get_drvdata(card);
+ struct snd_soc_dai *aif1_dai = rtd->codec_dai;
+ struct wm8994 *wm8994 = dev_get_drvdata(codec->dev->parent);
+ int ret;
+
+ ret = clk_prepare_enable(machine->codec_mclk);
+ if (ret < 0)
+ return ret;
+
+ ret = snd_soc_add_card_controls(card, card_controls,
+ ARRAY_SIZE(card_controls));
+ if (ret != 0)
+ dev_err(card->dev, "Failed to add card ctrls: %d\n", ret);
+
+ ret = snd_soc_add_codec_controls(codec, codec_controls,
+ ARRAY_SIZE(codec_controls));
+ if (ret != 0)
+ dev_err(codec->dev, "Failed to add codec ctrls: %d\n", ret);
+
+ ret = snd_soc_dapm_new_controls(&codec->dapm, machine_dapm_widgets,
+ ARRAY_SIZE(machine_dapm_widgets));
+ if (ret != 0)
+ dev_err(codec->dev, "Failed to add DAPM widgets: %d\n", ret);
+
+ ret = snd_soc_dapm_add_routes(&codec->dapm, machine_dapm_routes,
+ ARRAY_SIZE(machine_dapm_routes));
+ if (ret != 0)
+ dev_err(codec->dev, "Failed to add DAPM routes: %d\n", ret);
+
+ if (!strcmp(card->name, "redwood45")) {
+ ret = snd_soc_dapm_add_routes(&codec->dapm,
+ redwood45_input_dapm_routes,
+ ARRAY_SIZE(redwood45_input_dapm_routes));
+ } else if (!strcmp(card->name, "redwood")) {
+ ret = snd_soc_dapm_add_routes(&codec->dapm,
+ redwood_input_dapm_routes,
+ ARRAY_SIZE(redwood_input_dapm_routes));
+ } else {
+ ret = snd_soc_dapm_add_routes(&codec->dapm,
+ wm1811_input_dapm_routes,
+ ARRAY_SIZE(wm1811_input_dapm_routes));
+ }
+
+ if (ret != 0)
+ dev_err(codec->dev,
+ "Failed to add DAPM input routes: %d\n", ret);
+
+ ret = snd_soc_dai_set_sysclk(aif1_dai, WM8994_SYSCLK_MCLK2,
+ CODEC_CLK32K, SND_SOC_CLOCK_IN);
+ if (ret < 0)
+ dev_err(codec->dev, "Failed to boot clocking\n");
+
+ /* Force AIF1CLK on as it will be master for jack detection */
+ ret = snd_soc_dapm_force_enable_pin(&codec->dapm, "AIF1CLK");
+ if (ret < 0)
+ dev_err(codec->dev, "Failed to enable AIF1CLK: %d\n", ret);
+
+ /* check sub mic support */
+ if (machine && !machine->mic_avail[MIC_SUB])
+ snd_soc_dapm_nc_pin(&codec->dapm, "Sub Mic");
+ else
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "Sub Mic");
+
+ /* check earjack support */
+ if (machine->ignore_earjack)
+ snd_soc_dapm_nc_pin(&codec->dapm, "Headset Mic");
+ else
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "Headset Mic");
+
+ /* disable codec ldo for mic mias when using ext mic bias */
+ if (!machine->gpio_mic_bias[MIC_MAIN] &&
+ !machine->gpio_mic_bias[MIC_SUB])
+ snd_soc_dapm_nc_pin(&codec->dapm, "MICBIAS1");
+
+ /* disable fm radio analog input */
+ snd_soc_dapm_nc_pin(&codec->dapm, "IN2RN");
+ snd_soc_dapm_nc_pin(&codec->dapm, "IN2RP:VXRP");
+
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "RCV");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "SPK");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "HP");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "Main Mic");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF1DACDAT");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF2DACDAT");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF3DACDAT");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF1ADCDAT");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF2ADCDAT");
+ snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF3ADCDAT");
+
+ machine->codec = codec;
+
+ codec_micd_set_rate(codec);
+
+ ret = snd_soc_jack_new(codec, "Headset Jack",
+ SND_JACK_HEADSET | SND_JACK_BTN_0 |
+ SND_JACK_BTN_1 | SND_JACK_BTN_2,
+ &machine->jack);
+ if (ret < 0)
+ dev_err(codec->dev, "Failed to create jack: %d\n", ret);
+
+ ret = snd_jack_set_key(machine->jack.jack, SND_JACK_BTN_0, KEY_MEDIA);
+ if (ret < 0)
+ dev_err(codec->dev, "Failed to set KEY_MEDIA: %d\n", ret);
+
+ ret = snd_jack_set_key(machine->jack.jack, SND_JACK_BTN_1,
+ KEY_VOLUMEDOWN);
+ if (ret < 0)
+ dev_err(codec->dev, "Failed to set KEY_VOLUMEUP: %d\n", ret);
+
+ ret = snd_jack_set_key(machine->jack.jack, SND_JACK_BTN_2,
+ KEY_VOLUMEUP);
+ if (ret < 0)
+ dev_err(codec->dev, "Failed to set KEY_VOLUMEDOWN: %d\n", ret);
+
+ /* TODO : check this on fast boot environment */
+ machine->jack.status = 0;
+
+ /* check earjack support */
+ if (machine->ignore_earjack) {
+ dev_info(codec->dev,
+ "Earjack event doesn't support for this board");
+ ret = snd_soc_update_bits(codec, WM8958_MIC_DETECT_1,
+ WM8958_MICD_ENA, 0);
+ if (ret < 0)
+ dev_err(codec->dev,
+ "Failed to disable mic detection: %d\n", ret);
+ } else {
+#if 0
+ ret = wm8958_mic_detect(codec,
+ &machine->jack, codec_micdet, machine);
+ if (ret < 0)
+ dev_err(codec->dev,
+ "Failed start detection: %d\n", ret);
+#endif
+ /* To wakeup for earjack event in suspend mode */
+ enable_irq_wake(wm8994->irq);
+ device_init_wakeup(machine->codec->dev, true);
+ }
+
+ /* To support PBA function test */
+ audio_class = class_create(THIS_MODULE, "audio");
+
+ if (IS_ERR(audio_class))
+ pr_err("Failed to create class\n");
+
+ jack_dev = device_create(audio_class, NULL, 0, codec, "earjack");
+
+ if (device_create_file(jack_dev, &dev_attr_select_jack) < 0)
+ pr_err("Failed to create device file (%s)!\n",
+ dev_attr_select_jack.attr.name);
+
+ caps_dev = device_create(audio_class, NULL, 0, NULL, "caps");
+ dev_set_drvdata(caps_dev, machine);
+
+ if (device_create_file(caps_dev, &dev_attr_cp_caps) < 0)
+ pr_err("Failed to create device file (%s)!\n",
+ dev_attr_cp_caps.attr.name);
+
+ if (device_create_file(caps_dev, &dev_attr_mic_count) < 0)
+ pr_err("Failed to create device file (%s)!\n",
+ dev_attr_mic_count.attr.name);
+
+ return snd_soc_dapm_sync(&codec->dapm);
+}
+
+static struct snd_soc_dai_link machine_dai[] = {
+ {
+ /* Primary DAI i/f */
+ .name = "WM1811 AIF1",
+ .stream_name = "Pri_Dai",
+ .cpu_dai_name = "samsung-i2s.0",
+ .codec_dai_name = "wm8994-aif1",
+ .platform_name = "samsung-i2s.0",
+ .codec_name = "wm8994-codec",
+ .init = machine_init_paiftx,
+ .ops = &machine_aif1_ops,
+ }, {
+ .name = "WM1811 Voice",
+ .stream_name = "Voice Tx/Rx",
+ .cpu_dai_name = "voice-modem",
+ .codec_dai_name = "wm8994-aif2",
+ .platform_name = "snd-soc-dummy",
+ .codec_name = "wm8994-codec",
+ .ops = &machine_aif2_ops,
+ .ignore_suspend = 1,
+ }, {
+ .name = "WM1811 BT",
+ .stream_name = "BT Tx/Rx",
+ .cpu_dai_name = "voice-bluetooth",
+ .codec_dai_name = "wm8994-aif3",
+ .platform_name = "snd-soc-dummy",
+ .codec_name = "wm8994-codec",
+ .ops = &machine_aif3_ops,
+ .ignore_suspend = 1,
+ }, {
+ /* Sec_Fifo DAI i/f */
+ .cpu_dai_name = "samsung-i2s.4",
+ .codec_dai_name = "wm8994-aif1",
+#ifdef CONFIG_SND_SAMSUNG_USE_IDMA
+ .name = "Sec_FIFO TX",
+ .stream_name = "Sec_Dai",
+ .platform_name = "samsung-idma",
+#else
+ .name = "WM1811 AIF1 Playback",
+ .stream_name = "Pri_Dai Playback",
+ .platform_name = "samsung-audio",
+#endif
+ .codec_name = "wm8994-codec",
+ .ops = &machine_aif1_ops,
+ },
+};
+
+static int machine_card_suspend_post(struct snd_soc_card *card)
+{
+ struct exynos_wm1811 *machine = snd_soc_card_get_drvdata(card);
+ struct snd_soc_codec *codec = card->rtd->codec;
+ struct snd_soc_dai *aif1_dai = card->rtd[0].codec_dai;
+ struct snd_soc_dai *aif2_dai = card->rtd[1].codec_dai;
+ int ret;
+
+
+ if (!codec->active) {
+ /* change sysclk from pll out of mclk1 to mclk2
+ to disable mclk1 from AP */
+ dev_info(codec->dev, "use mclk2 and disable fll");
+ ret = snd_soc_dai_set_sysclk(aif2_dai,
+ WM8994_SYSCLK_MCLK2,
+ CODEC_CLK32K,
+ SND_SOC_CLOCK_IN);
+ if (ret < 0)
+ dev_err(codec->dev,
+ "Unable to switch aif2 sysclk to MCLK2: %d\n", ret);
+
+ ret = snd_soc_dai_set_pll(aif2_dai, WM8994_FLL2, 0, 0, 0);
+ if (ret < 0)
+ dev_err(codec->dev,
+ "Unable to stop FLL2: %d\n", ret);
+
+ ret = snd_soc_dai_set_sysclk(aif1_dai,
+ WM8994_SYSCLK_MCLK2,
+ CODEC_CLK32K,
+ SND_SOC_CLOCK_IN);
+ if (ret < 0)
+ dev_err(codec->dev,
+ "Unable to switch aif1 sysclk to MCLK2: %d\n", ret);
+
+ ret = snd_soc_dai_set_pll(aif1_dai, WM8994_FLL1, 0, 0, 0);
+ if (ret < 0)
+ dev_err(codec->dev, "Unsable to stop FLL1: 0x%x", ret);
+
+ /* Jack det rate and mic det rate should be changed
+ to match the above changed sysclk */
+ codec_micd_set_rate(codec);
+
+ clk_disable_unprepare(machine->codec_mclk);
+ }
+
+ snd_soc_dapm_sync(&codec->dapm);
+ return 0;
+}
+
+static int machine_card_resume_pre(struct snd_soc_card *card)
+{
+ struct exynos_wm1811 *machine = snd_soc_card_get_drvdata(card);
+ struct snd_soc_codec *codec = card->rtd->codec;
+ struct snd_soc_dai *aif1_dai = card->rtd[0].codec_dai;
+ int reg = 0;
+ int ret;
+
+ if (!codec->active)
+ clk_prepare_enable(machine->codec_mclk);
+
+ /* change sysclk from mclk2 to pll out of mclk1 */
+ ret = snd_soc_dai_set_pll(aif1_dai, WM8994_FLL1,
+ WM8994_FLL_SRC_MCLK1,
+ XTAL_24MHZ_AP,
+ CODEC_DEFAULT_SYNC_CLK);
+ if (ret < 0)
+ dev_err(aif1_dai->dev, "Unable to start FLL1: 0x%x\n", ret);
+
+ ret = snd_soc_dai_set_sysclk(aif1_dai, WM8994_SYSCLK_FLL1,
+ CODEC_DEFAULT_SYNC_CLK, SND_SOC_CLOCK_IN);
+ if (ret < 0)
+ dev_err(aif1_dai->dev,
+ "Unable to switch sysclk to FLL1: 0x%x\n", ret);
+
+ codec_micd_set_rate(codec);
+
+ /* workaround for jack detection
+ * sometimes WM8994_GPIO_1 type changed wrong function type
+ * so if type mismatched, update to IRQ type
+ */
+ reg = snd_soc_read(codec, WM8994_GPIO_1);
+
+ if ((reg & WM8994_GPN_FN_MASK) != WM8994_GP_FN_IRQ) {
+ dev_err(codec->dev, "%s: GPIO1 type 0x%x\n", __func__, reg);
+ snd_soc_write(codec, WM8994_GPIO_1, WM8994_GP_FN_IRQ);
+ }
+
+ return 0;
+}
+
+static int exynos4_wm1811_parse_dt(struct exynos_wm1811 *machine,
+ struct device *dev)
+{
+ struct device_node *node = dev->of_node;
+ int gpio, ret, i;
+
+ of_property_read_u32_array(node, "samsung,mic-availability",
+ machine->mic_avail,
+ ARRAY_SIZE(machine->mic_avail));
+ machine->ignore_earjack = of_property_read_bool(node,
+ "samsung,ignore-earjack");
+ machine->cp_wb_support = of_property_read_bool(node, "samsung,cp-wb");
+ machine->gpio_vps_en = -EINVAL;
+
+ for (i = MIC_MAIN; i < MIC_MAX; i++) {
+ machine->gpio_mic_bias[i] = -EINVAL;
+
+ if (!machine->mic_avail[i])
+ break;
+
+ gpio = of_get_named_gpio(node, "samsung,mic-en-gpios", i);
+
+ if (!gpio_is_valid(gpio)) {
+ dev_info(dev, "%s uses CODEC MICBIAS1\n", mic_names[i]);
+ continue;
+ }
+ ret = devm_gpio_request_one(dev, gpio, GPIOF_OUT_INIT_LOW,
+ mic_names[i]);
+ if (ret) {
+ dev_err(dev, "%s gpio request failed\n", mic_names[i]);
+ continue;
+ }
+ dev_info(dev, "%s enable GPIO initialized\n", mic_names[i]);
+ machine->gpio_mic_bias[i] = gpio;
+ }
+
+ gpio = of_get_named_gpio(node, "samsung,vps-en-gpios", 0);
+ if (!gpio_is_valid(gpio))
+ return 0;
+ ret = devm_gpio_request_one(dev, gpio, GPIOF_OUT_INIT_LOW, "wm1811");
+ if (!ret)
+ machine->gpio_vps_en = gpio;
+
+ pr_info("gpio: %d, ret: %d\n", ret, gpio);
+ return ret;
+}
+
+static int exynos4_wm1811_probe(struct platform_device *pdev)
+{
+ struct snd_soc_dai_link *dai_link = &machine_dai[0];
+ struct exynos_wm1811 *machine;
+ struct snd_soc_card *card;
+ struct clk *parent, *out_mux;
+ int ret;
+
+ if (!pdev->dev.of_node)
+ return -ENODEV;
+
+ card = devm_kzalloc(&pdev->dev, sizeof(*card), GFP_KERNEL);
+ if (!card)
+ return -ENOMEM;
+
+ card->dai_link = machine_dai;
+ /* FIXME: Enable all audio interfaces */
+ card->num_links = 1; /* ARRAY_SIZE(machine_dai); */
+ card->suspend_post = machine_card_suspend_post;
+ card->resume_pre = machine_card_resume_pre;
+ card->dev = &pdev->dev;
+
+ machine = devm_kzalloc(&pdev->dev, sizeof(*machine), GFP_KERNEL);
+ if (!machine)
+ return -ENOMEM;
+
+ ret = exynos4_wm1811_parse_dt(machine, &pdev->dev);
+ if (ret < 0)
+ return ret;
+
+ dai_link->cpu_dai_name = NULL;
+ dai_link->cpu_of_node = of_parse_phandle(pdev->dev.of_node,
+ "samsung,i2s-controller", 0);
+ if (dai_link->cpu_of_node == NULL) {
+ dev_err(&pdev->dev, "i2s-controller property parse error\n");
+ return -EINVAL;
+ }
+ dai_link->platform_name = NULL;
+ dai_link->platform_of_node = dai_link->cpu_of_node;
+
+ machine->codec_mclk = clk_get(&pdev->dev, "out");
+ if (IS_ERR(machine->codec_mclk)) {
+ dev_err(&pdev->dev, "failed to get out clock\n");
+ return PTR_ERR(machine->codec_mclk);
+ }
+
+ out_mux = clk_get(&pdev->dev, "out-mux");
+ if (IS_ERR(out_mux)) {
+ dev_err(&pdev->dev, "failed to get out mux clock\n");
+ return PTR_ERR(out_mux);
+ }
+
+ parent = clk_get(&pdev->dev, "parent");
+ if (IS_ERR(parent)) {
+ dev_err(&pdev->dev, "failed to get parent clock\n");
+ return PTR_ERR(parent);
+ }
+
+ clk_set_parent(out_mux, parent);
+
+ machine->clk_pll = clk_get(&pdev->dev, "pll");
+ if (IS_ERR(machine->clk_pll)) {
+ dev_err(&pdev->dev, "failed to get pll clock\n");
+ return PTR_ERR(machine->clk_pll);
+ }
+
+ ret = snd_soc_of_parse_card_name(card, "samsung,model");
+ if (ret)
+ return -ENODEV;
+
+ dev_info(&pdev->dev, "Card name is %s\n", card->name);
+ /* FIXME: Clean up on error path */
+
+ snd_soc_card_set_drvdata(card, machine);
+
+ return snd_soc_register_card(card);
+}
+
+static int exynos4_wm1811_remove(struct platform_device *pdev)
+{
+ struct snd_soc_card *card = platform_get_drvdata(pdev);
+ struct exynos_wm1811 *machine = snd_soc_card_get_drvdata(card);
+
+ snd_soc_unregister_card(card);
+ clk_put(machine->codec_mclk);
+ clk_put(machine->clk_pll);
+ return 0;
+}
+
+static const struct of_device_id exynos4_wm1811_of_match[] = {
+ {
+ .compatible = "samsung,exynos4-wm1811",
+ },
+ { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, exynos4_wm1811_of_match);
+
+static struct platform_driver exynos4_wm1811_driver = {
+ .driver = {
+ .name = "exynos4-wm1811",
+ .of_match_table = exynos4_wm1811_of_match,
+ .owner = THIS_MODULE,
+ .pm = &snd_soc_pm_ops,
+ },
+ .probe = exynos4_wm1811_probe,
+ .remove = exynos4_wm1811_remove,
+};
+
+module_platform_driver(exynos4_wm1811_driver);
+
+MODULE_AUTHOR("KwangHui Cho <kwanghui.cho@samsung.com>");
+MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
+MODULE_DESCRIPTION("Exynos4+WM1811 machine ASoC driver");
+MODULE_LICENSE("GPL");
projects / platform / kernel / linux-3.10.git / commitdiff