1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // rt700.c -- rt700 ALSA SoC audio driver 4 // 5 // Copyright(c) 2019 Realtek Semiconductor Corp. 6 // 7 // 8 9 #include <linux/module.h> 10 #include <linux/moduleparam.h> 11 #include <linux/kernel.h> 12 #include <linux/init.h> 13 #include <linux/delay.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/pm.h> 16 #include <linux/soundwire/sdw.h> 17 #include <linux/regmap.h> 18 #include <linux/slab.h> 19 #include <sound/core.h> 20 #include <sound/pcm.h> 21 #include <sound/pcm_params.h> 22 #include <sound/soc.h> 23 #include <sound/soc-dapm.h> 24 #include <sound/initval.h> 25 #include <sound/tlv.h> 26 #include <sound/hda_verbs.h> 27 #include <sound/jack.h> 28 29 #include "rt700.h" 30 31 static int rt700_index_write(struct regmap *regmap, 32 unsigned int reg, unsigned int value) 33 { 34 int ret; 35 unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg; 36 37 ret = regmap_write(regmap, addr, value); 38 if (ret < 0) 39 pr_err("Failed to set private value: %06x <= %04x ret=%d\n", 40 addr, value, ret); 41 42 return ret; 43 } 44 45 static int rt700_index_read(struct regmap *regmap, 46 unsigned int reg, unsigned int *value) 47 { 48 int ret; 49 unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg; 50 51 *value = 0; 52 ret = regmap_read(regmap, addr, value); 53 if (ret < 0) 54 pr_err("Failed to get private value: %06x => %04x ret=%d\n", 55 addr, *value, ret); 56 57 return ret; 58 } 59 60 static unsigned int rt700_button_detect(struct rt700_priv *rt700) 61 { 62 unsigned int btn_type = 0, val80, val81; 63 int ret; 64 65 ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE1, &val80); 66 if (ret < 0) 67 goto read_error; 68 ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE2, &val81); 69 if (ret < 0) 70 goto read_error; 71 72 val80 &= 0x0381; 73 val81 &= 0xff00; 74 75 switch (val80) { 76 case 0x0200: 77 case 0x0100: 78 case 0x0080: 79 btn_type |= SND_JACK_BTN_0; 80 break; 81 case 0x0001: 82 btn_type |= SND_JACK_BTN_3; 83 break; 84 } 85 switch (val81) { 86 case 0x8000: 87 case 0x4000: 88 case 0x2000: 89 btn_type |= SND_JACK_BTN_1; 90 break; 91 case 0x1000: 92 case 0x0800: 93 case 0x0400: 94 btn_type |= SND_JACK_BTN_2; 95 break; 96 case 0x0200: 97 case 0x0100: 98 btn_type |= SND_JACK_BTN_3; 99 break; 100 } 101 read_error: 102 return btn_type; 103 } 104 105 static int rt700_headset_detect(struct rt700_priv *rt700) 106 { 107 unsigned int buf, loop = 0; 108 int ret; 109 unsigned int jack_status = 0, reg; 110 111 ret = rt700_index_read(rt700->regmap, 112 RT700_COMBO_JACK_AUTO_CTL2, &buf); 113 if (ret < 0) 114 goto io_error; 115 116 while (loop < 500 && 117 (buf & RT700_COMBOJACK_AUTO_DET_STATUS) == 0) { 118 loop++; 119 120 usleep_range(9000, 10000); 121 ret = rt700_index_read(rt700->regmap, 122 RT700_COMBO_JACK_AUTO_CTL2, &buf); 123 if (ret < 0) 124 goto io_error; 125 126 reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT; 127 ret = regmap_read(rt700->regmap, reg, &jack_status); 128 if ((jack_status & (1 << 31)) == 0) 129 goto remove_error; 130 } 131 132 if (loop >= 500) 133 goto to_error; 134 135 if (buf & RT700_COMBOJACK_AUTO_DET_TRS) 136 rt700->jack_type = SND_JACK_HEADPHONE; 137 else if ((buf & RT700_COMBOJACK_AUTO_DET_CTIA) || 138 (buf & RT700_COMBOJACK_AUTO_DET_OMTP)) 139 rt700->jack_type = SND_JACK_HEADSET; 140 141 return 0; 142 143 to_error: 144 ret = -ETIMEDOUT; 145 pr_err_ratelimited("Time-out error in %s\n", __func__); 146 return ret; 147 io_error: 148 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 149 return ret; 150 remove_error: 151 pr_err_ratelimited("Jack removal in %s\n", __func__); 152 return -ENODEV; 153 } 154 155 static void rt700_jack_detect_handler(struct work_struct *work) 156 { 157 struct rt700_priv *rt700 = 158 container_of(work, struct rt700_priv, jack_detect_work.work); 159 int btn_type = 0, ret; 160 unsigned int jack_status = 0, reg; 161 162 if (!rt700->hs_jack) 163 return; 164 165 if (!rt700->component->card || !rt700->component->card->instantiated) 166 return; 167 168 reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT; 169 ret = regmap_read(rt700->regmap, reg, &jack_status); 170 if (ret < 0) 171 goto io_error; 172 173 /* pin attached */ 174 if (jack_status & (1 << 31)) { 175 /* jack in */ 176 if (rt700->jack_type == 0) { 177 ret = rt700_headset_detect(rt700); 178 if (ret < 0) 179 return; 180 if (rt700->jack_type == SND_JACK_HEADSET) 181 btn_type = rt700_button_detect(rt700); 182 } else if (rt700->jack_type == SND_JACK_HEADSET) { 183 /* jack is already in, report button event */ 184 btn_type = rt700_button_detect(rt700); 185 } 186 } else { 187 /* jack out */ 188 rt700->jack_type = 0; 189 } 190 191 dev_dbg(&rt700->slave->dev, 192 "in %s, jack_type=0x%x\n", __func__, rt700->jack_type); 193 dev_dbg(&rt700->slave->dev, 194 "in %s, btn_type=0x%x\n", __func__, btn_type); 195 196 snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type, 197 SND_JACK_HEADSET | 198 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 199 SND_JACK_BTN_2 | SND_JACK_BTN_3); 200 201 if (btn_type) { 202 /* button released */ 203 snd_soc_jack_report(rt700->hs_jack, rt700->jack_type, 204 SND_JACK_HEADSET | 205 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 206 SND_JACK_BTN_2 | SND_JACK_BTN_3); 207 208 mod_delayed_work(system_power_efficient_wq, 209 &rt700->jack_btn_check_work, msecs_to_jiffies(200)); 210 } 211 212 return; 213 214 io_error: 215 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 216 } 217 218 static void rt700_btn_check_handler(struct work_struct *work) 219 { 220 struct rt700_priv *rt700 = container_of(work, struct rt700_priv, 221 jack_btn_check_work.work); 222 int btn_type = 0, ret; 223 unsigned int jack_status = 0, reg; 224 225 reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT; 226 ret = regmap_read(rt700->regmap, reg, &jack_status); 227 if (ret < 0) 228 goto io_error; 229 230 /* pin attached */ 231 if (jack_status & (1 << 31)) { 232 if (rt700->jack_type == SND_JACK_HEADSET) { 233 /* jack is already in, report button event */ 234 btn_type = rt700_button_detect(rt700); 235 } 236 } else { 237 rt700->jack_type = 0; 238 } 239 240 /* cbj comparator */ 241 ret = rt700_index_read(rt700->regmap, RT700_COMBO_JACK_AUTO_CTL2, ®); 242 if (ret < 0) 243 goto io_error; 244 245 if ((reg & 0xf0) == 0xf0) 246 btn_type = 0; 247 248 dev_dbg(&rt700->slave->dev, 249 "%s, btn_type=0x%x\n", __func__, btn_type); 250 snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type, 251 SND_JACK_HEADSET | 252 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 253 SND_JACK_BTN_2 | SND_JACK_BTN_3); 254 255 if (btn_type) { 256 /* button released */ 257 snd_soc_jack_report(rt700->hs_jack, rt700->jack_type, 258 SND_JACK_HEADSET | 259 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 260 SND_JACK_BTN_2 | SND_JACK_BTN_3); 261 262 mod_delayed_work(system_power_efficient_wq, 263 &rt700->jack_btn_check_work, msecs_to_jiffies(200)); 264 } 265 266 return; 267 268 io_error: 269 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 270 } 271 272 static void rt700_jack_init(struct rt700_priv *rt700) 273 { 274 struct snd_soc_dapm_context *dapm = 275 snd_soc_component_get_dapm(rt700->component); 276 277 /* power on */ 278 if (dapm->bias_level <= SND_SOC_BIAS_STANDBY) 279 regmap_write(rt700->regmap, 280 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0); 281 282 if (rt700->hs_jack) { 283 /* Enable Jack Detection */ 284 regmap_write(rt700->regmap, 285 RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x82); 286 regmap_write(rt700->regmap, 287 RT700_SET_HP_UNSOLICITED_ENABLE, 0x81); 288 regmap_write(rt700->regmap, 289 RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x83); 290 rt700_index_write(rt700->regmap, 0x10, 0x2420); 291 rt700_index_write(rt700->regmap, 0x19, 0x2e11); 292 293 dev_dbg(&rt700->slave->dev, "in %s enable\n", __func__); 294 295 mod_delayed_work(system_power_efficient_wq, 296 &rt700->jack_detect_work, msecs_to_jiffies(250)); 297 } else { 298 regmap_write(rt700->regmap, 299 RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x00); 300 regmap_write(rt700->regmap, 301 RT700_SET_HP_UNSOLICITED_ENABLE, 0x00); 302 regmap_write(rt700->regmap, 303 RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x00); 304 305 dev_dbg(&rt700->slave->dev, "in %s disable\n", __func__); 306 } 307 308 /* power off */ 309 if (dapm->bias_level <= SND_SOC_BIAS_STANDBY) 310 regmap_write(rt700->regmap, 311 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3); 312 } 313 314 static int rt700_set_jack_detect(struct snd_soc_component *component, 315 struct snd_soc_jack *hs_jack, void *data) 316 { 317 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 318 int ret; 319 320 rt700->hs_jack = hs_jack; 321 322 ret = pm_runtime_resume_and_get(component->dev); 323 if (ret < 0) { 324 if (ret != -EACCES) { 325 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret); 326 return ret; 327 } 328 329 /* pm_runtime not enabled yet */ 330 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__); 331 return 0; 332 } 333 334 rt700_jack_init(rt700); 335 336 pm_runtime_mark_last_busy(component->dev); 337 pm_runtime_put_autosuspend(component->dev); 338 339 return 0; 340 } 341 342 static void rt700_get_gain(struct rt700_priv *rt700, unsigned int addr_h, 343 unsigned int addr_l, unsigned int val_h, 344 unsigned int *r_val, unsigned int *l_val) 345 { 346 /* R Channel */ 347 *r_val = (val_h << 8); 348 regmap_read(rt700->regmap, addr_l, r_val); 349 350 /* L Channel */ 351 val_h |= 0x20; 352 *l_val = (val_h << 8); 353 regmap_read(rt700->regmap, addr_h, l_val); 354 } 355 356 /* For Verb-Set Amplifier Gain (Verb ID = 3h) */ 357 static int rt700_set_amp_gain_put(struct snd_kcontrol *kcontrol, 358 struct snd_ctl_elem_value *ucontrol) 359 { 360 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 361 struct snd_soc_dapm_context *dapm = 362 snd_soc_component_get_dapm(component); 363 struct soc_mixer_control *mc = 364 (struct soc_mixer_control *)kcontrol->private_value; 365 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 366 unsigned int addr_h, addr_l, val_h, val_ll, val_lr; 367 unsigned int read_ll, read_rl; 368 int i; 369 370 /* Can't use update bit function, so read the original value first */ 371 addr_h = mc->reg; 372 addr_l = mc->rreg; 373 if (mc->shift == RT700_DIR_OUT_SFT) /* output */ 374 val_h = 0x80; 375 else /* input */ 376 val_h = 0x0; 377 378 rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll); 379 380 /* L Channel */ 381 if (mc->invert) { 382 /* for mute */ 383 val_ll = (mc->max - ucontrol->value.integer.value[0]) << 7; 384 /* keep gain */ 385 read_ll = read_ll & 0x7f; 386 val_ll |= read_ll; 387 } else { 388 /* for gain */ 389 val_ll = ((ucontrol->value.integer.value[0]) & 0x7f); 390 if (val_ll > mc->max) 391 val_ll = mc->max; 392 /* keep mute status */ 393 read_ll = read_ll & 0x80; 394 val_ll |= read_ll; 395 } 396 397 if (dapm->bias_level <= SND_SOC_BIAS_STANDBY) 398 regmap_write(rt700->regmap, 399 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0); 400 401 /* R Channel */ 402 if (mc->invert) { 403 /* for mute */ 404 val_lr = (mc->max - ucontrol->value.integer.value[1]) << 7; 405 /* keep gain */ 406 read_rl = read_rl & 0x7f; 407 val_lr |= read_rl; 408 } else { 409 /* for gain */ 410 val_lr = ((ucontrol->value.integer.value[1]) & 0x7f); 411 if (val_lr > mc->max) 412 val_lr = mc->max; 413 /* keep mute status */ 414 read_rl = read_rl & 0x80; 415 val_lr |= read_rl; 416 } 417 418 for (i = 0; i < 3; i++) { /* retry 3 times at most */ 419 if (val_ll == val_lr) { 420 /* Set both L/R channels at the same time */ 421 val_h = (1 << mc->shift) | (3 << 4); 422 regmap_write(rt700->regmap, 423 addr_h, (val_h << 8 | val_ll)); 424 regmap_write(rt700->regmap, 425 addr_l, (val_h << 8 | val_ll)); 426 } else { 427 /* Lch*/ 428 val_h = (1 << mc->shift) | (1 << 5); 429 regmap_write(rt700->regmap, 430 addr_h, (val_h << 8 | val_ll)); 431 432 /* Rch */ 433 val_h = (1 << mc->shift) | (1 << 4); 434 regmap_write(rt700->regmap, 435 addr_l, (val_h << 8 | val_lr)); 436 } 437 /* check result */ 438 if (mc->shift == RT700_DIR_OUT_SFT) /* output */ 439 val_h = 0x80; 440 else /* input */ 441 val_h = 0x0; 442 443 rt700_get_gain(rt700, addr_h, addr_l, val_h, 444 &read_rl, &read_ll); 445 if (read_rl == val_lr && read_ll == val_ll) 446 break; 447 } 448 449 if (dapm->bias_level <= SND_SOC_BIAS_STANDBY) 450 regmap_write(rt700->regmap, 451 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3); 452 return 0; 453 } 454 455 static int rt700_set_amp_gain_get(struct snd_kcontrol *kcontrol, 456 struct snd_ctl_elem_value *ucontrol) 457 { 458 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 459 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 460 struct soc_mixer_control *mc = 461 (struct soc_mixer_control *)kcontrol->private_value; 462 unsigned int addr_h, addr_l, val_h; 463 unsigned int read_ll, read_rl; 464 465 addr_h = mc->reg; 466 addr_l = mc->rreg; 467 if (mc->shift == RT700_DIR_OUT_SFT) /* output */ 468 val_h = 0x80; 469 else /* input */ 470 val_h = 0x0; 471 472 rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll); 473 474 if (mc->invert) { 475 /* for mute status */ 476 read_ll = !((read_ll & 0x80) >> RT700_MUTE_SFT); 477 read_rl = !((read_rl & 0x80) >> RT700_MUTE_SFT); 478 } else { 479 /* for gain */ 480 read_ll = read_ll & 0x7f; 481 read_rl = read_rl & 0x7f; 482 } 483 ucontrol->value.integer.value[0] = read_ll; 484 ucontrol->value.integer.value[1] = read_rl; 485 486 return 0; 487 } 488 489 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0); 490 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0); 491 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0); 492 493 static const struct snd_kcontrol_new rt700_snd_controls[] = { 494 SOC_DOUBLE_R_EXT_TLV("DAC Front Playback Volume", 495 RT700_SET_GAIN_DAC1_H, RT700_SET_GAIN_DAC1_L, 496 RT700_DIR_OUT_SFT, 0x57, 0, 497 rt700_set_amp_gain_get, rt700_set_amp_gain_put, out_vol_tlv), 498 SOC_DOUBLE_R_EXT("ADC 08 Capture Switch", 499 RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L, 500 RT700_DIR_IN_SFT, 1, 1, 501 rt700_set_amp_gain_get, rt700_set_amp_gain_put), 502 SOC_DOUBLE_R_EXT("ADC 09 Capture Switch", 503 RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L, 504 RT700_DIR_IN_SFT, 1, 1, 505 rt700_set_amp_gain_get, rt700_set_amp_gain_put), 506 SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume", 507 RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L, 508 RT700_DIR_IN_SFT, 0x3f, 0, 509 rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv), 510 SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume", 511 RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L, 512 RT700_DIR_IN_SFT, 0x3f, 0, 513 rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv), 514 SOC_DOUBLE_R_EXT_TLV("AMIC Volume", 515 RT700_SET_GAIN_AMIC_H, RT700_SET_GAIN_AMIC_L, 516 RT700_DIR_IN_SFT, 3, 0, 517 rt700_set_amp_gain_get, rt700_set_amp_gain_put, mic_vol_tlv), 518 }; 519 520 static int rt700_mux_get(struct snd_kcontrol *kcontrol, 521 struct snd_ctl_elem_value *ucontrol) 522 { 523 struct snd_soc_component *component = 524 snd_soc_dapm_kcontrol_component(kcontrol); 525 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 526 unsigned int reg, val = 0, nid; 527 int ret; 528 529 if (strstr(ucontrol->id.name, "HPO Mux")) 530 nid = RT700_HP_OUT; 531 else if (strstr(ucontrol->id.name, "ADC 22 Mux")) 532 nid = RT700_MIXER_IN1; 533 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 534 nid = RT700_MIXER_IN2; 535 else 536 return -EINVAL; 537 538 /* vid = 0xf01 */ 539 reg = RT700_VERB_SET_CONNECT_SEL | nid; 540 ret = regmap_read(rt700->regmap, reg, &val); 541 if (ret < 0) 542 return ret; 543 544 ucontrol->value.enumerated.item[0] = val; 545 546 return 0; 547 } 548 549 static int rt700_mux_put(struct snd_kcontrol *kcontrol, 550 struct snd_ctl_elem_value *ucontrol) 551 { 552 struct snd_soc_component *component = 553 snd_soc_dapm_kcontrol_component(kcontrol); 554 struct snd_soc_dapm_context *dapm = 555 snd_soc_dapm_kcontrol_dapm(kcontrol); 556 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 557 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 558 unsigned int *item = ucontrol->value.enumerated.item; 559 unsigned int val, val2 = 0, change, reg, nid; 560 int ret; 561 562 if (item[0] >= e->items) 563 return -EINVAL; 564 565 if (strstr(ucontrol->id.name, "HPO Mux")) 566 nid = RT700_HP_OUT; 567 else if (strstr(ucontrol->id.name, "ADC 22 Mux")) 568 nid = RT700_MIXER_IN1; 569 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 570 nid = RT700_MIXER_IN2; 571 else 572 return -EINVAL; 573 574 /* Verb ID = 0x701h */ 575 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 576 577 reg = RT700_VERB_SET_CONNECT_SEL | nid; 578 ret = regmap_read(rt700->regmap, reg, &val2); 579 if (ret < 0) 580 return ret; 581 582 if (val == val2) 583 change = 0; 584 else 585 change = 1; 586 587 if (change) { 588 reg = RT700_VERB_SET_CONNECT_SEL | nid; 589 regmap_write(rt700->regmap, reg, val); 590 } 591 592 snd_soc_dapm_mux_update_power(dapm, kcontrol, 593 item[0], e, NULL); 594 595 return change; 596 } 597 598 static const char * const adc_mux_text[] = { 599 "MIC2", 600 "LINE1", 601 "LINE2", 602 "DMIC", 603 }; 604 605 static SOC_ENUM_SINGLE_DECL( 606 rt700_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text); 607 608 static SOC_ENUM_SINGLE_DECL( 609 rt700_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text); 610 611 static const struct snd_kcontrol_new rt700_adc22_mux = 612 SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt700_adc22_enum, 613 rt700_mux_get, rt700_mux_put); 614 615 static const struct snd_kcontrol_new rt700_adc23_mux = 616 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt700_adc23_enum, 617 rt700_mux_get, rt700_mux_put); 618 619 static const char * const out_mux_text[] = { 620 "Front", 621 "Surround", 622 }; 623 624 static SOC_ENUM_SINGLE_DECL( 625 rt700_hp_enum, SND_SOC_NOPM, 0, out_mux_text); 626 627 static const struct snd_kcontrol_new rt700_hp_mux = 628 SOC_DAPM_ENUM_EXT("HP Mux", rt700_hp_enum, 629 rt700_mux_get, rt700_mux_put); 630 631 static int rt700_dac_front_event(struct snd_soc_dapm_widget *w, 632 struct snd_kcontrol *kcontrol, int event) 633 { 634 struct snd_soc_component *component = 635 snd_soc_dapm_to_component(w->dapm); 636 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 637 638 switch (event) { 639 case SND_SOC_DAPM_POST_PMU: 640 regmap_write(rt700->regmap, 641 RT700_SET_STREAMID_DAC1, 0x10); 642 break; 643 case SND_SOC_DAPM_PRE_PMD: 644 regmap_write(rt700->regmap, 645 RT700_SET_STREAMID_DAC1, 0x00); 646 break; 647 } 648 return 0; 649 } 650 651 static int rt700_dac_surround_event(struct snd_soc_dapm_widget *w, 652 struct snd_kcontrol *kcontrol, int event) 653 { 654 struct snd_soc_component *component = 655 snd_soc_dapm_to_component(w->dapm); 656 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 657 658 switch (event) { 659 case SND_SOC_DAPM_POST_PMU: 660 regmap_write(rt700->regmap, 661 RT700_SET_STREAMID_DAC2, 0x10); 662 break; 663 case SND_SOC_DAPM_PRE_PMD: 664 regmap_write(rt700->regmap, 665 RT700_SET_STREAMID_DAC2, 0x00); 666 break; 667 } 668 return 0; 669 } 670 671 static int rt700_adc_09_event(struct snd_soc_dapm_widget *w, 672 struct snd_kcontrol *kcontrol, int event) 673 { 674 struct snd_soc_component *component = 675 snd_soc_dapm_to_component(w->dapm); 676 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 677 678 switch (event) { 679 case SND_SOC_DAPM_POST_PMU: 680 regmap_write(rt700->regmap, 681 RT700_SET_STREAMID_ADC1, 0x10); 682 break; 683 case SND_SOC_DAPM_PRE_PMD: 684 regmap_write(rt700->regmap, 685 RT700_SET_STREAMID_ADC1, 0x00); 686 break; 687 } 688 return 0; 689 } 690 691 static int rt700_adc_08_event(struct snd_soc_dapm_widget *w, 692 struct snd_kcontrol *kcontrol, int event) 693 { 694 struct snd_soc_component *component = 695 snd_soc_dapm_to_component(w->dapm); 696 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 697 698 switch (event) { 699 case SND_SOC_DAPM_POST_PMU: 700 regmap_write(rt700->regmap, 701 RT700_SET_STREAMID_ADC2, 0x10); 702 break; 703 case SND_SOC_DAPM_PRE_PMD: 704 regmap_write(rt700->regmap, 705 RT700_SET_STREAMID_ADC2, 0x00); 706 break; 707 } 708 return 0; 709 } 710 711 static int rt700_hpo_mux_event(struct snd_soc_dapm_widget *w, 712 struct snd_kcontrol *kcontrol, int event) 713 { 714 struct snd_soc_component *component = 715 snd_soc_dapm_to_component(w->dapm); 716 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 717 unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4); 718 unsigned int val_l; 719 720 switch (event) { 721 case SND_SOC_DAPM_POST_PMU: 722 val_l = 0x00; 723 regmap_write(rt700->regmap, 724 RT700_SET_GAIN_HP_H, (val_h << 8 | val_l)); 725 break; 726 case SND_SOC_DAPM_PRE_PMD: 727 val_l = (1 << RT700_MUTE_SFT); 728 regmap_write(rt700->regmap, 729 RT700_SET_GAIN_HP_H, (val_h << 8 | val_l)); 730 usleep_range(50000, 55000); 731 break; 732 } 733 return 0; 734 } 735 736 static int rt700_spk_pga_event(struct snd_soc_dapm_widget *w, 737 struct snd_kcontrol *kcontrol, int event) 738 { 739 struct snd_soc_component *component = 740 snd_soc_dapm_to_component(w->dapm); 741 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 742 unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4); 743 unsigned int val_l; 744 745 switch (event) { 746 case SND_SOC_DAPM_POST_PMU: 747 val_l = 0x00; 748 regmap_write(rt700->regmap, 749 RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l)); 750 break; 751 case SND_SOC_DAPM_PRE_PMD: 752 val_l = (1 << RT700_MUTE_SFT); 753 regmap_write(rt700->regmap, 754 RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l)); 755 break; 756 } 757 return 0; 758 } 759 760 static const struct snd_soc_dapm_widget rt700_dapm_widgets[] = { 761 SND_SOC_DAPM_OUTPUT("HP"), 762 SND_SOC_DAPM_OUTPUT("SPK"), 763 SND_SOC_DAPM_INPUT("DMIC1"), 764 SND_SOC_DAPM_INPUT("DMIC2"), 765 SND_SOC_DAPM_INPUT("MIC2"), 766 SND_SOC_DAPM_INPUT("LINE1"), 767 SND_SOC_DAPM_INPUT("LINE2"), 768 SND_SOC_DAPM_DAC_E("DAC Front", NULL, SND_SOC_NOPM, 0, 0, 769 rt700_dac_front_event, 770 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 771 SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0, 772 rt700_dac_surround_event, 773 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 774 SND_SOC_DAPM_MUX_E("HPO Mux", SND_SOC_NOPM, 0, 0, &rt700_hp_mux, 775 rt700_hpo_mux_event, 776 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 777 SND_SOC_DAPM_PGA_E("SPK PGA", SND_SOC_NOPM, 0, 0, NULL, 0, 778 rt700_spk_pga_event, 779 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 780 SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0, 781 rt700_adc_09_event, 782 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 783 SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0, 784 rt700_adc_08_event, 785 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 786 SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0, 787 &rt700_adc22_mux), 788 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0, 789 &rt700_adc23_mux), 790 SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0), 791 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0), 792 SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0), 793 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0), 794 }; 795 796 static const struct snd_soc_dapm_route rt700_audio_map[] = { 797 {"DAC Front", NULL, "DP1RX"}, 798 {"DAC Surround", NULL, "DP3RX"}, 799 {"DP2TX", NULL, "ADC 09"}, 800 {"DP4TX", NULL, "ADC 08"}, 801 {"ADC 09", NULL, "ADC 22 Mux"}, 802 {"ADC 08", NULL, "ADC 23 Mux"}, 803 {"ADC 22 Mux", "DMIC", "DMIC1"}, 804 {"ADC 22 Mux", "LINE1", "LINE1"}, 805 {"ADC 22 Mux", "LINE2", "LINE2"}, 806 {"ADC 22 Mux", "MIC2", "MIC2"}, 807 {"ADC 23 Mux", "DMIC", "DMIC2"}, 808 {"ADC 23 Mux", "LINE1", "LINE1"}, 809 {"ADC 23 Mux", "LINE2", "LINE2"}, 810 {"ADC 23 Mux", "MIC2", "MIC2"}, 811 {"HPO Mux", "Front", "DAC Front"}, 812 {"HPO Mux", "Surround", "DAC Surround"}, 813 {"HP", NULL, "HPO Mux"}, 814 {"SPK PGA", NULL, "DAC Front"}, 815 {"SPK", NULL, "SPK PGA"}, 816 }; 817 818 static int rt700_probe(struct snd_soc_component *component) 819 { 820 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 821 int ret; 822 823 rt700->component = component; 824 825 ret = pm_runtime_resume(component->dev); 826 if (ret < 0 && ret != -EACCES) 827 return ret; 828 829 return 0; 830 } 831 832 static int rt700_set_bias_level(struct snd_soc_component *component, 833 enum snd_soc_bias_level level) 834 { 835 struct snd_soc_dapm_context *dapm = 836 snd_soc_component_get_dapm(component); 837 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 838 839 switch (level) { 840 case SND_SOC_BIAS_PREPARE: 841 if (dapm->bias_level == SND_SOC_BIAS_STANDBY) { 842 regmap_write(rt700->regmap, 843 RT700_SET_AUDIO_POWER_STATE, 844 AC_PWRST_D0); 845 } 846 break; 847 848 case SND_SOC_BIAS_STANDBY: 849 regmap_write(rt700->regmap, 850 RT700_SET_AUDIO_POWER_STATE, 851 AC_PWRST_D3); 852 break; 853 854 default: 855 break; 856 } 857 dapm->bias_level = level; 858 return 0; 859 } 860 861 static const struct snd_soc_component_driver soc_codec_dev_rt700 = { 862 .probe = rt700_probe, 863 .set_bias_level = rt700_set_bias_level, 864 .controls = rt700_snd_controls, 865 .num_controls = ARRAY_SIZE(rt700_snd_controls), 866 .dapm_widgets = rt700_dapm_widgets, 867 .num_dapm_widgets = ARRAY_SIZE(rt700_dapm_widgets), 868 .dapm_routes = rt700_audio_map, 869 .num_dapm_routes = ARRAY_SIZE(rt700_audio_map), 870 .set_jack = rt700_set_jack_detect, 871 .endianness = 1, 872 }; 873 874 static int rt700_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream, 875 int direction) 876 { 877 struct sdw_stream_data *stream; 878 879 if (!sdw_stream) 880 return 0; 881 882 stream = kzalloc(sizeof(*stream), GFP_KERNEL); 883 if (!stream) 884 return -ENOMEM; 885 886 stream->sdw_stream = sdw_stream; 887 888 /* Use tx_mask or rx_mask to configure stream tag and set dma_data */ 889 if (direction == SNDRV_PCM_STREAM_PLAYBACK) 890 dai->playback_dma_data = stream; 891 else 892 dai->capture_dma_data = stream; 893 894 return 0; 895 } 896 897 static void rt700_shutdown(struct snd_pcm_substream *substream, 898 struct snd_soc_dai *dai) 899 { 900 struct sdw_stream_data *stream; 901 902 stream = snd_soc_dai_get_dma_data(dai, substream); 903 snd_soc_dai_set_dma_data(dai, substream, NULL); 904 kfree(stream); 905 } 906 907 static int rt700_pcm_hw_params(struct snd_pcm_substream *substream, 908 struct snd_pcm_hw_params *params, 909 struct snd_soc_dai *dai) 910 { 911 struct snd_soc_component *component = dai->component; 912 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 913 struct sdw_stream_config stream_config; 914 struct sdw_port_config port_config; 915 enum sdw_data_direction direction; 916 struct sdw_stream_data *stream; 917 int retval, port, num_channels; 918 unsigned int val = 0; 919 920 dev_dbg(dai->dev, "%s %s", __func__, dai->name); 921 stream = snd_soc_dai_get_dma_data(dai, substream); 922 923 if (!stream) 924 return -EINVAL; 925 926 if (!rt700->slave) 927 return -EINVAL; 928 929 /* SoundWire specific configuration */ 930 /* This code assumes port 1 for playback and port 2 for capture */ 931 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 932 direction = SDW_DATA_DIR_RX; 933 port = 1; 934 } else { 935 direction = SDW_DATA_DIR_TX; 936 port = 2; 937 } 938 939 switch (dai->id) { 940 case RT700_AIF1: 941 break; 942 case RT700_AIF2: 943 port += 2; 944 break; 945 default: 946 dev_err(component->dev, "Invalid DAI id %d\n", dai->id); 947 return -EINVAL; 948 } 949 950 stream_config.frame_rate = params_rate(params); 951 stream_config.ch_count = params_channels(params); 952 stream_config.bps = snd_pcm_format_width(params_format(params)); 953 stream_config.direction = direction; 954 955 num_channels = params_channels(params); 956 port_config.ch_mask = (1 << (num_channels)) - 1; 957 port_config.num = port; 958 959 retval = sdw_stream_add_slave(rt700->slave, &stream_config, 960 &port_config, 1, stream->sdw_stream); 961 if (retval) { 962 dev_err(dai->dev, "Unable to configure port\n"); 963 return retval; 964 } 965 966 if (params_channels(params) <= 16) { 967 /* bit 3:0 Number of Channel */ 968 val |= (params_channels(params) - 1); 969 } else { 970 dev_err(component->dev, "Unsupported channels %d\n", 971 params_channels(params)); 972 return -EINVAL; 973 } 974 975 switch (params_width(params)) { 976 /* bit 6:4 Bits per Sample */ 977 case 8: 978 break; 979 case 16: 980 val |= (0x1 << 4); 981 break; 982 case 20: 983 val |= (0x2 << 4); 984 break; 985 case 24: 986 val |= (0x3 << 4); 987 break; 988 case 32: 989 val |= (0x4 << 4); 990 break; 991 default: 992 return -EINVAL; 993 } 994 995 /* 48Khz */ 996 regmap_write(rt700->regmap, RT700_DAC_FORMAT_H, val); 997 regmap_write(rt700->regmap, RT700_ADC_FORMAT_H, val); 998 999 return retval; 1000 } 1001 1002 static int rt700_pcm_hw_free(struct snd_pcm_substream *substream, 1003 struct snd_soc_dai *dai) 1004 { 1005 struct snd_soc_component *component = dai->component; 1006 struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component); 1007 struct sdw_stream_data *stream = 1008 snd_soc_dai_get_dma_data(dai, substream); 1009 1010 if (!rt700->slave) 1011 return -EINVAL; 1012 1013 sdw_stream_remove_slave(rt700->slave, stream->sdw_stream); 1014 return 0; 1015 } 1016 1017 #define RT700_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000) 1018 #define RT700_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \ 1019 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8) 1020 1021 static const struct snd_soc_dai_ops rt700_ops = { 1022 .hw_params = rt700_pcm_hw_params, 1023 .hw_free = rt700_pcm_hw_free, 1024 .set_stream = rt700_set_sdw_stream, 1025 .shutdown = rt700_shutdown, 1026 }; 1027 1028 static struct snd_soc_dai_driver rt700_dai[] = { 1029 { 1030 .name = "rt700-aif1", 1031 .id = RT700_AIF1, 1032 .playback = { 1033 .stream_name = "DP1 Playback", 1034 .channels_min = 1, 1035 .channels_max = 2, 1036 .rates = RT700_STEREO_RATES, 1037 .formats = RT700_FORMATS, 1038 }, 1039 .capture = { 1040 .stream_name = "DP2 Capture", 1041 .channels_min = 1, 1042 .channels_max = 2, 1043 .rates = RT700_STEREO_RATES, 1044 .formats = RT700_FORMATS, 1045 }, 1046 .ops = &rt700_ops, 1047 }, 1048 { 1049 .name = "rt700-aif2", 1050 .id = RT700_AIF2, 1051 .playback = { 1052 .stream_name = "DP3 Playback", 1053 .channels_min = 1, 1054 .channels_max = 2, 1055 .rates = RT700_STEREO_RATES, 1056 .formats = RT700_FORMATS, 1057 }, 1058 .capture = { 1059 .stream_name = "DP4 Capture", 1060 .channels_min = 1, 1061 .channels_max = 2, 1062 .rates = RT700_STEREO_RATES, 1063 .formats = RT700_FORMATS, 1064 }, 1065 .ops = &rt700_ops, 1066 }, 1067 }; 1068 1069 /* Bus clock frequency */ 1070 #define RT700_CLK_FREQ_9600000HZ 9600000 1071 #define RT700_CLK_FREQ_12000000HZ 12000000 1072 #define RT700_CLK_FREQ_6000000HZ 6000000 1073 #define RT700_CLK_FREQ_4800000HZ 4800000 1074 #define RT700_CLK_FREQ_2400000HZ 2400000 1075 #define RT700_CLK_FREQ_12288000HZ 12288000 1076 1077 int rt700_clock_config(struct device *dev) 1078 { 1079 struct rt700_priv *rt700 = dev_get_drvdata(dev); 1080 unsigned int clk_freq, value; 1081 1082 clk_freq = (rt700->params.curr_dr_freq >> 1); 1083 1084 switch (clk_freq) { 1085 case RT700_CLK_FREQ_12000000HZ: 1086 value = 0x0; 1087 break; 1088 case RT700_CLK_FREQ_6000000HZ: 1089 value = 0x1; 1090 break; 1091 case RT700_CLK_FREQ_9600000HZ: 1092 value = 0x2; 1093 break; 1094 case RT700_CLK_FREQ_4800000HZ: 1095 value = 0x3; 1096 break; 1097 case RT700_CLK_FREQ_2400000HZ: 1098 value = 0x4; 1099 break; 1100 case RT700_CLK_FREQ_12288000HZ: 1101 value = 0x5; 1102 break; 1103 default: 1104 return -EINVAL; 1105 } 1106 1107 regmap_write(rt700->regmap, 0xe0, value); 1108 regmap_write(rt700->regmap, 0xf0, value); 1109 1110 dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq); 1111 1112 return 0; 1113 } 1114 1115 int rt700_init(struct device *dev, struct regmap *sdw_regmap, 1116 struct regmap *regmap, struct sdw_slave *slave) 1117 1118 { 1119 struct rt700_priv *rt700; 1120 int ret; 1121 1122 rt700 = devm_kzalloc(dev, sizeof(*rt700), GFP_KERNEL); 1123 if (!rt700) 1124 return -ENOMEM; 1125 1126 dev_set_drvdata(dev, rt700); 1127 rt700->slave = slave; 1128 rt700->sdw_regmap = sdw_regmap; 1129 rt700->regmap = regmap; 1130 1131 mutex_init(&rt700->disable_irq_lock); 1132 1133 INIT_DELAYED_WORK(&rt700->jack_detect_work, 1134 rt700_jack_detect_handler); 1135 INIT_DELAYED_WORK(&rt700->jack_btn_check_work, 1136 rt700_btn_check_handler); 1137 1138 /* 1139 * Mark hw_init to false 1140 * HW init will be performed when device reports present 1141 */ 1142 rt700->hw_init = false; 1143 rt700->first_hw_init = false; 1144 1145 ret = devm_snd_soc_register_component(dev, 1146 &soc_codec_dev_rt700, 1147 rt700_dai, 1148 ARRAY_SIZE(rt700_dai)); 1149 1150 dev_dbg(&slave->dev, "%s\n", __func__); 1151 1152 return ret; 1153 } 1154 1155 int rt700_io_init(struct device *dev, struct sdw_slave *slave) 1156 { 1157 struct rt700_priv *rt700 = dev_get_drvdata(dev); 1158 1159 rt700->disable_irq = false; 1160 1161 if (rt700->hw_init) 1162 return 0; 1163 1164 if (rt700->first_hw_init) { 1165 regcache_cache_only(rt700->regmap, false); 1166 regcache_cache_bypass(rt700->regmap, true); 1167 } 1168 1169 /* 1170 * PM runtime is only enabled when a Slave reports as Attached 1171 */ 1172 if (!rt700->first_hw_init) { 1173 /* set autosuspend parameters */ 1174 pm_runtime_set_autosuspend_delay(&slave->dev, 3000); 1175 pm_runtime_use_autosuspend(&slave->dev); 1176 1177 /* update count of parent 'active' children */ 1178 pm_runtime_set_active(&slave->dev); 1179 1180 /* make sure the device does not suspend immediately */ 1181 pm_runtime_mark_last_busy(&slave->dev); 1182 1183 pm_runtime_enable(&slave->dev); 1184 } 1185 1186 pm_runtime_get_noresume(&slave->dev); 1187 1188 /* reset */ 1189 regmap_write(rt700->regmap, 0xff01, 0x0000); 1190 regmap_write(rt700->regmap, 0x7520, 0x001a); 1191 regmap_write(rt700->regmap, 0x7420, 0xc003); 1192 1193 /* power on */ 1194 regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0); 1195 /* Set Pin Widget */ 1196 regmap_write(rt700->regmap, RT700_SET_PIN_HP, 0x40); 1197 regmap_write(rt700->regmap, RT700_SET_PIN_SPK, 0x40); 1198 regmap_write(rt700->regmap, RT700_SET_EAPD_SPK, RT700_EAPD_HIGH); 1199 regmap_write(rt700->regmap, RT700_SET_PIN_DMIC1, 0x20); 1200 regmap_write(rt700->regmap, RT700_SET_PIN_DMIC2, 0x20); 1201 regmap_write(rt700->regmap, RT700_SET_PIN_MIC2, 0x20); 1202 1203 /* Set Configuration Default */ 1204 regmap_write(rt700->regmap, 0x4f12, 0x91); 1205 regmap_write(rt700->regmap, 0x4e12, 0xd6); 1206 regmap_write(rt700->regmap, 0x4d12, 0x11); 1207 regmap_write(rt700->regmap, 0x4c12, 0x20); 1208 regmap_write(rt700->regmap, 0x4f13, 0x91); 1209 regmap_write(rt700->regmap, 0x4e13, 0xd6); 1210 regmap_write(rt700->regmap, 0x4d13, 0x11); 1211 regmap_write(rt700->regmap, 0x4c13, 0x21); 1212 1213 regmap_write(rt700->regmap, 0x4f19, 0x02); 1214 regmap_write(rt700->regmap, 0x4e19, 0xa1); 1215 regmap_write(rt700->regmap, 0x4d19, 0x90); 1216 regmap_write(rt700->regmap, 0x4c19, 0x80); 1217 1218 /* Enable Line2 */ 1219 regmap_write(rt700->regmap, 0x371b, 0x40); 1220 regmap_write(rt700->regmap, 0x731b, 0xb0); 1221 regmap_write(rt700->regmap, 0x839b, 0x00); 1222 1223 /* Set index */ 1224 rt700_index_write(rt700->regmap, 0x4a, 0x201b); 1225 rt700_index_write(rt700->regmap, 0x45, 0x5089); 1226 rt700_index_write(rt700->regmap, 0x6b, 0x5064); 1227 rt700_index_write(rt700->regmap, 0x48, 0xd249); 1228 1229 /* Finish Initial Settings, set power to D3 */ 1230 regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3); 1231 1232 /* 1233 * if set_jack callback occurred early than io_init, 1234 * we set up the jack detection function now 1235 */ 1236 if (rt700->hs_jack) 1237 rt700_jack_init(rt700); 1238 1239 if (rt700->first_hw_init) { 1240 regcache_cache_bypass(rt700->regmap, false); 1241 regcache_mark_dirty(rt700->regmap); 1242 } else 1243 rt700->first_hw_init = true; 1244 1245 /* Mark Slave initialization complete */ 1246 rt700->hw_init = true; 1247 1248 pm_runtime_mark_last_busy(&slave->dev); 1249 pm_runtime_put_autosuspend(&slave->dev); 1250 1251 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__); 1252 1253 return 0; 1254 } 1255 1256 MODULE_DESCRIPTION("ASoC RT700 driver SDW"); 1257 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>"); 1258 MODULE_LICENSE("GPL v2"); 1259