ASoC: tegra: Notify SAR about speaker state
[linux-3.10.git] / sound / soc / tegra-alt / tegra_t210ref_mobile_es755_alt.c
1 /*
2  * tegra_t210ref_mobile.c - Tegra T210 Machine driver for mobile
3  *
4  * Copyright (c) 2013-2015 NVIDIA CORPORATION.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/module.h>
20 #include <linux/kobject.h>
21 #include <linux/sysfs.h>
22 #include <linux/platform_device.h>
23 #include <linux/slab.h>
24 #include <linux/gpio.h>
25 #include <linux/of_gpio.h>
26 #include <linux/i2c.h>
27 #include <linux/regulator/consumer.h>
28 #include <linux/delay.h>
29 #include <linux/sysedp.h>
30 #include <linux/input.h>
31 #include <linux/tegra-pmc.h>
32 #ifdef CONFIG_SWITCH
33 #include <linux/switch.h>
34 #endif
35 #include <linux/pm_runtime.h>
36 #include <mach/tegra_asoc_pdata.h>
37 #include <mach/tegra_rt5640_pdata.h>
38 #ifdef CONFIG_NVS_IQS2X3
39 #include <linux/nvs_iqs2x3.h>
40 #endif
41 #include <sound/core.h>
42 #include <sound/jack.h>
43 #include <sound/pcm.h>
44 #include <sound/pcm_params.h>
45 #include <sound/soc.h>
46
47 #include "tegra_asoc_utils_alt.h"
48 #include "tegra_asoc_machine_alt.h"
49 #include "tegra210_xbar_alt.h"
50
51 #include "../codecs/audience/es755.h"
52 #include "../codecs/tas2552.h"
53
54 #define DRV_NAME "tegra-snd-t210ref-mobile"
55
56 #define GPIO_SPKR_EN    BIT(0)
57 #define GPIO_HP_MUTE    BIT(1)
58 #define GPIO_INT_MIC_EN BIT(2)
59 #define GPIO_EXT_MIC_EN BIT(3)
60 #define GPIO_HP_DET     BIT(4)
61
62 struct tegra_t210ref {
63         struct snd_soc_card *pcard;
64         struct tegra_asoc_platform_data *pdata;
65         struct tegra_asoc_audio_clock_info audio_clock;
66         struct sysedp_consumer *sysedpc;
67         struct regulator *codec_reg;
68         struct regulator *digital_reg;
69         struct regulator *analog_reg;
70         struct regulator *spk_reg;
71         struct regulator *dmic_reg;
72         unsigned int num_codec_links;
73         int gpio_requested;
74 #ifdef CONFIG_SWITCH
75         int jack_status;
76 #endif
77         int clock_enabled;
78         enum snd_soc_bias_level bias_level;
79         const char *edp_name;
80         const char *dmic_input;
81         int rate_via_kcontrol;
82         int fmt_via_kcontrol;
83         /* Fast path QOS related variables */
84         u32 fast_latency_ms;
85         u32 fast_cpu_rate;
86         u32 fast_cpu_cores;
87         atomic_t qos_req_count;
88         struct pm_qos_request min_cpu_core;
89         struct pm_qos_request min_cpu_rate;
90 };
91
92 static const int tegra_t210ref_srate_values[] = {
93         0,
94         8000,
95         16000,
96         44100,
97         48000,
98         11025,
99         22050,
100         24000,
101         32000,
102         88200,
103         96000,
104         176000,
105         192000,
106 };
107
108 static struct snd_soc_jack tegra_t210ref_hp_jack;
109
110 static struct snd_soc_jack_gpio tegra_t210ref_hp_jack_gpio = {
111         .name = "headphone detect",
112         .report = SND_JACK_HEADPHONE,
113         .debounce_time = 150,
114         .invert = 1,
115 };
116
117 static ssize_t tegra_t210ref_dmic_input_show_attr(struct device *dev,
118         struct device_attribute *attr, char *buf)
119 {
120         struct snd_soc_card *card = (struct snd_soc_card *)dev_get_drvdata(dev);
121         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
122
123         return snprintf(buf, PAGE_SIZE, "%s\n", machine->dmic_input);
124 }
125
126 static struct device_attribute dmicinput_attrs = __ATTR(dmicinput, S_IRUGO,
127         tegra_t210ref_dmic_input_show_attr, NULL);
128
129 #ifdef CONFIG_SWITCH
130 static struct switch_dev tegra_t210ref_headset_switch = {
131         .name = "h2w",
132 };
133
134 static int tegra_t210ref_jack_notifier(struct notifier_block *self,
135                               unsigned long action, void *dev)
136 {
137         struct snd_soc_jack *jack = dev;
138         struct snd_soc_codec *codec = jack->codec;
139         struct snd_soc_card *card = codec->card;
140         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
141         enum headset_state state = BIT_NO_HEADSET;
142         static bool button_pressed;
143
144         if (button_pressed) {
145                 button_pressed = false;
146                 return NOTIFY_OK;
147         }
148
149         if (action & (SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2)) {
150                 button_pressed = true;
151                 return NOTIFY_OK;
152         }
153
154         if (jack == &tegra_t210ref_hp_jack) {
155                 machine->jack_status &= ~SND_JACK_HEADPHONE;
156                 machine->jack_status &= ~SND_JACK_MICROPHONE;
157                 machine->jack_status |= (action & SND_JACK_HEADSET);
158         }
159
160         switch (machine->jack_status) {
161         case SND_JACK_HEADPHONE:
162                 state = BIT_HEADSET_NO_MIC;
163                 break;
164         case SND_JACK_HEADSET:
165                 state = BIT_HEADSET;
166                 break;
167         case SND_JACK_MICROPHONE:
168                 /* mic: would not report */
169         default:
170                 state = BIT_NO_HEADSET;
171         }
172
173         switch_set_state(&tegra_t210ref_headset_switch, state);
174
175         return NOTIFY_OK;
176 }
177
178 static struct notifier_block tegra_t210ref_jack_detect_nb = {
179         .notifier_call = tegra_t210ref_jack_notifier,
180 };
181 #else
182 static struct snd_soc_jack_pin tegra_t210ref_hp_jack_pins[] = {
183         {
184                 .pin = "Headphone Jack",
185                 .mask = SND_JACK_HEADPHONE,
186         },
187 };
188 #endif
189
190 static int tegra_t210ref_dai_init(struct snd_soc_pcm_runtime *rtd,
191                                         int rate,
192                                         int channels,
193                                         u64 formats)
194 {
195         struct snd_soc_dai *codec_dai = rtd->codec_dai;
196         struct snd_soc_codec *codec = codec_dai->codec;
197         struct snd_soc_card *card = codec->card;
198         struct device_node *np = card->dev->of_node;
199         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
200         struct snd_soc_pcm_stream *dai_params;
201         unsigned int idx, mclk, clk_out_rate;
202         int err, codec_rate, clk_rate;
203
204         codec_rate = tegra_t210ref_srate_values[machine->rate_via_kcontrol];
205         clk_rate = (machine->rate_via_kcontrol) ? codec_rate : rate;
206
207         switch (clk_rate) {
208         case 11025:
209         case 22050:
210         case 44100:
211         case 88200:
212         case 176000:
213                 clk_out_rate = 19200000; /* Codec rate */
214                 mclk = 11289600 * 4; /* PLL_A rate */
215                 break;
216         case 8000:
217         case 16000:
218         case 32000:
219         case 48000:
220         case 64000:
221         case 96000:
222         case 192000:
223         default:
224                 clk_out_rate = 19200000;
225                 mclk = 12288000 * 3;
226                 break;
227         }
228
229         pr_info("Setting pll_a = %d Hz clk_out = %d Hz\n", mclk, clk_out_rate);
230         err = tegra_alt_asoc_utils_set_rate(&machine->audio_clock,
231                                 clk_rate, mclk, clk_out_rate);
232         if (err < 0) {
233                 dev_err(card->dev,
234                 "Can't configure clocks clk_rate %dHz mclk %dHz clk_out %dHz\n",
235                 clk_rate, mclk, clk_out_rate);
236                 return err;
237         }
238
239         err = tegra210_xbar_set_clock(mclk);
240         if (err < 0) {
241                 dev_err(card->dev,
242                 "Can't configure clocks pll_a = %d Hz\n", mclk);
243                 return err;
244         }
245
246         /* update dai link hw_params for non pcm links */
247         for (idx = 0; idx < TEGRA210_XBAR_DAI_LINKS; idx++) {
248                 if (card->rtd[idx].dai_link->params) {
249                         dai_params =
250                           (struct snd_soc_pcm_stream *)
251                           card->rtd[idx].dai_link->params;
252                         dai_params->rate_min = rate;
253                         dai_params->channels_min = channels;
254                         dai_params->formats = 1ULL <<
255                                 ((machine->fmt_via_kcontrol == 2) ?
256                                 SNDRV_PCM_FORMAT_S32_LE :
257                                 SNDRV_PCM_FORMAT_S16_LE);
258                 }
259         }
260
261         if (!of_device_is_compatible(np,
262           "nvidia,tegra-audio-t210ref-mobile-foster")) {
263                 idx = tegra_machine_get_codec_dai_link_idx("earSmart-playback");
264                 /* check if idx has valid number */
265                 if (idx != -EINVAL) {
266                         dai_params =
267                           (struct snd_soc_pcm_stream *)
268                           card->rtd[idx].dai_link->params;
269
270                         dai_params->formats = 1ULL <<
271                                 ((machine->fmt_via_kcontrol == 2) ?
272                                 SNDRV_PCM_FORMAT_S32_LE :
273                                 SNDRV_PCM_FORMAT_S16_LE);
274
275                         dai_params->rate_min = (machine->rate_via_kcontrol) ?
276                                 codec_rate : rate;
277                         dai_params->channels_min = channels;
278
279                         err = snd_soc_dai_set_bclk_ratio(card->rtd[idx].cpu_dai,
280                                 tegra_machine_get_bclk_ratio(&card->rtd[idx]));
281                         if (err < 0) {
282                                 dev_err(card->dev, "Can't set cpu dai bclk ratio\n");
283                                 return err;
284                         }
285                 }
286         }
287
288         idx = tegra_machine_get_codec_dai_link_idx("spdif-dit-1");
289         if (idx != -EINVAL) {
290                 dai_params =
291                   (struct snd_soc_pcm_stream *)card->rtd[idx].dai_link->params;
292
293                 /* update link_param to update hw_param for DAPM */
294                 dai_params->rate_min = rate;
295                 dai_params->channels_min = channels;
296                 dai_params->formats = formats;
297
298                 err = snd_soc_dai_set_bclk_ratio(card->rtd[idx].cpu_dai,
299                         tegra_machine_get_bclk_ratio(&card->rtd[idx]));
300                 if (err < 0) {
301                         dev_err(card->dev, "Can't set cpu dai bclk ratio\n");
302                         return err;
303                 }
304
305                 err = snd_soc_dai_set_tdm_slot(card->rtd[idx].cpu_dai,
306                         (1 << channels) - 1, (1 << channels) - 1, 0, 0);
307                 if (err < 0) {
308                         dev_err(card->dev, "Can't set cpu dai slot ctrl\n");
309                         return err;
310                 }
311         }
312
313         idx = tegra_machine_get_codec_dai_link_idx("spdif-dit-2");
314         if (idx != -EINVAL) {
315                 dai_params =
316                 (struct snd_soc_pcm_stream *)card->rtd[idx].dai_link->params;
317
318                 /* update link_param to update hw_param for DAPM */
319                 if (!machine->rate_via_kcontrol)
320                         dai_params->rate_min = rate;
321                 else
322                         dai_params->rate_min = codec_rate;
323         }
324
325         return 0;
326 }
327
328 static int tegra_t210ref_hw_params(struct snd_pcm_substream *substream,
329                                         struct snd_pcm_hw_params *params)
330 {
331         struct snd_soc_pcm_runtime *rtd = substream->private_data;
332         struct snd_soc_dai *codec_dai = rtd->codec_dai;
333         struct snd_soc_codec *codec = codec_dai->codec;
334         struct snd_soc_card *card = codec->card;
335         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
336         int buffer_time_ms = (params_buffer_size(params) * 1000) /
337                                                         params_rate(params);
338         int err;
339
340         err = tegra_t210ref_dai_init(rtd, params_rate(params),
341                         params_channels(params),
342                         (1ULL << (params_format(params))));
343         if (err < 0) {
344                 dev_err(card->dev, "Failed dai init\n");
345                 return err;
346         }
347
348         if (buffer_time_ms > machine->fast_latency_ms)
349                 return 0;
350
351         if (atomic_inc_return(&machine->qos_req_count) == 1) {
352                 if (machine->fast_cpu_cores > 1)
353                         pm_qos_add_min_bound_req(&machine->min_cpu_core,
354                                 PM_QOS_PRIO_DEFAULT_UNTRUSTED,
355                                 PM_QOS_ONLINE_CPUS_BOUNDS,
356                                 machine->fast_cpu_cores);
357                 if (machine->fast_cpu_rate)
358                         pm_qos_add_min_bound_req(&machine->min_cpu_rate,
359                                 PM_QOS_PRIO_DEFAULT_UNTRUSTED,
360                                 PM_QOS_CPU_FREQ_BOUNDS,
361                                 machine->fast_cpu_rate);
362         }
363
364         return 0;
365 }
366
367 static int tegra_t210ref_hw_free(struct snd_pcm_substream *substream)
368 {
369         struct snd_soc_pcm_runtime *rtd = substream->private_data;
370         struct snd_soc_dai *codec_dai = rtd->codec_dai;
371         struct snd_soc_codec *codec = codec_dai->codec;
372         struct snd_soc_card *card = codec->card;
373         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
374         struct snd_pcm_runtime *runtime = substream->runtime;
375         int buffer_time_ms = (runtime->buffer_size * 1000) / runtime->rate;
376
377         if (buffer_time_ms <= machine->fast_latency_ms) {
378                 if (atomic_dec_and_test(&machine->qos_req_count)) {
379                         if (pm_qos_request_active(&machine->min_cpu_core))
380                                 pm_qos_remove_request(&machine->min_cpu_core);
381                         if (pm_qos_request_active(&machine->min_cpu_rate))
382                                 pm_qos_remove_request(&machine->min_cpu_rate);
383                 }
384         }
385
386         return 0;
387 }
388
389 static int tegra_t210ref_compr_set_params(struct snd_compr_stream *cstream)
390 {
391         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
392         struct snd_soc_dai *codec_dai = rtd->codec_dai;
393         struct snd_soc_codec *codec = codec_dai->codec;
394         struct snd_soc_card *card = codec->card;
395         struct snd_soc_platform *platform = rtd->platform;
396         struct snd_codec codec_params;
397         int err;
398
399         if (platform->driver->compr_ops &&
400                 platform->driver->compr_ops->get_params) {
401                 err = platform->driver->compr_ops->get_params(cstream,
402                         &codec_params);
403                 if (err < 0) {
404                         dev_err(card->dev, "Failed to get compr params\n");
405                         return err;
406                 }
407         } else {
408                 dev_err(card->dev, "compr ops not set\n");
409                 return -EINVAL;
410         }
411
412         err = tegra_t210ref_dai_init(rtd, codec_params.sample_rate,
413                         codec_params.ch_out, SNDRV_PCM_FMTBIT_S16_LE);
414         if (err < 0) {
415                 dev_err(card->dev, "Failed dai init\n");
416                 return err;
417         }
418
419         return 0;
420 }
421
422 static int tegra_t210ref_init(struct snd_soc_pcm_runtime *rtd)
423 {
424         struct snd_soc_dai *codec_dai = rtd->codec_dai;
425         struct snd_soc_codec *codec = codec_dai->codec;
426         struct snd_soc_card *card = codec->card;
427         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
428         struct tegra_asoc_platform_data *pdata = machine->pdata;
429         struct snd_soc_pcm_stream *dai_params =
430                 (struct snd_soc_pcm_stream *)rtd->dai_link->params;
431         unsigned int srate;
432         int err;
433
434         srate = dai_params->rate_min;
435
436         err = tegra_alt_asoc_utils_set_extern_parent(&machine->audio_clock,
437                                                         "clk_m");
438         if (err < 0) {
439                 dev_err(card->dev, "Failed to set extern clk parent\n");
440                 return err;
441         }
442
443         if (gpio_is_valid(pdata->gpio_hp_det)) {
444                 tegra_t210ref_hp_jack_gpio.gpio = pdata->gpio_hp_det;
445                 tegra_t210ref_hp_jack_gpio.invert =
446                         !pdata->gpio_hp_det_active_high;
447                 err = snd_soc_jack_new(codec, "Headphone Jack",
448                                (SND_JACK_HEADSET | SND_JACK_BTN_0 |
449                                SND_JACK_BTN_1 | SND_JACK_BTN_2),
450                                &tegra_t210ref_hp_jack);
451                 if (err) {
452                         pr_err("failed to create a jack for es755\n");
453                         return err;
454                 }
455
456                 err = snd_jack_set_key(tegra_t210ref_hp_jack.jack,
457                                 SND_JACK_BTN_0, KEY_MEDIA);
458                 if (err < 0)
459                         pr_err("Failed to set KEY_MEDIA: %d\n", err);
460
461                 err = snd_jack_set_key(tegra_t210ref_hp_jack.jack,
462                                 SND_JACK_BTN_1, KEY_VOLUMEUP);
463                 if (err < 0)
464                         pr_err("Failed to set KEY_VOLUMEUP: %d\n", err);
465
466                 err = snd_jack_set_key(tegra_t210ref_hp_jack.jack,
467                                 SND_JACK_BTN_2, KEY_VOLUMEDOWN);
468                 if (err < 0)
469                         pr_err("Failed to set KEY_VOLUMEDOWN: %d\n", err);
470 #ifdef CONFIG_SWITCH
471                 snd_soc_jack_notifier_register(&tegra_t210ref_hp_jack,
472                                                 &tegra_t210ref_jack_detect_nb);
473 #else /* gpio based headset detection */
474                 snd_soc_jack_add_pins(&tegra_es755_hp_jack,
475                                         ARRAY_SIZE(tegra_es755_hs_jack_pins),
476                                         tegra_es755_hs_jack_pins);
477 #endif
478                 snd_soc_jack_add_gpios(&tegra_t210ref_hp_jack,
479                                         1, &tegra_t210ref_hp_jack_gpio);
480                 machine->gpio_requested |= GPIO_HP_DET;
481
482                 es755_detect(codec, &tegra_t210ref_hp_jack);
483         }
484
485         return 0;
486 }
487
488 static int tegra_es755_startup(struct snd_pcm_substream *substream)
489 {
490         escore_pm_get_sync();
491         return 0;
492 }
493
494 static void tegra_es755_shutdown(struct snd_pcm_substream *substream)
495 {
496         escore_pm_put_autosuspend();
497 }
498
499 static int tegra_es755_startup_compr(struct snd_compr_stream *cstream)
500 {
501         escore_pm_get_sync();
502         return 0;
503 }
504
505 static void tegra_es755_shutdown_compr(struct snd_compr_stream *cstream)
506 {
507         escore_pm_put_autosuspend();
508 }
509
510 static struct snd_soc_ops tegra_t210ref_ops = {
511         .hw_params = tegra_t210ref_hw_params,
512         .hw_free = tegra_t210ref_hw_free,
513         .startup = tegra_es755_startup,
514         .shutdown = tegra_es755_shutdown,
515 };
516
517 static struct snd_soc_compr_ops tegra_t210ref_compr_ops = {
518         .set_params = tegra_t210ref_compr_set_params,
519         .startup = tegra_es755_startup_compr,
520         .shutdown = tegra_es755_shutdown_compr,
521 };
522
523 static int tegra_t210ref_event_int_spk(struct snd_soc_dapm_widget *w,
524                                         struct snd_kcontrol *k, int event)
525 {
526         struct snd_soc_dapm_context *dapm = w->dapm;
527         struct snd_soc_card *card = dapm->card;
528         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
529         struct tegra_asoc_platform_data *pdata = machine->pdata;
530         int err;
531
532         if (machine->spk_reg) {
533                 if (SND_SOC_DAPM_EVENT_ON(event)) {
534                         if (machine->sysedpc)
535                                 sysedp_set_state(machine->sysedpc, 1);
536                         err = regulator_enable(machine->spk_reg);
537                         if (err < 0)
538                                 dev_err(card->dev, "Failed to enable spk regulator\n");
539                 } else {
540                         regulator_disable(machine->spk_reg);
541                         if (machine->sysedpc)
542                                 sysedp_set_state(machine->sysedpc, 0);
543                 }
544         }
545 #ifdef CONFIG_NVS_IQS2X3
546         /* Notify SAR about speaker enable/disable */
547         sar_external_status(!!SND_SOC_DAPM_EVENT_ON(event));
548 #endif
549
550         if (!(machine->gpio_requested & GPIO_SPKR_EN))
551                 return 0;
552
553         gpio_set_value_cansleep(pdata->gpio_spkr_en,
554                                 !!SND_SOC_DAPM_EVENT_ON(event));
555
556         return 0;
557 }
558
559
560 static const char * const tegra_t210ref_srate_text[] = {
561         "None",
562         "8kHz",
563         "16kHz",
564         "44kHz",
565         "48kHz",
566         "11kHz",
567         "22kHz",
568         "24kHz",
569         "32kHz",
570         "88kHz",
571         "96kHz",
572         "176kHz",
573         "192kHz",
574 };
575
576 static int tegra_t210ref_codec_get_rate(struct snd_kcontrol *kcontrol,
577         struct snd_ctl_elem_value *ucontrol)
578 {
579         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
580         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
581
582         ucontrol->value.integer.value[0] = machine->rate_via_kcontrol;
583
584         return 0;
585 }
586
587 static int tegra_t210ref_codec_put_rate(struct snd_kcontrol *kcontrol,
588         struct snd_ctl_elem_value *ucontrol)
589 {
590         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
591         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
592
593         /* set the rate control flag */
594         machine->rate_via_kcontrol = ucontrol->value.integer.value[0];
595
596         return 0;
597 }
598
599 static const char * const tegra_t210ref_format_text[] = {
600         "None",
601         "16",
602         "32",
603 };
604
605 static int tegra_t210ref_codec_get_format(struct snd_kcontrol *kcontrol,
606         struct snd_ctl_elem_value *ucontrol)
607 {
608         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
609         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
610
611         ucontrol->value.integer.value[0] = machine->fmt_via_kcontrol;
612
613         return 0;
614 }
615
616 static int tegra_t210ref_codec_put_format(struct snd_kcontrol *kcontrol,
617         struct snd_ctl_elem_value *ucontrol)
618 {
619         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
620         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
621
622         /* set the format control flag */
623         machine->fmt_via_kcontrol = ucontrol->value.integer.value[0];
624
625         return 0;
626 }
627
628 static const struct soc_enum tegra_t210ref_codec_rate =
629         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(tegra_t210ref_srate_text),
630                 tegra_t210ref_srate_text);
631
632 static const struct soc_enum tegra_t210ref_codec_format =
633         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(tegra_t210ref_format_text),
634                 tegra_t210ref_format_text);
635
636 static const struct snd_soc_dapm_widget tegra_t210ref_dapm_widgets[] = {
637         SND_SOC_DAPM_SPK("Int Spk", tegra_t210ref_event_int_spk),
638         SND_SOC_DAPM_HP("y Headphone", NULL),
639         SND_SOC_DAPM_MIC("y Mic", NULL),
640         SND_SOC_DAPM_HP("k Headphone", NULL),
641         SND_SOC_DAPM_MIC("k Mic", NULL),
642 };
643
644 static const struct snd_kcontrol_new tegra_t210ref_controls[] = {
645         SOC_DAPM_PIN_SWITCH("Int Spk"),
646         SOC_ENUM_EXT("codec-x rate", tegra_t210ref_codec_rate,
647                 tegra_t210ref_codec_get_rate, tegra_t210ref_codec_put_rate),
648         SOC_ENUM_EXT("codec-x format", tegra_t210ref_codec_format,
649                 tegra_t210ref_codec_get_format, tegra_t210ref_codec_put_format),
650 };
651
652 static int tegra_t210ref_suspend_pre(struct snd_soc_card *card)
653 {
654         unsigned int idx;
655
656         /* DAPM dai link stream work for non pcm links */
657         for (idx = 0; idx < card->num_rtd; idx++) {
658                 if (card->rtd[idx].dai_link->params)
659                         INIT_DELAYED_WORK(&card->rtd[idx].delayed_work, NULL);
660         }
661
662         return 0;
663 }
664
665 static int tegra_t210ref_suspend_post(struct snd_soc_card *card)
666 {
667         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
668
669         if (machine->clock_enabled) {
670                 machine->clock_enabled = 0;
671                 tegra_alt_asoc_utils_clk_disable(&machine->audio_clock);
672         }
673
674         if (machine->digital_reg)
675                 regulator_disable(machine->digital_reg);
676
677         return 0;
678 }
679
680 static int tegra_t210ref_resume_pre(struct snd_soc_card *card)
681 {
682         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
683         int ret;
684
685         if (machine->digital_reg)
686                 ret = regulator_enable(machine->digital_reg);
687
688         if (!machine->clock_enabled) {
689                 machine->clock_enabled = 1;
690                 tegra_alt_asoc_utils_clk_enable(&machine->audio_clock);
691         }
692
693         return 0;
694 }
695
696 static const struct snd_soc_dapm_route tegra_t210ref_audio_map[] = {
697 };
698
699 static int tegra_t210ref_remove(struct snd_soc_card *card)
700 {
701         return 0;
702 }
703
704 static struct snd_soc_card snd_soc_tegra_t210ref = {
705         .name = "tegra-t210ref",
706         .owner = THIS_MODULE,
707         .remove = tegra_t210ref_remove,
708         .suspend_post = tegra_t210ref_suspend_post,
709         .suspend_pre = tegra_t210ref_suspend_pre,
710         .resume_pre = tegra_t210ref_resume_pre,
711         .controls = tegra_t210ref_controls,
712         .num_controls = ARRAY_SIZE(tegra_t210ref_controls),
713         .dapm_widgets = tegra_t210ref_dapm_widgets,
714         .num_dapm_widgets = ARRAY_SIZE(tegra_t210ref_dapm_widgets),
715         .fully_routed = true,
716 };
717
718 static int tegra_t210ref_driver_probe(struct platform_device *pdev)
719 {
720         struct device_node *np = pdev->dev.of_node;
721         struct snd_soc_card *card = &snd_soc_tegra_t210ref;
722         struct tegra_t210ref *machine;
723         struct snd_soc_dai_link *tegra_machine_dai_links = NULL;
724         struct snd_soc_dai_link *tegra_t210ref_codec_links = NULL;
725         struct snd_soc_codec_conf *tegra_machine_codec_conf = NULL;
726         struct snd_soc_codec_conf *tegra_t210ref_codec_conf = NULL;
727         struct tegra_asoc_platform_data *pdata = NULL;
728         int ret = 0, i;
729
730         if (!np) {
731                 dev_err(&pdev->dev, "No device tree node for t210ref driver");
732                 return -ENODEV;
733         }
734
735         if (!of_device_is_compatible(np,
736           "nvidia,tegra-audio-t210ref-mobile-foster")) {
737                 if (escore_is_probe_error()) {
738                         dev_err(&pdev->dev, "No ES755 CODEC found");
739                         return -ENODEV;
740                 }
741         }
742
743         machine = devm_kzalloc(&pdev->dev, sizeof(struct tegra_t210ref),
744                                GFP_KERNEL);
745         if (!machine) {
746                 dev_err(&pdev->dev, "Can't allocate tegra_t210ref struct\n");
747                 ret = -ENOMEM;
748                 goto err;
749         }
750
751         pdata = devm_kzalloc(&pdev->dev,
752                                 sizeof(struct tegra_asoc_platform_data),
753                                 GFP_KERNEL);
754         if (!pdata) {
755                 dev_err(&pdev->dev,
756                         "Can't allocate tegra_asoc_platform_data struct\n");
757                 goto err;
758         }
759
760         card->dev = &pdev->dev;
761         platform_set_drvdata(pdev, card);
762         snd_soc_card_set_drvdata(card, machine);
763         dev_set_drvdata(&pdev->dev, card);
764
765         ret = snd_soc_of_parse_card_name(card, "nvidia,model");
766         if (ret)
767                 goto err;
768
769         ret = snd_soc_of_parse_audio_routing(card,
770                                 "nvidia,audio-routing");
771         if (ret)
772                 goto err;
773
774         /* set new codec links and conf */
775         tegra_t210ref_codec_links = tegra_machine_new_codec_links(pdev,
776                 tegra_t210ref_codec_links,
777                 &machine->num_codec_links);
778         if (!tegra_t210ref_codec_links)
779                 goto err_alloc_dai_link;
780
781         tegra_t210ref_codec_conf = tegra_machine_new_codec_conf(pdev,
782                 tegra_t210ref_codec_conf,
783                 &machine->num_codec_links);
784         if (!tegra_t210ref_codec_conf)
785                 goto err_alloc_dai_link;
786
787
788         /* get the xbar dai link/codec conf structure */
789         tegra_machine_dai_links = tegra_machine_get_dai_link();
790         if (!tegra_machine_dai_links)
791                 goto err_alloc_dai_link;
792         tegra_machine_codec_conf = tegra_machine_get_codec_conf();
793         if (!tegra_machine_codec_conf)
794                 goto err_alloc_dai_link;
795
796         /* set ADMAIF dai_ops */
797         for (i = TEGRA210_DAI_LINK_ADMAIF1;
798                 i <= TEGRA210_DAI_LINK_ADMAIF10; i++)
799                 tegra_machine_set_dai_ops(i, &tegra_t210ref_ops);
800
801         /* set ADSP PCM */
802         for (i = TEGRA210_DAI_LINK_ADSP_PCM1;
803                 i <= TEGRA210_DAI_LINK_ADSP_PCM2; i++) {
804                 tegra_machine_set_dai_ops(i,
805                         &tegra_t210ref_ops);
806         }
807
808         /* set ADSP COMPR */
809         for (i = TEGRA210_DAI_LINK_ADSP_COMPR1;
810                 i <= TEGRA210_DAI_LINK_ADSP_COMPR2; i++) {
811                 tegra_machine_set_dai_compr_ops(i,
812                         &tegra_t210ref_compr_ops);
813         }
814
815         pdata->gpio_hp_det = of_get_named_gpio(np,
816                                         "nvidia,hp-det-gpios", 0);
817         if (pdata->gpio_hp_det < 0)
818                 dev_warn(&pdev->dev, "Failed to get HP Det GPIO\n");
819
820         pdata->gpio_codec1 = pdata->gpio_codec2 = pdata->gpio_codec3 =
821         pdata->gpio_spkr_en = pdata->gpio_hp_mute =
822         pdata->gpio_int_mic_en = pdata->gpio_ext_mic_en =
823         pdata->gpio_ldo1_en =  -1;
824
825         /* set codec init */
826         for (i = 0; i < machine->num_codec_links; i++) {
827                 if (tegra_t210ref_codec_links[i].name) {
828                         if (strstr(tegra_t210ref_codec_links[i]
829                                 .name, "earSmart-playback"))
830                                 tegra_t210ref_codec_links[i].init =
831                                                 tegra_t210ref_init;
832                 }
833         }
834
835         /* append t210ref specific dai_links */
836         card->num_links =
837                 tegra_machine_append_dai_link(tegra_t210ref_codec_links,
838                         2 * machine->num_codec_links);
839         tegra_machine_dai_links = tegra_machine_get_dai_link();
840         card->dai_link = tegra_machine_dai_links;
841
842         /* append t210ref specific codec_conf */
843         card->num_configs =
844                 tegra_machine_append_codec_conf(tegra_t210ref_codec_conf,
845                         machine->num_codec_links);
846         tegra_machine_codec_conf = tegra_machine_get_codec_conf();
847         card->codec_conf = tegra_machine_codec_conf;
848
849 #ifdef CONFIG_SWITCH
850         /* Addd h2w swith class support */
851         ret = tegra_alt_asoc_switch_register(&tegra_t210ref_headset_switch);
852         if (ret < 0)
853                 goto err_alloc_dai_link;
854 #endif
855
856         /*
857         *digital_reg - provided the digital power for the codec and must be
858         *ON always
859         */
860         machine->digital_reg = regulator_get(&pdev->dev, "dbvdd");
861         if (IS_ERR(machine->digital_reg))
862                 machine->digital_reg = NULL;
863         else
864                 ret = regulator_enable(machine->digital_reg);
865
866         /*
867         *spk_reg - provided the speaker power and can be turned ON
868         *on need basis, when required
869         */
870         machine->spk_reg = regulator_get(&pdev->dev, "spkvdd");
871         if (IS_ERR(machine->spk_reg))
872                 machine->spk_reg = NULL;
873
874         /*
875         *dmic_reg - provided the DMIC power and can be turned ON
876         *on need basis, when required
877         */
878         machine->dmic_reg = regulator_get(&pdev->dev, "dmicvdd");
879         if (IS_ERR(machine->dmic_reg))
880                 machine->dmic_reg = NULL;
881
882         machine->pdata = pdata;
883         machine->pcard = card;
884         machine->clock_enabled = 1;
885         machine->rate_via_kcontrol = 0;
886
887         ret = tegra_alt_asoc_utils_init(&machine->audio_clock,
888                                         &pdev->dev,
889                                         card);
890         if (ret)
891                 goto err_switch_unregister;
892
893         card->dapm.idle_bias_off = 1;
894
895         ret = snd_soc_register_card(card);
896         if (ret) {
897                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
898                         ret);
899                 goto err_fini_utils;
900         }
901
902         if (!of_device_is_compatible(np,
903           "nvidia,tegra-audio-t210ref-mobile-foster")) {
904                 if (of_property_read_string(np, "edp-consumer-name",
905                         &machine->edp_name)) {
906                         machine->sysedpc = NULL;
907                         dev_err(&pdev->dev, "property 'edp-consumer-name' missing or invalid\n");
908                 } else {
909                         machine->sysedpc =
910                                 sysedp_create_consumer("codec+speaker",
911                                         machine->edp_name);
912                 }
913         }
914
915         if (!of_property_read_u32(np, "nvidia,fast-path-latency-ms",
916                 (u32 *)&machine->fast_latency_ms)) {
917                 if (machine->fast_latency_ms > 0) {
918                         of_property_read_u32(np,
919                                 "nvidia,fast-path-min-cpu-rate",
920                                 (u32 *)&machine->fast_cpu_rate);
921                         of_property_read_u32(np,
922                                 "nvidia,fast-path-min-cpu-core",
923                                 (u32 *)&machine->fast_cpu_cores);
924                 }
925         }
926
927         if (!of_property_read_string(np, "nvidia,digital-mic-data-input",
928                 &machine->dmic_input)) {
929                 /* Create sysnode for reading PDM info */
930                 ret = device_create_file(&pdev->dev, &dmicinput_attrs);
931                 if (ret != 0)
932                         dev_err(&pdev->dev, "Failed to create dmicinput sysfs node: %d\n", ret);
933         }
934
935         return 0;
936
937 err_fini_utils:
938         tegra_alt_asoc_utils_fini(&machine->audio_clock);
939 err_switch_unregister:
940 #ifdef CONFIG_SWITCH
941         tegra_alt_asoc_switch_unregister(&tegra_t210ref_headset_switch);
942 #endif
943         if (machine->gpio_requested & GPIO_HP_DET)
944                 snd_soc_jack_free_gpios(&tegra_t210ref_hp_jack,
945                                         1,
946                                         &tegra_t210ref_hp_jack_gpio);
947
948         if (machine->digital_reg) {
949                 regulator_disable(machine->digital_reg);
950                 regulator_put(machine->digital_reg);
951         }
952         if (machine->analog_reg) {
953                 regulator_disable(machine->analog_reg);
954                 regulator_put(machine->analog_reg);
955         }
956         if (machine->spk_reg)
957                 regulator_put(machine->spk_reg);
958
959         if (machine->dmic_reg)
960                 regulator_put(machine->dmic_reg);
961         if (machine->codec_reg) {
962                 regulator_disable(machine->codec_reg);
963                 regulator_put(machine->codec_reg);
964         }
965 err_alloc_dai_link:
966         tegra_machine_remove_dai_link();
967         tegra_machine_remove_codec_conf();
968 err:
969         return ret;
970 }
971
972 static int tegra_t210ref_driver_remove(struct platform_device *pdev)
973 {
974         struct snd_soc_card *card = platform_get_drvdata(pdev);
975         struct tegra_t210ref *machine = snd_soc_card_get_drvdata(card);
976
977         if (machine->gpio_requested & GPIO_HP_DET)
978                 snd_soc_jack_free_gpios(&tegra_t210ref_hp_jack,
979                                         1,
980                                         &tegra_t210ref_hp_jack_gpio);
981
982         if (machine->digital_reg) {
983                 regulator_disable(machine->digital_reg);
984                 regulator_put(machine->digital_reg);
985         }
986         if (machine->analog_reg) {
987                 regulator_disable(machine->analog_reg);
988                 regulator_put(machine->analog_reg);
989         }
990         if (machine->spk_reg)
991                 regulator_put(machine->spk_reg);
992
993         if (machine->dmic_reg)
994                 regulator_put(machine->dmic_reg);
995         if (machine->codec_reg) {
996                 regulator_disable(machine->codec_reg);
997                 regulator_put(machine->codec_reg);
998         }
999
1000         device_remove_file(&pdev->dev, &dmicinput_attrs);
1001
1002         snd_soc_unregister_card(card);
1003
1004         tegra_machine_remove_dai_link();
1005         tegra_machine_remove_codec_conf();
1006         tegra_alt_asoc_utils_fini(&machine->audio_clock);
1007
1008 #ifdef CONFIG_SWITCH
1009         tegra_alt_asoc_switch_unregister(&tegra_t210ref_headset_switch);
1010 #endif
1011         if (machine->sysedpc)
1012                 sysedp_free_consumer(machine->sysedpc);
1013
1014         return 0;
1015 }
1016
1017 static const struct of_device_id tegra_t210ref_of_match[] = {
1018         { .compatible = "nvidia,tegra-audio-t210ref-mobile-es755", },
1019         { .compatible = "nvidia,tegra-audio-t210ref-mobile-foster", },
1020         {},
1021 };
1022
1023 static struct platform_driver tegra_t210ref_driver = {
1024         .driver = {
1025                 .name = DRV_NAME,
1026                 .owner = THIS_MODULE,
1027                 .pm = &snd_soc_pm_ops,
1028                 .of_match_table = tegra_t210ref_of_match,
1029         },
1030         .probe = tegra_t210ref_driver_probe,
1031         .remove = tegra_t210ref_driver_remove,
1032 };
1033 module_platform_driver(tegra_t210ref_driver);
1034
1035 MODULE_AUTHOR("Dara Ramesh <dramesh@nvidia.com>");
1036 MODULE_DESCRIPTION("Tegra+t210ref machine ASoC driver");
1037 MODULE_LICENSE("GPL");
1038 MODULE_ALIAS("platform:" DRV_NAME);
1039 MODULE_DEVICE_TABLE(of, tegra_t210ref_of_match);