asoc: tegra: Fix cs42l73 mclk for all sample rates
[linux-2.6.git] / sound / soc / tegra / tegra_cs42l73.c
1 /*
2  * tegra_cs42l73.c - Tegra machine ASoC driver for boards using CS42L73 codec.
3  *
4  * Author: Vijay Mali <vmali@nvidia.com>
5  * Copyright (C) 2011-2012, NVIDIA, Inc.
6  *
7  * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23
24 #include <asm/mach-types.h>
25
26 #include <linux/clk.h>
27 #include <linux/module.h>
28 #include <linux/platform_device.h>
29 #include <linux/slab.h>
30 #include <linux/gpio.h>
31 #include <linux/regulator/consumer.h>
32 #include <linux/delay.h>
33 #ifdef CONFIG_SWITCH
34 #include <linux/switch.h>
35 #endif
36 #include <mach/tegra_asoc_pdata.h>
37 #include <mach/gpio-tegra.h>
38
39 #include <sound/core.h>
40 #include <sound/jack.h>
41 #include <sound/pcm.h>
42 #include <sound/pcm_params.h>
43 #include <sound/soc.h>
44
45 #include "../codecs/cs42l73.h"
46
47 #include "tegra_pcm.h"
48 #include "tegra_asoc_utils.h"
49
50 #define DRV_NAME "tegra-snd-cs42l73"
51
52 #define GPIO_SPKR_EN    BIT(0)
53 #define GPIO_HP_MUTE    BIT(1)
54 #define GPIO_INT_MIC_EN BIT(2)
55 #define GPIO_EXT_MIC_EN BIT(3)
56 #define GPIO_HP_DET     BIT(4)
57
58 struct tegra_cs42l73 {
59         struct tegra_asoc_utils_data util_data;
60         struct tegra_asoc_platform_data *pdata;
61         struct regulator *spk_reg;
62         struct regulator *dmic_reg;
63         struct regulator *cdc_en;
64         int gpio_requested;
65         enum snd_soc_bias_level bias_level;
66         int clock_enabled;
67 };
68
69 static int tegra_cs42l73_hw_params(struct snd_pcm_substream *substream,
70                                         struct snd_pcm_hw_params *params)
71 {
72         struct snd_soc_pcm_runtime *rtd = substream->private_data;
73         struct snd_soc_dai *codec_dai = rtd->codec_dai;
74         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
75         struct snd_soc_codec *codec = rtd->codec;
76         struct snd_soc_card *card = codec->card;
77         struct tegra_cs42l73 *machine = snd_soc_card_get_drvdata(card);
78         struct tegra_asoc_platform_data *pdata = machine->pdata;
79         int srate, mclk, i2s_daifmt;
80         int err, rate;
81
82         srate = params_rate(params);
83
84         switch (srate) {
85         case 8000:
86         case 16000:
87         case 32000:
88                 mclk = 12288000;
89                 break;
90         case 11025:
91                 mclk = 512 * srate;
92                 break;
93         default:
94                 mclk = 256 * srate;
95                 break;
96         }
97
98         i2s_daifmt = SND_SOC_DAIFMT_NB_NF;
99         i2s_daifmt |= pdata->i2s_param[HIFI_CODEC].is_i2s_master ?
100                         SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBM_CFM;
101
102         switch (pdata->i2s_param[HIFI_CODEC].i2s_mode) {
103         case TEGRA_DAIFMT_I2S:
104                 i2s_daifmt |= SND_SOC_DAIFMT_I2S;
105                 break;
106         case TEGRA_DAIFMT_DSP_A:
107                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
108                 break;
109         case TEGRA_DAIFMT_DSP_B:
110                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_B;
111                 break;
112         case TEGRA_DAIFMT_LEFT_J:
113                 i2s_daifmt |= SND_SOC_DAIFMT_LEFT_J;
114                 break;
115         case TEGRA_DAIFMT_RIGHT_J:
116                 i2s_daifmt |= SND_SOC_DAIFMT_RIGHT_J;
117                 break;
118         default:
119                 dev_err(card->dev, "Can't configure i2s format\n");
120                 return -EINVAL;
121         }
122
123         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
124         if (err < 0) {
125                 if (!(machine->util_data.set_mclk % mclk)) {
126                         mclk = machine->util_data.set_mclk;
127                 } else {
128                         dev_err(card->dev, "Can't configure clocks\n");
129                         return err;
130                 }
131         }
132
133         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
134
135         rate = clk_get_rate(machine->util_data.clk_cdev1);
136
137         err = snd_soc_dai_set_fmt(codec_dai, i2s_daifmt);
138         if (err < 0) {
139                 dev_err(card->dev, "codec_dai fmt not set\n");
140                 return err;
141         }
142
143         err = snd_soc_dai_set_fmt(cpu_dai, i2s_daifmt);
144         if (err < 0) {
145                 dev_err(card->dev, "cpu_dai fmt not set\n");
146                 return err;
147         }
148
149         err = snd_soc_dai_set_sysclk(codec_dai, 0, rate, SND_SOC_CLOCK_IN);
150         if (err < 0) {
151                 dev_err(card->dev, "codec_dai clock not set\n");
152                 return err;
153         }
154
155         return 0;
156 }
157
158 static int tegra_hw_free(struct snd_pcm_substream *substream)
159 {
160         struct snd_soc_pcm_runtime *rtd = substream->private_data;
161         struct tegra_cs42l73 *machine = snd_soc_card_get_drvdata(rtd->card);
162
163         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
164
165         return 0;
166 }
167
168 static struct snd_soc_ops tegra_cs42l73_ops = {
169         .hw_params = tegra_cs42l73_hw_params,
170         .hw_free = tegra_hw_free,
171 };
172
173 static struct snd_soc_jack tegra_cs42l73_hp_jack;
174
175 static struct snd_soc_jack_gpio tegra_cs42l73_hp_jack_gpio = {
176         .name = "headphone detect",
177         .report = SND_JACK_HEADPHONE,
178         .debounce_time = 150,
179         .invert = 1,
180 };
181
182 static int tegra_cs42l73_event_headset_mic(struct snd_soc_dapm_widget *w,
183                                         struct snd_kcontrol *k, int event)
184 {
185
186         struct snd_soc_codec *codec = w->codec;
187         snd_soc_update_bits(codec, CS42L73_DMMCC, MCLKDIS, 0);
188         snd_soc_update_bits(codec, CS42L73_PWRCTL1, PDN, 0);
189         snd_soc_update_bits(codec, CS42L73_PWRCTL2, PDN_MIC2_BIAS, 0);
190
191         /* Unmask MIC2_SDET interrupt */
192         snd_soc_update_bits(codec, CS42L73_IM1, MIC2_SDET, 1);
193
194         return 0;
195 }
196
197 static const struct snd_soc_dapm_widget tegra_cs42l73_dapm_widgets[] = {
198         SND_SOC_DAPM_HP("Headphone", NULL),
199         SND_SOC_DAPM_MIC("Headset Mic", tegra_cs42l73_event_headset_mic),
200 };
201
202 static const struct snd_soc_dapm_route tegra_cs42l73_audio_map[] = {
203         {"MIC2", NULL, "Headset Mic"},
204         /* Headphone (L+R)->  HPOUTA, HPOUTB */
205         {"Headphone", NULL, "HPOUTA"},
206         {"Headphone", NULL, "HPOUTB"},
207 };
208
209 static const struct snd_kcontrol_new tegra_cs42l73_controls[] = {
210         SOC_DAPM_PIN_SWITCH("Headphone"),
211         SOC_DAPM_PIN_SWITCH("Headset Mic"),
212 };
213
214 static int tegra_cs42l73_init(struct snd_soc_pcm_runtime *rtd)
215 {
216         struct snd_soc_codec *codec = rtd->codec;
217         struct snd_soc_dapm_context *dapm = &codec->dapm;
218         struct snd_soc_card *card = codec->card;
219         struct tegra_cs42l73 *machine = snd_soc_card_get_drvdata(card);
220         struct tegra_asoc_platform_data *pdata = machine->pdata;
221         int ret;
222
223         if (gpio_is_valid(pdata->gpio_spkr_en)) {
224                 ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
225                 if (ret) {
226                         dev_err(card->dev, "cannot get spkr_en gpio\n");
227                         return ret;
228                 }
229                 machine->gpio_requested |= GPIO_SPKR_EN;
230
231                 gpio_direction_output(pdata->gpio_spkr_en, 0);
232         }
233
234         if (gpio_is_valid(pdata->gpio_hp_mute)) {
235                 ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
236                 if (ret) {
237                         dev_err(card->dev, "cannot get hp_mute gpio\n");
238                         return ret;
239                 }
240                 machine->gpio_requested |= GPIO_HP_MUTE;
241
242                 gpio_direction_output(pdata->gpio_hp_mute, 0);
243         }
244
245         if (gpio_is_valid(pdata->gpio_int_mic_en)) {
246                 ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
247                 if (ret) {
248                         dev_err(card->dev, "cannot get int_mic_en gpio\n");
249                         return ret;
250                 }
251                 machine->gpio_requested |= GPIO_INT_MIC_EN;
252
253                 /* Disable int mic; enable signal is active-high */
254                 gpio_direction_output(pdata->gpio_int_mic_en, 0);
255         }
256
257         if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
258                 ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
259                 if (ret)
260                         dev_err(card->dev, "cannot get ext_mic_en gpio\n");
261                 else {
262                         machine->gpio_requested |= GPIO_EXT_MIC_EN;
263                         /* Disable ext mic; enable signal is active-low */
264                         gpio_direction_output(pdata->gpio_ext_mic_en, 1);
265                 }
266         }
267
268         machine->bias_level = SND_SOC_BIAS_STANDBY;
269         machine->clock_enabled = 1;
270
271         ret = snd_soc_add_card_controls(card, tegra_cs42l73_controls,
272                         ARRAY_SIZE(tegra_cs42l73_controls));
273         if (ret < 0)
274                 return ret;
275
276         snd_soc_dapm_new_controls(dapm, tegra_cs42l73_dapm_widgets,
277                         ARRAY_SIZE(tegra_cs42l73_dapm_widgets));
278
279         snd_soc_dapm_add_routes(dapm, tegra_cs42l73_audio_map,
280                                 ARRAY_SIZE(tegra_cs42l73_audio_map));
281
282         ret = tegra_asoc_utils_register_ctls(&machine->util_data);
283         if (ret < 0)
284                 return ret;
285
286         /* FIXME: Calculate automatically based on DAPM routes? */
287         snd_soc_dapm_nc_pin(dapm, "LOUTL");
288         snd_soc_dapm_nc_pin(dapm, "LOUTR");
289
290         snd_soc_dapm_sync(dapm);
291
292         return 0;
293 }
294
295 static struct snd_soc_dai_link tegra_cs42l73_dai[] = {
296         {
297                 .name = "CS42L73",
298                 .stream_name = "VSP Playback Record",
299                 .codec_name = "cs42l73.0-004a",
300                 .platform_name = "tegra-pcm-audio",
301                 .cpu_dai_name = "tegra30-i2s.1",
302                 .codec_dai_name = "cs42l73-vsp",
303                 .init = tegra_cs42l73_init,
304                 .ops = &tegra_cs42l73_ops,
305         },
306 };
307
308 static int tegra_cs42l73_resume_pre(struct snd_soc_card *card)
309 {
310         int val;
311         struct snd_soc_jack_gpio *gpio = &tegra_cs42l73_hp_jack_gpio;
312
313         if (gpio_is_valid(gpio->gpio)) {
314                 val = gpio_get_value(gpio->gpio);
315                 val = gpio->invert ? !val : val;
316                 snd_soc_jack_report(gpio->jack, val, gpio->report);
317         }
318
319         return 0;
320 }
321
322 static int tegra_cs42l73_set_bias_level(struct snd_soc_card *card,
323         struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
324 {
325         struct tegra_cs42l73 *machine = snd_soc_card_get_drvdata(card);
326
327         if (machine->bias_level == SND_SOC_BIAS_OFF &&
328                 level != SND_SOC_BIAS_OFF && (!machine->clock_enabled)) {
329                 machine->clock_enabled = 1;
330                 tegra_asoc_utils_clk_enable(&machine->util_data);
331                 machine->bias_level = level;
332         }
333
334         return 0;
335 }
336
337 static int tegra_cs42l73_set_bias_level_post(struct snd_soc_card *card,
338         struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
339 {
340         struct tegra_cs42l73 *machine = snd_soc_card_get_drvdata(card);
341
342         if (machine->bias_level != SND_SOC_BIAS_OFF &&
343                 level == SND_SOC_BIAS_OFF && machine->clock_enabled) {
344                 machine->clock_enabled = 0;
345                 tegra_asoc_utils_clk_disable(&machine->util_data);
346         }
347
348         machine->bias_level = level;
349
350         return 0 ;
351 }
352
353 static struct snd_soc_card snd_soc_tegra_cs42l73 = {
354         .name = "tegra-cs42l73",
355         .owner = THIS_MODULE,
356         .dai_link = tegra_cs42l73_dai,
357         .num_links = ARRAY_SIZE(tegra_cs42l73_dai),
358         .resume_pre = tegra_cs42l73_resume_pre,
359         .set_bias_level = tegra_cs42l73_set_bias_level,
360         .set_bias_level_post = tegra_cs42l73_set_bias_level_post,
361 };
362
363 static __devinit int tegra_cs42l73_driver_probe(struct platform_device *pdev)
364 {
365         struct snd_soc_card *card = &snd_soc_tegra_cs42l73;
366         struct tegra_cs42l73 *machine;
367         struct tegra_asoc_platform_data *pdata;
368         int ret;
369         pdata = pdev->dev.platform_data;
370         if (!pdata) {
371                 dev_err(&pdev->dev, "No platform data supplied\n");
372                 return -EINVAL;
373         }
374
375         if (pdata->codec_name)
376                 card->dai_link->codec_name = pdata->codec_name;
377
378         if (pdata->codec_dai_name)
379                 card->dai_link->codec_dai_name = pdata->codec_dai_name;
380
381         machine = kzalloc(sizeof(struct tegra_cs42l73), GFP_KERNEL);
382         if (!machine) {
383                 dev_err(&pdev->dev, "Can't allocate tegra_cs42l73 struct\n");
384                 return -ENOMEM;
385         }
386
387         if (gpio_is_valid(pdata->gpio_ldo1_en)) {
388                 ret = gpio_request(pdata->gpio_ldo1_en, "cs42l73");
389                 if (ret)
390                         dev_err(&pdev->dev, "Fail gpio_request AUDIO_LDO1\n");
391
392                 ret = gpio_direction_output(pdata->gpio_ldo1_en, 0);
393                 if (ret)
394                         dev_err(&pdev->dev, "Fail gpio_direction AUDIO_LDO1\n");
395
396                 msleep(200);
397         }
398
399         machine->pdata = pdata;
400
401         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
402         if (ret)
403                 goto err_free_machine;
404
405         machine->spk_reg = regulator_get(&pdev->dev, "vdd_spk");
406         if (IS_ERR(machine->spk_reg)) {
407                 dev_info(&pdev->dev, "No speaker regulator found\n");
408                 machine->spk_reg = 0;
409         }
410
411         machine->dmic_reg = regulator_get(&pdev->dev, "vdd_mic");
412         if (IS_ERR(machine->dmic_reg)) {
413                 dev_info(&pdev->dev, "No digital mic regulator found\n");
414                 machine->dmic_reg = 0;
415         } else
416                 regulator_enable(machine->dmic_reg);
417
418         card->dev = &pdev->dev;
419         platform_set_drvdata(pdev, card);
420         snd_soc_card_set_drvdata(card, machine);
421         card->dapm.idle_bias_off = 1;
422         ret = snd_soc_register_card(card);
423         if (ret) {
424                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
425                         ret);
426                 goto err_unregister_switch;
427         }
428
429         if (!card->instantiated) {
430                 ret = -ENODEV;
431                 dev_err(&pdev->dev, "sound card not instantiated (%d)\n",
432                         ret);
433                 goto err_unregister_card;
434         }
435
436         ret = tegra_asoc_utils_set_parent(&machine->util_data,
437                                 pdata->i2s_param[HIFI_CODEC].is_i2s_master);
438         if (ret) {
439                 dev_err(&pdev->dev, "tegra_asoc_utils_set_parent failed (%d)\n",
440                         ret);
441                 goto err_unregister_card;
442         }
443
444         return 0;
445
446 err_unregister_card:
447         snd_soc_unregister_card(card);
448 err_unregister_switch:
449         tegra_asoc_utils_fini(&machine->util_data);
450 err_free_machine:
451         kfree(machine);
452         return ret;
453 }
454
455 static int __devexit tegra_cs42l73_driver_remove(struct platform_device *pdev)
456 {
457         struct snd_soc_card *card = platform_get_drvdata(pdev);
458         struct tegra_cs42l73 *machine = snd_soc_card_get_drvdata(card);
459         struct tegra_asoc_platform_data *pdata = machine->pdata;
460
461         if (machine->gpio_requested & GPIO_HP_DET)
462                 snd_soc_jack_free_gpios(&tegra_cs42l73_hp_jack,
463                                         1,
464                                         &tegra_cs42l73_hp_jack_gpio);
465         if (machine->gpio_requested & GPIO_EXT_MIC_EN)
466                 gpio_free(pdata->gpio_ext_mic_en);
467         if (machine->gpio_requested & GPIO_INT_MIC_EN)
468                 gpio_free(pdata->gpio_int_mic_en);
469         if (machine->gpio_requested & GPIO_HP_MUTE)
470                 gpio_free(pdata->gpio_hp_mute);
471         if (machine->gpio_requested & GPIO_SPKR_EN)
472                 gpio_free(pdata->gpio_spkr_en);
473         machine->gpio_requested = 0;
474
475         if (machine->spk_reg)
476                 regulator_put(machine->spk_reg);
477         if (machine->dmic_reg)
478                 regulator_put(machine->dmic_reg);
479
480         if (machine->cdc_en) {
481                 regulator_disable(machine->cdc_en);
482                 regulator_put(machine->cdc_en);
483         }
484
485         if (gpio_is_valid(pdata->gpio_ldo1_en)) {
486                 gpio_set_value(pdata->gpio_ldo1_en, 0);
487                 gpio_free(pdata->gpio_ldo1_en);
488         }
489
490         snd_soc_unregister_card(card);
491
492         tegra_asoc_utils_fini(&machine->util_data);
493
494         kfree(machine);
495
496         return 0;
497 }
498
499 static struct platform_driver tegra_cs42l73_driver = {
500         .driver = {
501                 .name = DRV_NAME,
502                 .owner = THIS_MODULE,
503                 .pm = &snd_soc_pm_ops,
504         },
505         .probe = tegra_cs42l73_driver_probe,
506         .remove = __devexit_p(tegra_cs42l73_driver_remove),
507 };
508
509 static int __init tegra_cs42l73_modinit(void)
510 {
511         return platform_driver_register(&tegra_cs42l73_driver);
512 }
513 module_init(tegra_cs42l73_modinit);
514
515 static void __exit tegra_cs42l73_modexit(void)
516 {
517         platform_driver_unregister(&tegra_cs42l73_driver);
518 }
519 module_exit(tegra_cs42l73_modexit);
520
521 MODULE_AUTHOR("Vijay Mali <vmali@nvidia.com>");
522 MODULE_DESCRIPTION("Tegra+CS42L73 machine ASoC driver");
523 MODULE_LICENSE("GPL");
524 MODULE_ALIAS("platform:" DRV_NAME);