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 35enum { 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 45enum { 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 55enum { 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 61enum { 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 98struct 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}; 106static bool is_bytcr; 107 108static unsigned long byt_rt5640_quirk = BYT_RT5640_MCLK_EN; 109static int quirk_override = -1; 110module_param_named(quirk, quirk_override, int, 0444); 111MODULE_PARM_DESC(quirk, "Board-specific quirk override"); 112 113static 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 202static 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 252static 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 266static 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 307static 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 334static 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 346static 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 355static const struct snd_soc_dapm_route byt_rt5640_intmic_dmic1_map[] = { 356 {"Internal Mic", NULL, "Platform Clock"}, 357 {"DMIC1", NULL, "Internal Mic"}, 358}; 359 360static const struct snd_soc_dapm_route byt_rt5640_intmic_dmic2_map[] = { 361 {"Internal Mic", NULL, "Platform Clock"}, 362 {"DMIC2", NULL, "Internal Mic"}, 363}; 364 365static 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 371static 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 377static 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 383static 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 393static 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 403static 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 411static 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 419static 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 427static 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 433static 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 439static 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 448static 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 459static 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 471static 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 478static 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 485static const struct acpi_gpio_params acpi_gpio0 = { 0, 0, false }; 486static const struct acpi_gpio_params acpi_gpio1 = { 1, 0, false }; 487static const struct acpi_gpio_params acpi_gpio2 = { 2, 0, false }; 488 489static 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 496static 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 512static 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 528static 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 = snd_soc_substream_to_rtd(substream); 532 struct snd_soc_dai *dai = snd_soc_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 */ 538static 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 */ 1151static 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 */ 1213static const struct acpi_gpio_params amcr0f28_jd_gpio = { 1, 0, false }; 1214 1215static const struct acpi_gpio_mapping amcr0f28_gpios[] = { 1216 { "rt5640-jd-gpios", &amcr0f28_jd_gpio, 1 }, 1217 { } 1218}; 1219 1220static 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 1252put_adev: 1253 acpi_dev_put(adev); 1254 return ret; 1255} 1256 1257static 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 = snd_soc_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 1440static 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 1451static 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(snd_soc_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(snd_soc_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 1498static 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 1504static const struct snd_soc_ops byt_rt5640_aif1_ops = { 1505 .startup = byt_rt5640_aif1_startup, 1506}; 1507 1508static const struct snd_soc_ops byt_rt5640_be_ssp2_ops = { 1509 .hw_params = byt_rt5640_aif1_hw_params, 1510}; 1511 1512SND_SOC_DAILINK_DEF(dummy, 1513 DAILINK_COMP_ARRAY(COMP_DUMMY())); 1514 1515SND_SOC_DAILINK_DEF(media, 1516 DAILINK_COMP_ARRAY(COMP_CPU("media-cpu-dai"))); 1517 1518SND_SOC_DAILINK_DEF(deepbuffer, 1519 DAILINK_COMP_ARRAY(COMP_CPU("deepbuffer-cpu-dai"))); 1520 1521SND_SOC_DAILINK_DEF(ssp2_port, 1522 /* overwritten for ssp0 routing */ 1523 DAILINK_COMP_ARRAY(COMP_CPU("ssp2-port"))); 1524SND_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 1529SND_SOC_DAILINK_DEF(platform, 1530 DAILINK_COMP_ARRAY(COMP_PLATFORM("sst-mfld-platform"))); 1531 1532static 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 */ 1570static char byt_rt5640_codec_name[SND_ACPI_I2C_ID_LEN]; 1571#if !IS_ENABLED(CONFIG_SND_SOC_INTEL_USER_FRIENDLY_LONG_NAMES) 1572static char byt_rt5640_long_name[40]; /* = "bytcr-rt5640-*-spk-*-mic" */ 1573#endif 1574static char byt_rt5640_components[64]; /* = "cfg-spk:* cfg-mic:* ..." */ 1575 1576static 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 1594static 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 1621static 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 1634struct 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 1639static 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 (byt_rt5640_dais[i].codecs->name && 1670 !strcmp(byt_rt5640_dais[i].codecs->name, 1671 "i2c-10EC5640:00")) { 1672 dai_index = i; 1673 break; 1674 } 1675 } 1676 1677 /* fixup codec name based on HID */ 1678 adev = acpi_dev_get_first_match_dev(mach->id, NULL, -1); 1679 if (adev) { 1680 snprintf(byt_rt5640_codec_name, sizeof(byt_rt5640_codec_name), 1681 "i2c-%s", acpi_dev_name(adev)); 1682 byt_rt5640_dais[dai_index].codecs->name = byt_rt5640_codec_name; 1683 } else { 1684 dev_err(dev, "Error cannot find '%s' dev\n", mach->id); 1685 return -ENXIO; 1686 } 1687 1688 codec_dev = acpi_get_first_physical_node(adev); 1689 acpi_dev_put(adev); 1690 if (!codec_dev) 1691 return -EPROBE_DEFER; 1692 priv->codec_dev = get_device(codec_dev); 1693 1694 /* 1695 * swap SSP0 if bytcr is detected 1696 * (will be overridden if DMI quirk is detected) 1697 */ 1698 if (soc_intel_is_byt()) { 1699 if (mach->mach_params.acpi_ipc_irq_index == 0) 1700 is_bytcr = true; 1701 } 1702 1703 if (is_bytcr) { 1704 /* 1705 * Baytrail CR platforms may have CHAN package in BIOS, try 1706 * to find relevant routing quirk based as done on Windows 1707 * platforms. We have to read the information directly from the 1708 * BIOS, at this stage the card is not created and the links 1709 * with the codec driver/pdata are non-existent 1710 */ 1711 1712 struct acpi_chan_package chan_package = { 0 }; 1713 1714 /* format specified: 2 64-bit integers */ 1715 struct acpi_buffer format = {sizeof("NN"), "NN"}; 1716 struct acpi_buffer state = {0, NULL}; 1717 struct snd_soc_acpi_package_context pkg_ctx; 1718 bool pkg_found = false; 1719 1720 state.length = sizeof(chan_package); 1721 state.pointer = &chan_package; 1722 1723 pkg_ctx.name = "CHAN"; 1724 pkg_ctx.length = 2; 1725 pkg_ctx.format = &format; 1726 pkg_ctx.state = &state; 1727 pkg_ctx.data_valid = false; 1728 1729 pkg_found = snd_soc_acpi_find_package_from_hid(mach->id, 1730 &pkg_ctx); 1731 if (pkg_found) { 1732 if (chan_package.aif_value == 1) { 1733 dev_info(dev, "BIOS Routing: AIF1 connected\n"); 1734 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF1; 1735 } else if (chan_package.aif_value == 2) { 1736 dev_info(dev, "BIOS Routing: AIF2 connected\n"); 1737 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF2; 1738 } else { 1739 dev_info(dev, "BIOS Routing isn't valid, ignored\n"); 1740 pkg_found = false; 1741 } 1742 } 1743 1744 if (!pkg_found) { 1745 /* no BIOS indications, assume SSP0-AIF2 connection */ 1746 byt_rt5640_quirk |= BYT_RT5640_SSP0_AIF2; 1747 } 1748 1749 /* change defaults for Baytrail-CR capture */ 1750 byt_rt5640_quirk |= BYTCR_INPUT_DEFAULTS; 1751 } else { 1752 byt_rt5640_quirk |= BYT_RT5640_DMIC1_MAP | 1753 BYT_RT5640_JD_SRC_JD2_IN4N | 1754 BYT_RT5640_OVCD_TH_2000UA | 1755 BYT_RT5640_OVCD_SF_0P75; 1756 } 1757 1758 /* check quirks before creating card */ 1759 dmi_id = dmi_first_match(byt_rt5640_quirk_table); 1760 if (dmi_id) 1761 byt_rt5640_quirk = (unsigned long)dmi_id->driver_data; 1762 if (quirk_override != -1) { 1763 dev_info(dev, "Overriding quirk 0x%lx => 0x%x\n", 1764 byt_rt5640_quirk, quirk_override); 1765 byt_rt5640_quirk = quirk_override; 1766 } 1767 1768 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2) { 1769 acpi_dev_add_driver_gpios(ACPI_COMPANION(priv->codec_dev), 1770 byt_rt5640_hp_elitepad_1000g2_gpios); 1771 1772 priv->hsmic_detect = devm_fwnode_gpiod_get(dev, codec_dev->fwnode, 1773 "headset-mic-detect", GPIOD_IN, 1774 "headset-mic-detect"); 1775 if (IS_ERR(priv->hsmic_detect)) { 1776 ret_val = dev_err_probe(dev, PTR_ERR(priv->hsmic_detect), 1777 "getting hsmic-detect GPIO\n"); 1778 goto err_device; 1779 } 1780 } 1781 1782 /* Must be called before register_card, also see declaration comment. */ 1783 ret_val = byt_rt5640_add_codec_device_props(codec_dev, priv); 1784 if (ret_val) 1785 goto err_remove_gpios; 1786 1787 log_quirks(dev); 1788 1789 if ((byt_rt5640_quirk & BYT_RT5640_SSP2_AIF2) || 1790 (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) { 1791 byt_rt5640_dais[dai_index].codecs->dai_name = "rt5640-aif2"; 1792 aif = 2; 1793 } else { 1794 aif = 1; 1795 } 1796 1797 if ((byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) || 1798 (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF2)) 1799 byt_rt5640_dais[dai_index].cpus->dai_name = "ssp0-port"; 1800 1801 if (byt_rt5640_quirk & BYT_RT5640_MCLK_EN) { 1802 priv->mclk = devm_clk_get_optional(dev, "pmc_plt_clk_3"); 1803 if (IS_ERR(priv->mclk)) { 1804 ret_val = dev_err_probe(dev, PTR_ERR(priv->mclk), 1805 "Failed to get MCLK from pmc_plt_clk_3\n"); 1806 goto err; 1807 } 1808 /* 1809 * Fall back to bit clock usage when clock is not 1810 * available likely due to missing dependencies. 1811 */ 1812 if (!priv->mclk) 1813 byt_rt5640_quirk &= ~BYT_RT5640_MCLK_EN; 1814 } 1815 1816 if (byt_rt5640_quirk & BYT_RT5640_NO_SPEAKERS) { 1817 cfg_spk = "0"; 1818 spk_type = "none"; 1819 } else if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) { 1820 cfg_spk = "1"; 1821 spk_type = "mono"; 1822 } else if (byt_rt5640_quirk & BYT_RT5640_SWAPPED_SPEAKERS) { 1823 cfg_spk = "swapped"; 1824 spk_type = "swapped"; 1825 } else { 1826 cfg_spk = "2"; 1827 spk_type = "stereo"; 1828 } 1829 1830 if (byt_rt5640_quirk & BYT_RT5640_LINEOUT) { 1831 if (byt_rt5640_quirk & BYT_RT5640_LINEOUT_AS_HP2) 1832 lineout_string = " cfg-hp2:lineout"; 1833 else 1834 lineout_string = " cfg-lineout:2"; 1835 } 1836 1837 if (byt_rt5640_quirk & BYT_RT5640_HSMIC2_ON_IN1) 1838 headset2_string = " cfg-hs2:in1"; 1839 1840 snprintf(byt_rt5640_components, sizeof(byt_rt5640_components), 1841 "cfg-spk:%s cfg-mic:%s aif:%d%s%s", cfg_spk, 1842 map_name[BYT_RT5640_MAP(byt_rt5640_quirk)], aif, 1843 lineout_string, headset2_string); 1844 byt_rt5640_card.components = byt_rt5640_components; 1845#if !IS_ENABLED(CONFIG_SND_SOC_INTEL_USER_FRIENDLY_LONG_NAMES) 1846 snprintf(byt_rt5640_long_name, sizeof(byt_rt5640_long_name), 1847 "bytcr-rt5640-%s-spk-%s-mic", spk_type, 1848 map_name[BYT_RT5640_MAP(byt_rt5640_quirk)]); 1849 byt_rt5640_card.long_name = byt_rt5640_long_name; 1850#endif 1851 1852 /* override platform name, if required */ 1853 platform_name = mach->mach_params.platform; 1854 1855 ret_val = snd_soc_fixup_dai_links_platform_name(&byt_rt5640_card, 1856 platform_name); 1857 if (ret_val) 1858 goto err; 1859 1860 sof_parent = snd_soc_acpi_sof_parent(dev); 1861 1862 /* set card and driver name */ 1863 if (sof_parent) { 1864 byt_rt5640_card.name = SOF_CARD_NAME; 1865 byt_rt5640_card.driver_name = SOF_DRIVER_NAME; 1866 } else { 1867 byt_rt5640_card.name = CARD_NAME; 1868 byt_rt5640_card.driver_name = DRIVER_NAME; 1869 } 1870 1871 /* set pm ops */ 1872 if (sof_parent) 1873 dev->driver->pm = &snd_soc_pm_ops; 1874 1875 ret_val = devm_snd_soc_register_card(dev, &byt_rt5640_card); 1876 if (ret_val) { 1877 dev_err(dev, "devm_snd_soc_register_card failed %d\n", ret_val); 1878 goto err; 1879 } 1880 platform_set_drvdata(pdev, &byt_rt5640_card); 1881 return ret_val; 1882 1883err: 1884 device_remove_software_node(priv->codec_dev); 1885err_remove_gpios: 1886 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2) 1887 acpi_dev_remove_driver_gpios(ACPI_COMPANION(priv->codec_dev)); 1888err_device: 1889 put_device(priv->codec_dev); 1890 return ret_val; 1891} 1892 1893static void snd_byt_rt5640_mc_remove(struct platform_device *pdev) 1894{ 1895 struct snd_soc_card *card = platform_get_drvdata(pdev); 1896 struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card); 1897 1898 if (byt_rt5640_quirk & BYT_RT5640_JD_HP_ELITEP_1000G2) 1899 acpi_dev_remove_driver_gpios(ACPI_COMPANION(priv->codec_dev)); 1900 1901 device_remove_software_node(priv->codec_dev); 1902 put_device(priv->codec_dev); 1903} 1904 1905static struct platform_driver snd_byt_rt5640_mc_driver = { 1906 .driver = { 1907 .name = "bytcr_rt5640", 1908 }, 1909 .probe = snd_byt_rt5640_mc_probe, 1910 .remove_new = snd_byt_rt5640_mc_remove, 1911}; 1912 1913module_platform_driver(snd_byt_rt5640_mc_driver); 1914 1915MODULE_DESCRIPTION("ASoC Intel(R) Baytrail CR Machine driver"); 1916MODULE_AUTHOR("Subhransu S. Prusty <subhransu.s.prusty@intel.com>"); 1917MODULE_LICENSE("GPL v2"); 1918MODULE_ALIAS("platform:bytcr_rt5640"); 1919