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/gpio/consumer.h>
22 #include <linux/gpio/machine.h>
23 #include <linux/input.h>
24 #include <linux/slab.h>
25 #include <sound/pcm.h>
26 #include <sound/pcm_params.h>
27 #include <sound/soc.h>
28 #include <sound/jack.h>
29 #include <sound/soc-acpi.h>
30 #include <dt-bindings/sound/rt5640.h>
31 #include "../../codecs/rt5640.h"
32 #include "../atom/sst-atom-controls.h"
33 #include "../common/soc-intel-quirks.h"
34
35 enum {
36 BYT_RT5640_DMIC1_MAP,
37 BYT_RT5640_DMIC2_MAP,
38 BYT_RT5640_IN1_MAP,
39 BYT_RT5640_IN3_MAP,
40 BYT_RT5640_NO_INTERNAL_MIC_MAP,
41 };
42
43 #define RT5640_JD_SRC_EXT_GPIO 0x0f
44
45 enum {
46 BYT_RT5640_JD_SRC_GPIO1 = (RT5640_JD_SRC_GPIO1 << 4),
47 BYT_RT5640_JD_SRC_JD1_IN4P = (RT5640_JD_SRC_JD1_IN4P << 4),
48 BYT_RT5640_JD_SRC_JD2_IN4N = (RT5640_JD_SRC_JD2_IN4N << 4),
49 BYT_RT5640_JD_SRC_GPIO2 = (RT5640_JD_SRC_GPIO2 << 4),
50 BYT_RT5640_JD_SRC_GPIO3 = (RT5640_JD_SRC_GPIO3 << 4),
51 BYT_RT5640_JD_SRC_GPIO4 = (RT5640_JD_SRC_GPIO4 << 4),
52 BYT_RT5640_JD_SRC_EXT_GPIO = (RT5640_JD_SRC_EXT_GPIO << 4)
53 };
54
55 enum {
56 BYT_RT5640_OVCD_TH_600UA = (6 << 8),
57 BYT_RT5640_OVCD_TH_1500UA = (15 << 8),
58 BYT_RT5640_OVCD_TH_2000UA = (20 << 8),
59 };
60
61 enum {
62 BYT_RT5640_OVCD_SF_0P5 = (RT5640_OVCD_SF_0P5 << 13),
63 BYT_RT5640_OVCD_SF_0P75 = (RT5640_OVCD_SF_0P75 << 13),
64 BYT_RT5640_OVCD_SF_1P0 = (RT5640_OVCD_SF_1P0 << 13),
65 BYT_RT5640_OVCD_SF_1P5 = (RT5640_OVCD_SF_1P5 << 13),
66 };
67
68 #define BYT_RT5640_MAP(quirk) ((quirk) & GENMASK(3, 0))
69 #define BYT_RT5640_JDSRC(quirk) (((quirk) & GENMASK(7, 4)) >> 4)
70 #define BYT_RT5640_OVCD_TH(quirk) (((quirk) & GENMASK(12, 8)) >> 8)
71 #define BYT_RT5640_OVCD_SF(quirk) (((quirk) & GENMASK(14, 13)) >> 13)
72 #define BYT_RT5640_JD_NOT_INV BIT(16)
73 #define BYT_RT5640_MONO_SPEAKER BIT(17)
74 #define BYT_RT5640_DIFF_MIC BIT(18) /* default is single-ended */
75 #define BYT_RT5640_SSP2_AIF2 BIT(19) /* default is using AIF1 */
76 #define BYT_RT5640_SSP0_AIF1 BIT(20)
77 #define BYT_RT5640_SSP0_AIF2 BIT(21)
78 #define BYT_RT5640_MCLK_EN BIT(22)
79 #define BYT_RT5640_MCLK_25MHZ BIT(23)
80 #define BYT_RT5640_NO_SPEAKERS BIT(24)
81 #define BYT_RT5640_LINEOUT BIT(25)
82 #define BYT_RT5640_LINEOUT_AS_HP2 BIT(26)
83 #define BYT_RT5640_HSMIC2_ON_IN1 BIT(27)
84 #define BYT_RT5640_JD_HP_ELITEP_1000G2 BIT(28)
85 #define BYT_RT5640_USE_AMCR0F28 BIT(29)
86 #define BYT_RT5640_SWAPPED_SPEAKERS BIT(30)
87
88 #define BYTCR_INPUT_DEFAULTS \
89 (BYT_RT5640_IN3_MAP | \
90 BYT_RT5640_JD_SRC_JD1_IN4P | \
91 BYT_RT5640_OVCD_TH_2000UA | \
92 BYT_RT5640_OVCD_SF_0P75 | \
93 BYT_RT5640_DIFF_MIC)
94
95 /* in-diff or dmic-pin + jdsrc + ovcd-th + -sf + jd-inv + terminating entry */
96 #define MAX_NO_PROPS 6
97
98 struct byt_rt5640_private {
99 struct snd_soc_jack jack;
100 struct snd_soc_jack jack2;
101 struct rt5640_set_jack_data jack_data;
102 struct gpio_desc *hsmic_detect;
103 struct clk *mclk;
104 struct device *codec_dev;
105 };
106 static bool is_bytcr;
107
108 static unsigned long byt_rt5640_quirk = BYT_RT5640_MCLK_EN;
109 static int quirk_override = -1;
110 module_param_named(quirk, quirk_override, int, 0444);
111 MODULE_PARM_DESC(quirk, "Board-specific quirk override");
112
log_quirks(struct device * dev)113 static void log_quirks(struct device *dev)
114 {
115 int map;
116 bool has_mclk = false;
117 bool has_ssp0 = false;
118 bool has_ssp0_aif1 = false;
119 bool has_ssp0_aif2 = false;
120 bool has_ssp2_aif2 = false;
121
122 map = BYT_RT5640_MAP(byt_rt5640_quirk);
123 switch (map) {
124 case BYT_RT5640_DMIC1_MAP:
125 dev_info(dev, "quirk DMIC1_MAP enabled\n");
126 break;
127 case BYT_RT5640_DMIC2_MAP:
128 dev_info(dev, "quirk DMIC2_MAP enabled\n");
129 break;
130 case BYT_RT5640_IN1_MAP:
131 dev_info(dev, "quirk IN1_MAP enabled\n");
132 break;
133 case BYT_RT5640_IN3_MAP:
134 dev_info(dev, "quirk IN3_MAP enabled\n");
135 break;
136 case BYT_RT5640_NO_INTERNAL_MIC_MAP:
137 dev_info(dev, "quirk NO_INTERNAL_MIC_MAP enabled\n");
138 break;
139 default:
140 dev_err(dev, "quirk map 0x%x is not supported, microphone input will not work\n", map);
141 break;
142 }
143 if (byt_rt5640_quirk & BYT_RT5640_HSMIC2_ON_IN1)
144 dev_info(dev, "quirk HSMIC2_ON_IN1 enabled\n");
145 if (BYT_RT5640_JDSRC(byt_rt5640_quirk)) {
146 dev_info(dev, "quirk realtek,jack-detect-source %ld\n",
147 BYT_RT5640_JDSRC(byt_rt5640_quirk));
148 dev_info(dev, "quirk realtek,over-current-threshold-microamp %ld\n",
149 BYT_RT5640_OVCD_TH(byt_rt5640_quirk) * 100);
150 dev_info(dev, "quirk realtek,over-current-scale-factor %ld\n",
151 BYT_RT5640_OVCD_SF(byt_rt5640_quirk));
152 }
153 if (byt_rt5640_quirk & BYT_RT5640_JD_NOT_INV)
154 dev_info(dev, "quirk JD_NOT_INV enabled\n");
155 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2)
156 dev_info(dev, "quirk JD_HP_ELITEPAD_1000G2 enabled\n");
157 if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER)
158 dev_info(dev, "quirk MONO_SPEAKER enabled\n");
159 if (byt_rt5640_quirk & BYT_RT5640_NO_SPEAKERS)
160 dev_info(dev, "quirk NO_SPEAKERS enabled\n");
161 if (byt_rt5640_quirk & BYT_RT5640_SWAPPED_SPEAKERS)
162 dev_info(dev, "quirk SWAPPED_SPEAKERS enabled\n");
163 if (byt_rt5640_quirk & BYT_RT5640_LINEOUT)
164 dev_info(dev, "quirk LINEOUT enabled\n");
165 if (byt_rt5640_quirk & BYT_RT5640_LINEOUT_AS_HP2)
166 dev_info(dev, "quirk LINEOUT_AS_HP2 enabled\n");
167 if (byt_rt5640_quirk & BYT_RT5640_DIFF_MIC)
168 dev_info(dev, "quirk DIFF_MIC enabled\n");
169 if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) {
170 dev_info(dev, "quirk SSP0_AIF1 enabled\n");
171 has_ssp0 = true;
172 has_ssp0_aif1 = true;
173 }
174 if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2) {
175 dev_info(dev, "quirk SSP0_AIF2 enabled\n");
176 has_ssp0 = true;
177 has_ssp0_aif2 = true;
178 }
179 if (byt_rt5640_quirk & BYT_RT5640_SSP2_AIF2) {
180 dev_info(dev, "quirk SSP2_AIF2 enabled\n");
181 has_ssp2_aif2 = true;
182 }
183 if (is_bytcr && !has_ssp0)
184 dev_err(dev, "Invalid routing, bytcr detected but no SSP0-based quirk, audio cannot work with SSP2 on bytcr\n");
185 if (has_ssp0_aif1 && has_ssp0_aif2)
186 dev_err(dev, "Invalid routing, SSP0 cannot be connected to both AIF1 and AIF2\n");
187 if (has_ssp0 && has_ssp2_aif2)
188 dev_err(dev, "Invalid routing, cannot have both SSP0 and SSP2 connected to codec\n");
189
190 if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN) {
191 dev_info(dev, "quirk MCLK_EN enabled\n");
192 has_mclk = true;
193 }
194 if (byt_rt5640_quirk & BYT_RT5640_MCLK_25MHZ) {
195 if (has_mclk)
196 dev_info(dev, "quirk MCLK_25MHZ enabled\n");
197 else
198 dev_err(dev, "quirk MCLK_25MHZ enabled but quirk MCLK not selected, will be ignored\n");
199 }
200 }
201
byt_rt5640_prepare_and_enable_pll1(struct snd_soc_dai * codec_dai,int rate)202 static int byt_rt5640_prepare_and_enable_pll1(struct snd_soc_dai *codec_dai,
203 int rate)
204 {
205 int ret;
206
207 /* Configure the PLL before selecting it */
208 if (!(byt_rt5640_quirk & BYT_RT5640_MCLK_EN)) {
209 /* use bitclock as PLL input */
210 if ((byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) ||
211 (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) {
212 /* 2x16 bit slots on SSP0 */
213 ret = snd_soc_dai_set_pll(codec_dai, 0,
214 RT5640_PLL1_S_BCLK1,
215 rate * 32, rate * 512);
216 } else {
217 /* 2x15 bit slots on SSP2 */
218 ret = snd_soc_dai_set_pll(codec_dai, 0,
219 RT5640_PLL1_S_BCLK1,
220 rate * 50, rate * 512);
221 }
222 } else {
223 if (byt_rt5640_quirk & BYT_RT5640_MCLK_25MHZ) {
224 ret = snd_soc_dai_set_pll(codec_dai, 0,
225 RT5640_PLL1_S_MCLK,
226 25000000, rate * 512);
227 } else {
228 ret = snd_soc_dai_set_pll(codec_dai, 0,
229 RT5640_PLL1_S_MCLK,
230 19200000, rate * 512);
231 }
232 }
233
234 if (ret < 0) {
235 dev_err(codec_dai->component->dev, "can't set pll: %d\n", ret);
236 return ret;
237 }
238
239 ret = snd_soc_dai_set_sysclk(codec_dai, RT5640_SCLK_S_PLL1,
240 rate * 512, SND_SOC_CLOCK_IN);
241 if (ret < 0) {
242 dev_err(codec_dai->component->dev, "can't set clock %d\n", ret);
243 return ret;
244 }
245
246 return 0;
247 }
248
249 #define BYT_CODEC_DAI1 "rt5640-aif1"
250 #define BYT_CODEC_DAI2 "rt5640-aif2"
251
byt_rt5640_get_codec_dai(struct snd_soc_dapm_context * dapm)252 static struct snd_soc_dai *byt_rt5640_get_codec_dai(struct snd_soc_dapm_context *dapm)
253 {
254 struct snd_soc_card *card = dapm->card;
255 struct snd_soc_dai *codec_dai;
256
257 codec_dai = snd_soc_card_get_codec_dai(card, BYT_CODEC_DAI1);
258 if (!codec_dai)
259 codec_dai = snd_soc_card_get_codec_dai(card, BYT_CODEC_DAI2);
260 if (!codec_dai)
261 dev_err(card->dev, "Error codec dai not found\n");
262
263 return codec_dai;
264 }
265
platform_clock_control(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,int event)266 static int platform_clock_control(struct snd_soc_dapm_widget *w,
267 struct snd_kcontrol *k, int event)
268 {
269 struct snd_soc_dapm_context *dapm = w->dapm;
270 struct snd_soc_card *card = dapm->card;
271 struct snd_soc_dai *codec_dai;
272 struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
273 int ret;
274
275 codec_dai = byt_rt5640_get_codec_dai(dapm);
276 if (!codec_dai)
277 return -EIO;
278
279 if (SND_SOC_DAPM_EVENT_ON(event)) {
280 ret = clk_prepare_enable(priv->mclk);
281 if (ret < 0) {
282 dev_err(card->dev, "could not configure MCLK state\n");
283 return ret;
284 }
285 ret = byt_rt5640_prepare_and_enable_pll1(codec_dai, 48000);
286 } else {
287 /*
288 * Set codec clock source to internal clock before
289 * turning off the platform clock. Codec needs clock
290 * for Jack detection and button press
291 */
292 ret = snd_soc_dai_set_sysclk(codec_dai, RT5640_SCLK_S_RCCLK,
293 48000 * 512,
294 SND_SOC_CLOCK_IN);
295 if (!ret)
296 clk_disable_unprepare(priv->mclk);
297 }
298
299 if (ret < 0) {
300 dev_err(card->dev, "can't set codec sysclk: %d\n", ret);
301 return ret;
302 }
303
304 return 0;
305 }
306
byt_rt5640_event_lineout(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,int event)307 static int byt_rt5640_event_lineout(struct snd_soc_dapm_widget *w,
308 struct snd_kcontrol *k, int event)
309 {
310 unsigned int gpio_ctrl3_val = RT5640_GP1_PF_OUT;
311 struct snd_soc_dai *codec_dai;
312
313 if (!(byt_rt5640_quirk & BYT_RT5640_LINEOUT_AS_HP2))
314 return 0;
315
316 /*
317 * On devices which use line-out as a second headphones output,
318 * the codec's GPIO1 pin is used to enable an external HP-amp.
319 */
320
321 codec_dai = byt_rt5640_get_codec_dai(w->dapm);
322 if (!codec_dai)
323 return -EIO;
324
325 if (SND_SOC_DAPM_EVENT_ON(event))
326 gpio_ctrl3_val |= RT5640_GP1_OUT_HI;
327
328 snd_soc_component_update_bits(codec_dai->component, RT5640_GPIO_CTRL3,
329 RT5640_GP1_PF_MASK | RT5640_GP1_OUT_MASK, gpio_ctrl3_val);
330
331 return 0;
332 }
333
334 static const struct snd_soc_dapm_widget byt_rt5640_widgets[] = {
335 SND_SOC_DAPM_HP("Headphone", NULL),
336 SND_SOC_DAPM_MIC("Headset Mic", NULL),
337 SND_SOC_DAPM_MIC("Headset Mic 2", NULL),
338 SND_SOC_DAPM_MIC("Internal Mic", NULL),
339 SND_SOC_DAPM_SPK("Speaker", NULL),
340 SND_SOC_DAPM_LINE("Line Out", byt_rt5640_event_lineout),
341 SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
342 platform_clock_control, SND_SOC_DAPM_PRE_PMU |
343 SND_SOC_DAPM_POST_PMD),
344 };
345
346 static const struct snd_soc_dapm_route byt_rt5640_audio_map[] = {
347 {"Headphone", NULL, "Platform Clock"},
348 {"Headset Mic", NULL, "Platform Clock"},
349 {"Headset Mic", NULL, "MICBIAS1"},
350 {"IN2P", NULL, "Headset Mic"},
351 {"Headphone", NULL, "HPOL"},
352 {"Headphone", NULL, "HPOR"},
353 };
354
355 static const struct snd_soc_dapm_route byt_rt5640_intmic_dmic1_map[] = {
356 {"Internal Mic", NULL, "Platform Clock"},
357 {"DMIC1", NULL, "Internal Mic"},
358 };
359
360 static const struct snd_soc_dapm_route byt_rt5640_intmic_dmic2_map[] = {
361 {"Internal Mic", NULL, "Platform Clock"},
362 {"DMIC2", NULL, "Internal Mic"},
363 };
364
365 static const struct snd_soc_dapm_route byt_rt5640_intmic_in1_map[] = {
366 {"Internal Mic", NULL, "Platform Clock"},
367 {"Internal Mic", NULL, "MICBIAS1"},
368 {"IN1P", NULL, "Internal Mic"},
369 };
370
371 static const struct snd_soc_dapm_route byt_rt5640_intmic_in3_map[] = {
372 {"Internal Mic", NULL, "Platform Clock"},
373 {"Internal Mic", NULL, "MICBIAS1"},
374 {"IN3P", NULL, "Internal Mic"},
375 };
376
377 static const struct snd_soc_dapm_route byt_rt5640_hsmic2_in1_map[] = {
378 {"Headset Mic 2", NULL, "Platform Clock"},
379 {"Headset Mic 2", NULL, "MICBIAS1"},
380 {"IN1P", NULL, "Headset Mic 2"},
381 };
382
383 static const struct snd_soc_dapm_route byt_rt5640_ssp2_aif1_map[] = {
384 {"ssp2 Tx", NULL, "codec_out0"},
385 {"ssp2 Tx", NULL, "codec_out1"},
386 {"codec_in0", NULL, "ssp2 Rx"},
387 {"codec_in1", NULL, "ssp2 Rx"},
388
389 {"AIF1 Playback", NULL, "ssp2 Tx"},
390 {"ssp2 Rx", NULL, "AIF1 Capture"},
391 };
392
393 static const struct snd_soc_dapm_route byt_rt5640_ssp2_aif2_map[] = {
394 {"ssp2 Tx", NULL, "codec_out0"},
395 {"ssp2 Tx", NULL, "codec_out1"},
396 {"codec_in0", NULL, "ssp2 Rx"},
397 {"codec_in1", NULL, "ssp2 Rx"},
398
399 {"AIF2 Playback", NULL, "ssp2 Tx"},
400 {"ssp2 Rx", NULL, "AIF2 Capture"},
401 };
402
403 static const struct snd_soc_dapm_route byt_rt5640_ssp0_aif1_map[] = {
404 {"ssp0 Tx", NULL, "modem_out"},
405 {"modem_in", NULL, "ssp0 Rx"},
406
407 {"AIF1 Playback", NULL, "ssp0 Tx"},
408 {"ssp0 Rx", NULL, "AIF1 Capture"},
409 };
410
411 static const struct snd_soc_dapm_route byt_rt5640_ssp0_aif2_map[] = {
412 {"ssp0 Tx", NULL, "modem_out"},
413 {"modem_in", NULL, "ssp0 Rx"},
414
415 {"AIF2 Playback", NULL, "ssp0 Tx"},
416 {"ssp0 Rx", NULL, "AIF2 Capture"},
417 };
418
419 static const struct snd_soc_dapm_route byt_rt5640_stereo_spk_map[] = {
420 {"Speaker", NULL, "Platform Clock"},
421 {"Speaker", NULL, "SPOLP"},
422 {"Speaker", NULL, "SPOLN"},
423 {"Speaker", NULL, "SPORP"},
424 {"Speaker", NULL, "SPORN"},
425 };
426
427 static const struct snd_soc_dapm_route byt_rt5640_mono_spk_map[] = {
428 {"Speaker", NULL, "Platform Clock"},
429 {"Speaker", NULL, "SPOLP"},
430 {"Speaker", NULL, "SPOLN"},
431 };
432
433 static const struct snd_soc_dapm_route byt_rt5640_lineout_map[] = {
434 {"Line Out", NULL, "Platform Clock"},
435 {"Line Out", NULL, "LOUTR"},
436 {"Line Out", NULL, "LOUTL"},
437 };
438
439 static const struct snd_kcontrol_new byt_rt5640_controls[] = {
440 SOC_DAPM_PIN_SWITCH("Headphone"),
441 SOC_DAPM_PIN_SWITCH("Headset Mic"),
442 SOC_DAPM_PIN_SWITCH("Headset Mic 2"),
443 SOC_DAPM_PIN_SWITCH("Internal Mic"),
444 SOC_DAPM_PIN_SWITCH("Speaker"),
445 SOC_DAPM_PIN_SWITCH("Line Out"),
446 };
447
448 static struct snd_soc_jack_pin rt5640_pins[] = {
449 {
450 .pin = "Headphone",
451 .mask = SND_JACK_HEADPHONE,
452 },
453 {
454 .pin = "Headset Mic",
455 .mask = SND_JACK_MICROPHONE,
456 },
457 };
458
459 static struct snd_soc_jack_pin rt5640_pins2[] = {
460 {
461 /* The 2nd headset jack uses lineout with an external HP-amp */
462 .pin = "Line Out",
463 .mask = SND_JACK_HEADPHONE,
464 },
465 {
466 .pin = "Headset Mic 2",
467 .mask = SND_JACK_MICROPHONE,
468 },
469 };
470
471 static struct snd_soc_jack_gpio rt5640_jack_gpio = {
472 .name = "hp-detect",
473 .report = SND_JACK_HEADSET,
474 .invert = true,
475 .debounce_time = 200,
476 };
477
478 static struct snd_soc_jack_gpio rt5640_jack2_gpio = {
479 .name = "hp2-detect",
480 .report = SND_JACK_HEADSET,
481 .invert = true,
482 .debounce_time = 200,
483 };
484
485 static const struct acpi_gpio_params acpi_gpio0 = { 0, 0, false };
486 static const struct acpi_gpio_params acpi_gpio1 = { 1, 0, false };
487 static const struct acpi_gpio_params acpi_gpio2 = { 2, 0, false };
488
489 static const struct acpi_gpio_mapping byt_rt5640_hp_elitepad_1000g2_gpios[] = {
490 { "hp-detect-gpios", &acpi_gpio0, 1, },
491 { "headset-mic-detect-gpios", &acpi_gpio1, 1, },
492 { "hp2-detect-gpios", &acpi_gpio2, 1, },
493 { },
494 };
495
byt_rt5640_hp_elitepad_1000g2_jack1_check(void * data)496 static int byt_rt5640_hp_elitepad_1000g2_jack1_check(void *data)
497 {
498 struct byt_rt5640_private *priv = data;
499 int jack_status, mic_status;
500
501 jack_status = gpiod_get_value_cansleep(rt5640_jack_gpio.desc);
502 if (jack_status)
503 return 0;
504
505 mic_status = gpiod_get_value_cansleep(priv->hsmic_detect);
506 if (mic_status)
507 return SND_JACK_HEADPHONE;
508 else
509 return SND_JACK_HEADSET;
510 }
511
byt_rt5640_hp_elitepad_1000g2_jack2_check(void * data)512 static int byt_rt5640_hp_elitepad_1000g2_jack2_check(void *data)
513 {
514 struct snd_soc_component *component = data;
515 int jack_status, report;
516
517 jack_status = gpiod_get_value_cansleep(rt5640_jack2_gpio.desc);
518 if (jack_status)
519 return 0;
520
521 rt5640_enable_micbias1_for_ovcd(component);
522 report = rt5640_detect_headset(component, rt5640_jack2_gpio.desc);
523 rt5640_disable_micbias1_for_ovcd(component);
524
525 return report;
526 }
527
byt_rt5640_aif1_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)528 static int byt_rt5640_aif1_hw_params(struct snd_pcm_substream *substream,
529 struct snd_pcm_hw_params *params)
530 {
531 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
532 struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
533
534 return byt_rt5640_prepare_and_enable_pll1(dai, params_rate(params));
535 }
536
537 /* Please keep this list alphabetically sorted */
538 static const struct dmi_system_id byt_rt5640_quirk_table[] = {
539 { /* Acer Iconia One 7 B1-750 */
540 .matches = {
541 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Insyde"),
542 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "VESPA2"),
543 },
544 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
545 BYT_RT5640_JD_SRC_JD1_IN4P |
546 BYT_RT5640_OVCD_TH_1500UA |
547 BYT_RT5640_OVCD_SF_0P75 |
548 BYT_RT5640_SSP0_AIF1 |
549 BYT_RT5640_MCLK_EN),
550 },
551 { /* Acer Iconia Tab 8 W1-810 */
552 .matches = {
553 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"),
554 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Iconia W1-810"),
555 },
556 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
557 BYT_RT5640_JD_SRC_JD1_IN4P |
558 BYT_RT5640_OVCD_TH_1500UA |
559 BYT_RT5640_OVCD_SF_0P75 |
560 BYT_RT5640_SSP0_AIF1 |
561 BYT_RT5640_MCLK_EN),
562 },
563 { /* Acer One 10 S1002 */
564 .matches = {
565 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
566 DMI_MATCH(DMI_PRODUCT_NAME, "One S1002"),
567 },
568 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
569 BYT_RT5640_JD_SRC_JD2_IN4N |
570 BYT_RT5640_OVCD_TH_2000UA |
571 BYT_RT5640_OVCD_SF_0P75 |
572 BYT_RT5640_DIFF_MIC |
573 BYT_RT5640_SSP0_AIF2 |
574 BYT_RT5640_MCLK_EN),
575 },
576 {
577 .matches = {
578 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
579 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"),
580 },
581 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
582 BYT_RT5640_JD_SRC_JD2_IN4N |
583 BYT_RT5640_OVCD_TH_2000UA |
584 BYT_RT5640_OVCD_SF_0P75 |
585 BYT_RT5640_SSP0_AIF1 |
586 BYT_RT5640_MCLK_EN),
587 },
588 {
589 /* Advantech MICA-071 */
590 .matches = {
591 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Advantech"),
592 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "MICA-071"),
593 },
594 /* OVCD Th = 1500uA to reliable detect head-phones vs -set */
595 .driver_data = (void *)(BYT_RT5640_IN3_MAP |
596 BYT_RT5640_JD_SRC_JD2_IN4N |
597 BYT_RT5640_OVCD_TH_1500UA |
598 BYT_RT5640_OVCD_SF_0P75 |
599 BYT_RT5640_MONO_SPEAKER |
600 BYT_RT5640_DIFF_MIC |
601 BYT_RT5640_MCLK_EN),
602 },
603 {
604 .matches = {
605 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ARCHOS"),
606 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ARCHOS 80 Cesium"),
607 },
608 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
609 BYT_RT5640_MONO_SPEAKER |
610 BYT_RT5640_SSP0_AIF1 |
611 BYT_RT5640_MCLK_EN),
612 },
613 {
614 .matches = {
615 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ARCHOS"),
616 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ARCHOS 140 CESIUM"),
617 },
618 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
619 BYT_RT5640_JD_SRC_JD2_IN4N |
620 BYT_RT5640_OVCD_TH_2000UA |
621 BYT_RT5640_OVCD_SF_0P75 |
622 BYT_RT5640_SSP0_AIF1 |
623 BYT_RT5640_MCLK_EN),
624 },
625 {
626 .matches = {
627 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
628 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ME176C"),
629 },
630 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
631 BYT_RT5640_JD_SRC_JD2_IN4N |
632 BYT_RT5640_OVCD_TH_2000UA |
633 BYT_RT5640_OVCD_SF_0P75 |
634 BYT_RT5640_SSP0_AIF1 |
635 BYT_RT5640_MCLK_EN |
636 BYT_RT5640_USE_AMCR0F28),
637 },
638 {
639 /* Asus T100TAF, unlike other T100TA* models this one has a mono speaker */
640 .matches = {
641 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
642 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100TAF"),
643 },
644 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
645 BYT_RT5640_JD_SRC_JD2_IN4N |
646 BYT_RT5640_OVCD_TH_2000UA |
647 BYT_RT5640_OVCD_SF_0P75 |
648 BYT_RT5640_MONO_SPEAKER |
649 BYT_RT5640_DIFF_MIC |
650 BYT_RT5640_SSP0_AIF2 |
651 BYT_RT5640_MCLK_EN),
652 },
653 {
654 /* Asus T100TA and T100TAM, must come after T100TAF (mono spk) match */
655 .matches = {
656 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
657 DMI_MATCH(DMI_PRODUCT_NAME, "T100TA"),
658 },
659 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
660 BYT_RT5640_JD_SRC_JD2_IN4N |
661 BYT_RT5640_OVCD_TH_2000UA |
662 BYT_RT5640_OVCD_SF_0P75 |
663 BYT_RT5640_MCLK_EN),
664 },
665 {
666 .matches = {
667 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
668 DMI_MATCH(DMI_PRODUCT_NAME, "TF103C"),
669 },
670 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
671 BYT_RT5640_JD_SRC_EXT_GPIO |
672 BYT_RT5640_OVCD_TH_2000UA |
673 BYT_RT5640_OVCD_SF_0P75 |
674 BYT_RT5640_SSP0_AIF1 |
675 BYT_RT5640_MCLK_EN |
676 BYT_RT5640_USE_AMCR0F28),
677 },
678 { /* Chuwi Vi8 (CWI506) */
679 .matches = {
680 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Insyde"),
681 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "i86"),
682 /* The above are too generic, also match BIOS info */
683 DMI_MATCH(DMI_BIOS_VERSION, "CHUWI.D86JLBNR"),
684 },
685 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
686 BYT_RT5640_MONO_SPEAKER |
687 BYT_RT5640_SSP0_AIF1 |
688 BYT_RT5640_MCLK_EN),
689 },
690 { /* Chuwi Vi8 dual-boot (CWI506) */
691 .matches = {
692 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Insyde"),
693 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "i86"),
694 /* The above are too generic, also match BIOS info */
695 DMI_MATCH(DMI_BIOS_VERSION, "CHUWI2.D86JHBNR02"),
696 },
697 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
698 BYT_RT5640_MONO_SPEAKER |
699 BYT_RT5640_SSP0_AIF1 |
700 BYT_RT5640_MCLK_EN),
701 },
702 {
703 /* Chuwi Vi10 (CWI505) */
704 .matches = {
705 DMI_MATCH(DMI_BOARD_VENDOR, "Hampoo"),
706 DMI_MATCH(DMI_BOARD_NAME, "BYT-PF02"),
707 DMI_MATCH(DMI_SYS_VENDOR, "ilife"),
708 DMI_MATCH(DMI_PRODUCT_NAME, "S165"),
709 },
710 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
711 BYT_RT5640_JD_SRC_JD2_IN4N |
712 BYT_RT5640_OVCD_TH_2000UA |
713 BYT_RT5640_OVCD_SF_0P75 |
714 BYT_RT5640_DIFF_MIC |
715 BYT_RT5640_SSP0_AIF1 |
716 BYT_RT5640_MCLK_EN),
717 },
718 {
719 /* Chuwi Hi8 (CWI509) */
720 .matches = {
721 DMI_MATCH(DMI_BOARD_VENDOR, "Hampoo"),
722 DMI_MATCH(DMI_BOARD_NAME, "BYT-PA03C"),
723 DMI_MATCH(DMI_SYS_VENDOR, "ilife"),
724 DMI_MATCH(DMI_PRODUCT_NAME, "S806"),
725 },
726 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
727 BYT_RT5640_JD_SRC_JD2_IN4N |
728 BYT_RT5640_OVCD_TH_2000UA |
729 BYT_RT5640_OVCD_SF_0P75 |
730 BYT_RT5640_MONO_SPEAKER |
731 BYT_RT5640_DIFF_MIC |
732 BYT_RT5640_SSP0_AIF1 |
733 BYT_RT5640_MCLK_EN),
734 },
735 {
736 .matches = {
737 DMI_MATCH(DMI_SYS_VENDOR, "Circuitco"),
738 DMI_MATCH(DMI_PRODUCT_NAME, "Minnowboard Max B3 PLATFORM"),
739 },
740 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP),
741 },
742 { /* Connect Tablet 9 */
743 .matches = {
744 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Connect"),
745 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Tablet 9"),
746 },
747 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
748 BYT_RT5640_MONO_SPEAKER |
749 BYT_RT5640_SSP0_AIF1 |
750 BYT_RT5640_MCLK_EN),
751 },
752 {
753 .matches = {
754 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
755 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Venue 8 Pro 5830"),
756 },
757 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
758 BYT_RT5640_JD_SRC_JD2_IN4N |
759 BYT_RT5640_OVCD_TH_2000UA |
760 BYT_RT5640_OVCD_SF_0P75 |
761 BYT_RT5640_MONO_SPEAKER |
762 BYT_RT5640_MCLK_EN),
763 },
764 { /* Estar Beauty HD MID 7316R */
765 .matches = {
766 DMI_MATCH(DMI_SYS_VENDOR, "Estar"),
767 DMI_MATCH(DMI_PRODUCT_NAME, "eSTAR BEAUTY HD Intel Quad core"),
768 },
769 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
770 BYT_RT5640_MONO_SPEAKER |
771 BYT_RT5640_SSP0_AIF1 |
772 BYT_RT5640_MCLK_EN),
773 },
774 { /* Glavey TM800A550L */
775 .matches = {
776 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
777 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
778 /* Above strings are too generic, also match on BIOS version */
779 DMI_MATCH(DMI_BIOS_VERSION, "ZY-8-BI-PX4S70VTR400-X423B-005-D"),
780 },
781 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
782 BYT_RT5640_SSP0_AIF1 |
783 BYT_RT5640_MCLK_EN),
784 },
785 {
786 .matches = {
787 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
788 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP ElitePad 1000 G2"),
789 },
790 .driver_data = (void *)(BYT_RT5640_DMIC2_MAP |
791 BYT_RT5640_MCLK_EN |
792 BYT_RT5640_LINEOUT |
793 BYT_RT5640_LINEOUT_AS_HP2 |
794 BYT_RT5640_HSMIC2_ON_IN1 |
795 BYT_RT5640_JD_HP_ELITEP_1000G2),
796 },
797 { /* HP Pavilion x2 10-k0XX, 10-n0XX */
798 .matches = {
799 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
800 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
801 },
802 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
803 BYT_RT5640_JD_SRC_JD2_IN4N |
804 BYT_RT5640_OVCD_TH_1500UA |
805 BYT_RT5640_OVCD_SF_0P75 |
806 BYT_RT5640_SSP0_AIF1 |
807 BYT_RT5640_MCLK_EN),
808 },
809 { /* HP Pavilion x2 10-p0XX */
810 .matches = {
811 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
812 DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"),
813 },
814 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
815 BYT_RT5640_JD_SRC_JD1_IN4P |
816 BYT_RT5640_OVCD_TH_2000UA |
817 BYT_RT5640_OVCD_SF_0P75 |
818 BYT_RT5640_MCLK_EN),
819 },
820 { /* HP Pro Tablet 408 */
821 .matches = {
822 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
823 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pro Tablet 408"),
824 },
825 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
826 BYT_RT5640_JD_SRC_JD2_IN4N |
827 BYT_RT5640_OVCD_TH_1500UA |
828 BYT_RT5640_OVCD_SF_0P75 |
829 BYT_RT5640_SSP0_AIF1 |
830 BYT_RT5640_MCLK_EN),
831 },
832 { /* HP Stream 7 */
833 .matches = {
834 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
835 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Stream 7 Tablet"),
836 },
837 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
838 BYT_RT5640_MONO_SPEAKER |
839 BYT_RT5640_JD_NOT_INV |
840 BYT_RT5640_SSP0_AIF1 |
841 BYT_RT5640_MCLK_EN),
842 },
843 { /* HP Stream 8 */
844 .matches = {
845 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
846 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Stream 8 Tablet"),
847 },
848 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
849 BYT_RT5640_JD_NOT_INV |
850 BYT_RT5640_SSP0_AIF1 |
851 BYT_RT5640_MCLK_EN),
852 },
853 { /* I.T.Works TW891 */
854 .matches = {
855 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "To be filled by O.E.M."),
856 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "TW891"),
857 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "To be filled by O.E.M."),
858 DMI_EXACT_MATCH(DMI_BOARD_NAME, "TW891"),
859 },
860 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
861 BYT_RT5640_MONO_SPEAKER |
862 BYT_RT5640_SSP0_AIF1 |
863 BYT_RT5640_MCLK_EN),
864 },
865 { /* Lamina I8270 / T701BR.SE */
866 .matches = {
867 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "Lamina"),
868 DMI_EXACT_MATCH(DMI_BOARD_NAME, "T701BR.SE"),
869 },
870 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
871 BYT_RT5640_MONO_SPEAKER |
872 BYT_RT5640_JD_NOT_INV |
873 BYT_RT5640_SSP0_AIF1 |
874 BYT_RT5640_MCLK_EN),
875 },
876 { /* Lenovo Miix 2 8 */
877 .matches = {
878 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
879 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "20326"),
880 DMI_EXACT_MATCH(DMI_BOARD_NAME, "Hiking"),
881 },
882 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
883 BYT_RT5640_JD_SRC_JD2_IN4N |
884 BYT_RT5640_OVCD_TH_2000UA |
885 BYT_RT5640_OVCD_SF_0P75 |
886 BYT_RT5640_MONO_SPEAKER |
887 BYT_RT5640_MCLK_EN),
888 },
889 { /* Lenovo Miix 3-830 */
890 .matches = {
891 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
892 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 3-830"),
893 },
894 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
895 BYT_RT5640_JD_SRC_JD2_IN4N |
896 BYT_RT5640_OVCD_TH_2000UA |
897 BYT_RT5640_OVCD_SF_0P75 |
898 BYT_RT5640_MONO_SPEAKER |
899 BYT_RT5640_DIFF_MIC |
900 BYT_RT5640_SSP0_AIF1 |
901 BYT_RT5640_MCLK_EN),
902 },
903 { /* Linx Linx7 tablet */
904 .matches = {
905 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LINX"),
906 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "LINX7"),
907 },
908 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
909 BYT_RT5640_MONO_SPEAKER |
910 BYT_RT5640_JD_NOT_INV |
911 BYT_RT5640_SSP0_AIF1 |
912 BYT_RT5640_MCLK_EN),
913 },
914 {
915 /* Medion Lifetab S10346 */
916 .matches = {
917 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
918 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
919 /* Above strings are much too generic, also match on BIOS date */
920 DMI_MATCH(DMI_BIOS_DATE, "10/22/2015"),
921 },
922 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
923 BYT_RT5640_SWAPPED_SPEAKERS |
924 BYT_RT5640_SSP0_AIF1 |
925 BYT_RT5640_MCLK_EN),
926 },
927 { /* Mele PCG03 Mini PC */
928 .matches = {
929 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "Mini PC"),
930 DMI_EXACT_MATCH(DMI_BOARD_NAME, "Mini PC"),
931 },
932 .driver_data = (void *)(BYT_RT5640_NO_INTERNAL_MIC_MAP |
933 BYT_RT5640_NO_SPEAKERS |
934 BYT_RT5640_SSP0_AIF1),
935 },
936 { /* MPMAN Converter 9, similar hw as the I.T.Works TW891 2-in-1 */
937 .matches = {
938 DMI_MATCH(DMI_SYS_VENDOR, "MPMAN"),
939 DMI_MATCH(DMI_PRODUCT_NAME, "Converter9"),
940 },
941 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
942 BYT_RT5640_MONO_SPEAKER |
943 BYT_RT5640_SSP0_AIF1 |
944 BYT_RT5640_MCLK_EN),
945 },
946 {
947 /* MPMAN MPWIN895CL */
948 .matches = {
949 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "MPMAN"),
950 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "MPWIN8900CL"),
951 },
952 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
953 BYT_RT5640_MONO_SPEAKER |
954 BYT_RT5640_SSP0_AIF1 |
955 BYT_RT5640_MCLK_EN),
956 },
957 { /* MSI S100 tablet */
958 .matches = {
959 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Micro-Star International Co., Ltd."),
960 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "S100"),
961 },
962 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
963 BYT_RT5640_JD_SRC_JD2_IN4N |
964 BYT_RT5640_OVCD_TH_2000UA |
965 BYT_RT5640_OVCD_SF_0P75 |
966 BYT_RT5640_MONO_SPEAKER |
967 BYT_RT5640_DIFF_MIC |
968 BYT_RT5640_MCLK_EN),
969 },
970 { /* Nuvison/TMax TM800W560 */
971 .matches = {
972 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TMAX"),
973 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "TM800W560L"),
974 },
975 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
976 BYT_RT5640_JD_SRC_JD2_IN4N |
977 BYT_RT5640_OVCD_TH_2000UA |
978 BYT_RT5640_OVCD_SF_0P75 |
979 BYT_RT5640_JD_NOT_INV |
980 BYT_RT5640_DIFF_MIC |
981 BYT_RT5640_SSP0_AIF1 |
982 BYT_RT5640_MCLK_EN),
983 },
984 { /* Onda v975w */
985 .matches = {
986 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
987 DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
988 /* The above are too generic, also match BIOS info */
989 DMI_EXACT_MATCH(DMI_BIOS_VERSION, "5.6.5"),
990 DMI_EXACT_MATCH(DMI_BIOS_DATE, "07/25/2014"),
991 },
992 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
993 BYT_RT5640_JD_SRC_JD2_IN4N |
994 BYT_RT5640_OVCD_TH_2000UA |
995 BYT_RT5640_OVCD_SF_0P75 |
996 BYT_RT5640_DIFF_MIC |
997 BYT_RT5640_MCLK_EN),
998 },
999 { /* Pipo W4 */
1000 .matches = {
1001 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1002 DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1003 /* The above are too generic, also match BIOS info */
1004 DMI_MATCH(DMI_BIOS_VERSION, "V8L_WIN32_CHIPHD"),
1005 },
1006 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
1007 BYT_RT5640_MONO_SPEAKER |
1008 BYT_RT5640_SSP0_AIF1 |
1009 BYT_RT5640_MCLK_EN),
1010 },
1011 { /* Point of View Mobii TAB-P800W (V2.0) */
1012 .matches = {
1013 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1014 DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1015 /* The above are too generic, also match BIOS info */
1016 DMI_EXACT_MATCH(DMI_BIOS_VERSION, "3BAIR1014"),
1017 DMI_EXACT_MATCH(DMI_BIOS_DATE, "10/24/2014"),
1018 },
1019 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
1020 BYT_RT5640_JD_SRC_JD2_IN4N |
1021 BYT_RT5640_OVCD_TH_2000UA |
1022 BYT_RT5640_OVCD_SF_0P75 |
1023 BYT_RT5640_MONO_SPEAKER |
1024 BYT_RT5640_DIFF_MIC |
1025 BYT_RT5640_SSP0_AIF2 |
1026 BYT_RT5640_MCLK_EN),
1027 },
1028 { /* Point of View Mobii TAB-P800W (V2.1) */
1029 .matches = {
1030 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1031 DMI_EXACT_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1032 /* The above are too generic, also match BIOS info */
1033 DMI_EXACT_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
1034 DMI_EXACT_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1035 },
1036 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
1037 BYT_RT5640_JD_SRC_JD2_IN4N |
1038 BYT_RT5640_OVCD_TH_2000UA |
1039 BYT_RT5640_OVCD_SF_0P75 |
1040 BYT_RT5640_MONO_SPEAKER |
1041 BYT_RT5640_DIFF_MIC |
1042 BYT_RT5640_SSP0_AIF2 |
1043 BYT_RT5640_MCLK_EN),
1044 },
1045 { /* Point of View Mobii TAB-P1005W-232 (V2.0) */
1046 .matches = {
1047 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "POV"),
1048 DMI_EXACT_MATCH(DMI_BOARD_NAME, "I102A"),
1049 },
1050 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
1051 BYT_RT5640_JD_SRC_JD2_IN4N |
1052 BYT_RT5640_OVCD_TH_2000UA |
1053 BYT_RT5640_OVCD_SF_0P75 |
1054 BYT_RT5640_DIFF_MIC |
1055 BYT_RT5640_SSP0_AIF1 |
1056 BYT_RT5640_MCLK_EN),
1057 },
1058 {
1059 /* Prowise PT301 */
1060 .matches = {
1061 DMI_MATCH(DMI_SYS_VENDOR, "Prowise"),
1062 DMI_MATCH(DMI_PRODUCT_NAME, "PT301"),
1063 },
1064 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
1065 BYT_RT5640_JD_SRC_JD2_IN4N |
1066 BYT_RT5640_OVCD_TH_2000UA |
1067 BYT_RT5640_OVCD_SF_0P75 |
1068 BYT_RT5640_DIFF_MIC |
1069 BYT_RT5640_SSP0_AIF1 |
1070 BYT_RT5640_MCLK_EN),
1071 },
1072 {
1073 /* Teclast X89 */
1074 .matches = {
1075 DMI_MATCH(DMI_BOARD_VENDOR, "TECLAST"),
1076 DMI_MATCH(DMI_BOARD_NAME, "tPAD"),
1077 },
1078 .driver_data = (void *)(BYT_RT5640_IN3_MAP |
1079 BYT_RT5640_JD_SRC_JD1_IN4P |
1080 BYT_RT5640_OVCD_TH_2000UA |
1081 BYT_RT5640_OVCD_SF_1P0 |
1082 BYT_RT5640_SSP0_AIF1 |
1083 BYT_RT5640_MCLK_EN),
1084 },
1085 { /* Toshiba Satellite Click Mini L9W-B */
1086 .matches = {
1087 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1088 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "SATELLITE Click Mini L9W-B"),
1089 },
1090 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
1091 BYT_RT5640_JD_SRC_JD2_IN4N |
1092 BYT_RT5640_OVCD_TH_1500UA |
1093 BYT_RT5640_OVCD_SF_0P75 |
1094 BYT_RT5640_SSP0_AIF1 |
1095 BYT_RT5640_MCLK_EN),
1096 },
1097 { /* Toshiba Encore WT8-A */
1098 .matches = {
1099 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1100 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "TOSHIBA WT8-A"),
1101 },
1102 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
1103 BYT_RT5640_JD_SRC_JD2_IN4N |
1104 BYT_RT5640_OVCD_TH_2000UA |
1105 BYT_RT5640_OVCD_SF_0P75 |
1106 BYT_RT5640_JD_NOT_INV |
1107 BYT_RT5640_MCLK_EN),
1108 },
1109 { /* Toshiba Encore WT10-A */
1110 .matches = {
1111 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1112 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "TOSHIBA WT10-A-103"),
1113 },
1114 .driver_data = (void *)(BYT_RT5640_DMIC1_MAP |
1115 BYT_RT5640_JD_SRC_JD1_IN4P |
1116 BYT_RT5640_OVCD_TH_2000UA |
1117 BYT_RT5640_OVCD_SF_0P75 |
1118 BYT_RT5640_SSP0_AIF2 |
1119 BYT_RT5640_MCLK_EN),
1120 },
1121 { /* Voyo Winpad A15 */
1122 .matches = {
1123 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1124 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1125 /* Above strings are too generic, also match on BIOS date */
1126 DMI_MATCH(DMI_BIOS_DATE, "11/20/2014"),
1127 },
1128 .driver_data = (void *)(BYT_RT5640_IN1_MAP |
1129 BYT_RT5640_JD_SRC_JD2_IN4N |
1130 BYT_RT5640_OVCD_TH_2000UA |
1131 BYT_RT5640_OVCD_SF_0P75 |
1132 BYT_RT5640_DIFF_MIC |
1133 BYT_RT5640_MCLK_EN),
1134 },
1135 { /* Catch-all for generic Insyde tablets, must be last */
1136 .matches = {
1137 DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),
1138 },
1139 .driver_data = (void *)(BYTCR_INPUT_DEFAULTS |
1140 BYT_RT5640_MCLK_EN |
1141 BYT_RT5640_SSP0_AIF1),
1142
1143 },
1144 {}
1145 };
1146
1147 /*
1148 * Note this MUST be called before snd_soc_register_card(), so that the props
1149 * are in place before the codec component driver's probe function parses them.
1150 */
byt_rt5640_add_codec_device_props(struct device * i2c_dev,struct byt_rt5640_private * priv)1151 static int byt_rt5640_add_codec_device_props(struct device *i2c_dev,
1152 struct byt_rt5640_private *priv)
1153 {
1154 struct property_entry props[MAX_NO_PROPS] = {};
1155 struct fwnode_handle *fwnode;
1156 int cnt = 0;
1157 int ret;
1158
1159 switch (BYT_RT5640_MAP(byt_rt5640_quirk)) {
1160 case BYT_RT5640_DMIC1_MAP:
1161 props[cnt++] = PROPERTY_ENTRY_U32("realtek,dmic1-data-pin",
1162 RT5640_DMIC1_DATA_PIN_IN1P);
1163 break;
1164 case BYT_RT5640_DMIC2_MAP:
1165 props[cnt++] = PROPERTY_ENTRY_U32("realtek,dmic2-data-pin",
1166 RT5640_DMIC2_DATA_PIN_IN1N);
1167 break;
1168 case BYT_RT5640_IN1_MAP:
1169 if (byt_rt5640_quirk & BYT_RT5640_DIFF_MIC)
1170 props[cnt++] =
1171 PROPERTY_ENTRY_BOOL("realtek,in1-differential");
1172 break;
1173 case BYT_RT5640_IN3_MAP:
1174 if (byt_rt5640_quirk & BYT_RT5640_DIFF_MIC)
1175 props[cnt++] =
1176 PROPERTY_ENTRY_BOOL("realtek,in3-differential");
1177 break;
1178 }
1179
1180 if (BYT_RT5640_JDSRC(byt_rt5640_quirk)) {
1181 if (BYT_RT5640_JDSRC(byt_rt5640_quirk) != RT5640_JD_SRC_EXT_GPIO) {
1182 props[cnt++] = PROPERTY_ENTRY_U32(
1183 "realtek,jack-detect-source",
1184 BYT_RT5640_JDSRC(byt_rt5640_quirk));
1185 }
1186
1187 props[cnt++] = PROPERTY_ENTRY_U32(
1188 "realtek,over-current-threshold-microamp",
1189 BYT_RT5640_OVCD_TH(byt_rt5640_quirk) * 100);
1190
1191 props[cnt++] = PROPERTY_ENTRY_U32(
1192 "realtek,over-current-scale-factor",
1193 BYT_RT5640_OVCD_SF(byt_rt5640_quirk));
1194 }
1195
1196 if (byt_rt5640_quirk & BYT_RT5640_JD_NOT_INV)
1197 props[cnt++] = PROPERTY_ENTRY_BOOL("realtek,jack-detect-not-inverted");
1198
1199 fwnode = fwnode_create_software_node(props, NULL);
1200 if (IS_ERR(fwnode)) {
1201 /* put_device() is handled in caller */
1202 return PTR_ERR(fwnode);
1203 }
1204
1205 ret = device_add_software_node(i2c_dev, to_software_node(fwnode));
1206
1207 fwnode_handle_put(fwnode);
1208
1209 return ret;
1210 }
1211
1212 /* Some Android devs specify IRQs/GPIOS in a special AMCR0F28 ACPI device */
1213 static const struct acpi_gpio_params amcr0f28_jd_gpio = { 1, 0, false };
1214
1215 static const struct acpi_gpio_mapping amcr0f28_gpios[] = {
1216 { "rt5640-jd-gpios", &amcr0f28_jd_gpio, 1 },
1217 { }
1218 };
1219
byt_rt5640_get_amcr0f28_settings(struct snd_soc_card * card)1220 static int byt_rt5640_get_amcr0f28_settings(struct snd_soc_card *card)
1221 {
1222 struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
1223 struct rt5640_set_jack_data *data = &priv->jack_data;
1224 struct acpi_device *adev;
1225 int ret = 0;
1226
1227 adev = acpi_dev_get_first_match_dev("AMCR0F28", "1", -1);
1228 if (!adev) {
1229 dev_err(card->dev, "error cannot find AMCR0F28 adev\n");
1230 return -ENOENT;
1231 }
1232
1233 data->codec_irq_override = acpi_dev_gpio_irq_get(adev, 0);
1234 if (data->codec_irq_override < 0) {
1235 ret = data->codec_irq_override;
1236 dev_err(card->dev, "error %d getting codec IRQ\n", ret);
1237 goto put_adev;
1238 }
1239
1240 if (BYT_RT5640_JDSRC(byt_rt5640_quirk) == RT5640_JD_SRC_EXT_GPIO) {
1241 acpi_dev_add_driver_gpios(adev, amcr0f28_gpios);
1242 data->jd_gpio = devm_fwnode_gpiod_get(card->dev, acpi_fwnode_handle(adev),
1243 "rt5640-jd", GPIOD_IN, "rt5640-jd");
1244 acpi_dev_remove_driver_gpios(adev);
1245
1246 if (IS_ERR(data->jd_gpio)) {
1247 ret = PTR_ERR(data->jd_gpio);
1248 dev_err(card->dev, "error %d getting jd GPIO\n", ret);
1249 }
1250 }
1251
1252 put_adev:
1253 acpi_dev_put(adev);
1254 return ret;
1255 }
1256
byt_rt5640_init(struct snd_soc_pcm_runtime * runtime)1257 static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
1258 {
1259 struct snd_soc_card *card = runtime->card;
1260 struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
1261 struct rt5640_set_jack_data *jack_data = &priv->jack_data;
1262 struct snd_soc_component *component = asoc_rtd_to_codec(runtime, 0)->component;
1263 const struct snd_soc_dapm_route *custom_map = NULL;
1264 int num_routes = 0;
1265 int ret;
1266
1267 card->dapm.idle_bias_off = true;
1268 jack_data->use_platform_clock = true;
1269
1270 /* Start with RC clk for jack-detect (we disable MCLK below) */
1271 if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN)
1272 snd_soc_component_update_bits(component, RT5640_GLB_CLK,
1273 RT5640_SCLK_SRC_MASK, RT5640_SCLK_SRC_RCCLK);
1274
1275 rt5640_sel_asrc_clk_src(component,
1276 RT5640_DA_STEREO_FILTER |
1277 RT5640_DA_MONO_L_FILTER |
1278 RT5640_DA_MONO_R_FILTER |
1279 RT5640_AD_STEREO_FILTER |
1280 RT5640_AD_MONO_L_FILTER |
1281 RT5640_AD_MONO_R_FILTER,
1282 RT5640_CLK_SEL_ASRC);
1283
1284 ret = snd_soc_add_card_controls(card, byt_rt5640_controls,
1285 ARRAY_SIZE(byt_rt5640_controls));
1286 if (ret) {
1287 dev_err(card->dev, "unable to add card controls\n");
1288 return ret;
1289 }
1290
1291 switch (BYT_RT5640_MAP(byt_rt5640_quirk)) {
1292 case BYT_RT5640_IN1_MAP:
1293 custom_map = byt_rt5640_intmic_in1_map;
1294 num_routes = ARRAY_SIZE(byt_rt5640_intmic_in1_map);
1295 break;
1296 case BYT_RT5640_IN3_MAP:
1297 custom_map = byt_rt5640_intmic_in3_map;
1298 num_routes = ARRAY_SIZE(byt_rt5640_intmic_in3_map);
1299 break;
1300 case BYT_RT5640_DMIC1_MAP:
1301 custom_map = byt_rt5640_intmic_dmic1_map;
1302 num_routes = ARRAY_SIZE(byt_rt5640_intmic_dmic1_map);
1303 break;
1304 case BYT_RT5640_DMIC2_MAP:
1305 custom_map = byt_rt5640_intmic_dmic2_map;
1306 num_routes = ARRAY_SIZE(byt_rt5640_intmic_dmic2_map);
1307 break;
1308 }
1309
1310 ret = snd_soc_dapm_add_routes(&card->dapm, custom_map, num_routes);
1311 if (ret)
1312 return ret;
1313
1314 if (byt_rt5640_quirk & BYT_RT5640_HSMIC2_ON_IN1) {
1315 ret = snd_soc_dapm_add_routes(&card->dapm,
1316 byt_rt5640_hsmic2_in1_map,
1317 ARRAY_SIZE(byt_rt5640_hsmic2_in1_map));
1318 if (ret)
1319 return ret;
1320 }
1321
1322 if (byt_rt5640_quirk & BYT_RT5640_SSP2_AIF2) {
1323 ret = snd_soc_dapm_add_routes(&card->dapm,
1324 byt_rt5640_ssp2_aif2_map,
1325 ARRAY_SIZE(byt_rt5640_ssp2_aif2_map));
1326 } else if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) {
1327 ret = snd_soc_dapm_add_routes(&card->dapm,
1328 byt_rt5640_ssp0_aif1_map,
1329 ARRAY_SIZE(byt_rt5640_ssp0_aif1_map));
1330 } else if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2) {
1331 ret = snd_soc_dapm_add_routes(&card->dapm,
1332 byt_rt5640_ssp0_aif2_map,
1333 ARRAY_SIZE(byt_rt5640_ssp0_aif2_map));
1334 } else {
1335 ret = snd_soc_dapm_add_routes(&card->dapm,
1336 byt_rt5640_ssp2_aif1_map,
1337 ARRAY_SIZE(byt_rt5640_ssp2_aif1_map));
1338 }
1339 if (ret)
1340 return ret;
1341
1342 if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) {
1343 ret = snd_soc_dapm_add_routes(&card->dapm,
1344 byt_rt5640_mono_spk_map,
1345 ARRAY_SIZE(byt_rt5640_mono_spk_map));
1346 } else if (!(byt_rt5640_quirk & BYT_RT5640_NO_SPEAKERS)) {
1347 ret = snd_soc_dapm_add_routes(&card->dapm,
1348 byt_rt5640_stereo_spk_map,
1349 ARRAY_SIZE(byt_rt5640_stereo_spk_map));
1350 }
1351 if (ret)
1352 return ret;
1353
1354 if (byt_rt5640_quirk & BYT_RT5640_LINEOUT) {
1355 ret = snd_soc_dapm_add_routes(&card->dapm,
1356 byt_rt5640_lineout_map,
1357 ARRAY_SIZE(byt_rt5640_lineout_map));
1358 if (ret)
1359 return ret;
1360 }
1361
1362 /*
1363 * The firmware might enable the clock at boot (this information
1364 * may or may not be reflected in the enable clock register).
1365 * To change the rate we must disable the clock first to cover
1366 * these cases. Due to common clock framework restrictions that
1367 * do not allow to disable a clock that has not been enabled,
1368 * we need to enable the clock first.
1369 */
1370 ret = clk_prepare_enable(priv->mclk);
1371 if (!ret)
1372 clk_disable_unprepare(priv->mclk);
1373
1374 if (byt_rt5640_quirk & BYT_RT5640_MCLK_25MHZ)
1375 ret = clk_set_rate(priv->mclk, 25000000);
1376 else
1377 ret = clk_set_rate(priv->mclk, 19200000);
1378 if (ret) {
1379 dev_err(card->dev, "unable to set MCLK rate\n");
1380 return ret;
1381 }
1382
1383 if (BYT_RT5640_JDSRC(byt_rt5640_quirk)) {
1384 ret = snd_soc_card_jack_new_pins(card, "Headset",
1385 SND_JACK_HEADSET | SND_JACK_BTN_0,
1386 &priv->jack, rt5640_pins,
1387 ARRAY_SIZE(rt5640_pins));
1388 if (ret) {
1389 dev_err(card->dev, "Jack creation failed %d\n", ret);
1390 return ret;
1391 }
1392 snd_jack_set_key(priv->jack.jack, SND_JACK_BTN_0,
1393 KEY_PLAYPAUSE);
1394
1395 if (byt_rt5640_quirk & BYT_RT5640_USE_AMCR0F28) {
1396 ret = byt_rt5640_get_amcr0f28_settings(card);
1397 if (ret)
1398 return ret;
1399 }
1400
1401 snd_soc_component_set_jack(component, &priv->jack, &priv->jack_data);
1402 }
1403
1404 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2) {
1405 ret = snd_soc_card_jack_new_pins(card, "Headset",
1406 SND_JACK_HEADSET,
1407 &priv->jack, rt5640_pins,
1408 ARRAY_SIZE(rt5640_pins));
1409 if (ret)
1410 return ret;
1411
1412 ret = snd_soc_card_jack_new_pins(card, "Headset 2",
1413 SND_JACK_HEADSET,
1414 &priv->jack2, rt5640_pins2,
1415 ARRAY_SIZE(rt5640_pins2));
1416 if (ret)
1417 return ret;
1418
1419 rt5640_jack_gpio.data = priv;
1420 rt5640_jack_gpio.gpiod_dev = priv->codec_dev;
1421 rt5640_jack_gpio.jack_status_check = byt_rt5640_hp_elitepad_1000g2_jack1_check;
1422 ret = snd_soc_jack_add_gpios(&priv->jack, 1, &rt5640_jack_gpio);
1423 if (ret)
1424 return ret;
1425
1426 rt5640_set_ovcd_params(component);
1427 rt5640_jack2_gpio.data = component;
1428 rt5640_jack2_gpio.gpiod_dev = priv->codec_dev;
1429 rt5640_jack2_gpio.jack_status_check = byt_rt5640_hp_elitepad_1000g2_jack2_check;
1430 ret = snd_soc_jack_add_gpios(&priv->jack2, 1, &rt5640_jack2_gpio);
1431 if (ret) {
1432 snd_soc_jack_free_gpios(&priv->jack, 1, &rt5640_jack_gpio);
1433 return ret;
1434 }
1435 }
1436
1437 return 0;
1438 }
1439
byt_rt5640_exit(struct snd_soc_pcm_runtime * runtime)1440 static void byt_rt5640_exit(struct snd_soc_pcm_runtime *runtime)
1441 {
1442 struct snd_soc_card *card = runtime->card;
1443 struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
1444
1445 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2) {
1446 snd_soc_jack_free_gpios(&priv->jack2, 1, &rt5640_jack2_gpio);
1447 snd_soc_jack_free_gpios(&priv->jack, 1, &rt5640_jack_gpio);
1448 }
1449 }
1450
byt_rt5640_codec_fixup(struct snd_soc_pcm_runtime * rtd,struct snd_pcm_hw_params * params)1451 static int byt_rt5640_codec_fixup(struct snd_soc_pcm_runtime *rtd,
1452 struct snd_pcm_hw_params *params)
1453 {
1454 struct snd_interval *rate = hw_param_interval(params,
1455 SNDRV_PCM_HW_PARAM_RATE);
1456 struct snd_interval *channels = hw_param_interval(params,
1457 SNDRV_PCM_HW_PARAM_CHANNELS);
1458 int ret, bits;
1459
1460 /* The DSP will convert the FE rate to 48k, stereo */
1461 rate->min = rate->max = 48000;
1462 channels->min = channels->max = 2;
1463
1464 if ((byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) ||
1465 (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) {
1466 /* set SSP0 to 16-bit */
1467 params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
1468 bits = 16;
1469 } else {
1470 /* set SSP2 to 24-bit */
1471 params_set_format(params, SNDRV_PCM_FORMAT_S24_LE);
1472 bits = 24;
1473 }
1474
1475 /*
1476 * Default mode for SSP configuration is TDM 4 slot, override config
1477 * with explicit setting to I2S 2ch. The word length is set with
1478 * dai_set_tdm_slot() since there is no other API exposed
1479 */
1480 ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
1481 SND_SOC_DAIFMT_I2S |
1482 SND_SOC_DAIFMT_NB_NF |
1483 SND_SOC_DAIFMT_BP_FP);
1484 if (ret < 0) {
1485 dev_err(rtd->dev, "can't set format to I2S, err %d\n", ret);
1486 return ret;
1487 }
1488
1489 ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, bits);
1490 if (ret < 0) {
1491 dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
1492 return ret;
1493 }
1494
1495 return 0;
1496 }
1497
byt_rt5640_aif1_startup(struct snd_pcm_substream * substream)1498 static int byt_rt5640_aif1_startup(struct snd_pcm_substream *substream)
1499 {
1500 return snd_pcm_hw_constraint_single(substream->runtime,
1501 SNDRV_PCM_HW_PARAM_RATE, 48000);
1502 }
1503
1504 static const struct snd_soc_ops byt_rt5640_aif1_ops = {
1505 .startup = byt_rt5640_aif1_startup,
1506 };
1507
1508 static const struct snd_soc_ops byt_rt5640_be_ssp2_ops = {
1509 .hw_params = byt_rt5640_aif1_hw_params,
1510 };
1511
1512 SND_SOC_DAILINK_DEF(dummy,
1513 DAILINK_COMP_ARRAY(COMP_DUMMY()));
1514
1515 SND_SOC_DAILINK_DEF(media,
1516 DAILINK_COMP_ARRAY(COMP_CPU("media-cpu-dai")));
1517
1518 SND_SOC_DAILINK_DEF(deepbuffer,
1519 DAILINK_COMP_ARRAY(COMP_CPU("deepbuffer-cpu-dai")));
1520
1521 SND_SOC_DAILINK_DEF(ssp2_port,
1522 /* overwritten for ssp0 routing */
1523 DAILINK_COMP_ARRAY(COMP_CPU("ssp2-port")));
1524 SND_SOC_DAILINK_DEF(ssp2_codec,
1525 DAILINK_COMP_ARRAY(COMP_CODEC(
1526 /* overwritten with HID */ "i2c-10EC5640:00",
1527 /* changed w/ quirk */ "rt5640-aif1")));
1528
1529 SND_SOC_DAILINK_DEF(platform,
1530 DAILINK_COMP_ARRAY(COMP_PLATFORM("sst-mfld-platform")));
1531
1532 static struct snd_soc_dai_link byt_rt5640_dais[] = {
1533 [MERR_DPCM_AUDIO] = {
1534 .name = "Baytrail Audio Port",
1535 .stream_name = "Baytrail Audio",
1536 .nonatomic = true,
1537 .dynamic = 1,
1538 .dpcm_playback = 1,
1539 .dpcm_capture = 1,
1540 .ops = &byt_rt5640_aif1_ops,
1541 SND_SOC_DAILINK_REG(media, dummy, platform),
1542 },
1543 [MERR_DPCM_DEEP_BUFFER] = {
1544 .name = "Deep-Buffer Audio Port",
1545 .stream_name = "Deep-Buffer Audio",
1546 .nonatomic = true,
1547 .dynamic = 1,
1548 .dpcm_playback = 1,
1549 .ops = &byt_rt5640_aif1_ops,
1550 SND_SOC_DAILINK_REG(deepbuffer, dummy, platform),
1551 },
1552 /* back ends */
1553 {
1554 .name = "SSP2-Codec",
1555 .id = 0,
1556 .no_pcm = 1,
1557 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
1558 | SND_SOC_DAIFMT_CBC_CFC,
1559 .be_hw_params_fixup = byt_rt5640_codec_fixup,
1560 .dpcm_playback = 1,
1561 .dpcm_capture = 1,
1562 .init = byt_rt5640_init,
1563 .exit = byt_rt5640_exit,
1564 .ops = &byt_rt5640_be_ssp2_ops,
1565 SND_SOC_DAILINK_REG(ssp2_port, ssp2_codec, platform),
1566 },
1567 };
1568
1569 /* SoC card */
1570 static char byt_rt5640_codec_name[SND_ACPI_I2C_ID_LEN];
1571 #if !IS_ENABLED(CONFIG_SND_SOC_INTEL_USER_FRIENDLY_LONG_NAMES)
1572 static char byt_rt5640_long_name[40]; /* = "bytcr-rt5640-*-spk-*-mic" */
1573 #endif
1574 static char byt_rt5640_components[64]; /* = "cfg-spk:* cfg-mic:* ..." */
1575
byt_rt5640_suspend(struct snd_soc_card * card)1576 static int byt_rt5640_suspend(struct snd_soc_card *card)
1577 {
1578 struct snd_soc_component *component;
1579
1580 if (!BYT_RT5640_JDSRC(byt_rt5640_quirk))
1581 return 0;
1582
1583 for_each_card_components(card, component) {
1584 if (!strcmp(component->name, byt_rt5640_codec_name)) {
1585 dev_dbg(component->dev, "disabling jack detect before suspend\n");
1586 snd_soc_component_set_jack(component, NULL, NULL);
1587 break;
1588 }
1589 }
1590
1591 return 0;
1592 }
1593
byt_rt5640_resume(struct snd_soc_card * card)1594 static int byt_rt5640_resume(struct snd_soc_card *card)
1595 {
1596 struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
1597 struct snd_soc_component *component;
1598
1599 if (!BYT_RT5640_JDSRC(byt_rt5640_quirk))
1600 return 0;
1601
1602 for_each_card_components(card, component) {
1603 if (!strcmp(component->name, byt_rt5640_codec_name)) {
1604 dev_dbg(component->dev, "re-enabling jack detect after resume\n");
1605 snd_soc_component_set_jack(component, &priv->jack,
1606 &priv->jack_data);
1607 break;
1608 }
1609 }
1610
1611 return 0;
1612 }
1613
1614 /* use space before codec name to simplify card ID, and simplify driver name */
1615 #define SOF_CARD_NAME "bytcht rt5640" /* card name will be 'sof-bytcht rt5640' */
1616 #define SOF_DRIVER_NAME "SOF"
1617
1618 #define CARD_NAME "bytcr-rt5640"
1619 #define DRIVER_NAME NULL /* card name will be used for driver name */
1620
1621 static struct snd_soc_card byt_rt5640_card = {
1622 .owner = THIS_MODULE,
1623 .dai_link = byt_rt5640_dais,
1624 .num_links = ARRAY_SIZE(byt_rt5640_dais),
1625 .dapm_widgets = byt_rt5640_widgets,
1626 .num_dapm_widgets = ARRAY_SIZE(byt_rt5640_widgets),
1627 .dapm_routes = byt_rt5640_audio_map,
1628 .num_dapm_routes = ARRAY_SIZE(byt_rt5640_audio_map),
1629 .fully_routed = true,
1630 .suspend_pre = byt_rt5640_suspend,
1631 .resume_post = byt_rt5640_resume,
1632 };
1633
1634 struct acpi_chan_package { /* ACPICA seems to require 64 bit integers */
1635 u64 aif_value; /* 1: AIF1, 2: AIF2 */
1636 u64 mclock_value; /* usually 25MHz (0x17d7940), ignored */
1637 };
1638
snd_byt_rt5640_mc_probe(struct platform_device * pdev)1639 static int snd_byt_rt5640_mc_probe(struct platform_device *pdev)
1640 {
1641 struct device *dev = &pdev->dev;
1642 static const char * const map_name[] = { "dmic1", "dmic2", "in1", "in3", "none" };
1643 struct snd_soc_acpi_mach *mach = dev_get_platdata(dev);
1644 __maybe_unused const char *spk_type;
1645 const struct dmi_system_id *dmi_id;
1646 const char *headset2_string = "";
1647 const char *lineout_string = "";
1648 struct byt_rt5640_private *priv;
1649 const char *platform_name;
1650 struct acpi_device *adev;
1651 struct device *codec_dev;
1652 const char *cfg_spk;
1653 bool sof_parent;
1654 int ret_val = 0;
1655 int dai_index = 0;
1656 int i, aif;
1657
1658 is_bytcr = false;
1659 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
1660 if (!priv)
1661 return -ENOMEM;
1662
1663 /* register the soc card */
1664 byt_rt5640_card.dev = dev;
1665 snd_soc_card_set_drvdata(&byt_rt5640_card, priv);
1666
1667 /* fix index of codec dai */
1668 for (i = 0; i < ARRAY_SIZE(byt_rt5640_dais); i++) {
1669 if (!strcmp(byt_rt5640_dais[i].codecs->name,
1670 "i2c-10EC5640:00")) {
1671 dai_index = i;
1672 break;
1673 }
1674 }
1675
1676 /* fixup codec name based on HID */
1677 adev = acpi_dev_get_first_match_dev(mach->id, NULL, -1);
1678 if (adev) {
1679 snprintf(byt_rt5640_codec_name, sizeof(byt_rt5640_codec_name),
1680 "i2c-%s", acpi_dev_name(adev));
1681 byt_rt5640_dais[dai_index].codecs->name = byt_rt5640_codec_name;
1682 } else {
1683 dev_err(dev, "Error cannot find '%s' dev\n", mach->id);
1684 return -ENXIO;
1685 }
1686
1687 codec_dev = acpi_get_first_physical_node(adev);
1688 acpi_dev_put(adev);
1689 if (!codec_dev)
1690 return -EPROBE_DEFER;
1691 priv->codec_dev = get_device(codec_dev);
1692
1693 /*
1694 * swap SSP0 if bytcr is detected
1695 * (will be overridden if DMI quirk is detected)
1696 */
1697 if (soc_intel_is_byt()) {
1698 if (mach->mach_params.acpi_ipc_irq_index == 0)
1699 is_bytcr = true;
1700 }
1701
1702 if (is_bytcr) {
1703 /*
1704 * Baytrail CR platforms may have CHAN package in BIOS, try
1705 * to find relevant routing quirk based as done on Windows
1706 * platforms. We have to read the information directly from the
1707 * BIOS, at this stage the card is not created and the links
1708 * with the codec driver/pdata are non-existent
1709 */
1710
1711 struct acpi_chan_package chan_package = { 0 };
1712
1713 /* format specified: 2 64-bit integers */
1714 struct acpi_buffer format = {sizeof("NN"), "NN"};
1715 struct acpi_buffer state = {0, NULL};
1716 struct snd_soc_acpi_package_context pkg_ctx;
1717 bool pkg_found = false;
1718
1719 state.length = sizeof(chan_package);
1720 state.pointer = &chan_package;
1721
1722 pkg_ctx.name = "CHAN";
1723 pkg_ctx.length = 2;
1724 pkg_ctx.format = &format;
1725 pkg_ctx.state = &state;
1726 pkg_ctx.data_valid = false;
1727
1728 pkg_found = snd_soc_acpi_find_package_from_hid(mach->id,
1729 &pkg_ctx);
1730 if (pkg_found) {
1731 if (chan_package.aif_value == 1) {
1732 dev_info(dev, "BIOS Routing: AIF1 connected\n");
1733 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF1;
1734 } else if (chan_package.aif_value == 2) {
1735 dev_info(dev, "BIOS Routing: AIF2 connected\n");
1736 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF2;
1737 } else {
1738 dev_info(dev, "BIOS Routing isn't valid, ignored\n");
1739 pkg_found = false;
1740 }
1741 }
1742
1743 if (!pkg_found) {
1744 /* no BIOS indications, assume SSP0-AIF2 connection */
1745 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF2;
1746 }
1747
1748 /* change defaults for Baytrail-CR capture */
1749 byt_rt5640_quirk |= BYTCR_INPUT_DEFAULTS;
1750 } else {
1751 byt_rt5640_quirk |= BYT_RT5640_DMIC1_MAP |
1752 BYT_RT5640_JD_SRC_JD2_IN4N |
1753 BYT_RT5640_OVCD_TH_2000UA |
1754 BYT_RT5640_OVCD_SF_0P75;
1755 }
1756
1757 /* check quirks before creating card */
1758 dmi_id = dmi_first_match(byt_rt5640_quirk_table);
1759 if (dmi_id)
1760 byt_rt5640_quirk = (unsigned long)dmi_id->driver_data;
1761 if (quirk_override != -1) {
1762 dev_info(dev, "Overriding quirk 0x%lx => 0x%x\n",
1763 byt_rt5640_quirk, quirk_override);
1764 byt_rt5640_quirk = quirk_override;
1765 }
1766
1767 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2) {
1768 acpi_dev_add_driver_gpios(ACPI_COMPANION(priv->codec_dev),
1769 byt_rt5640_hp_elitepad_1000g2_gpios);
1770
1771 priv->hsmic_detect = devm_fwnode_gpiod_get(dev, codec_dev->fwnode,
1772 "headset-mic-detect", GPIOD_IN,
1773 "headset-mic-detect");
1774 if (IS_ERR(priv->hsmic_detect)) {
1775 ret_val = dev_err_probe(dev, PTR_ERR(priv->hsmic_detect),
1776 "getting hsmic-detect GPIO\n");
1777 goto err_device;
1778 }
1779 }
1780
1781 /* Must be called before register_card, also see declaration comment. */
1782 ret_val = byt_rt5640_add_codec_device_props(codec_dev, priv);
1783 if (ret_val)
1784 goto err_remove_gpios;
1785
1786 log_quirks(dev);
1787
1788 if ((byt_rt5640_quirk & BYT_RT5640_SSP2_AIF2) ||
1789 (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) {
1790 byt_rt5640_dais[dai_index].codecs->dai_name = "rt5640-aif2";
1791 aif = 2;
1792 } else {
1793 aif = 1;
1794 }
1795
1796 if ((byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) ||
1797 (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2))
1798 byt_rt5640_dais[dai_index].cpus->dai_name = "ssp0-port";
1799
1800 if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN) {
1801 priv->mclk = devm_clk_get_optional(dev, "pmc_plt_clk_3");
1802 if (IS_ERR(priv->mclk)) {
1803 ret_val = dev_err_probe(dev, PTR_ERR(priv->mclk),
1804 "Failed to get MCLK from pmc_plt_clk_3\n");
1805 goto err;
1806 }
1807 /*
1808 * Fall back to bit clock usage when clock is not
1809 * available likely due to missing dependencies.
1810 */
1811 if (!priv->mclk)
1812 byt_rt5640_quirk &= ~BYT_RT5640_MCLK_EN;
1813 }
1814
1815 if (byt_rt5640_quirk & BYT_RT5640_NO_SPEAKERS) {
1816 cfg_spk = "0";
1817 spk_type = "none";
1818 } else if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) {
1819 cfg_spk = "1";
1820 spk_type = "mono";
1821 } else if (byt_rt5640_quirk & BYT_RT5640_SWAPPED_SPEAKERS) {
1822 cfg_spk = "swapped";
1823 spk_type = "swapped";
1824 } else {
1825 cfg_spk = "2";
1826 spk_type = "stereo";
1827 }
1828
1829 if (byt_rt5640_quirk & BYT_RT5640_LINEOUT) {
1830 if (byt_rt5640_quirk & BYT_RT5640_LINEOUT_AS_HP2)
1831 lineout_string = " cfg-hp2:lineout";
1832 else
1833 lineout_string = " cfg-lineout:2";
1834 }
1835
1836 if (byt_rt5640_quirk & BYT_RT5640_HSMIC2_ON_IN1)
1837 headset2_string = " cfg-hs2:in1";
1838
1839 snprintf(byt_rt5640_components, sizeof(byt_rt5640_components),
1840 "cfg-spk:%s cfg-mic:%s aif:%d%s%s", cfg_spk,
1841 map_name[BYT_RT5640_MAP(byt_rt5640_quirk)], aif,
1842 lineout_string, headset2_string);
1843 byt_rt5640_card.components = byt_rt5640_components;
1844 #if !IS_ENABLED(CONFIG_SND_SOC_INTEL_USER_FRIENDLY_LONG_NAMES)
1845 snprintf(byt_rt5640_long_name, sizeof(byt_rt5640_long_name),
1846 "bytcr-rt5640-%s-spk-%s-mic", spk_type,
1847 map_name[BYT_RT5640_MAP(byt_rt5640_quirk)]);
1848 byt_rt5640_card.long_name = byt_rt5640_long_name;
1849 #endif
1850
1851 /* override platform name, if required */
1852 platform_name = mach->mach_params.platform;
1853
1854 ret_val = snd_soc_fixup_dai_links_platform_name(&byt_rt5640_card,
1855 platform_name);
1856 if (ret_val)
1857 goto err;
1858
1859 sof_parent = snd_soc_acpi_sof_parent(dev);
1860
1861 /* set card and driver name */
1862 if (sof_parent) {
1863 byt_rt5640_card.name = SOF_CARD_NAME;
1864 byt_rt5640_card.driver_name = SOF_DRIVER_NAME;
1865 } else {
1866 byt_rt5640_card.name = CARD_NAME;
1867 byt_rt5640_card.driver_name = DRIVER_NAME;
1868 }
1869
1870 /* set pm ops */
1871 if (sof_parent)
1872 dev->driver->pm = &snd_soc_pm_ops;
1873
1874 ret_val = devm_snd_soc_register_card(dev, &byt_rt5640_card);
1875 if (ret_val) {
1876 dev_err(dev, "devm_snd_soc_register_card failed %d\n", ret_val);
1877 goto err;
1878 }
1879 platform_set_drvdata(pdev, &byt_rt5640_card);
1880 return ret_val;
1881
1882 err:
1883 device_remove_software_node(priv->codec_dev);
1884 err_remove_gpios:
1885 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2)
1886 acpi_dev_remove_driver_gpios(ACPI_COMPANION(priv->codec_dev));
1887 err_device:
1888 put_device(priv->codec_dev);
1889 return ret_val;
1890 }
1891
snd_byt_rt5640_mc_remove(struct platform_device * pdev)1892 static void snd_byt_rt5640_mc_remove(struct platform_device *pdev)
1893 {
1894 struct snd_soc_card *card = platform_get_drvdata(pdev);
1895 struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
1896
1897 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2)
1898 acpi_dev_remove_driver_gpios(ACPI_COMPANION(priv->codec_dev));
1899
1900 device_remove_software_node(priv->codec_dev);
1901 put_device(priv->codec_dev);
1902 }
1903
1904 static struct platform_driver snd_byt_rt5640_mc_driver = {
1905 .driver = {
1906 .name = "bytcr_rt5640",
1907 },
1908 .probe = snd_byt_rt5640_mc_probe,
1909 .remove_new = snd_byt_rt5640_mc_remove,
1910 };
1911
1912 module_platform_driver(snd_byt_rt5640_mc_driver);
1913
1914 MODULE_DESCRIPTION("ASoC Intel(R) Baytrail CR Machine driver");
1915 MODULE_AUTHOR("Subhransu S. Prusty <subhransu.s.prusty@intel.com>");
1916 MODULE_LICENSE("GPL v2");
1917 MODULE_ALIAS("platform:bytcr_rt5640");
1918