Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tegra_wm8903.c
Go to the documentation of this file.
1 /*
2  * tegra_wm8903.c - Tegra machine ASoC driver for boards using WM8903 codec.
3  *
4  * Author: Stephen Warren <[email protected]>
5  * Copyright (C) 2010-2012 - NVIDIA, Inc.
6  *
7  * Based on code copyright/by:
8  *
9  * (c) 2009, 2010 Nvidia Graphics Pvt. Ltd.
10  *
11  * Copyright 2007 Wolfson Microelectronics PLC.
12  * Author: Graeme Gregory
13  * [email protected] or [email protected]
14  *
15  * This program is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU General Public License
17  * version 2 as published by the Free Software Foundation.
18  *
19  * This program is distributed in the hope that it will be useful, but
20  * WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22  * General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
27  * 02110-1301 USA
28  *
29  */
30 
31 #include <linux/module.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
34 #include <linux/gpio.h>
35 #include <linux/of_gpio.h>
36 
37 #include <sound/core.h>
38 #include <sound/jack.h>
39 #include <sound/pcm.h>
40 #include <sound/pcm_params.h>
41 #include <sound/soc.h>
42 #include <sound/tegra_wm8903.h>
43 
44 #include "../codecs/wm8903.h"
45 
46 #include "tegra_asoc_utils.h"
47 
48 #define DRV_NAME "tegra-snd-wm8903"
49 
50 struct tegra_wm8903 {
51  struct tegra_wm8903_platform_data pdata;
52  struct tegra_asoc_utils_data util_data;
53 };
54 
55 static int tegra_wm8903_hw_params(struct snd_pcm_substream *substream,
56  struct snd_pcm_hw_params *params)
57 {
58  struct snd_soc_pcm_runtime *rtd = substream->private_data;
59  struct snd_soc_dai *codec_dai = rtd->codec_dai;
60  struct snd_soc_codec *codec = codec_dai->codec;
61  struct snd_soc_card *card = codec->card;
62  struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
63  int srate, mclk;
64  int err;
65 
66  srate = params_rate(params);
67  switch (srate) {
68  case 64000:
69  case 88200:
70  case 96000:
71  mclk = 128 * srate;
72  break;
73  default:
74  mclk = 256 * srate;
75  break;
76  }
77  /* FIXME: Codec only requires >= 3MHz if OSR==0 */
78  while (mclk < 6000000)
79  mclk *= 2;
80 
81  err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
82  if (err < 0) {
83  dev_err(card->dev, "Can't configure clocks\n");
84  return err;
85  }
86 
87  err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
88  SND_SOC_CLOCK_IN);
89  if (err < 0) {
90  dev_err(card->dev, "codec_dai clock not set\n");
91  return err;
92  }
93 
94  return 0;
95 }
96 
97 static struct snd_soc_ops tegra_wm8903_ops = {
98  .hw_params = tegra_wm8903_hw_params,
99 };
100 
101 static struct snd_soc_jack tegra_wm8903_hp_jack;
102 
103 static struct snd_soc_jack_pin tegra_wm8903_hp_jack_pins[] = {
104  {
105  .pin = "Headphone Jack",
106  .mask = SND_JACK_HEADPHONE,
107  },
108 };
109 
110 static struct snd_soc_jack_gpio tegra_wm8903_hp_jack_gpio = {
111  .name = "headphone detect",
112  .report = SND_JACK_HEADPHONE,
113  .debounce_time = 150,
114  .invert = 1,
115 };
116 
117 static struct snd_soc_jack tegra_wm8903_mic_jack;
118 
119 static struct snd_soc_jack_pin tegra_wm8903_mic_jack_pins[] = {
120  {
121  .pin = "Mic Jack",
122  .mask = SND_JACK_MICROPHONE,
123  },
124 };
125 
126 static int tegra_wm8903_event_int_spk(struct snd_soc_dapm_widget *w,
127  struct snd_kcontrol *k, int event)
128 {
129  struct snd_soc_dapm_context *dapm = w->dapm;
130  struct snd_soc_card *card = dapm->card;
131  struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
132  struct tegra_wm8903_platform_data *pdata = &machine->pdata;
133 
134  if (!gpio_is_valid(pdata->gpio_spkr_en))
135  return 0;
136 
137  gpio_set_value_cansleep(pdata->gpio_spkr_en,
138  SND_SOC_DAPM_EVENT_ON(event));
139 
140  return 0;
141 }
142 
143 static int tegra_wm8903_event_hp(struct snd_soc_dapm_widget *w,
144  struct snd_kcontrol *k, int event)
145 {
146  struct snd_soc_dapm_context *dapm = w->dapm;
147  struct snd_soc_card *card = dapm->card;
148  struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
149  struct tegra_wm8903_platform_data *pdata = &machine->pdata;
150 
151  if (!gpio_is_valid(pdata->gpio_hp_mute))
152  return 0;
153 
154  gpio_set_value_cansleep(pdata->gpio_hp_mute,
155  !SND_SOC_DAPM_EVENT_ON(event));
156 
157  return 0;
158 }
159 
160 static const struct snd_soc_dapm_widget tegra_wm8903_dapm_widgets[] = {
161  SND_SOC_DAPM_SPK("Int Spk", tegra_wm8903_event_int_spk),
162  SND_SOC_DAPM_HP("Headphone Jack", tegra_wm8903_event_hp),
163  SND_SOC_DAPM_MIC("Mic Jack", NULL),
164 };
165 
166 static const struct snd_soc_dapm_route harmony_audio_map[] = {
167  {"Headphone Jack", NULL, "HPOUTR"},
168  {"Headphone Jack", NULL, "HPOUTL"},
169  {"Int Spk", NULL, "ROP"},
170  {"Int Spk", NULL, "RON"},
171  {"Int Spk", NULL, "LOP"},
172  {"Int Spk", NULL, "LON"},
173  {"Mic Jack", NULL, "MICBIAS"},
174  {"IN1L", NULL, "Mic Jack"},
175 };
176 
177 static const struct snd_kcontrol_new tegra_wm8903_controls[] = {
178  SOC_DAPM_PIN_SWITCH("Int Spk"),
179 };
180 
181 static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd)
182 {
183  struct snd_soc_dai *codec_dai = rtd->codec_dai;
184  struct snd_soc_codec *codec = codec_dai->codec;
185  struct snd_soc_dapm_context *dapm = &codec->dapm;
186  struct snd_soc_card *card = codec->card;
187  struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
188  struct tegra_wm8903_platform_data *pdata = &machine->pdata;
189 
190  if (gpio_is_valid(pdata->gpio_hp_det)) {
191  tegra_wm8903_hp_jack_gpio.gpio = pdata->gpio_hp_det;
192  snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
193  &tegra_wm8903_hp_jack);
194  snd_soc_jack_add_pins(&tegra_wm8903_hp_jack,
195  ARRAY_SIZE(tegra_wm8903_hp_jack_pins),
196  tegra_wm8903_hp_jack_pins);
197  snd_soc_jack_add_gpios(&tegra_wm8903_hp_jack,
198  1,
199  &tegra_wm8903_hp_jack_gpio);
200  }
201 
202  snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,
203  &tegra_wm8903_mic_jack);
204  snd_soc_jack_add_pins(&tegra_wm8903_mic_jack,
205  ARRAY_SIZE(tegra_wm8903_mic_jack_pins),
206  tegra_wm8903_mic_jack_pins);
207  wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE,
208  0);
209 
210  snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
211 
212  return 0;
213 }
214 
215 static int tegra_wm8903_remove(struct snd_soc_card *card)
216 {
217  struct snd_soc_pcm_runtime *rtd = &(card->rtd[0]);
218  struct snd_soc_dai *codec_dai = rtd->codec_dai;
219  struct snd_soc_codec *codec = codec_dai->codec;
220 
221  wm8903_mic_detect(codec, NULL, 0, 0);
222 
223  return 0;
224 }
225 
226 static struct snd_soc_dai_link tegra_wm8903_dai = {
227  .name = "WM8903",
228  .stream_name = "WM8903 PCM",
229  .codec_name = "wm8903.0-001a",
230  .platform_name = "tegra20-i2s.0",
231  .cpu_dai_name = "tegra20-i2s.0",
232  .codec_dai_name = "wm8903-hifi",
233  .init = tegra_wm8903_init,
234  .ops = &tegra_wm8903_ops,
235  .dai_fmt = SND_SOC_DAIFMT_I2S |
236  SND_SOC_DAIFMT_NB_NF |
237  SND_SOC_DAIFMT_CBS_CFS,
238 };
239 
240 static struct snd_soc_card snd_soc_tegra_wm8903 = {
241  .name = "tegra-wm8903",
242  .owner = THIS_MODULE,
243  .dai_link = &tegra_wm8903_dai,
244  .num_links = 1,
245 
246  .remove = tegra_wm8903_remove,
247 
248  .controls = tegra_wm8903_controls,
249  .num_controls = ARRAY_SIZE(tegra_wm8903_controls),
250  .dapm_widgets = tegra_wm8903_dapm_widgets,
251  .num_dapm_widgets = ARRAY_SIZE(tegra_wm8903_dapm_widgets),
252  .fully_routed = true,
253 };
254 
255 static __devinit int tegra_wm8903_driver_probe(struct platform_device *pdev)
256 {
257  struct device_node *np = pdev->dev.of_node;
258  struct snd_soc_card *card = &snd_soc_tegra_wm8903;
259  struct tegra_wm8903 *machine;
260  struct tegra_wm8903_platform_data *pdata;
261  int ret;
262 
263  if (!pdev->dev.platform_data && !pdev->dev.of_node) {
264  dev_err(&pdev->dev, "No platform data supplied\n");
265  return -EINVAL;
266  }
267 
268  machine = devm_kzalloc(&pdev->dev, sizeof(struct tegra_wm8903),
269  GFP_KERNEL);
270  if (!machine) {
271  dev_err(&pdev->dev, "Can't allocate tegra_wm8903 struct\n");
272  ret = -ENOMEM;
273  goto err;
274  }
275  pdata = &machine->pdata;
276 
277  card->dev = &pdev->dev;
278  platform_set_drvdata(pdev, card);
279  snd_soc_card_set_drvdata(card, machine);
280 
281  if (pdev->dev.platform_data) {
282  memcpy(pdata, card->dev->platform_data, sizeof(*pdata));
283  } else if (np) {
284  pdata->gpio_spkr_en = of_get_named_gpio(np,
285  "nvidia,spkr-en-gpios", 0);
286  if (pdata->gpio_spkr_en == -EPROBE_DEFER)
287  return -EPROBE_DEFER;
288 
289  pdata->gpio_hp_mute = of_get_named_gpio(np,
290  "nvidia,hp-mute-gpios", 0);
291  if (pdata->gpio_hp_mute == -EPROBE_DEFER)
292  return -EPROBE_DEFER;
293 
294  pdata->gpio_hp_det = of_get_named_gpio(np,
295  "nvidia,hp-det-gpios", 0);
296  if (pdata->gpio_hp_det == -EPROBE_DEFER)
297  return -EPROBE_DEFER;
298 
299  pdata->gpio_int_mic_en = of_get_named_gpio(np,
300  "nvidia,int-mic-en-gpios", 0);
301  if (pdata->gpio_int_mic_en == -EPROBE_DEFER)
302  return -EPROBE_DEFER;
303 
304  pdata->gpio_ext_mic_en = of_get_named_gpio(np,
305  "nvidia,ext-mic-en-gpios", 0);
306  if (pdata->gpio_ext_mic_en == -EPROBE_DEFER)
307  return -EPROBE_DEFER;
308  }
309 
310  if (np) {
311  ret = snd_soc_of_parse_card_name(card, "nvidia,model");
312  if (ret)
313  goto err;
314 
315  ret = snd_soc_of_parse_audio_routing(card,
316  "nvidia,audio-routing");
317  if (ret)
318  goto err;
319 
320  tegra_wm8903_dai.codec_name = NULL;
321  tegra_wm8903_dai.codec_of_node = of_parse_phandle(np,
322  "nvidia,audio-codec", 0);
323  if (!tegra_wm8903_dai.codec_of_node) {
324  dev_err(&pdev->dev,
325  "Property 'nvidia,audio-codec' missing or invalid\n");
326  ret = -EINVAL;
327  goto err;
328  }
329 
330  tegra_wm8903_dai.cpu_dai_name = NULL;
331  tegra_wm8903_dai.cpu_of_node = of_parse_phandle(np,
332  "nvidia,i2s-controller", 0);
333  if (!tegra_wm8903_dai.cpu_of_node) {
334  dev_err(&pdev->dev,
335  "Property 'nvidia,i2s-controller' missing or invalid\n");
336  ret = -EINVAL;
337  goto err;
338  }
339 
340  tegra_wm8903_dai.platform_name = NULL;
341  tegra_wm8903_dai.platform_of_node =
342  tegra_wm8903_dai.cpu_of_node;
343  } else {
344  card->dapm_routes = harmony_audio_map;
345  card->num_dapm_routes = ARRAY_SIZE(harmony_audio_map);
346  }
347 
348  if (gpio_is_valid(pdata->gpio_spkr_en)) {
349  ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_spkr_en,
350  GPIOF_OUT_INIT_LOW, "spkr_en");
351  if (ret) {
352  dev_err(card->dev, "cannot get spkr_en gpio\n");
353  return ret;
354  }
355  }
356 
357  if (gpio_is_valid(pdata->gpio_hp_mute)) {
358  ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_hp_mute,
359  GPIOF_OUT_INIT_HIGH, "hp_mute");
360  if (ret) {
361  dev_err(card->dev, "cannot get hp_mute gpio\n");
362  return ret;
363  }
364  }
365 
366  if (gpio_is_valid(pdata->gpio_int_mic_en)) {
367  /* Disable int mic; enable signal is active-high */
368  ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_int_mic_en,
369  GPIOF_OUT_INIT_LOW, "int_mic_en");
370  if (ret) {
371  dev_err(card->dev, "cannot get int_mic_en gpio\n");
372  return ret;
373  }
374  }
375 
376  if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
377  /* Enable ext mic; enable signal is active-low */
378  ret = devm_gpio_request_one(&pdev->dev, pdata->gpio_ext_mic_en,
379  GPIOF_OUT_INIT_LOW, "ext_mic_en");
380  if (ret) {
381  dev_err(card->dev, "cannot get ext_mic_en gpio\n");
382  return ret;
383  }
384  }
385 
386  ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);
387  if (ret)
388  goto err;
389 
390  ret = snd_soc_register_card(card);
391  if (ret) {
392  dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
393  ret);
394  goto err_fini_utils;
395  }
396 
397  return 0;
398 
399 err_fini_utils:
400  tegra_asoc_utils_fini(&machine->util_data);
401 err:
402  return ret;
403 }
404 
405 static int __devexit tegra_wm8903_driver_remove(struct platform_device *pdev)
406 {
407  struct snd_soc_card *card = platform_get_drvdata(pdev);
408  struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
409 
410  snd_soc_jack_free_gpios(&tegra_wm8903_hp_jack, 1,
411  &tegra_wm8903_hp_jack_gpio);
412 
413  snd_soc_unregister_card(card);
414 
415  tegra_asoc_utils_fini(&machine->util_data);
416 
417  return 0;
418 }
419 
420 static const struct of_device_id tegra_wm8903_of_match[] __devinitconst = {
421  { .compatible = "nvidia,tegra-audio-wm8903", },
422  {},
423 };
424 
425 static struct platform_driver tegra_wm8903_driver = {
426  .driver = {
427  .name = DRV_NAME,
428  .owner = THIS_MODULE,
429  .pm = &snd_soc_pm_ops,
430  .of_match_table = tegra_wm8903_of_match,
431  },
432  .probe = tegra_wm8903_driver_probe,
433  .remove = __devexit_p(tegra_wm8903_driver_remove),
434 };
435 module_platform_driver(tegra_wm8903_driver);
436 
437 MODULE_AUTHOR("Stephen Warren <[email protected]>");
438 MODULE_DESCRIPTION("Tegra+WM8903 machine ASoC driver");
439 MODULE_LICENSE("GPL");
440 MODULE_ALIAS("platform:" DRV_NAME);
441 MODULE_DEVICE_TABLE(of, tegra_wm8903_of_match);
Generated on Thu Jan 10 2013 15:08:36 for Linux Kernel by   doxygen 1.8.2