9c1aa4ec9cba49121e2c49f8ad85e2a415e5f417
[sfrench/cifs-2.6.git] / sound / soc / intel / boards / bytcr_rt5640.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  byt_cr_dpcm_rt5640.c - ASoc Machine driver for Intel Byt CR platform
4  *
5  *  Copyright (C) 2014 Intel Corp
6  *  Author: Subhransu S. Prusty <subhransu.s.prusty@intel.com>
7  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10  */
11
12 #include <linux/i2c.h>
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/platform_device.h>
17 #include <linux/acpi.h>
18 #include <linux/clk.h>
19 #include <linux/device.h>
20 #include <linux/dmi.h>
21 #include <linux/input.h>
22 #include <linux/slab.h>
23 #include <sound/pcm.h>
24 #include <sound/pcm_params.h>
25 #include <sound/soc.h>
26 #include <sound/jack.h>
27 #include <sound/soc-acpi.h>
28 #include <dt-bindings/sound/rt5640.h>
29 #include "../../codecs/rt5640.h"
30 #include "../atom/sst-atom-controls.h"
31 #include "../common/sst-dsp.h"
32 #include "../common/soc-intel-quirks.h"
33
34 enum {
35         BYT_RT5640_DMIC1_MAP,
36         BYT_RT5640_DMIC2_MAP,
37         BYT_RT5640_IN1_MAP,
38         BYT_RT5640_IN3_MAP,
39 };
40
41 enum {
42         BYT_RT5640_JD_SRC_GPIO1         = (RT5640_JD_SRC_GPIO1 << 4),
43         BYT_RT5640_JD_SRC_JD1_IN4P      = (RT5640_JD_SRC_JD1_IN4P << 4),
44         BYT_RT5640_JD_SRC_JD2_IN4N      = (RT5640_JD_SRC_JD2_IN4N << 4),
45         BYT_RT5640_JD_SRC_GPIO2         = (RT5640_JD_SRC_GPIO2 << 4),
46         BYT_RT5640_JD_SRC_GPIO3         = (RT5640_JD_SRC_GPIO3 << 4),
47         BYT_RT5640_JD_SRC_GPIO4         = (RT5640_JD_SRC_GPIO4 << 4),
48 };
49
50 enum {
51         BYT_RT5640_OVCD_TH_600UA        = (6 << 8),
52         BYT_RT5640_OVCD_TH_1500UA       = (15 << 8),
53         BYT_RT5640_OVCD_TH_2000UA       = (20 << 8),
54 };
55
56 enum {
57         BYT_RT5640_OVCD_SF_0P5          = (RT5640_OVCD_SF_0P5 << 13),
58         BYT_RT5640_OVCD_SF_0P75         = (RT5640_OVCD_SF_0P75 << 13),
59         BYT_RT5640_OVCD_SF_1P0          = (RT5640_OVCD_SF_1P0 << 13),
60         BYT_RT5640_OVCD_SF_1P5          = (RT5640_OVCD_SF_1P5 << 13),
61 };
62
63 #define BYT_RT5640_MAP(quirk)           ((quirk) &  GENMASK(3, 0))
64 #define BYT_RT5640_JDSRC(quirk)         (((quirk) & GENMASK(7, 4)) >> 4)
65 #define BYT_RT5640_OVCD_TH(quirk)       (((quirk) & GENMASK(12, 8)) >> 8)
66 #define BYT_RT5640_OVCD_SF(quirk)       (((quirk) & GENMASK(14, 13)) >> 13)
67 #define BYT_RT5640_JD_NOT_INV           BIT(16)
68 #define BYT_RT5640_MONO_SPEAKER         BIT(17)
69 #define BYT_RT5640_DIFF_MIC             BIT(18) /* default is single-ended */
70 #define BYT_RT5640_SSP2_AIF2            BIT(19) /* default is using AIF1  */
71 #define BYT_RT5640_SSP0_AIF1            BIT(20)
72 #define BYT_RT5640_SSP0_AIF2            BIT(21)
73 #define BYT_RT5640_MCLK_EN              BIT(22)
74 #define BYT_RT5640_MCLK_25MHZ           BIT(23)
75
76 #define BYTCR_INPUT_DEFAULTS                            \
77         (BYT_RT5640_IN3_MAP |                           \
78          BYT_RT5640_JD_SRC_JD1_IN4P |                   \
79          BYT_RT5640_OVCD_TH_2000UA |                    \
80          BYT_RT5640_OVCD_SF_0P75 |                      \
81          BYT_RT5640_DIFF_MIC)
82
83 /* in-diff or dmic-pin + jdsrc + ovcd-th + -sf + jd-inv + terminating entry */
84 #define MAX_NO_PROPS 6
85
86 struct byt_rt5640_private {
87         struct snd_soc_jack jack;
88         struct clk *mclk;
89 };
90 static bool is_bytcr;
91
92 static unsigned long byt_rt5640_quirk = BYT_RT5640_MCLK_EN;
93 static int quirk_override = -1;
94 module_param_named(quirk, quirk_override, int, 0444);
95 MODULE_PARM_DESC(quirk, "Board-specific quirk override");
96
97 static void log_quirks(struct device *dev)
98 {
99         int map;
100         bool has_mclk = false;
101         bool has_ssp0 = false;
102         bool has_ssp0_aif1 = false;
103         bool has_ssp0_aif2 = false;
104         bool has_ssp2_aif2 = false;
105
106         map = BYT_RT5640_MAP(byt_rt5640_quirk);
107         switch (map) {
108         case BYT_RT5640_DMIC1_MAP:
109                 dev_info(dev, "quirk DMIC1_MAP enabled\n");
110                 break;
111         case BYT_RT5640_DMIC2_MAP:
112                 dev_info(dev, "quirk DMIC2_MAP enabled\n");
113                 break;
114         case BYT_RT5640_IN1_MAP:
115                 dev_info(dev, "quirk IN1_MAP enabled\n");
116                 break;
117         case BYT_RT5640_IN3_MAP:
118                 dev_info(dev, "quirk IN3_MAP enabled\n");
119                 break;
120         default:
121                 dev_err(dev, "quirk map 0x%x is not supported, microphone input will not work\n", map);
122                 break;
123         }
124         if (BYT_RT5640_JDSRC(byt_rt5640_quirk)) {
125                 dev_info(dev, "quirk realtek,jack-detect-source %ld\n",
126                          BYT_RT5640_JDSRC(byt_rt5640_quirk));
127                 dev_info(dev, "quirk realtek,over-current-threshold-microamp %ld\n",
128                          BYT_RT5640_OVCD_TH(byt_rt5640_quirk) * 100);
129                 dev_info(dev, "quirk realtek,over-current-scale-factor %ld\n",
130                          BYT_RT5640_OVCD_SF(byt_rt5640_quirk));
131         }
132         if (byt_rt5640_quirk & BYT_RT5640_JD_NOT_INV)
133                 dev_info(dev, "quirk JD_NOT_INV enabled\n");
134         if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER)
135                 dev_info(dev, "quirk MONO_SPEAKER enabled\n");
136         if (byt_rt5640_quirk & BYT_RT5640_DIFF_MIC)
137                 dev_info(dev, "quirk DIFF_MIC enabled\n");
138         if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) {
139                 dev_info(dev, "quirk SSP0_AIF1 enabled\n");
140                 has_ssp0 = true;
141                 has_ssp0_aif1 = true;
142         }
143         if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2) {
144                 dev_info(dev, "quirk SSP0_AIF2 enabled\n");
145                 has_ssp0 = true;
146                 has_ssp0_aif2 = true;
147         }
148         if (byt_rt5640_quirk & BYT_RT5640_SSP2_AIF2) {
149                 dev_info(dev, "quirk SSP2_AIF2 enabled\n");
150                 has_ssp2_aif2 = true;
151         }
152         if (is_bytcr && !has_ssp0)
153                 dev_err(dev, "Invalid routing, bytcr detected but no SSP0-based quirk, audio cannot work with SSP2 on bytcr\n");
154         if (has_ssp0_aif1 && has_ssp0_aif2)
155                 dev_err(dev, "Invalid routing, SSP0 cannot be connected to both AIF1 and AIF2\n");
156         if (has_ssp0 && has_ssp2_aif2)
157                 dev_err(dev, "Invalid routing, cannot have both SSP0 and SSP2 connected to codec\n");
158
159         if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN) {
160                 dev_info(dev, "quirk MCLK_EN enabled\n");
161                 has_mclk = true;
162         }
163         if (byt_rt5640_quirk & BYT_RT5640_MCLK_25MHZ) {
164                 if (has_mclk)
165                         dev_info(dev, "quirk MCLK_25MHZ enabled\n");
166                 else
167                         dev_err(dev, "quirk MCLK_25MHZ enabled but quirk MCLK not selected, will be ignored\n");
168         }
169 }
170
171 static int byt_rt5640_prepare_and_enable_pll1(struct snd_soc_dai *codec_dai,
172                                               int rate)
173 {
174         int ret;
175
176         /* Configure the PLL before selecting it */
177         if (!(byt_rt5640_quirk & BYT_RT5640_MCLK_EN)) {
178                 /* use bitclock as PLL input */
179                 if ((byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) ||
180                     (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) {
181                         /* 2x16 bit slots on SSP0 */
182                         ret = snd_soc_dai_set_pll(codec_dai, 0,
183                                                   RT5640_PLL1_S_BCLK1,
184                                                   rate * 32, rate * 512);
185                 } else {
186                         /* 2x15 bit slots on SSP2 */
187                         ret = snd_soc_dai_set_pll(codec_dai, 0,
188                                                   RT5640_PLL1_S_BCLK1,
189                                                   rate * 50, rate * 512);
190                 }
191         } else {
192                 if (byt_rt5640_quirk & BYT_RT5640_MCLK_25MHZ) {
193                         ret = snd_soc_dai_set_pll(codec_dai, 0,
194                                                   RT5640_PLL1_S_MCLK,
195                                                   25000000, rate * 512);
196                 } else {
197                         ret = snd_soc_dai_set_pll(codec_dai, 0,
198                                                   RT5640_PLL1_S_MCLK,
199                                                   19200000, rate * 512);
200                 }
201         }
202
203         if (ret < 0) {
204                 dev_err(codec_dai->component->dev, "can't set pll: %d\n", ret);
205                 return ret;
206         }
207
208         ret = snd_soc_dai_set_sysclk(codec_dai, RT5640_SCLK_S_PLL1,
209                                      rate * 512, SND_SOC_CLOCK_IN);
210         if (ret < 0) {
211                 dev_err(codec_dai->component->dev, "can't set clock %d\n", ret);
212                 return ret;
213         }
214
215         return 0;
216 }
217
218 #define BYT_CODEC_DAI1  "rt5640-aif1"
219 #define BYT_CODEC_DAI2  "rt5640-aif2"
220
221 static int platform_clock_control(struct snd_soc_dapm_widget *w,
222                                   struct snd_kcontrol *k, int  event)
223 {
224         struct snd_soc_dapm_context *dapm = w->dapm;
225         struct snd_soc_card *card = dapm->card;
226         struct snd_soc_dai *codec_dai;
227         struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
228         int ret;
229
230         codec_dai = snd_soc_card_get_codec_dai(card, BYT_CODEC_DAI1);
231         if (!codec_dai)
232                 codec_dai = snd_soc_card_get_codec_dai(card, BYT_CODEC_DAI2);
233
234         if (!codec_dai) {
235                 dev_err(card->dev,
236                         "Codec dai not found; Unable to set platform clock\n");
237                 return -EIO;
238         }
239
240         if (SND_SOC_DAPM_EVENT_ON(event)) {
241                 if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN) {
242                         ret = clk_prepare_enable(priv->mclk);
243                         if (ret < 0) {
244                                 dev_err(card->dev,
245                                         "could not configure MCLK state\n");
246                                 return ret;
247                         }
248                 }
249                 ret = byt_rt5640_prepare_and_enable_pll1(codec_dai, 48000);
250         } else {
251                 /*
252                  * Set codec clock source to internal clock before
253                  * turning off the platform clock. Codec needs clock
254                  * for Jack detection and button press
255                  */
256                 ret = snd_soc_dai_set_sysclk(codec_dai, RT5640_SCLK_S_RCCLK,
257                                              48000 * 512,
258                                              SND_SOC_CLOCK_IN);
259                 if (!ret) {
260                         if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN)
261                                 clk_disable_unprepare(priv->mclk);
262                 }
263         }
264
265         if (ret < 0) {
266                 dev_err(card->dev, "can't set codec sysclk: %d\n", ret);
267                 return ret;
268         }
269
270         return 0;
271 }
272
273 static const struct snd_soc_dapm_widget byt_rt5640_widgets[] = {
274         SND_SOC_DAPM_HP("Headphone", NULL),
275         SND_SOC_DAPM_MIC("Headset Mic", NULL),
276         SND_SOC_DAPM_MIC("Internal Mic", NULL),
277         SND_SOC_DAPM_SPK("Speaker", NULL),
278         SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
279                             platform_clock_control, SND_SOC_DAPM_PRE_PMU |
280                             SND_SOC_DAPM_POST_PMD),
281
282 };
283
284 static const struct snd_soc_dapm_route byt_rt5640_audio_map[] = {
285         {"Headphone", NULL, "Platform Clock"},
286         {"Headset Mic", NULL, "Platform Clock"},
287         {"Internal Mic", NULL, "Platform Clock"},
288         {"Speaker", NULL, "Platform Clock"},
289
290         {"Headset Mic", NULL, "MICBIAS1"},
291         {"IN2P", NULL, "Headset Mic"},
292         {"Headphone", NULL, "HPOL"},
293         {"Headphone", NULL, "HPOR"},
294 };
295
296 static const struct snd_soc_dapm_route byt_rt5640_intmic_dmic1_map[] = {
297         {"DMIC1", NULL, "Internal Mic"},
298 };
299
300 static const struct snd_soc_dapm_route byt_rt5640_intmic_dmic2_map[] = {
301         {"DMIC2", NULL, "Internal Mic"},
302 };
303
304 static const struct snd_soc_dapm_route byt_rt5640_intmic_in1_map[] = {
305         {"Internal Mic", NULL, "MICBIAS1"},
306         {"IN1P", NULL, "Internal Mic"},
307 };
308
309 static const struct snd_soc_dapm_route byt_rt5640_intmic_in3_map[] = {
310         {"Internal Mic", NULL, "MICBIAS1"},
311         {"IN3P", NULL, "Internal Mic"},
312 };
313
314 static const struct snd_soc_dapm_route byt_rt5640_ssp2_aif1_map[] = {
315         {"ssp2 Tx", NULL, "codec_out0"},
316         {"ssp2 Tx", NULL, "codec_out1"},
317         {"codec_in0", NULL, "ssp2 Rx"},
318         {"codec_in1", NULL, "ssp2 Rx"},
319
320         {"AIF1 Playback", NULL, "ssp2 Tx"},
321         {"ssp2 Rx", NULL, "AIF1 Capture"},
322 };
323
324 static const struct snd_soc_dapm_route byt_rt5640_ssp2_aif2_map[] = {
325         {"ssp2 Tx", NULL, "codec_out0"},
326         {"ssp2 Tx", NULL, "codec_out1"},
327         {"codec_in0", NULL, "ssp2 Rx"},
328         {"codec_in1", NULL, "ssp2 Rx"},
329
330         {"AIF2 Playback", NULL, "ssp2 Tx"},
331         {"ssp2 Rx", NULL, "AIF2 Capture"},
332 };
333
334 static const struct snd_soc_dapm_route byt_rt5640_ssp0_aif1_map[] = {
335         {"ssp0 Tx", NULL, "modem_out"},
336         {"modem_in", NULL, "ssp0 Rx"},
337
338         {"AIF1 Playback", NULL, "ssp0 Tx"},
339         {"ssp0 Rx", NULL, "AIF1 Capture"},
340 };
341
342 static const struct snd_soc_dapm_route byt_rt5640_ssp0_aif2_map[] = {
343         {"ssp0 Tx", NULL, "modem_out"},
344         {"modem_in", NULL, "ssp0 Rx"},
345
346         {"AIF2 Playback", NULL, "ssp0 Tx"},
347         {"ssp0 Rx", NULL, "AIF2 Capture"},
348 };
349
350 static const struct snd_soc_dapm_route byt_rt5640_stereo_spk_map[] = {
351         {"Speaker", NULL, "SPOLP"},
352         {"Speaker", NULL, "SPOLN"},
353         {"Speaker", NULL, "SPORP"},
354         {"Speaker", NULL, "SPORN"},
355 };
356
357 static const struct snd_soc_dapm_route byt_rt5640_mono_spk_map[] = {
358         {"Speaker", NULL, "SPOLP"},
359         {"Speaker", NULL, "SPOLN"},
360 };
361
362 static const struct snd_kcontrol_new byt_rt5640_controls[] = {
363         SOC_DAPM_PIN_SWITCH("Headphone"),
364         SOC_DAPM_PIN_SWITCH("Headset Mic"),
365         SOC_DAPM_PIN_SWITCH("Internal Mic"),
366         SOC_DAPM_PIN_SWITCH("Speaker"),
367 };
368
369 static struct snd_soc_jack_pin rt5640_pins[] = {
370         {
371                 .pin    = "Headphone",
372                 .mask   = SND_JACK_HEADPHONE,
373         },
374         {
375                 .pin    = "Headset Mic",
376                 .mask   = SND_JACK_MICROPHONE,
377         },
378 };
379
380 static int byt_rt5640_aif1_hw_params(struct snd_pcm_substream *substream,
381                                         struct snd_pcm_hw_params *params)
382 {
383         struct snd_soc_pcm_runtime *rtd = substream->private_data;
384         struct snd_soc_dai *dai = rtd->codec_dai;
385
386         return byt_rt5640_prepare_and_enable_pll1(dai, params_rate(params));
387 }
388
389 /* Please keep this list alphabetically sorted */
390 static const struct dmi_system_id byt_rt5640_quirk_table[] = {
391         {       /* Acer Iconia Tab 8 W1-810 */
392                 .matches = {
393                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"),
394                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Iconia W1-810"),
395                 },
396                 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
397                                         BYT_RT5640_JD_SRC_JD1_IN4P |
398                                         BYT_RT5640_OVCD_TH_1500UA |
399                                         BYT_RT5640_OVCD_SF_0P75 |
400                                         BYT_RT5640_SSP0_AIF1 |
401                                         BYT_RT5640_MCLK_EN),
402         },
403         {
404                 .matches = {
405                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
406                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"),
407                 },
408                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
409                                                  BYT_RT5640_MCLK_EN |
410                                                  BYT_RT5640_SSP0_AIF1),
411
412         },
413         {
414                 .matches = {
415                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ARCHOS"),
416                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ARCHOS 80 Cesium"),
417                 },
418                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
419                                         BYT_RT5640_MONO_SPEAKER |
420                                         BYT_RT5640_SSP0_AIF1 |
421                                         BYT_RT5640_MCLK_EN),
422         },
423         {
424                 .matches = {
425                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
426                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ME176C"),
427                 },
428                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
429                                         BYT_RT5640_JD_SRC_JD2_IN4N |
430                                         BYT_RT5640_OVCD_TH_2000UA |
431                                         BYT_RT5640_OVCD_SF_0P75 |
432                                         BYT_RT5640_SSP0_AIF1 |
433                                         BYT_RT5640_MCLK_EN),
434         },
435         {
436                 .matches = {
437                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
438                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100TA"),
439                 },
440                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
441                                         BYT_RT5640_JD_SRC_JD2_IN4N |
442                                         BYT_RT5640_OVCD_TH_2000UA |
443                                         BYT_RT5640_OVCD_SF_0P75 |
444                                         BYT_RT5640_MCLK_EN),
445         },
446         {
447                 .matches = {
448                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
449                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100TAF"),
450                 },
451                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
452                                         BYT_RT5640_MONO_SPEAKER |
453                                         BYT_RT5640_DIFF_MIC |
454                                         BYT_RT5640_SSP0_AIF2 |
455                                         BYT_RT5640_MCLK_EN),
456         },
457         {       /* Chuwi Vi8 (CWI506) */
458                 .matches = {
459                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Insyde"),
460                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "i86"),
461                         /* The above are too generic, also match BIOS info */
462                         DMI_MATCH(DMI_BIOS_VERSION, "CHUWI.D86JLBNR"),
463                 },
464                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
465                                         BYT_RT5640_MONO_SPEAKER |
466                                         BYT_RT5640_SSP0_AIF1 |
467                                         BYT_RT5640_MCLK_EN),
468         },
469         {
470                 /* Chuwi Vi10 (CWI505) */
471                 .matches = {
472                         DMI_MATCH(DMI_BOARD_VENDOR, "Hampoo"),
473                         DMI_MATCH(DMI_BOARD_NAME, "BYT-PF02"),
474                         DMI_MATCH(DMI_SYS_VENDOR, "ilife"),
475                         DMI_MATCH(DMI_PRODUCT_NAME, "S165"),
476                 },
477                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
478                                         BYT_RT5640_JD_SRC_JD2_IN4N |
479                                         BYT_RT5640_OVCD_TH_2000UA |
480                                         BYT_RT5640_OVCD_SF_0P75 |
481                                         BYT_RT5640_DIFF_MIC |
482                                         BYT_RT5640_SSP0_AIF1 |
483                                         BYT_RT5640_MCLK_EN),
484         },
485         {
486                 .matches = {
487                         DMI_MATCH(DMI_SYS_VENDOR, "Circuitco"),
488                         DMI_MATCH(DMI_PRODUCT_NAME, "Minnowboard Max B3 PLATFORM"),
489                 },
490                 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP),
491         },
492         {       /* Connect Tablet 9 */
493                 .matches = {
494                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Connect"),
495                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Tablet 9"),
496                 },
497                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
498                                         BYT_RT5640_MONO_SPEAKER |
499                                         BYT_RT5640_SSP0_AIF1 |
500                                         BYT_RT5640_MCLK_EN),
501         },
502         {
503                 .matches = {
504                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
505                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Venue 8 Pro 5830"),
506                 },
507                 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
508                                         BYT_RT5640_JD_SRC_JD2_IN4N |
509                                         BYT_RT5640_OVCD_TH_2000UA |
510                                         BYT_RT5640_OVCD_SF_0P75 |
511                                         BYT_RT5640_MONO_SPEAKER |
512                                         BYT_RT5640_MCLK_EN),
513         },
514         {
515                 .matches = {
516                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
517                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP ElitePad 1000 G2"),
518                 },
519                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
520                                         BYT_RT5640_MCLK_EN),
521         },
522         {       /* HP Pavilion x2 10-n000nd */
523                 .matches = {
524                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
525                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
526                 },
527                 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
528                                         BYT_RT5640_JD_SRC_JD2_IN4N |
529                                         BYT_RT5640_OVCD_TH_1500UA |
530                                         BYT_RT5640_OVCD_SF_0P75 |
531                                         BYT_RT5640_SSP0_AIF1 |
532                                         BYT_RT5640_MCLK_EN),
533         },
534         {       /* HP Stream 7 */
535                 .matches = {
536                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
537                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Stream 7 Tablet"),
538                 },
539                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
540                                         BYT_RT5640_MONO_SPEAKER |
541                                         BYT_RT5640_JD_NOT_INV |
542                                         BYT_RT5640_SSP0_AIF1 |
543                                         BYT_RT5640_MCLK_EN),
544         },
545         {       /* I.T.Works TW891 */
546                 .matches = {
547                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "To be filled by O.E.M."),
548                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "TW891"),
549                         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "To be filled by O.E.M."),
550                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "TW891"),
551                 },
552                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
553                                         BYT_RT5640_MONO_SPEAKER |
554                                         BYT_RT5640_SSP0_AIF1 |
555                                         BYT_RT5640_MCLK_EN),
556         },
557         {       /* Lamina I8270 / T701BR.SE */
558                 .matches = {
559                         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "Lamina"),
560                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "T701BR.SE"),
561                 },
562                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
563                                         BYT_RT5640_MONO_SPEAKER |
564                                         BYT_RT5640_JD_NOT_INV |
565                                         BYT_RT5640_SSP0_AIF1 |
566                                         BYT_RT5640_MCLK_EN),
567         },
568         {       /* Lenovo Miix 2 8 */
569                 .matches = {
570                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
571                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "20326"),
572                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "Hiking"),
573                 },
574                 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
575                                         BYT_RT5640_JD_SRC_JD2_IN4N |
576                                         BYT_RT5640_OVCD_TH_2000UA |
577                                         BYT_RT5640_OVCD_SF_0P75 |
578                                         BYT_RT5640_MONO_SPEAKER |
579                                         BYT_RT5640_MCLK_EN),
580         },
581         {       /* Linx Linx7 tablet */
582                 .matches = {
583                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LINX"),
584                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "LINX7"),
585                 },
586                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
587                                         BYT_RT5640_MONO_SPEAKER |
588                                         BYT_RT5640_JD_NOT_INV |
589                                         BYT_RT5640_SSP0_AIF1 |
590                                         BYT_RT5640_MCLK_EN),
591         },
592         {       /* MSI S100 tablet */
593                 .matches = {
594                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Micro-Star International Co., Ltd."),
595                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "S100"),
596                 },
597                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
598                                         BYT_RT5640_JD_SRC_JD2_IN4N |
599                                         BYT_RT5640_OVCD_TH_2000UA |
600                                         BYT_RT5640_OVCD_SF_0P75 |
601                                         BYT_RT5640_MONO_SPEAKER |
602                                         BYT_RT5640_DIFF_MIC |
603                                         BYT_RT5640_MCLK_EN),
604         },
605         {       /* Nuvison/TMax TM800W560 */
606                 .matches = {
607                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TMAX"),
608                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "TM800W560L"),
609                 },
610                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
611                                         BYT_RT5640_JD_SRC_JD2_IN4N |
612                                         BYT_RT5640_OVCD_TH_2000UA |
613                                         BYT_RT5640_OVCD_SF_0P75 |
614                                         BYT_RT5640_JD_NOT_INV |
615                                         BYT_RT5640_DIFF_MIC |
616                                         BYT_RT5640_SSP0_AIF1 |
617                                         BYT_RT5640_MCLK_EN),
618         },
619         {       /* Onda v975w */
620                 .matches = {
621                         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
622                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
623                         /* The above are too generic, also match BIOS info */
624                         DMI_EXACT_MATCH(DMI_BIOS_VERSION, "5.6.5"),
625                         DMI_EXACT_MATCH(DMI_BIOS_DATE, "07/25/2014"),
626                 },
627                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
628                                         BYT_RT5640_JD_SRC_JD2_IN4N |
629                                         BYT_RT5640_OVCD_TH_2000UA |
630                                         BYT_RT5640_OVCD_SF_0P75 |
631                                         BYT_RT5640_DIFF_MIC |
632                                         BYT_RT5640_MCLK_EN),
633         },
634         {       /* Pipo W4 */
635                 .matches = {
636                         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
637                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
638                         /* The above are too generic, also match BIOS info */
639                         DMI_MATCH(DMI_BIOS_VERSION, "V8L_WIN32_CHIPHD"),
640                 },
641                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
642                                         BYT_RT5640_MONO_SPEAKER |
643                                         BYT_RT5640_SSP0_AIF1 |
644                                         BYT_RT5640_MCLK_EN),
645         },
646         {       /* Point of View Mobii TAB-P800W (V2.0) */
647                 .matches = {
648                         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
649                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
650                         /* The above are too generic, also match BIOS info */
651                         DMI_EXACT_MATCH(DMI_BIOS_VERSION, "3BAIR1014"),
652                         DMI_EXACT_MATCH(DMI_BIOS_DATE, "10/24/2014"),
653                 },
654                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
655                                         BYT_RT5640_JD_SRC_JD2_IN4N |
656                                         BYT_RT5640_OVCD_TH_2000UA |
657                                         BYT_RT5640_OVCD_SF_0P75 |
658                                         BYT_RT5640_MONO_SPEAKER |
659                                         BYT_RT5640_DIFF_MIC |
660                                         BYT_RT5640_SSP0_AIF2 |
661                                         BYT_RT5640_MCLK_EN),
662         },
663         {       /* Point of View Mobii TAB-P800W (V2.1) */
664                 .matches = {
665                         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
666                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
667                         /* The above are too generic, also match BIOS info */
668                         DMI_EXACT_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
669                         DMI_EXACT_MATCH(DMI_BIOS_DATE, "08/22/2014"),
670                 },
671                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
672                                         BYT_RT5640_JD_SRC_JD2_IN4N |
673                                         BYT_RT5640_OVCD_TH_2000UA |
674                                         BYT_RT5640_OVCD_SF_0P75 |
675                                         BYT_RT5640_MONO_SPEAKER |
676                                         BYT_RT5640_DIFF_MIC |
677                                         BYT_RT5640_SSP0_AIF2 |
678                                         BYT_RT5640_MCLK_EN),
679         },
680         {       /* Point of View Mobii TAB-P1005W-232 (V2.0) */
681                 .matches = {
682                         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "POV"),
683                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "I102A"),
684                 },
685                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
686                                         BYT_RT5640_JD_SRC_JD2_IN4N |
687                                         BYT_RT5640_OVCD_TH_2000UA |
688                                         BYT_RT5640_OVCD_SF_0P75 |
689                                         BYT_RT5640_DIFF_MIC |
690                                         BYT_RT5640_SSP0_AIF1 |
691                                         BYT_RT5640_MCLK_EN),
692         },
693         {
694                 /* Prowise PT301 */
695                 .matches = {
696                         DMI_MATCH(DMI_SYS_VENDOR, "Prowise"),
697                         DMI_MATCH(DMI_PRODUCT_NAME, "PT301"),
698                 },
699                 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
700                                         BYT_RT5640_JD_SRC_JD2_IN4N |
701                                         BYT_RT5640_OVCD_TH_2000UA |
702                                         BYT_RT5640_OVCD_SF_0P75 |
703                                         BYT_RT5640_DIFF_MIC |
704                                         BYT_RT5640_SSP0_AIF1 |
705                                         BYT_RT5640_MCLK_EN),
706         },
707         {
708                 .matches = {
709                         DMI_MATCH(DMI_BOARD_VENDOR, "TECLAST"),
710                         DMI_MATCH(DMI_BOARD_NAME, "tPAD"),
711                 },
712                 .driver_data = (void *)(BYT_RT5640_IN3_MAP |
713                                         BYT_RT5640_MCLK_EN |
714                                         BYT_RT5640_SSP0_AIF1),
715         },
716         {       /* Toshiba Satellite Click Mini L9W-B */
717                 .matches = {
718                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
719                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "SATELLITE Click Mini L9W-B"),
720                 },
721                 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
722                                         BYT_RT5640_JD_SRC_JD2_IN4N |
723                                         BYT_RT5640_OVCD_TH_1500UA |
724                                         BYT_RT5640_OVCD_SF_0P75 |
725                                         BYT_RT5640_SSP0_AIF1 |
726                                         BYT_RT5640_MCLK_EN),
727         },
728         {       /* Catch-all for generic Insyde tablets, must be last */
729                 .matches = {
730                         DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),
731                 },
732                 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
733                                         BYT_RT5640_MCLK_EN |
734                                         BYT_RT5640_SSP0_AIF1),
735
736         },
737         {}
738 };
739
740 /*
741  * Note this MUST be called before snd_soc_register_card(), so that the props
742  * are in place before the codec component driver's probe function parses them.
743  */
744 static int byt_rt5640_add_codec_device_props(const char *i2c_dev_name)
745 {
746         struct property_entry props[MAX_NO_PROPS] = {};
747         struct device *i2c_dev;
748         int ret, cnt = 0;
749
750         i2c_dev = bus_find_device_by_name(&i2c_bus_type, NULL, i2c_dev_name);
751         if (!i2c_dev)
752                 return -EPROBE_DEFER;
753
754         switch (BYT_RT5640_MAP(byt_rt5640_quirk)) {
755         case BYT_RT5640_DMIC1_MAP:
756                 props[cnt++] = PROPERTY_ENTRY_U32("realtek,dmic1-data-pin",
757                                                   RT5640_DMIC1_DATA_PIN_IN1P);
758                 break;
759         case BYT_RT5640_DMIC2_MAP:
760                 props[cnt++] = PROPERTY_ENTRY_U32("realtek,dmic2-data-pin",
761                                                   RT5640_DMIC2_DATA_PIN_IN1N);
762                 break;
763         case BYT_RT5640_IN1_MAP:
764                 if (byt_rt5640_quirk & BYT_RT5640_DIFF_MIC)
765                         props[cnt++] =
766                                 PROPERTY_ENTRY_BOOL("realtek,in1-differential");
767                 break;
768         case BYT_RT5640_IN3_MAP:
769                 if (byt_rt5640_quirk & BYT_RT5640_DIFF_MIC)
770                         props[cnt++] =
771                                 PROPERTY_ENTRY_BOOL("realtek,in3-differential");
772                 break;
773         }
774
775         if (BYT_RT5640_JDSRC(byt_rt5640_quirk)) {
776                 props[cnt++] = PROPERTY_ENTRY_U32(
777                                     "realtek,jack-detect-source",
778                                     BYT_RT5640_JDSRC(byt_rt5640_quirk));
779
780                 props[cnt++] = PROPERTY_ENTRY_U32(
781                                     "realtek,over-current-threshold-microamp",
782                                     BYT_RT5640_OVCD_TH(byt_rt5640_quirk) * 100);
783
784                 props[cnt++] = PROPERTY_ENTRY_U32(
785                                     "realtek,over-current-scale-factor",
786                                     BYT_RT5640_OVCD_SF(byt_rt5640_quirk));
787         }
788
789         if (byt_rt5640_quirk & BYT_RT5640_JD_NOT_INV)
790                 props[cnt++] = PROPERTY_ENTRY_BOOL("realtek,jack-detect-not-inverted");
791
792         ret = device_add_properties(i2c_dev, props);
793         put_device(i2c_dev);
794
795         return ret;
796 }
797
798 static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
799 {
800         struct snd_soc_card *card = runtime->card;
801         struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
802         struct snd_soc_component *component = runtime->codec_dai->component;
803         const struct snd_soc_dapm_route *custom_map;
804         int num_routes;
805         int ret;
806
807         card->dapm.idle_bias_off = true;
808
809         /* Start with RC clk for jack-detect (we disable MCLK below) */
810         if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN)
811                 snd_soc_component_update_bits(component, RT5640_GLB_CLK,
812                         RT5640_SCLK_SRC_MASK, RT5640_SCLK_SRC_RCCLK);
813
814         rt5640_sel_asrc_clk_src(component,
815                                 RT5640_DA_STEREO_FILTER |
816                                 RT5640_DA_MONO_L_FILTER |
817                                 RT5640_DA_MONO_R_FILTER |
818                                 RT5640_AD_STEREO_FILTER |
819                                 RT5640_AD_MONO_L_FILTER |
820                                 RT5640_AD_MONO_R_FILTER,
821                                 RT5640_CLK_SEL_ASRC);
822
823         ret = snd_soc_add_card_controls(card, byt_rt5640_controls,
824                                         ARRAY_SIZE(byt_rt5640_controls));
825         if (ret) {
826                 dev_err(card->dev, "unable to add card controls\n");
827                 return ret;
828         }
829
830         switch (BYT_RT5640_MAP(byt_rt5640_quirk)) {
831         case BYT_RT5640_IN1_MAP:
832                 custom_map = byt_rt5640_intmic_in1_map;
833                 num_routes = ARRAY_SIZE(byt_rt5640_intmic_in1_map);
834                 break;
835         case BYT_RT5640_IN3_MAP:
836                 custom_map = byt_rt5640_intmic_in3_map;
837                 num_routes = ARRAY_SIZE(byt_rt5640_intmic_in3_map);
838                 break;
839         case BYT_RT5640_DMIC2_MAP:
840                 custom_map = byt_rt5640_intmic_dmic2_map;
841                 num_routes = ARRAY_SIZE(byt_rt5640_intmic_dmic2_map);
842                 break;
843         default:
844                 custom_map = byt_rt5640_intmic_dmic1_map;
845                 num_routes = ARRAY_SIZE(byt_rt5640_intmic_dmic1_map);
846         }
847
848         ret = snd_soc_dapm_add_routes(&card->dapm, custom_map, num_routes);
849         if (ret)
850                 return ret;
851
852         if (byt_rt5640_quirk & BYT_RT5640_SSP2_AIF2) {
853                 ret = snd_soc_dapm_add_routes(&card->dapm,
854                                         byt_rt5640_ssp2_aif2_map,
855                                         ARRAY_SIZE(byt_rt5640_ssp2_aif2_map));
856         } else if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) {
857                 ret = snd_soc_dapm_add_routes(&card->dapm,
858                                         byt_rt5640_ssp0_aif1_map,
859                                         ARRAY_SIZE(byt_rt5640_ssp0_aif1_map));
860         } else if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2) {
861                 ret = snd_soc_dapm_add_routes(&card->dapm,
862                                         byt_rt5640_ssp0_aif2_map,
863                                         ARRAY_SIZE(byt_rt5640_ssp0_aif2_map));
864         } else {
865                 ret = snd_soc_dapm_add_routes(&card->dapm,
866                                         byt_rt5640_ssp2_aif1_map,
867                                         ARRAY_SIZE(byt_rt5640_ssp2_aif1_map));
868         }
869         if (ret)
870                 return ret;
871
872         if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) {
873                 ret = snd_soc_dapm_add_routes(&card->dapm,
874                                         byt_rt5640_mono_spk_map,
875                                         ARRAY_SIZE(byt_rt5640_mono_spk_map));
876         } else {
877                 ret = snd_soc_dapm_add_routes(&card->dapm,
878                                         byt_rt5640_stereo_spk_map,
879                                         ARRAY_SIZE(byt_rt5640_stereo_spk_map));
880         }
881         if (ret)
882                 return ret;
883
884         snd_soc_dapm_ignore_suspend(&card->dapm, "Headphone");
885         snd_soc_dapm_ignore_suspend(&card->dapm, "Speaker");
886
887         if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN) {
888                 /*
889                  * The firmware might enable the clock at
890                  * boot (this information may or may not
891                  * be reflected in the enable clock register).
892                  * To change the rate we must disable the clock
893                  * first to cover these cases. Due to common
894                  * clock framework restrictions that do not allow
895                  * to disable a clock that has not been enabled,
896                  * we need to enable the clock first.
897                  */
898                 ret = clk_prepare_enable(priv->mclk);
899                 if (!ret)
900                         clk_disable_unprepare(priv->mclk);
901
902                 if (byt_rt5640_quirk & BYT_RT5640_MCLK_25MHZ)
903                         ret = clk_set_rate(priv->mclk, 25000000);
904                 else
905                         ret = clk_set_rate(priv->mclk, 19200000);
906
907                 if (ret) {
908                         dev_err(card->dev, "unable to set MCLK rate\n");
909                         return ret;
910                 }
911         }
912
913         if (BYT_RT5640_JDSRC(byt_rt5640_quirk)) {
914                 ret = snd_soc_card_jack_new(card, "Headset",
915                                             SND_JACK_HEADSET | SND_JACK_BTN_0,
916                                             &priv->jack, rt5640_pins,
917                                             ARRAY_SIZE(rt5640_pins));
918                 if (ret) {
919                         dev_err(card->dev, "Jack creation failed %d\n", ret);
920                         return ret;
921                 }
922                 snd_jack_set_key(priv->jack.jack, SND_JACK_BTN_0,
923                                  KEY_PLAYPAUSE);
924                 snd_soc_component_set_jack(component, &priv->jack, NULL);
925         }
926
927         return 0;
928 }
929
930 static const struct snd_soc_pcm_stream byt_rt5640_dai_params = {
931         .formats = SNDRV_PCM_FMTBIT_S24_LE,
932         .rate_min = 48000,
933         .rate_max = 48000,
934         .channels_min = 2,
935         .channels_max = 2,
936 };
937
938 static int byt_rt5640_codec_fixup(struct snd_soc_pcm_runtime *rtd,
939                             struct snd_pcm_hw_params *params)
940 {
941         struct snd_interval *rate = hw_param_interval(params,
942                         SNDRV_PCM_HW_PARAM_RATE);
943         struct snd_interval *channels = hw_param_interval(params,
944                                                 SNDRV_PCM_HW_PARAM_CHANNELS);
945         int ret;
946
947         /* The DSP will covert the FE rate to 48k, stereo */
948         rate->min = rate->max = 48000;
949         channels->min = channels->max = 2;
950
951         if ((byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) ||
952                 (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) {
953
954                 /* set SSP0 to 16-bit */
955                 params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
956
957                 /*
958                  * Default mode for SSP configuration is TDM 4 slot, override config
959                  * with explicit setting to I2S 2ch 16-bit. The word length is set with
960                  * dai_set_tdm_slot() since there is no other API exposed
961                  */
962                 ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
963                                         SND_SOC_DAIFMT_I2S     |
964                                         SND_SOC_DAIFMT_NB_NF   |
965                                         SND_SOC_DAIFMT_CBS_CFS
966                         );
967                 if (ret < 0) {
968                         dev_err(rtd->dev, "can't set format to I2S, err %d\n", ret);
969                         return ret;
970                 }
971
972                 ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 16);
973                 if (ret < 0) {
974                         dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
975                         return ret;
976                 }
977
978         } else {
979
980                 /* set SSP2 to 24-bit */
981                 params_set_format(params, SNDRV_PCM_FORMAT_S24_LE);
982
983                 /*
984                  * Default mode for SSP configuration is TDM 4 slot, override config
985                  * with explicit setting to I2S 2ch 24-bit. The word length is set with
986                  * dai_set_tdm_slot() since there is no other API exposed
987                  */
988                 ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
989                                         SND_SOC_DAIFMT_I2S     |
990                                         SND_SOC_DAIFMT_NB_NF   |
991                                         SND_SOC_DAIFMT_CBS_CFS
992                         );
993                 if (ret < 0) {
994                         dev_err(rtd->dev, "can't set format to I2S, err %d\n", ret);
995                         return ret;
996                 }
997
998                 ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 24);
999                 if (ret < 0) {
1000                         dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
1001                         return ret;
1002                 }
1003         }
1004         return 0;
1005 }
1006
1007 static int byt_rt5640_aif1_startup(struct snd_pcm_substream *substream)
1008 {
1009         return snd_pcm_hw_constraint_single(substream->runtime,
1010                         SNDRV_PCM_HW_PARAM_RATE, 48000);
1011 }
1012
1013 static const struct snd_soc_ops byt_rt5640_aif1_ops = {
1014         .startup = byt_rt5640_aif1_startup,
1015 };
1016
1017 static const struct snd_soc_ops byt_rt5640_be_ssp2_ops = {
1018         .hw_params = byt_rt5640_aif1_hw_params,
1019 };
1020
1021 SND_SOC_DAILINK_DEF(dummy,
1022         DAILINK_COMP_ARRAY(COMP_DUMMY()));
1023
1024 SND_SOC_DAILINK_DEF(media,
1025         DAILINK_COMP_ARRAY(COMP_CPU("media-cpu-dai")));
1026
1027 SND_SOC_DAILINK_DEF(deepbuffer,
1028         DAILINK_COMP_ARRAY(COMP_CPU("deepbuffer-cpu-dai")));
1029
1030 SND_SOC_DAILINK_DEF(ssp2_port,
1031         /* overwritten for ssp0 routing */
1032         DAILINK_COMP_ARRAY(COMP_CPU("ssp2-port")));
1033 SND_SOC_DAILINK_DEF(ssp2_codec,
1034         DAILINK_COMP_ARRAY(COMP_CODEC(
1035         /* overwritten with HID */ "i2c-10EC5640:00",
1036         /* changed w/ quirk */  "rt5640-aif1")));
1037
1038 SND_SOC_DAILINK_DEF(platform,
1039         DAILINK_COMP_ARRAY(COMP_PLATFORM("sst-mfld-platform")));
1040
1041 static struct snd_soc_dai_link byt_rt5640_dais[] = {
1042         [MERR_DPCM_AUDIO] = {
1043                 .name = "Baytrail Audio Port",
1044                 .stream_name = "Baytrail Audio",
1045                 .nonatomic = true,
1046                 .dynamic = 1,
1047                 .dpcm_playback = 1,
1048                 .dpcm_capture = 1,
1049                 .ops = &byt_rt5640_aif1_ops,
1050                 SND_SOC_DAILINK_REG(media, dummy, platform),
1051         },
1052         [MERR_DPCM_DEEP_BUFFER] = {
1053                 .name = "Deep-Buffer Audio Port",
1054                 .stream_name = "Deep-Buffer Audio",
1055                 .nonatomic = true,
1056                 .dynamic = 1,
1057                 .dpcm_playback = 1,
1058                 .ops = &byt_rt5640_aif1_ops,
1059                 SND_SOC_DAILINK_REG(deepbuffer, dummy, platform),
1060         },
1061                 /* back ends */
1062         {
1063                 .name = "SSP2-Codec",
1064                 .id = 0,
1065                 .no_pcm = 1,
1066                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
1067                                                 | SND_SOC_DAIFMT_CBS_CFS,
1068                 .be_hw_params_fixup = byt_rt5640_codec_fixup,
1069                 .ignore_suspend = 1,
1070                 .nonatomic = true,
1071                 .dpcm_playback = 1,
1072                 .dpcm_capture = 1,
1073                 .init = byt_rt5640_init,
1074                 .ops = &byt_rt5640_be_ssp2_ops,
1075                 SND_SOC_DAILINK_REG(ssp2_port, ssp2_codec, platform),
1076         },
1077 };
1078
1079 /* SoC card */
1080 static char byt_rt5640_codec_name[SND_ACPI_I2C_ID_LEN];
1081 static char byt_rt5640_codec_aif_name[12]; /*  = "rt5640-aif[1|2]" */
1082 static char byt_rt5640_cpu_dai_name[10]; /*  = "ssp[0|2]-port" */
1083 static char byt_rt5640_long_name[40]; /* = "bytcr-rt5640-*-spk-*-mic" */
1084
1085 static int byt_rt5640_suspend(struct snd_soc_card *card)
1086 {
1087         struct snd_soc_component *component;
1088
1089         if (!BYT_RT5640_JDSRC(byt_rt5640_quirk))
1090                 return 0;
1091
1092         for_each_card_components(card, component) {
1093                 if (!strcmp(component->name, byt_rt5640_codec_name)) {
1094                         dev_dbg(component->dev, "disabling jack detect before suspend\n");
1095                         snd_soc_component_set_jack(component, NULL, NULL);
1096                         break;
1097                 }
1098         }
1099
1100         return 0;
1101 }
1102
1103 static int byt_rt5640_resume(struct snd_soc_card *card)
1104 {
1105         struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
1106         struct snd_soc_component *component;
1107
1108         if (!BYT_RT5640_JDSRC(byt_rt5640_quirk))
1109                 return 0;
1110
1111         for_each_card_components(card, component) {
1112                 if (!strcmp(component->name, byt_rt5640_codec_name)) {
1113                         dev_dbg(component->dev, "re-enabling jack detect after resume\n");
1114                         snd_soc_component_set_jack(component, &priv->jack, NULL);
1115                         break;
1116                 }
1117         }
1118
1119         return 0;
1120 }
1121
1122 static struct snd_soc_card byt_rt5640_card = {
1123         .name = "bytcr-rt5640",
1124         .owner = THIS_MODULE,
1125         .dai_link = byt_rt5640_dais,
1126         .num_links = ARRAY_SIZE(byt_rt5640_dais),
1127         .dapm_widgets = byt_rt5640_widgets,
1128         .num_dapm_widgets = ARRAY_SIZE(byt_rt5640_widgets),
1129         .dapm_routes = byt_rt5640_audio_map,
1130         .num_dapm_routes = ARRAY_SIZE(byt_rt5640_audio_map),
1131         .fully_routed = true,
1132         .suspend_pre = byt_rt5640_suspend,
1133         .resume_post = byt_rt5640_resume,
1134 };
1135
1136 struct acpi_chan_package {   /* ACPICA seems to require 64 bit integers */
1137         u64 aif_value;       /* 1: AIF1, 2: AIF2 */
1138         u64 mclock_value;    /* usually 25MHz (0x17d7940), ignored */
1139 };
1140
1141 static int snd_byt_rt5640_mc_probe(struct platform_device *pdev)
1142 {
1143         static const char * const map_name[] = { "dmic1", "dmic2", "in1", "in3" };
1144         const struct dmi_system_id *dmi_id;
1145         struct byt_rt5640_private *priv;
1146         struct snd_soc_acpi_mach *mach;
1147         const char *platform_name;
1148         struct acpi_device *adev;
1149         int ret_val = 0;
1150         int dai_index = 0;
1151         int i;
1152
1153         is_bytcr = false;
1154         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
1155         if (!priv)
1156                 return -ENOMEM;
1157
1158         /* register the soc card */
1159         byt_rt5640_card.dev = &pdev->dev;
1160         mach = byt_rt5640_card.dev->platform_data;
1161         snd_soc_card_set_drvdata(&byt_rt5640_card, priv);
1162
1163         /* fix index of codec dai */
1164         for (i = 0; i < ARRAY_SIZE(byt_rt5640_dais); i++) {
1165                 if (!strcmp(byt_rt5640_dais[i].codecs->name,
1166                             "i2c-10EC5640:00")) {
1167                         dai_index = i;
1168                         break;
1169                 }
1170         }
1171
1172         /* fixup codec name based on HID */
1173         adev = acpi_dev_get_first_match_dev(mach->id, NULL, -1);
1174         if (adev) {
1175                 snprintf(byt_rt5640_codec_name, sizeof(byt_rt5640_codec_name),
1176                          "i2c-%s", acpi_dev_name(adev));
1177                 put_device(&adev->dev);
1178                 byt_rt5640_dais[dai_index].codecs->name = byt_rt5640_codec_name;
1179         }
1180
1181         /*
1182          * swap SSP0 if bytcr is detected
1183          * (will be overridden if DMI quirk is detected)
1184          */
1185         if (soc_intel_is_byt()) {
1186                 if (mach->mach_params.acpi_ipc_irq_index == 0)
1187                         is_bytcr = true;
1188         }
1189
1190         if (is_bytcr) {
1191                 /*
1192                  * Baytrail CR platforms may have CHAN package in BIOS, try
1193                  * to find relevant routing quirk based as done on Windows
1194                  * platforms. We have to read the information directly from the
1195                  * BIOS, at this stage the card is not created and the links
1196                  * with the codec driver/pdata are non-existent
1197                  */
1198
1199                 struct acpi_chan_package chan_package;
1200
1201                 /* format specified: 2 64-bit integers */
1202                 struct acpi_buffer format = {sizeof("NN"), "NN"};
1203                 struct acpi_buffer state = {0, NULL};
1204                 struct snd_soc_acpi_package_context pkg_ctx;
1205                 bool pkg_found = false;
1206
1207                 state.length = sizeof(chan_package);
1208                 state.pointer = &chan_package;
1209
1210                 pkg_ctx.name = "CHAN";
1211                 pkg_ctx.length = 2;
1212                 pkg_ctx.format = &format;
1213                 pkg_ctx.state = &state;
1214                 pkg_ctx.data_valid = false;
1215
1216                 pkg_found = snd_soc_acpi_find_package_from_hid(mach->id,
1217                                                                &pkg_ctx);
1218                 if (pkg_found) {
1219                         if (chan_package.aif_value == 1) {
1220                                 dev_info(&pdev->dev, "BIOS Routing: AIF1 connected\n");
1221                                 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF1;
1222                         } else  if (chan_package.aif_value == 2) {
1223                                 dev_info(&pdev->dev, "BIOS Routing: AIF2 connected\n");
1224                                 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF2;
1225                         } else {
1226                                 dev_info(&pdev->dev, "BIOS Routing isn't valid, ignored\n");
1227                                 pkg_found = false;
1228                         }
1229                 }
1230
1231                 if (!pkg_found) {
1232                         /* no BIOS indications, assume SSP0-AIF2 connection */
1233                         byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF2;
1234                 }
1235
1236                 /* change defaults for Baytrail-CR capture */
1237                 byt_rt5640_quirk |= BYTCR_INPUT_DEFAULTS;
1238         } else {
1239                 byt_rt5640_quirk |= BYT_RT5640_DMIC1_MAP |
1240                                     BYT_RT5640_JD_SRC_JD2_IN4N |
1241                                     BYT_RT5640_OVCD_TH_2000UA |
1242                                     BYT_RT5640_OVCD_SF_0P75;
1243         }
1244
1245         /* check quirks before creating card */
1246         dmi_id = dmi_first_match(byt_rt5640_quirk_table);
1247         if (dmi_id)
1248                 byt_rt5640_quirk = (unsigned long)dmi_id->driver_data;
1249         if (quirk_override != -1) {
1250                 dev_info(&pdev->dev, "Overriding quirk 0x%x => 0x%x\n",
1251                          (unsigned int)byt_rt5640_quirk, quirk_override);
1252                 byt_rt5640_quirk = quirk_override;
1253         }
1254
1255         /* Must be called before register_card, also see declaration comment. */
1256         ret_val = byt_rt5640_add_codec_device_props(byt_rt5640_codec_name);
1257         if (ret_val)
1258                 return ret_val;
1259
1260         log_quirks(&pdev->dev);
1261
1262         if ((byt_rt5640_quirk & BYT_RT5640_SSP2_AIF2) ||
1263             (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) {
1264
1265                 /* fixup codec aif name */
1266                 snprintf(byt_rt5640_codec_aif_name,
1267                         sizeof(byt_rt5640_codec_aif_name),
1268                         "%s", "rt5640-aif2");
1269
1270                 byt_rt5640_dais[dai_index].codecs->dai_name =
1271                         byt_rt5640_codec_aif_name;
1272         }
1273
1274         if ((byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) ||
1275             (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) {
1276
1277                 /* fixup cpu dai name name */
1278                 snprintf(byt_rt5640_cpu_dai_name,
1279                         sizeof(byt_rt5640_cpu_dai_name),
1280                         "%s", "ssp0-port");
1281
1282                 byt_rt5640_dais[dai_index].cpus->dai_name =
1283                         byt_rt5640_cpu_dai_name;
1284         }
1285
1286         if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN) {
1287                 priv->mclk = devm_clk_get(&pdev->dev, "pmc_plt_clk_3");
1288                 if (IS_ERR(priv->mclk)) {
1289                         ret_val = PTR_ERR(priv->mclk);
1290
1291                         dev_err(&pdev->dev,
1292                                 "Failed to get MCLK from pmc_plt_clk_3: %d\n",
1293                                 ret_val);
1294
1295                         /*
1296                          * Fall back to bit clock usage for -ENOENT (clock not
1297                          * available likely due to missing dependencies), bail
1298                          * for all other errors, including -EPROBE_DEFER
1299                          */
1300                         if (ret_val != -ENOENT)
1301                                 return ret_val;
1302                         byt_rt5640_quirk &= ~BYT_RT5640_MCLK_EN;
1303                 }
1304         }
1305
1306         snprintf(byt_rt5640_long_name, sizeof(byt_rt5640_long_name),
1307                  "bytcr-rt5640-%s-spk-%s-mic",
1308                  (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) ?
1309                         "mono" : "stereo",
1310                  map_name[BYT_RT5640_MAP(byt_rt5640_quirk)]);
1311         byt_rt5640_card.long_name = byt_rt5640_long_name;
1312
1313         /* override plaform name, if required */
1314         platform_name = mach->mach_params.platform;
1315
1316         ret_val = snd_soc_fixup_dai_links_platform_name(&byt_rt5640_card,
1317                                                         platform_name);
1318         if (ret_val)
1319                 return ret_val;
1320
1321         ret_val = devm_snd_soc_register_card(&pdev->dev, &byt_rt5640_card);
1322
1323         if (ret_val) {
1324                 dev_err(&pdev->dev, "devm_snd_soc_register_card failed %d\n",
1325                         ret_val);
1326                 return ret_val;
1327         }
1328         platform_set_drvdata(pdev, &byt_rt5640_card);
1329         return ret_val;
1330 }
1331
1332 static struct platform_driver snd_byt_rt5640_mc_driver = {
1333         .driver = {
1334                 .name = "bytcr_rt5640",
1335         },
1336         .probe = snd_byt_rt5640_mc_probe,
1337 };
1338
1339 module_platform_driver(snd_byt_rt5640_mc_driver);
1340
1341 MODULE_DESCRIPTION("ASoC Intel(R) Baytrail CR Machine driver");
1342 MODULE_AUTHOR("Subhransu S. Prusty <subhransu.s.prusty@intel.com>");
1343 MODULE_LICENSE("GPL v2");
1344 MODULE_ALIAS("platform:bytcr_rt5640");