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